1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Support for Intel Camera Imaging ISP subsystem. 4 * Copyright (c) 2010-2015, Intel Corporation. 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms and conditions of the GNU General Public License, 8 * version 2, as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 13 * more details. 14 */ 15 16 #include "system_global.h" 17 18 #ifndef ISP2401 19 20 #include "input_formatter.h" 21 #include <type_support.h> 22 #include "gp_device.h" 23 24 #include "assert_support.h" 25 26 #ifndef __INLINE_INPUT_FORMATTER__ 27 #include "input_formatter_private.h" 28 #endif /* __INLINE_INPUT_FORMATTER__ */ 29 30 static const unsigned int input_formatter_alignment[N_INPUT_FORMATTER_ID] = { 31 ISP_VEC_ALIGN, ISP_VEC_ALIGN, HIVE_ISP_CTRL_DATA_BYTES 32 }; 33 34 const hrt_address HIVE_IF_SRST_ADDRESS[N_INPUT_FORMATTER_ID] = { 35 INPUT_FORMATTER0_SRST_OFFSET, 36 INPUT_FORMATTER1_SRST_OFFSET, 37 INPUT_FORMATTER2_SRST_OFFSET, 38 INPUT_FORMATTER3_SRST_OFFSET 39 }; 40 41 const hrt_data HIVE_IF_SRST_MASK[N_INPUT_FORMATTER_ID] = { 42 INPUT_FORMATTER0_SRST_MASK, 43 INPUT_FORMATTER1_SRST_MASK, 44 INPUT_FORMATTER2_SRST_MASK, 45 INPUT_FORMATTER3_SRST_MASK 46 }; 47 48 const u8 HIVE_IF_SWITCH_CODE[N_INPUT_FORMATTER_ID] = { 49 HIVE_INPUT_SWITCH_SELECT_IF_PRIM, 50 HIVE_INPUT_SWITCH_SELECT_IF_PRIM, 51 HIVE_INPUT_SWITCH_SELECT_IF_SEC, 52 HIVE_INPUT_SWITCH_SELECT_STR_TO_MEM 53 }; 54 55 /* MW Should be part of system_global.h, where we have the main enumeration */ 56 static const bool HIVE_IF_BIN_COPY[N_INPUT_FORMATTER_ID] = { 57 false, false, false, true 58 }; 59 60 void input_formatter_rst( 61 const input_formatter_ID_t ID) 62 { 63 hrt_address addr; 64 hrt_data rst; 65 66 assert(ID < N_INPUT_FORMATTER_ID); 67 68 addr = HIVE_IF_SRST_ADDRESS[ID]; 69 rst = HIVE_IF_SRST_MASK[ID]; 70 71 /* TEMPORARY HACK: THIS RESET BREAKS THE METADATA FEATURE 72 * WICH USES THE STREAM2MEMRY BLOCK. 73 * MUST BE FIXED PROPERLY 74 */ 75 if (!HIVE_IF_BIN_COPY[ID]) { 76 input_formatter_reg_store(ID, addr, rst); 77 } 78 79 return; 80 } 81 82 unsigned int input_formatter_get_alignment( 83 const input_formatter_ID_t ID) 84 { 85 assert(ID < N_INPUT_FORMATTER_ID); 86 87 return input_formatter_alignment[ID]; 88 } 89 90 void input_formatter_set_fifo_blocking_mode( 91 const input_formatter_ID_t ID, 92 const bool enable) 93 { 94 assert(ID < N_INPUT_FORMATTER_ID); 95 96 /* cnd_input_formatter_reg_store() */ 97 if (!HIVE_IF_BIN_COPY[ID]) { 98 input_formatter_reg_store(ID, 99 HIVE_IF_BLOCK_FIFO_NO_REQ_ADDRESS, enable); 100 } 101 return; 102 } 103 104 void input_formatter_get_switch_state( 105 const input_formatter_ID_t ID, 106 input_formatter_switch_state_t *state) 107 { 108 assert(ID < N_INPUT_FORMATTER_ID); 109 assert(state); 110 111 /* We'll change this into an intelligent function to get switch info per IF */ 112 (void)ID; 113 114 state->if_input_switch_lut_reg[0] = gp_device_reg_load(GP_DEVICE0_ID, 115 _REG_GP_IFMT_input_switch_lut_reg0); 116 state->if_input_switch_lut_reg[1] = gp_device_reg_load(GP_DEVICE0_ID, 117 _REG_GP_IFMT_input_switch_lut_reg1); 118 state->if_input_switch_lut_reg[2] = gp_device_reg_load(GP_DEVICE0_ID, 119 _REG_GP_IFMT_input_switch_lut_reg2); 120 state->if_input_switch_lut_reg[3] = gp_device_reg_load(GP_DEVICE0_ID, 121 _REG_GP_IFMT_input_switch_lut_reg3); 122 state->if_input_switch_lut_reg[4] = gp_device_reg_load(GP_DEVICE0_ID, 123 _REG_GP_IFMT_input_switch_lut_reg4); 124 state->if_input_switch_lut_reg[5] = gp_device_reg_load(GP_DEVICE0_ID, 125 _REG_GP_IFMT_input_switch_lut_reg5); 126 state->if_input_switch_lut_reg[6] = gp_device_reg_load(GP_DEVICE0_ID, 127 _REG_GP_IFMT_input_switch_lut_reg6); 128 state->if_input_switch_lut_reg[7] = gp_device_reg_load(GP_DEVICE0_ID, 129 _REG_GP_IFMT_input_switch_lut_reg7); 130 state->if_input_switch_fsync_lut = gp_device_reg_load(GP_DEVICE0_ID, 131 _REG_GP_IFMT_input_switch_fsync_lut); 132 state->if_input_switch_ch_id_fmt_type = gp_device_reg_load(GP_DEVICE0_ID, 133 _REG_GP_IFMT_input_switch_ch_id_fmt_type); 134 135 return; 136 } 137 138 void input_formatter_get_state( 139 const input_formatter_ID_t ID, 140 input_formatter_state_t *state) 141 { 142 assert(ID < N_INPUT_FORMATTER_ID); 143 assert(state); 144 /* 145 state->reset = input_formatter_reg_load(ID, 146 HIVE_IF_RESET_ADDRESS); 147 */ 148 state->start_line = input_formatter_reg_load(ID, 149 HIVE_IF_START_LINE_ADDRESS); 150 state->start_column = input_formatter_reg_load(ID, 151 HIVE_IF_START_COLUMN_ADDRESS); 152 state->cropped_height = input_formatter_reg_load(ID, 153 HIVE_IF_CROPPED_HEIGHT_ADDRESS); 154 state->cropped_width = input_formatter_reg_load(ID, 155 HIVE_IF_CROPPED_WIDTH_ADDRESS); 156 state->ver_decimation = input_formatter_reg_load(ID, 157 HIVE_IF_VERTICAL_DECIMATION_ADDRESS); 158 state->hor_decimation = input_formatter_reg_load(ID, 159 HIVE_IF_HORIZONTAL_DECIMATION_ADDRESS); 160 state->hor_deinterleaving = input_formatter_reg_load(ID, 161 HIVE_IF_H_DEINTERLEAVING_ADDRESS); 162 state->left_padding = input_formatter_reg_load(ID, 163 HIVE_IF_LEFTPADDING_WIDTH_ADDRESS); 164 state->eol_offset = input_formatter_reg_load(ID, 165 HIVE_IF_END_OF_LINE_OFFSET_ADDRESS); 166 state->vmem_start_address = input_formatter_reg_load(ID, 167 HIVE_IF_VMEM_START_ADDRESS_ADDRESS); 168 state->vmem_end_address = input_formatter_reg_load(ID, 169 HIVE_IF_VMEM_END_ADDRESS_ADDRESS); 170 state->vmem_increment = input_formatter_reg_load(ID, 171 HIVE_IF_VMEM_INCREMENT_ADDRESS); 172 state->is_yuv420 = input_formatter_reg_load(ID, 173 HIVE_IF_YUV_420_FORMAT_ADDRESS); 174 state->vsync_active_low = input_formatter_reg_load(ID, 175 HIVE_IF_VSYNCK_ACTIVE_LOW_ADDRESS); 176 state->hsync_active_low = input_formatter_reg_load(ID, 177 HIVE_IF_HSYNCK_ACTIVE_LOW_ADDRESS); 178 state->allow_fifo_overflow = input_formatter_reg_load(ID, 179 HIVE_IF_ALLOW_FIFO_OVERFLOW_ADDRESS); 180 state->block_fifo_when_no_req = input_formatter_reg_load(ID, 181 HIVE_IF_BLOCK_FIFO_NO_REQ_ADDRESS); 182 state->ver_deinterleaving = input_formatter_reg_load(ID, 183 HIVE_IF_V_DEINTERLEAVING_ADDRESS); 184 /* FSM */ 185 state->fsm_sync_status = input_formatter_reg_load(ID, 186 HIVE_IF_FSM_SYNC_STATUS); 187 state->fsm_sync_counter = input_formatter_reg_load(ID, 188 HIVE_IF_FSM_SYNC_COUNTER); 189 state->fsm_crop_status = input_formatter_reg_load(ID, 190 HIVE_IF_FSM_CROP_STATUS); 191 state->fsm_crop_line_counter = input_formatter_reg_load(ID, 192 HIVE_IF_FSM_CROP_LINE_COUNTER); 193 state->fsm_crop_pixel_counter = input_formatter_reg_load(ID, 194 HIVE_IF_FSM_CROP_PIXEL_COUNTER); 195 state->fsm_deinterleaving_index = input_formatter_reg_load(ID, 196 HIVE_IF_FSM_DEINTERLEAVING_IDX); 197 state->fsm_dec_h_counter = input_formatter_reg_load(ID, 198 HIVE_IF_FSM_DECIMATION_H_COUNTER); 199 state->fsm_dec_v_counter = input_formatter_reg_load(ID, 200 HIVE_IF_FSM_DECIMATION_V_COUNTER); 201 state->fsm_dec_block_v_counter = input_formatter_reg_load(ID, 202 HIVE_IF_FSM_DECIMATION_BLOCK_V_COUNTER); 203 state->fsm_padding_status = input_formatter_reg_load(ID, 204 HIVE_IF_FSM_PADDING_STATUS); 205 state->fsm_padding_elem_counter = input_formatter_reg_load(ID, 206 HIVE_IF_FSM_PADDING_ELEMENT_COUNTER); 207 state->fsm_vector_support_error = input_formatter_reg_load(ID, 208 HIVE_IF_FSM_VECTOR_SUPPORT_ERROR); 209 state->fsm_vector_buffer_full = input_formatter_reg_load(ID, 210 HIVE_IF_FSM_VECTOR_SUPPORT_BUFF_FULL); 211 state->vector_support = input_formatter_reg_load(ID, 212 HIVE_IF_FSM_VECTOR_SUPPORT); 213 state->sensor_data_lost = input_formatter_reg_load(ID, 214 HIVE_IF_FIFO_SENSOR_STATUS); 215 216 return; 217 } 218 219 void input_formatter_bin_get_state( 220 const input_formatter_ID_t ID, 221 input_formatter_bin_state_t *state) 222 { 223 assert(ID < N_INPUT_FORMATTER_ID); 224 assert(state); 225 226 state->reset = input_formatter_reg_load(ID, 227 HIVE_STR2MEM_SOFT_RESET_REG_ADDRESS); 228 state->input_endianness = input_formatter_reg_load(ID, 229 HIVE_STR2MEM_INPUT_ENDIANNESS_REG_ADDRESS); 230 state->output_endianness = input_formatter_reg_load(ID, 231 HIVE_STR2MEM_OUTPUT_ENDIANNESS_REG_ADDRESS); 232 state->bitswap = input_formatter_reg_load(ID, 233 HIVE_STR2MEM_BIT_SWAPPING_REG_ADDRESS); 234 state->block_synch = input_formatter_reg_load(ID, 235 HIVE_STR2MEM_BLOCK_SYNC_LEVEL_REG_ADDRESS); 236 state->packet_synch = input_formatter_reg_load(ID, 237 HIVE_STR2MEM_PACKET_SYNC_LEVEL_REG_ADDRESS); 238 state->readpostwrite_synch = input_formatter_reg_load(ID, 239 HIVE_STR2MEM_READ_POST_WRITE_SYNC_ENABLE_REG_ADDRESS); 240 state->is_2ppc = input_formatter_reg_load(ID, 241 HIVE_STR2MEM_DUAL_BYTE_INPUTS_ENABLED_REG_ADDRESS); 242 state->en_status_update = input_formatter_reg_load(ID, 243 HIVE_STR2MEM_EN_STAT_UPDATE_ADDRESS); 244 return; 245 } 246 #endif 247