| /* SPDX-License-Identifier: GPL-2.0 */ |
| /* |
| * Support for Intel Camera Imaging ISP subsystem. |
| * Copyright (c) 2015, Intel Corporation. |
| * |
| * This program is free software; you can redistribute it and/or modify it |
| * under the terms and conditions of the GNU General Public License, |
| * version 2, as published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| * more details. |
| */ |
| |
| #ifndef __IA_CSS_STREAM_PUBLIC_H |
| #define __IA_CSS_STREAM_PUBLIC_H |
| |
| /* @file |
| * This file contains support for configuring and controlling streams |
| */ |
| |
| #include <type_support.h> |
| #include "ia_css_types.h" |
| #include "ia_css_pipe_public.h" |
| #include "ia_css_metadata.h" |
| #include "ia_css_tpg.h" |
| #include "ia_css_prbs.h" |
| #include "ia_css_input_port.h" |
| |
| /* Input modes, these enumerate all supported input modes. |
| * Note that not all ISP modes support all input modes. |
| */ |
| enum ia_css_input_mode { |
| IA_CSS_INPUT_MODE_SENSOR, /** data from sensor */ |
| IA_CSS_INPUT_MODE_FIFO, /** data from input-fifo */ |
| IA_CSS_INPUT_MODE_TPG, /** data from test-pattern generator */ |
| IA_CSS_INPUT_MODE_PRBS, /** data from pseudo-random bit stream */ |
| IA_CSS_INPUT_MODE_MEMORY, /** data from a frame in memory */ |
| IA_CSS_INPUT_MODE_BUFFERED_SENSOR /** data is sent through mipi buffer */ |
| }; |
| |
| /* Structure of the MIPI buffer configuration |
| */ |
| struct ia_css_mipi_buffer_config { |
| unsigned int size_mem_words; /** The frame size in the system memory |
| words (32B) */ |
| bool contiguous; /** Allocated memory physically |
| contiguously or not. \deprecated{Will be false always.}*/ |
| unsigned int nof_mipi_buffers; /** The number of MIPI buffers required for this |
| stream */ |
| }; |
| |
| enum { |
| IA_CSS_STREAM_ISYS_STREAM_0 = 0, |
| IA_CSS_STREAM_DEFAULT_ISYS_STREAM_IDX = IA_CSS_STREAM_ISYS_STREAM_0, |
| IA_CSS_STREAM_ISYS_STREAM_1, |
| IA_CSS_STREAM_MAX_ISYS_STREAM_PER_CH |
| }; |
| |
| /* This is input data configuration for one MIPI data type. We can have |
| * multiple of this in one virtual channel. |
| */ |
| struct ia_css_stream_isys_stream_config { |
| struct ia_css_resolution input_res; /** Resolution of input data */ |
| enum atomisp_input_format format; /** Format of input stream. This data |
| format will be mapped to MIPI data |
| type internally. */ |
| int linked_isys_stream_id; /** default value is -1, other value means |
| current isys_stream shares the same buffer with |
| indicated isys_stream*/ |
| bool valid; /** indicate whether other fields have valid value */ |
| }; |
| |
| struct ia_css_stream_input_config { |
| struct ia_css_resolution input_res; /** Resolution of input data */ |
| struct ia_css_resolution effective_res; /** Resolution of input data. |
| Used for CSS 2400/1 System and deprecated for other |
| systems (replaced by input_effective_res in |
| ia_css_pipe_config) */ |
| enum atomisp_input_format format; /** Format of input stream. This data |
| format will be mapped to MIPI data |
| type internally. */ |
| enum ia_css_bayer_order bayer_order; /** Bayer order for RAW streams */ |
| }; |
| |
| /* Input stream description. This describes how input will flow into the |
| * CSS. This is used to program the CSS hardware. |
| */ |
| struct ia_css_stream_config { |
| enum ia_css_input_mode mode; /** Input mode */ |
| union { |
| struct ia_css_input_port port; /** Port, for sensor only. */ |
| struct ia_css_tpg_config tpg; /** TPG configuration */ |
| struct ia_css_prbs_config prbs; /** PRBS configuration */ |
| } source; /** Source of input data */ |
| unsigned int channel_id; /** Channel on which input data |
| will arrive. Use this field |
| to specify virtual channel id. |
| Valid values are: 0, 1, 2, 3 */ |
| struct ia_css_stream_isys_stream_config |
| isys_config[IA_CSS_STREAM_MAX_ISYS_STREAM_PER_CH]; |
| struct ia_css_stream_input_config input_config; |
| |
| /* Currently, Android and Windows platforms interpret the binning_factor parameter |
| * differently. In Android, the binning factor is expressed in the form |
| * 2^N * 2^N, whereas in Windows platform, the binning factor is N*N |
| * To use the Windows method of specification, the caller has to define |
| * macro USE_WINDOWS_BINNING_FACTOR. This is for backward compatibility only |
| * and will be deprecated. In the future,all platforms will use the N*N method |
| */ |
| /* ISP2401 */ |
| unsigned int sensor_binning_factor; /** Binning factor used by sensor |
| to produce image data. This is |
| used for shading correction. */ |
| unsigned int pixels_per_clock; /** Number of pixels per clock, which can be |
| 1, 2 or 4. */ |
| bool online; /** offline will activate RAW copy on SP, use this for |
| continuous capture. */ |
| /* ISYS2401 usage: ISP receives data directly from sensor, no copy. */ |
| unsigned int init_num_cont_raw_buf; /** initial number of raw buffers to |
| allocate */ |
| unsigned int target_num_cont_raw_buf; /** total number of raw buffers to |
| allocate */ |
| bool pack_raw_pixels; /** Pack pixels in the raw buffers */ |
| bool continuous; /** Use SP copy feature to continuously capture frames |
| to system memory and run pipes in offline mode */ |
| bool disable_cont_viewfinder; /** disable continuous viewfinder for ZSL use case */ |
| s32 flash_gpio_pin; /** pin on which the flash is connected, -1 for no flash */ |
| int left_padding; /** The number of input-formatter left-paddings, -1 for default from binary.*/ |
| struct ia_css_mipi_buffer_config |
| mipi_buffer_config; /** mipi buffer configuration */ |
| struct ia_css_metadata_config |
| metadata_config; /** Metadata configuration. */ |
| bool ia_css_enable_raw_buffer_locking; /** Enable Raw Buffer Locking for HALv3 Support */ |
| bool lock_all; |
| /** Lock all RAW buffers (true) or lock only buffers processed by |
| video or preview pipe (false). |
| This setting needs to be enabled to allow raw buffer locking |
| without continuous viewfinder. */ |
| }; |
| |
| struct ia_css_stream; |
| |
| /* Stream info, this struct describes properties of a stream after it has been |
| * created. |
| */ |
| struct ia_css_stream_info { |
| struct ia_css_metadata_info metadata_info; |
| /** Info about the metadata layout, this contains the stride. */ |
| }; |
| |
| /* @brief Load default stream configuration |
| * @param[in,out] stream_config The stream configuration. |
| * @return None |
| * |
| * This function will reset the stream configuration to the default state: |
| @code |
| memset(stream_config, 0, sizeof(*stream_config)); |
| stream_config->online = true; |
| stream_config->left_padding = -1; |
| @endcode |
| */ |
| void ia_css_stream_config_defaults(struct ia_css_stream_config *stream_config); |
| |
| /* |
| * create the internal structures and fill in the configuration data and pipes |
| */ |
| |
| /* @brief Creates a stream |
| * @param[in] stream_config The stream configuration. |
| * @param[in] num_pipes The number of pipes to incorporate in the stream. |
| * @param[in] pipes The pipes. |
| * @param[out] stream The stream. |
| * @return 0 or the error code. |
| * |
| * This function will create a stream with a given configuration and given pipes. |
| */ |
| int |
| ia_css_stream_create(const struct ia_css_stream_config *stream_config, |
| int num_pipes, |
| struct ia_css_pipe *pipes[], |
| struct ia_css_stream **stream); |
| |
| /* @brief Destroys a stream |
| * @param[in] stream The stream. |
| * @return 0 or the error code. |
| * |
| * This function will destroy a given stream. |
| */ |
| int |
| ia_css_stream_destroy(struct ia_css_stream *stream); |
| |
| /* @brief Provides information about a stream |
| * @param[in] stream The stream. |
| * @param[out] stream_info The information about the stream. |
| * @return 0 or the error code. |
| * |
| * This function will destroy a given stream. |
| */ |
| int |
| ia_css_stream_get_info(const struct ia_css_stream *stream, |
| struct ia_css_stream_info *stream_info); |
| |
| /* @brief load (rebuild) a stream that was unloaded. |
| * @param[in] stream The stream |
| * @return 0 or the error code |
| * |
| * Rebuild a stream, including allocating structs, setting configuration and |
| * building the required pipes. |
| */ |
| int |
| ia_css_stream_load(struct ia_css_stream *stream); |
| |
| /* @brief Starts the stream. |
| * @param[in] stream The stream. |
| * @return 0 or the error code. |
| * |
| * The dynamic data in |
| * the buffers are not used and need to be queued with a separate call |
| * to ia_css_pipe_enqueue_buffer. |
| * NOTE: this function will only send start event to corresponding |
| * thread and will not start SP any more. |
| */ |
| int |
| ia_css_stream_start(struct ia_css_stream *stream); |
| |
| /* @brief Stop the stream. |
| * @param[in] stream The stream. |
| * @return 0 or the error code. |
| * |
| * NOTE: this function will send stop event to pipes belong to this |
| * stream but will not terminate threads. |
| */ |
| int |
| ia_css_stream_stop(struct ia_css_stream *stream); |
| |
| /* @brief Check if a stream has stopped |
| * @param[in] stream The stream. |
| * @return boolean flag |
| * |
| * This function will check if the stream has stopped and return the correspondent boolean flag. |
| */ |
| bool |
| ia_css_stream_has_stopped(struct ia_css_stream *stream); |
| |
| /* @brief destroy a stream according to the stream seed previosly saved in the seed array. |
| * @param[in] stream The stream. |
| * @return 0 (no other errors are generated now) |
| * |
| * Destroy the stream and all the pipes related to it. |
| */ |
| int |
| ia_css_stream_unload(struct ia_css_stream *stream); |
| |
| /* @brief Returns stream format |
| * @param[in] stream The stream. |
| * @return format of the string |
| * |
| * This function will return the stream format. |
| */ |
| enum atomisp_input_format |
| ia_css_stream_get_format(const struct ia_css_stream *stream); |
| |
| /* @brief Check if the stream is configured for 2 pixels per clock |
| * @param[in] stream The stream. |
| * @return boolean flag |
| * |
| * This function will check if the stream is configured for 2 pixels per clock and |
| * return the correspondent boolean flag. |
| */ |
| bool |
| ia_css_stream_get_two_pixels_per_clock(const struct ia_css_stream *stream); |
| |
| /* @brief Sets the output frame stride (at the last pipe) |
| * @param[in] stream The stream |
| * @param[in] output_padded_width - the output buffer stride. |
| * @return ia_css_err |
| * |
| * This function will Set the output frame stride (at the last pipe) |
| */ |
| int |
| ia_css_stream_set_output_padded_width(struct ia_css_stream *stream, |
| unsigned int output_padded_width); |
| |
| /* @brief Return max number of continuous RAW frames. |
| * @param[in] stream The stream. |
| * @param[out] buffer_depth The maximum number of continuous RAW frames. |
| * @return 0 or -EINVAL |
| * |
| * This function will return the maximum number of continuous RAW frames |
| * the system can support. |
| */ |
| int |
| ia_css_stream_get_max_buffer_depth(struct ia_css_stream *stream, |
| int *buffer_depth); |
| |
| /* @brief Set nr of continuous RAW frames to use. |
| * |
| * @param[in] stream The stream. |
| * @param[in] buffer_depth Number of frames to set. |
| * @return 0 or error code upon error. |
| * |
| * Set the number of continuous frames to use during continuous modes. |
| */ |
| int |
| ia_css_stream_set_buffer_depth(struct ia_css_stream *stream, int buffer_depth); |
| |
| /* @brief Get number of continuous RAW frames to use. |
| * @param[in] stream The stream. |
| * @param[out] buffer_depth The number of frames to use |
| * @return 0 or -EINVAL |
| * |
| * Get the currently set number of continuous frames |
| * to use during continuous modes. |
| */ |
| int |
| ia_css_stream_get_buffer_depth(struct ia_css_stream *stream, int *buffer_depth); |
| |
| /* ===== CAPTURE ===== */ |
| |
| /* @brief Configure the continuous capture |
| * |
| * @param[in] stream The stream. |
| * @param[in] num_captures The number of RAW frames to be processed to |
| * YUV. Setting this to -1 will make continuous |
| * capture run until it is stopped. |
| * This number will also be used to allocate RAW |
| * buffers. To allow the viewfinder to also |
| * keep operating, 2 extra buffers will always be |
| * allocated. |
| * If the offset is negative and the skip setting |
| * is greater than 0, additional buffers may be |
| * needed. |
| * @param[in] skip Skip N frames in between captures. This can be |
| * used to select a slower capture frame rate than |
| * the sensor output frame rate. |
| * @param[in] offset Start the RAW-to-YUV processing at RAW buffer |
| * with this offset. This allows the user to |
| * process RAW frames that were captured in the |
| * past or future. |
| * @return 0 or error code upon error. |
| * |
| * For example, to capture the current frame plus the 2 previous |
| * frames and 2 subsequent frames, you would call |
| * ia_css_stream_capture(5, 0, -2). |
| */ |
| int |
| ia_css_stream_capture(struct ia_css_stream *stream, |
| int num_captures, |
| unsigned int skip, |
| int offset); |
| |
| /* @brief Specify which raw frame to tag based on exp_id found in frame info |
| * |
| * @param[in] stream The stream. |
| * @param[in] exp_id The exposure id of the raw frame to tag. |
| * |
| * @return 0 or error code upon error. |
| * |
| * This function allows the user to tag a raw frame based on the exposure id |
| * found in the viewfinder frames' frame info. |
| */ |
| int |
| ia_css_stream_capture_frame(struct ia_css_stream *stream, |
| unsigned int exp_id); |
| |
| /* ===== VIDEO ===== */ |
| |
| /* @brief Send streaming data into the css input FIFO |
| * |
| * @param[in] stream The stream. |
| * @param[in] data Pointer to the pixels to be send. |
| * @param[in] width Width of the input frame. |
| * @param[in] height Height of the input frame. |
| * @return None |
| * |
| * Send streaming data into the css input FIFO. This is for testing purposes |
| * only. This uses the channel ID and input format as set by the user with |
| * the regular functions for this. |
| * This function blocks until the entire frame has been written into the |
| * input FIFO. |
| * |
| * Note: |
| * For higher flexibility the ia_css_stream_send_input_frame is replaced by |
| * three separate functions: |
| * 1) ia_css_stream_start_input_frame |
| * 2) ia_css_stream_send_input_line |
| * 3) ia_css_stream_end_input_frame |
| * In this way it is possible to stream multiple frames on different |
| * channel ID's on a line basis. It will be possible to simulate |
| * line-interleaved Stereo 3D muxed on 1 mipi port. |
| * These 3 functions are for testing purpose only and can be used in |
| * conjunction with ia_css_stream_send_input_frame |
| */ |
| void |
| ia_css_stream_send_input_frame(const struct ia_css_stream *stream, |
| const unsigned short *data, |
| unsigned int width, |
| unsigned int height); |
| |
| /* @brief Start an input frame on the CSS input FIFO. |
| * |
| * @param[in] stream The stream. |
| * @return None |
| * |
| * Starts the streaming to mipi frame by sending SoF for channel channel_id. |
| * It will use the input_format and two_pixels_per_clock as provided by |
| * the user. |
| * For the "correct" use-case, input_format and two_pixels_per_clock must match |
| * with the values as set by the user with the regular functions. |
| * To simulate an error, the user can provide "incorrect" values for |
| * input_format and/or two_pixels_per_clock. |
| */ |
| void |
| ia_css_stream_start_input_frame(const struct ia_css_stream *stream); |
| |
| /* @brief Send a line of input data into the CSS input FIFO. |
| * |
| * @param[in] stream The stream. |
| * @param[in] data Array of the first line of image data. |
| * @param width The width (in pixels) of the first line. |
| * @param[in] data2 Array of the second line of image data. |
| * @param width2 The width (in pixels) of the second line. |
| * @return None |
| * |
| * Sends 1 frame line. Start with SoL followed by width bytes of data, followed |
| * by width2 bytes of data2 and followed by and EoL |
| * It will use the input_format and two_pixels_per_clock settings as provided |
| * with the ia_css_stream_start_input_frame function call. |
| * |
| * This function blocks until the entire line has been written into the |
| * input FIFO. |
| */ |
| void |
| ia_css_stream_send_input_line(const struct ia_css_stream *stream, |
| const unsigned short *data, |
| unsigned int width, |
| const unsigned short *data2, |
| unsigned int width2); |
| |
| /* @brief Send a line of input embedded data into the CSS input FIFO. |
| * |
| * @param[in] stream Pointer of the stream. |
| * @param[in] format Format of the embedded data. |
| * @param[in] data Pointer of the embedded data line. |
| * @param[in] width The width (in pixels) of the line. |
| * @return None |
| * |
| * Sends one embedded data line to input fifo. Start with SoL followed by |
| * width bytes of data, and followed by and EoL. |
| * It will use the two_pixels_per_clock settings as provided with the |
| * ia_css_stream_start_input_frame function call. |
| * |
| * This function blocks until the entire line has been written into the |
| * input FIFO. |
| */ |
| void |
| ia_css_stream_send_input_embedded_line(const struct ia_css_stream *stream, |
| enum atomisp_input_format format, |
| const unsigned short *data, |
| unsigned int width); |
| |
| /* @brief End an input frame on the CSS input FIFO. |
| * |
| * @param[in] stream The stream. |
| * @return None |
| * |
| * Send the end-of-frame signal into the CSS input FIFO. |
| */ |
| void |
| ia_css_stream_end_input_frame(const struct ia_css_stream *stream); |
| |
| /* @brief send a request flash command to SP |
| * |
| * @param[in] stream The stream. |
| * @return None |
| * |
| * Driver needs to call this function to send a flash request command |
| * to SP, SP will be responsible for switching on/off the flash at proper |
| * time. Due to the SP multi-threading environment, this request may have |
| * one-frame delay, the driver needs to check the flashed flag in frame info |
| * to determine which frame is being flashed. |
| */ |
| void |
| ia_css_stream_request_flash(struct ia_css_stream *stream); |
| |
| /* @brief Configure a stream with filter coefficients. |
| * @deprecated {Replaced by |
| * ia_css_pipe_set_isp_config_on_pipe()} |
| * |
| * @param[in] stream The stream. |
| * @param[in] config The set of filter coefficients. |
| * @param[in] pipe Pipe to be updated when set isp config, NULL means to |
| * update all pipes in the stream. |
| * @return 0 or error code upon error. |
| * |
| * This function configures the filter coefficients for an image |
| * stream. For image pipes that do not execute any ISP filters, this |
| * function will have no effect. |
| * It is safe to call this function while the image stream is running, |
| * in fact this is the expected behavior most of the time. Proper |
| * resource locking and double buffering is in place to allow for this. |
| */ |
| int |
| ia_css_stream_set_isp_config_on_pipe(struct ia_css_stream *stream, |
| const struct ia_css_isp_config *config, |
| struct ia_css_pipe *pipe); |
| |
| /* @brief Configure a stream with filter coefficients. |
| * @deprecated {Replaced by |
| * ia_css_pipe_set_isp_config()} |
| * @param[in] stream The stream. |
| * @param[in] config The set of filter coefficients. |
| * @return 0 or error code upon error. |
| * |
| * This function configures the filter coefficients for an image |
| * stream. For image pipes that do not execute any ISP filters, this |
| * function will have no effect. All pipes of a stream will be updated. |
| * See ::ia_css_stream_set_isp_config_on_pipe() for the per-pipe alternative. |
| * It is safe to call this function while the image stream is running, |
| * in fact this is the expected behaviour most of the time. Proper |
| * resource locking and double buffering is in place to allow for this. |
| */ |
| int |
| ia_css_stream_set_isp_config( |
| struct ia_css_stream *stream, |
| const struct ia_css_isp_config *config); |
| |
| /* @brief Get selected configuration settings |
| * @param[in] stream The stream. |
| * @param[out] config Configuration settings. |
| * @return None |
| */ |
| void |
| ia_css_stream_get_isp_config(const struct ia_css_stream *stream, |
| struct ia_css_isp_config *config); |
| |
| /* @brief allocate continuous raw frames for continuous capture |
| * @param[in] stream The stream. |
| * @return 0 or error code. |
| * |
| * because this allocation takes a long time (around 120ms per frame), |
| * we separate the allocation part and update part to let driver call |
| * this function without locking. This function is the allocation part |
| * and next one is update part |
| */ |
| int |
| ia_css_alloc_continuous_frame_remain(struct ia_css_stream *stream); |
| |
| /* @brief allocate continuous raw frames for continuous capture |
| * @param[in] stream The stream. |
| * @return 0 or error code. |
| * |
| * because this allocation takes a long time (around 120ms per frame), |
| * we separate the allocation part and update part to let driver call |
| * this function without locking. This function is the update part |
| */ |
| int |
| ia_css_update_continuous_frames(struct ia_css_stream *stream); |
| |
| /* @brief ia_css_unlock_raw_frame . unlock a raw frame (HALv3 Support) |
| * @param[in] stream The stream. |
| * @param[in] exp_id exposure id that uniquely identifies the locked Raw Frame Buffer |
| * @return ia_css_err 0 or error code |
| * |
| * As part of HALv3 Feature requirement, SP locks raw buffer until the Application |
| * releases its reference to a raw buffer (which are managed by SP), this function allows |
| * application to explicitly unlock that buffer in SP. |
| */ |
| int |
| ia_css_unlock_raw_frame(struct ia_css_stream *stream, uint32_t exp_id); |
| |
| /* @brief ia_css_en_dz_capt_pipe . Enable/Disable digital zoom for capture pipe |
| * @param[in] stream The stream. |
| * @param[in] enable - true, disable - false |
| * @return None |
| * |
| * Enables or disables digital zoom for capture pipe in provided stream, if capture pipe |
| * exists. This function sets enable_zoom flag in CAPTURE_PP stage of the capture pipe. |
| * In process_zoom_and_motion(), decision to enable or disable zoom for every stage depends |
| * on this flag. |
| */ |
| void |
| ia_css_en_dz_capt_pipe(struct ia_css_stream *stream, bool enable); |
| #endif /* __IA_CSS_STREAM_PUBLIC_H */ |