There's an fbdevdrm device for each supported fbdev device. The fbdevdrm driver listens for fb events, and creates and destroys fbdevdrm devices accordingly.

Only hardware-specific fbdev drivers are supported. Generic drivers, such as vga16fb or vesafb are not handled. DRM-based fbdev drivers are also not supported. This prevents the situation where a DRM drivers enables framebuffer emulation and fbdevdrm creates a second DRM device for the same hardware.

Signed-off-by: Thomas Zimmermann tzimmermann@suse.de --- drivers/gpu/drm/fbdevdrm/Makefile | 3 +- drivers/gpu/drm/fbdevdrm/fbdevdrm_device.c | 79 ++++++++++ drivers/gpu/drm/fbdevdrm/fbdevdrm_device.h | 44 ++++++ drivers/gpu/drm/fbdevdrm/fbdevdrm_drv.c | 173 ++++++++++++++++++++- 4 files changed, 296 insertions(+), 3 deletions(-) create mode 100644 drivers/gpu/drm/fbdevdrm/fbdevdrm_device.c create mode 100644 drivers/gpu/drm/fbdevdrm/fbdevdrm_device.h

diff --git a/drivers/gpu/drm/fbdevdrm/Makefile b/drivers/gpu/drm/fbdevdrm/Makefile index 65e6b43cf682..750940d38509 100644 --- a/drivers/gpu/drm/fbdevdrm/Makefile +++ b/drivers/gpu/drm/fbdevdrm/Makefile @@ -1,4 +1,5 @@ ccflags-y = -Iinclude/drm -fbdevdrm-y := fbdevdrm_drv.o +fbdevdrm-y := fbdevdrm_device.o \ + fbdevdrm_drv.o

obj-$(CONFIG_DRM_FBDEVDRM) += fbdevdrm.o diff --git a/drivers/gpu/drm/fbdevdrm/fbdevdrm_device.c b/drivers/gpu/drm/fbdevdrm/fbdevdrm_device.c new file mode 100644 index 000000000000..0abf41cf05bb --- /dev/null +++ b/drivers/gpu/drm/fbdevdrm/fbdevdrm_device.c @@ -0,0 +1,79 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * + * One purpose of this driver is to allow for easy conversion of framebuffer + * drivers to DRM. As a special exception to the GNU GPL, you are allowed to + * relicense this file under the terms of a license of your choice if you're + * porting a framebuffer driver. In order to do so, update the SPDX license + * identifier to the new license and remove this exception. + * + * If you add code to this file, please ensure that it's compatible with the + * stated exception. + */ + +#include "fbdevdrm_device.h" +#include <drm/drm_drv.h> +#include <drm/drm_modeset_helper.h> +#include <drm/drm_print.h> +#include <linux/fb.h> +#include <linux/pci.h> + +/* + * struct fbdrmdev_device + */ + +int fbdevdrm_device_init(struct fbdevdrm_device *fdev, struct drm_driver *drv, + struct fb_info *fb_info) +{ + int ret; + + ret = drm_dev_init(&fdev->dev, drv, fb_info->device); + if (ret) + return ret; + fdev->dev.dev_private = fdev; + fdev->dev.pdev = container_of(fb_info->device, struct pci_dev, dev); + fdev->fb_info = fb_info; + + INIT_LIST_HEAD(&fdev->device_list); + + return 0; +} + +void fbdevdrm_device_cleanup(struct fbdevdrm_device *fdev) +{ + struct drm_device *dev = &fdev->dev; + + if (!list_empty(&fdev->device_list)) { + DRM_ERROR("fbdevdrm: cleaned up device is still enqueued " + "in device list\n"); + } + + drm_dev_fini(dev); + dev->dev_private = NULL; +} + +struct fbdevdrm_device* fbdevdrm_device_create(struct drm_driver *drv, + struct fb_info *fb_info) +{ + struct fbdevdrm_device *fdev; + int ret; + + fdev = devm_kzalloc(fb_info->dev, sizeof(*fdev), GFP_KERNEL); + if (!fdev) + return ERR_PTR(-ENOMEM); + ret = fbdevdrm_device_init(fdev, drv, fb_info); + if (ret < 0) + goto err_devm_kfree; + return fdev; + +err_devm_kfree: + devm_kfree(fb_info->dev, fdev); + return ERR_PTR(ret); +} + +void fbdevdrm_device_destroy(struct fbdevdrm_device *fdev) +{ + struct device *dev = fdev->fb_info->dev; + + fbdevdrm_device_cleanup(fdev); + devm_kfree(dev, fdev); +} diff --git a/drivers/gpu/drm/fbdevdrm/fbdevdrm_device.h b/drivers/gpu/drm/fbdevdrm/fbdevdrm_device.h new file mode 100644 index 000000000000..85878f60bba4 --- /dev/null +++ b/drivers/gpu/drm/fbdevdrm/fbdevdrm_device.h @@ -0,0 +1,44 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * + * One purpose of this driver is to allow for easy conversion of framebuffer + * drivers to DRM. As a special exception to the GNU GPL, you are allowed to + * relicense this file under the terms of a license of your choice if you're + * porting a framebuffer driver. In order to do so, update the SPDX license + * identifier to the new license and remove this exception. + * + * If you add code to this file, please ensure that it's compatible with the + * stated exception. + */ + +#ifndef FBDEVDRM_DEVICE_H +#define FBDEVDRM_DEVICE_H + +#include <drm/drm_device.h> +#include <linux/kernel.h> +#include <linux/list.h> + +struct drm_driver; +struct fb_info; + +struct fbdevdrm_device { + struct drm_device dev; + struct fb_info *fb_info; + + struct list_head device_list; /* entry in global device list */ +}; + +static inline struct fbdevdrm_device* fbdevdrm_device_of_device_list( + struct list_head *device_list) +{ + return list_entry(device_list, struct fbdevdrm_device, device_list); +} + +int fbdevdrm_device_init(struct fbdevdrm_device *fdev, struct drm_driver *drv, + struct fb_info *fb_info); +void fbdevdrm_device_cleanup(struct fbdevdrm_device *fdev); + +struct fbdevdrm_device* fbdevdrm_device_create(struct drm_driver *drv, + struct fb_info *fb_info); +void fbdevdrm_device_destroy(struct fbdevdrm_device *fdev); + +#endif diff --git a/drivers/gpu/drm/fbdevdrm/fbdevdrm_drv.c b/drivers/gpu/drm/fbdevdrm/fbdevdrm_drv.c index dcb263b0c386..5be902094dc6 100644 --- a/drivers/gpu/drm/fbdevdrm/fbdevdrm_drv.c +++ b/drivers/gpu/drm/fbdevdrm/fbdevdrm_drv.c @@ -10,8 +10,13 @@ * stated exception. */

+#include <drm/drm_drv.h> +#include <drm/drm_print.h> +#include <linux/console.h> /* for console_{un/lock}() */ #include <linux/fb.h> #include <linux/module.h> +#include <linux/mutex.h> +#include "fbdevdrm_device.h"

/* DRM porting note: Here are some general information about the driver, * licensing and maintenance contact. If you're porting an fbdev driver @@ -29,18 +34,156 @@ #define DRIVER_MINOR 0 #define DRIVER_PATCHLEVEL 1

+/* + * DRM driver + */ + +static struct drm_driver fbdevdrm_drv = { + /* data fields */ + .major = DRIVER_MAJOR, + .minor = DRIVER_MINOR, + .patchlevel = DRIVER_PATCHLEVEL, + .name = DRIVER_NAME, + .desc = DRIVER_DESCRIPTION, + .date = DRIVER_DATE +}; + +/* Device list */ + +static DEFINE_MUTEX(device_list_mutex); +static LIST_HEAD(device_list); + +static void device_list_add(struct fbdevdrm_device *fdev) +{ + mutex_lock(&device_list_mutex); + list_add(&fdev->device_list, &device_list); + mutex_unlock(&device_list_mutex); +} + +static struct fbdevdrm_device* device_list_del(struct fbdevdrm_device *fdev) +{ + mutex_lock(&device_list_mutex); + list_del(&fdev->device_list); + mutex_unlock(&device_list_mutex); + + return fdev; +} + +static struct fbdevdrm_device* device_list_find_by_fb_info( + const struct fb_info *fb_info) +{ + struct list_head *pos; + struct fbdevdrm_device *fdev = NULL; + + mutex_lock(&device_list_mutex); + list_for_each(pos, &device_list) { + struct fbdevdrm_device *pos_fdev = + fbdevdrm_device_of_device_list(pos); + if (pos_fdev->fb_info == fb_info) { + fdev = pos_fdev; + goto out; + } + } +out: + mutex_unlock(&device_list_mutex); + return fdev; +} + /* Module entry points */

