1 #include "rk_aiq_comm.h"
2 #include "RawStreamProcUnit.h"
3 #include "CaptureRawData.h"
4 #include "CamHwIsp20.h"
5
6 namespace RkCam {
RawStreamProcUnit()7 RawStreamProcUnit::RawStreamProcUnit ()
8 : _is_multi_cam_conc(false)
9 , _first_trigger(true)
10 , _is_1608_sensor(false)
11 {
12 _raw_proc_thread = new RawProcThread(this);
13 _PollCallback = NULL;
14 mCamPhyId = -1;
15 _rawCap = NULL;
16 }
17
RawStreamProcUnit(const rk_sensor_full_info_t * s_info,bool linked_to_isp,int tx_buf_cnt)18 RawStreamProcUnit::RawStreamProcUnit (const rk_sensor_full_info_t *s_info, bool linked_to_isp, int tx_buf_cnt)
19 : _is_multi_cam_conc(false)
20 , _first_trigger(true)
21 , _is_1608_sensor(false)
22 {
23 _raw_proc_thread = new RawProcThread(this);
24 _PollCallback = NULL;
25 _rawCap = NULL;
26 //short frame
27 if (strlen(s_info->isp_info->rawrd2_s_path)) {
28 _dev[0] = new V4l2Device (s_info->isp_info->rawrd2_s_path);//rkisp_rawrd2_s
29 _dev[0]->open();
30 _dev[0]->set_mem_type(V4L2_MEMORY_DMABUF);
31 }
32 //mid frame
33 if (strlen(s_info->isp_info->rawrd0_m_path)) {
34 _dev[1] = new V4l2Device (s_info->isp_info->rawrd0_m_path);//rkisp_rawrd0_m
35 _dev[1]->open();
36 _dev[1]->set_mem_type(V4L2_MEMORY_DMABUF);
37 }
38 //long frame
39 if (strlen(s_info->isp_info->rawrd1_l_path)) {
40 _dev[2] = new V4l2Device (s_info->isp_info->rawrd1_l_path);//rkisp_rawrd1_l
41 _dev[2]->open();
42 _dev[2]->set_mem_type(V4L2_MEMORY_DMABUF);
43 }
44 int buf_cnt = 0;
45 if (tx_buf_cnt > 0) {
46 buf_cnt = tx_buf_cnt;
47 } else if (linked_to_isp) {
48 buf_cnt = ISP_TX_BUF_NUM;
49 } else if (s_info->linked_to_1608) {
50 buf_cnt = VIPCAP_TX_BUF_NUM_1608;
51 } else {
52 buf_cnt = VIPCAP_TX_BUF_NUM;
53 }
54 for (int i = 0; i < 3; i++) {
55 if (_dev[i].ptr()) {
56 _dev[i]->set_buffer_count(buf_cnt);
57 _dev[i]->set_buf_sync (true);
58 }
59
60 _dev_index[i] = i;
61 _stream[i] = new RKRawStream(_dev[i], i, ISP_POLL_RX);
62 _stream[i]->setPollCallback(this);
63 }
64 }
65
~RawStreamProcUnit()66 RawStreamProcUnit::~RawStreamProcUnit ()
67 {
68 }
69
start(int mode)70 XCamReturn RawStreamProcUnit::start(int mode)
71 {
72 _rawCap = new CaptureRawData(mCamPhyId);
73 for (int i = 0; i < _mipi_dev_max; i++) {
74 _stream[i]->setCamPhyId(mCamPhyId);
75 _stream[i]->start();
76 }
77 _msg_queue.clear();
78
79 // TODO: [baron] for rk1608, vi will capture data before start
80 _buf_mutex.lock();
81 for (int i = 0; i < _mipi_dev_max; i++) {
82 buf_list[i].clear ();
83 cache_list[i].clear ();
84 }
85 _isp_hdr_fid2ready_map.clear();
86 _buf_mutex.unlock();
87
88 _raw_proc_thread->set_policy(SCHED_RR);
89 _raw_proc_thread->set_priority(20);
90 _raw_proc_thread->start();
91 return XCAM_RETURN_NO_ERROR;
92 }
93
stop()94 XCamReturn RawStreamProcUnit::stop ()
95 {
96 _msg_queue.push(0);
97 _raw_proc_thread->stop();
98 _msg_queue.clear();
99
100 for (int i = 0; i < _mipi_dev_max; i++) {
101 _stream[i]->stopThreadOnly();
102 }
103
104 _buf_mutex.lock();
105 for (int i = 0; i < _mipi_dev_max; i++) {
106 buf_list[i].clear ();
107 cache_list[i].clear ();
108 }
109 _isp_hdr_fid2ready_map.clear();
110 _buf_mutex.unlock();
111
112 _mipi_trigger_mutex.lock();
113 _isp_hdr_fid2times_map.clear();
114 _sof_timestamp_map.clear();
115 _mipi_trigger_mutex.unlock();
116
117 if (_rawCap) {
118 delete _rawCap;
119 _rawCap = NULL;
120 }
121
122 for (int i = 0; i < _mipi_dev_max; i++) {
123 _stream[i]->stopDeviceOnly();
124 }
125
126 return XCAM_RETURN_NO_ERROR;
127 }
128
129 XCamReturn
prepare(int idx)130 RawStreamProcUnit::prepare(int idx)
131 {
132 XCamReturn ret = XCAM_RETURN_NO_ERROR;
133 // mipi rx/tx format should match to sensor.
134 for (int i = 0; i < 3; i++) {
135 if (!(idx & (1 << i)))
136 continue;
137
138 ret = _dev[i]->prepare();
139 if (ret < 0)
140 LOGE_CAMHW_SUBM(ISP20HW_SUBM,"mipi tx:%d prepare err: %d\n", ret);
141
142 _stream[i]->set_device_prepared(true);
143 }
144 return ret;
145 }
146
147 void
set_working_mode(int mode)148 RawStreamProcUnit::set_working_mode(int mode)
149 {
150 _working_mode = mode;
151
152 switch (_working_mode) {
153 case RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR:
154 case RK_AIQ_ISP_HDR_MODE_3_LINE_HDR:
155 _mipi_dev_max = 3;
156 break;
157 case RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR:
158 case RK_AIQ_ISP_HDR_MODE_2_LINE_HDR:
159 _mipi_dev_max = 2;
160 break;
161 default:
162 _mipi_dev_max = 1;
163 }
164
165 LOGD_CAMHW_SUBM(ISP20HW_SUBM,"working_mode:0x%x, _mipi_dev_max=%d\n", _working_mode, _mipi_dev_max);
166 }
167
168 void
set_rx_devices(SmartPtr<V4l2Device> mipi_rx_devs[3])169 RawStreamProcUnit::set_rx_devices(SmartPtr<V4l2Device> mipi_rx_devs[3])
170 {
171 for (int i = 0; i < 3; i++) {
172 _dev[i] = mipi_rx_devs[i];
173 _stream[i].release();
174 _stream[i] = new RKRawStream(_dev[i], i, ISP_POLL_RX);
175 _stream[i]->setPollCallback(this);
176 }
177 }
178
179 SmartPtr<V4l2Device>
get_rx_device(int index)180 RawStreamProcUnit::get_rx_device(int index)
181 {
182 if (index > _mipi_dev_max)
183 return nullptr;
184 else
185 return _dev[index];
186 }
187
188 XCamReturn
set_rx_format(const struct v4l2_subdev_format & sns_sd_fmt,uint32_t sns_v4l_pix_fmt)189 RawStreamProcUnit::set_rx_format(const struct v4l2_subdev_format& sns_sd_fmt,
190 uint32_t sns_v4l_pix_fmt)
191 {
192 XCamReturn ret = XCAM_RETURN_NO_ERROR;
193
194 for (int i = 0; i < 3; i++) {
195 if (!_dev[i].ptr()) {
196 ret = XCAM_RETURN_ERROR_PARAM;
197 break;
198 }
199
200 ret = _dev[i]->set_format(sns_sd_fmt.format.width,
201 sns_sd_fmt.format.height,
202 sns_v4l_pix_fmt,
203 V4L2_FIELD_NONE,
204 0);
205 if (ret < 0) {
206 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "device(%s) set format failed", _dev[i]->get_device_name());
207 } else {
208 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "device(%s) set fmt info: fmt 0x%x, %dx%d !",
209 _dev[i]->get_device_name(), sns_v4l_pix_fmt,
210 sns_sd_fmt.format.width, sns_sd_fmt.format.height);
211 }
212 }
213
214 return ret;
215 }
216
217 XCamReturn
set_rx_format(const struct v4l2_subdev_selection & sns_sd_sel,uint32_t sns_v4l_pix_fmt)218 RawStreamProcUnit::set_rx_format(const struct v4l2_subdev_selection& sns_sd_sel,
219 uint32_t sns_v4l_pix_fmt)
220 {
221 XCamReturn ret = XCAM_RETURN_NO_ERROR;
222
223 for (int i = 0; i < 3; i++) {
224 if (!_dev[i].ptr()) {
225 ret = XCAM_RETURN_ERROR_PARAM;
226 break;
227 }
228
229 ret = _dev[i]->set_format(sns_sd_sel.r.width,
230 sns_sd_sel.r.height,
231 sns_v4l_pix_fmt,
232 V4L2_FIELD_NONE,
233 0);
234 if (ret < 0) {
235 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "device(%s) set format failed", _dev[i]->get_device_name());
236 } else {
237 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "device(%s) set rx fmt info: fmt 0x%x, %dx%d !",
238 _dev[i]->get_device_name(), sns_v4l_pix_fmt,
239 sns_sd_sel.r.width, sns_sd_sel.r.height);
240 }
241 }
242
243 return ret;
244 }
245
246 void
set_devices(SmartPtr<V4l2SubDevice> ispdev,CamHwIsp20 * handle)247 RawStreamProcUnit::set_devices(SmartPtr<V4l2SubDevice> ispdev, CamHwIsp20* handle)
248 {
249 _isp_core_dev = ispdev;
250 _camHw = handle;
251 }
252
253 XCamReturn
poll_buffer_ready(SmartPtr<V4l2BufferProxy> & buf,int dev_index)254 RawStreamProcUnit::poll_buffer_ready (SmartPtr<V4l2BufferProxy> &buf, int dev_index)
255 {
256 SmartLock locker (_buf_mutex);
257
258 if (!buf_list[dev_index].is_empty()) {
259 SmartPtr<V4l2BufferProxy> rx_buf = buf_list[dev_index].pop(-1);
260 LOG1_CAMHW_SUBM(ISP20HW_SUBM,"%s dev_index:%d index:%d fd:%d\n",
261 __func__, dev_index, rx_buf->get_v4l2_buf_index(), rx_buf->get_expbuf_fd());
262 }
263 if (_PollCallback)
264 _PollCallback->poll_buffer_ready (buf, dev_index);
265
266 return XCAM_RETURN_NO_ERROR;
267 }
268
269 void
set_hdr_frame_readback_infos(uint32_t frame_id,int times)270 RawStreamProcUnit::set_hdr_frame_readback_infos(uint32_t frame_id, int times)
271 {
272 if (_working_mode == RK_AIQ_WORKING_MODE_NORMAL)
273 return;
274
275 _mipi_trigger_mutex.lock();
276 _isp_hdr_fid2times_map[frame_id] = times;
277 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "rdtimes seq %d \n", frame_id);
278 // trigger_isp_readback();
279 _mipi_trigger_mutex.unlock();
280 }
281
282 void
match_lumadetect_map(uint32_t sequence,sint32_t & additional_times)283 RawStreamProcUnit::match_lumadetect_map(uint32_t sequence, sint32_t &additional_times)
284 {
285 std::map<uint32_t, int>::iterator it_times_del;
286 _mipi_trigger_mutex.lock();
287 for (std::map<uint32_t, int>::iterator iter = _isp_hdr_fid2times_map.begin();
288 iter != _isp_hdr_fid2times_map.end();) {
289 if (iter->first < sequence) {
290 it_times_del = iter++;
291 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "del seq %d", it_times_del->first);
292 iter = _isp_hdr_fid2times_map.erase(it_times_del);
293 } else if (iter->first == sequence) {
294 additional_times = iter->second;
295 it_times_del = iter++;
296 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "del seq %d", it_times_del->first);
297 iter = _isp_hdr_fid2times_map.erase(it_times_del);
298 break;
299 } else {
300 LOGW_CAMHW_SUBM(ISP20HW_SUBM, "%s missing rdtimes for buf_seq %d, min rdtimes_seq %d !",
301 __func__, sequence, iter->first);
302 additional_times = 0;
303 break;
304 }
305 }
306 _mipi_trigger_mutex.unlock();
307 }
308
309 void
match_globaltmostate_map(uint32_t sequence,bool & isHdrGlobalTmo)310 RawStreamProcUnit::match_globaltmostate_map(uint32_t sequence, bool &isHdrGlobalTmo)
311 {
312 std::map<uint32_t, bool>::iterator it_del;
313 _mipi_trigger_mutex.lock();
314 for (std::map<uint32_t, bool>::iterator iter = _hdr_global_tmo_state_map.begin();
315 iter != _hdr_global_tmo_state_map.end();) {
316 if (iter->first < sequence) {
317 it_del = iter++;
318 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "del seq %d", it_del->first);
319 iter = _hdr_global_tmo_state_map.erase(it_del);
320 } else if (iter->first == sequence) {
321 isHdrGlobalTmo = iter->second;
322 it_del = iter++;
323 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "del seq %d", it_del->first);
324 iter = _hdr_global_tmo_state_map.erase(it_del);
325 break;
326 } else {
327 LOGW_CAMHW_SUBM(ISP20HW_SUBM, "%s missing tmo state for buf_seq %d, min rdtimes_seq %d !",
328 __func__, sequence, iter->first);
329 break;
330 }
331 }
332 _mipi_trigger_mutex.unlock();
333 }
334
335 XCamReturn
match_sof_timestamp_map(sint32_t sequence,uint64_t & timestamp)336 RawStreamProcUnit::match_sof_timestamp_map(sint32_t sequence, uint64_t ×tamp)
337 {
338 XCamReturn ret = XCAM_RETURN_NO_ERROR;
339 std::map<int, uint64_t>::iterator it;
340 sint32_t search_id = sequence < 0 ? 0 : sequence;
341
342 it = _sof_timestamp_map.find(search_id);
343 if (it != _sof_timestamp_map.end()) {
344 timestamp = it->second;
345 } else {
346 LOGW_CAMHW_SUBM(ISP20HW_SUBM, "can't find frameid(%d), get sof timestamp failed!\n",
347 sequence);
348 ret = XCAM_RETURN_ERROR_FAILED;
349 }
350
351 return ret;
352 }
353
354 void
set_hdr_global_tmo_mode(uint32_t frame_id,bool mode)355 RawStreamProcUnit::set_hdr_global_tmo_mode(uint32_t frame_id, bool mode)
356 {
357 _mipi_trigger_mutex.lock();
358 _hdr_global_tmo_state_map[frame_id] = mode;
359 _mipi_trigger_mutex.unlock();
360 }
361
362 void
notify_sof(uint64_t time,uint32_t frameid)363 RawStreamProcUnit::notify_sof(uint64_t time, uint32_t frameid)
364 {
365 _mipi_trigger_mutex.lock();
366 while (_sof_timestamp_map.size() > 8) {
367 _sof_timestamp_map.erase(_sof_timestamp_map.begin());
368 }
369 _sof_timestamp_map[frameid] = time;
370 _mipi_trigger_mutex.unlock();
371 }
372
raw_buffer_proc()373 bool RawStreamProcUnit::raw_buffer_proc()
374 {
375 LOGD("%s enter", __FUNCTION__);
376 int ret = true;
377 auto v = _msg_queue.front();
378 if (v)
379 trigger_isp_readback();
380 else
381 ret = false;
382 _msg_queue.pop();
383 LOGD("%s exit", __FUNCTION__);
384 return ret;
385 }
386
387 void
send_sync_buf(SmartPtr<V4l2BufferProxy> & buf_s,SmartPtr<V4l2BufferProxy> & buf_m,SmartPtr<V4l2BufferProxy> & buf_l)388 RawStreamProcUnit::send_sync_buf
389 (
390 SmartPtr<V4l2BufferProxy> &buf_s,
391 SmartPtr<V4l2BufferProxy> &buf_m,
392 SmartPtr<V4l2BufferProxy> &buf_l
393 )
394 {
395 _buf_mutex.lock();
396 for (int i = 0; i < _mipi_dev_max; i++) {
397 if (i == ISP_MIPI_HDR_S)
398 cache_list[ISP_MIPI_HDR_S].push(buf_s);
399 else if (i == ISP_MIPI_HDR_M)
400 cache_list[ISP_MIPI_HDR_M].push(buf_m);
401 else if (i == ISP_MIPI_HDR_L)
402 cache_list[ISP_MIPI_HDR_L].push(buf_l);
403 }
404 _isp_hdr_fid2ready_map[buf_s->get_sequence()] = true;
405 _buf_mutex.unlock();
406 _msg_queue.push(1);
407 }
408
409 void
trigger_isp_readback()410 RawStreamProcUnit::trigger_isp_readback()
411 {
412 std::map<uint32_t, bool>::iterator it_ready;
413 SmartPtr<V4l2Buffer> v4l2buf[3];
414 SmartPtr<V4l2BufferProxy> buf_proxy;
415 uint32_t sequence = -1;
416 sint32_t additional_times = -1;
417 bool isHdrGlobalTmo = false;
418
419 SmartLock locker (_buf_mutex);
420
421 if (_isp_hdr_fid2ready_map.size() == 0) {
422 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "%s buf not ready !", __func__);
423 return;
424 }
425
426 it_ready = _isp_hdr_fid2ready_map.begin();
427 sequence = it_ready->first;
428
429 if ( _working_mode != RK_AIQ_WORKING_MODE_NORMAL) {
430 match_lumadetect_map(sequence, additional_times);
431 if (additional_times == -1) {
432 // LOGE_CAMHW_SUBM(ISP20HW_SUBM, "%s rdtimes not ready for seq %d !", __func__, sequence);
433 // return;
434 additional_times = 0;//add by zyl
435 }
436
437 match_globaltmostate_map(sequence, isHdrGlobalTmo);
438 //if (isHdrGlobalTmo && !_camHw->getDhazState())
439 // additional_times = 0;
440 } else {
441 additional_times = 0;
442 }
443 _isp_hdr_fid2ready_map.erase(it_ready);
444
445 if (_camHw) {
446 {
447 int ret = XCAM_RETURN_NO_ERROR;
448
449 // whether to start capturing raw files
450 if (_rawCap)
451 _rawCap->detect_capture_raw_status(sequence, _first_trigger);
452
453 //CaptureRawData::getInstance().detect_capture_raw_status(sequence, _first_trigger);
454 //_camHw->setIsppConfig(sequence);
455 for (int i = 0; i < _mipi_dev_max; i++) {
456 ret = _dev[i]->get_buffer(v4l2buf[i],
457 cache_list[i].front()->get_v4l2_buf_index());
458 if (ret != XCAM_RETURN_NO_ERROR) {
459 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "Rx[%d] can not get buffer\n", i);
460 goto out;
461 } else {
462 buf_proxy = cache_list[i].pop(-1);
463 #if 0
464 if (_first_trigger) {
465 u8 *buf = (u8 *)buf_proxy->get_v4l2_userptr();
466 struct v4l2_format format = v4l2buf[i]->get_format();
467
468 if (buf) {
469 for (u32 j = 0; j < format.fmt.pix.width / 2; j++)
470 *buf++ += j % 16;
471 }
472 }
473 #endif
474 buf_list[i].push(buf_proxy);
475 if (_dev[i]->get_mem_type() == V4L2_MEMORY_USERPTR)
476 v4l2buf[i]->set_expbuf_usrptr(buf_proxy->get_v4l2_userptr());
477 else if (_dev[i]->get_mem_type() == V4L2_MEMORY_DMABUF){
478 v4l2buf[i]->set_expbuf_fd(buf_proxy->get_expbuf_fd());
479 }else if (_dev[i]->get_mem_type() == V4L2_MEMORY_MMAP) {
480 if (_dev[i]->get_use_type() == 1)
481 {
482 memcpy((void*)v4l2buf[i]->get_expbuf_usrptr(),(void*)buf_proxy->get_v4l2_userptr(),v4l2buf[i]->get_buf().m.planes[0].length);
483 v4l2buf[i]->set_reserved(buf_proxy->get_v4l2_userptr());
484 }
485 }
486
487 if (_rawCap) {
488 _rawCap->dynamic_capture_raw(i, sequence, buf_proxy, v4l2buf[i],_mipi_dev_max,_working_mode,_dev[0]);
489 }
490 //CaptureRawData::getInstance().dynamic_capture_raw(i, sequence, buf_proxy, v4l2buf[i],_mipi_dev_max,_working_mode,_dev[0]);
491 }
492 }
493
494 if (_rawCap) {
495 if (_rawCap->is_need_save_metadata_and_register()) {
496 rkisp_effect_params_v20 ispParams;
497 _camHw->getEffectiveIspParams(ispParams, sequence);
498
499 SmartPtr<BaseSensorHw> mSensorSubdev = _camHw->mSensorDev.dynamic_cast_ptr<BaseSensorHw>();
500 SmartPtr<RkAiqSensorExpParamsProxy> ExpParams = nullptr;
501 mSensorSubdev->getEffectiveExpParams(ExpParams, sequence);
502
503 SmartPtr<LensHw> mLensSubdev = _camHw->mLensDev.dynamic_cast_ptr<LensHw>();
504 SmartPtr<RkAiqAfInfoProxy> afParams = nullptr;
505 if (mLensSubdev.ptr())
506 mLensSubdev->getAfInfoParams(afParams, sequence);
507 _rawCap->save_metadata_and_register(sequence, ispParams, ExpParams, afParams, _working_mode);
508 }
509 }
510
511 for (int i = 0; i < _mipi_dev_max; i++) {
512 ret = _dev[i]->queue_buffer(v4l2buf[i]);
513 if (ret != XCAM_RETURN_NO_ERROR) {
514 buf_list[i].pop(-1);
515 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "Rx[%d] queue buffer failed\n", i);
516 break;
517 }
518 }
519
520 struct isp2x_csi_trigger tg = {
521 .sof_timestamp = 0,
522 .frame_timestamp = 0,
523 .frame_id = sequence,
524 .times = 0,
525 .mode = _mipi_dev_max == 1 ? T_START_X1 :
526 _mipi_dev_max == 2 ? T_START_X2 : T_START_X3,
527 /* .mode = T_START_X2, */
528 };
529
530 if (_first_trigger)
531 tg.times = 1;
532 else
533 tg.times += additional_times;
534
535 if (tg.times > 2)
536 tg.times = 2;
537 if (_is_multi_cam_conc && (tg.times < 1))
538 tg.times = 1;
539
540 uint64_t sof_timestamp = 0;
541 match_sof_timestamp_map(tg.frame_id, sof_timestamp);
542 tg.sof_timestamp = sof_timestamp;
543 tg.frame_timestamp = buf_proxy->get_timestamp () * 1000;
544 // tg.times = 1;//fixed to three times readback
545 LOGD_CAMHW_SUBM(ISP20HW_SUBM,
546 "camId: %d, frameId: %d: sof_ts %" PRId64 "ms, frame_ts %" PRId64 "ms, trigger readback times: %d\n",
547 mCamPhyId, sequence,
548 tg.sof_timestamp / 1000 / 1000,
549 tg.frame_timestamp / 1000 / 1000,
550 tg.times);
551
552 if (ret == XCAM_RETURN_NO_ERROR) {
553 _isp_core_dev->io_control(RKISP_CMD_TRIGGER_READ_BACK, &tg);
554 } else {
555 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "%s frame[%d] queue failed, don't read back!\n",
556 __func__, sequence);
557 }
558
559 if (_rawCap)
560 _rawCap->update_capture_raw_status(_first_trigger);
561 //CaptureRawData::getInstance().update_capture_raw_status(_first_trigger);
562 }
563 }
564
565 _first_trigger = false;
566 out:
567 return;
568 }
569
570 XCamReturn
set_csi_mem_word_big_align(uint32_t width,uint32_t height,uint32_t sns_v4l_pix_fmt,int8_t sns_bpp)571 RawStreamProcUnit::set_csi_mem_word_big_align(uint32_t width, uint32_t height,
572 uint32_t sns_v4l_pix_fmt, int8_t sns_bpp)
573 {
574 XCamReturn ret = XCAM_RETURN_NO_ERROR;
575
576 LOGD_CAMHW_SUBM(ISP20HW_SUBM,"sensor fmt 0x%x, %dx%d, sns_bpp: %d",
577 sns_v4l_pix_fmt, width, height, sns_bpp);
578
579 for (int i = 0; i < 3; i++) {
580 if (!_dev[i].ptr()) {
581 ret = XCAM_RETURN_BYPASS;
582 break;
583 }
584
585 if (((width / 2 - RKMOUDLE_UNITE_EXTEND_PIXEL) * sns_bpp / 8) & 0xf) {
586 int mem_mode = CSI_MEM_WORD_BIG_ALIGN;
587 int ret1 = _dev[i]->io_control (RKISP_CMD_SET_CSI_MEMORY_MODE, &mem_mode);
588 if (ret1) {
589 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set CSI_MEM_WORD_BIG_ALIGN failed !\n");
590 ret = XCAM_RETURN_ERROR_IOCTL;
591 } else {
592 LOGD_CAMHW_SUBM(ISP20HW_SUBM,"set the memory mode of isp rx to big align");
593 }
594 }
595 }
596
597 return ret;
598 }
599
600 }
601
602