drivers/media/platform/rockchip/rga/rga-buf.c

   1 /*
   2  * Copyright (C) 2017 Fuzhou Rockchip Electronics Co.Ltd
   3  * Author: Jacob Chen <jacob-chen@iotwrt.com>
   4  *
   5  * This software is licensed under the terms of the GNU General Public
   6  * License version 2, as published by the Free Software Foundation, and
   7  * may be copied, distributed, and modified under those terms.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  */
  14
  15 #include <linux/pm_runtime.h>
  16
  17 #include <media/v4l2-device.h>
  18 #include <media/v4l2-ioctl.h>
  19 #include <media/v4l2-mem2mem.h>
  20 #include <media/videobuf2-dma-sg.h>
  21 #include <media/videobuf2-v4l2.h>
  22
  23 #include "rga-hw.h"
  24 #include "rga.h"
  25
  26 static int
  27 rga_queue_setup(struct vb2_queue *vq,
  28                 unsigned int *nbuffers, unsigned int *nplanes,
  29                 unsigned int sizes[], struct device *alloc_devs[])
  30 {
  31         struct rga_ctx *ctx = vb2_get_drv_priv(vq);
  32         struct rga_frame *f = rga_get_frame(ctx, vq->type);
  33
  34         if (IS_ERR(f))
  35                 return PTR_ERR(f);
  36
  37         if (*nplanes)
  38                 return sizes[0] < f->size ? -EINVAL : 0;
  39
  40         sizes[0] = f->size;
  41         *nplanes = 1;
  42
  43         return 0;
  44 }
  45
  46 static int rga_buf_prepare(struct vb2_buffer *vb)
  47 {
  48         struct rga_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
  49         struct rga_frame *f = rga_get_frame(ctx, vb->vb2_queue->type);
  50
  51         if (IS_ERR(f))
  52                 return PTR_ERR(f);
  53
  54         vb2_set_plane_payload(vb, 0, f->size);
  55
  56         return 0;
  57 }
  58
  59 static void rga_buf_queue(struct vb2_buffer *vb)
  60 {
  61         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
  62         struct rga_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
  63
  64         v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
  65 }
  66
  67 static void rga_buf_return_buffers(struct vb2_queue *q,
  68                                    enum vb2_buffer_state state)
  69 {
  70         struct rga_ctx *ctx = vb2_get_drv_priv(q);
  71         struct vb2_v4l2_buffer *vbuf;
  72
  73         for (;;) {
  74                 if (V4L2_TYPE_IS_OUTPUT(q->type))
  75                         vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
  76                 else
  77                         vbuf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
  78                 if (!vbuf)
  79                         break;
  80                 v4l2_m2m_buf_done(vbuf, state);
  81         }
  82 }
  83
  84 static int rga_buf_start_streaming(struct vb2_queue *q, unsigned int count)
  85 {
  86         struct rga_ctx *ctx = vb2_get_drv_priv(q);
  87         struct rockchip_rga *rga = ctx->rga;
  88         int ret;
  89
  90         ret = pm_runtime_get_sync(rga->dev);
  91         if (ret < 0) {
  92                 pm_runtime_put_noidle(rga->dev);
  93                 rga_buf_return_buffers(q, VB2_BUF_STATE_QUEUED);
  94                 return ret;
  95         }
  96
  97         return 0;
  98 }
  99
 100 static void rga_buf_stop_streaming(struct vb2_queue *q)
 101 {
 102         struct rga_ctx *ctx = vb2_get_drv_priv(q);
 103         struct rockchip_rga *rga = ctx->rga;
 104
 105         rga_buf_return_buffers(q, VB2_BUF_STATE_ERROR);
 106         pm_runtime_put(rga->dev);
 107 }
 108
 109 const struct vb2_ops rga_qops = {
 110         .queue_setup = rga_queue_setup,
 111         .buf_prepare = rga_buf_prepare,
 112         .buf_queue = rga_buf_queue,
 113         .wait_prepare = vb2_ops_wait_prepare,
 114         .wait_finish = vb2_ops_wait_finish,
 115         .start_streaming = rga_buf_start_streaming,
 116         .stop_streaming = rga_buf_stop_streaming,
 117 };
 118
 119 /* RGA MMU is a 1-Level MMU, so it can't be used through the IOMMU API.
 120  * We use it more like a scatter-gather list.
 121  */
 122 void rga_buf_map(struct vb2_buffer *vb)
 123 {
 124         struct rga_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
 125         struct rockchip_rga *rga = ctx->rga;
 126         struct sg_table *sgt;
 127         struct scatterlist *sgl;
 128         unsigned int *pages;
 129         unsigned int address, len, i, p;
 130         unsigned int mapped_size = 0;
 131
 132         if (vb->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
 133                 pages = rga->src_mmu_pages;
 134         else
 135                 pages = rga->dst_mmu_pages;
 136
 137         /* Create local MMU table for RGA */
 138         sgt = vb2_plane_cookie(vb, 0);
 139
 140         for_each_sg(sgt->sgl, sgl, sgt->nents, i) {
 141                 len = sg_dma_len(sgl) >> PAGE_SHIFT;
 142                 address = sg_phys(sgl);
 143
 144                 for (p = 0; p < len; p++) {
 145                         dma_addr_t phys = address +
 146                                           ((dma_addr_t)p << PAGE_SHIFT);
 147
 148                         pages[mapped_size + p] = phys;
 149                 }
 150
 151                 mapped_size += len;
 152         }
 153
 154         /* sync local MMU table for RGA */
 155         dma_sync_single_for_device(rga->dev, virt_to_phys(pages),
 156                                    8 * PAGE_SIZE, DMA_BIDIRECTIONAL);
 157 }