drivers/media/platform/sti/bdisp/bdisp.h

   1 /*
   2  * Copyright (C) STMicroelectronics SA 2014
   3  * Authors: Fabien Dessenne <fabien.dessenne@st.com> for STMicroelectronics.
   4  * License terms:  GNU General Public License (GPL), version 2
   5  */
   6
   7 #include <linux/clk.h>
   8 #include <linux/ktime.h>
   9 #include <linux/platform_device.h>
  10 #include <linux/spinlock.h>
  11
  12 #include <media/v4l2-ctrls.h>
  13 #include <media/v4l2-device.h>
  14 #include <media/v4l2-mem2mem.h>
  15
  16 #include <media/videobuf2-dma-contig.h>
  17
  18 #define BDISP_NAME              "bdisp"
  19
  20 /*
  21  *  Max nb of nodes in node-list:
  22  *   - 2 nodes to handle wide 4K pictures
  23  *   - 2 nodes to handle two planes (Y & CbCr) */
  24 #define MAX_OUTPUT_PLANES       2
  25 #define MAX_VERTICAL_STRIDES    2
  26 #define MAX_NB_NODE             (MAX_OUTPUT_PLANES * MAX_VERTICAL_STRIDES)
  27
  28 /* struct bdisp_ctrls - bdisp control set
  29  * @hflip:      horizontal flip
  30  * @vflip:      vertical flip
  31  */
  32 struct bdisp_ctrls {
  33         struct v4l2_ctrl        *hflip;
  34         struct v4l2_ctrl        *vflip;
  35 };
  36
  37 /**
  38  * struct bdisp_fmt - driver's internal color format data
  39  * @pixelformat:fourcc code for this format
  40  * @nb_planes:  number of planes  (ex: [0]=RGB/Y - [1]=Cb/Cr, ...)
  41  * @bpp:        bits per pixel (general)
  42  * @bpp_plane0: byte per pixel for the 1st plane
  43  * @w_align:    width alignment in pixel (multiple of)
  44  * @h_align:    height alignment in pixel (multiple of)
  45  */
  46 struct bdisp_fmt {
  47         u32                     pixelformat;
  48         u8                      nb_planes;
  49         u8                      bpp;
  50         u8                      bpp_plane0;
  51         u8                      w_align;
  52         u8                      h_align;
  53 };
  54
  55 /**
  56  * struct bdisp_frame - frame properties
  57  *
  58  * @width:      frame width (including padding)
  59  * @height:     frame height (including padding)
  60  * @fmt:        pointer to frame format descriptor
  61  * @field:      frame / field type
  62  * @bytesperline: stride of the 1st plane
  63  * @sizeimage:  image size in bytes
  64  * @colorspace: colorspace
  65  * @crop:       crop area
  66  * @paddr:      image physical addresses per plane ([0]=RGB/Y - [1]=Cb/Cr, ...)
  67  */
  68 struct bdisp_frame {
  69         u32                     width;
  70         u32                     height;
  71         const struct bdisp_fmt  *fmt;
  72         enum v4l2_field         field;
  73         u32                     bytesperline;
  74         u32                     sizeimage;
  75         enum v4l2_colorspace    colorspace;
  76         struct v4l2_rect        crop;
  77         dma_addr_t              paddr[4];
  78 };
  79
  80 /**
  81  * struct bdisp_request - bdisp request
  82  *
  83  * @src:        source frame properties
  84  * @dst:        destination frame properties
  85  * @hflip:      horizontal flip
  86  * @vflip:      vertical flip
  87  * @nb_req:     number of run request
  88  */
  89 struct bdisp_request {
  90         struct bdisp_frame      src;
  91         struct bdisp_frame      dst;
  92         unsigned int            hflip:1;
  93         unsigned int            vflip:1;
  94         int                     nb_req;
  95 };
  96
  97 /**
  98  * struct bdisp_ctx - device context data
  99  *
 100  * @src:        source frame properties
 101  * @dst:        destination frame properties
 102  * @state:      flags to keep track of user configuration
 103  * @hflip:      horizontal flip
 104  * @vflip:      vertical flip
 105  * @bdisp_dev:  the device this context applies to
 106  * @node:       node array
 107  * @node_paddr: node physical address array
 108  * @fh:         v4l2 file handle
 109  * @ctrl_handler: v4l2 controls handler
 110  * @bdisp_ctrls: bdisp control set
 111  * @ctrls_rdy:  true if the control handler is initialized
 112  */
 113 struct bdisp_ctx {
 114         struct bdisp_frame      src;
 115         struct bdisp_frame      dst;
 116         u32                     state;
 117         unsigned int            hflip:1;
 118         unsigned int            vflip:1;
 119         struct bdisp_dev        *bdisp_dev;
 120         struct bdisp_node       *node[MAX_NB_NODE];
 121         dma_addr_t              node_paddr[MAX_NB_NODE];
 122         struct v4l2_fh          fh;
 123         struct v4l2_ctrl_handler ctrl_handler;
 124         struct bdisp_ctrls      bdisp_ctrls;
 125         bool                    ctrls_rdy;
 126 };
 127
 128 /**
 129  * struct bdisp_m2m_device - v4l2 memory-to-memory device data
 130  *
 131  * @vdev:       video device node for v4l2 m2m mode
 132  * @m2m_dev:    v4l2 m2m device data
 133  * @ctx:        hardware context data
 134  * @refcnt:     reference counter
 135  */
 136 struct bdisp_m2m_device {
 137         struct video_device     *vdev;
 138         struct v4l2_m2m_dev     *m2m_dev;
 139         struct bdisp_ctx        *ctx;
 140         int                     refcnt;
 141 };
 142
 143 /**
 144  * struct bdisp_dev - abstraction for bdisp entity
 145  *
 146  * @v4l2_dev:   v4l2 device
 147  * @vdev:       video device
 148  * @pdev:       platform device
 149  * @dev:        device
 150  * @lock:       mutex protecting this data structure
 151  * @slock:      spinlock protecting this data structure
 152  * @id:         device index
 153  * @m2m:        memory-to-memory V4L2 device information
 154  * @state:      flags used to synchronize m2m and capture mode operation
 155  * @alloc_ctx:  videobuf2 memory allocator context
 156  * @clock:      IP clock
 157  * @regs:       registers
 158  * @irq_queue:  interrupt handler waitqueue
 159  * @work_queue: workqueue to handle timeouts
 160  * @timeout_work: IRQ timeout structure
 161  */
 162 struct bdisp_dev {
 163         struct v4l2_device      v4l2_dev;
 164         struct video_device     vdev;
 165         struct platform_device  *pdev;
 166         struct device           *dev;
 167         spinlock_t              slock;
 168         struct mutex            lock;
 169         u16                     id;
 170         struct bdisp_m2m_device m2m;
 171         unsigned long           state;
 172         struct vb2_alloc_ctx    *alloc_ctx;
 173         struct clk              *clock;
 174         void __iomem            *regs;
 175         wait_queue_head_t       irq_queue;
 176         struct workqueue_struct *work_queue;
 177         struct delayed_work     timeout_work;
 178 };
 179
 180 void bdisp_hw_free_nodes(struct bdisp_ctx *ctx);
 181 int bdisp_hw_alloc_nodes(struct bdisp_ctx *ctx);
 182 void bdisp_hw_free_filters(struct device *dev);
 183 int bdisp_hw_alloc_filters(struct device *dev);
 184 int bdisp_hw_reset(struct bdisp_dev *bdisp);
 185 int bdisp_hw_get_and_clear_irq(struct bdisp_dev *bdisp);
 186 int bdisp_hw_update(struct bdisp_ctx *ctx);