Meg's Mirrors

zig

1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
2	/*
3	* ARM Mali-C55 ISP Driver - Userspace API
4	*
5	* Copyright (C) 2023 Ideas on Board Oy
6	*/
7
8	#ifndef __UAPI_MALI_C55_CONFIG_H
9	#define __UAPI_MALI_C55_CONFIG_H
10
11	#include <linux/types.h>
12	#include <linux/v4l2-controls.h>
13	#include <linux/media/v4l2-isp.h>
14
15	#define V4L2_CID_MALI_C55_CAPABILITIES (V4L2_CID_USER_MALI_C55_BASE + 0x0)
16	#define MALI_C55_GPS_PONG (1U << 0)
17	#define MALI_C55_GPS_WDR (1U << 1)
18	#define MALI_C55_GPS_COMPRESSION (1U << 2)
19	#define MALI_C55_GPS_TEMPER (1U << 3)
20	#define MALI_C55_GPS_SINTER_LITE (1U << 4)
21	#define MALI_C55_GPS_SINTER (1U << 5)
22	#define MALI_C55_GPS_IRIDIX_LTM (1U << 6)
23	#define MALI_C55_GPS_IRIDIX_GTM (1U << 7)
24	#define MALI_C55_GPS_CNR (1U << 8)
25	#define MALI_C55_GPS_FRSCALER (1U << 9)
26	#define MALI_C55_GPS_DS_PIPE (1U << 10)
27
28	/*
29	* Frames are split into zones of almost equal width and height - a zone is a
30	* rectangular tile of a frame. The metering blocks within the ISP collect
31	* aggregated statistics per zone. A maximum of 15x15 zones can be configured,
32	* and so the statistics buffer within the hardware is sized to accommodate
33	* that.
34	*
35	* The utilised number of zones is runtime configurable.
36	*/
37	#define MALI_C55_MAX_ZONES (15 * 15)
38
39	/**
40	* struct mali_c55_ae_1024bin_hist - Auto Exposure 1024-bin histogram statistics
41	*
42	* @bins: 1024 element array of 16-bit pixel counts.
43	*
44	* The 1024-bin histogram module collects image-global but zone-weighted
45	* intensity distributions of pixels in fixed-width bins. The modules can be
46	* configured into different "plane modes" which affect the contents of the
47	* collected statistics. In plane mode 0, pixel intensities are taken regardless
48	* of colour plane into a single 1024-bin histogram with a bin width of 4. In
49	* plane mode 1, four 256-bin histograms with a bin width of 16 are collected -
50	* one for each CFA colour plane. In plane modes 4, 5, 6 and 7 two 512-bin
51	* histograms with a bin width of 8 are collected - in each mode one of the
52	* colour planes is collected into the first histogram and all the others are
53	* combined into the second. The histograms are stored consecutively in the bins
54	* array.
55	*
56	* The 16-bit pixel counts are stored as a 4-bit exponent in the most
57	* significant bits followed by a 12-bit mantissa. Conversion to a usable
58	* format can be done according to the following pseudo-code::
59	*
60	* if (e == 0) {
61	* bin = m * 2;
62	* } else {
63	* bin = (m + 4096) * 2^e
64	* }
65	*
66	* where
67	* e is the exponent value in range 0..15
68	* m is the mantissa value in range 0..4095
69	*
70	* The pixels used in calculating the statistics can be masked using three
71	* methods:
72	*
73	* 1. Pixels can be skipped in X and Y directions independently.
74	* 2. Minimum/Maximum intensities can be configured
75	* 3. Zones can be differentially weighted, including 0 weighted to mask them
76	*
77	* The data for this histogram can be collected from different tap points in the
78	* ISP depending on configuration - after the white balance or digital gain
79	* blocks, or immediately after the input crossbar.
80	*/
81	struct mali_c55_ae_1024bin_hist {
82	__u16 bins[1024];
83	} __attribute__((packed));
84
85	/**
86	* struct mali_c55_ae_5bin_hist - Auto Exposure 5-bin histogram statistics
87	*
88	* @hist0: 16-bit normalised pixel count for the 0th intensity bin
89	* @hist1: 16-bit normalised pixel count for the 1st intensity bin
90	* @hist3: 16-bit normalised pixel count for the 3rd intensity bin
91	* @hist4: 16-bit normalised pixel count for the 4th intensity bin
92	*
93	* The ISP generates a 5-bin histogram of normalised pixel counts within bins of
94	* pixel intensity for each of 225 possible zones within a frame. The centre bin
95	* of the histogram for each zone is not available from the hardware and must be
96	* calculated by subtracting the values of hist0, hist1, hist3 and hist4 from
97	* 0xffff as in the following equation:
98	*
99	* hist2 = 0xffff - (hist0 + hist1 + hist3 + hist4)
100	*/
101	struct mali_c55_ae_5bin_hist {
102	__u16 hist0;
103	__u16 hist1;
104	__u16 hist3;
105	__u16 hist4;
106	} __attribute__((packed));
107
108	/**
109	* struct mali_c55_awb_average_ratios - Auto White Balance colour ratios
110	*
111	* @avg_rg_gr: Average R/G or G/R ratio in Q4.8 format.
112	* @avg_bg_br: Average B/G or B/R ratio in Q4.8 format.
113	* @num_pixels: The number of pixels used in the AWB calculation
114	*
115	* The ISP calculates and collects average colour ratios for each zone in an
116	* image and stores them in Q4.8 format (the lowest 8 bits are fractional, with
117	* bits [11:8] representing the integer). The exact ratios collected (either
118	* R/G, B/G or G/R, B/R) are configurable through the parameters buffer. The
119	* value of the 4 high bits is undefined.
120	*/
121	struct mali_c55_awb_average_ratios {
122	__u16 avg_rg_gr;
123	__u16 avg_bg_br;
124	__u32 num_pixels;
125	} __attribute__((packed));
126
127	/**
128	* struct mali_c55_af_statistics - Auto Focus edge and intensity statistics
129	*
130	* @intensity_stats: Packed mantissa and exponent value for pixel intensity
131	* @edge_stats: Packed mantissa and exponent values for edge intensity
132	*
133	* The ISP collects the squared sum of pixel intensities for each zone within a
134	* configurable Region of Interest on the frame. Additionally, the same data are
135	* collected after being passed through a bandpass filter which removes high and
136	* low frequency components - these are referred to as the edge statistics.
137	*
138	* The intensity and edge statistics for a zone can be used to calculate the
139	* contrast information for a zone
140	*
141	* C = E2 / I2
142	*
143	* Where I2 is the intensity statistic for a zone and E2 is the edge statistic
144	* for that zone. Optimum focus is reached when C is at its maximum.
145	*
146	* The intensity and edge statistics are stored packed into a non-standard 16
147	* bit floating point format, where the 7 most significant bits represent the
148	* exponent and the 9 least significant bits the mantissa. This format can be
149	* unpacked with the following pseudocode::
150	*
151	* if (e == 0) {
152	* x = m;
153	* } else {
154	* x = 2^e-1 * (m + 2^9)
155	* }
156	*
157	* where
158	* e is the exponent value in range 0..127
159	* m is the mantissa value in range 0..511
160	*/
161	struct mali_c55_af_statistics {
162	__u16 intensity_stats;
163	__u16 edge_stats;
164	} __attribute__((packed));
165
166	/**
167	* struct mali_c55_stats_buffer - 3A statistics for the mali-c55 ISP
168	*
169	* @ae_1024bin_hist: 1024-bin frame-global pixel intensity histogram
170	* @iridix_1024bin_hist: Post-Iridix block 1024-bin histogram
171	* @ae_5bin_hists: 5-bin pixel intensity histograms for AEC
172	* @reserved1: Undefined buffer space
173	* @awb_ratios: Color balance ratios for Auto White Balance
174	* @reserved2: Undefined buffer space
175	* @af_statistics: Pixel intensity statistics for Auto Focus
176	* @reserved3: Undefined buffer space
177	*
178	* This struct describes the metering statistics space in the Mali-C55 ISP's
179	* hardware in its entirety. The space between each defined area is marked as
180	* "unknown" and may not be 0, but should not be used. The @ae_5bin_hists,
181	* @awb_ratios and @af_statistics members are arrays of statistics per-zone.
182	* The zones are arranged in the array in raster order starting from the top
183	* left corner of the image.
184	*/
185
186	struct mali_c55_stats_buffer {
187	struct mali_c55_ae_1024bin_hist ae_1024bin_hist;
188	struct mali_c55_ae_1024bin_hist iridix_1024bin_hist;
189	struct mali_c55_ae_5bin_hist ae_5bin_hists[MALI_C55_MAX_ZONES];
190	__u32 reserved1[14];
191	struct mali_c55_awb_average_ratios awb_ratios[MALI_C55_MAX_ZONES];
192	__u32 reserved2[14];
193	struct mali_c55_af_statistics af_statistics[MALI_C55_MAX_ZONES];
194	__u32 reserved3[15];
195	} __attribute__((packed));
196
197	/**
198	* enum mali_c55_param_block_type - Enumeration of Mali-C55 parameter blocks
199	*
200	* This enumeration defines the types of Mali-C55 parameters block. Each block
201	* configures a specific processing block of the Mali-C55 ISP. The block
202	* type allows the driver to correctly interpret the parameters block data.
203	*
204	* It is the responsibility of userspace to correctly set the type of each
205	* parameters block.
206	*
207	* @MALI_C55_PARAM_BLOCK_SENSOR_OFFS: Sensor pre-shading black level offset
208	* @MALI_C55_PARAM_BLOCK_AEXP_HIST: Auto-exposure 1024-bin histogram
209	* configuration
210	* @MALI_C55_PARAM_BLOCK_AEXP_IHIST: Post-Iridix auto-exposure 1024-bin
211	* histogram configuration
212	* @MALI_C55_PARAM_BLOCK_AEXP_HIST_WEIGHTS: Auto-exposure 1024-bin histogram
213	* weighting
214	* @MALI_C55_PARAM_BLOCK_AEXP_IHIST_WEIGHTS: Post-Iridix auto-exposure 1024-bin
215	* histogram weighting
216	* @MALI_C55_PARAM_BLOCK_DIGITAL_GAIN: Digital gain
217	* @MALI_C55_PARAM_BLOCK_AWB_GAINS: Auto-white balance gains
218	* @MALI_C55_PARAM_BLOCK_AWB_CONFIG: Auto-white balance statistics config
219	* @MALI_C55_PARAM_BLOCK_AWB_GAINS_AEXP: Auto-white balance gains for AEXP-0 tap
220	* @MALI_C55_PARAM_MESH_SHADING_CONFIG : Mesh shading tables configuration
221	* @MALI_C55_PARAM_MESH_SHADING_SELECTION: Mesh shading table selection
222	*/
223	enum mali_c55_param_block_type {
224	MALI_C55_PARAM_BLOCK_SENSOR_OFFS,
225	MALI_C55_PARAM_BLOCK_AEXP_HIST,
226	MALI_C55_PARAM_BLOCK_AEXP_IHIST,
227	MALI_C55_PARAM_BLOCK_AEXP_HIST_WEIGHTS,
228	MALI_C55_PARAM_BLOCK_AEXP_IHIST_WEIGHTS,
229	MALI_C55_PARAM_BLOCK_DIGITAL_GAIN,
230	MALI_C55_PARAM_BLOCK_AWB_GAINS,
231	MALI_C55_PARAM_BLOCK_AWB_CONFIG,
232	MALI_C55_PARAM_BLOCK_AWB_GAINS_AEXP,
233	MALI_C55_PARAM_MESH_SHADING_CONFIG,
234	MALI_C55_PARAM_MESH_SHADING_SELECTION,
235	};
236
237	/**
238	* struct mali_c55_params_sensor_off_preshading - offset subtraction for each
239	* color channel
240	*
241	* Provides removal of the sensor black level from the sensor data. Separate
242	* offsets are provided for each of the four Bayer component color channels
243	* which are defaulted to R, Gr, Gb, B.
244	*
245	* header.type should be set to MALI_C55_PARAM_BLOCK_SENSOR_OFFS from
246	* :c:type:`mali_c55_param_block_type` for this block.
247	*
248	* @header: The Mali-C55 parameters block header
249	* @chan00: Offset for color channel 00 (default: R)
250	* @chan01: Offset for color channel 01 (default: Gr)
251	* @chan10: Offset for color channel 10 (default: Gb)
252	* @chan11: Offset for color channel 11 (default: B)
253	*/
254	struct mali_c55_params_sensor_off_preshading {
255	struct v4l2_isp_params_block_header header;
256	__u32 chan00;
257	__u32 chan01;
258	__u32 chan10;
259	__u32 chan11;
260	};
261
262	/**
263	* enum mali_c55_aexp_hist_tap_points - Tap points for the AEXP histogram
264	* @MALI_C55_AEXP_HIST_TAP_WB: After static white balance
265	* @MALI_C55_AEXP_HIST_TAP_FS: After WDR Frame Stitch
266	* @MALI_C55_AEXP_HIST_TAP_TPG: After the test pattern generator
267	*/
268	enum mali_c55_aexp_hist_tap_points {
269	MALI_C55_AEXP_HIST_TAP_WB = 0,
270	MALI_C55_AEXP_HIST_TAP_FS,
271	MALI_C55_AEXP_HIST_TAP_TPG,
272	};
273
274	/**
275	* enum mali_c55_aexp_skip_x - Horizontal pixel skipping
276	* @MALI_C55_AEXP_SKIP_X_EVERY_2ND: Collect every 2nd pixel horizontally
277	* @MALI_C55_AEXP_SKIP_X_EVERY_3RD: Collect every 3rd pixel horizontally
278	* @MALI_C55_AEXP_SKIP_X_EVERY_4TH: Collect every 4th pixel horizontally
279	* @MALI_C55_AEXP_SKIP_X_EVERY_5TH: Collect every 5th pixel horizontally
280	* @MALI_C55_AEXP_SKIP_X_EVERY_8TH: Collect every 8th pixel horizontally
281	* @MALI_C55_AEXP_SKIP_X_EVERY_9TH: Collect every 9th pixel horizontally
282	*/
283	enum mali_c55_aexp_skip_x {
284	MALI_C55_AEXP_SKIP_X_EVERY_2ND,
285	MALI_C55_AEXP_SKIP_X_EVERY_3RD,
286	MALI_C55_AEXP_SKIP_X_EVERY_4TH,
287	MALI_C55_AEXP_SKIP_X_EVERY_5TH,
288	MALI_C55_AEXP_SKIP_X_EVERY_8TH,
289	MALI_C55_AEXP_SKIP_X_EVERY_9TH
290	};
291
292	/**
293	* enum mali_c55_aexp_skip_y - Vertical pixel skipping
294	* @MALI_C55_AEXP_SKIP_Y_ALL: Collect every single pixel vertically
295	* @MALI_C55_AEXP_SKIP_Y_EVERY_2ND: Collect every 2nd pixel vertically
296	* @MALI_C55_AEXP_SKIP_Y_EVERY_3RD: Collect every 3rd pixel vertically
297	* @MALI_C55_AEXP_SKIP_Y_EVERY_4TH: Collect every 4th pixel vertically
298	* @MALI_C55_AEXP_SKIP_Y_EVERY_5TH: Collect every 5th pixel vertically
299	* @MALI_C55_AEXP_SKIP_Y_EVERY_8TH: Collect every 8th pixel vertically
300	* @MALI_C55_AEXP_SKIP_Y_EVERY_9TH: Collect every 9th pixel vertically
301	*/
302	enum mali_c55_aexp_skip_y {
303	MALI_C55_AEXP_SKIP_Y_ALL,
304	MALI_C55_AEXP_SKIP_Y_EVERY_2ND,
305	MALI_C55_AEXP_SKIP_Y_EVERY_3RD,
306	MALI_C55_AEXP_SKIP_Y_EVERY_4TH,
307	MALI_C55_AEXP_SKIP_Y_EVERY_5TH,
308	MALI_C55_AEXP_SKIP_Y_EVERY_8TH,
309	MALI_C55_AEXP_SKIP_Y_EVERY_9TH
310	};
311
312	/**
313	* enum mali_c55_aexp_row_column_offset - Start from the first or second row or
314	* column
315	* @MALI_C55_AEXP_FIRST_ROW_OR_COL: Start from the first row / column
316	* @MALI_C55_AEXP_SECOND_ROW_OR_COL: Start from the second row / column
317	*/
318	enum mali_c55_aexp_row_column_offset {
319	MALI_C55_AEXP_FIRST_ROW_OR_COL = 1,
320	MALI_C55_AEXP_SECOND_ROW_OR_COL = 2,
321	};
322
323	/**
324	* enum mali_c55_aexp_hist_plane_mode - Mode for the AEXP Histograms
325	* @MALI_C55_AEXP_HIST_COMBINED: All color planes in one 1024-bin histogram
326	* @MALI_C55_AEXP_HIST_SEPARATE: Each color plane in one 256-bin histogram with a bin width of 16
327	* @MALI_C55_AEXP_HIST_FOCUS_00: Top left plane in the first bank, rest in second bank
328	* @MALI_C55_AEXP_HIST_FOCUS_01: Top right plane in the first bank, rest in second bank
329	* @MALI_C55_AEXP_HIST_FOCUS_10: Bottom left plane in the first bank, rest in second bank
330	* @MALI_C55_AEXP_HIST_FOCUS_11: Bottom right plane in the first bank, rest in second bank
331	*
332	* In the "focus" modes statistics are collected into two 512-bin histograms
333	* with a bin width of 8. One colour plane is in the first histogram with the
334	* remainder combined into the second. The four options represent which of the
335	* four positions in a bayer pattern are the focused plane.
336	*/
337	enum mali_c55_aexp_hist_plane_mode {
338	MALI_C55_AEXP_HIST_COMBINED = 0,
339	MALI_C55_AEXP_HIST_SEPARATE = 1,
340	MALI_C55_AEXP_HIST_FOCUS_00 = 4,
341	MALI_C55_AEXP_HIST_FOCUS_01 = 5,
342	MALI_C55_AEXP_HIST_FOCUS_10 = 6,
343	MALI_C55_AEXP_HIST_FOCUS_11 = 7,
344	};
345
346	/**
347	* struct mali_c55_params_aexp_hist - configuration for AEXP metering hists
348	*
349	* This struct allows users to configure the 1024-bin AEXP histograms. Broadly
350	* speaking the parameters allow you to mask particular regions of the image and
351	* to select different kinds of histogram.
352	*
353	* The skip_x, offset_x, skip_y and offset_y fields allow users to ignore or
354	* mask pixels in the frame by their position relative to the top left pixel.
355	* First, the skip_y, offset_x and offset_y fields define which of the pixels
356	* within each 2x2 region will be counted in the statistics.
357	*
358	* If skip_y == 0 then two pixels from each covered region will be counted. If
359	* both offset_x and offset_y are zero, then the two left-most pixels in each
360	* 2x2 pixel region will be counted. Setting offset_x = 1 will discount the top
361	* left pixel and count the top right pixel. Setting offset_y = 1 will discount
362	* the bottom left pixel and count the bottom right pixel.
363	*
364	* If skip_y != 0 then only a single pixel from each region covered by the
365	* pattern will be counted. In this case offset_x controls whether the pixel
366	* that's counted is in the left (if offset_x == 0) or right (if offset_x == 1)
367	* column and offset_y controls whether the pixel that's counted is in the top
368	* (if offset_y == 0) or bottom (if offset_y == 1) row.
369	*
370	* The skip_x and skip_y fields control how the 2x2 pixel region is repeated
371	* across the image data. The first instance of the region is always in the top
372	* left of the image data. The skip_x field controls how many pixels are ignored
373	* in the x direction before the pixel masking region is repeated. The skip_y
374	* field controls how many pixels are ignored in the y direction before the
375	* pixel masking region is repeated.
376	*
377	* These fields can be used to reduce the number of pixels counted for the
378	* statistics, but it's important to be careful to configure them correctly.
379	* Some combinations of values will result in colour components from the input
380	* data being ignored entirely, for example in the following configuration:
381	*
382	* skip_x = 0
383	* offset_x = 0
384	* skip_y = 0
385	* offset_y = 0
386	*
387	* Only the R and Gb components of RGGB data that was input would be collected.
388	* Similarly in the following configuration:
389	*
390	* skip_x = 0
391	* offset_x = 0
392	* skip_y = 1
393	* offset_y = 1
394	*
395	* Only the Gb component of RGGB data that was input would be collected. To
396	* correct things such that all 4 colour components were included it would be
397	* necessary to set the skip_x and skip_y fields in a way that resulted in all
398	* four colour components being collected:
399	*
400	* skip_x = 1
401	* offset_x = 0
402	* skip_y = 1
403	* offset_y = 1
404	*
405	* header.type should be set to one of either MALI_C55_PARAM_BLOCK_AEXP_HIST or
406	* MALI_C55_PARAM_BLOCK_AEXP_IHIST from :c:type:`mali_c55_param_block_type`.
407	*
408	* @header: The Mali-C55 parameters block header
409	* @skip_x: Horizontal decimation. See enum mali_c55_aexp_skip_x
410	* @offset_x: Skip the first column, or not. See enum mali_c55_aexp_row_column_offset
411	* @skip_y: Vertical decimation. See enum mali_c55_aexp_skip_y
412	* @offset_y: Skip the first row, or not. See enum mali_c55_aexp_row_column_offset
413	* @scale_bottom: Scale pixels in bottom half of intensity range: 0=1x ,1=2x, 2=4x, 4=8x, 4=16x
414	* @scale_top: scale pixels in top half of intensity range: 0=1x ,1=2x, 2=4x, 4=8x, 4=16x
415	* @plane_mode: Plane separation mode. See enum mali_c55_aexp_hist_plane_mode
416	* @tap_point: Tap point for histogram from enum mali_c55_aexp_hist_tap_points.
417	* This parameter is unused for the post-Iridix Histogram
418	*/
419	struct mali_c55_params_aexp_hist {
420	struct v4l2_isp_params_block_header header;
421	__u8 skip_x;
422	__u8 offset_x;
423	__u8 skip_y;
424	__u8 offset_y;
425	__u8 scale_bottom;
426	__u8 scale_top;
427	__u8 plane_mode;
428	__u8 tap_point;
429	};
430
431	/**
432	* struct mali_c55_params_aexp_weights - Array of weights for AEXP metering
433	*
434	* This struct allows users to configure the weighting for both of the 1024-bin
435	* AEXP histograms. The pixel data collected for each zone is multiplied by the
436	* corresponding weight from this array, which may be zero if the intention is
437	* to mask off the zone entirely.
438	*
439	* header.type should be set to one of either MALI_C55_PARAM_BLOCK_AEXP_HIST_WEIGHTS
440	* or MALI_C55_PARAM_BLOCK_AEXP_IHIST_WEIGHTS from :c:type:`mali_c55_param_block_type`.
441	*
442	* @header: The Mali-C55 parameters block header
443	* @nodes_used_horiz: Number of active zones horizontally [0..15]
444	* @nodes_used_vert: Number of active zones vertically [0..15]
445	* @zone_weights: Zone weighting. Index is row*col where 0,0 is the top
446	* left zone continuing in raster order. Each zone can be
447	* weighted in the range [0..15]. The number of rows and
448	* columns is defined by @nodes_used_vert and
449	* @nodes_used_horiz
450	*/
451	struct mali_c55_params_aexp_weights {
452	struct v4l2_isp_params_block_header header;
453	__u8 nodes_used_horiz;
454	__u8 nodes_used_vert;
455	__u8 zone_weights[MALI_C55_MAX_ZONES];
456	};
457
458	/**
459	* struct mali_c55_params_digital_gain - Digital gain value
460	*
461	* This struct carries a digital gain value to set in the ISP.
462	*
463	* header.type should be set to MALI_C55_PARAM_BLOCK_DIGITAL_GAIN from
464	* :c:type:`mali_c55_param_block_type` for this block.
465	*
466	* @header: The Mali-C55 parameters block header
467	* @gain: The digital gain value to apply, in Q5.8 format.
468	*/
469	struct mali_c55_params_digital_gain {
470	struct v4l2_isp_params_block_header header;
471	__u16 gain;
472	};
473
474	/**
475	* enum mali_c55_awb_stats_mode - Statistics mode for AWB
476	* @MALI_C55_AWB_MODE_GRBR: Statistics collected as Green/Red and Blue/Red ratios
477	* @MALI_C55_AWB_MODE_RGBG: Statistics collected as Red/Green and Blue/Green ratios
478	*/
479	enum mali_c55_awb_stats_mode {
480	MALI_C55_AWB_MODE_GRBR = 0,
481	MALI_C55_AWB_MODE_RGBG,
482	};
483
484	/**
485	* struct mali_c55_params_awb_gains - Gain settings for auto white balance
486	*
487	* This struct allows users to configure the gains for auto-white balance. There
488	* are four gain settings corresponding to each colour channel in the bayer
489	* domain. Although named generically, the association between the gain applied
490	* and the colour channel is done automatically within the ISP depending on the
491	* input format, and so the following mapping always holds true::
492	*
493	* gain00 = R
494	* gain01 = Gr
495	* gain10 = Gb
496	* gain11 = B
497	*
498	* All of the gains are stored in Q4.8 format.
499	*
500	* header.type should be set to one of either MALI_C55_PARAM_BLOCK_AWB_GAINS or
501	* MALI_C55_PARAM_BLOCK_AWB_GAINS_AEXP from :c:type:`mali_c55_param_block_type`.
502	*
503	* @header: The Mali-C55 parameters block header
504	* @gain00: Multiplier for colour channel 00
505	* @gain01: Multiplier for colour channel 01
506	* @gain10: Multiplier for colour channel 10
507	* @gain11: Multiplier for colour channel 11
508	*/
509	struct mali_c55_params_awb_gains {
510	struct v4l2_isp_params_block_header header;
511	__u16 gain00;
512	__u16 gain01;
513	__u16 gain10;
514	__u16 gain11;
515	};
516
517	/**
518	* enum mali_c55_params_awb_tap_points - Tap points for the AWB statistics
519	* @MALI_C55_AWB_STATS_TAP_PF: Immediately after the Purple Fringe block
520	* @MALI_C55_AWB_STATS_TAP_CNR: Immediately after the CNR block
521	*/
522	enum mali_c55_params_awb_tap_points {
523	MALI_C55_AWB_STATS_TAP_PF = 0,
524	MALI_C55_AWB_STATS_TAP_CNR,
525	};
526
527	/**
528	* struct mali_c55_params_awb_config - Stats settings for auto-white balance
529	*
530	* This struct allows the configuration of the statistics generated for auto
531	* white balance. Pixel intensity limits can be set to exclude overly bright or
532	* dark regions of an image from the statistics entirely. Colour ratio minima
533	* and maxima can be set to discount pixels who's ratios fall outside the
534	* defined boundaries; there are two sets of registers to do this - the
535	* "min/max" ratios which bound a region and the "high/low" ratios which further
536	* trim the upper and lower ratios. For example with the boundaries configured
537	* as follows, only pixels whos colour ratios falls into the region marked "A"
538	* would be counted::
539	*
540	* cr_high
541	* 2.0 | |
542	* | cb_max --> _________________________v_____
543	* 1.8 | | \ |
544	* | | \ |
545	* 1.6 | | \ |
546	* | | \ |
547	* c 1.4 | cb_low -->|\ A \|<-- cb_high
548	* b | | \ |
549	* 1.2 | | \ |
550	* r | | \ |
551	* a 1.0 | cb_min --> |____\_________________________|
552	* t | ^ ^ ^
553	* i 0.8 | | | |
554	* o | cr_min | cr_max
555	* s 0.6 | |
556	* | cr_low
557	* 0.4 |
558	* |
559	* 0.2 |
560	* |
561	* 0.0 |_______________________________________________________________
562	* 0.0 0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6 1.8 2.0
563	* cr ratios
564	*
565	* header.type should be set to MALI_C55_PARAM_BLOCK_AWB_CONFIG from
566	* :c:type:`mali_c55_param_block_type` for this block.
567	*
568	* @header: The Mali-C55 parameters block header
569	* @tap_point: The tap point from enum mali_c55_params_awb_tap_points
570	* @stats_mode: AWB statistics collection mode, see :c:type:`mali_c55_awb_stats_mode`
571	* @white_level: Upper pixel intensity (I.E. raw pixel values) limit
572	* @black_level: Lower pixel intensity (I.E. raw pixel values) limit
573	* @cr_max: Maximum R/G ratio (Q4.8 format)
574	* @cr_min: Minimum R/G ratio (Q4.8 format)
575	* @cb_max: Maximum B/G ratio (Q4.8 format)
576	* @cb_min: Minimum B/G ratio (Q4.8 format)
577	* @nodes_used_horiz: Number of active zones horizontally [0..15]
578	* @nodes_used_vert: Number of active zones vertically [0..15]
579	* @cr_high: R/G ratio trim high (Q4.8 format)
580	* @cr_low: R/G ratio trim low (Q4.8 format)
581	* @cb_high: B/G ratio trim high (Q4.8 format)
582	* @cb_low: B/G ratio trim low (Q4.8 format)
583	*/
584	struct mali_c55_params_awb_config {
585	struct v4l2_isp_params_block_header header;
586	__u8 tap_point;
587	__u8 stats_mode;
588	__u16 white_level;
589	__u16 black_level;
590	__u16 cr_max;
591	__u16 cr_min;
592	__u16 cb_max;
593	__u16 cb_min;
594	__u8 nodes_used_horiz;
595	__u8 nodes_used_vert;
596	__u16 cr_high;
597	__u16 cr_low;
598	__u16 cb_high;
599	__u16 cb_low;
600	};
601
602	#define MALI_C55_NUM_MESH_SHADING_ELEMENTS 3072
603
604	/**
605	* struct mali_c55_params_mesh_shading_config - Mesh shading configuration
606	*
607	* The mesh shading correction module allows programming a separate table of
608	* either 16x16 or 32x32 node coefficients for 3 different light sources. The
609	* final correction coefficients applied are computed by blending the
610	* coefficients from two tables together.
611	*
612	* A page of 1024 32-bit integers is associated to each colour channel, with
613	* pages stored consecutively in memory. Each 32-bit integer packs 3 8-bit
614	* correction coefficients for a single node, one for each of the three light
615	* sources. The 8 most significant bits are unused. The following table
616	* describes the layout::
617	*
618	* +----------- Page (Colour Plane) 0 -------------+
619	* | @mesh[i] | Mesh Point | Bits | Light Source |
620	* +-----------+------------+-------+--------------+
621	* | 0 | 0,0 | 16,23 | LS2 |
622	* | | | 08-15 | LS1 |
623	* | | | 00-07 | LS0 |
624	* +-----------+------------+-------+--------------+
625	* | 1 | 0,1 | 16,23 | LS2 |
626	* | | | 08-15 | LS1 |
627	* | | | 00-07 | LS0 |
628	* +-----------+------------+-------+--------------+
629	* | ... | ... | ... | ... |
630	* +-----------+------------+-------+--------------+
631	* | 1023 | 31,31 | 16,23 | LS2 |
632	* | | | 08-15 | LS1 |
633	* | | | 00-07 | LS0 |
634	* +----------- Page (Colour Plane) 1 -------------+
635	* | @mesh[i] | Mesh Point | Bits | Light Source |
636	* +-----------+------------+-------+--------------+
637	* | 1024 | 0,0 | 16,23 | LS2 |
638	* | | | 08-15 | LS1 |
639	* | | | 00-07 | LS0 |
640	* +-----------+------------+-------+--------------+
641	* | 1025 | 0,1 | 16,23 | LS2 |
642	* | | | 08-15 | LS1 |
643	* | | | 00-07 | LS0 |
644	* +-----------+------------+-------+--------------+
645	* | ... | ... | ... | ... |
646	* +-----------+------------+-------+--------------+
647	* | 2047 | 31,31 | 16,23 | LS2 |
648	* | | | 08-15 | LS1 |
649	* | | | 00-07 | LS0 |
650	* +----------- Page (Colour Plane) 2 -------------+
651	* | @mesh[i] | Mesh Point | Bits | Light Source |
652	* +-----------+------------+-------+--------------+
653	* | 2048 | 0,0 | 16,23 | LS2 |
654	* | | | 08-15 | LS1 |
655	* | | | 00-07 | LS0 |
656	* +-----------+------------+-------+--------------+
657	* | 2049 | 0,1 | 16,23 | LS2 |
658	* | | | 08-15 | LS1 |
659	* | | | 00-07 | LS0 |
660	* +-----------+------------+-------+--------------+
661	* | ... | ... | ... | ... |
662	* +-----------+------------+-------+--------------+
663	* | 3071 | 31,31 | 16,23 | LS2 |
664	* | | | 08-15 | LS1 |
665	* | | | 00-07 | LS0 |
666	* +-----------+------------+-------+--------------+
667	*
668	* The @mesh_scale member determines the precision and minimum and maximum gain.
669	* For example if @mesh_scale is 0 and therefore selects 0 - 2x gain, a value of
670	* 0 in a coefficient means 0.0 gain, a value of 128 means 1.0 gain and 255
671	* means 2.0 gain.
672	*
673	* header.type should be set to MALI_C55_PARAM_MESH_SHADING_CONFIG from
674	* :c:type:`mali_c55_param_block_type` for this block.
675	*
676	* @header: The Mali-C55 parameters block header
677	* @mesh_show: Output the mesh data rather than image data
678	* @mesh_scale: Set the precision and maximum gain range of mesh shading
679	* - 0 = 0-2x gain
680	* - 1 = 0-4x gain
681	* - 2 = 0-8x gain
682	* - 3 = 0-16x gain
683	* - 4 = 1-2x gain
684	* - 5 = 1-3x gain
685	* - 6 = 1-5x gain
686	* - 7 = 1-9x gain
687	* @mesh_page_r: Mesh page select for red colour plane [0..2]
688	* @mesh_page_g: Mesh page select for green colour plane [0..2]
689	* @mesh_page_b: Mesh page select for blue colour plane [0..2]
690	* @mesh_width: Number of horizontal nodes minus 1 [15,31]
691	* @mesh_height: Number of vertical nodes minus 1 [15,31]
692	* @mesh: Mesh shading correction tables
693	*/
694	struct mali_c55_params_mesh_shading_config {
695	struct v4l2_isp_params_block_header header;
696	__u8 mesh_show;
697	__u8 mesh_scale;
698	__u8 mesh_page_r;
699	__u8 mesh_page_g;
700	__u8 mesh_page_b;
701	__u8 mesh_width;
702	__u8 mesh_height;
703	__u32 mesh[MALI_C55_NUM_MESH_SHADING_ELEMENTS];
704	};
705
706	/** enum mali_c55_params_mesh_alpha_bank - Mesh shading table bank selection
707	* @MALI_C55_MESH_ALPHA_BANK_LS0_AND_LS1 - Select Light Sources 0 and 1
708	* @MALI_C55_MESH_ALPHA_BANK_LS1_AND_LS2 - Select Light Sources 1 and 2
709	* @MALI_C55_MESH_ALPHA_BANK_LS0_AND_LS2 - Select Light Sources 0 and 2
710	*/
711	enum mali_c55_params_mesh_alpha_bank {
712	MALI_C55_MESH_ALPHA_BANK_LS0_AND_LS1 = 0,
713	MALI_C55_MESH_ALPHA_BANK_LS1_AND_LS2 = 1,
714	MALI_C55_MESH_ALPHA_BANK_LS0_AND_LS2 = 4
715	};
716
717	/**
718	* struct mali_c55_params_mesh_shading_selection - Mesh table selection
719	*
720	* The module computes the final correction coefficients by blending the ones
721	* from two light source tables, which are selected (independently for each
722	* colour channel) by the @mesh_alpha_bank_r/g/b fields.
723	*
724	* The final blended coefficients for each node are calculated using the
725	* following equation:
726	*
727	* Final coefficient = (a * LS\ :sub:`b`\ + (256 - a) * LS\ :sub:`a`\) / 256
728	*
729	* Where a is the @mesh_alpha_r/g/b value, and LS\ :sub:`a`\ and LS\ :sub:`b`\
730	* are the node cofficients for the two tables selected by the
731	* @mesh_alpha_bank_r/g/b value.
732	*
733	* The scale of the applied correction may also be controlled by tuning the
734	* @mesh_strength member. This is a modifier to the final coefficients which can
735	* be used to globally reduce the gains applied.
736	*
737	* header.type should be set to MALI_C55_PARAM_MESH_SHADING_SELECTION from
738	* :c:type:`mali_c55_param_block_type` for this block.
739	*
740	* @header: The Mali-C55 parameters block header
741	* @mesh_alpha_bank_r: Red mesh table select (c:type:`enum mali_c55_params_mesh_alpha_bank`)
742	* @mesh_alpha_bank_g: Green mesh table select (c:type:`enum mali_c55_params_mesh_alpha_bank`)
743	* @mesh_alpha_bank_b: Blue mesh table select (c:type:`enum mali_c55_params_mesh_alpha_bank`)
744	* @mesh_alpha_r: Blend coefficient for R [0..255]
745	* @mesh_alpha_g: Blend coefficient for G [0..255]
746	* @mesh_alpha_b: Blend coefficient for B [0..255]
747	* @mesh_strength: Mesh strength in Q4.12 format [0..4096]
748	*/
749	struct mali_c55_params_mesh_shading_selection {
750	struct v4l2_isp_params_block_header header;
751	__u8 mesh_alpha_bank_r;
752	__u8 mesh_alpha_bank_g;
753	__u8 mesh_alpha_bank_b;
754	__u8 mesh_alpha_r;
755	__u8 mesh_alpha_g;
756	__u8 mesh_alpha_b;
757	__u16 mesh_strength;
758	};
759
760	/**
761	* define MALI_C55_PARAMS_MAX_SIZE - Maximum size of all Mali C55 Parameters
762	*
763	* Though the parameters for the Mali-C55 are passed as optional blocks, the
764	* driver still needs to know the absolute maximum size so that it can allocate
765	* a buffer sized appropriately to accommodate userspace attempting to set all
766	* possible parameters in a single frame.
767	*
768	* Some structs are in this list multiple times. Where that's the case, it just
769	* reflects the fact that the same struct can be used with multiple different
770	* header types from :c:type:`mali_c55_param_block_type`.
771	*/
772	#define MALI_C55_PARAMS_MAX_SIZE \
773	(sizeof(struct mali_c55_params_sensor_off_preshading) + \
774	sizeof(struct mali_c55_params_aexp_hist) + \
775	sizeof(struct mali_c55_params_aexp_weights) + \
776	sizeof(struct mali_c55_params_aexp_hist) + \
777	sizeof(struct mali_c55_params_aexp_weights) + \
778	sizeof(struct mali_c55_params_digital_gain) + \
779	sizeof(struct mali_c55_params_awb_gains) + \
780	sizeof(struct mali_c55_params_awb_config) + \
781	sizeof(struct mali_c55_params_awb_gains) + \
782	sizeof(struct mali_c55_params_mesh_shading_config) + \
783	sizeof(struct mali_c55_params_mesh_shading_selection))
784
785	#endif /* __UAPI_MALI_C55_CONFIG_H */