2 * drivers/staging/omapdrm/omap_fbdev.c
4 * Copyright (C) 2011 Texas Instruments
5 * Author: Rob Clark <rob@ti.com>
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License version 2 as published by
9 * the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 * You should have received a copy of the GNU General Public License along with
17 * this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "drm_fb_helper.h"
25 MODULE_PARM_DESC(ywrap
, "Enable ywrap scrolling (omap44xx and later, default 'y')");
26 static bool ywrap_enabled
= true;
27 module_param_named(ywrap
, ywrap_enabled
, bool, 0644);
30 * fbdev funcs, to implement legacy fbdev interface on top of drm driver
33 #define to_omap_fbdev(x) container_of(x, struct omap_fbdev, base)
36 struct drm_fb_helper base
;
37 struct drm_framebuffer
*fb
;
38 struct drm_gem_object
*bo
;
41 /* for deferred dmm roll when getting called in atomic ctx */
42 struct work_struct work
;
45 static void omap_fbdev_flush(struct fb_info
*fbi
, int x
, int y
, int w
, int h
);
46 static struct drm_fb_helper
*get_fb(struct fb_info
*fbi
);
48 static ssize_t
omap_fbdev_write(struct fb_info
*fbi
, const char __user
*buf
,
49 size_t count
, loff_t
*ppos
)
53 res
= fb_sys_write(fbi
, buf
, count
, ppos
);
54 omap_fbdev_flush(fbi
, 0, 0, fbi
->var
.xres
, fbi
->var
.yres
);
59 static void omap_fbdev_fillrect(struct fb_info
*fbi
,
60 const struct fb_fillrect
*rect
)
62 sys_fillrect(fbi
, rect
);
63 omap_fbdev_flush(fbi
, rect
->dx
, rect
->dy
, rect
->width
, rect
->height
);
66 static void omap_fbdev_copyarea(struct fb_info
*fbi
,
67 const struct fb_copyarea
*area
)
69 sys_copyarea(fbi
, area
);
70 omap_fbdev_flush(fbi
, area
->dx
, area
->dy
, area
->width
, area
->height
);
73 static void omap_fbdev_imageblit(struct fb_info
*fbi
,
74 const struct fb_image
*image
)
76 sys_imageblit(fbi
, image
);
77 omap_fbdev_flush(fbi
, image
->dx
, image
->dy
,
78 image
->width
, image
->height
);
81 static void pan_worker(struct work_struct
*work
)
83 struct omap_fbdev
*fbdev
= container_of(work
, struct omap_fbdev
, work
);
84 struct fb_info
*fbi
= fbdev
->base
.fbdev
;
87 /* DMM roll shifts in 4K pages: */
88 npages
= fbi
->fix
.line_length
>> PAGE_SHIFT
;
89 omap_gem_roll(fbdev
->bo
, fbi
->var
.yoffset
* npages
);
92 static int omap_fbdev_pan_display(struct fb_var_screeninfo
*var
,
95 struct drm_fb_helper
*helper
= get_fb(fbi
);
96 struct omap_fbdev
*fbdev
= to_omap_fbdev(helper
);
101 if (!fbdev
->ywrap_enabled
)
104 if (drm_can_sleep()) {
105 pan_worker(&fbdev
->work
);
107 struct omap_drm_private
*priv
= helper
->dev
->dev_private
;
108 queue_work(priv
->wq
, &fbdev
->work
);
114 return drm_fb_helper_pan_display(var
, fbi
);
117 static struct fb_ops omap_fb_ops
= {
118 .owner
= THIS_MODULE
,
120 /* Note: to properly handle manual update displays, we wrap the
121 * basic fbdev ops which write to the framebuffer
123 .fb_read
= fb_sys_read
,
124 .fb_write
= omap_fbdev_write
,
125 .fb_fillrect
= omap_fbdev_fillrect
,
126 .fb_copyarea
= omap_fbdev_copyarea
,
127 .fb_imageblit
= omap_fbdev_imageblit
,
129 .fb_check_var
= drm_fb_helper_check_var
,
130 .fb_set_par
= drm_fb_helper_set_par
,
131 .fb_pan_display
= omap_fbdev_pan_display
,
132 .fb_blank
= drm_fb_helper_blank
,
133 .fb_setcmap
= drm_fb_helper_setcmap
,
135 .fb_debug_enter
= drm_fb_helper_debug_enter
,
136 .fb_debug_leave
= drm_fb_helper_debug_leave
,
139 static int omap_fbdev_create(struct drm_fb_helper
*helper
,
140 struct drm_fb_helper_surface_size
*sizes
)
142 struct omap_fbdev
*fbdev
= to_omap_fbdev(helper
);
143 struct drm_device
*dev
= helper
->dev
;
144 struct omap_drm_private
*priv
= dev
->dev_private
;
145 struct drm_framebuffer
*fb
= NULL
;
146 union omap_gem_size gsize
;
147 struct fb_info
*fbi
= NULL
;
148 struct drm_mode_fb_cmd2 mode_cmd
= {0};
152 /* only doing ARGB32 since this is what is needed to alpha-blend
153 * with video overlays:
155 sizes
->surface_bpp
= 32;
156 sizes
->surface_depth
= 32;
158 DBG("create fbdev: %dx%d@%d (%dx%d)", sizes
->surface_width
,
159 sizes
->surface_height
, sizes
->surface_bpp
,
160 sizes
->fb_width
, sizes
->fb_height
);
162 mode_cmd
.pixel_format
= drm_mode_legacy_fb_format(sizes
->surface_bpp
,
163 sizes
->surface_depth
);
165 mode_cmd
.width
= sizes
->surface_width
;
166 mode_cmd
.height
= sizes
->surface_height
;
168 mode_cmd
.pitches
[0] = align_pitch(
169 mode_cmd
.width
* ((sizes
->surface_bpp
+ 7) / 8),
170 mode_cmd
.width
, sizes
->surface_bpp
);
172 fbdev
->ywrap_enabled
= priv
->has_dmm
&& ywrap_enabled
;
173 if (fbdev
->ywrap_enabled
) {
174 /* need to align pitch to page size if using DMM scrolling */
175 mode_cmd
.pitches
[0] = ALIGN(mode_cmd
.pitches
[0], PAGE_SIZE
);
178 /* allocate backing bo */
179 gsize
= (union omap_gem_size
){
180 .bytes
= PAGE_ALIGN(mode_cmd
.pitches
[0] * mode_cmd
.height
),
182 DBG("allocating %d bytes for fb %d", gsize
.bytes
, dev
->primary
->index
);
183 fbdev
->bo
= omap_gem_new(dev
, gsize
, OMAP_BO_SCANOUT
| OMAP_BO_WC
);
185 dev_err(dev
->dev
, "failed to allocate buffer object\n");
190 fb
= omap_framebuffer_init(dev
, &mode_cmd
, &fbdev
->bo
);
192 dev_err(dev
->dev
, "failed to allocate fb\n");
193 /* note: if fb creation failed, we can't rely on fb destroy
196 drm_gem_object_unreference(fbdev
->bo
);
201 /* note: this keeps the bo pinned.. which is perhaps not ideal,
202 * but is needed as long as we use fb_mmap() to mmap to userspace
203 * (since this happens using fix.smem_start). Possibly we could
204 * implement our own mmap using GEM mmap support to avoid this
205 * (non-tiled buffer doesn't need to be pinned for fbcon to write
206 * to it). Then we just need to be sure that we are able to re-
207 * pin it in case of an opps.
209 ret
= omap_gem_get_paddr(fbdev
->bo
, &paddr
, true);
212 "could not map (paddr)! Skipping framebuffer alloc\n");
217 mutex_lock(&dev
->struct_mutex
);
219 fbi
= framebuffer_alloc(0, dev
->dev
);
221 dev_err(dev
->dev
, "failed to allocate fb info\n");
226 DBG("fbi=%p, dev=%p", fbi
, dev
);
233 fbi
->flags
= FBINFO_DEFAULT
;
234 fbi
->fbops
= &omap_fb_ops
;
236 strcpy(fbi
->fix
.id
, MODULE_NAME
);
238 ret
= fb_alloc_cmap(&fbi
->cmap
, 256, 0);
244 drm_fb_helper_fill_fix(fbi
, fb
->pitches
[0], fb
->depth
);
245 drm_fb_helper_fill_var(fbi
, helper
, sizes
->fb_width
, sizes
->fb_height
);
247 dev
->mode_config
.fb_base
= paddr
;
249 fbi
->screen_base
= omap_gem_vaddr(fbdev
->bo
);
250 fbi
->screen_size
= fbdev
->bo
->size
;
251 fbi
->fix
.smem_start
= paddr
;
252 fbi
->fix
.smem_len
= fbdev
->bo
->size
;
254 /* if we have DMM, then we can use it for scrolling by just
255 * shuffling pages around in DMM rather than doing sw blit.
257 if (fbdev
->ywrap_enabled
) {
258 DRM_INFO("Enabling DMM ywrap scrolling\n");
259 fbi
->flags
|= FBINFO_HWACCEL_YWRAP
| FBINFO_READS_FAST
;
260 fbi
->fix
.ywrapstep
= 1;
264 DBG("par=%p, %dx%d", fbi
->par
, fbi
->var
.xres
, fbi
->var
.yres
);
265 DBG("allocated %dx%d fb", fbdev
->fb
->width
, fbdev
->fb
->height
);
267 mutex_unlock(&dev
->struct_mutex
);
272 mutex_unlock(&dev
->struct_mutex
);
277 framebuffer_release(fbi
);
279 fb
->funcs
->destroy(fb
);
285 static void omap_crtc_fb_gamma_set(struct drm_crtc
*crtc
,
286 u16 red
, u16 green
, u16 blue
, int regno
)
288 DBG("fbdev: set gamma");
291 static void omap_crtc_fb_gamma_get(struct drm_crtc
*crtc
,
292 u16
*red
, u16
*green
, u16
*blue
, int regno
)
294 DBG("fbdev: get gamma");
297 static int omap_fbdev_probe(struct drm_fb_helper
*helper
,
298 struct drm_fb_helper_surface_size
*sizes
)
304 ret
= omap_fbdev_create(helper
, sizes
);
312 static struct drm_fb_helper_funcs omap_fb_helper_funcs
= {
313 .gamma_set
= omap_crtc_fb_gamma_set
,
314 .gamma_get
= omap_crtc_fb_gamma_get
,
315 .fb_probe
= omap_fbdev_probe
,
318 static struct drm_fb_helper
*get_fb(struct fb_info
*fbi
)
320 if (!fbi
|| strcmp(fbi
->fix
.id
, MODULE_NAME
)) {
321 /* these are not the fb's you're looking for */
327 /* flush an area of the framebuffer (in case of manual update display that
328 * is not automatically flushed)
330 static void omap_fbdev_flush(struct fb_info
*fbi
, int x
, int y
, int w
, int h
)
332 struct drm_fb_helper
*helper
= get_fb(fbi
);
337 VERB("flush fbdev: %d,%d %dx%d, fbi=%p", x
, y
, w
, h
, fbi
);
339 omap_framebuffer_flush(helper
->fb
, x
, y
, w
, h
);
342 /* initialize fbdev helper */
343 struct drm_fb_helper
*omap_fbdev_init(struct drm_device
*dev
)
345 struct omap_drm_private
*priv
= dev
->dev_private
;
346 struct omap_fbdev
*fbdev
= NULL
;
347 struct drm_fb_helper
*helper
;
350 fbdev
= kzalloc(sizeof(*fbdev
), GFP_KERNEL
);
352 dev_err(dev
->dev
, "could not allocate fbdev\n");
356 INIT_WORK(&fbdev
->work
, pan_worker
);
358 helper
= &fbdev
->base
;
360 helper
->funcs
= &omap_fb_helper_funcs
;
362 ret
= drm_fb_helper_init(dev
, helper
,
363 priv
->num_crtcs
, priv
->num_connectors
);
365 dev_err(dev
->dev
, "could not init fbdev: ret=%d\n", ret
);
369 drm_fb_helper_single_add_all_connectors(helper
);
370 drm_fb_helper_initial_config(helper
, 32);
372 priv
->fbdev
= helper
;
381 void omap_fbdev_free(struct drm_device
*dev
)
383 struct omap_drm_private
*priv
= dev
->dev_private
;
384 struct drm_fb_helper
*helper
= priv
->fbdev
;
385 struct omap_fbdev
*fbdev
;
392 /* only cleanup framebuffer if it is present */
394 unregister_framebuffer(fbi
);
395 framebuffer_release(fbi
);
398 drm_fb_helper_fini(helper
);
400 fbdev
= to_omap_fbdev(priv
->fbdev
);
402 /* this will free the backing object */
404 fbdev
->fb
->funcs
->destroy(fbdev
->fb
);