drm/tegra/fb.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (C) 2012-2013 Avionic Design GmbH
0004  * Copyright (C) 2012 NVIDIA CORPORATION.  All rights reserved.
0005  *
0006  * Based on the KMS/FB CMA helpers
0007  *   Copyright (C) 2012 Analog Devices Inc.
0008  */
0009
0010 #include <linux/console.h>
0011
0012 #include <drm/drm_fourcc.h>
0013 #include <drm/drm_framebuffer.h>
0014 #include <drm/drm_gem_framebuffer_helper.h>
0015 #include <drm/drm_modeset_helper.h>
0016
0017 #include "drm.h"
0018 #include "gem.h"
0019
0020 #ifdef CONFIG_DRM_FBDEV_EMULATION
0021 static inline struct tegra_fbdev *to_tegra_fbdev(struct drm_fb_helper *helper)
0022 {
0023     return container_of(helper, struct tegra_fbdev, base);
0024 }
0025 #endif
0026
0027 struct tegra_bo *tegra_fb_get_plane(struct drm_framebuffer *framebuffer,
0028                     unsigned int index)
0029 {
0030     return to_tegra_bo(drm_gem_fb_get_obj(framebuffer, index));
0031 }
0032
0033 bool tegra_fb_is_bottom_up(struct drm_framebuffer *framebuffer)
0034 {
0035     struct tegra_bo *bo = tegra_fb_get_plane(framebuffer, 0);
0036
0037     if (bo->flags & TEGRA_BO_BOTTOM_UP)
0038         return true;
0039
0040     return false;
0041 }
0042
0043 int tegra_fb_get_tiling(struct drm_framebuffer *framebuffer,
0044             struct tegra_bo_tiling *tiling)
0045 {
0046     uint64_t modifier = framebuffer->modifier;
0047
0048     if (fourcc_mod_is_vendor(modifier, NVIDIA)) {
0049         if ((modifier & DRM_FORMAT_MOD_NVIDIA_SECTOR_LAYOUT) == 0)
0050             tiling->sector_layout = TEGRA_BO_SECTOR_LAYOUT_TEGRA;
0051         else
0052             tiling->sector_layout = TEGRA_BO_SECTOR_LAYOUT_GPU;
0053
0054         modifier &= ~DRM_FORMAT_MOD_NVIDIA_SECTOR_LAYOUT;
0055     }
0056
0057     switch (modifier) {
0058     case DRM_FORMAT_MOD_LINEAR:
0059         tiling->mode = TEGRA_BO_TILING_MODE_PITCH;
0060         tiling->value = 0;
0061         break;
0062
0063     case DRM_FORMAT_MOD_NVIDIA_TEGRA_TILED:
0064         tiling->mode = TEGRA_BO_TILING_MODE_TILED;
0065         tiling->value = 0;
0066         break;
0067
0068     case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(0):
0069         tiling->mode = TEGRA_BO_TILING_MODE_BLOCK;
0070         tiling->value = 0;
0071         break;
0072
0073     case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(1):
0074         tiling->mode = TEGRA_BO_TILING_MODE_BLOCK;
0075         tiling->value = 1;
0076         break;
0077
0078     case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(2):
0079         tiling->mode = TEGRA_BO_TILING_MODE_BLOCK;
0080         tiling->value = 2;
0081         break;
0082
0083     case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(3):
0084         tiling->mode = TEGRA_BO_TILING_MODE_BLOCK;
0085         tiling->value = 3;
0086         break;
0087
0088     case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(4):
0089         tiling->mode = TEGRA_BO_TILING_MODE_BLOCK;
0090         tiling->value = 4;
0091         break;
0092
0093     case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(5):
0094         tiling->mode = TEGRA_BO_TILING_MODE_BLOCK;
0095         tiling->value = 5;
0096         break;
0097
0098     default:
0099         DRM_DEBUG_KMS("unknown format modifier: %llx\n", modifier);
0100         return -EINVAL;
0101     }
0102
0103     return 0;
0104 }
0105
0106 static const struct drm_framebuffer_funcs tegra_fb_funcs = {
0107     .destroy = drm_gem_fb_destroy,
0108     .create_handle = drm_gem_fb_create_handle,
0109 };
0110
0111 static struct drm_framebuffer *tegra_fb_alloc(struct drm_device *drm,
0112                           const struct drm_mode_fb_cmd2 *mode_cmd,
0113                           struct tegra_bo **planes,
0114                           unsigned int num_planes)
0115 {
0116     struct drm_framebuffer *fb;
0117     unsigned int i;
0118     int err;
0119
0120     fb = kzalloc(sizeof(*fb), GFP_KERNEL);
0121     if (!fb)
0122         return ERR_PTR(-ENOMEM);
0123
0124     drm_helper_mode_fill_fb_struct(drm, fb, mode_cmd);
0125
0126     for (i = 0; i < fb->format->num_planes; i++)
0127         fb->obj[i] = &planes[i]->gem;
0128
0129     err = drm_framebuffer_init(drm, fb, &tegra_fb_funcs);
0130     if (err < 0) {
0131         dev_err(drm->dev, "failed to initialize framebuffer: %d\n",
0132             err);
0133         kfree(fb);
0134         return ERR_PTR(err);
0135     }
0136
0137     return fb;
0138 }
0139
0140 struct drm_framebuffer *tegra_fb_create(struct drm_device *drm,
0141                     struct drm_file *file,
0142                     const struct drm_mode_fb_cmd2 *cmd)
0143 {
0144     const struct drm_format_info *info = drm_get_format_info(drm, cmd);
0145     struct tegra_bo *planes[4];
0146     struct drm_gem_object *gem;
0147     struct drm_framebuffer *fb;
0148     unsigned int i;
0149     int err;
0150
0151     for (i = 0; i < info->num_planes; i++) {
0152         unsigned int width = cmd->width / (i ? info->hsub : 1);
0153         unsigned int height = cmd->height / (i ? info->vsub : 1);
0154         unsigned int size, bpp;
0155
0156         gem = drm_gem_object_lookup(file, cmd->handles[i]);
0157         if (!gem) {
0158             err = -ENXIO;
0159             goto unreference;
0160         }
0161
0162         bpp = info->cpp[i];
0163
0164         size = (height - 1) * cmd->pitches[i] +
0165                width * bpp + cmd->offsets[i];
0166
0167         if (gem->size < size) {
0168             err = -EINVAL;
0169             goto unreference;
0170         }
0171
0172         planes[i] = to_tegra_bo(gem);
0173     }
0174
0175     fb = tegra_fb_alloc(drm, cmd, planes, i);
0176     if (IS_ERR(fb)) {
0177         err = PTR_ERR(fb);
0178         goto unreference;
0179     }
0180
0181     return fb;
0182
0183 unreference:
0184     while (i--)
0185         drm_gem_object_put(&planes[i]->gem);
0186
0187     return ERR_PTR(err);
0188 }
0189
0190 #ifdef CONFIG_DRM_FBDEV_EMULATION
0191 static int tegra_fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
0192 {
0193     struct drm_fb_helper *helper = info->par;
0194     struct tegra_bo *bo;
0195     int err;
0196
0197     bo = tegra_fb_get_plane(helper->fb, 0);
0198
0199     err = drm_gem_mmap_obj(&bo->gem, bo->gem.size, vma);
0200     if (err < 0)
0201         return err;
0202
0203     return __tegra_gem_mmap(&bo->gem, vma);
0204 }
0205
0206 static const struct fb_ops tegra_fb_ops = {
0207     .owner = THIS_MODULE,
0208     DRM_FB_HELPER_DEFAULT_OPS,
0209     .fb_fillrect = drm_fb_helper_sys_fillrect,
0210     .fb_copyarea = drm_fb_helper_sys_copyarea,
0211     .fb_imageblit = drm_fb_helper_sys_imageblit,
0212     .fb_mmap = tegra_fb_mmap,
0213 };
0214
0215 static int tegra_fbdev_probe(struct drm_fb_helper *helper,
0216                  struct drm_fb_helper_surface_size *sizes)
0217 {
0218     struct tegra_fbdev *fbdev = to_tegra_fbdev(helper);
0219     struct tegra_drm *tegra = helper->dev->dev_private;
0220     struct drm_device *drm = helper->dev;
0221     struct drm_mode_fb_cmd2 cmd = { 0 };
0222     unsigned int bytes_per_pixel;
0223     struct drm_framebuffer *fb;
0224     unsigned long offset;
0225     struct fb_info *info;
0226     struct tegra_bo *bo;
0227     size_t size;
0228     int err;
0229
0230     bytes_per_pixel = DIV_ROUND_UP(sizes->surface_bpp, 8);
0231
0232     cmd.width = sizes->surface_width;
0233     cmd.height = sizes->surface_height;
0234     cmd.pitches[0] = round_up(sizes->surface_width * bytes_per_pixel,
0235                   tegra->pitch_align);
0236
0237     cmd.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp,
0238                              sizes->surface_depth);
0239
0240     size = cmd.pitches[0] * cmd.height;
0241
0242     bo = tegra_bo_create(drm, size, 0);
0243     if (IS_ERR(bo))
0244         return PTR_ERR(bo);
0245
0246     info = drm_fb_helper_alloc_fbi(helper);
0247     if (IS_ERR(info)) {
0248         dev_err(drm->dev, "failed to allocate framebuffer info\n");
0249         drm_gem_object_put(&bo->gem);
0250         return PTR_ERR(info);
0251     }
0252
0253     fbdev->fb = tegra_fb_alloc(drm, &cmd, &bo, 1);
0254     if (IS_ERR(fbdev->fb)) {
0255         err = PTR_ERR(fbdev->fb);
0256         dev_err(drm->dev, "failed to allocate DRM framebuffer: %d\n",
0257             err);
0258         drm_gem_object_put(&bo->gem);
0259         return PTR_ERR(fbdev->fb);
0260     }
0261
0262     fb = fbdev->fb;
0263     helper->fb = fb;
0264     helper->fbdev = info;
0265
0266     info->fbops = &tegra_fb_ops;
0267
0268     drm_fb_helper_fill_info(info, helper, sizes);
0269
0270     offset = info->var.xoffset * bytes_per_pixel +
0271          info->var.yoffset * fb->pitches[0];
0272
0273     if (bo->pages) {
0274         bo->vaddr = vmap(bo->pages, bo->num_pages, VM_MAP,
0275                  pgprot_writecombine(PAGE_KERNEL));
0276         if (!bo->vaddr) {
0277             dev_err(drm->dev, "failed to vmap() framebuffer\n");
0278             err = -ENOMEM;
0279             goto destroy;
0280         }
0281     }
0282
0283     drm->mode_config.fb_base = (resource_size_t)bo->iova;
0284     info->screen_base = (void __iomem *)bo->vaddr + offset;
0285     info->screen_size = size;
0286     info->fix.smem_start = (unsigned long)(bo->iova + offset);
0287     info->fix.smem_len = size;
0288
0289     return 0;
0290
0291 destroy:
0292     drm_framebuffer_remove(fb);
0293     return err;
0294 }
0295
0296 static const struct drm_fb_helper_funcs tegra_fb_helper_funcs = {
0297     .fb_probe = tegra_fbdev_probe,
0298 };
0299
0300 static struct tegra_fbdev *tegra_fbdev_create(struct drm_device *drm)
0301 {
0302     struct tegra_fbdev *fbdev;
0303
0304     fbdev = kzalloc(sizeof(*fbdev), GFP_KERNEL);
0305     if (!fbdev) {
0306         dev_err(drm->dev, "failed to allocate DRM fbdev\n");
0307         return ERR_PTR(-ENOMEM);
0308     }
0309
0310     drm_fb_helper_prepare(drm, &fbdev->base, &tegra_fb_helper_funcs);
0311
0312     return fbdev;
0313 }
0314
0315 static void tegra_fbdev_free(struct tegra_fbdev *fbdev)
0316 {
0317     kfree(fbdev);
0318 }
0319
0320 static int tegra_fbdev_init(struct tegra_fbdev *fbdev,
0321                 unsigned int preferred_bpp,
0322                 unsigned int num_crtc,
0323                 unsigned int max_connectors)
0324 {
0325     struct drm_device *drm = fbdev->base.dev;
0326     int err;
0327
0328     err = drm_fb_helper_init(drm, &fbdev->base);
0329     if (err < 0) {
0330         dev_err(drm->dev, "failed to initialize DRM FB helper: %d\n",
0331             err);
0332         return err;
0333     }
0334
0335     err = drm_fb_helper_initial_config(&fbdev->base, preferred_bpp);
0336     if (err < 0) {
0337         dev_err(drm->dev, "failed to set initial configuration: %d\n",
0338             err);
0339         goto fini;
0340     }
0341
0342     return 0;
0343
0344 fini:
0345     drm_fb_helper_fini(&fbdev->base);
0346     return err;
0347 }
0348
0349 static void tegra_fbdev_exit(struct tegra_fbdev *fbdev)
0350 {
0351     drm_fb_helper_unregister_fbi(&fbdev->base);
0352
0353     if (fbdev->fb) {
0354         struct tegra_bo *bo = tegra_fb_get_plane(fbdev->fb, 0);
0355
0356         /* Undo the special mapping we made in fbdev probe. */
0357         if (bo && bo->pages) {
0358             vunmap(bo->vaddr);
0359             bo->vaddr = NULL;
0360         }
0361
0362         drm_framebuffer_remove(fbdev->fb);
0363     }
0364
0365     drm_fb_helper_fini(&fbdev->base);
0366     tegra_fbdev_free(fbdev);
0367 }
0368 #endif
0369
0370 int tegra_drm_fb_prepare(struct drm_device *drm)
0371 {
0372 #ifdef CONFIG_DRM_FBDEV_EMULATION
0373     struct tegra_drm *tegra = drm->dev_private;
0374
0375     tegra->fbdev = tegra_fbdev_create(drm);
0376     if (IS_ERR(tegra->fbdev))
0377         return PTR_ERR(tegra->fbdev);
0378 #endif
0379
0380     return 0;
0381 }
0382
0383 void tegra_drm_fb_free(struct drm_device *drm)
0384 {
0385 #ifdef CONFIG_DRM_FBDEV_EMULATION
0386     struct tegra_drm *tegra = drm->dev_private;
0387
0388     tegra_fbdev_free(tegra->fbdev);
0389 #endif
0390 }
0391
0392 int tegra_drm_fb_init(struct drm_device *drm)
0393 {
0394 #ifdef CONFIG_DRM_FBDEV_EMULATION
0395     struct tegra_drm *tegra = drm->dev_private;
0396     int err;
0397
0398     err = tegra_fbdev_init(tegra->fbdev, 32, drm->mode_config.num_crtc,
0399                    drm->mode_config.num_connector);
0400     if (err < 0)
0401         return err;
0402 #endif
0403
0404     return 0;
0405 }
0406
0407 void tegra_drm_fb_exit(struct drm_device *drm)
0408 {
0409 #ifdef CONFIG_DRM_FBDEV_EMULATION
0410     struct tegra_drm *tegra = drm->dev_private;
0411
0412     tegra_fbdev_exit(tegra->fbdev);
0413 #endif
0414 }