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