Loading...
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright 2019 Hans de Goede <hdegoede@redhat.com>
4 */
5
6#include <linux/dma-buf.h>
7#include <linux/module.h>
8#include <linux/usb.h>
9
10#include <drm/drm_atomic_helper.h>
11#include <drm/drm_atomic_state_helper.h>
12#include <drm/drm_connector.h>
13#include <drm/drm_damage_helper.h>
14#include <drm/drm_drv.h>
15#include <drm/drm_fb_helper.h>
16#include <drm/drm_file.h>
17#include <drm/drm_format_helper.h>
18#include <drm/drm_fourcc.h>
19#include <drm/drm_gem_shmem_helper.h>
20#include <drm/drm_gem_framebuffer_helper.h>
21#include <drm/drm_ioctl.h>
22#include <drm/drm_managed.h>
23#include <drm/drm_modeset_helper_vtables.h>
24#include <drm/drm_probe_helper.h>
25#include <drm/drm_simple_kms_helper.h>
26
27static bool eco_mode;
28module_param(eco_mode, bool, 0644);
29MODULE_PARM_DESC(eco_mode, "Turn on Eco mode (less bright, more silent)");
30
31#define DRIVER_NAME "gm12u320"
32#define DRIVER_DESC "Grain Media GM12U320 USB projector display"
33#define DRIVER_DATE "2019"
34#define DRIVER_MAJOR 1
35#define DRIVER_MINOR 0
36
37/*
38 * The DLP has an actual width of 854 pixels, but that is not a multiple
39 * of 8, breaking things left and right, so we export a width of 848.
40 */
41#define GM12U320_USER_WIDTH 848
42#define GM12U320_REAL_WIDTH 854
43#define GM12U320_HEIGHT 480
44
45#define GM12U320_BLOCK_COUNT 20
46
47#define GM12U320_ERR(fmt, ...) \
48 DRM_DEV_ERROR(&gm12u320->udev->dev, fmt, ##__VA_ARGS__)
49
50#define MISC_RCV_EPT 1
51#define DATA_RCV_EPT 2
52#define DATA_SND_EPT 3
53#define MISC_SND_EPT 4
54
55#define DATA_BLOCK_HEADER_SIZE 84
56#define DATA_BLOCK_CONTENT_SIZE 64512
57#define DATA_BLOCK_FOOTER_SIZE 20
58#define DATA_BLOCK_SIZE (DATA_BLOCK_HEADER_SIZE + \
59 DATA_BLOCK_CONTENT_SIZE + \
60 DATA_BLOCK_FOOTER_SIZE)
61#define DATA_LAST_BLOCK_CONTENT_SIZE 4032
62#define DATA_LAST_BLOCK_SIZE (DATA_BLOCK_HEADER_SIZE + \
63 DATA_LAST_BLOCK_CONTENT_SIZE + \
64 DATA_BLOCK_FOOTER_SIZE)
65
66#define CMD_SIZE 31
67#define READ_STATUS_SIZE 13
68#define MISC_VALUE_SIZE 4
69
70#define CMD_TIMEOUT msecs_to_jiffies(200)
71#define DATA_TIMEOUT msecs_to_jiffies(1000)
72#define IDLE_TIMEOUT msecs_to_jiffies(2000)
73#define FIRST_FRAME_TIMEOUT msecs_to_jiffies(2000)
74
75#define MISC_REQ_GET_SET_ECO_A 0xff
76#define MISC_REQ_GET_SET_ECO_B 0x35
77/* Windows driver does once every second, with arg d = 1, other args 0 */
78#define MISC_REQ_UNKNOWN1_A 0xff
79#define MISC_REQ_UNKNOWN1_B 0x38
80/* Windows driver does this on init, with arg a, b = 0, c = 0xa0, d = 4 */
81#define MISC_REQ_UNKNOWN2_A 0xa5
82#define MISC_REQ_UNKNOWN2_B 0x00
83
84struct gm12u320_device {
85 struct drm_device dev;
86 struct drm_simple_display_pipe pipe;
87 struct drm_connector conn;
88 struct usb_device *udev;
89 unsigned char *cmd_buf;
90 unsigned char *data_buf[GM12U320_BLOCK_COUNT];
91 struct {
92 struct delayed_work work;
93 struct mutex lock;
94 struct drm_framebuffer *fb;
95 struct drm_rect rect;
96 int frame;
97 int draw_status_timeout;
98 } fb_update;
99};
100
101#define to_gm12u320(__dev) container_of(__dev, struct gm12u320_device, dev)
102
103static const char cmd_data[CMD_SIZE] = {
104 0x55, 0x53, 0x42, 0x43, 0x00, 0x00, 0x00, 0x00,
105 0x68, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x10, 0xff,
106 0x00, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x80, 0x00,
107 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
108};
109
110static const char cmd_draw[CMD_SIZE] = {
111 0x55, 0x53, 0x42, 0x43, 0x00, 0x00, 0x00, 0x00,
112 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xfe,
113 0x00, 0x00, 0x00, 0xc0, 0xd1, 0x05, 0x00, 0x40,
114 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00
115};
116
117static const char cmd_misc[CMD_SIZE] = {
118 0x55, 0x53, 0x42, 0x43, 0x00, 0x00, 0x00, 0x00,
119 0x04, 0x00, 0x00, 0x00, 0x80, 0x01, 0x10, 0xfd,
120 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00,
121 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
122};
123
124static const char data_block_header[DATA_BLOCK_HEADER_SIZE] = {
125 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
126 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
127 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
128 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
129 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
130 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
131 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
132 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
133 0xfb, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
134 0x00, 0x04, 0x15, 0x00, 0x00, 0xfc, 0x00, 0x00,
135 0x01, 0x00, 0x00, 0xdb
136};
137
138static const char data_last_block_header[DATA_BLOCK_HEADER_SIZE] = {
139 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
140 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
141 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
142 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
143 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
144 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
145 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
146 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
147 0xfb, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
148 0x2a, 0x00, 0x20, 0x00, 0xc0, 0x0f, 0x00, 0x00,
149 0x01, 0x00, 0x00, 0xd7
150};
151
152static const char data_block_footer[DATA_BLOCK_FOOTER_SIZE] = {
153 0xfb, 0x14, 0x02, 0x20, 0x00, 0x00, 0x00, 0x00,
154 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
155 0x80, 0x00, 0x00, 0x4f
156};
157
158static int gm12u320_usb_alloc(struct gm12u320_device *gm12u320)
159{
160 int i, block_size;
161 const char *hdr;
162
163 gm12u320->cmd_buf = drmm_kmalloc(&gm12u320->dev, CMD_SIZE, GFP_KERNEL);
164 if (!gm12u320->cmd_buf)
165 return -ENOMEM;
166
167 for (i = 0; i < GM12U320_BLOCK_COUNT; i++) {
168 if (i == GM12U320_BLOCK_COUNT - 1) {
169 block_size = DATA_LAST_BLOCK_SIZE;
170 hdr = data_last_block_header;
171 } else {
172 block_size = DATA_BLOCK_SIZE;
173 hdr = data_block_header;
174 }
175
176 gm12u320->data_buf[i] = drmm_kzalloc(&gm12u320->dev,
177 block_size, GFP_KERNEL);
178 if (!gm12u320->data_buf[i])
179 return -ENOMEM;
180
181 memcpy(gm12u320->data_buf[i], hdr, DATA_BLOCK_HEADER_SIZE);
182 memcpy(gm12u320->data_buf[i] +
183 (block_size - DATA_BLOCK_FOOTER_SIZE),
184 data_block_footer, DATA_BLOCK_FOOTER_SIZE);
185 }
186
187 return 0;
188}
189
190static int gm12u320_misc_request(struct gm12u320_device *gm12u320,
191 u8 req_a, u8 req_b,
192 u8 arg_a, u8 arg_b, u8 arg_c, u8 arg_d)
193{
194 int ret, len;
195
196 memcpy(gm12u320->cmd_buf, &cmd_misc, CMD_SIZE);
197 gm12u320->cmd_buf[20] = req_a;
198 gm12u320->cmd_buf[21] = req_b;
199 gm12u320->cmd_buf[22] = arg_a;
200 gm12u320->cmd_buf[23] = arg_b;
201 gm12u320->cmd_buf[24] = arg_c;
202 gm12u320->cmd_buf[25] = arg_d;
203
204 /* Send request */
205 ret = usb_bulk_msg(gm12u320->udev,
206 usb_sndbulkpipe(gm12u320->udev, MISC_SND_EPT),
207 gm12u320->cmd_buf, CMD_SIZE, &len, CMD_TIMEOUT);
208 if (ret || len != CMD_SIZE) {
209 GM12U320_ERR("Misc. req. error %d\n", ret);
210 return -EIO;
211 }
212
213 /* Read value */
214 ret = usb_bulk_msg(gm12u320->udev,
215 usb_rcvbulkpipe(gm12u320->udev, MISC_RCV_EPT),
216 gm12u320->cmd_buf, MISC_VALUE_SIZE, &len,
217 DATA_TIMEOUT);
218 if (ret || len != MISC_VALUE_SIZE) {
219 GM12U320_ERR("Misc. value error %d\n", ret);
220 return -EIO;
221 }
222 /* cmd_buf[0] now contains the read value, which we don't use */
223
224 /* Read status */
225 ret = usb_bulk_msg(gm12u320->udev,
226 usb_rcvbulkpipe(gm12u320->udev, MISC_RCV_EPT),
227 gm12u320->cmd_buf, READ_STATUS_SIZE, &len,
228 CMD_TIMEOUT);
229 if (ret || len != READ_STATUS_SIZE) {
230 GM12U320_ERR("Misc. status error %d\n", ret);
231 return -EIO;
232 }
233
234 return 0;
235}
236
237static void gm12u320_32bpp_to_24bpp_packed(u8 *dst, u8 *src, int len)
238{
239 while (len--) {
240 *dst++ = *src++;
241 *dst++ = *src++;
242 *dst++ = *src++;
243 src++;
244 }
245}
246
247static void gm12u320_copy_fb_to_blocks(struct gm12u320_device *gm12u320)
248{
249 int block, dst_offset, len, remain, ret, x1, x2, y1, y2;
250 struct drm_framebuffer *fb;
251 void *vaddr;
252 u8 *src;
253
254 mutex_lock(&gm12u320->fb_update.lock);
255
256 if (!gm12u320->fb_update.fb)
257 goto unlock;
258
259 fb = gm12u320->fb_update.fb;
260 x1 = gm12u320->fb_update.rect.x1;
261 x2 = gm12u320->fb_update.rect.x2;
262 y1 = gm12u320->fb_update.rect.y1;
263 y2 = gm12u320->fb_update.rect.y2;
264
265 vaddr = drm_gem_shmem_vmap(fb->obj[0]);
266 if (IS_ERR(vaddr)) {
267 GM12U320_ERR("failed to vmap fb: %ld\n", PTR_ERR(vaddr));
268 goto put_fb;
269 }
270
271 if (fb->obj[0]->import_attach) {
272 ret = dma_buf_begin_cpu_access(
273 fb->obj[0]->import_attach->dmabuf, DMA_FROM_DEVICE);
274 if (ret) {
275 GM12U320_ERR("dma_buf_begin_cpu_access err: %d\n", ret);
276 goto vunmap;
277 }
278 }
279
280 src = vaddr + y1 * fb->pitches[0] + x1 * 4;
281
282 x1 += (GM12U320_REAL_WIDTH - GM12U320_USER_WIDTH) / 2;
283 x2 += (GM12U320_REAL_WIDTH - GM12U320_USER_WIDTH) / 2;
284
285 for (; y1 < y2; y1++) {
286 remain = 0;
287 len = (x2 - x1) * 3;
288 dst_offset = (y1 * GM12U320_REAL_WIDTH + x1) * 3;
289 block = dst_offset / DATA_BLOCK_CONTENT_SIZE;
290 dst_offset %= DATA_BLOCK_CONTENT_SIZE;
291
292 if ((dst_offset + len) > DATA_BLOCK_CONTENT_SIZE) {
293 remain = dst_offset + len - DATA_BLOCK_CONTENT_SIZE;
294 len = DATA_BLOCK_CONTENT_SIZE - dst_offset;
295 }
296
297 dst_offset += DATA_BLOCK_HEADER_SIZE;
298 len /= 3;
299
300 gm12u320_32bpp_to_24bpp_packed(
301 gm12u320->data_buf[block] + dst_offset,
302 src, len);
303
304 if (remain) {
305 block++;
306 dst_offset = DATA_BLOCK_HEADER_SIZE;
307 gm12u320_32bpp_to_24bpp_packed(
308 gm12u320->data_buf[block] + dst_offset,
309 src + len * 4, remain / 3);
310 }
311 src += fb->pitches[0];
312 }
313
314 if (fb->obj[0]->import_attach) {
315 ret = dma_buf_end_cpu_access(fb->obj[0]->import_attach->dmabuf,
316 DMA_FROM_DEVICE);
317 if (ret)
318 GM12U320_ERR("dma_buf_end_cpu_access err: %d\n", ret);
319 }
320vunmap:
321 drm_gem_shmem_vunmap(fb->obj[0], vaddr);
322put_fb:
323 drm_framebuffer_put(fb);
324 gm12u320->fb_update.fb = NULL;
325unlock:
326 mutex_unlock(&gm12u320->fb_update.lock);
327}
328
329static void gm12u320_fb_update_work(struct work_struct *work)
330{
331 struct gm12u320_device *gm12u320 =
332 container_of(to_delayed_work(work), struct gm12u320_device,
333 fb_update.work);
334 int block, block_size, len;
335 int ret = 0;
336
337 gm12u320_copy_fb_to_blocks(gm12u320);
338
339 for (block = 0; block < GM12U320_BLOCK_COUNT; block++) {
340 if (block == GM12U320_BLOCK_COUNT - 1)
341 block_size = DATA_LAST_BLOCK_SIZE;
342 else
343 block_size = DATA_BLOCK_SIZE;
344
345 /* Send data command to device */
346 memcpy(gm12u320->cmd_buf, cmd_data, CMD_SIZE);
347 gm12u320->cmd_buf[8] = block_size & 0xff;
348 gm12u320->cmd_buf[9] = block_size >> 8;
349 gm12u320->cmd_buf[20] = 0xfc - block * 4;
350 gm12u320->cmd_buf[21] =
351 block | (gm12u320->fb_update.frame << 7);
352
353 ret = usb_bulk_msg(gm12u320->udev,
354 usb_sndbulkpipe(gm12u320->udev, DATA_SND_EPT),
355 gm12u320->cmd_buf, CMD_SIZE, &len,
356 CMD_TIMEOUT);
357 if (ret || len != CMD_SIZE)
358 goto err;
359
360 /* Send data block to device */
361 ret = usb_bulk_msg(gm12u320->udev,
362 usb_sndbulkpipe(gm12u320->udev, DATA_SND_EPT),
363 gm12u320->data_buf[block], block_size,
364 &len, DATA_TIMEOUT);
365 if (ret || len != block_size)
366 goto err;
367
368 /* Read status */
369 ret = usb_bulk_msg(gm12u320->udev,
370 usb_rcvbulkpipe(gm12u320->udev, DATA_RCV_EPT),
371 gm12u320->cmd_buf, READ_STATUS_SIZE, &len,
372 CMD_TIMEOUT);
373 if (ret || len != READ_STATUS_SIZE)
374 goto err;
375 }
376
377 /* Send draw command to device */
378 memcpy(gm12u320->cmd_buf, cmd_draw, CMD_SIZE);
379 ret = usb_bulk_msg(gm12u320->udev,
380 usb_sndbulkpipe(gm12u320->udev, DATA_SND_EPT),
381 gm12u320->cmd_buf, CMD_SIZE, &len, CMD_TIMEOUT);
382 if (ret || len != CMD_SIZE)
383 goto err;
384
385 /* Read status */
386 ret = usb_bulk_msg(gm12u320->udev,
387 usb_rcvbulkpipe(gm12u320->udev, DATA_RCV_EPT),
388 gm12u320->cmd_buf, READ_STATUS_SIZE, &len,
389 gm12u320->fb_update.draw_status_timeout);
390 if (ret || len != READ_STATUS_SIZE)
391 goto err;
392
393 gm12u320->fb_update.draw_status_timeout = CMD_TIMEOUT;
394 gm12u320->fb_update.frame = !gm12u320->fb_update.frame;
395
396 /*
397 * We must draw a frame every 2s otherwise the projector
398 * switches back to showing its logo.
399 */
400 queue_delayed_work(system_long_wq, &gm12u320->fb_update.work,
401 IDLE_TIMEOUT);
402
403 return;
404err:
405 /* Do not log errors caused by module unload or device unplug */
406 if (ret != -ENODEV && ret != -ECONNRESET && ret != -ESHUTDOWN)
407 GM12U320_ERR("Frame update error: %d\n", ret);
408}
409
410static void gm12u320_fb_mark_dirty(struct drm_framebuffer *fb,
411 struct drm_rect *dirty)
412{
413 struct gm12u320_device *gm12u320 = to_gm12u320(fb->dev);
414 struct drm_framebuffer *old_fb = NULL;
415 bool wakeup = false;
416
417 mutex_lock(&gm12u320->fb_update.lock);
418
419 if (gm12u320->fb_update.fb != fb) {
420 old_fb = gm12u320->fb_update.fb;
421 drm_framebuffer_get(fb);
422 gm12u320->fb_update.fb = fb;
423 gm12u320->fb_update.rect = *dirty;
424 wakeup = true;
425 } else {
426 struct drm_rect *rect = &gm12u320->fb_update.rect;
427
428 rect->x1 = min(rect->x1, dirty->x1);
429 rect->y1 = min(rect->y1, dirty->y1);
430 rect->x2 = max(rect->x2, dirty->x2);
431 rect->y2 = max(rect->y2, dirty->y2);
432 }
433
434 mutex_unlock(&gm12u320->fb_update.lock);
435
436 if (wakeup)
437 mod_delayed_work(system_long_wq, &gm12u320->fb_update.work, 0);
438
439 if (old_fb)
440 drm_framebuffer_put(old_fb);
441}
442
443static void gm12u320_stop_fb_update(struct gm12u320_device *gm12u320)
444{
445 struct drm_framebuffer *old_fb;
446
447 cancel_delayed_work_sync(&gm12u320->fb_update.work);
448
449 mutex_lock(&gm12u320->fb_update.lock);
450 old_fb = gm12u320->fb_update.fb;
451 gm12u320->fb_update.fb = NULL;
452 mutex_unlock(&gm12u320->fb_update.lock);
453
454 drm_framebuffer_put(old_fb);
455}
456
457static int gm12u320_set_ecomode(struct gm12u320_device *gm12u320)
458{
459 return gm12u320_misc_request(gm12u320, MISC_REQ_GET_SET_ECO_A,
460 MISC_REQ_GET_SET_ECO_B, 0x01 /* set */,
461 eco_mode ? 0x01 : 0x00, 0x00, 0x01);
462}
463
464/* ------------------------------------------------------------------ */
465/* gm12u320 connector */
466
467/*
468 *Â We use fake EDID info so that userspace know that it is dealing with
469 * an Acer projector, rather then listing this as an "unknown" monitor.
470 * Note this assumes this driver is only ever used with the Acer C120, if we
471 * add support for other devices the vendor and model should be parameterized.
472 */
473static struct edid gm12u320_edid = {
474 .header = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 },
475 .mfg_id = { 0x04, 0x72 }, /* "ACR" */
476 .prod_code = { 0x20, 0xc1 }, /* C120h */
477 .serial = 0xaa55aa55,
478 .mfg_week = 1,
479 .mfg_year = 16,
480 .version = 1, /* EDID 1.3 */
481 .revision = 3, /* EDID 1.3 */
482 .input = 0x08, /* Analog input */
483 .features = 0x0a, /* Pref timing in DTD 1 */
484 .standard_timings = { { 1, 1 }, { 1, 1 }, { 1, 1 }, { 1, 1 },
485 { 1, 1 }, { 1, 1 }, { 1, 1 }, { 1, 1 } },
486 .detailed_timings = { {
487 .pixel_clock = 3383,
488 /* hactive = 848, hblank = 256 */
489 .data.pixel_data.hactive_lo = 0x50,
490 .data.pixel_data.hblank_lo = 0x00,
491 .data.pixel_data.hactive_hblank_hi = 0x31,
492 /* vactive = 480, vblank = 28 */
493 .data.pixel_data.vactive_lo = 0xe0,
494 .data.pixel_data.vblank_lo = 0x1c,
495 .data.pixel_data.vactive_vblank_hi = 0x10,
496 /* hsync offset 40 pw 128, vsync offset 1 pw 4 */
497 .data.pixel_data.hsync_offset_lo = 0x28,
498 .data.pixel_data.hsync_pulse_width_lo = 0x80,
499 .data.pixel_data.vsync_offset_pulse_width_lo = 0x14,
500 .data.pixel_data.hsync_vsync_offset_pulse_width_hi = 0x00,
501 /* Digital separate syncs, hsync+, vsync+ */
502 .data.pixel_data.misc = 0x1e,
503 }, {
504 .pixel_clock = 0,
505 .data.other_data.type = 0xfd, /* Monitor ranges */
506 .data.other_data.data.range.min_vfreq = 59,
507 .data.other_data.data.range.max_vfreq = 61,
508 .data.other_data.data.range.min_hfreq_khz = 29,
509 .data.other_data.data.range.max_hfreq_khz = 32,
510 .data.other_data.data.range.pixel_clock_mhz = 4, /* 40 MHz */
511 .data.other_data.data.range.flags = 0,
512 .data.other_data.data.range.formula.cvt = {
513 0xa0, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 },
514 }, {
515 .pixel_clock = 0,
516 .data.other_data.type = 0xfc, /* Model string */
517 .data.other_data.data.str.str = {
518 'P', 'r', 'o', 'j', 'e', 'c', 't', 'o', 'r', '\n',
519 ' ', ' ', ' ' },
520 }, {
521 .pixel_clock = 0,
522 .data.other_data.type = 0xfe, /* Unspecified text / padding */
523 .data.other_data.data.str.str = {
524 '\n', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
525 ' ', ' ', ' ' },
526 } },
527 .checksum = 0x13,
528};
529
530static int gm12u320_conn_get_modes(struct drm_connector *connector)
531{
532 drm_connector_update_edid_property(connector, &gm12u320_edid);
533 return drm_add_edid_modes(connector, &gm12u320_edid);
534}
535
536static const struct drm_connector_helper_funcs gm12u320_conn_helper_funcs = {
537 .get_modes = gm12u320_conn_get_modes,
538};
539
540static const struct drm_connector_funcs gm12u320_conn_funcs = {
541 .fill_modes = drm_helper_probe_single_connector_modes,
542 .destroy = drm_connector_cleanup,
543 .reset = drm_atomic_helper_connector_reset,
544 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
545 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
546};
547
548static int gm12u320_conn_init(struct gm12u320_device *gm12u320)
549{
550 drm_connector_helper_add(&gm12u320->conn, &gm12u320_conn_helper_funcs);
551 return drm_connector_init(&gm12u320->dev, &gm12u320->conn,
552 &gm12u320_conn_funcs, DRM_MODE_CONNECTOR_VGA);
553}
554
555/* ------------------------------------------------------------------ */
556/* gm12u320 (simple) display pipe */
557
558static void gm12u320_pipe_enable(struct drm_simple_display_pipe *pipe,
559 struct drm_crtc_state *crtc_state,
560 struct drm_plane_state *plane_state)
561{
562 struct drm_rect rect = { 0, 0, GM12U320_USER_WIDTH, GM12U320_HEIGHT };
563 struct gm12u320_device *gm12u320 = to_gm12u320(pipe->crtc.dev);
564
565 gm12u320->fb_update.draw_status_timeout = FIRST_FRAME_TIMEOUT;
566 gm12u320_fb_mark_dirty(plane_state->fb, &rect);
567}
568
569static void gm12u320_pipe_disable(struct drm_simple_display_pipe *pipe)
570{
571 struct gm12u320_device *gm12u320 = to_gm12u320(pipe->crtc.dev);
572
573 gm12u320_stop_fb_update(gm12u320);
574}
575
576static void gm12u320_pipe_update(struct drm_simple_display_pipe *pipe,
577 struct drm_plane_state *old_state)
578{
579 struct drm_plane_state *state = pipe->plane.state;
580 struct drm_rect rect;
581
582 if (drm_atomic_helper_damage_merged(old_state, state, &rect))
583 gm12u320_fb_mark_dirty(pipe->plane.state->fb, &rect);
584}
585
586static const struct drm_simple_display_pipe_funcs gm12u320_pipe_funcs = {
587 .enable = gm12u320_pipe_enable,
588 .disable = gm12u320_pipe_disable,
589 .update = gm12u320_pipe_update,
590};
591
592static const uint32_t gm12u320_pipe_formats[] = {
593 DRM_FORMAT_XRGB8888,
594};
595
596static const uint64_t gm12u320_pipe_modifiers[] = {
597 DRM_FORMAT_MOD_LINEAR,
598 DRM_FORMAT_MOD_INVALID
599};
600
601DEFINE_DRM_GEM_FOPS(gm12u320_fops);
602
603static struct drm_driver gm12u320_drm_driver = {
604 .driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC,
605
606 .name = DRIVER_NAME,
607 .desc = DRIVER_DESC,
608 .date = DRIVER_DATE,
609 .major = DRIVER_MAJOR,
610 .minor = DRIVER_MINOR,
611
612 .fops = &gm12u320_fops,
613 DRM_GEM_SHMEM_DRIVER_OPS,
614};
615
616static const struct drm_mode_config_funcs gm12u320_mode_config_funcs = {
617 .fb_create = drm_gem_fb_create_with_dirty,
618 .atomic_check = drm_atomic_helper_check,
619 .atomic_commit = drm_atomic_helper_commit,
620};
621
622static int gm12u320_usb_probe(struct usb_interface *interface,
623 const struct usb_device_id *id)
624{
625 struct gm12u320_device *gm12u320;
626 struct drm_device *dev;
627 int ret;
628
629 /*
630 * The gm12u320 presents itself to the system as 2 usb mass-storage
631 * interfaces, we only care about / need the first one.
632 */
633 if (interface->cur_altsetting->desc.bInterfaceNumber != 0)
634 return -ENODEV;
635
636 gm12u320 = devm_drm_dev_alloc(&interface->dev, &gm12u320_drm_driver,
637 struct gm12u320_device, dev);
638 if (IS_ERR(gm12u320))
639 return PTR_ERR(gm12u320);
640
641 gm12u320->udev = interface_to_usbdev(interface);
642 INIT_DELAYED_WORK(&gm12u320->fb_update.work, gm12u320_fb_update_work);
643 mutex_init(&gm12u320->fb_update.lock);
644
645 dev = &gm12u320->dev;
646
647 ret = drmm_mode_config_init(dev);
648 if (ret)
649 return ret;
650
651 dev->mode_config.min_width = GM12U320_USER_WIDTH;
652 dev->mode_config.max_width = GM12U320_USER_WIDTH;
653 dev->mode_config.min_height = GM12U320_HEIGHT;
654 dev->mode_config.max_height = GM12U320_HEIGHT;
655 dev->mode_config.funcs = &gm12u320_mode_config_funcs;
656
657 ret = gm12u320_usb_alloc(gm12u320);
658 if (ret)
659 return ret;
660
661 ret = gm12u320_set_ecomode(gm12u320);
662 if (ret)
663 return ret;
664
665 ret = gm12u320_conn_init(gm12u320);
666 if (ret)
667 return ret;
668
669 ret = drm_simple_display_pipe_init(&gm12u320->dev,
670 &gm12u320->pipe,
671 &gm12u320_pipe_funcs,
672 gm12u320_pipe_formats,
673 ARRAY_SIZE(gm12u320_pipe_formats),
674 gm12u320_pipe_modifiers,
675 &gm12u320->conn);
676 if (ret)
677 return ret;
678
679 drm_mode_config_reset(dev);
680
681 usb_set_intfdata(interface, dev);
682 ret = drm_dev_register(dev, 0);
683 if (ret)
684 return ret;
685
686 drm_fbdev_generic_setup(dev, 0);
687
688 return 0;
689}
690
691static void gm12u320_usb_disconnect(struct usb_interface *interface)
692{
693 struct drm_device *dev = usb_get_intfdata(interface);
694
695 drm_dev_unplug(dev);
696 drm_atomic_helper_shutdown(dev);
697}
698
699static __maybe_unused int gm12u320_suspend(struct usb_interface *interface,
700 pm_message_t message)
701{
702 struct drm_device *dev = usb_get_intfdata(interface);
703
704 return drm_mode_config_helper_suspend(dev);
705}
706
707static __maybe_unused int gm12u320_resume(struct usb_interface *interface)
708{
709 struct drm_device *dev = usb_get_intfdata(interface);
710 struct gm12u320_device *gm12u320 = to_gm12u320(dev);
711
712 gm12u320_set_ecomode(gm12u320);
713
714 return drm_mode_config_helper_resume(dev);
715}
716
717static const struct usb_device_id id_table[] = {
718 { USB_DEVICE(0x1de1, 0xc102) },
719 {},
720};
721MODULE_DEVICE_TABLE(usb, id_table);
722
723static struct usb_driver gm12u320_usb_driver = {
724 .name = "gm12u320",
725 .probe = gm12u320_usb_probe,
726 .disconnect = gm12u320_usb_disconnect,
727 .id_table = id_table,
728#ifdef CONFIG_PM
729 .suspend = gm12u320_suspend,
730 .resume = gm12u320_resume,
731 .reset_resume = gm12u320_resume,
732#endif
733};
734
735module_usb_driver(gm12u320_usb_driver);
736MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
737MODULE_LICENSE("GPL");
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright 2019 Hans de Goede <hdegoede@redhat.com>
4 */
5
6#include <linux/module.h>
7#include <linux/usb.h>
8
9#include <drm/drm_atomic_helper.h>
10#include <drm/drm_atomic_state_helper.h>
11#include <drm/drm_connector.h>
12#include <drm/drm_damage_helper.h>
13#include <drm/drm_drv.h>
14#include <drm/drm_edid.h>
15#include <drm/drm_fbdev_generic.h>
16#include <drm/drm_file.h>
17#include <drm/drm_format_helper.h>
18#include <drm/drm_fourcc.h>
19#include <drm/drm_framebuffer.h>
20#include <drm/drm_gem_atomic_helper.h>
21#include <drm/drm_gem_framebuffer_helper.h>
22#include <drm/drm_gem_shmem_helper.h>
23#include <drm/drm_ioctl.h>
24#include <drm/drm_managed.h>
25#include <drm/drm_modeset_helper_vtables.h>
26#include <drm/drm_probe_helper.h>
27#include <drm/drm_simple_kms_helper.h>
28
29static bool eco_mode;
30module_param(eco_mode, bool, 0644);
31MODULE_PARM_DESC(eco_mode, "Turn on Eco mode (less bright, more silent)");
32
33#define DRIVER_NAME "gm12u320"
34#define DRIVER_DESC "Grain Media GM12U320 USB projector display"
35#define DRIVER_DATE "2019"
36#define DRIVER_MAJOR 1
37#define DRIVER_MINOR 0
38
39/*
40 * The DLP has an actual width of 854 pixels, but that is not a multiple
41 * of 8, breaking things left and right, so we export a width of 848.
42 */
43#define GM12U320_USER_WIDTH 848
44#define GM12U320_REAL_WIDTH 854
45#define GM12U320_HEIGHT 480
46
47#define GM12U320_BLOCK_COUNT 20
48
49#define GM12U320_ERR(fmt, ...) \
50 DRM_DEV_ERROR(gm12u320->dev.dev, fmt, ##__VA_ARGS__)
51
52#define MISC_RCV_EPT 1
53#define DATA_RCV_EPT 2
54#define DATA_SND_EPT 3
55#define MISC_SND_EPT 4
56
57#define DATA_BLOCK_HEADER_SIZE 84
58#define DATA_BLOCK_CONTENT_SIZE 64512
59#define DATA_BLOCK_FOOTER_SIZE 20
60#define DATA_BLOCK_SIZE (DATA_BLOCK_HEADER_SIZE + \
61 DATA_BLOCK_CONTENT_SIZE + \
62 DATA_BLOCK_FOOTER_SIZE)
63#define DATA_LAST_BLOCK_CONTENT_SIZE 4032
64#define DATA_LAST_BLOCK_SIZE (DATA_BLOCK_HEADER_SIZE + \
65 DATA_LAST_BLOCK_CONTENT_SIZE + \
66 DATA_BLOCK_FOOTER_SIZE)
67
68#define CMD_SIZE 31
69#define READ_STATUS_SIZE 13
70#define MISC_VALUE_SIZE 4
71
72#define CMD_TIMEOUT msecs_to_jiffies(200)
73#define DATA_TIMEOUT msecs_to_jiffies(1000)
74#define IDLE_TIMEOUT msecs_to_jiffies(2000)
75#define FIRST_FRAME_TIMEOUT msecs_to_jiffies(2000)
76
77#define MISC_REQ_GET_SET_ECO_A 0xff
78#define MISC_REQ_GET_SET_ECO_B 0x35
79/* Windows driver does once every second, with arg d = 1, other args 0 */
80#define MISC_REQ_UNKNOWN1_A 0xff
81#define MISC_REQ_UNKNOWN1_B 0x38
82/* Windows driver does this on init, with arg a, b = 0, c = 0xa0, d = 4 */
83#define MISC_REQ_UNKNOWN2_A 0xa5
84#define MISC_REQ_UNKNOWN2_B 0x00
85
86struct gm12u320_device {
87 struct drm_device dev;
88 struct device *dmadev;
89 struct drm_simple_display_pipe pipe;
90 struct drm_connector conn;
91 unsigned char *cmd_buf;
92 unsigned char *data_buf[GM12U320_BLOCK_COUNT];
93 struct {
94 struct delayed_work work;
95 struct mutex lock;
96 struct drm_framebuffer *fb;
97 struct drm_rect rect;
98 int frame;
99 int draw_status_timeout;
100 struct iosys_map src_map;
101 } fb_update;
102};
103
104#define to_gm12u320(__dev) container_of(__dev, struct gm12u320_device, dev)
105
106static const char cmd_data[CMD_SIZE] = {
107 0x55, 0x53, 0x42, 0x43, 0x00, 0x00, 0x00, 0x00,
108 0x68, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x10, 0xff,
109 0x00, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x80, 0x00,
110 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
111};
112
113static const char cmd_draw[CMD_SIZE] = {
114 0x55, 0x53, 0x42, 0x43, 0x00, 0x00, 0x00, 0x00,
115 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xfe,
116 0x00, 0x00, 0x00, 0xc0, 0xd1, 0x05, 0x00, 0x40,
117 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00
118};
119
120static const char cmd_misc[CMD_SIZE] = {
121 0x55, 0x53, 0x42, 0x43, 0x00, 0x00, 0x00, 0x00,
122 0x04, 0x00, 0x00, 0x00, 0x80, 0x01, 0x10, 0xfd,
123 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00,
124 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
125};
126
127static const char data_block_header[DATA_BLOCK_HEADER_SIZE] = {
128 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
129 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
130 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
131 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
132 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
133 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
134 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
135 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
136 0xfb, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
137 0x00, 0x04, 0x15, 0x00, 0x00, 0xfc, 0x00, 0x00,
138 0x01, 0x00, 0x00, 0xdb
139};
140
141static const char data_last_block_header[DATA_BLOCK_HEADER_SIZE] = {
142 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
143 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
144 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
145 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
146 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
147 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
148 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
149 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
150 0xfb, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
151 0x2a, 0x00, 0x20, 0x00, 0xc0, 0x0f, 0x00, 0x00,
152 0x01, 0x00, 0x00, 0xd7
153};
154
155static const char data_block_footer[DATA_BLOCK_FOOTER_SIZE] = {
156 0xfb, 0x14, 0x02, 0x20, 0x00, 0x00, 0x00, 0x00,
157 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
158 0x80, 0x00, 0x00, 0x4f
159};
160
161static inline struct usb_device *gm12u320_to_usb_device(struct gm12u320_device *gm12u320)
162{
163 return interface_to_usbdev(to_usb_interface(gm12u320->dev.dev));
164}
165
166static int gm12u320_usb_alloc(struct gm12u320_device *gm12u320)
167{
168 int i, block_size;
169 const char *hdr;
170
171 gm12u320->cmd_buf = drmm_kmalloc(&gm12u320->dev, CMD_SIZE, GFP_KERNEL);
172 if (!gm12u320->cmd_buf)
173 return -ENOMEM;
174
175 for (i = 0; i < GM12U320_BLOCK_COUNT; i++) {
176 if (i == GM12U320_BLOCK_COUNT - 1) {
177 block_size = DATA_LAST_BLOCK_SIZE;
178 hdr = data_last_block_header;
179 } else {
180 block_size = DATA_BLOCK_SIZE;
181 hdr = data_block_header;
182 }
183
184 gm12u320->data_buf[i] = drmm_kzalloc(&gm12u320->dev,
185 block_size, GFP_KERNEL);
186 if (!gm12u320->data_buf[i])
187 return -ENOMEM;
188
189 memcpy(gm12u320->data_buf[i], hdr, DATA_BLOCK_HEADER_SIZE);
190 memcpy(gm12u320->data_buf[i] +
191 (block_size - DATA_BLOCK_FOOTER_SIZE),
192 data_block_footer, DATA_BLOCK_FOOTER_SIZE);
193 }
194
195 return 0;
196}
197
198static int gm12u320_misc_request(struct gm12u320_device *gm12u320,
199 u8 req_a, u8 req_b,
200 u8 arg_a, u8 arg_b, u8 arg_c, u8 arg_d)
201{
202 struct usb_device *udev = gm12u320_to_usb_device(gm12u320);
203 int ret, len;
204
205 memcpy(gm12u320->cmd_buf, &cmd_misc, CMD_SIZE);
206 gm12u320->cmd_buf[20] = req_a;
207 gm12u320->cmd_buf[21] = req_b;
208 gm12u320->cmd_buf[22] = arg_a;
209 gm12u320->cmd_buf[23] = arg_b;
210 gm12u320->cmd_buf[24] = arg_c;
211 gm12u320->cmd_buf[25] = arg_d;
212
213 /* Send request */
214 ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, MISC_SND_EPT),
215 gm12u320->cmd_buf, CMD_SIZE, &len, CMD_TIMEOUT);
216 if (ret || len != CMD_SIZE) {
217 GM12U320_ERR("Misc. req. error %d\n", ret);
218 return -EIO;
219 }
220
221 /* Read value */
222 ret = usb_bulk_msg(udev, usb_rcvbulkpipe(udev, MISC_RCV_EPT),
223 gm12u320->cmd_buf, MISC_VALUE_SIZE, &len,
224 DATA_TIMEOUT);
225 if (ret || len != MISC_VALUE_SIZE) {
226 GM12U320_ERR("Misc. value error %d\n", ret);
227 return -EIO;
228 }
229 /* cmd_buf[0] now contains the read value, which we don't use */
230
231 /* Read status */
232 ret = usb_bulk_msg(udev, usb_rcvbulkpipe(udev, MISC_RCV_EPT),
233 gm12u320->cmd_buf, READ_STATUS_SIZE, &len,
234 CMD_TIMEOUT);
235 if (ret || len != READ_STATUS_SIZE) {
236 GM12U320_ERR("Misc. status error %d\n", ret);
237 return -EIO;
238 }
239
240 return 0;
241}
242
243static void gm12u320_32bpp_to_24bpp_packed(u8 *dst, u8 *src, int len)
244{
245 while (len--) {
246 *dst++ = *src++;
247 *dst++ = *src++;
248 *dst++ = *src++;
249 src++;
250 }
251}
252
253static void gm12u320_copy_fb_to_blocks(struct gm12u320_device *gm12u320)
254{
255 int block, dst_offset, len, remain, ret, x1, x2, y1, y2;
256 struct drm_framebuffer *fb;
257 void *vaddr;
258 u8 *src;
259
260 mutex_lock(&gm12u320->fb_update.lock);
261
262 if (!gm12u320->fb_update.fb)
263 goto unlock;
264
265 fb = gm12u320->fb_update.fb;
266 x1 = gm12u320->fb_update.rect.x1;
267 x2 = gm12u320->fb_update.rect.x2;
268 y1 = gm12u320->fb_update.rect.y1;
269 y2 = gm12u320->fb_update.rect.y2;
270 vaddr = gm12u320->fb_update.src_map.vaddr; /* TODO: Use mapping abstraction properly */
271
272 ret = drm_gem_fb_begin_cpu_access(fb, DMA_FROM_DEVICE);
273 if (ret) {
274 GM12U320_ERR("drm_gem_fb_begin_cpu_access err: %d\n", ret);
275 goto put_fb;
276 }
277
278 src = vaddr + y1 * fb->pitches[0] + x1 * 4;
279
280 x1 += (GM12U320_REAL_WIDTH - GM12U320_USER_WIDTH) / 2;
281 x2 += (GM12U320_REAL_WIDTH - GM12U320_USER_WIDTH) / 2;
282
283 for (; y1 < y2; y1++) {
284 remain = 0;
285 len = (x2 - x1) * 3;
286 dst_offset = (y1 * GM12U320_REAL_WIDTH + x1) * 3;
287 block = dst_offset / DATA_BLOCK_CONTENT_SIZE;
288 dst_offset %= DATA_BLOCK_CONTENT_SIZE;
289
290 if ((dst_offset + len) > DATA_BLOCK_CONTENT_SIZE) {
291 remain = dst_offset + len - DATA_BLOCK_CONTENT_SIZE;
292 len = DATA_BLOCK_CONTENT_SIZE - dst_offset;
293 }
294
295 dst_offset += DATA_BLOCK_HEADER_SIZE;
296 len /= 3;
297
298 gm12u320_32bpp_to_24bpp_packed(
299 gm12u320->data_buf[block] + dst_offset,
300 src, len);
301
302 if (remain) {
303 block++;
304 dst_offset = DATA_BLOCK_HEADER_SIZE;
305 gm12u320_32bpp_to_24bpp_packed(
306 gm12u320->data_buf[block] + dst_offset,
307 src + len * 4, remain / 3);
308 }
309 src += fb->pitches[0];
310 }
311
312 drm_gem_fb_end_cpu_access(fb, DMA_FROM_DEVICE);
313put_fb:
314 drm_framebuffer_put(fb);
315 gm12u320->fb_update.fb = NULL;
316unlock:
317 mutex_unlock(&gm12u320->fb_update.lock);
318}
319
320static void gm12u320_fb_update_work(struct work_struct *work)
321{
322 struct gm12u320_device *gm12u320 =
323 container_of(to_delayed_work(work), struct gm12u320_device,
324 fb_update.work);
325 struct usb_device *udev = gm12u320_to_usb_device(gm12u320);
326 int block, block_size, len;
327 int ret = 0;
328
329 gm12u320_copy_fb_to_blocks(gm12u320);
330
331 for (block = 0; block < GM12U320_BLOCK_COUNT; block++) {
332 if (block == GM12U320_BLOCK_COUNT - 1)
333 block_size = DATA_LAST_BLOCK_SIZE;
334 else
335 block_size = DATA_BLOCK_SIZE;
336
337 /* Send data command to device */
338 memcpy(gm12u320->cmd_buf, cmd_data, CMD_SIZE);
339 gm12u320->cmd_buf[8] = block_size & 0xff;
340 gm12u320->cmd_buf[9] = block_size >> 8;
341 gm12u320->cmd_buf[20] = 0xfc - block * 4;
342 gm12u320->cmd_buf[21] =
343 block | (gm12u320->fb_update.frame << 7);
344
345 ret = usb_bulk_msg(udev,
346 usb_sndbulkpipe(udev, DATA_SND_EPT),
347 gm12u320->cmd_buf, CMD_SIZE, &len,
348 CMD_TIMEOUT);
349 if (ret || len != CMD_SIZE)
350 goto err;
351
352 /* Send data block to device */
353 ret = usb_bulk_msg(udev,
354 usb_sndbulkpipe(udev, DATA_SND_EPT),
355 gm12u320->data_buf[block], block_size,
356 &len, DATA_TIMEOUT);
357 if (ret || len != block_size)
358 goto err;
359
360 /* Read status */
361 ret = usb_bulk_msg(udev,
362 usb_rcvbulkpipe(udev, DATA_RCV_EPT),
363 gm12u320->cmd_buf, READ_STATUS_SIZE, &len,
364 CMD_TIMEOUT);
365 if (ret || len != READ_STATUS_SIZE)
366 goto err;
367 }
368
369 /* Send draw command to device */
370 memcpy(gm12u320->cmd_buf, cmd_draw, CMD_SIZE);
371 ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, DATA_SND_EPT),
372 gm12u320->cmd_buf, CMD_SIZE, &len, CMD_TIMEOUT);
373 if (ret || len != CMD_SIZE)
374 goto err;
375
376 /* Read status */
377 ret = usb_bulk_msg(udev, usb_rcvbulkpipe(udev, DATA_RCV_EPT),
378 gm12u320->cmd_buf, READ_STATUS_SIZE, &len,
379 gm12u320->fb_update.draw_status_timeout);
380 if (ret || len != READ_STATUS_SIZE)
381 goto err;
382
383 gm12u320->fb_update.draw_status_timeout = CMD_TIMEOUT;
384 gm12u320->fb_update.frame = !gm12u320->fb_update.frame;
385
386 /*
387 * We must draw a frame every 2s otherwise the projector
388 * switches back to showing its logo.
389 */
390 queue_delayed_work(system_long_wq, &gm12u320->fb_update.work,
391 IDLE_TIMEOUT);
392
393 return;
394err:
395 /* Do not log errors caused by module unload or device unplug */
396 if (ret != -ENODEV && ret != -ECONNRESET && ret != -ESHUTDOWN)
397 GM12U320_ERR("Frame update error: %d\n", ret);
398}
399
400static void gm12u320_fb_mark_dirty(struct drm_framebuffer *fb,
401 const struct iosys_map *map,
402 struct drm_rect *dirty)
403{
404 struct gm12u320_device *gm12u320 = to_gm12u320(fb->dev);
405 struct drm_framebuffer *old_fb = NULL;
406 bool wakeup = false;
407
408 mutex_lock(&gm12u320->fb_update.lock);
409
410 if (gm12u320->fb_update.fb != fb) {
411 old_fb = gm12u320->fb_update.fb;
412 drm_framebuffer_get(fb);
413 gm12u320->fb_update.fb = fb;
414 gm12u320->fb_update.rect = *dirty;
415 gm12u320->fb_update.src_map = *map;
416 wakeup = true;
417 } else {
418 struct drm_rect *rect = &gm12u320->fb_update.rect;
419
420 rect->x1 = min(rect->x1, dirty->x1);
421 rect->y1 = min(rect->y1, dirty->y1);
422 rect->x2 = max(rect->x2, dirty->x2);
423 rect->y2 = max(rect->y2, dirty->y2);
424 }
425
426 mutex_unlock(&gm12u320->fb_update.lock);
427
428 if (wakeup)
429 mod_delayed_work(system_long_wq, &gm12u320->fb_update.work, 0);
430
431 if (old_fb)
432 drm_framebuffer_put(old_fb);
433}
434
435static void gm12u320_stop_fb_update(struct gm12u320_device *gm12u320)
436{
437 struct drm_framebuffer *old_fb;
438
439 cancel_delayed_work_sync(&gm12u320->fb_update.work);
440
441 mutex_lock(&gm12u320->fb_update.lock);
442 old_fb = gm12u320->fb_update.fb;
443 gm12u320->fb_update.fb = NULL;
444 iosys_map_clear(&gm12u320->fb_update.src_map);
445 mutex_unlock(&gm12u320->fb_update.lock);
446
447 drm_framebuffer_put(old_fb);
448}
449
450static int gm12u320_set_ecomode(struct gm12u320_device *gm12u320)
451{
452 return gm12u320_misc_request(gm12u320, MISC_REQ_GET_SET_ECO_A,
453 MISC_REQ_GET_SET_ECO_B, 0x01 /* set */,
454 eco_mode ? 0x01 : 0x00, 0x00, 0x01);
455}
456
457/* ------------------------------------------------------------------ */
458/* gm12u320 connector */
459
460/*
461 *Â We use fake EDID info so that userspace know that it is dealing with
462 * an Acer projector, rather then listing this as an "unknown" monitor.
463 * Note this assumes this driver is only ever used with the Acer C120, if we
464 * add support for other devices the vendor and model should be parameterized.
465 */
466static struct edid gm12u320_edid = {
467 .header = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 },
468 .mfg_id = { 0x04, 0x72 }, /* "ACR" */
469 .prod_code = { 0x20, 0xc1 }, /* C120h */
470 .serial = 0xaa55aa55,
471 .mfg_week = 1,
472 .mfg_year = 16,
473 .version = 1, /* EDID 1.3 */
474 .revision = 3, /* EDID 1.3 */
475 .input = 0x08, /* Analog input */
476 .features = 0x0a, /* Pref timing in DTD 1 */
477 .standard_timings = { { 1, 1 }, { 1, 1 }, { 1, 1 }, { 1, 1 },
478 { 1, 1 }, { 1, 1 }, { 1, 1 }, { 1, 1 } },
479 .detailed_timings = { {
480 .pixel_clock = 3383,
481 /* hactive = 848, hblank = 256 */
482 .data.pixel_data.hactive_lo = 0x50,
483 .data.pixel_data.hblank_lo = 0x00,
484 .data.pixel_data.hactive_hblank_hi = 0x31,
485 /* vactive = 480, vblank = 28 */
486 .data.pixel_data.vactive_lo = 0xe0,
487 .data.pixel_data.vblank_lo = 0x1c,
488 .data.pixel_data.vactive_vblank_hi = 0x10,
489 /* hsync offset 40 pw 128, vsync offset 1 pw 4 */
490 .data.pixel_data.hsync_offset_lo = 0x28,
491 .data.pixel_data.hsync_pulse_width_lo = 0x80,
492 .data.pixel_data.vsync_offset_pulse_width_lo = 0x14,
493 .data.pixel_data.hsync_vsync_offset_pulse_width_hi = 0x00,
494 /* Digital separate syncs, hsync+, vsync+ */
495 .data.pixel_data.misc = 0x1e,
496 }, {
497 .pixel_clock = 0,
498 .data.other_data.type = 0xfd, /* Monitor ranges */
499 .data.other_data.data.range.min_vfreq = 59,
500 .data.other_data.data.range.max_vfreq = 61,
501 .data.other_data.data.range.min_hfreq_khz = 29,
502 .data.other_data.data.range.max_hfreq_khz = 32,
503 .data.other_data.data.range.pixel_clock_mhz = 4, /* 40 MHz */
504 .data.other_data.data.range.flags = 0,
505 .data.other_data.data.range.formula.cvt = {
506 0xa0, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 },
507 }, {
508 .pixel_clock = 0,
509 .data.other_data.type = 0xfc, /* Model string */
510 .data.other_data.data.str.str = {
511 'P', 'r', 'o', 'j', 'e', 'c', 't', 'o', 'r', '\n',
512 ' ', ' ', ' ' },
513 }, {
514 .pixel_clock = 0,
515 .data.other_data.type = 0xfe, /* Unspecified text / padding */
516 .data.other_data.data.str.str = {
517 '\n', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
518 ' ', ' ', ' ' },
519 } },
520 .checksum = 0x13,
521};
522
523static int gm12u320_conn_get_modes(struct drm_connector *connector)
524{
525 drm_connector_update_edid_property(connector, &gm12u320_edid);
526 return drm_add_edid_modes(connector, &gm12u320_edid);
527}
528
529static const struct drm_connector_helper_funcs gm12u320_conn_helper_funcs = {
530 .get_modes = gm12u320_conn_get_modes,
531};
532
533static const struct drm_connector_funcs gm12u320_conn_funcs = {
534 .fill_modes = drm_helper_probe_single_connector_modes,
535 .destroy = drm_connector_cleanup,
536 .reset = drm_atomic_helper_connector_reset,
537 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
538 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
539};
540
541static int gm12u320_conn_init(struct gm12u320_device *gm12u320)
542{
543 drm_connector_helper_add(&gm12u320->conn, &gm12u320_conn_helper_funcs);
544 return drm_connector_init(&gm12u320->dev, &gm12u320->conn,
545 &gm12u320_conn_funcs, DRM_MODE_CONNECTOR_VGA);
546}
547
548/* ------------------------------------------------------------------ */
549/* gm12u320 (simple) display pipe */
550
551static void gm12u320_pipe_enable(struct drm_simple_display_pipe *pipe,
552 struct drm_crtc_state *crtc_state,
553 struct drm_plane_state *plane_state)
554{
555 struct drm_rect rect = { 0, 0, GM12U320_USER_WIDTH, GM12U320_HEIGHT };
556 struct gm12u320_device *gm12u320 = to_gm12u320(pipe->crtc.dev);
557 struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(plane_state);
558
559 gm12u320->fb_update.draw_status_timeout = FIRST_FRAME_TIMEOUT;
560 gm12u320_fb_mark_dirty(plane_state->fb, &shadow_plane_state->data[0], &rect);
561}
562
563static void gm12u320_pipe_disable(struct drm_simple_display_pipe *pipe)
564{
565 struct gm12u320_device *gm12u320 = to_gm12u320(pipe->crtc.dev);
566
567 gm12u320_stop_fb_update(gm12u320);
568}
569
570static void gm12u320_pipe_update(struct drm_simple_display_pipe *pipe,
571 struct drm_plane_state *old_state)
572{
573 struct drm_plane_state *state = pipe->plane.state;
574 struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(state);
575 struct drm_rect rect;
576
577 if (drm_atomic_helper_damage_merged(old_state, state, &rect))
578 gm12u320_fb_mark_dirty(state->fb, &shadow_plane_state->data[0], &rect);
579}
580
581static const struct drm_simple_display_pipe_funcs gm12u320_pipe_funcs = {
582 .enable = gm12u320_pipe_enable,
583 .disable = gm12u320_pipe_disable,
584 .update = gm12u320_pipe_update,
585 DRM_GEM_SIMPLE_DISPLAY_PIPE_SHADOW_PLANE_FUNCS,
586};
587
588static const uint32_t gm12u320_pipe_formats[] = {
589 DRM_FORMAT_XRGB8888,
590};
591
592static const uint64_t gm12u320_pipe_modifiers[] = {
593 DRM_FORMAT_MOD_LINEAR,
594 DRM_FORMAT_MOD_INVALID
595};
596
597/*
598 * FIXME: Dma-buf sharing requires DMA support by the importing device.
599 * This function is a workaround to make USB devices work as well.
600 * See todo.rst for how to fix the issue in the dma-buf framework.
601 */
602static struct drm_gem_object *gm12u320_gem_prime_import(struct drm_device *dev,
603 struct dma_buf *dma_buf)
604{
605 struct gm12u320_device *gm12u320 = to_gm12u320(dev);
606
607 if (!gm12u320->dmadev)
608 return ERR_PTR(-ENODEV);
609
610 return drm_gem_prime_import_dev(dev, dma_buf, gm12u320->dmadev);
611}
612
613DEFINE_DRM_GEM_FOPS(gm12u320_fops);
614
615static const struct drm_driver gm12u320_drm_driver = {
616 .driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC,
617
618 .name = DRIVER_NAME,
619 .desc = DRIVER_DESC,
620 .date = DRIVER_DATE,
621 .major = DRIVER_MAJOR,
622 .minor = DRIVER_MINOR,
623
624 .fops = &gm12u320_fops,
625 DRM_GEM_SHMEM_DRIVER_OPS,
626 .gem_prime_import = gm12u320_gem_prime_import,
627};
628
629static const struct drm_mode_config_funcs gm12u320_mode_config_funcs = {
630 .fb_create = drm_gem_fb_create_with_dirty,
631 .atomic_check = drm_atomic_helper_check,
632 .atomic_commit = drm_atomic_helper_commit,
633};
634
635static int gm12u320_usb_probe(struct usb_interface *interface,
636 const struct usb_device_id *id)
637{
638 struct gm12u320_device *gm12u320;
639 struct drm_device *dev;
640 int ret;
641
642 /*
643 * The gm12u320 presents itself to the system as 2 usb mass-storage
644 * interfaces, we only care about / need the first one.
645 */
646 if (interface->cur_altsetting->desc.bInterfaceNumber != 0)
647 return -ENODEV;
648
649 gm12u320 = devm_drm_dev_alloc(&interface->dev, &gm12u320_drm_driver,
650 struct gm12u320_device, dev);
651 if (IS_ERR(gm12u320))
652 return PTR_ERR(gm12u320);
653 dev = &gm12u320->dev;
654
655 gm12u320->dmadev = usb_intf_get_dma_device(to_usb_interface(dev->dev));
656 if (!gm12u320->dmadev)
657 drm_warn(dev, "buffer sharing not supported"); /* not an error */
658
659 INIT_DELAYED_WORK(&gm12u320->fb_update.work, gm12u320_fb_update_work);
660 mutex_init(&gm12u320->fb_update.lock);
661
662 ret = drmm_mode_config_init(dev);
663 if (ret)
664 goto err_put_device;
665
666 dev->mode_config.min_width = GM12U320_USER_WIDTH;
667 dev->mode_config.max_width = GM12U320_USER_WIDTH;
668 dev->mode_config.min_height = GM12U320_HEIGHT;
669 dev->mode_config.max_height = GM12U320_HEIGHT;
670 dev->mode_config.funcs = &gm12u320_mode_config_funcs;
671
672 ret = gm12u320_usb_alloc(gm12u320);
673 if (ret)
674 goto err_put_device;
675
676 ret = gm12u320_set_ecomode(gm12u320);
677 if (ret)
678 goto err_put_device;
679
680 ret = gm12u320_conn_init(gm12u320);
681 if (ret)
682 goto err_put_device;
683
684 ret = drm_simple_display_pipe_init(&gm12u320->dev,
685 &gm12u320->pipe,
686 &gm12u320_pipe_funcs,
687 gm12u320_pipe_formats,
688 ARRAY_SIZE(gm12u320_pipe_formats),
689 gm12u320_pipe_modifiers,
690 &gm12u320->conn);
691 if (ret)
692 goto err_put_device;
693
694 drm_mode_config_reset(dev);
695
696 usb_set_intfdata(interface, dev);
697 ret = drm_dev_register(dev, 0);
698 if (ret)
699 goto err_put_device;
700
701 drm_fbdev_generic_setup(dev, 0);
702
703 return 0;
704
705err_put_device:
706 put_device(gm12u320->dmadev);
707 return ret;
708}
709
710static void gm12u320_usb_disconnect(struct usb_interface *interface)
711{
712 struct drm_device *dev = usb_get_intfdata(interface);
713 struct gm12u320_device *gm12u320 = to_gm12u320(dev);
714
715 put_device(gm12u320->dmadev);
716 gm12u320->dmadev = NULL;
717 drm_dev_unplug(dev);
718 drm_atomic_helper_shutdown(dev);
719}
720
721static __maybe_unused int gm12u320_suspend(struct usb_interface *interface,
722 pm_message_t message)
723{
724 struct drm_device *dev = usb_get_intfdata(interface);
725
726 return drm_mode_config_helper_suspend(dev);
727}
728
729static __maybe_unused int gm12u320_resume(struct usb_interface *interface)
730{
731 struct drm_device *dev = usb_get_intfdata(interface);
732 struct gm12u320_device *gm12u320 = to_gm12u320(dev);
733
734 gm12u320_set_ecomode(gm12u320);
735
736 return drm_mode_config_helper_resume(dev);
737}
738
739static const struct usb_device_id id_table[] = {
740 { USB_DEVICE(0x1de1, 0xc102) },
741 {},
742};
743MODULE_DEVICE_TABLE(usb, id_table);
744
745static struct usb_driver gm12u320_usb_driver = {
746 .name = "gm12u320",
747 .probe = gm12u320_usb_probe,
748 .disconnect = gm12u320_usb_disconnect,
749 .id_table = id_table,
750#ifdef CONFIG_PM
751 .suspend = gm12u320_suspend,
752 .resume = gm12u320_resume,
753 .reset_resume = gm12u320_resume,
754#endif
755};
756
757module_usb_driver(gm12u320_usb_driver);
758MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
759MODULE_LICENSE("GPL");