1 /* exynos_drm_fb.c 2 * 3 * Copyright (c) 2011 Samsung Electronics Co., Ltd. 4 * Authors: 5 * Inki Dae <inki.dae@samsung.com> 6 * Joonyoung Shim <jy0922.shim@samsung.com> 7 * Seung-Woo Kim <sw0312.kim@samsung.com> 8 * 9 * This program is free software; you can redistribute it and/or modify it 10 * under the terms of the GNU General Public License as published by the 11 * Free Software Foundation; either version 2 of the License, or (at your 12 * option) any later version. 13 */ 14 15 #include <drm/drmP.h> 16 #include <drm/drm_crtc.h> 17 #include <drm/drm_crtc_helper.h> 18 #include <drm/drm_fb_helper.h> 19 #include <drm/drm_atomic.h> 20 #include <drm/drm_atomic_helper.h> 21 #include <uapi/drm/exynos_drm.h> 22 23 #include "exynos_drm_drv.h" 24 #include "exynos_drm_fb.h" 25 #include "exynos_drm_fbdev.h" 26 #include "exynos_drm_gem.h" 27 #include "exynos_drm_iommu.h" 28 #include "exynos_drm_crtc.h" 29 30 #define to_exynos_fb(x) container_of(x, struct exynos_drm_fb, fb) 31 32 /* 33 * exynos specific framebuffer structure. 34 * 35 * @fb: drm framebuffer obejct. 36 * @buf_cnt: a buffer count to drm framebuffer. 37 * @exynos_gem_obj: array of exynos specific gem object containing a gem object. 38 */ 39 struct exynos_drm_fb { 40 struct drm_framebuffer fb; 41 unsigned int buf_cnt; 42 struct exynos_drm_gem_obj *exynos_gem_obj[MAX_FB_BUFFER]; 43 }; 44 45 static int check_fb_gem_memory_type(struct drm_device *drm_dev, 46 struct exynos_drm_gem_obj *exynos_gem_obj) 47 { 48 unsigned int flags; 49 50 /* 51 * if exynos drm driver supports iommu then framebuffer can use 52 * all the buffer types. 53 */ 54 if (is_drm_iommu_supported(drm_dev)) 55 return 0; 56 57 flags = exynos_gem_obj->flags; 58 59 /* 60 * without iommu support, not support physically non-continuous memory 61 * for framebuffer. 62 */ 63 if (IS_NONCONTIG_BUFFER(flags)) { 64 DRM_ERROR("cannot use this gem memory type for fb.\n"); 65 return -EINVAL; 66 } 67 68 return 0; 69 } 70 71 static void exynos_drm_fb_destroy(struct drm_framebuffer *fb) 72 { 73 struct exynos_drm_fb *exynos_fb = to_exynos_fb(fb); 74 unsigned int i; 75 76 /* make sure that overlay data are updated before relesing fb. */ 77 exynos_drm_crtc_complete_scanout(fb); 78 79 drm_framebuffer_cleanup(fb); 80 81 for (i = 0; i < ARRAY_SIZE(exynos_fb->exynos_gem_obj); i++) { 82 struct drm_gem_object *obj; 83 84 if (exynos_fb->exynos_gem_obj[i] == NULL) 85 continue; 86 87 obj = &exynos_fb->exynos_gem_obj[i]->base; 88 drm_gem_object_unreference_unlocked(obj); 89 } 90 91 kfree(exynos_fb); 92 exynos_fb = NULL; 93 } 94 95 static int exynos_drm_fb_create_handle(struct drm_framebuffer *fb, 96 struct drm_file *file_priv, 97 unsigned int *handle) 98 { 99 struct exynos_drm_fb *exynos_fb = to_exynos_fb(fb); 100 101 /* This fb should have only one gem object. */ 102 if (WARN_ON(exynos_fb->buf_cnt != 1)) 103 return -EINVAL; 104 105 return drm_gem_handle_create(file_priv, 106 &exynos_fb->exynos_gem_obj[0]->base, handle); 107 } 108 109 static int exynos_drm_fb_dirty(struct drm_framebuffer *fb, 110 struct drm_file *file_priv, unsigned flags, 111 unsigned color, struct drm_clip_rect *clips, 112 unsigned num_clips) 113 { 114 /* TODO */ 115 116 return 0; 117 } 118 119 static struct drm_framebuffer_funcs exynos_drm_fb_funcs = { 120 .destroy = exynos_drm_fb_destroy, 121 .create_handle = exynos_drm_fb_create_handle, 122 .dirty = exynos_drm_fb_dirty, 123 }; 124 125 void exynos_drm_fb_set_buf_cnt(struct drm_framebuffer *fb, 126 unsigned int cnt) 127 { 128 struct exynos_drm_fb *exynos_fb; 129 130 exynos_fb = to_exynos_fb(fb); 131 132 exynos_fb->buf_cnt = cnt; 133 } 134 135 unsigned int exynos_drm_fb_get_buf_cnt(struct drm_framebuffer *fb) 136 { 137 struct exynos_drm_fb *exynos_fb; 138 139 exynos_fb = to_exynos_fb(fb); 140 141 return exynos_fb->buf_cnt; 142 } 143 144 struct drm_framebuffer * 145 exynos_drm_framebuffer_init(struct drm_device *dev, 146 struct drm_mode_fb_cmd2 *mode_cmd, 147 struct drm_gem_object *obj) 148 { 149 struct exynos_drm_fb *exynos_fb; 150 struct exynos_drm_gem_obj *exynos_gem_obj; 151 int ret; 152 153 exynos_gem_obj = to_exynos_gem_obj(obj); 154 155 ret = check_fb_gem_memory_type(dev, exynos_gem_obj); 156 if (ret < 0) 157 return ERR_PTR(ret); 158 159 exynos_fb = kzalloc(sizeof(*exynos_fb), GFP_KERNEL); 160 if (!exynos_fb) 161 return ERR_PTR(-ENOMEM); 162 163 drm_helper_mode_fill_fb_struct(&exynos_fb->fb, mode_cmd); 164 exynos_fb->exynos_gem_obj[0] = exynos_gem_obj; 165 166 ret = drm_framebuffer_init(dev, &exynos_fb->fb, &exynos_drm_fb_funcs); 167 if (ret) { 168 kfree(exynos_fb); 169 DRM_ERROR("failed to initialize framebuffer\n"); 170 return ERR_PTR(ret); 171 } 172 173 return &exynos_fb->fb; 174 } 175 176 static struct drm_framebuffer * 177 exynos_user_fb_create(struct drm_device *dev, struct drm_file *file_priv, 178 struct drm_mode_fb_cmd2 *mode_cmd) 179 { 180 struct drm_gem_object *obj; 181 struct exynos_drm_gem_obj *exynos_gem_obj; 182 struct exynos_drm_fb *exynos_fb; 183 int i, ret; 184 185 exynos_fb = kzalloc(sizeof(*exynos_fb), GFP_KERNEL); 186 if (!exynos_fb) 187 return ERR_PTR(-ENOMEM); 188 189 obj = drm_gem_object_lookup(dev, file_priv, mode_cmd->handles[0]); 190 if (!obj) { 191 DRM_ERROR("failed to lookup gem object\n"); 192 ret = -ENOENT; 193 goto err_free; 194 } 195 196 drm_helper_mode_fill_fb_struct(&exynos_fb->fb, mode_cmd); 197 exynos_fb->exynos_gem_obj[0] = to_exynos_gem_obj(obj); 198 exynos_fb->buf_cnt = drm_format_num_planes(mode_cmd->pixel_format); 199 200 DRM_DEBUG_KMS("buf_cnt = %d\n", exynos_fb->buf_cnt); 201 202 for (i = 1; i < exynos_fb->buf_cnt; i++) { 203 obj = drm_gem_object_lookup(dev, file_priv, 204 mode_cmd->handles[i]); 205 if (!obj) { 206 DRM_ERROR("failed to lookup gem object\n"); 207 ret = -ENOENT; 208 exynos_fb->buf_cnt = i; 209 goto err_unreference; 210 } 211 212 exynos_gem_obj = to_exynos_gem_obj(obj); 213 exynos_fb->exynos_gem_obj[i] = exynos_gem_obj; 214 215 ret = check_fb_gem_memory_type(dev, exynos_gem_obj); 216 if (ret < 0) 217 goto err_unreference; 218 } 219 220 ret = drm_framebuffer_init(dev, &exynos_fb->fb, &exynos_drm_fb_funcs); 221 if (ret) { 222 DRM_ERROR("failed to init framebuffer.\n"); 223 goto err_unreference; 224 } 225 226 return &exynos_fb->fb; 227 228 err_unreference: 229 for (i = 0; i < exynos_fb->buf_cnt; i++) { 230 struct drm_gem_object *obj; 231 232 obj = &exynos_fb->exynos_gem_obj[i]->base; 233 if (obj) 234 drm_gem_object_unreference_unlocked(obj); 235 } 236 err_free: 237 kfree(exynos_fb); 238 return ERR_PTR(ret); 239 } 240 241 struct exynos_drm_gem_buf *exynos_drm_fb_buffer(struct drm_framebuffer *fb, 242 int index) 243 { 244 struct exynos_drm_fb *exynos_fb = to_exynos_fb(fb); 245 struct exynos_drm_gem_buf *buffer; 246 247 if (index >= MAX_FB_BUFFER) 248 return NULL; 249 250 buffer = exynos_fb->exynos_gem_obj[index]->buffer; 251 if (!buffer) 252 return NULL; 253 254 DRM_DEBUG_KMS("dma_addr = 0x%lx\n", (unsigned long)buffer->dma_addr); 255 256 return buffer; 257 } 258 259 static void exynos_drm_output_poll_changed(struct drm_device *dev) 260 { 261 struct exynos_drm_private *private = dev->dev_private; 262 struct drm_fb_helper *fb_helper = private->fb_helper; 263 264 if (fb_helper) 265 drm_fb_helper_hotplug_event(fb_helper); 266 else 267 exynos_drm_fbdev_init(dev); 268 } 269 270 static int exynos_atomic_commit(struct drm_device *dev, 271 struct drm_atomic_state *state, 272 bool async) 273 { 274 int ret; 275 276 ret = drm_atomic_helper_prepare_planes(dev, state); 277 if (ret) 278 return ret; 279 280 /* This is the point of no return */ 281 282 drm_atomic_helper_swap_state(dev, state); 283 284 drm_atomic_helper_commit_modeset_disables(dev, state); 285 286 drm_atomic_helper_commit_modeset_enables(dev, state); 287 288 /* 289 * Exynos can't update planes with CRTCs and encoders disabled, 290 * its updates routines, specially for FIMD, requires the clocks 291 * to be enabled. So it is necessary to handle the modeset operations 292 * *before* the commit_planes() step, this way it will always 293 * have the relevant clocks enabled to perform the update. 294 */ 295 296 drm_atomic_helper_commit_planes(dev, state); 297 298 drm_atomic_helper_cleanup_planes(dev, state); 299 300 drm_atomic_state_free(state); 301 302 return 0; 303 } 304 305 static const struct drm_mode_config_funcs exynos_drm_mode_config_funcs = { 306 .fb_create = exynos_user_fb_create, 307 .output_poll_changed = exynos_drm_output_poll_changed, 308 .atomic_check = drm_atomic_helper_check, 309 .atomic_commit = exynos_atomic_commit, 310 }; 311 312 void exynos_drm_mode_config_init(struct drm_device *dev) 313 { 314 dev->mode_config.min_width = 0; 315 dev->mode_config.min_height = 0; 316 317 /* 318 * set max width and height as default value(4096x4096). 319 * this value would be used to check framebuffer size limitation 320 * at drm_mode_addfb(). 321 */ 322 dev->mode_config.max_width = 4096; 323 dev->mode_config.max_height = 4096; 324 325 dev->mode_config.funcs = &exynos_drm_mode_config_funcs; 326 } 327