tegra_bo.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    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                 vm_page_busy_acquire(m, 0);
   68                 cdev_pager_free_page(bo->cdev_pager, 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(kmem_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 tries, i;
  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                         if (!vm_page_reclaim_contig(0, npages, low, high,
  113                             alignment, boundary))
  114                                 vm_wait(NULL);
  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 }
Cache object: 27b18552d611f0b0f9180370f409f915
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/arm/nvidia/drm2/tegra_bo.c

FreeBSD/Linux Kernel Cross Reference
sys/arm/nvidia/drm2/tegra_bo.c
