This adds generic fbdev emulation for drivers that support the
dumb buffer API. No fbdev code is necessary in the driver.

Differences from drm_fb_helper:
- The backing buffer is created when the first fd is opened.
- Supports changing the mode from userspace.
- Doesn't restore on lastclose if there is no fd/fbcon open.
- Supports changing the buffer size (yres_virtual) from userspace before
  the fd is opened (double/trippel/... buffering).
- Panning is only supported as page flipping, so no partial offset.
- Supports real page flipping with FBIO_WAITFORVSYNC waiting on the
  actual flip.
- Supports framebuffer flushing for fbcon on buffers that doesn't support
  fbdev deferred I/O (shmem). mmap doesn't work but fbcon does.

TODO:
- suspend/resume
- sysrq
- Look more into plane format selection/support.
- Need a way for the driver to say that it wants generic fbdev emulation.
  The client .new hook is run in drm_dev_register() which is before
  drivers set up fbdev themselves. So the client can't look at
  drm_device->fb_helper to find out.
- Do we need to support FB_VISUAL_PSEUDOCOLOR?

TROUBLE:
- fbcon can't handle fb_open returning an error, it just heads on. This
  results in a NULL deref in fbcon_init(). fbcon/vt is awful when it
  comes to error handling. It doesn't look to be easily fixed, so I guess
  a buffer has to be pre-allocated to ensure health and safety.

Signed-off-by: Noralf Trønnes <nor...@tronnes.org>
---
 drivers/gpu/drm/client/Kconfig     |  16 +
 drivers/gpu/drm/client/Makefile    |   2 +
 drivers/gpu/drm/client/drm_fbdev.c | 997 +++++++++++++++++++++++++++++++++++++
 3 files changed, 1015 insertions(+)
 create mode 100644 drivers/gpu/drm/client/drm_fbdev.c

diff --git a/drivers/gpu/drm/client/Kconfig b/drivers/gpu/drm/client/Kconfig
index 4bb8e4655ff7..73902ab44c75 100644
--- a/drivers/gpu/drm/client/Kconfig
+++ b/drivers/gpu/drm/client/Kconfig
@@ -1,4 +1,20 @@
 menu "DRM Clients"
        depends on DRM
 
+config DRM_CLIENT_FBDEV
+       tristate "Generic fbdev emulation"
+       depends on DRM
+       select FB
+       select FRAMEBUFFER_CONSOLE if !EXPERT
+       select FRAMEBUFFER_CONSOLE_DETECT_PRIMARY if FRAMEBUFFER_CONSOLE
+       select FB_SYS_FOPS
+       select FB_SYS_FILLRECT
+       select FB_SYS_COPYAREA
+       select FB_SYS_IMAGEBLIT
+       select FB_DEFERRED_IO
+       select FB_MODE_HELPERS
+       select VIDEOMODE_HELPERS
+       help
+         Generic fbdev emulation
+
 endmenu
diff --git a/drivers/gpu/drm/client/Makefile b/drivers/gpu/drm/client/Makefile
index f66554cd5c45..3ff694429dec 100644
--- a/drivers/gpu/drm/client/Makefile
+++ b/drivers/gpu/drm/client/Makefile
@@ -1 +1,3 @@
 # SPDX-License-Identifier: GPL-2.0
