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 	fbi = drm_fb_helper_alloc_fbi(helper);
174 	if (IS_ERR(fbi)) {
175 		dev_err(dev->dev, "failed to allocate fb info\n");
176 		ret = PTR_ERR(fbi);
177 		goto fail;
178 	}
179 
180 	DBG("fbi=%p, dev=%p", fbi, dev);
181 
182 	fbdev->fb = fb;
183 	helper->fb = fb;
184 
185 	fbi->par = helper;
186 	fbi->fbops = &omap_fb_ops;
187 
188 	strcpy(fbi->fix.id, MODULE_NAME);
189 
190 	drm_fb_helper_fill_fix(fbi, fb->pitches[0], fb->format->depth);
191 	drm_fb_helper_fill_var(fbi, helper, sizes->fb_width, sizes->fb_height);
192 
193 	dev->mode_config.fb_base = dma_addr;
194 
195 	fbi->screen_buffer = omap_gem_vaddr(fbdev->bo);
196 	fbi->screen_size = fbdev->bo->size;
197 	fbi->fix.smem_start = dma_addr;
198 	fbi->fix.smem_len = fbdev->bo->size;
199 
200 	/* if we have DMM, then we can use it for scrolling by just
201 	 * shuffling pages around in DMM rather than doing sw blit.
202 	 */
203 	if (fbdev->ywrap_enabled) {
204 		DRM_INFO("Enabling DMM ywrap scrolling\n");
205 		fbi->flags |= FBINFO_HWACCEL_YWRAP | FBINFO_READS_FAST;
206 		fbi->fix.ywrapstep = 1;
207 	}
208 
209 
210 	DBG("par=%p, %dx%d", fbi->par, fbi->var.xres, fbi->var.yres);
211 	DBG("allocated %dx%d fb", fbdev->fb->width, fbdev->fb->height);
212 
213 	return 0;
214 
215 fail:
216 
217 	if (ret) {
218 		if (fb)
219 			drm_framebuffer_remove(fb);
220 	}
221 
222 	return ret;
223 }
224 
225 static const struct drm_fb_helper_funcs omap_fb_helper_funcs = {
226 	.fb_probe = omap_fbdev_create,
227 };
228 
229 static struct drm_fb_helper *get_fb(struct fb_info *fbi)
230 {
231 	if (!fbi || strcmp(fbi->fix.id, MODULE_NAME)) {
232 		/* these are not the fb's you're looking for */
233 		return NULL;
234 	}
235 	return fbi->par;
236 }
237 
238 /* initialize fbdev helper */
239 void omap_fbdev_init(struct drm_device *dev)
240 {
241 	struct omap_drm_private *priv = dev->dev_private;
242 	struct omap_fbdev *fbdev = NULL;
243 	struct drm_fb_helper *helper;
244 	int ret = 0;
245 
246 	if (!priv->num_crtcs || !priv->num_connectors)
247 		return;
248 
249 	fbdev = kzalloc(sizeof(*fbdev), GFP_KERNEL);
250 	if (!fbdev)
251 		goto fail;
252 
253 	INIT_WORK(&fbdev->work, pan_worker);
254 
255 	helper = &fbdev->base;
256 
257 	drm_fb_helper_prepare(dev, helper, &omap_fb_helper_funcs);
258 
259 	ret = drm_fb_helper_init(dev, helper, priv->num_connectors);
260 	if (ret)
261 		goto fail;
262 
263 	ret = drm_fb_helper_single_add_all_connectors(helper);
264 	if (ret)
265 		goto fini;
266 
267 	ret = drm_fb_helper_initial_config(helper, 32);
268 	if (ret)
269 		goto fini;
270 
271 	priv->fbdev = helper;
272 
273 	return;
274 
275 fini:
276 	drm_fb_helper_fini(helper);
277 fail:
278 	kfree(fbdev);
279 
280 	dev_warn(dev->dev, "omap_fbdev_init failed\n");
281 }
282 
283 void omap_fbdev_fini(struct drm_device *dev)
284 {
285 	struct omap_drm_private *priv = dev->dev_private;
286 	struct drm_fb_helper *helper = priv->fbdev;
287 	struct omap_fbdev *fbdev;
288 
289 	DBG();
290 
291 	if (!helper)
292 		return;
293 
294 	drm_fb_helper_unregister_fbi(helper);
295 
296 	drm_fb_helper_fini(helper);
297 
298 	fbdev = to_omap_fbdev(helper);
299 
300 	/* unpin the GEM object pinned in omap_fbdev_create() */
301 	if (fbdev->bo)
302 		omap_gem_unpin(fbdev->bo);
303 
304 	/* this will free the backing object */
305 	if (fbdev->fb)
306 		drm_framebuffer_remove(fbdev->fb);
307 
308 	kfree(fbdev);
309 
310 	priv->fbdev = NULL;
311 }
312