Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 1 | /* |
Rob Clark | 8bb0daf | 2013-02-11 12:43:09 -0500 | [diff] [blame] | 2 | * drivers/gpu/drm/omapdrm/omap_fb.c |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 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" |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 21 | #include "omap_dmm_tiler.h" |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 22 | |
| 23 | #include "drm_crtc.h" |
| 24 | #include "drm_crtc_helper.h" |
| 25 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 26 | /* |
| 27 | * framebuffer funcs |
| 28 | */ |
| 29 | |
Rob Clark | ae43d7c | 2012-01-16 12:51:15 -0600 | [diff] [blame] | 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 | |
Rob Clark | a890e66 | 2012-03-05 10:48:31 -0600 | [diff] [blame] | 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 | |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 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 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 85 | #define to_omap_framebuffer(x) container_of(x, struct omap_framebuffer, base) |
| 86 | |
| 87 | struct omap_framebuffer { |
| 88 | struct drm_framebuffer base; |
Rob Clark | ae43d7c | 2012-01-16 12:51:15 -0600 | [diff] [blame] | 89 | const struct format *format; |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 90 | struct plane planes[4]; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 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); |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 98 | return drm_gem_handle_create(file_priv, |
| 99 | omap_fb->planes[0].bo, handle); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 100 | } |
| 101 | |
| 102 | static void omap_framebuffer_destroy(struct drm_framebuffer *fb) |
| 103 | { |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 104 | struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb); |
Rob Clark | 9f18c95 | 2012-03-05 10:48:34 -0600 | [diff] [blame] | 105 | int i, n = drm_format_num_planes(fb->pixel_format); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 106 | |
| 107 | DBG("destroy: FB ID: %d (%p)", fb->base.id, fb); |
| 108 | |
| 109 | drm_framebuffer_cleanup(fb); |
| 110 | |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 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); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 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 | for (i = 0; i < num_clips; i++) { |
| 127 | omap_framebuffer_flush(fb, clips[i].x1, clips[i].y1, |
| 128 | clips[i].x2 - clips[i].x1, |
| 129 | clips[i].y2 - clips[i].y1); |
| 130 | } |
| 131 | |
| 132 | return 0; |
| 133 | } |
| 134 | |
| 135 | static const struct drm_framebuffer_funcs omap_framebuffer_funcs = { |
| 136 | .create_handle = omap_framebuffer_create_handle, |
| 137 | .destroy = omap_framebuffer_destroy, |
| 138 | .dirty = omap_framebuffer_dirty, |
| 139 | }; |
| 140 | |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 141 | static uint32_t get_linear_addr(struct plane *plane, |
| 142 | const struct format *format, int n, int x, int y) |
| 143 | { |
| 144 | uint32_t offset; |
| 145 | |
| 146 | offset = plane->offset + |
| 147 | (x * format->planes[n].stride_bpp) + |
| 148 | (y * plane->pitch / format->planes[n].sub_y); |
| 149 | |
| 150 | return plane->paddr + offset; |
| 151 | } |
| 152 | |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 153 | /* update ovl info for scanout, handles cases of multi-planar fb's, etc. |
| 154 | */ |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 155 | void omap_framebuffer_update_scanout(struct drm_framebuffer *fb, |
| 156 | struct omap_drm_window *win, struct omap_overlay_info *info) |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 157 | { |
| 158 | struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb); |
| 159 | const struct format *format = omap_fb->format; |
| 160 | struct plane *plane = &omap_fb->planes[0]; |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 161 | uint32_t x, y, orient = 0; |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 162 | |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 163 | info->color_mode = format->dss_format; |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 164 | |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 165 | info->pos_x = win->crtc_x; |
| 166 | info->pos_y = win->crtc_y; |
| 167 | info->out_width = win->crtc_w; |
| 168 | info->out_height = win->crtc_h; |
| 169 | info->width = win->src_w; |
| 170 | info->height = win->src_h; |
| 171 | |
| 172 | x = win->src_x; |
| 173 | y = win->src_y; |
| 174 | |
| 175 | if (omap_gem_flags(plane->bo) & OMAP_BO_TILED) { |
| 176 | uint32_t w = win->src_w; |
| 177 | uint32_t h = win->src_h; |
| 178 | |
| 179 | switch (win->rotation & 0xf) { |
| 180 | default: |
| 181 | dev_err(fb->dev->dev, "invalid rotation: %02x", |
| 182 | (uint32_t)win->rotation); |
| 183 | /* fallthru to default to no rotation */ |
| 184 | case 0: |
| 185 | case BIT(DRM_ROTATE_0): |
| 186 | orient = 0; |
| 187 | break; |
| 188 | case BIT(DRM_ROTATE_90): |
| 189 | orient = MASK_XY_FLIP | MASK_X_INVERT; |
| 190 | break; |
| 191 | case BIT(DRM_ROTATE_180): |
| 192 | orient = MASK_X_INVERT | MASK_Y_INVERT; |
| 193 | break; |
| 194 | case BIT(DRM_ROTATE_270): |
| 195 | orient = MASK_XY_FLIP | MASK_Y_INVERT; |
| 196 | break; |
| 197 | } |
| 198 | |
| 199 | if (win->rotation & BIT(DRM_REFLECT_X)) |
| 200 | orient ^= MASK_X_INVERT; |
| 201 | |
| 202 | if (win->rotation & BIT(DRM_REFLECT_Y)) |
| 203 | orient ^= MASK_Y_INVERT; |
| 204 | |
| 205 | /* adjust x,y offset for flip/invert: */ |
| 206 | if (orient & MASK_XY_FLIP) |
| 207 | swap(w, h); |
| 208 | if (orient & MASK_Y_INVERT) |
| 209 | y += h - 1; |
| 210 | if (orient & MASK_X_INVERT) |
| 211 | x += w - 1; |
| 212 | |
| 213 | omap_gem_rotated_paddr(plane->bo, orient, x, y, &info->paddr); |
| 214 | info->rotation_type = OMAP_DSS_ROT_TILER; |
| 215 | info->screen_width = omap_gem_tiled_stride(plane->bo, orient); |
| 216 | } else { |
| 217 | info->paddr = get_linear_addr(plane, format, 0, x, y); |
| 218 | info->rotation_type = OMAP_DSS_ROT_DMA; |
| 219 | info->screen_width = plane->pitch; |
| 220 | } |
| 221 | |
| 222 | /* convert to pixels: */ |
| 223 | info->screen_width /= format->planes[0].stride_bpp; |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 224 | |
| 225 | if (format->dss_format == OMAP_DSS_COLOR_NV12) { |
| 226 | plane = &omap_fb->planes[1]; |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 227 | |
| 228 | if (info->rotation_type == OMAP_DSS_ROT_TILER) { |
| 229 | WARN_ON(!(omap_gem_flags(plane->bo) & OMAP_BO_TILED)); |
| 230 | omap_gem_rotated_paddr(plane->bo, orient, |
| 231 | x/2, y/2, &info->p_uv_addr); |
| 232 | } else { |
| 233 | info->p_uv_addr = get_linear_addr(plane, format, 1, x, y); |
| 234 | } |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 235 | } else { |
| 236 | info->p_uv_addr = 0; |
| 237 | } |
| 238 | } |
| 239 | |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 240 | /* Call for unpin 'a' (if not NULL), and pin 'b' (if not NULL). Although |
Justin P. Mattock | 6354eb8 | 2012-04-02 07:25:19 -0700 | [diff] [blame] | 241 | * buffers to unpin are just pushed to the unpin fifo so that the |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 242 | * caller can defer unpin until vblank. |
| 243 | * |
| 244 | * Note if this fails (ie. something went very wrong!), all buffers are |
| 245 | * unpinned, and the caller disables the overlay. We could have tried |
| 246 | * to revert back to the previous set of pinned buffers but if things are |
| 247 | * hosed there is no guarantee that would succeed. |
| 248 | */ |
| 249 | int omap_framebuffer_replace(struct drm_framebuffer *a, |
| 250 | struct drm_framebuffer *b, void *arg, |
| 251 | void (*unpin)(void *arg, struct drm_gem_object *bo)) |
| 252 | { |
| 253 | int ret = 0, i, na, nb; |
| 254 | struct omap_framebuffer *ofba = to_omap_framebuffer(a); |
| 255 | struct omap_framebuffer *ofbb = to_omap_framebuffer(b); |
Rob Clark | b74af83 | 2012-10-12 18:58:02 -0500 | [diff] [blame] | 256 | uint32_t pinned_mask = 0; |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 257 | |
| 258 | na = a ? drm_format_num_planes(a->pixel_format) : 0; |
| 259 | nb = b ? drm_format_num_planes(b->pixel_format) : 0; |
| 260 | |
| 261 | for (i = 0; i < max(na, nb); i++) { |
| 262 | struct plane *pa, *pb; |
| 263 | |
| 264 | pa = (i < na) ? &ofba->planes[i] : NULL; |
| 265 | pb = (i < nb) ? &ofbb->planes[i] : NULL; |
| 266 | |
Rob Clark | b74af83 | 2012-10-12 18:58:02 -0500 | [diff] [blame] | 267 | if (pa) |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 268 | unpin(arg, pa->bo); |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 269 | |
Rob Clark | 8b6b569 | 2012-05-17 02:37:25 -0600 | [diff] [blame] | 270 | if (pb && !ret) { |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 271 | ret = omap_gem_get_paddr(pb->bo, &pb->paddr, true); |
Rob Clark | b74af83 | 2012-10-12 18:58:02 -0500 | [diff] [blame] | 272 | if (!ret) { |
Rob Clark | 8b6b569 | 2012-05-17 02:37:25 -0600 | [diff] [blame] | 273 | omap_gem_dma_sync(pb->bo, DMA_TO_DEVICE); |
Rob Clark | b74af83 | 2012-10-12 18:58:02 -0500 | [diff] [blame] | 274 | pinned_mask |= (1 << i); |
| 275 | } |
Rob Clark | 8b6b569 | 2012-05-17 02:37:25 -0600 | [diff] [blame] | 276 | } |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 277 | } |
| 278 | |
| 279 | if (ret) { |
| 280 | /* something went wrong.. unpin what has been pinned */ |
| 281 | for (i = 0; i < nb; i++) { |
Rob Clark | b74af83 | 2012-10-12 18:58:02 -0500 | [diff] [blame] | 282 | if (pinned_mask & (1 << i)) { |
| 283 | struct plane *pb = &ofba->planes[i]; |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 284 | unpin(arg, pb->bo); |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 285 | } |
| 286 | } |
| 287 | } |
| 288 | |
| 289 | return ret; |
| 290 | } |
| 291 | |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 292 | struct drm_gem_object *omap_framebuffer_bo(struct drm_framebuffer *fb, int p) |
| 293 | { |
| 294 | struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb); |
Rob Clark | 9f18c95 | 2012-03-05 10:48:34 -0600 | [diff] [blame] | 295 | if (p >= drm_format_num_planes(fb->pixel_format)) |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 296 | return NULL; |
| 297 | return omap_fb->planes[p].bo; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 298 | } |
| 299 | |
| 300 | /* iterate thru all the connectors, returning ones that are attached |
| 301 | * to the same fb.. |
| 302 | */ |
| 303 | struct drm_connector *omap_framebuffer_get_next_connector( |
| 304 | struct drm_framebuffer *fb, struct drm_connector *from) |
| 305 | { |
| 306 | struct drm_device *dev = fb->dev; |
| 307 | struct list_head *connector_list = &dev->mode_config.connector_list; |
| 308 | struct drm_connector *connector = from; |
| 309 | |
YAMANE Toshiaki | ddcd49e | 2012-11-14 19:32:17 +0900 | [diff] [blame] | 310 | if (!from) |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 311 | return list_first_entry(connector_list, typeof(*from), head); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 312 | |
| 313 | list_for_each_entry_from(connector, connector_list, head) { |
| 314 | if (connector != from) { |
| 315 | struct drm_encoder *encoder = connector->encoder; |
| 316 | struct drm_crtc *crtc = encoder ? encoder->crtc : NULL; |
YAMANE Toshiaki | ddcd49e | 2012-11-14 19:32:17 +0900 | [diff] [blame] | 317 | if (crtc && crtc->fb == fb) |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 318 | return connector; |
YAMANE Toshiaki | ddcd49e | 2012-11-14 19:32:17 +0900 | [diff] [blame] | 319 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 320 | } |
| 321 | } |
| 322 | |
| 323 | return NULL; |
| 324 | } |
| 325 | |
| 326 | /* flush an area of the framebuffer (in case of manual update display that |
| 327 | * is not automatically flushed) |
| 328 | */ |
| 329 | void omap_framebuffer_flush(struct drm_framebuffer *fb, |
| 330 | int x, int y, int w, int h) |
| 331 | { |
| 332 | struct drm_connector *connector = NULL; |
| 333 | |
| 334 | VERB("flush: %d,%d %dx%d, fb=%p", x, y, w, h, fb); |
| 335 | |
| 336 | while ((connector = omap_framebuffer_get_next_connector(fb, connector))) { |
| 337 | /* only consider connectors that are part of a chain */ |
| 338 | if (connector->encoder && connector->encoder->crtc) { |
| 339 | /* TODO: maybe this should propagate thru the crtc who |
| 340 | * could do the coordinate translation.. |
| 341 | */ |
| 342 | struct drm_crtc *crtc = connector->encoder->crtc; |
| 343 | int cx = max(0, x - crtc->x); |
| 344 | int cy = max(0, y - crtc->y); |
| 345 | int cw = w + (x - crtc->x) - cx; |
| 346 | int ch = h + (y - crtc->y) - cy; |
| 347 | |
| 348 | omap_connector_flush(connector, cx, cy, cw, ch); |
| 349 | } |
| 350 | } |
| 351 | } |
| 352 | |
Rob Clark | f6b6036 | 2012-03-05 10:48:36 -0600 | [diff] [blame] | 353 | #ifdef CONFIG_DEBUG_FS |
| 354 | void omap_framebuffer_describe(struct drm_framebuffer *fb, struct seq_file *m) |
| 355 | { |
| 356 | struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb); |
| 357 | int i, n = drm_format_num_planes(fb->pixel_format); |
| 358 | |
| 359 | seq_printf(m, "fb: %dx%d@%4.4s\n", fb->width, fb->height, |
| 360 | (char *)&fb->pixel_format); |
| 361 | |
| 362 | for (i = 0; i < n; i++) { |
| 363 | struct plane *plane = &omap_fb->planes[i]; |
| 364 | seq_printf(m, " %d: offset=%d pitch=%d, obj: ", |
| 365 | i, plane->offset, plane->pitch); |
| 366 | omap_gem_describe(plane->bo, m); |
| 367 | } |
| 368 | } |
| 369 | #endif |
| 370 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 371 | struct drm_framebuffer *omap_framebuffer_create(struct drm_device *dev, |
Rob Clark | ae43d7c | 2012-01-16 12:51:15 -0600 | [diff] [blame] | 372 | struct drm_file *file, struct drm_mode_fb_cmd2 *mode_cmd) |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 373 | { |
Rob Clark | ae43d7c | 2012-01-16 12:51:15 -0600 | [diff] [blame] | 374 | struct drm_gem_object *bos[4]; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 375 | struct drm_framebuffer *fb; |
Rob Clark | ae43d7c | 2012-01-16 12:51:15 -0600 | [diff] [blame] | 376 | int ret; |
| 377 | |
| 378 | ret = objects_lookup(dev, file, mode_cmd->pixel_format, |
| 379 | bos, mode_cmd->handles); |
| 380 | if (ret) |
| 381 | return ERR_PTR(ret); |
| 382 | |
| 383 | fb = omap_framebuffer_init(dev, mode_cmd, bos); |
| 384 | if (IS_ERR(fb)) { |
| 385 | int i, n = drm_format_num_planes(mode_cmd->pixel_format); |
| 386 | for (i = 0; i < n; i++) |
| 387 | drm_gem_object_unreference_unlocked(bos[i]); |
| 388 | return fb; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 389 | } |
| 390 | return fb; |
| 391 | } |
| 392 | |
| 393 | struct drm_framebuffer *omap_framebuffer_init(struct drm_device *dev, |
Rob Clark | ae43d7c | 2012-01-16 12:51:15 -0600 | [diff] [blame] | 394 | struct drm_mode_fb_cmd2 *mode_cmd, struct drm_gem_object **bos) |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 395 | { |
| 396 | struct omap_framebuffer *omap_fb; |
| 397 | struct drm_framebuffer *fb = NULL; |
Rob Clark | ae43d7c | 2012-01-16 12:51:15 -0600 | [diff] [blame] | 398 | const struct format *format = NULL; |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 399 | int ret, i, n = drm_format_num_planes(mode_cmd->pixel_format); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 400 | |
Rob Clark | ae43d7c | 2012-01-16 12:51:15 -0600 | [diff] [blame] | 401 | DBG("create framebuffer: dev=%p, mode_cmd=%p (%dx%d@%4.4s)", |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 402 | dev, mode_cmd, mode_cmd->width, mode_cmd->height, |
Rob Clark | ae43d7c | 2012-01-16 12:51:15 -0600 | [diff] [blame] | 403 | (char *)&mode_cmd->pixel_format); |
| 404 | |
| 405 | for (i = 0; i < ARRAY_SIZE(formats); i++) { |
| 406 | if (formats[i].pixel_format == mode_cmd->pixel_format) { |
| 407 | format = &formats[i]; |
| 408 | break; |
| 409 | } |
| 410 | } |
| 411 | |
| 412 | if (!format) { |
| 413 | dev_err(dev->dev, "unsupported pixel format: %4.4s\n", |
| 414 | (char *)&mode_cmd->pixel_format); |
| 415 | ret = -EINVAL; |
| 416 | goto fail; |
| 417 | } |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 418 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 419 | omap_fb = kzalloc(sizeof(*omap_fb), GFP_KERNEL); |
| 420 | if (!omap_fb) { |
Rob Clark | ae43d7c | 2012-01-16 12:51:15 -0600 | [diff] [blame] | 421 | ret = -ENOMEM; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 422 | goto fail; |
| 423 | } |
| 424 | |
| 425 | fb = &omap_fb->base; |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 426 | omap_fb->format = format; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 427 | |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 428 | for (i = 0; i < n; i++) { |
| 429 | struct plane *plane = &omap_fb->planes[i]; |
| 430 | int size, pitch = mode_cmd->pitches[i]; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 431 | |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 432 | if (pitch < (mode_cmd->width * format->planes[i].stride_bpp)) { |
| 433 | dev_err(dev->dev, "provided buffer pitch is too small! %d < %d\n", |
| 434 | pitch, mode_cmd->width * format->planes[i].stride_bpp); |
| 435 | ret = -EINVAL; |
| 436 | goto fail; |
| 437 | } |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 438 | |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 439 | size = pitch * mode_cmd->height / format->planes[i].sub_y; |
| 440 | |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 441 | if (size > (omap_gem_mmap_size(bos[i]) - mode_cmd->offsets[i])) { |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 442 | dev_err(dev->dev, "provided buffer object is too small! %d < %d\n", |
| 443 | bos[i]->size - mode_cmd->offsets[i], size); |
| 444 | ret = -EINVAL; |
| 445 | goto fail; |
| 446 | } |
| 447 | |
| 448 | plane->bo = bos[i]; |
| 449 | plane->offset = mode_cmd->offsets[i]; |
Rob Clark | 9f18c95 | 2012-03-05 10:48:34 -0600 | [diff] [blame] | 450 | plane->pitch = pitch; |
| 451 | plane->paddr = 0; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 452 | } |
| 453 | |
| 454 | drm_helper_mode_fill_fb_struct(fb, mode_cmd); |
| 455 | |
Daniel Vetter | c7d73f6 | 2012-12-13 23:38:38 +0100 | [diff] [blame] | 456 | ret = drm_framebuffer_init(dev, fb, &omap_framebuffer_funcs); |
| 457 | if (ret) { |
| 458 | dev_err(dev->dev, "framebuffer init failed: %d\n", ret); |
| 459 | goto fail; |
| 460 | } |
| 461 | |
| 462 | DBG("create: FB ID: %d (%p)", fb->base.id, fb); |
| 463 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 464 | return fb; |
| 465 | |
| 466 | fail: |
YAMANE Toshiaki | ddcd49e | 2012-11-14 19:32:17 +0900 | [diff] [blame] | 467 | if (fb) |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 468 | omap_framebuffer_destroy(fb); |
YAMANE Toshiaki | ddcd49e | 2012-11-14 19:32:17 +0900 | [diff] [blame] | 469 | |
Rob Clark | ae43d7c | 2012-01-16 12:51:15 -0600 | [diff] [blame] | 470 | return ERR_PTR(ret); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 471 | } |