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