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