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_connector.h> 13 #include <drm/drm_damage_helper.h> 14 #include <drm/drm_device.h> 15 #include <drm/drm_drv.h> 16 #include <drm/drm_edid.h> 17 #include <drm/drm_fbdev_shmem.h> 18 #include <drm/drm_framebuffer.h> 19 #include <drm/drm_gem_atomic_helper.h> 20 #include <drm/drm_gem_framebuffer_helper.h> 21 #include <drm/drm_gem_shmem_helper.h> 22 #include <drm/drm_managed.h> 23 #include <drm/drm_modeset_helper_vtables.h> 24 #include <drm/drm_probe_helper.h> 25 26 #include <video/edid.h> 27 #include <video/pixel_format.h> 28 #include <video/vga.h> 29 30 #include "drm_sysfb_helper.h" 31 32 #define DRIVER_NAME "vesadrm" 33 #define DRIVER_DESC "DRM driver for VESA platform devices" 34 #define DRIVER_MAJOR 1 35 #define DRIVER_MINOR 0 36 37 #define VESADRM_GAMMA_LUT_SIZE 256 38 39 static const struct drm_format_info *vesadrm_get_format_si(struct drm_device *dev, 40 const struct screen_info *si) 41 { 42 static const struct drm_sysfb_format formats[] = { 43 { PIXEL_FORMAT_XRGB1555, DRM_FORMAT_XRGB1555, }, 44 { PIXEL_FORMAT_RGB565, DRM_FORMAT_RGB565, }, 45 { PIXEL_FORMAT_RGB888, DRM_FORMAT_RGB888, }, 46 { PIXEL_FORMAT_XRGB8888, DRM_FORMAT_XRGB8888, }, 47 { PIXEL_FORMAT_XBGR8888, DRM_FORMAT_XBGR8888, }, 48 }; 49 50 return drm_sysfb_get_format_si(dev, formats, ARRAY_SIZE(formats), si); 51 } 52 53 /* 54 * VESA device 55 */ 56 57 struct vesadrm_device { 58 struct drm_sysfb_device sysfb; 59 60 #if defined(CONFIG_X86_32) 61 /* VESA Protected Mode interface */ 62 struct { 63 const u8 *PrimaryPalette; 64 } pmi; 65 #endif 66 67 void (*cmap_write)(struct vesadrm_device *vesa, unsigned int index, 68 u16 red, u16 green, u16 blue); 69 70 /* modesetting */ 71 u32 formats[DRM_SYSFB_PLANE_NFORMATS(1)]; 72 struct drm_plane primary_plane; 73 struct drm_crtc crtc; 74 struct drm_encoder encoder; 75 struct drm_connector connector; 76 }; 77 78 static struct vesadrm_device *to_vesadrm_device(struct drm_device *dev) 79 { 80 return container_of(to_drm_sysfb_device(dev), struct vesadrm_device, sysfb); 81 } 82 83 /* 84 * Palette 85 */ 86 87 static void vesadrm_vga_cmap_write(struct vesadrm_device *vesa, unsigned int index, 88 u16 red, u16 green, u16 blue) 89 { 90 u8 i8, r8, g8, b8; 91 92 if (index > 255) 93 return; 94 95 i8 = index; 96 r8 = red >> 8; 97 g8 = green >> 8; 98 b8 = blue >> 8; 99 100 outb_p(i8, VGA_PEL_IW); 101 outb_p(r8, VGA_PEL_D); 102 outb_p(g8, VGA_PEL_D); 103 outb_p(b8, VGA_PEL_D); 104 } 105 106 #if defined(CONFIG_X86_32) 107 static void vesadrm_pmi_cmap_write(struct vesadrm_device *vesa, unsigned int index, 108 u16 red, u16 green, u16 blue) 109 { 110 u32 i32 = index; 111 struct { 112 u8 b8; 113 u8 g8; 114 u8 r8; 115 u8 x8; 116 } PaletteEntry = { 117 blue >> 8, 118 green >> 8, 119 red >> 8, 120 0x00, 121 }; 122 123 if (index > 255) 124 return; 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_gamma_linear(struct vesadrm_device *vesa, 139 const struct drm_format_info *format) 140 { 141 struct drm_device *dev = &vesa->sysfb.dev; 142 size_t i; 143 u16 r16, g16, b16; 144 145 switch (format->format) { 146 case DRM_FORMAT_XRGB1555: 147 for (i = 0; i < 32; ++i) { 148 r16 = i * 8 + i / 4; 149 r16 |= (r16 << 8) | r16; 150 vesa->cmap_write(vesa, i, r16, r16, r16); 151 } 152 break; 153 case DRM_FORMAT_RGB565: 154 for (i = 0; i < 32; ++i) { 155 r16 = i * 8 + i / 4; 156 r16 |= (r16 << 8) | r16; 157 g16 = i * 4 + i / 16; 158 g16 |= (g16 << 8) | g16; 159 b16 = r16; 160 vesa->cmap_write(vesa, i, r16, g16, b16); 161 } 162 for (i = 32; i < 64; ++i) { 163 g16 = i * 4 + i / 16; 164 g16 |= (g16 << 8) | g16; 165 vesa->cmap_write(vesa, i, 0, g16, 0); 166 } 167 break; 168 case DRM_FORMAT_RGB888: 169 case DRM_FORMAT_XRGB8888: 170 case DRM_FORMAT_BGRX8888: 171 for (i = 0; i < 256; ++i) { 172 r16 = (i << 8) | i; 173 vesa->cmap_write(vesa, i, r16, r16, r16); 174 } 175 break; 176 default: 177 drm_warn_once(dev, "Unsupported format %p4cc for gamma correction\n", 178 &format->format); 179 break; 180 } 181 } 182 183 static void vesadrm_set_gamma_lut(struct vesadrm_device *vesa, 184 const struct drm_format_info *format, 185 struct drm_color_lut *lut) 186 { 187 struct drm_device *dev = &vesa->sysfb.dev; 188 size_t i; 189 u16 r16, g16, b16; 190 191 switch (format->format) { 192 case DRM_FORMAT_XRGB1555: 193 for (i = 0; i < 32; ++i) { 194 r16 = lut[i * 8 + i / 4].red; 195 g16 = lut[i * 8 + i / 4].green; 196 b16 = lut[i * 8 + i / 4].blue; 197 vesa->cmap_write(vesa, i, r16, g16, b16); 198 } 199 break; 200 case DRM_FORMAT_RGB565: 201 for (i = 0; i < 32; ++i) { 202 r16 = lut[i * 8 + i / 4].red; 203 g16 = lut[i * 4 + i / 16].green; 204 b16 = lut[i * 8 + i / 4].blue; 205 vesa->cmap_write(vesa, i, r16, g16, b16); 206 } 207 for (i = 32; i < 64; ++i) 208 vesa->cmap_write(vesa, i, 0, lut[i * 4 + i / 16].green, 0); 209 break; 210 case DRM_FORMAT_RGB888: 211 case DRM_FORMAT_XRGB8888: 212 case DRM_FORMAT_BGRX8888: 213 for (i = 0; i < 256; ++i) 214 vesa->cmap_write(vesa, i, lut[i].red, lut[i].green, lut[i].blue); 215 break; 216 default: 217 drm_warn_once(dev, "Unsupported format %p4cc for gamma correction\n", 218 &format->format); 219 break; 220 } 221 } 222 223 /* 224 * Modesetting 225 */ 226 227 static const u64 vesadrm_primary_plane_format_modifiers[] = { 228 DRM_SYSFB_PLANE_FORMAT_MODIFIERS, 229 }; 230 231 static const struct drm_plane_helper_funcs vesadrm_primary_plane_helper_funcs = { 232 DRM_SYSFB_PLANE_HELPER_FUNCS, 233 }; 234 235 static const struct drm_plane_funcs vesadrm_primary_plane_funcs = { 236 DRM_SYSFB_PLANE_FUNCS, 237 .destroy = drm_plane_cleanup, 238 }; 239 240 static void vesadrm_crtc_helper_atomic_flush(struct drm_crtc *crtc, 241 struct drm_atomic_state *state) 242 { 243 struct drm_device *dev = crtc->dev; 244 struct drm_sysfb_device *sysfb = to_drm_sysfb_device(dev); 245 struct vesadrm_device *vesa = to_vesadrm_device(dev); 246 struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc); 247 struct drm_sysfb_crtc_state *sysfb_crtc_state = to_drm_sysfb_crtc_state(crtc_state); 248 249 /* 250 * The gamma LUT has to be reloaded after changing the primary 251 * plane's color format. 252 */ 253 if (crtc_state->enable && crtc_state->color_mgmt_changed) { 254 if (sysfb_crtc_state->format == sysfb->fb_format) { 255 if (crtc_state->gamma_lut) 256 vesadrm_set_gamma_lut(vesa, 257 sysfb_crtc_state->format, 258 crtc_state->gamma_lut->data); 259 else 260 vesadrm_set_gamma_linear(vesa, sysfb_crtc_state->format); 261 } else { 262 vesadrm_set_gamma_linear(vesa, sysfb_crtc_state->format); 263 } 264 } 265 } 266 267 static const struct drm_crtc_helper_funcs vesadrm_crtc_helper_funcs = { 268 DRM_SYSFB_CRTC_HELPER_FUNCS, 269 .atomic_flush = vesadrm_crtc_helper_atomic_flush, 270 }; 271 272 static const struct drm_crtc_funcs vesadrm_crtc_funcs = { 273 DRM_SYSFB_CRTC_FUNCS, 274 .destroy = drm_crtc_cleanup, 275 }; 276 277 static const struct drm_encoder_funcs vesadrm_encoder_funcs = { 278 .destroy = drm_encoder_cleanup, 279 }; 280 281 static const struct drm_connector_helper_funcs vesadrm_connector_helper_funcs = { 282 DRM_SYSFB_CONNECTOR_HELPER_FUNCS, 283 }; 284 285 static const struct drm_connector_funcs vesadrm_connector_funcs = { 286 DRM_SYSFB_CONNECTOR_FUNCS, 287 .destroy = drm_connector_cleanup, 288 }; 289 290 static const struct drm_mode_config_funcs vesadrm_mode_config_funcs = { 291 DRM_SYSFB_MODE_CONFIG_FUNCS, 292 }; 293 294 /* 295 * Init / Cleanup 296 */ 297 298 static struct vesadrm_device *vesadrm_device_create(struct drm_driver *drv, 299 struct platform_device *pdev) 300 { 301 const struct screen_info *si; 302 const struct drm_format_info *format; 303 int width, height, stride; 304 u64 vsize; 305 struct resource resbuf; 306 struct resource *res; 307 struct vesadrm_device *vesa; 308 struct drm_sysfb_device *sysfb; 309 struct drm_device *dev; 310 struct resource *mem = NULL; 311 void __iomem *screen_base; 312 struct drm_plane *primary_plane; 313 struct drm_crtc *crtc; 314 struct drm_encoder *encoder; 315 struct drm_connector *connector; 316 unsigned long max_width, max_height; 317 size_t nformats; 318 int ret; 319 320 si = dev_get_platdata(&pdev->dev); 321 if (!si) 322 return ERR_PTR(-ENODEV); 323 if (screen_info_video_type(si) != VIDEO_TYPE_VLFB) 324 return ERR_PTR(-ENODEV); 325 326 /* 327 * VESA DRM driver 328 */ 329 330 vesa = devm_drm_dev_alloc(&pdev->dev, drv, struct vesadrm_device, sysfb.dev); 331 if (IS_ERR(vesa)) 332 return ERR_CAST(vesa); 333 sysfb = &vesa->sysfb; 334 dev = &sysfb->dev; 335 platform_set_drvdata(pdev, dev); 336 337 /* 338 * Hardware settings 339 */ 340 341 format = vesadrm_get_format_si(dev, si); 342 if (!format) 343 return ERR_PTR(-EINVAL); 344 width = drm_sysfb_get_width_si(dev, si); 345 if (width < 0) 346 return ERR_PTR(width); 347 height = drm_sysfb_get_height_si(dev, si); 348 if (height < 0) 349 return ERR_PTR(height); 350 res = drm_sysfb_get_memory_si(dev, si, &resbuf); 351 if (!res) 352 return ERR_PTR(-EINVAL); 353 stride = drm_sysfb_get_stride_si(dev, si, format, width, height, resource_size(res)); 354 if (stride < 0) 355 return ERR_PTR(stride); 356 vsize = drm_sysfb_get_visible_size_si(dev, si, height, stride, resource_size(res)); 357 if (!vsize) 358 return ERR_PTR(-EINVAL); 359 360 drm_dbg(dev, "framebuffer format=%p4cc, size=%dx%d, stride=%d bytes\n", 361 &format->format, width, height, stride); 362 363 if (!__screen_info_vbe_mode_nonvga(si)) { 364 vesa->cmap_write = vesadrm_vga_cmap_write; 365 } else { 366 #if defined(CONFIG_X86_32) 367 phys_addr_t pmi_base = __screen_info_vesapm_info_base(si); 368 369 if (pmi_base) { 370 const u16 *pmi_addr = phys_to_virt(pmi_base); 371 372 vesa->pmi.PrimaryPalette = (u8 *)pmi_addr + pmi_addr[2]; 373 vesa->cmap_write = vesadrm_pmi_cmap_write; 374 } else 375 #endif 376 if (format->is_color_indexed) 377 drm_warn(dev, "hardware palette is unchangeable, colors may be incorrect\n"); 378 } 379 380 #ifdef CONFIG_X86 381 if (drm_edid_header_is_valid(edid_info.dummy) == 8) 382 sysfb->edid = edid_info.dummy; 383 #endif 384 sysfb->fb_mode = drm_sysfb_mode(width, height, 0, 0); 385 sysfb->fb_format = format; 386 sysfb->fb_pitch = stride; 387 if (vesa->cmap_write) 388 sysfb->fb_gamma_lut_size = VESADRM_GAMMA_LUT_SIZE; 389 390 /* 391 * Memory management 392 */ 393 394 ret = devm_aperture_acquire_for_platform_device(pdev, res->start, vsize); 395 if (ret) { 396 drm_err(dev, "could not acquire memory range %pr: %d\n", res, ret); 397 return ERR_PTR(ret); 398 } 399 400 drm_dbg(dev, "using I/O memory framebuffer at %pr\n", res); 401 402 mem = devm_request_mem_region(&pdev->dev, res->start, vsize, drv->name); 403 if (!mem) { 404 /* 405 * We cannot make this fatal. Sometimes this comes from magic 406 * spaces our resource handlers simply don't know about. Use 407 * the I/O-memory resource as-is and try to map that instead. 408 */ 409 drm_warn(dev, "could not acquire memory region %pr\n", res); 410 mem = res; 411 } 412 413 screen_base = devm_ioremap_wc(&pdev->dev, mem->start, resource_size(mem)); 414 if (!screen_base) 415 return ERR_PTR(-ENOMEM); 416 iosys_map_set_vaddr_iomem(&sysfb->fb_addr, screen_base); 417 418 /* 419 * Modesetting 420 */ 421 422 ret = drmm_mode_config_init(dev); 423 if (ret) 424 return ERR_PTR(ret); 425 426 max_width = max_t(unsigned long, width, DRM_SHADOW_PLANE_MAX_WIDTH); 427 max_height = max_t(unsigned long, height, DRM_SHADOW_PLANE_MAX_HEIGHT); 428 429 dev->mode_config.min_width = width; 430 dev->mode_config.max_width = max_width; 431 dev->mode_config.min_height = height; 432 dev->mode_config.max_height = max_height; 433 dev->mode_config.preferred_depth = format->depth; 434 dev->mode_config.funcs = &vesadrm_mode_config_funcs; 435 436 /* Primary plane */ 437 438 nformats = drm_fb_build_fourcc_list(dev, &format->format, 1, 439 vesa->formats, ARRAY_SIZE(vesa->formats)); 440 441 primary_plane = &vesa->primary_plane; 442 ret = drm_universal_plane_init(dev, primary_plane, 0, &vesadrm_primary_plane_funcs, 443 vesa->formats, nformats, 444 vesadrm_primary_plane_format_modifiers, 445 DRM_PLANE_TYPE_PRIMARY, NULL); 446 if (ret) 447 return ERR_PTR(ret); 448 drm_plane_helper_add(primary_plane, &vesadrm_primary_plane_helper_funcs); 449 drm_plane_enable_fb_damage_clips(primary_plane); 450 451 /* CRTC */ 452 453 crtc = &vesa->crtc; 454 ret = drm_crtc_init_with_planes(dev, crtc, primary_plane, NULL, 455 &vesadrm_crtc_funcs, NULL); 456 if (ret) 457 return ERR_PTR(ret); 458 drm_crtc_helper_add(crtc, &vesadrm_crtc_helper_funcs); 459 460 if (sysfb->fb_gamma_lut_size) { 461 ret = drm_mode_crtc_set_gamma_size(crtc, sysfb->fb_gamma_lut_size); 462 if (!ret) 463 drm_crtc_enable_color_mgmt(crtc, 0, false, sysfb->fb_gamma_lut_size); 464 } 465 466 /* Encoder */ 467 468 encoder = &vesa->encoder; 469 ret = drm_encoder_init(dev, encoder, &vesadrm_encoder_funcs, 470 DRM_MODE_ENCODER_NONE, NULL); 471 if (ret) 472 return ERR_PTR(ret); 473 encoder->possible_crtcs = drm_crtc_mask(crtc); 474 475 /* Connector */ 476 477 connector = &vesa->connector; 478 ret = drm_connector_init(dev, connector, &vesadrm_connector_funcs, 479 DRM_MODE_CONNECTOR_Unknown); 480 if (ret) 481 return ERR_PTR(ret); 482 drm_connector_helper_add(connector, &vesadrm_connector_helper_funcs); 483 drm_connector_set_panel_orientation_with_quirk(connector, 484 DRM_MODE_PANEL_ORIENTATION_UNKNOWN, 485 width, height); 486 if (sysfb->edid) 487 drm_connector_attach_edid_property(connector); 488 489 ret = drm_connector_attach_encoder(connector, encoder); 490 if (ret) 491 return ERR_PTR(ret); 492 493 drm_mode_config_reset(dev); 494 495 return vesa; 496 } 497 498 /* 499 * DRM driver 500 */ 501 502 DEFINE_DRM_GEM_FOPS(vesadrm_fops); 503 504 static struct drm_driver vesadrm_driver = { 505 DRM_GEM_SHMEM_DRIVER_OPS, 506 DRM_FBDEV_SHMEM_DRIVER_OPS, 507 .name = DRIVER_NAME, 508 .desc = DRIVER_DESC, 509 .major = DRIVER_MAJOR, 510 .minor = DRIVER_MINOR, 511 .driver_features = DRIVER_ATOMIC | DRIVER_GEM | DRIVER_MODESET, 512 .fops = &vesadrm_fops, 513 }; 514 515 /* 516 * Platform driver 517 */ 518 519 static int vesadrm_probe(struct platform_device *pdev) 520 { 521 struct vesadrm_device *vesa; 522 struct drm_sysfb_device *sysfb; 523 struct drm_device *dev; 524 int ret; 525 526 vesa = vesadrm_device_create(&vesadrm_driver, pdev); 527 if (IS_ERR(vesa)) 528 return PTR_ERR(vesa); 529 sysfb = &vesa->sysfb; 530 dev = &sysfb->dev; 531 532 ret = drm_dev_register(dev, 0); 533 if (ret) 534 return ret; 535 536 drm_client_setup(dev, sysfb->fb_format); 537 538 return 0; 539 } 540 541 static void vesadrm_remove(struct platform_device *pdev) 542 { 543 struct drm_device *dev = platform_get_drvdata(pdev); 544 545 drm_dev_unplug(dev); 546 } 547 548 static struct platform_driver vesadrm_platform_driver = { 549 .driver = { 550 .name = "vesa-framebuffer", 551 }, 552 .probe = vesadrm_probe, 553 .remove = vesadrm_remove, 554 }; 555 556 module_platform_driver(vesadrm_platform_driver); 557 558 MODULE_DESCRIPTION(DRIVER_DESC); 559 MODULE_LICENSE("GPL"); 560