Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2013 Red Hat |
| 3 | * Author: Rob Clark <robdclark@gmail.com> |
| 4 | * |
| 5 | * This program is free software; you can redistribute it and/or modify it |
| 6 | * under the terms of the GNU General Public License version 2 as published by |
| 7 | * the Free Software Foundation. |
| 8 | * |
| 9 | * This program is distributed in the hope that it will be useful, but WITHOUT |
| 10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| 11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| 12 | * more details. |
| 13 | * |
| 14 | * You should have received a copy of the GNU General Public License along with |
| 15 | * this program. If not, see <http://www.gnu.org/licenses/>. |
| 16 | */ |
| 17 | |
| 18 | #include "msm_drv.h" |
Rob Clark | dd2da6e | 2013-11-30 16:12:10 -0500 | [diff] [blame] | 19 | #include "msm_kms.h" |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 20 | |
| 21 | #include "drm_crtc.h" |
| 22 | #include "drm_crtc_helper.h" |
| 23 | |
| 24 | struct msm_framebuffer { |
| 25 | struct drm_framebuffer base; |
| 26 | const struct msm_format *format; |
Stephane Viau | 7ca1271 | 2014-12-08 10:48:57 -0500 | [diff] [blame] | 27 | struct drm_gem_object *planes[MAX_PLANE]; |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 28 | }; |
| 29 | #define to_msm_framebuffer(x) container_of(x, struct msm_framebuffer, base) |
| 30 | |
| 31 | |
| 32 | static int msm_framebuffer_create_handle(struct drm_framebuffer *fb, |
| 33 | struct drm_file *file_priv, |
| 34 | unsigned int *handle) |
| 35 | { |
| 36 | struct msm_framebuffer *msm_fb = to_msm_framebuffer(fb); |
| 37 | return drm_gem_handle_create(file_priv, |
| 38 | msm_fb->planes[0], handle); |
| 39 | } |
| 40 | |
| 41 | static void msm_framebuffer_destroy(struct drm_framebuffer *fb) |
| 42 | { |
| 43 | struct msm_framebuffer *msm_fb = to_msm_framebuffer(fb); |
| 44 | int i, n = drm_format_num_planes(fb->pixel_format); |
| 45 | |
| 46 | DBG("destroy: FB ID: %d (%p)", fb->base.id, fb); |
| 47 | |
| 48 | drm_framebuffer_cleanup(fb); |
| 49 | |
| 50 | for (i = 0; i < n; i++) { |
| 51 | struct drm_gem_object *bo = msm_fb->planes[i]; |
| 52 | if (bo) |
| 53 | drm_gem_object_unreference_unlocked(bo); |
| 54 | } |
| 55 | |
| 56 | kfree(msm_fb); |
| 57 | } |
| 58 | |
| 59 | static int msm_framebuffer_dirty(struct drm_framebuffer *fb, |
| 60 | struct drm_file *file_priv, unsigned flags, unsigned color, |
| 61 | struct drm_clip_rect *clips, unsigned num_clips) |
| 62 | { |
| 63 | return 0; |
| 64 | } |
| 65 | |
| 66 | static const struct drm_framebuffer_funcs msm_framebuffer_funcs = { |
| 67 | .create_handle = msm_framebuffer_create_handle, |
| 68 | .destroy = msm_framebuffer_destroy, |
| 69 | .dirty = msm_framebuffer_dirty, |
| 70 | }; |
| 71 | |
| 72 | #ifdef CONFIG_DEBUG_FS |
| 73 | void msm_framebuffer_describe(struct drm_framebuffer *fb, struct seq_file *m) |
| 74 | { |
| 75 | struct msm_framebuffer *msm_fb = to_msm_framebuffer(fb); |
| 76 | int i, n = drm_format_num_planes(fb->pixel_format); |
| 77 | |
| 78 | seq_printf(m, "fb: %dx%d@%4.4s (%2d, ID:%d)\n", |
| 79 | fb->width, fb->height, (char *)&fb->pixel_format, |
| 80 | fb->refcount.refcount.counter, fb->base.id); |
| 81 | |
| 82 | for (i = 0; i < n; i++) { |
| 83 | seq_printf(m, " %d: offset=%d pitch=%d, obj: ", |
| 84 | i, fb->offsets[i], fb->pitches[i]); |
| 85 | msm_gem_describe(msm_fb->planes[i], m); |
| 86 | } |
| 87 | } |
| 88 | #endif |
| 89 | |
Rob Clark | 2638d90 | 2014-11-08 09:13:37 -0500 | [diff] [blame] | 90 | /* prepare/pin all the fb's bo's for scanout. Note that it is not valid |
| 91 | * to prepare an fb more multiple different initiator 'id's. But that |
| 92 | * should be fine, since only the scanout (mdpN) side of things needs |
| 93 | * this, the gpu doesn't care about fb's. |
| 94 | */ |
| 95 | int msm_framebuffer_prepare(struct drm_framebuffer *fb, int id) |
| 96 | { |
| 97 | struct msm_framebuffer *msm_fb = to_msm_framebuffer(fb); |
| 98 | int ret, i, n = drm_format_num_planes(fb->pixel_format); |
| 99 | uint32_t iova; |
| 100 | |
| 101 | for (i = 0; i < n; i++) { |
| 102 | ret = msm_gem_get_iova(msm_fb->planes[i], id, &iova); |
| 103 | DBG("FB[%u]: iova[%d]: %08x (%d)", fb->base.id, i, iova, ret); |
| 104 | if (ret) |
| 105 | return ret; |
| 106 | } |
| 107 | |
| 108 | return 0; |
| 109 | } |
| 110 | |
| 111 | void msm_framebuffer_cleanup(struct drm_framebuffer *fb, int id) |
| 112 | { |
| 113 | struct msm_framebuffer *msm_fb = to_msm_framebuffer(fb); |
| 114 | int i, n = drm_format_num_planes(fb->pixel_format); |
| 115 | |
| 116 | for (i = 0; i < n; i++) |
| 117 | msm_gem_put_iova(msm_fb->planes[i], id); |
| 118 | } |
| 119 | |
| 120 | uint32_t msm_framebuffer_iova(struct drm_framebuffer *fb, int id, int plane) |
| 121 | { |
| 122 | struct msm_framebuffer *msm_fb = to_msm_framebuffer(fb); |
Rob Clark | 3e2f29e | 2014-11-19 12:29:33 -0500 | [diff] [blame] | 123 | if (!msm_fb->planes[plane]) |
| 124 | return 0; |
Stephane Viau | f8d9b51 | 2014-12-08 10:48:58 -0500 | [diff] [blame] | 125 | return msm_gem_iova(msm_fb->planes[plane], id) + fb->offsets[plane]; |
Rob Clark | 2638d90 | 2014-11-08 09:13:37 -0500 | [diff] [blame] | 126 | } |
| 127 | |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 128 | struct drm_gem_object *msm_framebuffer_bo(struct drm_framebuffer *fb, int plane) |
| 129 | { |
| 130 | struct msm_framebuffer *msm_fb = to_msm_framebuffer(fb); |
| 131 | return msm_fb->planes[plane]; |
| 132 | } |
| 133 | |
| 134 | const struct msm_format *msm_framebuffer_format(struct drm_framebuffer *fb) |
| 135 | { |
| 136 | struct msm_framebuffer *msm_fb = to_msm_framebuffer(fb); |
| 137 | return msm_fb->format; |
| 138 | } |
| 139 | |
| 140 | struct drm_framebuffer *msm_framebuffer_create(struct drm_device *dev, |
| 141 | struct drm_file *file, struct drm_mode_fb_cmd2 *mode_cmd) |
| 142 | { |
| 143 | struct drm_gem_object *bos[4] = {0}; |
| 144 | struct drm_framebuffer *fb; |
| 145 | int ret, i, n = drm_format_num_planes(mode_cmd->pixel_format); |
| 146 | |
| 147 | for (i = 0; i < n; i++) { |
| 148 | bos[i] = drm_gem_object_lookup(dev, file, |
| 149 | mode_cmd->handles[i]); |
| 150 | if (!bos[i]) { |
| 151 | ret = -ENXIO; |
| 152 | goto out_unref; |
| 153 | } |
| 154 | } |
| 155 | |
| 156 | fb = msm_framebuffer_init(dev, mode_cmd, bos); |
| 157 | if (IS_ERR(fb)) { |
| 158 | ret = PTR_ERR(fb); |
| 159 | goto out_unref; |
| 160 | } |
| 161 | |
| 162 | return fb; |
| 163 | |
| 164 | out_unref: |
| 165 | for (i = 0; i < n; i++) |
| 166 | drm_gem_object_unreference_unlocked(bos[i]); |
| 167 | return ERR_PTR(ret); |
| 168 | } |
| 169 | |
| 170 | struct drm_framebuffer *msm_framebuffer_init(struct drm_device *dev, |
| 171 | struct drm_mode_fb_cmd2 *mode_cmd, struct drm_gem_object **bos) |
| 172 | { |
| 173 | struct msm_drm_private *priv = dev->dev_private; |
| 174 | struct msm_kms *kms = priv->kms; |
| 175 | struct msm_framebuffer *msm_fb; |
| 176 | struct drm_framebuffer *fb = NULL; |
| 177 | const struct msm_format *format; |
| 178 | int ret, i, n; |
| 179 | unsigned int hsub, vsub; |
| 180 | |
| 181 | DBG("create framebuffer: dev=%p, mode_cmd=%p (%dx%d@%4.4s)", |
| 182 | dev, mode_cmd, mode_cmd->width, mode_cmd->height, |
| 183 | (char *)&mode_cmd->pixel_format); |
| 184 | |
| 185 | n = drm_format_num_planes(mode_cmd->pixel_format); |
| 186 | hsub = drm_format_horz_chroma_subsampling(mode_cmd->pixel_format); |
| 187 | vsub = drm_format_vert_chroma_subsampling(mode_cmd->pixel_format); |
| 188 | |
| 189 | format = kms->funcs->get_format(kms, mode_cmd->pixel_format); |
| 190 | if (!format) { |
| 191 | dev_err(dev->dev, "unsupported pixel format: %4.4s\n", |
| 192 | (char *)&mode_cmd->pixel_format); |
| 193 | ret = -EINVAL; |
| 194 | goto fail; |
| 195 | } |
| 196 | |
| 197 | msm_fb = kzalloc(sizeof(*msm_fb), GFP_KERNEL); |
| 198 | if (!msm_fb) { |
| 199 | ret = -ENOMEM; |
| 200 | goto fail; |
| 201 | } |
| 202 | |
| 203 | fb = &msm_fb->base; |
| 204 | |
| 205 | msm_fb->format = format; |
| 206 | |
Rob Clark | 10291bf | 2014-11-08 09:20:28 -0500 | [diff] [blame] | 207 | if (n > ARRAY_SIZE(msm_fb->planes)) { |
| 208 | ret = -EINVAL; |
| 209 | goto fail; |
| 210 | } |
| 211 | |
Rob Clark | c8afe68 | 2013-06-26 12:44:06 -0400 | [diff] [blame] | 212 | for (i = 0; i < n; i++) { |
| 213 | unsigned int width = mode_cmd->width / (i ? hsub : 1); |
| 214 | unsigned int height = mode_cmd->height / (i ? vsub : 1); |
| 215 | unsigned int min_size; |
| 216 | |
| 217 | min_size = (height - 1) * mode_cmd->pitches[i] |
| 218 | + width * drm_format_plane_cpp(mode_cmd->pixel_format, i) |
| 219 | + mode_cmd->offsets[i]; |
| 220 | |
| 221 | if (bos[i]->size < min_size) { |
| 222 | ret = -EINVAL; |
| 223 | goto fail; |
| 224 | } |
| 225 | |
| 226 | msm_fb->planes[i] = bos[i]; |
| 227 | } |
| 228 | |
| 229 | drm_helper_mode_fill_fb_struct(fb, mode_cmd); |
| 230 | |
| 231 | ret = drm_framebuffer_init(dev, fb, &msm_framebuffer_funcs); |
| 232 | if (ret) { |
| 233 | dev_err(dev->dev, "framebuffer init failed: %d\n", ret); |
| 234 | goto fail; |
| 235 | } |
| 236 | |
| 237 | DBG("create: FB ID: %d (%p)", fb->base.id, fb); |
| 238 | |
| 239 | return fb; |
| 240 | |
| 241 | fail: |
| 242 | if (fb) |
| 243 | msm_framebuffer_destroy(fb); |
| 244 | |
| 245 | return ERR_PTR(ret); |
| 246 | } |