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 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 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 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 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 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 */ 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 */ 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 */ 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. */ 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 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 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 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 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 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 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 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 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