1 // SPDX-License-Identifier: GPL-2.0-only 2 3 #include <linux/aperture.h> 4 #include <linux/efi.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 29 #include "drm_sysfb_helper.h" 30 31 #define DRIVER_NAME "efidrm" 32 #define DRIVER_DESC "DRM driver for EFI platform devices" 33 #define DRIVER_MAJOR 1 34 #define DRIVER_MINOR 0 35 36 static int efidrm_get_validated_int(struct drm_device *dev, const char *name, 37 u64 value, u32 max) 38 { 39 if (max > INT_MAX) 40 max = INT_MAX; 41 if (value > max) { 42 drm_err(dev, "%s of %llu exceeds maximum of %u\n", name, value, max); 43 return -EINVAL; 44 } 45 return value; 46 } 47 48 static int efidrm_get_validated_int0(struct drm_device *dev, const char *name, 49 u64 value, u32 max) 50 { 51 if (!value) { 52 drm_err(dev, "%s of 0 not allowed\n", name); 53 return -EINVAL; 54 } 55 return efidrm_get_validated_int(dev, name, value, max); 56 } 57 58 static s64 efidrm_get_validated_size0(struct drm_device *dev, const char *name, 59 u64 value, u64 max) 60 { 61 if (!value) { 62 drm_err(dev, "%s of 0 not allowed\n", name); 63 return -EINVAL; 64 } else if (value > max) { 65 drm_err(dev, "%s of %llu exceeds maximum of %llu\n", name, value, max); 66 return -EINVAL; 67 } 68 return value; 69 } 70 71 static int efidrm_get_width_si(struct drm_device *dev, const struct screen_info *si) 72 { 73 return efidrm_get_validated_int0(dev, "width", si->lfb_width, U16_MAX); 74 } 75 76 static int efidrm_get_height_si(struct drm_device *dev, const struct screen_info *si) 77 { 78 return efidrm_get_validated_int0(dev, "height", si->lfb_height, U16_MAX); 79 } 80 81 static struct resource *efidrm_get_memory_si(struct drm_device *dev, 82 const struct screen_info *si, 83 struct resource *res) 84 { 85 ssize_t num; 86 87 num = screen_info_resources(si, res, 1); 88 if (!num) { 89 drm_err(dev, "memory resource not found\n"); 90 return NULL; 91 } 92 93 return res; 94 } 95 96 static int efidrm_get_stride_si(struct drm_device *dev, const struct screen_info *si, 97 const struct drm_format_info *format, 98 unsigned int width, unsigned int height, u64 size) 99 { 100 u64 lfb_linelength = si->lfb_linelength; 101 102 if (!lfb_linelength) 103 lfb_linelength = drm_format_info_min_pitch(format, 0, width); 104 105 return efidrm_get_validated_int0(dev, "stride", lfb_linelength, div64_u64(size, height)); 106 } 107 108 static u64 efidrm_get_visible_size_si(struct drm_device *dev, const struct screen_info *si, 109 unsigned int height, unsigned int stride, u64 size) 110 { 111 u64 vsize = PAGE_ALIGN(height * stride); 112 113 return efidrm_get_validated_size0(dev, "visible size", vsize, size); 114 } 115 116 static const struct drm_format_info *efidrm_get_format_si(struct drm_device *dev, 117 const struct screen_info *si) 118 { 119 static const struct { 120 struct pixel_format pixel; 121 u32 fourcc; 122 } efi_formats[] = { 123 { PIXEL_FORMAT_XRGB1555, DRM_FORMAT_XRGB1555, }, 124 { PIXEL_FORMAT_RGB565, DRM_FORMAT_RGB565, }, 125 { PIXEL_FORMAT_RGB888, DRM_FORMAT_RGB888, }, 126 { PIXEL_FORMAT_XRGB8888, DRM_FORMAT_XRGB8888, }, 127 { PIXEL_FORMAT_XBGR8888, DRM_FORMAT_XBGR8888, }, 128 { PIXEL_FORMAT_XRGB2101010, DRM_FORMAT_XRGB2101010, }, 129 }; 130 const struct drm_format_info *format = NULL; 131 u32 bits_per_pixel; 132 size_t i; 133 134 bits_per_pixel = __screen_info_lfb_bits_per_pixel(si); 135 136 for (i = 0; i < ARRAY_SIZE(efi_formats); ++i) { 137 const struct pixel_format *f = &efi_formats[i].pixel; 138 139 if (bits_per_pixel == f->bits_per_pixel && 140 si->red_size == f->red.length && 141 si->red_pos == f->red.offset && 142 si->green_size == f->green.length && 143 si->green_pos == f->green.offset && 144 si->blue_size == f->blue.length && 145 si->blue_pos == f->blue.offset) { 146 format = drm_format_info(efi_formats[i].fourcc); 147 break; 148 } 149 } 150 151 if (!format) 152 return ERR_PTR(-EINVAL); 153 if (format->is_color_indexed) 154 return ERR_PTR(-EINVAL); 155 156 return format; 157 } 158 159 static u64 efidrm_get_mem_flags(struct drm_device *dev, resource_size_t start, 160 resource_size_t len) 161 { 162 u64 attribute = EFI_MEMORY_UC | EFI_MEMORY_WC | 163 EFI_MEMORY_WT | EFI_MEMORY_WB; 164 u64 mem_flags = EFI_MEMORY_WC | EFI_MEMORY_UC; 165 resource_size_t end = start + len; 166 efi_memory_desc_t md; 167 u64 md_end; 168 169 if (!efi_enabled(EFI_MEMMAP) || efi_mem_desc_lookup(start, &md)) 170 goto out; 171 172 md_end = md.phys_addr + (md.num_pages << EFI_PAGE_SHIFT); 173 if (end > md_end) 174 goto out; 175 176 attribute &= md.attribute; 177 if (attribute) { 178 mem_flags |= EFI_MEMORY_WT | EFI_MEMORY_WB; 179 mem_flags &= attribute; 180 } 181 182 out: 183 return mem_flags; 184 } 185 186 /* 187 * EFI device 188 */ 189 190 struct efidrm_device { 191 struct drm_sysfb_device sysfb; 192 193 /* modesetting */ 194 u32 formats[DRM_SYSFB_PLANE_NFORMATS(1)]; 195 struct drm_plane primary_plane; 196 struct drm_crtc crtc; 197 struct drm_encoder encoder; 198 struct drm_connector connector; 199 }; 200 201 /* 202 * Modesetting 203 */ 204 205 static const u64 efidrm_primary_plane_format_modifiers[] = { 206 DRM_SYSFB_PLANE_FORMAT_MODIFIERS, 207 }; 208 209 static const struct drm_plane_helper_funcs efidrm_primary_plane_helper_funcs = { 210 DRM_SYSFB_PLANE_HELPER_FUNCS, 211 }; 212 213 static const struct drm_plane_funcs efidrm_primary_plane_funcs = { 214 DRM_SYSFB_PLANE_FUNCS, 215 .destroy = drm_plane_cleanup, 216 }; 217 218 static const struct drm_crtc_helper_funcs efidrm_crtc_helper_funcs = { 219 DRM_SYSFB_CRTC_HELPER_FUNCS, 220 }; 221 222 static const struct drm_crtc_funcs efidrm_crtc_funcs = { 223 DRM_SYSFB_CRTC_FUNCS, 224 .destroy = drm_crtc_cleanup, 225 }; 226 227 static const struct drm_encoder_funcs efidrm_encoder_funcs = { 228 .destroy = drm_encoder_cleanup, 229 }; 230 231 static const struct drm_connector_helper_funcs efidrm_connector_helper_funcs = { 232 DRM_SYSFB_CONNECTOR_HELPER_FUNCS, 233 }; 234 235 static const struct drm_connector_funcs efidrm_connector_funcs = { 236 DRM_SYSFB_CONNECTOR_FUNCS, 237 .destroy = drm_connector_cleanup, 238 }; 239 240 static const struct drm_mode_config_funcs efidrm_mode_config_funcs = { 241 DRM_SYSFB_MODE_CONFIG_FUNCS, 242 }; 243 244 /* 245 * Init / Cleanup 246 */ 247 248 static struct efidrm_device *efidrm_device_create(struct drm_driver *drv, 249 struct platform_device *pdev) 250 { 251 const struct screen_info *si; 252 const struct drm_format_info *format; 253 int width, height, stride; 254 u64 vsize, mem_flags; 255 struct resource resbuf; 256 struct resource *res; 257 struct efidrm_device *efi; 258 struct drm_sysfb_device *sysfb; 259 struct drm_device *dev; 260 struct resource *mem = NULL; 261 void __iomem *screen_base = NULL; 262 struct drm_plane *primary_plane; 263 struct drm_crtc *crtc; 264 struct drm_encoder *encoder; 265 struct drm_connector *connector; 266 unsigned long max_width, max_height; 267 size_t nformats; 268 int ret; 269 270 si = dev_get_platdata(&pdev->dev); 271 if (!si) 272 return ERR_PTR(-ENODEV); 273 if (screen_info_video_type(si) != VIDEO_TYPE_EFI) 274 return ERR_PTR(-ENODEV); 275 276 /* 277 * EFI DRM driver 278 */ 279 280 efi = devm_drm_dev_alloc(&pdev->dev, drv, struct efidrm_device, sysfb.dev); 281 if (IS_ERR(efi)) 282 return ERR_CAST(efi); 283 sysfb = &efi->sysfb; 284 dev = &sysfb->dev; 285 platform_set_drvdata(pdev, dev); 286 287 /* 288 * Hardware settings 289 */ 290 291 format = efidrm_get_format_si(dev, si); 292 if (IS_ERR(format)) 293 return ERR_CAST(format); 294 width = efidrm_get_width_si(dev, si); 295 if (width < 0) 296 return ERR_PTR(width); 297 height = efidrm_get_height_si(dev, si); 298 if (height < 0) 299 return ERR_PTR(height); 300 res = efidrm_get_memory_si(dev, si, &resbuf); 301 if (!res) 302 return ERR_PTR(-EINVAL); 303 stride = efidrm_get_stride_si(dev, si, format, width, height, resource_size(res)); 304 if (stride < 0) 305 return ERR_PTR(stride); 306 vsize = efidrm_get_visible_size_si(dev, si, height, stride, resource_size(res)); 307 if (!vsize) 308 return ERR_PTR(-EINVAL); 309 310 drm_dbg(dev, "framebuffer format=%p4cc, size=%dx%d, stride=%d bytes\n", 311 &format->format, width, height, stride); 312 313 #ifdef CONFIG_X86 314 if (drm_edid_header_is_valid(edid_info.dummy) == 8) 315 sysfb->edid = edid_info.dummy; 316 #endif 317 sysfb->fb_mode = drm_sysfb_mode(width, height, 0, 0); 318 sysfb->fb_format = format; 319 sysfb->fb_pitch = stride; 320 321 /* 322 * Memory management 323 */ 324 325 ret = devm_aperture_acquire_for_platform_device(pdev, res->start, vsize); 326 if (ret) { 327 drm_err(dev, "could not acquire memory range %pr: %d\n", res, ret); 328 return ERR_PTR(ret); 329 } 330 331 drm_dbg(dev, "using I/O memory framebuffer at %pr\n", res); 332 333 mem = devm_request_mem_region(&pdev->dev, res->start, vsize, drv->name); 334 if (!mem) { 335 /* 336 * We cannot make this fatal. Sometimes this comes from magic 337 * spaces our resource handlers simply don't know about. Use 338 * the I/O-memory resource as-is and try to map that instead. 339 */ 340 drm_warn(dev, "could not acquire memory region %pr\n", res); 341 mem = res; 342 } 343 344 mem_flags = efidrm_get_mem_flags(dev, res->start, vsize); 345 346 if (mem_flags & EFI_MEMORY_WC) 347 screen_base = devm_ioremap_wc(&pdev->dev, mem->start, resource_size(mem)); 348 else if (mem_flags & EFI_MEMORY_UC) 349 screen_base = devm_ioremap(&pdev->dev, mem->start, resource_size(mem)); 350 else if (mem_flags & EFI_MEMORY_WT) 351 screen_base = devm_memremap(&pdev->dev, mem->start, resource_size(mem), 352 MEMREMAP_WT); 353 else if (mem_flags & EFI_MEMORY_WB) 354 screen_base = devm_memremap(&pdev->dev, mem->start, resource_size(mem), 355 MEMREMAP_WB); 356 else 357 drm_err(dev, "invalid mem_flags: 0x%llx\n", mem_flags); 358 if (!screen_base) 359 return ERR_PTR(-ENOMEM); 360 iosys_map_set_vaddr_iomem(&sysfb->fb_addr, screen_base); 361 362 /* 363 * Modesetting 364 */ 365 366 ret = drmm_mode_config_init(dev); 367 if (ret) 368 return ERR_PTR(ret); 369 370 max_width = max_t(unsigned long, width, DRM_SHADOW_PLANE_MAX_WIDTH); 371 max_height = max_t(unsigned long, height, DRM_SHADOW_PLANE_MAX_HEIGHT); 372 373 dev->mode_config.min_width = width; 374 dev->mode_config.max_width = max_width; 375 dev->mode_config.min_height = height; 376 dev->mode_config.max_height = max_height; 377 dev->mode_config.preferred_depth = format->depth; 378 dev->mode_config.funcs = &efidrm_mode_config_funcs; 379 380 /* Primary plane */ 381 382 nformats = drm_fb_build_fourcc_list(dev, &format->format, 1, 383 efi->formats, ARRAY_SIZE(efi->formats)); 384 385 primary_plane = &efi->primary_plane; 386 ret = drm_universal_plane_init(dev, primary_plane, 0, &efidrm_primary_plane_funcs, 387 efi->formats, nformats, 388 efidrm_primary_plane_format_modifiers, 389 DRM_PLANE_TYPE_PRIMARY, NULL); 390 if (ret) 391 return ERR_PTR(ret); 392 drm_plane_helper_add(primary_plane, &efidrm_primary_plane_helper_funcs); 393 drm_plane_enable_fb_damage_clips(primary_plane); 394 395 /* CRTC */ 396 397 crtc = &efi->crtc; 398 ret = drm_crtc_init_with_planes(dev, crtc, primary_plane, NULL, 399 &efidrm_crtc_funcs, NULL); 400 if (ret) 401 return ERR_PTR(ret); 402 drm_crtc_helper_add(crtc, &efidrm_crtc_helper_funcs); 403 404 /* Encoder */ 405 406 encoder = &efi->encoder; 407 ret = drm_encoder_init(dev, encoder, &efidrm_encoder_funcs, 408 DRM_MODE_ENCODER_NONE, NULL); 409 if (ret) 410 return ERR_PTR(ret); 411 encoder->possible_crtcs = drm_crtc_mask(crtc); 412 413 /* Connector */ 414 415 connector = &efi->connector; 416 ret = drm_connector_init(dev, connector, &efidrm_connector_funcs, 417 DRM_MODE_CONNECTOR_Unknown); 418 if (ret) 419 return ERR_PTR(ret); 420 drm_connector_helper_add(connector, &efidrm_connector_helper_funcs); 421 drm_connector_set_panel_orientation_with_quirk(connector, 422 DRM_MODE_PANEL_ORIENTATION_UNKNOWN, 423 width, height); 424 if (sysfb->edid) 425 drm_connector_attach_edid_property(connector); 426 427 ret = drm_connector_attach_encoder(connector, encoder); 428 if (ret) 429 return ERR_PTR(ret); 430 431 drm_mode_config_reset(dev); 432 433 return efi; 434 } 435 436 /* 437 * DRM driver 438 */ 439 440 DEFINE_DRM_GEM_FOPS(efidrm_fops); 441 442 static struct drm_driver efidrm_driver = { 443 DRM_GEM_SHMEM_DRIVER_OPS, 444 DRM_FBDEV_SHMEM_DRIVER_OPS, 445 .name = DRIVER_NAME, 446 .desc = DRIVER_DESC, 447 .major = DRIVER_MAJOR, 448 .minor = DRIVER_MINOR, 449 .driver_features = DRIVER_ATOMIC | DRIVER_GEM | DRIVER_MODESET, 450 .fops = &efidrm_fops, 451 }; 452 453 /* 454 * Platform driver 455 */ 456 457 static int efidrm_probe(struct platform_device *pdev) 458 { 459 struct efidrm_device *efi; 460 struct drm_sysfb_device *sysfb; 461 struct drm_device *dev; 462 int ret; 463 464 efi = efidrm_device_create(&efidrm_driver, pdev); 465 if (IS_ERR(efi)) 466 return PTR_ERR(efi); 467 sysfb = &efi->sysfb; 468 dev = &sysfb->dev; 469 470 ret = drm_dev_register(dev, 0); 471 if (ret) 472 return ret; 473 474 drm_client_setup(dev, sysfb->fb_format); 475 476 return 0; 477 } 478 479 static void efidrm_remove(struct platform_device *pdev) 480 { 481 struct drm_device *dev = platform_get_drvdata(pdev); 482 483 drm_dev_unplug(dev); 484 } 485 486 static struct platform_driver efidrm_platform_driver = { 487 .driver = { 488 .name = "efi-framebuffer", 489 }, 490 .probe = efidrm_probe, 491 .remove = efidrm_remove, 492 }; 493 494 module_platform_driver(efidrm_platform_driver); 495 496 MODULE_DESCRIPTION(DRIVER_DESC); 497 MODULE_LICENSE("GPL"); 498