// SPDX-License-Identifier: GPL-2.0-only #include <linux/aperture.h>#include <linux/coreboot.h>#include <linux/minmax.h>#include <linux/platform_device.h>#include <linux/pm.h> #include <drm/clients/drm_client_setup.h>#include <drm/drm_atomic.h>#include <drm/drm_atomic_state_helper.h>#include <drm/drm_connector.h>#include <drm/drm_damage_helper.h>#include <drm/drm_device.h>#include <drm/drm_drv.h>#include <drm/drm_fbdev_shmem.h>#include <drm/drm_framebuffer.h>#include <drm/drm_gem_atomic_helper.h>#include <drm/drm_gem_framebuffer_helper.h>#include <drm/drm_gem_shmem_helper.h>#include <drm/drm_managed.h>#include <drm/drm_modeset_helper.h>#include <drm/drm_modeset_helper_vtables.h>#include <drm/drm_print.h>#include <drm/drm_probe_helper.h> #include "drm_sysfb_helper.h" #define DRIVER_NAME	"corebootdrm"#define DRIVER_DESC	"DRM driver for Coreboot framebuffers"#define DRIVER_MAJOR	1#define DRIVER_MINOR	0 static const struct drm_format_info *corebootdrm_get_format_fb(struct drm_device *dev, const struct lb_framebuffer *fb){	static const struct drm_sysfb_format formats[] = {		{ PIXEL_FORMAT_XRGB1555, DRM_FORMAT_XRGB1555, },		{ PIXEL_FORMAT_RGB565, DRM_FORMAT_RGB565, },		{ PIXEL_FORMAT_RGB888, DRM_FORMAT_RGB888, },		{ PIXEL_FORMAT_XRGB8888, DRM_FORMAT_XRGB8888, },		{ PIXEL_FORMAT_XBGR8888, DRM_FORMAT_XBGR8888, },		{ PIXEL_FORMAT_XRGB2101010, DRM_FORMAT_XRGB2101010, },	};	const struct pixel_format pixel = {		.bits_per_pixel = fb->bits_per_pixel,		.indexed  = false,		.alpha = {			.offset = 0,			.length = 0,		},		.red = {			.offset = fb->red_mask_pos,			.length = fb->red_mask_size,		},		.green = {			.offset = fb->green_mask_pos,			.length = fb->green_mask_size,		},		.blue = {			.offset = fb->blue_mask_pos,			.length = fb->blue_mask_size,		},	}; 	return drm_sysfb_get_format(dev, formats, ARRAY_SIZE(formats), &pixel);} static int corebootdrm_get_width_fb(struct drm_device *dev, const struct lb_framebuffer *fb){	return drm_sysfb_get_validated_int0(dev, "width", fb->x_resolution, INT_MAX);} static int corebootdrm_get_height_fb(struct drm_device *dev, const struct lb_framebuffer *fb){	return drm_sysfb_get_validated_int0(dev, "height", fb->y_resolution, INT_MAX);} static int corebootdrm_get_pitch_fb(struct drm_device *dev, const struct drm_format_info *format,				    unsigned int width, const struct lb_framebuffer *fb){	u64 bytes_per_line = fb->bytes_per_line; 	if (!bytes_per_line)		bytes_per_line = drm_format_info_min_pitch(format, 0, width); 	return drm_sysfb_get_validated_int0(dev, "pitch", bytes_per_line, INT_MAX);} static resource_size_t corebootdrm_get_size_fb(struct drm_device *dev, unsigned int height,					       unsigned int pitch,					       const struct lb_framebuffer *fb){	resource_size_t size; 	if (check_mul_overflow(height, pitch, &size))		return 0; 	return size;} static phys_addr_t corebootdrm_get_address_fb(struct drm_device *dev, resource_size_t size,					      const struct lb_framebuffer *fb){	if (size > PHYS_ADDR_MAX)		return 0;	if (!fb->physical_address)		return 0;	if (fb->physical_address > (PHYS_ADDR_MAX - size))		return 0; 	return fb->physical_address;} static enum drm_panel_orientation corebootdrm_get_orientation_fb(struct drm_device *dev,								 const struct lb_framebuffer *fb){	if (!LB_FRAMEBUFFER_HAS_ORIENTATION(fb))		return DRM_MODE_PANEL_ORIENTATION_UNKNOWN; 	switch (fb->orientation) {	case LB_FRAMEBUFFER_ORIENTATION_NORMAL:		return DRM_MODE_PANEL_ORIENTATION_NORMAL;	case LB_FRAMEBUFFER_ORIENTATION_BOTTOM_UP:		return DRM_MODE_PANEL_ORIENTATION_BOTTOM_UP;	case LB_FRAMEBUFFER_ORIENTATION_LEFT_UP:		return DRM_MODE_PANEL_ORIENTATION_LEFT_UP;	case LB_FRAMEBUFFER_ORIENTATION_RIGHT_UP:		return DRM_MODE_PANEL_ORIENTATION_RIGHT_UP;	} 	return DRM_MODE_PANEL_ORIENTATION_UNKNOWN;} /* * Simple Framebuffer device */ struct corebootdrm_device {	struct drm_sysfb_device sysfb; 	/* modesetting */	u32 formats[DRM_SYSFB_PLANE_NFORMATS(1)];	struct drm_plane primary_plane;	struct drm_crtc crtc;	struct drm_encoder encoder;	struct drm_connector connector;}; /* * Modesetting */ static const u64 corebootdrm_primary_plane_format_modifiers[] = {	DRM_SYSFB_PLANE_FORMAT_MODIFIERS,}; static const struct drm_plane_helper_funcs corebootdrm_primary_plane_helper_funcs = {	DRM_SYSFB_PLANE_HELPER_FUNCS,}; static const struct drm_plane_funcs corebootdrm_primary_plane_funcs = {	DRM_SYSFB_PLANE_FUNCS,	.destroy = drm_plane_cleanup,}; static const struct drm_crtc_helper_funcs corebootdrm_crtc_helper_funcs = {	DRM_SYSFB_CRTC_HELPER_FUNCS,}; static const struct drm_crtc_funcs corebootdrm_crtc_funcs = {	DRM_SYSFB_CRTC_FUNCS,	.destroy = drm_crtc_cleanup,}; static const struct drm_encoder_funcs corebootdrm_encoder_funcs = {	.destroy = drm_encoder_cleanup,}; static const struct drm_connector_helper_funcs corebootdrm_connector_helper_funcs = {	DRM_SYSFB_CONNECTOR_HELPER_FUNCS,}; static const struct drm_connector_funcs corebootdrm_connector_funcs = {	DRM_SYSFB_CONNECTOR_FUNCS,	.destroy = drm_connector_cleanup,}; static const struct drm_mode_config_funcs corebootdrm_mode_config_funcs = {	DRM_SYSFB_MODE_CONFIG_FUNCS,}; static int corebootdrm_mode_config_init(struct corebootdrm_device *cdev,					enum drm_panel_orientation orientation){	struct drm_sysfb_device *sysfb = &cdev->sysfb;	struct drm_device *dev = &sysfb->dev;	const struct drm_format_info *format = sysfb->fb_format;	unsigned int width = sysfb->fb_mode.hdisplay;	unsigned int height = sysfb->fb_mode.vdisplay;	struct drm_plane *primary_plane;	struct drm_crtc *crtc;	struct drm_encoder *encoder;	struct drm_connector *connector;	size_t nformats;	int ret; 	ret = drmm_mode_config_init(dev);	if (ret)		return ret; 	dev->mode_config.min_width = width;	dev->mode_config.max_width = max_t(unsigned int, width, DRM_SHADOW_PLANE_MAX_WIDTH);	dev->mode_config.min_height = height;	dev->mode_config.max_height = max_t(unsigned int, height, DRM_SHADOW_PLANE_MAX_HEIGHT);	dev->mode_config.funcs = &corebootdrm_mode_config_funcs;	dev->mode_config.preferred_depth = format->depth; 	/* Primary plane */ 	nformats = drm_sysfb_build_fourcc_list(dev, &format->format, 1,					       cdev->formats, ARRAY_SIZE(cdev->formats)); 	primary_plane = &cdev->primary_plane;	ret = drm_universal_plane_init(dev, primary_plane, 0, &corebootdrm_primary_plane_funcs,				       cdev->formats, nformats,				       corebootdrm_primary_plane_format_modifiers,				       DRM_PLANE_TYPE_PRIMARY, NULL);	if (ret)		return ret;	drm_plane_helper_add(primary_plane, &corebootdrm_primary_plane_helper_funcs);	drm_plane_enable_fb_damage_clips(primary_plane); 	/* CRTC */ 	crtc = &cdev->crtc;	ret = drm_crtc_init_with_planes(dev, crtc, primary_plane, NULL,					&corebootdrm_crtc_funcs, NULL);	if (ret)		return ret;	drm_crtc_helper_add(crtc, &corebootdrm_crtc_helper_funcs); 	/* Encoder */ 	encoder = &cdev->encoder;	ret = drm_encoder_init(dev, encoder, &corebootdrm_encoder_funcs,			       DRM_MODE_ENCODER_NONE, NULL);	if (ret)		return ret;	encoder->possible_crtcs = drm_crtc_mask(crtc); 	/* Connector */ 	connector = &cdev->connector;	ret = drm_connector_init(dev, connector, &corebootdrm_connector_funcs,				 DRM_MODE_CONNECTOR_Unknown);	if (ret)		return ret;	drm_connector_helper_add(connector, &corebootdrm_connector_helper_funcs);	drm_connector_set_panel_orientation_with_quirk(connector, orientation,						       width, height); 	ret = drm_connector_attach_encoder(connector, encoder);	if (ret)		return ret; 	return 0;} /* * DRM driver */ DEFINE_DRM_GEM_FOPS(corebootdrm_fops); static struct drm_driver corebootdrm_drm_driver = {	DRM_GEM_SHMEM_DRIVER_OPS,	DRM_FBDEV_SHMEM_DRIVER_OPS,	.name			= DRIVER_NAME,	.desc			= DRIVER_DESC,	.major			= DRIVER_MAJOR,	.minor			= DRIVER_MINOR,	.driver_features	= DRIVER_ATOMIC | DRIVER_GEM | DRIVER_MODESET,	.fops			= &corebootdrm_fops,}; /* * Coreboot driver */ static int corebootdrm_pm_suspend(struct device *dev){	struct corebootdrm_device *cdev = dev_get_drvdata(dev);	struct drm_device *drm = &cdev->sysfb.dev; 	return drm_mode_config_helper_suspend(drm);} static int corebootdrm_pm_resume(struct device *dev){	struct corebootdrm_device *cdev = dev_get_drvdata(dev);	struct drm_device *drm = &cdev->sysfb.dev; 	return drm_mode_config_helper_resume(drm);} static DEFINE_SIMPLE_DEV_PM_OPS(corebootdrm_pm_ops, corebootdrm_pm_suspend, corebootdrm_pm_resume); static int corebootdrm_probe(struct platform_device *pdev){	const struct lb_framebuffer *fb = dev_get_platdata(&pdev->dev);	struct corebootdrm_device *cdev;	struct drm_sysfb_device *sysfb;	struct drm_device *dev;	const struct drm_format_info *format;	int width, height, pitch;	resource_size_t size;	phys_addr_t address;	enum drm_panel_orientation orientation;	struct resource *res, *mem = NULL;	struct resource aperture;	void __iomem *screen_base;	int ret; 	cdev = devm_drm_dev_alloc(&pdev->dev, &corebootdrm_drm_driver,				  struct corebootdrm_device, sysfb.dev);	if (IS_ERR(cdev))		return PTR_ERR(cdev);	platform_set_drvdata(pdev, cdev); 	sysfb = &cdev->sysfb;	dev = &sysfb->dev; 	if (!fb) {		drm_err(dev, "coreboot framebuffer not found\n");		return -EINVAL;	} else if (!LB_FRAMEBUFFER_HAS_LFB(fb)) {		drm_err(dev, "coreboot framebuffer entry too small\n");		return -EINVAL;	} 	/*	 * Hardware settings	 */ 	format = corebootdrm_get_format_fb(dev, fb);	if (!format)		return -EINVAL;	width = corebootdrm_get_width_fb(dev, fb);	if (width < 0)		return width;	height = corebootdrm_get_height_fb(dev, fb);	if (height < 0)		return height;	pitch = corebootdrm_get_pitch_fb(dev, format, width, fb);	if (pitch < 0)		return pitch;	size = corebootdrm_get_size_fb(dev, height, pitch, fb);	if (!size)		return -EINVAL;	address = corebootdrm_get_address_fb(dev, size, fb);	if (!address)		return -EINVAL;	orientation = corebootdrm_get_orientation_fb(dev, fb); 	sysfb->fb_mode = drm_sysfb_mode(width, height, 0, 0);	sysfb->fb_format = format;	sysfb->fb_pitch = pitch; 	drm_dbg(dev, "display mode={" DRM_MODE_FMT "}\n", DRM_MODE_ARG(&sysfb->fb_mode));	drm_dbg(dev, "framebuffer format=%p4cc, size=%dx%d, pitch=%d byte\n",		&format->format, width, height, pitch); 	/*	 * Memory management	 */ 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);	if (!res) {		drm_err(dev, "memory resource not found\n");		return -EINVAL;	} 	mem = devm_request_mem_region(&pdev->dev, res->start, resource_size(res),				      dev->driver->name);	if (!mem) {		drm_warn(dev, "could not acquire memory resource at %pr\n", res);		/*		 * We cannot make this fatal. Sometimes this comes from magic		 * spaces our resource handlers simply don't know about. Use		 * the memory resource as-is and try to map that instead.		 */		mem = res;	} 	drm_dbg(dev, "using memory resource at %pr\n", mem); 	aperture = DEFINE_RES_MEM(address, size);	if (!resource_contains(mem, &aperture)) {		drm_err(dev, "framebuffer aperture at invalid memory range %pr\n", &aperture);		return -EINVAL;	} 	ret = devm_aperture_acquire_for_platform_device(pdev, address, size);	if (ret) {		drm_err(dev, "could not acquire framebuffer aperture: %d\n", ret);		return ret;	} 	screen_base = devm_ioremap_wc(&pdev->dev, address, size);	if (!screen_base)		return -ENOMEM; 	iosys_map_set_vaddr_iomem(&sysfb->fb_addr, screen_base); 	/*	 * DRM mode setting and registration	 */ 	ret = corebootdrm_mode_config_init(cdev, orientation);	if (ret)		return ret; 	drm_mode_config_reset(dev); 	ret = drm_dev_register(dev, 0);	if (ret)		return ret; 	drm_client_setup(dev, sysfb->fb_format); 	return 0;} static void corebootdrm_remove(struct platform_device *pdev){	struct corebootdrm_device *cdev = platform_get_drvdata(pdev);	struct drm_device *dev = &cdev->sysfb.dev; 	drm_dev_unplug(dev);} static struct platform_driver corebootdrm_platform_driver = {	.driver = {		.name = "coreboot-framebuffer",		.pm = pm_sleep_ptr(&corebootdrm_pm_ops),	},	.probe = corebootdrm_probe,	.remove = corebootdrm_remove,}; module_platform_driver(corebootdrm_platform_driver); MODULE_DESCRIPTION(DRIVER_DESC);MODULE_LICENSE("GPL");