xref: /openbmc/linux/drivers/gpu/drm/omapdrm/omap_fb.c (revision b34e08d5)
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 	const struct format *format;
90 	struct plane planes[4];
91 };
92 
93 static int omap_framebuffer_create_handle(struct drm_framebuffer *fb,
94 		struct drm_file *file_priv,
95 		unsigned int *handle)
96 {
97 	struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb);
98 	return drm_gem_handle_create(file_priv,
99 			omap_fb->planes[0].bo, handle);
100 }
101 
102 static void omap_framebuffer_destroy(struct drm_framebuffer *fb)
103 {
104 	struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb);
105 	int i, n = drm_format_num_planes(fb->pixel_format);
106 
107 	DBG("destroy: FB ID: %d (%p)", fb->base.id, fb);
108 
109 	drm_framebuffer_cleanup(fb);
110 
111 	for (i = 0; i < n; i++) {
112 		struct plane *plane = &omap_fb->planes[i];
113 		if (plane->bo)
114 			drm_gem_object_unreference_unlocked(plane->bo);
115 	}
116 
117 	kfree(omap_fb);
118 }
119 
120 static int omap_framebuffer_dirty(struct drm_framebuffer *fb,
121 		struct drm_file *file_priv, unsigned flags, unsigned color,
122 		struct drm_clip_rect *clips, unsigned num_clips)
123 {
124 	int i;
125 
126 	drm_modeset_lock_all(fb->dev);
127 
128 	for (i = 0; i < num_clips; i++) {
129 		omap_framebuffer_flush(fb, clips[i].x1, clips[i].y1,
130 					clips[i].x2 - clips[i].x1,
131 					clips[i].y2 - clips[i].y1);
132 	}
133 
134 	drm_modeset_unlock_all(fb->dev);
135 
136 	return 0;
137 }
138 
139 static const struct drm_framebuffer_funcs omap_framebuffer_funcs = {
140 	.create_handle = omap_framebuffer_create_handle,
141 	.destroy = omap_framebuffer_destroy,
142 	.dirty = omap_framebuffer_dirty,
143 };
144 
145 static uint32_t get_linear_addr(struct plane *plane,
146 		const struct format *format, int n, int x, int y)
147 {
148 	uint32_t offset;
149 
150 	offset = plane->offset +
151 			(x * format->planes[n].stride_bpp) +
152 			(y * plane->pitch / format->planes[n].sub_y);
153 
154 	return plane->paddr + offset;
155 }
156 
157 /* update ovl info for scanout, handles cases of multi-planar fb's, etc.
158  */
159 void omap_framebuffer_update_scanout(struct drm_framebuffer *fb,
160 		struct omap_drm_window *win, struct omap_overlay_info *info)
161 {
162 	struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb);
163 	const struct format *format = omap_fb->format;
164 	struct plane *plane = &omap_fb->planes[0];
165 	uint32_t x, y, orient = 0;
166 
167 	info->color_mode = format->dss_format;
168 
169 	info->pos_x      = win->crtc_x;
170 	info->pos_y      = win->crtc_y;
171 	info->out_width  = win->crtc_w;
172 	info->out_height = win->crtc_h;
173 	info->width      = win->src_w;
174 	info->height     = win->src_h;
175 
176 	x = win->src_x;
177 	y = win->src_y;
178 
179 	if (omap_gem_flags(plane->bo) & OMAP_BO_TILED) {
180 		uint32_t w = win->src_w;
181 		uint32_t h = win->src_h;
182 
183 		switch (win->rotation & 0xf) {
184 		default:
185 			dev_err(fb->dev->dev, "invalid rotation: %02x",
186 					(uint32_t)win->rotation);
187 			/* fallthru to default to no rotation */
188 		case 0:
189 		case BIT(DRM_ROTATE_0):
190 			orient = 0;
191 			break;
192 		case BIT(DRM_ROTATE_90):
193 			orient = MASK_XY_FLIP | MASK_X_INVERT;
194 			break;
195 		case BIT(DRM_ROTATE_180):
196 			orient = MASK_X_INVERT | MASK_Y_INVERT;
197 			break;
198 		case BIT(DRM_ROTATE_270):
199 			orient = MASK_XY_FLIP | MASK_Y_INVERT;
200 			break;
201 		}
202 
203 		if (win->rotation & BIT(DRM_REFLECT_X))
204 			orient ^= MASK_X_INVERT;
205 
206 		if (win->rotation & BIT(DRM_REFLECT_Y))
207 			orient ^= MASK_Y_INVERT;
208 
209 		/* adjust x,y offset for flip/invert: */
210 		if (orient & MASK_XY_FLIP)
211 			swap(w, h);
212 		if (orient & MASK_Y_INVERT)
213 			y += h - 1;
214 		if (orient & MASK_X_INVERT)
215 			x += w - 1;
216 
217 		omap_gem_rotated_paddr(plane->bo, orient, x, y, &info->paddr);
218 		info->rotation_type = OMAP_DSS_ROT_TILER;
219 		info->screen_width  = omap_gem_tiled_stride(plane->bo, orient);
220 	} else {
221 		info->paddr         = get_linear_addr(plane, format, 0, x, y);
222 		info->rotation_type = OMAP_DSS_ROT_DMA;
223 		info->screen_width  = plane->pitch;
224 	}
225 
226 	/* convert to pixels: */
227 	info->screen_width /= format->planes[0].stride_bpp;
228 
229 	if (format->dss_format == OMAP_DSS_COLOR_NV12) {
230 		plane = &omap_fb->planes[1];
231 
232 		if (info->rotation_type == OMAP_DSS_ROT_TILER) {
233 			WARN_ON(!(omap_gem_flags(plane->bo) & OMAP_BO_TILED));
234 			omap_gem_rotated_paddr(plane->bo, orient,
235 					x/2, y/2, &info->p_uv_addr);
236 		} else {
237 			info->p_uv_addr = get_linear_addr(plane, format, 1, x, y);
238 		}
239 	} else {
240 		info->p_uv_addr = 0;
241 	}
242 }
243 
244 /* pin, prepare for scanout: */
245 int omap_framebuffer_pin(struct drm_framebuffer *fb)
246 {
247 	struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb);
248 	int ret, i, n = drm_format_num_planes(fb->pixel_format);
249 
250 	for (i = 0; i < n; i++) {
251 		struct plane *plane = &omap_fb->planes[i];
252 		ret = omap_gem_get_paddr(plane->bo, &plane->paddr, true);
253 		if (ret)
254 			goto fail;
255 		omap_gem_dma_sync(plane->bo, DMA_TO_DEVICE);
256 	}
257 
258 	return 0;
259 
260 fail:
261 	for (i--; i >= 0; i--) {
262 		struct plane *plane = &omap_fb->planes[i];
263 		omap_gem_put_paddr(plane->bo);
264 		plane->paddr = 0;
265 	}
266 
267 	return ret;
268 }
269 
270 /* unpin, no longer being scanned out: */
271 int omap_framebuffer_unpin(struct drm_framebuffer *fb)
272 {
273 	struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb);
274 	int ret, i, n = drm_format_num_planes(fb->pixel_format);
275 
276 	for (i = 0; i < n; i++) {
277 		struct plane *plane = &omap_fb->planes[i];
278 		ret = omap_gem_put_paddr(plane->bo);
279 		if (ret)
280 			goto fail;
281 		plane->paddr = 0;
282 	}
283 
284 	return 0;
285 
286 fail:
287 	return ret;
288 }
289 
290 struct drm_gem_object *omap_framebuffer_bo(struct drm_framebuffer *fb, int p)
291 {
292 	struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb);
293 	if (p >= drm_format_num_planes(fb->pixel_format))
294 		return NULL;
295 	return omap_fb->planes[p].bo;
296 }
297 
298 /* iterate thru all the connectors, returning ones that are attached
299  * to the same fb..
300  */
301 struct drm_connector *omap_framebuffer_get_next_connector(
302 		struct drm_framebuffer *fb, struct drm_connector *from)
303 {
304 	struct drm_device *dev = fb->dev;
305 	struct list_head *connector_list = &dev->mode_config.connector_list;
306 	struct drm_connector *connector = from;
307 
308 	if (!from)
309 		return list_first_entry_or_null(connector_list, typeof(*from),
310 						head);
311 
312 	list_for_each_entry_from(connector, connector_list, head) {
313 		if (connector != from) {
314 			struct drm_encoder *encoder = connector->encoder;
315 			struct drm_crtc *crtc = encoder ? encoder->crtc : NULL;
316 			if (crtc && crtc->primary->fb == fb)
317 				return connector;
318 
319 		}
320 	}
321 
322 	return NULL;
323 }
324 
325 /* flush an area of the framebuffer (in case of manual update display that
326  * is not automatically flushed)
327  */
328 void omap_framebuffer_flush(struct drm_framebuffer *fb,
329 		int x, int y, int w, int h)
330 {
331 	struct drm_connector *connector = NULL;
332 
333 	VERB("flush: %d,%d %dx%d, fb=%p", x, y, w, h, fb);
334 
335 	while ((connector = omap_framebuffer_get_next_connector(fb, connector))) {
336 		/* only consider connectors that are part of a chain */
337 		if (connector->encoder && connector->encoder->crtc) {
338 			/* TODO: maybe this should propagate thru the crtc who
339 			 * could do the coordinate translation..
340 			 */
341 			struct drm_crtc *crtc = connector->encoder->crtc;
342 			int cx = max(0, x - crtc->x);
343 			int cy = max(0, y - crtc->y);
344 			int cw = w + (x - crtc->x) - cx;
345 			int ch = h + (y - crtc->y) - cy;
346 
347 			omap_connector_flush(connector, cx, cy, cw, ch);
348 		}
349 	}
350 }
351 
352 #ifdef CONFIG_DEBUG_FS
353 void omap_framebuffer_describe(struct drm_framebuffer *fb, struct seq_file *m)
354 {
355 	struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb);
356 	int i, n = drm_format_num_planes(fb->pixel_format);
357 
358 	seq_printf(m, "fb: %dx%d@%4.4s\n", fb->width, fb->height,
359 			(char *)&fb->pixel_format);
360 
361 	for (i = 0; i < n; i++) {
362 		struct plane *plane = &omap_fb->planes[i];
363 		seq_printf(m, "   %d: offset=%d pitch=%d, obj: ",
364 				i, plane->offset, plane->pitch);
365 		omap_gem_describe(plane->bo, m);
366 	}
367 }
368 #endif
369 
370 struct drm_framebuffer *omap_framebuffer_create(struct drm_device *dev,
371 		struct drm_file *file, struct drm_mode_fb_cmd2 *mode_cmd)
372 {
373 	struct drm_gem_object *bos[4];
374 	struct drm_framebuffer *fb;
375 	int ret;
376 
377 	ret = objects_lookup(dev, file, mode_cmd->pixel_format,
378 			bos, mode_cmd->handles);
379 	if (ret)
380 		return ERR_PTR(ret);
381 
382 	fb = omap_framebuffer_init(dev, mode_cmd, bos);
383 	if (IS_ERR(fb)) {
384 		int i, n = drm_format_num_planes(mode_cmd->pixel_format);
385 		for (i = 0; i < n; i++)
386 			drm_gem_object_unreference_unlocked(bos[i]);
387 		return fb;
388 	}
389 	return fb;
390 }
391 
392 struct drm_framebuffer *omap_framebuffer_init(struct drm_device *dev,
393 		struct drm_mode_fb_cmd2 *mode_cmd, struct drm_gem_object **bos)
394 {
395 	struct omap_framebuffer *omap_fb;
396 	struct drm_framebuffer *fb = NULL;
397 	const struct format *format = NULL;
398 	int ret, i, n = drm_format_num_planes(mode_cmd->pixel_format);
399 
400 	DBG("create framebuffer: dev=%p, mode_cmd=%p (%dx%d@%4.4s)",
401 			dev, mode_cmd, mode_cmd->width, mode_cmd->height,
402 			(char *)&mode_cmd->pixel_format);
403 
404 	for (i = 0; i < ARRAY_SIZE(formats); i++) {
405 		if (formats[i].pixel_format == mode_cmd->pixel_format) {
406 			format = &formats[i];
407 			break;
408 		}
409 	}
410 
411 	if (!format) {
412 		dev_err(dev->dev, "unsupported pixel format: %4.4s\n",
413 				(char *)&mode_cmd->pixel_format);
414 		ret = -EINVAL;
415 		goto fail;
416 	}
417 
418 	omap_fb = kzalloc(sizeof(*omap_fb), GFP_KERNEL);
419 	if (!omap_fb) {
420 		ret = -ENOMEM;
421 		goto fail;
422 	}
423 
424 	fb = &omap_fb->base;
425 	omap_fb->format = format;
426 
427 	for (i = 0; i < n; i++) {
428 		struct plane *plane = &omap_fb->planes[i];
429 		int size, pitch = mode_cmd->pitches[i];
430 
431 		if (pitch < (mode_cmd->width * format->planes[i].stride_bpp)) {
432 			dev_err(dev->dev, "provided buffer pitch is too small! %d < %d\n",
433 					pitch, mode_cmd->width * format->planes[i].stride_bpp);
434 			ret = -EINVAL;
435 			goto fail;
436 		}
437 
438 		size = pitch * mode_cmd->height / format->planes[i].sub_y;
439 
440 		if (size > (omap_gem_mmap_size(bos[i]) - mode_cmd->offsets[i])) {
441 			dev_err(dev->dev, "provided buffer object is too small! %d < %d\n",
442 					bos[i]->size - mode_cmd->offsets[i], size);
443 			ret = -EINVAL;
444 			goto fail;
445 		}
446 
447 		plane->bo     = bos[i];
448 		plane->offset = mode_cmd->offsets[i];
449 		plane->pitch  = pitch;
450 		plane->paddr  = 0;
451 	}
452 
453 	drm_helper_mode_fill_fb_struct(fb, mode_cmd);
454 
455 	ret = drm_framebuffer_init(dev, fb, &omap_framebuffer_funcs);
456 	if (ret) {
457 		dev_err(dev->dev, "framebuffer init failed: %d\n", ret);
458 		goto fail;
459 	}
460 
461 	DBG("create: FB ID: %d (%p)", fb->base.id, fb);
462 
463 	return fb;
464 
465 fail:
466 	if (fb)
467 		omap_framebuffer_destroy(fb);
468 
469 	return ERR_PTR(ret);
470 }
471