drivers/staging/media/atomisp/pci/atomisp2/css2400/ia_css_frame_public.h

   1 /*
   2  * Support for Intel Camera Imaging ISP subsystem.
   3  * Copyright (c) 2015, Intel Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  */
  14
  15 #ifndef __IA_CSS_FRAME_PUBLIC_H
  16 #define __IA_CSS_FRAME_PUBLIC_H
  17
  18 /* @file
  19  * This file contains structs to describe various frame-formats supported by the ISP.
  20  */
  21
  22 #include <type_support.h>
  23 #include "ia_css_err.h"
  24 #include "ia_css_types.h"
  25 #include "ia_css_frame_format.h"
  26 #include "ia_css_buffer.h"
  27
  28 /* For RAW input, the bayer order needs to be specified separately. There
  29  *  are 4 possible orders. The name is constructed by taking the first two
  30  *  colors on the first line and the first two colors from the second line.
  31  */
  32 enum ia_css_bayer_order {
  33         IA_CSS_BAYER_ORDER_GRBG, /** GRGRGRGRGR .. BGBGBGBGBG */
  34         IA_CSS_BAYER_ORDER_RGGB, /** RGRGRGRGRG .. GBGBGBGBGB */
  35         IA_CSS_BAYER_ORDER_BGGR, /** BGBGBGBGBG .. GRGRGRGRGR */
  36         IA_CSS_BAYER_ORDER_GBRG, /** GBGBGBGBGB .. RGRGRGRGRG */
  37 };
  38 #define IA_CSS_BAYER_ORDER_NUM (IA_CSS_BAYER_ORDER_GBRG + 1)
  39
  40 /* Frame plane structure. This describes one plane in an image
  41  *  frame buffer.
  42  */
  43 struct ia_css_frame_plane {
  44         unsigned int height; /** height of a plane in lines */
  45         unsigned int width;  /** width of a line, in DMA elements, note that
  46                                   for RGB565 the three subpixels are stored in
  47                                   one element. For all other formats this is
  48                                   the number of subpixels per line. */
  49         unsigned int stride; /** stride of a line in bytes */
  50         unsigned int offset; /** offset in bytes to start of frame data.
  51                                   offset is wrt data field in ia_css_frame */
  52 };
  53
  54 /* Binary "plane". This is used to story binary streams such as jpeg
  55  *  images. This is not actually a real plane.
  56  */
  57 struct ia_css_frame_binary_plane {
  58         unsigned int              size; /** number of bytes in the stream */
  59         struct ia_css_frame_plane data; /** plane */
  60 };
  61
  62 /* Container for planar YUV frames. This contains 3 planes.
  63  */
  64 struct ia_css_frame_yuv_planes {
  65         struct ia_css_frame_plane y; /** Y plane */
  66         struct ia_css_frame_plane u; /** U plane */
  67         struct ia_css_frame_plane v; /** V plane */
  68 };
  69
  70 /* Container for semi-planar YUV frames.
  71   */
  72 struct ia_css_frame_nv_planes {
  73         struct ia_css_frame_plane y;  /** Y plane */
  74         struct ia_css_frame_plane uv; /** UV plane */
  75 };
  76
  77 /* Container for planar RGB frames. Each color has its own plane.
  78  */
  79 struct ia_css_frame_rgb_planes {
  80         struct ia_css_frame_plane r; /** Red plane */
  81         struct ia_css_frame_plane g; /** Green plane */
  82         struct ia_css_frame_plane b; /** Blue plane */
  83 };
  84
  85 /* Container for 6-plane frames. These frames are used internally
  86  *  in the advanced ISP only.
  87  */
  88 struct ia_css_frame_plane6_planes {
  89         struct ia_css_frame_plane r;      /** Red plane */
  90         struct ia_css_frame_plane r_at_b; /** Red at blue plane */
  91         struct ia_css_frame_plane gr;     /** Red-green plane */
  92         struct ia_css_frame_plane gb;     /** Blue-green plane */
  93         struct ia_css_frame_plane b;      /** Blue plane */
  94         struct ia_css_frame_plane b_at_r; /** Blue at red plane */
  95 };
  96
  97 /* Crop info struct - stores the lines to be cropped in isp */
  98 struct ia_css_crop_info {
  99         /* the final start column and start line
 100          * sum of lines to be cropped + bayer offset
 101          */
 102         unsigned int start_column;
 103         unsigned int start_line;
 104 };
 105
 106 /* Frame info struct. This describes the contents of an image frame buffer.
 107   */
 108 struct ia_css_frame_info {
 109         struct ia_css_resolution res; /** Frame resolution (valid data) */
 110         unsigned int padded_width; /** stride of line in memory (in pixels) */
 111         enum ia_css_frame_format format; /** format of the frame data */
 112         unsigned int raw_bit_depth; /** number of valid bits per pixel,
 113                                          only valid for RAW bayer frames */
 114         enum ia_css_bayer_order raw_bayer_order; /** bayer order, only valid
 115                                                       for RAW bayer frames */
 116         /* the params below are computed based on bayer_order
 117          * we can remove the raw_bayer_order if it is redundant
 118          * keeping it for now as bxt and fpn code seem to use it
 119          */
 120         struct ia_css_crop_info crop_info;
 121 };
 122
 123 #define IA_CSS_BINARY_DEFAULT_FRAME_INFO \
 124 (struct ia_css_frame_info) { \
 125         .format                 = IA_CSS_FRAME_FORMAT_NUM,  \
 126         .raw_bayer_order        = IA_CSS_BAYER_ORDER_NUM, \
 127 }
 128
 129 /**
 130  *  Specifies the DVS loop delay in "frame periods"
 131  */
 132 enum ia_css_frame_delay {
 133         IA_CSS_FRAME_DELAY_0, /** Frame delay = 0 */
 134         IA_CSS_FRAME_DELAY_1, /** Frame delay = 1 */
 135         IA_CSS_FRAME_DELAY_2  /** Frame delay = 2 */
 136 };
 137
 138 enum ia_css_frame_flash_state {
 139         IA_CSS_FRAME_FLASH_STATE_NONE,
 140         IA_CSS_FRAME_FLASH_STATE_PARTIAL,
 141         IA_CSS_FRAME_FLASH_STATE_FULL
 142 };
 143
 144 /* Frame structure. This structure describes an image buffer or frame.
 145  *  This is the main structure used for all input and output images.
 146  */
 147 struct ia_css_frame {
 148         struct ia_css_frame_info info; /** info struct describing the frame */
 149         ia_css_ptr   data;             /** pointer to start of image data */
 150         unsigned int data_bytes;       /** size of image data in bytes */
 151         /* LA: move this to ia_css_buffer */
 152         /*
 153          * -1 if data address is static during life time of pipeline
 154          * >=0 if data address can change per pipeline/frame iteration
 155          *     index to dynamic data: ia_css_frame_in, ia_css_frame_out
 156          *                            ia_css_frame_out_vf
 157          *     index to host-sp queue id: queue_0, queue_1 etc.
 158          */
 159         int dynamic_queue_id;
 160         /*
 161          * if it is dynamic frame, buf_type indicates which buffer type it
 162          * should use for event generation. we have this because in vf_pp
 163          * binary, we use output port, but we expect VF_OUTPUT_DONE event
 164          */
 165         enum ia_css_buffer_type buf_type;
 166         enum ia_css_frame_flash_state flash_state;
 167         unsigned int exp_id;
 168         /** exposure id, see ia_css_event_public.h for more detail */
 169         uint32_t isp_config_id; /** Unique ID to track which config was actually applied to a particular frame */
 170         bool valid; /** First video output frame is not valid */
 171         bool contiguous; /** memory is allocated physically contiguously */
 172         union {
 173                 unsigned int    _initialisation_dummy;
 174                 struct ia_css_frame_plane raw;
 175                 struct ia_css_frame_plane rgb;
 176                 struct ia_css_frame_rgb_planes planar_rgb;
 177                 struct ia_css_frame_plane yuyv;
 178                 struct ia_css_frame_yuv_planes yuv;
 179                 struct ia_css_frame_nv_planes nv;
 180                 struct ia_css_frame_plane6_planes plane6;
 181                 struct ia_css_frame_binary_plane binary;
 182         } planes; /** frame planes, select the right one based on
 183                        info.format */
 184 };
 185
 186 #define DEFAULT_FRAME \
 187 (struct ia_css_frame) { \
 188         .info                   = IA_CSS_BINARY_DEFAULT_FRAME_INFO, \
 189         .dynamic_queue_id       = SH_CSS_INVALID_QUEUE_ID, \
 190         .buf_type               = IA_CSS_BUFFER_TYPE_INVALID, \
 191         .flash_state            = IA_CSS_FRAME_FLASH_STATE_NONE, \
 192 }
 193
 194 /* @brief Fill a frame with zeros
 195  *
 196  * @param       frame           The frame.
 197  * @return      None
 198  *
 199  * Fill a frame with pixel values of zero
 200  */
 201 void ia_css_frame_zero(struct ia_css_frame *frame);
 202
 203 /* @brief Allocate a CSS frame structure
 204  *
 205  * @param       frame           The allocated frame.
 206  * @param       width           The width (in pixels) of the frame.
 207  * @param       height          The height (in lines) of the frame.
 208  * @param       format          The frame format.
 209  * @param       stride          The padded stride, in pixels.
 210  * @param       raw_bit_depth   The raw bit depth, in bits.
 211  * @return                      The error code.
 212  *
 213  * Allocate a CSS frame structure. The memory for the frame data will be
 214  * allocated in the CSS address space.
 215  */
 216 enum ia_css_err
 217 ia_css_frame_allocate(struct ia_css_frame **frame,
 218                       unsigned int width,
 219                       unsigned int height,
 220                       enum ia_css_frame_format format,
 221                       unsigned int stride,
 222                       unsigned int raw_bit_depth);
 223
 224 /* @brief Allocate a CSS frame structure using a frame info structure.
 225  *
 226  * @param       frame   The allocated frame.
 227  * @param[in]   info    The frame info structure.
 228  * @return              The error code.
 229  *
 230  * Allocate a frame using the resolution and format from a frame info struct.
 231  * This is a convenience function, implemented on top of
 232  * ia_css_frame_allocate().
 233  */
 234 enum ia_css_err
 235 ia_css_frame_allocate_from_info(struct ia_css_frame **frame,
 236                                 const struct ia_css_frame_info *info);
 237 /* @brief Free a CSS frame structure.
 238  *
 239  * @param[in]   frame   Pointer to the frame.
 240  * @return      None
 241  *
 242  * Free a CSS frame structure. This will free both the frame structure
 243  * and the pixel data pointer contained within the frame structure.
 244  */
 245 void
 246 ia_css_frame_free(struct ia_css_frame *frame);
 247
 248 /* @brief Allocate a contiguous CSS frame structure
 249  *
 250  * @param       frame           The allocated frame.
 251  * @param       width           The width (in pixels) of the frame.
 252  * @param       height          The height (in lines) of the frame.
 253  * @param       format          The frame format.
 254  * @param       stride          The padded stride, in pixels.
 255  * @param       raw_bit_depth   The raw bit depth, in bits.
 256  * @return                      The error code.
 257  *
 258  * Contiguous frame allocation, only for FPGA display driver which needs
 259  * physically contiguous memory.
 260  * Deprecated.
 261  */
 262 enum ia_css_err
 263 ia_css_frame_allocate_contiguous(struct ia_css_frame **frame,
 264                                  unsigned int width,
 265                                  unsigned int height,
 266                                  enum ia_css_frame_format format,
 267                                  unsigned int stride,
 268                                  unsigned int raw_bit_depth);
 269
 270 /* @brief Allocate a contiguous CSS frame from a frame info structure.
 271  *
 272  * @param       frame   The allocated frame.
 273  * @param[in]   info    The frame info structure.
 274  * @return              The error code.
 275  *
 276  * Allocate a frame using the resolution and format from a frame info struct.
 277  * This is a convenience function, implemented on top of
 278  * ia_css_frame_allocate_contiguous().
 279  * Only for FPGA display driver which needs physically contiguous memory.
 280  * Deprecated.
 281  */
 282 enum ia_css_err
 283 ia_css_frame_allocate_contiguous_from_info(struct ia_css_frame **frame,
 284                                           const struct ia_css_frame_info *info);
 285
 286 /* @brief Allocate a CSS frame structure using a frame info structure.
 287  *
 288  * @param       frame   The allocated frame.
 289  * @param[in]   info    The frame info structure.
 290  * @return              The error code.
 291  *
 292  * Allocate an empty CSS frame with no data buffer using the parameters
 293  * in the frame info.
 294  */
 295 enum ia_css_err
 296 ia_css_frame_create_from_info(struct ia_css_frame **frame,
 297         const struct ia_css_frame_info *info);
 298
 299 /* @brief Set a mapped data buffer to a CSS frame
 300  *
 301  * @param[in]   frame       Valid CSS frame pointer
 302  * @param[in]   mapped_data  Mapped data buffer to be assigned to the CSS frame
 303  * @param[in]   data_size_bytes  Size of the mapped_data in bytes
 304  * @return      The error code.
 305  *
 306  * Sets a mapped data buffer to this frame. This function can be called multiple
 307  * times with different buffers or NULL to reset the data pointer. This API
 308  * would not try free the mapped_data and its the callers responsiblity to
 309  * free the mapped_data buffer. However if ia_css_frame_free() is called and
 310  * the frame had a valid data buffer, it would be freed along with the frame.
 311  */
 312 enum ia_css_err
 313 ia_css_frame_set_data(struct ia_css_frame *frame,
 314         const ia_css_ptr   mapped_data,
 315         size_t data_size_bytes);
 316
 317 /* @brief Map an existing frame data pointer to a CSS frame.
 318  *
 319  * @param       frame           Pointer to the frame to be initialized
 320  * @param[in]   info            The frame info.
 321  * @param[in]   data            Pointer to the allocated frame data.
 322  * @param[in]   attribute       Attributes to be passed to mmgr_mmap.
 323  * @param[in]   context         Pointer to the a context to be passed to mmgr_mmap.
 324  * @return                      The allocated frame structure.
 325  *
 326  * This function maps a pre-allocated pointer into a CSS frame. This can be
 327  * used when an upper software layer is responsible for allocating the frame
 328  * data and it wants to share that frame pointer with the CSS code.
 329  * This function will fill the CSS frame structure just like
 330  * ia_css_frame_allocate() does, but instead of allocating the memory, it will
 331  * map the pre-allocated memory into the CSS address space.
 332  */
 333 enum ia_css_err
 334 ia_css_frame_map(struct ia_css_frame **frame,
 335                  const struct ia_css_frame_info *info,
 336                  const void *data,
 337                  uint16_t attribute,
 338                  void *context);
 339
 340 /* @brief Unmap a CSS frame structure.
 341  *
 342  * @param[in]   frame   Pointer to the CSS frame.
 343  * @return      None
 344  *
 345  * This function unmaps the frame data pointer within a CSS frame and
 346  * then frees the CSS frame structure. Use this for frame pointers created
 347  * using ia_css_frame_map().
 348  */
 349 void
 350 ia_css_frame_unmap(struct ia_css_frame *frame);
 351
 352 #endif /* __IA_CSS_FRAME_PUBLIC_H */