mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/herbert/cryptodev-2.6.git
synced 2026-04-19 20:13:49 -04:00
22cd0db47f
The Mali C55 driver uses the v4l2-isp framework, which defines its own versioning number which does not need to be defined again in each platform-specific header. Remove the definition of mali_c55_param_buffer_version enumeration from the Mali C55 uAPI header. Signed-off-by: Jacopo Mondi <jacopo.mondi@ideasonboard.com> Reviewed-by: Daniel Scally <dan.scally@ideasonboard.com> Signed-off-by: Hans Verkuil <hverkuil+cisco@kernel.org>
786 lines
32 KiB
C
786 lines
32 KiB
C
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
|
/*
|
|
* ARM Mali-C55 ISP Driver - Userspace API
|
|
*
|
|
* Copyright (C) 2023 Ideas on Board Oy
|
|
*/
|
|
|
|
#ifndef __UAPI_MALI_C55_CONFIG_H
|
|
#define __UAPI_MALI_C55_CONFIG_H
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/v4l2-controls.h>
|
|
#include <linux/media/v4l2-isp.h>
|
|
|
|
#define V4L2_CID_MALI_C55_CAPABILITIES (V4L2_CID_USER_MALI_C55_BASE + 0x0)
|
|
#define MALI_C55_GPS_PONG (1U << 0)
|
|
#define MALI_C55_GPS_WDR (1U << 1)
|
|
#define MALI_C55_GPS_COMPRESSION (1U << 2)
|
|
#define MALI_C55_GPS_TEMPER (1U << 3)
|
|
#define MALI_C55_GPS_SINTER_LITE (1U << 4)
|
|
#define MALI_C55_GPS_SINTER (1U << 5)
|
|
#define MALI_C55_GPS_IRIDIX_LTM (1U << 6)
|
|
#define MALI_C55_GPS_IRIDIX_GTM (1U << 7)
|
|
#define MALI_C55_GPS_CNR (1U << 8)
|
|
#define MALI_C55_GPS_FRSCALER (1U << 9)
|
|
#define MALI_C55_GPS_DS_PIPE (1U << 10)
|
|
|
|
/*
|
|
* Frames are split into zones of almost equal width and height - a zone is a
|
|
* rectangular tile of a frame. The metering blocks within the ISP collect
|
|
* aggregated statistics per zone. A maximum of 15x15 zones can be configured,
|
|
* and so the statistics buffer within the hardware is sized to accommodate
|
|
* that.
|
|
*
|
|
* The utilised number of zones is runtime configurable.
|
|
*/
|
|
#define MALI_C55_MAX_ZONES (15 * 15)
|
|
|
|
/**
|
|
* struct mali_c55_ae_1024bin_hist - Auto Exposure 1024-bin histogram statistics
|
|
*
|
|
* @bins: 1024 element array of 16-bit pixel counts.
|
|
*
|
|
* The 1024-bin histogram module collects image-global but zone-weighted
|
|
* intensity distributions of pixels in fixed-width bins. The modules can be
|
|
* configured into different "plane modes" which affect the contents of the
|
|
* collected statistics. In plane mode 0, pixel intensities are taken regardless
|
|
* of colour plane into a single 1024-bin histogram with a bin width of 4. In
|
|
* plane mode 1, four 256-bin histograms with a bin width of 16 are collected -
|
|
* one for each CFA colour plane. In plane modes 4, 5, 6 and 7 two 512-bin
|
|
* histograms with a bin width of 8 are collected - in each mode one of the
|
|
* colour planes is collected into the first histogram and all the others are
|
|
* combined into the second. The histograms are stored consecutively in the bins
|
|
* array.
|
|
*
|
|
* The 16-bit pixel counts are stored as a 4-bit exponent in the most
|
|
* significant bits followed by a 12-bit mantissa. Conversion to a usable
|
|
* format can be done according to the following pseudo-code::
|
|
*
|
|
* if (e == 0) {
|
|
* bin = m * 2;
|
|
* } else {
|
|
* bin = (m + 4096) * 2^e
|
|
* }
|
|
*
|
|
* where
|
|
* e is the exponent value in range 0..15
|
|
* m is the mantissa value in range 0..4095
|
|
*
|
|
* The pixels used in calculating the statistics can be masked using three
|
|
* methods:
|
|
*
|
|
* 1. Pixels can be skipped in X and Y directions independently.
|
|
* 2. Minimum/Maximum intensities can be configured
|
|
* 3. Zones can be differentially weighted, including 0 weighted to mask them
|
|
*
|
|
* The data for this histogram can be collected from different tap points in the
|
|
* ISP depending on configuration - after the white balance or digital gain
|
|
* blocks, or immediately after the input crossbar.
|
|
*/
|
|
struct mali_c55_ae_1024bin_hist {
|
|
__u16 bins[1024];
|
|
} __attribute__((packed));
|
|
|
|
/**
|
|
* struct mali_c55_ae_5bin_hist - Auto Exposure 5-bin histogram statistics
|
|
*
|
|
* @hist0: 16-bit normalised pixel count for the 0th intensity bin
|
|
* @hist1: 16-bit normalised pixel count for the 1st intensity bin
|
|
* @hist3: 16-bit normalised pixel count for the 3rd intensity bin
|
|
* @hist4: 16-bit normalised pixel count for the 4th intensity bin
|
|
*
|
|
* The ISP generates a 5-bin histogram of normalised pixel counts within bins of
|
|
* pixel intensity for each of 225 possible zones within a frame. The centre bin
|
|
* of the histogram for each zone is not available from the hardware and must be
|
|
* calculated by subtracting the values of hist0, hist1, hist3 and hist4 from
|
|
* 0xffff as in the following equation:
|
|
*
|
|
* hist2 = 0xffff - (hist0 + hist1 + hist3 + hist4)
|
|
*/
|
|
struct mali_c55_ae_5bin_hist {
|
|
__u16 hist0;
|
|
__u16 hist1;
|
|
__u16 hist3;
|
|
__u16 hist4;
|
|
} __attribute__((packed));
|
|
|
|
/**
|
|
* struct mali_c55_awb_average_ratios - Auto White Balance colour ratios
|
|
*
|
|
* @avg_rg_gr: Average R/G or G/R ratio in Q4.8 format.
|
|
* @avg_bg_br: Average B/G or B/R ratio in Q4.8 format.
|
|
* @num_pixels: The number of pixels used in the AWB calculation
|
|
*
|
|
* The ISP calculates and collects average colour ratios for each zone in an
|
|
* image and stores them in Q4.8 format (the lowest 8 bits are fractional, with
|
|
* bits [11:8] representing the integer). The exact ratios collected (either
|
|
* R/G, B/G or G/R, B/R) are configurable through the parameters buffer. The
|
|
* value of the 4 high bits is undefined.
|
|
*/
|
|
struct mali_c55_awb_average_ratios {
|
|
__u16 avg_rg_gr;
|
|
__u16 avg_bg_br;
|
|
__u32 num_pixels;
|
|
} __attribute__((packed));
|
|
|
|
/**
|
|
* struct mali_c55_af_statistics - Auto Focus edge and intensity statistics
|
|
*
|
|
* @intensity_stats: Packed mantissa and exponent value for pixel intensity
|
|
* @edge_stats: Packed mantissa and exponent values for edge intensity
|
|
*
|
|
* The ISP collects the squared sum of pixel intensities for each zone within a
|
|
* configurable Region of Interest on the frame. Additionally, the same data are
|
|
* collected after being passed through a bandpass filter which removes high and
|
|
* low frequency components - these are referred to as the edge statistics.
|
|
*
|
|
* The intensity and edge statistics for a zone can be used to calculate the
|
|
* contrast information for a zone
|
|
*
|
|
* C = E2 / I2
|
|
*
|
|
* Where I2 is the intensity statistic for a zone and E2 is the edge statistic
|
|
* for that zone. Optimum focus is reached when C is at its maximum.
|
|
*
|
|
* The intensity and edge statistics are stored packed into a non-standard 16
|
|
* bit floating point format, where the 7 most significant bits represent the
|
|
* exponent and the 9 least significant bits the mantissa. This format can be
|
|
* unpacked with the following pseudocode::
|
|
*
|
|
* if (e == 0) {
|
|
* x = m;
|
|
* } else {
|
|
* x = 2^e-1 * (m + 2^9)
|
|
* }
|
|
*
|
|
* where
|
|
* e is the exponent value in range 0..127
|
|
* m is the mantissa value in range 0..511
|
|
*/
|
|
struct mali_c55_af_statistics {
|
|
__u16 intensity_stats;
|
|
__u16 edge_stats;
|
|
} __attribute__((packed));
|
|
|
|
/**
|
|
* struct mali_c55_stats_buffer - 3A statistics for the mali-c55 ISP
|
|
*
|
|
* @ae_1024bin_hist: 1024-bin frame-global pixel intensity histogram
|
|
* @iridix_1024bin_hist: Post-Iridix block 1024-bin histogram
|
|
* @ae_5bin_hists: 5-bin pixel intensity histograms for AEC
|
|
* @reserved1: Undefined buffer space
|
|
* @awb_ratios: Color balance ratios for Auto White Balance
|
|
* @reserved2: Undefined buffer space
|
|
* @af_statistics: Pixel intensity statistics for Auto Focus
|
|
* @reserved3: Undefined buffer space
|
|
*
|
|
* This struct describes the metering statistics space in the Mali-C55 ISP's
|
|
* hardware in its entirety. The space between each defined area is marked as
|
|
* "unknown" and may not be 0, but should not be used. The @ae_5bin_hists,
|
|
* @awb_ratios and @af_statistics members are arrays of statistics per-zone.
|
|
* The zones are arranged in the array in raster order starting from the top
|
|
* left corner of the image.
|
|
*/
|
|
|
|
struct mali_c55_stats_buffer {
|
|
struct mali_c55_ae_1024bin_hist ae_1024bin_hist;
|
|
struct mali_c55_ae_1024bin_hist iridix_1024bin_hist;
|
|
struct mali_c55_ae_5bin_hist ae_5bin_hists[MALI_C55_MAX_ZONES];
|
|
__u32 reserved1[14];
|
|
struct mali_c55_awb_average_ratios awb_ratios[MALI_C55_MAX_ZONES];
|
|
__u32 reserved2[14];
|
|
struct mali_c55_af_statistics af_statistics[MALI_C55_MAX_ZONES];
|
|
__u32 reserved3[15];
|
|
} __attribute__((packed));
|
|
|
|
/**
|
|
* enum mali_c55_param_block_type - Enumeration of Mali-C55 parameter blocks
|
|
*
|
|
* This enumeration defines the types of Mali-C55 parameters block. Each block
|
|
* configures a specific processing block of the Mali-C55 ISP. The block
|
|
* type allows the driver to correctly interpret the parameters block data.
|
|
*
|
|
* It is the responsibility of userspace to correctly set the type of each
|
|
* parameters block.
|
|
*
|
|
* @MALI_C55_PARAM_BLOCK_SENSOR_OFFS: Sensor pre-shading black level offset
|
|
* @MALI_C55_PARAM_BLOCK_AEXP_HIST: Auto-exposure 1024-bin histogram
|
|
* configuration
|
|
* @MALI_C55_PARAM_BLOCK_AEXP_IHIST: Post-Iridix auto-exposure 1024-bin
|
|
* histogram configuration
|
|
* @MALI_C55_PARAM_BLOCK_AEXP_HIST_WEIGHTS: Auto-exposure 1024-bin histogram
|
|
* weighting
|
|
* @MALI_C55_PARAM_BLOCK_AEXP_IHIST_WEIGHTS: Post-Iridix auto-exposure 1024-bin
|
|
* histogram weighting
|
|
* @MALI_C55_PARAM_BLOCK_DIGITAL_GAIN: Digital gain
|
|
* @MALI_C55_PARAM_BLOCK_AWB_GAINS: Auto-white balance gains
|
|
* @MALI_C55_PARAM_BLOCK_AWB_CONFIG: Auto-white balance statistics config
|
|
* @MALI_C55_PARAM_BLOCK_AWB_GAINS_AEXP: Auto-white balance gains for AEXP-0 tap
|
|
* @MALI_C55_PARAM_MESH_SHADING_CONFIG : Mesh shading tables configuration
|
|
* @MALI_C55_PARAM_MESH_SHADING_SELECTION: Mesh shading table selection
|
|
*/
|
|
enum mali_c55_param_block_type {
|
|
MALI_C55_PARAM_BLOCK_SENSOR_OFFS,
|
|
MALI_C55_PARAM_BLOCK_AEXP_HIST,
|
|
MALI_C55_PARAM_BLOCK_AEXP_IHIST,
|
|
MALI_C55_PARAM_BLOCK_AEXP_HIST_WEIGHTS,
|
|
MALI_C55_PARAM_BLOCK_AEXP_IHIST_WEIGHTS,
|
|
MALI_C55_PARAM_BLOCK_DIGITAL_GAIN,
|
|
MALI_C55_PARAM_BLOCK_AWB_GAINS,
|
|
MALI_C55_PARAM_BLOCK_AWB_CONFIG,
|
|
MALI_C55_PARAM_BLOCK_AWB_GAINS_AEXP,
|
|
MALI_C55_PARAM_MESH_SHADING_CONFIG,
|
|
MALI_C55_PARAM_MESH_SHADING_SELECTION,
|
|
};
|
|
|
|
/**
|
|
* struct mali_c55_params_sensor_off_preshading - offset subtraction for each
|
|
* color channel
|
|
*
|
|
* Provides removal of the sensor black level from the sensor data. Separate
|
|
* offsets are provided for each of the four Bayer component color channels
|
|
* which are defaulted to R, Gr, Gb, B.
|
|
*
|
|
* header.type should be set to MALI_C55_PARAM_BLOCK_SENSOR_OFFS from
|
|
* :c:type:`mali_c55_param_block_type` for this block.
|
|
*
|
|
* @header: The Mali-C55 parameters block header
|
|
* @chan00: Offset for color channel 00 (default: R)
|
|
* @chan01: Offset for color channel 01 (default: Gr)
|
|
* @chan10: Offset for color channel 10 (default: Gb)
|
|
* @chan11: Offset for color channel 11 (default: B)
|
|
*/
|
|
struct mali_c55_params_sensor_off_preshading {
|
|
struct v4l2_isp_params_block_header header;
|
|
__u32 chan00;
|
|
__u32 chan01;
|
|
__u32 chan10;
|
|
__u32 chan11;
|
|
};
|
|
|
|
/**
|
|
* enum mali_c55_aexp_hist_tap_points - Tap points for the AEXP histogram
|
|
* @MALI_C55_AEXP_HIST_TAP_WB: After static white balance
|
|
* @MALI_C55_AEXP_HIST_TAP_FS: After WDR Frame Stitch
|
|
* @MALI_C55_AEXP_HIST_TAP_TPG: After the test pattern generator
|
|
*/
|
|
enum mali_c55_aexp_hist_tap_points {
|
|
MALI_C55_AEXP_HIST_TAP_WB = 0,
|
|
MALI_C55_AEXP_HIST_TAP_FS,
|
|
MALI_C55_AEXP_HIST_TAP_TPG,
|
|
};
|
|
|
|
/**
|
|
* enum mali_c55_aexp_skip_x - Horizontal pixel skipping
|
|
* @MALI_C55_AEXP_SKIP_X_EVERY_2ND: Collect every 2nd pixel horizontally
|
|
* @MALI_C55_AEXP_SKIP_X_EVERY_3RD: Collect every 3rd pixel horizontally
|
|
* @MALI_C55_AEXP_SKIP_X_EVERY_4TH: Collect every 4th pixel horizontally
|
|
* @MALI_C55_AEXP_SKIP_X_EVERY_5TH: Collect every 5th pixel horizontally
|
|
* @MALI_C55_AEXP_SKIP_X_EVERY_8TH: Collect every 8th pixel horizontally
|
|
* @MALI_C55_AEXP_SKIP_X_EVERY_9TH: Collect every 9th pixel horizontally
|
|
*/
|
|
enum mali_c55_aexp_skip_x {
|
|
MALI_C55_AEXP_SKIP_X_EVERY_2ND,
|
|
MALI_C55_AEXP_SKIP_X_EVERY_3RD,
|
|
MALI_C55_AEXP_SKIP_X_EVERY_4TH,
|
|
MALI_C55_AEXP_SKIP_X_EVERY_5TH,
|
|
MALI_C55_AEXP_SKIP_X_EVERY_8TH,
|
|
MALI_C55_AEXP_SKIP_X_EVERY_9TH
|
|
};
|
|
|
|
/**
|
|
* enum mali_c55_aexp_skip_y - Vertical pixel skipping
|
|
* @MALI_C55_AEXP_SKIP_Y_ALL: Collect every single pixel vertically
|
|
* @MALI_C55_AEXP_SKIP_Y_EVERY_2ND: Collect every 2nd pixel vertically
|
|
* @MALI_C55_AEXP_SKIP_Y_EVERY_3RD: Collect every 3rd pixel vertically
|
|
* @MALI_C55_AEXP_SKIP_Y_EVERY_4TH: Collect every 4th pixel vertically
|
|
* @MALI_C55_AEXP_SKIP_Y_EVERY_5TH: Collect every 5th pixel vertically
|
|
* @MALI_C55_AEXP_SKIP_Y_EVERY_8TH: Collect every 8th pixel vertically
|
|
* @MALI_C55_AEXP_SKIP_Y_EVERY_9TH: Collect every 9th pixel vertically
|
|
*/
|
|
enum mali_c55_aexp_skip_y {
|
|
MALI_C55_AEXP_SKIP_Y_ALL,
|
|
MALI_C55_AEXP_SKIP_Y_EVERY_2ND,
|
|
MALI_C55_AEXP_SKIP_Y_EVERY_3RD,
|
|
MALI_C55_AEXP_SKIP_Y_EVERY_4TH,
|
|
MALI_C55_AEXP_SKIP_Y_EVERY_5TH,
|
|
MALI_C55_AEXP_SKIP_Y_EVERY_8TH,
|
|
MALI_C55_AEXP_SKIP_Y_EVERY_9TH
|
|
};
|
|
|
|
/**
|
|
* enum mali_c55_aexp_row_column_offset - Start from the first or second row or
|
|
* column
|
|
* @MALI_C55_AEXP_FIRST_ROW_OR_COL: Start from the first row / column
|
|
* @MALI_C55_AEXP_SECOND_ROW_OR_COL: Start from the second row / column
|
|
*/
|
|
enum mali_c55_aexp_row_column_offset {
|
|
MALI_C55_AEXP_FIRST_ROW_OR_COL = 1,
|
|
MALI_C55_AEXP_SECOND_ROW_OR_COL = 2,
|
|
};
|
|
|
|
/**
|
|
* enum mali_c55_aexp_hist_plane_mode - Mode for the AEXP Histograms
|
|
* @MALI_C55_AEXP_HIST_COMBINED: All color planes in one 1024-bin histogram
|
|
* @MALI_C55_AEXP_HIST_SEPARATE: Each color plane in one 256-bin histogram with a bin width of 16
|
|
* @MALI_C55_AEXP_HIST_FOCUS_00: Top left plane in the first bank, rest in second bank
|
|
* @MALI_C55_AEXP_HIST_FOCUS_01: Top right plane in the first bank, rest in second bank
|
|
* @MALI_C55_AEXP_HIST_FOCUS_10: Bottom left plane in the first bank, rest in second bank
|
|
* @MALI_C55_AEXP_HIST_FOCUS_11: Bottom right plane in the first bank, rest in second bank
|
|
*
|
|
* In the "focus" modes statistics are collected into two 512-bin histograms
|
|
* with a bin width of 8. One colour plane is in the first histogram with the
|
|
* remainder combined into the second. The four options represent which of the
|
|
* four positions in a bayer pattern are the focused plane.
|
|
*/
|
|
enum mali_c55_aexp_hist_plane_mode {
|
|
MALI_C55_AEXP_HIST_COMBINED = 0,
|
|
MALI_C55_AEXP_HIST_SEPARATE = 1,
|
|
MALI_C55_AEXP_HIST_FOCUS_00 = 4,
|
|
MALI_C55_AEXP_HIST_FOCUS_01 = 5,
|
|
MALI_C55_AEXP_HIST_FOCUS_10 = 6,
|
|
MALI_C55_AEXP_HIST_FOCUS_11 = 7,
|
|
};
|
|
|
|
/**
|
|
* struct mali_c55_params_aexp_hist - configuration for AEXP metering hists
|
|
*
|
|
* This struct allows users to configure the 1024-bin AEXP histograms. Broadly
|
|
* speaking the parameters allow you to mask particular regions of the image and
|
|
* to select different kinds of histogram.
|
|
*
|
|
* The skip_x, offset_x, skip_y and offset_y fields allow users to ignore or
|
|
* mask pixels in the frame by their position relative to the top left pixel.
|
|
* First, the skip_y, offset_x and offset_y fields define which of the pixels
|
|
* within each 2x2 region will be counted in the statistics.
|
|
*
|
|
* If skip_y == 0 then two pixels from each covered region will be counted. If
|
|
* both offset_x and offset_y are zero, then the two left-most pixels in each
|
|
* 2x2 pixel region will be counted. Setting offset_x = 1 will discount the top
|
|
* left pixel and count the top right pixel. Setting offset_y = 1 will discount
|
|
* the bottom left pixel and count the bottom right pixel.
|
|
*
|
|
* If skip_y != 0 then only a single pixel from each region covered by the
|
|
* pattern will be counted. In this case offset_x controls whether the pixel
|
|
* that's counted is in the left (if offset_x == 0) or right (if offset_x == 1)
|
|
* column and offset_y controls whether the pixel that's counted is in the top
|
|
* (if offset_y == 0) or bottom (if offset_y == 1) row.
|
|
*
|
|
* The skip_x and skip_y fields control how the 2x2 pixel region is repeated
|
|
* across the image data. The first instance of the region is always in the top
|
|
* left of the image data. The skip_x field controls how many pixels are ignored
|
|
* in the x direction before the pixel masking region is repeated. The skip_y
|
|
* field controls how many pixels are ignored in the y direction before the
|
|
* pixel masking region is repeated.
|
|
*
|
|
* These fields can be used to reduce the number of pixels counted for the
|
|
* statistics, but it's important to be careful to configure them correctly.
|
|
* Some combinations of values will result in colour components from the input
|
|
* data being ignored entirely, for example in the following configuration:
|
|
*
|
|
* skip_x = 0
|
|
* offset_x = 0
|
|
* skip_y = 0
|
|
* offset_y = 0
|
|
*
|
|
* Only the R and Gb components of RGGB data that was input would be collected.
|
|
* Similarly in the following configuration:
|
|
*
|
|
* skip_x = 0
|
|
* offset_x = 0
|
|
* skip_y = 1
|
|
* offset_y = 1
|
|
*
|
|
* Only the Gb component of RGGB data that was input would be collected. To
|
|
* correct things such that all 4 colour components were included it would be
|
|
* necessary to set the skip_x and skip_y fields in a way that resulted in all
|
|
* four colour components being collected:
|
|
*
|
|
* skip_x = 1
|
|
* offset_x = 0
|
|
* skip_y = 1
|
|
* offset_y = 1
|
|
*
|
|
* header.type should be set to one of either MALI_C55_PARAM_BLOCK_AEXP_HIST or
|
|
* MALI_C55_PARAM_BLOCK_AEXP_IHIST from :c:type:`mali_c55_param_block_type`.
|
|
*
|
|
* @header: The Mali-C55 parameters block header
|
|
* @skip_x: Horizontal decimation. See enum mali_c55_aexp_skip_x
|
|
* @offset_x: Skip the first column, or not. See enum mali_c55_aexp_row_column_offset
|
|
* @skip_y: Vertical decimation. See enum mali_c55_aexp_skip_y
|
|
* @offset_y: Skip the first row, or not. See enum mali_c55_aexp_row_column_offset
|
|
* @scale_bottom: Scale pixels in bottom half of intensity range: 0=1x ,1=2x, 2=4x, 4=8x, 4=16x
|
|
* @scale_top: scale pixels in top half of intensity range: 0=1x ,1=2x, 2=4x, 4=8x, 4=16x
|
|
* @plane_mode: Plane separation mode. See enum mali_c55_aexp_hist_plane_mode
|
|
* @tap_point: Tap point for histogram from enum mali_c55_aexp_hist_tap_points.
|
|
* This parameter is unused for the post-Iridix Histogram
|
|
*/
|
|
struct mali_c55_params_aexp_hist {
|
|
struct v4l2_isp_params_block_header header;
|
|
__u8 skip_x;
|
|
__u8 offset_x;
|
|
__u8 skip_y;
|
|
__u8 offset_y;
|
|
__u8 scale_bottom;
|
|
__u8 scale_top;
|
|
__u8 plane_mode;
|
|
__u8 tap_point;
|
|
};
|
|
|
|
/**
|
|
* struct mali_c55_params_aexp_weights - Array of weights for AEXP metering
|
|
*
|
|
* This struct allows users to configure the weighting for both of the 1024-bin
|
|
* AEXP histograms. The pixel data collected for each zone is multiplied by the
|
|
* corresponding weight from this array, which may be zero if the intention is
|
|
* to mask off the zone entirely.
|
|
*
|
|
* header.type should be set to one of either MALI_C55_PARAM_BLOCK_AEXP_HIST_WEIGHTS
|
|
* or MALI_C55_PARAM_BLOCK_AEXP_IHIST_WEIGHTS from :c:type:`mali_c55_param_block_type`.
|
|
*
|
|
* @header: The Mali-C55 parameters block header
|
|
* @nodes_used_horiz: Number of active zones horizontally [0..15]
|
|
* @nodes_used_vert: Number of active zones vertically [0..15]
|
|
* @zone_weights: Zone weighting. Index is row*col where 0,0 is the top
|
|
* left zone continuing in raster order. Each zone can be
|
|
* weighted in the range [0..15]. The number of rows and
|
|
* columns is defined by @nodes_used_vert and
|
|
* @nodes_used_horiz
|
|
*/
|
|
struct mali_c55_params_aexp_weights {
|
|
struct v4l2_isp_params_block_header header;
|
|
__u8 nodes_used_horiz;
|
|
__u8 nodes_used_vert;
|
|
__u8 zone_weights[MALI_C55_MAX_ZONES];
|
|
};
|
|
|
|
/**
|
|
* struct mali_c55_params_digital_gain - Digital gain value
|
|
*
|
|
* This struct carries a digital gain value to set in the ISP.
|
|
*
|
|
* header.type should be set to MALI_C55_PARAM_BLOCK_DIGITAL_GAIN from
|
|
* :c:type:`mali_c55_param_block_type` for this block.
|
|
*
|
|
* @header: The Mali-C55 parameters block header
|
|
* @gain: The digital gain value to apply, in Q5.8 format.
|
|
*/
|
|
struct mali_c55_params_digital_gain {
|
|
struct v4l2_isp_params_block_header header;
|
|
__u16 gain;
|
|
};
|
|
|
|
/**
|
|
* enum mali_c55_awb_stats_mode - Statistics mode for AWB
|
|
* @MALI_C55_AWB_MODE_GRBR: Statistics collected as Green/Red and Blue/Red ratios
|
|
* @MALI_C55_AWB_MODE_RGBG: Statistics collected as Red/Green and Blue/Green ratios
|
|
*/
|
|
enum mali_c55_awb_stats_mode {
|
|
MALI_C55_AWB_MODE_GRBR = 0,
|
|
MALI_C55_AWB_MODE_RGBG,
|
|
};
|
|
|
|
/**
|
|
* struct mali_c55_params_awb_gains - Gain settings for auto white balance
|
|
*
|
|
* This struct allows users to configure the gains for auto-white balance. There
|
|
* are four gain settings corresponding to each colour channel in the bayer
|
|
* domain. Although named generically, the association between the gain applied
|
|
* and the colour channel is done automatically within the ISP depending on the
|
|
* input format, and so the following mapping always holds true::
|
|
*
|
|
* gain00 = R
|
|
* gain01 = Gr
|
|
* gain10 = Gb
|
|
* gain11 = B
|
|
*
|
|
* All of the gains are stored in Q4.8 format.
|
|
*
|
|
* header.type should be set to one of either MALI_C55_PARAM_BLOCK_AWB_GAINS or
|
|
* MALI_C55_PARAM_BLOCK_AWB_GAINS_AEXP from :c:type:`mali_c55_param_block_type`.
|
|
*
|
|
* @header: The Mali-C55 parameters block header
|
|
* @gain00: Multiplier for colour channel 00
|
|
* @gain01: Multiplier for colour channel 01
|
|
* @gain10: Multiplier for colour channel 10
|
|
* @gain11: Multiplier for colour channel 11
|
|
*/
|
|
struct mali_c55_params_awb_gains {
|
|
struct v4l2_isp_params_block_header header;
|
|
__u16 gain00;
|
|
__u16 gain01;
|
|
__u16 gain10;
|
|
__u16 gain11;
|
|
};
|
|
|
|
/**
|
|
* enum mali_c55_params_awb_tap_points - Tap points for the AWB statistics
|
|
* @MALI_C55_AWB_STATS_TAP_PF: Immediately after the Purple Fringe block
|
|
* @MALI_C55_AWB_STATS_TAP_CNR: Immediately after the CNR block
|
|
*/
|
|
enum mali_c55_params_awb_tap_points {
|
|
MALI_C55_AWB_STATS_TAP_PF = 0,
|
|
MALI_C55_AWB_STATS_TAP_CNR,
|
|
};
|
|
|
|
/**
|
|
* struct mali_c55_params_awb_config - Stats settings for auto-white balance
|
|
*
|
|
* This struct allows the configuration of the statistics generated for auto
|
|
* white balance. Pixel intensity limits can be set to exclude overly bright or
|
|
* dark regions of an image from the statistics entirely. Colour ratio minima
|
|
* and maxima can be set to discount pixels who's ratios fall outside the
|
|
* defined boundaries; there are two sets of registers to do this - the
|
|
* "min/max" ratios which bound a region and the "high/low" ratios which further
|
|
* trim the upper and lower ratios. For example with the boundaries configured
|
|
* as follows, only pixels whos colour ratios falls into the region marked "A"
|
|
* would be counted::
|
|
*
|
|
* cr_high
|
|
* 2.0 | |
|
|
* | cb_max --> _________________________v_____
|
|
* 1.8 | | \ |
|
|
* | | \ |
|
|
* 1.6 | | \ |
|
|
* | | \ |
|
|
* c 1.4 | cb_low -->|\ A \|<-- cb_high
|
|
* b | | \ |
|
|
* 1.2 | | \ |
|
|
* r | | \ |
|
|
* a 1.0 | cb_min --> |____\_________________________|
|
|
* t | ^ ^ ^
|
|
* i 0.8 | | | |
|
|
* o | cr_min | cr_max
|
|
* s 0.6 | |
|
|
* | cr_low
|
|
* 0.4 |
|
|
* |
|
|
* 0.2 |
|
|
* |
|
|
* 0.0 |_______________________________________________________________
|
|
* 0.0 0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6 1.8 2.0
|
|
* cr ratios
|
|
*
|
|
* header.type should be set to MALI_C55_PARAM_BLOCK_AWB_CONFIG from
|
|
* :c:type:`mali_c55_param_block_type` for this block.
|
|
*
|
|
* @header: The Mali-C55 parameters block header
|
|
* @tap_point: The tap point from enum mali_c55_params_awb_tap_points
|
|
* @stats_mode: AWB statistics collection mode, see :c:type:`mali_c55_awb_stats_mode`
|
|
* @white_level: Upper pixel intensity (I.E. raw pixel values) limit
|
|
* @black_level: Lower pixel intensity (I.E. raw pixel values) limit
|
|
* @cr_max: Maximum R/G ratio (Q4.8 format)
|
|
* @cr_min: Minimum R/G ratio (Q4.8 format)
|
|
* @cb_max: Maximum B/G ratio (Q4.8 format)
|
|
* @cb_min: Minimum B/G ratio (Q4.8 format)
|
|
* @nodes_used_horiz: Number of active zones horizontally [0..15]
|
|
* @nodes_used_vert: Number of active zones vertically [0..15]
|
|
* @cr_high: R/G ratio trim high (Q4.8 format)
|
|
* @cr_low: R/G ratio trim low (Q4.8 format)
|
|
* @cb_high: B/G ratio trim high (Q4.8 format)
|
|
* @cb_low: B/G ratio trim low (Q4.8 format)
|
|
*/
|
|
struct mali_c55_params_awb_config {
|
|
struct v4l2_isp_params_block_header header;
|
|
__u8 tap_point;
|
|
__u8 stats_mode;
|
|
__u16 white_level;
|
|
__u16 black_level;
|
|
__u16 cr_max;
|
|
__u16 cr_min;
|
|
__u16 cb_max;
|
|
__u16 cb_min;
|
|
__u8 nodes_used_horiz;
|
|
__u8 nodes_used_vert;
|
|
__u16 cr_high;
|
|
__u16 cr_low;
|
|
__u16 cb_high;
|
|
__u16 cb_low;
|
|
};
|
|
|
|
#define MALI_C55_NUM_MESH_SHADING_ELEMENTS 3072
|
|
|
|
/**
|
|
* struct mali_c55_params_mesh_shading_config - Mesh shading configuration
|
|
*
|
|
* The mesh shading correction module allows programming a separate table of
|
|
* either 16x16 or 32x32 node coefficients for 3 different light sources. The
|
|
* final correction coefficients applied are computed by blending the
|
|
* coefficients from two tables together.
|
|
*
|
|
* A page of 1024 32-bit integers is associated to each colour channel, with
|
|
* pages stored consecutively in memory. Each 32-bit integer packs 3 8-bit
|
|
* correction coefficients for a single node, one for each of the three light
|
|
* sources. The 8 most significant bits are unused. The following table
|
|
* describes the layout::
|
|
*
|
|
* +----------- Page (Colour Plane) 0 -------------+
|
|
* | @mesh[i] | Mesh Point | Bits | Light Source |
|
|
* +-----------+------------+-------+--------------+
|
|
* | 0 | 0,0 | 16,23 | LS2 |
|
|
* | | | 08-15 | LS1 |
|
|
* | | | 00-07 | LS0 |
|
|
* +-----------+------------+-------+--------------+
|
|
* | 1 | 0,1 | 16,23 | LS2 |
|
|
* | | | 08-15 | LS1 |
|
|
* | | | 00-07 | LS0 |
|
|
* +-----------+------------+-------+--------------+
|
|
* | ... | ... | ... | ... |
|
|
* +-----------+------------+-------+--------------+
|
|
* | 1023 | 31,31 | 16,23 | LS2 |
|
|
* | | | 08-15 | LS1 |
|
|
* | | | 00-07 | LS0 |
|
|
* +----------- Page (Colour Plane) 1 -------------+
|
|
* | @mesh[i] | Mesh Point | Bits | Light Source |
|
|
* +-----------+------------+-------+--------------+
|
|
* | 1024 | 0,0 | 16,23 | LS2 |
|
|
* | | | 08-15 | LS1 |
|
|
* | | | 00-07 | LS0 |
|
|
* +-----------+------------+-------+--------------+
|
|
* | 1025 | 0,1 | 16,23 | LS2 |
|
|
* | | | 08-15 | LS1 |
|
|
* | | | 00-07 | LS0 |
|
|
* +-----------+------------+-------+--------------+
|
|
* | ... | ... | ... | ... |
|
|
* +-----------+------------+-------+--------------+
|
|
* | 2047 | 31,31 | 16,23 | LS2 |
|
|
* | | | 08-15 | LS1 |
|
|
* | | | 00-07 | LS0 |
|
|
* +----------- Page (Colour Plane) 2 -------------+
|
|
* | @mesh[i] | Mesh Point | Bits | Light Source |
|
|
* +-----------+------------+-------+--------------+
|
|
* | 2048 | 0,0 | 16,23 | LS2 |
|
|
* | | | 08-15 | LS1 |
|
|
* | | | 00-07 | LS0 |
|
|
* +-----------+------------+-------+--------------+
|
|
* | 2049 | 0,1 | 16,23 | LS2 |
|
|
* | | | 08-15 | LS1 |
|
|
* | | | 00-07 | LS0 |
|
|
* +-----------+------------+-------+--------------+
|
|
* | ... | ... | ... | ... |
|
|
* +-----------+------------+-------+--------------+
|
|
* | 3071 | 31,31 | 16,23 | LS2 |
|
|
* | | | 08-15 | LS1 |
|
|
* | | | 00-07 | LS0 |
|
|
* +-----------+------------+-------+--------------+
|
|
*
|
|
* The @mesh_scale member determines the precision and minimum and maximum gain.
|
|
* For example if @mesh_scale is 0 and therefore selects 0 - 2x gain, a value of
|
|
* 0 in a coefficient means 0.0 gain, a value of 128 means 1.0 gain and 255
|
|
* means 2.0 gain.
|
|
*
|
|
* header.type should be set to MALI_C55_PARAM_MESH_SHADING_CONFIG from
|
|
* :c:type:`mali_c55_param_block_type` for this block.
|
|
*
|
|
* @header: The Mali-C55 parameters block header
|
|
* @mesh_show: Output the mesh data rather than image data
|
|
* @mesh_scale: Set the precision and maximum gain range of mesh shading
|
|
* - 0 = 0-2x gain
|
|
* - 1 = 0-4x gain
|
|
* - 2 = 0-8x gain
|
|
* - 3 = 0-16x gain
|
|
* - 4 = 1-2x gain
|
|
* - 5 = 1-3x gain
|
|
* - 6 = 1-5x gain
|
|
* - 7 = 1-9x gain
|
|
* @mesh_page_r: Mesh page select for red colour plane [0..2]
|
|
* @mesh_page_g: Mesh page select for green colour plane [0..2]
|
|
* @mesh_page_b: Mesh page select for blue colour plane [0..2]
|
|
* @mesh_width: Number of horizontal nodes minus 1 [15,31]
|
|
* @mesh_height: Number of vertical nodes minus 1 [15,31]
|
|
* @mesh: Mesh shading correction tables
|
|
*/
|
|
struct mali_c55_params_mesh_shading_config {
|
|
struct v4l2_isp_params_block_header header;
|
|
__u8 mesh_show;
|
|
__u8 mesh_scale;
|
|
__u8 mesh_page_r;
|
|
__u8 mesh_page_g;
|
|
__u8 mesh_page_b;
|
|
__u8 mesh_width;
|
|
__u8 mesh_height;
|
|
__u32 mesh[MALI_C55_NUM_MESH_SHADING_ELEMENTS];
|
|
};
|
|
|
|
/** enum mali_c55_params_mesh_alpha_bank - Mesh shading table bank selection
|
|
* @MALI_C55_MESH_ALPHA_BANK_LS0_AND_LS1 - Select Light Sources 0 and 1
|
|
* @MALI_C55_MESH_ALPHA_BANK_LS1_AND_LS2 - Select Light Sources 1 and 2
|
|
* @MALI_C55_MESH_ALPHA_BANK_LS0_AND_LS2 - Select Light Sources 0 and 2
|
|
*/
|
|
enum mali_c55_params_mesh_alpha_bank {
|
|
MALI_C55_MESH_ALPHA_BANK_LS0_AND_LS1 = 0,
|
|
MALI_C55_MESH_ALPHA_BANK_LS1_AND_LS2 = 1,
|
|
MALI_C55_MESH_ALPHA_BANK_LS0_AND_LS2 = 4
|
|
};
|
|
|
|
/**
|
|
* struct mali_c55_params_mesh_shading_selection - Mesh table selection
|
|
*
|
|
* The module computes the final correction coefficients by blending the ones
|
|
* from two light source tables, which are selected (independently for each
|
|
* colour channel) by the @mesh_alpha_bank_r/g/b fields.
|
|
*
|
|
* The final blended coefficients for each node are calculated using the
|
|
* following equation:
|
|
*
|
|
* Final coefficient = (a * LS\ :sub:`b`\ + (256 - a) * LS\ :sub:`a`\) / 256
|
|
*
|
|
* Where a is the @mesh_alpha_r/g/b value, and LS\ :sub:`a`\ and LS\ :sub:`b`\
|
|
* are the node cofficients for the two tables selected by the
|
|
* @mesh_alpha_bank_r/g/b value.
|
|
*
|
|
* The scale of the applied correction may also be controlled by tuning the
|
|
* @mesh_strength member. This is a modifier to the final coefficients which can
|
|
* be used to globally reduce the gains applied.
|
|
*
|
|
* header.type should be set to MALI_C55_PARAM_MESH_SHADING_SELECTION from
|
|
* :c:type:`mali_c55_param_block_type` for this block.
|
|
*
|
|
* @header: The Mali-C55 parameters block header
|
|
* @mesh_alpha_bank_r: Red mesh table select (c:type:`enum mali_c55_params_mesh_alpha_bank`)
|
|
* @mesh_alpha_bank_g: Green mesh table select (c:type:`enum mali_c55_params_mesh_alpha_bank`)
|
|
* @mesh_alpha_bank_b: Blue mesh table select (c:type:`enum mali_c55_params_mesh_alpha_bank`)
|
|
* @mesh_alpha_r: Blend coefficient for R [0..255]
|
|
* @mesh_alpha_g: Blend coefficient for G [0..255]
|
|
* @mesh_alpha_b: Blend coefficient for B [0..255]
|
|
* @mesh_strength: Mesh strength in Q4.12 format [0..4096]
|
|
*/
|
|
struct mali_c55_params_mesh_shading_selection {
|
|
struct v4l2_isp_params_block_header header;
|
|
__u8 mesh_alpha_bank_r;
|
|
__u8 mesh_alpha_bank_g;
|
|
__u8 mesh_alpha_bank_b;
|
|
__u8 mesh_alpha_r;
|
|
__u8 mesh_alpha_g;
|
|
__u8 mesh_alpha_b;
|
|
__u16 mesh_strength;
|
|
};
|
|
|
|
/**
|
|
* define MALI_C55_PARAMS_MAX_SIZE - Maximum size of all Mali C55 Parameters
|
|
*
|
|
* Though the parameters for the Mali-C55 are passed as optional blocks, the
|
|
* driver still needs to know the absolute maximum size so that it can allocate
|
|
* a buffer sized appropriately to accommodate userspace attempting to set all
|
|
* possible parameters in a single frame.
|
|
*
|
|
* Some structs are in this list multiple times. Where that's the case, it just
|
|
* reflects the fact that the same struct can be used with multiple different
|
|
* header types from :c:type:`mali_c55_param_block_type`.
|
|
*/
|
|
#define MALI_C55_PARAMS_MAX_SIZE \
|
|
(sizeof(struct mali_c55_params_sensor_off_preshading) + \
|
|
sizeof(struct mali_c55_params_aexp_hist) + \
|
|
sizeof(struct mali_c55_params_aexp_weights) + \
|
|
sizeof(struct mali_c55_params_aexp_hist) + \
|
|
sizeof(struct mali_c55_params_aexp_weights) + \
|
|
sizeof(struct mali_c55_params_digital_gain) + \
|
|
sizeof(struct mali_c55_params_awb_gains) + \
|
|
sizeof(struct mali_c55_params_awb_config) + \
|
|
sizeof(struct mali_c55_params_awb_gains) + \
|
|
sizeof(struct mali_c55_params_mesh_shading_config) + \
|
|
sizeof(struct mali_c55_params_mesh_shading_selection))
|
|
|
|
#endif /* __UAPI_MALI_C55_CONFIG_H */
|