Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 1 | /* |
Alan Kwong | 578cdaf | 2017-01-28 17:25:43 -0800 | [diff] [blame] | 2 | * Copyright (c) 2016-2017, The Linux Foundation. All rights reserved. |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 3 | * Copyright (C) 2013 Red Hat |
| 4 | * Author: Rob Clark <robdclark@gmail.com> |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify it |
| 7 | * under the terms of the GNU General Public License version 2 as published by |
| 8 | * the Free Software Foundation. |
| 9 | * |
| 10 | * This program is distributed in the hope that it will be useful, but WITHOUT |
| 11 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| 12 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| 13 | * more details. |
| 14 | * |
| 15 | * You should have received a copy of the GNU General Public License along with |
| 16 | * this program. If not, see <http://www.gnu.org/licenses/>. |
| 17 | */ |
| 18 | |
Alan Kwong | 578cdaf | 2017-01-28 17:25:43 -0800 | [diff] [blame] | 19 | #include <linux/dma-mapping.h> |
| 20 | #include <linux/dma-buf.h> |
| 21 | |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 22 | #include "msm_drv.h" |
Rob Clark | dd2da6e | 2013-11-30 16:12:10 -0500 | [diff] [blame] | 23 | #include "msm_kms.h" |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 24 | |
| 25 | #include "drm_crtc.h" |
| 26 | #include "drm_crtc_helper.h" |
| 27 | |
Alan Kwong | 578cdaf | 2017-01-28 17:25:43 -0800 | [diff] [blame] | 28 | #define MSM_FRAMEBUFFER_FLAG_KMAP BIT(0) |
| 29 | |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 30 | struct msm_framebuffer { |
| 31 | struct drm_framebuffer base; |
| 32 | const struct msm_format *format; |
Stephane Viau | 7ca1271 | 2014-12-08 10:48:57 -0500 | [diff] [blame] | 33 | struct drm_gem_object *planes[MAX_PLANE]; |
Alan Kwong | 578cdaf | 2017-01-28 17:25:43 -0800 | [diff] [blame] | 34 | void *vaddr[MAX_PLANE]; |
| 35 | atomic_t kmap_count; |
| 36 | u32 flags; |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 37 | }; |
| 38 | #define to_msm_framebuffer(x) container_of(x, struct msm_framebuffer, base) |
| 39 | |
| 40 | |
| 41 | static int msm_framebuffer_create_handle(struct drm_framebuffer *fb, |
| 42 | struct drm_file *file_priv, |
| 43 | unsigned int *handle) |
| 44 | { |
| 45 | struct msm_framebuffer *msm_fb = to_msm_framebuffer(fb); |
| 46 | return drm_gem_handle_create(file_priv, |
| 47 | msm_fb->planes[0], handle); |
| 48 | } |
| 49 | |
| 50 | static void msm_framebuffer_destroy(struct drm_framebuffer *fb) |
| 51 | { |
| 52 | struct msm_framebuffer *msm_fb = to_msm_framebuffer(fb); |
| 53 | int i, n = drm_format_num_planes(fb->pixel_format); |
| 54 | |
| 55 | DBG("destroy: FB ID: %d (%p)", fb->base.id, fb); |
| 56 | |
| 57 | drm_framebuffer_cleanup(fb); |
| 58 | |
| 59 | for (i = 0; i < n; i++) { |
| 60 | struct drm_gem_object *bo = msm_fb->planes[i]; |
Markus Elfring | e73a856 | 2016-07-13 19:15:35 +0200 | [diff] [blame] | 61 | |
| 62 | drm_gem_object_unreference_unlocked(bo); |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 63 | } |
| 64 | |
| 65 | kfree(msm_fb); |
| 66 | } |
| 67 | |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 68 | static const struct drm_framebuffer_funcs msm_framebuffer_funcs = { |
| 69 | .create_handle = msm_framebuffer_create_handle, |
| 70 | .destroy = msm_framebuffer_destroy, |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 71 | }; |
| 72 | |
| 73 | #ifdef CONFIG_DEBUG_FS |
| 74 | void msm_framebuffer_describe(struct drm_framebuffer *fb, struct seq_file *m) |
| 75 | { |
| 76 | struct msm_framebuffer *msm_fb = to_msm_framebuffer(fb); |
| 77 | int i, n = drm_format_num_planes(fb->pixel_format); |
| 78 | |
| 79 | seq_printf(m, "fb: %dx%d@%4.4s (%2d, ID:%d)\n", |
| 80 | fb->width, fb->height, (char *)&fb->pixel_format, |
Dave Airlie | 747a598 | 2016-04-15 15:10:35 +1000 | [diff] [blame] | 81 | drm_framebuffer_read_refcount(fb), fb->base.id); |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 82 | |
| 83 | for (i = 0; i < n; i++) { |
| 84 | seq_printf(m, " %d: offset=%d pitch=%d, obj: ", |
| 85 | i, fb->offsets[i], fb->pitches[i]); |
| 86 | msm_gem_describe(msm_fb->planes[i], m); |
| 87 | } |
| 88 | } |
| 89 | #endif |
| 90 | |
Alan Kwong | 578cdaf | 2017-01-28 17:25:43 -0800 | [diff] [blame] | 91 | void msm_framebuffer_set_kmap(struct drm_framebuffer *fb, bool enable) |
| 92 | { |
| 93 | struct msm_framebuffer *msm_fb = to_msm_framebuffer(fb); |
| 94 | |
| 95 | if (enable) |
| 96 | msm_fb->flags |= MSM_FRAMEBUFFER_FLAG_KMAP; |
| 97 | else |
| 98 | msm_fb->flags &= ~MSM_FRAMEBUFFER_FLAG_KMAP; |
| 99 | } |
| 100 | |
| 101 | static int msm_framebuffer_kmap(struct drm_framebuffer *fb) |
| 102 | { |
| 103 | struct msm_framebuffer *msm_fb = to_msm_framebuffer(fb); |
| 104 | int i, n = drm_format_num_planes(fb->pixel_format); |
| 105 | struct drm_gem_object *bo; |
| 106 | |
| 107 | if (atomic_inc_return(&msm_fb->kmap_count) > 1) |
| 108 | return 0; |
| 109 | |
| 110 | for (i = 0; i < n; i++) { |
| 111 | bo = msm_framebuffer_bo(fb, i); |
| 112 | if (!bo || !bo->dma_buf) { |
| 113 | msm_fb->vaddr[i] = NULL; |
| 114 | continue; |
| 115 | } |
| 116 | dma_buf_begin_cpu_access(bo->dma_buf, DMA_BIDIRECTIONAL); |
| 117 | msm_fb->vaddr[i] = dma_buf_kmap(bo->dma_buf, 0); |
| 118 | DRM_INFO("FB[%u]: vaddr[%d]:%ux%u:0x%llx\n", fb->base.id, i, |
| 119 | fb->width, fb->height, (u64) msm_fb->vaddr[i]); |
| 120 | } |
| 121 | |
| 122 | return 0; |
| 123 | } |
| 124 | |
| 125 | static void msm_framebuffer_kunmap(struct drm_framebuffer *fb) |
| 126 | { |
| 127 | struct msm_framebuffer *msm_fb = to_msm_framebuffer(fb); |
| 128 | int i, n = drm_format_num_planes(fb->pixel_format); |
| 129 | struct drm_gem_object *bo; |
| 130 | |
| 131 | if (atomic_dec_return(&msm_fb->kmap_count) > 0) |
| 132 | return; |
| 133 | |
| 134 | for (i = 0; i < n; i++) { |
| 135 | bo = msm_framebuffer_bo(fb, i); |
| 136 | if (!bo || !msm_fb->vaddr[i]) |
| 137 | continue; |
| 138 | if (bo->dma_buf) { |
| 139 | dma_buf_kunmap(bo->dma_buf, 0, msm_fb->vaddr[i]); |
| 140 | dma_buf_end_cpu_access(bo->dma_buf, DMA_BIDIRECTIONAL); |
| 141 | } |
| 142 | msm_fb->vaddr[i] = NULL; |
| 143 | } |
| 144 | } |
| 145 | |
Rob Clark | 2638d90 | 2014-11-08 09:13:37 -0500 | [diff] [blame] | 146 | /* prepare/pin all the fb's bo's for scanout. Note that it is not valid |
| 147 | * to prepare an fb more multiple different initiator 'id's. But that |
| 148 | * should be fine, since only the scanout (mdpN) side of things needs |
| 149 | * this, the gpu doesn't care about fb's. |
| 150 | */ |
Jordan Crouse | d8e9652 | 2017-02-13 10:14:16 -0700 | [diff] [blame] | 151 | int msm_framebuffer_prepare(struct drm_framebuffer *fb, |
| 152 | struct msm_gem_address_space *aspace) |
Rob Clark | 2638d90 | 2014-11-08 09:13:37 -0500 | [diff] [blame] | 153 | { |
| 154 | struct msm_framebuffer *msm_fb = to_msm_framebuffer(fb); |
| 155 | int ret, i, n = drm_format_num_planes(fb->pixel_format); |
| 156 | uint32_t iova; |
| 157 | |
| 158 | for (i = 0; i < n; i++) { |
Jordan Crouse | d8e9652 | 2017-02-13 10:14:16 -0700 | [diff] [blame] | 159 | ret = msm_gem_get_iova(msm_fb->planes[i], aspace, &iova); |
Rob Clark | 2638d90 | 2014-11-08 09:13:37 -0500 | [diff] [blame] | 160 | DBG("FB[%u]: iova[%d]: %08x (%d)", fb->base.id, i, iova, ret); |
| 161 | if (ret) |
| 162 | return ret; |
| 163 | } |
| 164 | |
Alan Kwong | 578cdaf | 2017-01-28 17:25:43 -0800 | [diff] [blame] | 165 | if (msm_fb->flags & MSM_FRAMEBUFFER_FLAG_KMAP) |
| 166 | msm_framebuffer_kmap(fb); |
| 167 | |
Rob Clark | 2638d90 | 2014-11-08 09:13:37 -0500 | [diff] [blame] | 168 | return 0; |
| 169 | } |
| 170 | |
Jordan Crouse | d8e9652 | 2017-02-13 10:14:16 -0700 | [diff] [blame] | 171 | void msm_framebuffer_cleanup(struct drm_framebuffer *fb, |
| 172 | struct msm_gem_address_space *aspace) |
Rob Clark | 2638d90 | 2014-11-08 09:13:37 -0500 | [diff] [blame] | 173 | { |
| 174 | struct msm_framebuffer *msm_fb = to_msm_framebuffer(fb); |
| 175 | int i, n = drm_format_num_planes(fb->pixel_format); |
| 176 | |
Alan Kwong | 578cdaf | 2017-01-28 17:25:43 -0800 | [diff] [blame] | 177 | if (msm_fb->flags & MSM_FRAMEBUFFER_FLAG_KMAP) |
| 178 | msm_framebuffer_kunmap(fb); |
| 179 | |
Rob Clark | 2638d90 | 2014-11-08 09:13:37 -0500 | [diff] [blame] | 180 | for (i = 0; i < n; i++) |
Jordan Crouse | d8e9652 | 2017-02-13 10:14:16 -0700 | [diff] [blame] | 181 | msm_gem_put_iova(msm_fb->planes[i], aspace); |
Rob Clark | 2638d90 | 2014-11-08 09:13:37 -0500 | [diff] [blame] | 182 | } |
| 183 | |
Jordan Crouse | d8e9652 | 2017-02-13 10:14:16 -0700 | [diff] [blame] | 184 | uint32_t msm_framebuffer_iova(struct drm_framebuffer *fb, |
| 185 | struct msm_gem_address_space *aspace, int plane) |
Rob Clark | 2638d90 | 2014-11-08 09:13:37 -0500 | [diff] [blame] | 186 | { |
| 187 | struct msm_framebuffer *msm_fb = to_msm_framebuffer(fb); |
Rob Clark | 3e2f29e | 2014-11-19 12:29:33 -0500 | [diff] [blame] | 188 | if (!msm_fb->planes[plane]) |
| 189 | return 0; |
Jordan Crouse | d8e9652 | 2017-02-13 10:14:16 -0700 | [diff] [blame] | 190 | return msm_gem_iova(msm_fb->planes[plane], aspace) + fb->offsets[plane]; |
Rob Clark | 2638d90 | 2014-11-08 09:13:37 -0500 | [diff] [blame] | 191 | } |
| 192 | |
Abhijit Kulkarni | 1b3340c | 2017-06-22 12:39:37 -0700 | [diff] [blame^] | 193 | uint32_t msm_framebuffer_phys(struct drm_framebuffer *fb, |
| 194 | int plane) |
| 195 | { |
| 196 | struct msm_framebuffer *msm_fb = to_msm_framebuffer(fb); |
| 197 | dma_addr_t phys_addr; |
| 198 | |
| 199 | if (!msm_fb->planes[plane]) |
| 200 | return 0; |
| 201 | |
| 202 | phys_addr = msm_gem_get_dma_addr(msm_fb->planes[plane]); |
| 203 | if (!phys_addr) |
| 204 | return 0; |
| 205 | |
| 206 | return phys_addr + fb->offsets[plane]; |
| 207 | } |
| 208 | |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 209 | struct drm_gem_object *msm_framebuffer_bo(struct drm_framebuffer *fb, int plane) |
| 210 | { |
| 211 | struct msm_framebuffer *msm_fb = to_msm_framebuffer(fb); |
| 212 | return msm_fb->planes[plane]; |
| 213 | } |
| 214 | |
| 215 | const struct msm_format *msm_framebuffer_format(struct drm_framebuffer *fb) |
| 216 | { |
Dhaval Patel | ccbcb3d | 2016-08-22 11:58:14 -0700 | [diff] [blame] | 217 | return fb ? (to_msm_framebuffer(fb))->format : NULL; |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 218 | } |
| 219 | |
| 220 | struct drm_framebuffer *msm_framebuffer_create(struct drm_device *dev, |
Ville Syrjälä | 1eb8345 | 2015-11-11 19:11:29 +0200 | [diff] [blame] | 221 | struct drm_file *file, const struct drm_mode_fb_cmd2 *mode_cmd) |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 222 | { |
| 223 | struct drm_gem_object *bos[4] = {0}; |
| 224 | struct drm_framebuffer *fb; |
| 225 | int ret, i, n = drm_format_num_planes(mode_cmd->pixel_format); |
| 226 | |
| 227 | for (i = 0; i < n; i++) { |
Chris Wilson | a8ad0bd | 2016-05-09 11:04:54 +0100 | [diff] [blame] | 228 | bos[i] = drm_gem_object_lookup(file, mode_cmd->handles[i]); |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 229 | if (!bos[i]) { |
| 230 | ret = -ENXIO; |
| 231 | goto out_unref; |
| 232 | } |
| 233 | } |
| 234 | |
| 235 | fb = msm_framebuffer_init(dev, mode_cmd, bos); |
| 236 | if (IS_ERR(fb)) { |
| 237 | ret = PTR_ERR(fb); |
| 238 | goto out_unref; |
| 239 | } |
| 240 | |
| 241 | return fb; |
| 242 | |
| 243 | out_unref: |
| 244 | for (i = 0; i < n; i++) |
| 245 | drm_gem_object_unreference_unlocked(bos[i]); |
| 246 | return ERR_PTR(ret); |
| 247 | } |
| 248 | |
| 249 | struct drm_framebuffer *msm_framebuffer_init(struct drm_device *dev, |
Ville Syrjälä | 1eb8345 | 2015-11-11 19:11:29 +0200 | [diff] [blame] | 250 | const struct drm_mode_fb_cmd2 *mode_cmd, struct drm_gem_object **bos) |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 251 | { |
| 252 | struct msm_drm_private *priv = dev->dev_private; |
| 253 | struct msm_kms *kms = priv->kms; |
Stephane Viau | 7194b62 | 2015-05-05 09:47:57 -0400 | [diff] [blame] | 254 | struct msm_framebuffer *msm_fb = NULL; |
| 255 | struct drm_framebuffer *fb; |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 256 | const struct msm_format *format; |
Lloyd Atkinson | 9a67349 | 2016-07-05 11:41:57 -0400 | [diff] [blame] | 257 | int ret, i, num_planes; |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 258 | unsigned int hsub, vsub; |
Lloyd Atkinson | 80be567 | 2016-05-25 15:13:23 -0400 | [diff] [blame] | 259 | bool is_modified = false; |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 260 | |
| 261 | DBG("create framebuffer: dev=%p, mode_cmd=%p (%dx%d@%4.4s)", |
| 262 | dev, mode_cmd, mode_cmd->width, mode_cmd->height, |
| 263 | (char *)&mode_cmd->pixel_format); |
| 264 | |
Lloyd Atkinson | 9a67349 | 2016-07-05 11:41:57 -0400 | [diff] [blame] | 265 | num_planes = drm_format_num_planes(mode_cmd->pixel_format); |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 266 | hsub = drm_format_horz_chroma_subsampling(mode_cmd->pixel_format); |
| 267 | vsub = drm_format_vert_chroma_subsampling(mode_cmd->pixel_format); |
| 268 | |
Lloyd Atkinson | 9a67349 | 2016-07-05 11:41:57 -0400 | [diff] [blame] | 269 | format = kms->funcs->get_format(kms, mode_cmd->pixel_format, |
| 270 | mode_cmd->modifier, num_planes); |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 271 | if (!format) { |
| 272 | dev_err(dev->dev, "unsupported pixel format: %4.4s\n", |
| 273 | (char *)&mode_cmd->pixel_format); |
| 274 | ret = -EINVAL; |
| 275 | goto fail; |
| 276 | } |
| 277 | |
| 278 | msm_fb = kzalloc(sizeof(*msm_fb), GFP_KERNEL); |
| 279 | if (!msm_fb) { |
| 280 | ret = -ENOMEM; |
| 281 | goto fail; |
| 282 | } |
| 283 | |
| 284 | fb = &msm_fb->base; |
| 285 | |
| 286 | msm_fb->format = format; |
Alan Kwong | 578cdaf | 2017-01-28 17:25:43 -0800 | [diff] [blame] | 287 | atomic_set(&msm_fb->kmap_count, 0); |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 288 | |
Lloyd Atkinson | 80be567 | 2016-05-25 15:13:23 -0400 | [diff] [blame] | 289 | if (mode_cmd->flags & DRM_MODE_FB_MODIFIERS) { |
| 290 | for (i = 0; i < ARRAY_SIZE(mode_cmd->modifier); i++) { |
| 291 | if (mode_cmd->modifier[i]) { |
| 292 | is_modified = true; |
| 293 | break; |
| 294 | } |
| 295 | } |
| 296 | } |
| 297 | |
Lloyd Atkinson | 9a67349 | 2016-07-05 11:41:57 -0400 | [diff] [blame] | 298 | if (num_planes > ARRAY_SIZE(msm_fb->planes)) { |
Rob Clark | 10291bf | 2014-11-08 09:20:28 -0500 | [diff] [blame] | 299 | ret = -EINVAL; |
| 300 | goto fail; |
| 301 | } |
| 302 | |
Lloyd Atkinson | 80be567 | 2016-05-25 15:13:23 -0400 | [diff] [blame] | 303 | if (is_modified) { |
| 304 | if (!kms->funcs->check_modified_format) { |
| 305 | dev_err(dev->dev, "can't check modified fb format\n"); |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 306 | ret = -EINVAL; |
| 307 | goto fail; |
Lloyd Atkinson | 80be567 | 2016-05-25 15:13:23 -0400 | [diff] [blame] | 308 | } else { |
| 309 | ret = kms->funcs->check_modified_format( |
| 310 | kms, msm_fb->format, mode_cmd, bos); |
| 311 | if (ret) |
| 312 | goto fail; |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 313 | } |
Lloyd Atkinson | 80be567 | 2016-05-25 15:13:23 -0400 | [diff] [blame] | 314 | } else { |
| 315 | for (i = 0; i < num_planes; i++) { |
| 316 | unsigned int width = mode_cmd->width / (i ? hsub : 1); |
| 317 | unsigned int height = mode_cmd->height / (i ? vsub : 1); |
| 318 | unsigned int min_size; |
| 319 | unsigned int cpp; |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 320 | |
Lloyd Atkinson | 80be567 | 2016-05-25 15:13:23 -0400 | [diff] [blame] | 321 | cpp = drm_format_plane_cpp(mode_cmd->pixel_format, i); |
| 322 | |
| 323 | min_size = (height - 1) * mode_cmd->pitches[i] |
| 324 | + width * cpp |
| 325 | + mode_cmd->offsets[i]; |
| 326 | |
| 327 | if (bos[i]->size < min_size) { |
| 328 | ret = -EINVAL; |
| 329 | goto fail; |
| 330 | } |
| 331 | } |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 332 | } |
| 333 | |
Lloyd Atkinson | 80be567 | 2016-05-25 15:13:23 -0400 | [diff] [blame] | 334 | for (i = 0; i < num_planes; i++) |
| 335 | msm_fb->planes[i] = bos[i]; |
| 336 | |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 337 | drm_helper_mode_fill_fb_struct(fb, mode_cmd); |
| 338 | |
| 339 | ret = drm_framebuffer_init(dev, fb, &msm_framebuffer_funcs); |
| 340 | if (ret) { |
| 341 | dev_err(dev->dev, "framebuffer init failed: %d\n", ret); |
| 342 | goto fail; |
| 343 | } |
| 344 | |
| 345 | DBG("create: FB ID: %d (%p)", fb->base.id, fb); |
| 346 | |
| 347 | return fb; |
| 348 | |
| 349 | fail: |
Stephane Viau | 7194b62 | 2015-05-05 09:47:57 -0400 | [diff] [blame] | 350 | kfree(msm_fb); |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 351 | |
| 352 | return ERR_PTR(ret); |
| 353 | } |