Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 1 | /* |
Rob Clark | 8bb0daf | 2013-02-11 12:43:09 -0500 | [diff] [blame] | 2 | * drivers/gpu/drm/omapdrm/omap_plane.c |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 3 | * |
| 4 | * Copyright (C) 2011 Texas Instruments |
| 5 | * Author: Rob Clark <rob.clark@linaro.org> |
| 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 | |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 20 | #include <linux/kfifo.h> |
| 21 | |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 22 | #include "omap_drv.h" |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 23 | #include "omap_dmm_tiler.h" |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 24 | |
| 25 | /* some hackery because omapdss has an 'enum omap_plane' (which would be |
| 26 | * better named omap_plane_id).. and compiler seems unhappy about having |
| 27 | * both a 'struct omap_plane' and 'enum omap_plane' |
| 28 | */ |
| 29 | #define omap_plane _omap_plane |
| 30 | |
| 31 | /* |
| 32 | * plane funcs |
| 33 | */ |
| 34 | |
Rob Clark | 72d0c33 | 2012-03-11 21:11:21 -0500 | [diff] [blame] | 35 | struct callback { |
| 36 | void (*fxn)(void *); |
| 37 | void *arg; |
| 38 | }; |
| 39 | |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 40 | #define to_omap_plane(x) container_of(x, struct omap_plane, base) |
| 41 | |
| 42 | struct omap_plane { |
| 43 | struct drm_plane base; |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 44 | int id; /* TODO rename omap_plane -> omap_plane_id in omapdss so I can use the enum */ |
| 45 | const char *name; |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 46 | struct omap_overlay_info info; |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 47 | struct omap_drm_apply apply; |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 48 | |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 49 | /* position/orientation of scanout within the fb: */ |
| 50 | struct omap_drm_window win; |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 51 | bool enabled; |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 52 | |
| 53 | /* last fb that we pinned: */ |
| 54 | struct drm_framebuffer *pinned_fb; |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 55 | |
Rob Clark | a890e66 | 2012-03-05 10:48:31 -0600 | [diff] [blame] | 56 | uint32_t nformats; |
| 57 | uint32_t formats[32]; |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 58 | |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 59 | struct omap_drm_irq error_irq; |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 60 | |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 61 | /* set of bo's pending unpin until next post_apply() */ |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 62 | DECLARE_KFIFO_PTR(unpin_fifo, struct drm_gem_object *); |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 63 | |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 64 | // XXX maybe get rid of this and handle vblank in crtc too? |
| 65 | struct callback apply_done_cb; |
Rob Clark | a890e66 | 2012-03-05 10:48:31 -0600 | [diff] [blame] | 66 | }; |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 67 | |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 68 | static void unpin(void *arg, struct drm_gem_object *bo) |
| 69 | { |
| 70 | struct drm_plane *plane = arg; |
| 71 | struct omap_plane *omap_plane = to_omap_plane(plane); |
| 72 | |
| 73 | if (kfifo_put(&omap_plane->unpin_fifo, |
| 74 | (const struct drm_gem_object **)&bo)) { |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 75 | /* also hold a ref so it isn't free'd while pinned */ |
| 76 | drm_gem_object_reference(bo); |
| 77 | } else { |
| 78 | dev_err(plane->dev->dev, "unpin fifo full!\n"); |
| 79 | omap_gem_put_paddr(bo); |
| 80 | } |
| 81 | } |
| 82 | |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 83 | /* update which fb (if any) is pinned for scanout */ |
| 84 | static int update_pin(struct drm_plane *plane, struct drm_framebuffer *fb) |
| 85 | { |
| 86 | struct omap_plane *omap_plane = to_omap_plane(plane); |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 87 | struct drm_framebuffer *pinned_fb = omap_plane->pinned_fb; |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 88 | |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 89 | if (pinned_fb != fb) { |
| 90 | int ret; |
| 91 | |
| 92 | DBG("%p -> %p", pinned_fb, fb); |
| 93 | |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 94 | if (fb) |
| 95 | drm_framebuffer_reference(fb); |
| 96 | |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 97 | ret = omap_framebuffer_replace(pinned_fb, fb, plane, unpin); |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 98 | |
| 99 | if (pinned_fb) |
| 100 | drm_framebuffer_unreference(pinned_fb); |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 101 | |
| 102 | if (ret) { |
| 103 | dev_err(plane->dev->dev, "could not swap %p -> %p\n", |
| 104 | omap_plane->pinned_fb, fb); |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 105 | if (fb) |
| 106 | drm_framebuffer_unreference(fb); |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 107 | omap_plane->pinned_fb = NULL; |
| 108 | return ret; |
| 109 | } |
| 110 | |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 111 | omap_plane->pinned_fb = fb; |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 112 | } |
| 113 | |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 114 | return 0; |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 115 | } |
| 116 | |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 117 | static void omap_plane_pre_apply(struct omap_drm_apply *apply) |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 118 | { |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 119 | struct omap_plane *omap_plane = |
| 120 | container_of(apply, struct omap_plane, apply); |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 121 | struct omap_drm_window *win = &omap_plane->win; |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 122 | struct drm_plane *plane = &omap_plane->base; |
| 123 | struct drm_device *dev = plane->dev; |
| 124 | struct omap_overlay_info *info = &omap_plane->info; |
| 125 | struct drm_crtc *crtc = plane->crtc; |
| 126 | enum omap_channel channel; |
| 127 | bool enabled = omap_plane->enabled && crtc; |
| 128 | bool ilace, replication; |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 129 | int ret; |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 130 | |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 131 | DBG("%s, enabled=%d", omap_plane->name, enabled); |
| 132 | |
| 133 | /* if fb has changed, pin new fb: */ |
| 134 | update_pin(plane, enabled ? plane->fb : NULL); |
| 135 | |
| 136 | if (!enabled) { |
| 137 | dispc_ovl_enable(omap_plane->id, false); |
Rob Clark | 2f53700 | 2012-01-16 12:51:18 -0600 | [diff] [blame] | 138 | return; |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 139 | } |
| 140 | |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 141 | channel = omap_crtc_channel(crtc); |
| 142 | |
| 143 | /* update scanout: */ |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 144 | omap_framebuffer_update_scanout(plane->fb, win, info); |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 145 | |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 146 | DBG("%dx%d -> %dx%d (%d)", info->width, info->height, |
| 147 | info->out_width, info->out_height, |
Rob Clark | 9a0774e | 2012-01-16 12:51:17 -0600 | [diff] [blame] | 148 | info->screen_width); |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 149 | DBG("%d,%d %08x %08x", info->pos_x, info->pos_y, |
| 150 | info->paddr, info->p_uv_addr); |
| 151 | |
| 152 | /* TODO: */ |
| 153 | ilace = false; |
| 154 | replication = false; |
| 155 | |
| 156 | /* and finally, update omapdss: */ |
| 157 | ret = dispc_ovl_setup(omap_plane->id, info, |
| 158 | replication, omap_crtc_timings(crtc), false); |
| 159 | if (ret) { |
| 160 | dev_err(dev->dev, "dispc_ovl_setup failed: %d\n", ret); |
| 161 | return; |
| 162 | } |
| 163 | |
| 164 | dispc_ovl_enable(omap_plane->id, true); |
| 165 | dispc_ovl_set_channel_out(omap_plane->id, channel); |
| 166 | } |
| 167 | |
| 168 | static void omap_plane_post_apply(struct omap_drm_apply *apply) |
| 169 | { |
| 170 | struct omap_plane *omap_plane = |
| 171 | container_of(apply, struct omap_plane, apply); |
| 172 | struct drm_plane *plane = &omap_plane->base; |
| 173 | struct omap_overlay_info *info = &omap_plane->info; |
| 174 | struct drm_gem_object *bo = NULL; |
| 175 | struct callback cb; |
| 176 | |
| 177 | cb = omap_plane->apply_done_cb; |
| 178 | omap_plane->apply_done_cb.fxn = NULL; |
| 179 | |
| 180 | while (kfifo_get(&omap_plane->unpin_fifo, &bo)) { |
| 181 | omap_gem_put_paddr(bo); |
| 182 | drm_gem_object_unreference_unlocked(bo); |
| 183 | } |
| 184 | |
| 185 | if (cb.fxn) |
| 186 | cb.fxn(cb.arg); |
| 187 | |
| 188 | if (omap_plane->enabled) { |
| 189 | omap_framebuffer_flush(plane->fb, info->pos_x, info->pos_y, |
| 190 | info->out_width, info->out_height); |
| 191 | } |
| 192 | } |
| 193 | |
| 194 | static int apply(struct drm_plane *plane) |
| 195 | { |
| 196 | if (plane->crtc) { |
| 197 | struct omap_plane *omap_plane = to_omap_plane(plane); |
| 198 | return omap_crtc_apply(plane->crtc, &omap_plane->apply); |
| 199 | } |
| 200 | return 0; |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 201 | } |
| 202 | |
Rob Clark | 2f53700 | 2012-01-16 12:51:18 -0600 | [diff] [blame] | 203 | int omap_plane_mode_set(struct drm_plane *plane, |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 204 | struct drm_crtc *crtc, struct drm_framebuffer *fb, |
| 205 | int crtc_x, int crtc_y, |
| 206 | unsigned int crtc_w, unsigned int crtc_h, |
| 207 | uint32_t src_x, uint32_t src_y, |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 208 | uint32_t src_w, uint32_t src_h, |
| 209 | void (*fxn)(void *), void *arg) |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 210 | { |
| 211 | struct omap_plane *omap_plane = to_omap_plane(plane); |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 212 | struct omap_drm_window *win = &omap_plane->win; |
| 213 | |
| 214 | win->crtc_x = crtc_x; |
| 215 | win->crtc_y = crtc_y; |
| 216 | win->crtc_w = crtc_w; |
| 217 | win->crtc_h = crtc_h; |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 218 | |
| 219 | /* src values are in Q16 fixed point, convert to integer: */ |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 220 | win->src_x = src_x >> 16; |
| 221 | win->src_y = src_y >> 16; |
| 222 | win->src_w = src_w >> 16; |
| 223 | win->src_h = src_h >> 16; |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 224 | |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 225 | if (fxn) { |
| 226 | /* omap_crtc should ensure that a new page flip |
| 227 | * isn't permitted while there is one pending: |
| 228 | */ |
| 229 | BUG_ON(omap_plane->apply_done_cb.fxn); |
| 230 | |
| 231 | omap_plane->apply_done_cb.fxn = fxn; |
| 232 | omap_plane->apply_done_cb.arg = arg; |
| 233 | } |
| 234 | |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 235 | plane->fb = fb; |
| 236 | plane->crtc = crtc; |
| 237 | |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 238 | return apply(plane); |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 239 | } |
| 240 | |
Rob Clark | 2f53700 | 2012-01-16 12:51:18 -0600 | [diff] [blame] | 241 | static int omap_plane_update(struct drm_plane *plane, |
| 242 | struct drm_crtc *crtc, struct drm_framebuffer *fb, |
| 243 | int crtc_x, int crtc_y, |
| 244 | unsigned int crtc_w, unsigned int crtc_h, |
| 245 | uint32_t src_x, uint32_t src_y, |
| 246 | uint32_t src_w, uint32_t src_h) |
| 247 | { |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 248 | struct omap_plane *omap_plane = to_omap_plane(plane); |
| 249 | omap_plane->enabled = true; |
| 250 | return omap_plane_mode_set(plane, crtc, fb, |
| 251 | crtc_x, crtc_y, crtc_w, crtc_h, |
| 252 | src_x, src_y, src_w, src_h, |
| 253 | NULL, NULL); |
Rob Clark | 2f53700 | 2012-01-16 12:51:18 -0600 | [diff] [blame] | 254 | } |
| 255 | |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 256 | static int omap_plane_disable(struct drm_plane *plane) |
| 257 | { |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 258 | struct omap_plane *omap_plane = to_omap_plane(plane); |
| 259 | omap_plane->win.rotation = BIT(DRM_ROTATE_0); |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 260 | return omap_plane_dpms(plane, DRM_MODE_DPMS_OFF); |
| 261 | } |
| 262 | |
| 263 | static void omap_plane_destroy(struct drm_plane *plane) |
| 264 | { |
| 265 | struct omap_plane *omap_plane = to_omap_plane(plane); |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 266 | |
| 267 | DBG("%s", omap_plane->name); |
| 268 | |
| 269 | omap_irq_unregister(plane->dev, &omap_plane->error_irq); |
| 270 | |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 271 | omap_plane_disable(plane); |
| 272 | drm_plane_cleanup(plane); |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 273 | |
| 274 | WARN_ON(!kfifo_is_empty(&omap_plane->unpin_fifo)); |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 275 | kfifo_free(&omap_plane->unpin_fifo); |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 276 | |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 277 | kfree(omap_plane); |
| 278 | } |
| 279 | |
| 280 | int omap_plane_dpms(struct drm_plane *plane, int mode) |
| 281 | { |
| 282 | struct omap_plane *omap_plane = to_omap_plane(plane); |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 283 | bool enabled = (mode == DRM_MODE_DPMS_ON); |
| 284 | int ret = 0; |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 285 | |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 286 | if (enabled != omap_plane->enabled) { |
| 287 | omap_plane->enabled = enabled; |
| 288 | ret = apply(plane); |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 289 | } |
| 290 | |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 291 | return ret; |
Rob Clark | 72d0c33 | 2012-03-11 21:11:21 -0500 | [diff] [blame] | 292 | } |
| 293 | |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 294 | /* helper to install properties which are common to planes and crtcs */ |
| 295 | void omap_plane_install_properties(struct drm_plane *plane, |
| 296 | struct drm_mode_object *obj) |
| 297 | { |
| 298 | struct drm_device *dev = plane->dev; |
| 299 | struct omap_drm_private *priv = dev->dev_private; |
| 300 | struct drm_property *prop; |
| 301 | |
Rob Clark | c2a6a55 | 2012-10-25 17:14:13 -0500 | [diff] [blame] | 302 | if (priv->has_dmm) { |
| 303 | prop = priv->rotation_prop; |
| 304 | if (!prop) { |
| 305 | const struct drm_prop_enum_list props[] = { |
| 306 | { DRM_ROTATE_0, "rotate-0" }, |
| 307 | { DRM_ROTATE_90, "rotate-90" }, |
| 308 | { DRM_ROTATE_180, "rotate-180" }, |
| 309 | { DRM_ROTATE_270, "rotate-270" }, |
| 310 | { DRM_REFLECT_X, "reflect-x" }, |
| 311 | { DRM_REFLECT_Y, "reflect-y" }, |
| 312 | }; |
| 313 | prop = drm_property_create_bitmask(dev, 0, "rotation", |
| 314 | props, ARRAY_SIZE(props)); |
| 315 | if (prop == NULL) |
| 316 | return; |
| 317 | priv->rotation_prop = prop; |
| 318 | } |
| 319 | drm_object_attach_property(obj, prop, 0); |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 320 | } |
Andre Renaud | 8451b5a | 2012-08-15 15:18:02 -0500 | [diff] [blame] | 321 | |
YAMANE Toshiaki | c17d37d | 2012-11-14 19:41:13 +0900 | [diff] [blame] | 322 | prop = priv->zorder_prop; |
| 323 | if (!prop) { |
Andre Renaud | 8451b5a | 2012-08-15 15:18:02 -0500 | [diff] [blame] | 324 | prop = drm_property_create_range(dev, 0, "zorder", 0, 3); |
| 325 | if (prop == NULL) |
| 326 | return; |
| 327 | priv->zorder_prop = prop; |
| 328 | } |
| 329 | drm_object_attach_property(obj, prop, 0); |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 330 | } |
| 331 | |
| 332 | int omap_plane_set_property(struct drm_plane *plane, |
| 333 | struct drm_property *property, uint64_t val) |
| 334 | { |
| 335 | struct omap_plane *omap_plane = to_omap_plane(plane); |
| 336 | struct omap_drm_private *priv = plane->dev->dev_private; |
| 337 | int ret = -EINVAL; |
| 338 | |
| 339 | if (property == priv->rotation_prop) { |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 340 | DBG("%s: rotation: %02x", omap_plane->name, (uint32_t)val); |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 341 | omap_plane->win.rotation = val; |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 342 | ret = apply(plane); |
Andre Renaud | 8451b5a | 2012-08-15 15:18:02 -0500 | [diff] [blame] | 343 | } else if (property == priv->zorder_prop) { |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 344 | DBG("%s: zorder: %02x", omap_plane->name, (uint32_t)val); |
Andre Renaud | 8451b5a | 2012-08-15 15:18:02 -0500 | [diff] [blame] | 345 | omap_plane->info.zorder = val; |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 346 | ret = apply(plane); |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 347 | } |
| 348 | |
| 349 | return ret; |
| 350 | } |
| 351 | |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 352 | static const struct drm_plane_funcs omap_plane_funcs = { |
| 353 | .update_plane = omap_plane_update, |
| 354 | .disable_plane = omap_plane_disable, |
| 355 | .destroy = omap_plane_destroy, |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 356 | .set_property = omap_plane_set_property, |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 357 | }; |
| 358 | |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 359 | static void omap_plane_error_irq(struct omap_drm_irq *irq, uint32_t irqstatus) |
| 360 | { |
| 361 | struct omap_plane *omap_plane = |
| 362 | container_of(irq, struct omap_plane, error_irq); |
| 363 | DRM_ERROR("%s: errors: %08x\n", omap_plane->name, irqstatus); |
| 364 | } |
| 365 | |
| 366 | static const char *plane_names[] = { |
| 367 | [OMAP_DSS_GFX] = "gfx", |
| 368 | [OMAP_DSS_VIDEO1] = "vid1", |
| 369 | [OMAP_DSS_VIDEO2] = "vid2", |
| 370 | [OMAP_DSS_VIDEO3] = "vid3", |
| 371 | }; |
| 372 | |
| 373 | static const uint32_t error_irqs[] = { |
| 374 | [OMAP_DSS_GFX] = DISPC_IRQ_GFX_FIFO_UNDERFLOW, |
| 375 | [OMAP_DSS_VIDEO1] = DISPC_IRQ_VID1_FIFO_UNDERFLOW, |
| 376 | [OMAP_DSS_VIDEO2] = DISPC_IRQ_VID2_FIFO_UNDERFLOW, |
| 377 | [OMAP_DSS_VIDEO3] = DISPC_IRQ_VID3_FIFO_UNDERFLOW, |
| 378 | }; |
| 379 | |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 380 | /* initialize plane */ |
| 381 | struct drm_plane *omap_plane_init(struct drm_device *dev, |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 382 | int id, bool private_plane) |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 383 | { |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 384 | struct omap_drm_private *priv = dev->dev_private; |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 385 | struct drm_plane *plane = NULL; |
| 386 | struct omap_plane *omap_plane; |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 387 | struct omap_overlay_info *info; |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 388 | int ret; |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 389 | |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 390 | DBG("%s: priv=%d", plane_names[id], private_plane); |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 391 | |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 392 | omap_plane = kzalloc(sizeof(*omap_plane), GFP_KERNEL); |
Joe Perches | 78110bb | 2013-02-11 09:41:29 -0800 | [diff] [blame] | 393 | if (!omap_plane) |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 394 | goto fail; |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 395 | |
Rob Clark | b33f34d | 2012-03-05 10:48:35 -0600 | [diff] [blame] | 396 | ret = kfifo_alloc(&omap_plane->unpin_fifo, 16, GFP_KERNEL); |
| 397 | if (ret) { |
| 398 | dev_err(dev->dev, "could not allocate unpin FIFO\n"); |
| 399 | goto fail; |
| 400 | } |
| 401 | |
Rob Clark | a890e66 | 2012-03-05 10:48:31 -0600 | [diff] [blame] | 402 | omap_plane->nformats = omap_framebuffer_get_formats( |
| 403 | omap_plane->formats, ARRAY_SIZE(omap_plane->formats), |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 404 | dss_feat_get_supported_color_modes(id)); |
| 405 | omap_plane->id = id; |
| 406 | omap_plane->name = plane_names[id]; |
| 407 | |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 408 | plane = &omap_plane->base; |
| 409 | |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 410 | omap_plane->apply.pre_apply = omap_plane_pre_apply; |
| 411 | omap_plane->apply.post_apply = omap_plane_post_apply; |
| 412 | |
| 413 | omap_plane->error_irq.irqmask = error_irqs[id]; |
| 414 | omap_plane->error_irq.irq = omap_plane_error_irq; |
| 415 | omap_irq_register(dev, &omap_plane->error_irq); |
| 416 | |
| 417 | drm_plane_init(dev, plane, (1 << priv->num_crtcs) - 1, &omap_plane_funcs, |
| 418 | omap_plane->formats, omap_plane->nformats, private_plane); |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 419 | |
Rob Clark | 3c810c6 | 2012-08-15 15:18:01 -0500 | [diff] [blame] | 420 | omap_plane_install_properties(plane, &plane->base); |
| 421 | |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 422 | /* get our starting configuration, set defaults for parameters |
| 423 | * we don't currently use, etc: |
| 424 | */ |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 425 | info = &omap_plane->info; |
| 426 | info->rotation_type = OMAP_DSS_ROT_DMA; |
| 427 | info->rotation = OMAP_DSS_ROT_0; |
| 428 | info->global_alpha = 0xff; |
| 429 | info->mirror = 0; |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 430 | |
| 431 | /* Set defaults depending on whether we are a CRTC or overlay |
| 432 | * layer. |
| 433 | * TODO add ioctl to give userspace an API to change this.. this |
| 434 | * will come in a subsequent patch. |
| 435 | */ |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 436 | if (private_plane) |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 437 | omap_plane->info.zorder = 0; |
| 438 | else |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 439 | omap_plane->info.zorder = id; |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 440 | |
| 441 | return plane; |
| 442 | |
| 443 | fail: |
YAMANE Toshiaki | 373de7f | 2012-11-14 19:40:57 +0900 | [diff] [blame] | 444 | if (plane) |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 445 | omap_plane_destroy(plane); |
YAMANE Toshiaki | 373de7f | 2012-11-14 19:40:57 +0900 | [diff] [blame] | 446 | |
Rob Clark | bb5c2d9 | 2012-01-16 12:51:16 -0600 | [diff] [blame] | 447 | return NULL; |
| 448 | } |