Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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
37static 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
52static 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
75out:
76 return mem_flags;
77}
78
79/*
80 * EFI device
81 */
82
83struct 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
98static const u64 efidrm_primary_plane_format_modifiers[] = {
99 DRM_SYSFB_PLANE_FORMAT_MODIFIERS,
100};
101
102static const struct drm_plane_helper_funcs efidrm_primary_plane_helper_funcs = {
103 DRM_SYSFB_PLANE_HELPER_FUNCS,
104};
105
106static const struct drm_plane_funcs efidrm_primary_plane_funcs = {
107 DRM_SYSFB_PLANE_FUNCS,
108 .destroy = drm_plane_cleanup,
109};
110
111static const struct drm_crtc_helper_funcs efidrm_crtc_helper_funcs = {
112 DRM_SYSFB_CRTC_HELPER_FUNCS,
113};
114
115static const struct drm_crtc_funcs efidrm_crtc_funcs = {
116 DRM_SYSFB_CRTC_FUNCS,
117 .destroy = drm_crtc_cleanup,
118};
119
120static const struct drm_encoder_funcs efidrm_encoder_funcs = {
121 .destroy = drm_encoder_cleanup,
122};
123
124static const struct drm_connector_helper_funcs efidrm_connector_helper_funcs = {
125 DRM_SYSFB_CONNECTOR_HELPER_FUNCS,
126};
127
128static const struct drm_connector_funcs efidrm_connector_funcs = {
129 DRM_SYSFB_CONNECTOR_FUNCS,
130 .destroy = drm_connector_cleanup,
131};
132
133static const struct drm_mode_config_funcs efidrm_mode_config_funcs = {
134 DRM_SYSFB_MODE_CONFIG_FUNCS,
135};
136
137/*
138 * Init / Cleanup
139 */
140
141static 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
333DEFINE_DRM_GEM_FOPS(efidrm_fops);
334
335static 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
350static 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
372static 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
379static struct platform_driver efidrm_platform_driver = {
380 .driver = {
381 .name = "efi-framebuffer",
382 },
383 .probe = efidrm_probe,
384 .remove = efidrm_remove,
385};
386
387module_platform_driver(efidrm_platform_driver);
388
389MODULE_DESCRIPTION(DRIVER_DESC);
390MODULE_LICENSE("GPL");