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