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