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