1 2 /* 3 * Copyright (c) 2019 Rockchip Corporation 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 */ 18 19 #ifndef _CAM_HW_ISP20_H_ 20 #define _CAM_HW_ISP20_H_ 21 22 #include <linux/rk-video-format.h> 23 #include "CamHwBase.h" 24 #include "Isp20Params.h" 25 #include "SensorHw.h" 26 #include "LensHw.h" 27 #include "Isp20StatsBuffer.h" 28 #include "Stream.h" 29 #include "RawStreamCapUnit.h" 30 #include "RawStreamProcUnit.h" 31 #include "SPStreamProcUnit.h" 32 #include "PdafStreamProcUnit.h" 33 #ifdef ISP_HW_V20 34 #include "TnrStreamProcUnit.h" 35 #include "NrStreamProcUnit.h" 36 #include "FecParamStream.h" 37 #endif 38 #include "thumbnails.h" 39 #include "CifScaleStream.h" 40 41 #include <unordered_map> 42 43 struct media_device; 44 45 /* 46 * [sub modules]: use bits 4-11 to define the sub modules of each module, the 47 * specific meaning of each bit is decided by the module itself. These bits 48 * is designed to implement the sub module's log switch. 49 50 * ---------------------------- 51 * | sub modules | bits | 52 * ---------------------------- 53 * | ISP20HW_SUBM | 0x01 | 54 * ---------------------------- 55 * | ISP20PARAM_SUBM | 0x02 | 56 * ---------------------------- 57 * | SENSOR_SUBM | 0x04 | 58 * ---------------------------- 59 * | FL_SUBM | 0x08 | 60 * ---------------------------- 61 * | LENS_SUBM | 0x10 | 62 * ---------------------------- 63 * | CAPTURERAW_SUBM | 0x80 | 64 * ---------------------------- 65 */ 66 67 namespace RkCam { 68 69 class IspParamsSplitter; 70 71 #define ISP20HW_SUBM (0x1) 72 73 #define MAX_PARAMS_QUEUE_SIZE 5 74 #define ISP_PARAMS_EFFECT_DELAY_CNT 2 75 #define CAM_INDEX_FOR_1608 8 76 77 #define DISABLE_PARAMS_POLL_THREAD 78 // FIXME: share 1608 data ptr(aiq/rawdata) 79 typedef struct sensor_info_share_s { 80 RawStreamProcUnit* raw_proc_unit[CAM_INDEX_FOR_1608]; // bind rx by camId 81 SmartPtr<RawStreamCapUnit> raw_cap_unit; // save 1st tx obj addr 82 char reference_name[64]; // save vicap name(for 1608) 83 rk_aiq_cif_info_t* reference_mipi_cif; // vicap inf (for 1608) 84 // us: union_stream 85 int us_open_cnt; // for hwi open(1608) 86 int us_prepare_cnt; // for rawCap buffer manage(1608). 87 int us_stream_cnt; // mark cnt. on: ++, off: -- 88 int us_stop_cnt; // last sensor stop 89 // tracking opened sensor num 90 int en_sns_num; // Record the number of open sensors 91 int first_en[CAM_INDEX_FOR_1608]; // set/get fmt for 1608 sensor 92 } sensor_info_share_t; 93 94 class CamHwIsp20 95 : public CamHwBase, virtual public Isp20Params, public V4l2Device 96 , public isp_drv_share_mem_ops_t { 97 public: 98 friend class RawStreamProcUnit; 99 explicit CamHwIsp20(); 100 virtual ~CamHwIsp20(); 101 102 // from ICamHw 103 virtual XCamReturn init(const char* sns_ent_name) override; 104 virtual XCamReturn deInit() override; 105 virtual XCamReturn prepare(uint32_t width, uint32_t height, int mode, int t_delay, int g_delay) override; 106 virtual XCamReturn start() override; 107 virtual XCamReturn stop() override; 108 virtual XCamReturn pause() override; 109 virtual XCamReturn resume() override; 110 virtual XCamReturn swWorkingModeDyn(int mode) override; 111 virtual XCamReturn getSensorModeData(const char* sns_ent_name, 112 rk_aiq_exposure_sensor_descriptor& sns_des) override; 113 virtual void setCalib(const CamCalibDbV2Context_t* calibv2) override; 114 virtual XCamReturn applyAnalyzerResult(SmartPtr<SharedItemBase> base, bool sync) override; 115 virtual XCamReturn applyAnalyzerResult(cam3aResultList& list) override; 116 XCamReturn setModuleCtl(rk_aiq_module_id_t moduleId, bool en) override; 117 XCamReturn getModuleCtl(rk_aiq_module_id_t moduleId, bool& en) override; 118 XCamReturn notify_capture_raw() override; 119 XCamReturn capture_raw_ctl(capture_raw_t type, int count = 0, const char* capture_dir = nullptr, char* output_dir = nullptr) override; 120 XCamReturn getSensorCrop(rk_aiq_rect_t& rect) override; 121 XCamReturn setSensorCrop(rk_aiq_rect_t& rect) override; 122 XCamReturn setSensorFlip(bool mirror, bool flip, int skip_frm_cnt) override; 123 XCamReturn getSensorFlip(bool& mirror, bool& flip) override; 124 void setMulCamConc(bool cc); 125 XCamReturn getZoomPosition(int& position) override; 126 XCamReturn getIrisParams(SmartPtr<RkAiqIrisParamsProxy>& irisPar, CalibDb_IrisTypeV2_t irisType); 127 XCamReturn getLensVcmCfg(rk_aiq_lens_vcmcfg& lens_cfg) override; 128 XCamReturn setLensVcmCfg(rk_aiq_lens_vcmcfg& lens_cfg) override; 129 XCamReturn setLensVcmCfg(struct rkmodule_inf& mod_info); 130 XCamReturn FocusCorrection() override; 131 XCamReturn ZoomCorrection() override; 132 XCamReturn setAngleZ(float angleZ) override; 133 virtual void getShareMemOps(isp_drv_share_mem_ops_t** mem_ops) override; 134 uint64_t getIspModuleEnState() override; 135 136 static rk_aiq_static_info_t* getStaticCamHwInfo(const char* sns_ent_name, uint16_t index = 0); 137 static rk_aiq_static_info_t* getStaticCamHwInfoByPhyId(const char* sns_ent_name, uint16_t index = 0); 138 static XCamReturn clearStaticCamHwInfo(); 139 static XCamReturn initCamHwInfos(); 140 static XCamReturn selectIqFile(const char* sns_ent_name, char* iqfile_name); 141 static const char* getBindedSnsEntNmByVd(const char* vd); 142 143 // from PollCallback 144 virtual XCamReturn poll_event_ready (uint32_t sequence, int type) override; 145 virtual XCamReturn poll_event_failed (int64_t timestamp, const char *msg) override; 146 XCamReturn rawReproc_genIspParams (uint32_t sequence, rk_aiq_frame_info_t *offline_finfo, int mode) override; 147 XCamReturn rawReProc_prepare (uint32_t sequence, rk_aiq_frame_info_t *offline_finfo) override; 148 //fake sensor 149 static const char* rawReproc_preInit(const char* isp_driver, const char* offline_sns_ent_name); 150 XCamReturn rawReproc_deInit (const char* fakeSensor); 151 152 XCamReturn getEffectiveIspParams(rkisp_effect_params_v20& ispParams, uint32_t frame_id) override; 153 void setHdrGlobalTmoMode(uint32_t frame_id, bool mode); setSharpFbcRotation(rk_aiq_rotation_t rot)154 XCamReturn setSharpFbcRotation(rk_aiq_rotation_t rot) { 155 _sharp_fbc_rotation = rot; 156 return XCAM_RETURN_NO_ERROR; 157 } 158 XCamReturn notify_sof(SmartPtr<VideoBuffer>& buf); 159 SmartPtr<ispHwEvt_t> make_ispHwEvt (uint32_t sequence, int type, int64_t timestamp); get_workingg_mode()160 int get_workingg_mode() { 161 return _hdr_mode; 162 } 163 //should be called after prepare 164 XCamReturn get_stream_format(rkaiq_stream_type_t type, struct v4l2_format &format); 165 XCamReturn get_sp_resolution(int &width, int &height, int &aligned_w, int &aligned_h) override; 166 XCamReturn showOtpPdafData(struct rkmodule_pdaf_inf *otp_pdaf); 167 XCamReturn showOtpAfData(struct rkmodule_af_inf *otp_af); 168 #if RKAIQ_HAVE_PDAF 169 bool get_pdaf_support() override; 170 #endif setIspStreamMode(rk_isp_stream_mode_t mode)171 virtual XCamReturn setIspStreamMode(rk_isp_stream_mode_t mode) override { 172 if (mode == RK_ISP_STREAM_MODE_ONLNIE) { 173 mNoReadBack = true; 174 } else if (mode == RK_ISP_STREAM_MODE_OFFLNIE) { 175 mNoReadBack = false; 176 } else { 177 return XCAM_RETURN_ERROR_FAILED; 178 } 179 return XCAM_RETURN_NO_ERROR; 180 } getIspStreamMode()181 virtual rk_isp_stream_mode_t getIspStreamMode() override { 182 if (true == mNoReadBack) 183 return RK_ISP_STREAM_MODE_ONLNIE; 184 else 185 return RK_ISP_STREAM_MODE_OFFLNIE; 186 } 187 void notify_isp_stream_status(bool on); 188 bool getParamsForEffMap(uint32_t frameId); 189 XCamReturn reset_hardware() override; 190 191 // FIXME: Set struct to static. 192 static sensor_info_share_t rk1608_share_inf; 193 setUserSensorFormat(uint16_t width,uint16_t height,uint16_t code)194 virtual void setUserSensorFormat(uint16_t width, uint16_t height, uint16_t code) override { 195 userSensorWidth = width; 196 userSensorHeight = height; 197 userSensorFmtCode = code; 198 } 199 200 // cif scale flag 201 XCamReturn setCifSclStartFlag(int ratio, bool mode); 202 203 private: 204 using V4l2Device::start; 205 206 #if defined(ISP_HW_V20) 207 XCamReturn handlePpReslut(SmartPtr<cam3aResult> &result); 208 XCamReturn setPpConfig(SmartPtr<cam3aResult> &result); 209 #endif 210 XCamReturn setExposureParams(SmartPtr<RkAiqExpParamsProxy>& expPar); 211 XCamReturn setIrisParams(SmartPtr<RkAiqIrisParamsProxy>& irisPar, CalibDb_IrisTypeV2_t irisType); 212 XCamReturn setHdrProcessCount(rk_aiq_luma_params_t luma_params) override; 213 XCamReturn setFocusParams(SmartPtr<RkAiqFocusParamsProxy>& focus_params); 214 XCamReturn setCpslParams(SmartPtr<RkAiqCpslParamsProxy>& cpsl_params); 215 XCamReturn setupHdrLink(int mode, int isp_index, bool enable); 216 static void findAttachedSubdevs(struct media_device *device, uint32_t count, rk_sensor_full_info_t *s_info); 217 XCamReturn setExpDelayInfo(int mode); 218 void analyzePpInitEns(SmartPtr<cam3aResult> &result); 219 XCamReturn get_sensor_pdafinfo(rk_sensor_full_info_t *sensor_info, rk_sensor_pdaf_info_t *pdaf_info); 220 protected: 221 XCAM_DEAD_COPY(CamHwIsp20); 222 virtual XCamReturn setIspConfig(cam3aResultList* result_list = NULL); 223 virtual void updateEffParams(void* params, void* ori_params = NULL) { return; } processTb(void * params)224 virtual bool processTb(void* params) { return false; } 225 virtual XCamReturn poll_buffer_ready (SmartPtr<VideoBuffer> &buf) override; 226 enum cam_hw_state_e { 227 CAM_HW_STATE_INVALID, 228 CAM_HW_STATE_INITED, 229 CAM_HW_STATE_PREPARED, 230 CAM_HW_STATE_STARTED, 231 CAM_HW_STATE_PAUSED, 232 CAM_HW_STATE_STOPPED, 233 }; 234 enum ircut_state_e { 235 IRCUT_STATE_CLOSED, /* close ir-cut,meaning that infrared ray can be received */ 236 IRCUT_STATE_CLOSING, 237 IRCUT_STATE_OPENING, 238 IRCUT_STATE_OPENED, /* open ir-cut,meaning that only visible light can be received */ 239 }; 240 241 typedef struct calib_infos_s { 242 struct { 243 bool enable; 244 bool motion_detect_en; 245 } mfnr; 246 247 struct { 248 CalibDb_IrisTypeV2_t IrisType; 249 } aec; 250 251 struct { 252 CalibDbV2_Af_VcmCfg_t vcmcfg; 253 CalibDbV2_Af_LdgParam_t ldg_param; 254 CalibDbV2_Af_HighLightParam_t highlight; 255 } af; 256 257 struct { 258 CalibDb_DcgSetV2_t CISDcgSet; 259 CalibDb_ExpUpdate_CombV2_t CISExpUpdate; 260 } sensor; 261 } calib_infos_t; 262 calib_infos_t _cur_calib_infos; 263 int _hdr_mode; 264 Mutex _isp_params_cfg_mutex; 265 int _state; 266 volatile bool _is_exit; 267 bool _linked_to_isp; 268 bool _linked_to_1608; 269 #if defined(ISP_HW_V20) 270 struct rkispp_params_cfg _full_active_ispp_params; 271 uint32_t _ispp_module_init_ens; 272 SmartPtr<V4l2SubDevice> _ispp_sd; 273 #endif 274 SmartPtr<V4l2SubDevice> _cif_csi2_sd; 275 char sns_name[32]; 276 public: 277 static std::unordered_map<std::string, SmartPtr<rk_aiq_static_info_t>> mCamHwInfos; 278 static rk_aiq_isp_hw_info_t mIspHwInfos; 279 static rk_aiq_cif_hw_info_t mCifHwInfos; 280 static std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t>> mSensorHwInfos; 281 static std::unordered_map<std::string, std::string> mFakeCameraName; 282 protected: 283 static bool mIsMultiIspMode; 284 static uint16_t mMultiIspExtendedPixel; 285 // TODO: Sync 1608 sensor start streaming 286 static XCam::Mutex _sync_1608_mutex; 287 static bool _sync_1608_done; 288 #if defined(ISP_HW_V20) 289 void gen_full_ispp_params(const struct rkispp_params_cfg* update_params, 290 struct rkispp_params_cfg* full_params); 291 #endif 292 #if 0 293 void dump_isp_config(struct isp2x_isp_params_cfg* isp_params, 294 SmartPtr<RkAiqIspParamsProxy> aiq_results, 295 SmartPtr<RkAiqIspParamsProxy> aiq_other_results); 296 void dumpRawnrFixValue(struct isp2x_rawnr_cfg * pRawnrCfg ); 297 void dumpTnrFixValue(struct rkispp_tnr_config * pTnrCfg); 298 void dumpUvnrFixValue(struct rkispp_nr_config * pNrCfg); 299 void dumpYnrFixValue(struct rkispp_nr_config * pNrCfg); 300 void dumpSharpFixValue(struct rkispp_sharp_config * pSharpCfg); 301 #endif 302 XCamReturn setIrcutParams(bool on); 303 XCamReturn setIsppSharpFbcRot(struct rkispp_sharp_config* shp_cfg); 304 XCamReturn setupPipelineFmt(); 305 XCamReturn setupPipelineFmtIsp(struct v4l2_subdev_selection& sns_sd_sel, 306 struct v4l2_subdev_format& sns_sd_fmt, 307 __u32 sns_v4l_pix_fmt); 308 XCamReturn setupPipelineFmtCif(struct v4l2_subdev_selection& sns_sd_sel, 309 struct v4l2_subdev_format& sns_sd_fmt, 310 __u32 sns_v4l_pix_fmt); 311 XCamReturn setupHdrLink_vidcap(int hdr_mode, int cif_index, bool enable); 312 #if defined(ISP_HW_V20) 313 XCamReturn init_pp(rk_sensor_full_info_t *s_info); 314 #endif 315 virtual bool isOnlineByWorkingMode(); 316 enum mipi_stream_idx { 317 MIPI_STREAM_IDX_0 = 1, 318 MIPI_STREAM_IDX_1 = 2, 319 MIPI_STREAM_IDX_2 = 4, 320 MIPI_STREAM_IDX_ALL = 7, 321 }; 322 XCamReturn hdr_mipi_start_mode(int mode); 323 XCamReturn hdr_mipi_stop(); 324 XCamReturn hdr_mipi_prepare_mode(int mode); 325 static void allocMemResource(uint8_t id, void *ops_ctx, void *config, void **mem_ctx); 326 static void releaseMemResource(uint8_t id, void *mem_ctx); 327 static void* getFreeItem(uint8_t id, void *mem_ctx); 328 uint64_t _isp_module_ens{0}; 329 bool mNoReadBack; 330 rk_aiq_rotation_t _sharp_fbc_rotation; 331 332 rk_aiq_ldch_share_mem_info_t ldch_mem_info_array[2 * ISP2X_MESH_BUF_NUM]; 333 rk_aiq_fec_share_mem_info_t fec_mem_info_array[FEC_MESH_BUF_NUM]; 334 rk_aiq_cac_share_mem_info_t cac_mem_info_array[2 * ISP3X_MESH_BUF_NUM]; 335 rk_aiq_dbg_share_mem_info_t dbg_mem_info_array[2 * RKISP_INFO2DDR_BUF_MAX]; 336 typedef struct drv_share_mem_ctx_s { 337 void* ops_ctx; 338 void* mem_info; 339 rk_aiq_drv_share_mem_type_t type; 340 } drv_share_mem_ctx_t; 341 drv_share_mem_ctx_t _ldch_drv_mem_ctx; 342 drv_share_mem_ctx_t _fec_drv_mem_ctx; 343 drv_share_mem_ctx_t _cac_drv_mem_ctx; 344 drv_share_mem_ctx_t _dbg_drv_mem_ctx; 345 Mutex _mem_mutex; 346 rk_aiq_rect_t _crop_rect; 347 uint32_t _ds_width; 348 uint32_t _ds_heigth; 349 uint32_t _ds_width_align; 350 uint32_t _ds_heigth_align; 351 uint32_t _exp_delay; 352 rk_aiq_lens_descriptor _lens_des; 353 //ispp 354 #if defined(ISP_HW_V20) 355 SmartPtr<FecParamStream> mFecParamStream; 356 SmartPtr<NrStreamProcUnit> mNrStreamProcUnit; 357 SmartPtr<TnrStreamProcUnit> mTnrStreamProcUnit; 358 #endif 359 //isp 360 SmartPtr<RKStream> mLumaStream; 361 SmartPtr<RKStatsStream> mIspStatsStream; 362 SmartPtr<RKStream> mIspParamStream; 363 SmartPtr<RKSofEventStream> mIspSofStream; 364 #if defined(RKAIQ_ENABLE_SPSTREAM) 365 SmartPtr<SPStreamProcUnit> mSpStreamUnit; 366 #endif 367 SmartPtr<RkStreamEventPollThread> mIspStremEvtTh; 368 369 SmartPtr<RawStreamCapUnit> mRawCapUnit; 370 SmartPtr<RawStreamProcUnit> mRawProcUnit; 371 372 SmartPtr<CifSclStream> mCifScaleStream; 373 374 SmartPtr<PdafStreamProcUnit> mPdafStreamUnit; 375 376 SmartPtr<cam3aResult> get_3a_module_result (cam3aResultList &results, int32_t type); 377 XCamReturn handleIsp3aReslut(SmartPtr<cam3aResult> &result); 378 XCamReturn handleIsp3aReslut(cam3aResultList& list); 379 virtual XCamReturn dispatchResult(SmartPtr<cam3aResult> cam3a_result); 380 virtual XCamReturn dispatchResult(cam3aResultList& list); 381 382 std::map<int, cam3aResultList> _camIsp3aResult; 383 384 std::map<uint32_t, SmartPtr<RkAiqIspEffParamsProxy>> _effecting_ispparam_map; 385 SmartPtr<RkAiqIspEffParamsPool> mEffectIspParamsPool; 386 #ifndef DISABLE_PARAMS_ASSEMBLER 387 SmartPtr<IspParamsAssembler> mParamsAssembler; 388 #endif 389 uint32_t mPpModuleInitEns; 390 bool mVicapIspPhyLinkSupported; // if phsical link between vicap and isp, only isp3x support now 391 SmartPtr<IspParamsSplitter> mParamsSplitter; 392 enum ISP_STREAM_STATUS_E { 393 ISP_STREAM_STATUS_INVALID, 394 ISP_STREAM_STATUS_STREAM_ON, 395 ISP_STREAM_STATUS_STREAM_OFF, 396 }; 397 int _isp_stream_status; 398 399 rk_sensor_pdaf_info_t mPdafInfo; 400 401 Mutex _stop_cond_mutex; 402 403 // TODO: Sync(1608 sensor) sdk hwEvt cb 404 XCam::Cond _sync_done_cond; 405 XCamReturn waitLastSensorDone(); 406 XCamReturn pixFmt2Bpp(uint32_t pixFmt, int8_t& bpp); 407 uint32_t _curIspParamsSeq; 408 409 uint16_t userSensorWidth; 410 uint16_t userSensorHeight; 411 uint16_t userSensorFmtCode; 412 413 bool _not_skip_first{true}; 414 struct isp32_rawawb_meas_cfg _first_awb_cfg{}; 415 }; 416 417 } 418 #endif 419