sys/arm/nvidia/drm2/tegra_bo.c

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