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