1 /*
2 *
3 * SPDX-License-Identifier: GPL-2.0
4 *
5 * Copyright (C) 2011-2018 ARM or its affiliates
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; version 2.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
12 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * for more details.
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17 *
18 */
19
20 #include "acamera.h"
21 #include "revision.h"
22 #include "acamera_command_api.h"
23 #include "acamera_command_api_impl.h"
24 #include "acamera_fw.h"
25 #include "acamera_types.h"
26 #include "acamera_calibrations.h"
27 #if defined( ISP_HAS_AF_LMS_FSM ) || defined( ISP_HAS_AF_MANUAL_FSM )
28 #include "acamera_sbus_api.h"
29 #endif
30 #include "acamera_math.h"
31 #if ISP_HAS_GENERAL_FSM
32 #include "general_fsm.h"
33 #endif
34
35 #include "acamera_isp_config.h"
36
37
38 #if ISP_HAS_FPGA_WRAPPER
39 #include "acamera_fpga_config.h"
40 #endif
41
42 #include "acamera_fsm_mgr.h"
43 #include "acamera_types.h"
44 #include "system_timer.h"
45 #include "acamera_firmware_api.h"
46 #include "acamera_firmware_config.h"
47 #include "system_am_sc.h"
48
49 #if ISP_HAS_CMOS_FSM
50 #include "cmos_fsm.h"
51 #endif
52
53 #if ISP_HAS_MATRIX_YUV_FSM
54 #include "matrix_yuv_fsm.h" // for PIPE_OUT_RGB
55 #endif
56
57 #include "acamera_logger.h"
58
59 #define D1E6 1000000
60
61
62 #ifdef CALIBRATION_DEFECT_PIXELS
63 extern int32_t defect_pixel_table_write( uint32_t *dp_table, uint32_t size );
64 extern int32_t defect_pixel_table_read( uint32_t *dp_table, uint32_t size );
65 #endif
66
67 #if FW_HAS_CONTROL_CHANNEL
68 #include "acamera_ctrl_channel.h"
69 #endif
70
71 #include "fsm_param.h"
72
73 extern int32_t acamera_set_api_context( uint32_t ctx_num );
74 extern int32_t acamera_get_api_context( void );
75 extern int32_t acamera_get_context_number( void );
76 extern void *acamera_get_api_ctx_ptr( void );
77 extern void *acamera_get_ctx_ptr( uint32_t ctx_id );
78
isp_safe_stop(uint32_t base)79 static uint8_t isp_safe_stop( uint32_t base )
80 {
81 uint16_t sleep_in_us = 2 * 1000;
82 uint8_t count = 0;
83 uint8_t rc = 0;
84
85 acamera_isp_input_port_mode_request_write( base, ACAMERA_ISP_INPUT_PORT_MODE_REQUEST_SAFE_STOP );
86
87 // check whether the HW is stopped or not.
88 while ( acamera_isp_input_port_mode_status_read( base ) != ACAMERA_ISP_INPUT_PORT_MODE_REQUEST_SAFE_STOP ) {
89 system_timer_usleep( sleep_in_us );
90
91 // it should be stopped within 1 frame, normally is 33ms for 30 fps.
92 // we set the timeout as 100 ms here in case the system_timer is not implemented correctly.
93 count++;
94 if ( count > 50 ) {
95 LOG( LOG_CRIT, "stop fsm_mgr failed, timeout: %u.", (unsigned int)count * sleep_in_us );
96 rc = 1;
97 break;
98 }
99 }
100
101 return rc;
102 }
103
isp_safe_start(uint32_t base)104 static uint8_t isp_safe_start( uint32_t base )
105 {
106 uint16_t sleep_in_us = 2 * 1000;
107 uint8_t count = 0;
108 uint8_t rc = 0;
109
110 acamera_isp_input_port_mode_request_write( base, ACAMERA_ISP_INPUT_PORT_MODE_REQUEST_SAFE_START );
111
112 // check whether the HW is started or not.
113 while ( acamera_isp_input_port_mode_status_read( base ) != ACAMERA_ISP_INPUT_PORT_MODE_REQUEST_SAFE_START ) {
114 system_timer_usleep( sleep_in_us );
115
116 // it should be start within 1 frame, normally is 33ms for 30 fps.
117 // we set the timeout as 100 ms here in case the system_timer is not implemented correctly.
118 count++;
119 if ( count > 50 ) {
120 LOG( LOG_CRIT, "start fsm_mgr failed, timeout: %u.", (unsigned int)count * sleep_in_us );
121 rc = 1;
122 break;
123 }
124 }
125
126 return rc;
127 }
128
129 #ifdef CONTEXT_NUMBER
general_context_number(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)130 uint8_t general_context_number( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
131 {
132 uint32_t result = NOT_SUPPORTED;
133 *ret_value = 0;
134 if ( direction == COMMAND_GET ) {
135 *ret_value = acamera_get_context_number();
136 result = SUCCESS;
137 } else if ( direction == COMMAND_SET ) {
138 result = NOT_SUPPORTED;
139 }
140 return result;
141 }
142 #endif
143
144
145 #ifdef ACTIVE_CONTEXT
general_active_context(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)146 uint8_t general_active_context( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
147 {
148 uint32_t result = NOT_SUPPORTED;
149 *ret_value = 0;
150 if ( direction == COMMAND_GET ) {
151 *ret_value = acamera_get_api_context();
152 result = SUCCESS;
153 } else if ( direction == COMMAND_SET ) {
154 acamera_set_api_context( value );
155 result = SUCCESS;
156 }
157 return result;
158 }
159 #endif
160
161
162 #ifdef DMA_WRITER_SINGLE_FRAME_MODE
dma_writer_single_frame(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)163 uint8_t dma_writer_single_frame( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
164 {
165 uint32_t result = NOT_SUPPORTED;
166 *ret_value = 0;
167 if ( direction == COMMAND_GET ) {
168 if ( acamera_isp_fr_dma_writer_single_frame_read( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base ) )
169 *ret_value = ON;
170 else
171 *ret_value = OFF;
172 result = SUCCESS;
173 } else if ( direction == COMMAND_SET ) {
174 if ( value == ON || value == OFF ) {
175 acamera_isp_fr_dma_writer_single_frame_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, ( value == ON ) ? 1 : 0 );
176 result = SUCCESS;
177 } else {
178 result = FAIL;
179 }
180 }
181 return result;
182 }
183 #endif
184
185 #ifdef DMA_RAW_CAPTURE_ENABLED_ID
dma_raw_capture_enable_api(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)186 uint8_t dma_raw_capture_enable_api( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
187 {
188 uint32_t result = NOT_SUPPORTED;
189 *ret_value = 0;
190 #if ISP_DMA_RAW_CAPTURE
191 if ( direction == COMMAND_SET ) {
192 if ( value == ON ) {
193 dma_raw_capture_start( ACAMERA_MGR2FIRMWARE_PTR( instance ) );
194 result = SUCCESS;
195 } else if ( value == OFF ) {
196 dma_capture_stop( ACAMERA_MGR2FIRMWARE_PTR( instance ) );
197 result = SUCCESS;
198 } else {
199 result = FAIL;
200 }
201 } else if ( direction == COMMAND_GET ) {
202 if ( dma_raw_capture_status_capture( ACAMERA_MGR2FIRMWARE_PTR( instance ) ) )
203 *ret_value = ON;
204 else
205 *ret_value = OFF;
206 result = SUCCESS;
207 }
208 #endif
209 return result;
210 }
211 #endif
212
213 #ifdef DMA_RAW_CAPTURE_WRITEON_ID
dma_raw_capture_writeon_api(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)214 uint8_t dma_raw_capture_writeon_api( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
215 {
216 uint32_t result = NOT_SUPPORTED;
217 *ret_value = 0;
218 #if ISP_DMA_RAW_CAPTURE
219 if ( direction == COMMAND_SET ) {
220 if ( value == 1 || value == 0 ) {
221 dma_raw_capture_writeon( ACAMERA_MGR2FIRMWARE_PTR( instance ), value );
222 result = SUCCESS;
223 } else {
224 result = FAIL;
225 }
226 } else if ( direction == COMMAND_GET ) {
227 *ret_value = dma_raw_capture_status_writeon( ACAMERA_MGR2FIRMWARE_PTR( instance ) );
228 result = SUCCESS;
229 }
230 #endif
231 return result;
232 }
233 #endif
234
235 #ifdef SENSOR_STREAMING
sensor_streaming(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)236 uint8_t sensor_streaming( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
237 {
238 uint8_t result = SUCCESS;
239
240 *ret_value = 0;
241 if ( direction == COMMAND_GET ) {
242 uint32_t is_streaming = 0;
243 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_STREAMING, NULL, 0, &is_streaming, sizeof( is_streaming ) );
244 *ret_value = is_streaming ? ON : OFF;
245 } else {
246 uint32_t is_streaming = 0;
247
248 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_STREAMING, NULL, 0, &is_streaming, sizeof( is_streaming ) );
249
250 if ( ( value == OFF ) && is_streaming ) {
251 uint32_t streaming = 0;
252 instance->isp_seamless = 0;
253 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_SENSOR_STREAMING, &streaming, sizeof( streaming ) );
254 isp_safe_stop( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base );
255 } else if ( ( value == ON ) && !is_streaming ) {
256 uint32_t streaming = 1;
257
258 if(instance->isp_seamless)
259 {
260 if(acamera_isp_input_port_mode_status_read( 0 ) == ACAMERA_ISP_INPUT_PORT_MODE_REQUEST_SAFE_START)
261 {
262 streaming = 2;
263 }
264 }
265
266 acamera_fsm_mgr_set_param(instance, FSM_PARAM_SET_AUTOCAP_HW_RESET, NULL, 0 );
267
268 acamera_reset_ping_pong_port();
269 acamera_update_cur_settings_to_isp(ISP_CONFIG_PING);
270
271 acamera_api_dma_buff_get_next(instance->ctx_id, dma_fr);
272 acamera_update_cur_settings_to_isp(ISP_CONFIG_PONG);
273
274 acamera_isp_isp_global_interrupt_mask_vector_write( 0, ISP_IRQ_MASK_VECTOR );
275 acamera_isp_isp_global_mcu_override_config_select_write( 0, 1 );
276
277 isp_safe_start( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base );
278 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_SENSOR_STREAMING, &streaming, sizeof( streaming ) );
279 } else {
280 result = NOT_SUPPORTED;
281 }
282 }
283
284 return result;
285 }
286 #endif
287
288 #ifdef SENSOR_SUPPORTED_PRESETS
sensor_supported_presets(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)289 uint8_t sensor_supported_presets( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
290 {
291 *ret_value = 0;
292 if ( direction == COMMAND_GET ) {
293 const sensor_param_t *param = NULL;
294 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_PARAM, NULL, 0, ¶m, sizeof( param ) );
295
296 *ret_value = param->modes_num;
297 return SUCCESS;
298 } else {
299 return NOT_SUPPORTED;
300 }
301 }
302 #endif
303
304
305 #ifdef SENSOR_PRESET
sensor_preset(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)306 uint8_t sensor_preset( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
307 {
308 uint32_t result = SUCCESS;
309 *ret_value = 0;
310
311 const sensor_param_t *param = NULL;
312 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_PARAM, NULL, 0, ¶m, sizeof( param ) );
313
314 if ( direction == COMMAND_GET ) {
315 *ret_value = param->mode;
316 result = SUCCESS;
317 } else {
318 if ( value < param->modes_num ) {
319 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_SENSOR_PRESET_MODE, &value, sizeof( value ) );
320
321 if(instance->isp_seamless)
322 {
323 if(acamera_isp_input_port_mode_status_read( 0 ) != ACAMERA_ISP_INPUT_PORT_MODE_REQUEST_SAFE_START)
324 isp_safe_stop( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base );
325 }
326 else
327 isp_safe_stop( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base );
328
329 acamera_fsm_mgr_raise_event( instance, event_id_acamera_reset_sensor_hw );
330
331 result = SUCCESS;
332 } else {
333 result = FAIL;
334 }
335 }
336 return result;
337 }
338 #endif
339
340
341 #ifdef SENSOR_WDR_MODE
sensor_wdr_mode(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)342 uint8_t sensor_wdr_mode( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
343 {
344 uint32_t result = SUCCESS;
345 *ret_value = 0;
346 if ( direction == COMMAND_GET ) {
347 const sensor_param_t *param = NULL;
348 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_PARAM, NULL, 0, ¶m, sizeof( param ) );
349
350 uint32_t cur_mode = param->mode;
351 if ( cur_mode < param->modes_num ) {
352 *ret_value = param->modes_table[cur_mode].wdr_mode;
353 } else {
354 result = FAIL;
355 }
356 } else {
357 result = NOT_SUPPORTED;
358 }
359 return result;
360 }
361 #endif
362
363 #ifdef SENSOR_FPS
sensor_fps(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)364 uint8_t sensor_fps( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
365 {
366 uint32_t result = SUCCESS;
367 *ret_value = 0;
368 if ( direction == COMMAND_GET ) {
369 const sensor_param_t *param = NULL;
370 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_PARAM, NULL, 0, ¶m, sizeof( param ) );
371
372 uint32_t cur_mode = param->mode;
373 if ( cur_mode < param->modes_num ) {
374 *ret_value = param->modes_table[cur_mode].fps;
375 result = SUCCESS;
376 } else {
377 result = FAIL;
378 }
379 } else {
380 result = NOT_SUPPORTED;
381 }
382 return result;
383 }
384 #endif
385
386 #ifdef SENSOR_NAME
sensor_name(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)387 uint8_t sensor_name( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
388 {
389 uint32_t result = SUCCESS;
390 *ret_value = 0;
391 if ( direction == COMMAND_GET ) {
392 const sensor_param_t *param = NULL;
393 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_PARAM, NULL, 0, ¶m, sizeof( param ) );
394
395 uint32_t cur_mode = param->mode;
396 if ( cur_mode < param->modes_num ) {
397 memcpy(ret_value, param->s_name.name, (param->s_name.name_len)*sizeof(char));
398 result = SUCCESS;
399 } else {
400 result = FAIL;
401 }
402 } else {
403 result = NOT_SUPPORTED;
404 }
405 return result;
406 }
407 #endif
408
409 #ifdef SENSOR_NAME
sensor_test_pattern(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)410 uint8_t sensor_test_pattern( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
411 {
412 uint32_t result = SUCCESS;
413 if ( direction == COMMAND_SET ) {
414 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_SENSOR_TEST_PATTERN, &value, sizeof( value ) );
415 return SUCCESS;
416 } else {
417 result = NOT_SUPPORTED;
418 }
419 return result;
420 }
421 #endif
422
423
424 #ifdef SENSOR_WIDTH
sensor_width(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)425 uint8_t sensor_width( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
426 {
427 uint32_t result = SUCCESS;
428 *ret_value = 0;
429 if ( direction == COMMAND_GET ) {
430 const sensor_param_t *param = NULL;
431 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_PARAM, NULL, 0, ¶m, sizeof( param ) );
432 uint32_t cur_mode = param->mode;
433 if ( cur_mode < param->modes_num ) {
434 *ret_value = param->modes_table[cur_mode].resolution.width;
435 result = SUCCESS;
436 } else {
437 result = FAIL;
438 }
439 } else {
440 result = NOT_SUPPORTED;
441 }
442 return result;
443 }
444 #endif
445
446
447 #ifdef SENSOR_HEIGHT
sensor_height(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)448 uint8_t sensor_height( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
449 {
450 uint32_t result = SUCCESS;
451 *ret_value = 0;
452 if ( direction == COMMAND_GET ) {
453 const sensor_param_t *param = NULL;
454 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_PARAM, NULL, 0, ¶m, sizeof( param ) );
455 uint32_t cur_mode = param->mode;
456 if ( cur_mode < param->modes_num ) {
457 *ret_value = param->modes_table[cur_mode].resolution.height;
458 result = SUCCESS;
459 } else {
460 result = FAIL;
461 }
462 } else {
463 result = NOT_SUPPORTED;
464 }
465 return result;
466 }
467 #endif
468
469 #ifdef SENSOR_EXPOSURES
sensor_exposures(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)470 uint8_t sensor_exposures( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
471 {
472 uint32_t result = SUCCESS;
473 *ret_value = 0;
474 if ( direction == COMMAND_GET ) {
475 const sensor_param_t *param = NULL;
476 uint32_t cur_mode;
477 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_PARAM, NULL, 0, ¶m, sizeof( param ) );
478 cur_mode = param->mode;
479 if ( cur_mode < param->modes_num ) {
480 *ret_value = param->modes_table[cur_mode].exposures;
481 result = SUCCESS;
482 } else {
483 result = FAIL;
484 }
485 } else {
486 result = NOT_SUPPORTED;
487 }
488 return result;
489 }
490 #endif
491
492
493 #ifdef SENSOR_INFO_PRESET
sensor_info_preset(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)494 uint8_t sensor_info_preset( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
495 {
496 uint32_t result = SUCCESS;
497 *ret_value = 0;
498
499 if ( direction == COMMAND_GET ) {
500 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_INFO_PRESET_NUM, NULL, 0, ret_value, sizeof( uint32_t ) );
501 result = SUCCESS;
502 } else {
503 const sensor_param_t *param = NULL;
504 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_PARAM, NULL, 0, ¶m, sizeof( param ) );
505
506 if ( value < param->modes_num ) {
507 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_SENSOR_INFO_PRESET_NUM, &value, sizeof( value ) );
508 result = SUCCESS;
509 } else {
510 result = FAIL;
511 }
512 }
513 return result;
514 }
515 #endif
516
517
518 #ifdef SENSOR_INFO_WDR_MODE
sensor_info_wdr_mode(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)519 uint8_t sensor_info_wdr_mode( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
520 {
521 uint32_t result = SUCCESS;
522 *ret_value = 0;
523 if ( direction == COMMAND_GET ) {
524 const sensor_param_t *param = NULL;
525 uint32_t cur_mode;
526 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_PARAM, NULL, 0, ¶m, sizeof( param ) );
527 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_INFO_PRESET_NUM, NULL, 0, &cur_mode, sizeof( cur_mode ) );
528 if ( cur_mode < param->modes_num ) {
529 *ret_value = param->modes_table[cur_mode].wdr_mode;
530 } else {
531 result = FAIL;
532 }
533 } else {
534 result = NOT_SUPPORTED;
535 }
536 return result;
537 }
538 #endif
539
540 #ifdef SENSOR_INFO_FPS
sensor_info_fps(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)541 uint8_t sensor_info_fps( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
542 {
543 uint32_t result = SUCCESS;
544 *ret_value = 0;
545 if ( direction == COMMAND_GET ) {
546 const sensor_param_t *param = NULL;
547 uint32_t cur_mode;
548 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_PARAM, NULL, 0, ¶m, sizeof( param ) );
549 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_INFO_PRESET_NUM, NULL, 0, &cur_mode, sizeof( cur_mode ) );
550 if ( cur_mode < param->modes_num ) {
551 *ret_value = param->modes_table[cur_mode].fps;
552 result = SUCCESS;
553 } else {
554 result = FAIL;
555 }
556 } else {
557 result = NOT_SUPPORTED;
558 }
559 return result;
560 }
561 #endif
562
563 #ifdef SENSOR_INFO_WIDTH
sensor_info_width(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)564 uint8_t sensor_info_width( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
565 {
566 uint32_t result = SUCCESS;
567 *ret_value = 0;
568 if ( direction == COMMAND_GET ) {
569 const sensor_param_t *param = NULL;
570 uint32_t cur_mode;
571 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_PARAM, NULL, 0, ¶m, sizeof( param ) );
572 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_INFO_PRESET_NUM, NULL, 0, &cur_mode, sizeof( cur_mode ) );
573 if ( cur_mode < param->modes_num ) {
574 *ret_value = param->modes_table[cur_mode].resolution.width;
575 result = SUCCESS;
576 } else {
577 result = FAIL;
578 }
579 } else {
580 result = NOT_SUPPORTED;
581 }
582 return result;
583 }
584 #endif
585
586
587 #ifdef SENSOR_INFO_HEIGHT
sensor_info_height(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)588 uint8_t sensor_info_height( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
589 {
590 uint32_t result = SUCCESS;
591 *ret_value = 0;
592 if ( direction == COMMAND_GET ) {
593 const sensor_param_t *param = NULL;
594 uint32_t cur_mode;
595 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_PARAM, NULL, 0, ¶m, sizeof( param ) );
596 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_INFO_PRESET_NUM, NULL, 0, &cur_mode, sizeof( cur_mode ) );
597 if ( cur_mode < param->modes_num ) {
598 *ret_value = param->modes_table[cur_mode].resolution.height;
599 result = SUCCESS;
600 } else {
601 result = FAIL;
602 }
603 } else {
604 result = NOT_SUPPORTED;
605 }
606 return result;
607 }
608 #endif
609
610 #ifdef SENSOR_INFO_EXPOSURES
sensor_info_exposures(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)611 uint8_t sensor_info_exposures( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
612 {
613 uint32_t result = SUCCESS;
614 *ret_value = 0;
615 if ( direction == COMMAND_GET ) {
616 const sensor_param_t *param = NULL;
617 uint32_t cur_mode;
618 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_PARAM, NULL, 0, ¶m, sizeof( param ) );
619 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_INFO_PRESET_NUM, NULL, 0, &cur_mode, sizeof( cur_mode ) );
620 if ( cur_mode < param->modes_num ) {
621 *ret_value = param->modes_table[cur_mode].exposures;
622 result = SUCCESS;
623 } else {
624 result = FAIL;
625 }
626 } else {
627 result = NOT_SUPPORTED;
628 }
629 return result;
630 }
631 #endif
632
633 #ifdef SENSOR_IR_CUT
sensor_ir_cut_set(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)634 uint8_t sensor_ir_cut_set( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
635 {
636 uint32_t ir_cut_state = *ret_value;
637 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_SENSOR_SENSOR_IR_CUT, &ir_cut_state, sizeof( ir_cut_state ) );
638 return 0;
639 }
640 #endif
641
642 #ifdef SENSOR_WDRMODE_ID
sensor_mode_dynamic_switch(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)643 uint8_t sensor_mode_dynamic_switch( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
644 {
645 uint32_t result = SUCCESS;
646 uint32_t wdr_mode = value;
647 uint32_t preset_mode = 0;
648 *ret_value = 0;
649
650 const sensor_param_t *param = NULL;
651 uint32_t cur_mode;
652 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_PARAM, NULL, 0, ¶m, sizeof( param ) );
653
654 cur_mode = param->mode;
655
656 if ( direction == COMMAND_GET ) {
657 *ret_value = param->modes_table[cur_mode].wdr_mode;
658 result = SUCCESS;
659 }
660 else {
661 int i = 0;
662 for (i = 0; i < param->modes_num; i ++)
663 {
664 if ((param->modes_table[cur_mode].resolution.width == param->modes_table[i].resolution.width) &&
665 (param->modes_table[cur_mode].resolution.height == param->modes_table[i].resolution.height) &&
666 (param->modes_table[cur_mode].fps == param->modes_table[i].fps) &&
667 (param->modes_table[i].wdr_mode == wdr_mode))
668 {
669 preset_mode = i;
670 break;
671 }
672 }
673
674 if ( i == param->modes_num )
675 {
676 preset_mode = cur_mode;
677 result = NOT_SUPPORTED;
678 return result;
679 }
680
681 if ( i != cur_mode )
682 {
683 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_SENSOR_MODE_SWITCH, &preset_mode, sizeof( preset_mode ) );
684 acamera_fsm_mgr_raise_event( instance, event_id_acamera_reset_sensor_hw );
685 }
686 else
687 result = IMPLEMENTED;
688 }
689
690 return result;
691 }
692 #endif
693
694 #ifdef SENSOR_ANTIFLICKER_ID
sensor_antiflicker_switch(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)695 uint8_t sensor_antiflicker_switch( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
696 {
697 uint32_t result = SUCCESS;
698 uint32_t fps = value * 256;
699 uint32_t preset_mode = 0;
700 *ret_value = 0;
701
702 const sensor_param_t *param = NULL;
703 uint32_t cur_mode;
704 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_PARAM, NULL, 0, ¶m, sizeof( param ) );
705
706 cur_mode = param->mode;
707
708 if ( direction == COMMAND_GET ) {
709 *ret_value = param->modes_table[cur_mode].wdr_mode;
710 result = SUCCESS;
711 }
712 else {
713 int i = 0;
714 for (i = 0; i < param->modes_num; i ++)
715 {
716 if ((param->modes_table[cur_mode].resolution.width == param->modes_table[i].resolution.width) &&
717 (param->modes_table[cur_mode].resolution.height == param->modes_table[i].resolution.height) &&
718 (param->modes_table[cur_mode].exposures== param->modes_table[i].exposures) &&
719 (param->modes_table[cur_mode].wdr_mode == param->modes_table[i].wdr_mode) &&
720 (param->modes_table[i].fps == fps))
721 {
722 preset_mode = i;
723 break;
724 }
725 }
726
727 if ( i == param->modes_num )
728 {
729 preset_mode = cur_mode;
730 result = NOT_SUPPORTED;
731 return result;
732 }
733
734 if ( i != cur_mode )
735 {
736 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_SENSOR_MODE_SWITCH, &preset_mode, sizeof( preset_mode ) );
737 acamera_fsm_mgr_raise_event( instance, event_id_acamera_reset_sensor_hw );
738 }
739 else
740 result = IMPLEMENTED;
741 }
742
743 return result;
744 }
745 #endif
746
747 #ifdef SENSOR_HWID
sensor_hw_id(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)748 uint8_t sensor_hw_id( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
749 {
750 uint32_t result = SUCCESS;
751 *ret_value = 0;
752 if ( direction == COMMAND_GET ) {
753 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_ID, NULL, 0, ret_value, sizeof( uint32_t ) );
754 LOG(LOG_INFO, "Sensor ID:%x", *ret_value);
755 result = SUCCESS;
756 if ( *ret_value != 0xFFFF ) {
757 result = SUCCESS;
758 } else {
759 result = FAIL;
760 }
761 } else {
762 result = NOT_SUPPORTED;
763 }
764 return result;
765 }
766
767 #endif
768
769 #ifdef SYSTEM_FREEZE_FIRMWARE
system_freeze_firmware(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)770 uint8_t system_freeze_firmware( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
771 {
772 *ret_value = 0;
773 if ( direction == COMMAND_GET ) {
774 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_freeze_firmware;
775 return SUCCESS;
776 } else if ( direction == COMMAND_SET ) {
777 ACAMERA_MGR2CTX_PTR( instance )
778 ->stab.global_freeze_firmware = value;
779 return SUCCESS;
780 } else {
781 return NOT_SUPPORTED;
782 }
783 return NOT_SUPPORTED;
784 }
785 #endif
786
787 #ifdef SYSTEM_MANUAL_EXPOSURE
system_manual_exposure(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)788 uint8_t system_manual_exposure( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
789 {
790 *ret_value = 0;
791 if ( direction == COMMAND_GET ) {
792 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_manual_exposure;
793 return SUCCESS;
794 } else if ( direction == COMMAND_SET ) {
795 ACAMERA_MGR2CTX_PTR( instance )
796 ->stab.global_manual_exposure = value;
797 return SUCCESS;
798 } else {
799 return NOT_SUPPORTED;
800 }
801 return NOT_SUPPORTED;
802 }
803 #endif
804
805
806 // ------------------------------------------------------------------------------ //
807 // system_exposure_priority description:
808 //
809 // System exposure priority 0: means frame rate is constant 1:frame rate could change
810 //
811 //
812 // ------------------------------------------------------------------------------ //
813
814 #ifdef SYSTEM_EXPOSURE_PRIORITY
system_exposure_priority(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)815 uint8_t system_exposure_priority( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
816 {
817 const sensor_param_t *param = NULL;
818 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_PARAM, NULL, 0, ¶m, sizeof( param ) );
819 cmos_control_param_t *param_cmos = (cmos_control_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_CMOS_CONTROL );
820 if ( direction == COMMAND_SET ) {
821 if ( value == 0 ) {
822 param_cmos->global_max_integration_time = param->integration_time_max;
823 } else if ( value == 1 ) {
824 param_cmos->global_max_integration_time = param->integration_time_limit;
825 } else {
826 return NOT_SUPPORTED;
827 }
828 return SUCCESS;
829 } else if ( direction == COMMAND_GET ) {
830 if ( param_cmos->global_max_integration_time == param->integration_time_max )
831 *ret_value = 0;
832 else
833 *ret_value = 1;
834 return SUCCESS;
835 } else {
836 return NOT_SUPPORTED;
837 }
838 }
839 #endif
840
841
842 #ifdef SYSTEM_MANUAL_MAX_INTEGRATION_TIME
system_manual_max_integration_time(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)843 uint8_t system_manual_max_integration_time( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
844 {
845 *ret_value = 0;
846 cmos_control_param_t *param = (cmos_control_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_CMOS_CONTROL );
847 if ( direction == COMMAND_GET ) {
848 *ret_value = param->global_manual_max_integration_time;
849 return SUCCESS;
850 } else if ( direction == COMMAND_SET ) {
851 param->global_manual_max_integration_time = value;
852 return SUCCESS;
853 } else {
854 return NOT_SUPPORTED;
855 }
856 return NOT_SUPPORTED;
857 }
858 #endif
859
860 #ifdef SYSTEM_MANUAL_EXPOSURE_RATIO
system_manual_exposure_ratio(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)861 uint8_t system_manual_exposure_ratio( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
862 {
863 *ret_value = 0;
864 if ( direction == COMMAND_GET ) {
865 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_manual_exposure_ratio;
866 return SUCCESS;
867 } else if ( direction == COMMAND_SET ) {
868 ACAMERA_MGR2CTX_PTR( instance )
869 ->stab.global_manual_exposure_ratio = value;
870 return SUCCESS;
871 } else {
872 return NOT_SUPPORTED;
873 }
874 return NOT_SUPPORTED;
875 }
876 #endif
877
878 #ifdef SYSTEM_MANUAL_INTEGRATION_TIME
system_manual_integration_time(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)879 uint8_t system_manual_integration_time( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
880 {
881 *ret_value = 0;
882 cmos_control_param_t *param = (cmos_control_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_CMOS_CONTROL );
883 if ( direction == COMMAND_GET ) {
884 *ret_value = param->global_manual_integration_time;
885 return SUCCESS;
886 } else if ( direction == COMMAND_SET ) {
887 param->global_manual_integration_time = value;
888 return SUCCESS;
889 } else {
890 return NOT_SUPPORTED;
891 }
892 return NOT_SUPPORTED;
893 }
894 #endif
895
896 #ifdef SYSTEM_MANUAL_SENSOR_ANALOG_GAIN
system_manual_sensor_analog_gain(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)897 uint8_t system_manual_sensor_analog_gain( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
898 {
899 *ret_value = 0;
900 cmos_control_param_t *param = (cmos_control_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_CMOS_CONTROL );
901 if ( direction == COMMAND_GET ) {
902 *ret_value = param->global_manual_sensor_analog_gain;
903 return SUCCESS;
904 } else if ( direction == COMMAND_SET ) {
905 param->global_manual_sensor_analog_gain = value;
906 return SUCCESS;
907 } else {
908 return NOT_SUPPORTED;
909 }
910 return NOT_SUPPORTED;
911 }
912 #endif
913
914 #ifdef SYSTEM_MANUAL_SENSOR_DIGITAL_GAIN
system_manual_sensor_digital_gain(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)915 uint8_t system_manual_sensor_digital_gain( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
916 {
917 *ret_value = 0;
918 cmos_control_param_t *param = (cmos_control_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_CMOS_CONTROL );
919 if ( direction == COMMAND_GET ) {
920 *ret_value = param->global_manual_sensor_digital_gain;
921 return SUCCESS;
922 } else if ( direction == COMMAND_SET ) {
923 param->global_manual_sensor_digital_gain = value;
924 return SUCCESS;
925 } else {
926 return NOT_SUPPORTED;
927 }
928 return NOT_SUPPORTED;
929 }
930 #endif
931
932 #ifdef SYSTEM_MANUAL_ISP_DIGITAL_GAIN
system_manual_isp_digital_gain(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)933 uint8_t system_manual_isp_digital_gain( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
934 {
935 *ret_value = 0;
936 cmos_control_param_t *param = (cmos_control_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_CMOS_CONTROL );
937 if ( direction == COMMAND_GET ) {
938 *ret_value = param->global_manual_isp_digital_gain;
939 return SUCCESS;
940 } else if ( direction == COMMAND_SET ) {
941 param->global_manual_isp_digital_gain = value;
942 return SUCCESS;
943 } else {
944 return NOT_SUPPORTED;
945 }
946 return NOT_SUPPORTED;
947 }
948 #endif
949
950 // ------------------------------------------------------------------------------ //
951 // system_iso_gain description:
952 //
953 // base 0: means iso gain is disabled, any other value is enabled with the base
954 //
955 //
956 // ------------------------------------------------------------------------------ //
957
958 #ifdef SYSTEM_ISO_GAIN
959 typedef struct _iso_base_100_gains_t {
960 uint32_t iso_base_100_again;
961 uint32_t iso_base_100_dgain;
962 uint32_t iso_base_100_isp_dgain;
963 } iso_base_100_gains_t;
system_iso_gain(acamera_fsm_mgr_t * instance,uint32_t value,uint8_t direction,uint32_t * ret_value)964 uint8_t system_iso_gain( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
965 {
966 *ret_value = 0;
967 static uint32_t iso_base = 0;
968 static cmos_control_param_t prev_params = 0;
969 if ( direction == COMMAND_GET ) {
970 *ret_value = iso_base;
971 return SUCCESS;
972 } else if ( direction == COMMAND_SET ) {
973 if ( value % 100 == 0 ) {
974 cmos_control_param_t *param = (cmos_control_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_CMOS_CONTROL );
975 iso_base_100_gains_t *iso_gains = (iso_base_100_gains_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_ISO_100_GAIN );
976 if ( iso_gains->iso_base_100_again == 0 || param->global_max_sensor_analog_gain / iso_gains->iso_base_100_again == 0 )
977 return FAIL;
978 if ( value == 0 && iso_base != 0 ) { //disable iso gain
979 *param = prev_params;
980 iso_base = 0;
981 } else if ( value >= 100 ) { //get analog gain and digital gain value from gain 100
982 if ( iso_base == 0 ) //from disabled
983 prev_params = *param;
984
985 param->global_sensor_analog_gain = ( iso_gains->iso_base_100_again ) * ( value / 100 );
986 param->global_sensor_digital_gain = iso_gains->iso_base_100_dgain;
987 param->global_isp_digital_gain = iso_gains->iso_base_100_isp_dgain;
988
989 if ( param->global_sensor_analog_gain > param->global_max_sensor_analog_gain ) {
990 param->global_sensor_digital_gain += param->global_sensor_analog_gain - param->global_max_sensor_analog_gain;
991 param->global_sensor_analog_gain = param->global_max_sensor_analog_gain;
992 }
993
994 if ( param->global_sensor_digital_gain > param->global_max_sensor_digital_gain ) {
995 param->global_isp_digital_gain += param->global_sensor_digital_gain - param->global_max_sensor_digital_gain;
996 param->global_sensor_digital_gain = param->global_max_sensor_digital_gain;
997 }
998
999 if ( param->global_isp_digital_gain > param->global_max_isp_digital_gain )
1000 param->global_isp_digital_gain = param->global_max_isp_digital_gain;
1001
1002 param->global_manual_sensor_digital_gain = 1;
1003 param->global_manual_sensor_analog_gain = 1;
1004 param->global_manual_isp_digital_gain = 1;
1005 iso_base = value;
1006 } else {
1007 return NOT_SUPPORTED;
1008 }
1009
1010 return SUCCESS;
1011 } else { //only support 100s ISO gains
1012 return NOT_SUPPORTED
1013 }
1014 } else {
1015 return NOT_SUPPORTED;
1016 }
1017 }
1018 #endif
1019
1020
1021 #ifdef ISP_MODULES_MANUAL_IRIDIX
1022 uint8_t isp_modules_manual_iridix( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1023 {
1024 *ret_value = 0;
1025 if ( direction == COMMAND_GET ) {
1026 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_manual_iridix;
1027 return SUCCESS;
1028 } else if ( direction == COMMAND_SET ) {
1029 ACAMERA_MGR2CTX_PTR( instance )
1030 ->stab.global_manual_iridix = value;
1031 return SUCCESS;
1032 } else {
1033 return NOT_SUPPORTED;
1034 }
1035 return NOT_SUPPORTED;
1036 }
1037 #endif
1038
1039 #ifdef ISP_MODULES_MANUAL_SINTER
1040 uint8_t isp_modules_manual_sinter( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1041 {
1042 *ret_value = 0;
1043 if ( direction == COMMAND_GET ) {
1044 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_manual_sinter;
1045 return SUCCESS;
1046 } else if ( direction == COMMAND_SET ) {
1047 ACAMERA_MGR2CTX_PTR( instance )
1048 ->stab.global_manual_sinter = value;
1049 return SUCCESS;
1050 } else {
1051 return NOT_SUPPORTED;
1052 }
1053 return NOT_SUPPORTED;
1054 }
1055 #endif
1056
1057 #ifdef ISP_MODULES_MANUAL_TEMPER
1058 uint8_t isp_modules_manual_temper( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1059 {
1060 *ret_value = 0;
1061 if ( direction == COMMAND_GET ) {
1062 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_manual_temper;
1063 return SUCCESS;
1064 } else if ( direction == COMMAND_SET ) {
1065 ACAMERA_MGR2CTX_PTR( instance )
1066 ->stab.global_manual_temper = value;
1067 return SUCCESS;
1068 } else {
1069 return NOT_SUPPORTED;
1070 }
1071 return NOT_SUPPORTED;
1072 }
1073 #endif
1074
1075 #ifdef ISP_MODULES_MANUAL_AUTO_LEVEL
1076 uint8_t isp_modules_manual_auto_level( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1077 {
1078 *ret_value = 0;
1079 if ( direction == COMMAND_GET ) {
1080 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_manual_auto_level;
1081 return SUCCESS;
1082 } else if ( direction == COMMAND_SET ) {
1083 ACAMERA_MGR2CTX_PTR( instance )
1084 ->stab.global_manual_auto_level = value;
1085 return SUCCESS;
1086 } else {
1087 return NOT_SUPPORTED;
1088 }
1089 return NOT_SUPPORTED;
1090 }
1091 #endif
1092
1093 #ifdef ISP_MODULES_MANUAL_FRAME_STITCH
1094 uint8_t isp_modules_manual_frame_stitch( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1095 {
1096 *ret_value = 0;
1097 if ( direction == COMMAND_GET ) {
1098 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_manual_frame_stitch;
1099 return SUCCESS;
1100 } else if ( direction == COMMAND_SET ) {
1101 ACAMERA_MGR2CTX_PTR( instance )
1102 ->stab.global_manual_frame_stitch = value;
1103 return SUCCESS;
1104 } else {
1105 return NOT_SUPPORTED;
1106 }
1107 return NOT_SUPPORTED;
1108 }
1109 #endif
1110
1111 #ifdef ISP_MODULES_MANUAL_RAW_FRONTEND
1112 uint8_t isp_modules_manual_raw_frontend( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1113 {
1114 *ret_value = 0;
1115 if ( direction == COMMAND_GET ) {
1116 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_manual_raw_frontend;
1117 return SUCCESS;
1118 } else if ( direction == COMMAND_SET ) {
1119 ACAMERA_MGR2CTX_PTR( instance )
1120 ->stab.global_manual_raw_frontend = value;
1121 return SUCCESS;
1122 } else {
1123 return NOT_SUPPORTED;
1124 }
1125 return NOT_SUPPORTED;
1126 }
1127 #endif
1128
1129 #ifdef ISP_MODULES_MANUAL_BLACK_LEVEL
1130 uint8_t isp_modules_manual_black_level( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1131 {
1132 *ret_value = 0;
1133 if ( direction == COMMAND_GET ) {
1134 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_manual_black_level;
1135 return SUCCESS;
1136 } else if ( direction == COMMAND_SET ) {
1137 ACAMERA_MGR2CTX_PTR( instance )
1138 ->stab.global_manual_black_level = value;
1139 return SUCCESS;
1140 } else {
1141 return NOT_SUPPORTED;
1142 }
1143 return NOT_SUPPORTED;
1144 }
1145 #endif
1146
1147 #ifdef ISP_MODULES_MANUAL_SHADING
1148 uint8_t isp_modules_manual_shading( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1149 {
1150 *ret_value = 0;
1151 if ( direction == COMMAND_GET ) {
1152 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_manual_shading;
1153 return SUCCESS;
1154 } else if ( direction == COMMAND_SET ) {
1155 ACAMERA_MGR2CTX_PTR( instance )
1156 ->stab.global_manual_shading = value;
1157 return SUCCESS;
1158 } else {
1159 return NOT_SUPPORTED;
1160 }
1161 return NOT_SUPPORTED;
1162 }
1163 #endif
1164
1165 #ifdef ISP_MODULES_MANUAL_DEMOSAIC
1166 uint8_t isp_modules_manual_demosaic( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1167 {
1168 *ret_value = 0;
1169 if ( direction == COMMAND_GET ) {
1170 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_manual_demosaic;
1171 return SUCCESS;
1172 } else if ( direction == COMMAND_SET ) {
1173 ACAMERA_MGR2CTX_PTR( instance )
1174 ->stab.global_manual_demosaic = value;
1175 return SUCCESS;
1176 } else {
1177 return NOT_SUPPORTED;
1178 }
1179 return NOT_SUPPORTED;
1180 }
1181 #endif
1182
1183 #ifdef ISP_MODULES_MANUAL_CNR
1184 uint8_t isp_modules_manual_cnr( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1185 {
1186 *ret_value = 0;
1187 if ( direction == COMMAND_GET ) {
1188 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_manual_cnr;
1189 return SUCCESS;
1190 } else if ( direction == COMMAND_SET ) {
1191 ACAMERA_MGR2CTX_PTR( instance )
1192 ->stab.global_manual_cnr = value;
1193 return SUCCESS;
1194 } else {
1195 return NOT_SUPPORTED;
1196 }
1197 return NOT_SUPPORTED;
1198 }
1199 #endif
1200
1201 #ifdef ISP_MODULES_MANUAL_SHARPEN
1202 uint8_t isp_modules_manual_sharpen( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1203 {
1204 *ret_value = 0;
1205 if ( direction == COMMAND_GET ) {
1206 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_manual_sharpen;
1207 return SUCCESS;
1208 } else if ( direction == COMMAND_SET ) {
1209 ACAMERA_MGR2CTX_PTR( instance )
1210 ->stab.global_manual_sharpen = value;
1211 return SUCCESS;
1212 } else {
1213 return NOT_SUPPORTED;
1214 }
1215 return NOT_SUPPORTED;
1216 }
1217 #endif
1218
1219 #ifdef SYSTEM_MANUAL_AWB
1220 uint8_t system_manual_awb( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1221 {
1222 *ret_value = 0;
1223 if ( direction == COMMAND_GET ) {
1224 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_manual_awb;
1225 return SUCCESS;
1226 } else if ( direction == COMMAND_SET ) {
1227 ACAMERA_MGR2CTX_PTR( instance )
1228 ->stab.global_manual_awb = value;
1229 return SUCCESS;
1230 } else {
1231 return NOT_SUPPORTED;
1232 }
1233 return NOT_SUPPORTED;
1234 }
1235 #endif
1236
1237 #ifdef SYSTEM_ANTIFLICKER_ENABLE
1238 uint8_t system_antiflicker_enable( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1239 {
1240 *ret_value = 0;
1241 cmos_control_param_t *param = (cmos_control_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_CMOS_CONTROL );
1242 if ( direction == COMMAND_GET ) {
1243 *ret_value = param->global_antiflicker_enable;
1244 return SUCCESS;
1245 } else if ( direction == COMMAND_SET ) {
1246 param->global_antiflicker_enable = value;
1247 return SUCCESS;
1248 } else {
1249 return NOT_SUPPORTED;
1250 }
1251 return NOT_SUPPORTED;
1252 }
1253 #endif
1254
1255 #ifdef SYSTEM_MANUAL_SATURATION
1256 uint8_t system_manual_saturation( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1257 {
1258 *ret_value = 0;
1259 if ( direction == COMMAND_GET ) {
1260 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_manual_saturation;
1261 return SUCCESS;
1262 } else if ( direction == COMMAND_SET ) {
1263 ACAMERA_MGR2CTX_PTR( instance )
1264 ->stab.global_manual_saturation = value;
1265 return SUCCESS;
1266 } else {
1267 return NOT_SUPPORTED;
1268 }
1269 return NOT_SUPPORTED;
1270 }
1271 #endif
1272
1273 #ifdef SYSTEM_EXPOSURE
1274 uint8_t system_exposure( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1275 {
1276 *ret_value = 0;
1277
1278 if ( direction == COMMAND_GET ) {
1279 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_exposure;
1280 return SUCCESS;
1281 } else if ( direction == COMMAND_SET ) {
1282 ACAMERA_MGR2CTX_PTR( instance )
1283 ->stab.global_exposure = value;
1284 return SUCCESS;
1285 } else {
1286 return NOT_SUPPORTED;
1287 }
1288 return NOT_SUPPORTED;
1289 }
1290 #endif
1291
1292 #ifdef SYSTEM_EXPOSURE_RATIO
1293 uint8_t system_exposure_ratio( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1294 {
1295 *ret_value = 0;
1296 if ( direction == COMMAND_GET ) {
1297 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_exposure_ratio;
1298 return SUCCESS;
1299 } else if ( direction == COMMAND_SET ) {
1300 ACAMERA_MGR2CTX_PTR( instance )
1301 ->stab.global_exposure_ratio = value;
1302 return SUCCESS;
1303 } else {
1304 return NOT_SUPPORTED;
1305 }
1306 return NOT_SUPPORTED;
1307 }
1308 #endif
1309
1310 #ifdef SYSTEM_MAX_EXPOSURE_RATIO
1311 uint8_t system_max_exposure_ratio( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1312 {
1313 *ret_value = 0;
1314 cmos_control_param_t *param = (cmos_control_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_CMOS_CONTROL );
1315 if ( direction == COMMAND_GET ) {
1316 *ret_value = param->global_max_exposure_ratio;
1317 return SUCCESS;
1318 } else if ( direction == COMMAND_SET ) {
1319 param->global_max_exposure_ratio = value;
1320 return SUCCESS;
1321 } else {
1322 return NOT_SUPPORTED;
1323 }
1324 return NOT_SUPPORTED;
1325 }
1326 #endif
1327
1328 #ifdef SYSTEM_INTEGRATION_TIME
1329 uint8_t system_integration_time( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1330 {
1331 *ret_value = 0;
1332 const sensor_param_t *param = NULL;
1333 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_PARAM, NULL, 0, ¶m, sizeof( param ) );
1334 cmos_control_param_t *param_cmos = (cmos_control_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_CMOS_CONTROL );
1335 if ( direction == COMMAND_GET ) {
1336 *ret_value = param_cmos->global_integration_time;
1337 return SUCCESS;
1338 } else if ( direction == COMMAND_SET ) {
1339 if ( value == 0 ) {
1340 param_cmos->global_integration_time = 1;
1341 LOG(LOG_WARNING, "Warning: manual integration time rang: 1 - %d", param->integration_time_limit );
1342 }
1343 else if ( param->integration_time_limit < value ) {
1344 param_cmos->global_integration_time = param->integration_time_limit;
1345 LOG(LOG_WARNING, "Warning: manual integration time rang: 1 - %d", param->integration_time_limit );
1346 }
1347 else {
1348 param_cmos->global_integration_time = value;
1349 }
1350 LOG( LOG_INFO, "manual_sensor_integration_time = %d", param_cmos->global_integration_time );
1351 return SUCCESS;
1352 } else {
1353 return NOT_SUPPORTED;
1354 }
1355 return NOT_SUPPORTED;
1356 }
1357 #endif
1358
1359
1360 #ifdef SYSTEM_LONG_INTEGRATION_TIME
1361 uint8_t system_long_integration_time( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1362 {
1363 *ret_value = 0;
1364 if ( direction == COMMAND_GET ) {
1365 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_long_integration_time;
1366 return SUCCESS;
1367 } else {
1368 return NOT_SUPPORTED;
1369 }
1370 return NOT_SUPPORTED;
1371 }
1372 #endif
1373
1374
1375 #ifdef SYSTEM_SHORT_INTEGRATION_TIME
1376 uint8_t system_short_integration_time( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1377 {
1378 *ret_value = 0;
1379 if ( direction == COMMAND_GET ) {
1380 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_short_integration_time;
1381 return SUCCESS;
1382 } else {
1383 return NOT_SUPPORTED;
1384 }
1385 return NOT_SUPPORTED;
1386 }
1387 #endif
1388
1389
1390 #ifdef SYSTEM_MAX_INTEGRATION_TIME
1391 uint8_t system_max_integration_time( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1392 {
1393 *ret_value = 0;
1394 cmos_control_param_t *param = (cmos_control_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_CMOS_CONTROL );
1395 if ( direction == COMMAND_GET ) {
1396 *ret_value = param->global_max_integration_time;
1397 return SUCCESS;
1398 } else if ( direction == COMMAND_SET ) {
1399 fsm_param_sensor_info_t sensor_info;
1400 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_INFO, NULL, 0, &sensor_info, sizeof( sensor_info ) );
1401
1402 int32_t max_integration_time = sensor_info.integration_time_limit;
1403 if ( value > max_integration_time ) {
1404 param->global_max_integration_time = max_integration_time;
1405 } else {
1406 param->global_max_integration_time = value;
1407 }
1408 return SUCCESS;
1409 } else {
1410 return NOT_SUPPORTED;
1411 }
1412 return NOT_SUPPORTED;
1413 }
1414 #endif
1415
1416 #ifdef SYSTEM_SENSOR_ANALOG_GAIN
1417 uint8_t system_sensor_analog_gain( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1418 {
1419 *ret_value = 0;
1420 cmos_control_param_t *param = (cmos_control_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_CMOS_CONTROL );
1421 if ( direction == COMMAND_GET ) {
1422 *ret_value = param->global_sensor_analog_gain;
1423 return SUCCESS;
1424 } else if ( direction == COMMAND_SET ) {
1425 if ( value > param->global_max_sensor_analog_gain ) {
1426 param->global_sensor_analog_gain = param->global_max_sensor_analog_gain;
1427 LOG(LOG_WARNING, "Warning: manual sensor analog gain rang: 0 - %d", param->global_max_sensor_analog_gain );
1428 } else {
1429 param->global_sensor_analog_gain = value;
1430 }
1431 LOG( LOG_INFO, "manual_sensor_analog_gain = %d", param->global_sensor_analog_gain );
1432 return SUCCESS;
1433 } else {
1434 return NOT_SUPPORTED;
1435 }
1436 return NOT_SUPPORTED;
1437 }
1438 #endif
1439
1440 #ifdef SYSTEM_MAX_SENSOR_ANALOG_GAIN
1441 uint8_t system_max_sensor_analog_gain( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1442 {
1443 *ret_value = 0;
1444 cmos_control_param_t *param = (cmos_control_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_CMOS_CONTROL );
1445 if ( direction == COMMAND_GET ) {
1446 *ret_value = param->global_max_sensor_analog_gain;
1447 return SUCCESS;
1448 } else if ( direction == COMMAND_SET ) {
1449 fsm_param_sensor_info_t sensor_info;
1450 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_INFO, NULL, 0, &sensor_info, sizeof( sensor_info ) );
1451 int32_t max_manual_again_log2 = sensor_info.again_log2_max >> ( LOG2_GAIN_SHIFT - 5 );
1452 if ( value > max_manual_again_log2 ) {
1453 param->global_max_sensor_analog_gain = max_manual_again_log2;
1454 } else {
1455 param->global_max_sensor_analog_gain = value;
1456 }
1457 return SUCCESS;
1458 } else {
1459 return NOT_SUPPORTED;
1460 }
1461 return NOT_SUPPORTED;
1462 }
1463 #endif
1464
1465 #ifdef SYSTEM_SENSOR_DIGITAL_GAIN
1466 uint8_t system_sensor_digital_gain( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1467 {
1468 *ret_value = 0;
1469 cmos_control_param_t *param = (cmos_control_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_CMOS_CONTROL );
1470 if ( direction == COMMAND_GET ) {
1471 *ret_value = param->global_sensor_digital_gain;
1472 return SUCCESS;
1473 } else if ( direction == COMMAND_SET ) {
1474 if ( value > param->global_max_sensor_digital_gain ) {
1475 param->global_sensor_digital_gain = param->global_max_sensor_digital_gain;
1476 LOG(LOG_WARNING, "Warning: manual sensor digital gain rang: 0 - %d", param->global_max_sensor_digital_gain );
1477 } else {
1478 param->global_sensor_digital_gain = value;
1479 }
1480 LOG( LOG_INFO, "manual_sensor_digital_gain = %d", param->global_sensor_digital_gain );
1481 return SUCCESS;
1482 } else {
1483 return NOT_SUPPORTED;
1484 }
1485 return NOT_SUPPORTED;
1486 }
1487 #endif
1488
1489 #ifdef SYSTEM_MAX_SENSOR_DIGITAL_GAIN
1490 uint8_t system_max_sensor_digital_gain( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1491 {
1492 *ret_value = 0;
1493 cmos_control_param_t *param = (cmos_control_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_CMOS_CONTROL );
1494 if ( direction == COMMAND_GET ) {
1495 *ret_value = param->global_max_sensor_digital_gain;
1496 return SUCCESS;
1497 } else if ( direction == COMMAND_SET ) {
1498 fsm_param_sensor_info_t sensor_info;
1499 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_INFO, NULL, 0, &sensor_info, sizeof( sensor_info ) );
1500 int32_t max_manual_dgain_log2 = sensor_info.dgain_log2_max >> ( LOG2_GAIN_SHIFT - 5 );
1501 if ( value > max_manual_dgain_log2 ) {
1502 param->global_max_sensor_digital_gain = max_manual_dgain_log2;
1503 } else {
1504 param->global_max_sensor_digital_gain = value;
1505 }
1506 return SUCCESS;
1507 } else {
1508 return NOT_SUPPORTED;
1509 }
1510 return NOT_SUPPORTED;
1511 }
1512 #endif
1513
1514 #ifdef SYSTEM_ISP_DIGITAL_GAIN
1515 uint8_t system_isp_digital_gain( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1516 {
1517 *ret_value = 0;
1518 cmos_control_param_t *param = (cmos_control_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_CMOS_CONTROL );
1519 if ( direction == COMMAND_GET ) {
1520 *ret_value = param->global_isp_digital_gain;
1521 return SUCCESS;
1522 } else if ( direction == COMMAND_SET ) {
1523 if ( value > param->global_max_isp_digital_gain ) {
1524 param->global_isp_digital_gain = param->global_max_isp_digital_gain;
1525 LOG(LOG_WARNING, "Warning: manual isp digital gain rang: 0 - %d", param->global_max_isp_digital_gain );
1526 } else
1527 param->global_isp_digital_gain = value;
1528 LOG( LOG_INFO, "manual_isp_digital_gain = %d", param->global_isp_digital_gain );
1529 return SUCCESS;
1530 } else {
1531 return NOT_SUPPORTED;
1532 }
1533 return NOT_SUPPORTED;
1534 }
1535 #endif
1536
1537 #ifdef SYSTEM_MAX_ISP_DIGITAL_GAIN
1538 uint8_t system_max_isp_digital_gain( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1539 {
1540 *ret_value = 0;
1541 cmos_control_param_t *param = (cmos_control_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_CMOS_CONTROL );
1542 if ( direction == COMMAND_GET ) {
1543 *ret_value = param->global_max_isp_digital_gain;
1544 return SUCCESS;
1545 } else if ( direction == COMMAND_SET ) {
1546 param->global_max_isp_digital_gain = value;
1547 return SUCCESS;
1548 } else {
1549 return NOT_SUPPORTED;
1550 }
1551 return NOT_SUPPORTED;
1552 }
1553 #endif
1554
1555
1556 // ------------------------------------------------------------------------------ //
1557 // awb_red_gain description:
1558 //
1559 // Control the AWB red gain
1560 // Setting is only available when AWB_MODE is set to {AWB_MANUAL}
1561 //
1562 // Values:
1563 // Unsigned 8 bit fixed point value (1.7)
1564 //
1565 // Format:
1566 // Integer Part - [7:7]
1567 // Fractional Part - [6:0]
1568 //
1569 // Example:
1570 // To set a red gain of 1.125: The integer part would be set to 1 and the fraction part to 16 (.125*128).
1571 // The value 144 ((1 << 7) + 16) would then be passed to the API
1572 // ------------------------------------------------------------------------------ //
1573 #ifdef SYSTEM_AWB_RED_GAIN
1574 uint8_t system_awb_red_gain( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1575 {
1576 *ret_value = 0;
1577 if ( direction == COMMAND_GET ) {
1578 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_awb_red_gain;
1579 return SUCCESS;
1580 } else if ( direction == COMMAND_SET ) {
1581 ACAMERA_MGR2CTX_PTR( instance )
1582 ->stab.global_awb_red_gain = value;
1583 return SUCCESS;
1584 } else {
1585 return NOT_SUPPORTED;
1586 }
1587 return NOT_SUPPORTED;
1588 }
1589 #endif
1590
1591 // ------------------------------------------------------------------------------ //
1592 // system_awb_blue_gain description:
1593 //
1594 // Control the AWB blue gain
1595 // Setting is only available when AWB_MODE is set to {AWB_MANUAL}
1596 //
1597 // Values:
1598 // Unsigned 8 bit fixed point value (1.7)
1599 //
1600 // Format:
1601 // Integer Part - [7:7]
1602 // Fractional Part - [6:0]
1603 //
1604 // Example:
1605 // To set a blue gain of 1.125: The integer part would be set to 1 and the fraction part to 16 (.125*128).
1606 // The value 144 ((1 << 7) + 16) would then be passed to the API
1607 // ------------------------------------------------------------------------------ //
1608 #ifdef SYSTEM_AWB_BLUE_GAIN
1609 uint8_t system_awb_blue_gain( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1610 {
1611 *ret_value = 0;
1612 if ( direction == COMMAND_GET ) {
1613 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_awb_blue_gain;
1614 return SUCCESS;
1615 } else if ( direction == COMMAND_SET ) {
1616 ACAMERA_MGR2CTX_PTR( instance )
1617 ->stab.global_awb_blue_gain = value;
1618 return SUCCESS;
1619 } else {
1620 return NOT_SUPPORTED;
1621 }
1622 return NOT_SUPPORTED;
1623 }
1624 #endif
1625
1626 #ifdef SYSTEM_SATURATION_TARGET
1627 uint8_t system_saturation_target( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1628 {
1629 *ret_value = 0;
1630 if ( direction == COMMAND_GET ) {
1631 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_saturation_target;
1632 return SUCCESS;
1633 } else if ( direction == COMMAND_SET ) {
1634 ACAMERA_MGR2CTX_PTR( instance )
1635 ->stab.global_saturation_target = value;
1636 return SUCCESS;
1637 } else {
1638 return NOT_SUPPORTED;
1639 }
1640 return NOT_SUPPORTED;
1641 }
1642 #endif
1643
1644 #ifdef SYSTEM_ANTI_FLICKER_FREQUENCY
1645 uint8_t system_anti_flicker_frequency( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1646 {
1647 *ret_value = 0;
1648 cmos_control_param_t *param = (cmos_control_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_CMOS_CONTROL );
1649 if ( direction == COMMAND_GET ) {
1650 *ret_value = param->global_anti_flicker_frequency;
1651 return SUCCESS;
1652 } else if ( direction == COMMAND_SET ) {
1653 param->global_anti_flicker_frequency = value;
1654 return SUCCESS;
1655 } else {
1656 return NOT_SUPPORTED;
1657 }
1658 return NOT_SUPPORTED;
1659 }
1660 #endif
1661
1662 #ifdef SYSTEM_LOGGER_LEVEL
1663 uint8_t system_logger_level( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1664 {
1665 *ret_value = 0;
1666 switch ( direction ) {
1667 case COMMAND_SET:
1668 ACAMERA_LOGGER_SET_LEVEL( value - DEBUG );
1669 return SUCCESS;
1670 case COMMAND_GET:
1671 *ret_value = acamera_logger_get_level() + DEBUG;
1672 return SUCCESS;
1673 default:
1674 return NOT_IMPLEMENTED;
1675 }
1676 }
1677 #endif
1678
1679 #ifdef SYSTEM_LOGGER_MASK
1680 uint8_t system_logger_mask( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1681 {
1682 *ret_value = 0;
1683 switch ( direction ) {
1684 case COMMAND_SET:
1685 ACAMERA_LOGGER_SET_MASK( value );
1686 return SUCCESS;
1687 case COMMAND_GET:
1688 *ret_value = acamera_logger_get_mask();
1689 return SUCCESS;
1690 default:
1691 return NOT_IMPLEMENTED;
1692 }
1693 }
1694 #endif
1695
1696
1697 // ------------------------------------------------------------------------------ //
1698
1699 // ------------------------------------------------------------------------------ //
1700 // selftest_fw_revision description:
1701 //
1702 // Get fw revision
1703 //
1704 // GET returns fw revision number
1705 // ------------------------------------------------------------------------------ //
1706 uint8_t selftest_fw_revision( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1707 {
1708 *ret_value = 0;
1709 if ( direction == COMMAND_GET ) {
1710 *ret_value = (uint32_t)FIRMWARE_REVISION;
1711 return SUCCESS;
1712 } else {
1713 return NOT_SUPPORTED;
1714 }
1715 }
1716
1717 // bsp_test_start description:
1718 //
1719 // Run all BSP tests.
1720 //
1721 // GET returns DONE otherwise still running
1722 // ------------------------------------------------------------------------------ //
1723
1724 #ifdef BSP_TEST_START
1725 uint8_t bsp_test_start( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1726 {
1727 *ret_value = 0;
1728 #ifdef ISP_HAS_BSP_TEST_FSM
1729 uint32_t is_testing = 0;
1730 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_BSP_TESTING, NULL, 0, &is_testing, sizeof( is_testing ) );
1731
1732 if ( direction == COMMAND_SET ) {
1733 switch ( value ) {
1734 case RUN:
1735 if ( is_testing == 0 )
1736 acamera_fsm_mgr_raise_event( instance, event_id_bsp_test_interrupt_start );
1737 return SUCCESS;
1738 default:
1739 *ret_value = ERR_BAD_ARGUMENT;
1740 return FAIL;
1741 }
1742 } else if ( direction == COMMAND_GET ) {
1743 *ret_value = ( is_testing == 1 ? RUN : DONE );
1744 return SUCCESS;
1745 } else
1746 #endif
1747 {
1748 return NOT_SUPPORTED;
1749 }
1750 }
1751 #endif
1752
1753
1754 // ------------------------------------------------------------------------------ //
1755 // TSYSTEM
1756 // ------------------------------------------------------------------------------ //
1757
1758 // ------------------------------------------------------------------------------ //
1759 // temper_mode description:
1760 //
1761 // Controls the mode of temper module
1762 //
1763 // Values:
1764 // {TEMPER3_MODE}
1765 // {TEMPER2_MODE}
1766 //
1767 // Default Value: {TEMPER2_MODE}
1768 // ------------------------------------------------------------------------------ //
1769 #ifdef TEMPER_MODE_ID
1770 uint8_t temper_mode( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1771 {
1772 *ret_value = 0;
1773
1774 if ( direction == COMMAND_SET ) {
1775
1776 acamera_context_ptr_t p_ctx = ACAMERA_MGR2CTX_PTR( instance );
1777
1778 uint16_t height = acamera_isp_top_active_height_read( p_ctx->settings.isp_base );
1779 uint32_t temper_line_offset = acamera_isp_temper_dma_line_offset_read( p_ctx->settings.isp_base );
1780 uint32_t temper_frames_number = p_ctx->settings.temper_frames_number;
1781 aframe_t *temper_frames = p_ctx->settings.temper_frames;
1782 uint32_t temper_frame_size = temper_line_offset * height;
1783
1784 switch ( value ) {
1785 case TEMPER3_MODE:
1786 // temper3 needs 2 buffers
1787 if ( temper_frames_number > 1 && ( temper_frames[0].size + temper_frames[1].size >= temper_frame_size * 2 ) ) {
1788 acamera_isp_temper_temper2_mode_write( p_ctx->settings.isp_base, 0 );
1789 acamera_isp_top_bypass_temper_write( p_ctx->settings.isp_base, 0 );
1790 } else {
1791 LOG( LOG_ERR, "Bypass temper due to memory configuration is not enough, config: 0x%x, expected: 0x%x.", temper_frames[0].size, temper_frame_size );
1792 acamera_isp_top_bypass_temper_write( p_ctx->settings.isp_base, 1 );
1793 }
1794 break;
1795
1796 case TEMPER2_MODE:
1797 if ( temper_frames[0].size >= temper_frame_size ) {
1798 acamera_isp_temper_temper2_mode_write( p_ctx->settings.isp_base, 1 );
1799 acamera_isp_top_bypass_temper_write( p_ctx->settings.isp_base, 0 );
1800 } else {
1801 LOG( LOG_ERR, "Bypass temper due to memory configuration is not enough, config: 0x%x, expected: 0x%x.", temper_frames[0].size, temper_frame_size );
1802 acamera_isp_top_bypass_temper_write( p_ctx->settings.isp_base, 1 );
1803 }
1804 break;
1805
1806 default:
1807 LOG( LOG_ERR, "Invalid parameter %d.", value );
1808 return FAIL;
1809 }
1810 return SUCCESS;
1811
1812 } else if ( direction == COMMAND_GET ) {
1813 switch ( acamera_isp_temper_temper2_mode_read( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base ) ) {
1814 case 1:
1815 *ret_value = TEMPER2_MODE;
1816 return SUCCESS;
1817 break;
1818 case 0:
1819 *ret_value = TEMPER3_MODE;
1820 return SUCCESS;
1821 break;
1822 default:
1823 return FAIL;
1824 break;
1825 }
1826 }
1827
1828 return NOT_SUPPORTED;
1829 }
1830 #endif
1831
1832 // ------------------------------------------------------------------------------ //
1833 // test_pattern_enable description:
1834 //
1835 // Controls the video test pattern generator
1836 //
1837 // Values:
1838 // {ON}
1839 // {OFF}
1840 //
1841 // Default Value: {OFF}
1842 // ------------------------------------------------------------------------------ //
1843 #ifdef TEST_PATTERN_ENABLE_ID
1844 uint8_t test_pattern_enable( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1845 {
1846 *ret_value = 0;
1847
1848 if ( direction == COMMAND_SET ) {
1849
1850 switch ( value ) {
1851 case ON:
1852 acamera_isp_video_test_gen_ch0_test_pattern_off_on_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, 1 );
1853 acamera_isp_video_test_gen_ch1_test_pattern_off_on_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, 1 );
1854 acamera_isp_video_test_gen_ch2_test_pattern_off_on_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, 1 );
1855 acamera_isp_video_test_gen_ch3_test_pattern_off_on_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, 1 );
1856 break;
1857 default:
1858 acamera_isp_video_test_gen_ch0_test_pattern_off_on_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, 0 );
1859 acamera_isp_video_test_gen_ch1_test_pattern_off_on_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, 0 );
1860 acamera_isp_video_test_gen_ch2_test_pattern_off_on_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, 0 );
1861 acamera_isp_video_test_gen_ch3_test_pattern_off_on_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, 0 );
1862 break;
1863 }
1864 return SUCCESS;
1865
1866 } else if ( direction == COMMAND_GET ) {
1867 switch ( acamera_isp_video_test_gen_ch0_test_pattern_off_on_read( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base ) ) {
1868 case 1:
1869 *ret_value = ON;
1870 return SUCCESS;
1871 break;
1872 case 0:
1873 *ret_value = OFF;
1874 return SUCCESS;
1875 break;
1876 default:
1877 return FAIL;
1878 break;
1879 }
1880 }
1881 return NOT_SUPPORTED;
1882 }
1883 #endif
1884
1885 // ------------------------------------------------------------------------------ //
1886 // test_pattern description:
1887 //
1888 // Controls the pattern the test pattern generator shows
1889 //
1890 // Values:
1891 // [0-255]
1892 //
1893 // Key:
1894 // 0=Flat field
1895 // 1=Horizontal gradient
1896 // 2=Vertical Gradient
1897 // 3=Vertical Bars
1898 // Default Value: 3
1899 // ------------------------------------------------------------------------------ //
1900 uint8_t test_pattern( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1901 {
1902 *ret_value = 0;
1903
1904 if ( direction == COMMAND_SET ) {
1905 if ( value <= 5 ) {
1906 acamera_isp_video_test_gen_ch0_pattern_type_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, value );
1907 acamera_isp_video_test_gen_ch1_pattern_type_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, value );
1908 acamera_isp_video_test_gen_ch2_pattern_type_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, value );
1909 acamera_isp_video_test_gen_ch3_pattern_type_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, value );
1910 return SUCCESS;
1911 } else {
1912 *ret_value = ERR_BAD_ARGUMENT;
1913 return FAIL;
1914 }
1915 return NOT_SUPPORTED;
1916
1917 } else if ( direction == COMMAND_GET ) {
1918 *ret_value = acamera_isp_video_test_gen_ch0_pattern_type_read( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base );
1919 return SUCCESS;
1920 }
1921
1922 return NOT_SUPPORTED;
1923 }
1924
1925
1926 // ------------------------------------------------------------------------------ //
1927 // TIMAGE
1928 // ------------------------------------------------------------------------------ //
1929
1930
1931 // ------------------------------------------------------------------------------ //
1932 // dma_reader_output description:
1933 //
1934 //Set DMA READER output from Full resolution pipe or from downscaler
1935 //
1936 //Values:
1937 // {DMA_READER_OUT_FR} - output is full resulution pipe
1938 // {DMA_READER_OUT_DS} - output is downscaler pipe
1939 //
1940 // Default Value: {DMA_READER_OUT_FR}
1941 // ------------------------------------------------------------------------------ //
1942
1943
1944 #ifdef DMA_READER_OUTPUT_ID
1945
1946 uint8_t dma_reader_output( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
1947 {
1948 #if defined( ISP_HAS_DMA_WRITER_FSM )
1949 dma_type dma_reader_out;
1950 *ret_value = 0;
1951 switch ( direction ) {
1952 case COMMAND_SET:
1953 switch ( value ) {
1954 case DMA_READER_OUT_FR:
1955 dma_reader_out = dma_fr;
1956 break;
1957
1958 #if ISP_HAS_DS1
1959 case DMA_READER_OUT_DS:
1960 dma_reader_out = dma_ds1;
1961 break;
1962 #endif
1963
1964 default:
1965 *ret_value = ERR_BAD_ARGUMENT;
1966 return FAIL;
1967 }
1968
1969 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_DMA_READER_OUTPUT, &dma_reader_out, sizeof( dma_reader_out ) );
1970
1971 return SUCCESS;
1972
1973 case COMMAND_GET:
1974 *ret_value = DMA_READER_OUT_FR;
1975 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_DMA_READER_OUTPUT, NULL, 0, &dma_reader_out, sizeof( dma_reader_out ) );
1976
1977 if ( dma_reader_out == dma_fr ) {
1978 *ret_value = DMA_READER_OUT_FR;
1979 }
1980
1981 #if ISP_HAS_DS1
1982 if ( dma_reader_out == dma_ds1 ) {
1983 *ret_value = DMA_READER_OUT_DS;
1984 }
1985 #endif
1986
1987 return SUCCESS;
1988 default:
1989 return NOT_IMPLEMENTED;
1990 }
1991 #else
1992 return NOT_SUPPORTED;
1993 #endif
1994 }
1995 #endif
1996
1997
1998 // ------------------------------------------------------------------------------ //
1999 // image_resize_type description:
2000 //
2001 // Sets the type of resize corresponding crop or downscaler.
2002 // Sets the type of resize so api can switch between types to compensate the lacking read on api functionality
2003 //
2004 // Values:
2005 // {CROP_FR} - Control the crop settings on the full resolution pipe.
2006 // {CROP_DS} - Control the crop settings on the downscaler pipe.
2007 // {SCALER} - Control the width and height of the output of the downscaler.
2008 // {CROP_DS2} - Control the crop settings on the downscaler pipe.
2009 // {SCALER2} - Control the width and height of the output of the downscaler.
2010 //
2011 // Example:
2012 // To set the DS crop type set value = CROP_DS.
2013 //
2014 // Default Value: 0 or unimplemented
2015 //
2016 // ------------------------------------------------------------------------------ //
2017 #ifdef IMAGE_RESIZE_TYPE_ID
2018
2019 uint8_t image_resize_type( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
2020 {
2021 *ret_value = 0;
2022 #ifdef ISP_HAS_CROP_FSM
2023 int rc;
2024 uint16_t val = value & 0xFFFF;
2025 LOG( LOG_DEBUG, "resize type %s %d\n", ( direction == COMMAND_SET ) ? "set" : "get", val );
2026
2027 if ( direction == COMMAND_SET ) {
2028 if ( value > 0xFFFF ) {
2029 *ret_value = ERR_BAD_ARGUMENT;
2030 LOG( LOG_DEBUG, "returning fail on value too big %d\n", (int)value );
2031 return FAIL;
2032 }
2033
2034 fsm_param_crop_setting_t crop_setting;
2035 crop_setting.flag = CROP_SETTING_BIT_RESIZE_TYPE;
2036 crop_setting.resize_type = val;
2037 rc = acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_CROP_SETTING, &crop_setting, sizeof( crop_setting ) );
2038 if ( rc ) {
2039 *ret_value = ERR_BAD_ARGUMENT;
2040 LOG( LOG_ERR, "return fail on bad argument %d\n", val );
2041 return FAIL;
2042 }
2043
2044 return SUCCESS;
2045
2046 } else if ( direction == COMMAND_GET ) {
2047 fsm_param_crop_setting_t crop_setting;
2048 crop_setting.flag = CROP_SETTING_BIT_RESIZE_TYPE;
2049 rc = acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_CROP_SETTING, &crop_setting, sizeof( crop_setting ), &crop_setting, sizeof( crop_setting ) );
2050 if ( rc ) {
2051 *ret_value = ERR_BAD_ARGUMENT;
2052 LOG( LOG_ERR, "return fail on bad argument %d\n", val );
2053 return FAIL;
2054 }
2055
2056 *ret_value = crop_setting.resize_type;
2057 return SUCCESS;
2058 }
2059
2060 return NOT_IMPLEMENTED;
2061 #else
2062 return NOT_SUPPORTED;
2063 #endif
2064 }
2065
2066 #endif
2067
2068 // ------------------------------------------------------------------------------ //
2069 // image_resize_enable description:
2070 //
2071 // Enables or disables corresponding crop or downscaler.
2072 //
2073 // Values:
2074 // {CROP_FR} - Control the crop settings on the full resolution pipe.
2075 // {CROP_DS} - Control the crop settings on the downscaler pipe.
2076 // {SCALER} - Control the width and height of the output of the downscaler.
2077 // {ENABLE}
2078 // {DISABLE}
2079 //
2080 // Example:
2081 // To enable the FR downscaler set value = (CROP_FR<<16) + ENABLE.
2082 //
2083 // Default Value: {DISABLE}
2084 // ------------------------------------------------------------------------------ //
2085 #ifdef IMAGE_RESIZE_ENABLE_ID
2086
2087 uint8_t image_resize_enable( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
2088 {
2089 *ret_value = 0;
2090 #ifdef ISP_HAS_CROP_FSM
2091 int rc;
2092 uint16_t type = value >> 16;
2093 uint16_t val = value & 0xFFFF;
2094
2095 LOG( LOG_DEBUG, "enable %s %d %d\n", ( direction == COMMAND_SET ) ? "set" : "get", type, val );
2096
2097 if ( direction == COMMAND_SET ) {
2098 if ( val != RUN ) {
2099 *ret_value = ERR_BAD_ARGUMENT;
2100 return FAIL;
2101 }
2102
2103 fsm_param_crop_setting_t crop_setting;
2104
2105 crop_setting.flag = CROP_SETTING_BIT_ENABLE;
2106 crop_setting.resize_type = type;
2107 crop_setting.enable = 1;
2108 rc = acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_CROP_SETTING, &crop_setting, sizeof( crop_setting ) );
2109 if ( rc ) {
2110 *ret_value = ERR_BAD_ARGUMENT;
2111 LOG( LOG_ERR, "enable set returning fail on bad argument %d\n", val );
2112 return FAIL;
2113 }
2114
2115 return SUCCESS;
2116
2117 } else if ( direction == COMMAND_GET ) {
2118 fsm_param_crop_setting_t crop_setting;
2119 crop_setting.flag = CROP_SETTING_BIT_DONE;
2120 crop_setting.resize_type = type;
2121 rc = acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_CROP_SETTING, &crop_setting, sizeof( crop_setting ), &crop_setting, sizeof( crop_setting ) );
2122 if ( rc ) {
2123 *ret_value = ERR_BAD_ARGUMENT;
2124 LOG( LOG_ERR, "enable get returning fail on bad argument %d\n", val );
2125 return FAIL;
2126 }
2127
2128 *ret_value = ( value & 0xFFFF0000 ) | ( crop_setting.done == 0 ? RUN : DONE );
2129 return SUCCESS;
2130 }
2131
2132 return NOT_IMPLEMENTED;
2133 #else
2134 return NOT_SUPPORTED;
2135 #endif
2136 }
2137
2138 #endif
2139
2140 // ------------------------------------------------------------------------------ //
2141 // image_resize_width description:
2142 //
2143 // Set the width of the system selected by IMAGE_CROP_AND_DS_SELECT.
2144 //
2145 // Values:
2146 // Context dependent and limited by active image resolution
2147 // ------------------------------------------------------------------------------ //
2148 #ifdef IMAGE_RESIZE_WIDTH_ID
2149
2150 uint8_t image_resize_width( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
2151 {
2152 *ret_value = 0;
2153
2154 #ifdef ISP_HAS_CROP_FSM
2155 int rc;
2156 uint16_t type = value >> 16;
2157 uint16_t val = value & 0xFFFF;
2158
2159 LOG( LOG_DEBUG, "width %s %d %d\n", ( direction == COMMAND_SET ) ? "set" : "get", type, val );
2160
2161 if ( direction == COMMAND_SET ) {
2162 fsm_param_crop_setting_t crop_setting;
2163 crop_setting.flag = CROP_SETTING_BIT_XSIZE;
2164 crop_setting.resize_type = type;
2165 crop_setting.xsize = val;
2166 rc = acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_CROP_SETTING, &crop_setting, sizeof( crop_setting ) );
2167 if ( rc ) {
2168 *ret_value = ERR_BAD_ARGUMENT;
2169 LOG( LOG_ERR, "return fail on bad argument %d\n", val );
2170 return FAIL;
2171 }
2172
2173 return SUCCESS;
2174
2175 } else if ( direction == COMMAND_GET ) {
2176 fsm_param_crop_setting_t crop_setting;
2177 crop_setting.flag = CROP_SETTING_BIT_XSIZE;
2178 crop_setting.resize_type = type;
2179 rc = acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_CROP_SETTING, &crop_setting, sizeof( crop_setting ), &crop_setting, sizeof( crop_setting ) );
2180 if ( rc ) {
2181 *ret_value = ERR_BAD_ARGUMENT;
2182 LOG( LOG_ERR, "return fail on bad argument %d\n", val );
2183 return FAIL;
2184 }
2185
2186 *ret_value = ( value & 0xFFFF0000 ) | crop_setting.xsize;
2187 return SUCCESS;
2188 }
2189
2190 return NOT_IMPLEMENTED;
2191 #else
2192 return NOT_SUPPORTED;
2193 #endif
2194 }
2195
2196 #endif
2197
2198
2199 // ------------------------------------------------------------------------------ //
2200 // image_resize_height description:
2201 //
2202 // Set the height of the system selected by IMAGE_CROP_AND_DS_SELECT.
2203 //
2204 // Values:
2205 // Context dependent and limited by active image resolution
2206 // ------------------------------------------------------------------------------ //
2207 #ifdef IMAGE_RESIZE_HEIGHT_ID
2208
2209 uint8_t image_resize_height( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
2210 {
2211 *ret_value = 0;
2212
2213 #ifdef ISP_HAS_CROP_FSM
2214 int rc;
2215 uint16_t type = value >> 16;
2216 uint16_t val = value & 0xFFFF;
2217
2218 LOG( LOG_DEBUG, "height %s %d %d\n", ( direction == COMMAND_SET ) ? "set" : "get", type, val );
2219
2220 if ( direction == COMMAND_SET ) {
2221 fsm_param_crop_setting_t crop_setting;
2222 crop_setting.flag = CROP_SETTING_BIT_YSIZE;
2223 crop_setting.resize_type = type;
2224 crop_setting.ysize = val;
2225 rc = acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_CROP_SETTING, &crop_setting, sizeof( crop_setting ) );
2226 if ( rc ) {
2227 *ret_value = ERR_BAD_ARGUMENT;
2228 LOG( LOG_ERR, "return fail on bad argument %d\n", val );
2229 return FAIL;
2230 }
2231
2232 return SUCCESS;
2233
2234 } else if ( direction == COMMAND_GET ) {
2235 fsm_param_crop_setting_t crop_setting;
2236 crop_setting.flag = CROP_SETTING_BIT_YSIZE;
2237 crop_setting.resize_type = type;
2238 rc = acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_CROP_SETTING, &crop_setting, sizeof( crop_setting ), &crop_setting, sizeof( crop_setting ) );
2239 if ( rc ) {
2240 *ret_value = ERR_BAD_ARGUMENT;
2241 LOG( LOG_ERR, "return fail on bad argument %d\n", val );
2242 return FAIL;
2243 }
2244
2245 *ret_value = ( value & 0xFFFF0000 ) | crop_setting.ysize;
2246 return SUCCESS;
2247 }
2248
2249 return NOT_IMPLEMENTED;
2250 #else
2251 return NOT_SUPPORTED;
2252 #endif
2253 }
2254
2255 #endif
2256
2257
2258 // ------------------------------------------------------------------------------ //
2259 // image_crop_xoffset description:
2260 //
2261 // Set the x-offset of the system selected by IMAGE_CROP_AND_DS_SELECT.
2262 // NOTE: this command is not available when IMAGE_CROP_AND_DS_SELECT is set to {SCALER}.
2263 //
2264 // Values:
2265 // Context dependent and limited by active image resolution
2266 // ------------------------------------------------------------------------------ //
2267 #ifdef IMAGE_CROP_XOFFSET_ID
2268
2269 uint8_t image_crop_xoffset( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
2270 {
2271 *ret_value = 0;
2272
2273 #ifdef ISP_HAS_CROP_FSM
2274 int rc;
2275 uint16_t type = value >> 16;
2276 uint16_t val = value & 0xFFFF;
2277
2278 LOG( LOG_DEBUG, "x offset %s %d %d\n", ( direction == COMMAND_SET ) ? "set" : "get", type, val );
2279
2280 if ( direction == COMMAND_SET ) {
2281 fsm_param_crop_setting_t crop_setting;
2282 crop_setting.flag = CROP_SETTING_BIT_XOFFSET;
2283 crop_setting.resize_type = type;
2284 crop_setting.xoffset = val;
2285 rc = acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_CROP_SETTING, &crop_setting, sizeof( crop_setting ) );
2286 if ( rc ) {
2287 *ret_value = ERR_BAD_ARGUMENT;
2288 LOG( LOG_ERR, "return fail on bad argument %d\n", val );
2289 return FAIL;
2290 }
2291
2292 return SUCCESS;
2293
2294 } else if ( direction == COMMAND_GET ) {
2295 fsm_param_crop_setting_t crop_setting;
2296 crop_setting.flag = CROP_SETTING_BIT_XOFFSET;
2297 crop_setting.resize_type = type;
2298 rc = acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_CROP_SETTING, &crop_setting, sizeof( crop_setting ), &crop_setting, sizeof( crop_setting ) );
2299 if ( rc ) {
2300 *ret_value = ERR_BAD_ARGUMENT;
2301 LOG( LOG_ERR, "return fail on bad argument %d\n", val );
2302 return FAIL;
2303 }
2304
2305 *ret_value = ( value & 0xFFFF0000 ) | crop_setting.xoffset;
2306 return SUCCESS;
2307 }
2308
2309 return NOT_IMPLEMENTED;
2310 #else
2311 return NOT_SUPPORTED;
2312 #endif
2313 }
2314
2315 #endif
2316
2317
2318 // ------------------------------------------------------------------------------ //
2319 // image_crop_yoffset description:
2320 //
2321 // Set the y-offset of the system selected by IMAGE_CROP_AND_DS_SELECT.
2322 // NOTE: this command is not available when IMAGE_CROP_AND_DS_SELECT is set to {SCALER}.
2323 //
2324 // Values:
2325 // Context dependent and limited by active image resolution
2326 // ------------------------------------------------------------------------------ //
2327 #ifdef IMAGE_CROP_YOFFSET_ID
2328
2329 uint8_t image_crop_yoffset( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
2330 {
2331 *ret_value = 0;
2332
2333 #ifdef ISP_HAS_CROP_FSM
2334 int rc;
2335 uint16_t type = value >> 16;
2336 uint16_t val = value & 0xFFFF;
2337
2338 LOG( LOG_DEBUG, "y offset %s %d %d\n", ( direction == COMMAND_SET ) ? "set" : "get", type, val );
2339
2340 if ( direction == COMMAND_SET ) {
2341 fsm_param_crop_setting_t crop_setting;
2342 crop_setting.flag = CROP_SETTING_BIT_YOFFSET;
2343 crop_setting.resize_type = type;
2344 crop_setting.yoffset = val;
2345 rc = acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_CROP_SETTING, &crop_setting, sizeof( crop_setting ) );
2346 if ( rc ) {
2347 *ret_value = ERR_BAD_ARGUMENT;
2348 LOG( LOG_ERR, "return fail on bad argument %d\n", val );
2349 return FAIL;
2350 }
2351
2352 return SUCCESS;
2353
2354 } else if ( direction == COMMAND_GET ) {
2355 fsm_param_crop_setting_t crop_setting;
2356 crop_setting.flag = CROP_SETTING_BIT_YOFFSET;
2357 crop_setting.resize_type = type;
2358 rc = acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_CROP_SETTING, &crop_setting, sizeof( crop_setting ), &crop_setting, sizeof( crop_setting ) );
2359 if ( rc ) {
2360 *ret_value = ERR_BAD_ARGUMENT;
2361 LOG( LOG_ERR, "return fail on bad argument %d\n", val );
2362 return FAIL;
2363 }
2364
2365 *ret_value = ( value & 0xFFFF0000 ) | crop_setting.yoffset;
2366 return SUCCESS;
2367 }
2368
2369 return NOT_IMPLEMENTED;
2370 #else
2371 return NOT_SUPPORTED;
2372 #endif
2373 }
2374
2375 #endif
2376
2377
2378 // ------------------------------------------------------------------------------ //
2379 // TALGORITHMS
2380 // ------------------------------------------------------------------------------ //
2381
2382
2383 // ------------------------------------------------------------------------------ //
2384 // af_mode description:
2385 //
2386 // Sets the mode of operation for the AF algorithm.
2387 //
2388 // Values:
2389 // {AF_AUTO_SINGLE}
2390 // {AF_AUTO_CONTINUOUS}
2391 // {AF_HYPER_FOCAL}
2392 // {AF_INFINITY}
2393 // {AF_ABORT}
2394 // {AF_MANUAL}
2395 //
2396 // Default Value: {AF_AUTO_SINGLE}
2397 // ------------------------------------------------------------------------------ //
2398 #ifdef AF_MODE_ID
2399 uint8_t af_mode( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
2400 {
2401 *ret_value = 0;
2402 #if defined( ISP_HAS_AF_LMS_FSM ) || defined( ISP_HAS_AF_MANUAL_FSM )
2403 uint32_t mode = AF_MODE_AF;
2404 if ( direction == COMMAND_SET ) {
2405 switch ( value ) {
2406 #ifdef AF_AUTO_SINGLE
2407 case AF_AUTO_SINGLE:
2408 mode = AF_MODE_AF;
2409 break;
2410 #endif
2411 #ifdef AF_AUTO_CONTINUOUS
2412 case AF_AUTO_CONTINUOUS:
2413 mode = AF_MODE_CAF;
2414 break;
2415 #endif
2416 #ifdef AF_MANUAL
2417 case AF_MANUAL:
2418 mode = AF_MODE_MANUAL;
2419 break;
2420 #endif
2421 #ifdef AF_CALIBRATION
2422 case AF_CALIBRATION:
2423 mode = AF_MODE_CALIBRATION;
2424 break;
2425 #endif
2426 default:
2427 return NOT_SUPPORTED;
2428 }
2429
2430 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_AF_MODE, &mode, sizeof( mode ) );
2431
2432 return SUCCESS;
2433
2434 } else if ( direction == COMMAND_GET ) {
2435
2436 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_AF_MODE, NULL, 0, &mode, sizeof( mode ) );
2437
2438 switch ( mode ) {
2439 #ifdef AF_AUTO_SINGLE
2440 case AF_MODE_AF:
2441 *ret_value = AF_AUTO_SINGLE;
2442 return SUCCESS;
2443 break;
2444 #endif
2445 #ifdef AF_AUTO_CONTINUOUS
2446 case AF_MODE_CAF:
2447 *ret_value = AF_AUTO_CONTINUOUS;
2448 return SUCCESS;
2449 break;
2450 #endif
2451 #ifdef AF_MANUAL
2452 case AF_MODE_MANUAL:
2453 *ret_value = AF_MANUAL;
2454 return SUCCESS;
2455 break;
2456 #endif
2457 #ifdef AF_CALIBRATION
2458 case AF_MODE_CALIBRATION:
2459 *ret_value = AF_CALIBRATION;
2460 return SUCCESS;
2461 break;
2462 #endif
2463 default:
2464 *ret_value = mode;
2465 }
2466 return NOT_EXISTS;
2467 }
2468
2469 return NOT_SUPPORTED;
2470 #else
2471 return NOT_SUPPORTED;
2472 #endif
2473 }
2474 #endif
2475
2476
2477 #ifdef AF_LENS_STATUS
2478 uint8_t af_lens_status( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
2479 {
2480 *ret_value = 0;
2481 if ( direction == COMMAND_SET ) {
2482 return NOT_SUPPORTED;
2483 } else if ( direction == COMMAND_GET ) {
2484 int32_t lens_driver_ok = 0;
2485
2486 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_AF_LENS_STATUS, NULL, 0, &lens_driver_ok, sizeof( lens_driver_ok ) );
2487
2488 if ( lens_driver_ok == 0 ) {
2489 *ret_value = LENS_FAILED;
2490 } else {
2491 *ret_value = LENS_SUCCESS;
2492 }
2493 return SUCCESS;
2494 }
2495 return FAIL;
2496 }
2497 #endif
2498
2499 // ------------------------------------------------------------------------------ //
2500 // af_manual_control description:
2501 //
2502 // Manually set the focal length, only available when AF_MODE_ID is set to AF_MANUAL.
2503 //
2504 // Values:
2505 // [0-255]
2506 //
2507 // Key:
2508 // 0 - macro mechanical end
2509 // 255 - infinity end
2510 //
2511 // ------------------------------------------------------------------------------ //
2512 #ifdef AF_MANUAL_CONTROL_ID
2513 uint8_t af_manual_control( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
2514 {
2515 *ret_value = 0;
2516 #if defined( ISP_HAS_AF_LMS_FSM ) || defined( ISP_HAS_AF_MANUAL_FSM )
2517 if ( direction == COMMAND_SET ) {
2518 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_AF_MANUAL_POS, &value, sizeof( value ) );
2519 return SUCCESS;
2520 } else if ( direction == COMMAND_GET ) {
2521 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_AF_MANUAL_POS, NULL, 0, ret_value, sizeof( uint32_t ) );
2522 return SUCCESS;
2523 }
2524
2525 return NOT_SUPPORTED;
2526 #else
2527 return NOT_SUPPORTED;
2528 #endif
2529 }
2530 #endif
2531
2532 // ------------------------------------------------------------------------------ //
2533 // af_range_low description:
2534 //
2535 // Sets the lowest value that the AF algorithm can select.
2536 //
2537 // Values:
2538 // [0-255]
2539 //
2540 // Key:
2541 // 0 - macro mechanical end
2542 // 255 - infinity end
2543 //
2544 // Default Value:
2545 // {AF_RANGE_LOW} = 0
2546 // {AF_RANGE_HIGH} = 255
2547 // ------------------------------------------------------------------------------ //
2548 #ifdef AF_RANGE_LOW_ID
2549 uint8_t af_range_low( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
2550 {
2551 *ret_value = 0;
2552 #if defined( ISP_HAS_AF_LMS_FSM ) || defined( ISP_HAS_AF_MANUAL_FSM )
2553 if ( direction == COMMAND_SET ) {
2554 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_AF_RANGE_LOW, &value, sizeof( value ) );
2555 return SUCCESS;
2556 } else if ( direction == COMMAND_GET ) {
2557 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_AF_RANGE_LOW, NULL, 0, ret_value, sizeof( uint32_t ) );
2558 return SUCCESS;
2559 }
2560
2561 return NOT_SUPPORTED;
2562 #else
2563 return NOT_SUPPORTED;
2564 #endif
2565 }
2566 #endif
2567
2568
2569 // ------------------------------------------------------------------------------ //
2570 // af_range_high description:
2571 //
2572 // Sets the highest value that the AF algorithm can select.
2573 //
2574 // Values:
2575 // [0-255]
2576 //
2577 // Key:
2578 // 0 - macro mechanical end
2579 // 255 - infinity end
2580 //
2581 // Default Value:
2582 // {AF_RANGE_LOW} = 0
2583 // {AF_RANGE_HIGH} = 255
2584 // ------------------------------------------------------------------------------ //
2585 #ifdef AF_RANGE_HIGH_ID
2586 uint8_t af_range_high( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
2587 {
2588 *ret_value = 0;
2589 #if defined( ISP_HAS_AF_LMS_FSM ) || defined( ISP_HAS_AF_MANUAL_FSM )
2590 if ( direction == COMMAND_SET ) {
2591 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_AF_RANGE_HIGH, &value, sizeof( value ) );
2592 return SUCCESS;
2593 } else if ( direction == COMMAND_GET ) {
2594 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_AF_RANGE_HIGH, NULL, 0, ret_value, sizeof( uint32_t ) );
2595 return SUCCESS;
2596 }
2597
2598 return NOT_SUPPORTED;
2599 #else
2600 return NOT_SUPPORTED;
2601 #endif
2602 }
2603 #endif
2604
2605 // ------------------------------------------------------------------------------ //
2606 // af_roi description:
2607 //
2608 // Select which zones are used to gather AF statistics.
2609 // The region of interest is defined as a rectangle with top-left coordinates (AF_ROI_X1, AF_ROI_Y1) and bottom-right coordinates (AF_ROI_X2, AF_ROI_Y2), with (0,0) defined as the top-left of the image and (255,255) as the bottom right of the image.
2610 //
2611 // Values:
2612 // Four 8 bit numbers concatenated into the 32 bit value.
2613 //
2614 // Format:
2615 // AF_ROI_X1 [31:24]
2616 // AF_ROI_Y1 [23:16]
2617 // AF_ROI_X2 [15:8]
2618 // AF_ROI_Y2 [7:0]
2619 //
2620 // Default Values:
2621 // AF_ROI_X1 = 85
2622 // AF_ROI_Y1 = 85
2623 // AF_ROI_X2 = 171
2624 // AF_ROI_Y2 = 171
2625 // ------------------------------------------------------------------------------ //
2626 #ifdef AF_ROI_ID
2627 uint8_t af_roi( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
2628 {
2629
2630 #ifdef ISP_HAS_AF
2631
2632 if ( direction == COMMAND_SET ) {
2633 uint8_t x1, y1, x2, y2;
2634
2635 // Read in values
2636 y2 = ( value & 0xff );
2637 x2 = ( ( value >> 8 ) & 0xff );
2638 y1 = ( ( value >> 16 ) & 0xff );
2639 x1 = ( ( value >> 24 ) & 0xff );
2640
2641 if ( x2 <= x1 || y2 <= y1 ) {
2642 *ret_value = ERR_BAD_ARGUMENT;
2643 return FAIL;
2644 }
2645
2646 #if defined( ISP_HAS_DMA_WRITER_FSM )
2647 uint32_t vflip = 0;
2648 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_DMA_VFLIP, NULL, 0, &vflip, sizeof( vflip ) );
2649 if ( vflip ) {
2650 uint8_t y = y2;
2651 y2 = 0xff - y1;
2652 y1 = 0xff - y;
2653 }
2654 #endif
2655
2656 fsm_param_roi_t new_roi;
2657 new_roi.roi_api = value;
2658 new_roi.roi = ( (uint32_t)x1 << 24 ) | ( (uint32_t)y1 << 16 ) | ( (uint32_t)x2 << 8 ) | y2;
2659 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_AF_ROI, &new_roi, sizeof( new_roi ) );
2660
2661 return SUCCESS;
2662
2663 } else if ( direction == COMMAND_GET ) {
2664
2665 fsm_param_roi_t new_roi;
2666 new_roi.roi_api = 0;
2667 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_AF_ROI, NULL, 0, &new_roi, sizeof( new_roi ) );
2668 *ret_value = new_roi.roi_api;
2669
2670 return SUCCESS;
2671 }
2672
2673 return NOT_SUPPORTED;
2674
2675 #else
2676
2677 return NOT_SUPPORTED;
2678
2679 #endif
2680 }
2681 #endif
2682
2683
2684 // ------------------------------------------------------------------------------ //
2685 // ae_mode description:
2686 //
2687 // Set the AE mode
2688 //
2689 // Values:
2690 // {AE_AUTO}
2691 // {AE_FULL_MANUAL}
2692 //
2693 // Default Value:
2694 // {AE_AUTO}
2695 // ------------------------------------------------------------------------------ //
2696 #ifdef AE_MODE_ID
2697 uint8_t ae_mode( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
2698 {
2699 uint32_t manual_integration_time = 0;
2700 uint8_t manual_gain_mode = 0;
2701
2702 *ret_value = 0;
2703
2704 if ( direction == COMMAND_SET ) {
2705
2706 switch ( value ) {
2707 case AE_AUTO:
2708 manual_integration_time = ( 0 );
2709 manual_gain_mode = 0;
2710 break;
2711 case AE_FULL_MANUAL:
2712 manual_integration_time = ( 1 );
2713 manual_gain_mode = 1;
2714 break;
2715 case AE_MANUAL_GAIN:
2716 manual_integration_time = ( 0 );
2717 manual_gain_mode = 1;
2718 break;
2719 case AE_MANUAL_EXPOSURE_TIME:
2720 manual_integration_time = ( 1 );
2721 manual_gain_mode = 0;
2722 break;
2723 default:
2724 return NOT_SUPPORTED;
2725 }
2726
2727 fsm_param_ae_mode_t ae_mode;
2728
2729 ae_mode.manual_integration_time = manual_integration_time;
2730 ae_mode.manual_gain_mode = manual_gain_mode;
2731 ae_mode.flag = AE_MODE_BIT_MANUAL_INT_TIME | AE_MODE_BIT_MANUAL_GAIN_MODE;
2732
2733 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_AE_MODE, &ae_mode, sizeof( ae_mode ) );
2734
2735 return SUCCESS;
2736
2737 } else if ( direction == COMMAND_GET ) {
2738
2739 fsm_param_ae_mode_t ae_mode;
2740 ae_mode.flag = AE_MODE_BIT_MANUAL_INT_TIME | AE_MODE_BIT_MANUAL_GAIN_MODE;
2741 if ( 0 == acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_AE_MODE, NULL, 0, &ae_mode, sizeof( ae_mode ) ) ) {
2742 manual_integration_time = ae_mode.manual_integration_time;
2743 manual_gain_mode = ae_mode.manual_gain_mode;
2744 }
2745
2746 if ( manual_integration_time && manual_gain_mode ) {
2747 *ret_value = AE_FULL_MANUAL;
2748 } else if ( manual_integration_time ) {
2749 *ret_value = AE_MANUAL_EXPOSURE_TIME;
2750 } else if ( manual_gain_mode ) {
2751 *ret_value = AE_MANUAL_GAIN;
2752 } else {
2753 *ret_value = AE_AUTO;
2754 }
2755 return SUCCESS;
2756 }
2757 return NOT_SUPPORTED;
2758 }
2759 #endif
2760
2761
2762 #ifdef AE_SPLIT_PRESET_ID
2763 uint8_t ae_split_preset( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
2764 {
2765 int rc;
2766 *ret_value = 0;
2767 if ( direction == COMMAND_SET ) {
2768
2769 rc = acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_CMOS_SPLIT_STRATEGY, &value, sizeof( value ) );
2770 if ( rc == 0 ) {
2771 return SUCCESS;
2772 } else {
2773 return NOT_SUPPORTED;
2774 }
2775 } else if ( direction == COMMAND_GET ) {
2776
2777 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_CMOS_SPLIT_STRATEGY, NULL, 0, ret_value, sizeof( *ret_value ) );
2778 return SUCCESS;
2779 }
2780
2781 return NOT_SUPPORTED;
2782 }
2783 #endif
2784
2785
2786 // ------------------------------------------------------------------------------ //
2787 // ae_gain description:
2788 //
2789 // Control the total gain: (Analogue gain)*(Sensor digital gain)*(ISP digital gain).
2790 // NOTE: Only gains of 1.0 or above are supported.
2791 //
2792 // Values:
2793 // Unsigned 16 bit fixed floating point value (8.8)
2794 //
2795 // Format:
2796 // Integer Part - [15:8]
2797 // Fractional Part - [7:0]
2798 //
2799 // Example:
2800 // To set a gain of 2.25, the integer part is set to 2 and the fractional part to 64 (0.25*256).
2801 // The value 576 ((2 << 8) + 64) is then passed to AE_GAIN
2802 // ------------------------------------------------------------------------------ //
2803 #ifdef AE_GAIN_ID
2804 uint8_t ae_gain( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
2805 {
2806 *ret_value = 0;
2807 #ifdef ISP_HAS_CMOS_FSM
2808 if ( direction == COMMAND_SET ) {
2809 uint8_t manual_gain_mode = 0;
2810 fsm_param_ae_mode_t ae_mode;
2811 ae_mode.flag = AE_MODE_BIT_MANUAL_GAIN_MODE;
2812 if ( 0 == acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_AE_MODE, NULL, 0, &ae_mode, sizeof( ae_mode ) ) ) {
2813 manual_gain_mode = ae_mode.manual_gain_mode;
2814 }
2815
2816 if ( !manual_gain_mode ) {
2817 return NOT_PERMITTED;
2818 }
2819
2820 if ( value >= ( 1 << 8 ) ) {
2821 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_MANUAL_GAIN, &value, sizeof( value ) );
2822 return SUCCESS;
2823 }
2824
2825 *ret_value = ERR_BAD_ARGUMENT;
2826 return FAIL;
2827
2828 } else if ( direction == COMMAND_GET ) {
2829
2830 fsm_param_gain_calc_param_t param;
2831 param.shift_in = LOG2_GAIN_SHIFT;
2832 param.shift_out = 8;
2833 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_GAIN, ¶m, sizeof( param ), ret_value, sizeof( uint32_t ) );
2834
2835 return SUCCESS;
2836
2837 } else {
2838
2839 return NOT_SUPPORTED;
2840 }
2841 #else
2842 return NOT_IMPLEMENTED;
2843 #endif
2844 }
2845 #endif
2846
2847
2848 // ------------------------------------------------------------------------------ //
2849 // ae_exposure description:
2850 //
2851 // Returns exposure in micro sec.
2852 // Setting exposure is only available when AE_MODE is set to {AE_FULL_MANUAL}
2853 //
2854 // Values:
2855 // Unsigned 32 bit value
2856 // ------------------------------------------------------------------------------ //
2857 #ifdef AE_EXPOSURE_ID
2858 uint8_t ae_exposure( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
2859 {
2860 *ret_value = 0;
2861 #ifdef ISP_HAS_CMOS_FSM
2862 uint64_t large_store;
2863 uint32_t store;
2864 uint32_t lines_per_second = 1;
2865
2866 cmos_control_param_t *param = (cmos_control_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_CMOS_CONTROL );
2867 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SENSOR_LINES_SECOND, NULL, 0, &lines_per_second, sizeof( lines_per_second ) );
2868
2869 if ( direction == COMMAND_SET ) {
2870
2871 if ( !param->global_integration_time || !param->global_manual_integration_time ) {
2872 return NOT_PERMITTED;
2873 }
2874
2875
2876 large_store = value;
2877 large_store *= lines_per_second;
2878 store = (uint32_t)div64_u64( large_store, D1E6 );
2879
2880 if ( large_store > ( (uint64_t)D1E6 ) * 0xFFFFFFFF ) {
2881 return NOT_SUPPORTED;
2882 } else {
2883 param->global_integration_time = store;
2884 return SUCCESS;
2885 }
2886 } else if ( direction == COMMAND_GET ) {
2887 large_store = ( (uint64_t)D1E6 ) * param->global_integration_time;
2888 if ( lines_per_second != 0 ) {
2889 *ret_value = div64_u64( large_store, lines_per_second ); // division by zero is checked
2890 } else {
2891 *ret_value = 0;
2892 LOG( LOG_CRIT, "AVOIDED DIVISION BY ZERO" );
2893 }
2894 return SUCCESS;
2895
2896 } else {
2897 return NOT_SUPPORTED;
2898 }
2899
2900 #else
2901 return NOT_SUPPORTED;
2902 #endif
2903 }
2904 #endif
2905
2906
2907 // ------------------------------------------------------------------------------ //
2908 // ae_roi description:
2909 //
2910 // Select which zones are used to gather AE statistics.
2911 // The region of interest is defined as a rectangle with top-left coordinates (AE_ROI_X1, AE_ROI_Y1) and bottom-right coordinates (AE_ROI_X2, AE_ROI_Y2), with (0,0) defined as the top-left of the image and (255,255) as the bottom right of the image.
2912 //
2913 // Values:
2914 // Four 8 bit values concatenated into one 32 bit value.
2915 //
2916 // Format:
2917 // AE_ROI_X1 [31:24]
2918 // AE_ROI_Y1 [23:16]
2919 // AE_ROI_X2 [15:8]
2920 // AE_ROI_Y2 [7:0]
2921 //
2922 // Default Values:
2923 // AE_ROI_X1 = 0
2924 // AE_ROI_Y1 = 0
2925 // AE_ROI_X2 = 255
2926 // AE_ROI_Y2 = 255
2927 // ------------------------------------------------------------------------------ //
2928 #ifdef AE_ROI_ID
2929 uint8_t ae_roi( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
2930 {
2931
2932 if ( direction == COMMAND_SET ) {
2933 uint16_t x1, y1, x2, y2;
2934
2935 // Read in values
2936 y2 = ( value & 0xff );
2937 x2 = ( ( value >> 8 ) & 0xff );
2938 y1 = ( ( value >> 16 ) & 0xff );
2939 x1 = ( ( value >> 24 ) & 0xff );
2940
2941 if ( x2 <= x1 || y2 <= y1 ) {
2942 *ret_value = ERR_BAD_ARGUMENT;
2943 return FAIL;
2944 }
2945
2946 #if defined( ISP_HAS_DMA_WRITER_FSM )
2947 uint32_t vflip = 0;
2948 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_DMA_VFLIP, NULL, 0, &vflip, sizeof( vflip ) );
2949 if ( vflip ) {
2950 uint8_t y = y2;
2951 y2 = 0xff - y1;
2952 y1 = 0xff - y;
2953 }
2954 #endif
2955
2956 fsm_param_roi_t new_roi;
2957 new_roi.roi_api = value;
2958 new_roi.roi = ( (uint32_t)x1 << 24 ) | ( (uint32_t)y1 << 16 ) | ( (uint32_t)x2 << 8 ) | y2;
2959 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_AE_ROI, &new_roi, sizeof( new_roi ) );
2960
2961 return SUCCESS;
2962
2963 } else if ( direction == COMMAND_GET ) {
2964
2965 fsm_param_roi_t new_roi;
2966 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_AE_ROI, NULL, 0, &new_roi, sizeof( new_roi ) );
2967 *ret_value = new_roi.roi_api;
2968
2969 return SUCCESS;
2970
2971 } else {
2972
2973 return NOT_SUPPORTED;
2974 }
2975 }
2976 #endif
2977
2978 uint8_t ae_zone_weight( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
2979 {
2980 int ret = -1;
2981
2982 if (direction == COMMAND_SET) {
2983 ret = acamera_fsm_mgr_set_param(instance,
2984 FSM_PARAM_SET_AE_ZONE_WEIGHT,
2985 ret_value, sizeof(ret_value));
2986 if (ret != 0)
2987 return FAIL;
2988 else
2989 return SUCCESS;
2990 } else {
2991 return NOT_SUPPORTED;
2992 }
2993 }
2994
2995 uint8_t awb_zone_weight( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
2996 {
2997 int ret = -1;
2998
2999 if (direction == COMMAND_SET) {
3000 ret = acamera_fsm_mgr_set_param(instance,
3001 FSM_PARAM_SET_AWB_ZONE_WEIGHT,
3002 ret_value, sizeof(ret_value));
3003 if (ret != 0)
3004 return FAIL;
3005 else
3006 return SUCCESS;
3007 } else {
3008 return NOT_SUPPORTED;
3009 }
3010 }
3011
3012 // ------------------------------------------------------------------------------ //
3013 // ae_compensation description:
3014 //
3015 // Adjust AE compensation to under/over-expose an image
3016 //
3017 // Values:
3018 // Unsigned 8 bit value
3019 //
3020 // Description:
3021 // A value of 128 is no compensation.
3022 // Values below 128 are negative, Values above 128 are positive.
3023 // A step of 4 corresponds to 0.5 dB gain.
3024 //
3025 // Example:
3026 // For +1.5 dB compensation the value should be 140 (128+12).
3027 // For -1.5 dB compensation the value should be 116 (128-12).
3028 //
3029 // Default Value: 128
3030 // ------------------------------------------------------------------------------ //
3031 #ifdef AE_COMPENSATION_ID
3032 uint8_t ae_compensation( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
3033 {
3034 *ret_value = 0;
3035 if ( direction == COMMAND_SET ) {
3036
3037 if ( value < ( 1 << 8 ) ) {
3038 ACAMERA_MGR2CTX_PTR( instance )
3039 ->stab.global_ae_compensation = ( value );
3040 return SUCCESS;
3041 } else {
3042 return NOT_SUPPORTED;
3043 }
3044
3045 } else if ( direction == COMMAND_GET ) {
3046 *ret_value = ACAMERA_MGR2CTX_PTR( instance )->stab.global_ae_compensation;
3047 return SUCCESS;
3048 }
3049 return NOT_SUPPORTED;
3050 }
3051 #endif
3052
3053 // ------------------------------------------------------------------------------ //
3054 // awb_mode description:
3055 //
3056 // Select an AWB mode
3057 //
3058 // Values:
3059 // {AWB_AUTO}
3060 // {AWB_MANUAL}
3061 // {AWB_DAY_LIGHT}
3062 // {AWB_CLOUDY}
3063 // {AWB_INCANDESCENT}
3064 // {AWB_FLOURESCENT}
3065 // {AWB_TWILIGHT}
3066 // {AWB_SHADE}
3067 // {AWB_WARM_FLOURESCENT}
3068 //
3069 // Default Value: {AWB_AUTO}
3070 // ------------------------------------------------------------------------------ //
3071 #ifdef AWB_MODE_ID
3072
3073 uint8_t awb_mode( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
3074 {
3075 int rc = 0;
3076 *ret_value = 0;
3077
3078 if ( direction == COMMAND_SET ) {
3079 rc = acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_AWB_MODE, &value, sizeof( value ) );
3080 if ( rc ) {
3081 return NOT_SUPPORTED;
3082 }
3083
3084 return SUCCESS;
3085
3086 } else if ( direction == COMMAND_GET ) {
3087 rc = acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_AWB_MODE, NULL, 0, ret_value, sizeof( uint32_t ) );
3088 if ( rc ) {
3089 return NOT_SUPPORTED;
3090 }
3091
3092 return SUCCESS;
3093 }
3094
3095 return NOT_SUPPORTED;
3096 }
3097
3098 #endif
3099
3100 // ------------------------------------------------------------------------------ //
3101 // awb_temperature description:
3102 //
3103 // Returns the current color temperature being used by the AWB algorithm, in kelvin [K], divided by 100.
3104 //
3105 // Values:
3106 // [0-255]
3107 // ------------------------------------------------------------------------------ //
3108 #ifdef AWB_TEMPERATURE_ID
3109 uint8_t awb_temperature( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
3110 {
3111 *ret_value = 0;
3112
3113 if ( direction == COMMAND_SET ) {
3114
3115 if ( ACAMERA_MGR2CTX_PTR( instance )->stab.global_manual_awb ) {
3116 fsm_param_awb_info_t awb_info;
3117 awb_info.flag = AWB_INFO_TEMPERATURE_DETECTED;
3118 awb_info.temperature_detected = value * 100;
3119 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_AWB_INFO, &awb_info, sizeof( awb_info ) );
3120 return SUCCESS;
3121 } else {
3122 return NOT_SUPPORTED;
3123 }
3124
3125 } else if ( direction == COMMAND_GET ) {
3126 fsm_param_awb_info_t awb_info;
3127 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_AWB_INFO, NULL, 0, &awb_info, sizeof( awb_info ) );
3128 *ret_value = awb_info.temperature_detected / 100;
3129 return SUCCESS;
3130 }
3131
3132 return NOT_SUPPORTED;
3133 }
3134 #endif
3135
3136
3137 // ------------------------------------------------------------------------------ //
3138 // awb_light_source description:
3139 //
3140 // Returns the current light source candidate and p_high being used by the AWB algorithm.
3141 //
3142 // Values:
3143 // Two 8 bit values concatenated into one 32 bit value.
3144 //
3145 // Format:
3146 // AWB_P_HIGH [15:8]
3147 // AWB_LIGHT_SOURCE [7:0]
3148 //
3149 // Default Values:
3150 // AWB_P_HIGH = 50
3151 // AWB_LIGHT_SOURCE = 3
3152 // ------------------------------------------------------------------------------ //
3153 #ifdef AWB_LIGHT_SOURCE_ID
3154 uint8_t awb_light_source( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
3155 {
3156 *ret_value = 0;
3157
3158 if ( direction == COMMAND_SET ) {
3159
3160 if ( ACAMERA_MGR2CTX_PTR( instance )->stab.global_manual_awb ) {
3161 fsm_param_awb_info_t awb_info;
3162 awb_info.flag = AWB_INFO_P_HIGH | AWB_INFO_LIGHT_SOURCE_CANDIDATE;
3163 awb_info.p_high = ( value >> 8 ) & 0xFF;
3164 awb_info.light_source_candidate = value & 0xFF;
3165 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_AWB_INFO, &awb_info, sizeof( awb_info ) );
3166 return SUCCESS;
3167 } else {
3168 return NOT_SUPPORTED;
3169 }
3170
3171 } else if ( direction == COMMAND_GET ) {
3172
3173 fsm_param_awb_info_t awb_info;
3174 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_AWB_INFO, NULL, 0, &awb_info, sizeof( awb_info ) );
3175 *ret_value = ( awb_info.p_high << 8 ) | awb_info.light_source_candidate;
3176
3177 return SUCCESS;
3178 }
3179
3180 return NOT_SUPPORTED;
3181 }
3182 #endif
3183
3184 // ------------------------------------------------------------------------------ //
3185 // antiflicker_mode description:
3186 //
3187 // Set the frequency for the anti-flicker to remove.
3188 // (0 - disabled)
3189 // Default Value: 50HZ
3190 // ------------------------------------------------------------------------------ //
3191 #ifdef ANTIFLICKER_MODE_ID
3192 uint8_t antiflicker_mode( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
3193 {
3194 *ret_value = 0;
3195 cmos_control_param_t *param = (cmos_control_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_CMOS_CONTROL );
3196 if ( direction == COMMAND_SET ) {
3197 param->global_anti_flicker_frequency = ( value );
3198 return SUCCESS;
3199 } else if ( direction == COMMAND_GET ) {
3200
3201 *ret_value = param->global_anti_flicker_frequency;
3202 return SUCCESS;
3203 }
3204 return NOT_SUPPORTED;
3205 }
3206 #endif
3207
3208 uint8_t defog_alg_mode( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
3209 {
3210 uint32_t ret = 0;
3211 uint32_t d_size = 0;
3212 uint32_t ctx_id = 0;
3213 defog_calibration_control_t *d_base;
3214 defog_calibration_control_t d_param;
3215
3216 d_base = (void *)_GET_UINT_PTR(ACAMERA_MGR2CTX_PTR(instance), CALIBRATION_DEFOG_CONTROL);
3217 d_size = _GET_SIZE(ACAMERA_MGR2CTX_PTR(instance), CALIBRATION_DEFOG_CONTROL);
3218
3219 system_memcpy(&d_param, d_base, d_size);
3220
3221 if (direction == COMMAND_SET) {
3222 switch (value) {
3223 case DEFOG_DISABLE:
3224 d_param.defog_en = 0;
3225 break;
3226 case DEFOG_ONLY:
3227 d_param.defog_en = 1;
3228 break;
3229 case DEFOG_BLEND:
3230 d_param.defog_en = 2;
3231 break;
3232 default:
3233 break;
3234 }
3235 ctx_id = acamera_get_api_context();
3236 acamera_api_calibration(ctx_id, DYNAMIC_CALIBRATIONS_ID,
3237 CALIBRATION_DEFOG_CONTROL,
3238 COMMAND_SET, &d_param, sizeof(d_param), &ret);
3239 return SUCCESS;
3240 } else if (direction == COMMAND_GET) {
3241 switch (d_base->defog_en) {
3242 case 0:
3243 *ret_value = DEFOG_DISABLE;
3244 break;
3245 case 1:
3246 *ret_value = DEFOG_ONLY;
3247 break;
3248 case 2:
3249 *ret_value = DEFOG_BLEND;
3250 break;
3251 default:
3252 *ret_value = NOT_SUPPORTED;
3253 break;
3254 }
3255 return SUCCESS;
3256 }
3257
3258 return NOT_SUPPORTED;
3259 }
3260
3261 uint8_t defog_alg_ratio_delta( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
3262 {
3263 uint32_t ret = 0;
3264 uint32_t d_size = 0;
3265 uint32_t ctx_id = 0;
3266 defog_calibration_control_t *d_base;
3267 defog_calibration_control_t d_param;
3268
3269 d_base = (void *)_GET_UINT_PTR(ACAMERA_MGR2CTX_PTR(instance), CALIBRATION_DEFOG_CONTROL);
3270 d_size = _GET_SIZE(ACAMERA_MGR2CTX_PTR(instance), CALIBRATION_DEFOG_CONTROL);
3271
3272 system_memcpy(&d_param, d_base, d_size);
3273
3274 if (direction == COMMAND_SET) {
3275 d_param.ratio_delta = value;
3276 ctx_id = acamera_get_api_context();
3277 acamera_api_calibration(ctx_id, DYNAMIC_CALIBRATIONS_ID,
3278 CALIBRATION_DEFOG_CONTROL,
3279 COMMAND_SET, &d_param, sizeof(d_param), &ret);
3280 return SUCCESS;
3281 } else if (direction == COMMAND_GET) {
3282 *ret_value = d_base->ratio_delta;
3283 return SUCCESS;
3284 }
3285
3286 return NOT_SUPPORTED;
3287 }
3288
3289 uint8_t defog_alg_black_pctg( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
3290 {
3291 uint32_t ret = 0;
3292 uint32_t d_size = 0;
3293 uint32_t ctx_id = 0;
3294 defog_calibration_control_t *d_base;
3295 defog_calibration_control_t d_param;
3296
3297 d_base = (void *)_GET_UINT_PTR(ACAMERA_MGR2CTX_PTR(instance), CALIBRATION_DEFOG_CONTROL);
3298 d_size = _GET_SIZE(ACAMERA_MGR2CTX_PTR(instance), CALIBRATION_DEFOG_CONTROL);
3299
3300 system_memcpy(&d_param, d_base, d_size);
3301
3302 if (direction == COMMAND_SET) {
3303 d_param.black_percentage = value;
3304 ctx_id = acamera_get_api_context();
3305 acamera_api_calibration(ctx_id, DYNAMIC_CALIBRATIONS_ID,
3306 CALIBRATION_DEFOG_CONTROL,
3307 COMMAND_SET, &d_param, sizeof(d_param), &ret);
3308 return SUCCESS;
3309 } else if (direction == COMMAND_GET) {
3310 *ret_value = d_base->black_percentage;
3311 return SUCCESS;
3312 }
3313
3314 return NOT_SUPPORTED;
3315 }
3316
3317 uint8_t defog_alg_white_pctg( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
3318 {
3319 uint32_t ret = 0;
3320 uint32_t d_size = 0;
3321 uint32_t ctx_id = 0;
3322 defog_calibration_control_t *d_base;
3323 defog_calibration_control_t d_param;
3324
3325 d_base = (void *)_GET_UINT_PTR(ACAMERA_MGR2CTX_PTR(instance), CALIBRATION_DEFOG_CONTROL);
3326 d_size = _GET_SIZE(ACAMERA_MGR2CTX_PTR(instance), CALIBRATION_DEFOG_CONTROL);
3327
3328 system_memcpy(&d_param, d_base, d_size);
3329
3330 if (direction == COMMAND_SET) {
3331 d_param.white_percentage = value;
3332 ctx_id = acamera_get_api_context();
3333 acamera_api_calibration(ctx_id, DYNAMIC_CALIBRATIONS_ID,
3334 CALIBRATION_DEFOG_CONTROL,
3335 COMMAND_SET, &d_param, sizeof(d_param), &ret);
3336 return SUCCESS;
3337 } else if (direction == COMMAND_GET) {
3338 *ret_value = d_base->white_percentage;
3339 return SUCCESS;
3340 }
3341
3342 return NOT_SUPPORTED;
3343 }
3344
3345 // ------------------------------------------------------------------------------ //
3346 // TREGISTERS
3347 // ------------------------------------------------------------------------------ //
3348
3349
3350 // ------------------------------------------------------------------------------ //
3351 // register_address description:
3352 //
3353 // Set/get the registers address.
3354 //
3355 // ------------------------------------------------------------------------------ //
3356 #ifdef REGISTERS_ADDRESS_ID
3357 uint8_t register_address( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
3358 {
3359 *ret_value = 0;
3360
3361 if ( direction == COMMAND_SET ) {
3362 fsm_param_reg_setting_t reg;
3363 reg.flag = REG_SETTING_BIT_REG_ADDR;
3364 reg.api_reg_addr = value;
3365 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_REG_SETTING, ®, sizeof( reg ) );
3366 return SUCCESS;
3367
3368 } else if ( direction == COMMAND_GET ) {
3369 fsm_param_reg_setting_t reg;
3370 reg.flag = REG_SETTING_BIT_REG_ADDR;
3371 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_REG_SETTING, ®, sizeof( reg ), ®, sizeof( reg ) );
3372 *ret_value = reg.api_reg_addr;
3373 return SUCCESS;
3374
3375 } else {
3376 return NOT_SUPPORTED;
3377 }
3378 }
3379 #endif
3380
3381
3382 // ------------------------------------------------------------------------------ //
3383 // register_size description:
3384 //
3385 // Set/get the size of the register in bits.
3386 //
3387 // Values:
3388 // 8
3389 // 16
3390 // 32
3391 //
3392 // ------------------------------------------------------------------------------ //
3393 #ifdef REGISTERS_SIZE_ID
3394 uint8_t register_size( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
3395 {
3396 *ret_value = 0;
3397
3398 if ( direction == COMMAND_SET ) {
3399 if ( value == 8 || value == 16 || value == 32 ) {
3400 fsm_param_reg_setting_t reg;
3401 reg.flag = REG_SETTING_BIT_REG_SIZE;
3402 reg.api_reg_size = value;
3403 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_REG_SETTING, ®, sizeof( reg ) );
3404 return SUCCESS;
3405 } else {
3406 *ret_value = ERR_BAD_ARGUMENT;
3407 return FAIL;
3408 }
3409
3410 } else if ( direction == COMMAND_GET ) {
3411 fsm_param_reg_setting_t reg;
3412 reg.flag = REG_SETTING_BIT_REG_SIZE;
3413 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_REG_SETTING, ®, sizeof( reg ), ®, sizeof( reg ) );
3414 *ret_value = reg.api_reg_size;
3415 return SUCCESS;
3416
3417 } else {
3418 return NOT_SUPPORTED;
3419 }
3420 }
3421 #endif
3422
3423
3424 // ------------------------------------------------------------------------------ //
3425 // register_source description:
3426 //
3427 // Set/get the register source.
3428 //
3429 // Values:
3430 // {SENSOR}
3431 // {LENS}
3432 // {ISP}
3433 //
3434 // ------------------------------------------------------------------------------ //
3435 #ifdef REGISTERS_SOURCE_ID
3436 uint8_t register_source( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
3437 {
3438 *ret_value = 0;
3439
3440 if ( direction == COMMAND_SET ) {
3441 fsm_param_reg_setting_t reg;
3442 reg.flag = REG_SETTING_BIT_REG_SOURCE;
3443 reg.api_reg_source = value;
3444 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_REG_SETTING, ®, sizeof( reg ) );
3445
3446 return SUCCESS;
3447
3448 } else if ( direction == COMMAND_GET ) {
3449 fsm_param_reg_setting_t reg;
3450 reg.flag = REG_SETTING_BIT_REG_SOURCE;
3451 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_REG_SETTING, ®, sizeof( reg ), ®, sizeof( reg ) );
3452 *ret_value = reg.api_reg_source;
3453 return SUCCESS;
3454
3455 } else {
3456 return NOT_SUPPORTED;
3457 }
3458 }
3459 #endif
3460
3461
3462 // ------------------------------------------------------------------------------ //
3463 // register_value description:
3464 //
3465 // Set/get the register value.
3466 //
3467 // Example:
3468 // To read an 8bit register at address 0x3c from the sensor set
3469 // - SET REGISTERS_ADDRESS_ID to 0x3c
3470 // - SET REGISTERS_SIZE_ID to 8
3471 // - SET REGISTERS_SOURCE_ID to SENSOR
3472 // - GET REGISTERS_VALUE_ID
3473 //
3474 // To set a 32bit lens register at address 0x1d to be 0x3f0E2B03:
3475 // - SET REGISTERS_ADDRESS_ID to 0x1d
3476 // - SET REGISTERS_SIZE_ID to 32
3477 // - SET REGISTERS_SOURCE_ID to LENS
3478 // - SET REGISTERS_VALUE_ID to 0x3f0E2B03
3479 // ------------------------------------------------------------------------------ //
3480 #ifdef REGISTERS_VALUE_ID
3481 uint8_t register_value( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
3482 {
3483 int rc = 0;
3484 *ret_value = 0;
3485
3486 if ( direction == COMMAND_SET ) {
3487
3488 fsm_param_reg_setting_t reg;
3489 reg.flag = REG_SETTING_BIT_REG_VALUE;
3490 reg.api_reg_value = value;
3491 rc = acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_REG_SETTING, ®, sizeof( reg ) );
3492
3493 if ( rc ) {
3494 *ret_value = ERR_BAD_ARGUMENT;
3495 return FAIL;
3496 } else {
3497 return SUCCESS;
3498 }
3499
3500 } else if ( direction == COMMAND_GET ) {
3501
3502 fsm_param_reg_setting_t reg;
3503 reg.flag = REG_SETTING_BIT_REG_VALUE;
3504 rc = acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_REG_SETTING, ®, sizeof( reg ), ®, sizeof( reg ) );
3505
3506 if ( rc ) {
3507 *ret_value = ERR_BAD_ARGUMENT;
3508 return FAIL;
3509 } else {
3510 *ret_value = reg.api_reg_value;
3511 return SUCCESS;
3512 }
3513
3514 } else {
3515 return NOT_SUPPORTED;
3516 }
3517 }
3518 #endif
3519
3520
3521 // ------------------------------------------------------------------------------ //
3522 // TSCENE_MODES
3523 // ------------------------------------------------------------------------------ //
3524
3525
3526 // ------------------------------------------------------------------------------ //
3527 // sharpening_strength description:
3528 //
3529 // Control the exact sharpening value.
3530 //
3531 // Values:
3532 // [0-255]
3533 //
3534 // Key:
3535 // 128 - Standard Sharpening
3536 // <128 - Decreased Sharpening
3537 // >128 - Increased Sharpening
3538 //
3539 // Default Value: 128
3540 // ------------------------------------------------------------------------------ //
3541 #ifdef SHARPENING_STRENGTH_ID
3542 uint8_t sharpening_strength( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
3543 {
3544 *ret_value = 0;
3545 if ( direction == COMMAND_SET ) {
3546
3547 if ( value < 256 ) {
3548 uint32_t strength = value;
3549 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_SHARPENING_STRENGTH, &strength, sizeof( strength ) );
3550
3551 return SUCCESS;
3552 } else {
3553 return NOT_SUPPORTED;
3554 }
3555
3556 } else if ( direction == COMMAND_GET ) {
3557 uint32_t strength = 0;
3558 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SHARPENING_STRENGTH, NULL, 0, &strength, sizeof( strength ) );
3559 *ret_value = strength;
3560 return SUCCESS;
3561 }
3562 return NOT_SUPPORTED;
3563 }
3564 #endif
3565 // ------------------------------------------------------------------------------ //
3566 // fr_output_mode description:
3567 //
3568 // Select the output mode of the ISP.
3569 //
3570 // Values:
3571 // {RGB}
3572 // {YUV444}
3573 // {YUV422}
3574 // {YUV420}
3575 //
3576 // Default Value: {RGB}
3577 // ------------------------------------------------------------------------------ //
3578 #ifdef FR_OUTPUT_MODE_ID
3579 uint8_t fr_output_mode( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
3580 {
3581 uint32_t fr_output_fmt = 0;
3582 *ret_value = 0;
3583 if ( direction == COMMAND_SET ) {
3584 switch ( value ) {
3585 case RGB:
3586 fr_output_fmt = PIPE_OUT_RGB;
3587 break;
3588 case YUV444:
3589 fr_output_fmt = PIPE_OUT_YUV444;
3590 break;
3591 case YUV422:
3592 fr_output_fmt = PIPE_OUT_YUV422;
3593 break;
3594 case YUV420:
3595 fr_output_fmt = PIPE_OUT_YUV420;
3596 break;
3597 default:
3598 return NOT_SUPPORTED;
3599 }
3600
3601 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_MATRIX_YUV_FR_OUT_FMT, &fr_output_fmt, sizeof( fr_output_fmt ) );
3602
3603 return SUCCESS;
3604 } else if ( direction == COMMAND_GET ) {
3605
3606 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MATRIX_YUV_FR_OUT_FMT, NULL, 0, &fr_output_fmt, sizeof( fr_output_fmt ) );
3607 switch ( fr_output_fmt ) {
3608 case PIPE_OUT_RGB:
3609 *ret_value = RGB;
3610 break;
3611 case PIPE_OUT_YUV444:
3612 *ret_value = YUV444;
3613 break;
3614 case PIPE_OUT_YUV422:
3615 *ret_value = YUV422;
3616 break;
3617 case PIPE_OUT_YUV420:
3618 *ret_value = YUV420;
3619 break;
3620 default:
3621 return NOT_SUPPORTED;
3622 }
3623 return SUCCESS;
3624 }
3625 return NOT_IMPLEMENTED;
3626 }
3627 #endif
3628
3629
3630 // ------------------------------------------------------------------------------ //
3631 //Change FR Base and plane select and matrix yuv fsm accordingly
3632 //
3633 //FORMAT = PLANE_SELECT<<6 | BASE
3634 // ------------------------------------------------------------------------------ //
3635 #if defined( FR_FORMAT_BASE_PLANE_ID )
3636 uint8_t fr_format_base_plane( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
3637 {
3638 uint32_t result = NOT_SUPPORTED;
3639 *ret_value = 0;
3640 if ( direction == COMMAND_GET ) {
3641 uint8_t base = acamera_isp_fr_dma_writer_format_read( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base );
3642 uint8_t base_uv = acamera_isp_fr_uv_dma_writer_format_read( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base );
3643 switch ( base ) {
3644 case DMA_FORMAT_DISABLE:
3645 value = DMA_DISABLE;
3646 break;
3647 case DMA_FORMAT_RGB32:
3648 value = RGB32;
3649 break;
3650 case DMA_FORMAT_A2R10G10B10:
3651 value = A2R10G10B10;
3652 break;
3653 case DMA_FORMAT_RGB565:
3654 value = RGB565;
3655 break;
3656 case DMA_FORMAT_RGB24:
3657 value = RGB24;
3658 break;
3659 case DMA_FORMAT_GEN32:
3660 value = GEN32;
3661 break;
3662 case DMA_FORMAT_RAW16:
3663 value = RAW16;
3664 break;
3665 case DMA_FORMAT_RAW12:
3666 value = RAW12;
3667 break;
3668 case DMA_FORMAT_AYUV:
3669 value = AYUV;
3670 break;
3671 case DMA_FORMAT_Y410:
3672 value = Y410;
3673 break;
3674 case DMA_FORMAT_YUY2:
3675 value = YUY2;
3676 break;
3677 case DMA_FORMAT_UYVY:
3678 value = UYVY;
3679 break;
3680 case DMA_FORMAT_Y210:
3681 value = DMA_FORMAT_Y210;
3682 break;
3683 case DMA_FORMAT_NV12_Y:
3684 if ( base_uv == DMA_FORMAT_NV12_UV )
3685 value = NV12_YUV;
3686 else if (base_uv == DMA_FORMAT_NV12_VU)
3687 value = NV12_YVU;
3688 else if (base_uv == DMA_FORMAT_DISABLE)
3689 value = NV12_GREY;
3690 break;
3691 case DMA_FORMAT_YV12_Y:
3692 if ( base_uv == DMA_FORMAT_YV12_U )
3693 value = YV12_YU;
3694 else
3695 value = YV12_YV;
3696 break;
3697 default:
3698 return NOT_SUPPORTED;
3699 }
3700
3701 *ret_value = value;
3702 result = SUCCESS;
3703 } else if ( direction == COMMAND_SET ) {
3704 uint8_t base, base_uv = DMA_FORMAT_DISABLE;
3705 am_sc_set_input_format(value);
3706 switch ( value ) {
3707 case DMA_DISABLE:
3708 base = DMA_FORMAT_DISABLE;
3709 break;
3710 case RGB32:
3711 base = DMA_FORMAT_RGB32;
3712 break;
3713 case A2R10G10B10:
3714 base = DMA_FORMAT_A2R10G10B10;
3715 break;
3716 case RGB565:
3717 base = DMA_FORMAT_RGB565;
3718 break;
3719 case RGB24:
3720 base = DMA_FORMAT_RGB24;
3721 break;
3722 case GEN32:
3723 base = DMA_FORMAT_GEN32;
3724 break;
3725 case RAW16:
3726 base = DMA_FORMAT_RAW16;
3727 break;
3728 case RAW12:
3729 base = DMA_FORMAT_RAW12;
3730 break;
3731 case AYUV:
3732 base = DMA_FORMAT_AYUV;
3733 break;
3734 case Y410:
3735 base = DMA_FORMAT_Y410;
3736 break;
3737 case YUY2:
3738 base = DMA_FORMAT_YUY2;
3739 break;
3740 case UYVY:
3741 base = DMA_FORMAT_UYVY;
3742 break;
3743 case Y210:
3744 base = DMA_FORMAT_Y210;
3745 break;
3746 case NV12_YUV:
3747 base = DMA_FORMAT_NV12_Y;
3748 base_uv = DMA_FORMAT_NV12_UV;
3749 break;
3750 case NV12_YVU:
3751 base = DMA_FORMAT_NV12_Y;
3752 base_uv = DMA_FORMAT_NV12_VU;
3753 break;
3754 case NV12_GREY:
3755 base = DMA_FORMAT_NV12_Y;
3756 base_uv = DMA_FORMAT_DISABLE;
3757 break;
3758 case YV12_YU:
3759 base = DMA_FORMAT_YV12_Y;
3760 base_uv = DMA_FORMAT_YV12_U;
3761 break;
3762 case YV12_YV:
3763 base = DMA_FORMAT_YV12_Y;
3764 base_uv = DMA_FORMAT_YV12_V;
3765 break;
3766 default:
3767 return NOT_SUPPORTED;
3768 }
3769
3770 //uint8_t base = value & 0xFF;
3771
3772 uint32_t pipe_output_format = PIPE_OUT_RGB;
3773 switch ( base & 0xF ) {
3774
3775 case DMA_FORMAT_AYUV:
3776 case DMA_FORMAT_Y410:
3777 pipe_output_format = PIPE_OUT_YUV444;
3778 break;
3779 case DMA_FORMAT_YUY2:
3780 case DMA_FORMAT_UYVY:
3781 case DMA_FORMAT_Y210:
3782 pipe_output_format = PIPE_OUT_YUV422;
3783 break;
3784 case DMA_FORMAT_NV12_Y:
3785 case DMA_FORMAT_NV12_UV:
3786 case DMA_FORMAT_NV12_VU:
3787 pipe_output_format = PIPE_OUT_YUV420;
3788 break;
3789 }
3790
3791 if (base == DMA_FORMAT_RAW16)
3792 acamera_isp_top_isp_processing_fr_bypass_mode_write(ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, 1);
3793 else
3794 acamera_isp_top_isp_processing_fr_bypass_mode_write(ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, 0);
3795 acamera_isp_fr_dma_writer_format_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, base );
3796 acamera_isp_fr_uv_dma_writer_format_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, base_uv );
3797
3798 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_MATRIX_YUV_FR_OUT_FMT, &pipe_output_format, sizeof( pipe_output_format ) );
3799 result = SUCCESS;
3800 }
3801 return result;
3802 }
3803 #endif
3804
3805 // ------------------------------------------------------------------------------ //
3806 // ds1_output_mode description:
3807 //
3808 // Select the output mode of the ISP.
3809 //
3810 // Values:
3811 // {RGB}
3812 // {YUV444}
3813 // {YUV422}
3814 // {YUV420}
3815 //
3816 // Default Value: {RGB}
3817 // ------------------------------------------------------------------------------ //
3818 #if defined( DS1_OUTPUT_MODE_ID ) && ( ISP_HAS_DS1 )
3819 uint8_t ds1_output_mode( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
3820 {
3821 uint32_t output_fmt = 0;
3822 *ret_value = 0;
3823 if ( direction == COMMAND_SET ) {
3824 switch ( value ) {
3825 case RGB:
3826 output_fmt = PIPE_OUT_RGB;
3827 break;
3828 case YUV444:
3829 output_fmt = PIPE_OUT_YUV444;
3830 break;
3831 case YUV422:
3832 output_fmt = PIPE_OUT_YUV422;
3833 break;
3834 case YUV420:
3835 output_fmt = PIPE_OUT_YUV420;
3836 break;
3837 default:
3838 return NOT_SUPPORTED;
3839 }
3840
3841 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_MATRIX_YUV_DS1_OUT_FMT, &output_fmt, sizeof( output_fmt ) );
3842
3843 return SUCCESS;
3844 } else if ( direction == COMMAND_GET ) {
3845
3846 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MATRIX_YUV_DS1_OUT_FMT, NULL, 0, &output_fmt, sizeof( output_fmt ) );
3847 switch ( output_fmt ) {
3848 case PIPE_OUT_RGB:
3849 *ret_value = RGB;
3850 break;
3851 case PIPE_OUT_YUV444:
3852 *ret_value = YUV444;
3853 break;
3854 case PIPE_OUT_YUV422:
3855 *ret_value = YUV422;
3856 break;
3857 case PIPE_OUT_YUV420:
3858 *ret_value = YUV420;
3859 break;
3860 default:
3861 return NOT_SUPPORTED;
3862 }
3863 return SUCCESS;
3864 }
3865 return NOT_IMPLEMENTED;
3866 }
3867 #endif
3868
3869 // ------------------------------------------------------------------------------ //
3870 //Change FR Base and plane select and matrix yuv fsm accordingly
3871 //
3872 //FORMAT = PLANE_SELECT<<6 | BASE
3873 // ------------------------------------------------------------------------------ //
3874 #if defined( DS1_FORMAT_BASE_PLANE_ID ) && ( ISP_HAS_DS1 )
3875 uint8_t ds1_format_base_plane( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
3876 {
3877 uint32_t result = NOT_SUPPORTED;
3878 *ret_value = 0;
3879 if ( direction == COMMAND_GET ) {
3880 uint8_t base = acamera_isp_ds1_dma_writer_format_read( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base );
3881 uint8_t base_uv = acamera_isp_ds1_uv_dma_writer_format_read( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base );
3882 switch ( base ) {
3883 case DMA_FORMAT_DISABLE:
3884 value = DMA_DISABLE;
3885 break;
3886 case DMA_FORMAT_RGB32:
3887 value = RGB32;
3888 break;
3889 case DMA_FORMAT_A2R10G10B10:
3890 value = A2R10G10B10;
3891 break;
3892 case DMA_FORMAT_RGB565:
3893 value = RGB565;
3894 break;
3895 case DMA_FORMAT_RGB24:
3896 value = RGB24;
3897 break;
3898 case DMA_FORMAT_GEN32:
3899 value = GEN32;
3900 break;
3901 case DMA_FORMAT_RAW16:
3902 value = RAW16;
3903 break;
3904 case DMA_FORMAT_RAW12:
3905 value = RAW12;
3906 break;
3907 case DMA_FORMAT_AYUV:
3908 value = AYUV;
3909 break;
3910 case DMA_FORMAT_Y410:
3911 value = Y410;
3912 break;
3913 case DMA_FORMAT_YUY2:
3914 value = YUY2;
3915 break;
3916 case DMA_FORMAT_UYVY:
3917 value = UYVY;
3918 break;
3919 case DMA_FORMAT_Y210:
3920 value = DMA_FORMAT_Y210;
3921 break;
3922 case DMA_FORMAT_NV12_Y:
3923 if ( base_uv == DMA_FORMAT_NV12_UV )
3924 value = NV12_YUV;
3925 else if (base_uv == DMA_FORMAT_NV12_VU)
3926 value = NV12_YVU;
3927 else if (base_uv == DMA_FORMAT_DISABLE)
3928 value = NV12_GREY;
3929 break;
3930 case DMA_FORMAT_YV12_Y:
3931 if ( base_uv == DMA_FORMAT_YV12_U )
3932 value = YV12_YU;
3933 else
3934 value = YV12_YV;
3935 break;
3936 default:
3937 return NOT_SUPPORTED;
3938 }
3939
3940 *ret_value = value;
3941 result = SUCCESS;
3942 } else if ( direction == COMMAND_SET ) {
3943 uint8_t base, base_uv = DMA_FORMAT_DISABLE;
3944
3945 switch ( value ) {
3946 case DMA_DISABLE:
3947 base = DMA_FORMAT_DISABLE;
3948 break;
3949 case RGB32:
3950 base = DMA_FORMAT_RGB32;
3951 break;
3952 case A2R10G10B10:
3953 base = DMA_FORMAT_A2R10G10B10;
3954 break;
3955 case RGB565:
3956 base = DMA_FORMAT_RGB565;
3957 break;
3958 case RGB24:
3959 base = DMA_FORMAT_RGB24;
3960 break;
3961 case GEN32:
3962 base = DMA_FORMAT_GEN32;
3963 break;
3964 case RAW16:
3965 base = DMA_FORMAT_RAW16;
3966 break;
3967 case RAW12:
3968 base = DMA_FORMAT_RAW12;
3969 break;
3970 case AYUV:
3971 base = DMA_FORMAT_AYUV;
3972 break;
3973 case Y410:
3974 base = DMA_FORMAT_Y410;
3975 break;
3976 case YUY2:
3977 base = DMA_FORMAT_YUY2;
3978 break;
3979 case UYVY:
3980 base = DMA_FORMAT_UYVY;
3981 break;
3982 case Y210:
3983 base = DMA_FORMAT_Y210;
3984 break;
3985 case NV12_YUV:
3986 base = DMA_FORMAT_NV12_Y;
3987 base_uv = DMA_FORMAT_NV12_UV;
3988 break;
3989 case NV12_YVU:
3990 base = DMA_FORMAT_NV12_Y;
3991 base_uv = DMA_FORMAT_NV12_VU;
3992 break;
3993 case NV12_GREY:
3994 base = DMA_FORMAT_NV12_Y;
3995 base_uv = DMA_FORMAT_DISABLE;
3996 break;
3997 case YV12_YU:
3998 base = DMA_FORMAT_YV12_Y;
3999 base_uv = DMA_FORMAT_YV12_U;
4000 break;
4001 case YV12_YV:
4002 base = DMA_FORMAT_YV12_Y;
4003 base_uv = DMA_FORMAT_YV12_V;
4004 break;
4005 default:
4006 return NOT_SUPPORTED;
4007 }
4008
4009 //uint8_t base = value & 0xFF;
4010
4011 uint32_t pipe_output_format = PIPE_OUT_RGB;
4012 switch ( base & 0xF ) {
4013
4014 case DMA_FORMAT_AYUV:
4015 case DMA_FORMAT_Y410:
4016 pipe_output_format = PIPE_OUT_YUV444;
4017 break;
4018 case DMA_FORMAT_YUY2:
4019 case DMA_FORMAT_UYVY:
4020 case DMA_FORMAT_Y210:
4021 pipe_output_format = PIPE_OUT_YUV422;
4022 break;
4023 case DMA_FORMAT_NV12_Y:
4024 case DMA_FORMAT_NV12_UV:
4025 case DMA_FORMAT_NV12_VU:
4026 pipe_output_format = PIPE_OUT_YUV420;
4027 break;
4028 }
4029
4030 if (base == DMA_FORMAT_RAW16)
4031 return result;
4032
4033 acamera_isp_ds1_dma_writer_format_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, base );
4034 acamera_isp_ds1_uv_dma_writer_format_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, base_uv );
4035
4036 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_MATRIX_YUV_DS1_OUT_FMT, &pipe_output_format, sizeof( pipe_output_format ) );
4037 result = SUCCESS;
4038 }
4039 return result;
4040 }
4041 #endif
4042
4043 #if ISP_HAS_DS2
4044 uint8_t scaler_width(acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value)
4045 {
4046 uint32_t result = SUCCESS;
4047 *ret_value = 0;
4048 if ( direction == COMMAND_GET ) {
4049 *ret_value = am_sc_get_width();
4050 } else if (direction == COMMAND_SET){
4051 //first get fr width as amloigc scaler src width
4052 uint32_t width_cur = acamera_isp_top_active_width_read(instance->isp_base);
4053 am_sc_set_width(width_cur, value);
4054 } else {
4055 result = NOT_SUPPORTED;
4056 }
4057 return result;
4058 }
4059
4060 uint8_t scaler_height(acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value)
4061 {
4062 uint32_t result = SUCCESS;
4063 *ret_value = 0;
4064 if ( direction == COMMAND_GET ) {
4065
4066 } else if (direction == COMMAND_SET) {
4067 //first get fr height as amlogic scaler src height
4068 uint32_t height_cur = acamera_isp_top_active_height_read(instance->isp_base);
4069 am_sc_set_height(height_cur, value);
4070 } else {
4071 result = NOT_SUPPORTED;
4072 }
4073 return result;
4074 }
4075
4076 uint8_t scaler_src_width(acamera_fsm_mgr_t *instance, uint32_t value,
4077 uint8_t direction, uint32_t *ret_value)
4078 {
4079 uint32_t result = SUCCESS;
4080 *ret_value = 0;
4081 if ( direction == COMMAND_GET ) {
4082
4083 } else if (direction == COMMAND_SET) {
4084 am_sc_set_src_width(value);
4085 } else {
4086 result = NOT_SUPPORTED;
4087 }
4088 return result;
4089 }
4090
4091 uint8_t scaler_src_height(acamera_fsm_mgr_t *instance, uint32_t value,
4092 uint8_t direction, uint32_t *ret_value)
4093 {
4094 uint32_t result = SUCCESS;
4095 *ret_value = 0;
4096 if ( direction == COMMAND_GET ) {
4097
4098 } else if (direction == COMMAND_SET) {
4099 am_sc_set_src_height(value);
4100 } else {
4101 result = NOT_SUPPORTED;
4102 }
4103 return result;
4104 }
4105
4106
4107
4108 uint8_t scaler_output_mode( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
4109 {
4110 uint32_t result = SUCCESS;
4111 *ret_value = 0;
4112 if (direction == COMMAND_SET) {
4113 //todo list
4114 am_sc_set_output_format(value);
4115 } else {
4116 result = NOT_SUPPORTED;
4117 }
4118 return result;
4119 }
4120
4121 void scaler_streaming_on(void)
4122 {
4123 am_sc_hw_init();
4124 am_sc_start();
4125 }
4126
4127 void scaler_streaming_off(void)
4128 {
4129 am_sc_stop();
4130 }
4131
4132 #endif
4133
4134 // ------------------------------------------------------------------------------ //
4135 // brightness_strength description:
4136 //
4137 // Control the exact brightness value.
4138 //
4139 //
4140 // Values:
4141 // [0-255]
4142 //
4143 // Key:
4144 // 128 - Standard Brightness
4145 // <128 - Decreased Brightness
4146 // >128 - Increased Brightness
4147 //
4148 // Default Value: 128
4149 // ------------------------------------------------------------------------------ //
4150 #ifdef BRIGHTNESS_STRENGTH_ID
4151 uint8_t brightness_strength( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
4152 {
4153 #if defined( ISP_HAS_MATRIX_YUV_FSM )
4154 *ret_value = 0;
4155 if ( direction == COMMAND_SET ) {
4156 uint32_t brightness;
4157
4158 if ( value >= 256 )
4159 return NOT_SUPPORTED;
4160
4161 brightness = value;
4162 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_MATRIX_YUV_BRIGHTNESS_STRENGTH, &brightness, sizeof( brightness ) );
4163 return SUCCESS;
4164
4165 } else if ( direction == COMMAND_GET ) {
4166 uint32_t brightness = 0;
4167 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MATRIX_YUV_BRIGHTNESS_STRENGTH, NULL, 0, &brightness, sizeof( brightness ) );
4168 *ret_value = brightness;
4169 return SUCCESS;
4170 }
4171
4172 return NOT_SUPPORTED;
4173 #else
4174 return NOT_SUPPORTED;
4175 #endif
4176 }
4177 #endif
4178
4179
4180 // ------------------------------------------------------------------------------ //
4181 // contrast_strength description:
4182 //
4183 // Control the exact contrast value.
4184 //
4185 // Values:
4186 // [0-255]
4187 //
4188 // Key:
4189 // 128 - Standard Contrast
4190 // <128 - Decreased Contrast
4191 // >128 - Increased Contrast
4192 //
4193 // Default Value: 128
4194 // ------------------------------------------------------------------------------ //
4195 #ifdef CONTRAST_STRENGTH_ID
4196 uint8_t contrast_strength( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
4197 {
4198 #if defined( ISP_HAS_MATRIX_YUV_FSM )
4199 *ret_value = 0;
4200 if ( direction == COMMAND_SET ) {
4201 uint32_t strength;
4202
4203 if ( value >= 256 )
4204 return NOT_SUPPORTED;
4205
4206 strength = value;
4207 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_MATRIX_YUV_CONTRAST_STRENGTH, &strength, sizeof( strength ) );
4208 return SUCCESS;
4209
4210 } else if ( direction == COMMAND_GET ) {
4211 uint32_t strength = 0;
4212 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MATRIX_YUV_CONTRAST_STRENGTH, NULL, 0, &strength, sizeof( strength ) );
4213 *ret_value = strength;
4214 return SUCCESS;
4215 }
4216
4217 return NOT_SUPPORTED;
4218 #else
4219 return NOT_SUPPORTED;
4220 #endif
4221 }
4222 #endif
4223
4224
4225 // ------------------------------------------------------------------------------ //
4226 // saturation_strength description:
4227 //
4228 // Control the exact saturation strength.
4229 //
4230 // Values:
4231 // [0-255]
4232 //
4233 // Key:
4234 // 128 - Standard Saturation
4235 // <128 - Decreased Saturation
4236 // >128 - Increased Saturation
4237 //
4238 // Default Value: 128
4239 // ------------------------------------------------------------------------------ //
4240
4241 #ifdef SATURATION_STRENGTH_ID
4242 uint8_t saturation_strength( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
4243 {
4244 #if defined( ISP_HAS_MATRIX_YUV_FSM )
4245 uint32_t saturation_strength = 0;
4246 *ret_value = 0;
4247 if ( direction == COMMAND_SET ) {
4248 saturation_strength = value;
4249 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_MATRIX_YUV_SATURATION_STRENGTH, &saturation_strength, sizeof( saturation_strength ) );
4250 return SUCCESS;
4251 } else if ( direction == COMMAND_GET ) {
4252 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MATRIX_YUV_SATURATION_STRENGTH, NULL, 0, &saturation_strength, sizeof( saturation_strength ) );
4253 *ret_value = saturation_strength;
4254 return SUCCESS;
4255 }
4256
4257 return NOT_SUPPORTED;
4258 #else
4259 return NOT_SUPPORTED;
4260 #endif
4261 }
4262 #endif
4263 // ------------------------------------------------------------------------------ //
4264 // hue theta description:
4265 // Control the hue
4266 //
4267 // Values:[0-360]
4268 //
4269 //Default Value: 0
4270 // ------------------------------------------------------------------------------ //
4271 #ifdef HUE_THETA_ID
4272 uint8_t hue_theta( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
4273 {
4274 #if defined( ISP_HAS_MATRIX_YUV_FSM )
4275 uint16_t hue_theta = (uint16_t)value;
4276 *ret_value = 0;
4277 if ( direction == COMMAND_SET ) {
4278 if ( value > 360 )
4279 return NOT_SUPPORTED;
4280 else
4281 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_MATRIX_YUV_HUE_THETA, &hue_theta, sizeof( hue_theta ) );
4282
4283 return SUCCESS;
4284 } else if ( direction == COMMAND_GET ) {
4285 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MATRIX_YUV_HUE_THETA, NULL, 0, &hue_theta, sizeof( hue_theta ) );
4286 *ret_value = hue_theta;
4287 return SUCCESS;
4288 }
4289
4290 return NOT_SUPPORTED;
4291 #else
4292 return NOT_SUPPORTED;
4293 #endif
4294 }
4295 #endif
4296
4297 // ------------------------------------------------------------------------------ //
4298 // snr manual description:
4299 // Control the hue
4300 //
4301 // Values:[0-1]
4302 //
4303 //Default Value: 0
4304 // ------------------------------------------------------------------------------ //
4305 #ifdef SNR_MANUAL_ID
4306 uint8_t snr_manual( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
4307 {
4308 #if defined( ISP_HAS_SINTER_RADIAL_LUT )
4309 uint32_t snr_manual = (uint32_t)value;
4310 *ret_value = 0;
4311 if ( direction == COMMAND_SET ) {
4312 if ( value > 1 )
4313 return NOT_SUPPORTED;
4314 else
4315 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_SNR_MANUAL, &snr_manual, sizeof( snr_manual ) );
4316
4317 return SUCCESS;
4318 } else if ( direction == COMMAND_GET ) {
4319 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SNR_MANUAL, NULL, 0, &snr_manual, sizeof( snr_manual ) );
4320 *ret_value = snr_manual;
4321 return SUCCESS;
4322 }
4323
4324 return NOT_SUPPORTED;
4325 #else
4326 return NOT_SUPPORTED;
4327 #endif
4328 }
4329 #endif
4330
4331 // ------------------------------------------------------------------------------ //
4332 // snr strength description:
4333 // Control the hue
4334 //
4335 // Values:[0-255]
4336 //
4337 //Default Value: 128
4338 // ------------------------------------------------------------------------------ //
4339 #ifdef SNR_STRENGTH_ID
4340 uint8_t snr_strength( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
4341 {
4342 #if defined( ISP_HAS_SINTER_RADIAL_LUT )
4343 uint32_t snr_strength = (uint32_t)value;
4344 *ret_value = 0;
4345 if ( direction == COMMAND_SET ) {
4346 if ( value > 255 )
4347 return NOT_SUPPORTED;
4348 else
4349 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_SNR_STRENGTH, &snr_strength, sizeof( snr_strength ) );
4350
4351 return SUCCESS;
4352 } else if ( direction == COMMAND_GET ) {
4353 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_SNR_STRENGTH, NULL, 0, &snr_strength, sizeof( snr_strength ) );
4354 *ret_value = snr_strength;
4355 return SUCCESS;
4356 }
4357
4358 return NOT_SUPPORTED;
4359 #else
4360 return NOT_SUPPORTED;
4361 #endif
4362 }
4363 #endif
4364
4365 // ------------------------------------------------------------------------------ //
4366 // tnr manual description:
4367 // Control the hue
4368 //
4369 // Values:[0-1]
4370 //
4371 //Default Value: 0
4372 // ------------------------------------------------------------------------------ //
4373 #ifdef TNR_MANUAL_ID
4374 uint8_t tnr_manual( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
4375 {
4376 #if defined( ISP_HAS_SINTER_RADIAL_LUT )
4377 uint32_t tnr_manual = (uint32_t)value;
4378 *ret_value = 0;
4379 if ( direction == COMMAND_SET ) {
4380 if ( value > 1 )
4381 return NOT_SUPPORTED;
4382 else
4383 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_TNR_MANUAL, &tnr_manual, sizeof( tnr_manual ) );
4384
4385 return SUCCESS;
4386 } else if ( direction == COMMAND_GET ) {
4387 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_TNR_MANUAL, NULL, 0, &tnr_manual, sizeof( tnr_manual ) );
4388 *ret_value = tnr_manual;
4389 return SUCCESS;
4390 }
4391
4392 return NOT_SUPPORTED;
4393 #else
4394 return NOT_SUPPORTED;
4395 #endif
4396 }
4397 #endif
4398
4399 // ------------------------------------------------------------------------------ //
4400 // tnr offset description:
4401 // Control the hue
4402 //
4403 // Values:[0-255]
4404 //
4405 //Default Value: 128
4406 // ------------------------------------------------------------------------------ //
4407 #ifdef TNR_OFFSET_ID
4408 uint8_t tnr_offset( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
4409 {
4410 #if defined( ISP_HAS_SINTER_RADIAL_LUT )
4411 uint32_t tnr_offset = (uint32_t)value;
4412 *ret_value = 0;
4413 if ( direction == COMMAND_SET ) {
4414 if ( value > 255 )
4415 return NOT_SUPPORTED;
4416 else
4417 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_TNR_OFFSET, &tnr_offset, sizeof( tnr_offset ) );
4418
4419 return SUCCESS;
4420 } else if ( direction == COMMAND_GET ) {
4421 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_TNR_OFFSET, NULL, 0, &tnr_offset, sizeof( tnr_offset ) );
4422 *ret_value = tnr_offset;
4423 return SUCCESS;
4424 }
4425
4426 return NOT_SUPPORTED;
4427 #else
4428 return NOT_SUPPORTED;
4429 #endif
4430 }
4431 #endif
4432
4433 // ------------------------------------------------------------------------------ //
4434 // orientation_hflip description:
4435 //
4436 // Horizontally flip the output image.
4437 //
4438 // Values:
4439 // {ENABLE}
4440 // {DISABLE}
4441 //
4442 // Default Value: {DISABLE}
4443 // ------------------------------------------------------------------------------ //
4444 #ifdef ORIENTATION_HFLIP_ID
4445 uint8_t orientation_hflip( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
4446 {
4447 *ret_value = 0;
4448
4449 switch ( direction ) {
4450 case COMMAND_SET:
4451 switch ( value ) {
4452 case ENABLE:
4453 if(instance->p_ctx->hflip == 0)
4454 {
4455 instance->p_ctx->hflip = 1;
4456 acamera_isp_top_bypass_mirror_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, 0 ); // enable mirror
4457 uint8_t mirror = acamera_isp_top_rggb_start_post_mirror_read(ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base);
4458 if(mirror == BAYER_RGGB)
4459 acamera_isp_top_rggb_start_post_mirror_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, BAYER_GRBG ); // color after mirror is: Gr-R-B-Gb
4460 else if(mirror == BAYER_GRBG)
4461 acamera_isp_top_rggb_start_post_mirror_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, BAYER_RGGB );
4462 else if(mirror == BAYER_GBRG)
4463 acamera_isp_top_rggb_start_post_mirror_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, BAYER_BGGR );
4464 else if(mirror == BAYER_BGGR)
4465 acamera_isp_top_rggb_start_post_mirror_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, BAYER_GBRG );
4466 }
4467 break;
4468 case DISABLE:
4469 if(instance->p_ctx->hflip == 1)
4470 {
4471 instance->p_ctx->hflip = 0;
4472 acamera_isp_top_bypass_mirror_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, 1 ); // bypass mirror
4473 uint8_t mirror = acamera_isp_top_rggb_start_post_mirror_read(ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base);
4474 if(mirror == BAYER_RGGB)
4475 acamera_isp_top_rggb_start_post_mirror_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, BAYER_GRBG ); // color after mirror is: Gr-R-B-Gb
4476 else if(mirror == BAYER_GRBG)
4477 acamera_isp_top_rggb_start_post_mirror_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, BAYER_RGGB );
4478 else if(mirror == BAYER_GBRG)
4479 acamera_isp_top_rggb_start_post_mirror_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, BAYER_BGGR );
4480 else if(mirror == BAYER_BGGR)
4481 acamera_isp_top_rggb_start_post_mirror_write( ACAMERA_MGR2CTX_PTR( instance )->settings.isp_base, BAYER_GBRG );
4482 }
4483 break;
4484 default:
4485 *ret_value = ERR_BAD_ARGUMENT;
4486 return FAIL;
4487 }
4488
4489 // reload some tables according with flip
4490 #if FW_DO_INITIALIZATION && ISP_HAS_COLOR_MATRIX_FSM
4491 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_SHADING_MESH_RELOAD, NULL, 0 );
4492 #endif
4493
4494 #ifdef AF_ROI_ID
4495 {
4496 uint32_t roi;
4497 af_roi( instance, 0, COMMAND_GET, &roi );
4498 af_roi( instance, roi, COMMAND_SET, &roi );
4499 }
4500 #endif
4501 #ifdef AE_ROI_ID
4502 {
4503 uint32_t roi;
4504 ae_roi( instance, 0, COMMAND_GET, &roi );
4505 ae_roi( instance, roi, COMMAND_SET, &roi );
4506 }
4507 #endif
4508 return SUCCESS;
4509 case COMMAND_GET:
4510 *ret_value = instance->p_ctx->hflip ? ENABLE : DISABLE;
4511 return SUCCESS;
4512 default:
4513 return NOT_IMPLEMENTED;
4514 }
4515 }
4516 #endif
4517
4518 // ------------------------------------------------------------------------------ //
4519 // orientation_vflip description:
4520 //
4521 // Vertically flip the output image.
4522 //
4523 // Values:
4524 // {ENABLE}
4525 // {DISABLE}
4526 //
4527 // Default Value: {DISABLE}
4528 // ------------------------------------------------------------------------------ //
4529 #ifdef ORIENTATION_VFLIP_ID
4530 uint8_t orientation_vflip( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
4531 {
4532 *ret_value = 0;
4533 #if defined( ISP_HAS_DMA_WRITER_FSM )
4534 switch ( direction ) {
4535 case COMMAND_SET: {
4536 uint32_t vflip = 0;
4537 switch ( value ) {
4538 case ENABLE:
4539 vflip = 1;
4540 break;
4541 case DISABLE:
4542 vflip = 0;
4543 break;
4544 default:
4545 *ret_value = ERR_BAD_ARGUMENT;
4546 return FAIL;
4547 }
4548
4549 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_DMA_VFLIP, &vflip, sizeof( vflip ) );
4550
4551 #ifdef AF_ROI_ID
4552 {
4553 uint32_t roi;
4554 af_roi( instance, 0, COMMAND_GET, &roi );
4555 af_roi( instance, roi, COMMAND_SET, &roi );
4556 }
4557 #endif
4558 #ifdef AE_ROI_ID
4559 {
4560 uint32_t roi;
4561 ae_roi( instance, 0, COMMAND_GET, &roi );
4562 ae_roi( instance, roi, COMMAND_SET, &roi );
4563 }
4564 #endif
4565 return SUCCESS;
4566 }
4567
4568 case COMMAND_GET: {
4569 uint32_t vflip = 0;
4570 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_DMA_VFLIP, NULL, 0, &vflip, sizeof( vflip ) );
4571
4572 // PROBABLY WILL BE DIFFERENT FOR DIFFERENT ISP
4573 *ret_value = vflip ? ENABLE : DISABLE;
4574
4575 return SUCCESS;
4576 }
4577
4578 default:
4579 return NOT_IMPLEMENTED;
4580 }
4581 #else
4582 return NOT_SUPPORTED;
4583 #endif
4584 }
4585 #endif
4586
4587
4588 // ------------------------------------------------------------------------------ //
4589 // color_mode description:
4590 //
4591 // Select the color mode of the ISP.
4592 //
4593 // Values:
4594 // {NORMAL}
4595 // {BLACK_AND_WHITE}
4596 // {NEGATIVE}
4597 // {SEPIA}
4598 // {VIVID}
4599 //
4600 // Default Value: {NORMAL}
4601 // ------------------------------------------------------------------------------ //
4602 #ifdef COLOR_MODE_ID
4603 uint8_t color_mode( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
4604 {
4605 *ret_value = 0;
4606
4607 if ( direction == COMMAND_SET ) {
4608
4609 if ( VIVID == value ) {
4610 acamera_command( instance->ctx_id, TSCENE_MODES, SATURATION_STRENGTH_ID, 154, COMMAND_SET, ret_value );
4611 } else {
4612 acamera_command( instance->ctx_id, TSCENE_MODES, SATURATION_STRENGTH_ID, 128, COMMAND_SET, ret_value );
4613 }
4614
4615 switch ( value ) {
4616 case VIVID:
4617 case NORMAL:
4618 case BLACK_AND_WHITE:
4619 case NEGATIVE:
4620 case SEPIA: {
4621 uint32_t color_mode = (uint16_t)value;
4622 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_MATRIX_YUV_COLOR_MODE, &color_mode, sizeof( color_mode ) );
4623 } break;
4624 default:
4625 return NOT_SUPPORTED;
4626 break;
4627 }
4628 return SUCCESS;
4629
4630 } else if ( direction == COMMAND_GET ) {
4631 uint32_t color_mode = 0;
4632
4633 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MATRIX_YUV_COLOR_MODE, NULL, 0, &color_mode, sizeof( color_mode ) );
4634
4635 if ( color_mode == 0 ) //at init
4636 *ret_value = NORMAL;
4637 else
4638 *ret_value = color_mode;
4639
4640 return SUCCESS;
4641 }
4642 return NOT_SUPPORTED;
4643 }
4644 #endif
4645
4646 //---------------------------------------------------------------------------------------
4647
4648
4649 #ifdef STATUS_INFO_AWB_MIX_LIGHT_CONTRAST
4650 uint8_t status_info_awb_mix_light_contrast( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
4651 {
4652 *ret_value = 0;
4653
4654 switch ( direction ) {
4655 case COMMAND_SET:
4656 return NOT_PERMITTED;
4657 case COMMAND_GET: {
4658 status_info_param_t *p_status_info = (status_info_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_STATUS_INFO );
4659 *ret_value = p_status_info->awb_info.mix_light_contrast;
4660 return SUCCESS;
4661 }
4662 default:
4663 return NOT_IMPLEMENTED;
4664 }
4665 }
4666 #endif
4667
4668 #ifdef STATUS_INFO_AF_LENS_POS
4669 uint8_t status_info_af_lens_pos( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
4670 {
4671 *ret_value = 0;
4672
4673 switch ( direction ) {
4674 case COMMAND_SET:
4675 return NOT_PERMITTED;
4676 case COMMAND_GET: {
4677 status_info_param_t *p_status_info = (status_info_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_STATUS_INFO );
4678 *ret_value = p_status_info->af_info.lens_pos;
4679 return SUCCESS;
4680 }
4681 default:
4682 return NOT_IMPLEMENTED;
4683 }
4684 }
4685 #endif
4686
4687 #ifdef STATUS_INFO_AF_FOCUS_VALUE
4688 uint8_t status_info_af_focus_value( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
4689 {
4690 *ret_value = 0;
4691
4692 switch ( direction ) {
4693 case COMMAND_SET:
4694 return NOT_PERMITTED;
4695 case COMMAND_GET: {
4696 status_info_param_t *p_status_info = (status_info_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_STATUS_INFO );
4697 *ret_value = p_status_info->af_info.focus_value;
4698 return SUCCESS;
4699 }
4700 default:
4701 return NOT_IMPLEMENTED;
4702 }
4703 }
4704 #endif
4705
4706 #ifdef STATUS_INFO_EXPOSURE_LOG2_ID
4707 uint8_t status_info_exposure_log2( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
4708 {
4709 *ret_value = 0;
4710 switch ( direction ) {
4711 case COMMAND_SET:
4712 return NOT_PERMITTED;
4713 case COMMAND_GET: {
4714 status_info_param_t *p_status_info = (status_info_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_STATUS_INFO );
4715 *ret_value = p_status_info->sys_info.exposure_log2;
4716 return SUCCESS;
4717 }
4718 default:
4719 return NOT_IMPLEMENTED;
4720 }
4721 }
4722 #endif
4723
4724 #ifdef STATUS_INFO_GAIN_ONES_ID
4725 uint8_t status_info_gain_ones( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
4726 {
4727 *ret_value = 0;
4728 switch ( direction ) {
4729 case COMMAND_SET:
4730 return NOT_PERMITTED;
4731 case COMMAND_GET: {
4732 status_info_param_t *p_status_info = (status_info_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_STATUS_INFO );
4733 *ret_value = acamera_math_exp2( p_status_info->sys_info.total_gain_log2, LOG2_GAIN_SHIFT, 0 );
4734
4735 return SUCCESS;
4736 }
4737 default:
4738 return NOT_IMPLEMENTED;
4739 }
4740 }
4741 #endif
4742
4743 #ifdef STATUS_INFO_GAIN_LOG2_ID
4744 uint8_t status_info_gain_log2( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
4745 {
4746 *ret_value = 0;
4747 switch ( direction ) {
4748 case COMMAND_SET:
4749 return NOT_PERMITTED;
4750 case COMMAND_GET: {
4751 status_info_param_t *p_status_info = (status_info_param_t *)_GET_UINT_PTR( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_STATUS_INFO );
4752 *ret_value = ( p_status_info->sys_info.total_gain_log2 + ( ( 1 << ( LOG2_GAIN_SHIFT - 1 ) ) - 1 ) ) >> LOG2_GAIN_SHIFT;
4753 return SUCCESS;
4754 }
4755 default:
4756 return NOT_IMPLEMENTED;
4757 }
4758 }
4759 #endif
4760
4761
4762 //---------------------------------------------------------------------------------------
4763 static uint8_t acamera_calibration_update( acamera_fsm_mgr_t *instance, uint32_t id, uint8_t direction, void *data, uint32_t data_size, uint32_t *ret_value )
4764 {
4765 uint8_t result = SUCCESS;
4766 *ret_value = 0;
4767 if ( id < CALIBRATION_TOTAL_SIZE && data != NULL ) {
4768 // we require preceise size of source and destanation
4769 if ( data_size == _GET_SIZE( ACAMERA_MGR2CTX_PTR( instance ), id ) ) {
4770 // assume command_set by default
4771 uint8_t *src = (uint8_t *)data;
4772 uint8_t *dst = (uint8_t *)_GET_LUT_PTR( ACAMERA_MGR2CTX_PTR( instance ), id );
4773 if ( direction == COMMAND_GET ) {
4774 // change src and dst
4775 src = (uint8_t *)_GET_LUT_PTR( ACAMERA_MGR2CTX_PTR( instance ), id );
4776 dst = (uint8_t *)data;
4777 }
4778 // copy buffers from src to dst as char array
4779 uint32_t idx = 0;
4780 for ( idx = 0; idx < data_size; idx++ ) {
4781 dst[idx] = src[idx];
4782 }
4783 result = SUCCESS;
4784 *ret_value = 0;
4785 } else {
4786 result = FAIL;
4787 *ret_value = ERR_WRONG_SIZE;
4788 }
4789 } else {
4790 result = FAIL;
4791 *ret_value = ERR_BAD_ARGUMENT;
4792 }
4793 return result;
4794 }
4795
4796 #ifdef BUFFER_DATA_TYPE
4797
4798 static uint32_t get_calibration_description( acamera_fsm_mgr_t *instance, uint32_t id )
4799 {
4800 uint32_t result = 0;
4801 if ( id < CALIBRATION_TOTAL_SIZE ) {
4802 // support only 1, 2 and 4 bytes format now.
4803 // it's enough 2 bits only for this data
4804 uint32_t width = _GET_WIDTH( ACAMERA_MGR2CTX_PTR( instance ), id ) - 1;
4805 uint32_t rows = _GET_ROWS( ACAMERA_MGR2CTX_PTR( instance ), id );
4806 uint32_t cols = _GET_COLS( ACAMERA_MGR2CTX_PTR( instance ), id );
4807 // the description format is 2 bits for width
4808 // 15 bits for rows number and 15 bits for cols number
4809 result = ( width << 30 | ( rows << 15 ) | cols );
4810 } else {
4811 LOG( LOG_ERR, "Table pointer has invalid index %d. Maximum possible value is %d", (int)id, CALIBRATION_TOTAL_SIZE );
4812 }
4813 return result;
4814 }
4815
4816
4817 uint8_t buffer_data_type( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
4818 {
4819 *ret_value = 0;
4820 switch ( direction ) {
4821 case COMMAND_GET:
4822 *ret_value = get_calibration_description( instance, value );
4823 return SUCCESS;
4824 default:
4825 return NOT_IMPLEMENTED;
4826 }
4827 }
4828 #endif
4829
4830
4831 uint8_t acamera_api_calibration( uint32_t ctx_id, uint8_t type, uint8_t id, uint8_t direction, void *data, uint32_t data_size, uint32_t *ret_value )
4832 {
4833
4834 #ifdef BUFFER_DATA_TYPE
4835 uint8_t result = SUCCESS;
4836 acamera_fsm_mgr_t *instance = &( ( (acamera_context_t *)acamera_get_ctx_ptr(ctx_id) )->fsm_mgr );
4837 *ret_value = 0;
4838
4839 #ifdef CALIBRATION_SENSOR_REGISTER_LUT
4840 uint16_t *src;
4841 uint32_t rows;
4842 uint32_t i;
4843 fsm_param_reg_cfg_t reg_cfg;
4844 #endif
4845
4846 if ( !instance || ( direction != COMMAND_SET && direction != COMMAND_GET ) ) {
4847 *ret_value = ERR_BAD_ARGUMENT;
4848 return FAIL;
4849 }
4850
4851 #if FW_HAS_CONTROL_CHANNEL
4852 ctrl_channel_handle_api_calibration( ctx_id, type, id, direction, data, data_size );
4853 #endif
4854
4855 if ( id < CALIBRATION_TOTAL_SIZE ) {
4856
4857 int16_t internal_lut_idx = id;
4858
4859 if ( internal_lut_idx != -1 ) {
4860 // update an internal look-up table
4861 result = acamera_calibration_update( instance, internal_lut_idx, direction, data, data_size, ret_value );
4862
4863 if ( direction == COMMAND_SET ) {
4864 // do some initialization after
4865 // a lut was updated
4866 switch ( internal_lut_idx ) {
4867 #ifdef CALIBRATION_SENSOR_REGISTER_LUT
4868 case CALIBRATION_SENSOR_REGISTER_LUT:
4869 src = (uint16_t *)_GET_LUT_PTR( ACAMERA_MGR2CTX_PTR( instance ), internal_lut_idx );
4870 rows = _GET_ROWS( ACAMERA_MGR2CTX_PTR( instance ), internal_lut_idx );
4871 for ( i = 0; i < rows; i++ ) {
4872 reg_cfg.reg_addr = *src;
4873 reg_cfg.reg_value = *( src + 1 );
4874 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_SENSOR_REG, ®_cfg, sizeof( reg_cfg ) );
4875 src += 2;
4876 }
4877 break;
4878 #endif
4879 case CALIBRATION_SHARPEN_FR:
4880 #ifdef CALIBRATION_SHARPEN_DS1
4881 case CALIBRATION_SHARPEN_DS1:
4882 #endif
4883 #ifdef CALIBRATION_SHARPEN_DS2
4884 case CALIBRATION_SHARPEN_DS2:
4885 #endif
4886 case CALIBRATION_SHARP_ALT_D:
4887 case CALIBRATION_SHARP_ALT_UD:
4888 #if defined( ISP_HAS_SHARPENING_FSM )
4889 // sharpening_initialize is an empty function right now, so we don't need to
4890 // add function here for new FW.
4891
4892 #endif
4893 break;
4894 case CALIBRATION_MT_ABSOLUTE_LS_A_CCM:
4895 case CALIBRATION_MT_ABSOLUTE_LS_D40_CCM:
4896 case CALIBRATION_MT_ABSOLUTE_LS_D50_CCM:
4897 #if ISP_HAS_COLOR_MATRIX_FSM
4898 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_CCM_CHANGE, NULL, 0 );
4899 #endif
4900 break;
4901 case CALIBRATION_GAMMA:
4902 case CALIBRATION_DEMOSAIC:
4903 #ifdef CALIBRATION_GAMMA_EV1
4904 case CALIBRATION_GAMMA_EV1:
4905 #endif
4906 #ifdef CALIBRATION_GAMMA_EV2
4907 case CALIBRATION_GAMMA_EV2:
4908 #endif
4909 case CALIBRATION_NOISE_PROFILE:
4910 #ifdef CALIBRATION_GAMMA_FE_0
4911 case CALIBRATION_GAMMA_FE_0:
4912 #endif
4913 #ifdef CALIBRATION_GAMMA_FE_1
4914 case CALIBRATION_GAMMA_FE_1:
4915 #endif
4916 #ifdef CALIBRATION_GAMMA_THRESHOLD
4917 case CALIBRATION_GAMMA_THRESHOLD:
4918 #endif
4919 case CALIBRATION_SHADING_LS_A_R:
4920 case CALIBRATION_SHADING_LS_A_G:
4921 case CALIBRATION_SHADING_LS_A_B:
4922 case CALIBRATION_SHADING_LS_TL84_R:
4923 case CALIBRATION_SHADING_LS_TL84_G:
4924 case CALIBRATION_SHADING_LS_TL84_B:
4925 case CALIBRATION_SHADING_LS_D65_R:
4926 case CALIBRATION_SHADING_LS_D65_G:
4927 case CALIBRATION_SHADING_LS_D65_B:
4928 #if ISP_HAS_GENERAL_FSM
4929 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_RELOAD_CALIBRATION, NULL, 0 );
4930 #endif
4931 break;
4932 case CALIBRATION_IRIDIX_ASYMMETRY:
4933 #if defined( ISP_HAS_IRIDIX_FSM ) || defined( ISP_HAS_IRIDIX_HIST_FSM ) || defined( ISP_HAS_IRIDIX_MANUAL_FSM )
4934 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_IRIDIX_INIT, NULL, 0 );
4935 #endif
4936 break;
4937 #ifdef CALIBRATION_DEFECT_PIXELS
4938 case CALIBRATION_DEFECT_PIXELS: {
4939 int32_t res = defect_pixel_table_write( data, _GET_LEN( ACAMERA_MGR2CTX_PTR( instance ), CALIBRATION_DEFECT_PIXELS ) );
4940 if ( res == 0 )
4941 result = SUCCESS;
4942 else
4943 result = FAIL;
4944 } break;
4945 #endif
4946 default:
4947 // do not do anything for this lut
4948 result = SUCCESS;
4949 }
4950 }
4951 } else {
4952 LOG( LOG_ERR, "Trying to get an access with an invalid LUT index %d", internal_lut_idx );
4953 result = FAIL;
4954 }
4955 } else {
4956 LOG( LOG_ERR, "Trying to get an access with an invalid LUT index %d", id );
4957 result = FAIL;
4958 }
4959
4960 return result;
4961 #else
4962 return FAIL;
4963 #endif
4964 }
4965
4966
4967 #ifdef CALIBRATION_UPDATE
4968 extern int32_t acamera_update_calibration_set( acamera_context_ptr_t p_ctx );
4969 uint8_t calibration_update( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
4970 {
4971 //set for each context
4972 acamera_context_ptr_t p_ctx = (acamera_context_t *)acamera_get_api_ctx_ptr();
4973 *ret_value = 0;
4974 if ( direction == COMMAND_GET ) {
4975 *ret_value = DONE;
4976 return SUCCESS;
4977 } else if ( direction == COMMAND_SET ) {
4978 if ( value == UPDATE ) {
4979 uint32_t result = acamera_update_calibration_set( p_ctx );
4980 if ( result != 0 ) {
4981 *ret_value = FAIL;
4982 }
4983 }
4984 return SUCCESS;
4985 } else {
4986 return NOT_SUPPORTED;
4987 }
4988 return NOT_SUPPORTED;
4989 }
4990 #endif
4991
4992
4993 //type: dma pipe fs or ds1; id:context but reserved for now; direction MASK reserved for now
4994 uint8_t acamera_api_dma_buffer( uint32_t ctx_id, uint8_t type, void *data, uint32_t data_size, uint32_t *ret_value, uint32_t index)
4995 {
4996 uint8_t result = SUCCESS;
4997
4998 //disable dma
4999
5000 //write frames
5001 #if defined( ISP_HAS_DMA_WRITER_FSM )
5002 acamera_fsm_mgr_t *instance = &( ( (acamera_context_t *)acamera_get_ctx_ptr(ctx_id) )->fsm_mgr );
5003 fsm_param_dma_pipe_setting_t pipe_update;
5004
5005 pipe_update.pipe_id = type;
5006 pipe_update.buf_array = (tframe_t *)data;
5007 pipe_update.buf_len = data_size;
5008 pipe_update.callback = NULL;
5009 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_DMA_PIPE_SETTING, &pipe_update, sizeof( pipe_update ) );
5010 #else
5011 result = NOT_SUPPORTED;
5012 #endif
5013
5014 return result;
5015 }
5016
5017 uint8_t acamera_api_set_fps(uint32_t ctx_id, uint8_t type, uint32_t c_fps, uint32_t t_fps)
5018 {
5019 acamera_fsm_mgr_t *instance = NULL;
5020 fsm_param_path_fps_t pipe_fps;
5021
5022 pipe_fps.pipe_id = type;
5023 pipe_fps.c_fps = c_fps;
5024 pipe_fps.t_fps = t_fps;
5025
5026 instance = &(((acamera_context_t *)acamera_get_ctx_ptr(ctx_id) )->fsm_mgr);
5027
5028 acamera_fsm_mgr_set_param(instance, FSM_PARAM_SET_PATH_FPS, &pipe_fps, sizeof(pipe_fps));
5029
5030 return SUCCESS;
5031 }
5032
5033 void acamera_api_dma_buff_queue_reset(uint32_t ctx_id, uint8_t type)
5034 {
5035 uint8_t d_type = 0xff;
5036
5037 acamera_fsm_mgr_t *instance = &( ( (acamera_context_t *)acamera_get_ctx_ptr(ctx_id) )->fsm_mgr );
5038
5039 d_type = type;
5040
5041 acamera_fsm_mgr_set_param(instance, FSM_PARAM_SET_DMA_QUEUE_RESET, &d_type, sizeof(d_type));
5042 }
5043
5044 void acamera_api_dma_buff_get_next(uint32_t ctx_id, uint8_t type)
5045 {
5046 uint8_t d_type = 0xff;
5047
5048 acamera_fsm_mgr_t *instance = &( ( (acamera_context_t *)acamera_get_ctx_ptr(ctx_id) )->fsm_mgr );
5049
5050 d_type = type;
5051
5052 acamera_fsm_mgr_set_param(instance, FSM_PARAM_SET_DMA_PULL_BUFFER, &d_type, sizeof(d_type));
5053 }
5054
5055 #ifdef MON_ERROR_CALIBRATION_LUT_NULL
5056 uint8_t monitor_error_calibration_lut_null( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5057 {
5058 uint8_t result = SUCCESS;
5059 uint32_t err_type = MON_TYPE_ERR_CALIBRATION_LUT_NULL;
5060 *ret_value = 0;
5061
5062 if ( direction == COMMAND_GET ) {
5063 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_ERROR, &err_type, sizeof( err_type ), ret_value, sizeof( uint32_t ) );
5064 result = SUCCESS;
5065 } else {
5066 if ( value != 0 ) {
5067 result = NOT_SUPPORTED;
5068 } else {
5069 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_MON_RESET_ERROR, &err_type, sizeof( err_type ) );
5070 result = SUCCESS;
5071 }
5072 }
5073
5074 return result;
5075 }
5076 #endif
5077
5078 #ifdef MON_ERROR_CMOS_FS_DELAY
5079 uint8_t monitor_error_cmos_frame_start_delay( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5080 {
5081 uint8_t result = SUCCESS;
5082 uint32_t err_type = MON_TYPE_ERR_CMOS_FS_DELAY;
5083 *ret_value = 0;
5084
5085 if ( direction == COMMAND_GET ) {
5086 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_ERROR, &err_type, sizeof( err_type ), ret_value, sizeof( uint32_t ) );
5087 result = SUCCESS;
5088 } else {
5089 if ( value != 0 ) {
5090 result = NOT_SUPPORTED;
5091 } else {
5092 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_MON_RESET_ERROR, &err_type, sizeof( err_type ) );
5093 result = SUCCESS;
5094 }
5095 }
5096
5097 return result;
5098 }
5099 #endif
5100
5101 #ifdef MON_ERROR_CMOS_UPDATE_NOT_IN_VB
5102 uint8_t monitor_error_cmos_update_not_in_vb( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5103 {
5104 uint8_t result = SUCCESS;
5105 uint32_t err_type = MON_TYPE_ERR_CMOS_UPDATE_NOT_IN_VB;
5106 *ret_value = 0;
5107
5108 if ( direction == COMMAND_GET ) {
5109 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_ERROR, &err_type, sizeof( err_type ), ret_value, sizeof( uint32_t ) );
5110 result = SUCCESS;
5111 } else {
5112 if ( value != 0 ) {
5113 result = NOT_SUPPORTED;
5114 } else {
5115 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_MON_RESET_ERROR, &err_type, sizeof( err_type ) );
5116 result = SUCCESS;
5117 }
5118 }
5119
5120 return result;
5121 }
5122 #endif
5123
5124 #ifdef MON_ERROR_CMOS_UPDATE_DGAIN_WRONG_TIMING
5125 uint8_t monitor_error_cmos_update_dgain_wrong_timing( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5126 {
5127 uint8_t result = SUCCESS;
5128 uint32_t err_type = MON_TYPE_ERR_CMOS_UPDATE_DGAIN_WRONG_TIMING;
5129 *ret_value = 0;
5130
5131 if ( direction == COMMAND_GET ) {
5132 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_ERROR, &err_type, sizeof( err_type ), ret_value, sizeof( uint32_t ) );
5133 result = SUCCESS;
5134 } else {
5135 if ( value != 0 ) {
5136 result = NOT_SUPPORTED;
5137 } else {
5138 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_MON_RESET_ERROR, &err_type, sizeof( err_type ) );
5139 result = SUCCESS;
5140 }
5141 }
5142
5143 return result;
5144 }
5145 #endif
5146
5147 #ifdef MON_ERROR_IRIDIX_UPDATE_NOT_IN_VB
5148 uint8_t monitor_error_iridix_update_not_in_vb( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5149 {
5150 uint8_t result = SUCCESS;
5151 uint32_t err_type = MON_TYPE_ERR_IRIDIX_UPDATE_NOT_IN_VB;
5152 *ret_value = 0;
5153
5154 if ( direction == COMMAND_GET ) {
5155 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_ERROR, &err_type, sizeof( err_type ), ret_value, sizeof( uint32_t ) );
5156 result = SUCCESS;
5157 } else {
5158 if ( value != 0 ) {
5159 result = NOT_SUPPORTED;
5160 } else {
5161 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_MON_RESET_ERROR, &err_type, sizeof( err_type ) );
5162 result = SUCCESS;
5163 }
5164 }
5165
5166 return result;
5167 }
5168 #endif
5169
5170 #ifdef MON_STATUS_AE_RESET
5171 uint8_t monitor_status_ae_reset( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5172 {
5173 uint8_t result = SUCCESS;
5174 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_STATUS_RESET;
5175 *ret_value = 0;
5176
5177 if ( direction == COMMAND_GET ) {
5178 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_AE, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5179 result = SUCCESS;
5180 } else {
5181 fsm_param_mon_status_head_t mon_status;
5182 mon_status.status_type = MON_TYPE_STATUS_ALG_STATUS_RESET;
5183 mon_status.status_param = value;
5184 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_MON_STATUS_AE, &mon_status, sizeof( mon_status ) );
5185 result = SUCCESS;
5186 }
5187
5188 return result;
5189 }
5190 #endif
5191
5192 #ifdef MON_STATUS_AE_FPT_MIN
5193 uint8_t monitor_status_ae_fpt_min( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5194 {
5195 uint8_t result = SUCCESS;
5196 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_FPT_MIN;
5197 *ret_value = 0;
5198
5199 if ( direction == COMMAND_GET ) {
5200 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_AE, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5201 result = SUCCESS;
5202 } else {
5203 result = NOT_SUPPORTED;
5204 }
5205
5206 return result;
5207 }
5208 #endif
5209
5210 #ifdef MON_STATUS_AE_FPT_CUR
5211 uint8_t monitor_status_ae_fpt_cur( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5212 {
5213 uint8_t result = SUCCESS;
5214 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_FPT_CUR;
5215 *ret_value = 0;
5216
5217 if ( direction == COMMAND_GET ) {
5218 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_AE, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5219 result = SUCCESS;
5220 } else {
5221 result = NOT_SUPPORTED;
5222 }
5223
5224 return result;
5225 }
5226 #endif
5227
5228 #ifdef MON_STATUS_AE_FPT_MAX
5229 uint8_t monitor_status_ae_fpt_max( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5230 {
5231 uint8_t result = SUCCESS;
5232 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_FPT_MAX;
5233 *ret_value = 0;
5234
5235 if ( direction == COMMAND_GET ) {
5236 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_AE, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5237 result = SUCCESS;
5238 } else {
5239 result = NOT_SUPPORTED;
5240 }
5241
5242 return result;
5243 }
5244 #endif
5245
5246 #ifdef MON_STATUS_AE_DELAY_STATS2EV_MIN
5247 uint8_t monitor_status_ae_delay_stats2ev_min( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5248 {
5249 uint8_t result = SUCCESS;
5250 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_IN2OUT_MIN;
5251 *ret_value = 0;
5252
5253 if ( direction == COMMAND_GET ) {
5254 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_AE, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5255 result = SUCCESS;
5256 } else {
5257 result = NOT_SUPPORTED;
5258 }
5259
5260 return result;
5261 }
5262 #endif
5263
5264 #ifdef MON_STATUS_AE_DELAY_STATS2EV_CUR
5265 uint8_t monitor_status_ae_delay_stats2ev_cur( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5266 {
5267 uint8_t result = SUCCESS;
5268 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_IN2OUT_CUR;
5269 *ret_value = 0;
5270
5271 if ( direction == COMMAND_GET ) {
5272 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_AE, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5273 result = SUCCESS;
5274 } else {
5275 result = NOT_SUPPORTED;
5276 }
5277
5278 return result;
5279 }
5280 #endif
5281
5282 #ifdef MON_STATUS_AE_DELAY_STATS2EV_MAX
5283 uint8_t monitor_status_ae_delay_stats2ev_max( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5284 {
5285 uint8_t result = SUCCESS;
5286 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_IN2OUT_MAX;
5287 *ret_value = 0;
5288
5289 if ( direction == COMMAND_GET ) {
5290 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_AE, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5291 result = SUCCESS;
5292 } else {
5293 result = NOT_SUPPORTED;
5294 }
5295
5296 return result;
5297 }
5298 #endif
5299
5300 #ifdef MON_STATUS_AE_DELAY_EV2APPLY_MIN
5301 uint8_t monitor_status_ae_delay_ev2apply_min( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5302 {
5303 uint8_t result = SUCCESS;
5304 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_OUT2APPLY_MIN;
5305 *ret_value = 0;
5306
5307 if ( direction == COMMAND_GET ) {
5308 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_AE, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5309 result = SUCCESS;
5310 } else {
5311 result = NOT_SUPPORTED;
5312 }
5313
5314 return result;
5315 }
5316 #endif
5317
5318 #ifdef MON_STATUS_AE_DELAY_EV2APPLY_CUR
5319 uint8_t monitor_status_ae_delay_ev2apply_cur( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5320 {
5321 uint8_t result = SUCCESS;
5322 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_OUT2APPLY_CUR;
5323 *ret_value = 0;
5324
5325 if ( direction == COMMAND_GET ) {
5326 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_AE, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5327 result = SUCCESS;
5328 } else {
5329 result = NOT_SUPPORTED;
5330 }
5331
5332 return result;
5333 }
5334 #endif
5335
5336 #ifdef MON_STATUS_AE_DELAY_EV2APPLY_MAX
5337 uint8_t monitor_status_ae_delay_ev2apply_max( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5338 {
5339 uint8_t result = SUCCESS;
5340 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_OUT2APPLY_MAX;
5341 *ret_value = 0;
5342
5343 if ( direction == COMMAND_GET ) {
5344 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_AE, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5345 result = SUCCESS;
5346 } else {
5347 result = NOT_SUPPORTED;
5348 }
5349
5350 return result;
5351 }
5352 #endif
5353
5354 #ifdef MON_STATUS_AWB_RESET
5355 uint8_t monitor_status_awb_reset( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5356 {
5357 uint8_t result = SUCCESS;
5358 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_STATUS_RESET;
5359 *ret_value = 0;
5360
5361 if ( direction == COMMAND_GET ) {
5362 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_AWB, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5363 result = SUCCESS;
5364 } else {
5365 fsm_param_mon_status_head_t mon_status;
5366 mon_status.status_type = MON_TYPE_STATUS_ALG_STATUS_RESET;
5367 mon_status.status_param = value;
5368 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_MON_STATUS_AWB, &mon_status, sizeof( mon_status ) );
5369 result = SUCCESS;
5370 }
5371
5372 return result;
5373 }
5374 #endif
5375
5376 #ifdef MON_STATUS_AWB_FPT_MIN
5377 uint8_t monitor_status_awb_fpt_min( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5378 {
5379 uint8_t result = SUCCESS;
5380 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_FPT_MIN;
5381 *ret_value = 0;
5382
5383 if ( direction == COMMAND_GET ) {
5384 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_AWB, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5385 result = SUCCESS;
5386 } else {
5387 result = NOT_SUPPORTED;
5388 }
5389
5390 return result;
5391 }
5392 #endif
5393
5394 #ifdef MON_STATUS_AWB_FPT_CUR
5395 uint8_t monitor_status_awb_fpt_cur( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5396 {
5397 uint8_t result = SUCCESS;
5398 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_FPT_CUR;
5399 *ret_value = 0;
5400
5401 if ( direction == COMMAND_GET ) {
5402 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_AWB, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5403 result = SUCCESS;
5404 } else {
5405 result = NOT_SUPPORTED;
5406 }
5407
5408 return result;
5409 }
5410 #endif
5411
5412 #ifdef MON_STATUS_AWB_FPT_MAX
5413 uint8_t monitor_status_awb_fpt_max( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5414 {
5415 uint8_t result = SUCCESS;
5416 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_FPT_MAX;
5417 *ret_value = 0;
5418
5419 if ( direction == COMMAND_GET ) {
5420 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_AWB, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5421 result = SUCCESS;
5422 } else {
5423 result = NOT_SUPPORTED;
5424 }
5425
5426 return result;
5427 }
5428 #endif
5429
5430 #ifdef MON_STATUS_AWB_DELAY_STATS2GAIN_MIN
5431 uint8_t monitor_status_awb_delay_stats2gain_min( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5432 {
5433 uint8_t result = SUCCESS;
5434 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_IN2OUT_MIN;
5435 *ret_value = 0;
5436
5437 if ( direction == COMMAND_GET ) {
5438 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_AWB, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5439 result = SUCCESS;
5440 } else {
5441 result = NOT_SUPPORTED;
5442 }
5443
5444 return result;
5445 }
5446 #endif
5447
5448 #ifdef MON_STATUS_AWB_DELAY_STATS2GAIN_CUR
5449 uint8_t monitor_status_awb_delay_stats2gain_cur( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5450 {
5451 uint8_t result = SUCCESS;
5452 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_IN2OUT_CUR;
5453 *ret_value = 0;
5454
5455 if ( direction == COMMAND_GET ) {
5456 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_AWB, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5457 result = SUCCESS;
5458 } else {
5459 result = NOT_SUPPORTED;
5460 }
5461
5462 return result;
5463 }
5464 #endif
5465
5466 #ifdef MON_STATUS_AWB_DELAY_STATS2GAIN_MAX
5467 uint8_t monitor_status_awb_delay_stats2gain_max( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5468 {
5469 uint8_t result = SUCCESS;
5470 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_IN2OUT_MAX;
5471 *ret_value = 0;
5472
5473 if ( direction == COMMAND_GET ) {
5474 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_AWB, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5475 result = SUCCESS;
5476 } else {
5477 result = NOT_SUPPORTED;
5478 }
5479
5480 return result;
5481 }
5482 #endif
5483
5484 #ifdef MON_STATUS_AWB_DELAY_GAIN2APPLY_MIN
5485 uint8_t monitor_status_awb_delay_gain2apply_min( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5486 {
5487 uint8_t result = SUCCESS;
5488 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_OUT2APPLY_MIN;
5489 *ret_value = 0;
5490
5491 if ( direction == COMMAND_GET ) {
5492 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_AWB, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5493 result = SUCCESS;
5494 } else {
5495 result = NOT_SUPPORTED;
5496 }
5497
5498 return result;
5499 }
5500 #endif
5501
5502 #ifdef MON_STATUS_AWB_DELAY_GAIN2APPLY_CUR
5503 uint8_t monitor_status_awb_delay_gain2apply_cur( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5504 {
5505 uint8_t result = SUCCESS;
5506 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_OUT2APPLY_CUR;
5507 *ret_value = 0;
5508
5509 if ( direction == COMMAND_GET ) {
5510 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_AWB, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5511 result = SUCCESS;
5512 } else {
5513 result = NOT_SUPPORTED;
5514 }
5515
5516 return result;
5517 }
5518 #endif
5519
5520 #ifdef MON_STATUS_AWB_DELAY_GAIN2APPLY_MAX
5521 uint8_t monitor_status_awb_delay_gain2apply_max( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5522 {
5523 uint8_t result = SUCCESS;
5524 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_OUT2APPLY_MAX;
5525 *ret_value = 0;
5526
5527 if ( direction == COMMAND_GET ) {
5528 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_AWB, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5529 result = SUCCESS;
5530 } else {
5531 result = NOT_SUPPORTED;
5532 }
5533
5534 return result;
5535 }
5536 #endif
5537
5538 #ifdef MON_STATUS_GAMMA_RESET
5539 uint8_t monitor_status_gamma_reset( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5540 {
5541 uint8_t result = SUCCESS;
5542 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_STATUS_RESET;
5543 *ret_value = 0;
5544
5545 if ( direction == COMMAND_GET ) {
5546 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_GAMMA, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5547 result = SUCCESS;
5548 } else {
5549 fsm_param_mon_status_head_t mon_status;
5550 mon_status.status_type = MON_TYPE_STATUS_ALG_STATUS_RESET;
5551 mon_status.status_param = value;
5552 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_MON_STATUS_GAMMA, &mon_status, sizeof( mon_status ) );
5553 result = SUCCESS;
5554 }
5555
5556 return result;
5557 }
5558 #endif
5559
5560 #ifdef MON_STATUS_GAMMA_FPT_MIN
5561 uint8_t monitor_status_gamma_fpt_min( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5562 {
5563 uint8_t result = SUCCESS;
5564 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_FPT_MIN;
5565 *ret_value = 0;
5566
5567 if ( direction == COMMAND_GET ) {
5568 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_GAMMA, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5569 result = SUCCESS;
5570 } else {
5571 result = NOT_SUPPORTED;
5572 }
5573
5574 return result;
5575 }
5576 #endif
5577
5578 #ifdef MON_STATUS_GAMMA_FPT_CUR
5579 uint8_t monitor_status_gamma_fpt_cur( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5580 {
5581 uint8_t result = SUCCESS;
5582 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_FPT_CUR;
5583 *ret_value = 0;
5584
5585 if ( direction == COMMAND_GET ) {
5586 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_GAMMA, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5587 result = SUCCESS;
5588 } else {
5589 result = NOT_SUPPORTED;
5590 }
5591
5592 return result;
5593 }
5594 #endif
5595
5596 #ifdef MON_STATUS_GAMMA_FPT_MAX
5597 uint8_t monitor_status_gamma_fpt_max( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5598 {
5599 uint8_t result = SUCCESS;
5600 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_FPT_MAX;
5601 *ret_value = 0;
5602
5603 if ( direction == COMMAND_GET ) {
5604 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_GAMMA, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5605 result = SUCCESS;
5606 } else {
5607 result = NOT_SUPPORTED;
5608 }
5609
5610 return result;
5611 }
5612 #endif
5613
5614
5615 #ifdef MON_STATUS_GAMMA_DELAY_STATS2LUT_MIN
5616 uint8_t monitor_status_gamma_delay_stats2lut_min( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5617 {
5618 uint8_t result = SUCCESS;
5619 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_IN2OUT_MIN;
5620 *ret_value = 0;
5621
5622 if ( direction == COMMAND_GET ) {
5623 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_GAMMA, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5624 result = SUCCESS;
5625 } else {
5626 result = NOT_SUPPORTED;
5627 }
5628
5629 return result;
5630 }
5631 #endif
5632
5633 #ifdef MON_STATUS_GAMMA_DELAY_STATS2LUT_CUR
5634 uint8_t monitor_status_gamma_delay_stats2lut_cur( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5635 {
5636 uint8_t result = SUCCESS;
5637 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_IN2OUT_CUR;
5638 *ret_value = 0;
5639
5640 if ( direction == COMMAND_GET ) {
5641 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_GAMMA, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5642 result = SUCCESS;
5643 } else {
5644 result = NOT_SUPPORTED;
5645 }
5646
5647 return result;
5648 }
5649 #endif
5650
5651 #ifdef MON_STATUS_GAMMA_DELAY_STATS2LUT_MAX
5652 uint8_t monitor_status_gamma_delay_stats2lut_max( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5653 {
5654 uint8_t result = SUCCESS;
5655 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_IN2OUT_MAX;
5656 *ret_value = 0;
5657
5658 if ( direction == COMMAND_GET ) {
5659 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_GAMMA, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5660 result = SUCCESS;
5661 } else {
5662 result = NOT_SUPPORTED;
5663 }
5664
5665 return result;
5666 }
5667 #endif
5668
5669 #ifdef MON_STATUS_GAMMA_DELAY_LUT2APPLY_MIN
5670 uint8_t monitor_status_gamma_delay_lut2apply_min( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5671 {
5672 uint8_t result = SUCCESS;
5673 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_OUT2APPLY_MIN;
5674 *ret_value = 0;
5675
5676 if ( direction == COMMAND_GET ) {
5677 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_GAMMA, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5678 result = SUCCESS;
5679 } else {
5680 result = NOT_SUPPORTED;
5681 }
5682
5683 return result;
5684 }
5685 #endif
5686
5687 #ifdef MON_STATUS_GAMMA_DELAY_LUT2APPLY_CUR
5688 uint8_t monitor_status_gamma_delay_lut2apply_cur( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5689 {
5690 uint8_t result = SUCCESS;
5691 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_OUT2APPLY_CUR;
5692 *ret_value = 0;
5693
5694 if ( direction == COMMAND_GET ) {
5695 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_GAMMA, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5696 result = SUCCESS;
5697 } else {
5698 result = NOT_SUPPORTED;
5699 }
5700
5701 return result;
5702 }
5703 #endif
5704
5705 #ifdef MON_STATUS_GAMMA_DELAY_LUT2APPLY_MAX
5706 uint8_t monitor_status_gamma_delay_lut2apply_max( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5707 {
5708 uint8_t result = SUCCESS;
5709 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_OUT2APPLY_MAX;
5710 *ret_value = 0;
5711
5712 if ( direction == COMMAND_GET ) {
5713 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_GAMMA, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5714 result = SUCCESS;
5715 } else {
5716 result = NOT_SUPPORTED;
5717 }
5718
5719 return result;
5720 }
5721 #endif
5722
5723 #ifdef MON_STATUS_IRIDIX_RESET
5724 uint8_t monitor_status_iridix_reset( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5725 {
5726 uint8_t result = SUCCESS;
5727 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_STATUS_RESET;
5728 *ret_value = 0;
5729
5730 if ( direction == COMMAND_GET ) {
5731 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_IRIDIX, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5732 result = SUCCESS;
5733 } else {
5734 fsm_param_mon_status_head_t mon_status;
5735 mon_status.status_type = MON_TYPE_STATUS_ALG_STATUS_RESET;
5736 mon_status.status_param = value;
5737 acamera_fsm_mgr_set_param( instance, FSM_PARAM_SET_MON_STATUS_IRIDIX, &mon_status, sizeof( mon_status ) );
5738 result = SUCCESS;
5739 }
5740
5741 return result;
5742 }
5743 #endif
5744
5745 #ifdef MON_STATUS_IRIDIX_FPT_MIN
5746 uint8_t monitor_status_iridix_fpt_min( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5747 {
5748 uint8_t result = SUCCESS;
5749 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_FPT_MIN;
5750 *ret_value = 0;
5751
5752 if ( direction == COMMAND_GET ) {
5753 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_IRIDIX, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5754 result = SUCCESS;
5755 } else {
5756 result = NOT_SUPPORTED;
5757 }
5758
5759 return result;
5760 }
5761 #endif
5762
5763 #ifdef MON_STATUS_IRIDIX_FPT_CUR
5764 uint8_t monitor_status_iridix_fpt_cur( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5765 {
5766 uint8_t result = SUCCESS;
5767 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_FPT_CUR;
5768 *ret_value = 0;
5769
5770 if ( direction == COMMAND_GET ) {
5771 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_IRIDIX, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5772 result = SUCCESS;
5773 } else {
5774 result = NOT_SUPPORTED;
5775 }
5776
5777 return result;
5778 }
5779 #endif
5780
5781 #ifdef MON_STATUS_IRIDIX_FPT_MAX
5782 uint8_t monitor_status_iridix_fpt_max( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5783 {
5784 uint8_t result = SUCCESS;
5785 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_FPT_MAX;
5786 *ret_value = 0;
5787
5788 if ( direction == COMMAND_GET ) {
5789 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_IRIDIX, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5790 result = SUCCESS;
5791 } else {
5792 result = NOT_SUPPORTED;
5793 }
5794
5795 return result;
5796 }
5797 #endif
5798
5799 #ifdef MON_STATUS_IRIDIX_DELAY_STATS2TARGET_MIN
5800 uint8_t monitor_status_iridix_delay_stats2target_min( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5801 {
5802 uint8_t result = SUCCESS;
5803 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_IN2OUT_MIN;
5804 *ret_value = 0;
5805
5806 if ( direction == COMMAND_GET ) {
5807 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_IRIDIX, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5808 result = SUCCESS;
5809 } else {
5810 result = NOT_SUPPORTED;
5811 }
5812
5813 return result;
5814 }
5815 #endif
5816
5817 #ifdef MON_STATUS_IRIDIX_DELAY_STATS2TARGET_CUR
5818 uint8_t monitor_status_iridix_delay_stats2target_cur( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5819 {
5820 uint8_t result = SUCCESS;
5821 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_IN2OUT_CUR;
5822 *ret_value = 0;
5823
5824 if ( direction == COMMAND_GET ) {
5825 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_IRIDIX, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5826 result = SUCCESS;
5827 } else {
5828 result = NOT_SUPPORTED;
5829 }
5830
5831 return result;
5832 }
5833 #endif
5834
5835 #ifdef MON_STATUS_IRIDIX_DELAY_STATS2TARGET_MAX
5836 uint8_t monitor_status_iridix_delay_stats2target_max( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5837 {
5838 uint8_t result = SUCCESS;
5839 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_IN2OUT_MAX;
5840 *ret_value = 0;
5841
5842 if ( direction == COMMAND_GET ) {
5843 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_IRIDIX, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5844 result = SUCCESS;
5845 } else {
5846 result = NOT_SUPPORTED;
5847 }
5848
5849 return result;
5850 }
5851 #endif
5852
5853 #ifdef MON_STATUS_IRIDIX_DELAY_TARGET2APPLY_MIN
5854 uint8_t monitor_status_iridix_delay_target2apply_min( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5855 {
5856 uint8_t result = SUCCESS;
5857 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_OUT2APPLY_MIN;
5858 *ret_value = 0;
5859
5860 if ( direction == COMMAND_GET ) {
5861 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_IRIDIX, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5862 result = SUCCESS;
5863 } else {
5864 result = NOT_SUPPORTED;
5865 }
5866
5867 return result;
5868 }
5869 #endif
5870
5871 #ifdef MON_STATUS_IRIDIX_DELAY_TARGET2APPLY_CUR
5872 uint8_t monitor_status_iridix_delay_target2apply_cur( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5873 {
5874 uint8_t result = SUCCESS;
5875 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_OUT2APPLY_CUR;
5876 *ret_value = 0;
5877
5878 if ( direction == COMMAND_GET ) {
5879 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_IRIDIX, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5880 result = SUCCESS;
5881 } else {
5882 result = NOT_SUPPORTED;
5883 }
5884
5885 return result;
5886 }
5887 #endif
5888
5889 #ifdef MON_STATUS_IRIDIX_DELAY_TARGET2APPLY_MAX
5890 uint8_t monitor_status_iridix_delay_target2apply_max( acamera_fsm_mgr_t *instance, uint32_t value, uint8_t direction, uint32_t *ret_value )
5891 {
5892 uint8_t result = SUCCESS;
5893 uint32_t mon_status_type = MON_TYPE_STATUS_ALG_DELAY_OUT2APPLY_MAX;
5894 *ret_value = 0;
5895
5896 if ( direction == COMMAND_GET ) {
5897 acamera_fsm_mgr_get_param( instance, FSM_PARAM_GET_MON_STATUS_IRIDIX, &mon_status_type, sizeof( mon_status_type ), ret_value, sizeof( uint32_t ) );
5898 result = SUCCESS;
5899 } else {
5900 result = NOT_SUPPORTED;
5901 }
5902
5903 return result;
5904 }
5905 #endif
5906