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