1 // SPDX-License-Identifier: MIT
2 /*
3 * Copyright 2020 Noralf Trønnes
4 */
5
6 #include <linux/dma-buf.h>
7 #include <linux/dma-mapping.h>
8 #include <linux/lz4.h>
9 #include <linux/module.h>
10 #include <linux/platform_device.h>
11 #include <linux/string_helpers.h>
12 #include <linux/usb.h>
13 #include <linux/vmalloc.h>
14 #include <linux/workqueue.h>
15
16 #include <drm/clients/drm_client_setup.h>
17 #include <drm/drm_atomic_helper.h>
18 #include <drm/drm_blend.h>
19 #include <drm/drm_crtc_helper.h>
20 #include <drm/drm_damage_helper.h>
21 #include <drm/drm_debugfs.h>
22 #include <drm/drm_drv.h>
23 #include <drm/drm_fbdev_shmem.h>
24 #include <drm/drm_fourcc.h>
25 #include <drm/drm_gem_atomic_helper.h>
26 #include <drm/drm_gem_framebuffer_helper.h>
27 #include <drm/drm_gem_shmem_helper.h>
28 #include <drm/drm_managed.h>
29 #include <drm/drm_print.h>
30 #include <drm/drm_probe_helper.h>
31 #include <drm/gud.h>
32
33 #include "gud_internal.h"
34
35 /* Only used internally */
36 static const struct drm_format_info gud_drm_format_r1 = {
37 .format = GUD_DRM_FORMAT_R1,
38 .num_planes = 1,
39 .char_per_block = { 1, 0, 0 },
40 .block_w = { 8, 0, 0 },
41 .block_h = { 1, 0, 0 },
42 .hsub = 1,
43 .vsub = 1,
44 };
45
46 static const struct drm_format_info gud_drm_format_xrgb1111 = {
47 .format = GUD_DRM_FORMAT_XRGB1111,
48 .num_planes = 1,
49 .char_per_block = { 1, 0, 0 },
50 .block_w = { 2, 0, 0 },
51 .block_h = { 1, 0, 0 },
52 .hsub = 1,
53 .vsub = 1,
54 };
55
gud_usb_control_msg(struct usb_interface * intf,bool in,u8 request,u16 value,void * buf,size_t len)56 static int gud_usb_control_msg(struct usb_interface *intf, bool in,
57 u8 request, u16 value, void *buf, size_t len)
58 {
59 u8 requesttype = USB_TYPE_VENDOR | USB_RECIP_INTERFACE;
60 u8 ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
61 struct usb_device *usb = interface_to_usbdev(intf);
62 unsigned int pipe;
63
64 if (len && !buf)
65 return -EINVAL;
66
67 if (in) {
68 pipe = usb_rcvctrlpipe(usb, 0);
69 requesttype |= USB_DIR_IN;
70 } else {
71 pipe = usb_sndctrlpipe(usb, 0);
72 requesttype |= USB_DIR_OUT;
73 }
74
75 return usb_control_msg(usb, pipe, request, requesttype, value,
76 ifnum, buf, len, USB_CTRL_GET_TIMEOUT);
77 }
78
gud_get_display_descriptor(struct usb_interface * intf,struct gud_display_descriptor_req * desc)79 static int gud_get_display_descriptor(struct usb_interface *intf,
80 struct gud_display_descriptor_req *desc)
81 {
82 void *buf;
83 int ret;
84
85 buf = kmalloc_obj(*desc);
86 if (!buf)
87 return -ENOMEM;
88
89 ret = gud_usb_control_msg(intf, true, GUD_REQ_GET_DESCRIPTOR, 0, buf, sizeof(*desc));
90 memcpy(desc, buf, sizeof(*desc));
91 kfree(buf);
92 if (ret < 0)
93 return ret;
94 if (ret != sizeof(*desc))
95 return -EIO;
96
97 if (desc->magic != le32_to_cpu(GUD_DISPLAY_MAGIC))
98 return -ENODATA;
99
100 DRM_DEV_DEBUG_DRIVER(&intf->dev,
101 "version=%u flags=0x%x compression=0x%x max_buffer_size=%u\n",
102 desc->version, le32_to_cpu(desc->flags), desc->compression,
103 le32_to_cpu(desc->max_buffer_size));
104
105 if (!desc->version || !desc->max_width || !desc->max_height ||
106 le32_to_cpu(desc->min_width) > le32_to_cpu(desc->max_width) ||
107 le32_to_cpu(desc->min_height) > le32_to_cpu(desc->max_height))
108 return -EINVAL;
109
110 return 0;
111 }
112
gud_status_to_errno(u8 status)113 static int gud_status_to_errno(u8 status)
114 {
115 switch (status) {
116 case GUD_STATUS_OK:
117 return 0;
118 case GUD_STATUS_BUSY:
119 return -EBUSY;
120 case GUD_STATUS_REQUEST_NOT_SUPPORTED:
121 return -EOPNOTSUPP;
122 case GUD_STATUS_PROTOCOL_ERROR:
123 return -EPROTO;
124 case GUD_STATUS_INVALID_PARAMETER:
125 return -EINVAL;
126 case GUD_STATUS_ERROR:
127 return -EREMOTEIO;
128 default:
129 return -EREMOTEIO;
130 }
131 }
132
gud_usb_get_status(struct usb_interface * intf)133 static int gud_usb_get_status(struct usb_interface *intf)
134 {
135 int ret, status = -EIO;
136 u8 *buf;
137
138 buf = kmalloc_obj(*buf);
139 if (!buf)
140 return -ENOMEM;
141
142 ret = gud_usb_control_msg(intf, true, GUD_REQ_GET_STATUS, 0, buf, sizeof(*buf));
143 if (ret == sizeof(*buf))
144 status = gud_status_to_errno(*buf);
145 kfree(buf);
146
147 if (ret < 0)
148 return ret;
149
150 return status;
151 }
152
gud_usb_transfer(struct gud_device * gdrm,bool in,u8 request,u16 index,void * buf,size_t len)153 static int gud_usb_transfer(struct gud_device *gdrm, bool in, u8 request, u16 index,
154 void *buf, size_t len)
155 {
156 struct usb_interface *intf = to_usb_interface(gdrm->drm.dev);
157 int idx, ret;
158
159 drm_dbg(&gdrm->drm, "%s: request=0x%x index=%u len=%zu\n",
160 in ? "get" : "set", request, index, len);
161
162 if (!drm_dev_enter(&gdrm->drm, &idx))
163 return -ENODEV;
164
165 mutex_lock(&gdrm->ctrl_lock);
166
167 ret = gud_usb_control_msg(intf, in, request, index, buf, len);
168 if (ret == -EPIPE || ((gdrm->flags & GUD_DISPLAY_FLAG_STATUS_ON_SET) && !in && ret >= 0)) {
169 int status;
170
171 status = gud_usb_get_status(intf);
172 if (status < 0) {
173 ret = status;
174 } else if (ret < 0) {
175 dev_err_once(gdrm->drm.dev,
176 "Unexpected status OK for failed transfer\n");
177 ret = -EPIPE;
178 }
179 }
180
181 if (ret < 0) {
182 drm_dbg(&gdrm->drm, "ret=%d\n", ret);
183 gdrm->stats_num_errors++;
184 }
185
186 mutex_unlock(&gdrm->ctrl_lock);
187 drm_dev_exit(idx);
188
189 return ret;
190 }
191
192 /*
193 * @buf cannot be allocated on the stack.
194 * Returns number of bytes received or negative error code on failure.
195 */
gud_usb_get(struct gud_device * gdrm,u8 request,u16 index,void * buf,size_t max_len)196 int gud_usb_get(struct gud_device *gdrm, u8 request, u16 index, void *buf, size_t max_len)
197 {
198 return gud_usb_transfer(gdrm, true, request, index, buf, max_len);
199 }
200
201 /*
202 * @buf can be allocated on the stack or NULL.
203 * Returns zero on success or negative error code on failure.
204 */
gud_usb_set(struct gud_device * gdrm,u8 request,u16 index,void * buf,size_t len)205 int gud_usb_set(struct gud_device *gdrm, u8 request, u16 index, void *buf, size_t len)
206 {
207 void *trbuf = NULL;
208 int ret;
209
210 if (buf && len) {
211 trbuf = kmemdup(buf, len, GFP_KERNEL);
212 if (!trbuf)
213 return -ENOMEM;
214 }
215
216 ret = gud_usb_transfer(gdrm, false, request, index, trbuf, len);
217 kfree(trbuf);
218 if (ret < 0)
219 return ret;
220
221 return ret != len ? -EIO : 0;
222 }
223
224 /*
225 * @val can be allocated on the stack.
226 * Returns zero on success or negative error code on failure.
227 */
gud_usb_get_u8(struct gud_device * gdrm,u8 request,u16 index,u8 * val)228 int gud_usb_get_u8(struct gud_device *gdrm, u8 request, u16 index, u8 *val)
229 {
230 u8 *buf;
231 int ret;
232
233 buf = kmalloc(sizeof(*val), GFP_KERNEL);
234 if (!buf)
235 return -ENOMEM;
236
237 ret = gud_usb_get(gdrm, request, index, buf, sizeof(*val));
238 *val = *buf;
239 kfree(buf);
240 if (ret < 0)
241 return ret;
242
243 return ret != sizeof(*val) ? -EIO : 0;
244 }
245
246 /* Returns zero on success or negative error code on failure. */
gud_usb_set_u8(struct gud_device * gdrm,u8 request,u8 val)247 int gud_usb_set_u8(struct gud_device *gdrm, u8 request, u8 val)
248 {
249 return gud_usb_set(gdrm, request, 0, &val, sizeof(val));
250 }
251
gud_plane_add_properties(struct gud_device * gdrm)252 static int gud_plane_add_properties(struct gud_device *gdrm)
253 {
254 struct gud_property_req *properties;
255 unsigned int i, num_properties;
256 int ret;
257
258 properties = kzalloc_objs(*properties, GUD_PROPERTIES_MAX_NUM);
259 if (!properties)
260 return -ENOMEM;
261
262 ret = gud_usb_get(gdrm, GUD_REQ_GET_PROPERTIES, 0,
263 properties, GUD_PROPERTIES_MAX_NUM * sizeof(*properties));
264 if (ret <= 0)
265 goto out;
266 if (ret % sizeof(*properties)) {
267 ret = -EIO;
268 goto out;
269 }
270
271 num_properties = ret / sizeof(*properties);
272 ret = 0;
273
274 gdrm->properties = drmm_kcalloc(&gdrm->drm, num_properties, sizeof(*gdrm->properties),
275 GFP_KERNEL);
276 if (!gdrm->properties) {
277 ret = -ENOMEM;
278 goto out;
279 }
280
281 for (i = 0; i < num_properties; i++) {
282 u16 prop = le16_to_cpu(properties[i].prop);
283 u64 val = le64_to_cpu(properties[i].val);
284
285 switch (prop) {
286 case GUD_PROPERTY_ROTATION:
287 /*
288 * DRM UAPI matches the protocol so use the value directly,
289 * but mask out any additions on future devices.
290 */
291 val &= GUD_ROTATION_MASK;
292 if (!(val & GUD_ROTATION_0))
293 continue;
294 ret = drm_plane_create_rotation_property(&gdrm->plane,
295 DRM_MODE_ROTATE_0, val);
296 break;
297 default:
298 /* New ones might show up in future devices, skip those we don't know. */
299 drm_dbg(&gdrm->drm, "Ignoring unknown property: %u\n", prop);
300 continue;
301 }
302
303 if (ret)
304 goto out;
305
306 gdrm->properties[gdrm->num_properties++] = prop;
307 }
308 out:
309 kfree(properties);
310
311 return ret;
312 }
313
gud_stats_debugfs(struct seq_file * m,void * data)314 static int gud_stats_debugfs(struct seq_file *m, void *data)
315 {
316 struct drm_debugfs_entry *entry = m->private;
317 struct gud_device *gdrm = to_gud_device(entry->dev);
318 char buf[10];
319
320 string_get_size(gdrm->bulk_len, 1, STRING_UNITS_2, buf, sizeof(buf));
321 seq_printf(m, "Max buffer size: %s\n", buf);
322 seq_printf(m, "Number of errors: %u\n", gdrm->stats_num_errors);
323
324 seq_puts(m, "Compression: ");
325 if (gdrm->compression & GUD_COMPRESSION_LZ4)
326 seq_puts(m, " lz4");
327 if (!gdrm->compression)
328 seq_puts(m, " none");
329 seq_puts(m, "\n");
330
331 if (gdrm->compression) {
332 u64 remainder;
333 u64 ratio = div64_u64_rem(gdrm->stats_length, gdrm->stats_actual_length,
334 &remainder);
335 u64 ratio_frac = div64_u64(remainder * 10, gdrm->stats_actual_length);
336
337 seq_printf(m, "Compression ratio: %llu.%llu\n", ratio, ratio_frac);
338 }
339
340 return 0;
341 }
342
343 static const struct drm_crtc_helper_funcs gud_crtc_helper_funcs = {
344 .atomic_check = drm_crtc_helper_atomic_check,
345 .atomic_enable = gud_crtc_atomic_enable,
346 .atomic_disable = gud_crtc_atomic_disable,
347 };
348
349 static const struct drm_crtc_funcs gud_crtc_funcs = {
350 .reset = drm_atomic_helper_crtc_reset,
351 .destroy = drm_crtc_cleanup,
352 .set_config = drm_atomic_helper_set_config,
353 .page_flip = drm_atomic_helper_page_flip,
354 .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
355 .atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
356 };
357
358 static const struct drm_plane_helper_funcs gud_plane_helper_funcs = {
359 DRM_GEM_SHADOW_PLANE_HELPER_FUNCS,
360 .atomic_check = gud_plane_atomic_check,
361 .atomic_update = gud_plane_atomic_update,
362 };
363
364 static const struct drm_plane_funcs gud_plane_funcs = {
365 .update_plane = drm_atomic_helper_update_plane,
366 .disable_plane = drm_atomic_helper_disable_plane,
367 .destroy = drm_plane_cleanup,
368 DRM_GEM_SHADOW_PLANE_FUNCS,
369 };
370
371 static const struct drm_mode_config_helper_funcs gud_mode_config_helpers = {
372 .atomic_commit_tail = drm_atomic_helper_commit_tail_rpm,
373 };
374
375 static const struct drm_mode_config_funcs gud_mode_config_funcs = {
376 .fb_create = drm_gem_fb_create_with_dirty,
377 .atomic_check = drm_atomic_helper_check,
378 .atomic_commit = drm_atomic_helper_commit,
379 };
380
381 static const u64 gud_plane_modifiers[] = {
382 DRM_FORMAT_MOD_LINEAR,
383 DRM_FORMAT_MOD_INVALID
384 };
385
386 DEFINE_DRM_GEM_FOPS(gud_fops);
387
388 static const struct drm_driver gud_drm_driver = {
389 .driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC,
390 .fops = &gud_fops,
391 DRM_GEM_SHMEM_DRIVER_OPS,
392 DRM_FBDEV_SHMEM_DRIVER_OPS,
393
394 .name = "gud",
395 .desc = "Generic USB Display",
396 .major = 1,
397 .minor = 0,
398 };
399
gud_alloc_bulk_buffer(struct gud_device * gdrm)400 static int gud_alloc_bulk_buffer(struct gud_device *gdrm)
401 {
402 unsigned int i, num_pages;
403 struct page **pages;
404 void *ptr;
405 int ret;
406
407 gdrm->bulk_buf = vmalloc_32(gdrm->bulk_len);
408 if (!gdrm->bulk_buf)
409 return -ENOMEM;
410
411 num_pages = DIV_ROUND_UP(gdrm->bulk_len, PAGE_SIZE);
412 pages = kmalloc_objs(struct page *, num_pages);
413 if (!pages)
414 return -ENOMEM;
415
416 for (i = 0, ptr = gdrm->bulk_buf; i < num_pages; i++, ptr += PAGE_SIZE)
417 pages[i] = vmalloc_to_page(ptr);
418
419 ret = sg_alloc_table_from_pages(&gdrm->bulk_sgt, pages, num_pages,
420 0, gdrm->bulk_len, GFP_KERNEL);
421 kfree(pages);
422
423 return ret;
424 }
425
gud_free_buffers_and_mutex(void * data)426 static void gud_free_buffers_and_mutex(void *data)
427 {
428 struct gud_device *gdrm = data;
429
430 vfree(gdrm->compress_buf);
431 gdrm->compress_buf = NULL;
432 sg_free_table(&gdrm->bulk_sgt);
433 vfree(gdrm->bulk_buf);
434 gdrm->bulk_buf = NULL;
435 mutex_destroy(&gdrm->ctrl_lock);
436 }
437
gud_probe(struct usb_interface * intf,const struct usb_device_id * id)438 static int gud_probe(struct usb_interface *intf, const struct usb_device_id *id)
439 {
440 const struct drm_format_info *xrgb8888_emulation_format = NULL;
441 bool rgb565_supported = false, xrgb8888_supported = false;
442 unsigned int num_formats_dev, num_formats = 0;
443 struct usb_endpoint_descriptor *bulk_out;
444 struct gud_display_descriptor_req desc;
445 struct device *dev = &intf->dev;
446 size_t max_buffer_size = 0;
447 struct gud_device *gdrm;
448 struct drm_device *drm;
449 struct device *dma_dev;
450 u8 *formats_dev;
451 u32 *formats;
452 int ret, i;
453
454 ret = usb_find_bulk_out_endpoint(intf->cur_altsetting, &bulk_out);
455 if (ret)
456 return ret;
457
458 ret = gud_get_display_descriptor(intf, &desc);
459 if (ret) {
460 DRM_DEV_DEBUG_DRIVER(dev, "Not a display interface: ret=%d\n", ret);
461 return -ENODEV;
462 }
463
464 if (desc.version > 1) {
465 dev_err(dev, "Protocol version %u is not supported\n", desc.version);
466 return -ENODEV;
467 }
468
469 gdrm = devm_drm_dev_alloc(dev, &gud_drm_driver, struct gud_device, drm);
470 if (IS_ERR(gdrm))
471 return PTR_ERR(gdrm);
472
473 drm = &gdrm->drm;
474
475 gdrm->flags = le32_to_cpu(desc.flags);
476 gdrm->compression = desc.compression & GUD_COMPRESSION_LZ4;
477
478 if (gdrm->flags & GUD_DISPLAY_FLAG_FULL_UPDATE && gdrm->compression)
479 return -EINVAL;
480
481 mutex_init(&gdrm->ctrl_lock);
482 mutex_init(&gdrm->damage_lock);
483 INIT_WORK(&gdrm->work, gud_flush_work);
484 gud_clear_damage(gdrm);
485
486 ret = devm_add_action(dev, gud_free_buffers_and_mutex, gdrm);
487 if (ret)
488 return ret;
489
490 usb_set_intfdata(intf, gdrm);
491
492 dma_dev = usb_intf_get_dma_device(intf);
493 if (dma_dev) {
494 drm_dev_set_dma_dev(drm, dma_dev);
495 put_device(dma_dev);
496 } else {
497 dev_warn(dev, "buffer sharing not supported"); /* not an error */
498 }
499
500 /* Mode config init */
501 ret = drmm_mode_config_init(drm);
502 if (ret)
503 return ret;
504
505 drm->mode_config.min_width = le32_to_cpu(desc.min_width);
506 drm->mode_config.max_width = le32_to_cpu(desc.max_width);
507 drm->mode_config.min_height = le32_to_cpu(desc.min_height);
508 drm->mode_config.max_height = le32_to_cpu(desc.max_height);
509 drm->mode_config.funcs = &gud_mode_config_funcs;
510 drm->mode_config.helper_private = &gud_mode_config_helpers;
511
512 /* Format init */
513 formats_dev = devm_kmalloc(dev, GUD_FORMATS_MAX_NUM, GFP_KERNEL);
514 /* Add room for emulated XRGB8888 */
515 formats = devm_kmalloc_array(dev, GUD_FORMATS_MAX_NUM + 1, sizeof(*formats), GFP_KERNEL);
516 if (!formats_dev || !formats)
517 return -ENOMEM;
518
519 ret = gud_usb_get(gdrm, GUD_REQ_GET_FORMATS, 0, formats_dev, GUD_FORMATS_MAX_NUM);
520 if (ret < 0)
521 return ret;
522
523 num_formats_dev = ret;
524 for (i = 0; i < num_formats_dev; i++) {
525 const struct drm_format_info *info;
526 size_t fmt_buf_size;
527 u32 format;
528
529 format = gud_to_fourcc(formats_dev[i]);
530 if (!format) {
531 drm_dbg(drm, "Unsupported format: 0x%02x\n", formats_dev[i]);
532 continue;
533 }
534
535 if (format == GUD_DRM_FORMAT_R1)
536 info = &gud_drm_format_r1;
537 else if (format == GUD_DRM_FORMAT_XRGB1111)
538 info = &gud_drm_format_xrgb1111;
539 else
540 info = drm_format_info(format);
541
542 switch (format) {
543 case GUD_DRM_FORMAT_R1:
544 fallthrough;
545 case DRM_FORMAT_R8:
546 fallthrough;
547 case GUD_DRM_FORMAT_XRGB1111:
548 fallthrough;
549 case DRM_FORMAT_RGB332:
550 fallthrough;
551 case DRM_FORMAT_RGB888:
552 if (!xrgb8888_emulation_format)
553 xrgb8888_emulation_format = info;
554 break;
555 case DRM_FORMAT_RGB565:
556 rgb565_supported = true;
557 if (!xrgb8888_emulation_format)
558 xrgb8888_emulation_format = info;
559 break;
560 case DRM_FORMAT_XRGB8888:
561 xrgb8888_supported = true;
562 break;
563 }
564
565 fmt_buf_size = drm_format_info_min_pitch(info, 0, drm->mode_config.max_width) *
566 drm->mode_config.max_height;
567 max_buffer_size = max(max_buffer_size, fmt_buf_size);
568
569 if (format == GUD_DRM_FORMAT_R1 || format == GUD_DRM_FORMAT_XRGB1111)
570 continue; /* Internal not for userspace */
571
572 formats[num_formats++] = format;
573 }
574
575 if (!num_formats && !xrgb8888_emulation_format) {
576 dev_err(dev, "No supported pixel formats found\n");
577 return -EINVAL;
578 }
579
580 /* Prefer speed over color depth */
581 if (rgb565_supported)
582 drm->mode_config.preferred_depth = 16;
583
584 if (!xrgb8888_supported && xrgb8888_emulation_format) {
585 gdrm->xrgb8888_emulation_format = xrgb8888_emulation_format;
586 formats[num_formats++] = DRM_FORMAT_XRGB8888;
587 }
588
589 if (desc.max_buffer_size)
590 max_buffer_size = le32_to_cpu(desc.max_buffer_size);
591 /* Prevent a misbehaving device from allocating loads of RAM. 4096x4096@XRGB8888 = 64 MB */
592 if (max_buffer_size > SZ_64M)
593 max_buffer_size = SZ_64M;
594
595 gdrm->bulk_pipe = usb_sndbulkpipe(interface_to_usbdev(intf), usb_endpoint_num(bulk_out));
596 gdrm->bulk_len = max_buffer_size;
597
598 ret = gud_alloc_bulk_buffer(gdrm);
599 if (ret)
600 return ret;
601
602 if (gdrm->compression & GUD_COMPRESSION_LZ4) {
603 gdrm->lz4_comp_mem = devm_kmalloc(dev, LZ4_MEM_COMPRESS, GFP_KERNEL);
604 if (!gdrm->lz4_comp_mem)
605 return -ENOMEM;
606
607 gdrm->compress_buf = vmalloc(gdrm->bulk_len);
608 if (!gdrm->compress_buf)
609 return -ENOMEM;
610 }
611
612 /* Pipeline init */
613 ret = drm_universal_plane_init(drm, &gdrm->plane, 0,
614 &gud_plane_funcs,
615 formats, num_formats,
616 gud_plane_modifiers,
617 DRM_PLANE_TYPE_PRIMARY, NULL);
618 if (ret)
619 return ret;
620
621 drm_plane_helper_add(&gdrm->plane, &gud_plane_helper_funcs);
622 drm_plane_enable_fb_damage_clips(&gdrm->plane);
623
624 ret = gud_plane_add_properties(gdrm);
625 if (ret) {
626 dev_err(dev, "Failed to add properties (error=%d)\n", ret);
627 return ret;
628 }
629
630 ret = drm_crtc_init_with_planes(drm, &gdrm->crtc, &gdrm->plane, NULL,
631 &gud_crtc_funcs, NULL);
632 if (ret)
633 return ret;
634
635 drm_crtc_helper_add(&gdrm->crtc, &gud_crtc_helper_funcs);
636
637 ret = gud_get_connectors(gdrm);
638 if (ret) {
639 dev_err(dev, "Failed to get connectors (error=%d)\n", ret);
640 return ret;
641 }
642
643 drm_mode_config_reset(drm);
644 drm_kms_helper_poll_init(drm);
645
646 drm_debugfs_add_file(drm, "stats", gud_stats_debugfs, NULL);
647
648 ret = drm_dev_register(drm, 0);
649 if (ret)
650 return ret;
651
652 devm_kfree(dev, formats);
653 devm_kfree(dev, formats_dev);
654
655 drm_client_setup(drm, NULL);
656
657 return 0;
658 }
659
gud_disconnect(struct usb_interface * interface)660 static void gud_disconnect(struct usb_interface *interface)
661 {
662 struct gud_device *gdrm = usb_get_intfdata(interface);
663 struct drm_device *drm = &gdrm->drm;
664
665 drm_kms_helper_poll_fini(drm);
666 drm_dev_unplug(drm);
667 drm_atomic_helper_shutdown(drm);
668 }
669
gud_suspend(struct usb_interface * intf,pm_message_t message)670 static int gud_suspend(struct usb_interface *intf, pm_message_t message)
671 {
672 struct gud_device *gdrm = usb_get_intfdata(intf);
673
674 return drm_mode_config_helper_suspend(&gdrm->drm);
675 }
676
gud_resume(struct usb_interface * intf)677 static int gud_resume(struct usb_interface *intf)
678 {
679 struct gud_device *gdrm = usb_get_intfdata(intf);
680
681 drm_mode_config_helper_resume(&gdrm->drm);
682
683 return 0;
684 }
685
686 static const struct usb_device_id gud_id_table[] = {
687 { USB_DEVICE_INTERFACE_CLASS(0x1d50, 0x614d, USB_CLASS_VENDOR_SPEC) },
688 { USB_DEVICE_INTERFACE_CLASS(0x16d0, 0x10a9, USB_CLASS_VENDOR_SPEC) },
689 { USB_DEVICE_INTERFACE_CLASS(0x1209, 0x4fb3, USB_CLASS_VENDOR_SPEC) },
690 { }
691 };
692
693 MODULE_DEVICE_TABLE(usb, gud_id_table);
694
695 static struct usb_driver gud_usb_driver = {
696 .name = "gud",
697 .probe = gud_probe,
698 .disconnect = gud_disconnect,
699 .id_table = gud_id_table,
700 .suspend = gud_suspend,
701 .resume = gud_resume,
702 .reset_resume = gud_resume,
703 };
704
705 module_usb_driver(gud_usb_driver);
706
707 MODULE_AUTHOR("Noralf Trønnes");
708 MODULE_DESCRIPTION("GUD USB Display driver");
709 MODULE_LICENSE("Dual MIT/GPL");
710