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
efidrm_get_format_si(struct drm_device * dev,const struct screen_info * si)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
efidrm_get_mem_flags(struct drm_device * dev,resource_size_t start,resource_size_t len)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
efidrm_device_create(struct drm_driver * drv,struct platform_device * pdev)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
efidrm_probe(struct platform_device * pdev)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
efidrm_remove(struct platform_device * pdev)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