1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2011 Texas Instruments Incorporated - https://www.ti.com/ 4 * Author: Rob Clark <rob@ti.com> 5 */ 6 7 #include <drm/drm_crtc.h> 8 #include <drm/drm_util.h> 9 #include <drm/drm_fb_helper.h> 10 #include <drm/drm_file.h> 11 #include <drm/drm_fourcc.h> 12 #include <drm/drm_framebuffer.h> 13 14 #include "omap_drv.h" 15 16 MODULE_PARM_DESC(ywrap, "Enable ywrap scrolling (omap44xx and later, default 'y')"); 17 static bool ywrap_enabled = true; 18 module_param_named(ywrap, ywrap_enabled, bool, 0644); 19 20 /* 21 * fbdev funcs, to implement legacy fbdev interface on top of drm driver 22 */ 23 24 #define to_omap_fbdev(x) container_of(x, struct omap_fbdev, base) 25 26 struct omap_fbdev { 27 struct drm_fb_helper base; 28 struct drm_framebuffer *fb; 29 struct drm_gem_object *bo; 30 bool ywrap_enabled; 31 32 /* for deferred dmm roll when getting called in atomic ctx */ 33 struct work_struct work; 34 }; 35 36 static struct drm_fb_helper *get_fb(struct fb_info *fbi); 37 38 static void pan_worker(struct work_struct *work) 39 { 40 struct omap_fbdev *fbdev = container_of(work, struct omap_fbdev, work); 41 struct fb_info *fbi = fbdev->base.info; 42 int npages; 43 44 /* DMM roll shifts in 4K pages: */ 45 npages = fbi->fix.line_length >> PAGE_SHIFT; 46 omap_gem_roll(fbdev->bo, fbi->var.yoffset * npages); 47 } 48 49 static int omap_fbdev_pan_display(struct fb_var_screeninfo *var, 50 struct fb_info *fbi) 51 { 52 struct drm_fb_helper *helper = get_fb(fbi); 53 struct omap_fbdev *fbdev = to_omap_fbdev(helper); 54 55 if (!helper) 56 goto fallback; 57 58 if (!fbdev->ywrap_enabled) 59 goto fallback; 60 61 if (drm_can_sleep()) { 62 pan_worker(&fbdev->work); 63 } else { 64 struct omap_drm_private *priv = helper->dev->dev_private; 65 queue_work(priv->wq, &fbdev->work); 66 } 67 68 return 0; 69 70 fallback: 71 return drm_fb_helper_pan_display(var, fbi); 72 } 73 74 static const struct fb_ops omap_fb_ops = { 75 .owner = THIS_MODULE, 76 77 .fb_check_var = drm_fb_helper_check_var, 78 .fb_set_par = drm_fb_helper_set_par, 79 .fb_setcmap = drm_fb_helper_setcmap, 80 .fb_blank = drm_fb_helper_blank, 81 .fb_pan_display = omap_fbdev_pan_display, 82 .fb_ioctl = drm_fb_helper_ioctl, 83 84 .fb_read = drm_fb_helper_sys_read, 85 .fb_write = drm_fb_helper_sys_write, 86 .fb_fillrect = drm_fb_helper_sys_fillrect, 87 .fb_copyarea = drm_fb_helper_sys_copyarea, 88 .fb_imageblit = drm_fb_helper_sys_imageblit, 89 }; 90 91 static int omap_fbdev_create(struct drm_fb_helper *helper, 92 struct drm_fb_helper_surface_size *sizes) 93 { 94 struct omap_fbdev *fbdev = to_omap_fbdev(helper); 95 struct drm_device *dev = helper->dev; 96 struct omap_drm_private *priv = dev->dev_private; 97 struct drm_framebuffer *fb = NULL; 98 union omap_gem_size gsize; 99 struct fb_info *fbi = NULL; 100 struct drm_mode_fb_cmd2 mode_cmd = {0}; 101 dma_addr_t dma_addr; 102 int ret; 103 104 sizes->surface_bpp = 32; 105 sizes->surface_depth = 24; 106 107 DBG("create fbdev: %dx%d@%d (%dx%d)", sizes->surface_width, 108 sizes->surface_height, sizes->surface_bpp, 109 sizes->fb_width, sizes->fb_height); 110 111 mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp, 112 sizes->surface_depth); 113 114 mode_cmd.width = sizes->surface_width; 115 mode_cmd.height = sizes->surface_height; 116 117 mode_cmd.pitches[0] = 118 DIV_ROUND_UP(mode_cmd.width * sizes->surface_bpp, 8); 119 120 fbdev->ywrap_enabled = priv->has_dmm && ywrap_enabled; 121 if (fbdev->ywrap_enabled) { 122 /* need to align pitch to page size if using DMM scrolling */ 123 mode_cmd.pitches[0] = PAGE_ALIGN(mode_cmd.pitches[0]); 124 } 125 126 /* allocate backing bo */ 127 gsize = (union omap_gem_size){ 128 .bytes = PAGE_ALIGN(mode_cmd.pitches[0] * mode_cmd.height), 129 }; 130 DBG("allocating %d bytes for fb %d", gsize.bytes, dev->primary->index); 131 fbdev->bo = omap_gem_new(dev, gsize, OMAP_BO_SCANOUT | OMAP_BO_WC); 132 if (!fbdev->bo) { 133 dev_err(dev->dev, "failed to allocate buffer object\n"); 134 ret = -ENOMEM; 135 goto fail; 136 } 137 138 fb = omap_framebuffer_init(dev, &mode_cmd, &fbdev->bo); 139 if (IS_ERR(fb)) { 140 dev_err(dev->dev, "failed to allocate fb\n"); 141 /* note: if fb creation failed, we can't rely on fb destroy 142 * to unref the bo: 143 */ 144 drm_gem_object_put(fbdev->bo); 145 ret = PTR_ERR(fb); 146 goto fail; 147 } 148 149 /* note: this keeps the bo pinned.. which is perhaps not ideal, 150 * but is needed as long as we use fb_mmap() to mmap to userspace 151 * (since this happens using fix.smem_start). Possibly we could 152 * implement our own mmap using GEM mmap support to avoid this 153 * (non-tiled buffer doesn't need to be pinned for fbcon to write 154 * to it). Then we just need to be sure that we are able to re- 155 * pin it in case of an opps. 156 */ 157 ret = omap_gem_pin(fbdev->bo, &dma_addr); 158 if (ret) { 159 dev_err(dev->dev, "could not pin framebuffer\n"); 160 ret = -ENOMEM; 161 goto fail; 162 } 163 164 fbi = drm_fb_helper_alloc_info(helper); 165 if (IS_ERR(fbi)) { 166 dev_err(dev->dev, "failed to allocate fb info\n"); 167 ret = PTR_ERR(fbi); 168 goto fail; 169 } 170 171 DBG("fbi=%p, dev=%p", fbi, dev); 172 173 fbdev->fb = fb; 174 helper->fb = fb; 175 176 fbi->fbops = &omap_fb_ops; 177 178 drm_fb_helper_fill_info(fbi, helper, sizes); 179 180 fbi->screen_buffer = omap_gem_vaddr(fbdev->bo); 181 fbi->screen_size = fbdev->bo->size; 182 fbi->fix.smem_start = dma_addr; 183 fbi->fix.smem_len = fbdev->bo->size; 184 185 /* if we have DMM, then we can use it for scrolling by just 186 * shuffling pages around in DMM rather than doing sw blit. 187 */ 188 if (fbdev->ywrap_enabled) { 189 DRM_INFO("Enabling DMM ywrap scrolling\n"); 190 fbi->flags |= FBINFO_HWACCEL_YWRAP | FBINFO_READS_FAST; 191 fbi->fix.ywrapstep = 1; 192 } 193 194 195 DBG("par=%p, %dx%d", fbi->par, fbi->var.xres, fbi->var.yres); 196 DBG("allocated %dx%d fb", fbdev->fb->width, fbdev->fb->height); 197 198 return 0; 199 200 fail: 201 202 if (ret) { 203 if (fb) 204 drm_framebuffer_remove(fb); 205 } 206 207 return ret; 208 } 209 210 static const struct drm_fb_helper_funcs omap_fb_helper_funcs = { 211 .fb_probe = omap_fbdev_create, 212 }; 213 214 static struct drm_fb_helper *get_fb(struct fb_info *fbi) 215 { 216 if (!fbi || strcmp(fbi->fix.id, MODULE_NAME)) { 217 /* these are not the fb's you're looking for */ 218 return NULL; 219 } 220 return fbi->par; 221 } 222 223 /* initialize fbdev helper */ 224 void omap_fbdev_init(struct drm_device *dev) 225 { 226 struct omap_drm_private *priv = dev->dev_private; 227 struct omap_fbdev *fbdev = NULL; 228 struct drm_fb_helper *helper; 229 int ret = 0; 230 231 if (!priv->num_pipes) 232 return; 233 234 fbdev = kzalloc(sizeof(*fbdev), GFP_KERNEL); 235 if (!fbdev) 236 return; 237 238 INIT_WORK(&fbdev->work, pan_worker); 239 240 helper = &fbdev->base; 241 242 drm_fb_helper_prepare(dev, helper, 32, &omap_fb_helper_funcs); 243 244 ret = drm_fb_helper_init(dev, helper); 245 if (ret) 246 goto fail; 247 248 ret = drm_fb_helper_initial_config(helper); 249 if (ret) 250 goto fini; 251 252 priv->fbdev = helper; 253 254 return; 255 256 fini: 257 drm_fb_helper_fini(helper); 258 fail: 259 drm_fb_helper_unprepare(helper); 260 kfree(fbdev); 261 262 dev_warn(dev->dev, "omap_fbdev_init failed\n"); 263 } 264 265 void omap_fbdev_fini(struct drm_device *dev) 266 { 267 struct omap_drm_private *priv = dev->dev_private; 268 struct drm_fb_helper *helper = priv->fbdev; 269 struct omap_fbdev *fbdev; 270 271 DBG(); 272 273 if (!helper) 274 return; 275 276 drm_fb_helper_unregister_info(helper); 277 278 drm_fb_helper_fini(helper); 279 280 fbdev = to_omap_fbdev(helper); 281 282 /* unpin the GEM object pinned in omap_fbdev_create() */ 283 if (fbdev->bo) 284 omap_gem_unpin(fbdev->bo); 285 286 /* this will free the backing object */ 287 if (fbdev->fb) 288 drm_framebuffer_remove(fbdev->fb); 289 290 drm_fb_helper_unprepare(helper); 291 kfree(fbdev); 292 293 priv->fbdev = NULL; 294 } 295