projects/linux·blob master · refs

434 lines · 10.9 KiB

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