Quelle  exynos_drm_fbdev.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/* exynos_drm_fbdev.c
 *
 * Copyright (c) 2011 Samsung Electronics Co., Ltd.
 * Authors:
 * Inki Dae <inki.dae@samsung.com>
 * Joonyoung Shim <jy0922.shim@samsung.com>
 * Seung-Woo Kim <sw0312.kim@samsung.com>
 */

#include <linux/fb.h>

#include <drm/drm_crtc_helper.h>
#include <drm/drm_drv.h>
#include <drm/drm_fb_helper.h>
#include <drm/drm_framebuffer.h>
#include <drm/drm_gem_framebuffer_helper.h>
#include <drm/drm_prime.h>
#include <drm/exynos_drm.h>

#include "exynos_drm_drv.h"
#include "exynos_drm_fb.h"
#include "exynos_drm_fbdev.h"

#define MAX_CONNECTOR  4

static int exynos_drm_fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
{
 struct drm_fb_helper *helper = info->par;
 struct drm_gem_object *obj = drm_gem_fb_get_obj(helper->fb, 0);

 return drm_gem_prime_mmap(obj, vma);
}

static void exynos_drm_fb_destroy(struct fb_info *info)
{
 struct drm_fb_helper *fb_helper = info->par;
 struct drm_framebuffer *fb = fb_helper->fb;

 drm_fb_helper_fini(fb_helper);

 drm_framebuffer_remove(fb);

 drm_client_release(&fb_helper->client);
 drm_fb_helper_unprepare(fb_helper);
 kfree(fb_helper);
}

static const struct fb_ops exynos_drm_fb_ops = {
 .owner  = THIS_MODULE,
 __FB_DEFAULT_DMAMEM_OPS_RDWR,
 DRM_FB_HELPER_DEFAULT_OPS,
 __FB_DEFAULT_DMAMEM_OPS_DRAW,
 .fb_mmap        = exynos_drm_fb_mmap,
 .fb_destroy = exynos_drm_fb_destroy,
};

static int exynos_drm_fbdev_update(struct drm_fb_helper *helper,
       struct drm_fb_helper_surface_size *sizes,
       struct exynos_drm_gem *exynos_gem)
{
 struct fb_info *fbi;
 struct drm_framebuffer *fb = helper->fb;
 unsigned int size = fb->width * fb->height * fb->format->cpp[0];
 unsigned long offset;

 fbi = drm_fb_helper_alloc_info(helper);
 if (IS_ERR(fbi)) {
  DRM_DEV_ERROR(to_dma_dev(helper->dev),
         "failed to allocate fb info.\n");
  return PTR_ERR(fbi);
 }

 fbi->fbops = &exynos_drm_fb_ops;

 drm_fb_helper_fill_info(fbi, helper, sizes);

 offset = fbi->var.xoffset * fb->format->cpp[0];
 offset += fbi->var.yoffset * fb->pitches[0];

 fbi->flags |= FBINFO_VIRTFB;
 fbi->screen_buffer = exynos_gem->kvaddr + offset;
 fbi->screen_size = size;
 fbi->fix.smem_len = size;

 return 0;
}

static const struct drm_fb_helper_funcs exynos_drm_fbdev_helper_funcs = {
};

int exynos_drm_fbdev_driver_fbdev_probe(struct drm_fb_helper *helper,
     struct drm_fb_helper_surface_size *sizes)
{
 struct exynos_drm_gem *exynos_gem;
 struct drm_device *dev = helper->dev;
 struct drm_mode_fb_cmd2 mode_cmd = { 0 };
 unsigned long size;
 int ret;

 DRM_DEV_DEBUG_KMS(dev->dev,
     "surface width(%d), height(%d) and bpp(%d\n",
     sizes->surface_width, sizes->surface_height,
     sizes->surface_bpp);

 mode_cmd.width = sizes->surface_width;
 mode_cmd.height = sizes->surface_height;
 mode_cmd.pitches[0] = sizes->surface_width * (sizes->surface_bpp >> 3);
 mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp,
         sizes->surface_depth);

 size = mode_cmd.pitches[0] * mode_cmd.height;

 exynos_gem = exynos_drm_gem_create(dev, EXYNOS_BO_WC, size, true);
 if (IS_ERR(exynos_gem))
  return PTR_ERR(exynos_gem);

 helper->fb =
  exynos_drm_framebuffer_init(dev,
         drm_get_format_info(dev, mode_cmd.pixel_format,
        mode_cmd.modifier[0]),
         &mode_cmd, &exynos_gem, 1);
 if (IS_ERR(helper->fb)) {
  DRM_DEV_ERROR(dev->dev, "failed to create drm framebuffer.\n");
  ret = PTR_ERR(helper->fb);
  goto err_destroy_gem;
 }
 helper->funcs = &exynos_drm_fbdev_helper_funcs;

 ret = exynos_drm_fbdev_update(helper, sizes, exynos_gem);
 if (ret < 0)
  goto err_destroy_framebuffer;

 return 0;

err_destroy_framebuffer:
 drm_framebuffer_cleanup(helper->fb);
 helper->fb = NULL;
err_destroy_gem:
 exynos_drm_gem_destroy(exynos_gem);
 return ret;
}