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