drm/gud/gud_drv.c

0001 // SPDX-License-Identifier: MIT
0002 /*
0003  * Copyright 2020 Noralf Trønnes
0004  */
0005
0006 #include <linux/dma-buf.h>
0007 #include <linux/dma-mapping.h>
0008 #include <linux/lz4.h>
0009 #include <linux/module.h>
0010 #include <linux/platform_device.h>
0011 #include <linux/string_helpers.h>
0012 #include <linux/usb.h>
0013 #include <linux/vmalloc.h>
0014 #include <linux/workqueue.h>
0015
0016 #include <drm/drm_atomic_helper.h>
0017 #include <drm/drm_blend.h>
0018 #include <drm/drm_damage_helper.h>
0019 #include <drm/drm_debugfs.h>
0020 #include <drm/drm_drv.h>
0021 #include <drm/drm_fb_helper.h>
0022 #include <drm/drm_fourcc.h>
0023 #include <drm/drm_gem_atomic_helper.h>
0024 #include <drm/drm_gem_framebuffer_helper.h>
0025 #include <drm/drm_gem_shmem_helper.h>
0026 #include <drm/drm_managed.h>
0027 #include <drm/drm_print.h>
0028 #include <drm/drm_probe_helper.h>
0029 #include <drm/drm_simple_kms_helper.h>
0030 #include <drm/gud.h>
0031
0032 #include "gud_internal.h"
0033
0034 /* Only used internally */
0035 static const struct drm_format_info gud_drm_format_r1 = {
0036     .format = GUD_DRM_FORMAT_R1,
0037     .num_planes = 1,
0038     .char_per_block = { 1, 0, 0 },
0039     .block_w = { 8, 0, 0 },
0040     .block_h = { 1, 0, 0 },
0041     .hsub = 1,
0042     .vsub = 1,
0043 };
0044
0045 static const struct drm_format_info gud_drm_format_xrgb1111 = {
0046     .format = GUD_DRM_FORMAT_XRGB1111,
0047     .num_planes = 1,
0048     .char_per_block = { 1, 0, 0 },
0049     .block_w = { 2, 0, 0 },
0050     .block_h = { 1, 0, 0 },
0051     .hsub = 1,
0052     .vsub = 1,
0053 };
0054
0055 static int gud_usb_control_msg(struct usb_interface *intf, bool in,
0056                    u8 request, u16 value, void *buf, size_t len)
0057 {
0058     u8 requesttype = USB_TYPE_VENDOR | USB_RECIP_INTERFACE;
0059     u8 ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
0060     struct usb_device *usb = interface_to_usbdev(intf);
0061     unsigned int pipe;
0062
0063     if (len && !buf)
0064         return -EINVAL;
0065
0066     if (in) {
0067         pipe = usb_rcvctrlpipe(usb, 0);
0068         requesttype |= USB_DIR_IN;
0069     } else {
0070         pipe = usb_sndctrlpipe(usb, 0);
0071         requesttype |= USB_DIR_OUT;
0072     }
0073
0074     return usb_control_msg(usb, pipe, request, requesttype, value,
0075                    ifnum, buf, len, USB_CTRL_GET_TIMEOUT);
0076 }
0077
0078 static int gud_get_display_descriptor(struct usb_interface *intf,
0079                       struct gud_display_descriptor_req *desc)
0080 {
0081     void *buf;
0082     int ret;
0083
0084     buf = kmalloc(sizeof(*desc), GFP_KERNEL);
0085     if (!buf)
0086         return -ENOMEM;
0087
0088     ret = gud_usb_control_msg(intf, true, GUD_REQ_GET_DESCRIPTOR, 0, buf, sizeof(*desc));
0089     memcpy(desc, buf, sizeof(*desc));
0090     kfree(buf);
0091     if (ret < 0)
0092         return ret;
0093     if (ret != sizeof(*desc))
0094         return -EIO;
0095
0096     if (desc->magic != le32_to_cpu(GUD_DISPLAY_MAGIC))
0097         return -ENODATA;
0098
0099     DRM_DEV_DEBUG_DRIVER(&intf->dev,
0100                  "version=%u flags=0x%x compression=0x%x max_buffer_size=%u\n",
0101                  desc->version, le32_to_cpu(desc->flags), desc->compression,
0102                  le32_to_cpu(desc->max_buffer_size));
0103
0104     if (!desc->version || !desc->max_width || !desc->max_height ||
0105         le32_to_cpu(desc->min_width) > le32_to_cpu(desc->max_width) ||
0106         le32_to_cpu(desc->min_height) > le32_to_cpu(desc->max_height))
0107         return -EINVAL;
0108
0109     return 0;
0110 }
0111
0112 static int gud_status_to_errno(u8 status)
0113 {
0114     switch (status) {
0115     case GUD_STATUS_OK:
0116         return 0;
0117     case GUD_STATUS_BUSY:
0118         return -EBUSY;
0119     case GUD_STATUS_REQUEST_NOT_SUPPORTED:
0120         return -EOPNOTSUPP;
0121     case GUD_STATUS_PROTOCOL_ERROR:
0122         return -EPROTO;
0123     case GUD_STATUS_INVALID_PARAMETER:
0124         return -EINVAL;
0125     case GUD_STATUS_ERROR:
0126         return -EREMOTEIO;
0127     default:
0128         return -EREMOTEIO;
0129     }
0130 }
0131
0132 static int gud_usb_get_status(struct usb_interface *intf)
0133 {
0134     int ret, status = -EIO;
0135     u8 *buf;
0136
0137     buf = kmalloc(sizeof(*buf), GFP_KERNEL);
0138     if (!buf)
0139         return -ENOMEM;
0140
0141     ret = gud_usb_control_msg(intf, true, GUD_REQ_GET_STATUS, 0, buf, sizeof(*buf));
0142     if (ret == sizeof(*buf))
0143         status = gud_status_to_errno(*buf);
0144     kfree(buf);
0145
0146     if (ret < 0)
0147         return ret;
0148
0149     return status;
0150 }
0151
0152 static int gud_usb_transfer(struct gud_device *gdrm, bool in, u8 request, u16 index,
0153                 void *buf, size_t len)
0154 {
0155     struct usb_interface *intf = to_usb_interface(gdrm->drm.dev);
0156     int idx, ret;
0157
0158     drm_dbg(&gdrm->drm, "%s: request=0x%x index=%u len=%zu\n",
0159         in ? "get" : "set", request, index, len);
0160
0161     if (!drm_dev_enter(&gdrm->drm, &idx))
0162         return -ENODEV;
0163
0164     mutex_lock(&gdrm->ctrl_lock);
0165
0166     ret = gud_usb_control_msg(intf, in, request, index, buf, len);
0167     if (ret == -EPIPE || ((gdrm->flags & GUD_DISPLAY_FLAG_STATUS_ON_SET) && !in && ret >= 0)) {
0168         int status;
0169
0170         status = gud_usb_get_status(intf);
0171         if (status < 0) {
0172             ret = status;
0173         } else if (ret < 0) {
0174             dev_err_once(gdrm->drm.dev,
0175                      "Unexpected status OK for failed transfer\n");
0176             ret = -EPIPE;
0177         }
0178     }
0179
0180     if (ret < 0) {
0181         drm_dbg(&gdrm->drm, "ret=%d\n", ret);
0182         gdrm->stats_num_errors++;
0183     }
0184
0185     mutex_unlock(&gdrm->ctrl_lock);
0186     drm_dev_exit(idx);
0187
0188     return ret;
0189 }
0190
0191 /*
0192  * @buf cannot be allocated on the stack.
0193  * Returns number of bytes received or negative error code on failure.
0194  */
0195 int gud_usb_get(struct gud_device *gdrm, u8 request, u16 index, void *buf, size_t max_len)
0196 {
0197     return gud_usb_transfer(gdrm, true, request, index, buf, max_len);
0198 }
0199
0200 /*
0201  * @buf can be allocated on the stack or NULL.
0202  * Returns zero on success or negative error code on failure.
0203  */
0204 int gud_usb_set(struct gud_device *gdrm, u8 request, u16 index, void *buf, size_t len)
0205 {
0206     void *trbuf = NULL;
0207     int ret;
0208
0209     if (buf && len) {
0210         trbuf = kmemdup(buf, len, GFP_KERNEL);
0211         if (!trbuf)
0212             return -ENOMEM;
0213     }
0214
0215     ret = gud_usb_transfer(gdrm, false, request, index, trbuf, len);
0216     kfree(trbuf);
0217     if (ret < 0)
0218         return ret;
0219
0220     return ret != len ? -EIO : 0;
0221 }
0222
0223 /*
0224  * @val can be allocated on the stack.
0225  * Returns zero on success or negative error code on failure.
0226  */
0227 int gud_usb_get_u8(struct gud_device *gdrm, u8 request, u16 index, u8 *val)
0228 {
0229     u8 *buf;
0230     int ret;
0231
0232     buf = kmalloc(sizeof(*val), GFP_KERNEL);
0233     if (!buf)
0234         return -ENOMEM;
0235
0236     ret = gud_usb_get(gdrm, request, index, buf, sizeof(*val));
0237     *val = *buf;
0238     kfree(buf);
0239     if (ret < 0)
0240         return ret;
0241
0242     return ret != sizeof(*val) ? -EIO : 0;
0243 }
0244
0245 /* Returns zero on success or negative error code on failure. */
0246 int gud_usb_set_u8(struct gud_device *gdrm, u8 request, u8 val)
0247 {
0248     return gud_usb_set(gdrm, request, 0, &val, sizeof(val));
0249 }
0250
0251 static int gud_get_properties(struct gud_device *gdrm)
0252 {
0253     struct gud_property_req *properties;
0254     unsigned int i, num_properties;
0255     int ret;
0256
0257     properties = kcalloc(GUD_PROPERTIES_MAX_NUM, sizeof(*properties), GFP_KERNEL);
0258     if (!properties)
0259         return -ENOMEM;
0260
0261     ret = gud_usb_get(gdrm, GUD_REQ_GET_PROPERTIES, 0,
0262               properties, GUD_PROPERTIES_MAX_NUM * sizeof(*properties));
0263     if (ret <= 0)
0264         goto out;
0265     if (ret % sizeof(*properties)) {
0266         ret = -EIO;
0267         goto out;
0268     }
0269
0270     num_properties = ret / sizeof(*properties);
0271     ret = 0;
0272
0273     gdrm->properties = drmm_kcalloc(&gdrm->drm, num_properties, sizeof(*gdrm->properties),
0274                     GFP_KERNEL);
0275     if (!gdrm->properties) {
0276         ret = -ENOMEM;
0277         goto out;
0278     }
0279
0280     for (i = 0; i < num_properties; i++) {
0281         u16 prop = le16_to_cpu(properties[i].prop);
0282         u64 val = le64_to_cpu(properties[i].val);
0283
0284         switch (prop) {
0285         case GUD_PROPERTY_ROTATION:
0286             /*
0287              * DRM UAPI matches the protocol so use the value directly,
0288              * but mask out any additions on future devices.
0289              */
0290             val &= GUD_ROTATION_MASK;
0291             ret = drm_plane_create_rotation_property(&gdrm->pipe.plane,
0292                                  DRM_MODE_ROTATE_0, val);
0293             break;
0294         default:
0295             /* New ones might show up in future devices, skip those we don't know. */
0296             drm_dbg(&gdrm->drm, "Ignoring unknown property: %u\n", prop);
0297             continue;
0298         }
0299
0300         if (ret)
0301             goto out;
0302
0303         gdrm->properties[gdrm->num_properties++] = prop;
0304     }
0305 out:
0306     kfree(properties);
0307
0308     return ret;
0309 }
0310
0311 /*
0312  * FIXME: Dma-buf sharing requires DMA support by the importing device.
0313  *        This function is a workaround to make USB devices work as well.
0314  *        See todo.rst for how to fix the issue in the dma-buf framework.
0315  */
0316 static struct drm_gem_object *gud_gem_prime_import(struct drm_device *drm, struct dma_buf *dma_buf)
0317 {
0318     struct gud_device *gdrm = to_gud_device(drm);
0319
0320     if (!gdrm->dmadev)
0321         return ERR_PTR(-ENODEV);
0322
0323     return drm_gem_prime_import_dev(drm, dma_buf, gdrm->dmadev);
0324 }
0325
0326 static int gud_stats_debugfs(struct seq_file *m, void *data)
0327 {
0328     struct drm_info_node *node = m->private;
0329     struct gud_device *gdrm = to_gud_device(node->minor->dev);
0330     char buf[10];
0331
0332     string_get_size(gdrm->bulk_len, 1, STRING_UNITS_2, buf, sizeof(buf));
0333     seq_printf(m, "Max buffer size: %s\n", buf);
0334     seq_printf(m, "Number of errors:  %u\n", gdrm->stats_num_errors);
0335
0336     seq_puts(m, "Compression:      ");
0337     if (gdrm->compression & GUD_COMPRESSION_LZ4)
0338         seq_puts(m, " lz4");
0339     if (!gdrm->compression)
0340         seq_puts(m, " none");
0341     seq_puts(m, "\n");
0342
0343     if (gdrm->compression) {
0344         u64 remainder;
0345         u64 ratio = div64_u64_rem(gdrm->stats_length, gdrm->stats_actual_length,
0346                       &remainder);
0347         u64 ratio_frac = div64_u64(remainder * 10, gdrm->stats_actual_length);
0348
0349         seq_printf(m, "Compression ratio: %llu.%llu\n", ratio, ratio_frac);
0350     }
0351
0352     return 0;
0353 }
0354
0355 static const struct drm_info_list gud_debugfs_list[] = {
0356     { "stats", gud_stats_debugfs, 0, NULL },
0357 };
0358
0359 static void gud_debugfs_init(struct drm_minor *minor)
0360 {
0361     drm_debugfs_create_files(gud_debugfs_list, ARRAY_SIZE(gud_debugfs_list),
0362                  minor->debugfs_root, minor);
0363 }
0364
0365 static const struct drm_simple_display_pipe_funcs gud_pipe_funcs = {
0366     .check      = gud_pipe_check,
0367     .update     = gud_pipe_update,
0368 };
0369
0370 static const struct drm_mode_config_funcs gud_mode_config_funcs = {
0371     .fb_create = drm_gem_fb_create_with_dirty,
0372     .atomic_check = drm_atomic_helper_check,
0373     .atomic_commit = drm_atomic_helper_commit,
0374 };
0375
0376 static const u64 gud_pipe_modifiers[] = {
0377     DRM_FORMAT_MOD_LINEAR,
0378     DRM_FORMAT_MOD_INVALID
0379 };
0380
0381 DEFINE_DRM_GEM_FOPS(gud_fops);
0382
0383 static const struct drm_driver gud_drm_driver = {
0384     .driver_features    = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC,
0385     .fops           = &gud_fops,
0386     DRM_GEM_SHMEM_DRIVER_OPS,
0387     .gem_prime_import   = gud_gem_prime_import,
0388     .debugfs_init       = gud_debugfs_init,
0389
0390     .name           = "gud",
0391     .desc           = "Generic USB Display",
0392     .date           = "20200422",
0393     .major          = 1,
0394     .minor          = 0,
0395 };
0396
0397 static int gud_alloc_bulk_buffer(struct gud_device *gdrm)
0398 {
0399     unsigned int i, num_pages;
0400     struct page **pages;
0401     void *ptr;
0402     int ret;
0403
0404     gdrm->bulk_buf = vmalloc_32(gdrm->bulk_len);
0405     if (!gdrm->bulk_buf)
0406         return -ENOMEM;
0407
0408     num_pages = DIV_ROUND_UP(gdrm->bulk_len, PAGE_SIZE);
0409     pages = kmalloc_array(num_pages, sizeof(struct page *), GFP_KERNEL);
0410     if (!pages)
0411         return -ENOMEM;
0412
0413     for (i = 0, ptr = gdrm->bulk_buf; i < num_pages; i++, ptr += PAGE_SIZE)
0414         pages[i] = vmalloc_to_page(ptr);
0415
0416     ret = sg_alloc_table_from_pages(&gdrm->bulk_sgt, pages, num_pages,
0417                     0, gdrm->bulk_len, GFP_KERNEL);
0418     kfree(pages);
0419
0420     return ret;
0421 }
0422
0423 static void gud_free_buffers_and_mutex(void *data)
0424 {
0425     struct gud_device *gdrm = data;
0426
0427     vfree(gdrm->compress_buf);
0428     gdrm->compress_buf = NULL;
0429     sg_free_table(&gdrm->bulk_sgt);
0430     vfree(gdrm->bulk_buf);
0431     gdrm->bulk_buf = NULL;
0432     mutex_destroy(&gdrm->ctrl_lock);
0433 }
0434
0435 static int gud_probe(struct usb_interface *intf, const struct usb_device_id *id)
0436 {
0437     const struct drm_format_info *xrgb8888_emulation_format = NULL;
0438     bool rgb565_supported = false, xrgb8888_supported = false;
0439     unsigned int num_formats_dev, num_formats = 0;
0440     struct usb_endpoint_descriptor *bulk_out;
0441     struct gud_display_descriptor_req desc;
0442     struct device *dev = &intf->dev;
0443     size_t max_buffer_size = 0;
0444     struct gud_device *gdrm;
0445     struct drm_device *drm;
0446     u8 *formats_dev;
0447     u32 *formats;
0448     int ret, i;
0449
0450     ret = usb_find_bulk_out_endpoint(intf->cur_altsetting, &bulk_out);
0451     if (ret)
0452         return ret;
0453
0454     ret = gud_get_display_descriptor(intf, &desc);
0455     if (ret) {
0456         DRM_DEV_DEBUG_DRIVER(dev, "Not a display interface: ret=%d\n", ret);
0457         return -ENODEV;
0458     }
0459
0460     if (desc.version > 1) {
0461         dev_err(dev, "Protocol version %u is not supported\n", desc.version);
0462         return -ENODEV;
0463     }
0464
0465     gdrm = devm_drm_dev_alloc(dev, &gud_drm_driver, struct gud_device, drm);
0466     if (IS_ERR(gdrm))
0467         return PTR_ERR(gdrm);
0468
0469     drm = &gdrm->drm;
0470     drm->mode_config.funcs = &gud_mode_config_funcs;
0471     ret = drmm_mode_config_init(drm);
0472     if (ret)
0473         return ret;
0474
0475     gdrm->flags = le32_to_cpu(desc.flags);
0476     gdrm->compression = desc.compression & GUD_COMPRESSION_LZ4;
0477
0478     if (gdrm->flags & GUD_DISPLAY_FLAG_FULL_UPDATE && gdrm->compression)
0479         return -EINVAL;
0480
0481     mutex_init(&gdrm->ctrl_lock);
0482     mutex_init(&gdrm->damage_lock);
0483     INIT_WORK(&gdrm->work, gud_flush_work);
0484     gud_clear_damage(gdrm);
0485
0486     ret = devm_add_action(dev, gud_free_buffers_and_mutex, gdrm);
0487     if (ret)
0488         return ret;
0489
0490     drm->mode_config.min_width = le32_to_cpu(desc.min_width);
0491     drm->mode_config.max_width = le32_to_cpu(desc.max_width);
0492     drm->mode_config.min_height = le32_to_cpu(desc.min_height);
0493     drm->mode_config.max_height = le32_to_cpu(desc.max_height);
0494
0495     formats_dev = devm_kmalloc(dev, GUD_FORMATS_MAX_NUM, GFP_KERNEL);
0496     /* Add room for emulated XRGB8888 */
0497     formats = devm_kmalloc_array(dev, GUD_FORMATS_MAX_NUM + 1, sizeof(*formats), GFP_KERNEL);
0498     if (!formats_dev || !formats)
0499         return -ENOMEM;
0500
0501     ret = gud_usb_get(gdrm, GUD_REQ_GET_FORMATS, 0, formats_dev, GUD_FORMATS_MAX_NUM);
0502     if (ret < 0)
0503         return ret;
0504
0505     num_formats_dev = ret;
0506     for (i = 0; i < num_formats_dev; i++) {
0507         const struct drm_format_info *info;
0508         size_t fmt_buf_size;
0509         u32 format;
0510
0511         format = gud_to_fourcc(formats_dev[i]);
0512         if (!format) {
0513             drm_dbg(drm, "Unsupported format: 0x%02x\n", formats_dev[i]);
0514             continue;
0515         }
0516
0517         if (format == GUD_DRM_FORMAT_R1)
0518             info = &gud_drm_format_r1;
0519         else if (format == GUD_DRM_FORMAT_XRGB1111)
0520             info = &gud_drm_format_xrgb1111;
0521         else
0522             info = drm_format_info(format);
0523
0524         switch (format) {
0525         case GUD_DRM_FORMAT_R1:
0526             fallthrough;
0527         case DRM_FORMAT_R8:
0528             fallthrough;
0529         case GUD_DRM_FORMAT_XRGB1111:
0530             fallthrough;
0531         case DRM_FORMAT_RGB332:
0532             fallthrough;
0533         case DRM_FORMAT_RGB888:
0534             if (!xrgb8888_emulation_format)
0535                 xrgb8888_emulation_format = info;
0536             break;
0537         case DRM_FORMAT_RGB565:
0538             rgb565_supported = true;
0539             if (!xrgb8888_emulation_format)
0540                 xrgb8888_emulation_format = info;
0541             break;
0542         case DRM_FORMAT_XRGB8888:
0543             xrgb8888_supported = true;
0544             break;
0545         }
0546
0547         fmt_buf_size = drm_format_info_min_pitch(info, 0, drm->mode_config.max_width) *
0548                    drm->mode_config.max_height;
0549         max_buffer_size = max(max_buffer_size, fmt_buf_size);
0550
0551         if (format == GUD_DRM_FORMAT_R1 || format == GUD_DRM_FORMAT_XRGB1111)
0552             continue; /* Internal not for userspace */
0553
0554         formats[num_formats++] = format;
0555     }
0556
0557     if (!num_formats && !xrgb8888_emulation_format) {
0558         dev_err(dev, "No supported pixel formats found\n");
0559         return -EINVAL;
0560     }
0561
0562     /* Prefer speed over color depth */
0563     if (rgb565_supported)
0564         drm->mode_config.preferred_depth = 16;
0565
0566     if (!xrgb8888_supported && xrgb8888_emulation_format) {
0567         gdrm->xrgb8888_emulation_format = xrgb8888_emulation_format;
0568         formats[num_formats++] = DRM_FORMAT_XRGB8888;
0569     }
0570
0571     if (desc.max_buffer_size)
0572         max_buffer_size = le32_to_cpu(desc.max_buffer_size);
0573     /* Prevent a misbehaving device from allocating loads of RAM. 4096x4096@XRGB8888 = 64 MB */
0574     if (max_buffer_size > SZ_64M)
0575         max_buffer_size = SZ_64M;
0576
0577     gdrm->bulk_pipe = usb_sndbulkpipe(interface_to_usbdev(intf), usb_endpoint_num(bulk_out));
0578     gdrm->bulk_len = max_buffer_size;
0579
0580     ret = gud_alloc_bulk_buffer(gdrm);
0581     if (ret)
0582         return ret;
0583
0584     if (gdrm->compression & GUD_COMPRESSION_LZ4) {
0585         gdrm->lz4_comp_mem = devm_kmalloc(dev, LZ4_MEM_COMPRESS, GFP_KERNEL);
0586         if (!gdrm->lz4_comp_mem)
0587             return -ENOMEM;
0588
0589         gdrm->compress_buf = vmalloc(gdrm->bulk_len);
0590         if (!gdrm->compress_buf)
0591             return -ENOMEM;
0592     }
0593
0594     ret = drm_simple_display_pipe_init(drm, &gdrm->pipe, &gud_pipe_funcs,
0595                        formats, num_formats,
0596                        gud_pipe_modifiers, NULL);
0597     if (ret)
0598         return ret;
0599
0600     devm_kfree(dev, formats);
0601     devm_kfree(dev, formats_dev);
0602
0603     ret = gud_get_properties(gdrm);
0604     if (ret) {
0605         dev_err(dev, "Failed to get properties (error=%d)\n", ret);
0606         return ret;
0607     }
0608
0609     drm_plane_enable_fb_damage_clips(&gdrm->pipe.plane);
0610
0611     ret = gud_get_connectors(gdrm);
0612     if (ret) {
0613         dev_err(dev, "Failed to get connectors (error=%d)\n", ret);
0614         return ret;
0615     }
0616
0617     drm_mode_config_reset(drm);
0618
0619     usb_set_intfdata(intf, gdrm);
0620
0621     gdrm->dmadev = usb_intf_get_dma_device(intf);
0622     if (!gdrm->dmadev)
0623         dev_warn(dev, "buffer sharing not supported");
0624
0625     ret = drm_dev_register(drm, 0);
0626     if (ret) {
0627         put_device(gdrm->dmadev);
0628         return ret;
0629     }
0630
0631     drm_kms_helper_poll_init(drm);
0632
0633     drm_fbdev_generic_setup(drm, 0);
0634
0635     return 0;
0636 }
0637
0638 static void gud_disconnect(struct usb_interface *interface)
0639 {
0640     struct gud_device *gdrm = usb_get_intfdata(interface);
0641     struct drm_device *drm = &gdrm->drm;
0642
0643     drm_dbg(drm, "%s:\n", __func__);
0644
0645     drm_kms_helper_poll_fini(drm);
0646     drm_dev_unplug(drm);
0647     drm_atomic_helper_shutdown(drm);
0648     put_device(gdrm->dmadev);
0649     gdrm->dmadev = NULL;
0650 }
0651
0652 static int gud_suspend(struct usb_interface *intf, pm_message_t message)
0653 {
0654     struct gud_device *gdrm = usb_get_intfdata(intf);
0655
0656     return drm_mode_config_helper_suspend(&gdrm->drm);
0657 }
0658
0659 static int gud_resume(struct usb_interface *intf)
0660 {
0661     struct gud_device *gdrm = usb_get_intfdata(intf);
0662
0663     drm_mode_config_helper_resume(&gdrm->drm);
0664
0665     return 0;
0666 }
0667
0668 static const struct usb_device_id gud_id_table[] = {
0669     { USB_DEVICE_INTERFACE_CLASS(0x1d50, 0x614d, USB_CLASS_VENDOR_SPEC) },
0670     { USB_DEVICE_INTERFACE_CLASS(0x16d0, 0x10a9, USB_CLASS_VENDOR_SPEC) },
0671     { }
0672 };
0673
0674 MODULE_DEVICE_TABLE(usb, gud_id_table);
0675
0676 static struct usb_driver gud_usb_driver = {
0677     .name       = "gud",
0678     .probe      = gud_probe,
0679     .disconnect = gud_disconnect,
0680     .id_table   = gud_id_table,
0681     .suspend    = gud_suspend,
0682     .resume     = gud_resume,
0683     .reset_resume   = gud_resume,
0684 };
0685
0686 module_usb_driver(gud_usb_driver);
0687
0688 MODULE_AUTHOR("Noralf Trønnes");
0689 MODULE_LICENSE("Dual MIT/GPL");