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