[PATCH v5 1/5] drm/ofdrm: Add ofdrm for Open Firmware framebuffers

Michal Suchánek msuchanek at suse.de
Sat Nov 19 15:25:35 UTC 2022


Hello,

On Tue, Oct 11, 2022 at 05:07:08PM +0200, Thomas Zimmermann wrote:
> Open Firmware provides basic display output via the 'display' node.
> DT platform code already provides a device that represents the node's
> framebuffer. Add a DRM driver for the device. The display mode and
> color format is pre-initialized by the system's firmware. Runtime
> modesetting via DRM is not possible. The display is useful during
> early boot stages or as error fallback.
> 
> Similar functionality is already provided by fbdev's offb driver,
> which is insufficient for modern userspace. The old driver includes
> support for BootX device tree, which can be found on old 32-bit
> PowerPC Macintosh systems. If these are still in use, the
> functionality can be added to ofdrm or implemented in a new
> driver. As with simpledrm, the fbdev driver cannot be selected if
> ofdrm is already enabled.
> 
> Two notable points about the driver:
> 
>  * Reading the framebuffer aperture from the device tree is not
> reliable on all systems. Ofdrm takes the heuristics and a comment
> from offb to pick the correct range.
> 
>  * No resource management may be tied to the underlying PCI device.
> Otherwise the handover to the native driver will fail with a resource
> conflict. PCI management is therefore done as part of the platform
> device's cleanup.
> 
> The driver has been tested on qemu's ppc64le emulation. The device
> hand-over has been tested with bochs.
> 
> v5:
> 	* use drm_atomic_helper_check_crtc_primary_plane()
> v4:
> 	* set preferred depth to the correct value
> 	* set bpp value for console emulation
> 	* output scanout-buffer parameters with drm_dbg()
> v3:
> 	* reintegrate FWFB helpers into ofdrm
> 	* use damage iterator
> 	* sync GEM BOs with drm_gem_fb_{begin,end}_cpu_access()
> 	* fix various atomic_check helpers
> 	* remove CRTC atomic_{enable,disable} (Javier)
> 	* compute stride with drm_format_info_min_pitch() (Daniel)
> v2:
> 	* removed simple-pipe helpers
> 	* built driver on top of FWFB helpers
> 	* merged all init code into single function
> 	* make PCI support optional (Michal)
> 	* support COMPILE_TEST (Javier)
> 
> Signed-off-by: Thomas Zimmermann <tzimmermann at suse.de>
> Reviewed-by: Javier Martinez Canillas <javierm at redhat.com>
> 
> convert
> ---
>  MAINTAINERS                   |   1 +
>  drivers/gpu/drm/tiny/Kconfig  |  13 +
>  drivers/gpu/drm/tiny/Makefile |   1 +
>  drivers/gpu/drm/tiny/ofdrm.c  | 763 ++++++++++++++++++++++++++++++++++
>  drivers/video/fbdev/Kconfig   |   1 +
>  5 files changed, 779 insertions(+)
>  create mode 100644 drivers/gpu/drm/tiny/ofdrm.c
> 
> diff --git a/MAINTAINERS b/MAINTAINERS
> index f07a8bf8744f..7c3bb04bd08e 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -6656,6 +6656,7 @@ L:	dri-devel at lists.freedesktop.org
>  S:	Maintained
>  T:	git git://anongit.freedesktop.org/drm/drm-misc
>  F:	drivers/gpu/drm/drm_aperture.c
> +F:	drivers/gpu/drm/tiny/ofdrm.c
>  F:	drivers/gpu/drm/tiny/simpledrm.c
>  F:	drivers/video/aperture.c
>  F:	include/drm/drm_aperture.h
> diff --git a/drivers/gpu/drm/tiny/Kconfig b/drivers/gpu/drm/tiny/Kconfig
> index 565957264875..a300b03a3c7a 100644
> --- a/drivers/gpu/drm/tiny/Kconfig
> +++ b/drivers/gpu/drm/tiny/Kconfig
> @@ -51,6 +51,19 @@ config DRM_GM12U320
>  	 This is a KMS driver for projectors which use the GM12U320 chipset
>  	 for video transfer over USB2/3, such as the Acer C120 mini projector.
>  
> +config DRM_OFDRM
> +	tristate "Open Firmware display driver"
> +	depends on DRM && OF && (PPC || COMPILE_TEST)
> +	select APERTURE_HELPERS
> +	select DRM_GEM_SHMEM_HELPER
> +	select DRM_KMS_HELPER
> +	help
> +	  DRM driver for Open Firmware framebuffers.
> +
> +	  This driver assumes that the display hardware has been initialized
> +	  by the Open Firmware before the kernel boots. Scanout buffer, size,
> +	  and display format must be provided via device tree.
> +
>  config DRM_PANEL_MIPI_DBI
>  	tristate "DRM support for MIPI DBI compatible panels"
>  	depends on DRM && SPI
> diff --git a/drivers/gpu/drm/tiny/Makefile b/drivers/gpu/drm/tiny/Makefile
> index 1d9d6227e7ab..76dde89a044b 100644
> --- a/drivers/gpu/drm/tiny/Makefile
> +++ b/drivers/gpu/drm/tiny/Makefile
> @@ -4,6 +4,7 @@ obj-$(CONFIG_DRM_ARCPGU)		+= arcpgu.o
>  obj-$(CONFIG_DRM_BOCHS)			+= bochs.o
>  obj-$(CONFIG_DRM_CIRRUS_QEMU)		+= cirrus.o
>  obj-$(CONFIG_DRM_GM12U320)		+= gm12u320.o
> +obj-$(CONFIG_DRM_OFDRM)			+= ofdrm.o
>  obj-$(CONFIG_DRM_PANEL_MIPI_DBI)	+= panel-mipi-dbi.o
>  obj-$(CONFIG_DRM_SIMPLEDRM)		+= simpledrm.o
>  obj-$(CONFIG_TINYDRM_HX8357D)		+= hx8357d.o
> diff --git a/drivers/gpu/drm/tiny/ofdrm.c b/drivers/gpu/drm/tiny/ofdrm.c
> new file mode 100644
> index 000000000000..96a46078ade8
> --- /dev/null
> +++ b/drivers/gpu/drm/tiny/ofdrm.c
> @@ -0,0 +1,763 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +
> +#include <linux/of_address.h>
> +#include <linux/pci.h>
> +#include <linux/platform_device.h>
> +
> +#include <drm/drm_aperture.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_fb_helper.h>
> +#include <drm/drm_format_helper.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_vtables.h>
> +#include <drm/drm_plane_helper.h>
> +#include <drm/drm_probe_helper.h>
> +#include <drm/drm_simple_kms_helper.h>
> +
> +#define DRIVER_NAME	"ofdrm"
> +#define DRIVER_DESC	"DRM driver for OF platform devices"
> +#define DRIVER_DATE	"20220501"
> +#define DRIVER_MAJOR	1
> +#define DRIVER_MINOR	0
> +
> +/*
> + * Helpers for display nodes
> + */
> +
> +static int display_get_validated_int(struct drm_device *dev, const char *name, uint32_t value)
> +{
> +	if (value > INT_MAX) {
> +		drm_err(dev, "invalid framebuffer %s of %u\n", name, value);
> +		return -EINVAL;
> +	}
> +	return (int)value;
> +}
> +
> +static int display_get_validated_int0(struct drm_device *dev, const char *name, uint32_t value)
> +{
> +	if (!value) {
> +		drm_err(dev, "invalid framebuffer %s of %u\n", name, value);
> +		return -EINVAL;
> +	}
> +	return display_get_validated_int(dev, name, value);
> +}
> +
> +static const struct drm_format_info *display_get_validated_format(struct drm_device *dev,
> +								  u32 depth)
> +{
> +	const struct drm_format_info *info;
> +	u32 format;
> +
> +	switch (depth) {
> +	case 8:
> +		format = drm_mode_legacy_fb_format(8, 8);
> +		break;
> +	case 15:
> +	case 16:
> +		format = drm_mode_legacy_fb_format(16, depth);
> +		break;
> +	case 32:
> +		format = drm_mode_legacy_fb_format(32, 24);
> +		break;
> +	default:
> +		drm_err(dev, "unsupported framebuffer depth %u\n", depth);
> +		return ERR_PTR(-EINVAL);
> +	}
> +
> +	info = drm_format_info(format);
> +	if (!info) {
> +		drm_err(dev, "cannot find framebuffer format for depth %u\n", depth);
> +		return ERR_PTR(-EINVAL);
> +	}
> +
> +	return info;
> +}
> +
> +static int display_read_u32_of(struct drm_device *dev, struct device_node *of_node,
> +			       const char *name, u32 *value)
> +{
> +	int ret = of_property_read_u32(of_node, name, value);
> +
> +	if (ret)
> +		drm_err(dev, "cannot parse framebuffer %s: error %d\n", name, ret);
> +	return ret;
> +}
> +
> +static int display_get_width_of(struct drm_device *dev, struct device_node *of_node)
> +{
> +	u32 width;
> +	int ret = display_read_u32_of(dev, of_node, "width", &width);
> +
> +	if (ret)
> +		return ret;
> +	return display_get_validated_int0(dev, "width", width);
> +}
> +
> +static int display_get_height_of(struct drm_device *dev, struct device_node *of_node)
> +{
> +	u32 height;
> +	int ret = display_read_u32_of(dev, of_node, "height", &height);
> +
> +	if (ret)
> +		return ret;
> +	return display_get_validated_int0(dev, "height", height);
> +}
> +
> +static int display_get_depth_of(struct drm_device *dev, struct device_node *of_node)
> +{
> +	u32 depth;
> +	int ret = display_read_u32_of(dev, of_node, "depth", &depth);
> +
> +	if (ret)
> +		return ret;
> +	return display_get_validated_int0(dev, "depth", depth);
> +}
> +
> +static int display_get_linebytes_of(struct drm_device *dev, struct device_node *of_node)
> +{
> +	u32 linebytes;
> +	int ret = display_read_u32_of(dev, of_node, "linebytes", &linebytes);
> +
> +	if (ret)
> +		return ret;
> +	return display_get_validated_int(dev, "linebytes", linebytes);
> +}
> +
> +static u64 display_get_address_of(struct drm_device *dev, struct device_node *of_node)
> +{
> +	u32 address;
> +	int ret;
> +
> +	/*
> +	 * Not all devices provide an address property, it's not
> +	 * a bug if this fails. The driver will try to find the
> +	 * framebuffer base address from the device's memory regions.
> +	 */
> +	ret = of_property_read_u32(of_node, "address", &address);
> +	if (ret)
> +		return OF_BAD_ADDR;
> +
> +	return address;
> +}
> +
> +/*
> + * Open Firmware display device
> + */
> +
> +struct ofdrm_device {
> +	struct drm_device dev;
> +	struct platform_device *pdev;
> +
> +	/* firmware-buffer settings */
> +	struct iosys_map screen_base;
> +	struct drm_display_mode mode;
> +	const struct drm_format_info *format;
> +	unsigned int pitch;
> +
> +	/* modesetting */
> +	uint32_t formats[8];
> +	struct drm_plane primary_plane;
> +	struct drm_crtc crtc;
> +	struct drm_encoder encoder;
> +	struct drm_connector connector;
> +};
> +
> +static struct ofdrm_device *ofdrm_device_of_dev(struct drm_device *dev)
> +{
> +	return container_of(dev, struct ofdrm_device, dev);
> +}
> +
> +/*
> + * Hardware
> + */
> +
> +#if defined(CONFIG_PCI)
> +static struct pci_dev *display_get_pci_dev_of(struct drm_device *dev, struct device_node *of_node)
> +{
> +	const __be32 *vendor_p, *device_p;
> +	u32 vendor, device;
> +	struct pci_dev *pcidev;
> +
> +	vendor_p = of_get_property(of_node, "vendor-id", NULL);
> +	if (!vendor_p)
> +		return ERR_PTR(-ENODEV);
> +	vendor = be32_to_cpup(vendor_p);
> +
> +	device_p = of_get_property(of_node, "device-id", NULL);
> +	if (!device_p)
> +		return ERR_PTR(-ENODEV);
> +	device = be32_to_cpup(device_p);
> +
> +	pcidev = pci_get_device(vendor, device, NULL);
> +	if (!pcidev)
> +		return ERR_PTR(-ENODEV);
> +
> +	return pcidev;
> +}
> +
> +static void ofdrm_pci_release(void *data)
> +{
> +	struct pci_dev *pcidev = data;
> +
> +	pci_disable_device(pcidev);
> +}
> +
> +static int ofdrm_device_init_pci(struct ofdrm_device *odev)
> +{
> +	struct drm_device *dev = &odev->dev;
> +	struct platform_device *pdev = to_platform_device(dev->dev);
> +	struct device_node *of_node = pdev->dev.of_node;
> +	struct pci_dev *pcidev;
> +	int ret;
> +
> +	/*
> +	 * Never use pcim_ or other managed helpers on the returned PCI
> +	 * device. Otherwise, probing the native driver will fail for
> +	 * resource conflicts. PCI-device management has to be tied to
> +	 * the lifetime of the platform device until the native driver
> +	 * takes over.
> +	 */
> +	pcidev = display_get_pci_dev_of(dev, of_node);
> +	if (IS_ERR(pcidev))
> +		return 0; /* no PCI device found; ignore the error */
> +
> +	ret = pci_enable_device(pcidev);
> +	if (ret) {
> +		drm_err(dev, "pci_enable_device(%s) failed: %d\n",
> +			dev_name(&pcidev->dev), ret);
> +		return ret;
> +	}
> +	ret = devm_add_action_or_reset(&pdev->dev, ofdrm_pci_release, pcidev);
> +	if (ret)
> +		return ret;
> +
> +	return 0;
> +}
> +#else
> +static int ofdrm_device_init_pci(struct ofdrm_device *odev)
> +{
> +	return 0;
> +}
> +#endif
> +
> +/*
> + *  OF display settings
> + */
> +
> +static struct resource *ofdrm_find_fb_resource(struct ofdrm_device *odev,
> +					       struct resource *fb_res)
> +{
> +	struct platform_device *pdev = to_platform_device(odev->dev.dev);
> +	struct resource *res, *max_res = NULL;
> +	u32 i;
> +
> +	for (i = 0; pdev->num_resources; ++i) {
> +		res = platform_get_resource(pdev, IORESOURCE_MEM, i);
> +		if (!res)
> +			break; /* all resources processed */
> +		if (resource_size(res) < resource_size(fb_res))
> +			continue; /* resource too small */
> +		if (fb_res->start && resource_contains(res, fb_res))
> +			return res; /* resource contains framebuffer */
> +		if (!max_res || resource_size(res) > resource_size(max_res))
> +			max_res = res; /* store largest resource as fallback */
> +	}
> +
> +	return max_res;
> +}
> +
> +/*
> + * Modesetting
> + */
> +
> +/*
> + * Support all formats of OF display and maybe more; in order
> + * of preference. The display's update function will do any
> + * conversion necessary.
> + *
> + * TODO: Add blit helpers for remaining formats and uncomment
> + *       constants.
> + */
> +static const uint32_t ofdrm_primary_plane_formats[] = {
> +	DRM_FORMAT_XRGB8888,
> +	DRM_FORMAT_RGB565,
> +	//DRM_FORMAT_XRGB1555,
> +	//DRM_FORMAT_C8,
> +};
> +
> +static const uint64_t ofdrm_primary_plane_format_modifiers[] = {
> +	DRM_FORMAT_MOD_LINEAR,
> +	DRM_FORMAT_MOD_INVALID
> +};
> +
> +static int ofdrm_primary_plane_helper_atomic_check(struct drm_plane *plane,
> +						   struct drm_atomic_state *new_state)
> +{
> +	struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(new_state, plane);
> +	struct drm_crtc *new_crtc = new_plane_state->crtc;
> +	struct drm_crtc_state *new_crtc_state = NULL;
> +
> +	if (new_crtc)
> +		new_crtc_state = drm_atomic_get_new_crtc_state(new_state, new_plane_state->crtc);
> +
> +	return drm_atomic_helper_check_plane_state(new_plane_state, new_crtc_state,
> +						   DRM_PLANE_NO_SCALING,
> +						   DRM_PLANE_NO_SCALING,
> +						   false, false);
> +}
> +
> +static void ofdrm_primary_plane_helper_atomic_update(struct drm_plane *plane,
> +						     struct drm_atomic_state *state)
> +{
> +	struct drm_device *dev = plane->dev;
> +	struct ofdrm_device *odev = ofdrm_device_of_dev(dev);
> +	struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane);
> +	struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane);
> +	struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(plane_state);
> +	struct drm_framebuffer *fb = plane_state->fb;
> +	unsigned int dst_pitch = odev->pitch;
> +	const struct drm_format_info *dst_format = odev->format;
> +	struct drm_atomic_helper_damage_iter iter;
> +	struct drm_rect damage;
> +	int ret, idx;
> +
> +	ret = drm_gem_fb_begin_cpu_access(fb, DMA_FROM_DEVICE);
> +	if (ret)
> +		return;
> +
> +	if (!drm_dev_enter(dev, &idx))
> +		goto out_drm_gem_fb_end_cpu_access;
> +
> +	drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state);
> +	drm_atomic_for_each_plane_damage(&iter, &damage) {
> +		struct iosys_map dst = odev->screen_base;
> +		struct drm_rect dst_clip = plane_state->dst;
> +
> +		if (!drm_rect_intersect(&dst_clip, &damage))
> +			continue;
> +
> +		iosys_map_incr(&dst, drm_fb_clip_offset(dst_pitch, dst_format, &dst_clip));
> +		drm_fb_blit(&dst, &dst_pitch, dst_format->format, shadow_plane_state->data, fb,
> +			    &damage);
> +	}
> +
> +	drm_dev_exit(idx);
> +out_drm_gem_fb_end_cpu_access:
> +	drm_gem_fb_end_cpu_access(fb, DMA_FROM_DEVICE);
> +}
> +
> +static void ofdrm_primary_plane_helper_atomic_disable(struct drm_plane *plane,
> +						      struct drm_atomic_state *state)
> +{
> +	struct drm_device *dev = plane->dev;
> +	struct ofdrm_device *odev = ofdrm_device_of_dev(dev);
> +	struct iosys_map dst = odev->screen_base;
> +	struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane);
> +	void __iomem *dst_vmap = dst.vaddr_iomem; /* TODO: Use mapping abstraction */
> +	unsigned int dst_pitch = odev->pitch;
> +	const struct drm_format_info *dst_format = odev->format;
> +	struct drm_rect dst_clip;
> +	unsigned long lines, linepixels, i;
> +	int idx;
> +
> +	drm_rect_init(&dst_clip,
> +		      plane_state->src_x >> 16, plane_state->src_y >> 16,
> +		      plane_state->src_w >> 16, plane_state->src_h >> 16);
> +
> +	lines = drm_rect_height(&dst_clip);
> +	linepixels = drm_rect_width(&dst_clip);
> +
> +	if (!drm_dev_enter(dev, &idx))
> +		return;
> +
> +	/* Clear buffer to black if disabled */
> +	dst_vmap += drm_fb_clip_offset(dst_pitch, dst_format, &dst_clip);
> +	for (i = 0; i < lines; ++i) {
> +		memset_io(dst_vmap, 0, linepixels * dst_format->cpp[0]);
> +		dst_vmap += dst_pitch;
> +	}
> +
> +	drm_dev_exit(idx);
> +}
> +
> +static const struct drm_plane_helper_funcs ofdrm_primary_plane_helper_funcs = {
> +	DRM_GEM_SHADOW_PLANE_HELPER_FUNCS,
> +	.atomic_check = ofdrm_primary_plane_helper_atomic_check,
> +	.atomic_update = ofdrm_primary_plane_helper_atomic_update,
> +	.atomic_disable = ofdrm_primary_plane_helper_atomic_disable,
> +};
> +
> +static const struct drm_plane_funcs ofdrm_primary_plane_funcs = {
> +	.update_plane = drm_atomic_helper_update_plane,
> +	.disable_plane = drm_atomic_helper_disable_plane,
> +	.destroy = drm_plane_cleanup,
> +	DRM_GEM_SHADOW_PLANE_FUNCS,
> +};
> +
> +static enum drm_mode_status ofdrm_crtc_helper_mode_valid(struct drm_crtc *crtc,
> +							 const struct drm_display_mode *mode)
> +{
> +	struct ofdrm_device *odev = ofdrm_device_of_dev(crtc->dev);
> +
> +	return drm_crtc_helper_mode_valid_fixed(crtc, mode, &odev->mode);
> +}
> +
> +static int ofdrm_crtc_helper_atomic_check(struct drm_crtc *crtc,
> +					  struct drm_atomic_state *new_state)
> +{
> +	struct drm_crtc_state *new_crtc_state = drm_atomic_get_new_crtc_state(new_state, crtc);
> +
> +	if (!new_crtc_state->enable)
> +		return 0;
> +
> +	return drm_atomic_helper_check_crtc_primary_plane(new_crtc_state);
> +}
> +
> +/*
> + * The CRTC is always enabled. Screen updates are performed by
> + * the primary plane's atomic_update function. Disabling clears
> + * the screen in the primary plane's atomic_disable function.
> + */
> +static const struct drm_crtc_helper_funcs ofdrm_crtc_helper_funcs = {
> +	.mode_valid = ofdrm_crtc_helper_mode_valid,
> +	.atomic_check = ofdrm_crtc_helper_atomic_check,
> +};
> +
> +static const struct drm_crtc_funcs ofdrm_crtc_funcs = {
> +	.reset = drm_atomic_helper_crtc_reset,
> +	.destroy = drm_crtc_cleanup,
> +	.set_config = drm_atomic_helper_set_config,
> +	.page_flip = drm_atomic_helper_page_flip,
> +	.atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
> +	.atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
> +};
> +
> +static int ofdrm_connector_helper_get_modes(struct drm_connector *connector)
> +{
> +	struct ofdrm_device *odev = ofdrm_device_of_dev(connector->dev);
> +
> +	return drm_connector_helper_get_modes_fixed(connector, &odev->mode);
> +}
> +
> +static const struct drm_connector_helper_funcs ofdrm_connector_helper_funcs = {
> +	.get_modes = ofdrm_connector_helper_get_modes,
> +};
> +
> +static const struct drm_connector_funcs ofdrm_connector_funcs = {
> +	.reset = drm_atomic_helper_connector_reset,
> +	.fill_modes = drm_helper_probe_single_connector_modes,
> +	.destroy = drm_connector_cleanup,
> +	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
> +	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
> +};
> +
> +static const struct drm_mode_config_funcs ofdrm_mode_config_funcs = {
> +	.fb_create = drm_gem_fb_create_with_dirty,
> +	.atomic_check = drm_atomic_helper_check,
> +	.atomic_commit = drm_atomic_helper_commit,
> +};
> +
> +/*
> + * Init / Cleanup
> + */
> +
> +static struct drm_display_mode ofdrm_mode(unsigned int width, unsigned int height)
> +{
> +	/*
> +	 * Assume a monitor resolution of 96 dpi to
> +	 * get a somewhat reasonable screen size.
> +	 */
> +	const struct drm_display_mode mode = {
> +		DRM_MODE_INIT(60, width, height,
> +			      DRM_MODE_RES_MM(width, 96ul),
> +			      DRM_MODE_RES_MM(height, 96ul))
> +	};
> +
> +	return mode;
> +}
> +
> +static struct ofdrm_device *ofdrm_device_create(struct drm_driver *drv,
> +						struct platform_device *pdev)
> +{
> +	struct device_node *of_node = pdev->dev.of_node;
> +	struct ofdrm_device *odev;
> +	struct drm_device *dev;
> +	int width, height, depth, linebytes;
> +	const struct drm_format_info *format;
> +	u64 address;
> +	resource_size_t fb_size, fb_base, fb_pgbase, fb_pgsize;
> +	struct resource *res, *mem;
> +	void __iomem *screen_base;
> +	struct drm_plane *primary_plane;
> +	struct drm_crtc *crtc;
> +	struct drm_encoder *encoder;
> +	struct drm_connector *connector;
> +	unsigned long max_width, max_height;
> +	size_t nformats;
> +	int ret;
> +
> +	odev = devm_drm_dev_alloc(&pdev->dev, drv, struct ofdrm_device, dev);
> +	if (IS_ERR(odev))
> +		return ERR_CAST(odev);
> +	dev = &odev->dev;
> +	platform_set_drvdata(pdev, dev);
> +
> +	ret = ofdrm_device_init_pci(odev);
> +	if (ret)
> +		return ERR_PTR(ret);
> +
> +	/*
> +	 * OF display-node settings
> +	 */
> +
> +	width = display_get_width_of(dev, of_node);
> +	if (width < 0)
> +		return ERR_PTR(width);
> +	height = display_get_height_of(dev, of_node);
> +	if (height < 0)
> +		return ERR_PTR(height);
> +	depth = display_get_depth_of(dev, of_node);
> +	if (depth < 0)
> +		return ERR_PTR(depth);
> +	linebytes = display_get_linebytes_of(dev, of_node);
> +	if (linebytes < 0)
> +		return ERR_PTR(linebytes);
> +
> +	format = display_get_validated_format(dev, depth);
> +	if (IS_ERR(format))
> +		return ERR_CAST(format);
> +	if (!linebytes) {
> +		linebytes = drm_format_info_min_pitch(format, 0, width);
> +		if (drm_WARN_ON(dev, !linebytes))
> +			return ERR_PTR(-EINVAL);
> +	}
> +
> +	fb_size = linebytes * height;
> +
> +	/*
> +	 * Try to figure out the address of the framebuffer. Unfortunately, Open
> +	 * Firmware doesn't provide a standard way to do so. All we can do is a
> +	 * dodgy heuristic that happens to work in practice.
> +	 *
> +	 * On most machines, the "address" property contains what we need, though
> +	 * not on Matrox cards found in IBM machines. What appears to give good
> +	 * results is to go through the PCI ranges and pick one that encloses the
> +	 * "address" property. If none match, we pick the largest.
> +	 */
> +	address = display_get_address_of(dev, of_node);
> +	if (address != OF_BAD_ADDR) {
> +		struct resource fb_res = DEFINE_RES_MEM(address, fb_size);
> +
> +		res = ofdrm_find_fb_resource(odev, &fb_res);
> +		if (!res)
> +			return ERR_PTR(-EINVAL);
> +		if (resource_contains(res, &fb_res))
> +			fb_base = address;
> +		else
> +			fb_base = res->start;
> +	} else {
> +		struct resource fb_res = DEFINE_RES_MEM(0u, fb_size);
> +
> +		res = ofdrm_find_fb_resource(odev, &fb_res);
> +		if (!res)
> +			return ERR_PTR(-EINVAL);
> +		fb_base = res->start;
> +	}
> +
> +	/*
> +	 * I/O resources
> +	 */
> +
> +	fb_pgbase = round_down(fb_base, PAGE_SIZE);
> +	fb_pgsize = fb_base - fb_pgbase + round_up(fb_size, PAGE_SIZE);
> +
> +	ret = devm_aperture_acquire_from_firmware(dev, fb_pgbase, fb_pgsize);
> +	if (ret) {
> +		drm_err(dev, "could not acquire memory range %pr: error %d\n", &res, ret);
> +		return ERR_PTR(ret);
> +	}
> +
> +	mem = devm_request_mem_region(&pdev->dev, fb_pgbase, fb_pgsize, drv->name);
> +	if (!mem) {
> +		drm_warn(dev, "could not acquire memory region %pr\n", &res);
> +		return ERR_PTR(-ENOMEM);
> +	}
> +
> +	screen_base = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
> +	if (!screen_base)
> +		return ERR_PTR(-ENOMEM);
> +
> +	/*
> +	 * Firmware framebuffer
> +	 */
> +
> +	iosys_map_set_vaddr_iomem(&odev->screen_base, screen_base);
> +	odev->mode = ofdrm_mode(width, height);
> +	odev->format = format;
> +	odev->pitch = linebytes;
> +
> +	drm_dbg(dev, "display mode={" DRM_MODE_FMT "}\n", DRM_MODE_ARG(&odev->mode));
> +	drm_dbg(dev, "framebuffer format=%p4cc, size=%dx%d, linebytes=%d byte\n",
> +		&format->format, width, height, linebytes);
> +
> +	/*
> +	 * Mode-setting pipeline
> +	 */
> +
> +	ret = drmm_mode_config_init(dev);
> +	if (ret)
> +		return ERR_PTR(ret);
> +
> +	max_width = max_t(unsigned long, width, DRM_SHADOW_PLANE_MAX_WIDTH);
> +	max_height = max_t(unsigned long, height, DRM_SHADOW_PLANE_MAX_HEIGHT);
> +
> +	dev->mode_config.min_width = width;
> +	dev->mode_config.max_width = max_width;
> +	dev->mode_config.min_height = height;
> +	dev->mode_config.max_height = max_height;
> +	dev->mode_config.funcs = &ofdrm_mode_config_funcs;
> +	switch (depth) {
> +	case 32:
> +		dev->mode_config.preferred_depth = 24;
> +		break;
> +	default:
> +		dev->mode_config.preferred_depth = depth;
> +		break;
> +	}
> +
> +	/* Primary plane */
> +
> +	nformats = drm_fb_build_fourcc_list(dev, &format->format, 1,
> +					    ofdrm_primary_plane_formats,
> +					    ARRAY_SIZE(ofdrm_primary_plane_formats),
> +					    odev->formats, ARRAY_SIZE(odev->formats));
> +
> +	primary_plane = &odev->primary_plane;
> +	ret = drm_universal_plane_init(dev, primary_plane, 0, &ofdrm_primary_plane_funcs,
> +				       odev->formats, nformats,
> +				       ofdrm_primary_plane_format_modifiers,
> +				       DRM_PLANE_TYPE_PRIMARY, NULL);
> +	if (ret)
> +		return ERR_PTR(ret);
> +	drm_plane_helper_add(primary_plane, &ofdrm_primary_plane_helper_funcs);
> +	drm_plane_enable_fb_damage_clips(primary_plane);
> +
> +	/* CRTC */
> +
> +	crtc = &odev->crtc;
> +	ret = drm_crtc_init_with_planes(dev, crtc, primary_plane, NULL,
> +					&ofdrm_crtc_funcs, NULL);
> +	if (ret)
> +		return ERR_PTR(ret);
> +	drm_crtc_helper_add(crtc, &ofdrm_crtc_helper_funcs);
> +
> +	/* Encoder */
> +
> +	encoder = &odev->encoder;
> +	ret = drm_simple_encoder_init(dev, encoder, DRM_MODE_ENCODER_NONE);
> +	if (ret)
> +		return ERR_PTR(ret);
> +	encoder->possible_crtcs = drm_crtc_mask(crtc);
> +
> +	/* Connector */
> +
> +	connector = &odev->connector;
> +	ret = drm_connector_init(dev, connector, &ofdrm_connector_funcs,
> +				 DRM_MODE_CONNECTOR_Unknown);
> +	if (ret)
> +		return ERR_PTR(ret);
> +	drm_connector_helper_add(connector, &ofdrm_connector_helper_funcs);
> +	drm_connector_set_panel_orientation_with_quirk(connector,
> +						       DRM_MODE_PANEL_ORIENTATION_UNKNOWN,
> +						       width, height);
> +
> +	ret = drm_connector_attach_encoder(connector, encoder);
> +	if (ret)
> +		return ERR_PTR(ret);
> +
> +	drm_mode_config_reset(dev);
> +
> +	return odev;
> +}
> +
> +/*
> + * DRM driver
> + */
> +
> +DEFINE_DRM_GEM_FOPS(ofdrm_fops);
> +
> +static struct drm_driver ofdrm_driver = {
> +	DRM_GEM_SHMEM_DRIVER_OPS,
> +	.name			= DRIVER_NAME,
> +	.desc			= DRIVER_DESC,
> +	.date			= DRIVER_DATE,
> +	.major			= DRIVER_MAJOR,
> +	.minor			= DRIVER_MINOR,
> +	.driver_features	= DRIVER_ATOMIC | DRIVER_GEM | DRIVER_MODESET,
> +	.fops			= &ofdrm_fops,
> +};
> +
> +/*
> + * Platform driver
> + */
> +
> +static int ofdrm_probe(struct platform_device *pdev)
> +{
> +	struct ofdrm_device *odev;
> +	struct drm_device *dev;
> +	int ret;
> +
> +	odev = ofdrm_device_create(&ofdrm_driver, pdev);
> +	if (IS_ERR(odev))
> +		return PTR_ERR(odev);
> +	dev = &odev->dev;
> +
> +	ret = drm_dev_register(dev, 0);
> +	if (ret)
> +		return ret;
> +
> +	/*
> +	 * FIXME: 24-bit color depth does not work reliably with a 32-bpp
> +	 * value. Force the bpp value of the scanout buffer's format.
> +	 */
> +	drm_fbdev_generic_setup(dev, drm_format_info_bpp(odev->format, 0));
> +
> +	return 0;
> +}
> +
> +static int ofdrm_remove(struct platform_device *pdev)
> +{
> +	struct drm_device *dev = platform_get_drvdata(pdev);
> +
> +	drm_dev_unplug(dev);
> +
> +	return 0;
> +}
> +
> +static const struct of_device_id ofdrm_of_match_display[] = {
> +	{ .compatible = "display", },
> +	{ },
> +};
> +MODULE_DEVICE_TABLE(of, ofdrm_of_match_display);
> +
> +static struct platform_driver ofdrm_platform_driver = {
> +	.driver = {
> +		.name = "of-display",
> +		.of_match_table = ofdrm_of_match_display,
> +	},
> +	.probe = ofdrm_probe,
> +	.remove = ofdrm_remove,
> +};
> +
> +module_platform_driver(ofdrm_platform_driver);
> +
> +MODULE_DESCRIPTION(DRIVER_DESC);
> +MODULE_LICENSE("GPL");
> diff --git a/drivers/video/fbdev/Kconfig b/drivers/video/fbdev/Kconfig
> index cfc55273dc5d..a98987aa2784 100644
> --- a/drivers/video/fbdev/Kconfig
> +++ b/drivers/video/fbdev/Kconfig
> @@ -455,6 +455,7 @@ config FB_ATARI
>  config FB_OF
>  	bool "Open Firmware frame buffer device support"
>  	depends on (FB = y) && PPC && (!PPC_PSERIES || PCI)
> +	depends on !DRM_OFDRM

This breaks build - see
https://lore.kernel.org/linux-kbuild/CAK7LNASBhTvzkjXuJDH8ePCVXnZ=GUYdNa-OU+QURbBp3oyEBQ@mail.gmail.com/

Thanks

Michal

>  	select APERTURE_HELPERS
>  	select FB_CFB_FILLRECT
>  	select FB_CFB_COPYAREA
> -- 
> 2.37.3
> 


More information about the dri-devel mailing list