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