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 | |
Laurent Pinchart | 2d278f5 | 2015-03-05 21:31:37 +0200 | [diff] [blame] | 20 | #include <drm/drm_crtc.h> |
| 21 | #include <drm/drm_crtc_helper.h> |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 22 | |
Laurent Pinchart | 2d278f5 | 2015-03-05 21:31:37 +0200 | [diff] [blame] | 23 | #include "omap_dmm_tiler.h" |
| 24 | #include "omap_drv.h" |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 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; |
Tomi Valkeinen | f36eb5a | 2014-09-03 19:25:54 +0000 | [diff] [blame] | 89 | int pin_count; |
Rob Clark | ae43d7c | 2012-01-16 12:51:15 -0600 | [diff] [blame] | 90 | const struct format *format; |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 91 | struct plane planes[4]; |
Tomi Valkeinen | f524ab7 | 2015-06-04 10:56:33 +0300 | [diff] [blame] | 92 | /* lock for pinning (pin_count and planes.paddr) */ |
| 93 | struct mutex lock; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 94 | }; |
| 95 | |
| 96 | static int omap_framebuffer_create_handle(struct drm_framebuffer *fb, |
| 97 | struct drm_file *file_priv, |
| 98 | unsigned int *handle) |
| 99 | { |
| 100 | struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb); |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 101 | return drm_gem_handle_create(file_priv, |
| 102 | omap_fb->planes[0].bo, handle); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 103 | } |
| 104 | |
| 105 | static void omap_framebuffer_destroy(struct drm_framebuffer *fb) |
| 106 | { |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 107 | struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb); |
Rob Clark | 9f18c95 | 2012-03-05 10:48:34 -0600 | [diff] [blame] | 108 | int i, n = drm_format_num_planes(fb->pixel_format); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 109 | |
| 110 | DBG("destroy: FB ID: %d (%p)", fb->base.id, fb); |
| 111 | |
| 112 | drm_framebuffer_cleanup(fb); |
| 113 | |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 114 | for (i = 0; i < n; i++) { |
| 115 | struct plane *plane = &omap_fb->planes[i]; |
| 116 | if (plane->bo) |
| 117 | drm_gem_object_unreference_unlocked(plane->bo); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 118 | } |
| 119 | |
| 120 | kfree(omap_fb); |
| 121 | } |
| 122 | |
| 123 | static int omap_framebuffer_dirty(struct drm_framebuffer *fb, |
| 124 | struct drm_file *file_priv, unsigned flags, unsigned color, |
| 125 | struct drm_clip_rect *clips, unsigned num_clips) |
| 126 | { |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 127 | return 0; |
| 128 | } |
| 129 | |
| 130 | static const struct drm_framebuffer_funcs omap_framebuffer_funcs = { |
| 131 | .create_handle = omap_framebuffer_create_handle, |
| 132 | .destroy = omap_framebuffer_destroy, |
| 133 | .dirty = omap_framebuffer_dirty, |
| 134 | }; |
| 135 | |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 136 | static uint32_t get_linear_addr(struct plane *plane, |
| 137 | const struct format *format, int n, int x, int y) |
| 138 | { |
| 139 | uint32_t offset; |
| 140 | |
| 141 | offset = plane->offset + |
| 142 | (x * format->planes[n].stride_bpp) + |
| 143 | (y * plane->pitch / format->planes[n].sub_y); |
| 144 | |
| 145 | return plane->paddr + offset; |
| 146 | } |
| 147 | |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 148 | /* update ovl info for scanout, handles cases of multi-planar fb's, etc. |
| 149 | */ |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 150 | void omap_framebuffer_update_scanout(struct drm_framebuffer *fb, |
| 151 | struct omap_drm_window *win, struct omap_overlay_info *info) |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 152 | { |
| 153 | struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb); |
| 154 | const struct format *format = omap_fb->format; |
| 155 | struct plane *plane = &omap_fb->planes[0]; |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 156 | uint32_t x, y, orient = 0; |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 157 | |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 158 | info->color_mode = format->dss_format; |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 159 | |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 160 | info->pos_x = win->crtc_x; |
| 161 | info->pos_y = win->crtc_y; |
| 162 | info->out_width = win->crtc_w; |
| 163 | info->out_height = win->crtc_h; |
| 164 | info->width = win->src_w; |
| 165 | info->height = win->src_h; |
| 166 | |
| 167 | x = win->src_x; |
| 168 | y = win->src_y; |
| 169 | |
| 170 | if (omap_gem_flags(plane->bo) & OMAP_BO_TILED) { |
| 171 | uint32_t w = win->src_w; |
| 172 | uint32_t h = win->src_h; |
| 173 | |
| 174 | switch (win->rotation & 0xf) { |
| 175 | default: |
| 176 | dev_err(fb->dev->dev, "invalid rotation: %02x", |
| 177 | (uint32_t)win->rotation); |
| 178 | /* fallthru to default to no rotation */ |
| 179 | case 0: |
| 180 | case BIT(DRM_ROTATE_0): |
| 181 | orient = 0; |
| 182 | break; |
| 183 | case BIT(DRM_ROTATE_90): |
| 184 | orient = MASK_XY_FLIP | MASK_X_INVERT; |
| 185 | break; |
| 186 | case BIT(DRM_ROTATE_180): |
| 187 | orient = MASK_X_INVERT | MASK_Y_INVERT; |
| 188 | break; |
| 189 | case BIT(DRM_ROTATE_270): |
| 190 | orient = MASK_XY_FLIP | MASK_Y_INVERT; |
| 191 | break; |
| 192 | } |
| 193 | |
| 194 | if (win->rotation & BIT(DRM_REFLECT_X)) |
| 195 | orient ^= MASK_X_INVERT; |
| 196 | |
| 197 | if (win->rotation & BIT(DRM_REFLECT_Y)) |
| 198 | orient ^= MASK_Y_INVERT; |
| 199 | |
| 200 | /* adjust x,y offset for flip/invert: */ |
| 201 | if (orient & MASK_XY_FLIP) |
| 202 | swap(w, h); |
| 203 | if (orient & MASK_Y_INVERT) |
| 204 | y += h - 1; |
| 205 | if (orient & MASK_X_INVERT) |
| 206 | x += w - 1; |
| 207 | |
| 208 | omap_gem_rotated_paddr(plane->bo, orient, x, y, &info->paddr); |
| 209 | info->rotation_type = OMAP_DSS_ROT_TILER; |
| 210 | info->screen_width = omap_gem_tiled_stride(plane->bo, orient); |
| 211 | } else { |
Tomi Valkeinen | 5ac9634 | 2014-04-08 16:18:41 +0300 | [diff] [blame] | 212 | switch (win->rotation & 0xf) { |
| 213 | case 0: |
| 214 | case BIT(DRM_ROTATE_0): |
| 215 | /* OK */ |
| 216 | break; |
| 217 | |
| 218 | default: |
| 219 | dev_warn(fb->dev->dev, |
| 220 | "rotation '%d' ignored for non-tiled fb\n", |
| 221 | win->rotation); |
| 222 | win->rotation = 0; |
| 223 | break; |
| 224 | } |
| 225 | |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 226 | info->paddr = get_linear_addr(plane, format, 0, x, y); |
| 227 | info->rotation_type = OMAP_DSS_ROT_DMA; |
| 228 | info->screen_width = plane->pitch; |
| 229 | } |
| 230 | |
| 231 | /* convert to pixels: */ |
| 232 | info->screen_width /= format->planes[0].stride_bpp; |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 233 | |
| 234 | if (format->dss_format == OMAP_DSS_COLOR_NV12) { |
| 235 | plane = &omap_fb->planes[1]; |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 236 | |
| 237 | if (info->rotation_type == OMAP_DSS_ROT_TILER) { |
| 238 | WARN_ON(!(omap_gem_flags(plane->bo) & OMAP_BO_TILED)); |
| 239 | omap_gem_rotated_paddr(plane->bo, orient, |
| 240 | x/2, y/2, &info->p_uv_addr); |
| 241 | } else { |
| 242 | info->p_uv_addr = get_linear_addr(plane, format, 1, x, y); |
| 243 | } |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 244 | } else { |
| 245 | info->p_uv_addr = 0; |
| 246 | } |
| 247 | } |
| 248 | |
Rob Clark | 5833bd2 | 2013-08-07 13:41:21 -0400 | [diff] [blame] | 249 | /* pin, prepare for scanout: */ |
| 250 | int omap_framebuffer_pin(struct drm_framebuffer *fb) |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 251 | { |
Rob Clark | 5833bd2 | 2013-08-07 13:41:21 -0400 | [diff] [blame] | 252 | struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb); |
| 253 | int ret, i, n = drm_format_num_planes(fb->pixel_format); |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 254 | |
Tomi Valkeinen | f524ab7 | 2015-06-04 10:56:33 +0300 | [diff] [blame] | 255 | mutex_lock(&omap_fb->lock); |
| 256 | |
Tomi Valkeinen | f36eb5a | 2014-09-03 19:25:54 +0000 | [diff] [blame] | 257 | if (omap_fb->pin_count > 0) { |
| 258 | omap_fb->pin_count++; |
Tomi Valkeinen | f524ab7 | 2015-06-04 10:56:33 +0300 | [diff] [blame] | 259 | mutex_unlock(&omap_fb->lock); |
Tomi Valkeinen | f36eb5a | 2014-09-03 19:25:54 +0000 | [diff] [blame] | 260 | return 0; |
| 261 | } |
| 262 | |
Rob Clark | 5833bd2 | 2013-08-07 13:41:21 -0400 | [diff] [blame] | 263 | for (i = 0; i < n; i++) { |
| 264 | struct plane *plane = &omap_fb->planes[i]; |
| 265 | ret = omap_gem_get_paddr(plane->bo, &plane->paddr, true); |
| 266 | if (ret) |
| 267 | goto fail; |
| 268 | omap_gem_dma_sync(plane->bo, DMA_TO_DEVICE); |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 269 | } |
| 270 | |
Tomi Valkeinen | f36eb5a | 2014-09-03 19:25:54 +0000 | [diff] [blame] | 271 | omap_fb->pin_count++; |
| 272 | |
Tomi Valkeinen | f524ab7 | 2015-06-04 10:56:33 +0300 | [diff] [blame] | 273 | mutex_unlock(&omap_fb->lock); |
| 274 | |
Rob Clark | 5833bd2 | 2013-08-07 13:41:21 -0400 | [diff] [blame] | 275 | return 0; |
| 276 | |
| 277 | fail: |
| 278 | for (i--; i >= 0; i--) { |
| 279 | struct plane *plane = &omap_fb->planes[i]; |
| 280 | omap_gem_put_paddr(plane->bo); |
| 281 | plane->paddr = 0; |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 282 | } |
| 283 | |
Tomi Valkeinen | f524ab7 | 2015-06-04 10:56:33 +0300 | [diff] [blame] | 284 | mutex_unlock(&omap_fb->lock); |
| 285 | |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 286 | return ret; |
| 287 | } |
| 288 | |
Rob Clark | 5833bd2 | 2013-08-07 13:41:21 -0400 | [diff] [blame] | 289 | /* unpin, no longer being scanned out: */ |
| 290 | int omap_framebuffer_unpin(struct drm_framebuffer *fb) |
| 291 | { |
| 292 | struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb); |
| 293 | int ret, i, n = drm_format_num_planes(fb->pixel_format); |
| 294 | |
Tomi Valkeinen | f524ab7 | 2015-06-04 10:56:33 +0300 | [diff] [blame] | 295 | mutex_lock(&omap_fb->lock); |
| 296 | |
Tomi Valkeinen | f36eb5a | 2014-09-03 19:25:54 +0000 | [diff] [blame] | 297 | omap_fb->pin_count--; |
| 298 | |
Tomi Valkeinen | f524ab7 | 2015-06-04 10:56:33 +0300 | [diff] [blame] | 299 | if (omap_fb->pin_count > 0) { |
| 300 | mutex_unlock(&omap_fb->lock); |
Tomi Valkeinen | f36eb5a | 2014-09-03 19:25:54 +0000 | [diff] [blame] | 301 | return 0; |
Tomi Valkeinen | f524ab7 | 2015-06-04 10:56:33 +0300 | [diff] [blame] | 302 | } |
Tomi Valkeinen | f36eb5a | 2014-09-03 19:25:54 +0000 | [diff] [blame] | 303 | |
Rob Clark | 5833bd2 | 2013-08-07 13:41:21 -0400 | [diff] [blame] | 304 | for (i = 0; i < n; i++) { |
| 305 | struct plane *plane = &omap_fb->planes[i]; |
| 306 | ret = omap_gem_put_paddr(plane->bo); |
| 307 | if (ret) |
| 308 | goto fail; |
| 309 | plane->paddr = 0; |
| 310 | } |
| 311 | |
Tomi Valkeinen | f524ab7 | 2015-06-04 10:56:33 +0300 | [diff] [blame] | 312 | mutex_unlock(&omap_fb->lock); |
| 313 | |
Rob Clark | 5833bd2 | 2013-08-07 13:41:21 -0400 | [diff] [blame] | 314 | return 0; |
| 315 | |
| 316 | fail: |
Tomi Valkeinen | f524ab7 | 2015-06-04 10:56:33 +0300 | [diff] [blame] | 317 | mutex_unlock(&omap_fb->lock); |
Rob Clark | 5833bd2 | 2013-08-07 13:41:21 -0400 | [diff] [blame] | 318 | return ret; |
| 319 | } |
| 320 | |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 321 | struct drm_gem_object *omap_framebuffer_bo(struct drm_framebuffer *fb, int p) |
| 322 | { |
| 323 | struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb); |
Rob Clark | 9f18c95 | 2012-03-05 10:48:34 -0600 | [diff] [blame] | 324 | if (p >= drm_format_num_planes(fb->pixel_format)) |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 325 | return NULL; |
| 326 | return omap_fb->planes[p].bo; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 327 | } |
| 328 | |
| 329 | /* iterate thru all the connectors, returning ones that are attached |
| 330 | * to the same fb.. |
| 331 | */ |
| 332 | struct drm_connector *omap_framebuffer_get_next_connector( |
| 333 | struct drm_framebuffer *fb, struct drm_connector *from) |
| 334 | { |
| 335 | struct drm_device *dev = fb->dev; |
| 336 | struct list_head *connector_list = &dev->mode_config.connector_list; |
| 337 | struct drm_connector *connector = from; |
| 338 | |
YAMANE Toshiaki | ddcd49e | 2012-11-14 19:32:17 +0900 | [diff] [blame] | 339 | if (!from) |
Laurent Pinchart | 06fb220 | 2013-12-24 12:58:01 +0100 | [diff] [blame] | 340 | return list_first_entry_or_null(connector_list, typeof(*from), |
| 341 | head); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 342 | |
| 343 | list_for_each_entry_from(connector, connector_list, head) { |
| 344 | if (connector != from) { |
| 345 | struct drm_encoder *encoder = connector->encoder; |
| 346 | struct drm_crtc *crtc = encoder ? encoder->crtc : NULL; |
Matt Roper | f4510a2 | 2014-04-01 15:22:40 -0700 | [diff] [blame] | 347 | if (crtc && crtc->primary->fb == fb) |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 348 | return connector; |
YAMANE Toshiaki | ddcd49e | 2012-11-14 19:32:17 +0900 | [diff] [blame] | 349 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 350 | } |
| 351 | } |
| 352 | |
| 353 | return NULL; |
| 354 | } |
| 355 | |
Rob Clark | f6b6036 | 2012-03-05 10:48:36 -0600 | [diff] [blame] | 356 | #ifdef CONFIG_DEBUG_FS |
| 357 | void omap_framebuffer_describe(struct drm_framebuffer *fb, struct seq_file *m) |
| 358 | { |
| 359 | struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb); |
| 360 | int i, n = drm_format_num_planes(fb->pixel_format); |
| 361 | |
| 362 | seq_printf(m, "fb: %dx%d@%4.4s\n", fb->width, fb->height, |
| 363 | (char *)&fb->pixel_format); |
| 364 | |
| 365 | for (i = 0; i < n; i++) { |
| 366 | struct plane *plane = &omap_fb->planes[i]; |
| 367 | seq_printf(m, " %d: offset=%d pitch=%d, obj: ", |
| 368 | i, plane->offset, plane->pitch); |
| 369 | omap_gem_describe(plane->bo, m); |
| 370 | } |
| 371 | } |
| 372 | #endif |
| 373 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 374 | struct drm_framebuffer *omap_framebuffer_create(struct drm_device *dev, |
Rob Clark | ae43d7c | 2012-01-16 12:51:15 -0600 | [diff] [blame] | 375 | struct drm_file *file, struct drm_mode_fb_cmd2 *mode_cmd) |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 376 | { |
Rob Clark | ae43d7c | 2012-01-16 12:51:15 -0600 | [diff] [blame] | 377 | struct drm_gem_object *bos[4]; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 378 | struct drm_framebuffer *fb; |
Rob Clark | ae43d7c | 2012-01-16 12:51:15 -0600 | [diff] [blame] | 379 | int ret; |
| 380 | |
| 381 | ret = objects_lookup(dev, file, mode_cmd->pixel_format, |
| 382 | bos, mode_cmd->handles); |
| 383 | if (ret) |
| 384 | return ERR_PTR(ret); |
| 385 | |
| 386 | fb = omap_framebuffer_init(dev, mode_cmd, bos); |
| 387 | if (IS_ERR(fb)) { |
| 388 | int i, n = drm_format_num_planes(mode_cmd->pixel_format); |
| 389 | for (i = 0; i < n; i++) |
| 390 | drm_gem_object_unreference_unlocked(bos[i]); |
| 391 | return fb; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 392 | } |
| 393 | return fb; |
| 394 | } |
| 395 | |
| 396 | struct drm_framebuffer *omap_framebuffer_init(struct drm_device *dev, |
Rob Clark | ae43d7c | 2012-01-16 12:51:15 -0600 | [diff] [blame] | 397 | struct drm_mode_fb_cmd2 *mode_cmd, struct drm_gem_object **bos) |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 398 | { |
Tomi Valkeinen | 925e494 | 2014-09-25 19:24:27 +0000 | [diff] [blame] | 399 | struct omap_framebuffer *omap_fb = NULL; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 400 | struct drm_framebuffer *fb = NULL; |
Rob Clark | ae43d7c | 2012-01-16 12:51:15 -0600 | [diff] [blame] | 401 | const struct format *format = NULL; |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 402 | int ret, i, n = drm_format_num_planes(mode_cmd->pixel_format); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 403 | |
Rob Clark | ae43d7c | 2012-01-16 12:51:15 -0600 | [diff] [blame] | 404 | DBG("create framebuffer: dev=%p, mode_cmd=%p (%dx%d@%4.4s)", |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 405 | dev, mode_cmd, mode_cmd->width, mode_cmd->height, |
Rob Clark | ae43d7c | 2012-01-16 12:51:15 -0600 | [diff] [blame] | 406 | (char *)&mode_cmd->pixel_format); |
| 407 | |
| 408 | for (i = 0; i < ARRAY_SIZE(formats); i++) { |
| 409 | if (formats[i].pixel_format == mode_cmd->pixel_format) { |
| 410 | format = &formats[i]; |
| 411 | break; |
| 412 | } |
| 413 | } |
| 414 | |
| 415 | if (!format) { |
| 416 | dev_err(dev->dev, "unsupported pixel format: %4.4s\n", |
| 417 | (char *)&mode_cmd->pixel_format); |
| 418 | ret = -EINVAL; |
| 419 | goto fail; |
| 420 | } |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 421 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 422 | omap_fb = kzalloc(sizeof(*omap_fb), GFP_KERNEL); |
| 423 | if (!omap_fb) { |
Rob Clark | ae43d7c | 2012-01-16 12:51:15 -0600 | [diff] [blame] | 424 | ret = -ENOMEM; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 425 | goto fail; |
| 426 | } |
| 427 | |
| 428 | fb = &omap_fb->base; |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 429 | omap_fb->format = format; |
Tomi Valkeinen | f524ab7 | 2015-06-04 10:56:33 +0300 | [diff] [blame] | 430 | mutex_init(&omap_fb->lock); |
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 | for (i = 0; i < n; i++) { |
| 433 | struct plane *plane = &omap_fb->planes[i]; |
| 434 | int size, pitch = mode_cmd->pitches[i]; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 435 | |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 436 | if (pitch < (mode_cmd->width * format->planes[i].stride_bpp)) { |
| 437 | dev_err(dev->dev, "provided buffer pitch is too small! %d < %d\n", |
| 438 | pitch, mode_cmd->width * format->planes[i].stride_bpp); |
| 439 | ret = -EINVAL; |
| 440 | goto fail; |
| 441 | } |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 442 | |
Tomi Valkeinen | 2dab0ba | 2014-09-25 19:24:28 +0000 | [diff] [blame] | 443 | if (pitch % format->planes[i].stride_bpp != 0) { |
| 444 | dev_err(dev->dev, |
| 445 | "buffer pitch (%d bytes) is not a multiple of pixel size (%d bytes)\n", |
| 446 | pitch, format->planes[i].stride_bpp); |
| 447 | ret = -EINVAL; |
| 448 | goto fail; |
| 449 | } |
| 450 | |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 451 | size = pitch * mode_cmd->height / format->planes[i].sub_y; |
| 452 | |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 453 | if (size > (omap_gem_mmap_size(bos[i]) - mode_cmd->offsets[i])) { |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 454 | dev_err(dev->dev, "provided buffer object is too small! %d < %d\n", |
| 455 | bos[i]->size - mode_cmd->offsets[i], size); |
| 456 | ret = -EINVAL; |
| 457 | goto fail; |
| 458 | } |
| 459 | |
| 460 | plane->bo = bos[i]; |
| 461 | plane->offset = mode_cmd->offsets[i]; |
Rob Clark | 9f18c95 | 2012-03-05 10:48:34 -0600 | [diff] [blame] | 462 | plane->pitch = pitch; |
| 463 | plane->paddr = 0; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 464 | } |
| 465 | |
| 466 | drm_helper_mode_fill_fb_struct(fb, mode_cmd); |
| 467 | |
Daniel Vetter | c7d73f6 | 2012-12-13 23:38:38 +0100 | [diff] [blame] | 468 | ret = drm_framebuffer_init(dev, fb, &omap_framebuffer_funcs); |
| 469 | if (ret) { |
| 470 | dev_err(dev->dev, "framebuffer init failed: %d\n", ret); |
| 471 | goto fail; |
| 472 | } |
| 473 | |
| 474 | DBG("create: FB ID: %d (%p)", fb->base.id, fb); |
| 475 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 476 | return fb; |
| 477 | |
| 478 | fail: |
Tomi Valkeinen | 925e494 | 2014-09-25 19:24:27 +0000 | [diff] [blame] | 479 | kfree(omap_fb); |
YAMANE Toshiaki | ddcd49e | 2012-11-14 19:32:17 +0900 | [diff] [blame] | 480 | |
Rob Clark | ae43d7c | 2012-01-16 12:51:15 -0600 | [diff] [blame] | 481 | return ERR_PTR(ret); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 482 | } |