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