Branch data     Line data    Source code

       1                 :            : /*
       2                 :            :  * videobuf2-vmalloc.c - vmalloc memory allocator for videobuf2
       3                 :            :  *
       4                 :            :  * Copyright (C) 2010 Samsung Electronics
       5                 :            :  *
       6                 :            :  * Author: Pawel Osciak <pawel@osciak.com>
       7                 :            :  *
       8                 :            :  * This program is free software; you can redistribute it and/or modify
       9                 :            :  * it under the terms of the GNU General Public License as published by
      10                 :            :  * the Free Software Foundation.
      11                 :            :  */
      12                 :            : 
      13                 :            : #include <linux/io.h>
      14                 :            : #include <linux/module.h>
      15                 :            : #include <linux/mm.h>
      16                 :            : #include <linux/refcount.h>
      17                 :            : #include <linux/sched.h>
      18                 :            : #include <linux/slab.h>
      19                 :            : #include <linux/vmalloc.h>
      20                 :            : 
      21                 :            : #include <media/videobuf2-v4l2.h>
      22                 :            : #include <media/videobuf2-vmalloc.h>
      23                 :            : #include <media/videobuf2-memops.h>
      24                 :            : 
      25                 :            : struct vb2_vmalloc_buf {
      26                 :            :         void                            *vaddr;
      27                 :            :         struct frame_vector             *vec;
      28                 :            :         enum dma_data_direction         dma_dir;
      29                 :            :         unsigned long                   size;
      30                 :            :         refcount_t                      refcount;
      31                 :            :         struct vb2_vmarea_handler       handler;
      32                 :            :         struct dma_buf                  *dbuf;
      33                 :            : };
      34                 :            : 
      35                 :            : static void vb2_vmalloc_put(void *buf_priv);
      36                 :            : 
      37                 :          0 : static void *vb2_vmalloc_alloc(struct device *dev, unsigned long attrs,
      38                 :            :                                unsigned long size, enum dma_data_direction dma_dir,
      39                 :            :                                gfp_t gfp_flags)
      40                 :            : {
      41                 :            :         struct vb2_vmalloc_buf *buf;
      42                 :            : 
      43                 :          0 :         buf = kzalloc(sizeof(*buf), GFP_KERNEL | gfp_flags);
      44                 :          0 :         if (!buf)
      45                 :            :                 return ERR_PTR(-ENOMEM);
      46                 :            : 
      47                 :          0 :         buf->size = size;
      48                 :          0 :         buf->vaddr = vmalloc_user(buf->size);
      49                 :          0 :         if (!buf->vaddr) {
      50                 :            :                 pr_debug("vmalloc of size %ld failed\n", buf->size);
      51                 :          0 :                 kfree(buf);
      52                 :          0 :                 return ERR_PTR(-ENOMEM);
      53                 :            :         }
      54                 :            : 
      55                 :          0 :         buf->dma_dir = dma_dir;
      56                 :          0 :         buf->handler.refcount = &buf->refcount;
      57                 :          0 :         buf->handler.put = vb2_vmalloc_put;
      58                 :          0 :         buf->handler.arg = buf;
      59                 :            : 
      60                 :            :         refcount_set(&buf->refcount, 1);
      61                 :          0 :         return buf;
      62                 :            : }
      63                 :            : 
      64                 :          0 : static void vb2_vmalloc_put(void *buf_priv)
      65                 :            : {
      66                 :            :         struct vb2_vmalloc_buf *buf = buf_priv;
      67                 :            : 
      68                 :          0 :         if (refcount_dec_and_test(&buf->refcount)) {
      69                 :          0 :                 vfree(buf->vaddr);
      70                 :          0 :                 kfree(buf);
      71                 :            :         }
      72                 :          0 : }
      73                 :            : 
      74                 :          0 : static void *vb2_vmalloc_get_userptr(struct device *dev, unsigned long vaddr,
      75                 :            :                                      unsigned long size,
      76                 :            :                                      enum dma_data_direction dma_dir)
      77                 :            : {
      78                 :            :         struct vb2_vmalloc_buf *buf;
      79                 :            :         struct frame_vector *vec;
      80                 :            :         int n_pages, offset, i;
      81                 :            :         int ret = -ENOMEM;
      82                 :            : 
      83                 :          0 :         buf = kzalloc(sizeof(*buf), GFP_KERNEL);
      84                 :          0 :         if (!buf)
      85                 :            :                 return ERR_PTR(-ENOMEM);
      86                 :            : 
      87                 :          0 :         buf->dma_dir = dma_dir;
      88                 :          0 :         offset = vaddr & ~PAGE_MASK;
      89                 :          0 :         buf->size = size;
      90                 :          0 :         vec = vb2_create_framevec(vaddr, size);
      91                 :          0 :         if (IS_ERR(vec)) {
      92                 :            :                 ret = PTR_ERR(vec);
      93                 :          0 :                 goto fail_pfnvec_create;
      94                 :            :         }
      95                 :          0 :         buf->vec = vec;
      96                 :          0 :         n_pages = frame_vector_count(vec);
      97                 :          0 :         if (frame_vector_to_pages(vec) < 0) {
      98                 :            :                 unsigned long *nums = frame_vector_pfns(vec);
      99                 :            : 
     100                 :            :                 /*
     101                 :            :                  * We cannot get page pointers for these pfns. Check memory is
     102                 :            :                  * physically contiguous and use direct mapping.
     103                 :            :                  */
     104                 :          0 :                 for (i = 1; i < n_pages; i++)
     105                 :          0 :                         if (nums[i-1] + 1 != nums[i])
     106                 :            :                                 goto fail_map;
     107                 :          0 :                 buf->vaddr = (__force void *)
     108                 :          0 :                         ioremap_nocache(__pfn_to_phys(nums[0]), size + offset);
     109                 :            :         } else {
     110                 :          0 :                 buf->vaddr = vm_map_ram(frame_vector_pages(vec), n_pages, -1,
     111                 :            :                                         PAGE_KERNEL);
     112                 :            :         }
     113                 :            : 
     114                 :          0 :         if (!buf->vaddr)
     115                 :            :                 goto fail_map;
     116                 :          0 :         buf->vaddr += offset;
     117                 :          0 :         return buf;
     118                 :            : 
     119                 :            : fail_map:
     120                 :          0 :         vb2_destroy_framevec(vec);
     121                 :            : fail_pfnvec_create:
     122                 :          0 :         kfree(buf);
     123                 :            : 
     124                 :          0 :         return ERR_PTR(ret);
     125                 :            : }
     126                 :            : 
     127                 :          0 : static void vb2_vmalloc_put_userptr(void *buf_priv)
     128                 :            : {
     129                 :            :         struct vb2_vmalloc_buf *buf = buf_priv;
     130                 :          0 :         unsigned long vaddr = (unsigned long)buf->vaddr & PAGE_MASK;
     131                 :            :         unsigned int i;
     132                 :            :         struct page **pages;
     133                 :            :         unsigned int n_pages;
     134                 :            : 
     135                 :          0 :         if (!buf->vec->is_pfns) {
     136                 :            :                 n_pages = frame_vector_count(buf->vec);
     137                 :            :                 pages = frame_vector_pages(buf->vec);
     138                 :          0 :                 if (vaddr)
     139                 :          0 :                         vm_unmap_ram((void *)vaddr, n_pages);
     140                 :          0 :                 if (buf->dma_dir == DMA_FROM_DEVICE ||
     141                 :            :                     buf->dma_dir == DMA_BIDIRECTIONAL)
     142                 :          0 :                         for (i = 0; i < n_pages; i++)
     143                 :          0 :                                 set_page_dirty_lock(pages[i]);
     144                 :            :         } else {
     145                 :          0 :                 iounmap((__force void __iomem *)buf->vaddr);
     146                 :            :         }
     147                 :          0 :         vb2_destroy_framevec(buf->vec);
     148                 :          0 :         kfree(buf);
     149                 :          0 : }
     150                 :            : 
     151                 :          0 : static void *vb2_vmalloc_vaddr(void *buf_priv)
     152                 :            : {
     153                 :            :         struct vb2_vmalloc_buf *buf = buf_priv;
     154                 :            : 
     155                 :          0 :         if (!buf->vaddr) {
     156                 :          0 :                 pr_err("Address of an unallocated plane requested or cannot map user pointer\n");
     157                 :          0 :                 return NULL;
     158                 :            :         }
     159                 :            : 
     160                 :            :         return buf->vaddr;
     161                 :            : }
     162                 :            : 
     163                 :          0 : static unsigned int vb2_vmalloc_num_users(void *buf_priv)
     164                 :            : {
     165                 :            :         struct vb2_vmalloc_buf *buf = buf_priv;
     166                 :          0 :         return refcount_read(&buf->refcount);
     167                 :            : }
     168                 :            : 
     169                 :          0 : static int vb2_vmalloc_mmap(void *buf_priv, struct vm_area_struct *vma)
     170                 :            : {
     171                 :            :         struct vb2_vmalloc_buf *buf = buf_priv;
     172                 :            :         int ret;
     173                 :            : 
     174                 :          0 :         if (!buf) {
     175                 :          0 :                 pr_err("No memory to map\n");
     176                 :          0 :                 return -EINVAL;
     177                 :            :         }
     178                 :            : 
     179                 :          0 :         ret = remap_vmalloc_range(vma, buf->vaddr, 0);
     180                 :          0 :         if (ret) {
     181                 :          0 :                 pr_err("Remapping vmalloc memory, error: %d\n", ret);
     182                 :          0 :                 return ret;
     183                 :            :         }
     184                 :            : 
     185                 :            :         /*
     186                 :            :          * Make sure that vm_areas for 2 buffers won't be merged together
     187                 :            :          */
     188                 :          0 :         vma->vm_flags                |= VM_DONTEXPAND;
     189                 :            : 
     190                 :            :         /*
     191                 :            :          * Use common vm_area operations to track buffer refcount.
     192                 :            :          */
     193                 :          0 :         vma->vm_private_data = &buf->handler;
     194                 :          0 :         vma->vm_ops          = &vb2_common_vm_ops;
     195                 :            : 
     196                 :          0 :         vma->vm_ops->open(vma);
     197                 :            : 
     198                 :          0 :         return 0;
     199                 :            : }
     200                 :            : 
     201                 :            : #ifdef CONFIG_HAS_DMA
     202                 :            : /*********************************************/
     203                 :            : /*         DMABUF ops for exporters          */
     204                 :            : /*********************************************/
     205                 :            : 
     206                 :            : struct vb2_vmalloc_attachment {
     207                 :            :         struct sg_table sgt;
     208                 :            :         enum dma_data_direction dma_dir;
     209                 :            : };
     210                 :            : 
     211                 :          0 : static int vb2_vmalloc_dmabuf_ops_attach(struct dma_buf *dbuf,
     212                 :            :         struct dma_buf_attachment *dbuf_attach)
     213                 :            : {
     214                 :            :         struct vb2_vmalloc_attachment *attach;
     215                 :          0 :         struct vb2_vmalloc_buf *buf = dbuf->priv;
     216                 :          0 :         int num_pages = PAGE_ALIGN(buf->size) / PAGE_SIZE;
     217                 :            :         struct sg_table *sgt;
     218                 :            :         struct scatterlist *sg;
     219                 :          0 :         void *vaddr = buf->vaddr;
     220                 :            :         int ret;
     221                 :            :         int i;
     222                 :            : 
     223                 :          0 :         attach = kzalloc(sizeof(*attach), GFP_KERNEL);
     224                 :          0 :         if (!attach)
     225                 :            :                 return -ENOMEM;
     226                 :            : 
     227                 :          0 :         sgt = &attach->sgt;
     228                 :          0 :         ret = sg_alloc_table(sgt, num_pages, GFP_KERNEL);
     229                 :          0 :         if (ret) {
     230                 :          0 :                 kfree(attach);
     231                 :          0 :                 return ret;
     232                 :            :         }
     233                 :          0 :         for_each_sg(sgt->sgl, sg, sgt->nents, i) {
     234                 :          0 :                 struct page *page = vmalloc_to_page(vaddr);
     235                 :            : 
     236                 :          0 :                 if (!page) {
     237                 :          0 :                         sg_free_table(sgt);
     238                 :          0 :                         kfree(attach);
     239                 :          0 :                         return -ENOMEM;
     240                 :            :                 }
     241                 :            :                 sg_set_page(sg, page, PAGE_SIZE, 0);
     242                 :          0 :                 vaddr += PAGE_SIZE;
     243                 :            :         }
     244                 :            : 
     245                 :          0 :         attach->dma_dir = DMA_NONE;
     246                 :          0 :         dbuf_attach->priv = attach;
     247                 :          0 :         return 0;
     248                 :            : }
     249                 :            : 
     250                 :          0 : static void vb2_vmalloc_dmabuf_ops_detach(struct dma_buf *dbuf,
     251                 :            :         struct dma_buf_attachment *db_attach)
     252                 :            : {
     253                 :          0 :         struct vb2_vmalloc_attachment *attach = db_attach->priv;
     254                 :            :         struct sg_table *sgt;
     255                 :            : 
     256                 :          0 :         if (!attach)
     257                 :          0 :                 return;
     258                 :            : 
     259                 :          0 :         sgt = &attach->sgt;
     260                 :            : 
     261                 :            :         /* release the scatterlist cache */
     262                 :          0 :         if (attach->dma_dir != DMA_NONE)
     263                 :          0 :                 dma_unmap_sg(db_attach->dev, sgt->sgl, sgt->orig_nents,
     264                 :            :                         attach->dma_dir);
     265                 :          0 :         sg_free_table(sgt);
     266                 :          0 :         kfree(attach);
     267                 :          0 :         db_attach->priv = NULL;
     268                 :            : }
     269                 :            : 
     270                 :          0 : static struct sg_table *vb2_vmalloc_dmabuf_ops_map(
     271                 :            :         struct dma_buf_attachment *db_attach, enum dma_data_direction dma_dir)
     272                 :            : {
     273                 :          0 :         struct vb2_vmalloc_attachment *attach = db_attach->priv;
     274                 :            :         /* stealing dmabuf mutex to serialize map/unmap operations */
     275                 :          0 :         struct mutex *lock = &db_attach->dmabuf->lock;
     276                 :            :         struct sg_table *sgt;
     277                 :            : 
     278                 :          0 :         mutex_lock(lock);
     279                 :            : 
     280                 :          0 :         sgt = &attach->sgt;
     281                 :            :         /* return previously mapped sg table */
     282                 :          0 :         if (attach->dma_dir == dma_dir) {
     283                 :          0 :                 mutex_unlock(lock);
     284                 :          0 :                 return sgt;
     285                 :            :         }
     286                 :            : 
     287                 :            :         /* release any previous cache */
     288                 :          0 :         if (attach->dma_dir != DMA_NONE) {
     289                 :          0 :                 dma_unmap_sg(db_attach->dev, sgt->sgl, sgt->orig_nents,
     290                 :            :                         attach->dma_dir);
     291                 :          0 :                 attach->dma_dir = DMA_NONE;
     292                 :            :         }
     293                 :            : 
     294                 :            :         /* mapping to the client with new direction */
     295                 :          0 :         sgt->nents = dma_map_sg(db_attach->dev, sgt->sgl, sgt->orig_nents,
     296                 :            :                                 dma_dir);
     297                 :          0 :         if (!sgt->nents) {
     298                 :          0 :                 pr_err("failed to map scatterlist\n");
     299                 :          0 :                 mutex_unlock(lock);
     300                 :          0 :                 return ERR_PTR(-EIO);
     301                 :            :         }
     302                 :            : 
     303                 :          0 :         attach->dma_dir = dma_dir;
     304                 :            : 
     305                 :          0 :         mutex_unlock(lock);
     306                 :            : 
     307                 :          0 :         return sgt;
     308                 :            : }
     309                 :            : 
     310                 :          0 : static void vb2_vmalloc_dmabuf_ops_unmap(struct dma_buf_attachment *db_attach,
     311                 :            :         struct sg_table *sgt, enum dma_data_direction dma_dir)
     312                 :            : {
     313                 :            :         /* nothing to be done here */
     314                 :          0 : }
     315                 :            : 
     316                 :          0 : static void vb2_vmalloc_dmabuf_ops_release(struct dma_buf *dbuf)
     317                 :            : {
     318                 :            :         /* drop reference obtained in vb2_vmalloc_get_dmabuf */
     319                 :          0 :         vb2_vmalloc_put(dbuf->priv);
     320                 :          0 : }
     321                 :            : 
     322                 :          0 : static void *vb2_vmalloc_dmabuf_ops_kmap(struct dma_buf *dbuf, unsigned long pgnum)
     323                 :            : {
     324                 :          0 :         struct vb2_vmalloc_buf *buf = dbuf->priv;
     325                 :            : 
     326                 :          0 :         return buf->vaddr + pgnum * PAGE_SIZE;
     327                 :            : }
     328                 :            : 
     329                 :          0 : static void *vb2_vmalloc_dmabuf_ops_vmap(struct dma_buf *dbuf)
     330                 :            : {
     331                 :          0 :         struct vb2_vmalloc_buf *buf = dbuf->priv;
     332                 :            : 
     333                 :          0 :         return buf->vaddr;
     334                 :            : }
     335                 :            : 
     336                 :          0 : static int vb2_vmalloc_dmabuf_ops_mmap(struct dma_buf *dbuf,
     337                 :            :         struct vm_area_struct *vma)
     338                 :            : {
     339                 :          0 :         return vb2_vmalloc_mmap(dbuf->priv, vma);
     340                 :            : }
     341                 :            : 
     342                 :            : static const struct dma_buf_ops vb2_vmalloc_dmabuf_ops = {
     343                 :            :         .attach = vb2_vmalloc_dmabuf_ops_attach,
     344                 :            :         .detach = vb2_vmalloc_dmabuf_ops_detach,
     345                 :            :         .map_dma_buf = vb2_vmalloc_dmabuf_ops_map,
     346                 :            :         .unmap_dma_buf = vb2_vmalloc_dmabuf_ops_unmap,
     347                 :            :         .map = vb2_vmalloc_dmabuf_ops_kmap,
     348                 :            :         .vmap = vb2_vmalloc_dmabuf_ops_vmap,
     349                 :            :         .mmap = vb2_vmalloc_dmabuf_ops_mmap,
     350                 :            :         .release = vb2_vmalloc_dmabuf_ops_release,
     351                 :            : };
     352                 :            : 
     353                 :          0 : static struct dma_buf *vb2_vmalloc_get_dmabuf(void *buf_priv, unsigned long flags)
     354                 :            : {
     355                 :            :         struct vb2_vmalloc_buf *buf = buf_priv;
     356                 :            :         struct dma_buf *dbuf;
     357                 :          0 :         DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
     358                 :            : 
     359                 :          0 :         exp_info.ops = &vb2_vmalloc_dmabuf_ops;
     360                 :          0 :         exp_info.size = buf->size;
     361                 :          0 :         exp_info.flags = flags;
     362                 :          0 :         exp_info.priv = buf;
     363                 :            : 
     364                 :          0 :         if (WARN_ON(!buf->vaddr))
     365                 :            :                 return NULL;
     366                 :            : 
     367                 :          0 :         dbuf = dma_buf_export(&exp_info);
     368                 :          0 :         if (IS_ERR(dbuf))
     369                 :            :                 return NULL;
     370                 :            : 
     371                 :            :         /* dmabuf keeps reference to vb2 buffer */
     372                 :          0 :         refcount_inc(&buf->refcount);
     373                 :            : 
     374                 :          0 :         return dbuf;
     375                 :            : }
     376                 :            : #endif /* CONFIG_HAS_DMA */
     377                 :            : 
     378                 :            : 
     379                 :            : /*********************************************/
     380                 :            : /*       callbacks for DMABUF buffers        */
     381                 :            : /*********************************************/
     382                 :            : 
     383                 :          0 : static int vb2_vmalloc_map_dmabuf(void *mem_priv)
     384                 :            : {
     385                 :            :         struct vb2_vmalloc_buf *buf = mem_priv;
     386                 :            : 
     387                 :          0 :         buf->vaddr = dma_buf_vmap(buf->dbuf);
     388                 :            : 
     389                 :          0 :         return buf->vaddr ? 0 : -EFAULT;
     390                 :            : }
     391                 :            : 
     392                 :          0 : static void vb2_vmalloc_unmap_dmabuf(void *mem_priv)
     393                 :            : {
     394                 :            :         struct vb2_vmalloc_buf *buf = mem_priv;
     395                 :            : 
     396                 :          0 :         dma_buf_vunmap(buf->dbuf, buf->vaddr);
     397                 :          0 :         buf->vaddr = NULL;
     398                 :          0 : }
     399                 :            : 
     400                 :          0 : static void vb2_vmalloc_detach_dmabuf(void *mem_priv)
     401                 :            : {
     402                 :            :         struct vb2_vmalloc_buf *buf = mem_priv;
     403                 :            : 
     404                 :          0 :         if (buf->vaddr)
     405                 :          0 :                 dma_buf_vunmap(buf->dbuf, buf->vaddr);
     406                 :            : 
     407                 :          0 :         kfree(buf);
     408                 :          0 : }
     409                 :            : 
     410                 :          0 : static void *vb2_vmalloc_attach_dmabuf(struct device *dev, struct dma_buf *dbuf,
     411                 :            :         unsigned long size, enum dma_data_direction dma_dir)
     412                 :            : {
     413                 :            :         struct vb2_vmalloc_buf *buf;
     414                 :            : 
     415                 :          0 :         if (dbuf->size < size)
     416                 :            :                 return ERR_PTR(-EFAULT);
     417                 :            : 
     418                 :          0 :         buf = kzalloc(sizeof(*buf), GFP_KERNEL);
     419                 :          0 :         if (!buf)
     420                 :            :                 return ERR_PTR(-ENOMEM);
     421                 :            : 
     422                 :          0 :         buf->dbuf = dbuf;
     423                 :          0 :         buf->dma_dir = dma_dir;
     424                 :          0 :         buf->size = size;
     425                 :            : 
     426                 :          0 :         return buf;
     427                 :            : }
     428                 :            : 
     429                 :            : 
     430                 :            : const struct vb2_mem_ops vb2_vmalloc_memops = {
     431                 :            :         .alloc          = vb2_vmalloc_alloc,
     432                 :            :         .put            = vb2_vmalloc_put,
     433                 :            :         .get_userptr    = vb2_vmalloc_get_userptr,
     434                 :            :         .put_userptr    = vb2_vmalloc_put_userptr,
     435                 :            : #ifdef CONFIG_HAS_DMA
     436                 :            :         .get_dmabuf     = vb2_vmalloc_get_dmabuf,
     437                 :            : #endif
     438                 :            :         .map_dmabuf     = vb2_vmalloc_map_dmabuf,
     439                 :            :         .unmap_dmabuf   = vb2_vmalloc_unmap_dmabuf,
     440                 :            :         .attach_dmabuf  = vb2_vmalloc_attach_dmabuf,
     441                 :            :         .detach_dmabuf  = vb2_vmalloc_detach_dmabuf,
     442                 :            :         .vaddr          = vb2_vmalloc_vaddr,
     443                 :            :         .mmap           = vb2_vmalloc_mmap,
     444                 :            :         .num_users      = vb2_vmalloc_num_users,
     445                 :            : };
     446                 :            : EXPORT_SYMBOL_GPL(vb2_vmalloc_memops);
     447                 :            : 
     448                 :            : MODULE_DESCRIPTION("vmalloc memory handling routines for videobuf2");
     449                 :            : MODULE_AUTHOR("Pawel Osciak <pawel@osciak.com>");
     450                 :            : MODULE_LICENSE("GPL");