xref: /linux/drivers/gpu/drm/omapdrm/omap_fb.c (revision 3ce095c16263630dde46d6051854073edaacf3d7)
1 /*
2  * drivers/gpu/drm/omapdrm/omap_fb.c
3  *
4  * Copyright (C) 2011 Texas Instruments
5  * Author: Rob Clark <rob@ti.com>
6  *
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.
10  *
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
14  * more details.
15  *
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/>.
18  */
19 
20 #include "omap_drv.h"
21 #include "omap_dmm_tiler.h"
22 
23 #include "drm_crtc.h"
24 #include "drm_crtc_helper.h"
25 
26 /*
27  * framebuffer funcs
28  */
29 
30 /* per-format info: */
31 struct format {
32 	enum omap_color_mode dss_format;
33 	uint32_t pixel_format;
34 	struct {
35 		int stride_bpp;           /* this times width is stride */
36 		int sub_y;                /* sub-sample in y dimension */
37 	} planes[4];
38 	bool yuv;
39 };
40 
41 static const struct format formats[] = {
42 	/* 16bpp [A]RGB: */
43 	{ OMAP_DSS_COLOR_RGB16,       DRM_FORMAT_RGB565,   {{2, 1}}, false }, /* RGB16-565 */
44 	{ OMAP_DSS_COLOR_RGB12U,      DRM_FORMAT_RGBX4444, {{2, 1}}, false }, /* RGB12x-4444 */
45 	{ OMAP_DSS_COLOR_RGBX16,      DRM_FORMAT_XRGB4444, {{2, 1}}, false }, /* xRGB12-4444 */
46 	{ OMAP_DSS_COLOR_RGBA16,      DRM_FORMAT_RGBA4444, {{2, 1}}, false }, /* RGBA12-4444 */
47 	{ OMAP_DSS_COLOR_ARGB16,      DRM_FORMAT_ARGB4444, {{2, 1}}, false }, /* ARGB16-4444 */
48 	{ OMAP_DSS_COLOR_XRGB16_1555, DRM_FORMAT_XRGB1555, {{2, 1}}, false }, /* xRGB15-1555 */
49 	{ OMAP_DSS_COLOR_ARGB16_1555, DRM_FORMAT_ARGB1555, {{2, 1}}, false }, /* ARGB16-1555 */
50 	/* 24bpp RGB: */
51 	{ OMAP_DSS_COLOR_RGB24P,      DRM_FORMAT_RGB888,   {{3, 1}}, false }, /* RGB24-888 */
52 	/* 32bpp [A]RGB: */
53 	{ OMAP_DSS_COLOR_RGBX32,      DRM_FORMAT_RGBX8888, {{4, 1}}, false }, /* RGBx24-8888 */
54 	{ OMAP_DSS_COLOR_RGB24U,      DRM_FORMAT_XRGB8888, {{4, 1}}, false }, /* xRGB24-8888 */
55 	{ OMAP_DSS_COLOR_RGBA32,      DRM_FORMAT_RGBA8888, {{4, 1}}, false }, /* RGBA32-8888 */
56 	{ OMAP_DSS_COLOR_ARGB32,      DRM_FORMAT_ARGB8888, {{4, 1}}, false }, /* ARGB32-8888 */
57 	/* YUV: */
58 	{ OMAP_DSS_COLOR_NV12,        DRM_FORMAT_NV12,     {{1, 1}, {1, 2}}, true },
59 	{ OMAP_DSS_COLOR_YUV2,        DRM_FORMAT_YUYV,     {{2, 1}}, true },
60 	{ OMAP_DSS_COLOR_UYVY,        DRM_FORMAT_UYVY,     {{2, 1}}, true },
61 };
62 
63 /* convert from overlay's pixel formats bitmask to an array of fourcc's */
64 uint32_t omap_framebuffer_get_formats(uint32_t *pixel_formats,
65 		uint32_t max_formats, enum omap_color_mode supported_modes)
66 {
67 	uint32_t nformats = 0;
68 	int i = 0;
69 
70 	for (i = 0; i < ARRAY_SIZE(formats) && nformats < max_formats; i++)
71 		if (formats[i].dss_format & supported_modes)
72 			pixel_formats[nformats++] = formats[i].pixel_format;
73 
74 	return nformats;
75 }
76 
77 /* per-plane info for the fb: */
78 struct plane {
79 	struct drm_gem_object *bo;
80 	uint32_t pitch;
81 	uint32_t offset;
82 	dma_addr_t paddr;
83 };
84 
85 #define to_omap_framebuffer(x) container_of(x, struct omap_framebuffer, base)
86 
87 struct omap_framebuffer {
88 	struct drm_framebuffer base;
89 	int pin_count;
90 	const struct format *format;
91 	struct plane planes[4];
92 };
93 
94 static int omap_framebuffer_create_handle(struct drm_framebuffer *fb,
95 		struct drm_file *file_priv,
96 		unsigned int *handle)
97 {
98 	struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb);
99 	return drm_gem_handle_create(file_priv,
100 			omap_fb->planes[0].bo, handle);
101 }
102 
103 static void omap_framebuffer_destroy(struct drm_framebuffer *fb)
104 {
105 	struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb);
106 	int i, n = drm_format_num_planes(fb->pixel_format);
107 
108 	DBG("destroy: FB ID: %d (%p)", fb->base.id, fb);
109 
110 	drm_framebuffer_cleanup(fb);
111 
112 	for (i = 0; i < n; i++) {
113 		struct plane *plane = &omap_fb->planes[i];
114 		if (plane->bo)
115 			drm_gem_object_unreference_unlocked(plane->bo);
116 	}
117 
118 	kfree(omap_fb);
119 }
120 
121 static int omap_framebuffer_dirty(struct drm_framebuffer *fb,
122 		struct drm_file *file_priv, unsigned flags, unsigned color,
123 		struct drm_clip_rect *clips, unsigned num_clips)
124 {
125 	return 0;
126 }
127 
128 static const struct drm_framebuffer_funcs omap_framebuffer_funcs = {
129 	.create_handle = omap_framebuffer_create_handle,
130 	.destroy = omap_framebuffer_destroy,
131 	.dirty = omap_framebuffer_dirty,
132 };
133 
134 static uint32_t get_linear_addr(struct plane *plane,
135 		const struct format *format, int n, int x, int y)
136 {
137 	uint32_t offset;
138 
139 	offset = plane->offset +
140 			(x * format->planes[n].stride_bpp) +
141 			(y * plane->pitch / format->planes[n].sub_y);
142 
143 	return plane->paddr + offset;
144 }
145 
146 /* update ovl info for scanout, handles cases of multi-planar fb's, etc.
147  */
148 void omap_framebuffer_update_scanout(struct drm_framebuffer *fb,
149 		struct omap_drm_window *win, struct omap_overlay_info *info)
150 {
151 	struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb);
152 	const struct format *format = omap_fb->format;
153 	struct plane *plane = &omap_fb->planes[0];
154 	uint32_t x, y, orient = 0;
155 
156 	info->color_mode = format->dss_format;
157 
158 	info->pos_x      = win->crtc_x;
159 	info->pos_y      = win->crtc_y;
160 	info->out_width  = win->crtc_w;
161 	info->out_height = win->crtc_h;
162 	info->width      = win->src_w;
163 	info->height     = win->src_h;
164 
165 	x = win->src_x;
166 	y = win->src_y;
167 
168 	if (omap_gem_flags(plane->bo) & OMAP_BO_TILED) {
169 		uint32_t w = win->src_w;
170 		uint32_t h = win->src_h;
171 
172 		switch (win->rotation & 0xf) {
173 		default:
174 			dev_err(fb->dev->dev, "invalid rotation: %02x",
175 					(uint32_t)win->rotation);
176 			/* fallthru to default to no rotation */
177 		case 0:
178 		case BIT(DRM_ROTATE_0):
179 			orient = 0;
180 			break;
181 		case BIT(DRM_ROTATE_90):
182 			orient = MASK_XY_FLIP | MASK_X_INVERT;
183 			break;
184 		case BIT(DRM_ROTATE_180):
185 			orient = MASK_X_INVERT | MASK_Y_INVERT;
186 			break;
187 		case BIT(DRM_ROTATE_270):
188 			orient = MASK_XY_FLIP | MASK_Y_INVERT;
189 			break;
190 		}
191 
192 		if (win->rotation & BIT(DRM_REFLECT_X))
193 			orient ^= MASK_X_INVERT;
194 
195 		if (win->rotation & BIT(DRM_REFLECT_Y))
196 			orient ^= MASK_Y_INVERT;
197 
198 		/* adjust x,y offset for flip/invert: */
199 		if (orient & MASK_XY_FLIP)
200 			swap(w, h);
201 		if (orient & MASK_Y_INVERT)
202 			y += h - 1;
203 		if (orient & MASK_X_INVERT)
204 			x += w - 1;
205 
206 		omap_gem_rotated_paddr(plane->bo, orient, x, y, &info->paddr);
207 		info->rotation_type = OMAP_DSS_ROT_TILER;
208 		info->screen_width  = omap_gem_tiled_stride(plane->bo, orient);
209 	} else {
210 		switch (win->rotation & 0xf) {
211 		case 0:
212 		case BIT(DRM_ROTATE_0):
213 			/* OK */
214 			break;
215 
216 		default:
217 			dev_warn(fb->dev->dev,
218 				"rotation '%d' ignored for non-tiled fb\n",
219 				win->rotation);
220 			win->rotation = 0;
221 			break;
222 		}
223 
224 		info->paddr         = get_linear_addr(plane, format, 0, x, y);
225 		info->rotation_type = OMAP_DSS_ROT_DMA;
226 		info->screen_width  = plane->pitch;
227 	}
228 
229 	/* convert to pixels: */
230 	info->screen_width /= format->planes[0].stride_bpp;
231 
232 	if (format->dss_format == OMAP_DSS_COLOR_NV12) {
233 		plane = &omap_fb->planes[1];
234 
235 		if (info->rotation_type == OMAP_DSS_ROT_TILER) {
236 			WARN_ON(!(omap_gem_flags(plane->bo) & OMAP_BO_TILED));
237 			omap_gem_rotated_paddr(plane->bo, orient,
238 					x/2, y/2, &info->p_uv_addr);
239 		} else {
240 			info->p_uv_addr = get_linear_addr(plane, format, 1, x, y);
241 		}
242 	} else {
243 		info->p_uv_addr = 0;
244 	}
245 }
246 
247 /* pin, prepare for scanout: */
248 int omap_framebuffer_pin(struct drm_framebuffer *fb)
249 {
250 	struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb);
251 	int ret, i, n = drm_format_num_planes(fb->pixel_format);
252 
253 	if (omap_fb->pin_count > 0) {
254 		omap_fb->pin_count++;
255 		return 0;
256 	}
257 
258 	for (i = 0; i < n; i++) {
259 		struct plane *plane = &omap_fb->planes[i];
260 		ret = omap_gem_get_paddr(plane->bo, &plane->paddr, true);
261 		if (ret)
262 			goto fail;
263 		omap_gem_dma_sync(plane->bo, DMA_TO_DEVICE);
264 	}
265 
266 	omap_fb->pin_count++;
267 
268 	return 0;
269 
270 fail:
271 	for (i--; i >= 0; i--) {
272 		struct plane *plane = &omap_fb->planes[i];
273 		omap_gem_put_paddr(plane->bo);
274 		plane->paddr = 0;
275 	}
276 
277 	return ret;
278 }
279 
280 /* unpin, no longer being scanned out: */
281 int omap_framebuffer_unpin(struct drm_framebuffer *fb)
282 {
283 	struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb);
284 	int ret, i, n = drm_format_num_planes(fb->pixel_format);
285 
286 	omap_fb->pin_count--;
287 
288 	if (omap_fb->pin_count > 0)
289 		return 0;
290 
291 	for (i = 0; i < n; i++) {
292 		struct plane *plane = &omap_fb->planes[i];
293 		ret = omap_gem_put_paddr(plane->bo);
294 		if (ret)
295 			goto fail;
296 		plane->paddr = 0;
297 	}
298 
299 	return 0;
300 
301 fail:
302 	return ret;
303 }
304 
305 struct drm_gem_object *omap_framebuffer_bo(struct drm_framebuffer *fb, int p)
306 {
307 	struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb);
308 	if (p >= drm_format_num_planes(fb->pixel_format))
309 		return NULL;
310 	return omap_fb->planes[p].bo;
311 }
312 
313 /* iterate thru all the connectors, returning ones that are attached
314  * to the same fb..
315  */
316 struct drm_connector *omap_framebuffer_get_next_connector(
317 		struct drm_framebuffer *fb, struct drm_connector *from)
318 {
319 	struct drm_device *dev = fb->dev;
320 	struct list_head *connector_list = &dev->mode_config.connector_list;
321 	struct drm_connector *connector = from;
322 
323 	if (!from)
324 		return list_first_entry_or_null(connector_list, typeof(*from),
325 						head);
326 
327 	list_for_each_entry_from(connector, connector_list, head) {
328 		if (connector != from) {
329 			struct drm_encoder *encoder = connector->encoder;
330 			struct drm_crtc *crtc = encoder ? encoder->crtc : NULL;
331 			if (crtc && crtc->primary->fb == fb)
332 				return connector;
333 
334 		}
335 	}
336 
337 	return NULL;
338 }
339 
340 #ifdef CONFIG_DEBUG_FS
341 void omap_framebuffer_describe(struct drm_framebuffer *fb, struct seq_file *m)
342 {
343 	struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb);
344 	int i, n = drm_format_num_planes(fb->pixel_format);
345 
346 	seq_printf(m, "fb: %dx%d@%4.4s\n", fb->width, fb->height,
347 			(char *)&fb->pixel_format);
348 
349 	for (i = 0; i < n; i++) {
350 		struct plane *plane = &omap_fb->planes[i];
351 		seq_printf(m, "   %d: offset=%d pitch=%d, obj: ",
352 				i, plane->offset, plane->pitch);
353 		omap_gem_describe(plane->bo, m);
354 	}
355 }
356 #endif
357 
358 struct drm_framebuffer *omap_framebuffer_create(struct drm_device *dev,
359 		struct drm_file *file, struct drm_mode_fb_cmd2 *mode_cmd)
360 {
361 	struct drm_gem_object *bos[4];
362 	struct drm_framebuffer *fb;
363 	int ret;
364 
365 	ret = objects_lookup(dev, file, mode_cmd->pixel_format,
366 			bos, mode_cmd->handles);
367 	if (ret)
368 		return ERR_PTR(ret);
369 
370 	fb = omap_framebuffer_init(dev, mode_cmd, bos);
371 	if (IS_ERR(fb)) {
372 		int i, n = drm_format_num_planes(mode_cmd->pixel_format);
373 		for (i = 0; i < n; i++)
374 			drm_gem_object_unreference_unlocked(bos[i]);
375 		return fb;
376 	}
377 	return fb;
378 }
379 
380 struct drm_framebuffer *omap_framebuffer_init(struct drm_device *dev,
381 		struct drm_mode_fb_cmd2 *mode_cmd, struct drm_gem_object **bos)
382 {
383 	struct omap_framebuffer *omap_fb = NULL;
384 	struct drm_framebuffer *fb = NULL;
385 	const struct format *format = NULL;
386 	int ret, i, n = drm_format_num_planes(mode_cmd->pixel_format);
387 
388 	DBG("create framebuffer: dev=%p, mode_cmd=%p (%dx%d@%4.4s)",
389 			dev, mode_cmd, mode_cmd->width, mode_cmd->height,
390 			(char *)&mode_cmd->pixel_format);
391 
392 	for (i = 0; i < ARRAY_SIZE(formats); i++) {
393 		if (formats[i].pixel_format == mode_cmd->pixel_format) {
394 			format = &formats[i];
395 			break;
396 		}
397 	}
398 
399 	if (!format) {
400 		dev_err(dev->dev, "unsupported pixel format: %4.4s\n",
401 				(char *)&mode_cmd->pixel_format);
402 		ret = -EINVAL;
403 		goto fail;
404 	}
405 
406 	omap_fb = kzalloc(sizeof(*omap_fb), GFP_KERNEL);
407 	if (!omap_fb) {
408 		ret = -ENOMEM;
409 		goto fail;
410 	}
411 
412 	fb = &omap_fb->base;
413 	omap_fb->format = format;
414 
415 	for (i = 0; i < n; i++) {
416 		struct plane *plane = &omap_fb->planes[i];
417 		int size, pitch = mode_cmd->pitches[i];
418 
419 		if (pitch < (mode_cmd->width * format->planes[i].stride_bpp)) {
420 			dev_err(dev->dev, "provided buffer pitch is too small! %d < %d\n",
421 					pitch, mode_cmd->width * format->planes[i].stride_bpp);
422 			ret = -EINVAL;
423 			goto fail;
424 		}
425 
426 		if (pitch % format->planes[i].stride_bpp != 0) {
427 			dev_err(dev->dev,
428 				"buffer pitch (%d bytes) is not a multiple of pixel size (%d bytes)\n",
429 				pitch, format->planes[i].stride_bpp);
430 			ret = -EINVAL;
431 			goto fail;
432 		}
433 
434 		size = pitch * mode_cmd->height / format->planes[i].sub_y;
435 
436 		if (size > (omap_gem_mmap_size(bos[i]) - mode_cmd->offsets[i])) {
437 			dev_err(dev->dev, "provided buffer object is too small! %d < %d\n",
438 					bos[i]->size - mode_cmd->offsets[i], size);
439 			ret = -EINVAL;
440 			goto fail;
441 		}
442 
443 		plane->bo     = bos[i];
444 		plane->offset = mode_cmd->offsets[i];
445 		plane->pitch  = pitch;
446 		plane->paddr  = 0;
447 	}
448 
449 	drm_helper_mode_fill_fb_struct(fb, mode_cmd);
450 
451 	ret = drm_framebuffer_init(dev, fb, &omap_framebuffer_funcs);
452 	if (ret) {
453 		dev_err(dev->dev, "framebuffer init failed: %d\n", ret);
454 		goto fail;
455 	}
456 
457 	DBG("create: FB ID: %d (%p)", fb->base.id, fb);
458 
459 	return fb;
460 
461 fail:
462 	kfree(omap_fb);
463 
464 	return ERR_PTR(ret);
465 }
466