+static bool is_generic_driver(const struct fb_info *fb_info) +{ + /* DRM porting note: We don't want to bind to vga16fb, vesafb, or any + * other generic fbdev driver. Usually, these drivers have limited + * capabilitis. We only continue if the fix structure indicates a + * hardware-specific drivers . This test will also sort out drivers + * registered via DRM's fbdev emulation. If you're porting an fbdev + * driver to DRM, you can remove this test. The module's PCI device + * ids will contain this information. + */ + return !fb_info->fix.accel && + !!strcmp(fb_info->fix.id, "S3 Virge/DX"); +} + +static int on_fb_registered(struct fb_info *fb_info, void *data) +{ + struct fbdevdrm_device *fdev; + int ret; + + if (is_generic_driver(fb_info)) { + DRM_ERROR("fbdevdrm: not binding to %s\n", fb_info->fix.id); + return 0; + } + + fdev = fbdevdrm_device_create(&fbdevdrm_drv, fb_info); + if (IS_ERR(fdev)) + return PTR_ERR(fdev); + device_list_add(fdev); + + ret = drm_dev_register(&fdev->dev, 0); + if (ret) + goto err_device_list_del; + + return 0; + +err_device_list_del: + device_list_del(fdev); + fbdevdrm_device_destroy(fdev); + return ret; +} + +static int on_fb_unregistered(struct fb_info *fb_info, void *data) +{ + struct fbdevdrm_device *fdev; + + fdev = device_list_find_by_fb_info(fb_info); + if (!fdev) + return 0; + + device_list_del(fdev); + fbdevdrm_device_destroy(fdev); + + return 0; +} + static int fb_client_notifier_call(struct notifier_block *nb, unsigned long action, void *data) { + static const char* const event_name[] = { +#define EVENT_NAME(_ev) \ + [_ev] = #_ev + EVENT_NAME(FB_EVENT_MODE_CHANGE), + EVENT_NAME(FB_EVENT_SUSPEND), + EVENT_NAME(FB_EVENT_RESUME), + EVENT_NAME(FB_EVENT_MODE_DELETE), + EVENT_NAME(FB_EVENT_FB_REGISTERED), + EVENT_NAME(FB_EVENT_FB_UNREGISTERED), + EVENT_NAME(FB_EVENT_GET_CONSOLE_MAP), + EVENT_NAME(FB_EVENT_SET_CONSOLE_MAP), + EVENT_NAME(FB_EVENT_BLANK), + EVENT_NAME(FB_EVENT_NEW_MODELIST), + EVENT_NAME(FB_EVENT_MODE_CHANGE_ALL), + EVENT_NAME(FB_EVENT_CONBLANK), + EVENT_NAME(FB_EVENT_GET_REQ), + EVENT_NAME(FB_EVENT_FB_UNBIND), + EVENT_NAME(FB_EVENT_REMAP_ALL_CONSOLE), + EVENT_NAME(FB_EARLY_EVENT_BLANK), + EVENT_NAME(FB_R_EARLY_EVENT_BLANK) +#undef EVENT_NAME + }; + static int (* const on_event[])(struct fb_info*, void*) = { + [FB_EVENT_FB_REGISTERED] = on_fb_registered, + [FB_EVENT_FB_UNREGISTERED] = on_fb_unregistered };

const struct fb_event *event = data;

- if ((action >= ARRAY_SIZE(on_event)) || !on_event[action]) + if ((action >= ARRAY_SIZE(on_event)) || !on_event[action]) { + DRM_ERROR("fbdevdrm: unhandled event %s\n", + event_name[action]); return 0; /* event not handled by us */ + } return on_event[action](event->info, event->data); }

@@ -50,13 +193,39 @@ static struct notifier_block fb_client = {

static int __init fbdevdrm_init(void) { - int ret; + int ret, i;

ret = fb_register_client(&fb_client); if (ret < 0) return ret;

+ /* There might already be registered FB devices. We go + * through them manually to create a corresponding DRM + * device. For the event notifier, all the locking is + * performed by the fbdev framework. Here, we have to + * do it by ourselves. */ + + console_lock(); + + for_each_registered_fb(i) { + struct fb_info *fb_info = registered_fb[i]; + if (!lock_fb_info(fb_info)) { + ret = -ENODEV; + goto err_console_unlock; + } + ret = on_fb_registered(fb_info, NULL); + unlock_fb_info(fb_info); + if (ret < 0) + goto err_console_unlock; + } + + console_unlock(); + return 0; + +err_console_unlock: + console_unlock(); + return ret; }

static void __exit fbdevdrm_exit(void)

Memory management in fbdevdrm is provided by TTM. Fbdev implements page flipping via display pan operations, which require scanout buffers to be aligned at scanline boundaries. At the same time memory-mapping operations of individual buffers requires page alignment of each buffer. Fbdevdrm ensures that both requirements are met.

Signed-off-by: Thomas Zimmermann tzimmermann@suse.de --- drivers/gpu/drm/fbdevdrm/Makefile | 6 +- drivers/gpu/drm/fbdevdrm/fbdevdrm_bo.c | 276 +++++++++++++++++++++ drivers/gpu/drm/fbdevdrm/fbdevdrm_bo.h | 58 +++++ drivers/gpu/drm/fbdevdrm/fbdevdrm_device.c | 10 + drivers/gpu/drm/fbdevdrm/fbdevdrm_device.h | 9 + drivers/gpu/drm/fbdevdrm/fbdevdrm_ttm.c | 202 +++++++++++++++ drivers/gpu/drm/fbdevdrm/fbdevdrm_ttm.h | 35 +++ 7 files changed, 594 insertions(+), 2 deletions(-) create mode 100644 drivers/gpu/drm/fbdevdrm/fbdevdrm_bo.c create mode 100644 drivers/gpu/drm/fbdevdrm/fbdevdrm_bo.h create mode 100644 drivers/gpu/drm/fbdevdrm/fbdevdrm_ttm.c create mode 100644 drivers/gpu/drm/fbdevdrm/fbdevdrm_ttm.h

diff --git a/drivers/gpu/drm/fbdevdrm/Makefile b/drivers/gpu/drm/fbdevdrm/Makefile index 750940d38509..fdfdb5233831 100644 --- a/drivers/gpu/drm/fbdevdrm/Makefile +++ b/drivers/gpu/drm/fbdevdrm/Makefile @@ -1,5 +1,7 @@ ccflags-y = -Iinclude/drm -fbdevdrm-y := fbdevdrm_device.o \ - fbdevdrm_drv.o +fbdevdrm-y := fbdevdrm_bo.o \ + fbdevdrm_device.o \ + fbdevdrm_drv.o \ + fbdevdrm_ttm.o

obj-$(CONFIG_DRM_FBDEVDRM) += fbdevdrm.o diff --git a/drivers/gpu/drm/fbdevdrm/fbdevdrm_bo.c b/drivers/gpu/drm/fbdevdrm/fbdevdrm_bo.c new file mode 100644 index 000000000000..78370db6c504 --- /dev/null +++ b/drivers/gpu/drm/fbdevdrm/fbdevdrm_bo.c @@ -0,0 +1,276 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * + * One purpose of this driver is to allow for easy conversion of framebuffer + * drivers to DRM. As a special exception to the GNU GPL, you are allowed to + * relicense this file under the terms of a license of your choice if you're + * porting a framebuffer driver. In order to do so, update the SPDX license + * identifier to the new license and remove this exception. + * + * If you add code to this file, please ensure that it's compatible with the + * stated exception. + */ + +#include "fbdevdrm_bo.h" +#include "fbdevdrm_device.h" + +static void fbdevdrm_bo_cleanup(struct fbdevdrm_bo *fbo) +{ + drm_gem_object_release(&fbo->gem); +} + +static void fbdevdrm_bo_destroy(struct fbdevdrm_bo *fbo) +{ + /* We got here via ttm_bo_put(), which means that the + * TTM buffer object in 'bo' has already been cleaned + * up. */ + + fbdevdrm_bo_cleanup(fbo); + kfree(fbo); +} + +static void fbdevdrm_bo_ttm_destroy(struct ttm_buffer_object *bo) +{ + struct fbdevdrm_bo *fbo = fbdevdrm_bo_of_bo(bo); + fbdevdrm_bo_destroy(fbo); +} + +static void fbdevdrm_bo_ttm_placement(struct fbdevdrm_bo *bo, int pl_flag) +{ + unsigned int i; + unsigned int c = 0; + + bo->placement.placement = bo->placements; + bo->placement.busy_placement = bo->placements; + + if (pl_flag & TTM_PL_FLAG_VRAM) + bo->placements[c++].flags = TTM_PL_FLAG_WC | TTM_PL_FLAG_UNCACHED | TTM_PL_FLAG_VRAM; + + if (pl_flag & TTM_PL_FLAG_SYSTEM) + bo->placements[c++].flags = TTM_PL_MASK_CACHING | TTM_PL_FLAG_SYSTEM; + + if (!c) + bo->placements[c++].flags = TTM_PL_MASK_CACHING | TTM_PL_FLAG_SYSTEM; + + bo->placement.num_placement = c; + bo->placement.num_busy_placement = c; + + for (i = 0; i < c; ++i) { + bo->placements[i].fpfn = 0; + bo->placements[i].lpfn = 0; + } +} + +static int fbdevdrm_bo_init(struct fbdevdrm_bo *fbo, struct drm_device *dev, + int size, int align, uint32_t flags) +{ + struct fbdevdrm_device *fdev; + int ret; + size_t acc_size; + + fdev = fbdevdrm_device_of_dev(dev); + + ret = drm_gem_object_init(dev, &fbo->gem, size); + if (ret < 0) + return ret; + + fbo->bo.bdev = &fdev->ttm.bdev; + + fbdevdrm_bo_ttm_placement(fbo, TTM_PL_FLAG_VRAM | TTM_PL_FLAG_SYSTEM); + + acc_size = ttm_bo_dma_acc_size(&fdev->ttm.bdev, size, sizeof(*fbo)); + + ret = ttm_bo_init(&fdev->ttm.bdev, &fbo->bo, size, + ttm_bo_type_device, &fbo->placement, + align >> PAGE_SHIFT, false, acc_size, + NULL, NULL, fbdevdrm_bo_ttm_destroy); + if (ret < 0) + goto err_drm_gem_object_release; + + return 0; + +err_drm_gem_object_release: + drm_gem_object_release(&fbo->gem); + return ret; +} + +/* Returns the least common multiple of a value and the page size + */ +static u32 lcm_with_page_size(u32 size) +{ + if (!size) + return size; /* 0 is always correct */ + while (size && (size & ~PAGE_MASK)) + size <<= 1; + if (!size) + return (u32)-EINVAL; /* no common multiple found */ + return size; +} + +static int fbdevdrm_bo_init_with_pitch(struct fbdevdrm_bo *fbo, + struct drm_device *dev, int size, + int pitch, uint32_t flags) +{ + u32 align = lcm_with_page_size(pitch); + if (align == (u32)-EINVAL) { + DRM_ERROR("fbdevdrm: buffer pitch of %d bytes has no " + "common multiple with page size.\n", pitch); + return -EINVAL; + } + + return fbdevdrm_bo_init(fbo, dev, size, align, flags); +} + +/* + * Public interface + */ + +struct fbdevdrm_bo* fbdevdrm_bo_create(struct drm_device *dev, int size, + int align, uint32_t flags) +{ + struct fbdevdrm_bo *fbo; + int ret; + + fbo = kzalloc(sizeof(*fbo), GFP_KERNEL); + if (!fbo) + return ERR_PTR(-ENOMEM); + + ret = fbdevdrm_bo_init(fbo, dev, size, align, flags); + if (ret < 0) + goto err_kfree; + + return fbo; + +err_kfree: + kfree(fbo); + return ERR_PTR(ret); +} + +struct fbdevdrm_bo* fbdevdrm_bo_create_with_pitch(struct drm_device *dev, + int size, int pitch, + uint32_t flags) +{ + struct fbdevdrm_bo *fbo; + int ret; + + fbo = kzalloc(sizeof(*fbo), GFP_KERNEL); + if (!fbo) + return ERR_PTR(-ENOMEM); + + ret = fbdevdrm_bo_init_with_pitch(fbo, dev, size, pitch, flags); + if (ret < 0) + goto err_kfree; + + return fbo; + +err_kfree: + kfree(fbo); + return ERR_PTR(ret); +} + +void fbdevdrm_bo_put(struct fbdevdrm_bo *fbo) +{ + ttm_bo_put(&fbo->bo); +} + +int fbdevdrm_bo_reserve(struct fbdevdrm_bo *fbo, bool no_wait) +{ + int ret; + + ret = ttm_bo_reserve(&fbo->bo, true, no_wait, NULL); + if (ret < 0) { + if (ret != -ERESTARTSYS && ret != -EBUSY) + DRM_ERROR("fbdevdrm: ttm_bo_reserve(%p) failed," + " error %d\n", fbo, -ret); + return ret; + } + return 0; +} + +void fbdevdrm_bo_unreserve(struct fbdevdrm_bo *fbo) +{ + ttm_bo_unreserve(&fbo->bo); +} + +u64 fbdevdrm_bo_mmap_offset(struct fbdevdrm_bo *fbo) +{ + return drm_vma_node_offset_addr(&fbo->bo.vma_node); +} + +int fbdevdrm_bo_pin(struct fbdevdrm_bo *fbo, u32 pl_flag) +{ + int i, ret; + struct ttm_operation_ctx ctx = { false, false }; + + if (fbo->pin_count) { + ++fbo->pin_count; + return 0; + } + + fbdevdrm_bo_ttm_placement(fbo, pl_flag); + for (i = 0; i < fbo->placement.num_placement; ++i) + fbo->placements[i].flags |= TTM_PL_FLAG_NO_EVICT; + + ret = ttm_bo_validate(&fbo->bo, &fbo->placement, &ctx); + if (ret < 0) { + DRM_ERROR("fbdevdrm: ttm_bo_validate failed, error %d\n", -ret); + return ret; + } + + fbo->pin_count = 1; + + return 0; +} + +int fbdevdrm_bo_unpin(struct fbdevdrm_bo *fbo) +{ + int i, ret; + struct ttm_operation_ctx ctx = { false, false }; + + if (!fbo->pin_count) { + DRM_ERROR("fbdevdrm: BO %p is not pinned \n", fbo); + return 0; + } + --fbo->pin_count; + if (fbo->pin_count) + return 0; + + for (i = 0; i < fbo->placement.num_placement ; ++i) + fbo->placements[i].flags &= ~TTM_PL_FLAG_NO_EVICT; + + ret = ttm_bo_validate(&fbo->bo, &fbo->placement, &ctx); + if (ret < 0) { + DRM_ERROR("fbdevdrm: ttm_bo_validate failed, error %d\n", -ret); + return ret; + } + + return 0; +} + +int fbdevdrm_bo_push_to_system(struct fbdevdrm_bo *fbo) +{ + int i, ret; + struct ttm_operation_ctx ctx = { false, false }; + + if (!fbo->pin_count) { + DRM_ERROR("fbdevdrm: BO %p is not pinned \n", fbo); + return 0; + } + --fbo->pin_count; + if (fbo->pin_count) + return 0; + + if (fbo->kmap.virtual) + ttm_bo_kunmap(&fbo->kmap); + + fbdevdrm_bo_ttm_placement(fbo, TTM_PL_FLAG_SYSTEM); + for (i = 0; i < fbo->placement.num_placement ; ++i) + fbo->placements[i].flags |= TTM_PL_FLAG_NO_EVICT; + + ret = ttm_bo_validate(&fbo->bo, &fbo->placement, &ctx); + if (ret) { + DRM_ERROR("fbdevdrm: ttm_bo_validate failed, error %d\n", -ret); + return ret; + } + + return 0; +} diff --git a/drivers/gpu/drm/fbdevdrm/fbdevdrm_bo.h b/drivers/gpu/drm/fbdevdrm/fbdevdrm_bo.h new file mode 100644 index 000000000000..7602a0fbd6a5 --- /dev/null +++ b/drivers/gpu/drm/fbdevdrm/fbdevdrm_bo.h @@ -0,0 +1,58 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * + * One purpose of this driver is to allow for easy conversion of framebuffer + * drivers to DRM. As a special exception to the GNU GPL, you are allowed to + * relicense this file under the terms of a license of your choice if you're + * porting a framebuffer driver. In order to do so, update the SPDX license + * identifier to the new license and remove this exception. + * + * If you add code to this file, please ensure that it's compatible with the + * stated exception. + */ + +#ifndef FBDEVDRM_BO_H +#define FBDEVDRM_BO_H + +#include <drm/drm_gem.h> +#include <drm/ttm/ttm_bo_api.h> +#include <drm/ttm/ttm_placement.h> +#include <linux/kernel.h> /* for container_of() */ + +struct fbdevdrm_bo { + struct ttm_buffer_object bo; + struct ttm_placement placement; + struct ttm_bo_kmap_obj kmap; + struct drm_gem_object gem; + + /* Supported placements are VRAM and SYSTEM */ + struct ttm_place placements[3]; + int pin_count; +}; + +static inline struct fbdevdrm_bo* fbdevdrm_bo_of_bo( + struct ttm_buffer_object *bo) +{ + return container_of(bo, struct fbdevdrm_bo, bo); +} + +static inline struct fbdevdrm_bo* fbdevdrm_bo_of_gem( + struct drm_gem_object *gem) +{ + return container_of(gem, struct fbdevdrm_bo, gem); +} + +struct fbdevdrm_bo* fbdevdrm_bo_create(struct drm_device *dev, int size, + int align, uint32_t flags); +struct fbdevdrm_bo* fbdevdrm_bo_create_with_pitch(struct drm_device *dev, + int size, int pitch, + uint32_t flags); +void fbdevdrm_bo_put(struct fbdevdrm_bo *fbo); + +int fbdevdrm_bo_reserve(struct fbdevdrm_bo *fbo, bool no_wait); +void fbdevdrm_bo_unreserve(struct fbdevdrm_bo *fbo); +u64 fbdevdrm_bo_mmap_offset(struct fbdevdrm_bo *fbo); +int fbdevdrm_bo_pin(struct fbdevdrm_bo *fbo, u32 pl_flag); +int fbdevdrm_bo_unpin(struct fbdevdrm_bo *fbo); +int fbdevdrm_bo_push_to_system(struct fbdevdrm_bo *fbo); + +#endif diff --git a/drivers/gpu/drm/fbdevdrm/fbdevdrm_device.c b/drivers/gpu/drm/fbdevdrm/fbdevdrm_device.c index 0abf41cf05bb..c8054eac271d 100644 --- a/drivers/gpu/drm/fbdevdrm/fbdevdrm_device.c +++ b/drivers/gpu/drm/fbdevdrm/fbdevdrm_device.c @@ -33,9 +33,17 @@ int fbdevdrm_device_init(struct fbdevdrm_device *fdev, struct drm_driver *drv, fdev->dev.pdev = container_of(fb_info->device, struct pci_dev, dev); fdev->fb_info = fb_info;

+ ret = fbdevdrm_ttm_init(&fdev->ttm, &fdev->dev, fb_info); + if (ret) + goto err_drm_dev_fini; + INIT_LIST_HEAD(&fdev->device_list);

return 0; + +err_drm_dev_fini: + drm_dev_fini(&fdev->dev); + return ret; }

void fbdevdrm_device_cleanup(struct fbdevdrm_device *fdev) @@ -47,6 +55,8 @@ void fbdevdrm_device_cleanup(struct fbdevdrm_device *fdev) "in device list\n"); }

