1 // SPDX-License-Identifier: GPL-2.0-only 2 3 #include <linux/aperture.h> 4 #include <linux/ioport.h> 5 #include <linux/limits.h> 6 #include <linux/platform_device.h> 7 #include <linux/sysfb.h> 8 #include <linux/pm.h> 9 10 #include <drm/clients/drm_client_setup.h> 11 #include <drm/drm_atomic.h> 12 #include <drm/drm_atomic_state_helper.h> 13 #include <drm/drm_color_mgmt.h> 14 #include <drm/drm_connector.h> 15 #include <drm/drm_damage_helper.h> 16 #include <drm/drm_device.h> 17 #include <drm/drm_drv.h> 18 #include <drm/drm_edid.h> 19 #include <drm/drm_fbdev_shmem.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_managed.h> 25 #include <drm/drm_modeset_helper.h> 26 #include <drm/drm_modeset_helper_vtables.h> 27 #include <drm/drm_panic_helper.h> 28 #include <drm/drm_print.h> 29 #include <drm/drm_probe_helper.h> 30 31 #include <video/pixel_format.h> 32 #include <video/vga.h> 33 34 #include "drm_sysfb_helper.h" 35 36 #define DRIVER_NAME "vesadrm" 37 #define DRIVER_DESC "DRM driver for VESA platform devices" 38 #define DRIVER_MAJOR 1 39 #define DRIVER_MINOR 0 40 41 #define VESADRM_GAMMA_LUT_SIZE 256 42 43 static const struct drm_format_info *vesadrm_get_format_si(struct drm_device *dev, 44 const struct screen_info *si) 45 { 46 static const struct drm_sysfb_format formats[] = { 47 { PIXEL_FORMAT_XRGB1555, DRM_FORMAT_XRGB1555, }, 48 { PIXEL_FORMAT_RGB565, DRM_FORMAT_RGB565, }, 49 { PIXEL_FORMAT_RGB888, DRM_FORMAT_RGB888, }, 50 { PIXEL_FORMAT_XRGB8888, DRM_FORMAT_XRGB8888, }, 51 { PIXEL_FORMAT_XBGR8888, DRM_FORMAT_XBGR8888, }, 52 { PIXEL_FORMAT_C8, DRM_FORMAT_C8, }, 53 }; 54 struct pixel_format pixel; 55 int ret; 56 57 ret = screen_info_pixel_format(si, &pixel); 58 if (ret) 59 return NULL; 60 61 return drm_sysfb_get_format(dev, formats, ARRAY_SIZE(formats), &pixel); 62 } 63 64 /* 65 * VESA device 66 */ 67 68 struct vesadrm_device { 69 struct drm_sysfb_device sysfb; 70 71 #if defined(CONFIG_X86_32) 72 /* VESA Protected Mode interface */ 73 struct { 74 const u8 *PrimaryPalette; 75 } pmi; 76 #endif 77 78 void (*cmap_write)(struct vesadrm_device *vesa, unsigned int index, 79 u16 red, u16 green, u16 blue); 80 81 /* modesetting */ 82 u32 formats[DRM_SYSFB_PLANE_NFORMATS(1)]; 83 struct drm_plane primary_plane; 84 struct drm_crtc crtc; 85 struct drm_encoder encoder; 86 struct drm_connector connector; 87 }; 88 89 static struct vesadrm_device *to_vesadrm_device(struct drm_device *dev) 90 { 91 return container_of(to_drm_sysfb_device(dev), struct vesadrm_device, sysfb); 92 } 93 94 /* 95 * Color LUT 96 */ 97 98 static void vesadrm_vga_cmap_write(struct vesadrm_device *vesa, unsigned int index, 99 u16 red, u16 green, u16 blue) 100 { 101 u8 i8 = index; 102 u8 r8 = red >> 8; 103 u8 g8 = green >> 8; 104 u8 b8 = blue >> 8; 105 106 outb_p(i8, VGA_PEL_IW); 107 outb_p(r8, VGA_PEL_D); 108 outb_p(g8, VGA_PEL_D); 109 outb_p(b8, VGA_PEL_D); 110 } 111 112 #if defined(CONFIG_X86_32) 113 static void vesadrm_pmi_cmap_write(struct vesadrm_device *vesa, unsigned int index, 114 u16 red, u16 green, u16 blue) 115 { 116 u32 i32 = index; 117 struct { 118 u8 b8; 119 u8 g8; 120 u8 r8; 121 u8 x8; 122 } PaletteEntry = { 123 blue >> 8, 124 green >> 8, 125 red >> 8, 126 0x00, 127 }; 128 129 __asm__ __volatile__ ( 130 "call *(%%esi)" 131 : /* no return value */ 132 : "a" (0x4f09), 133 "b" (0), 134 "c" (1), 135 "d" (i32), 136 "D" (&PaletteEntry), 137 "S" (&vesa->pmi.PrimaryPalette)); 138 } 139 #endif 140 141 static void vesadrm_set_color_lut(struct drm_crtc *crtc, unsigned int index, 142 u16 red, u16 green, u16 blue) 143 { 144 struct drm_device *dev = crtc->dev; 145 struct vesadrm_device *vesa = to_vesadrm_device(dev); 146 u8 i8 = index & 0xff; 147 148 if (drm_WARN_ON_ONCE(dev, index != i8)) 149 return; /* driver bug */ 150 151 vesa->cmap_write(vesa, i8, red, green, blue); 152 } 153 154 static void vesadrm_fill_gamma_lut(struct vesadrm_device *vesa, 155 const struct drm_format_info *format) 156 { 157 struct drm_device *dev = &vesa->sysfb.dev; 158 struct drm_crtc *crtc = &vesa->crtc; 159 160 switch (format->format) { 161 case DRM_FORMAT_XRGB1555: 162 drm_crtc_fill_gamma_555(crtc, vesadrm_set_color_lut); 163 break; 164 case DRM_FORMAT_RGB565: 165 drm_crtc_fill_gamma_565(crtc, vesadrm_set_color_lut); 166 break; 167 case DRM_FORMAT_RGB888: 168 case DRM_FORMAT_XRGB8888: 169 case DRM_FORMAT_BGRX8888: 170 drm_crtc_fill_gamma_888(crtc, vesadrm_set_color_lut); 171 break; 172 default: 173 drm_warn_once(dev, "Unsupported format %p4cc for gamma correction\n", 174 &format->format); 175 break; 176 } 177 } 178 179 static void vesadrm_load_gamma_lut(struct vesadrm_device *vesa, 180 const struct drm_format_info *format, 181 struct drm_color_lut *lut) 182 { 183 struct drm_device *dev = &vesa->sysfb.dev; 184 struct drm_crtc *crtc = &vesa->crtc; 185 186 switch (format->format) { 187 case DRM_FORMAT_XRGB1555: 188 drm_crtc_load_gamma_555_from_888(crtc, lut, vesadrm_set_color_lut); 189 break; 190 case DRM_FORMAT_RGB565: 191 drm_crtc_load_gamma_565_from_888(crtc, lut, vesadrm_set_color_lut); 192 break; 193 case DRM_FORMAT_RGB888: 194 case DRM_FORMAT_XRGB8888: 195 case DRM_FORMAT_BGRX8888: 196 drm_crtc_load_gamma_888(crtc, lut, vesadrm_set_color_lut); 197 break; 198 default: 199 drm_warn_once(dev, "Unsupported format %p4cc for gamma correction\n", 200 &format->format); 201 break; 202 } 203 } 204 205 static void vesadrm_fill_palette_lut(struct vesadrm_device *vesa, 206 const struct drm_format_info *format) 207 { 208 struct drm_device *dev = &vesa->sysfb.dev; 209 struct drm_crtc *crtc = &vesa->crtc; 210 211 switch (format->format) { 212 case DRM_FORMAT_C8: 213 drm_crtc_fill_palette_8(crtc, vesadrm_set_color_lut); 214 break; 215 case DRM_FORMAT_RGB332: 216 drm_crtc_fill_palette_332(crtc, vesadrm_set_color_lut); 217 break; 218 default: 219 drm_warn_once(dev, "Unsupported format %p4cc for palette\n", 220 &format->format); 221 break; 222 } 223 } 224 225 static void vesadrm_load_palette_lut(struct vesadrm_device *vesa, 226 const struct drm_format_info *format, 227 struct drm_color_lut *lut) 228 { 229 struct drm_device *dev = &vesa->sysfb.dev; 230 struct drm_crtc *crtc = &vesa->crtc; 231 232 switch (format->format) { 233 case DRM_FORMAT_C8: 234 drm_crtc_load_palette_8(crtc, lut, vesadrm_set_color_lut); 235 break; 236 default: 237 drm_warn_once(dev, "Unsupported format %p4cc for gamma correction\n", 238 &format->format); 239 break; 240 } 241 } 242 243 /* 244 * Modesetting 245 */ 246 247 static const u64 vesadrm_primary_plane_format_modifiers[] = { 248 DRM_SYSFB_PLANE_FORMAT_MODIFIERS, 249 }; 250 251 static int vesadrm_primary_plane_helper_atomic_check(struct drm_plane *plane, 252 struct drm_atomic_commit *new_state) 253 { 254 struct drm_sysfb_device *sysfb = to_drm_sysfb_device(plane->dev); 255 struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(new_state, plane); 256 struct drm_framebuffer *new_fb = new_plane_state->fb; 257 struct drm_crtc_state *new_crtc_state; 258 struct drm_sysfb_crtc_state *new_sysfb_crtc_state; 259 int ret; 260 261 ret = drm_sysfb_plane_helper_atomic_check(plane, new_state); 262 if (ret) 263 return ret; 264 else if (!new_plane_state->visible) 265 return 0; 266 267 /* 268 * Fix up format conversion for specific cases 269 */ 270 271 switch (sysfb->fb_format->format) { 272 case DRM_FORMAT_C8: 273 new_crtc_state = drm_atomic_get_new_crtc_state(new_state, new_plane_state->crtc); 274 new_sysfb_crtc_state = to_drm_sysfb_crtc_state(new_crtc_state); 275 276 switch (new_fb->format->format) { 277 case DRM_FORMAT_XRGB8888: 278 /* 279 * Reduce XRGB8888 to RGB332. Each resulting pixel is an index 280 * into the C8 hardware palette, which stores RGB332 colors. 281 */ 282 if (new_sysfb_crtc_state->format->format != DRM_FORMAT_RGB332) { 283 new_sysfb_crtc_state->format = 284 drm_format_info(DRM_FORMAT_RGB332); 285 new_crtc_state->color_mgmt_changed = true; 286 } 287 break; 288 case DRM_FORMAT_C8: 289 /* 290 * Restore original output. Emulation of XRGB8888 set RBG332 291 * output format and hardware palette. This needs to be undone 292 * when we switch back to DRM_FORMAT_C8. 293 */ 294 if (new_sysfb_crtc_state->format->format == DRM_FORMAT_RGB332) { 295 new_sysfb_crtc_state->format = sysfb->fb_format; 296 new_crtc_state->color_mgmt_changed = true; 297 } 298 break; 299 } 300 break; 301 } 302 303 return 0; 304 } 305 306 static const struct drm_plane_helper_funcs vesadrm_primary_plane_helper_funcs = { 307 .begin_fb_access = drm_sysfb_plane_helper_begin_fb_access, 308 .end_fb_access = drm_gem_end_shadow_fb_access, 309 .atomic_check = vesadrm_primary_plane_helper_atomic_check, 310 .atomic_update = drm_sysfb_plane_helper_atomic_update, 311 .atomic_disable = drm_sysfb_plane_helper_atomic_disable, 312 .get_scanout_buffer = drm_sysfb_plane_helper_get_scanout_buffer, 313 }; 314 315 static const struct drm_plane_funcs vesadrm_primary_plane_funcs = { 316 DRM_SYSFB_PLANE_FUNCS, 317 .destroy = drm_plane_cleanup, 318 }; 319 320 static void vesadrm_crtc_helper_atomic_flush(struct drm_crtc *crtc, 321 struct drm_atomic_commit *state) 322 { 323 struct drm_device *dev = crtc->dev; 324 struct drm_sysfb_device *sysfb = to_drm_sysfb_device(dev); 325 struct vesadrm_device *vesa = to_vesadrm_device(dev); 326 struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc); 327 struct drm_sysfb_crtc_state *sysfb_crtc_state = to_drm_sysfb_crtc_state(crtc_state); 328 329 /* 330 * The gamma LUT has to be reloaded after changing the primary 331 * plane's color format. 332 */ 333 if (crtc_state->enable && crtc_state->color_mgmt_changed) { 334 switch (sysfb->fb_format->format) { 335 /* 336 * Index formats 337 */ 338 case DRM_FORMAT_C8: 339 if (sysfb_crtc_state->format->format == DRM_FORMAT_RGB332) { 340 vesadrm_fill_palette_lut(vesa, sysfb_crtc_state->format); 341 } else if (crtc->state->gamma_lut) { 342 vesadrm_load_palette_lut(vesa, 343 sysfb_crtc_state->format, 344 crtc_state->gamma_lut->data); 345 } else { 346 vesadrm_fill_palette_lut(vesa, sysfb_crtc_state->format); 347 } 348 break; 349 /* 350 * Component formats 351 */ 352 default: 353 if (sysfb_crtc_state->format == sysfb->fb_format) { 354 if (crtc_state->gamma_lut) 355 vesadrm_load_gamma_lut(vesa, 356 sysfb_crtc_state->format, 357 crtc_state->gamma_lut->data); 358 else 359 vesadrm_fill_gamma_lut(vesa, sysfb_crtc_state->format); 360 } else { 361 vesadrm_fill_gamma_lut(vesa, sysfb_crtc_state->format); 362 } 363 break; 364 } 365 } 366 } 367 368 static const struct drm_crtc_helper_funcs vesadrm_crtc_helper_funcs = { 369 DRM_SYSFB_CRTC_HELPER_FUNCS, 370 .atomic_flush = vesadrm_crtc_helper_atomic_flush, 371 }; 372 373 static const struct drm_crtc_funcs vesadrm_crtc_funcs = { 374 DRM_SYSFB_CRTC_FUNCS, 375 .destroy = drm_crtc_cleanup, 376 }; 377 378 static const struct drm_encoder_funcs vesadrm_encoder_funcs = { 379 .destroy = drm_encoder_cleanup, 380 }; 381 382 static const struct drm_connector_helper_funcs vesadrm_connector_helper_funcs = { 383 DRM_SYSFB_CONNECTOR_HELPER_FUNCS, 384 }; 385 386 static const struct drm_connector_funcs vesadrm_connector_funcs = { 387 DRM_SYSFB_CONNECTOR_FUNCS, 388 .destroy = drm_connector_cleanup, 389 }; 390 391 static const struct drm_mode_config_funcs vesadrm_mode_config_funcs = { 392 DRM_SYSFB_MODE_CONFIG_FUNCS, 393 }; 394 395 /* 396 * Init / Cleanup 397 */ 398 399 static struct vesadrm_device *vesadrm_device_create(struct drm_driver *drv, 400 struct platform_device *pdev) 401 { 402 const struct sysfb_display_info *dpy; 403 const struct screen_info *si; 404 const struct drm_format_info *format; 405 int width, height, stride; 406 unsigned int panel_width, panel_height; 407 s64 vsize; 408 struct resource resbuf; 409 struct resource *res; 410 struct vesadrm_device *vesa; 411 struct drm_sysfb_device *sysfb; 412 struct drm_device *dev; 413 struct resource *mem = NULL; 414 void __iomem *screen_base; 415 struct drm_plane *primary_plane; 416 struct drm_crtc *crtc; 417 struct drm_encoder *encoder; 418 struct drm_connector *connector; 419 unsigned long max_width, max_height; 420 size_t nformats; 421 int ret; 422 423 dpy = dev_get_platdata(&pdev->dev); 424 if (!dpy) 425 return ERR_PTR(-ENODEV); 426 si = &dpy->screen; 427 428 if (screen_info_video_type(si) != VIDEO_TYPE_VLFB) 429 return ERR_PTR(-ENODEV); 430 431 /* 432 * VESA DRM driver 433 */ 434 435 vesa = devm_drm_dev_alloc(&pdev->dev, drv, struct vesadrm_device, sysfb.dev); 436 if (IS_ERR(vesa)) 437 return ERR_CAST(vesa); 438 sysfb = &vesa->sysfb; 439 dev = &sysfb->dev; 440 platform_set_drvdata(pdev, dev); 441 442 /* 443 * Hardware settings 444 */ 445 446 format = vesadrm_get_format_si(dev, si); 447 if (!format) 448 return ERR_PTR(-EINVAL); 449 width = drm_sysfb_get_width_si(dev, si); 450 if (width < 0) 451 return ERR_PTR(width); 452 height = drm_sysfb_get_height_si(dev, si); 453 if (height < 0) 454 return ERR_PTR(height); 455 res = drm_sysfb_get_memory_si(dev, si, &resbuf); 456 if (!res) 457 return ERR_PTR(-EINVAL); 458 stride = drm_sysfb_get_stride_si(dev, si, format, width, height, resource_size(res)); 459 if (stride < 0) 460 return ERR_PTR(stride); 461 vsize = drm_sysfb_get_visible_size_si(dev, si, height, stride, resource_size(res)); 462 if (vsize < 0) 463 return ERR_PTR(vsize); 464 465 drm_dbg(dev, "framebuffer format=%p4cc, size=%dx%d, stride=%d bytes\n", 466 &format->format, width, height, stride); 467 468 if (!__screen_info_vbe_mode_nonvga(si)) { 469 vesa->cmap_write = vesadrm_vga_cmap_write; 470 } else { 471 #if defined(CONFIG_X86_32) 472 phys_addr_t pmi_base = __screen_info_vesapm_info_base(si); 473 474 if (pmi_base) { 475 const u16 *pmi_addr = phys_to_virt(pmi_base); 476 477 vesa->pmi.PrimaryPalette = (u8 *)pmi_addr + pmi_addr[2]; 478 vesa->cmap_write = vesadrm_pmi_cmap_write; 479 } else 480 #endif 481 if (format->is_color_indexed) 482 drm_warn(dev, "hardware palette is unchangeable, colors may be incorrect\n"); 483 } 484 485 #if defined(CONFIG_FIRMWARE_EDID) 486 if (drm_edid_header_is_valid(dpy->edid.dummy) == 8) 487 sysfb->edid = dpy->edid.dummy; 488 #endif 489 490 panel_width = width; 491 panel_height = height; 492 493 if (sysfb->edid) { 494 const struct drm_edid *drm_edid; 495 496 drm_edid = drm_edid_alloc(sysfb->edid, EDID_LENGTH); 497 if (drm_edid) { 498 drm_edid_detect_panel_size(drm_edid, &panel_width, &panel_height); 499 drm_edid_free(drm_edid); 500 } 501 } 502 503 sysfb->fb_mode = drm_sysfb_mode(width, height, 0, 0); 504 sysfb->fb_format = format; 505 sysfb->fb_pitch = stride; 506 if (vesa->cmap_write) 507 sysfb->fb_gamma_lut_size = VESADRM_GAMMA_LUT_SIZE; 508 509 /* 510 * Memory management 511 */ 512 513 ret = devm_aperture_acquire_for_platform_device(pdev, res->start, vsize); 514 if (ret) { 515 drm_err(dev, "could not acquire memory range %pr: %d\n", res, ret); 516 return ERR_PTR(ret); 517 } 518 519 drm_dbg(dev, "using I/O memory framebuffer at %pr\n", res); 520 521 mem = devm_request_mem_region(&pdev->dev, res->start, vsize, drv->name); 522 if (!mem) { 523 /* 524 * We cannot make this fatal. Sometimes this comes from magic 525 * spaces our resource handlers simply don't know about. Use 526 * the I/O-memory resource as-is and try to map that instead. 527 */ 528 drm_warn(dev, "could not acquire memory region %pr\n", res); 529 mem = res; 530 } 531 532 screen_base = devm_ioremap_wc(&pdev->dev, mem->start, resource_size(mem)); 533 if (!screen_base) 534 return ERR_PTR(-ENOMEM); 535 iosys_map_set_vaddr_iomem(&sysfb->fb_addr, screen_base); 536 537 /* 538 * Modesetting 539 */ 540 541 ret = drmm_mode_config_init(dev); 542 if (ret) 543 return ERR_PTR(ret); 544 545 max_width = max_t(unsigned long, width, DRM_SHADOW_PLANE_MAX_WIDTH); 546 max_height = max_t(unsigned long, height, DRM_SHADOW_PLANE_MAX_HEIGHT); 547 548 dev->mode_config.min_width = width; 549 dev->mode_config.max_width = max_width; 550 dev->mode_config.min_height = height; 551 dev->mode_config.max_height = max_height; 552 dev->mode_config.preferred_depth = format->depth; 553 dev->mode_config.funcs = &vesadrm_mode_config_funcs; 554 555 /* Primary plane */ 556 557 nformats = drm_sysfb_build_fourcc_list(dev, &format->format, 1, 558 vesa->formats, ARRAY_SIZE(vesa->formats)); 559 560 primary_plane = &vesa->primary_plane; 561 ret = drm_universal_plane_init(dev, primary_plane, 0, &vesadrm_primary_plane_funcs, 562 vesa->formats, nformats, 563 vesadrm_primary_plane_format_modifiers, 564 DRM_PLANE_TYPE_PRIMARY, NULL); 565 if (ret) 566 return ERR_PTR(ret); 567 drm_plane_helper_add(primary_plane, &vesadrm_primary_plane_helper_funcs); 568 drm_plane_enable_fb_damage_clips(primary_plane); 569 570 /* CRTC */ 571 572 crtc = &vesa->crtc; 573 ret = drm_crtc_init_with_planes(dev, crtc, primary_plane, NULL, 574 &vesadrm_crtc_funcs, NULL); 575 if (ret) 576 return ERR_PTR(ret); 577 drm_crtc_helper_add(crtc, &vesadrm_crtc_helper_funcs); 578 579 if (sysfb->fb_gamma_lut_size) { 580 ret = drm_mode_crtc_set_gamma_size(crtc, sysfb->fb_gamma_lut_size); 581 if (!ret) 582 drm_crtc_enable_color_mgmt(crtc, 0, false, sysfb->fb_gamma_lut_size); 583 } 584 585 /* Encoder */ 586 587 encoder = &vesa->encoder; 588 ret = drm_encoder_init(dev, encoder, &vesadrm_encoder_funcs, 589 DRM_MODE_ENCODER_NONE, NULL); 590 if (ret) 591 return ERR_PTR(ret); 592 encoder->possible_crtcs = drm_crtc_mask(crtc); 593 594 /* Connector */ 595 596 connector = &vesa->connector; 597 ret = drm_connector_init(dev, connector, &vesadrm_connector_funcs, 598 DRM_MODE_CONNECTOR_Unknown); 599 if (ret) 600 return ERR_PTR(ret); 601 drm_connector_helper_add(connector, &vesadrm_connector_helper_funcs); 602 drm_connector_set_panel_orientation_with_quirk(connector, 603 DRM_MODE_PANEL_ORIENTATION_UNKNOWN, 604 panel_width, panel_height); 605 if (sysfb->edid) 606 drm_connector_attach_edid_property(connector); 607 608 ret = drm_connector_attach_encoder(connector, encoder); 609 if (ret) 610 return ERR_PTR(ret); 611 612 drm_mode_config_reset(dev); 613 614 return vesa; 615 } 616 617 /* 618 * DRM driver 619 */ 620 621 DEFINE_DRM_GEM_FOPS(vesadrm_fops); 622 623 static struct drm_driver vesadrm_driver = { 624 DRM_GEM_SHMEM_DRIVER_OPS, 625 DRM_FBDEV_SHMEM_DRIVER_OPS, 626 .name = DRIVER_NAME, 627 .desc = DRIVER_DESC, 628 .major = DRIVER_MAJOR, 629 .minor = DRIVER_MINOR, 630 .driver_features = DRIVER_ATOMIC | DRIVER_GEM | DRIVER_MODESET, 631 .fops = &vesadrm_fops, 632 }; 633 634 /* 635 * Platform driver 636 */ 637 638 static int vesadrm_pm_suspend(struct device *dev) 639 { 640 struct drm_device *drm = dev_get_drvdata(dev); 641 642 return drm_mode_config_helper_suspend(drm); 643 } 644 645 static int vesadrm_pm_resume(struct device *dev) 646 { 647 struct drm_device *drm = dev_get_drvdata(dev); 648 649 return drm_mode_config_helper_resume(drm); 650 } 651 652 static DEFINE_SIMPLE_DEV_PM_OPS(vesadrm_pm_ops, vesadrm_pm_suspend, vesadrm_pm_resume); 653 654 static int vesadrm_probe(struct platform_device *pdev) 655 { 656 struct vesadrm_device *vesa; 657 struct drm_sysfb_device *sysfb; 658 struct drm_device *dev; 659 int ret; 660 661 vesa = vesadrm_device_create(&vesadrm_driver, pdev); 662 if (IS_ERR(vesa)) 663 return PTR_ERR(vesa); 664 sysfb = &vesa->sysfb; 665 dev = &sysfb->dev; 666 667 ret = drm_dev_register(dev, 0); 668 if (ret) 669 return ret; 670 671 drm_client_setup(dev, sysfb->fb_format); 672 673 return 0; 674 } 675 676 static void vesadrm_remove(struct platform_device *pdev) 677 { 678 struct drm_device *dev = platform_get_drvdata(pdev); 679 680 drm_dev_unplug(dev); 681 } 682 683 static struct platform_driver vesadrm_platform_driver = { 684 .driver = { 685 .name = "vesa-framebuffer", 686 .pm = pm_sleep_ptr(&vesadrm_pm_ops), 687 }, 688 .probe = vesadrm_probe, 689 .remove = vesadrm_remove, 690 }; 691 692 module_platform_driver(vesadrm_platform_driver); 693 694 MODULE_DESCRIPTION(DRIVER_DESC); 695 MODULE_LICENSE("GPL"); 696