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