efidrm.c

  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	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		void __iomem *screen_base = devm_ioremap_wc(&pdev->dev, mem->start,
240							    resource_size(mem));
241
242		if (!screen_base)
243			return ERR_PTR(-ENXIO);
244		iosys_map_set_vaddr_iomem(&sysfb->fb_addr, screen_base);
245	} else if (mem_flags & EFI_MEMORY_UC) {
246		void __iomem *screen_base = devm_ioremap(&pdev->dev, mem->start,
247							 resource_size(mem));
248
249		if (!screen_base)
250			return ERR_PTR(-ENXIO);
251		iosys_map_set_vaddr_iomem(&sysfb->fb_addr, screen_base);
252	} else if (mem_flags & EFI_MEMORY_WT) {
253		void *screen_base = devm_memremap(&pdev->dev, mem->start,
254						  resource_size(mem), MEMREMAP_WT);
255
256		if (IS_ERR(screen_base))
257			return ERR_CAST(screen_base);
258		iosys_map_set_vaddr(&sysfb->fb_addr, screen_base);
259	} else if (mem_flags & EFI_MEMORY_WB) {
260		void *screen_base = devm_memremap(&pdev->dev, mem->start,
261						  resource_size(mem), MEMREMAP_WB);
262
263		if (IS_ERR(screen_base))
264			return ERR_CAST(screen_base);
265		iosys_map_set_vaddr(&sysfb->fb_addr, screen_base);
266	} else {
267		drm_err(dev, "invalid mem_flags: 0x%llx\n", mem_flags);
268		return ERR_PTR(-EINVAL);
269	}
270
271	/*
272	 * Modesetting
273	 */
274
275	ret = drmm_mode_config_init(dev);
276	if (ret)
277		return ERR_PTR(ret);
278
279	max_width = max_t(unsigned long, width, DRM_SHADOW_PLANE_MAX_WIDTH);
280	max_height = max_t(unsigned long, height, DRM_SHADOW_PLANE_MAX_HEIGHT);
281
282	dev->mode_config.min_width = width;
283	dev->mode_config.max_width = max_width;
284	dev->mode_config.min_height = height;
285	dev->mode_config.max_height = max_height;
286	dev->mode_config.preferred_depth = format->depth;
287	dev->mode_config.funcs = &efidrm_mode_config_funcs;
288
289	/* Primary plane */
290
291	nformats = drm_sysfb_build_fourcc_list(dev, &format->format, 1,
292					       efi->formats, ARRAY_SIZE(efi->formats));
293
294	primary_plane = &efi->primary_plane;
295	ret = drm_universal_plane_init(dev, primary_plane, 0, &efidrm_primary_plane_funcs,
296				       efi->formats, nformats,
297				       efidrm_primary_plane_format_modifiers,
298				       DRM_PLANE_TYPE_PRIMARY, NULL);
299	if (ret)
300		return ERR_PTR(ret);
301	drm_plane_helper_add(primary_plane, &efidrm_primary_plane_helper_funcs);
302	drm_plane_enable_fb_damage_clips(primary_plane);
303
304	/* CRTC */
305
306	crtc = &efi->crtc;
307	ret = drm_crtc_init_with_planes(dev, crtc, primary_plane, NULL,
308					&efidrm_crtc_funcs, NULL);
309	if (ret)
310		return ERR_PTR(ret);
311	drm_crtc_helper_add(crtc, &efidrm_crtc_helper_funcs);
312
313	/* Encoder */
314
315	encoder = &efi->encoder;
316	ret = drm_encoder_init(dev, encoder, &efidrm_encoder_funcs,
317			       DRM_MODE_ENCODER_NONE, NULL);
318	if (ret)
319		return ERR_PTR(ret);
320	encoder->possible_crtcs = drm_crtc_mask(crtc);
321
322	/* Connector */
323
324	connector = &efi->connector;
325	ret = drm_connector_init(dev, connector, &efidrm_connector_funcs,
326				 DRM_MODE_CONNECTOR_Unknown);
327	if (ret)
328		return ERR_PTR(ret);
329	drm_connector_helper_add(connector, &efidrm_connector_helper_funcs);
330	drm_connector_set_panel_orientation_with_quirk(connector,
331						       DRM_MODE_PANEL_ORIENTATION_UNKNOWN,
332						       width, height);
333	if (sysfb->edid)
334		drm_connector_attach_edid_property(connector);
335
336	ret = drm_connector_attach_encoder(connector, encoder);
337	if (ret)
338		return ERR_PTR(ret);
339
340	drm_mode_config_reset(dev);
341
342	return efi;
343}
344
345/*
346 * DRM driver
347 */
348
349DEFINE_DRM_GEM_FOPS(efidrm_fops);
350
351static struct drm_driver efidrm_driver = {
352	DRM_GEM_SHMEM_DRIVER_OPS,
353	DRM_FBDEV_SHMEM_DRIVER_OPS,
354	.name			= DRIVER_NAME,
355	.desc			= DRIVER_DESC,
356	.major			= DRIVER_MAJOR,
357	.minor			= DRIVER_MINOR,
358	.driver_features	= DRIVER_ATOMIC | DRIVER_GEM | DRIVER_MODESET,
359	.fops			= &efidrm_fops,
360};
361
362/*
363 * Platform driver
364 */
365
366static int efidrm_probe(struct platform_device *pdev)
367{
368	struct efidrm_device *efi;
369	struct drm_sysfb_device *sysfb;
370	struct drm_device *dev;
371	int ret;
372
373	efi = efidrm_device_create(&efidrm_driver, pdev);
374	if (IS_ERR(efi))
375		return PTR_ERR(efi);
376	sysfb = &efi->sysfb;
377	dev = &sysfb->dev;
378
379	ret = drm_dev_register(dev, 0);
380	if (ret)
381		return ret;
382
383	drm_client_setup(dev, sysfb->fb_format);
384
385	return 0;
386}
387
388static void efidrm_remove(struct platform_device *pdev)
389{
390	struct drm_device *dev = platform_get_drvdata(pdev);
391
392	drm_dev_unplug(dev);
393}
394
395static struct platform_driver efidrm_platform_driver = {
396	.driver = {
397		.name = "efi-framebuffer",
398	},
399	.probe = efidrm_probe,
400	.remove = efidrm_remove,
401};
402
403module_platform_driver(efidrm_platform_driver);
404
405MODULE_DESCRIPTION(DRIVER_DESC);
406MODULE_LICENSE("GPL");