Hi, please see my review below.
Am 07.10.22 um 14:49 schrieb Thierry Reding:
From: Thierry Reding <tred...@nvidia.com> Simple framebuffers can be set up in system memory, which cannot be requested and/or I/O remapped using the I/O resource helpers. Add a separate code path that obtains system memory framebuffers from the reserved memory region referenced in the memory-region property. v2: make screen base a struct iosys_map to avoid sparse warnings Signed-off-by: Thierry Reding <tred...@nvidia.com> --- drivers/gpu/drm/tiny/simpledrm.c | 177 ++++++++++++++++++++++++------- 1 file changed, 141 insertions(+), 36 deletions(-) diff --git a/drivers/gpu/drm/tiny/simpledrm.c b/drivers/gpu/drm/tiny/simpledrm.c index 18489779fb8a..cf36f67d22e4 100644 --- a/drivers/gpu/drm/tiny/simpledrm.c +++ b/drivers/gpu/drm/tiny/simpledrm.c @@ -2,6 +2,7 @@#include <linux/clk.h>#include <linux/of_clk.h> +#include <linux/of_reserved_mem.h> #include <linux/minmax.h> #include <linux/platform_data/simplefb.h> #include <linux/platform_device.h> @@ -207,7 +208,9 @@ struct simpledrm_device { unsigned int pitch;/* memory management */- void __iomem *screen_base; + struct iosys_map screen_base; + phys_addr_t sysmem_start; + size_t sysmem_size;
Please store a pointer to the struct reserved_mem here. If set, we use it; if NULL, we use the memory region as before.
/* modesetting */uint32_t formats[8]; @@ -441,6 +444,106 @@ static int simpledrm_device_init_regulators(struct simpledrm_device *sdev) } #endif+/*+ * Memory management + */ + +static int simpledrm_device_init_mm_sysmem(struct simpledrm_device *sdev, phys_addr_t start, + size_t size) +{ + struct drm_device *dev = &sdev->dev; + phys_addr_t end = start + size - 1; + void *screen_base; + + drm_info(dev, "using system memory framebuffer at [%pa-%pa]\n", &start, &end); + + screen_base = devm_memremap(dev->dev, start, size, MEMREMAP_WC); + if (!screen_base) + return -ENOMEM; + + iosys_map_set_vaddr(&sdev->screen_base, screen_base); + + return 0; +} + +static int simpledrm_device_init_mm_io(struct simpledrm_device *sdev, phys_addr_t start, + size_t size) +{ + struct drm_device *dev = &sdev->dev; + phys_addr_t end = start + size - 1; + void __iomem *screen_base; + struct resource *mem; + + drm_info(dev, "using I/O memory framebuffer at [%pa-%pa]\n", &start, &end); + + mem = devm_request_mem_region(dev->dev, start, size, sdev->dev.driver->name); + if (!mem) { + /* + * We cannot make this fatal. Sometimes this comes from magic + * spaces our resource handlers simply don't know about. Use + * the I/O-memory resource as-is and try to map that instead. + */ + drm_warn(dev, "could not acquire memory region [%pa-%pa]\n", &start, &end); + } else { + size = resource_size(mem); + start = mem->start; + } + + screen_base = devm_ioremap_wc(dev->dev, start, size); + if (!screen_base) + return -ENOMEM; + + iosys_map_set_vaddr_iomem(&sdev->screen_base, screen_base); + + return 0; +} + +static void simpledrm_device_exit_mm(void *data) +{ + struct simpledrm_device *sdev = data; + struct drm_device *dev = &sdev->dev; + + of_reserved_mem_device_release(dev->dev); +} + +static int simpledrm_device_init_mm(struct simpledrm_device *sdev) +{
No such _init_mm() helper please. Simply do everything in the _create() function.
+ int (*init)(struct simpledrm_device *sdev, phys_addr_t start, size_t size); + struct drm_device *dev = &sdev->dev; + struct platform_device *pdev = to_platform_device(dev->dev); + phys_addr_t start, end; + size_t size; + int ret; + + ret = of_reserved_mem_device_init_by_idx(dev->dev, dev->dev->of_node, 0);
Instead of doing our own lookup of the memory node, I'd prefer to keep this function. If we encasulate it, it's better than reinventing the wheel within this driver.
A number of helpers look-up the various properties from the device tree. They are at [1] and below. We should add a new helper that reads the memory node via of_reserved_mem_device_init_by_idx(). Here's some example code
struct reserved_mem *
simplefb_get_memory_of(drm_device dev, of_node node)
{
sdev = simpledrm_device_of_dev(dev)
ret = of_reserved_mem_device_init_by_idx()
if (ret)
return ERR_PTR()
ret = devm_add_action_or_reset(dev->dev,
simpledrm_device_exit_mm, sdev)
if (ret)
return ERR_PTR()
return sdev->rmem;
}
That wraps the rmem instance quite nicely and is similar to the rest of
the code. You can call this function within the else branch at [2].
Later in _create() where we map the I/O memory, branch depending on the returned value of rmem.
if (rmem) {
devm_aperture_acquire_from_firmware()
devm_memremap()
} else {
platform_get_resource()
devm_aperture_acquire_from_firmware()
devm_request_mem_region()
devm_ioremap_wc()
}
Don't bother with reducing the code size. The only call that is sharable
is devm_aperture_acquire_from_firmware(), which isn't worth the effort.
[1] https://elixir.bootlin.com/linux/v6.1-rc1/source/drivers/gpu/drm/tiny/simpledrm.c#L141 [2] https://elixir.bootlin.com/linux/v6.1-rc1/source/drivers/gpu/drm/tiny/simpledrm.c#L678
+ if (ret) { + struct resource *res; + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + if (!res) + return -EINVAL; + + init = simpledrm_device_init_mm_io; + size = resource_size(res); + start = res->start; + } else { + devm_add_action_or_reset(dev->dev, simpledrm_device_exit_mm, sdev); + init = simpledrm_device_init_mm_sysmem; + start = sdev->sysmem_start; + size = sdev->sysmem_size; + } + + end = start + size - 1; + + ret = devm_aperture_acquire_from_firmware(dev, start, size); + if (ret) { + drm_err(dev, "could not acquire memory range [%pa-%pa]: %d\n", &start, &end, ret); + return ret; + } + + return init(sdev, start, size); +} + /* * Modesetting */ @@ -491,15 +594,15 @@ static void simpledrm_primary_plane_helper_atomic_update(struct drm_plane *planedrm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state);drm_atomic_for_each_plane_damage(&iter, &damage) { - struct iosys_map dst = IOSYS_MAP_INIT_VADDR(sdev->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(sdev->pitch, sdev->format, &dst_clip));- drm_fb_blit(&dst, &sdev->pitch, sdev->format->format, shadow_plane_state->data, fb, - &damage); + iosys_map_incr(&sdev->screen_base, drm_fb_clip_offset(sdev->pitch, sdev->format, + &dst_clip)); + drm_fb_blit(&sdev->screen_base, &sdev->pitch, sdev->format->format, + shadow_plane_state->data, fb, &damage); }drm_dev_exit(idx);@@ -518,7 +621,7 @@ static void simpledrm_primary_plane_helper_atomic_disable(struct drm_plane *plan return;/* Clear screen to black if disabled */- memset_io(sdev->screen_base, 0, sdev->pitch * sdev->mode.vdisplay); + iosys_map_memset(&sdev->screen_base, 0, 0, sdev->pitch * sdev->mode.vdisplay);drm_dev_exit(idx);} @@ -635,8 +738,6 @@ static struct simpledrm_device *simpledrm_device_create(struct drm_driver *drv, struct drm_device *dev; int width, height, stride; const struct drm_format_info *format; - struct resource *res, *mem; - void __iomem *screen_base; struct drm_plane *primary_plane; struct drm_crtc *crtc; struct drm_encoder *encoder; @@ -706,35 +807,9 @@ static struct simpledrm_device *simpledrm_device_create(struct drm_driver *drv, drm_dbg(dev, "framebuffer format=%p4cc, size=%dx%d, stride=%d byte\n", &format->format, width, height, stride);- /*- * Memory management - */ - - res = platform_get_resource(pdev, IORESOURCE_MEM, 0); - if (!res) - return ERR_PTR(-EINVAL); - - ret = devm_aperture_acquire_from_firmware(dev, res->start, resource_size(res)); - if (ret) { - drm_err(dev, "could not acquire memory range %pr: error %d\n", res, ret); + ret = simpledrm_device_init_mm(sdev); + if (ret) return ERR_PTR(ret); - } - - mem = devm_request_mem_region(&pdev->dev, res->start, resource_size(res), drv->name); - if (!mem) { - /* - * We cannot make this fatal. Sometimes this comes from magic - * spaces our resource handlers simply don't know about. Use - * the I/O-memory resource as-is and try to map that instead. - */ - drm_warn(dev, "could not acquire memory region %pr\n", res); - mem = res; - } - - screen_base = devm_ioremap_wc(&pdev->dev, mem->start, resource_size(mem)); - if (!screen_base) - return ERR_PTR(-ENOMEM); - sdev->screen_base = screen_base;/** Modesetting @@ -878,5 +953,35 @@ static struct platform_driver simpledrm_platform_driver = {module_platform_driver(simpledrm_platform_driver); +static int simple_framebuffer_device_init(struct reserved_mem *rmem, struct device *dev)
'Simple-framebuffer' is the mechanism that provides the Linux platform device. And there's also a simplefb driver in fbdev.
The better name would be simpledrm_reserved_mem_device_init(). It makes it clear what this code belongs to.
+{
+ struct simpledrm_device *sdev = dev_get_drvdata(dev);
+
+ sdev->sysmem_start = rmem->base;
+ sdev->sysmem_size = rmem->size;
As mentioned, assign rmem directly. Should we warn here if platform_get_resource(pdev, IORESOURCE_MEM, 0) returns anything but NULL?
+ + return 0; +} + +static void simple_framebuffer_device_release(struct reserved_mem *rmem, struct device *dev)
simpledrm_reserved_mem_device_release()
+{
+}
I think the caller should be updated to support callbacks of NULL here.
+
+static const struct reserved_mem_ops simple_framebuffer_ops = {
simpledrm_reserved_mem_ops
+ .device_init = simple_framebuffer_device_init, + .device_release = simple_framebuffer_device_release, +}; + +static int simple_framebuffer_init(struct reserved_mem *rmem)
simpledrm_reserved_mem_init()
+{
+ pr_info("framebuffer memory at %pa, size %lu bytes\n", &rmem->base,
pr_debug() please.
+ (unsigned long)rmem->size); + + rmem->ops = &simple_framebuffer_ops; + + return 0; +} +RESERVEDMEM_OF_DECLARE(simple_framebuffer, "framebuffer", simple_framebuffer_init);
(simpledrm_reserved_mem, framebuffer, simpledrm_reserved_mem_init) , I guess. Best regards Thomas
+
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL v2");
-- Thomas Zimmermann Graphics Driver Developer SUSE Software Solutions Germany GmbH Maxfeldstr. 5, 90409 Nürnberg, Germany (HRB 36809, AG Nürnberg) Geschäftsführer: Ivo Totev
OpenPGP_signature
Description: OpenPGP digital signature
