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/pm.h>
8 #include <linux/usb.h>
9
10 #include <drm/clients/drm_client_setup.h>
11 #include <drm/drm_atomic_helper.h>
12 #include <drm/drm_atomic_state_helper.h>
13 #include <drm/drm_connector.h>
14 #include <drm/drm_damage_helper.h>
15 #include <drm/drm_drv.h>
16 #include <drm/drm_edid.h>
17 #include <drm/drm_fbdev_shmem.h>
18 #include <drm/drm_file.h>
19 #include <drm/drm_format_helper.h>
20 #include <drm/drm_fourcc.h>
21 #include <drm/drm_framebuffer.h>
22 #include <drm/drm_gem_atomic_helper.h>
23 #include <drm/drm_gem_framebuffer_helper.h>
24 #include <drm/drm_gem_shmem_helper.h>
25 #include <drm/drm_ioctl.h>
26 #include <drm/drm_managed.h>
27 #include <drm/drm_modeset_helper_vtables.h>
28 #include <drm/drm_probe_helper.h>
29 #include <drm/drm_simple_kms_helper.h>
30
31 static bool eco_mode;
32 module_param(eco_mode, bool, 0644);
33 MODULE_PARM_DESC(eco_mode, "Turn on Eco mode (less bright, more silent)");
34
35 #define DRIVER_NAME "gm12u320"
36 #define DRIVER_DESC "Grain Media GM12U320 USB projector display"
37 #define DRIVER_MAJOR 1
38 #define DRIVER_MINOR 0
39
40 /*
41 * The DLP has an actual width of 854 pixels, but that is not a multiple
42 * of 8, breaking things left and right, so we export a width of 848.
43 */
44 #define GM12U320_USER_WIDTH 848
45 #define GM12U320_REAL_WIDTH 854
46 #define GM12U320_HEIGHT 480
47
48 #define GM12U320_BLOCK_COUNT 20
49
50 #define GM12U320_ERR(fmt, ...) \
51 DRM_DEV_ERROR(gm12u320->dev.dev, fmt, ##__VA_ARGS__)
52
53 #define MISC_RCV_EPT 1
54 #define DATA_RCV_EPT 2
55 #define DATA_SND_EPT 3
56 #define MISC_SND_EPT 4
57
58 #define DATA_BLOCK_HEADER_SIZE 84
59 #define DATA_BLOCK_CONTENT_SIZE 64512
60 #define DATA_BLOCK_FOOTER_SIZE 20
61 #define DATA_BLOCK_SIZE (DATA_BLOCK_HEADER_SIZE + \
62 DATA_BLOCK_CONTENT_SIZE + \
63 DATA_BLOCK_FOOTER_SIZE)
64 #define DATA_LAST_BLOCK_CONTENT_SIZE 4032
65 #define DATA_LAST_BLOCK_SIZE (DATA_BLOCK_HEADER_SIZE + \
66 DATA_LAST_BLOCK_CONTENT_SIZE + \
67 DATA_BLOCK_FOOTER_SIZE)
68
69 #define CMD_SIZE 31
70 #define READ_STATUS_SIZE 13
71 #define MISC_VALUE_SIZE 4
72
73 #define CMD_TIMEOUT 200
74 #define DATA_TIMEOUT 1000
75 #define IDLE_TIMEOUT 2000
76 #define FIRST_FRAME_TIMEOUT 2000
77
78 #define MISC_REQ_GET_SET_ECO_A 0xff
79 #define MISC_REQ_GET_SET_ECO_B 0x35
80 /* Windows driver does once every second, with arg d = 1, other args 0 */
81 #define MISC_REQ_UNKNOWN1_A 0xff
82 #define MISC_REQ_UNKNOWN1_B 0x38
83 /* Windows driver does this on init, with arg a, b = 0, c = 0xa0, d = 4 */
84 #define MISC_REQ_UNKNOWN2_A 0xa5
85 #define MISC_REQ_UNKNOWN2_B 0x00
86
87 struct gm12u320_device {
88 struct drm_device dev;
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
106 static 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
113 static 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
120 static 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
127 static 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
141 static 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
155 static 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
gm12u320_to_usb_device(struct gm12u320_device * gm12u320)161 static 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
gm12u320_usb_alloc(struct gm12u320_device * gm12u320)166 static 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
gm12u320_misc_request(struct gm12u320_device * gm12u320,u8 req_a,u8 req_b,u8 arg_a,u8 arg_b,u8 arg_c,u8 arg_d)198 static 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
gm12u320_32bpp_to_24bpp_packed(u8 * dst,u8 * src,int len)243 static 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
gm12u320_copy_fb_to_blocks(struct gm12u320_device * gm12u320)253 static 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);
313 put_fb:
314 drm_framebuffer_put(fb);
315 gm12u320->fb_update.fb = NULL;
316 unlock:
317 mutex_unlock(&gm12u320->fb_update.lock);
318 }
319
gm12u320_fb_update_work(struct work_struct * work)320 static 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 msecs_to_jiffies(IDLE_TIMEOUT));
392
393 return;
394 err:
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
gm12u320_fb_mark_dirty(struct drm_framebuffer * fb,const struct iosys_map * map,struct drm_rect * dirty)400 static 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
gm12u320_stop_fb_update(struct gm12u320_device * gm12u320)435 static 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
gm12u320_set_ecomode(struct gm12u320_device * gm12u320)450 static 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 */
466 static const 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
gm12u320_conn_get_modes(struct drm_connector * connector)523 static int gm12u320_conn_get_modes(struct drm_connector *connector)
524 {
525 const struct drm_edid *drm_edid;
526 int count;
527
528 drm_edid = drm_edid_alloc(&gm12u320_edid, sizeof(gm12u320_edid));
529 drm_edid_connector_update(connector, drm_edid);
530 count = drm_edid_connector_add_modes(connector);
531 drm_edid_free(drm_edid);
532
533 return count;
534 }
535
536 static const struct drm_connector_helper_funcs gm12u320_conn_helper_funcs = {
537 .get_modes = gm12u320_conn_get_modes,
538 };
539
540 static 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
gm12u320_conn_init(struct gm12u320_device * gm12u320)548 static 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
gm12u320_pipe_enable(struct drm_simple_display_pipe * pipe,struct drm_crtc_state * crtc_state,struct drm_plane_state * plane_state)558 static 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 struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(plane_state);
565
566 gm12u320->fb_update.draw_status_timeout = FIRST_FRAME_TIMEOUT;
567 gm12u320_fb_mark_dirty(plane_state->fb, &shadow_plane_state->data[0], &rect);
568 }
569
gm12u320_pipe_disable(struct drm_simple_display_pipe * pipe)570 static void gm12u320_pipe_disable(struct drm_simple_display_pipe *pipe)
571 {
572 struct gm12u320_device *gm12u320 = to_gm12u320(pipe->crtc.dev);
573
574 gm12u320_stop_fb_update(gm12u320);
575 }
576
gm12u320_pipe_update(struct drm_simple_display_pipe * pipe,struct drm_plane_state * old_state)577 static void gm12u320_pipe_update(struct drm_simple_display_pipe *pipe,
578 struct drm_plane_state *old_state)
579 {
580 struct drm_plane_state *state = pipe->plane.state;
581 struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(state);
582 struct drm_rect rect;
583
584 if (drm_atomic_helper_damage_merged(old_state, state, &rect))
585 gm12u320_fb_mark_dirty(state->fb, &shadow_plane_state->data[0], &rect);
586 }
587
588 static const struct drm_simple_display_pipe_funcs gm12u320_pipe_funcs = {
589 .enable = gm12u320_pipe_enable,
590 .disable = gm12u320_pipe_disable,
591 .update = gm12u320_pipe_update,
592 DRM_GEM_SIMPLE_DISPLAY_PIPE_SHADOW_PLANE_FUNCS,
593 };
594
595 static const uint32_t gm12u320_pipe_formats[] = {
596 DRM_FORMAT_XRGB8888,
597 };
598
599 static const uint64_t gm12u320_pipe_modifiers[] = {
600 DRM_FORMAT_MOD_LINEAR,
601 DRM_FORMAT_MOD_INVALID
602 };
603
604 DEFINE_DRM_GEM_FOPS(gm12u320_fops);
605
606 static const struct drm_driver gm12u320_drm_driver = {
607 .driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC,
608
609 .name = DRIVER_NAME,
610 .desc = DRIVER_DESC,
611 .major = DRIVER_MAJOR,
612 .minor = DRIVER_MINOR,
613
614 .fops = &gm12u320_fops,
615 DRM_GEM_SHMEM_DRIVER_OPS,
616 DRM_FBDEV_SHMEM_DRIVER_OPS,
617 };
618
619 static const struct drm_mode_config_funcs gm12u320_mode_config_funcs = {
620 .fb_create = drm_gem_fb_create_with_dirty,
621 .atomic_check = drm_atomic_helper_check,
622 .atomic_commit = drm_atomic_helper_commit,
623 };
624
gm12u320_usb_probe(struct usb_interface * interface,const struct usb_device_id * id)625 static int gm12u320_usb_probe(struct usb_interface *interface,
626 const struct usb_device_id *id)
627 {
628 struct gm12u320_device *gm12u320;
629 struct drm_device *dev;
630 struct device *dma_dev;
631 int ret;
632
633 /*
634 * The gm12u320 presents itself to the system as 2 usb mass-storage
635 * interfaces, we only care about / need the first one.
636 */
637 if (interface->cur_altsetting->desc.bInterfaceNumber != 0)
638 return -ENODEV;
639
640 gm12u320 = devm_drm_dev_alloc(&interface->dev, &gm12u320_drm_driver,
641 struct gm12u320_device, dev);
642 if (IS_ERR(gm12u320))
643 return PTR_ERR(gm12u320);
644 dev = &gm12u320->dev;
645
646 dma_dev = usb_intf_get_dma_device(interface);
647 if (dma_dev) {
648 drm_dev_set_dma_dev(dev, dma_dev);
649 put_device(dma_dev);
650 } else {
651 drm_warn(dev, "buffer sharing not supported"); /* not an error */
652 }
653
654 INIT_DELAYED_WORK(&gm12u320->fb_update.work, gm12u320_fb_update_work);
655 mutex_init(&gm12u320->fb_update.lock);
656
657 ret = drmm_mode_config_init(dev);
658 if (ret)
659 return ret;
660
661 dev->mode_config.min_width = GM12U320_USER_WIDTH;
662 dev->mode_config.max_width = GM12U320_USER_WIDTH;
663 dev->mode_config.min_height = GM12U320_HEIGHT;
664 dev->mode_config.max_height = GM12U320_HEIGHT;
665 dev->mode_config.funcs = &gm12u320_mode_config_funcs;
666
667 ret = gm12u320_usb_alloc(gm12u320);
668 if (ret)
669 return ret;
670
671 ret = gm12u320_set_ecomode(gm12u320);
672 if (ret)
673 return ret;
674
675 ret = gm12u320_conn_init(gm12u320);
676 if (ret)
677 return ret;
678
679 ret = drm_simple_display_pipe_init(&gm12u320->dev,
680 &gm12u320->pipe,
681 &gm12u320_pipe_funcs,
682 gm12u320_pipe_formats,
683 ARRAY_SIZE(gm12u320_pipe_formats),
684 gm12u320_pipe_modifiers,
685 &gm12u320->conn);
686 if (ret)
687 return ret;
688
689 drm_mode_config_reset(dev);
690
691 usb_set_intfdata(interface, dev);
692 ret = drm_dev_register(dev, 0);
693 if (ret)
694 return ret;
695
696 drm_client_setup(dev, NULL);
697
698 return 0;
699 }
700
gm12u320_usb_disconnect(struct usb_interface * interface)701 static void gm12u320_usb_disconnect(struct usb_interface *interface)
702 {
703 struct drm_device *dev = usb_get_intfdata(interface);
704
705 drm_dev_unplug(dev);
706 drm_atomic_helper_shutdown(dev);
707 }
708
gm12u320_suspend(struct usb_interface * interface,pm_message_t message)709 static int gm12u320_suspend(struct usb_interface *interface,
710 pm_message_t message)
711 {
712 struct drm_device *dev = usb_get_intfdata(interface);
713
714 return drm_mode_config_helper_suspend(dev);
715 }
716
gm12u320_resume(struct usb_interface * interface)717 static int gm12u320_resume(struct usb_interface *interface)
718 {
719 struct drm_device *dev = usb_get_intfdata(interface);
720 struct gm12u320_device *gm12u320 = to_gm12u320(dev);
721
722 gm12u320_set_ecomode(gm12u320);
723
724 return drm_mode_config_helper_resume(dev);
725 }
726
727 static const struct usb_device_id id_table[] = {
728 { USB_DEVICE(0x1de1, 0xc102) },
729 {},
730 };
731 MODULE_DEVICE_TABLE(usb, id_table);
732
733 static struct usb_driver gm12u320_usb_driver = {
734 .name = "gm12u320",
735 .probe = gm12u320_usb_probe,
736 .disconnect = gm12u320_usb_disconnect,
737 .id_table = id_table,
738 .suspend = pm_ptr(gm12u320_suspend),
739 .resume = pm_ptr(gm12u320_resume),
740 .reset_resume = pm_ptr(gm12u320_resume),
741 };
742
743 module_usb_driver(gm12u320_usb_driver);
744 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
745 MODULE_DESCRIPTION("GM12U320 driver for USB projectors");
746 MODULE_LICENSE("GPL");
747