+ fbdevdrm_ttm_cleanup(&fdev->ttm); + drm_dev_fini(dev); dev->dev_private = NULL; } diff --git a/drivers/gpu/drm/fbdevdrm/fbdevdrm_device.h b/drivers/gpu/drm/fbdevdrm/fbdevdrm_device.h index 85878f60bba4..381d9cfb1450 100644 --- a/drivers/gpu/drm/fbdevdrm/fbdevdrm_device.h +++ b/drivers/gpu/drm/fbdevdrm/fbdevdrm_device.h @@ -16,6 +16,7 @@ #include <drm/drm_device.h> #include <linux/kernel.h> #include <linux/list.h> +#include "fbdevdrm_ttm.h"

struct drm_driver; struct fb_info; @@ -24,6 +25,8 @@ struct fbdevdrm_device { struct drm_device dev; struct fb_info *fb_info;

+ struct fbdevdrm_ttm ttm; + struct list_head device_list; /* entry in global device list */ };

@@ -33,6 +36,12 @@ static inline struct fbdevdrm_device* fbdevdrm_device_of_device_list( return list_entry(device_list, struct fbdevdrm_device, device_list); }

+static inline struct fbdevdrm_device* fbdevdrm_device_of_dev( + struct drm_device *dev) +{ + return container_of(dev, struct fbdevdrm_device, dev); +} + int fbdevdrm_device_init(struct fbdevdrm_device *fdev, struct drm_driver *drv, struct fb_info *fb_info); void fbdevdrm_device_cleanup(struct fbdevdrm_device *fdev); diff --git a/drivers/gpu/drm/fbdevdrm/fbdevdrm_ttm.c b/drivers/gpu/drm/fbdevdrm/fbdevdrm_ttm.c new file mode 100644 index 000000000000..f7aeff755c30 --- /dev/null +++ b/drivers/gpu/drm/fbdevdrm/fbdevdrm_ttm.c @@ -0,0 +1,202 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * + * One purpose of this driver is to allow for easy conversion of framebuffer + * drivers to DRM. As a special exception to the GNU GPL, you are allowed to + * relicense this file under the terms of a license of your choice if you're + * porting a framebuffer driver. In order to do so, update the SPDX license + * identifier to the new license and remove this exception. + * + * If you add code to this file, please ensure that it's compatible with the + * stated exception. + */ + +#include "fbdevdrm_ttm.h" +#include <drm/drmP.h> +#include <drm/ttm/ttm_page_alloc.h> +#include "fbdevdrm_bo.h" + +static struct fbdevdrm_ttm* fbdevdrm_ttm_of_bdev( + struct ttm_bo_device *bdev) +{ + return container_of(bdev, struct fbdevdrm_ttm, bdev); +} + +/* + * TTM BO device + */ + +static void fbdevdrm_ttm_backend_destroy(struct ttm_tt *tt) +{ + ttm_tt_fini(tt); + kfree(tt); +} + +static struct ttm_backend_func fbdevdrm_ttm_backend_func = { + .destroy = fbdevdrm_ttm_backend_destroy +}; + +static struct ttm_tt *fbdevdrm_ttm_tt_create(struct ttm_buffer_object *bo, + uint32_t page_flags) +{ + struct ttm_tt *tt; + int ret; + + tt = kzalloc(sizeof(*tt), GFP_KERNEL); + if (!tt) + return NULL; + + tt->func = &fbdevdrm_ttm_backend_func; + + ret = ttm_tt_init(tt, bo, page_flags); + if (ret < 0) + goto err_ttm_tt_init; + + return tt; + +err_ttm_tt_init: + kfree(tt); + return NULL; +} + +static int fbdevdrm_bo_init_mem_type(struct ttm_bo_device *bdev, uint32_t type, + struct ttm_mem_type_manager *man) +{ + switch (type) { + case TTM_PL_SYSTEM: + man->flags = TTM_MEMTYPE_FLAG_MAPPABLE; + man->available_caching = TTM_PL_MASK_CACHING; + man->default_caching = TTM_PL_FLAG_CACHED; + break; + case TTM_PL_VRAM: + man->func = &ttm_bo_manager_func; + man->flags = TTM_MEMTYPE_FLAG_FIXED | + TTM_MEMTYPE_FLAG_MAPPABLE; + man->available_caching = TTM_PL_FLAG_UNCACHED | + TTM_PL_FLAG_WC; + man->default_caching = TTM_PL_FLAG_WC; + break; + default: + DRM_ERROR("fbdevdrm: Unsupported memory type %u\n", (unsigned)type); + return -EINVAL; + } + return 0; +} + +static void fbdevdrm_bo_evict_flags(struct ttm_buffer_object *bo, + struct ttm_placement *pl) +{ } + +static int fbdevdrm_bo_verify_access(struct ttm_buffer_object *bo, + struct file *filp) +{ + struct fbdevdrm_bo *fbo = fbdevdrm_bo_of_bo(bo); + + return drm_vma_node_verify_access(&fbo->gem.vma_node, + filp->private_data); +} + +static int fbdevdrm_ttm_io_mem_reserve(struct ttm_bo_device *bdev, + struct ttm_mem_reg *mem) +{ + struct ttm_mem_type_manager *man = bdev->man + mem->mem_type; + struct fbdevdrm_ttm *ttm = fbdevdrm_ttm_of_bdev(bdev); + + if (!(man->flags & TTM_MEMTYPE_FLAG_MAPPABLE)) + return -EINVAL; + + mem->bus.addr = NULL; + mem->bus.size = mem->num_pages << PAGE_SHIFT; + + switch (mem->mem_type) { + case TTM_PL_SYSTEM: /* nothing to do */ + mem->bus.offset = 0; + mem->bus.base = 0; + mem->bus.is_iomem = false; + break; + case TTM_PL_VRAM: + mem->bus.offset = mem->start << PAGE_SHIFT; + mem->bus.base = ttm->fb_info->fix.smem_start; + mem->bus.is_iomem = true; + break; + default: + return -EINVAL; + } + + return 0; +} + +static void fbdevdrm_ttm_io_mem_free(struct ttm_bo_device *bdev, + struct ttm_mem_reg *mem) +{ } + +static struct ttm_bo_driver fbdevdrm_bo_driver = { + .ttm_tt_create = fbdevdrm_ttm_tt_create, + .ttm_tt_populate = ttm_pool_populate, + .ttm_tt_unpopulate = ttm_pool_unpopulate, + .init_mem_type = fbdevdrm_bo_init_mem_type, + .eviction_valuable = ttm_bo_eviction_valuable, + .evict_flags = fbdevdrm_bo_evict_flags, + .verify_access = fbdevdrm_bo_verify_access, + .io_mem_reserve = fbdevdrm_ttm_io_mem_reserve, + .io_mem_free = fbdevdrm_ttm_io_mem_free, +}; + +static int fbdevdrm_init_ttm_bo_device(struct fbdevdrm_ttm *ttm, + struct drm_device *dev, + unsigned long p_size) +{ + int ret; + + ret = ttm_bo_device_init(&ttm->bdev, + &fbdevdrm_bo_driver, + dev->anon_inode->i_mapping, + DRM_FILE_PAGE_OFFSET, + true); + if (ret) { + DRM_ERROR("fbdevdrm: ttm_bo_device_init failed; %d\n", ret); + return ret; + } + + ret = ttm_bo_init_mm(&ttm->bdev, TTM_PL_VRAM, p_size); + if (ret) { + DRM_ERROR("fbdevdrm: ttm_bo_init_mm failed: %d\n", ret); + return ret; + } + + return 0; +} + +/* + * struct fbdevdrm_ttm + */ + +int fbdevdrm_ttm_init(struct fbdevdrm_ttm *ttm, struct drm_device *dev, + struct fb_info *fb_info) +{ + int ret; + + ttm->dev = dev; + ttm->fb_info = fb_info; + + /* DRM porting notes: programming the linear scanout buffer is + * implemented via display panning. To make this work, all BOs + * have to end at scanline boundaries. The final BO could be placed + * at the very end of the display memory, which might not align + * with the end of the final scanline. Fbdev would reject such a + * coordinate for display panning. To avoid this, we don't use the + * display memory's final 4 pages. If you convert an fbdev driver + * to DRM, remove this workaround and hand-over all memory to TTM. + */ + ttm->vram_size = fb_info->fix.smem_len - 4 * PAGE_SIZE; + + ret = fbdevdrm_init_ttm_bo_device(ttm, dev, ttm->vram_size >> PAGE_SHIFT); + if (ret < 0) + return ret; + + return 0; +} + +void fbdevdrm_ttm_cleanup(struct fbdevdrm_ttm *ttm) +{ + ttm_bo_device_release(&ttm->bdev); +} diff --git a/drivers/gpu/drm/fbdevdrm/fbdevdrm_ttm.h b/drivers/gpu/drm/fbdevdrm/fbdevdrm_ttm.h new file mode 100644 index 000000000000..d3e964cd8215 --- /dev/null +++ b/drivers/gpu/drm/fbdevdrm/fbdevdrm_ttm.h @@ -0,0 +1,35 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * + * One purpose of this driver is to allow for easy conversion of framebuffer + * drivers to DRM. As a special exception to the GNU GPL, you are allowed to + * relicense this file under the terms of a license of your choice if you're + * porting a framebuffer driver. In order to do so, update the SPDX license + * identifier to the new license and remove this exception. + * + * If you add code to this file, please ensure that it's compatible with the + * stated exception. + */ + +#ifndef FBDEVDRM_TTM_H +#define FBDEVDRM_TTM_H + +#include <drm/ttm/ttm_bo_driver.h> + +#define DRM_FILE_PAGE_OFFSET (0x100000000ULL >> PAGE_SHIFT) + +struct drm_device; +struct fb_info; + +struct fbdevdrm_ttm { + struct drm_device *dev; + struct fb_info *fb_info; + + size_t vram_size; + struct ttm_bo_device bdev; +}; + +int fbdevdrm_ttm_init(struct fbdevdrm_ttm *ttm, struct drm_device *dev, + struct fb_info *fb_info); +void fbdevdrm_ttm_cleanup(struct fbdevdrm_ttm *ttm); + +#endif