+
+obj-$(CONFIG_DRM_CLIENT_FBDEV) += drm_fbdev.o
diff --git a/drivers/gpu/drm/client/drm_fbdev.c 
b/drivers/gpu/drm/client/drm_fbdev.c
new file mode 100644
index 000000000000..e28416d72de1
--- /dev/null
+++ b/drivers/gpu/drm/client/drm_fbdev.c
@@ -0,0 +1,997 @@
+// SPDX-License-Identifier: GPL-2.0
+// Copyright 2018 Noralf Trønnes
+
+#include <linux/console.h>
+#include <linux/dma-buf.h>
+#include <linux/fb.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/workqueue.h>
+#include <video/videomode.h>
+
+#include <drm/drm_client.h>
+#include <drm/drm_drv.h>
+#include <drm/drm_fourcc.h>
+#include <drm/drm_framebuffer.h>
+#include <drm/drm_modes.h>
+#include <drm/drm_print.h>
+
+struct drm_fbdev {
+       struct mutex lock;
+
+       struct drm_client_dev *client;
+       struct drm_client_display *display;
+
+       unsigned int open_count;
+       struct drm_client_buffer *buffer;
+       bool page_flip_sent;
+       u32 curr_fb;
+
+       struct fb_info *info;
+       u32 pseudo_palette[17];
+
+       bool flush;
+       bool defio_no_flushing;
+       struct drm_clip_rect dirty_clip;
+       spinlock_t dirty_lock;
+       struct work_struct dirty_work;
+};
+
+static int drm_fbdev_mode_to_fb_mode(struct drm_device *dev,
+                                    struct drm_mode_modeinfo *mode,
+                                    struct fb_videomode *fb_mode)
+{
+       struct drm_display_mode display_mode = { };
+       struct videomode videomode = { };
+       int ret;
+
+       ret = drm_mode_convert_umode(dev, &display_mode, mode);
+       if (ret)
+               return ret;
+
+       memset(fb_mode, 0, sizeof(*fb_mode));
+       drm_display_mode_to_videomode(&display_mode, &videomode);
+       fb_videomode_from_videomode(&videomode, fb_mode);
+
+       return 0;
+}
+
+static void drm_fbdev_destroy_modelist(struct fb_info *info)
+{
+       struct fb_modelist *modelist, *tmp;
+
+       list_for_each_entry_safe(modelist, tmp, &info->modelist, list) {
+               kfree(modelist->mode.name);
+               list_del(&modelist->list);
+               kfree(modelist);
+       }
+}
+
+static void drm_fbdev_use_first_mode(struct fb_info *info)
+{
+       struct fb_modelist *modelist;
+
+       modelist = list_first_entry(&info->modelist, struct fb_modelist, list);
+       fb_videomode_to_var(&info->var, &modelist->mode);
+       info->mode = &modelist->mode;
+}
+
+static struct drm_mode_modeinfo *drm_fbdev_get_drm_mode(struct drm_fbdev 
*fbdev)
+{
+       struct drm_mode_modeinfo *mode_pos, *mode = NULL;
+       struct fb_info *info = fbdev->info;
+       struct fb_videomode tmp;
+
+       mutex_lock(&fbdev->display->modes_lock);
+       drm_client_display_for_each_mode(fbdev->display, mode_pos) {
+               if (drm_fbdev_mode_to_fb_mode(fbdev->client->dev, mode_pos, 
&tmp))
+                       continue;
+               if (fb_mode_is_equal(info->mode, &tmp)) {
+                       mode = mode_pos;
+                       break;
+               }
+       }
+       mutex_unlock(&fbdev->display->modes_lock);
+
+       return mode;
+}
+
+/* Return number of modes or negative error */
+static int drm_fbdev_sync_modes(struct drm_fbdev *fbdev, bool force)
+{
+       struct fb_info *info = fbdev->info;
+       struct drm_mode_modeinfo *mode;
+       struct fb_videomode fb_mode;
+       bool changed;
+
+       struct fb_modelist *fbdev_modelist;
+       int num_modes;
+
+       num_modes = drm_client_display_update_modes(fbdev->display, &changed);
+       if (num_modes <= 0)
+               return num_modes;
+
+       if (!info)
+               return num_modes;
+
+       if (!force && !changed)
+               return num_modes;
+
+       drm_fbdev_destroy_modelist(info);
+
+       mutex_lock(&fbdev->display->modes_lock);
+       drm_client_display_for_each_mode(fbdev->display, mode) {
+               if (drm_fbdev_mode_to_fb_mode(fbdev->client->dev, mode, 
&fb_mode)) {
+                       num_modes--;
+                       continue;
+               }
+
+               fbdev_modelist = kzalloc(sizeof(*fbdev_modelist), GFP_KERNEL);
+               if (!fbdev_modelist) {
+                       drm_fbdev_destroy_modelist(info);
+                       mutex_unlock(&fbdev->display->modes_lock);
+                       return -ENOMEM;
+               }
+
+               fbdev_modelist->mode = fb_mode;
+               fbdev_modelist->mode.name = kstrndup(mode->name,
+                                                    DRM_DISPLAY_MODE_LEN,
+                                                    GFP_KERNEL);
+
+               if (mode->type & DRM_MODE_TYPE_PREFERRED)
+                       fbdev_modelist->mode.flag |= FB_MODE_IS_FIRST;
+
+               list_add_tail(&fbdev_modelist->list, &info->modelist);
+       }
+       mutex_unlock(&fbdev->display->modes_lock);
+
+       if (!fbdev->open_count)
+               drm_fbdev_use_first_mode(info);
+
+       return num_modes;
+}
+
+static void drm_fbdev_format_fill_var(u32 format, struct fb_var_screeninfo 
*var)
+{
+       switch (format) {
+       case DRM_FORMAT_XRGB1555:
+               var->red.offset = 10;
+               var->red.length = 5;
+               var->green.offset = 5;
+               var->green.length = 5;
+               var->blue.offset = 0;
+               var->blue.length = 5;
+               var->transp.offset = 0;
+               var->transp.length = 0;
+               break;
+       case DRM_FORMAT_ARGB1555:
+               var->red.offset = 10;
+               var->red.length = 5;
+               var->green.offset = 5;
+               var->green.length = 5;
+               var->blue.offset = 0;
+               var->blue.length = 5;
+               var->transp.offset = 15;
+               var->transp.length = 1;
+               break;
+       case DRM_FORMAT_RGB565:
+               var->red.offset = 11;
+               var->red.length = 5;
+               var->green.offset = 5;
+               var->green.length = 6;
+               var->blue.offset = 0;
+               var->blue.length = 5;
+               var->transp.offset = 0;
+               var->transp.length = 0;
+               break;
+       case DRM_FORMAT_RGB888:
+       case DRM_FORMAT_XRGB8888:
+               var->red.offset = 16;
+               var->red.length = 8;
+               var->green.offset = 8;
+               var->green.length = 8;
+               var->blue.offset = 0;
+               var->blue.length = 8;
+               var->transp.offset = 0;
+               var->transp.length = 0;
+               break;
+       case DRM_FORMAT_ARGB8888:
+               var->red.offset = 16;
+               var->red.length = 8;
+               var->green.offset = 8;
+               var->green.length = 8;
+               var->blue.offset = 0;
+               var->blue.length = 8;
+               var->transp.offset = 24;
+               var->transp.length = 8;
+               break;
+       default:
+               WARN_ON_ONCE(1);
+               return;
+       }
+
+       var->colorspace = 0;
+       var->grayscale = 0;
+       var->nonstd = 0;
+}
+
+int drm_fbdev_var_to_format(struct fb_var_screeninfo *var, u32 *format)
+{
+       switch (var->bits_per_pixel) {
+       case 15:
+               *format = DRM_FORMAT_ARGB1555;
+               break;
+       case 16:
+               if (var->green.length != 5)
+                       *format = DRM_FORMAT_RGB565;
+               else if (var->transp.length > 0)
+                       *format = DRM_FORMAT_ARGB1555;
+               else
+                       *format = DRM_FORMAT_XRGB1555;
+               break;
+       case 24:
+               *format = DRM_FORMAT_RGB888;
+               break;
+       case 32:
+               if (var->transp.length > 0)
+                       *format = DRM_FORMAT_ARGB8888;
+               else
+                       *format = DRM_FORMAT_XRGB8888;
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       return 0;
+}
+
+static void drm_fbdev_dirty_work(struct work_struct *work)
+{
+       struct drm_fbdev *fbdev = container_of(work, struct drm_fbdev,
+                                              dirty_work);
+       struct drm_clip_rect *clip = &fbdev->dirty_clip;
+       struct drm_clip_rect clip_copy;
+       unsigned long flags;
+
+       spin_lock_irqsave(&fbdev->dirty_lock, flags);
+       clip_copy = *clip;
+       clip->x1 = clip->y1 = ~0;
+       clip->x2 = clip->y2 = 0;
+       spin_unlock_irqrestore(&fbdev->dirty_lock, flags);
+
+       /* call dirty callback only when it has been really touched */
+       if (clip_copy.x1 < clip_copy.x2 && clip_copy.y1 < clip_copy.y2)
+               drm_client_display_flush(fbdev->display, fbdev->curr_fb,
+                                        &clip_copy, 1);
+}
+
+static void drm_fbdev_dirty(struct fb_info *info, u32 x, u32 y,
+                           u32 width, u32 height)
+{
+       struct drm_fbdev *fbdev = info->par;
+       struct drm_clip_rect *clip = &fbdev->dirty_clip;
+       unsigned long flags;
+
+       if (!fbdev->flush)
+               return;
+
+       spin_lock_irqsave(&fbdev->dirty_lock, flags);
+       clip->x1 = min_t(u32, clip->x1, x);
+       clip->y1 = min_t(u32, clip->y1, y);
+       clip->x2 = max_t(u32, clip->x2, x + width);
+       clip->y2 = max_t(u32, clip->y2, y + height);
+       spin_unlock_irqrestore(&fbdev->dirty_lock, flags);
+
+       schedule_work(&fbdev->dirty_work);
+}
+
+static void drm_fbdev_deferred_io(struct fb_info *info,
+                                 struct list_head *pagelist)
+{
+       struct drm_fbdev *fbdev = info->par;
+       unsigned long start, end, min, max;
+       struct page *page;
+       u32 y1, y2;
+
+       /* Is userspace doing explicit pageflip flushing? */
+       if (fbdev->defio_no_flushing)
+               return;
+
+       min = ULONG_MAX;
+       max = 0;
+       list_for_each_entry(page, pagelist, lru) {
+               start = page->index << PAGE_SHIFT;
+               end = start + PAGE_SIZE;
+               min = min(min, start);
+               max = max(max, end);
+       }
+
+       if (min < max) {
+               y1 = min / info->fix.line_length;
+               y2 = DIV_ROUND_UP(max, info->fix.line_length);
+               y2 = min(y2, info->var.yres);
+               drm_fbdev_dirty(info, 0, y1, info->var.xres, y2 - y1);
+       }
+}
+
+static struct fb_deferred_io drm_fbdev_fbdefio = {
+       .delay          = HZ / 20,
+       .deferred_io    = drm_fbdev_deferred_io,
+};
+
+static int
+drm_fbdev_fb_mmap_notsupp(struct fb_info *info, struct vm_area_struct *vma)
+{
+       return -ENOTSUPP;
+}
+
+static void drm_fbdev_delete_buffer(struct drm_fbdev *fbdev)
+{
+       struct fb_info *info = fbdev->info;
+
+       if (info->fbdefio) {
+               /* Stop worker and clear page->mapping */
+               fb_deferred_io_cleanup(info);
+               info->fbdefio = NULL;
+       }
+       if (fbdev->flush) {
+               fbdev->flush = false;
+               cancel_work_sync(&fbdev->dirty_work);
+       }
+
+       drm_client_buffer_rmfb(fbdev->buffer);
+       drm_client_buffer_delete(fbdev->buffer);
+
+       fbdev->buffer = NULL;
+       fbdev->curr_fb = 0;
+       fbdev->page_flip_sent = false;
+       info->screen_buffer = NULL;
+       info->screen_size = 0;
+       info->fix.smem_len = 0;
+       info->fix.line_length = 0;
+}
+
+/* Temporary hack to make tinydrm work before converting to vmalloc buffers */
+static int drm_fbdev_cma_deferred_io_mmap(struct fb_info *info,
+                                         struct vm_area_struct *vma)
+{
+       fb_deferred_io_mmap(info, vma);
+       vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
+
+       return 0;
+}
+
+static int drm_fbdev_create_buffer(struct drm_fbdev *fbdev)
+{
+       struct drm_client_dev *client = fbdev->client;
+       struct fb_info *info = fbdev->info;
+       struct drm_client_buffer *buffer;
+       struct drm_mode_modeinfo *mode;
+       u32 format;
+       int ret;
+
+       ret = drm_fbdev_var_to_format(&info->var, &format);
+       if (ret)
+               return ret;
+
+       buffer = drm_client_buffer_create(client, info->var.xres_virtual,
+                                         info->var.yres_virtual, format);
+       if (IS_ERR(buffer))
+               return PTR_ERR(buffer);
+
+       mode = drm_fbdev_get_drm_mode(fbdev);
+       if (!mode)
+               return -EINVAL;
+
+       ret = drm_client_buffer_addfb(buffer, mode);
+       if (ret)
+               goto err_free_buffer;
+
+       fbdev->curr_fb = buffer->fb_ids[0];
+
+       if (drm_mode_can_dirtyfb(client->dev, fbdev->curr_fb, client->file)) {
+               fbdev->flush = true;
+/*             if (is_vmalloc_addr(buffer->vaddr)) { */
+/* Temporary hack for testing on tinydrm before it has moved to vmalloc */
+               if (1) {
+                       fbdev->dirty_clip.x1 = fbdev->dirty_clip.y1 = ~0;
+                       fbdev->dirty_clip.x2 = fbdev->dirty_clip.y2 = 0;
+                       info->fbdefio = &drm_fbdev_fbdefio;
+
+                       /* tinydrm hack */
+                       info->fix.smem_start = 
page_to_phys(virt_to_page(buffer->vaddr));
+
+                       fb_deferred_io_init(info);
+                       /* tinydrm hack */
+                       info->fbops->fb_mmap = drm_fbdev_cma_deferred_io_mmap;
+               } else {
+                       info->fbops->fb_mmap = drm_fbdev_fb_mmap_notsupp;
+               }
+       }
+
+       fbdev->buffer = buffer;
+       info->screen_buffer = buffer->vaddr;
+       info->screen_size = buffer->size;
+       info->fix.smem_len = buffer->size;
+       info->fix.line_length = buffer->pitch;
+
+       return 0;
+
+err_free_buffer:
+       drm_client_buffer_delete(buffer);
+
+       return ret;
+}
+
+static int drm_fbdev_fb_open(struct fb_info *info, int user)
+{
+       struct drm_fbdev *fbdev = info->par;
+       int ret = 0;
+
+       DRM_DEV_DEBUG_KMS(fbdev->client->dev->dev, "\n");
+
+       mutex_lock(&fbdev->lock);
+
+       if (!fbdev->display) {
+               ret = -ENODEV;
+               goto out_unlock;
+       }
+
+       if (!fbdev->open_count) {
+               /* Pipeline is disabled, make sure it's forced on */
+               info->var.activate = FB_ACTIVATE_NOW | FB_ACTIVATE_FORCE;
+               ret = drm_fbdev_create_buffer(fbdev);
+               if (ret)
+                       goto out_unlock;
+       }
+
+       fbdev->open_count++;
+
+out_unlock:
+       mutex_unlock(&fbdev->lock);
+
+       if (ret)
+               DRM_DEV_ERROR(fbdev->client->dev->dev, "fb_open failed (%d)\n", 
ret);
+
+       return ret;
+}
+
+static int drm_fbdev_fb_release(struct fb_info *info, int user)
+{
+       struct drm_fbdev *fbdev = info->par;
+
+       DRM_DEV_DEBUG_KMS(fbdev->client->dev->dev, "\n");
+       mutex_lock(&fbdev->lock);
+
+       if (--fbdev->open_count == 0) {
+               drm_client_display_dpms(fbdev->display, DRM_MODE_DPMS_OFF);
+               drm_fbdev_delete_buffer(fbdev);
+       }
+
+       fbdev->defio_no_flushing = false;
+
+       mutex_unlock(&fbdev->lock);
+
+       return 0;
+}
+
+static ssize_t drm_fbdev_fb_write(struct fb_info *info, const char __user *buf,
+                                 size_t count, loff_t *ppos)
+{
+       ssize_t ret;
+
+       ret = fb_sys_write(info, buf, count, ppos);
+       if (ret > 0)
+               drm_fbdev_dirty(info, 0, 0, info->var.xres, info->var.yres);
+
+       return ret;
+}
+
+static void
+drm_fbdev_fb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
+{
+       sys_fillrect(info, rect);
+       drm_fbdev_dirty(info, rect->dx, rect->dy, rect->width, rect->height);
+}
+
+static void
+drm_fbdev_fb_copyarea(struct fb_info *info, const struct fb_copyarea *area)
+{
+       sys_copyarea(info, area);
+       drm_fbdev_dirty(info, area->dx, area->dy, area->width, area->height);
+}
+
+static void
+drm_fbdev_fb_imageblit(struct fb_info *info, const struct fb_image *image)
+{
+       sys_imageblit(info, image);
+       drm_fbdev_dirty(info, image->dx, image->dy, image->width, 
image->height);
+}
+
+static int
+drm_fbdev_fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
+{
+       u32 new_format, old_format, yres_virtual;
+       struct drm_fbdev *fbdev = info->par;
+       const struct fb_videomode *fb_mode;
+       bool is_open;
+       int ret;
+
+       mutex_lock(&fbdev->lock);
+       is_open = fbdev->open_count;
+       mutex_unlock(&fbdev->lock);
+
+       if (!is_open && in_dbg_master())
+               return -EINVAL;
+
+       /* Can be called from sysfs */
+       if (is_open && (var->xres_virtual > fbdev->buffer->width ||
+           var->yres_virtual > fbdev->buffer->height)) {
+               DRM_DEBUG_KMS("Cannot increase virtual resolution while 
open\n");
+               return -EBUSY;
+       }
+
+       if (var->xres > var->xres_virtual || var->yres > var->yres_virtual) {
+               DRM_DEBUG_KMS("Requested width/height to big: %dx%d > virtual 
%dx%d\n",
+                             var->xres, var->yres, var->xres_virtual,
+                             var->yres_virtual);
+               return -EINVAL;
+       }
+
+       ret = drm_fbdev_var_to_format(var, &new_format);
+       if (ret) {
+               DRM_DEBUG_KMS("Unsupported format\n");
+               return -EINVAL;
+       }
+
+       ret = drm_fbdev_var_to_format(&info->var, &old_format);
+       if (ret)
+               return ret;
+
+       if (new_format != old_format && is_open) {
+               DRM_DEBUG_KMS("Cannot change format while open\n");
+               return -EBUSY;
+       }
+
+       drm_fbdev_format_fill_var(new_format, var);
+
+       fb_mode = fb_find_best_mode(var, &info->modelist);
+       if (!fb_mode)
+               return -EINVAL;
+
+       yres_virtual = var->yres_virtual;
+       fb_videomode_to_var(var, fb_mode);
+       var->yres_virtual = yres_virtual;
+
+       return 0;
+}
+
+static int drm_fbdev_fb_set_par(struct fb_info *info)
+{
+       struct drm_fbdev *fbdev = info->par;
+       const struct fb_videomode *fb_mode;
+       struct drm_mode_modeinfo *mode;
+       bool mode_changed;
+       int ret;
+
+       mutex_lock(&fbdev->lock);
+
+       if (!fbdev->open_count) {
+               ret = 0;
+               goto out_unlock;
+       }
+
+       fb_mode = fb_match_mode(&info->var, &info->modelist);
+       if (!fb_mode) {
+               DRM_DEBUG_KMS("Couldn't find var mode\n");
+               ret = -EINVAL;
+               goto out_unlock;
+       }
+
+       mode_changed = !fb_mode_is_equal(info->mode, fb_mode);
+       info->mode = (struct fb_videomode *)fb_mode;
+
+       mode = drm_fbdev_get_drm_mode(fbdev);
+       if (!mode) {
+               DRM_DEBUG_KMS("Couldn't find the matching DRM mode\n");
+               ret = -EINVAL;
+               goto out_unlock;
+       }
+
+       if (mode_changed) {
+               drm_client_buffer_rmfb(fbdev->buffer);
+               fbdev->curr_fb = 0;
+               ret = drm_client_buffer_addfb(fbdev->buffer, mode);
+               if (ret)
+                       goto out_unlock;
+
+               fbdev->curr_fb = fbdev->buffer->fb_ids[0];
+               info->var.yoffset = 0;
+       }
+
+//     info->var.width = drm_mode->width_mm;
+//     info->var.height = drm_mode->height_mm;
+
+       /* Panning is only supported to do page flipping */
+       info->fix.ypanstep = info->var.yres;
+
+       ret = drm_client_display_commit_mode(fbdev->display, fbdev->curr_fb, 
mode);
+
+out_unlock:
+       mutex_unlock(&fbdev->lock);
+
+       return ret;
+}
+
+/*
+ * Do we need to support FB_VISUAL_PSEUDOCOLOR?
+
+static int drm_fbdev_fb_setcolreg(unsigned regno, unsigned red, unsigned green,
+                   unsigned blue, unsigned transp, struct fb_info *info)
+{
+
+}
+*/
+
+static int setcmap_pseudo_palette(struct fb_cmap *cmap, struct fb_info *info)
+{
+       u32 *palette = (u32 *)info->pseudo_palette;
+       int i;
+
+       if (cmap->start + cmap->len > 16)
+               return -EINVAL;
+
+       for (i = 0; i < cmap->len; ++i) {
+               u16 red = cmap->red[i];
+               u16 green = cmap->green[i];
+               u16 blue = cmap->blue[i];
+               u32 value;
+
+               red >>= 16 - info->var.red.length;
+               green >>= 16 - info->var.green.length;
+               blue >>= 16 - info->var.blue.length;
+               value = (red << info->var.red.offset) |
+                       (green << info->var.green.offset) |
+                       (blue << info->var.blue.offset);
+               if (info->var.transp.length > 0) {
+                       u32 mask = (1 << info->var.transp.length) - 1;
+
+                       mask <<= info->var.transp.offset;
+                       value |= mask;
+               }
+               palette[cmap->start + i] = value;
+       }
+
+       return 0;
+}
+
+static int drm_fbdev_fb_setcmap(struct fb_cmap *cmap, struct fb_info *info)
+{
+       if (oops_in_progress)
+               return -EBUSY;
+
+       if (info->fix.visual == FB_VISUAL_TRUECOLOR)
+               return setcmap_pseudo_palette(cmap, info);
+
+       return -EINVAL;
+}
+
+static int drm_fbdev_fb_blank(int blank, struct fb_info *info)
+{
+       struct drm_fbdev *fbdev = info->par;
+       bool is_open;
+       int mode;
+
+       if (oops_in_progress)
+               return -EBUSY;
+
+       mutex_lock(&fbdev->lock);
+       is_open = fbdev->open_count;
+       mutex_unlock(&fbdev->lock);
+
+       if (!is_open)
+               return -EINVAL;
+
+       if (blank == FB_BLANK_UNBLANK)
+               mode = DRM_MODE_DPMS_ON;
+       else
+               mode = DRM_MODE_DPMS_OFF;
+
+       return drm_client_display_dpms(fbdev->display, mode);
+}
+
+static int
+drm_fbdev_fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
+{
+       struct drm_fbdev *fbdev = info->par;
+       struct drm_event *event;
+       unsigned int fb_idx;
+       int ret = 0;
+
+       mutex_lock(&fbdev->lock);
+
+       if (!fbdev->open_count)
+               goto out_unlock;
+
+       fb_idx = var->yoffset / info->var.yres;
+       if (fb_idx >= fbdev->buffer->num_fbs) {
+               ret = -EINVAL;
+               goto out_unlock;
+       }
+
+       /* Drain previous flip event if userspace didn't care */
+       if (fbdev->page_flip_sent) {
+               event = drm_client_read_event(fbdev->client, false);
+               if (!IS_ERR(event))
+                       kfree(event);
+               fbdev->page_flip_sent = false;
+       }
+
+       if (fbdev->curr_fb == fbdev->buffer->fb_ids[fb_idx])
+               goto out_unlock;
+
+       fbdev->curr_fb = fbdev->buffer->fb_ids[fb_idx];
+       fbdev->defio_no_flushing = true;
+
+       ret = drm_client_display_page_flip(fbdev->display, fbdev->curr_fb, 
true);
+       if (ret)
+               goto out_unlock;
+
+       fbdev->page_flip_sent = true;
+
+out_unlock:
+       mutex_unlock(&fbdev->lock);
+
+       return ret;
+}
+
+static int drm_fbdev_fb_ioctl(struct fb_info *info, unsigned int cmd,
+                             unsigned long arg)
+{
+       struct drm_fbdev *fbdev = info->par;
+       struct drm_event *event;
+       bool page_flip_sent;
+       int ret = 0;
+
+       switch (cmd) {
+//     case FBIOGET_VBLANK:
+//             break;
+       case FBIO_WAITFORVSYNC:
+               mutex_lock(&fbdev->lock);
+               page_flip_sent = fbdev->page_flip_sent;
+               fbdev->page_flip_sent = false;
+               mutex_unlock(&fbdev->lock);
+
+               if (page_flip_sent) {
+                       event = drm_client_read_event(fbdev->client, true);
+                       if (IS_ERR(event))
+                               ret = PTR_ERR(event);
+                       else
+                               kfree(event);
+               } else {
+                       drm_client_display_wait_vblank(fbdev->display);
+               }
+
+               break;
+       default:
+               ret = -ENOTTY;
+       }
+
+       return ret;
+}
+
+static int drm_fbdev_fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
+{
+       struct drm_fbdev *fbdev = info->par;
+
+       return dma_buf_mmap(fbdev->buffer->dma_buf, vma, 0);
+}
+
+static void drm_fbdev_fb_destroy(struct fb_info *info)
+{
+       struct drm_fbdev *fbdev = info->par;
+
+       DRM_DEV_DEBUG_KMS(fbdev->client->dev->dev, "\n");
+       drm_client_display_free(fbdev->display);
+       drm_client_free(fbdev->client);
+       kfree(fbdev);
+}
+
+static struct fb_ops drm_fbdev_fb_ops = {
+       .owner          = THIS_MODULE,
+       .fb_open        = drm_fbdev_fb_open,
+       .fb_release     = drm_fbdev_fb_release,
+       .fb_read        = fb_sys_read,
+       .fb_write       = drm_fbdev_fb_write,
+       .fb_check_var   = drm_fbdev_fb_check_var,
+       .fb_set_par     = drm_fbdev_fb_set_par,
+//     .fb_setcolreg   = drm_fbdev_fb_setcolreg,
+       .fb_setcmap     = drm_fbdev_fb_setcmap,
+       .fb_blank       = drm_fbdev_fb_blank,
+       .fb_pan_display = drm_fbdev_fb_pan_display,
+       .fb_fillrect    = drm_fbdev_fb_fillrect,
+       .fb_copyarea    = drm_fbdev_fb_copyarea,
+       .fb_imageblit   = drm_fbdev_fb_imageblit,
+       .fb_ioctl       = drm_fbdev_fb_ioctl,
+       .fb_mmap        = drm_fbdev_fb_mmap,
+       .fb_destroy     = drm_fbdev_fb_destroy,
+};
+
+static int drm_fbdev_register_framebuffer(struct drm_fbdev *fbdev)
+{
+       struct drm_client_display *display;
+       struct fb_info *info;
+       struct fb_ops *fbops;
+       u32 format;
+       int ret;
+
+       display = drm_client_display_get_first_enabled(fbdev->client, false);
+       if (IS_ERR_OR_NULL(display))
+               return PTR_ERR_OR_ZERO(display);
+
+       fbdev->display = display;
+
+       /*
+        * fb_deferred_io_cleanup() clears &fbops->fb_mmap so a per instance
+        * version is necessary. We do it for all users since we don't know
+        * yet if the fb has a dirty callback.
+        */
+       fbops = kzalloc(sizeof(*fbops), GFP_KERNEL);
+       if (!fbops) {
+               ret = -ENOMEM;
+               goto err_free;
+       }
+
+       *fbops = drm_fbdev_fb_ops;
+
+       info = framebuffer_alloc(0, fbdev->client->dev->dev);
+       if (!info) {
+               ret = -ENOMEM;
+               goto err_free;
+       }
+
+       ret = fb_alloc_cmap(&info->cmap, 256, 0);
+       if (ret)
+               goto err_release;
+
+       info->par = fbdev;
+       info->fbops = fbops;
+       INIT_LIST_HEAD(&info->modelist);
+       info->pseudo_palette = fbdev->pseudo_palette;
+
+       info->fix.type = FB_TYPE_PACKED_PIXELS;
+       info->fix.visual = FB_VISUAL_TRUECOLOR;
+       info->fix.ypanstep = info->var.yres;
+
+       strcpy(info->fix.id, "DRM emulated");
+
+       fbdev->info = info;
+       ret = drm_fbdev_sync_modes(fbdev, true);
+       if (ret < 0)
+               goto err_free_cmap;
+
+       info->var.bits_per_pixel = 
drm_client_display_preferred_depth(fbdev->display);
+       ret = drm_fbdev_var_to_format(&info->var, &format);
+       if (ret) {
+               DRM_WARN("Unsupported bpp, assuming x8r8g8b8 pixel format\n");
+               format = DRM_FORMAT_XRGB8888;
+       }
+       drm_fbdev_format_fill_var(format, &info->var);
+
+       info->var.xres_virtual = info->var.xres;
+       info->var.yres_virtual = info->var.yres;
+
+       info->var.yres_virtual *= CONFIG_DRM_FBDEV_OVERALLOC;
+       info->var.yres_virtual /= 100;
+
+       ret = register_framebuffer(info);
+       if (ret)
+               goto err_free_cmap;
+
+       dev_info(fbdev->client->dev->dev, "fb%d: %s frame buffer device\n",
+                info->node, info->fix.id);
+
+       return 0;
+
+err_free_cmap:
+       fb_dealloc_cmap(&info->cmap);
+err_release:
+       framebuffer_release(info);
+err_free:
+       kfree(fbops);
+       fbdev->info = NULL;
+       drm_client_display_free(fbdev->display);
+       fbdev->display = NULL;
+
+       return ret;
+}
+
+static int drm_fbdev_client_hotplug(struct drm_client_dev *client)
+{
+       struct drm_fbdev *fbdev = client->private;
+       int ret;
+
+       if (!fbdev->info)
+               ret = drm_fbdev_register_framebuffer(fbdev);
+       else
+               ret = drm_fbdev_sync_modes(fbdev, false);
+
+       return ret;
+}
+
+static int drm_fbdev_client_new(struct drm_client_dev *client)
+{
+       struct drm_fbdev *fbdev;
+
+       fbdev = kzalloc(sizeof(*fbdev), GFP_KERNEL);
+       if (!fbdev)
+               return -ENOMEM;
+
+       mutex_init(&fbdev->lock);
+       spin_lock_init(&fbdev->dirty_lock);
+       INIT_WORK(&fbdev->dirty_work, drm_fbdev_dirty_work);
+
+       fbdev->client = client;
+       client->private = fbdev;
+
+       /*
+        * vc4 isn't done with it's setup when drm_dev_register() is called.
+        * It should have shouldn't it?
+        * So to keep it from crashing defer setup to hotplug...
+        */
+       if (client->dev->mode_config.max_width)
+               drm_fbdev_client_hotplug(client);
+
+       return 0;
+}
+
+static int drm_fbdev_client_remove(struct drm_client_dev *client)
+{
+       struct drm_fbdev *fbdev = client->private;
+
+       if (!fbdev->info) {
+               kfree(fbdev);
+               return 0;
+       }
+
+       unregister_framebuffer(fbdev->info);
+
+       /* drm_fbdev_fb_destroy() frees the client */
+       return 1;
+}
+
+static int drm_fbdev_client_lastclose(struct drm_client_dev *client)
+{
+       struct drm_fbdev *fbdev = client->private;
+       int ret = -ENOENT;
+
+       if (fbdev->info)
+               ret = fbdev->info->fbops->fb_set_par(fbdev->info);
+
+       return ret;
+}
+
+static const struct drm_client_funcs drm_fbdev_client_funcs = {
+       .name           = "drm_fbdev",
+       .new            = drm_fbdev_client_new,
+       .remove         = drm_fbdev_client_remove,
+       .lastclose      = drm_fbdev_client_lastclose,
+       .hotplug        = drm_fbdev_client_hotplug,
+};
+
+static int __init drm_fbdev_init(void)
+{
+       return drm_client_register(&drm_fbdev_client_funcs);
+}
+module_init(drm_fbdev_init);
+
+static void __exit drm_fbdev_exit(void)
+{
+       drm_client_unregister(&drm_fbdev_client_funcs);
+}
+module_exit(drm_fbdev_exit);
+
+MODULE_DESCRIPTION("DRM Generic fbdev emulation");
+MODULE_AUTHOR("Noralf Trønnes");
+MODULE_LICENSE("GPL");
-- 
2.15.1

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Reply via email to