From: David Herrmann dh.herrmann@googlemail.com

For a long time now we have the problem that there are multiple drivers available that try to use system framebuffers (like EFI, VESA/VBE, ...). There is no way to control which driver gets access to the devices, but instead works on a first-come-first-serve basis.

Furthermore, hardware drivers (eg., gpu/drm/*) that get loaded on the real hardware bus (eg., pci-bus) of the framebuffer devices have a hard time unloading other drivers that currently use system framebuffers.

This introduces a new bus-type: sysfb (system framebuffer bus)

Any available system framebuffer gets registered as a device on this bus. A bus-driver can then pick up the device and use it. Standard sysfs bind/unbind interfaces can be used to change drivers on-the-fly.

There are actually two types of drivers: generic and real drivers

Generic drivers use the generic framebuffer interface exclusively. They are often used as a fallback interface where no real driver for the hardware is available. Generic drivers register as sysfb drivers to the sysfb bus and will get loaded dynamically. User-space can bind/unbind them via sysfs to control which driver should get access. Only one driver can be active per device. During probe the driver can retrieve additional information via a screen_info object of the device. Generic drivers include: efifb, (u)vesafb, vgacon, ...

Real drivers work differently. Instead of being loaded via sysfb, they register as drivers on the real bus (eg., pci-bus). During probe they should verify whether their real device provides a system-framebuffer. If it does, they call sysfb_claim() to claim exclusive access to the device. This guarantees that any generic driver gets unloaded and the real hardware driver can gain access. This also guarantees that a real hardware driver always takes precedence over generic fallback drivers. Real drivers include: i915, radeon, nouveau, ...

Signed-off-by: David Herrmann dh.herrmann@googlemail.com --- drivers/video/Kconfig | 17 ++++ drivers/video/Makefile | 1 + drivers/video/sysfb.c | 230 +++++++++++++++++++++++++++++++++++++++++++++++++ include/linux/sysfb.h | 134 ++++++++++++++++++++++++++++ 4 files changed, 382 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 d08d799..eac56ef 100644 --- a/drivers/video/Kconfig +++ b/drivers/video/Kconfig @@ -27,6 +27,23 @@ config VGASTATE tristate default n

+config SYSFB + tristate "System Framebuffer Bus" + help + Framebuffers like VGA, VESA/VBE, EFI and others can be handled by many + different drivers. This bus provides an infrastructure for drivers to + register themselves and then get bound/unbound to these system-wide + framebuffers. + This bus prevents framebuffers from being used by multiple drivers + simultaneously and also provides a sysfs API to bind/rebind different + drivers to each device from userspace. + + Chipset-specific drivers (like real GPU drivers) will always take + precedence over generic framebuffer drivers. + + A driver should normally select this bus-option automatically. Enable + it only if you need out-of-tree builds. + config VIDEO_OUTPUT_CONTROL tristate "Lowlevel video output switch controls" help diff --git a/drivers/video/Makefile b/drivers/video/Makefile index 23e948e..f0eb006 100644 --- a/drivers/video/Makefile +++ b/drivers/video/Makefile @@ -5,6 +5,7 @@ # Each configuration option enables a list of files.

obj-$(CONFIG_VGASTATE) += vgastate.o +obj-$(CONFIG_SYSFB) += sysfb.o obj-y += fb_notify.o obj-$(CONFIG_FB) += fb.o fb-y := fbmem.o fbmon.o fbcmap.o fbsysfs.o \ diff --git a/drivers/video/sysfb.c b/drivers/video/sysfb.c new file mode 100644 index 0000000..8249006 --- /dev/null +++ b/drivers/video/sysfb.c @@ -0,0 +1,230 @@ +/* + * System framebuffer bus + * Copyright (c) 2013 David Herrmann + */ + +/* + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; either version 2 of the License, or (at your option) + * any later version. + */ + +/* + * The system framebuffer bus (sysfb) provides a way to register global system + * framebuffers and load different drivers for it. This includes VESA/VBE and + * EFI framebuffers. + * Platform code is responsible of adding the framebuffer devices to the system + * platform bus. The sysfb bus will pick up known devices and provide them via + * the sysfb bus to system drivers. This guarantees that only one driver uses + * a single system framebuffer at a time. + * + * Drivers that can make use of the generic interfaces of system framebuffers + * should register as a sysfb driver. They will get notified via probe/remove + * callbacks just like any other hotpluggable driver. Users can load/unload + * drivers via the sysfs bus interface so drivers must be hotplug capable. + * + * Drivers that cannot make use of the generic interfaces but instead control + * the real hardware should instead claim the device. These drivers normally + * register through PCI or platform devices and control the device via another + * interface. + * By claiming a device, all other generic drivers are unregistered and no more + * drivers will be probed unless the device is released again. + * + * Only _real_ hardware drivers should claim devices as there is always another + * mechanism to control which real hardware driver gets loaded (eg. pci-bus). + * Generic drivers which aren't controlled via another bus should use this + * generic sysfb driver interface instead of claiming a device. + * + * All drivers must make sure that after they get unloaded or release a device, + * the device is reset to a usable state. If the driver cannot guarantee that, + * it should taint the device so other drivers will notice it and can + * optionally recover the device. + */ + +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include <linux/device.h> +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/mutex.h> +#include <linux/platform_device.h> +#include <linux/screen_info.h> +#include <linux/slab.h> +#include <linux/spinlock.h> +#include <linux/sysfb.h> + +static DEFINE_SPINLOCK(sysfb_lock); +static unsigned int claimed_types; + +static int sysfb_bus_match(struct device *dev, struct device_driver *drv) +{ + struct sysfb_device *sdev = to_sysfb_device(dev); + struct sysfb_driver *sdrv = to_sysfb_driver(drv); + + return (sdrv->type_mask & sdev->type) && + (sdrv->allow_tainted || !sdev->tainted); +} + +static int sysfb_bus_probe(struct device *dev) +{ + struct sysfb_device *sdev = to_sysfb_device(dev); + struct sysfb_driver *sdrv = to_sysfb_driver(dev->driver); + unsigned long flags; + int ret; + + if (!(sdrv->type_mask & sdev->type)) + return -ENODEV; + if (!sdrv->allow_tainted && sdev->tainted) + return -ENODEV; + + spin_lock_irqsave(&sysfb_lock, flags); + if ((claimed_types & sdev->type)) { + spin_unlock_irqrestore(&sysfb_lock, flags); + return -ENODEV; + } + spin_unlock_irqrestore(&sysfb_lock, flags); + + if (sdrv->probe) { + ret = sdrv->probe(sdev); + if (ret) + return ret; + } + + return 0; +} + +static int sysfb_bus_remove(struct device *dev) +{ + struct sysfb_device *sdev = to_sysfb_device(dev); + struct sysfb_driver *sdrv = to_sysfb_driver(dev->driver); + + if (sdrv->remove) + sdrv->remove(sdev); + + return 0; +} + +static struct bus_type sysfb_bus_type = { + .name = "sysfb", + .match = sysfb_bus_match, + .probe = sysfb_bus_probe, + .remove = sysfb_bus_remove, +}; + +int sysfb_register_driver(struct sysfb_driver *drv) +{ + int ret; + + drv->driver.bus = &sysfb_bus_type; + + ret = driver_register(&drv->driver); + if (ret) + return ret; + + return 0; +} +EXPORT_SYMBOL(sysfb_register_driver); + +void sysfb_unregister_driver(struct sysfb_driver *drv) +{ + driver_unregister(&drv->driver); +} +EXPORT_SYMBOL(sysfb_unregister_driver); + +static int __sysfb_rescan(struct device *dev, void *data) +{ + return device_attach(dev); +} + +static void sysfb_rescan(void) +{ + bus_for_each_dev(&sysfb_bus_type, NULL, NULL, __sysfb_rescan); +} + +static int __sysfb_claim(struct device *dev, void *data) +{ + struct sysfb_device *sdev = to_sysfb_device(dev); + unsigned int claim = (long)data; + + if (!(sdev->type & claim)) + return 0; + + device_release_driver(dev); + return 0; +} + +int sysfb_claim(unsigned int types) +{ + unsigned long flags; + int ret; + + if (!(types & SYSFB_TYPES)) + return -EINVAL; + + spin_lock_irqsave(&sysfb_lock, flags); + if ((claimed_types & types)) { + spin_unlock_irqrestore(&sysfb_lock, flags); + return -EALREADY; + } + claimed_types |= types; + spin_unlock_irqrestore(&sysfb_lock, flags); + + ret = bus_for_each_dev(&sysfb_bus_type, NULL, (void*)(long)types, + __sysfb_claim); + if (ret) + goto err_restore; + + return 0; + +err_restore: + spin_lock_irqsave(&sysfb_lock, flags); + claimed_types &= ~types; + spin_unlock_irqrestore(&sysfb_lock, flags); + + sysfb_rescan(); + return ret; +} +EXPORT_SYMBOL(sysfb_claim); + +void sysfb_release(unsigned int types) +{ + unsigned long flags; + + spin_lock_irqsave(&sysfb_lock, flags); + claimed_types &= ~types; + spin_unlock_irqrestore(&sysfb_lock, flags); + + sysfb_rescan(); +} +EXPORT_SYMBOL(sysfb_release); + +void sysfb_taint(struct sysfb_device *sdev, bool set) +{ + sdev->tainted = set; +} +EXPORT_SYMBOL(sysfb_taint); + +static int __init sysfb_init(void) +{ + int ret; + + ret = bus_register(&sysfb_bus_type); + if (ret) { + pr_err("cannot register sysfb bus\n"); + return ret; + } + + return 0; +} + +static void __exit sysfb_exit(void) +{ + bus_unregister(&sysfb_bus_type); +} + +module_init(sysfb_init); +module_exit(sysfb_exit); +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("David Herrmann dh.herrmann@gmail.com"); +MODULE_DESCRIPTION("System framebuffer bus"); diff --git a/include/linux/sysfb.h b/include/linux/sysfb.h new file mode 100644 index 0000000..6cd3c24 --- /dev/null +++ b/include/linux/sysfb.h @@ -0,0 +1,134 @@ +#ifndef __LINUX_SYSFB_H_ +#define __LINUX_SYSFB_H_ + +/* + * System framebuffer bus + * Copyright (c) 2013 David Herrmann + */ + +/* + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; either version 2 of the License, or (at your option) + * any later version. + */ + +#include <linux/device.h> +#include <linux/kernel.h> +#include <linux/screen_info.h> +#include <linux/types.h> + +/** + * sysfb_type + * + * Different types of available framebuffer devices. Only one device of each + * type can be available at a time. In most systems there even is only one + * device at all. + * + * Use the sysfb_device->screen pointer to get information about the framebuffer + * devices. + */ +enum sysfb_type { + SYSFB_TYPES = 0, +}; + +/** + * sysfb_device + * @tainted: whether the device was tainted or not + * @type: type of the fb device (@sysfb_type) + * @screen: pointer to supplemental screen-info object + * @dev: device object + * + * Each framebuffer device is represented by a sysfb_device object. The sysfb + * core manages them and they cannot be registered from the outside. + */ +struct sysfb_device { + bool tainted; + unsigned int type; + struct screen_info *screen; + struct device dev; +}; + +#define to_sysfb_device(_dev) container_of((_dev), struct sysfb_device, dev) + +/** + * sysfb_driver + * @type_mask: mask of device-types that are supported (@sysfb_type) + * @allow_tainted: whether the driver can be bound to tainted devices + * @driver: driver object + * @probe: probe callback + * @remove: remove callback + * + * Each generic framebuffer driver must provide this structure when registering + * to the sysfb core. The @driver field must also be provided by the caller + * except for the 'driver.bus' field which is initialized by the core. + */ +struct sysfb_driver { + unsigned int type_mask; + bool allow_tainted; + struct device_driver driver; + + int (*probe) (struct sysfb_device *dev); + void (*remove) (struct sysfb_device *dev); +}; + +#define to_sysfb_driver(_drv) container_of((_drv), struct sysfb_driver, driver) + +/** + * sysfb_register_driver + * @drv: Driver object + * + * Register a new driver on the sysfb bus. + */ +int sysfb_register_driver(struct sysfb_driver *drv); + +/** + * sysfb_unregister_driver + * @drv: Driver object + * + * Remove a driver from the sysfb bus. + */ +void sysfb_unregister_driver(struct sysfb_driver *drv); + +/** + * sysfb_claim + * @types: Bitmask of sysfb_type flags + * + * Unbind all drivers from all devices matching the given types and prevent + * further drivers to get loaded on these types of devices. This allows real + * hardware drivers that are loaded by other bus-types (eg. pci-bus) to prevent + * any generic driver from using the given framebuffer types. + * + * Return 0 if the types could be claimed, otherwise a negative error code + * is returned. + */ +int sysfb_claim(unsigned int types); + +/** + * sysfb_release + * @types: Bitmask of sysfb_type flags + * + * Releases the given previously claimed types. See sysfb_claim(). This does + * not check whether the types are actually claimed or who claimed them. So make + * sure to call this only when you really claimed these types previously. + */ +void sysfb_release(unsigned int types); + +/** + * sysfb_taint + * @sdev: sysfb device + * @set: whether to taint or untaint + * + * This taints a given sysfb device. This should be done by all drivers if they + * change the framebuffer device in a way that other generic drivers might not + * be able to detect afterwards. + * This includes changing the resolution or properties of a framebuffer without + * adjusting the screen_info object. + * This can be reset to 'false' after all the changes have been undone. + * + * This is an unlocked function. You must call it from within your probe/remove + * callbacks in the driver. + */ +void sysfb_taint(struct sysfb_device *sdev, bool set); + +#endif /* __LINUX_SYSFB_H_ */

From: David Herrmann dh.herrmann@googlemail.com

HACK: This should be provided by architecture setup code. But to show how it is supposed to work, we now simply add a "vbefb" device during initialization.

The better way to do this is by moving this into arch-code. So for instance the x86 boot initialization should create this platform-device after VBE/VESA screen detection. Other architectures can do the same or introduce other framebuffer types than SYSFB_VBE.

Signed-off-by: David Herrmann dh.herrmann@googlemail.com --- drivers/video/sysfb.c | 8 ++++++++ 1 file changed, 8 insertions(+)

diff --git a/drivers/video/sysfb.c b/drivers/video/sysfb.c index 5b47a9a..0c0a4e7 100644 --- a/drivers/video/sysfb.c +++ b/drivers/video/sysfb.c @@ -271,6 +271,8 @@ static struct platform_driver sysfb_vbe_driver = { .remove = sysfb_vbe_remove, };

+static struct platform_device *sysfb_vbe_device; + static int __init sysfb_init(void) { int ret; @@ -287,6 +289,12 @@ static int __init sysfb_init(void) goto err_bus; }

+ sysfb_vbe_device = platform_device_register_data(NULL, "vbefb", -1, + &screen_info, + sizeof(screen_info)); + if (!sysfb_vbe_device) + pr_warn("cannot create vbefb device\n"); + return 0;

err_bus:

Instead of using our own platform device, we now register as sysfb driver and get notified whenever we are loaded on a system VBE device. This allows other VBE drivers to be loaded at the same time and users can bind/unbind drivers via sysfs. We also no longer need to fake a platform-device because the sysfb bus provides all devices now.

Signed-off-by: David Herrmann dh.herrmann@gmail.com --- drivers/video/Kconfig | 1 + drivers/video/vesafb.c | 49 +++++++++++++++---------------------------------- 2 files changed, 16 insertions(+), 34 deletions(-)

diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig index d5723c2..5c23d32 100644 --- a/drivers/video/Kconfig +++ b/drivers/video/Kconfig @@ -776,6 +776,7 @@ config FB_VESA select FB_CFB_COPYAREA select FB_CFB_IMAGEBLIT select FB_BOOT_VESA_SUPPORT + select SYSFB help This is the frame buffer device driver for generic VESA 2.0 compliant graphic cards. The older VESA 1.2 cards are not supported. diff --git a/drivers/video/vesafb.c b/drivers/video/vesafb.c index 4ad7b40..652858f 100644 --- a/drivers/video/vesafb.c +++ b/drivers/video/vesafb.c @@ -19,6 +19,7 @@ #include <linux/init.h> #include <linux/platform_device.h> #include <linux/screen_info.h> +#include <linux/sysfb.h>

#include <video/vga.h> #include <asm/io.h> @@ -214,7 +215,7 @@ static int vesafb_setup(char *options) return 0; }

-static int vesafb_probe(struct platform_device *dev) +static int vesafb_probe(struct sysfb_device *dev) { struct fb_info *info; struct vesafb_par *par; @@ -491,7 +492,7 @@ static int vesafb_probe(struct platform_device *dev) } printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node, info->fix.id); - platform_set_drvdata(dev, info); + dev_set_drvdata(&dev->dev, info); return 0; err: if (info->screen_base) @@ -501,59 +502,39 @@ err: return err; }

