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