1 #include "CamHwIsp20.h"
2 #include "rk_aiq_comm.h"
3 #include "fake_v4l2_device.h"
4 #include "rkcif-config.h"
5
6 namespace RkCam {
RawStreamCapUnit()7 RawStreamCapUnit::RawStreamCapUnit ()
8 :_is_1608_stream(false)
9 ,_skip_num(0)
10 ,_state(RAW_CAP_STATE_INVALID)
11 {
12 }
13
RawStreamCapUnit(const rk_sensor_full_info_t * s_info,bool linked_to_isp,int tx_buf_cnt)14 RawStreamCapUnit::RawStreamCapUnit (const rk_sensor_full_info_t *s_info, bool linked_to_isp, int tx_buf_cnt)
15 :_is_1608_stream(false)
16 ,_skip_num(0)
17 ,_state(RAW_CAP_STATE_INVALID)
18 {
19 /*
20 * for _mipi_tx_devs, index 0 refer to short frame always, inedex 1 refer
21 * to middle frame always, index 2 refert to long frame always.
22 * for CIF usecase, because mipi_id0 refert to long frame always, so we
23 * should know the HDR mode firstly befor building the relationship between
24 * _mipi_tx_devs array and mipi_idx. here we just set the mipi_idx to
25 * _mipi_tx_devs, we will build the real relation in start.
26 * for CIF usecase, rawwr2_path is always connected to _mipi_tx_devs[0],
27 * rawwr0_path is always connected to _mipi_tx_devs[1], and rawwr1_path is always
28 * connected to _mipi_tx_devs[0]
29 */
30 // FIXME: flag(start_en) is ensure 1608 sensor already open.
31 bool start_en = true;
32 if (s_info->linked_to_1608) {
33 // Traverse the corresponding [1~4] nodes
34 if (CamHwIsp20::rk1608_share_inf.us_open_cnt > 0) {
35 // 1st open
36 start_en = false;
37 }
38
39 // state update.
40 CamHwIsp20::rk1608_share_inf.us_open_cnt++;
41 if (CamHwIsp20::rk1608_share_inf.us_open_cnt > 10)
42 CamHwIsp20::rk1608_share_inf.us_open_cnt = 10;
43 }
44
45 //short frame
46 if (strlen(s_info->isp_info->rawrd2_s_path)) {
47 if (linked_to_isp)
48 _dev[0] = new V4l2Device (s_info->isp_info->rawwr2_path);//rkisp_rawwr2
49 else {
50 if (s_info->dvp_itf) {
51 if (strlen(s_info->cif_info->stream_cif_path))
52 _dev[0] = new V4l2Device (s_info->cif_info->stream_cif_path);
53 else
54 _dev[0] = new V4l2Device (s_info->cif_info->dvp_id0);
55 } else {
56 if (!s_info->linked_to_1608) {
57 // normal mode
58 _dev[0] = new V4l2Device (s_info->cif_info->mipi_id0);
59 } else {
60 if (start_en) {
61 // 1608 sensor mode.
62 _dev[0] = new V4l2Device (s_info->cif_info->mipi_id0);
63 }
64 }
65 }
66 }
67 if (_dev[0].ptr())
68 _dev[0]->open();
69
70 }
71 //mid frame
72 if (strlen(s_info->isp_info->rawrd0_m_path)) {
73 if (linked_to_isp)
74 _dev[1] = new V4l2Device (s_info->isp_info->rawwr0_path);//rkisp_rawwr0
75 else {
76 if (!s_info->dvp_itf) {
77 if (!s_info->linked_to_1608) {
78 // normal mode.
79 _dev[1] = new V4l2Device (s_info->cif_info->mipi_id1);
80 } else {
81 if (start_en) {
82 // 1608 sensor mode.
83 _dev[1] = new V4l2Device (s_info->cif_info->mipi_id1);
84 }
85 }
86 }
87 }
88
89 if (_dev[1].ptr())
90 _dev[1]->open();
91 }
92 //long frame
93 if (strlen(s_info->isp_info->rawrd1_l_path)) {
94 if (linked_to_isp)
95 _dev[2] = new V4l2Device (s_info->isp_info->rawwr1_path);//rkisp_rawwr1
96 else {
97 if (!s_info->dvp_itf) {
98 if (!s_info->linked_to_1608) {
99 // normal mode.
100 _dev[2] = new V4l2Device (s_info->cif_info->mipi_id2);//rkisp_rawwr1
101 } else {
102 if (start_en) {
103 // 1608 sensor mode.
104 _dev[2] = new V4l2Device (s_info->cif_info->mipi_id2);//rkisp_rawwr1
105 }
106 }
107 }
108 }
109 if (_dev[2].ptr())
110 _dev[2]->open();
111 }
112 int buf_cnt = tx_buf_cnt;
113 if (tx_buf_cnt == 0) {
114 if (linked_to_isp) {
115 buf_cnt = ISP_TX_BUF_NUM;
116 } else if (s_info->linked_to_1608) {
117 buf_cnt = VIPCAP_TX_BUF_NUM_1608;
118 } else {
119 buf_cnt = VIPCAP_TX_BUF_NUM;
120 }
121 }
122
123 for (int i = 0; i < 3; i++) {
124 if (_dev[i].ptr()) {
125 _dev[i]->set_buffer_count(buf_cnt);
126 _dev[i]->set_buf_sync (true);
127 _dev_bakup[i] = _dev[i];
128 _dev_index[i] = i;
129 _stream[i] = new RKRawStream(_dev[i], i, ISP_POLL_TX);
130 _stream[i]->setPollCallback(this);
131 } else {
132 _dev_bakup[i] = NULL;
133 _dev_index[i] = i;
134 }
135 }
136
137 _state = RAW_CAP_STATE_INITED;
138 }
139
~RawStreamCapUnit()140 RawStreamCapUnit::~RawStreamCapUnit ()
141 {
142 _state = RAW_CAP_STATE_INVALID;
143 }
144
start(int mode)145 XCamReturn RawStreamCapUnit::start(int mode)
146 {
147 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "%s enter", __FUNCTION__);
148 for (int i = 0; i < _mipi_dev_max; i++) {
149 _stream[i]->setCamPhyId(mCamPhyId);
150 _stream[i]->start();
151 }
152 _state = RAW_CAP_STATE_STARTED;
153 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "%s exit", __FUNCTION__);
154 return XCAM_RETURN_NO_ERROR;
155 }
156
stop()157 XCamReturn RawStreamCapUnit::stop ()
158 {
159 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "%s enter", __FUNCTION__);
160 for (int i = 0; i < _mipi_dev_max; i++) {
161 _stream[i]->stopThreadOnly();
162 }
163 _buf_mutex.lock();
164 for (int i = 0; i < _mipi_dev_max; i++) {
165 buf_list[i].clear ();
166 }
167 _buf_mutex.unlock();
168 for (int i = 0; i < _mipi_dev_max; i++) {
169 _stream[i]->stopDeviceOnly();
170 }
171 _state = RAW_CAP_STATE_STOPPED;
172 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "%s exit", __FUNCTION__);
173 return XCAM_RETURN_NO_ERROR;
174 }
175
176 XCamReturn
prepare(int idx)177 RawStreamCapUnit::prepare(int idx)
178 {
179 XCamReturn ret = XCAM_RETURN_NO_ERROR;
180 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "%s enter", __FUNCTION__);
181 // mipi rx/tx format should match to sensor.
182 for (int i = 0; i < 3; i++) {
183 if (!(idx & (1 << i)))
184 continue;
185 ret = _dev[i]->prepare();
186 if (ret < 0)
187 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "mipi tx:%d prepare err: %d\n", ret);
188
189 _stream[i]->set_device_prepared(true);
190 }
191 _state = RAW_CAP_STATE_PREPARED;
192 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "%s exit", __FUNCTION__);
193 return ret;
194 }
195
196 void
prepare_cif_mipi()197 RawStreamCapUnit::prepare_cif_mipi()
198 {
199 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "%s enter,working_mode=0x%x", __FUNCTION__, _working_mode);
200
201 FakeV4l2Device* fake_dev = dynamic_cast<FakeV4l2Device* >(_dev[0].ptr());
202
203 if (fake_dev) {
204 LOGD_CAMHW_SUBM(ISP20HW_SUBM,"ignore fake tx");
205 return;
206 }
207
208 SmartPtr<V4l2Device> tx_devs_tmp[3] =
209 {
210 _dev_bakup[0],
211 _dev_bakup[1],
212 _dev_bakup[2],
213 };
214
215 // _mipi_tx_devs
216 if (_working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
217 // use _mipi_tx_devs[0] only
218 // id0 as normal
219 // do nothing
220 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "CIF tx: %s -> normal",
221 _dev[0]->get_device_name());
222 } else if (RK_AIQ_HDR_GET_WORKING_MODE(_working_mode) == RK_AIQ_WORKING_MODE_ISP_HDR2) {
223 // use _mipi_tx_devs[0] and _mipi_tx_devs[1]
224 // id0 as l, id1 as s
225 SmartPtr<V4l2Device> tmp = tx_devs_tmp[1];
226 tx_devs_tmp[1] = tx_devs_tmp[0];
227 tx_devs_tmp[0] = tmp;
228 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "CIF tx: %s -> long",
229 _dev[1]->get_device_name());
230 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "CIF tx: %s -> short",
231 _dev[0]->get_device_name());
232 } else if (RK_AIQ_HDR_GET_WORKING_MODE(_working_mode) == RK_AIQ_WORKING_MODE_ISP_HDR3) {
233 // use _mipi_tx_devs[0] and _mipi_tx_devs[1]
234 // id0 as l, id1 as m, id2 as s
235 SmartPtr<V4l2Device> tmp = tx_devs_tmp[2];
236 tx_devs_tmp[2] = tx_devs_tmp[0];
237 tx_devs_tmp[0] = tmp;
238 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "CIF tx: %s -> long",
239 _dev[2]->get_device_name());
240 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "CIF tx: %s -> middle",
241 _dev[1]->get_device_name());
242 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "CIF tx: %s -> short",
243 _dev[0]->get_device_name());
244 } else {
245 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "wrong hdr mode: %d\n", _working_mode);
246 }
247 for (int i = 0; i < 3; i++) {
248 if (tx_devs_tmp[i].ptr()) {
249 _dev[i] = tx_devs_tmp[i];
250 _dev_index[i] = i;
251 _stream[i].release();
252 _stream[i] = new RKRawStream(_dev[i], i, ISP_POLL_TX);
253 _stream[i]->setPollCallback(this);
254 }
255 }
256 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "%s exit", __FUNCTION__);
257 }
258
259 void
set_working_mode(int mode)260 RawStreamCapUnit::set_working_mode(int mode)
261 {
262 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "%s enter,mode=0x%x", __FUNCTION__, mode);
263 _working_mode = mode;
264
265 switch (_working_mode) {
266 case RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR:
267 case RK_AIQ_ISP_HDR_MODE_3_LINE_HDR:
268 _mipi_dev_max = 3;
269 break;
270 case RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR:
271 case RK_AIQ_ISP_HDR_MODE_2_LINE_HDR:
272 _mipi_dev_max = 2;
273 break;
274 default:
275 _mipi_dev_max = 1;
276 }
277 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "%s exit", __FUNCTION__);
278 }
279
280 void
set_tx_devices(SmartPtr<V4l2Device> mipi_tx_devs[3])281 RawStreamCapUnit::set_tx_devices(SmartPtr<V4l2Device> mipi_tx_devs[3])
282 {
283 for (int i = 0; i < 3; i++) {
284 _dev[i] = mipi_tx_devs[i];
285 _stream[i].release();
286 _stream[i] = new RKRawStream(_dev[i], i, ISP_POLL_TX);
287 _stream[i]->setPollCallback(this);
288 }
289 }
290
291 SmartPtr<V4l2Device>
get_tx_device(int index)292 RawStreamCapUnit::get_tx_device(int index)
293 {
294 if (index > _mipi_dev_max)
295 return nullptr;
296 else
297 return _dev[index];
298 }
299
300 XCamReturn
set_tx_format(const struct v4l2_subdev_format & sns_sd_fmt,uint32_t sns_v4l_pix_fmt)301 RawStreamCapUnit::set_tx_format(const struct v4l2_subdev_format& sns_sd_fmt,
302 uint32_t sns_v4l_pix_fmt)
303 {
304 XCamReturn ret = XCAM_RETURN_NO_ERROR;
305
306 for (int i = 0; i < 3; i++) {
307 if (!_dev[i].ptr()) {
308 ret = XCAM_RETURN_ERROR_PARAM;
309 break;
310 }
311
312 ret = _dev[i]->set_format(sns_sd_fmt.format.width,
313 sns_sd_fmt.format.height,
314 sns_v4l_pix_fmt,
315 V4L2_FIELD_NONE,
316 0);
317 if (ret < 0) {
318 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "device(%s) set format failed", _dev[i]->get_device_name());
319 } else {
320 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "device(%s) set fmt info: fmt 0x%x, %dx%d !",
321 _dev[i]->get_device_name(), sns_v4l_pix_fmt,
322 sns_sd_fmt.format.width, sns_sd_fmt.format.height);
323 }
324 }
325
326 return ret;
327 }
328
329 XCamReturn
set_tx_format(const struct v4l2_subdev_selection & sns_sd_sel,uint32_t sns_v4l_pix_fmt)330 RawStreamCapUnit::set_tx_format(const struct v4l2_subdev_selection& sns_sd_sel,
331 uint32_t sns_v4l_pix_fmt)
332 {
333 XCamReturn ret = XCAM_RETURN_NO_ERROR;
334
335 for (int i = 0; i < 3; i++) {
336 if (!_dev[i].ptr()) {
337 ret = XCAM_RETURN_ERROR_PARAM;
338 break;
339 }
340
341 ret = _dev[i]->set_format(sns_sd_sel.r.width,
342 sns_sd_sel.r.height,
343 sns_v4l_pix_fmt,
344 V4L2_FIELD_NONE,
345 0);
346 if (ret < 0) {
347 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "device(%s) set format failed", _dev[i]->get_device_name());
348 } else {
349 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "device(%s) set fmt info: fmt 0x%x, %dx%d !",
350 _dev[i]->get_device_name(), sns_v4l_pix_fmt,
351 sns_sd_sel.r.width, sns_sd_sel.r.height);
352 }
353 }
354
355 return ret;
356 }
357
358 void
set_devices(SmartPtr<V4l2SubDevice> ispdev,CamHwIsp20 * handle,RawStreamProcUnit * proc)359 RawStreamCapUnit::set_devices(SmartPtr<V4l2SubDevice> ispdev, CamHwIsp20* handle, RawStreamProcUnit *proc)
360 {
361 _isp_core_dev = ispdev;
362 _camHw = handle;
363 _proc_stream = proc;
364 }
365
366 XCamReturn
poll_buffer_ready(SmartPtr<V4l2BufferProxy> & buf,int dev_index)367 RawStreamCapUnit::poll_buffer_ready (SmartPtr<V4l2BufferProxy> &buf, int dev_index)
368 {
369 XCamReturn ret = XCAM_RETURN_NO_ERROR;
370 SmartPtr<V4l2BufferProxy> buf_s, buf_m, buf_l;
371
372 _buf_mutex.lock();
373 buf_list[dev_index].push(buf);
374 ret = sync_raw_buf(buf_s, buf_m, buf_l);
375 _buf_mutex.unlock();
376
377 if (ret == XCAM_RETURN_NO_ERROR) {
378 // FIXME: rawCap only has one valid pointer(just malloc once buf), so it needs to do multiple syncs
379 if (!_is_1608_stream) {
380 // normal
381 if (_proc_stream) {
382 _proc_stream->send_sync_buf(buf_s, buf_m, buf_l);
383 }
384 } else {
385 // 1608 mode.
386 for (int idx = 0; idx < CAM_INDEX_FOR_1608; idx++) {
387 if (CamHwIsp20::rk1608_share_inf.raw_proc_unit[idx]) {
388 CamHwIsp20::rk1608_share_inf.raw_proc_unit[idx]->send_sync_buf(buf_s, buf_m, buf_l);
389 }
390 }
391 }
392
393 if (_camHw->mHwResLintener) {
394 auto vbufInfo = buf_s->get_video_info();
395 SmartPtr<SubVideoBuffer> subvbuf = new SubVideoBuffer (buf_s);
396 subvbuf->_buf_type = ISP_POLL_TX;
397 subvbuf->set_sequence(buf_s->get_sequence());
398 subvbuf->set_video_info(vbufInfo);
399 SmartPtr<VideoBuffer> vbuf = subvbuf.dynamic_cast_ptr<VideoBuffer>();
400 _camHw->mHwResLintener->hwResCb(vbuf);
401 }
402 }
403
404 return XCAM_RETURN_NO_ERROR;
405 }
406
skip_frames(int skip_num,int32_t skip_seq)407 void RawStreamCapUnit::skip_frames(int skip_num, int32_t skip_seq)
408 {
409 _mipi_mutex.lock();
410 _skip_num = skip_num;
411 _skip_to_seq = skip_seq + _skip_num;
412 _mipi_mutex.unlock();
413 }
414
check_skip_frame(int32_t buf_seq)415 bool RawStreamCapUnit::check_skip_frame(int32_t buf_seq)
416 {
417 _mipi_mutex.lock();
418 #if 0 // ts
419 if (_skip_num > 0) {
420 int64_t skip_ts_ms = _skip_start_ts / 1000 / 1000;
421 int64_t buf_ts_ms = buf_ts / 1000;
422 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "skip num %d, start from %" PRId64 " ms, buf ts %" PRId64 " ms",
423 _skip_num,
424 skip_ts_ms,
425 buf_ts_ms);
426 if (buf_ts_ms > skip_ts_ms) {
427 _skip_num--;
428 _mipi_mutex.unlock();
429 return true;
430 }
431 }
432 #else
433
434 if ((_skip_num > 0) && (buf_seq < _skip_to_seq)) {
435 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "skip num %d, skip seq %d, dest seq %d",
436 _skip_num, buf_seq, _skip_to_seq);
437 _skip_num--;
438 _mipi_mutex.unlock();
439 return true;
440 }
441 #endif
442 _mipi_mutex.unlock();
443 return false;
444 }
445
446 XCamReturn
sync_raw_buf(SmartPtr<V4l2BufferProxy> & buf_s,SmartPtr<V4l2BufferProxy> & buf_m,SmartPtr<V4l2BufferProxy> & buf_l)447 RawStreamCapUnit::sync_raw_buf
448 (
449 SmartPtr<V4l2BufferProxy> &buf_s,
450 SmartPtr<V4l2BufferProxy> &buf_m,
451 SmartPtr<V4l2BufferProxy> &buf_l
452 )
453 {
454 uint32_t sequence_s = -1, sequence_m = -1, sequence_l = -1;
455
456 for (int i = 0; i < _mipi_dev_max; i++) {
457 if (buf_list[i].is_empty()) {
458 return XCAM_RETURN_ERROR_FAILED;
459 }
460 }
461
462 buf_l = buf_list[ISP_MIPI_HDR_L].front();
463 if (buf_l.ptr())
464 sequence_l = buf_l->get_sequence();
465
466 buf_m = buf_list[ISP_MIPI_HDR_M].front();
467 if (buf_m.ptr())
468 sequence_m = buf_m->get_sequence();
469
470 buf_s = buf_list[ISP_MIPI_HDR_S].front();
471
472 if (buf_s.ptr()) {
473 sequence_s = buf_s->get_sequence();
474 if ((_working_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR ||
475 _working_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR) &&
476 buf_m.ptr() && buf_l.ptr() && buf_s.ptr() &&
477 sequence_l == sequence_s && sequence_m == sequence_s) {
478
479 buf_list[ISP_MIPI_HDR_S].erase(buf_s);
480 buf_list[ISP_MIPI_HDR_M].erase(buf_m);
481 buf_list[ISP_MIPI_HDR_L].erase(buf_l);
482 if (check_skip_frame(sequence_s)) {
483 LOGW_CAMHW_SUBM(ISP20HW_SUBM, "skip frame %d", sequence_s);
484 goto end;
485 }
486 } else if ((_working_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR ||
487 _working_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR) &&
488 buf_m.ptr() && buf_s.ptr() && sequence_m == sequence_s) {
489 buf_list[ISP_MIPI_HDR_S].erase(buf_s);
490 buf_list[ISP_MIPI_HDR_M].erase(buf_m);
491 if (check_skip_frame(sequence_s)) {
492 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "skip frame %d", sequence_s);
493 goto end;
494 }
495 } else if (_working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
496 buf_list[ISP_MIPI_HDR_S].erase(buf_s);
497 if (check_skip_frame(sequence_s)) {
498 LOGW_CAMHW_SUBM(ISP20HW_SUBM, "skip frame %d", sequence_s);
499 goto end;
500 }
501 } else {
502 LOGW_CAMHW_SUBM(ISP20HW_SUBM, "do nothing, sequence not match l: %d, s: %d, m: %d !!!",
503 sequence_l, sequence_s, sequence_m);
504 }
505 return XCAM_RETURN_NO_ERROR;
506 }
507 end:
508 return XCAM_RETURN_ERROR_FAILED;
509 }
510
511 XCamReturn
reset_hardware()512 RawStreamCapUnit::reset_hardware()
513 {
514 XCamReturn ret = XCAM_RETURN_NO_ERROR;
515 if (_dev[0].ptr()) {
516 int32_t reset = 1;
517 int32_t b_ret = 0;
518
519 errno = 0;
520 b_ret = _dev[0]->io_control(RKCIF_CMD_SET_RESET, &reset);
521 if (b_ret < 0) {
522 LOGE_CAMHW_SUBM(SENSOR_SUBM, "device(%s) reset failed: %d (%s)!",
523 XCAM_STR(_dev[0]->get_device_name()), b_ret, strerror(errno));
524 return XCAM_RETURN_ERROR_IOCTL;
525 }
526
527 LOGD_CAMHW_SUBM(SENSOR_SUBM, "device(%s) reset", XCAM_STR(_dev[0]->get_device_name()));
528 }
529
530 return ret;
531 }
532
533 XCamReturn
set_csi_mem_word_big_align(uint32_t width,uint32_t height,uint32_t sns_v4l_pix_fmt,int8_t sns_bpp)534 RawStreamCapUnit::set_csi_mem_word_big_align(uint32_t width, uint32_t height,
535 uint32_t sns_v4l_pix_fmt, int8_t sns_bpp)
536 {
537 XCamReturn ret = XCAM_RETURN_NO_ERROR;
538
539 LOGD_CAMHW_SUBM(ISP20HW_SUBM,"sensor fmt 0x%x, %dx%d, sns_bpp: %d",
540 sns_v4l_pix_fmt, width, height, sns_bpp);
541
542 for (int i = 0; i < 3; i++) {
543 if (!_dev[i].ptr()) {
544 ret = XCAM_RETURN_BYPASS;
545 break;
546 }
547
548 if (((width / 2 - RKMOUDLE_UNITE_EXTEND_PIXEL) * sns_bpp / 8) & 0xf) {
549 int mem_mode = CSI_LVDS_MEM_WORD_HIGH_ALIGN;
550 int ret1 = _dev[i]->io_control (RKCIF_CMD_SET_CSI_MEMORY_MODE, &mem_mode);
551 if (ret1) {
552 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set CSI_MEM_WORD_BIG_ALIGN failed!\n");
553 ret = XCAM_RETURN_ERROR_IOCTL;
554 } else {
555 LOGD_CAMHW_SUBM(ISP20HW_SUBM,"set the memory mode of vicap to big align");
556 }
557 }
558 }
559
560 return ret;
561 }
562
563 }
564