1 /*
2 * Copyright (c) 2019 Rockchip Corporation
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 *
16 */
17
18 #include <linux/v4l2-subdev.h>
19 #include "LensHw.h"
20
21 //#define DISABLE_ZOOM_FOCUS
22
23 namespace RkCam {
24
25 uint16_t LensHw::DEFAULT_POOL_SIZE = 20;
26
LensHw(const char * name)27 LensHw::LensHw(const char* name)
28 : V4l2SubDevice (name)
29 {
30 ENTER_CAMHW_FUNCTION();
31 _rec_sof_idx = 0;
32 memset(_frame_time, 0, sizeof(_frame_time));
33 memset(_frame_sequence, 0, sizeof(_frame_sequence));
34 _afInfoPool = new RkAiqAfInfoPool("LensLocalAfInfoParams", LensHw::DEFAULT_POOL_SIZE);
35 _irisInfoPool = new RkAiqIrisParamsPool("LensLocalIrisInfoParams", LensHw::DEFAULT_POOL_SIZE);
36 _lenshw_thd = new LensHwHelperThd(this, 0);
37 _lenshw_thd1 = new LensHwHelperThd(this, 1);
38 _piris_step = -1;
39 _max_logical_pos = 64;
40 EXIT_CAMHW_FUNCTION();
41 }
42
~LensHw()43 LensHw::~LensHw()
44 {
45 ENTER_CAMHW_FUNCTION();
46 EXIT_CAMHW_FUNCTION();
47 }
48
49 XCamReturn
getOTPData()50 LensHw::getOTPData()
51 {
52 ENTER_CAMHW_FUNCTION();
53
54 _otp_valid = false;
55 _startCurrent = -1;
56 _endCurrent = -1;
57 _posture = -1;
58 _hysteresis = -1;
59
60 return XCAM_RETURN_NO_ERROR;
61 }
62
63 XCamReturn
queryLensSupport()64 LensHw::queryLensSupport()
65 {
66 ENTER_CAMHW_FUNCTION();
67
68 _iris_enable = false;
69 _focus_enable = false;
70 _zoom_enable = false;
71
72 if (!_name)
73 return XCAM_RETURN_NO_ERROR;
74
75 memset(&_iris_query, 0, sizeof(_iris_query));
76 _iris_query.id = V4L2_CID_IRIS_ABSOLUTE;
77 if (io_control(VIDIOC_QUERYCTRL, &_iris_query) < 0) {
78 LOGI_CAMHW_SUBM(LENS_SUBM, "query iris ctrl failed");
79 _iris_enable = false;
80 } else {
81 _iris_enable = true;
82 }
83
84 memset(&_focus_query, 0, sizeof(_focus_query));
85 _focus_query.id = V4L2_CID_FOCUS_ABSOLUTE;
86 if (io_control(VIDIOC_QUERYCTRL, &_focus_query) < 0) {
87 LOGI_CAMHW_SUBM(LENS_SUBM, "query focus ctrl failed");
88 _focus_enable = false;
89 } else {
90 _focus_enable = true;
91 }
92
93 memset(&_zoom_query, 0, sizeof(_zoom_query));
94 _zoom_query.id = V4L2_CID_ZOOM_ABSOLUTE;
95 if (io_control(VIDIOC_QUERYCTRL, &_zoom_query) < 0) {
96 LOGI_CAMHW_SUBM(LENS_SUBM, "query zoom ctrl failed");
97 _zoom_enable = false;
98 } else {
99 _zoom_enable = true;
100 }
101
102 getOTPData();
103
104 EXIT_CAMHW_FUNCTION();
105 return XCAM_RETURN_NO_ERROR;
106 }
107
108 XCamReturn
start_internal()109 LensHw::start_internal()
110 {
111 ENTER_CAMHW_FUNCTION();
112
113 if (_active)
114 return XCAM_RETURN_NO_ERROR;
115
116 _rec_sof_idx = 0;
117 _rec_lowfv_idx = 0;
118 _piris_step = 0;
119 _last_piris_step = 0;
120 _dciris_pwmduty = 0;
121 _last_dciris_pwmduty = 0;
122 _focus_pos = -1;
123 _zoom_pos = -1;
124 _angleZ = 0;
125 _zoom_correction = false;
126 _focus_correction = false;
127 memset(&_focus_tim, 0, sizeof(_focus_tim));
128 memset(&_zoom_tim, 0, sizeof(_zoom_tim));
129 memset(_frame_time, 0, sizeof(_frame_time));
130 memset(_frame_sequence, 0, sizeof(_frame_sequence));
131 memset(_lowfv_fv4_4, 0, sizeof(_lowfv_fv4_4));
132 memset(_lowfv_fv8_8, 0, sizeof(_lowfv_fv8_8));
133 memset(_lowfv_highlht, 0, sizeof(_lowfv_highlht));
134 memset(_lowfv_seq, 0, sizeof(_lowfv_seq));
135 queryLensSupport();
136 if (_zoom_enable) {
137 _lenshw_thd->triger_start();
138 _lenshw_thd->start();
139 _lenshw_thd1->triger_start();
140 _lenshw_thd1->start();
141 }
142
143 _active = true;
144 EXIT_CAMHW_FUNCTION();
145 return XCAM_RETURN_NO_ERROR;
146 }
147
148 XCamReturn
start(bool prepared)149 LensHw::start(bool prepared)
150 {
151 (void)prepared;
152 ENTER_CAMHW_FUNCTION();
153 SmartLock locker (_mutex);
154
155 if (!_name)
156 return XCAM_RETURN_NO_ERROR;
157
158 start_internal();
159
160 EXIT_CAMHW_FUNCTION();
161 return XCAM_RETURN_NO_ERROR;
162 }
163
164 XCamReturn
stop()165 LensHw::stop()
166 {
167 ENTER_CAMHW_FUNCTION();
168
169 if (!_name)
170 return XCAM_RETURN_NO_ERROR;
171
172 if (_zoom_enable) {
173 _lenshw_thd->triger_stop();
174 _lenshw_thd->stop();
175 _lenshw_thd1->triger_stop();
176 _lenshw_thd1->stop();
177 }
178
179 _mutex.lock();
180 _active = false;
181 _mutex.unlock();
182 EXIT_CAMHW_FUNCTION();
183 return XCAM_RETURN_NO_ERROR;
184 }
185
186 XCamReturn
getLensModeData(rk_aiq_lens_descriptor & lens_des)187 LensHw::getLensModeData(rk_aiq_lens_descriptor& lens_des)
188 {
189 ENTER_CAMHW_FUNCTION();
190 SmartLock locker (_mutex);
191
192 if (!_name)
193 return XCAM_RETURN_NO_ERROR;
194
195 if (!_active)
196 queryLensSupport();
197 lens_des.focus_support = _focus_enable;
198 lens_des.iris_support = _iris_enable;
199 lens_des.zoom_support = _zoom_enable;
200 lens_des.focus_minimum = _focus_query.minimum;
201 lens_des.focus_maximum = _focus_query.maximum;
202 lens_des.zoom_minimum = _zoom_query.minimum;
203 lens_des.zoom_maximum = _zoom_query.maximum;
204 lens_des.otp_valid = _otp_valid;
205 lens_des.posture = _posture;
206 lens_des.hysteresis = _hysteresis;
207 lens_des.startCurrent = _startCurrent;
208 lens_des.endCurrent = _endCurrent;
209 EXIT_CAMHW_FUNCTION();
210
211 return XCAM_RETURN_NO_ERROR;
212 }
213
214 XCamReturn
getLensVcmCfg(rk_aiq_lens_vcmcfg & lens_cfg)215 LensHw::getLensVcmCfg(rk_aiq_lens_vcmcfg& lens_cfg)
216 {
217 ENTER_CAMHW_FUNCTION();
218 struct rk_cam_vcm_cfg cfg;
219
220 if (!_name)
221 return XCAM_RETURN_NO_ERROR;
222
223 if (io_control (RK_VIDIOC_GET_VCM_CFG, &cfg) < 0) {
224 LOGE_CAMHW_SUBM(LENS_SUBM, "get vcm cfg failed");
225 return XCAM_RETURN_ERROR_IOCTL;
226 }
227 lens_cfg.start_ma = cfg.start_ma;
228 lens_cfg.rated_ma = cfg.rated_ma;
229 lens_cfg.step_mode = cfg.step_mode;
230
231 EXIT_CAMHW_FUNCTION();
232 return XCAM_RETURN_NO_ERROR;
233 }
234
235 XCamReturn
setLensVcmCfg(rk_aiq_lens_vcmcfg & lens_cfg)236 LensHw::setLensVcmCfg(rk_aiq_lens_vcmcfg& lens_cfg)
237 {
238 ENTER_CAMHW_FUNCTION();
239 struct rk_cam_vcm_cfg cfg;
240
241 if (!_name)
242 return XCAM_RETURN_NO_ERROR;
243
244 cfg.start_ma = lens_cfg.start_ma;
245 cfg.rated_ma = lens_cfg.rated_ma;
246 cfg.step_mode = lens_cfg.step_mode;
247 if (io_control (RK_VIDIOC_SET_VCM_CFG, &cfg) < 0) {
248 LOGE_CAMHW_SUBM(LENS_SUBM, "set vcm cfg failed");
249 return XCAM_RETURN_ERROR_IOCTL;
250 }
251
252 LOGD_AF("%s: start_ma %d, rated_ma %d, step_mode %d",
253 __func__, cfg.start_ma, cfg.rated_ma, cfg.step_mode);
254
255 EXIT_CAMHW_FUNCTION();
256 return XCAM_RETURN_NO_ERROR;
257 }
258
getLensVcmMaxlogpos(int & max_log_pos)259 XCamReturn LensHw::getLensVcmMaxlogpos(int& max_log_pos)
260 {
261 ENTER_CAMHW_FUNCTION();
262
263 if (!_name)
264 return XCAM_RETURN_NO_ERROR;
265
266 max_log_pos = _max_logical_pos;
267
268 EXIT_CAMHW_FUNCTION();
269 return XCAM_RETURN_NO_ERROR;
270 }
271
setLensVcmMaxlogpos(int & max_log_pos)272 XCamReturn LensHw::setLensVcmMaxlogpos(int& max_log_pos)
273 {
274 ENTER_CAMHW_FUNCTION();
275
276 struct v4l2_queryctrl focus_query;
277
278 _max_logical_pos = max_log_pos;
279 if (!_name)
280 return XCAM_RETURN_NO_ERROR;
281
282 if (io_control (RK_VIDIOC_SET_VCM_MAX_LOGICALPOS, &max_log_pos) < 0) {
283 LOGE_CAMHW_SUBM(LENS_SUBM, "set vcm cfg failed");
284 return XCAM_RETURN_ERROR_IOCTL;
285 }
286
287 memset(&focus_query, 0, sizeof(focus_query));
288 focus_query.id = V4L2_CID_FOCUS_ABSOLUTE;
289 if (io_control(VIDIOC_QUERYCTRL, &focus_query) < 0) {
290 LOGI_CAMHW_SUBM(LENS_SUBM, "query focus ctrl failed");
291 return XCAM_RETURN_ERROR_IOCTL;
292 } else {
293 _focus_query = focus_query;
294 }
295
296 LOGD_AF("%s: max_log_pos %d", __func__, max_log_pos);
297
298 EXIT_CAMHW_FUNCTION();
299 return XCAM_RETURN_NO_ERROR;
300 }
301
302 XCamReturn
setFocusParamsSync(int position,bool is_update_time,bool focus_noreback)303 LensHw::setFocusParamsSync(int position, bool is_update_time, bool focus_noreback)
304 {
305 ENTER_CAMHW_FUNCTION();
306 struct rk_cam_set_focus set_focus;
307 unsigned long end_time;
308
309 #ifdef DISABLE_ZOOM_FOCUS
310 return XCAM_RETURN_NO_ERROR;
311 #endif
312
313 if (!_focus_enable) {
314 LOGE_CAMHW_SUBM(LENS_SUBM, "focus is not supported");
315 return XCAM_RETURN_NO_ERROR;
316 }
317
318 if (position < _focus_query.minimum)
319 position = _focus_query.minimum;
320 if (position > _focus_query.maximum)
321 position = _focus_query.maximum;
322
323 xcam_mem_clear (set_focus);
324 set_focus.focus_pos = position;
325 if ((position < _focus_pos) && !focus_noreback)
326 set_focus.is_need_reback = true;
327
328 if (io_control (RK_VIDIOC_FOCUS_SET_POSITION, &set_focus) < 0) {
329 LOGE_CAMHW_SUBM(LENS_SUBM, "set focus result failed to device");
330 return XCAM_RETURN_ERROR_IOCTL;
331 }
332 _focus_pos = position;
333
334 if (!focus_noreback)
335 _last_zoomchg_focus = position;
336
337 struct rk_cam_vcm_tim tim;
338 if (io_control (RK_VIDIOC_VCM_TIMEINFO, &tim) < 0) {
339 LOGE_CAMHW_SUBM(LENS_SUBM, "get focus timeinfo failed");
340 _mutex.lock();
341 if (is_update_time)
342 _focus_tim.vcm_end_t.tv_sec += 2;
343 _mutex.unlock();
344 } else {
345 _mutex.lock();
346 if (is_update_time)
347 _focus_tim = tim;
348 _mutex.unlock();
349
350 end_time = _focus_tim.vcm_end_t.tv_sec * 1000 + _focus_tim.vcm_end_t.tv_usec / 1000;
351 LOGD_CAMHW_SUBM(LENS_SUBM, "|||set focus result: %d, focus_pos %d, _last_zoomchg_focus %d, end time %ld, is_update_time %d, is_need_reback %d",
352 position, set_focus.focus_pos, _last_zoomchg_focus, end_time, is_update_time, set_focus.is_need_reback);
353 }
354
355 EXIT_CAMHW_FUNCTION();
356 return XCAM_RETURN_NO_ERROR;
357 }
358
359 XCamReturn
setFocusParams(SmartPtr<RkAiqFocusParamsProxy> & focus_params)360 LensHw::setFocusParams(SmartPtr<RkAiqFocusParamsProxy>& focus_params)
361 {
362 ENTER_CAMHW_FUNCTION();
363 SmartLock locker (_mutex);
364 unsigned long end_time;
365 rk_aiq_focus_params_t* p_focus = &focus_params->data()->result;
366
367 if (!_focus_enable) {
368 LOGE_CAMHW_SUBM(LENS_SUBM, "focus is not supported");
369 return XCAM_RETURN_NO_ERROR;
370 }
371
372 if (!_active)
373 start_internal();
374
375 #ifdef DISABLE_ZOOM_FOCUS
376 return XCAM_RETURN_NO_ERROR;
377 #endif
378
379 if (_zoom_enable) {
380 SmartPtr<rk_aiq_focus_params_t> attrPtr = new rk_aiq_focus_params_t;
381
382 attrPtr->zoomfocus_modifypos = false;
383 attrPtr->focus_correction = false;
384 attrPtr->zoom_correction = false;
385 attrPtr->lens_pos_valid = true;
386 attrPtr->zoom_pos_valid = false;
387 attrPtr->send_zoom_reback = p_focus->send_zoom_reback;
388 attrPtr->send_focus_reback = p_focus->send_focus_reback;
389 attrPtr->end_zoom_chg = p_focus->end_zoom_chg;
390 attrPtr->focus_noreback = p_focus->focus_noreback;
391 attrPtr->next_pos_num = 1;
392 attrPtr->next_lens_pos[0] = p_focus->next_lens_pos[0];
393
394 LOGI_AF("set focus position: %d", attrPtr->next_lens_pos[0]);
395 _lenshw_thd->push_attr(attrPtr);
396 } else {
397 struct v4l2_control control;
398 unsigned long start_time, end_time;
399 int algo_pos, driver_pos;
400
401 algo_pos = p_focus->next_lens_pos[0];
402 driver_pos = algo_pos * (_focus_query.maximum - _focus_query.minimum) / _max_logical_pos + _focus_query.minimum;
403 if (driver_pos < _focus_query.minimum)
404 driver_pos = _focus_query.minimum;
405 if (driver_pos > _focus_query.maximum)
406 driver_pos = _focus_query.maximum;
407
408 xcam_mem_clear (control);
409 control.id = V4L2_CID_FOCUS_ABSOLUTE;
410 control.value = driver_pos;
411
412 if (io_control (VIDIOC_S_CTRL, &control) < 0) {
413 LOGE_CAMHW_SUBM(LENS_SUBM, "set focus result failed to device");
414 return XCAM_RETURN_ERROR_IOCTL;
415 }
416 _focus_pos = algo_pos;
417
418 struct rk_cam_vcm_tim tim;
419 if (io_control (RK_VIDIOC_VCM_TIMEINFO, &tim) < 0) {
420 LOGE_CAMHW_SUBM(LENS_SUBM, "get focus timeinfo failed");
421 return XCAM_RETURN_ERROR_IOCTL;
422 }
423 _focus_tim = tim;
424
425 start_time = _focus_tim.vcm_start_t.tv_sec * 1000 + _focus_tim.vcm_start_t.tv_usec / 1000;
426 end_time = _focus_tim.vcm_end_t.tv_sec * 1000 + _focus_tim.vcm_end_t.tv_usec / 1000;
427 LOGI_AF("|||set focus: algo_pos %d, driver_pos %d, end time %ld, need time %d",
428 algo_pos, driver_pos, end_time, end_time - start_time);
429 }
430
431 EXIT_CAMHW_FUNCTION();
432 return XCAM_RETURN_NO_ERROR;
433 }
434
435 XCamReturn
setPIrisParams(int step)436 LensHw::setPIrisParams(int step)
437 {
438 ENTER_CAMHW_FUNCTION();
439 SmartLock locker (_mutex);
440 struct v4l2_control control;
441
442 if (!_iris_enable) {
443 LOGE_CAMHW_SUBM(LENS_SUBM, "iris is not supported");
444 return XCAM_RETURN_NO_ERROR;
445 }
446
447 if (!_active)
448 start_internal();
449
450 if (_piris_step == step)
451 return XCAM_RETURN_NO_ERROR;
452
453 //get old Piris-step
454 _last_piris_step = _piris_step;
455
456 xcam_mem_clear (control);
457 control.id = V4L2_CID_IRIS_ABSOLUTE;
458 control.value = step;
459
460 LOGD_CAMHW_SUBM(LENS_SUBM, "|||set iris result: %d, control.value %d", step, control.value);
461 if (io_control (VIDIOC_S_CTRL, &control) < 0) {
462 LOGE_CAMHW_SUBM(LENS_SUBM, "set iris result failed to device");
463 return XCAM_RETURN_ERROR_IOCTL;
464 }
465 _piris_step = step;
466
467 struct rk_cam_motor_tim tim;
468 if (io_control (RK_VIDIOC_IRIS_TIMEINFO, &tim) < 0) {
469 LOGE_CAMHW_SUBM(LENS_SUBM, "get iris timeinfo failed");
470 return XCAM_RETURN_ERROR_IOCTL;
471 }
472 _piris_tim = tim;
473
474 EXIT_CAMHW_FUNCTION();
475 return XCAM_RETURN_NO_ERROR;
476 }
477
478 XCamReturn
setDCIrisParams(int pwmDuty)479 LensHw::setDCIrisParams(int pwmDuty)
480 {
481 ENTER_CAMHW_FUNCTION();
482 SmartLock locker (_mutex);
483 struct v4l2_control control;
484
485 if (!_iris_enable) {
486 LOGE_CAMHW_SUBM(LENS_SUBM, "iris is not supported");
487 return XCAM_RETURN_NO_ERROR;
488 }
489
490 if (!_active)
491 start_internal();
492
493 if (_dciris_pwmduty == pwmDuty)
494 return XCAM_RETURN_NO_ERROR;
495
496 //get old DCiris-step
497 _last_dciris_pwmduty = pwmDuty;
498
499 xcam_mem_clear (control);
500 control.id = V4L2_CID_IRIS_ABSOLUTE;
501 control.value = pwmDuty;
502
503 LOGD_CAMHW_SUBM(LENS_SUBM, "|||set dc-iris result: %d, control.value %d", pwmDuty, control.value);
504 if (io_control (VIDIOC_S_CTRL, &control) < 0) {
505 LOGE_CAMHW_SUBM(LENS_SUBM, "set dc-iris result failed to device");
506 return XCAM_RETURN_ERROR_IOCTL;
507 }
508 _dciris_pwmduty = pwmDuty;
509
510 EXIT_CAMHW_FUNCTION();
511 return XCAM_RETURN_NO_ERROR;
512 }
513
514 XCamReturn
setHDCIrisParams(int target)515 LensHw::setHDCIrisParams(int target)
516 {
517 ENTER_CAMHW_FUNCTION();
518 SmartLock locker (_mutex);
519 struct v4l2_control control;
520
521 if (!_iris_enable) {
522 LOGE_CAMHW_SUBM(LENS_SUBM, "iris is not supported");
523 return XCAM_RETURN_NO_ERROR;
524 }
525
526 if (!_active)
527 start_internal();
528
529 if (_hdciris_target == target)
530 return XCAM_RETURN_NO_ERROR;
531
532 //get old HDCiris-step
533 _last_hdciris_target = _hdciris_target;
534
535 xcam_mem_clear (control);
536 control.id = V4L2_CID_IRIS_ABSOLUTE;
537 control.value = target;
538
539 LOGD_CAMHW_SUBM(LENS_SUBM, "|||set hdc-iris result: %d, control.value %d", target, control.value);
540 if (io_control (VIDIOC_S_CTRL, &control) < 0) {
541 LOGE_CAMHW_SUBM(LENS_SUBM, "set hdc-iris result failed to device");
542 return XCAM_RETURN_ERROR_IOCTL;
543 }
544 _hdciris_target = target;
545
546 EXIT_CAMHW_FUNCTION();
547 return XCAM_RETURN_NO_ERROR;
548 }
549
550 XCamReturn
getHDCIrisParams(int * adc)551 LensHw::getHDCIrisParams(int* adc)
552 {
553 ENTER_CAMHW_FUNCTION();
554 SmartLock locker (_mutex);
555
556 if (!_iris_enable) {
557 LOGE_CAMHW_SUBM(LENS_SUBM, "iris is not supported");
558 return XCAM_RETURN_ERROR_FAILED;
559 }
560
561 int iris_adc = 0;
562 // No work for now
563 /*
564 if (io_control(RK_VIDIOC_GET_DCIRIS_HALL_ADC, &iris_adc) < 0) {
565 LOGD_CAMHW_SUBM(LENS_SUBM, "failed to get iris adc");
566 *adc = 0;
567 return XCAM_RETURN_ERROR_IOCTL;
568 }
569 */
570 *adc = iris_adc;
571 LOGD("|||get dciris adc value=%d\n", iris_adc);
572
573 EXIT_CAMHW_FUNCTION();
574 return XCAM_RETURN_NO_ERROR;
575 }
576
577 XCamReturn
getPIrisParams(int * step)578 LensHw::getPIrisParams(int* step)
579 {
580 ENTER_CAMHW_FUNCTION();
581 SmartLock locker (_mutex);
582 struct v4l2_control control;
583
584 if (!_iris_enable) {
585 LOGE_CAMHW_SUBM(LENS_SUBM, "iris is not supported");
586 return XCAM_RETURN_ERROR_FAILED;
587 }
588
589 xcam_mem_clear (control);
590 control.id = V4L2_CID_IRIS_ABSOLUTE;
591
592 if (io_control (VIDIOC_G_CTRL, &control) < 0) {
593 LOGE_CAMHW_SUBM(LENS_SUBM, "get iris result failed");
594 return XCAM_RETURN_ERROR_IOCTL;
595 }
596 *step = control.value;
597 LOGD_CAMHW_SUBM(LENS_SUBM, "|||get iris result: %d, control.value %d", *step, control.value);
598
599 EXIT_CAMHW_FUNCTION();
600 return XCAM_RETURN_NO_ERROR;
601 }
602
603 XCamReturn
setZoomParams(int position)604 LensHw::setZoomParams(int position)
605 {
606 return XCAM_RETURN_NO_ERROR;
607 }
608
609 XCamReturn
setZoomFocusRebackSync(SmartPtr<rk_aiq_focus_params_t> attrPtr,bool is_update_time)610 LensHw::setZoomFocusRebackSync(SmartPtr<rk_aiq_focus_params_t> attrPtr, bool is_update_time)
611 {
612 ENTER_CAMHW_FUNCTION();
613 struct rk_cam_vcm_tim zoomtim, focustim;
614 struct rk_cam_set_zoom set_zoom;
615 struct v4l2_control control;
616 unsigned long time0, time1;
617 int zoom_pos = 0, focus_pos = 0;
618
619 #ifdef DISABLE_ZOOM_FOCUS
620 return XCAM_RETURN_NO_ERROR;
621 #endif
622
623 if (!_zoom_enable || !_focus_enable) {
624 LOGE_CAMHW_SUBM(LENS_SUBM, "zoom or focus is not supported");
625 return XCAM_RETURN_NO_ERROR;
626 }
627
628 xcam_mem_clear (set_zoom);
629 set_zoom.setzoom_cnt = 1;
630 if (attrPtr->send_zoom_reback)
631 set_zoom.is_need_zoom_reback = true;
632 if (attrPtr->send_focus_reback)
633 set_zoom.is_need_focus_reback = true;
634 _mutex.lock();
635 zoom_pos = _zoom_pos;
636 focus_pos = _focus_pos;
637 _mutex.unlock();
638 set_zoom.zoom_pos[0].zoom_pos = zoom_pos;
639 set_zoom.zoom_pos[0].focus_pos = focus_pos;
640
641 if (io_control (RK_VIDIOC_ZOOM_SET_POSITION, &set_zoom) < 0) {
642 LOGE_CAMHW_SUBM(LENS_SUBM, "set zoom position failed");
643 return XCAM_RETURN_ERROR_IOCTL;
644 }
645
646 if (io_control (RK_VIDIOC_ZOOM_TIMEINFO, &zoomtim) < 0) {
647 LOGE_CAMHW_SUBM(LENS_SUBM, "get zoom timeinfo failed");
648 _mutex.lock();
649 zoomtim = _zoom_tim;
650 zoomtim.vcm_end_t.tv_sec += 1;
651 _mutex.unlock();
652 }
653
654 if (io_control (RK_VIDIOC_VCM_TIMEINFO, &focustim) < 0) {
655 LOGE_CAMHW_SUBM(LENS_SUBM, "get focus timeinfo failed");
656 _mutex.lock();
657 focustim = _focus_tim;
658 focustim.vcm_end_t.tv_sec += 1;
659 _mutex.unlock();
660 }
661
662 _mutex.lock();
663 if (is_update_time) {
664 _zoom_tim = zoomtim;
665 }
666 _zoom_pos = zoom_pos;
667 _focus_pos = focus_pos;
668 _mutex.unlock();
669
670 time0 = _zoom_tim.vcm_end_t.tv_sec * 1000 + _zoom_tim.vcm_end_t.tv_usec / 1000;
671 LOGD_CAMHW_SUBM(LENS_SUBM, "zoom_pos %d, focus_pos %d, is_need_zoom_reback %d, is_need_focus_reback %d, end time %ld, is_update_time %d",
672 zoom_pos, focus_pos, set_zoom.is_need_zoom_reback, set_zoom.is_need_focus_reback, time0, is_update_time);
673
674 EXIT_CAMHW_FUNCTION();
675 return XCAM_RETURN_NO_ERROR;
676 }
677
678 XCamReturn
endZoomChgSync(SmartPtr<rk_aiq_focus_params_t> attrPtr,bool is_update_time)679 LensHw::endZoomChgSync(SmartPtr<rk_aiq_focus_params_t> attrPtr, bool is_update_time)
680 {
681 ENTER_CAMHW_FUNCTION();
682 struct rk_cam_vcm_tim zoomtim, focustim;
683 struct rk_cam_set_zoom set_zoom;
684 struct v4l2_control control;
685 unsigned long time0, time1;
686 int zoom_pos = 0, focus_pos = 0;
687
688 #ifdef DISABLE_ZOOM_FOCUS
689 return XCAM_RETURN_NO_ERROR;
690 #endif
691
692 if (!_zoom_enable || !_focus_enable) {
693 LOGE_CAMHW_SUBM(LENS_SUBM, "zoom or focus is not supported");
694 return XCAM_RETURN_NO_ERROR;
695 }
696
697 xcam_mem_clear (set_zoom);
698 if (attrPtr->end_zoom_chg) {
699 set_zoom.setzoom_cnt = 1;
700 _mutex.lock();
701 zoom_pos = _zoom_pos;
702 focus_pos = _focus_pos;
703 _mutex.unlock();
704 set_zoom.zoom_pos[0].zoom_pos = zoom_pos;
705 set_zoom.zoom_pos[0].focus_pos = focus_pos;
706
707 LOGD_CAMHW_SUBM(LENS_SUBM, "zoom_pos %d, focus_pos %d, _last_zoomchg_zoom %d, _last_zoomchg_focus %d\n",
708 zoom_pos, focus_pos, _last_zoomchg_zoom, _last_zoomchg_focus);
709 if (zoom_pos < _last_zoomchg_zoom)
710 set_zoom.is_need_zoom_reback = true;
711 else
712 set_zoom.is_need_zoom_reback = false;
713
714 if (focus_pos < _last_zoomchg_focus)
715 set_zoom.is_need_focus_reback = true;
716 else
717 set_zoom.is_need_focus_reback = false;
718
719 _last_zoomchg_zoom = zoom_pos;
720 _last_zoomchg_focus = focus_pos;
721
722 if (io_control (RK_VIDIOC_ZOOM_SET_POSITION, &set_zoom) < 0) {
723 LOGE_CAMHW_SUBM(LENS_SUBM, "set zoom position failed");
724 return XCAM_RETURN_ERROR_IOCTL;
725 }
726
727 if (io_control (RK_VIDIOC_ZOOM_TIMEINFO, &zoomtim) < 0) {
728 LOGE_CAMHW_SUBM(LENS_SUBM, "get zoom timeinfo failed");
729 _mutex.lock();
730 zoomtim = _zoom_tim;
731 zoomtim.vcm_end_t.tv_sec += 1;
732 _mutex.unlock();
733 }
734
735 if (io_control (RK_VIDIOC_VCM_TIMEINFO, &focustim) < 0) {
736 LOGE_CAMHW_SUBM(LENS_SUBM, "get focus timeinfo failed");
737 _mutex.lock();
738 focustim = _focus_tim;
739 focustim.vcm_end_t.tv_sec += 1;
740 _mutex.unlock();
741 }
742
743 time0 = zoomtim.vcm_end_t.tv_sec * 1000 + zoomtim.vcm_end_t.tv_usec / 1000;
744 time1 = focustim.vcm_end_t.tv_sec * 1000 + focustim.vcm_end_t.tv_usec / 1000;
745 if (time1 > time0)
746 zoomtim = focustim;
747
748 _mutex.lock();
749 if (is_update_time) {
750 _zoom_tim = zoomtim;
751 }
752 _zoom_pos = zoom_pos;
753 _focus_pos = focus_pos;
754 _mutex.unlock();
755
756 time0 = _zoom_tim.vcm_end_t.tv_sec * 1000 + _zoom_tim.vcm_end_t.tv_usec / 1000;
757 LOGD_CAMHW_SUBM(LENS_SUBM, "zoom_pos %d, focus_pos %d, zoom focus move end time %ld, is_need_zoom_reback %d, is_need_focus_reback %d, is_update_time %d",
758 zoom_pos, focus_pos, time0, set_zoom.is_need_zoom_reback, set_zoom.is_need_focus_reback, is_update_time);
759 }
760
761 EXIT_CAMHW_FUNCTION();
762 return XCAM_RETURN_NO_ERROR;
763 }
764
765
766 XCamReturn
setZoomFocusParamsSync(SmartPtr<rk_aiq_focus_params_t> attrPtr,bool is_update_time)767 LensHw::setZoomFocusParamsSync(SmartPtr<rk_aiq_focus_params_t> attrPtr, bool is_update_time)
768 {
769 ENTER_CAMHW_FUNCTION();
770 struct rk_cam_vcm_tim zoomtim, focustim;
771 struct rk_cam_set_zoom set_zoom;
772 struct v4l2_control control;
773 unsigned long time0, time1;
774 int zoom_pos = 0, focus_pos = 0;
775
776 #ifdef DISABLE_ZOOM_FOCUS
777 return XCAM_RETURN_NO_ERROR;
778 #endif
779
780 if (!_zoom_enable || !_focus_enable) {
781 LOGE_CAMHW_SUBM(LENS_SUBM, "zoom or focus is not supported");
782 return XCAM_RETURN_NO_ERROR;
783 }
784
785 if (!attrPtr->lens_pos_valid && !attrPtr->zoom_pos_valid) {
786 return XCAM_RETURN_NO_ERROR;
787 }
788
789 xcam_mem_clear (set_zoom);
790 if (attrPtr->lens_pos_valid || attrPtr->zoom_pos_valid) {
791 set_zoom.setzoom_cnt = attrPtr->next_pos_num;
792 set_zoom.is_need_zoom_reback = false;
793 set_zoom.is_need_focus_reback = false;
794 for (unsigned int i = 0; i < set_zoom.setzoom_cnt; i++) {
795 zoom_pos = attrPtr->next_zoom_pos[i];
796 focus_pos = attrPtr->next_lens_pos[i];
797
798 if (zoom_pos < _zoom_query.minimum)
799 zoom_pos = _zoom_query.minimum;
800 if (zoom_pos > _zoom_query.maximum)
801 zoom_pos = _zoom_query.maximum;
802
803 if (focus_pos < _focus_query.minimum)
804 focus_pos = _focus_query.minimum;
805 if (focus_pos > _focus_query.maximum)
806 focus_pos = _focus_query.maximum;
807
808 set_zoom.zoom_pos[i].zoom_pos = zoom_pos;
809 set_zoom.zoom_pos[i].focus_pos = focus_pos;
810 LOGD_CAMHW_SUBM(LENS_SUBM, "i %d, zoom_pos %d, focus_pos %d\n", i, zoom_pos, focus_pos);
811 }
812
813 if (io_control (RK_VIDIOC_ZOOM_SET_POSITION, &set_zoom) < 0) {
814 LOGE_CAMHW_SUBM(LENS_SUBM, "set zoom position failed");
815 return XCAM_RETURN_ERROR_IOCTL;
816 }
817
818 if (io_control (RK_VIDIOC_ZOOM_TIMEINFO, &zoomtim) < 0) {
819 LOGE_CAMHW_SUBM(LENS_SUBM, "get zoom timeinfo failed");
820 _mutex.lock();
821 zoomtim = _zoom_tim;
822 zoomtim.vcm_end_t.tv_sec += 1;
823 _mutex.unlock();
824 }
825
826 if (io_control (RK_VIDIOC_VCM_TIMEINFO, &focustim) < 0) {
827 LOGE_CAMHW_SUBM(LENS_SUBM, "get focus timeinfo failed");
828 _mutex.lock();
829 focustim = _focus_tim;
830 focustim.vcm_end_t.tv_sec += 1;
831 _mutex.unlock();
832 }
833
834 time0 = zoomtim.vcm_end_t.tv_sec * 1000 + zoomtim.vcm_end_t.tv_usec / 1000;
835 time1 = focustim.vcm_end_t.tv_sec * 1000 + focustim.vcm_end_t.tv_usec / 1000;
836 if (time1 > time0)
837 zoomtim = focustim;
838
839 _mutex.lock();
840 if (is_update_time) {
841 _zoom_tim = zoomtim;
842 }
843 _zoom_pos = zoom_pos;
844 _focus_pos = focus_pos;
845 _mutex.unlock();
846
847 time0 = _zoom_tim.vcm_end_t.tv_sec * 1000 + _zoom_tim.vcm_end_t.tv_usec / 1000;
848 LOGD_CAMHW_SUBM(LENS_SUBM, "zoom_pos %d, focus_pos %d, zoom focus move end time %ld, is_need_zoom_reback %d, is_need_focus_reback %d, is_update_time %d",
849 zoom_pos, focus_pos, time0, set_zoom.is_need_zoom_reback, set_zoom.is_need_focus_reback, is_update_time);
850 }
851
852 EXIT_CAMHW_FUNCTION();
853 return XCAM_RETURN_NO_ERROR;
854 }
855
856 XCamReturn
setZoomFocusParams(SmartPtr<RkAiqFocusParamsProxy> & focus_params)857 LensHw::setZoomFocusParams(SmartPtr<RkAiqFocusParamsProxy>& focus_params)
858 {
859 ENTER_CAMHW_FUNCTION();
860 SmartLock locker (_mutex);
861 rk_aiq_focus_params_t* p_focus = &focus_params->data()->result;
862 int zoom_pos = 0, focus_pos = 0;
863
864 if (!_zoom_enable || !_focus_enable) {
865 LOGE_CAMHW_SUBM(LENS_SUBM, "zoom or focus is not supported");
866 return XCAM_RETURN_NO_ERROR;
867 }
868
869 if (!_active)
870 start_internal();
871
872 #ifdef DISABLE_ZOOM_FOCUS
873 return XCAM_RETURN_NO_ERROR;
874 #endif
875
876 SmartPtr<rk_aiq_focus_params_t> attrPtr = new rk_aiq_focus_params_t;
877
878 memset(attrPtr.ptr(), 0, sizeof(rk_aiq_focus_params_t));
879 attrPtr->zoomfocus_modifypos = false;
880 attrPtr->focus_correction = false;
881 attrPtr->zoom_correction = false;
882 attrPtr->lens_pos_valid = p_focus->lens_pos_valid;
883 attrPtr->zoom_pos_valid = p_focus->zoom_pos_valid;
884 attrPtr->send_zoom_reback = p_focus->send_zoom_reback;
885 attrPtr->send_focus_reback = p_focus->send_focus_reback;
886 attrPtr->end_zoom_chg = p_focus->end_zoom_chg;
887 attrPtr->focus_noreback = false;
888 if (attrPtr->lens_pos_valid || attrPtr->zoom_pos_valid) {
889 attrPtr->next_pos_num = p_focus->next_pos_num;
890 for (int i = 0; i < attrPtr->next_pos_num; i++) {
891 zoom_pos = p_focus->next_zoom_pos[i];
892 focus_pos = p_focus->next_lens_pos[i];
893
894 if (zoom_pos < _zoom_query.minimum)
895 zoom_pos = _zoom_query.minimum;
896 if (zoom_pos > _zoom_query.maximum)
897 zoom_pos = _zoom_query.maximum;
898
899 if (focus_pos < _focus_query.minimum)
900 focus_pos = _focus_query.minimum;
901 if (focus_pos > _focus_query.maximum)
902 focus_pos = _focus_query.maximum;
903
904 attrPtr->next_zoom_pos[i] = zoom_pos;
905 attrPtr->next_lens_pos[i] = focus_pos;
906 }
907
908 LOGD_CAMHW_SUBM(LENS_SUBM, "zoom_pos %d, focus_pos %d", zoom_pos, focus_pos);
909 _lenshw_thd->push_attr(attrPtr);
910 } else if (attrPtr->send_zoom_reback || attrPtr->send_focus_reback) {
911 LOGD_CAMHW_SUBM(LENS_SUBM, "send reback zoom_pos %d, focus_pos %d", _zoom_pos, _focus_pos);
912 _lenshw_thd->push_attr(attrPtr);
913 } else if (attrPtr->end_zoom_chg) {
914 LOGD_CAMHW_SUBM(LENS_SUBM, "end_zoom_chg zoom_pos %d, focus_pos %d, next_pos_num %d",
915 _zoom_pos, _focus_pos, attrPtr->next_pos_num);
916 _lenshw_thd->push_attr(attrPtr);
917 }
918
919 EXIT_CAMHW_FUNCTION();
920 return XCAM_RETURN_NO_ERROR;
921 }
922
923 XCamReturn
getFocusParams(int * position)924 LensHw::getFocusParams(int* position)
925 {
926 ENTER_CAMHW_FUNCTION();
927 SmartLock locker (_mutex);
928 struct v4l2_control control;
929
930 if (!_focus_enable) {
931 LOGE_CAMHW_SUBM(LENS_SUBM, "focus is not supported");
932 return XCAM_RETURN_ERROR_FAILED;
933 }
934
935 xcam_mem_clear (control);
936 control.id = V4L2_CID_FOCUS_ABSOLUTE;
937
938 if (io_control (VIDIOC_G_CTRL, &control) < 0) {
939 LOGE_CAMHW_SUBM(LENS_SUBM, "get focus result failed");
940 return XCAM_RETURN_ERROR_IOCTL;
941 }
942 *position = control.value;
943 LOGD_CAMHW_SUBM(LENS_SUBM, "|||get focus result: %d, control.value %d", *position, control.value);
944
945 _focus_pos = *position;
946
947 EXIT_CAMHW_FUNCTION();
948 return XCAM_RETURN_NO_ERROR;
949 }
950
951 XCamReturn
getZoomParams(int * position)952 LensHw::getZoomParams(int* position)
953 {
954 ENTER_CAMHW_FUNCTION();
955 SmartLock locker (_mutex);
956 //struct v4l2_control control;
957
958 if (!_zoom_enable) {
959 LOGE_CAMHW_SUBM(LENS_SUBM, "zoom is not supported");
960 return XCAM_RETURN_ERROR_FAILED;
961 }
962 #if 0
963 xcam_mem_clear (control);
964 control.id = V4L2_CID_ZOOM_ABSOLUTE;
965
966 if (io_control (VIDIOC_G_CTRL, &control) < 0) {
967 LOGE_CAMHW_SUBM(LENS_SUBM, "get zoom result failed");
968 return XCAM_RETURN_ERROR_IOCTL;
969 }
970 *position = control.value;
971 LOGD_CAMHW_SUBM(LENS_SUBM, "|||get zoom result: %d, control.value %d", *position, control.value);
972
973 _zoom_pos = *position;
974 #else
975 *position = _zoom_pos;
976 #endif
977 LOGD_CAMHW_SUBM(LENS_SUBM, "*position %d", *position);
978
979 EXIT_CAMHW_FUNCTION();
980 return XCAM_RETURN_NO_ERROR;
981 }
982
983 XCamReturn
FocusCorrectionSync()984 LensHw::FocusCorrectionSync()
985 {
986 ENTER_CAMHW_FUNCTION();
987 int correction = 0;
988
989 if (!_focus_enable) {
990 LOGE_CAMHW_SUBM(LENS_SUBM, "focus is not supported");
991 return XCAM_RETURN_ERROR_FAILED;
992 }
993
994 LOGD_CAMHW_SUBM(LENS_SUBM, "focus_correction start");
995 if (io_control (RK_VIDIOC_FOCUS_CORRECTION, &correction) < 0) {
996 LOGE_CAMHW_SUBM(LENS_SUBM, "focus correction failed");
997 return XCAM_RETURN_ERROR_IOCTL;
998 }
999
1000 _mutex.lock();
1001 _focus_pos = 0;
1002 _focus_correction = false;
1003 _mutex.unlock();
1004 LOGD_CAMHW_SUBM(LENS_SUBM, "focus_correction end");
1005
1006 EXIT_CAMHW_FUNCTION();
1007 return XCAM_RETURN_NO_ERROR;
1008 }
1009
1010 XCamReturn
FocusCorrection()1011 LensHw::FocusCorrection()
1012 {
1013 ENTER_CAMHW_FUNCTION();
1014 SmartLock locker (_mutex);
1015 unsigned long end_time;
1016
1017 if (!_focus_enable) {
1018 LOGE_CAMHW_SUBM(LENS_SUBM, "focus is not supported");
1019 return XCAM_RETURN_NO_ERROR;
1020 }
1021
1022 if (!_active)
1023 start_internal();
1024
1025 #ifdef DISABLE_ZOOM_FOCUS
1026 return XCAM_RETURN_NO_ERROR;
1027 #endif
1028
1029 SmartPtr<rk_aiq_focus_params_t> attrPtr = new rk_aiq_focus_params_t;
1030
1031 attrPtr->zoomfocus_modifypos = false;
1032 attrPtr->focus_correction = true;
1033 attrPtr->zoom_correction = false;
1034
1035 LOGD_CAMHW_SUBM(LENS_SUBM, "focus_correction");
1036 _focus_correction = true;
1037 _lenshw_thd->push_attr(attrPtr);
1038
1039 EXIT_CAMHW_FUNCTION();
1040 return XCAM_RETURN_NO_ERROR;
1041 }
1042
1043 XCamReturn
ZoomCorrectionSync()1044 LensHw::ZoomCorrectionSync()
1045 {
1046 ENTER_CAMHW_FUNCTION();
1047 int correction = 0;
1048
1049 if (!_zoom_enable) {
1050 LOGE_CAMHW_SUBM(LENS_SUBM, "zoom is not supported");
1051 return XCAM_RETURN_ERROR_FAILED;
1052 }
1053
1054 LOGD_CAMHW_SUBM(LENS_SUBM, "zoom_correction start");
1055 if (io_control (RK_VIDIOC_ZOOM_CORRECTION, &correction) < 0) {
1056 LOGE_CAMHW_SUBM(LENS_SUBM, "zoom correction failed");
1057 return XCAM_RETURN_ERROR_IOCTL;
1058 }
1059
1060 _mutex.lock();
1061 _zoom_pos = 0;
1062 _zoom_correction = false;
1063 _mutex.unlock();
1064 LOGD_CAMHW_SUBM(LENS_SUBM, "zoom_correction end");
1065
1066 EXIT_CAMHW_FUNCTION();
1067 return XCAM_RETURN_NO_ERROR;
1068 }
1069
1070 XCamReturn
ZoomCorrection()1071 LensHw::ZoomCorrection()
1072 {
1073 ENTER_CAMHW_FUNCTION();
1074 SmartLock locker (_mutex);
1075 unsigned long end_time;
1076
1077 if (!_zoom_enable) {
1078 LOGE_CAMHW_SUBM(LENS_SUBM, "focus is not supported");
1079 return XCAM_RETURN_NO_ERROR;
1080 }
1081
1082 if (!_active)
1083 start_internal();
1084
1085 #ifdef DISABLE_ZOOM_FOCUS
1086 return XCAM_RETURN_NO_ERROR;
1087 #endif
1088
1089 SmartPtr<rk_aiq_focus_params_t> attrPtr = new rk_aiq_focus_params_t;
1090
1091 attrPtr->zoomfocus_modifypos = false;
1092 attrPtr->zoom_correction = true;
1093 attrPtr->focus_correction = false;
1094
1095 LOGD_CAMHW_SUBM(LENS_SUBM, "zoom_correction");
1096 _zoom_correction = true;
1097 _lenshw_thd1->push_attr(attrPtr);
1098
1099 EXIT_CAMHW_FUNCTION();
1100 return XCAM_RETURN_NO_ERROR;
1101 }
1102
1103 XCamReturn
ZoomFocusModifyPositionSync(SmartPtr<rk_aiq_focus_params_t> attrPtr)1104 LensHw::ZoomFocusModifyPositionSync(SmartPtr<rk_aiq_focus_params_t> attrPtr)
1105 {
1106 ENTER_CAMHW_FUNCTION();
1107 struct rk_cam_modify_pos modify_pos;
1108
1109 if (!_zoom_enable) {
1110 LOGE_CAMHW_SUBM(LENS_SUBM, "zoom is not supported");
1111 return XCAM_RETURN_ERROR_FAILED;
1112 }
1113
1114 if (!attrPtr->use_manual) {
1115 modify_pos.zoom_pos = attrPtr->auto_zoompos;
1116 modify_pos.zoom1_pos = attrPtr->auto_zoompos;
1117 modify_pos.focus_pos = attrPtr->auto_focpos;
1118 } else {
1119 modify_pos.zoom_pos = attrPtr->manual_zoompos;
1120 modify_pos.zoom1_pos = attrPtr->manual_zoompos;
1121 modify_pos.focus_pos = attrPtr->manual_focpos;
1122 }
1123 if (io_control (RK_VIDIOC_MODIFY_POSITION, &modify_pos) < 0) {
1124 LOGE_CAMHW_SUBM(LENS_SUBM, "zoom focus modify position failed");
1125 return XCAM_RETURN_ERROR_IOCTL;
1126 }
1127
1128 _zoom_pos = modify_pos.zoom_pos;
1129 _focus_pos = modify_pos.focus_pos;
1130 _last_zoomchg_zoom = attrPtr->auto_zoompos;
1131 _last_zoomchg_focus = attrPtr->auto_focpos;
1132
1133 LOGD_CAMHW_SUBM(LENS_SUBM, "zoom focus modify position, use_manual %d, zoom_pos %d, focus_pos %d",
1134 attrPtr->use_manual, modify_pos.zoom_pos, modify_pos.focus_pos);
1135
1136 EXIT_CAMHW_FUNCTION();
1137 return XCAM_RETURN_NO_ERROR;
1138 }
1139
1140 XCamReturn
ZoomFocusModifyPosition(SmartPtr<RkAiqFocusParamsProxy> & focus_params)1141 LensHw::ZoomFocusModifyPosition(SmartPtr<RkAiqFocusParamsProxy>& focus_params)
1142 {
1143 ENTER_CAMHW_FUNCTION();
1144 SmartLock locker (_mutex);
1145 rk_aiq_focus_params_t* p_focus = &focus_params->data()->result;
1146 unsigned long end_time;
1147
1148 if (!_zoom_enable) {
1149 LOGE_CAMHW_SUBM(LENS_SUBM, "focus is not supported");
1150 return XCAM_RETURN_NO_ERROR;
1151 }
1152
1153 if (!_active)
1154 start_internal();
1155
1156 #ifdef DISABLE_ZOOM_FOCUS
1157 return XCAM_RETURN_NO_ERROR;
1158 #endif
1159
1160 SmartPtr<rk_aiq_focus_params_t> attrPtr = new rk_aiq_focus_params_t;
1161
1162 attrPtr->zoomfocus_modifypos = true;
1163 attrPtr->zoom_correction = false;
1164 attrPtr->focus_correction = false;
1165 attrPtr->use_manual = p_focus->use_manual;
1166 attrPtr->auto_focpos = p_focus->auto_focpos;
1167 attrPtr->auto_zoompos = p_focus->auto_zoompos;
1168 attrPtr->manual_focpos = p_focus->manual_focpos;
1169 attrPtr->manual_zoompos = p_focus->manual_zoompos;
1170
1171 _lenshw_thd->push_attr(attrPtr);
1172
1173 EXIT_CAMHW_FUNCTION();
1174 return XCAM_RETURN_NO_ERROR;
1175 }
1176
1177 XCamReturn
handle_sof(int64_t time,uint32_t frameid)1178 LensHw::handle_sof(int64_t time, uint32_t frameid)
1179 {
1180 ENTER_CAMHW_FUNCTION();
1181 //SmartLock locker (_mutex);
1182
1183 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1184 int idx;
1185
1186 idx = (_rec_sof_idx + 1) % LENSHW_RECORD_SOF_NUM;
1187 _frame_sequence[idx] = frameid;
1188 _frame_time[idx] = time;
1189 _rec_sof_idx = idx;
1190
1191 LOGD_CAMHW_SUBM(LENS_SUBM, "%s: frm_id %u, time %lld\n", __func__, frameid, time);
1192
1193 EXIT_CAMHW_FUNCTION();
1194 return ret;
1195 }
1196
1197 XCamReturn
setLowPassFv(uint32_t sub_shp4_4[RKAIQ_RAWAF_SUMDATA_NUM],uint32_t sub_shp8_8[RKAIQ_RAWAF_SUMDATA_NUM],uint32_t high_light[RKAIQ_RAWAF_SUMDATA_NUM],uint32_t high_light2[RKAIQ_RAWAF_SUMDATA_NUM],uint32_t frameid)1198 LensHw::setLowPassFv(uint32_t sub_shp4_4[RKAIQ_RAWAF_SUMDATA_NUM], uint32_t sub_shp8_8[RKAIQ_RAWAF_SUMDATA_NUM],
1199 uint32_t high_light[RKAIQ_RAWAF_SUMDATA_NUM], uint32_t high_light2[RKAIQ_RAWAF_SUMDATA_NUM], uint32_t frameid)
1200 {
1201 ENTER_CAMHW_FUNCTION();
1202 //SmartLock locker (_mutex);
1203
1204 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1205 int idx;
1206 int64_t lowPassFv4_4, lowPassFv8_8, lowPassLight;
1207
1208 if (!_active)
1209 start_internal();
1210
1211 idx = (_rec_lowfv_idx + 1) % LENSHW_RECORD_LOWPASSFV_NUM;
1212 _lowfv_seq[idx] = frameid;
1213 memcpy(&_lowfv_fv4_4[idx], sub_shp4_4, sizeof(_lowfv_fv4_4[idx]));
1214 memcpy(&_lowfv_fv8_8[idx], sub_shp8_8, sizeof(_lowfv_fv8_8[idx]));
1215 memcpy(&_lowfv_highlht[idx], high_light, sizeof(_lowfv_highlht[idx]));
1216 memcpy(&_lowfv_highlht2[idx], high_light2, sizeof(_lowfv_highlht2[idx]));
1217 _rec_lowfv_idx = idx;
1218
1219 lowPassFv4_4 = 0;
1220 lowPassFv8_8 = 0;
1221 lowPassLight = 0;
1222 for (int i = 0; i < RKAIQ_RAWAF_SUMDATA_NUM; i++) {
1223 lowPassFv4_4 += sub_shp4_4[i];
1224 lowPassFv8_8 += sub_shp8_8[i];
1225 lowPassLight += high_light[i];
1226 }
1227
1228 LOGD_CAMHW_SUBM(LENS_SUBM, "%s: frm_id %d, lowPassFv4_4 %lld, lowPassFv8_8 %lld, lowPassLight %lld\n",
1229 __func__, frameid, lowPassFv4_4, lowPassFv8_8, lowPassLight);
1230
1231 EXIT_CAMHW_FUNCTION();
1232 return ret;
1233 }
1234
1235 XCamReturn
getIrisInfoParams(SmartPtr<RkAiqIrisParamsProxy> & irisParams,uint32_t frame_id)1236 LensHw::getIrisInfoParams(SmartPtr<RkAiqIrisParamsProxy>& irisParams, uint32_t frame_id)
1237 {
1238 ENTER_CAMHW_FUNCTION();
1239 //SmartLock locker (_mutex);
1240
1241 int i;
1242
1243 irisParams = NULL;
1244 if (_irisInfoPool->has_free_items()) {
1245 irisParams = (SmartPtr<RkAiqIrisParamsProxy>)_irisInfoPool->get_item();
1246 } else {
1247 LOGE_CAMHW_SUBM(LENS_SUBM, "%s: no free params buffer!\n", __FUNCTION__);
1248 return XCAM_RETURN_ERROR_MEM;
1249 }
1250
1251 for (i = 0; i < LENSHW_RECORD_SOF_NUM; i++) {
1252 if (frame_id == _frame_sequence[i])
1253 break;
1254 }
1255
1256 //Piris
1257 irisParams->data()->PIris.StartTim = _piris_tim.motor_start_t;
1258 irisParams->data()->PIris.EndTim = _piris_tim.motor_end_t;
1259 irisParams->data()->PIris.laststep = _last_piris_step;
1260 irisParams->data()->PIris.step = _piris_step;
1261
1262 //DCiris
1263
1264 if (i < LENSHW_RECORD_SOF_NUM) {
1265 irisParams->data()->sofTime = _frame_time[i];
1266 } else {
1267 LOGE_CAMHW_SUBM(LENS_SUBM, "%s: frame_id %u, can not find sof time!\n", __FUNCTION__, frame_id);
1268 return XCAM_RETURN_ERROR_PARAM;
1269 }
1270
1271 LOGD_CAMHW_SUBM(LENS_SUBM, "%s: frm_id %u, time %lld\n", __func__, frame_id, irisParams->data()->sofTime);
1272
1273 EXIT_CAMHW_FUNCTION();
1274
1275 return XCAM_RETURN_NO_ERROR;
1276 }
1277
1278 XCamReturn
getAfInfoParams(SmartPtr<RkAiqAfInfoProxy> & afInfo,uint32_t frame_id)1279 LensHw::getAfInfoParams(SmartPtr<RkAiqAfInfoProxy>& afInfo, uint32_t frame_id)
1280 {
1281 ENTER_CAMHW_FUNCTION();
1282 SmartLock locker (_mutex);
1283
1284 int i;
1285
1286 afInfo = NULL;
1287 if (_afInfoPool->has_free_items()) {
1288 afInfo = (SmartPtr<RkAiqAfInfoProxy>)_afInfoPool->get_item();
1289 } else {
1290 LOGE_CAMHW_SUBM(LENS_SUBM, "%s: no free params buffer!\n", __FUNCTION__);
1291 return XCAM_RETURN_ERROR_MEM;
1292 }
1293
1294 for (i = 0; i < LENSHW_RECORD_SOF_NUM; i++) {
1295 if (frame_id == _frame_sequence[i])
1296 break;
1297 }
1298
1299 afInfo->data()->focusStartTim = _focus_tim.vcm_start_t;
1300 afInfo->data()->focusEndTim = _focus_tim.vcm_end_t;
1301 afInfo->data()->zoomStartTim = _zoom_tim.vcm_start_t;
1302 afInfo->data()->zoomEndTim = _zoom_tim.vcm_end_t;
1303 afInfo->data()->focusCode = _focus_pos;
1304 afInfo->data()->zoomCode = _zoom_pos;
1305 afInfo->data()->angleZ = _angleZ;
1306 afInfo->data()->zoomCorrection = _zoom_correction;
1307 afInfo->data()->focusCorrection = _focus_correction;
1308 if (i < LENSHW_RECORD_SOF_NUM) {
1309 afInfo->data()->sofTime = _frame_time[i];
1310 } else {
1311 LOGE_CAMHW_SUBM(LENS_SUBM, "%s: frame_id %d, can not find sof time!\n", __FUNCTION__, frame_id);
1312 return XCAM_RETURN_ERROR_PARAM;
1313 }
1314
1315 for (i = 0; i < LENSHW_RECORD_LOWPASSFV_NUM; i++) {
1316 if (frame_id == _lowfv_seq[i] + 1)
1317 break;
1318 }
1319
1320 if (i < LENSHW_RECORD_SOF_NUM) {
1321 afInfo->data()->lowPassId = _lowfv_seq[i];
1322 memcpy(afInfo->data()->lowPassFv4_4,
1323 _lowfv_fv4_4[i], RKAIQ_RAWAF_SUMDATA_NUM * sizeof(int32_t));
1324 memcpy(afInfo->data()->lowPassFv8_8,
1325 _lowfv_fv8_8[i], RKAIQ_RAWAF_SUMDATA_NUM * sizeof(int32_t));
1326 memcpy(afInfo->data()->lowPassHighLht,
1327 _lowfv_highlht[i], RKAIQ_RAWAF_SUMDATA_NUM * sizeof(int32_t));
1328 memcpy(afInfo->data()->lowPassHighLht2,
1329 _lowfv_highlht2[i], RKAIQ_RAWAF_SUMDATA_NUM * sizeof(int32_t));
1330 } else {
1331 afInfo->data()->lowPassId = 0;
1332 memset(afInfo->data()->lowPassFv4_4, 0, RKAIQ_RAWAF_SUMDATA_NUM * sizeof(int32_t));
1333 memset(afInfo->data()->lowPassFv8_8, 0, RKAIQ_RAWAF_SUMDATA_NUM * sizeof(int32_t));
1334 memset(afInfo->data()->lowPassHighLht, 0, RKAIQ_RAWAF_SUMDATA_NUM * sizeof(int32_t));
1335 memset(afInfo->data()->lowPassHighLht2, 0, RKAIQ_RAWAF_SUMDATA_NUM * sizeof(int32_t));
1336 }
1337
1338 LOGD_CAMHW_SUBM(LENS_SUBM, "%s: frm_id %u, time %lld, lowPassFv4_4[0] %d, lowPassId %d\n",
1339 __func__, frame_id, afInfo->data()->sofTime, afInfo->data()->lowPassFv4_4[0], afInfo->data()->lowPassId);
1340
1341
1342 LOGD_CAMHW_SUBM(LENS_SUBM, "%s: frm_id %u, time %lld\n", __func__, frame_id, afInfo->data()->sofTime);
1343
1344 EXIT_CAMHW_FUNCTION();
1345
1346 return XCAM_RETURN_NO_ERROR;
1347 }
1348
1349 XCamReturn
setAngleZ(float angleZ)1350 LensHw::setAngleZ(float angleZ)
1351 {
1352 ENTER_CAMHW_FUNCTION();
1353 SmartLock locker (_mutex);
1354
1355 _angleZ = angleZ;
1356 EXIT_CAMHW_FUNCTION();
1357
1358 return XCAM_RETURN_NO_ERROR;
1359 }
1360
loop()1361 bool LensHwHelperThd::loop()
1362 {
1363 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1364 ENTER_CAMHW_FUNCTION();
1365
1366 const static int32_t timeout = -1;
1367 SmartPtr<rk_aiq_focus_params_t> attrib = mAttrQueue.pop (timeout);
1368 int pos;
1369
1370 if (!attrib.ptr()) {
1371 LOGE_CAMHW_SUBM(LENS_SUBM, "LensHwHelperThd got empty attrib, stop thread");
1372 return false;
1373 }
1374
1375 if (attrib->zoomfocus_modifypos) {
1376 mLensHw->ZoomFocusModifyPositionSync(attrib);
1377 } else if (attrib->focus_correction) {
1378 mLensHw->FocusCorrectionSync();
1379 } else if (attrib->zoom_correction) {
1380 mLensHw->ZoomCorrectionSync();
1381 } else if (attrib->lens_pos_valid == 1 && attrib->zoom_pos_valid == 0) {
1382 if (attrib->end_zoom_chg) {
1383 ret = mLensHw->endZoomChgSync(attrib, true);
1384 }
1385 ret = mLensHw->setFocusParamsSync(attrib->next_lens_pos[0], true, attrib->focus_noreback);
1386 } else {
1387 if (attrib->send_zoom_reback == 1 || attrib->send_focus_reback == 1) {
1388 mLensHw->setZoomFocusRebackSync(attrib, false);
1389 }
1390 if (attrib->end_zoom_chg) {
1391 ret = mLensHw->setZoomFocusParamsSync(attrib, false);
1392 ret = mLensHw->endZoomChgSync(attrib, true);
1393 } else {
1394 ret = mLensHw->setZoomFocusParamsSync(attrib, true);
1395 }
1396 }
1397 if (ret == XCAM_RETURN_NO_ERROR)
1398 return true;
1399
1400 LOGE_CAMHW_SUBM(LENS_SUBM, "LensHwHelperThd failed to run command!");
1401
1402 EXIT_CAMHW_FUNCTION();
1403
1404 return false;
1405 }
1406
1407 } //namespace RkCam
1408