On Fri, Sep 2, 2016 at 10:22 AM, David Herrmann dh.herrmann@gmail.com wrote:
There are several situations where we want hardware handover from an early boot GFX driver (e.g., vgacon, vesafb, efifb, simplefb) to a full fletched GFX driver (e.g., most DRM drivers). So far, we relied on remove_conflicting_framebuffers() to do this for us, however, this had a bunch of downsides:
o It only removes conflicting fbdev drivers. It does not drop vgacon, early boot console drivers, conflicting DRM drivers, etc.
o It only unloads the fbdev driver, it does not modify the underlying device or resources. In case of "screen_info" drivers (e.g., efifb) this is fine, since no resources are pinned. However, if the driver binds to a platform-device like "simple-framebuffer", we must make sure to unregister that device as well. Otherwise, pinned resources like IORESOURCE_MEM stay around, triggering WARN_ONs if the following driver requests those resources.
o It is only available if CONFIG_FB is selected.
This commit adds a new infrastructure that manages system-framebuffers (short: sysfb). The initial commit provides conflict-resolution for system-framebuffers. At its core it provides sysfb_evict_conflicts(), which implements conflict detection and removal for all known types of GFX driver hand-overs. So far, this includes platform-device removal, fbdev-firmware-device removal, vgacon removal and VBE detection. To further simplify the callers, it also provides helpers to figure out what hand-over to do, based on the device the new drivers binds to:
o PCI drivers can use sysfb_evict_conflicts_pci(), which will figure out the apertures automatically, and does VGA/VBE detection.
o Generic firmware drivers that might be shadowed at any address in memory can use sysfb_evict_conflicts_firmware(), basically removing *all* firmware framebuffers in effect.
This only adds the generic sysfb helpers. No users are converted, yet.
Signed-off-by: David Herrmann dh.herrmann@gmail.com
Reviewed-by: Tom Gundersen teg@jklm.no
drivers/video/Kconfig | 4 + drivers/video/Makefile | 1 + drivers/video/sysfb.c | 327 +++++++++++++++++++++++++++++++++++++++++++++++++ include/linux/sysfb.h | 34 +++++ 4 files changed, 366 insertions(+) create mode 100644 drivers/video/sysfb.c create mode 100644 include/linux/sysfb.h
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig index 3c20af9..56a8294 100644 --- a/drivers/video/Kconfig +++ b/drivers/video/Kconfig @@ -36,6 +36,10 @@ config VIDEOMODE_HELPERS config HDMI bool
+config SYSFB
boolselect DUMMY_CONSOLE if VTif VT source "drivers/video/console/Kconfig" endif diff --git a/drivers/video/Makefile b/drivers/video/Makefile index 9ad3c17..df7bd75 100644 --- a/drivers/video/Makefile +++ b/drivers/video/Makefile @@ -1,5 +1,6 @@ obj-$(CONFIG_VGASTATE) += vgastate.o obj-$(CONFIG_HDMI) += hdmi.o +obj-$(CONFIG_SYSFB) += sysfb.o
obj-$(CONFIG_VT) += console/ obj-$(CONFIG_LOGO) += logo/ diff --git a/drivers/video/sysfb.c b/drivers/video/sysfb.c new file mode 100644 index 0000000..00585c9 --- /dev/null +++ b/drivers/video/sysfb.c @@ -0,0 +1,327 @@ +/*
- Copyright (C) 2013-2016 Red Hat, Inc.
- This program is free software; you can redistribute it and/or modify it
- under the terms of the GNU Lesser General Public License as published by the
- Free Software Foundation; either version 2.1 of the License, or (at your
- option) any later version.
- */
+#define pr_fmt(fmt) "sysfb: " fmt +#include <linux/console.h> +#include <linux/device.h> +#include <linux/err.h> +#include <linux/export.h> +#include <linux/fb.h> +#include <linux/ioport.h> +#include <linux/kernel.h> +#include <linux/of.h> +#include <linux/of_platform.h> +#include <linux/pci.h> +#include <linux/platform_device.h> +#include <linux/slab.h> +#include <linux/sysfb.h> +#include <linux/vt.h>
+static bool sysfb_evict_match_resource(struct sysfb_evict_ctx *ctx,
struct resource *mem)+{
struct aperture *g;unsigned int i;for (i = 0; i < ctx->ap->count; ++i) {g = &ctx->ap->ranges[i];if (mem->start == g->base)return true;if (mem->start >= g->base && mem->end < g->base + g->size)return true;if ((ctx->flags & SYSFB_EVICT_VBE) && mem->start == 0xA0000)return true;}return false;+}
+static int sysfb_evict_platform_device(struct device *dev, void *userdata) +{
struct sysfb_evict_ctx *ctx = userdata;struct platform_device *pdev = to_platform_device(dev);struct resource *mem;if (!pdev->name)return 0;if (!strcmp(pdev->name, "simple-framebuffer")) {mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);if (!mem)return 0;if (!sysfb_evict_match_resource(ctx, mem))return 0;+#ifdef CONFIG_OF_ADDRESS
if (dev->of_node)of_platform_device_destroy(dev);else+#endif
if (dev_get_platdata(&pdev->dev))platform_device_del(pdev);}return 0;+}
+static int sysfb_evict_platform(struct sysfb_evict_ctx *ctx) +{
/** Early-boot architecture setup and boot-loarders sometimes create* preliminary platform devices with a generic framebuffer setup. This* allows graphics access during boot-up, without a real graphics* driver loaded. However, once a real graphics driver takes over, we* have to destroy those platform devices. In the legacy fbdev case, we* just used to unload the fbdev driver. However, to make sure any kind* of driver is unloaded, the platform-eviction code here simply* removes any conflicting platform device directly. This causes any* bound driver to be detached, and then removes the device entirely so* it cannot be bound to later on.** Please note that any such platform device must be registered by* early architecture setup code. If they are registered after regular* GFX drivers, this will fail horribly.*/static DEFINE_MUTEX(lock);int ret;/** In case of static platform-devices, we must iterate the bus and* remove them manually. We know that we're the only code that might* remove them, so a simple static lock serializes all calls here.*/mutex_lock(&lock);ret = bus_for_each_dev(&platform_bus_type, NULL, ctx,sysfb_evict_platform_device);mutex_unlock(&lock);return ret;+}
+static int sysfb_evict_fbdev(struct sysfb_evict_ctx *ctx) +{
/** Usually, evicting platform devices should be enough to also trigger* fbdev unloading. However, some legacy devices (e.g., uvesafb) have* no platform devices that can be evicted, so we still fall back to* the legacy fbdev removal code. Note that this only removes fbdev* devices marked as FBINFO_MISC_FIRMWARE. Anything else is left* untouched.** As usual, this only works if the fbdev device is probed early,* before any real GFX driver wants to take over.*/int ret = 0;+#ifdef CONFIG_FB
ret = remove_conflicting_framebuffers(ctx->ap, "sysfb",ctx->flags & SYSFB_EVICT_VBE);+#endif
return ret;+}
+static int sysfb_evict_vgacon(struct sysfb_evict_ctx *ctx) +{
/** The VGACON console driver pokes at VGA registers randomly. If a GFX* driver cannot keep the VGA support alive, it better makes sure to* unload VGACON before probing.** Unloading VGACON requires us to first force dummycon to take over* from vgacon (but only if vgacon is really in use), followed by a* deregistration of vgacon. Note that this prevents vgacon from being* used again after the GFX driver is unloaded. But that is usually* fine, since VGA state is rarely restored on driver-unload, anyway.** Note that we rely on VGACON to be probed in early boot (actually* done by ARCH setup code). If it is probed after GFX drivers, this* will fail horribly. You better make sure VGACON is probed early and* GFX drivers are probed as normal modules.*/int ret = 0;+#ifdef CONFIG_VGA_CONSOLE
console_lock();if (con_is_bound(&vga_con))ret = do_take_over_console(&dummy_con, 0,MAX_NR_CONSOLES - 1, 1);if (ret == 0) {ret = do_unregister_con_driver(&vga_con);if (ret == -ENODEV) /* ignore "already unregistered" */ret = 0;}console_unlock();+#endif
return ret;+}
+/**
- sysfb_evict_conflicts - remove any conflicting system-framebuffers
- @ctx: eviction context
- This function evicts any conflicting system-framebuffers and their bound
- drivers, according to the data given in @ctx.
- Depending on @ctx->flags, the following operations are performed:
- SYSFB_EVICT_PLATFORM: Firmware framebuffer platform devices (eg.,
'simple-framebuffer') that overlap @ctx are removed
from the system, causing drivers to be unbound.
If SYSFB_EVICT_VBE is given, this also affects
devices that own the VGA region.
- SYSFB_EVICT_FBDEV: Any firmware fbdev drivers that overlap @ctx are
unloaded.
Furthermore, if SYSFB_EVICT_VBE is given as well, any
fbdev driver that maps the VGA region is unloaded.
- SYSFB_EVICT_VGACON: The vgacon console driver is unbound and unregistered.
- This might call into fbdev driver unregistration, or even device_del() on
- some buses. Hence, make sure you call this from your top-level
- probe-callbacks, rather than with any gfx-subsystem locks held.
- RETURNS:
- 0 on success, negative error code on failure.
- */
+int sysfb_evict_conflicts(struct sysfb_evict_ctx *ctx) +{
int ret;if (WARN_ON(!ctx || !ctx->ap))return -EINVAL;pr_info("removing conflicts (sysfb%s%s%s%s)\n",(ctx->flags & SYSFB_EVICT_PLATFORM) ? ", platform" : "",(ctx->flags & SYSFB_EVICT_FBDEV) ? ", fbdev" : "",(ctx->flags & SYSFB_EVICT_VGACON) ? ", vgacon" : "",(ctx->flags & SYSFB_EVICT_VBE) ? ", vbe" : "");if (ctx->flags & SYSFB_EVICT_PLATFORM) {ret = sysfb_evict_platform(ctx);if (ret < 0)return ret;}if (ctx->flags & SYSFB_EVICT_FBDEV) {ret = sysfb_evict_fbdev(ctx);if (ret < 0)return ret;}if (ctx->flags & SYSFB_EVICT_VGACON) {ret = sysfb_evict_vgacon(ctx);if (ret < 0)return ret;}return 0;+} +EXPORT_SYMBOL(sysfb_evict_conflicts);
+/**
- sysfb_evict_conflicts_firmware() - remove all firmware framebuffers
- This is similar to sysfb_evict_conflicts() but uses a fake aperture spanning
- the entire address-space. This is suitable for any GFX driver that just
- wants to get rid of all available firmware framebuffers.
- RETURNS:
- 0 on success, negative error code on failure.
- */
+int sysfb_evict_conflicts_firmware(void) +{
struct sysfb_evict_ctx ctx = {};int ret;ctx.ap = alloc_apertures(1);if (!ctx.ap)return -ENOMEM;ctx.ap->ranges[0].base = 0;ctx.ap->ranges[0].size = ~0;ctx.flags |= SYSFB_EVICT_FBDEV | SYSFB_EVICT_PLATFORM;ret = sysfb_evict_conflicts(&ctx);kfree(ctx.ap);return ret;+} +EXPORT_SYMBOL(sysfb_evict_conflicts_firmware);
+#ifdef CONFIG_PCI +/**
- sysfb_evict_conflicts_pci() - remove all system framebuffers conflicting
with the given pci device
- @pdev: pci device
- This is similar to sysfb_evict_conflicts() but generates the eviction
- context based on the given pci device @pdev.
- RETURNS:
- 0 on success, negative error code on failure.
- */
+int sysfb_evict_conflicts_pci(struct pci_dev *pdev) +{
struct sysfb_evict_ctx ctx = {};size_t i, n, offset;int ret;/** If this device is used as primary VGA device, it is shadowed at the* VBE base address, so make sure to include it in the apertures.*/if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW)ctx.flags |= SYSFB_EVICT_VBE;/** If a device is a VGA device, make sure to kick out vgacon. We cannot* rely on the IORESOURCE_ROM_SHADOW, since vgacon can switch between* vga devices at runtime. So kick out vgacon anyway.*/if ((pdev->class >> 8) == PCI_CLASS_DISPLAY_VGA)ctx.flags |= SYSFB_EVICT_VGACON;/** Allocate apertures for all standard PCI resources. Skip them in case* they are empty.*/ctx.ap = alloc_apertures(PCI_STD_RESOURCE_END - PCI_STD_RESOURCES + 1);if (!ctx.ap)return -ENOMEM;offset = PCI_STD_RESOURCES;for (n = 0, i = 0; i < ctx.ap->count; ++i) {if (pci_resource_len(pdev, offset + i) < 1)continue;ctx.ap->ranges[n].base = pci_resource_start(pdev, offset + i);ctx.ap->ranges[n].size = pci_resource_len(pdev, offset + i);++n;}ctx.ap->count = n;/** Evict all matching fbdev devices, VBE devices if they shadow this* device, vgacon if this is a vga device, and platform devices if they* match.*/ctx.flags |= SYSFB_EVICT_FBDEV | SYSFB_EVICT_PLATFORM;ret = sysfb_evict_conflicts(&ctx);kfree(ctx.ap);return ret;+} +EXPORT_SYMBOL(sysfb_evict_conflicts_pci); +#endif /* CONFIG_PCI */ diff --git a/include/linux/sysfb.h b/include/linux/sysfb.h new file mode 100644 index 0000000..b67c74a --- /dev/null +++ b/include/linux/sysfb.h @@ -0,0 +1,34 @@ +#ifndef __LINUX_SYSFB_H +#define __LINUX_SYSFB_H
+/*
- Copyright (C) 2013-2016 Red Hat, Inc.
- This program is free software; you can redistribute it and/or modify it
- under the terms of the GNU Lesser General Public License as published by the
- Free Software Foundation; either version 2.1 of the License, or (at your
- option) any later version.
- */
+#include <linux/kernel.h>
+struct apertures_struct; +struct pci_dev;
+enum {
SYSFB_EVICT_PLATFORM = (1U << 0),SYSFB_EVICT_FBDEV = (1U << 1),SYSFB_EVICT_VGACON = (1U << 2),SYSFB_EVICT_VBE = (1U << 3),+};
+struct sysfb_evict_ctx {
struct apertures_struct *ap;unsigned int flags;+};
+int sysfb_evict_conflicts(struct sysfb_evict_ctx *ctx); +int sysfb_evict_conflicts_firmware(void); +int sysfb_evict_conflicts_pci(struct pci_dev *pdev);
+#endif /* __LINUX_SYSFB_H */
2.9.3
dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel