1 /*- 2 * Copyright (c) 2016 Michal Meloun 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 #include <sys/param.h> 31 #include <sys/systm.h> 32 #include <sys/bus.h> 33 #include <sys/kernel.h> 34 #include <sys/malloc.h> 35 36 #include <machine/bus.h> 37 38 #include <dev/extres/clk/clk.h> 39 #include <dev/drm2/drmP.h> 40 #include <dev/drm2/drm_crtc_helper.h> 41 #include <dev/drm2/drm_fb_helper.h> 42 43 #include <arm/nvidia/drm2/tegra_drm.h> 44 45 static void 46 fb_destroy(struct drm_framebuffer *drm_fb) 47 { 48 struct tegra_fb *fb; 49 struct tegra_bo *bo; 50 unsigned int i; 51 52 fb = container_of(drm_fb, struct tegra_fb, drm_fb); 53 for (i = 0; i < fb->nplanes; i++) { 54 bo = fb->planes[i]; 55 if (bo != NULL) 56 drm_gem_object_unreference_unlocked(&bo->gem_obj); 57 } 58 59 drm_framebuffer_cleanup(drm_fb); 60 free(fb->planes, DRM_MEM_DRIVER); 61 } 62 63 static int 64 fb_create_handle(struct drm_framebuffer *drm_fb, struct drm_file *file, 65 unsigned int *handle) 66 { 67 struct tegra_fb *fb; 68 int rv; 69 70 fb = container_of(drm_fb, struct tegra_fb, drm_fb); 71 rv = drm_gem_handle_create(file, &fb->planes[0]->gem_obj, handle); 72 return (rv); 73 } 74 75 /* XXX Probably not needed */ 76 static int 77 fb_dirty(struct drm_framebuffer *fb, struct drm_file *file_priv, 78 unsigned flags, unsigned color, struct drm_clip_rect *clips, unsigned num_clips) 79 { 80 81 return (0); 82 } 83 84 static const struct drm_framebuffer_funcs fb_funcs = { 85 .destroy = fb_destroy, 86 .create_handle = fb_create_handle, 87 .dirty = fb_dirty, 88 }; 89 90 static int 91 fb_alloc(struct drm_device *drm, struct drm_mode_fb_cmd2 *mode_cmd, 92 struct tegra_bo **planes, int num_planes, struct tegra_fb **res_fb) 93 { 94 struct tegra_fb *fb; 95 int i; 96 int rv; 97 98 fb = malloc(sizeof(*fb), DRM_MEM_DRIVER, M_WAITOK | M_ZERO); 99 fb->planes = malloc(num_planes * sizeof(*fb->planes), DRM_MEM_DRIVER, 100 M_WAITOK | M_ZERO); 101 fb->nplanes = num_planes; 102 103 drm_helper_mode_fill_fb_struct(&fb->drm_fb, mode_cmd); 104 for (i = 0; i < fb->nplanes; i++) 105 fb->planes[i] = planes[i]; 106 rv = drm_framebuffer_init(drm, &fb->drm_fb, &fb_funcs); 107 if (rv < 0) { 108 device_printf(drm->dev, 109 "Cannot initialize frame buffer %d\n", rv); 110 free(fb->planes, DRM_MEM_DRIVER); 111 return (rv); 112 } 113 *res_fb = fb; 114 return (0); 115 } 116 117 static int 118 tegra_fb_probe(struct drm_fb_helper *helper, 119 struct drm_fb_helper_surface_size *sizes) 120 { 121 u_int bpp, size; 122 struct tegra_drm *drm; 123 struct tegra_fb *fb; 124 struct fb_info *info; 125 struct tegra_bo *bo; 126 struct drm_mode_fb_cmd2 mode_cmd; 127 struct drm_device *drm_dev; 128 int rv; 129 130 if (helper->fb != NULL) 131 return (0); 132 133 DRM_DEBUG_KMS("surface: %d x %d (bpp: %d)\n", sizes->surface_width, 134 sizes->surface_height, sizes->surface_bpp); 135 136 drm_dev = helper->dev; 137 fb = container_of(helper, struct tegra_fb, fb_helper); 138 drm = container_of(drm_dev, struct tegra_drm, drm_dev); 139 bpp = (sizes->surface_bpp + 7) / 8; 140 141 /* Create mode_cmd */ 142 memset(&mode_cmd, 0, sizeof(mode_cmd)); 143 mode_cmd.width = sizes->surface_width; 144 mode_cmd.height = sizes->surface_height; 145 mode_cmd.pitches[0] = roundup(sizes->surface_width * bpp, 146 drm->pitch_align); 147 mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp, 148 sizes->surface_depth); 149 size = mode_cmd.pitches[0] * mode_cmd.height; 150 151 DRM_LOCK(drm_dev); 152 rv = tegra_bo_create(drm_dev, size, &bo); 153 DRM_UNLOCK(drm_dev); 154 if (rv != 0) 155 return (rv); 156 157 info = framebuffer_alloc(); 158 if (info == NULL) { 159 device_printf(drm_dev->dev, 160 "Cannot allocate DRM framebuffer info.\n"); 161 rv = -ENOMEM; 162 goto err_object; 163 } 164 165 rv = fb_alloc(drm_dev, &mode_cmd, &bo, 1, &fb); 166 if (rv != 0) { 167 device_printf(drm_dev->dev, 168 "Cannot allocate DRM framebuffer.\n"); 169 goto err_fb; 170 } 171 helper->fb = &fb->drm_fb; 172 helper->fbdev = info; 173 174 /* Fill FB info */ 175 info->fb_vbase = bo->vbase; 176 info->fb_pbase = bo->pbase; 177 info->fb_size = size; 178 info->fb_bpp = sizes->surface_bpp; 179 drm_fb_helper_fill_fix(info, fb->drm_fb.pitches[0], fb->drm_fb.depth); 180 drm_fb_helper_fill_var(info, helper, fb->drm_fb.width, 181 fb->drm_fb.height); 182 183 DRM_DEBUG_KMS("allocated %dx%d (s %dbits) fb size: %d, bo %p\n", 184 fb->drm_fb.width, fb->drm_fb.height, fb->drm_fb.depth, 185 size, bo); 186 return (1); 187 err_fb: 188 drm_gem_object_unreference_unlocked(&bo->gem_obj); 189 framebuffer_release(info); 190 err_object: 191 drm_gem_object_release(&bo->gem_obj); 192 return (rv); 193 } 194 195 static struct drm_fb_helper_funcs fb_helper_funcs = { 196 .fb_probe = tegra_fb_probe, 197 }; 198 199 /* 200 * Exported functions 201 */ 202 struct fb_info * 203 tegra_drm_fb_getinfo(struct drm_device *drm_dev) 204 { 205 struct tegra_fb *fb; 206 struct tegra_drm *drm; 207 208 drm = container_of(drm_dev, struct tegra_drm, drm_dev); 209 fb = drm->fb; 210 if (fb == NULL) 211 return (NULL); 212 return (fb->fb_helper.fbdev); 213 } 214 215 struct tegra_bo * 216 tegra_fb_get_plane(struct tegra_fb *fb, int idx) 217 { 218 219 if (idx >= drm_format_num_planes(fb->drm_fb.pixel_format)) 220 return (NULL); 221 if (idx >= fb->nplanes) 222 return (NULL); 223 return (fb->planes[idx]); 224 } 225 226 int 227 tegra_drm_fb_init(struct drm_device *drm_dev) 228 { 229 struct tegra_fb *fb; 230 struct tegra_drm *drm; 231 int rv; 232 233 drm = drm_dev->dev_private; 234 drm = container_of(drm_dev, struct tegra_drm, drm_dev); 235 fb = malloc(sizeof(*fb), DRM_MEM_DRIVER, M_WAITOK | M_ZERO); 236 drm->fb = fb; 237 238 fb->fb_helper.funcs = &fb_helper_funcs; 239 rv = drm_fb_helper_init(drm_dev, &fb->fb_helper, 240 drm_dev->mode_config.num_crtc, drm_dev->mode_config.num_connector); 241 if (rv != 0) { 242 device_printf(drm_dev->dev, 243 "Cannot initialize frame buffer %d\n", rv); 244 return (rv); 245 } 246 247 rv = drm_fb_helper_single_add_all_connectors(&fb->fb_helper); 248 if (rv != 0) { 249 device_printf(drm_dev->dev, "Cannot add all connectors: %d\n", 250 rv); 251 goto err_fini; 252 } 253 254 rv = drm_fb_helper_initial_config(&fb->fb_helper, 32); 255 if (rv != 0) { 256 device_printf(drm_dev->dev, 257 "Cannot set initial config: %d\n", rv); 258 goto err_fini; 259 } 260 /* XXXX Setup initial mode for FB */ 261 /* drm_fb_helper_set_par(fb->fb_helper.fbdev); */ 262 return 0; 263 264 err_fini: 265 drm_fb_helper_fini(&fb->fb_helper); 266 return (rv); 267 } 268 269 int 270 tegra_drm_fb_create(struct drm_device *drm, struct drm_file *file, 271 struct drm_mode_fb_cmd2 *cmd, struct drm_framebuffer **fb_res) 272 { 273 int hsub, vsub, i; 274 int width, height, size, bpp; 275 struct tegra_bo *planes[4]; 276 struct drm_gem_object *gem_obj; 277 struct tegra_fb *fb; 278 int rv, nplanes; 279 280 hsub = drm_format_horz_chroma_subsampling(cmd->pixel_format); 281 vsub = drm_format_vert_chroma_subsampling(cmd->pixel_format); 282 283 nplanes = drm_format_num_planes(cmd->pixel_format); 284 for (i = 0; i < nplanes; i++) { 285 width = cmd->width; 286 height = cmd->height; 287 if (i != 0) { 288 width /= hsub; 289 height /= vsub; 290 } 291 gem_obj = drm_gem_object_lookup(drm, file, cmd->handles[i]); 292 if (gem_obj == NULL) { 293 rv = -ENXIO; 294 goto fail; 295 } 296 297 bpp = drm_format_plane_cpp(cmd->pixel_format, i); 298 size = (height - 1) * cmd->pitches[i] + 299 width * bpp + cmd->offsets[i]; 300 if (gem_obj->size < size) { 301 rv = -EINVAL; 302 goto fail; 303 } 304 planes[i] = container_of(gem_obj, struct tegra_bo, gem_obj); 305 } 306 307 rv = fb_alloc(drm, cmd, planes, nplanes, &fb); 308 if (rv != 0) 309 goto fail; 310 311 *fb_res = &fb->drm_fb; 312 return (0); 313 314 fail: 315 while (i--) 316 drm_gem_object_unreference_unlocked(&planes[i]->gem_obj); 317 return (rv); 318 } 319 320 void 321 tegra_drm_fb_destroy(struct drm_device *drm_dev) 322 { 323 struct fb_info *info; 324 struct tegra_fb *fb; 325 struct tegra_drm *drm; 326 327 drm = container_of(drm_dev, struct tegra_drm, drm_dev); 328 fb = drm->fb; 329 if (fb == NULL) 330 return; 331 info = fb->fb_helper.fbdev; 332 drm_framebuffer_remove(&fb->drm_fb); 333 framebuffer_release(info); 334 drm_fb_helper_fini(&fb->fb_helper); 335 drm_framebuffer_cleanup(&fb->drm_fb); 336 free(fb, DRM_MEM_DRIVER); 337 drm->fb = NULL; 338 } 339