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 "MediaInfo.h"
19
20 namespace RkRawStream {
21
pixFmt2Bpp(uint32_t pixFmt)22 int8_t pixFmt2Bpp(uint32_t pixFmt)
23 {
24 int8_t bpp;
25 switch (pixFmt) {
26 case V4L2_PIX_FMT_SBGGR8:
27 case V4L2_PIX_FMT_SGBRG8:
28 case V4L2_PIX_FMT_SGRBG8:
29 case V4L2_PIX_FMT_SRGGB8:
30 bpp = 8;
31 break;
32 case V4L2_PIX_FMT_SBGGR10:
33 case V4L2_PIX_FMT_SGBRG10:
34 case V4L2_PIX_FMT_SGRBG10:
35 case V4L2_PIX_FMT_SRGGB10:
36 bpp = 10;
37 break;
38 case V4L2_PIX_FMT_SBGGR12:
39 case V4L2_PIX_FMT_SGBRG12:
40 case V4L2_PIX_FMT_SGRBG12:
41 case V4L2_PIX_FMT_SRGGB12:
42 bpp = 12;
43 break;
44 case V4L2_PIX_FMT_SBGGR14:
45 case V4L2_PIX_FMT_SGBRG14:
46 case V4L2_PIX_FMT_SGRBG14:
47 case V4L2_PIX_FMT_SRGGB14:
48 bpp = 14;
49 break;
50 case V4L2_PIX_FMT_SBGGR16:
51 case V4L2_PIX_FMT_SGBRG16:
52 case V4L2_PIX_FMT_SGRBG16:
53 case V4L2_PIX_FMT_SRGGB16:
54 bpp = 16;
55 break;
56 default:
57 return -1;
58 }
59
60 return bpp;
61 }
62
MediaInfo()63 MediaInfo::MediaInfo (){
64 LOGD_RKSTREAM ("MediaInfo constructed.");
65 }
66
~MediaInfo()67 MediaInfo::~MediaInfo(){
68 LOGD_RKSTREAM ("~MediaInfo destructed");
69 }
70
get_isp_ver(rk_aiq_isp_hw_info_t * hw_info)71 static XCamReturn get_isp_ver(rk_aiq_isp_hw_info_t *hw_info) {
72 XCamReturn ret = XCAM_RETURN_NO_ERROR;
73 struct v4l2_capability cap;
74 V4l2Device vdev(hw_info->isp_info[0].stats_path);
75
76
77 ret = vdev.open();
78 if (ret != XCAM_RETURN_NO_ERROR) {
79 LOGE_RKSTREAM("failed to open dev (%s)", hw_info->isp_info[0].stats_path);
80 return XCAM_RETURN_ERROR_FAILED;
81 }
82
83 if (vdev.query_cap(cap) == XCAM_RETURN_NO_ERROR) {
84 char *p;
85 p = strrchr((char*)cap.driver, '_');
86 if (p == NULL) {
87 ret = XCAM_RETURN_ERROR_FAILED;
88 goto out;
89 }
90
91 if (*(p + 1) != 'v') {
92 ret = XCAM_RETURN_ERROR_FAILED;
93 goto out;
94 }
95
96 hw_info->hw_ver_info.isp_ver = atoi(p + 2);
97 //awb/aec version?
98 vdev.close();
99 return XCAM_RETURN_NO_ERROR;
100 } else {
101 ret = XCAM_RETURN_ERROR_FAILED;
102 goto out;
103 }
104
105 out:
106 vdev.close();
107 LOGE_RKSTREAM("get isp version failed !");
108 return ret;
109 }
110
get_sensor_caps(rk_sensor_full_info_t * sensor_info)111 static XCamReturn get_sensor_caps(rk_sensor_full_info_t *sensor_info) {
112 struct v4l2_subdev_frame_size_enum fsize_enum;
113 struct v4l2_subdev_mbus_code_enum code_enum;
114 std::vector<uint32_t> formats;
115 rk_frame_fmt_t frameSize;
116 XCamReturn ret = XCAM_RETURN_NO_ERROR;
117
118 V4l2SubDevice vdev(sensor_info->device_name.c_str());
119 ret = vdev.open();
120 if (ret != XCAM_RETURN_NO_ERROR) {
121 LOGE_RKSTREAM("failed to open dev (%s)", sensor_info->device_name.c_str());
122 return XCAM_RETURN_ERROR_FAILED;
123 }
124 //get module info
125 struct rkmodule_inf *minfo = &(sensor_info->mod_info);
126 if(vdev.io_control(RKMODULE_GET_MODULE_INFO, minfo) < 0) {
127 LOGE_RKSTREAM("@%s %s: Get sensor module info failed", __FUNCTION__, sensor_info->device_name.c_str());
128 return XCAM_RETURN_ERROR_FAILED;
129 }
130 sensor_info->len_name = std::string(minfo->base.lens);
131
132 struct v4l2_subdev_frame_interval_enum fie;
133 memset(&fie, 0, sizeof(fie));
134 while(vdev.io_control(VIDIOC_SUBDEV_ENUM_FRAME_INTERVAL, &fie) == 0) {
135 frameSize.format = (rk_aiq_format_t)fie.code;
136 frameSize.width = fie.width;
137 frameSize.height = fie.height;
138 frameSize.fps = fie.interval.denominator / fie.interval.numerator;
139 frameSize.hdr_mode = fie.reserved[0];
140 sensor_info->frame_size.push_back(frameSize);
141 fie.index++;
142 }
143 if (fie.index == 0)
144 LOGE_RKSTREAM("@%s %s: Enum sensor frame interval failed", __FUNCTION__, sensor_info->device_name.c_str());
145 vdev.close();
146
147 return ret;
148 }
149
150 static XCamReturn
parse_module_info(rk_sensor_full_info_t * sensor_info)151 parse_module_info(rk_sensor_full_info_t *sensor_info)
152 {
153 // sensor entity name format SHOULD be like this:
154 // m00_b_ov13850 1-0010
155 std::string entity_name(sensor_info->sensor_name);
156
157 if (entity_name.empty())
158 return XCAM_RETURN_ERROR_SENSOR;
159
160 int parse_index = 0;
161
162 if (entity_name.at(parse_index) != 'm') {
163 LOGE_RKSTREAM("%d:parse sensor entity name %s error at %d, please check sensor driver !",
164 __LINE__, entity_name.c_str(), parse_index);
165 return XCAM_RETURN_ERROR_SENSOR;
166 }
167
168 std::string index_str = entity_name.substr (parse_index, 3);
169 sensor_info->module_index_str = index_str;
170
171 parse_index += 3;
172
173 if (entity_name.at(parse_index) != '_') {
174 LOGE_RKSTREAM("%d:parse sensor entity name %s error at %d, please check sensor driver !",
175 __LINE__, entity_name.c_str(), parse_index);
176 return XCAM_RETURN_ERROR_SENSOR;
177 }
178
179 parse_index++;
180
181 if (entity_name.at(parse_index) != 'b' &&
182 entity_name.at(parse_index) != 'f') {
183 LOGE_RKSTREAM("%d:parse sensor entity name %s error at %d, please check sensor driver !",
184 __LINE__, entity_name.c_str(), parse_index);
185 return XCAM_RETURN_ERROR_SENSOR;
186 }
187 sensor_info->phy_module_orient = entity_name.at(parse_index);
188
189 parse_index++;
190
191 if (entity_name.at(parse_index) != '_') {
192 LOGE_RKSTREAM("%d:parse sensor entity name %s error at %d, please check sensor driver !",
193 __LINE__, entity_name.c_str(), parse_index);
194 return XCAM_RETURN_ERROR_SENSOR;
195 }
196
197 parse_index++;
198
199 std::size_t real_name_end = std::string::npos;
200 if ((real_name_end = entity_name.find(' ')) == std::string::npos) {
201 LOGE_RKSTREAM("%d:parse sensor entity name %s error at %d, please check sensor driver !",
202 __LINE__, entity_name.c_str(), parse_index);
203 return XCAM_RETURN_ERROR_SENSOR;
204 }
205
206 std::string real_name_str = entity_name.substr(parse_index, real_name_end - parse_index);
207 sensor_info->module_real_sensor_name = real_name_str;
208
209 LOGI_RKSTREAM("%s:%d, real sensor name %s, module ori %c, module id %s",
210 __FUNCTION__, __LINE__, sensor_info->module_real_sensor_name.c_str(),
211 sensor_info->phy_module_orient, sensor_info->module_index_str.c_str());
212
213 return XCAM_RETURN_NO_ERROR;
214 }
215
216 static rk_aiq_ispp_t*
get_ispp_subdevs(struct media_device * device,const char * devpath,rk_aiq_ispp_t * ispp_info)217 get_ispp_subdevs(struct media_device *device, const char *devpath, rk_aiq_ispp_t* ispp_info)
218 {
219 media_entity *entity = NULL;
220 const char *entity_name = NULL;
221 int index = 0;
222
223 if(!device || !ispp_info || !devpath)
224 return NULL;
225
226 for(index = 0; index < MAX_CAM_NUM; index++) {
227 if (0 == strlen(ispp_info[index].media_dev_path))
228 break;
229 if (0 == strncmp(ispp_info[index].media_dev_path, devpath, sizeof(ispp_info[index].media_dev_path)-1)) {
230 LOGE_RKSTREAM("isp info of path %s exists!", devpath);
231 return &ispp_info[index];
232 }
233 }
234
235 if (index >= MAX_CAM_NUM)
236 return NULL;
237 #if defined(ISP_HW_V30)
238 // parse driver pattern: soc:rkisp0-vir0
239 int model_idx = -1;
240 char* rkispp = strstr(device->info.driver, "rkispp");
241 if (rkispp) {
242 int ispp_idx = atoi(rkispp + strlen("rkispp"));
243 char* vir = strstr(device->info.driver, "vir");
244 if (vir) {
245 int vir_idx = atoi(vir + strlen("vir"));
246 model_idx = ispp_idx * 4 + vir_idx;
247 }
248 }
249
250 if (model_idx == -1) {
251 LOGE_RKSTREAM("wrong ispp media driver info: %s", device->info.driver);
252 return NULL;
253 }
254
255 ispp_info[index].model_idx = model_idx;
256 #else
257
258 if (strcmp(device->info.model, "rkispp0") == 0 ||
259 strcmp(device->info.model, "rkispp") == 0)
260 ispp_info[index].model_idx = 0;
261 else if (strcmp(device->info.model, "rkispp1") == 0)
262 ispp_info[index].model_idx = 1;
263 else if (strcmp(device->info.model, "rkispp2") == 0)
264 ispp_info[index].model_idx = 2;
265 else if (strcmp(device->info.model, "rkispp3") == 0)
266 ispp_info[index].model_idx = 3;
267 else
268 ispp_info[index].model_idx = -1;
269 #endif
270 strncpy(ispp_info[index].media_dev_path, devpath, sizeof(ispp_info[index].media_dev_path)-1);
271
272 entity = media_get_entity_by_name(device, "rkispp_input_image", strlen("rkispp_input_image"));
273 if(entity) {
274 entity_name = media_entity_get_devname (entity);
275 if(entity_name) {
276 strncpy(ispp_info[index].pp_input_image_path, entity_name, sizeof(ispp_info[index].pp_input_image_path)-1);
277 }
278 }
279 entity = media_get_entity_by_name(device, "rkispp_m_bypass", strlen("rkispp_m_bypass"));
280 if(entity) {
281 entity_name = media_entity_get_devname (entity);
282 if(entity_name) {
283 strncpy(ispp_info[index].pp_m_bypass_path, entity_name, sizeof(ispp_info[index].pp_m_bypass_path)-1);
284 }
285 }
286 entity = media_get_entity_by_name(device, "rkispp_scale0", strlen("rkispp_scale0"));
287 if(entity) {
288 entity_name = media_entity_get_devname (entity);
289 if(entity_name) {
290 strncpy(ispp_info[index].pp_scale0_path, entity_name, sizeof(ispp_info[index].pp_scale0_path)-1);
291 }
292 }
293 entity = media_get_entity_by_name(device, "rkispp_scale1", strlen("rkispp_scale1"));
294 if(entity) {
295 entity_name = media_entity_get_devname (entity);
296 if(entity_name) {
297 strncpy(ispp_info[index].pp_scale1_path, entity_name, sizeof(ispp_info[index].pp_scale1_path)-1);
298 }
299 }
300 entity = media_get_entity_by_name(device, "rkispp_scale2", strlen("rkispp_scale2"));
301 if(entity) {
302 entity_name = media_entity_get_devname (entity);
303 if(entity_name) {
304 strncpy(ispp_info[index].pp_scale2_path, entity_name, sizeof(ispp_info[index].pp_scale2_path)-1);
305 }
306 }
307 /*
308 entity = media_get_entity_by_name(device, "rkispp_tnr_params", strlen("rkispp_tnr_params"));
309 if(entity) {
310 entity_name = media_entity_get_devname (entity);
311 if(entity_name) {
312 strncpy(ispp_info[index].pp_tnr_params_path, entity_name, sizeof(ispp_info[index].pp_tnr_params_path)-1);
313 }
314 }
315 entity = media_get_entity_by_name(device, "rkispp_tnr_stats", strlen("rkispp_tnr_stats"));
316 if(entity) {
317 entity_name = media_entity_get_devname (entity);
318 if(entity_name) {
319 strncpy(ispp_info[index].pp_tnr_stats_path, entity_name, sizeof(ispp_info[index].pp_tnr_stats_path)-1);
320 }
321 }
322 entity = media_get_entity_by_name(device, "rkispp_nr_params", strlen("rkispp_nr_params"));
323 if(entity) {
324 entity_name = media_entity_get_devname (entity);
325 if(entity_name) {
326 strncpy(ispp_info[index].pp_nr_params_path, entity_name, sizeof(ispp_info[index].pp_nr_params_path)-1);
327 }
328 }
329 entity = media_get_entity_by_name(device, "rkispp_nr_stats", strlen("rkispp_nr_stats"));
330 if(entity) {
331 entity_name = media_entity_get_devname (entity);
332 if(entity_name) {
333 strncpy(ispp_info[index].pp_nr_stats_path, entity_name, sizeof(ispp_info[index].pp_nr_stats_path)-1);
334 }
335 }
336 */
337 entity = media_get_entity_by_name(device, "rkispp_fec_params", strlen("rkispp_fec_params"));
338 if(entity) {
339 entity_name = media_entity_get_devname (entity);
340 if(entity_name) {
341 strncpy(ispp_info[index].pp_fec_params_path, entity_name, sizeof(ispp_info[index].pp_fec_params_path)-1);
342 }
343 }
344 entity = media_get_entity_by_name(device, "rkispp-subdev", strlen("rkispp-subdev"));
345 if(entity) {
346 entity_name = media_entity_get_devname (entity);
347 if(entity_name) {
348 strncpy(ispp_info[index].pp_dev_path, entity_name, sizeof(ispp_info[index].pp_dev_path)-1);
349 }
350 }
351
352 LOGI_RKSTREAM( "model(%s): ispp_info(%d): ispp-subdev entity name: %s\n",
353 device->info.model, index,
354 ispp_info[index].pp_dev_path);
355
356 return &ispp_info[index];
357 }
358
359 static rk_aiq_isp_t*
get_isp_subdevs(struct media_device * device,const char * devpath,rk_aiq_isp_t * isp_info)360 get_isp_subdevs(struct media_device *device, const char *devpath, rk_aiq_isp_t* isp_info)
361 {
362 media_entity *entity = NULL;
363 const char *entity_name = NULL;
364 int index = 0;
365 if(!device || !isp_info || !devpath)
366 return NULL;
367
368 for(index = 0; index < MAX_CAM_NUM; index++) {
369 if (0 == strlen(isp_info[index].media_dev_path)) {
370 isp_info[index].logic_id = index;
371 break;
372 }
373 if (0 == strncmp(isp_info[index].media_dev_path, devpath, sizeof(isp_info[index].media_dev_path)-1)) {
374 LOGE_RKSTREAM("isp info of path %s exists!", devpath);
375 return &isp_info[index];
376 }
377 }
378 if (index >= MAX_CAM_NUM)
379 return NULL;
380
381 #if defined(ISP_HW_V30)
382 // parse driver pattern: soc:rkisp0-vir0
383 int model_idx = -1;
384 char* rkisp = strstr(device->info.driver, "rkisp");
385 if (rkisp) {
386 char* str_unite = NULL;
387 str_unite = strstr(device->info.driver, "unite");
388 if (str_unite) {
389 model_idx = 0;
390 } else {
391 int isp_idx = atoi(rkisp + strlen("rkisp"));
392 char* vir = strstr(device->info.driver, "vir");
393 if (vir) {
394 int vir_idx = atoi(vir + strlen("vir"));
395 model_idx = isp_idx * 4 + vir_idx;
396 isp_info[index].phy_id = isp_idx;
397 }
398 }
399 }
400
401 if (model_idx == -1) {
402 LOGE_RKSTREAM("wrong isp media driver info: %s", device->info.driver);
403 return NULL;
404 }
405
406 isp_info[index].model_idx = model_idx;
407 #else
408 if (strcmp(device->info.model, "rkisp0") == 0 ||
409 strcmp(device->info.model, "rkisp") == 0)
410 isp_info[index].model_idx = 0;
411 else if (strcmp(device->info.model, "rkisp1") == 0)
412 isp_info[index].model_idx = 1;
413 else if (strcmp(device->info.model, "rkisp2") == 0)
414 isp_info[index].model_idx = 2;
415 else if (strcmp(device->info.model, "rkisp3") == 0)
416 isp_info[index].model_idx = 3;
417 else
418 isp_info[index].model_idx = -1;
419 #endif
420
421 strncpy(isp_info[index].media_dev_path, devpath, sizeof(isp_info[index].media_dev_path)-1);
422
423 entity = media_get_entity_by_name(device, "rkisp-isp-subdev", strlen("rkisp-isp-subdev"));
424 if(entity) {
425 entity_name = media_entity_get_devname (entity);
426 if(entity_name) {
427 strncpy(isp_info[index].isp_dev_path, entity_name, sizeof(isp_info[index].isp_dev_path)-1);
428 }
429 }
430
431 entity = media_get_entity_by_name(device, "rkisp-csi-subdev", strlen("rkisp-csi-subdev"));
432 if(entity) {
433 entity_name = media_entity_get_devname (entity);
434 if(entity_name) {
435 strncpy(isp_info[index].csi_dev_path, entity_name, sizeof(isp_info[index].csi_dev_path)-1);
436 }
437 }
438 entity = media_get_entity_by_name(device, "rkisp-mpfbc-subdev", strlen("rkisp-mpfbc-subdev"));
439 if(entity) {
440 entity_name = media_entity_get_devname (entity);
441 if(entity_name) {
442 strncpy(isp_info[index].mpfbc_dev_path, entity_name, sizeof(isp_info[index].mpfbc_dev_path)-1);
443 }
444 }
445 entity = media_get_entity_by_name(device, "rkisp_mainpath", strlen("rkisp_mainpath"));
446 if(entity) {
447 entity_name = media_entity_get_devname (entity);
448 if(entity_name) {
449 strncpy(isp_info[index].main_path, entity_name, sizeof(isp_info[index].main_path)-1);
450 }
451 }
452 entity = media_get_entity_by_name(device, "rkisp_selfpath", strlen("rkisp_selfpath"));
453 if(entity) {
454 entity_name = media_entity_get_devname (entity);
455 if(entity_name) {
456 strncpy(isp_info[index].self_path, entity_name, sizeof(isp_info[index].self_path)-1);
457 }
458 }
459 entity = media_get_entity_by_name(device, "rkisp_rawwr0", strlen("rkisp_rawwr0"));
460 if(entity) {
461 entity_name = media_entity_get_devname (entity);
462 if(entity_name) {
463 strncpy(isp_info[index].rawwr0_path, entity_name, sizeof(isp_info[index].rawwr0_path)-1);
464 }
465 }
466 entity = media_get_entity_by_name(device, "rkisp_rawwr1", strlen("rkisp_rawwr1"));
467 if(entity) {
468 entity_name = media_entity_get_devname (entity);
469 if(entity_name) {
470 strncpy(isp_info[index].rawwr1_path, entity_name, sizeof(isp_info[index].rawwr1_path)-1);
471 }
472 }
473 entity = media_get_entity_by_name(device, "rkisp_rawwr2", strlen("rkisp_rawwr2"));
474 if(entity) {
475 entity_name = media_entity_get_devname (entity);
476 if(entity_name) {
477 strncpy(isp_info[index].rawwr2_path, entity_name, sizeof(isp_info[index].rawwr2_path)-1);
478 }
479 }
480 entity = media_get_entity_by_name(device, "rkisp_rawwr3", strlen("rkisp_rawwr3"));
481 if(entity) {
482 entity_name = media_entity_get_devname (entity);
483 if(entity_name) {
484 strncpy(isp_info[index].rawwr3_path, entity_name, sizeof(isp_info[index].rawwr3_path)-1);
485 }
486 }
487 entity = media_get_entity_by_name(device, "rkisp_dmapath", strlen("rkisp_dmapath"));
488 if(entity) {
489 entity_name = media_entity_get_devname (entity);
490 if(entity_name) {
491 strncpy(isp_info[index].dma_path, entity_name, sizeof(isp_info[index].dma_path)-1);
492 }
493 }
494 entity = media_get_entity_by_name(device, "rkisp_rawrd0_m", strlen("rkisp_rawrd0_m"));
495 if(entity) {
496 entity_name = media_entity_get_devname (entity);
497 if(entity_name) {
498 strncpy(isp_info[index].rawrd0_m_path, entity_name, sizeof(isp_info[index].rawrd0_m_path)-1);
499 }
500 }
501 entity = media_get_entity_by_name(device, "rkisp_rawrd1_l", strlen("rkisp_rawrd1_l"));
502 if(entity) {
503 entity_name = media_entity_get_devname (entity);
504 if(entity_name) {
505 strncpy(isp_info[index].rawrd1_l_path, entity_name, sizeof(isp_info[index].rawrd1_l_path)-1);
506 }
507 }
508 entity = media_get_entity_by_name(device, "rkisp_rawrd2_s", strlen("rkisp_rawrd2_s"));
509 if(entity) {
510 entity_name = media_entity_get_devname (entity);
511 if(entity_name) {
512 strncpy(isp_info[index].rawrd2_s_path, entity_name, sizeof(isp_info[index].rawrd2_s_path)-1);
513 }
514 }
515 entity = media_get_entity_by_name(device, "rkisp-statistics", strlen("rkisp-statistics"));
516 if(entity) {
517 entity_name = media_entity_get_devname (entity);
518 if(entity_name) {
519 strncpy(isp_info[index].stats_path, entity_name, sizeof(isp_info[index].stats_path)-1);
520 }
521 }
522 entity = media_get_entity_by_name(device, "rkisp-input-params", strlen("rkisp-input-params"));
523 if(entity) {
524 entity_name = media_entity_get_devname (entity);
525 if(entity_name) {
526 strncpy(isp_info[index].input_params_path, entity_name, sizeof(isp_info[index].input_params_path)-1);
527 }
528 }
529 entity = media_get_entity_by_name(device, "rkisp-mipi-luma", strlen("rkisp-mipi-luma"));
530 if(entity) {
531 entity_name = media_entity_get_devname (entity);
532 if(entity_name) {
533 strncpy(isp_info[index].mipi_luma_path, entity_name, sizeof(isp_info[index].mipi_luma_path)-1);
534 }
535 }
536 entity = media_get_entity_by_name(device, "rockchip-mipi-dphy-rx", strlen("rockchip-mipi-dphy-rx"));
537 if(entity) {
538 entity_name = media_entity_get_devname (entity);
539 if(entity_name) {
540 strncpy(isp_info[index].mipi_dphy_rx_path, entity_name, sizeof(isp_info[index].mipi_dphy_rx_path)-1);
541 }
542 } else {
543 entity = media_get_entity_by_name(device, "rockchip-csi2-dphy0", strlen("rockchip-csi2-dphy0"));
544 if(entity) {
545 entity_name = media_entity_get_devname (entity);
546 if(entity_name) {
547 strncpy(isp_info[index].mipi_dphy_rx_path, entity_name, sizeof(isp_info[index].mipi_dphy_rx_path)-1);
548 }
549 }
550 }
551
552 entity = media_get_entity_by_name(device, "rkcif_dvp", strlen("rkcif_dvp"));
553 if(entity)
554 isp_info[index].linked_dvp = true;
555 else
556 isp_info[index].linked_dvp = false;
557
558 const char* linked_entity_name_strs[] = {
559 "rkcif_dvp",
560 "rkcif_lite_mipi_lvds",
561 "rkcif_mipi_lvds",
562 "rkcif_mipi_lvds1",
563 "rkcif_mipi_lvds2",
564 "rkcif_mipi_lvds3",
565 "rkcif_mipi_lvds4",
566 "rkcif_mipi_lvds5",
567 "rkcif-mipi-lvds",
568 "rkcif-mipi-lvds1",
569 "rkcif-mipi-lvds2",
570 "rkcif-mipi-lvds3",
571 "rkcif-mipi-lvds4",
572 "rkcif-mipi-lvds5",
573 NULL
574 };
575
576 int vicap_idx = 0;
577 for (int i = 0; linked_entity_name_strs[i] != NULL; i++) {
578 entity = media_get_entity_by_name(device, linked_entity_name_strs[i], strlen(linked_entity_name_strs[i]));
579 if (entity) {
580 strncpy(isp_info[index].linked_vicap[vicap_idx], entity->info.name, sizeof(isp_info[index].linked_vicap[vicap_idx]));
581 isp_info[index].linked_sensor = true;
582 if (vicap_idx++ >= MAX_ISP_LINKED_VICAP_CNT) {
583 break;
584 }
585 }
586 }
587
588 LOGI_RKSTREAM("model(%s): isp_info(%d): ispp-subdev entity name: %s\n",
589 device->info.model, index,
590 isp_info[index].isp_dev_path);
591
592 return &isp_info[index];
593 }
594
595 static rk_aiq_cif_info_t*
get_cif_subdevs(struct media_device * device,const char * devpath,rk_aiq_cif_info_t * cif_info)596 get_cif_subdevs(struct media_device *device, const char *devpath, rk_aiq_cif_info_t* cif_info)
597 {
598 media_entity *entity = NULL;
599 const char *entity_name = NULL;
600 int index = 0;
601 if(!device || !devpath || !cif_info)
602 return NULL;
603
604 for(index = 0; index < MAX_CAM_NUM; index++) {
605 if (0 == strlen(cif_info[index].media_dev_path))
606 break;
607 if (0 == strncmp(cif_info[index].media_dev_path, devpath, sizeof(cif_info[index].media_dev_path)-1)) {
608 LOGE_RKSTREAM("isp info of path %s exists!", devpath);
609 return &cif_info[index];
610 }
611 }
612 if (index >= MAX_CAM_NUM)
613 return NULL;
614
615 cif_info[index].model_idx = index;
616
617 strncpy(cif_info[index].media_dev_path, devpath, sizeof(cif_info[index].media_dev_path)-1 - 1);
618
619 entity = media_get_entity_by_name(device, "stream_cif_mipi_id0", strlen("stream_cif_mipi_id0"));
620 if(entity) {
621 entity_name = media_entity_get_devname (entity);
622 if(entity_name) {
623 strncpy(cif_info[index].mipi_id0, entity_name, sizeof(cif_info[index].mipi_id0) - 1);
624 }
625 }
626
627 entity = media_get_entity_by_name(device, "stream_cif_mipi_id1", strlen("stream_cif_mipi_id1"));
628 if(entity) {
629 entity_name = media_entity_get_devname (entity);
630 if(entity_name) {
631 strncpy(cif_info[index].mipi_id1, entity_name, sizeof(cif_info[index].mipi_id1) - 1);
632 }
633 }
634
635 entity = media_get_entity_by_name(device, "stream_cif_mipi_id2", strlen("stream_cif_mipi_id2"));
636 if(entity) {
637 entity_name = media_entity_get_devname (entity);
638 if(entity_name) {
639 strncpy(cif_info[index].mipi_id2, entity_name, sizeof(cif_info[index].mipi_id2) - 1);
640 }
641 }
642
643 entity = media_get_entity_by_name(device, "stream_cif_mipi_id3", strlen("stream_cif_mipi_id3"));
644 if(entity) {
645 entity_name = media_entity_get_devname (entity);
646 if(entity_name) {
647 strncpy(cif_info[index].mipi_id3, entity_name, sizeof(cif_info[index].mipi_id3) - 1);
648 }
649 }
650
651 entity = media_get_entity_by_name(device, "rkcif_scale_ch0", strlen("rkcif_scale_ch0"));
652 if(entity) {
653 entity_name = media_entity_get_devname (entity);
654 if(entity_name) {
655 strncpy(cif_info[index].mipi_scl0, entity_name, sizeof(cif_info[index].mipi_scl0) - 1);
656 }
657 }
658
659 entity = media_get_entity_by_name(device, "rkcif_scale_ch1", strlen("rkcif_scale_ch1"));
660 if(entity) {
661 entity_name = media_entity_get_devname (entity);
662 if(entity_name) {
663 strncpy(cif_info[index].mipi_scl1, entity_name, sizeof(cif_info[index].mipi_scl1) - 1);
664 }
665 }
666
667 entity = media_get_entity_by_name(device, "rkcif_scale_ch2", strlen("rkcif_scale_ch2"));
668 if(entity) {
669 entity_name = media_entity_get_devname (entity);
670 if(entity_name) {
671 strncpy(cif_info[index].mipi_scl2, entity_name, sizeof(cif_info[index].mipi_scl2) - 1);
672 }
673 }
674
675 entity = media_get_entity_by_name(device, "rkcif_scale_ch3", strlen("rkcif_scale_ch3"));
676 if(entity) {
677 entity_name = media_entity_get_devname (entity);
678 if(entity_name) {
679 strncpy(cif_info[index].mipi_scl3, entity_name, sizeof(cif_info[index].mipi_scl3) - 1);
680 }
681 }
682
683 entity = media_get_entity_by_name(device, "stream_cif_dvp_id0", strlen("stream_cif_dvp_id0"));
684 if(entity) {
685 entity_name = media_entity_get_devname (entity);
686 if(entity_name) {
687 strncpy(cif_info[index].dvp_id0, entity_name, sizeof(cif_info[index].dvp_id0) - 1);
688 }
689 }
690
691 entity = media_get_entity_by_name(device, "stream_cif_dvp_id1", strlen("stream_cif_dvp_id1"));
692 if(entity) {
693 entity_name = media_entity_get_devname (entity);
694 if(entity_name) {
695 strncpy(cif_info[index].dvp_id1, entity_name, sizeof(cif_info[index].dvp_id1) - 1);
696 }
697 }
698
699 entity = media_get_entity_by_name(device, "stream_cif_dvp_id2", strlen("stream_cif_dvp_id2"));
700 if(entity) {
701 entity_name = media_entity_get_devname (entity);
702 if(entity_name) {
703 strncpy(cif_info[index].dvp_id2, entity_name, sizeof(cif_info[index].dvp_id2) - 1);
704 }
705 }
706
707 entity = media_get_entity_by_name(device, "stream_cif_dvp_id3", strlen("stream_cif_dvp_id3"));
708 if(entity) {
709 entity_name = media_entity_get_devname (entity);
710 if(entity_name) {
711 strncpy(cif_info[index].dvp_id3, entity_name, sizeof(cif_info[index].dvp_id3) - 1);
712 }
713 }
714
715 entity = media_get_entity_by_name(device, "rkcif-mipi-luma", strlen("rkisp-mipi-luma"));
716 if(entity) {
717 entity_name = media_entity_get_devname (entity);
718 if(entity_name) {
719 strncpy(cif_info[index].mipi_luma_path, entity_name, sizeof(cif_info[index].mipi_luma_path)-1 - 1);
720 }
721 }
722
723 entity = media_get_entity_by_name(device, "rockchip-mipi-csi2", strlen("rockchip-mipi-csi2"));
724 if(entity) {
725 entity_name = media_entity_get_devname (entity);
726 if(entity_name) {
727 strncpy(cif_info[index].mipi_csi2_sd_path, entity_name, sizeof(cif_info[index].mipi_csi2_sd_path)-1 - 1);
728 }
729 }
730
731 entity = media_get_entity_by_name(device, "rkcif-lvds-subdev", strlen("rkcif-lvds-subdev"));
732 if(entity) {
733 entity_name = media_entity_get_devname (entity);
734 if(entity_name) {
735 strncpy(cif_info[index].lvds_sd_path, entity_name, sizeof(cif_info[index].lvds_sd_path)-1 - 1);
736 }
737 }
738
739 entity = media_get_entity_by_name(device, "rkcif-lite-lvds-subdev", strlen("rkcif-lite-lvds-subdev"));
740 if(entity) {
741 entity_name = media_entity_get_devname (entity);
742 if(entity_name) {
743 strncpy(cif_info[index].lvds_sd_path, entity_name, sizeof(cif_info[index].lvds_sd_path)-1 - 1);
744 }
745 }
746
747 entity = media_get_entity_by_name(device, "rockchip-mipi-dphy-rx", strlen("rockchip-mipi-dphy-rx"));
748 if(entity) {
749 entity_name = media_entity_get_devname (entity);
750 if(entity_name) {
751 strncpy(cif_info[index].mipi_dphy_rx_path, entity_name, sizeof(cif_info[index].mipi_dphy_rx_path)-1 - 1);
752 }
753 } else {
754 entity = media_get_entity_by_name(device, "rockchip-csi2-dphy0", strlen("rockchip-csi2-dphy0"));
755 if(entity) {
756 entity_name = media_entity_get_devname (entity);
757 if(entity_name) {
758 strncpy(cif_info[index].mipi_dphy_rx_path, entity_name, sizeof(cif_info[index].mipi_dphy_rx_path)-1 - 1);
759 }
760 }
761 }
762
763 entity = media_get_entity_by_name(device, "stream_cif", strlen("stream_cif"));
764 if(entity) {
765 entity_name = media_entity_get_devname (entity);
766 if(entity_name) {
767 strncpy(cif_info[index].stream_cif_path, entity_name, sizeof(cif_info[index].stream_cif_path)-1 - 1);
768 }
769 }
770
771 entity = media_get_entity_by_name(device, "rkcif-dvp-sof", strlen("rkcif-dvp-sof"));
772 if(entity) {
773 entity_name = media_entity_get_devname (entity);
774 if(entity_name) {
775 strncpy(cif_info[index].dvp_sof_sd_path, entity_name, sizeof(cif_info[index].dvp_sof_sd_path)-1 - 1);
776 }
777 }
778
779 return &cif_info[index];
780 }
781
782 static
783 XCamReturn
SensorInfoCopy(rk_sensor_full_info_t * finfo,rk_aiq_static_info_t * info)784 SensorInfoCopy(rk_sensor_full_info_t *finfo, rk_aiq_static_info_t *info) {
785 int fs_num, i = 0;
786 rk_aiq_sensor_info_t *sinfo = NULL;
787
788 //info->media_node_index = finfo->media_node_index;
789 strncpy(info->lens_info.len_name, finfo->len_name.c_str(), sizeof(info->lens_info.len_name)-1);
790 sinfo = &info->sensor_info;
791 strncpy(sinfo->sensor_name, finfo->sensor_name.c_str(), sizeof(sinfo->sensor_name)-1);
792 fs_num = finfo->frame_size.size();
793 if (fs_num) {
794 for (auto iter = finfo->frame_size.begin(); iter != finfo->frame_size.end() && i < 10; ++iter, i++) {
795 sinfo->support_fmt[i].width = (*iter).width;
796 sinfo->support_fmt[i].height = (*iter).height;
797 sinfo->support_fmt[i].format = (*iter).format;
798 sinfo->support_fmt[i].fps = (*iter).fps;
799 sinfo->support_fmt[i].hdr_mode = (*iter).hdr_mode;
800 }
801 sinfo->num = i;
802 }
803
804 if (finfo->module_index_str.size()) {
805 sinfo->phyId = atoi(finfo->module_index_str.c_str() + 1);
806 } else {
807 sinfo->phyId = -1;
808 }
809
810 return XCAM_RETURN_NO_ERROR;
811 }
812
813 rk_aiq_static_info_t*
getStaticCamHwInfo(const char * sns_ent_name,uint16_t index)814 MediaInfo::getStaticCamHwInfo(const char* sns_ent_name, uint16_t index)
815 {
816 std::map<std::string, SmartPtr<rk_aiq_static_info_t>>::iterator it;
817
818 if (sns_ent_name) {
819 std::string str(sns_ent_name);
820
821 it = mCamHwInfos.find(str);
822 if (it != mCamHwInfos.end()) {
823 LOGD_RKSTREAM("find camerainfo of %s!", sns_ent_name);
824 return it->second.ptr();
825 } else {
826 LOGE_RKSTREAM("camerainfo of %s not fount!", sns_ent_name);
827 }
828 } else {
829 if (index >= 0 && index < mCamHwInfos.size()) {
830 int i = 0;
831 for (it = mCamHwInfos.begin(); it != mCamHwInfos.end(); it++, i++) {
832 if (i == index)
833 return it->second.ptr();
834 }
835 }
836 }
837
838 return NULL;
839 }
840
841 rk_sensor_full_info_t*
getSensorFullInfo(char * sns_ent_name,uint16_t index)842 MediaInfo::getSensorFullInfo(char* sns_ent_name, uint16_t index)
843 {
844 std::map<std::string, SmartPtr<rk_sensor_full_info_t>>::iterator it;
845 if (sns_ent_name) {
846 std::string str(sns_ent_name);
847
848 it = mSensorHwInfos.find(str);
849 if (it != mSensorHwInfos.end()) {
850 LOGD_RKSTREAM("find camerainfo of %s!", sns_ent_name);
851 return it->second.ptr();
852 } else {
853 LOGE_RKSTREAM("camerainfo of %s not fount!", sns_ent_name);
854 }
855 } else {
856 if (index >= 0 && index < mSensorHwInfos.size()) {
857 int i = 0;
858 for (it = mSensorHwInfos.begin(); it != mSensorHwInfos.end(); it++, i++) {
859 if (i == index)
860 return it->second.ptr();
861 }
862 }
863 }
864
865 return NULL;
866 }
867
868 XCamReturn
clearStaticCamHwInfo()869 MediaInfo::clearStaticCamHwInfo()
870 {
871 mCamHwInfos.clear();
872 mSensorHwInfos.clear();
873
874 return XCAM_RETURN_NO_ERROR;
875 }
876
877 void
findAttachedSubdevs(struct media_device * device,uint32_t count,rk_sensor_full_info_t * s_info)878 MediaInfo::findAttachedSubdevs(struct media_device *device, uint32_t count, rk_sensor_full_info_t *s_info)
879 {
880 const struct media_entity_desc *entity_info = NULL;
881 struct media_entity *entity = NULL;
882 uint32_t k;
883
884 for (k = 0; k < count; ++k) {
885 entity = media_get_entity (device, k);
886 entity_info = media_entity_get_info(entity);
887 if ((NULL != entity_info) && (entity_info->type == MEDIA_ENT_T_V4L2_SUBDEV_LENS)) {
888 if ((entity_info->name[0] == 'm') &&
889 (strncmp(entity_info->name, s_info->module_index_str.c_str(), 3) == 0)) {
890 if (entity_info->flags == 1)
891 s_info->module_ircut_dev_name = std::string(media_entity_get_devname(entity));
892 else//vcm
893 s_info->module_lens_dev_name = std::string(media_entity_get_devname(entity));
894 }
895 } else if ((NULL != entity_info) && (entity_info->type == MEDIA_ENT_T_V4L2_SUBDEV_FLASH)) {
896 if ((entity_info->name[0] == 'm') &&
897 (strncmp(entity_info->name, s_info->module_index_str.c_str(), 3) == 0)) {
898
899 /* check if entity name has the format string mxx_x_xxx-irxxx */
900 if (strstr(entity_info->name, "-ir") != NULL) {
901 s_info->module_flash_ir_dev_name[s_info->flash_ir_num++] =
902 std::string(media_entity_get_devname(entity));
903 } else
904 s_info->module_flash_dev_name[s_info->flash_num++] =
905 std::string(media_entity_get_devname(entity));
906 }
907 }
908 }
909 // query flash infos
910 /*
911 if (s_info->flash_num) {
912 SmartPtr<FlashLightHw> fl = new FlashLightHw(s_info->module_flash_dev_name, s_info->flash_num);
913 fl->init(1);
914 s_info->fl_strth_adj_sup = fl->isStrengthAdj();
915 fl->deinit();
916 }
917 if (s_info->flash_ir_num) {
918 SmartPtr<FlashLightHw> fl_ir = new FlashLightHw(s_info->module_flash_ir_dev_name, s_info->flash_ir_num);
919 fl_ir->init(1);
920 s_info->fl_ir_strth_adj_sup = fl_ir->isStrengthAdj();
921 fl_ir->deinit();
922 }
923 */
924 }
925
926 XCamReturn
initCamHwInfos()927 MediaInfo::initCamHwInfos()
928 {
929 char sys_path[64], devpath[32];
930 FILE *fp = NULL;
931 struct media_device *device = NULL;
932 int nents, j = 0, i = 0, node_index = 0;
933 const struct media_entity_desc *entity_info = NULL;
934 struct media_entity *entity = NULL;
935
936 xcam_mem_clear (mIspHwInfos);
937 xcam_mem_clear (mCifHwInfos);
938
939 while (i < MAX_MEDIA_INDEX) {
940 node_index = i;
941 snprintf (sys_path, 64, "/dev/media%d", i++);
942
943 fp = fopen (sys_path, "r");
944 if (!fp)
945 continue;
946 fclose (fp);
947 device = media_device_new (sys_path);
948 if (!device) {
949 continue;
950 }
951
952 /* Enumerate entities, pads and links. */
953 media_device_enumerate (device);
954
955 rk_aiq_isp_t* isp_info = NULL;
956 rk_aiq_cif_info_t* cif_info = NULL;
957 bool dvp_itf = false;
958 if (strcmp(device->info.model, "rkispp0") == 0 ||
959 strcmp(device->info.model, "rkispp1") == 0 ||
960 strcmp(device->info.model, "rkispp2") == 0 ||
961 strcmp(device->info.model, "rkispp3") == 0 ||
962 strcmp(device->info.model, "rkispp") == 0) {
963 rk_aiq_ispp_t* ispp_info = get_ispp_subdevs(device, sys_path, mIspHwInfos.ispp_info);
964 if (ispp_info)
965 ispp_info->valid = true;
966 goto media_unref;
967 } else if (strcmp(device->info.model, "rkisp0") == 0 ||
968 strcmp(device->info.model, "rkisp1") == 0 ||
969 strcmp(device->info.model, "rkisp2") == 0 ||
970 strcmp(device->info.model, "rkisp3") == 0 ||
971 strcmp(device->info.model, "rkisp") == 0) {
972 isp_info = get_isp_subdevs(device, sys_path, mIspHwInfos.isp_info);
973 if (strstr(device->info.driver, "rkisp-unite")) {
974 isp_info->is_multi_isp_mode = true;
975 mIsMultiIspMode = true;
976 mMultiIspExtendedPixel = RKMOUDLE_UNITE_EXTEND_PIXEL;
977 } else {
978 isp_info->is_multi_isp_mode = false;
979 mIsMultiIspMode = false;
980 mMultiIspExtendedPixel = 0;
981 }
982 isp_info->valid = true;
983 } else if (strcmp(device->info.model, "rkcif") == 0 ||
984 strcmp(device->info.model, "rkcif_dvp") == 0 ||
985 strstr(device->info.model, "rkcif_mipi_lvds") ||
986 strstr(device->info.model, "rkcif-mipi-lvds") ||
987 strcmp(device->info.model, "rkcif_lite_mipi_lvds") == 0) {
988 cif_info = get_cif_subdevs(device, sys_path, mCifHwInfos.cif_info);
989 strncpy(cif_info->model_str, device->info.model, sizeof(cif_info->model_str));
990
991 if (strcmp(device->info.model, "rkcif_dvp") == 0)
992 dvp_itf = true;
993 } else {
994 goto media_unref;
995 }
996
997 nents = media_get_entities_count (device);
998 for (j = 0; j < nents; ++j) {
999 entity = media_get_entity (device, j);
1000 entity_info = media_entity_get_info(entity);
1001 if ((NULL != entity_info) && (entity_info->type == MEDIA_ENT_T_V4L2_SUBDEV_SENSOR)) {
1002 rk_aiq_static_info_t *info = new rk_aiq_static_info_t();
1003 rk_sensor_full_info_t *s_full_info = new rk_sensor_full_info_t();
1004 s_full_info->media_node_index = node_index;
1005 strncpy(devpath, media_entity_get_devname(entity), sizeof(devpath)-1);
1006 s_full_info->device_name = std::string(devpath);
1007 s_full_info->sensor_name = std::string(entity_info->name);
1008 s_full_info->parent_media_dev = std::string(sys_path);
1009 parse_module_info(s_full_info);
1010 get_sensor_caps(s_full_info);
1011
1012 if (cif_info) {
1013 s_full_info->linked_to_isp = false;
1014 s_full_info->cif_info = cif_info;
1015 s_full_info->isp_info = NULL;
1016 s_full_info->dvp_itf = dvp_itf;
1017 } else if (isp_info) {
1018 s_full_info->linked_to_isp = true;
1019 isp_info->linked_sensor = true;
1020 isp_info->isMultiplex = false;
1021 s_full_info->isp_info = isp_info;
1022 } else {
1023 LOGE_RKSTREAM("sensor device mount error!\n");
1024 }
1025
1026 findAttachedSubdevs(device, nents, s_full_info);
1027 SensorInfoCopy(s_full_info, info);
1028 info->has_lens_vcm = s_full_info->module_lens_dev_name.empty() ? false : true;
1029 info->has_fl = s_full_info->flash_num > 0 ? true : false;
1030 info->has_irc = s_full_info->module_ircut_dev_name.empty() ? false : true;
1031 info->fl_strth_adj_sup = s_full_info->fl_ir_strth_adj_sup;
1032 info->fl_ir_strth_adj_sup = s_full_info->fl_ir_strth_adj_sup;
1033 if (s_full_info->isp_info)
1034 info->is_multi_isp_mode = s_full_info->isp_info->is_multi_isp_mode;
1035 info->multi_isp_extended_pixel = mMultiIspExtendedPixel;
1036 LOGD_RKSTREAM("Init sensor %s with Multi-ISP Mode:%d Extended Pixels:%d ",
1037 s_full_info->sensor_name.c_str(), info->is_multi_isp_mode,
1038 info->multi_isp_extended_pixel);
1039 mSensorHwInfos[s_full_info->sensor_name] = s_full_info;
1040 mCamHwInfos[s_full_info->sensor_name] = info;
1041 }
1042 }
1043
1044 media_unref:
1045 media_device_unref (device);
1046 }
1047
1048 // judge isp if multiplex by multiple cams
1049 rk_aiq_isp_t* isp_info = NULL;
1050 for (i = 0; i < MAX_CAM_NUM; i++) {
1051 isp_info = &mIspHwInfos.isp_info[i];
1052 if (isp_info->valid) {
1053 for (j = i - 1; j >= 0; j--) {
1054 if (isp_info->phy_id == mIspHwInfos.isp_info[j].phy_id) {
1055 isp_info->isMultiplex = true;
1056 mIspHwInfos.isp_info[j].isMultiplex = true;
1057 }
1058 }
1059 }
1060 }
1061
1062 std::map<std::string, SmartPtr<rk_sensor_full_info_t>>::iterator iter;
1063 for(iter = mSensorHwInfos.begin(); \
1064 iter != mSensorHwInfos.end(); iter++) {
1065 LOGI_RKSTREAM("match the sensor_name(%s) media link\n", (iter->first).c_str());
1066 SmartPtr<rk_sensor_full_info_t> s_full_info = iter->second;
1067
1068 /*
1069 * The ISP and ISPP match links through the media device model
1070 */
1071 if (s_full_info->linked_to_isp) {
1072 for (i = 0; i < MAX_CAM_NUM; i++) {
1073 LOGI_RKSTREAM("isp model_idx: %d, ispp(%d) model_idx: %d\n",
1074 s_full_info->isp_info->model_idx,
1075 i,
1076 mIspHwInfos.ispp_info[i].model_idx);
1077
1078 if (mIspHwInfos.ispp_info[i].valid &&
1079 (s_full_info->isp_info->model_idx == mIspHwInfos.ispp_info[i].model_idx)) {
1080 s_full_info->ispp_info = &mIspHwInfos.ispp_info[i];
1081 LOGI_RKSTREAM("isp(%d) link to ispp(%d)\n",
1082 s_full_info->isp_info->model_idx,
1083 mIspHwInfos.ispp_info[i].model_idx);
1084 mCamHwInfos[s_full_info->sensor_name]->sensor_info.binded_strm_media_idx =
1085 atoi(s_full_info->ispp_info->media_dev_path + strlen("/dev/media"));
1086 LOGI_RKSTREAM("sensor %s adapted to pp media %d:%s\n",
1087 s_full_info->sensor_name.c_str(),
1088 mCamHwInfos[s_full_info->sensor_name]->sensor_info.binded_strm_media_idx,
1089 s_full_info->ispp_info->media_dev_path);
1090 break;
1091 }
1092 }
1093 } else {
1094 /*
1095 * Determine which isp that vipCap is linked
1096 */
1097 for (i = 0; i < MAX_CAM_NUM; i++) {
1098 rk_aiq_isp_t* isp_info = &mIspHwInfos.isp_info[i];
1099
1100 for (int vicap_idx = 0; vicap_idx < MAX_ISP_LINKED_VICAP_CNT; vicap_idx++) {
1101 LOGI_RKSTREAM("vicap %s, linked_vicap %s",
1102 s_full_info->cif_info->model_str, isp_info->linked_vicap[vicap_idx]);
1103 if (strcmp(s_full_info->cif_info->model_str, isp_info->linked_vicap[vicap_idx]) == 0) {
1104 s_full_info->isp_info = &mIspHwInfos.isp_info[i];
1105 mCamHwInfos[s_full_info->sensor_name]->is_multi_isp_mode =
1106 s_full_info->isp_info->is_multi_isp_mode;
1107 mCamHwInfos[s_full_info->sensor_name]
1108 ->multi_isp_extended_pixel = mMultiIspExtendedPixel;
1109 if (mIspHwInfos.ispp_info[i].valid)
1110 s_full_info->ispp_info = &mIspHwInfos.ispp_info[i];
1111 LOGI_RKSTREAM("vicap link to isp(%d) to ispp(%d)\n",
1112 s_full_info->isp_info->model_idx,
1113 s_full_info->ispp_info ? s_full_info->ispp_info->model_idx : -1);
1114 mCamHwInfos[s_full_info->sensor_name]->sensor_info.binded_strm_media_idx =
1115 s_full_info->ispp_info ? atoi(s_full_info->ispp_info->media_dev_path + strlen("/dev/media")) :
1116 -1;
1117 LOGI_RKSTREAM("sensor %s adapted to pp media %d:%s\n",
1118 s_full_info->sensor_name.c_str(),
1119 mCamHwInfos[s_full_info->sensor_name]->sensor_info.binded_strm_media_idx,
1120 s_full_info->ispp_info ? s_full_info->ispp_info->media_dev_path : "null");
1121 mIspHwInfos.isp_info[i].linked_sensor = true;
1122 }
1123 }
1124 }
1125 }
1126 if (!s_full_info->isp_info/* || !s_full_info->ispp_info*/) {
1127 LOGE_RKSTREAM("get isp or ispp info fail, something gos wrong!");
1128 } else {
1129 //mCamHwInfos[s_full_info->sensor_name]->linked_isp_info = *s_full_info->isp_info;
1130 //mCamHwInfos[s_full_info->sensor_name]->linked_ispp_info = *s_full_info->ispp_info;
1131 }
1132 }
1133
1134 /* Look for free isp&ispp link to fake camera */
1135 for (i = 0; i < MAX_CAM_NUM; i++) {
1136 if (mIspHwInfos.isp_info[i].valid &&
1137 !mIspHwInfos.isp_info[i].linked_sensor) {
1138 rk_aiq_static_info_t *hwinfo = new rk_aiq_static_info_t();
1139 rk_sensor_full_info_t *fullinfo = new rk_sensor_full_info_t();
1140
1141 fullinfo->isp_info = &mIspHwInfos.isp_info[i];
1142 if (mIspHwInfos.ispp_info[i].valid) {
1143 fullinfo->ispp_info = &mIspHwInfos.ispp_info[i];
1144 hwinfo->sensor_info.binded_strm_media_idx =
1145 atoi(fullinfo->ispp_info->media_dev_path + strlen("/dev/media"));
1146 }
1147 fullinfo->media_node_index = -1;
1148 fullinfo->device_name = std::string("/dev/null");
1149 fullinfo->sensor_name = std::string("FakeCamera");
1150 fullinfo->sensor_name += std::to_string(i);
1151 fullinfo->parent_media_dev = std::string("/dev/null");
1152 fullinfo->linked_to_isp = true;
1153
1154 hwinfo->sensor_info.support_fmt[0].hdr_mode = NO_HDR;
1155 hwinfo->sensor_info.support_fmt[1].hdr_mode = HDR_X2;
1156 hwinfo->sensor_info.support_fmt[2].hdr_mode = HDR_X3;
1157 hwinfo->sensor_info.num = 3;
1158 mIspHwInfos.isp_info[i].linked_sensor = true;
1159
1160 SensorInfoCopy(fullinfo, hwinfo);
1161 hwinfo->has_lens_vcm = false;
1162 hwinfo->has_fl = false;
1163 hwinfo->has_irc = false;
1164 hwinfo->fl_strth_adj_sup = 0;
1165 hwinfo->fl_ir_strth_adj_sup = 0;
1166 hwinfo->is_multi_isp_mode = fullinfo->isp_info->is_multi_isp_mode;
1167 hwinfo->multi_isp_extended_pixel = mMultiIspExtendedPixel;
1168 mSensorHwInfos[fullinfo->sensor_name] = fullinfo;
1169 mCamHwInfos[fullinfo->sensor_name] = hwinfo;
1170 LOGI_RKSTREAM("fake camera %d link to isp(%d) to ispp(%d)\n",
1171 i,
1172 fullinfo->isp_info->model_idx,
1173 fullinfo->ispp_info ? fullinfo->ispp_info->model_idx : -1);
1174 LOGI_RKSTREAM("sensor %s adapted to pp media %d:%s\n",
1175 fullinfo->sensor_name.c_str(),
1176 mCamHwInfos[fullinfo->sensor_name]->sensor_info.binded_strm_media_idx,
1177 fullinfo->ispp_info ? fullinfo->ispp_info->media_dev_path : "null");
1178 }
1179 }
1180 get_isp_ver(&mIspHwInfos);
1181 for (auto &item : mCamHwInfos)
1182 item.second->isp_hw_ver = mIspHwInfos.hw_ver_info.isp_ver;
1183 return XCAM_RETURN_NO_ERROR;
1184
1185 }
1186
getCamHwEntNames(char buf[12][32])1187 void MediaInfo::getCamHwEntNames(char buf[12][32])
1188 {
1189 int i = 0;
1190 for(auto it=mSensorHwInfos.begin(); it!=mSensorHwInfos.end(); ++it){
1191 strcpy(buf[i], it->first.c_str());
1192 i++;
1193 //printf("printStaticCamHwInfo %s\n",it->first.c_str());
1194 }
1195 }
1196
1197 void
offline(const char * isp_driver,const char * offline_sns_ent_name)1198 MediaInfo::offline(const char* isp_driver, const char* offline_sns_ent_name)
1199 {
1200 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1201 int isp_driver_index = -1;
1202 if (!isp_driver) {
1203 return;
1204 } else {
1205 // if driver = 3588
1206 if(strlen(isp_driver) > 8) {
1207 char* isp_driver_name = const_cast<char*>(isp_driver);
1208 char *rkisp = strstr(isp_driver_name, "rkisp");
1209 if (rkisp) {
1210 int isp_mode = atoi(rkisp + strlen("rkisp"));
1211 char* vir = strstr(isp_driver_name, "vir");
1212 if (vir) {
1213 int vir_idx = atoi(vir + strlen("vir"));
1214 isp_driver_index = isp_mode * 4 + vir_idx;
1215 }
1216 }
1217 } else {
1218 if (strcmp(isp_driver, "rkisp0") == 0 ||
1219 strcmp(isp_driver, "rkisp") == 0)
1220 isp_driver_index = 0;
1221 else if (strcmp(isp_driver, "rkisp1") == 0)
1222 isp_driver_index = 1;
1223 else if (strcmp(isp_driver, "rkisp2") == 0)
1224 isp_driver_index = 2;
1225 else if (strcmp(isp_driver, "rkisp3") == 0)
1226 isp_driver_index = 3;
1227 else
1228 isp_driver_index = -1;
1229 }
1230 }
1231 std::map<std::string, SmartPtr<rk_sensor_full_info_t> >::iterator iter;
1232 std::map<std::string, SmartPtr<rk_aiq_static_info_t> >::iterator iter_info;
1233 for (iter = mSensorHwInfos.begin(); \
1234 iter != mSensorHwInfos.end(); iter++) {
1235 rk_sensor_full_info_t *s_full_info_f = iter->second.ptr();
1236 if (s_full_info_f->isp_info) {
1237 if (s_full_info_f->isp_info->model_idx != isp_driver_index) {
1238 continue;
1239 }
1240 rk_sensor_full_info_t *s_full_info = new rk_sensor_full_info_t;
1241 *s_full_info = *s_full_info_f;
1242 iter_info = mCamHwInfos.find(iter->first);
1243 if (iter_info == mCamHwInfos.end()) {
1244 continue;
1245 }
1246 rk_aiq_static_info_t *cam_hw_info_f = iter_info->second.ptr();
1247 rk_aiq_static_info_t *cam_hw_info = new rk_aiq_static_info_t;
1248 *cam_hw_info = *cam_hw_info_f;
1249 char sensor_name_real[64];
1250 if (!strstr(const_cast<char*>(s_full_info->sensor_name.c_str()), offline_sns_ent_name)) {
1251 int module_index = 0;
1252 std::map<std::string, SmartPtr<rk_sensor_full_info_t> >::iterator sns_it;
1253 for (sns_it = mSensorHwInfos.begin(); \
1254 sns_it != mSensorHwInfos.end(); sns_it++) {
1255 rk_sensor_full_info_t *sns_full= sns_it->second.ptr();
1256 if (strstr(sns_full->sensor_name.c_str(), "_s_")) {
1257 int sns_index = atoi(sns_full->sensor_name.c_str() + 2);
1258 if (module_index <= sns_index) {
1259 module_index = sns_index + 1;
1260 }
1261 }
1262 }
1263 std::string tmp_sensor_name = s_full_info_f->sensor_name;
1264 s_full_info->module_real_sensor_name = (std::string)offline_sns_ent_name;
1265 s_full_info->phy_module_orient = 's';
1266 memset(sensor_name_real, 0, sizeof(sensor_name_real));
1267 sprintf(sensor_name_real, "%s%d%s%s%s", "m0", module_index, "_s_",
1268 s_full_info->module_real_sensor_name.c_str(),
1269 " 1-111a");
1270 std::string sns_fake_name = sensor_name_real;
1271 s_full_info->sensor_name = sns_fake_name;
1272 printf("sns_fake_name:%s %s\n", s_full_info->sensor_name.c_str(), s_full_info_f->sensor_name.c_str());
1273 mSensorHwInfos[s_full_info->sensor_name] = s_full_info;
1274 mCamHwInfos[s_full_info->sensor_name] = cam_hw_info;
1275 mSensorHwInfos.erase(tmp_sensor_name);
1276 mCamHwInfos.erase(tmp_sensor_name);
1277 iter_info++;
1278 } else {
1279 std::string tmp_sensor_name = s_full_info_f->sensor_name;
1280 s_full_info->phy_module_orient = 's';
1281 memset(sensor_name_real, 0, sizeof(sensor_name_real));
1282 sprintf(sensor_name_real, "%s%s%s%s", s_full_info->module_index_str.c_str(), "_s_",
1283 s_full_info->module_real_sensor_name.c_str(),
1284 " 1-111a");
1285 std::string sns_fake_name = sensor_name_real;
1286 s_full_info->sensor_name = sns_fake_name;
1287 printf("sns_fake_name:%s %s\n", s_full_info->sensor_name.c_str(), s_full_info_f->sensor_name.c_str());
1288 mSensorHwInfos[s_full_info->sensor_name] = s_full_info;
1289 mCamHwInfos[s_full_info->sensor_name] = cam_hw_info;
1290 mSensorHwInfos.erase(tmp_sensor_name);
1291 mCamHwInfos.erase(tmp_sensor_name);
1292 iter_info++;
1293 }
1294 return;
1295 }
1296 }
1297 printf("offline preInit faile\n");
1298 }
1299
1300 }