Signed-off-by: Thomas Zimmermann tzimmermann@suse.de --- drivers/gpu/drm/fbdevdrm/fbdevdrm_drv.c | 77 +++++++++++++++++++++++++ 1 file changed, 77 insertions(+)

diff --git a/drivers/gpu/drm/fbdevdrm/fbdevdrm_drv.c b/drivers/gpu/drm/fbdevdrm/fbdevdrm_drv.c index 4a6ba6c85c5c..4724e3df6ace 100644 --- a/drivers/gpu/drm/fbdevdrm/fbdevdrm_drv.c +++ b/drivers/gpu/drm/fbdevdrm/fbdevdrm_drv.c @@ -18,6 +18,7 @@ #include <linux/fb.h> #include <linux/module.h> #include <linux/mutex.h> +#include "fbdevdrm_bo.h" #include "fbdevdrm_device.h"

/* DRM porting note: Here are some general information about the driver, @@ -64,7 +65,82 @@ static const struct file_operations driver_fops = { .read = drm_read };

+static void driver_gem_free_object(struct drm_gem_object *gobj) +{ + struct fbdevdrm_bo *fbo = fbdevdrm_bo_of_gem(gobj); + fbdevdrm_bo_put(fbo); +} + +static int driver_dumb_create(struct drm_file *file_priv, + struct drm_device *dev, + struct drm_mode_create_dumb *args) +{ + int ret; + struct fbdevdrm_bo *fbo; + u32 size, handle; + + args->pitch = args->width * ((args->bpp + 7) / 8); + args->size = args->pitch * args->height; + + size = roundup(args->size, PAGE_SIZE); + if (!size) + return -EINVAL; + + /* DRM porting note: FBdev aligns scanout buffers to multiples + * of the scanline size in bytes. TTM aligns buffers to page + * boundaries. To maintain FBdev buffers with TTM, we align BOs + * at both, the scanline offsets and the page offsets. Depending + * on resolution and color depth, this may result in some memory + * overhead. After porting an FBdev driver to DRM, you can remove + * this constrain and simply align to page boundaries. + */ + fbo = fbdevdrm_bo_create_with_pitch(dev, size, args->pitch, 0); + if (IS_ERR(fbo)) { + ret = PTR_ERR(fbo); + if (ret != -ERESTARTSYS) + DRM_ERROR("fbdevdrm: fbdevdrm_bo_create_with_pitch() " + "failed, error %d\n", -ret); + return ret; + } + + ret = drm_gem_handle_create(file_priv, &fbo->gem, &handle); + drm_gem_object_put_unlocked(&fbo->gem); /* TODO: verify ref-count */ + if (ret < 0) + goto err_fbdevdrm_bo_put; + + args->handle = handle; + + return 0; + +err_fbdevdrm_bo_put: + fbdevdrm_bo_put(fbo); + return ret; +} + +static int driver_dumb_mmap_offset(struct drm_file *file_priv, + struct drm_device *dev, uint32_t handle, + uint64_t *offset) +{ + struct drm_gem_object *obj; + struct fbdevdrm_bo *fbo; + + obj = drm_gem_object_lookup(file_priv, handle); + if (obj == NULL) + return -ENOENT; + + fbo = fbdevdrm_bo_of_gem(obj); + *offset = fbdevdrm_bo_mmap_offset(fbo); + + drm_gem_object_put_unlocked(obj); + return 0; +} + static struct drm_driver fbdevdrm_drv = { + /* GEM interfaces */ + .gem_free_object = driver_gem_free_object, + /* Dumb interfaces */ + .dumb_create = driver_dumb_create, + .dumb_map_offset = driver_dumb_mmap_offset, /* data fields */ .major = DRIVER_MAJOR, .minor = DRIVER_MINOR, @@ -72,6 +148,7 @@ static struct drm_driver fbdevdrm_drv = { .name = DRIVER_NAME, .desc = DRIVER_DESCRIPTION, .date = DRIVER_DATE, + .driver_features = DRIVER_GEM, .fops = &driver_fops };

Signed-off-by: Thomas Zimmermann tzimmermann@suse.de --- drivers/gpu/drm/fbdevdrm/Makefile | 1 + drivers/gpu/drm/fbdevdrm/fbdevdrm_format.c | 441 +++++++++++++++++++++ drivers/gpu/drm/fbdevdrm/fbdevdrm_format.h | 26 ++ 3 files changed, 468 insertions(+) create mode 100644 drivers/gpu/drm/fbdevdrm/fbdevdrm_format.c create mode 100644 drivers/gpu/drm/fbdevdrm/fbdevdrm_format.h

diff --git a/drivers/gpu/drm/fbdevdrm/Makefile b/drivers/gpu/drm/fbdevdrm/Makefile index b8fab9d52faa..aef60d0f4888 100644 --- a/drivers/gpu/drm/fbdevdrm/Makefile +++ b/drivers/gpu/drm/fbdevdrm/Makefile @@ -2,6 +2,7 @@ ccflags-y = -Iinclude/drm fbdevdrm-y := fbdevdrm_bo.o \ fbdevdrm_device.o \ fbdevdrm_drv.o \ + fbdevdrm_format.o \ fbdevdrm_modeset.o \ fbdevdrm_ttm.o

diff --git a/drivers/gpu/drm/fbdevdrm/fbdevdrm_format.c b/drivers/gpu/drm/fbdevdrm/fbdevdrm_format.c new file mode 100644 index 000000000000..208f7c60e525 --- /dev/null +++ b/drivers/gpu/drm/fbdevdrm/fbdevdrm_format.c @@ -0,0 +1,441 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * + * One purpose of this driver is to allow for easy conversion of framebuffer + * drivers to DRM. As a special exception to the GNU GPL, you are allowed to + * relicense this file under the terms of a license of your choice if you're + * porting a framebuffer driver. In order to do so, update the SPDX license + * identifier to the new license and remove this exception. + * + * If you add code to this file, please ensure that it's compatible with the + * stated exception. + */ + +#include "fbdevdrm_format.h" +#include <asm/byteorder.h> +#include <linux/fb.h> + +#if defined __BIG_ENDIAN +#define HOST_FUNC(_func) \ + _func ## _be +#elif defined __LITTLE_ENDIAN +#define HOST_FUNC(_func) \ + _func ## _le +#else +#error "Unsupported endianess" +#endif + +static bool is_c8(const struct fb_info* fb_info) +{ + return fb_info->var.bits_per_pixel == 8; +} + +static bool is_rgb565_be(const struct fb_info* fb_info) +{ + return (fb_info->var.bits_per_pixel == 16) && + (fb_info->var.red.offset == 0) && + (fb_info->var.red.length == 5) && + (fb_info->var.green.offset == 5) && + (fb_info->var.green.length == 6) && + (fb_info->var.blue.offset == 11) && + (fb_info->var.blue.length == 5); +} + +static bool is_bgr565_be(const struct fb_info* fb_info) +{ + return (fb_info->var.bits_per_pixel == 16) && + (fb_info->var.red.offset == 11) && + (fb_info->var.red.length == 5) && + (fb_info->var.green.offset == 5) && + (fb_info->var.green.length == 6) && + (fb_info->var.blue.offset == 0) && + (fb_info->var.blue.length == 5); +} + +static bool is_rgb888_be(const struct fb_info* fb_info) +{ + return (fb_info->var.bits_per_pixel == 24) && + (fb_info->var.red.offset == 0) && + (fb_info->var.red.length == 8) && + (fb_info->var.green.offset == 8) && + (fb_info->var.green.length == 8) && + (fb_info->var.blue.offset == 16) && + (fb_info->var.blue.length == 8); +} + +static bool is_bgr888_be(const struct fb_info* fb_info) +{ + return (fb_info->var.bits_per_pixel == 24) && + (fb_info->var.red.offset == 16) && + (fb_info->var.red.length == 8) && + (fb_info->var.green.offset == 8) && + (fb_info->var.green.length == 8) && + (fb_info->var.blue.offset == 0) && + (fb_info->var.blue.length == 8); +} + +static bool is_xrgb8888_be(const struct fb_info* fb_info) +{ + return (fb_info->var.bits_per_pixel == 32) && + (fb_info->var.red.offset == 8) && + (fb_info->var.red.length == 8) && + (fb_info->var.green.offset == 16) && + (fb_info->var.green.length == 8) && + (fb_info->var.blue.offset == 24) && + (fb_info->var.blue.length == 8) && + (fb_info->var.transp.length == 0); +} + +static bool is_xbgr8888_be(const struct fb_info* fb_info) +{ + return (fb_info->var.bits_per_pixel == 32) && + (fb_info->var.red.offset == 24) && + (fb_info->var.red.length == 8) && + (fb_info->var.green.offset == 16) && + (fb_info->var.green.length == 8) && + (fb_info->var.blue.offset == 8) && + (fb_info->var.blue.length == 8) && + (fb_info->var.transp.length == 0); +} + +static bool is_rgbx8888_be(const struct fb_info* fb_info) +{ + return (fb_info->var.bits_per_pixel == 32) && + (fb_info->var.red.offset == 0) && + (fb_info->var.red.length == 8) && + (fb_info->var.green.offset == 8) && + (fb_info->var.green.length == 8) && + (fb_info->var.blue.offset == 16) && + (fb_info->var.blue.length == 8) && + (fb_info->var.transp.length == 0); +} + +static bool is_bgrx8888_be(const struct fb_info* fb_info) +{ + return (fb_info->var.bits_per_pixel == 32) && + (fb_info->var.red.offset == 16) && + (fb_info->var.red.length == 8) && + (fb_info->var.green.offset == 8) && + (fb_info->var.green.length == 8) && + (fb_info->var.blue.offset == 0) && + (fb_info->var.blue.length == 8) && + (fb_info->var.transp.length == 0); +} + +static bool is_argb8888_be(const struct fb_info* fb_info) +{ + return (fb_info->var.bits_per_pixel == 32) && + (fb_info->var.red.offset == 8) && + (fb_info->var.red.length == 8) && + (fb_info->var.green.offset == 16) && + (fb_info->var.green.length == 8) && + (fb_info->var.blue.offset == 24) && + (fb_info->var.blue.length == 8) && + (fb_info->var.transp.offset == 0) && + (fb_info->var.transp.length == 8); +} + +static bool is_abgr8888_be(const struct fb_info* fb_info) +{ + return (fb_info->var.bits_per_pixel == 32) && + (fb_info->var.red.offset == 24) && + (fb_info->var.red.length == 8) && + (fb_info->var.green.offset == 16) && + (fb_info->var.green.length == 8) && + (fb_info->var.blue.offset == 8) && + (fb_info->var.blue.length == 8) && + (fb_info->var.transp.offset == 0) && + (fb_info->var.transp.length == 8); +} + +static bool is_rgba8888_be(const struct fb_info* fb_info) +{ + return (fb_info->var.bits_per_pixel == 32) && + (fb_info->var.red.offset == 0) && + (fb_info->var.red.length == 8) && + (fb_info->var.green.offset == 8) && + (fb_info->var.green.length == 8) && + (fb_info->var.blue.offset == 16) && + (fb_info->var.blue.length == 8) && + (fb_info->var.transp.offset == 24) && + (fb_info->var.transp.length == 8); +} + +static bool is_bgra8888_be(const struct fb_info* fb_info) +{ + return (fb_info->var.bits_per_pixel == 32) && + (fb_info->var.red.offset == 16) && + (fb_info->var.red.length == 8) && + (fb_info->var.green.offset == 8) && + (fb_info->var.green.length == 8) && + (fb_info->var.blue.offset == 0) && + (fb_info->var.blue.length == 8) && + (fb_info->var.transp.offset == 24) && + (fb_info->var.transp.length == 8); +} + +#define is_rgb565_le is_bgr565_be +#define is_bgr565_le is_rgb565_be +#define is_rgb888_le is_bgr888_be +#define is_bgr888_le is_rgb888_be +#define is_xrgb8888_le is_bgrx8888_be +#define is_xbgr8888_le is_rgbx8888_be +#define is_rgbx8888_le is_xbgr8888_be +#define is_bgrx8888_le is_xrgb8888_be +#define is_argb8888_le is_bgra8888_be +#define is_abgr8888_le is_rgba8888_be +#define is_rgba8888_le is_abgr8888_be +#define is_bgra8888_le is_argb8888_be + +struct format_map { + bool (*is_format)(const struct fb_info*); + uint32_t format; +}; + +uint32_t fbdevdrm_format_of_fb_info(const struct fb_info *fb_info) +{ + static const struct format_map map[] = { + { is_c8, DRM_FORMAT_C8 }, /* 256-color palette */ + { HOST_FUNC(is_rgb565), DRM_FORMAT_RGB565 }, + { HOST_FUNC(is_bgr565), DRM_FORMAT_BGR565 }, + { HOST_FUNC(is_rgb888), DRM_FORMAT_RGB888 }, + { HOST_FUNC(is_bgr888), DRM_FORMAT_BGR888 }, + { HOST_FUNC(is_xrgb8888), DRM_FORMAT_XRGB8888 }, + { HOST_FUNC(is_xbgr8888), DRM_FORMAT_XBGR8888 }, + { HOST_FUNC(is_rgbx8888), DRM_FORMAT_RGBX8888 }, + { HOST_FUNC(is_bgrx8888), DRM_FORMAT_BGRX8888 }, + { HOST_FUNC(is_argb8888), DRM_FORMAT_ARGB8888 }, + { HOST_FUNC(is_abgr8888), DRM_FORMAT_ABGR8888 }, + { HOST_FUNC(is_rgba8888), DRM_FORMAT_RGBA8888 }, + { HOST_FUNC(is_bgra8888), DRM_FORMAT_BGRA8888 } + }; + + size_t i; + + if (fb_info->fix.type != FB_TYPE_PACKED_PIXELS) + goto err; /* multi-plane formats are not supported */ + if (fb_info->var.bits_per_pixel < 8) + goto err; /* at least 8-bit color required */ + if (fb_info->var.grayscale == 1) + goto err; /* grayscale output is not supported */ + + for (i = 0; i < ARRAY_SIZE(map); ++i) { + if (map[i].is_format(fb_info)) + return map[i].format; + } + +err: + return DRM_FORMAT_INVALID; +} + +static void set_fb_bitfield(struct fb_bitfield *bits, __u32 offset, + __u32 length) +{ + bits->offset = offset; + bits->length = length; + bits->msb_right = 0; +} + +static void set_c8(struct fb_var_screeninfo *fb_var) +{ + fb_var->bits_per_pixel = 8; + fb_var->grayscale = 0; + set_fb_bitfield(&fb_var->red, 0, 8); + set_fb_bitfield(&fb_var->green, 0, 8); + set_fb_bitfield(&fb_var->blue, 0, 8); + set_fb_bitfield(&fb_var->transp, 0, 0); + fb_var->nonstd = 0; +} + +static void set_rgb565_be(struct fb_var_screeninfo *fb_var) +{ + fb_var->bits_per_pixel = 16; + fb_var->grayscale = 0; + set_fb_bitfield(&fb_var->red, 0, 5); + set_fb_bitfield(&fb_var->green, 5, 6); + set_fb_bitfield(&fb_var->blue, 11, 5); + set_fb_bitfield(&fb_var->transp, 0, 0); + fb_var->nonstd = 0; +} + +static void set_bgr565_be(struct fb_var_screeninfo *fb_var) +{ + fb_var->bits_per_pixel = 16; + fb_var->grayscale = 0; + set_fb_bitfield(&fb_var->red, 11, 5); + set_fb_bitfield(&fb_var->green, 5, 6); + set_fb_bitfield(&fb_var->blue, 0, 5); + set_fb_bitfield(&fb_var->transp, 0, 0); + fb_var->nonstd = 0; +} + +static void set_rgb888_be(struct fb_var_screeninfo *fb_var) +{ + fb_var->bits_per_pixel = 24; + fb_var->grayscale = 0; + set_fb_bitfield(&fb_var->red, 0, 8); + set_fb_bitfield(&fb_var->green, 8, 8); + set_fb_bitfield(&fb_var->blue, 16, 8); + set_fb_bitfield(&fb_var->transp, 0, 0); + fb_var->nonstd = 0; +} + +static void set_bgr888_be(struct fb_var_screeninfo *fb_var) +{ + fb_var->bits_per_pixel = 24; + fb_var->grayscale = 0; + set_fb_bitfield(&fb_var->red, 16, 8); + set_fb_bitfield(&fb_var->green, 8, 8); + set_fb_bitfield(&fb_var->blue, 0, 8); + set_fb_bitfield(&fb_var->transp, 0, 0); + fb_var->nonstd = 0; +} + +static void set_xrgb8888_be(struct fb_var_screeninfo *fb_var) +{ + fb_var->bits_per_pixel = 32; + fb_var->grayscale = 0; + set_fb_bitfield(&fb_var->red, 8, 8); + set_fb_bitfield(&fb_var->green, 16, 8); + set_fb_bitfield(&fb_var->blue, 24, 8); + set_fb_bitfield(&fb_var->transp, 0, 0); + fb_var->nonstd = 0; +} + +static void set_xbgr8888_be(struct fb_var_screeninfo *fb_var) +{ + fb_var->bits_per_pixel = 32; + fb_var->grayscale = 0; + set_fb_bitfield(&fb_var->red, 24, 8); + set_fb_bitfield(&fb_var->green, 16, 8); + set_fb_bitfield(&fb_var->blue, 8, 8); + set_fb_bitfield(&fb_var->transp, 0, 0); + fb_var->nonstd = 0; +} + +static void set_rgbx8888_be(struct fb_var_screeninfo *fb_var) +{ + fb_var->bits_per_pixel = 32; + fb_var->grayscale = 0; + set_fb_bitfield(&fb_var->red, 0, 8); + set_fb_bitfield(&fb_var->green, 8, 8); + set_fb_bitfield(&fb_var->blue, 16, 8); + set_fb_bitfield(&fb_var->transp, 24, 0); + fb_var->nonstd = 0; +} + +static void set_bgrx8888_be(struct fb_var_screeninfo *fb_var) +{ + fb_var->bits_per_pixel = 32; + fb_var->grayscale = 0; + set_fb_bitfield(&fb_var->red, 16, 8); + set_fb_bitfield(&fb_var->green, 8, 8); + set_fb_bitfield(&fb_var->blue, 0, 8); + set_fb_bitfield(&fb_var->transp, 24, 0); + fb_var->nonstd = 0; +} + +static void set_argb8888_be(struct fb_var_screeninfo *fb_var) +{ + fb_var->bits_per_pixel = 32; + fb_var->grayscale = 0; + set_fb_bitfield(&fb_var->red, 8, 8); + set_fb_bitfield(&fb_var->green, 16, 8); + set_fb_bitfield(&fb_var->blue, 24, 8); + set_fb_bitfield(&fb_var->transp, 0, 8); + fb_var->nonstd = 0; +} + +static void set_abgr8888_be(struct fb_var_screeninfo *fb_var) +{ + fb_var->bits_per_pixel = 32; + fb_var->grayscale = 0; + set_fb_bitfield(&fb_var->red, 24, 8); + set_fb_bitfield(&fb_var->green, 16, 8); + set_fb_bitfield(&fb_var->blue, 8, 8); + set_fb_bitfield(&fb_var->transp, 0, 8); + fb_var->nonstd = 0; +} + +static void set_rgba8888_be(struct fb_var_screeninfo *fb_var) +{ + fb_var->bits_per_pixel = 32; + fb_var->grayscale = 0; + set_fb_bitfield(&fb_var->red, 0, 8); + set_fb_bitfield(&fb_var->green, 8, 8); + set_fb_bitfield(&fb_var->blue, 16, 8); + set_fb_bitfield(&fb_var->transp, 24, 8); + fb_var->nonstd = 0; +} + +static void set_bgra8888_be(struct fb_var_screeninfo *fb_var) +{ + fb_var->bits_per_pixel = 32; + fb_var->grayscale = 0; + set_fb_bitfield(&fb_var->red, 16, 8); + set_fb_bitfield(&fb_var->green, 8, 8); + set_fb_bitfield(&fb_var->blue, 0, 8); + set_fb_bitfield(&fb_var->transp, 24, 8); + fb_var->nonstd = 0; +} + +#define set_rgb565_le set_bgr565_be +#define set_bgr565_le set_rgb565_be +#define set_rgb888_le set_bgr888_be +#define set_bgr888_le set_rgb888_be +#define set_xrgb8888_le set_bgrx8888_be +#define set_xbgr8888_le set_rgbx8888_be +#define set_rgbx8888_le set_xbgr8888_be +#define set_bgrx8888_le set_xrgb8888_be +#define set_argb8888_le set_bgra8888_be +#define set_abgr8888_le set_rgba8888_be +#define set_rgba8888_le set_abgr8888_be +#define set_bgra8888_le set_argb8888_be + +int fbdevdrm_update_fb_var_screeninfo_from_format( + struct fb_var_screeninfo *fb_var, uint32_t format) +{ + switch (format) { + case DRM_FORMAT_C8: + set_c8(fb_var); + break; + case DRM_FORMAT_RGB565: + HOST_FUNC(set_rgb565)(fb_var); + break; + case DRM_FORMAT_BGR565: + HOST_FUNC(set_bgr565)(fb_var); + break; + case DRM_FORMAT_RGB888: + HOST_FUNC(set_rgb888)(fb_var); + break; + case DRM_FORMAT_BGR888: + HOST_FUNC(set_bgr888)(fb_var); + break; + case DRM_FORMAT_XRGB8888: + HOST_FUNC(set_xrgb8888)(fb_var); + break; + case DRM_FORMAT_XBGR8888: + HOST_FUNC(set_xbgr8888)(fb_var); + break; + case DRM_FORMAT_RGBX8888: + HOST_FUNC(set_rgbx8888)(fb_var); + break; + case DRM_FORMAT_BGRX8888: + HOST_FUNC(set_bgrx8888)(fb_var); + break; + case DRM_FORMAT_ARGB8888: + HOST_FUNC(set_argb8888)(fb_var); + break; + case DRM_FORMAT_ABGR8888: + HOST_FUNC(set_abgr8888)(fb_var); + break; + case DRM_FORMAT_RGBA8888: + HOST_FUNC(set_rgba8888)(fb_var); + break; + case DRM_FORMAT_BGRA8888: + HOST_FUNC(set_bgra8888)(fb_var); + break; + default: + return -EINVAL; + } + return 0; +} diff --git a/drivers/gpu/drm/fbdevdrm/fbdevdrm_format.h b/drivers/gpu/drm/fbdevdrm/fbdevdrm_format.h new file mode 100644 index 000000000000..e837978ac8fc --- /dev/null +++ b/drivers/gpu/drm/fbdevdrm/fbdevdrm_format.h @@ -0,0 +1,26 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * + * One purpose of this driver is to allow for easy conversion of framebuffer + * drivers to DRM. As a special exception to the GNU GPL, you are allowed to + * relicense this file under the terms of a license of your choice if you're + * porting a framebuffer driver. In order to do so, update the SPDX license + * identifier to the new license and remove this exception. + * + * If you add code to this file, please ensure that it's compatible with the + * stated exception. + */ + +#ifndef FBDEVDRM_FORMAT_H +#define FBDEVDRM_FORMAT_H + +#include <drm/drm_fourcc.h> + +struct fb_info; +struct fb_var_screeninfo; + +uint32_t fbdevdrm_format_of_fb_info(const struct fb_info *fb_info); + +int fbdevdrm_update_fb_var_screeninfo_from_format( + struct fb_var_screeninfo *fb_var, uint32_t format); + +#endif

Signed-off-by: Thomas Zimmermann tzimmermann@suse.de --- drivers/gpu/drm/fbdevdrm/Makefile | 1 + drivers/gpu/drm/fbdevdrm/fbdevdrm_modes.c | 153 ++++++++++++++++++++++ drivers/gpu/drm/fbdevdrm/fbdevdrm_modes.h | 46 +++++++ 3 files changed, 200 insertions(+) create mode 100644 drivers/gpu/drm/fbdevdrm/fbdevdrm_modes.c create mode 100644 drivers/gpu/drm/fbdevdrm/fbdevdrm_modes.h

diff --git a/drivers/gpu/drm/fbdevdrm/Makefile b/drivers/gpu/drm/fbdevdrm/Makefile index aef60d0f4888..2ca906a3258b 100644 --- a/drivers/gpu/drm/fbdevdrm/Makefile +++ b/drivers/gpu/drm/fbdevdrm/Makefile @@ -3,6 +3,7 @@ fbdevdrm-y := fbdevdrm_bo.o \ fbdevdrm_device.o \ fbdevdrm_drv.o \ fbdevdrm_format.o \ + fbdevdrm_modes.o \ fbdevdrm_modeset.o \ fbdevdrm_ttm.o

diff --git a/drivers/gpu/drm/fbdevdrm/fbdevdrm_modes.c b/drivers/gpu/drm/fbdevdrm/fbdevdrm_modes.c new file mode 100644 index 000000000000..bd3ad691e7ce --- /dev/null +++ b/drivers/gpu/drm/fbdevdrm/fbdevdrm_modes.c @@ -0,0 +1,153 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * + * One purpose of this driver is to allow for easy conversion of framebuffer + * drivers to DRM. As a special exception to the GNU GPL, you are allowed to + * relicense this file under the terms of a license of your choice if you're + * porting a framebuffer driver. In order to do so, update the SPDX license + * identifier to the new license and remove this exception. + * + * If you add code to this file, please ensure that it's compatible with the + * stated exception. + */ + +#include "fbdevdrm_modes.h" +#include <drm/drm_modes.h> +#include <linux/fb.h> + +void drm_mode_update_from_fb_videomode(struct drm_display_mode *mode, + const struct fb_videomode *fb_mode) +{ + mode->type = DRM_MODE_TYPE_DRIVER; + + mode->clock = PICOS2KHZ(fb_mode->pixclock); + + mode->hdisplay = fb_mode->xres; + mode->hsync_start = mode->hdisplay + fb_mode->right_margin; + mode->hsync_end = mode->hsync_start + fb_mode->hsync_len; + mode->htotal = mode->hsync_end + fb_mode->left_margin; + mode->hskew = 0; + + mode->vdisplay = fb_mode->yres; + mode->vsync_start = mode->vdisplay + fb_mode->lower_margin; + mode->vsync_end = mode->vsync_start + fb_mode->vsync_len; + mode->vtotal = mode->vsync_end + fb_mode->upper_margin; + mode->vscan = 0; + + mode->flags = 0; + + if (fb_mode->sync & FB_SYNC_HOR_HIGH_ACT) + mode->flags |= DRM_MODE_FLAG_PHSYNC; + else + mode->flags |= DRM_MODE_FLAG_NHSYNC; + + if (fb_mode->sync & FB_SYNC_VERT_HIGH_ACT) + mode->flags |= DRM_MODE_FLAG_PVSYNC; + else + mode->flags |= DRM_MODE_FLAG_NVSYNC; + + if (fb_mode->sync & FB_SYNC_COMP_HIGH_ACT) + mode->flags |= DRM_MODE_FLAG_CSYNC | DRM_MODE_FLAG_PCSYNC; + + if (fb_mode->vmode & FB_VMODE_INTERLACED) + mode->flags |= DRM_MODE_FLAG_INTERLACE; + + if (fb_mode->vmode & FB_VMODE_DOUBLE) + mode->flags |= DRM_MODE_FLAG_DBLSCAN; + + mode->width_mm = 0; + mode->height_mm = 0; + + mode->vrefresh = fb_mode->refresh; + mode->hsync = mode->clock / mode->vtotal; + + /* final step; depends on previous setup */ + if (fb_mode->name) { + strncpy(mode->name, fb_mode->name, sizeof(mode->name) - 1); + mode->name[sizeof(mode->name) - 1] = '\0'; + } else { + drm_mode_set_name(mode); + } +} + +void drm_mode_update_from_fb_var_screeninfo( + struct drm_display_mode *mode, const struct fb_var_screeninfo *fb_var) +{ + struct fb_videomode fb_mode; + + fb_var_to_videomode(&fb_mode, fb_var); + drm_mode_update_from_fb_videomode(mode, &fb_mode); +} + +struct drm_display_mode* drm_mode_create_from_fb_videomode( + struct drm_device *dev, const struct fb_videomode *fb_mode) +{ + /* cleared to '0' */ + struct drm_display_mode *mode = drm_mode_create(dev); + if (!mode) + return NULL; + + drm_mode_update_from_fb_videomode(mode, fb_mode); + + return mode; +} + +void +fbdevdrm_update_fb_videomode_from_mode(struct fb_videomode *fb_mode, + const struct drm_display_mode *mode) +{ + fb_mode->name = NULL; + fb_mode->refresh = mode->vrefresh; + fb_mode->xres = mode->hdisplay; + fb_mode->yres = mode->vdisplay; + fb_mode->pixclock = KHZ2PICOS(mode->clock); + fb_mode->left_margin = mode->htotal - mode->hsync_end; + fb_mode->right_margin = mode->hsync_start - mode->hdisplay; + fb_mode->upper_margin = mode->vtotal - mode->vsync_end; + fb_mode->lower_margin = mode->vsync_start - mode->vdisplay; + fb_mode->hsync_len = mode->hsync_end - mode->hsync_start; + fb_mode->vsync_len = mode->vsync_end - mode->vsync_start; + + fb_mode->sync = 0; + if (mode->flags & DRM_MODE_FLAG_PHSYNC) + fb_mode->sync |= FB_SYNC_HOR_HIGH_ACT; + if (mode->flags & DRM_MODE_FLAG_PVSYNC) + fb_mode->sync |= FB_SYNC_VERT_HIGH_ACT; + if (mode->flags & (DRM_MODE_FLAG_CSYNC | DRM_MODE_FLAG_PCSYNC)) + fb_mode->sync |= FB_SYNC_COMP_HIGH_ACT; + + fb_mode->vmode = 0; + if (mode->flags & DRM_MODE_FLAG_INTERLACE) + fb_mode->vmode |= FB_VMODE_INTERLACED; + if (mode->flags & DRM_MODE_FLAG_DBLSCAN) + fb_mode->vmode |= FB_VMODE_DOUBLE; + + fb_mode->flag = 0; +} + +void +fbdevdrm_init_fb_videomode_from_mode(struct fb_videomode *fb_mode, + const struct drm_display_mode *mode) +{ + memset(fb_mode, 0, sizeof(*fb_mode)); + fbdevdrm_update_fb_videomode_from_mode(fb_mode, mode); +} + +void +fbdevdrm_update_fb_var_screeninfo_from_mode(struct fb_var_screeninfo *fb_var, + const struct drm_display_mode *mode) +{ + struct fb_videomode fb_mode; + fbdevdrm_init_fb_videomode_from_mode(&fb_mode, mode); + fb_videomode_to_var(fb_var, &fb_mode); + + fb_var->height = mode->height_mm; + fb_var->width = mode->width_mm; +} + +void +fbdevdrm_init_fb_var_screeninfo_from_mode(struct fb_var_screeninfo *fb_var, + const struct drm_display_mode *mode) +{ + memset(fb_var, 0, sizeof(*fb_var)); + fbdevdrm_update_fb_var_screeninfo_from_mode(fb_var, mode); +} diff --git a/drivers/gpu/drm/fbdevdrm/fbdevdrm_modes.h b/drivers/gpu/drm/fbdevdrm/fbdevdrm_modes.h new file mode 100644 index 000000000000..f88a86a83858 --- /dev/null +++ b/drivers/gpu/drm/fbdevdrm/fbdevdrm_modes.h @@ -0,0 +1,46 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * + * One purpose of this driver is to allow for easy conversion of framebuffer + * drivers to DRM. As a special exception to the GNU GPL, you are allowed to + * relicense this file under the terms of a license of your choice if you're + * porting a framebuffer driver. In order to do so, update the SPDX license + * identifier to the new license and remove this exception. + * + * If you add code to this file, please ensure that it's compatible with the + * stated exception. + */ + +#ifndef FBDEVDRM_MODES_H +#define FBDEVDRM_MODES_H + +struct drm_device; +struct drm_display_mode; +struct fb_videomode; +struct fb_var_screeninfo; + +void drm_mode_update_from_fb_videomode(struct drm_display_mode *mode, + const struct fb_videomode *fb_mode); + +void drm_mode_update_from_fb_var_screeninfo( + struct drm_display_mode *mode, const struct fb_var_screeninfo *fb_var); + +struct drm_display_mode* drm_mode_create_from_fb_videomode( + struct drm_device *dev, const struct fb_videomode *fb_mode); + +void +fbdevdrm_update_fb_videomode_from_mode(struct fb_videomode *fb_mode, + const struct drm_display_mode *mode); + +void +fbdevdrm_init_fb_videomode_from_mode(struct fb_videomode *fb_mode, + const struct drm_display_mode *mode); + +void +fbdevdrm_update_fb_var_screeninfo_from_mode(struct fb_var_screeninfo *var, + const struct drm_display_mode *mode); + +void +fbdevdrm_init_fb_var_screeninfo_from_mode(struct fb_var_screeninfo *var, + const struct drm_display_mode *mode); + +#endif

Signed-off-by: Thomas Zimmermann tzimmermann@suse.de --- drivers/gpu/drm/fbdevdrm/fbdevdrm_modeset.c | 150 +++++++++++++++++++- 1 file changed, 149 insertions(+), 1 deletion(-)

diff --git a/drivers/gpu/drm/fbdevdrm/fbdevdrm_modeset.c b/drivers/gpu/drm/fbdevdrm/fbdevdrm_modeset.c index 3473b85acbf1..87f56ec76edf 100644 --- a/drivers/gpu/drm/fbdevdrm/fbdevdrm_modeset.c +++ b/drivers/gpu/drm/fbdevdrm/fbdevdrm_modeset.c @@ -18,10 +18,18 @@ #include <drm/drm_gem_framebuffer_helper.h> #include <drm/drm_modeset_helper.h> #include <drm/drm_modeset_helper_vtables.h> +#include <drm/drm_print.h> #include <drm/drm_probe_helper.h> #include <linux/fb.h> +#include "fbdevdrm_modes.h" #include "fbdevdrm_primary.h"

+static struct fbdevdrm_modeset* fbdevdrm_modeset_of_crtc( + struct drm_crtc *crtc) +{ + return container_of(crtc, struct fbdevdrm_modeset, crtc); +} + /* * CRTC */ @@ -29,18 +37,124 @@ static enum drm_mode_status crtc_helper_mode_valid( struct drm_crtc *crtc, const struct drm_display_mode *mode) { + static const unsigned char bits_per_pixel[] = { + 32, 16, 8, 24, 15 + }; + + struct fbdevdrm_modeset *modeset; + struct fb_var_screeninfo fb_var; + size_t i; + int ret; + + modeset = fbdevdrm_modeset_of_crtc(crtc); + + if (!modeset->fb_info->fbops->fb_check_var) + return MODE_OK; + + for (i = 0; i < ARRAY_SIZE(bits_per_pixel); ++i) { + + memcpy(&fb_var, &modeset->fb_info->var, sizeof(fb_var)); + fbdevdrm_update_fb_var_screeninfo_from_mode(&fb_var, mode); + fb_var.bits_per_pixel = bits_per_pixel[i]; + + ret = modeset->fb_info->fbops->fb_check_var(&fb_var, modeset->fb_info); + if (ret) + continue; /* generally not supported */ + if ((mode->hdisplay != fb_var.xres) || + (mode->vdisplay != fb_var.yres)) + continue; /* unsupported resolution */ + if (KHZ2PICOS(mode->clock) != fb_var.pixclock) + continue; /* unsupported pixel clock */ + + break; /* mode successfully tested */ + } + if (i == ARRAY_SIZE(bits_per_pixel)) + return MODE_BAD; /* mode is not support */ + return MODE_OK; }

+static int fbdevdrm_update_fb_var_screeninfo_from_crtc( + struct fb_var_screeninfo *fb_var, struct drm_crtc* crtc) +{ + struct drm_plane *primary = crtc->primary; + struct fbdevdrm_modeset *modeset = fbdevdrm_modeset_of_crtc(crtc); + + if (primary && primary->state && primary->state->fb) + return fbdevdrm_update_fb_var_screeninfo_from_framebuffer( + fb_var, primary->state->fb, + modeset->fb_info->fix.smem_len); + + fb_var->xres_virtual = fb_var->xres; + fb_var->yres_virtual = fb_var->yres; + fb_var->bits_per_pixel = modeset->dev->mode_config.preferred_depth; + + return 0; +} + static bool crtc_helper_mode_fixup(struct drm_crtc *crtc, const struct drm_display_mode *mode, struct drm_display_mode *adjusted_mode) { + struct fbdevdrm_modeset *modeset; + struct fb_var_screeninfo fb_var; + int ret; + + modeset = fbdevdrm_modeset_of_crtc(crtc); + + if (!modeset->fb_info->fbops->fb_check_var) + return true; + + fbdevdrm_init_fb_var_screeninfo_from_mode(&fb_var, mode); + + ret = fbdevdrm_update_fb_var_screeninfo_from_crtc(&fb_var, crtc); + if (ret) + return true; + + ret = modeset->fb_info->fbops->fb_check_var(&fb_var, modeset->fb_info); + if (ret < 0) + return false; + + drm_mode_update_from_fb_var_screeninfo(adjusted_mode, &fb_var); + return true; }

static void crtc_helper_mode_set_nofb(struct drm_crtc *crtc) -{ } +{ + struct fbdevdrm_modeset *modeset; + struct fb_var_screeninfo fb_var; + int ret; + + /* As this is atomic mode setting, any function call is not + * allowed to fail. If it does, an additional test should be + * added to crtc_helper_atomic_check(). + */ + + modeset = fbdevdrm_modeset_of_crtc(crtc); + + memset(&fb_var, 0, sizeof(fb_var)); + fbdevdrm_update_fb_var_screeninfo_from_mode(&fb_var, &crtc->state->adjusted_mode); + + if (crtc->primary && crtc->primary->state && crtc->primary->state->fb) { + ret = fbdevdrm_update_fb_var_screeninfo_from_framebuffer( + &fb_var, crtc->primary->state->fb, + modeset->fb_info->fix.smem_len); + if (ret) + return; + } else { + fb_var.xres_virtual = fb_var.xres; + fb_var.yres_virtual = fb_var.yres; + } + + fb_var.activate = FB_ACTIVATE_NOW; + + ret = fb_set_var(modeset->fb_info, &fb_var); + if (ret) { + DRM_ERROR("fbdevdrm: fb_set_var() failed: %d\n", ret); + return; + } +}

static int crtc_helper_mode_set_base_atomic(struct drm_crtc *crtc, struct drm_framebuffer *fb, @@ -53,6 +167,40 @@ static int crtc_helper_mode_set_base_atomic(struct drm_crtc *crtc, static int crtc_helper_atomic_check(struct drm_crtc *crtc, struct drm_crtc_state *state) { + struct fbdevdrm_modeset *modeset; + struct fb_videomode fb_mode, fb_var_mode; + + modeset = fbdevdrm_modeset_of_crtc(crtc); + + /* DRM porting notes: when fbcon takes over the console, it regularly + * changes the display mode. Where's apparently no way to detect this + * directly from fbcon itself. DRM's mode information might therefore + * be out of data, after it takes over the display at a later time. + * Here, we test the CRTC's current mode with the fbdev state. If they + * do not match, we request a mode change from DRM. If you port an + * fbdev driver to DRM, you can remove this code section, DRM will + * be in full control of the display device and doesn't have to react + * to changes from external sources. + */ + + if (!state->mode_changed && state->adjusted_mode.clock) { + fbdevdrm_init_fb_videomode_from_mode(&fb_mode, &state->adjusted_mode); + fb_var_to_videomode(&fb_var_mode, &modeset->fb_info->var); + if (!fb_mode_is_equal(&fb_mode, &fb_var_mode)) + state->mode_changed = true; + } + + /* TODO: The vblank interupt is currently not supported. We set + * the corresponding flag as a workaround. Some fbdev drivers + * support FBIO_WAITFORVSYNC, which we might use for querying + * vblanks. + * + * DRM porting notes: if you're porting an fbdev driver to DRM, + * remove this line and instead signal a vblank event from the + * interupt handler. + */ + state->no_vblank = true; + return 0; }