-static int vesafb_remove(struct platform_device *dev) +static void vesafb_remove(struct sysfb_device *dev) { - struct fb_info *info = platform_get_drvdata(dev); + struct fb_info *info = dev_get_drvdata(&dev->dev);

unregister_framebuffer(info); - return 0; }

-static struct platform_driver vesafb_driver = { +static struct sysfb_driver vesafb_driver = { + .type_mask = SYSFB_VBE, + .allow_tainted = false, + .driver = { + .name = "vesafb", + .owner = THIS_MODULE, + .mod_name = KBUILD_MODNAME, + }, .probe = vesafb_probe, .remove = vesafb_remove, - .driver = { - .name = "vesafb", - }, };

-static struct platform_device *vesafb_device; - static int __init vesafb_init(void) { - int ret; char *option = NULL;

/* ignore error return of fb_get_options */ fb_get_options("vesafb", &option); vesafb_setup(option);

- vesafb_device = platform_device_alloc("vesafb", -1); - if (!vesafb_device) - return -ENOMEM; - - ret = platform_driver_register(&vesafb_driver); - if (ret) - goto err_dev; - - ret = platform_device_add(vesafb_device); - if (ret) - goto err_drv; - - return 0; - -err_drv: - platform_driver_unregister(&vesafb_driver); -err_dev: - platform_device_put(vesafb_device); - return ret; + return sysfb_register_driver(&vesafb_driver); }

static void __exit vesafb_exit(void) { - platform_device_del(vesafb_device); - platform_device_put(vesafb_device); - platform_driver_unregister(&vesafb_driver); + sysfb_unregister_driver(&vesafb_driver); }

module_init(vesafb_init);

This driver uses the VESA BIOS Extensions to control the display device. Modesetting has to be done during the boot-process by the architecture code (same way as vesafb requires it). No runtime modesetting is allowed due to RealMode/ProtectedMode restrictions.

This patch only introduces the stub DRM driver without any VESA/VBE backend that actually touches the hardware.

The driver simply provides a single crtc+encoder+connector combination that user-space can use to access the VBE framebuffer. No page-flips are supported and users must explicitly mark buffers as dirty to get them copied into the framebuffer.

All buffer objects are backed by shmem so we can later add PRIME support.

Signed-off-by: David Herrmann dh.herrmann@gmail.com --- drivers/gpu/drm/Kconfig | 2 + drivers/gpu/drm/Makefile | 1 + drivers/gpu/drm/dvbe/Kconfig | 28 +++ drivers/gpu/drm/dvbe/Makefile | 4 + drivers/gpu/drm/dvbe/dvbe.h | 73 +++++++ drivers/gpu/drm/dvbe/dvbe_drv.c | 104 ++++++++++ drivers/gpu/drm/dvbe/dvbe_main.c | 399 +++++++++++++++++++++++++++++++++++++++ drivers/gpu/drm/dvbe/dvbe_mem.c | 269 ++++++++++++++++++++++++++ 8 files changed, 880 insertions(+) create mode 100644 drivers/gpu/drm/dvbe/Kconfig create mode 100644 drivers/gpu/drm/dvbe/Makefile create mode 100644 drivers/gpu/drm/dvbe/dvbe.h create mode 100644 drivers/gpu/drm/dvbe/dvbe_drv.c create mode 100644 drivers/gpu/drm/dvbe/dvbe_main.c create mode 100644 drivers/gpu/drm/dvbe/dvbe_mem.c

diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig index 2df448e..fbbdabc 100644 --- a/drivers/gpu/drm/Kconfig +++ b/drivers/gpu/drm/Kconfig @@ -215,3 +215,5 @@ source "drivers/gpu/drm/mgag200/Kconfig" source "drivers/gpu/drm/cirrus/Kconfig"

source "drivers/gpu/drm/shmobile/Kconfig" + +source "drivers/gpu/drm/dvbe/Kconfig" diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index 9249b66..ec91ae8 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -49,4 +49,5 @@ obj-$(CONFIG_DRM_GMA500) += gma500/ obj-$(CONFIG_DRM_UDL) += udl/ obj-$(CONFIG_DRM_AST) += ast/ obj-$(CONFIG_DRM_SHMOBILE) +=shmobile/ +obj-$(CONFIG_DRM_DVBE) += dvbe/ obj-y += i2c/ diff --git a/drivers/gpu/drm/dvbe/Kconfig b/drivers/gpu/drm/dvbe/Kconfig new file mode 100644 index 0000000..bb3aa7b --- /dev/null +++ b/drivers/gpu/drm/dvbe/Kconfig @@ -0,0 +1,28 @@ +config DRM_DVBE + tristate "VESA BIOS Extension DRM Driver" + depends on DRM + select DRM_KMS_HELPER + select DRM_SYSFB + help + This is a DRM/KMS driver for VESA BIOS Extension (VBE) compatible + cards. At least VBE 2.0 is needed. Older VBE 1.2 cards are not + supported. + Nearly all modern x86 graphics cards support VBE 2.0 so this driver + should work with all those graphics cards. However, it does not allow + mode-switching during runtime but requires the kernel to setup the + mode with the vga= kernel command line option. If you want full + support for your graphics card, please select a driver for your + specific model. + + This driver can be enabled together with any other DRM graphics + driver. If another driver probes a device that conflicts with DVBE, + then DVBE will automatically drop the device and let the + model-specific driver take precedence. + + This driver replaces the old vesafb framebuffer driver and provides + full backwards compatibility. + + If unsure, say Y. + + To compile this driver as a module, choose M here: the + module will be called dvbe. diff --git a/drivers/gpu/drm/dvbe/Makefile b/drivers/gpu/drm/dvbe/Makefile new file mode 100644 index 0000000..b053da3 --- /dev/null +++ b/drivers/gpu/drm/dvbe/Makefile @@ -0,0 +1,4 @@ +ccflags-y := -Iinclude/drm + +dvbe-y := dvbe_drv.o dvbe_main.o dvbe_mem.o +obj-$(CONFIG_DRM_DVBE) := dvbe.o diff --git a/drivers/gpu/drm/dvbe/dvbe.h b/drivers/gpu/drm/dvbe/dvbe.h new file mode 100644 index 0000000..0235a95 --- /dev/null +++ b/drivers/gpu/drm/dvbe/dvbe.h @@ -0,0 +1,73 @@ +/* + * DRM VESA BIOS Extension Driver + * Copyright (c) 2012-2013 David Herrmann dh.herrmann@gmail.com + */ + +/* + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; either version 2 of the License, or (at your option) + * any later version. + */ + +#ifndef DVBE_DRV_H +#define DVBE_DRV_H + +#include <linux/errno.h> +#include <linux/kernel.h> +#include <linux/mm.h> +#include <linux/module.h> +#include <linux/string.h> +#include <drm/drmP.h> + +/* dvbe devices */ + +struct dvbe_device { + struct drm_device *ddev; + + /* mode-setting objects */ + struct drm_crtc crtc; + struct drm_encoder enc; + struct drm_connector conn; + struct drm_display_mode *mode; +}; + +int dvbe_drm_load(struct drm_device *ddev, unsigned long flags); +int dvbe_drm_unload(struct drm_device *ddev); +int dvbe_drm_mmap(struct file *filp, struct vm_area_struct *vma); + +/* dvbe gem objects */ + +struct dvbe_gem_object { + struct drm_gem_object base; + struct page **pages; + uint8_t *vmapping; +}; + +#define to_dvbe_bo(x) container_of(x, struct dvbe_gem_object, base) + +int dvbe_gem_init_object(struct drm_gem_object *obj); +void dvbe_gem_free_object(struct drm_gem_object *obj); +int dvbe_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf); +int dvbe_gem_vmap(struct dvbe_gem_object *obj); +void dvbe_gem_vunmap(struct dvbe_gem_object *obj); + +/* dumb buffers */ + +int dvbe_dumb_create(struct drm_file *file_priv, struct drm_device *ddev, + struct drm_mode_create_dumb *arg); +int dvbe_dumb_destroy(struct drm_file *file_priv, struct drm_device *ddev, + uint32_t handle); +int dvbe_dumb_map_offset(struct drm_file *file_priv, struct drm_device *ddev, + uint32_t handle, uint64_t *offset); + +/* dvbe framebuffers */ + +struct dvbe_framebuffer { + struct drm_framebuffer base; + struct dvbe_gem_object *obj; +}; + +#define to_dvbe_fb(x) container_of(x, struct dvbe_framebuffer, base) + +#endif /* DVBE_DRV_H */ diff --git a/drivers/gpu/drm/dvbe/dvbe_drv.c b/drivers/gpu/drm/dvbe/dvbe_drv.c new file mode 100644 index 0000000..98d4d37 --- /dev/null +++ b/drivers/gpu/drm/dvbe/dvbe_drv.c @@ -0,0 +1,104 @@ +/* + * DRM VESA BIOS Extension Driver + * Copyright (c) 2012-2013 David Herrmann dh.herrmann@gmail.com + */ + +/* + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; either version 2 of the License, or (at your option) + * any later version. + */ + +#include <linux/errno.h> +#include <linux/kernel.h> +#include <linux/mm.h> +#include <linux/module.h> +#include <linux/string.h> +#include <linux/sysfb.h> +#include <drm/drmP.h> +#include <drm/drm_sysfb.h> +#include "dvbe.h" + +static const struct vm_operations_struct dvbe_gem_vm_ops = { + .fault = dvbe_gem_fault, + .open = drm_gem_vm_open, + .close = drm_gem_vm_close, +}; + +static const struct file_operations dvbe_drm_fops = { + .owner = THIS_MODULE, + .open = drm_open, + .mmap = dvbe_drm_mmap, + .poll = drm_poll, + .read = drm_read, + .unlocked_ioctl = drm_ioctl, + .release = drm_release, + .fasync = drm_fasync, +#ifdef CONFIG_COMPAT + .compat_ioctl = drm_compat_ioctl, +#endif + .llseek = noop_llseek, +}; + +static struct drm_driver dvbe_drm_driver = { + .driver_features = DRIVER_MODESET | DRIVER_GEM, + .load = dvbe_drm_load, + .unload = dvbe_drm_unload, + .fops = &dvbe_drm_fops, + + .gem_init_object = dvbe_gem_init_object, + .gem_free_object = dvbe_gem_free_object, + .gem_vm_ops = &dvbe_gem_vm_ops, + + .dumb_create = dvbe_dumb_create, + .dumb_map_offset = dvbe_dumb_map_offset, + .dumb_destroy = dvbe_dumb_destroy, + + .name = "dvbe", + .desc = "DRM VESA BIOS Extension Driver", + .date = "20130127", + .major = 0, + .minor = 0, + .patchlevel = 1, +}; + +static int dvbe_sysfb_probe(struct sysfb_device *sdev) +{ + return drm_get_sysfb_dev(sdev, &dvbe_drm_driver); +} + +static void dvbe_sysfb_remove(struct sysfb_device *sdev) +{ + struct drm_device *ddev = dev_get_drvdata(&sdev->dev); + + drm_unplug_dev(ddev); +} + +static struct sysfb_driver dvbe_sysfb_driver = { + .type_mask = SYSFB_VBE, + .allow_tainted = false, + .driver = { + .name = "dvbe", + .owner = THIS_MODULE, + .mod_name = KBUILD_MODNAME, + }, + .probe = dvbe_sysfb_probe, + .remove = dvbe_sysfb_remove, +}; + +static int __init dvbe_init(void) +{ + return drm_sysfb_init(&dvbe_drm_driver, &dvbe_sysfb_driver); +} + +static void __exit dvbe_exit(void) +{ + drm_sysfb_exit(&dvbe_drm_driver, &dvbe_sysfb_driver); +} + +module_init(dvbe_init); +module_exit(dvbe_exit); +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("David Herrmann dh.herrmann@gmail.com"); +MODULE_DESCRIPTION("DRM VESA BIOS Extension Driver"); diff --git a/drivers/gpu/drm/dvbe/dvbe_main.c b/drivers/gpu/drm/dvbe/dvbe_main.c new file mode 100644 index 0000000..e73c77e --- /dev/null +++ b/drivers/gpu/drm/dvbe/dvbe_main.c @@ -0,0 +1,399 @@ +/* + * DRM VESA BIOS Extension Driver + * Copyright (c) 2012-2013 David Herrmann dh.herrmann@gmail.com + */ + +/* + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; either version 2 of the License, or (at your option) + * any later version. + */ + +/* + * Main Modesetting and Control + * We register exactly one CRTC, encoder and connector on initialization. This + * simplifies the logic a lot. The actual device control is not implemented + * here. This file only provides the interaction with DRM core. + * + * Userspace has only one valid CRTC+encoder+connector combination which + * corresponds to the VESA framebuffer that we detected. The initial mode is + * deduced from the initial VESA configuration and should be used by user-space. + * Real mode-setting (i.e., changing display resolution) requires the processor + * to be in RealMode, which we cannot do in the kernel so it is not provided. + * Driver-specific ioctls may be used to allow userspace to perform mode-setting + * themself. + */ + +#include <linux/errno.h> +#include <linux/kernel.h> +#include <linux/mm.h> +#include <linux/module.h> +#include <linux/string.h> +#include <drm/drmP.h> +#include <drm/drm_crtc_helper.h> +#include "dvbe.h" + +/* crtcs */ + +static void dvbe_crtc_dpms(struct drm_crtc *crtc, int mode) +{ + /* There is no way to tell DRM core that we do not support DPMS. + * Therefore, simply make this a no-op and always be online. */ +} + +static bool dvbe_crtc_mode_fixup(struct drm_crtc *crtc, + const struct drm_display_mode *mode, + struct drm_display_mode *adjusted_mode) +{ + drm_mode_copy(adjusted_mode, mode); + return true; +} + +static void dvbe_crtc_prepare(struct drm_crtc *crtc) +{ + /* nothing to prepare */ +} + +static void dvbe_crtc_commit(struct drm_crtc *crtc) +{ + /* all work already done by immediate mode-set */ +} + +static int dvbe_crtc_mode_set(struct drm_crtc *crtc, + struct drm_display_mode *mode, + struct drm_display_mode *adjusted_mode, + int x, int y, + struct drm_framebuffer *old_fb) +{ + struct dvbe_framebuffer *dfb = to_dvbe_fb(crtc->fb); + + /* We can scan out any framebuffer that is given. The framebuffer + * allocation guarantees that it is a valid framebuffer. If the x/y + * corrdinates are out of bounds, we fail. We don't care whether the + * framebuffer is bigger/smaller than the real screen. The + * blit-functions clip it correctly. + * The mode was already checked by mode_fixup above so we can savely let + * it pass. */ + + if (x >= dfb->base.width || y >= dfb->base.height) + return -EINVAL; + + return 0; +} + +/* + * Shortcut if no full mode-set is needed but only the offsets or framebuffer + * parameters changed. See @mode_set for details. + */ +static int dvbe_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y, + struct drm_framebuffer *fb) +{ + struct dvbe_framebuffer *dfb = to_dvbe_fb(crtc->fb); + + if (x >= dfb->base.width || y >= dfb->base.height) + return -EINVAL; + + return 0; +} + +static const struct drm_crtc_helper_funcs dvbe_crtc_helper_ops = { + .dpms = dvbe_crtc_dpms, + .mode_fixup = dvbe_crtc_mode_fixup, + .prepare = dvbe_crtc_prepare, + .commit = dvbe_crtc_commit, + .mode_set = dvbe_crtc_mode_set, + .mode_set_base = dvbe_crtc_mode_set_base, +}; + +static const struct drm_crtc_funcs dvbe_crtc_ops = { + .destroy = drm_crtc_cleanup, + .set_config = drm_crtc_helper_set_config, +}; + +/* encoders */ + +static void dvbe_enc_dpms(struct drm_encoder *enc, int mode) +{ + /* DPMS is done by the CRTC */ +} + +static bool dvbe_enc_mode_fixup(struct drm_encoder *enc, + const struct drm_display_mode *mode, + struct drm_display_mode *adjusted_mode) +{ + /* mode-fixup is done by the CRTC */ + return true; +} + +static void dvbe_enc_prepare(struct drm_encoder *enc) +{ + /* no preparation to do */ +} + +static void dvbe_enc_mode_set(struct drm_encoder *enc, + struct drm_display_mode *mode, + struct drm_display_mode *adjusted_mode) +{ + /* mode-setting is done by the CRTC */ +} + +static void dvbe_enc_commit(struct drm_encoder *enc) +{ + /* committing mode changes is done by the CRTC */ +} + +static const struct drm_encoder_helper_funcs dvbe_enc_helper_ops = { + .dpms = dvbe_enc_dpms, + .mode_fixup = dvbe_enc_mode_fixup, + .prepare = dvbe_enc_prepare, + .mode_set = dvbe_enc_mode_set, + .commit = dvbe_enc_commit, +}; + +static const struct drm_encoder_funcs dvbe_enc_ops = { + .destroy = drm_encoder_cleanup, +}; + +/* connectors */ + +static int dvbe_conn_get_modes(struct drm_connector *conn) +{ + return 0; +} + +static int dvbe_conn_mode_valid(struct drm_connector *conn, + struct drm_display_mode *mode) +{ + /* every mode of our own is valid */ + return MODE_OK; +} + +static struct drm_encoder *dvbe_conn_best_encoder(struct drm_connector *conn) +{ + struct dvbe_device *dvbe = conn->dev->dev_private; + + /* We only have a single encoder for the VBE device. Hence, return it + * as best-encoder so it is always used. There is no real encoder that + * we control as VBE doesn't provide such information. */ + return &dvbe->enc; +} + +static const struct drm_connector_helper_funcs dvbe_conn_helper_ops = { + .get_modes = dvbe_conn_get_modes, + .mode_valid = dvbe_conn_mode_valid, + .best_encoder = dvbe_conn_best_encoder, +}; + +static enum drm_connector_status dvbe_conn_detect(struct drm_connector *conn, + bool force) +{ + /* We simulate an always connected monitor. The VESA ABI doesn't + * provide any way to detect whether the connector is active. Hence, + * signal DRM core that it is always connected. */ + return connector_status_connected; +} + +static void dvbe_conn_destroy(struct drm_connector *conn) +{ + /* Remove the fake-connector from sysfs and then let the DRM core + * clean up all associated resources. */ + if (device_is_registered(&conn->kdev)) + drm_sysfs_connector_remove(conn); + drm_connector_cleanup(conn); +} + +static const struct drm_connector_funcs dvbe_conn_ops = { + .dpms = drm_helper_connector_dpms, + .detect = dvbe_conn_detect, + .fill_modes = drm_helper_probe_single_connector_modes, + .destroy = dvbe_conn_destroy, +}; + +/* framebuffers */ + +static int dvbe_fb_create_handle(struct drm_framebuffer *fb, + struct drm_file *dfile, + unsigned int *handle) +{ + struct dvbe_framebuffer *dfb = to_dvbe_fb(fb); + + return drm_gem_handle_create(dfile, &dfb->obj->base, handle); +} + +static int dvbe_fb_dirty(struct drm_framebuffer *fb, struct drm_file *file, + unsigned int flags, unsigned int color, + struct drm_clip_rect *clips, unsigned int num) +{ + struct dvbe_device *dvbe = fb->dev->dev_private; + + if (dvbe->crtc.fb != fb) + return 0; + + return 0; +} + +static void dvbe_fb_destroy(struct drm_framebuffer *fb) +{ + struct dvbe_framebuffer *dfb = to_dvbe_fb(fb); + + drm_framebuffer_cleanup(fb); + drm_gem_object_unreference_unlocked(&dfb->obj->base); + kfree(dfb); +} + +static const struct drm_framebuffer_funcs dvbe_fb_ops = { + .create_handle = dvbe_fb_create_handle, + .dirty = dvbe_fb_dirty, + .destroy = dvbe_fb_destroy, +}; + +static struct drm_framebuffer *dvbe_fb_create(struct drm_device *ddev, + struct drm_file *dfile, + struct drm_mode_fb_cmd2 *cmd) +{ + struct dvbe_framebuffer *dfb; + int ret; + struct drm_gem_object *dobj; + unsigned int Bpp; + size_t siz; + void *err; + + if (cmd->flags) + return ERR_PTR(-EINVAL); + + switch (cmd->pixel_format) { + case DRM_FORMAT_RGB565: + case DRM_FORMAT_BGR565: + Bpp = 2; + break; + case DRM_FORMAT_XRGB8888: + case DRM_FORMAT_ARGB8888: + case DRM_FORMAT_XBGR8888: + case DRM_FORMAT_ABGR8888: + Bpp = 4; + break; + default: + return ERR_PTR(-EINVAL); + } + + siz = cmd->pitches[0] * (cmd->height - 1) + + Bpp * cmd->width + cmd->offsets[0]; + + dobj = drm_gem_object_lookup(ddev, dfile, cmd->handles[0]); + if (!dobj) + return ERR_PTR(-EINVAL); + if (dobj->size < siz) { + err = ERR_PTR(-ENOMEM); + goto err_unref; + } + + dfb = kzalloc(sizeof(*dfb), GFP_KERNEL); + if (!dfb) { + err = ERR_PTR(-ENOMEM); + goto err_unref; + } + dfb->obj = to_dvbe_bo(dobj); + + ret = drm_helper_mode_fill_fb_struct(&dfb->base, cmd); + if (ret < 0) { + err = ERR_PTR(ret); + goto err_free; + } + + ret = drm_framebuffer_init(ddev, &dfb->base, &dvbe_fb_ops); + if (ret < 0) { + err = ERR_PTR(ret); + goto err_free; + } + + return &dfb->base; + +err_free: + kfree(dfb); +err_unref: + drm_gem_object_unreference_unlocked(dobj); + return err; +} + +static const struct drm_mode_config_funcs dvbe_mode_config_ops = { + .fb_create = dvbe_fb_create, +}; + +/* initialization */ + +int dvbe_drm_load(struct drm_device *ddev, unsigned long flags) +{ + struct dvbe_device *dvbe; + int ret; + + dvbe = kzalloc(sizeof(*dvbe), GFP_KERNEL); + if (!dvbe) + return -ENOMEM; + + dvbe->ddev = ddev; + ddev->dev_private = dvbe; + + drm_mode_config_init(ddev); + ddev->mode_config.min_width = 0; + ddev->mode_config.min_height = 0; + ddev->mode_config.max_width = 4095; + ddev->mode_config.max_height = 4095; + ddev->mode_config.funcs = &dvbe_mode_config_ops; + + ret = drm_mode_create_dirty_info_property(ddev); + if (ret) + goto err_cleanup; + + ret = drm_crtc_init(ddev, &dvbe->crtc, &dvbe_crtc_ops); + if (ret) + goto err_cleanup; + drm_crtc_helper_add(&dvbe->crtc, &dvbe_crtc_helper_ops); + + dvbe->enc.possible_crtcs = 1; + dvbe->enc.possible_clones = 0; + ret = drm_encoder_init(ddev, &dvbe->enc, &dvbe_enc_ops, + DRM_MODE_ENCODER_VIRTUAL); + if (ret) + goto err_cleanup; + drm_encoder_helper_add(&dvbe->enc, &dvbe_enc_helper_ops); + + dvbe->conn.display_info.width_mm = 0; + dvbe->conn.display_info.height_mm = 0; + dvbe->conn.interlace_allowed = false; + dvbe->conn.doublescan_allowed = false; + dvbe->conn.polled = 0; + ret = drm_connector_init(ddev, &dvbe->conn, &dvbe_conn_ops, + DRM_MODE_CONNECTOR_VIRTUAL); + if (ret) + goto err_cleanup; + drm_connector_helper_add(&dvbe->conn, &dvbe_conn_helper_ops); + + drm_object_attach_property(&dvbe->conn.base, + ddev->mode_config.dirty_info_property, 1); + + ret = drm_mode_connector_attach_encoder(&dvbe->conn, &dvbe->enc); + if (ret) + goto err_cleanup; + + ret = drm_sysfs_connector_add(&dvbe->conn); + if (ret) + goto err_cleanup; + + return 0; + +err_cleanup: + drm_mode_config_cleanup(ddev); + kfree(dvbe); + return ret; +} + +int dvbe_drm_unload(struct drm_device *ddev) +{ + struct dvbe_device *dvbe = ddev->dev_private; + + drm_mode_config_cleanup(ddev); + kfree(dvbe); + + return 0; +} diff --git a/drivers/gpu/drm/dvbe/dvbe_mem.c b/drivers/gpu/drm/dvbe/dvbe_mem.c new file mode 100644 index 0000000..211aebf --- /dev/null +++ b/drivers/gpu/drm/dvbe/dvbe_mem.c @@ -0,0 +1,269 @@ +/* + * DRM VESA BIOS Extension Driver + * Copyright (c) 2012-2013 David Herrmann dh.herrmann@gmail.com + */ + +/* + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; either version 2 of the License, or (at your option) + * any later version. + */ + +/* + * DVBA Memory Objects + * Due to the limited functionality of the VESA ABI, we support only one memory + * object type which is the framebuffer object. To allow file-descriptors for + * frambuffers we use shmem storage for all gem objects. + * + * Furthermore, we use lazy storage allocation. As long as the storage isn't + * mapped or accessed, we do not allocate it. If it is mapped, we allocate an + * array of pointers to the pages so we can easily vmap/vunmap it for CPU + * access. + */ + +#include <linux/errno.h> +#include <linux/kernel.h> +#include <linux/mm.h> +#include <linux/module.h> +#include <linux/shmem_fs.h> +#include <linux/string.h> +#include <drm/drmP.h> +#include <drm/drm_mem_util.h> +#include "dvbe.h" + +static struct dvbe_gem_object *dvbe_gem_alloc_object(struct drm_device *ddev, + size_t size) +{ + struct dvbe_gem_object *obj; + + BUG_ON((size & (PAGE_SIZE - 1)) != 0); + + obj = kzalloc(sizeof(*obj), GFP_KERNEL); + if (!obj) + return NULL; + + if (drm_gem_object_init(ddev, &obj->base, size)) { + kfree(obj); + return NULL; + } + + return obj; +} + +/* + * First time user-space requests access to a gem object, we allocate an array + * of all backing pages so our page-fault handler can map them efficiently. + * shmem_read_mapping_page_gfp allocates missing pages with the given GFP mask + * which we deduce from the tmpfs-dentry object. + */ +static int dvbe_gem_get_pages(struct dvbe_gem_object *obj) +{ + size_t i, page_count = obj->base.size / PAGE_SIZE; + struct page *page; + struct address_space *mapping; + gfp_t gfp; + + if (obj->pages) + return 0; + + obj->pages = drm_malloc_ab(page_count, sizeof(struct page*)); + if (!obj->pages) + return -ENOMEM; + + mapping = obj->base.filp->f_path.dentry->d_inode->i_mapping; + gfp = mapping_gfp_mask(mapping) | GFP_KERNEL; + + for (i = 0; i < page_count; ++i) { + page = shmem_read_mapping_page_gfp(mapping, i, gfp); + if (IS_ERR(page)) + goto err_pages; + + obj->pages[i] = page; + } + + return 0; + +err_pages: + while (i--) + page_cache_release(obj->pages[i]); + drm_free_large(obj->pages); + obj->pages = NULL; + return PTR_ERR(page); +} + +static void dvbe_gem_put_pages(struct dvbe_gem_object *obj) +{ + size_t i, page_count = obj->base.size / PAGE_SIZE; + + if (!obj->pages) + return; + + for (i = 0; i < page_count; ++i) + page_cache_release(obj->pages[i]); + + drm_free_large(obj->pages); + obj->pages = NULL; +} + +int dvbe_gem_vmap(struct dvbe_gem_object *obj) +{ + int ret, page_count = obj->base.size / PAGE_SIZE; + + if (obj->vmapping) + return 0; + + ret = dvbe_gem_get_pages(obj); + if (ret) + return ret; + + obj->vmapping = vmap(obj->pages, page_count, 0, PAGE_KERNEL); + if (!obj->vmapping) + return -ENOMEM; + + return 0; +} + +void dvbe_gem_vunmap(struct dvbe_gem_object *obj) +{ + if (!obj->vmapping) + return; + + vunmap(obj->vmapping); + obj->vmapping = NULL; +} + +/* drm_gem_object_alloc() is not supported */ +int dvbe_gem_init_object(struct drm_gem_object *gobj) +{ + BUG(); + + return -EINVAL; +} + +void dvbe_gem_free_object(struct drm_gem_object *gobj) +{ + struct dvbe_gem_object *obj = to_dvbe_bo(gobj); + + if (gobj->map_list.map) + drm_gem_free_mmap_offset(gobj); + dvbe_gem_vunmap(obj); + dvbe_gem_put_pages(obj); + drm_gem_object_release(gobj); + kfree(obj); +} + +/* + * On page-faults we need to calculate the page-offset ourself as the vma-offset + * is based on the fake-offset of drm_mmap() instead of any real offset. + * We simply insert the page via vm_insert_page() as it has been marked as + * VM_MIXEDMAP in the vma. + */ +int dvbe_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf) +{ + struct dvbe_gem_object *obj = to_dvbe_bo(vma->vm_private_data); + unsigned long off, vaddr; + int ret; + + if (!obj->pages) + return VM_FAULT_SIGBUS; + + vaddr = (unsigned long)vmf->virtual_address; + off = (vaddr - vma->vm_start) >> PAGE_SHIFT; + + ret = vm_insert_page(vma, vaddr, obj->pages[off]); + switch (ret) { + case -ENOMEM: + return VM_FAULT_OOM; + case -EAGAIN: + set_need_resched(); + /* fallthrough */ + case -ERESTARTSYS: + case 0: + return VM_FAULT_NOPAGE; + } + + return VM_FAULT_SIGBUS; +} + +int dvbe_dumb_create(struct drm_file *dfile, struct drm_device *ddev, + struct drm_mode_create_dumb *args) +{ + struct dvbe_gem_object *obj; + int ret; + + args->pitch = args->width * ((args->bpp + 7) / 8); + args->size = args->pitch * args->height; + + if (!args->size) + return -EINVAL; + + args->size = roundup(args->size, PAGE_SIZE); + obj = dvbe_gem_alloc_object(ddev, args->size); + if (!obj) + return -ENOMEM; + + ret = drm_gem_handle_create(dfile, &obj->base, &args->handle); + if (ret) { + drm_gem_object_unreference(&obj->base); + return ret; + } + + drm_gem_object_unreference(&obj->base); + return 0; +} + +int dvbe_dumb_destroy(struct drm_file *dfile, struct drm_device *ddev, + uint32_t handle) +{ + return drm_gem_handle_delete(dfile, handle); +} + +int dvbe_dumb_map_offset(struct drm_file *dfile, struct drm_device *ddev, + uint32_t handle, uint64_t *offset) +{ + struct dvbe_gem_object *obj; + struct drm_gem_object *gobj; + int ret; + + mutex_lock(&ddev->struct_mutex); + gobj = drm_gem_object_lookup(ddev, dfile, handle); + if (!gobj) { + ret = -ENOENT; + goto out_unlock; + } + obj = to_dvbe_bo(gobj); + + ret = dvbe_gem_get_pages(obj); + if (ret) + goto out_unref; + + if (!gobj->map_list.map) { + ret = drm_gem_create_mmap_offset(gobj); + if (ret) + goto out_unref; + } + + *offset = gobj->map_list.hash.key << PAGE_SHIFT; + +out_unref: + drm_gem_object_unreference(gobj); +out_unlock: + mutex_unlock(&ddev->struct_mutex); + return ret; +} + +int dvbe_drm_mmap(struct file *filp, struct vm_area_struct *vma) +{ + int ret; + + ret = drm_gem_mmap(filp, vma); + if (ret) + return ret; + + vma->vm_flags &= ~VM_PFNMAP; + vma->vm_flags |= VM_MIXEDMAP; + vma->vm_page_prot = pgprot_writecombine(vm_get_page_prot(vma->vm_flags)); + + return ret; +}

This adds a new fbdev frontend to the dvbe driver. It allows userspace to access the dvbe driver via an fbdev frontend.

It is disabled by default so you can use dvbe without CONFIG_FB. It should only be used for backwards-compatibility. Use the DRM dumb API to access dvbe buffers properly.

Signed-off-by: David Herrmann dh.herrmann@gmail.com --- drivers/gpu/drm/dvbe/Kconfig | 18 +++ drivers/gpu/drm/dvbe/Makefile | 1 + drivers/gpu/drm/dvbe/dvbe.h | 23 ++++ drivers/gpu/drm/dvbe/dvbe_fbdev.c | 235 ++++++++++++++++++++++++++++++++++++++ drivers/gpu/drm/dvbe/dvbe_main.c | 2 + 5 files changed, 279 insertions(+) create mode 100644 drivers/gpu/drm/dvbe/dvbe_fbdev.c

diff --git a/drivers/gpu/drm/dvbe/Kconfig b/drivers/gpu/drm/dvbe/Kconfig index e49df10..ca27455 100644 --- a/drivers/gpu/drm/dvbe/Kconfig +++ b/drivers/gpu/drm/dvbe/Kconfig @@ -27,3 +27,21 @@ config DRM_DVBE

To compile this driver as a module, choose M here: the module will be called dvbe. + +config DRM_DVBE_FBDEV + bool "VESA BIOS Extension DRM fbdev Compatibility Layer" + depends on DRM_DVBE && FB + select FB_CFB_FILLRECT + select FB_CFB_COPYAREA + select FB_CFB_IMAGEBLIT + help + This provides an fbdev frontend (via /dev/fbX) for the DVBE VESA + driver. Old userspace that depends on the fbdev API can access the + DVBE driver this way. It provides full backwards compatibility to the + old vesafb driver. + + Newer userspace accesses graphics devices via the DRM API and the old + fbdev compatibility layer is not needed. Activate it only if you + really need to run old userspace programs. + + If unsure, say N. diff --git a/drivers/gpu/drm/dvbe/Makefile b/drivers/gpu/drm/dvbe/Makefile index f6fb888..e01aaa1 100644 --- a/drivers/gpu/drm/dvbe/Makefile +++ b/drivers/gpu/drm/dvbe/Makefile @@ -1,4 +1,5 @@ ccflags-y := -Iinclude/drm

dvbe-y := dvbe_drv.o dvbe_main.o dvbe_mem.o dvbe_vesa.o +dvbe-$(CONFIG_DRM_DVBE_FBDEV) += dvbe_fbdev.o obj-$(CONFIG_DRM_DVBE) := dvbe.o diff --git a/drivers/gpu/drm/dvbe/dvbe.h b/drivers/gpu/drm/dvbe/dvbe.h index 68fd452..dfe7c20 100644 --- a/drivers/gpu/drm/dvbe/dvbe.h +++ b/drivers/gpu/drm/dvbe/dvbe.h @@ -14,6 +14,7 @@ #define DVBE_DRV_H

#include <linux/errno.h> +#include <linux/fb.h> #include <linux/kernel.h> #include <linux/mm.h> #include <linux/module.h> @@ -47,6 +48,9 @@ struct dvbe_device { struct drm_encoder enc; struct drm_connector conn; struct drm_display_mode *mode; + + /* fbdev */ + void *fbdev; };

int dvbe_drm_load(struct drm_device *ddev, unsigned long flags); @@ -95,4 +99,23 @@ int dvbe_vesa_damage(struct dvbe_device *dvbe, struct dvbe_framebuffer *fb, unsigned int flags, unsigned int color, struct drm_clip_rect *clips, unsigned int num);

+/* fbdev helpers */ + +#ifdef CONFIG_DRM_DVBE_FBDEV + +void dvbe_fbdev_init(struct dvbe_device *dvbe); +void dvbe_fbdev_cleanup(struct dvbe_device *dvbe); + +#else /* CONFIG_DRM_DVBE_FBDEV */ + +static inline void dvbe_fbdev_init(struct dvbe_device *dvbe) +{ +} + +static inline void dvbe_fbdev_cleanup(struct dvbe_device *dvbe) +{ +} + +#endif /* CONFIG_DRM_DVBE_FBDEV */ + #endif /* DVBE_DRV_H */ diff --git a/drivers/gpu/drm/dvbe/dvbe_fbdev.c b/drivers/gpu/drm/dvbe/dvbe_fbdev.c new file mode 100644 index 0000000..0e22e12 --- /dev/null +++ b/drivers/gpu/drm/dvbe/dvbe_fbdev.c @@ -0,0 +1,235 @@ +/* + * DRM VESA BIOS Extension Driver + * Copyright (c) 2012-2013 David Herrmann dh.herrmann@gmail.com + */ + +/* + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; either version 2 of the License, or (at your option) + * any later version. + */ + +/* + * fbdev compatibility layer + * This provides an fbdev framebuffer device for the DVBE driver. It is + * based on the old vesafb.c driver: + * (c) 1998 Gerd Knorr kraxel@goldbach.in-berlin.de + */ + +#include <linux/errno.h> +#include <linux/kernel.h> +#include <linux/mm.h> +#include <linux/module.h> +#include <linux/string.h> +#include <linux/fb.h> +#include "dvbe.h" + +struct dvbe_fbdev { + struct dvbe_device *dvbe; + u32 palette[256]; +}; + +static int dvbe_fbdev_setcolreg(unsigned regno, unsigned red, unsigned green, + unsigned blue, unsigned transp, + struct fb_info *info) +{ + /* + * Set a single color register. The values supplied are + * already rounded down to the hardware's capabilities + * (according to the entries in the `var' structure). Return != 0 for + * invalid regno. + */ + + if (regno >= info->cmap.len) + return 1; + if (info->var.bits_per_pixel == 8) + return -EINVAL; + if (regno >= 16) + return 0; + + switch (info->var.bits_per_pixel) { + case 16: + if (info->var.red.offset == 10) { + /* 1:5:5:5 */ + ((u32*) (info->pseudo_palette))[regno] = + ((red & 0xf800) >> 1) | + ((green & 0xf800) >> 6) | + ((blue & 0xf800) >> 11); + } else { + /* 0:5:6:5 */ + ((u32*) (info->pseudo_palette))[regno] = + ((red & 0xf800) ) | + ((green & 0xfc00) >> 5) | + ((blue & 0xf800) >> 11); + } + break; + case 24: + case 32: + red >>= 8; + green >>= 8; + blue >>= 8; + ((u32*) (info->pseudo_palette))[regno] = + (red << info->var.red.offset) | + (green << info->var.green.offset) | + (blue << info->var.blue.offset); + break; + } + + return 0; +} + +static void dvbe_fbdev_free(struct dvbe_device *dvbe, struct fb_info *info) +{ + dev_info(dvbe->ddev->dev, "fbdev cleanup\n"); + fb_dealloc_cmap(&info->cmap); + framebuffer_release(info); +} + +static void dvbe_fbdev_destroy(struct fb_info *info) +{ + struct dvbe_fbdev *fb = info->par; + struct dvbe_device *dvbe = fb->dvbe; + + mutex_lock(&dvbe->ddev->struct_mutex); + info = dvbe->fbdev; + dvbe->fbdev = NULL; + mutex_unlock(&dvbe->ddev->struct_mutex); + + if (info) + dvbe_fbdev_free(dvbe, info); +} + +static struct fb_ops dvbe_fbdev_ops = { + .owner = THIS_MODULE, + .fb_destroy = dvbe_fbdev_destroy, + .fb_setcolreg = dvbe_fbdev_setcolreg, + .fb_fillrect = cfb_fillrect, + .fb_copyarea = cfb_copyarea, + .fb_imageblit = cfb_imageblit, +}; + +void dvbe_fbdev_init(struct dvbe_device *dvbe) +{ + struct dvbe_fbdev *fb; + struct fb_info *info; + int ret; + + info = framebuffer_alloc(sizeof(struct dvbe_fbdev), dvbe->ddev->dev); + if (!info) { + ret = -ENOMEM; + goto err_out; + } + + fb = info->par; + fb->dvbe = dvbe; + info->flags = FBINFO_FLAG_DEFAULT | FBINFO_MISC_FIRMWARE; + info->pseudo_palette = fb->palette; + info->screen_base = dvbe->vbe_map; + info->fbops = &dvbe_fbdev_ops; + + strncpy(info->fix.id, "dvbedrmfb", 15); + info->fix.type = FB_TYPE_PACKED_PIXELS; + info->fix.accel = FB_ACCEL_NONE; + info->fix.smem_start = (unsigned long)dvbe->vbe_addr; + info->fix.smem_len = dvbe->vbe_size; + info->fix.line_length = dvbe->vbe_stride; + + if (dvbe->vbe_bpp == 8) + info->fix.visual = FB_VISUAL_STATIC_PSEUDOCOLOR; + else + info->fix.visual = FB_VISUAL_TRUECOLOR; + + info->var.activate = FB_ACTIVATE_NOW; + info->var.vmode = FB_VMODE_NONINTERLACED; + info->var.bits_per_pixel = dvbe->vbe_bpp; + info->var.xres = dvbe->vbe_width; + info->var.yres = dvbe->vbe_height; + info->var.xres_virtual = info->var.xres; + info->var.yres_virtual = info->var.yres; + + /* some dummy values for timing to make fbset happy */ + info->var.pixclock = 10000000 / info->var.xres * 1000 / info->var.yres; + info->var.left_margin = (info->var.xres / 8) & 0xf8; + info->var.right_margin = 32; + info->var.upper_margin = 16; + info->var.lower_margin = 4; + info->var.hsync_len = (info->var.xres / 8) & 0xf8; + info->var.vsync_len = 4; + + info->var.red.offset = dvbe->vbe_red_pos; + info->var.red.length = dvbe->vbe_red_size; + info->var.green.offset = dvbe->vbe_green_pos; + info->var.green.length = dvbe->vbe_green_size; + info->var.blue.offset = dvbe->vbe_blue_pos; + info->var.blue.length = dvbe->vbe_blue_size; + + if (info->var.bits_per_pixel <= 8) { + info->var.red.length = info->var.bits_per_pixel; + info->var.green.length = info->var.bits_per_pixel; + info->var.blue.length = info->var.bits_per_pixel; + } + + info->apertures = alloc_apertures(1); + if (!info->apertures) { + ret = -ENOMEM; + goto err_free; + } + info->apertures->ranges[0].base = (unsigned long)dvbe->vbe_addr; + info->apertures->ranges[0].size = dvbe->vbe_vsize; + + ret = fb_alloc_cmap(&info->cmap, 256, 0); + if (ret < 0) + goto err_free; + + /* + * TODO: Fix register_framebuffer() to not reset refcounts! + * So register_framebuffer() resets the refcnt of \info to 1. However, + * any other context might call remove_conflicting_framebuffers() + * before our call to register_framebuffer() returns. + * remove_conflicting_framebuffers() calls unregister_framebuffer() + * which then calls put_fb_info() and destroys \info by calling our + * fb_destroy() callback. + * To summarize, \info might be dead after register_framebuffer() + * returns so don't access it afterwards. There is _no_ reliable way to + * detect that so don't use \info at all now. + * Instead we lock all accesses around dvbe->fbdev and the first one who + * resets it is responsible of freeing it. + */ + + dvbe->fbdev = info; + ret = register_framebuffer(info); + if (ret < 0) + goto err_cmap; + + mutex_lock(&dvbe->ddev->struct_mutex); + if (dvbe->fbdev) + dev_info(dvbe->ddev->dev, "fbdev frontend %s as fb%d\n", + info->fix.id, info->node); + mutex_unlock(&dvbe->ddev->struct_mutex); + + return; + +err_cmap: + fb_dealloc_cmap(&info->cmap); +err_free: + framebuffer_release(info); +err_out: + dev_warn(dvbe->ddev->dev, "cannot create fbdev frontend (%d)\n", ret); +} + +void dvbe_fbdev_cleanup(struct dvbe_device *dvbe) +{ + struct fb_info *info; + + mutex_lock(&dvbe->ddev->struct_mutex); + info = dvbe->fbdev; + dvbe->fbdev = NULL; + mutex_unlock(&dvbe->ddev->struct_mutex); + + if (!info) + return; + + unregister_framebuffer(info); + dvbe_fbdev_free(dvbe, info); +} diff --git a/drivers/gpu/drm/dvbe/dvbe_main.c b/drivers/gpu/drm/dvbe/dvbe_main.c index c418310..95241a6 100644 --- a/drivers/gpu/drm/dvbe/dvbe_main.c +++ b/drivers/gpu/drm/dvbe/dvbe_main.c @@ -408,6 +408,7 @@ int dvbe_drm_load(struct drm_device *ddev, unsigned long flags) if (ret) goto err_cleanup;

+ dvbe_fbdev_init(dvbe); return 0;

err_cleanup: @@ -422,6 +423,7 @@ int dvbe_drm_unload(struct drm_device *ddev) { struct dvbe_device *dvbe = ddev->dev_private;

+ dvbe_fbdev_cleanup(dvbe); drm_mode_config_cleanup(ddev); dvbe_vesa_cleanup(dvbe); kfree(dvbe);