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_fw.h"
21 #include "monitor_fsm.h"
22
23 #ifdef LOG_MODULE
24 #undef LOG_MODULE
25 #define LOG_MODULE LOG_MODULE_MONITOR
26 #endif
27
28 // Note: this name order should match the order of MON_ALG_INDEX
29 static char *mon_alg_name[MON_ALG_INDEX_MAX] = {
30 "AE",
31 "AWB",
32 "GAMMA",
33 "IRIDIX",
34 };
35
monitor_fsm_clear(monitor_fsm_t * p_fsm)36 void monitor_fsm_clear( monitor_fsm_t *p_fsm )
37 {
38 uint32_t i;
39 mon_alg_info_t *p_mon_info = NULL;
40
41 memset( &p_fsm->mon_info_cali, 0, sizeof( p_fsm->mon_info_cali ) );
42 memset( &p_fsm->mon_info_cmos, 0, sizeof( p_fsm->mon_info_cmos ) );
43 memset( &p_fsm->mon_info_iridix, 0, sizeof( p_fsm->mon_info_iridix ) );
44
45 for ( i = 0; i < MON_ALG_INDEX_MAX; i++ ) {
46 p_mon_info = &p_fsm->mon_alg_arr[i];
47 p_mon_info->alg_name = mon_alg_name[i];
48
49 // Init to 0xFFFFFFFF which is an invalid value
50 p_mon_info->alg_delay_in2out_min = 0xFFFFFFFF;
51 p_mon_info->alg_delay_in2out_cur = 0xFFFFFFFF;
52 p_mon_info->alg_delay_in2out_max = 0xFFFFFFFF;
53 p_mon_info->alg_delay_out2apply_min = 0xFFFFFFFF;
54 p_mon_info->alg_delay_out2apply_cur = 0xFFFFFFFF;
55 p_mon_info->alg_delay_out2apply_max = 0xFFFFFFFF;
56 p_mon_info->alg_fpt_min = 0xFFFF;
57 p_mon_info->alg_fpt_cur = 0;
58 p_mon_info->alg_fpt_max = 0;
59 p_mon_info->mon_alg_frame_count = 0;
60 memset( p_mon_info->alg_state_arr, 0, sizeof( p_mon_info->alg_state_arr ) );
61 p_mon_info->alg_arr_write_pos = 0;
62
63 p_mon_info->alg_reset_status = 0;
64 }
65 }
66
monitor_request_interrupt(monitor_fsm_ptr_t p_fsm,system_fw_interrupt_mask_t mask)67 void monitor_request_interrupt( monitor_fsm_ptr_t p_fsm, system_fw_interrupt_mask_t mask )
68 {
69 acamera_isp_interrupts_disable( ACAMERA_FSM2MGR_PTR( p_fsm ) );
70 p_fsm->mask.irq_mask |= mask;
71 acamera_isp_interrupts_enable( ACAMERA_FSM2MGR_PTR( p_fsm ) );
72 }
73
monitor_fsm_init(void * fsm,fsm_init_param_t * init_param)74 void monitor_fsm_init( void *fsm, fsm_init_param_t *init_param )
75 {
76 monitor_fsm_t *p_fsm = (monitor_fsm_t *)fsm;
77 p_fsm->cmn.p_fsm_mgr = init_param->p_fsm_mgr;
78 p_fsm->cmn.isp_base = init_param->isp_base;
79 p_fsm->p_fsm_mgr = init_param->p_fsm_mgr;
80
81 monitor_fsm_clear( p_fsm );
82
83 monitor_initialize( p_fsm );
84 }
85
monitor_fsm_process_event(monitor_fsm_t * p_fsm,event_id_t event_id)86 uint8_t monitor_fsm_process_event( monitor_fsm_t *p_fsm, event_id_t event_id )
87 {
88 uint8_t b_event_processed = 0;
89 switch ( event_id ) {
90 default:
91 break;
92 case event_id_monitor_frame_end:
93
94 b_event_processed = 1;
95 }
96
97 return b_event_processed;
98 }
99
monitor_fsm_set_param(void * fsm,uint32_t param_id,void * input,uint32_t input_size)100 int monitor_fsm_set_param( void *fsm, uint32_t param_id, void *input, uint32_t input_size )
101 {
102 int rc = 0;
103 monitor_fsm_t *p_fsm = (monitor_fsm_t *)fsm;
104
105 switch ( param_id ) {
106 case FSM_PARAM_SET_MON_ERROR_REPORT: {
107 if ( !input || input_size < sizeof( fsm_param_mon_err_head_t ) ) {
108 LOG( LOG_ERR, "Invalid param, param_id: %d.", param_id );
109 rc = -1;
110 break;
111 }
112
113 monitor_handle_error_report( p_fsm, (fsm_param_mon_err_head_t *)input );
114
115 break;
116 }
117
118 case FSM_PARAM_SET_MON_RESET_ERROR: {
119 if ( !input || input_size != sizeof( uint32_t ) ) {
120 LOG( LOG_ERR, "Invalid param, param_id: %d.", param_id );
121 rc = -1;
122 break;
123 }
124
125 uint32_t err_type = *(uint32_t *)input;
126
127 monitor_handle_reset_error_report( p_fsm, err_type );
128
129 break;
130 }
131
132 case FSM_PARAM_SET_MON_AE_FLOW:
133 if ( !input || input_size != sizeof( fsm_param_mon_alg_flow_t ) ) {
134 LOG( LOG_ERR, "Invalid param, param_id: %d.", param_id );
135 rc = -1;
136 break;
137 }
138
139 monitor_handle_alg_flow( p_fsm, &p_fsm->mon_alg_arr[MON_ALG_AE_INDEX], (fsm_param_mon_alg_flow_t *)input );
140 break;
141
142 case FSM_PARAM_SET_MON_AWB_FLOW:
143 if ( !input || input_size != sizeof( fsm_param_mon_alg_flow_t ) ) {
144 LOG( LOG_ERR, "Invalid param, param_id: %d.", param_id );
145 rc = -1;
146 break;
147 }
148
149 monitor_handle_alg_flow( p_fsm, &p_fsm->mon_alg_arr[MON_ALG_AWB_INDEX], (fsm_param_mon_alg_flow_t *)input );
150 break;
151
152 case FSM_PARAM_SET_MON_GAMMA_FLOW:
153 if ( !input || input_size != sizeof( fsm_param_mon_alg_flow_t ) ) {
154 LOG( LOG_ERR, "Invalid param, param_id: %d.", param_id );
155 rc = -1;
156 break;
157 }
158
159 monitor_handle_alg_flow( p_fsm, &p_fsm->mon_alg_arr[MON_ALG_GAMMA_INDEX], (fsm_param_mon_alg_flow_t *)input );
160 break;
161
162 case FSM_PARAM_SET_MON_IRIDIX_FLOW:
163 if ( !input || input_size != sizeof( fsm_param_mon_alg_flow_t ) ) {
164 LOG( LOG_ERR, "Invalid param, param_id: %d.", param_id );
165 rc = -1;
166 break;
167 }
168
169 monitor_handle_alg_flow( p_fsm, &p_fsm->mon_alg_arr[MON_ALG_IRIDIX_INDEX], (fsm_param_mon_alg_flow_t *)input );
170 break;
171
172 case FSM_PARAM_SET_MON_STATUS_AE:
173 if ( !input || input_size != sizeof( fsm_param_mon_status_head_t ) ) {
174 LOG( LOG_ERR, "Invalid param, param_id: %d.", param_id );
175 rc = -1;
176 break;
177 }
178
179 monitor_set_alg_status( p_fsm, &p_fsm->mon_alg_arr[MON_ALG_AE_INDEX], (fsm_param_mon_status_head_t *)input );
180 break;
181
182 case FSM_PARAM_SET_MON_STATUS_AWB:
183 if ( !input || input_size != sizeof( fsm_param_mon_status_head_t ) ) {
184 LOG( LOG_ERR, "Invalid param, param_id: %d.", param_id );
185 rc = -1;
186 break;
187 }
188
189 monitor_set_alg_status( p_fsm, &p_fsm->mon_alg_arr[MON_ALG_AWB_INDEX], (fsm_param_mon_status_head_t *)input );
190 break;
191
192 case FSM_PARAM_SET_MON_STATUS_GAMMA:
193 if ( !input || input_size != sizeof( fsm_param_mon_status_head_t ) ) {
194 LOG( LOG_ERR, "Invalid param, param_id: %d.", param_id );
195 rc = -1;
196 break;
197 }
198
199 monitor_set_alg_status( p_fsm, &p_fsm->mon_alg_arr[MON_ALG_GAMMA_INDEX], (fsm_param_mon_status_head_t *)input );
200 break;
201
202 case FSM_PARAM_SET_MON_STATUS_IRIDIX:
203 if ( !input || input_size != sizeof( fsm_param_mon_status_head_t ) ) {
204 LOG( LOG_ERR, "Invalid param, param_id: %d.", param_id );
205 rc = -1;
206 break;
207 }
208
209 monitor_set_alg_status( p_fsm, &p_fsm->mon_alg_arr[MON_ALG_IRIDIX_INDEX], (fsm_param_mon_status_head_t *)input );
210 break;
211
212 default:
213 LOG( LOG_ERR, "Invalid param, param_id: %d.", param_id );
214 rc = -1;
215 break;
216 }
217
218 return rc;
219 }
220
monitor_fsm_get_param(void * fsm,uint32_t param_id,void * input,uint32_t input_size,void * output,uint32_t output_size)221 int monitor_fsm_get_param( void *fsm, uint32_t param_id, void *input, uint32_t input_size, void *output, uint32_t output_size )
222 {
223 int rc = 0;
224 monitor_fsm_t *p_fsm = (monitor_fsm_t *)fsm;
225
226 switch ( param_id ) {
227 case FSM_PARAM_GET_MON_ERROR: {
228 if ( !input || input_size != sizeof( uint32_t ) ||
229 !output || output_size != sizeof( uint32_t ) ) {
230 LOG( LOG_ERR, "Invalid param, param_id: %d.", param_id );
231 rc = -1;
232 break;
233 }
234
235 monitor_get_error_report( p_fsm, *(uint32_t *)input, (uint32_t *)output );
236 break;
237 }
238
239 case FSM_PARAM_GET_MON_STATUS_AE: {
240 if ( !input || input_size != sizeof( uint32_t ) ||
241 !output || output_size != sizeof( uint32_t ) ) {
242 LOG( LOG_ERR, "Invalid param, param_id: %d.", param_id );
243 rc = -1;
244 break;
245 }
246
247 monitor_get_alg_status( p_fsm, &p_fsm->mon_alg_arr[MON_ALG_AE_INDEX], *(uint32_t *)input, (uint32_t *)output );
248 break;
249 }
250
251 case FSM_PARAM_GET_MON_STATUS_AWB: {
252 if ( !input || input_size != sizeof( uint32_t ) ||
253 !output || output_size != sizeof( uint32_t ) ) {
254 LOG( LOG_ERR, "Invalid param, param_id: %d.", param_id );
255 rc = -1;
256 break;
257 }
258
259 monitor_get_alg_status( p_fsm, &p_fsm->mon_alg_arr[MON_ALG_AWB_INDEX], *(uint32_t *)input, (uint32_t *)output );
260 break;
261 }
262
263 case FSM_PARAM_GET_MON_STATUS_GAMMA: {
264 if ( !input || input_size != sizeof( uint32_t ) ||
265 !output || output_size != sizeof( uint32_t ) ) {
266 LOG( LOG_ERR, "Invalid param, param_id: %d.", param_id );
267 rc = -1;
268 break;
269 }
270
271 monitor_get_alg_status( p_fsm, &p_fsm->mon_alg_arr[MON_ALG_GAMMA_INDEX], *(uint32_t *)input, (uint32_t *)output );
272 break;
273 }
274
275 case FSM_PARAM_GET_MON_STATUS_IRIDIX: {
276 if ( !input || input_size != sizeof( uint32_t ) ||
277 !output || output_size != sizeof( uint32_t ) ) {
278 LOG( LOG_ERR, "Invalid param, param_id: %d.", param_id );
279 rc = -1;
280 break;
281 }
282
283 monitor_get_alg_status( p_fsm, &p_fsm->mon_alg_arr[MON_ALG_IRIDIX_INDEX], *(uint32_t *)input, (uint32_t *)output );
284 break;
285 }
286
287 default:
288 LOG( LOG_ERR, "Invalid param, param_id: %d.", param_id );
289 rc = -1;
290 break;
291 }
292
293 return rc;
294 }
295
monitor_fsm_process_interrupt(monitor_fsm_const_ptr_t p_fsm,uint8_t irq_event)296 void monitor_fsm_process_interrupt( monitor_fsm_const_ptr_t p_fsm, uint8_t irq_event )
297 {
298 if ( acamera_fsm_util_is_irq_event_ignored( (fsm_irq_mask_t *)( &p_fsm->mask ), irq_event ) )
299 return;
300
301 switch ( irq_event ) {
302 case ACAMERA_IRQ_FRAME_END:
303 fsm_raise_event( p_fsm, event_id_monitor_frame_end );
304 break;
305 }
306 }