1 /*- 2 * Copyright (c) 2015 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/param.h> 28 #include <sys/systm.h> 29 #include <sys/bus.h> 30 #include <sys/kernel.h> 31 #include <sys/malloc.h> 32 #include <sys/pctrie.h> 33 #include <sys/vmem.h> 34 35 #include <machine/bus.h> 36 37 #include <dev/clk/clk.h> 38 #include <dev/drm2/drmP.h> 39 #include <dev/drm2/drm_crtc_helper.h> 40 #include <dev/drm2/drm_fb_helper.h> 41 42 #include <arm/nvidia/drm2/tegra_drm.h> 43 44 #include <vm/vm.h> 45 #include <vm/vm_pageout.h> 46 #include <vm/vm_radix.h> 47 48 static void 49 tegra_bo_destruct(struct tegra_bo *bo) 50 { 51 struct pctrie_iter pages; 52 vm_page_t m; 53 size_t size; 54 int i; 55 56 if (bo->cdev_pager == NULL) 57 return; 58 59 size = round_page(bo->gem_obj.size); 60 if (bo->vbase != 0) 61 pmap_qremove(bo->vbase, bo->npages); 62 63 vm_page_iter_init(&pages, bo->cdev_pager); 64 VM_OBJECT_WLOCK(bo->cdev_pager); 65 for (i = 0; i < bo->npages; i++) { 66 m = vm_radix_iter_lookup(&pages, i); 67 vm_page_busy_acquire(m, 0); 68 cdev_mgtdev_pager_free_page(&pages, m); 69 m->flags &= ~PG_FICTITIOUS; 70 vm_page_unwire_noq(m); 71 vm_page_free(m); 72 } 73 VM_OBJECT_WUNLOCK(bo->cdev_pager); 74 75 vm_object_deallocate(bo->cdev_pager); 76 if (bo->vbase != 0) 77 vmem_free(kernel_arena, bo->vbase, size); 78 } 79 80 static void 81 tegra_bo_free_object(struct drm_gem_object *gem_obj) 82 { 83 struct tegra_bo *bo; 84 85 bo = container_of(gem_obj, struct tegra_bo, gem_obj); 86 drm_gem_free_mmap_offset(gem_obj); 87 drm_gem_object_release(gem_obj); 88 89 tegra_bo_destruct(bo); 90 91 free(bo->m, DRM_MEM_DRIVER); 92 free(bo, DRM_MEM_DRIVER); 93 } 94 95 static int 96 tegra_bo_alloc_contig(size_t npages, u_long alignment, vm_memattr_t memattr, 97 vm_page_t **ret_page) 98 { 99 vm_page_t m; 100 int err, i, tries; 101 vm_paddr_t low, high, boundary; 102 103 low = 0; 104 high = -1UL; 105 boundary = 0; 106 tries = 0; 107 retry: 108 m = vm_page_alloc_noobj_contig(VM_ALLOC_WIRED | VM_ALLOC_ZERO, npages, 109 low, high, alignment, boundary, memattr); 110 if (m == NULL) { 111 if (tries < 3) { 112 err = vm_page_reclaim_contig(0, npages, low, high, 113 alignment, boundary); 114 if (err == ENOMEM) 115 vm_wait(NULL); 116 else if (err != 0) 117 return (ENOMEM); 118 tries++; 119 goto retry; 120 } 121 return (ENOMEM); 122 } 123 124 for (i = 0; i < npages; i++, m++) { 125 m->valid = VM_PAGE_BITS_ALL; 126 (*ret_page)[i] = m; 127 } 128 129 return (0); 130 } 131 132 /* Initialize pager and insert all object pages to it*/ 133 static int 134 tegra_bo_init_pager(struct tegra_bo *bo) 135 { 136 vm_page_t m; 137 size_t size; 138 int i; 139 140 size = round_page(bo->gem_obj.size); 141 142 bo->pbase = VM_PAGE_TO_PHYS(bo->m[0]); 143 if (vmem_alloc(kernel_arena, size, M_WAITOK | M_BESTFIT, &bo->vbase)) 144 return (ENOMEM); 145 146 VM_OBJECT_WLOCK(bo->cdev_pager); 147 for (i = 0; i < bo->npages; i++) { 148 m = bo->m[i]; 149 /* 150 * XXX This is a temporary hack. 151 * We need pager suitable for paging (mmap) managed 152 * real (non-fictitious) pages. 153 * - managed pages are needed for clean module unload. 154 * - aliasing fictitious page to real one is bad, 155 * pmap cannot handle this situation without issues 156 * It expects that 157 * paddr = PHYS_TO_VM_PAGE(VM_PAGE_TO_PHYS(paddr)) 158 * for every single page passed to pmap. 159 */ 160 m->oflags &= ~VPO_UNMANAGED; 161 m->flags |= PG_FICTITIOUS; 162 if (vm_page_insert(m, bo->cdev_pager, i) != 0) 163 return (EINVAL); 164 } 165 VM_OBJECT_WUNLOCK(bo->cdev_pager); 166 167 pmap_qenter(bo->vbase, bo->m, bo->npages); 168 return (0); 169 } 170 171 /* Allocate memory for frame buffer */ 172 static int 173 tegra_bo_alloc(struct drm_device *drm, struct tegra_bo *bo) 174 { 175 size_t size; 176 int rv; 177 178 size = bo->gem_obj.size; 179 180 bo->npages = atop(size); 181 bo->m = malloc(sizeof(vm_page_t *) * bo->npages, DRM_MEM_DRIVER, 182 M_WAITOK | M_ZERO); 183 184 rv = tegra_bo_alloc_contig(bo->npages, PAGE_SIZE, 185 VM_MEMATTR_WRITE_COMBINING, &(bo->m)); 186 if (rv != 0) { 187 DRM_WARNING("Cannot allocate memory for gem object.\n"); 188 return (rv); 189 } 190 rv = tegra_bo_init_pager(bo); 191 if (rv != 0) { 192 DRM_WARNING("Cannot initialize gem object pager.\n"); 193 return (rv); 194 } 195 return (0); 196 } 197 198 int 199 tegra_bo_create(struct drm_device *drm, size_t size, struct tegra_bo **res_bo) 200 { 201 struct tegra_bo *bo; 202 int rv; 203 204 if (size <= 0) 205 return (-EINVAL); 206 207 bo = malloc(sizeof(*bo), DRM_MEM_DRIVER, M_WAITOK | M_ZERO); 208 209 size = round_page(size); 210 rv = drm_gem_object_init(drm, &bo->gem_obj, size); 211 if (rv != 0) { 212 free(bo, DRM_MEM_DRIVER); 213 return (rv); 214 } 215 rv = drm_gem_create_mmap_offset(&bo->gem_obj); 216 if (rv != 0) { 217 drm_gem_object_release(&bo->gem_obj); 218 free(bo, DRM_MEM_DRIVER); 219 return (rv); 220 } 221 222 bo->cdev_pager = cdev_pager_allocate(&bo->gem_obj, OBJT_MGTDEVICE, 223 drm->driver->gem_pager_ops, size, 0, 0, NULL); 224 rv = tegra_bo_alloc(drm, bo); 225 if (rv != 0) { 226 tegra_bo_free_object(&bo->gem_obj); 227 return (rv); 228 } 229 230 *res_bo = bo; 231 return (0); 232 } 233 234 static int 235 tegra_bo_create_with_handle(struct drm_file *file, struct drm_device *drm, 236 size_t size, uint32_t *handle, struct tegra_bo **res_bo) 237 { 238 int rv; 239 struct tegra_bo *bo; 240 241 rv = tegra_bo_create(drm, size, &bo); 242 if (rv != 0) 243 return (rv); 244 245 rv = drm_gem_handle_create(file, &bo->gem_obj, handle); 246 if (rv != 0) { 247 tegra_bo_free_object(&bo->gem_obj); 248 drm_gem_object_release(&bo->gem_obj); 249 return (rv); 250 } 251 252 drm_gem_object_unreference_unlocked(&bo->gem_obj); 253 254 *res_bo = bo; 255 return (0); 256 } 257 258 static int 259 tegra_bo_dumb_create(struct drm_file *file, struct drm_device *drm_dev, 260 struct drm_mode_create_dumb *args) 261 { 262 struct tegra_drm *drm; 263 struct tegra_bo *bo; 264 int rv; 265 266 drm = container_of(drm_dev, struct tegra_drm, drm_dev); 267 268 args->pitch= (args->width * args->bpp + 7) / 8; 269 args->pitch = roundup(args->pitch, drm->pitch_align); 270 args->size = args->pitch * args->height; 271 rv = tegra_bo_create_with_handle(file, drm_dev, args->size, 272 &args->handle, &bo); 273 274 return (rv); 275 } 276 277 static int 278 tegra_bo_dumb_map_offset(struct drm_file *file_priv, 279 struct drm_device *drm_dev, uint32_t handle, uint64_t *offset) 280 { 281 struct drm_gem_object *gem_obj; 282 int rv; 283 284 DRM_LOCK(drm_dev); 285 gem_obj = drm_gem_object_lookup(drm_dev, file_priv, handle); 286 if (gem_obj == NULL) { 287 device_printf(drm_dev->dev, "Object not found\n"); 288 DRM_UNLOCK(drm_dev); 289 return (-EINVAL); 290 } 291 rv = drm_gem_create_mmap_offset(gem_obj); 292 if (rv != 0) 293 goto fail; 294 295 *offset = DRM_GEM_MAPPING_OFF(gem_obj->map_list.key) | 296 DRM_GEM_MAPPING_KEY; 297 298 drm_gem_object_unreference(gem_obj); 299 DRM_UNLOCK(drm_dev); 300 return (0); 301 302 fail: 303 drm_gem_object_unreference(gem_obj); 304 DRM_UNLOCK(drm_dev); 305 return (rv); 306 } 307 308 static int 309 tegra_bo_dumb_destroy(struct drm_file *file_priv, struct drm_device *drm_dev, 310 unsigned int handle) 311 { 312 int rv; 313 314 rv = drm_gem_handle_delete(file_priv, handle); 315 return (rv); 316 } 317 318 /* 319 * mmap support 320 */ 321 static int 322 tegra_gem_pager_fault(vm_object_t vm_obj, vm_ooffset_t offset, int prot, 323 vm_page_t *mres) 324 { 325 326 #ifdef DRM_PAGER_DEBUG 327 DRM_DEBUG("object %p offset %jd prot %d mres %p\n", 328 vm_obj, (intmax_t)offset, prot, mres); 329 #endif 330 return (VM_PAGER_FAIL); 331 332 } 333 334 static int 335 tegra_gem_pager_ctor(void *handle, vm_ooffset_t size, vm_prot_t prot, 336 vm_ooffset_t foff, struct ucred *cred, u_short *color) 337 { 338 339 if (color != NULL) 340 *color = 0; 341 return (0); 342 } 343 344 static void 345 tegra_gem_pager_dtor(void *handle) 346 { 347 348 } 349 350 static struct cdev_pager_ops tegra_gem_pager_ops = { 351 .cdev_pg_fault = tegra_gem_pager_fault, 352 .cdev_pg_ctor = tegra_gem_pager_ctor, 353 .cdev_pg_dtor = tegra_gem_pager_dtor 354 }; 355 356 /* Fill up relevant fields in drm_driver ops */ 357 void 358 tegra_bo_driver_register(struct drm_driver *drm_drv) 359 { 360 drm_drv->gem_free_object = tegra_bo_free_object; 361 drm_drv->gem_pager_ops = &tegra_gem_pager_ops; 362 drm_drv->dumb_create = tegra_bo_dumb_create; 363 drm_drv->dumb_map_offset = tegra_bo_dumb_map_offset; 364 drm_drv->dumb_destroy = tegra_bo_dumb_destroy; 365 } 366