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