1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 *
4 * HDF is dual licensed: you can use it either under the terms of
5 * the GPL, or the BSD license, at your option.
6 * See the LICENSE file in the root of this repository for complete details.
7 */
8
9 #include <hdf_log.h>
10 #include "camera_config_parser.h"
11
12 #define HDF_LOG_TAG HDF_CAMERA_PARSER
13
14 #define CHECK_PARSER_CONFIG_RET(ret, str) do { \
15 if ((ret) != HDF_SUCCESS) { \
16 HDF_LOGE("%s: get %{public}s failed, ret = %{public}d, line : %{public}d", __func__, str, ret, __LINE__); \
17 return ret; \
18 } \
19 } while (0)
20
21 static struct CameraConfigRoot g_configCameraRoot;
22
SetCtrlCapInfo(struct CtrlCapInfo * ctrlCap,int ctrlValueNum,const int * ctrlValue)23 static void SetCtrlCapInfo(struct CtrlCapInfo *ctrlCap, int ctrlValueNum, const int *ctrlValue)
24 {
25 int32_t i;
26
27 for (i = 0; i < ctrlValueNum; i += CTRL_INFO_COUNT) {
28 ctrlCap[i / CTRL_INFO_COUNT].ctrlId = ctrlValue[i + CTRL_ID_INDEX];
29 ctrlCap[i / CTRL_INFO_COUNT].max = ctrlValue[i + CTRL_MAX_INDEX];
30 ctrlCap[i / CTRL_INFO_COUNT].min = ctrlValue[i + CTRL_MIN_INDEX];
31 ctrlCap[i / CTRL_INFO_COUNT].step = ctrlValue[i + CTRL_STEP_INDEX];
32 ctrlCap[i / CTRL_INFO_COUNT].def = ctrlValue[i + CTRL_DEF_INDEX];
33 HDF_LOGD("%s: get ctrlCap[%{public}d]: ctrlId=%{public}d, max=%{public}d, min=%{public}d, "
34 "step = %{public}d, def = %{public}d", __func__, (i / CTRL_INFO_COUNT),
35 ctrlCap[i / CTRL_INFO_COUNT].ctrlId, ctrlCap[i / CTRL_INFO_COUNT].max, ctrlCap[i / CTRL_INFO_COUNT].min,
36 ctrlCap[i / CTRL_INFO_COUNT].step, ctrlCap[i / CTRL_INFO_COUNT].def);
37 }
38 }
39
ParseCameraSensorDeviceConfig(const struct DeviceResourceNode * node,struct DeviceResourceIface * drsOps,struct SensorDeviceConfig * sensorConfig)40 static int32_t ParseCameraSensorDeviceConfig(const struct DeviceResourceNode *node,
41 struct DeviceResourceIface *drsOps, struct SensorDeviceConfig *sensorConfig)
42 {
43 int32_t ret;
44
45 ret = drsOps->GetString(node, "name", &sensorConfig->name, NULL);
46 CHECK_PARSER_CONFIG_RET(ret, "name");
47 ret = drsOps->GetUint8(node, "id", &sensorConfig->id, 0);
48 CHECK_PARSER_CONFIG_RET(ret, "id");
49 ret = drsOps->GetUint8(node, "exposure", &sensorConfig->exposure, 0);
50 CHECK_PARSER_CONFIG_RET(ret, "exposure");
51 ret = drsOps->GetUint8(node, "mirror", &sensorConfig->mirror, 0);
52 CHECK_PARSER_CONFIG_RET(ret, "mirror");
53 ret = drsOps->GetUint8(node, "gain", &sensorConfig->gain, 0);
54 CHECK_PARSER_CONFIG_RET(ret, "gain");
55 sensorConfig->ctrlValueNum = drsOps->GetElemNum(node, "ctrlValue");
56 if (sensorConfig->ctrlValueNum > CTRL_VALUE_MAX_NUM) {
57 HDF_LOGE("%s: parser ctrlValue num failed! num = %{public}d", __func__, sensorConfig->ctrlValueNum);
58 return HDF_ERR_INVALID_PARAM;
59 }
60 ret = drsOps->GetUint32Array(node, "ctrlValue", sensorConfig->ctrlValue, sensorConfig->ctrlValueNum, 0);
61 CHECK_PARSER_CONFIG_RET(ret, "ctrlValue");
62 SetCtrlCapInfo(sensorConfig->ctrlCap, sensorConfig->ctrlValueNum, sensorConfig->ctrlValue);
63
64 HDF_LOGD("%s: name=%{public}s, id=%{public}d, exposure=%{public}d, mirror=%{public}d, gain=%{public}d",
65 __func__, sensorConfig->name, sensorConfig->id, sensorConfig->exposure, sensorConfig->mirror,
66 sensorConfig->gain);
67
68 return HDF_SUCCESS;
69 }
70
ParseCameraIspDeviceConfig(const struct DeviceResourceNode * node,struct DeviceResourceIface * drsOps,struct IspDeviceConfig * ispConfig)71 static int32_t ParseCameraIspDeviceConfig(const struct DeviceResourceNode *node,
72 struct DeviceResourceIface *drsOps, struct IspDeviceConfig *ispConfig)
73 {
74 int32_t ret;
75
76 ret = drsOps->GetString(node, "name", &ispConfig->name, NULL);
77 CHECK_PARSER_CONFIG_RET(ret, "name");
78 ret = drsOps->GetUint8(node, "id", &ispConfig->id, 0);
79 CHECK_PARSER_CONFIG_RET(ret, "id");
80 ret = drsOps->GetUint8(node, "brightness", &ispConfig->brightness, 0);
81 CHECK_PARSER_CONFIG_RET(ret, "brightness");
82 ret = drsOps->GetUint8(node, "contrast", &ispConfig->contrast, 0);
83 CHECK_PARSER_CONFIG_RET(ret, "contrast");
84 ret = drsOps->GetUint8(node, "saturation", &ispConfig->saturation, 0);
85 CHECK_PARSER_CONFIG_RET(ret, "saturation");
86 ret = drsOps->GetUint8(node, "hue", &ispConfig->hue, 0);
87 CHECK_PARSER_CONFIG_RET(ret, "hue");
88 ret = drsOps->GetUint8(node, "sharpness", &ispConfig->sharpness, 0);
89 CHECK_PARSER_CONFIG_RET(ret, "sharpness");
90 ret = drsOps->GetUint8(node, "gain", &ispConfig->gain, 0);
91 CHECK_PARSER_CONFIG_RET(ret, "gain");
92 ret = drsOps->GetUint8(node, "gamma", &ispConfig->gamma, 0);
93 CHECK_PARSER_CONFIG_RET(ret, "gamma");
94 ret = drsOps->GetUint8(node, "whiteBalance", &ispConfig->whiteBalance, 0);
95 CHECK_PARSER_CONFIG_RET(ret, "whiteBalance");
96 ispConfig->ctrlValueNum = drsOps->GetElemNum(node, "ctrlValue");
97 if (ispConfig->ctrlValueNum > CTRL_VALUE_MAX_NUM) {
98 HDF_LOGE("%s: parser ctrlValue num failed! num = %{public}d", __func__, ispConfig->ctrlValueNum);
99 return HDF_ERR_INVALID_PARAM;
100 }
101 ret = drsOps->GetUint32Array(node, "ctrlValue", ispConfig->ctrlValue, ispConfig->ctrlValueNum, 0);
102 CHECK_PARSER_CONFIG_RET(ret, "ctrlValue");
103 SetCtrlCapInfo(ispConfig->ctrlCap, ispConfig->ctrlValueNum, ispConfig->ctrlValue);
104
105 HDF_LOGD("%s: name=%{public}s, id=%{public}d, brightness=%{public}d, contrast=%{public}d, saturation=%{public}d, "
106 "sharpness=%{public}d, gain=%{public}d, gamma=%{public}d, whiteBalance=%{public}d", __func__, ispConfig->name,
107 ispConfig->id, ispConfig->brightness, ispConfig->contrast, ispConfig->saturation,
108 ispConfig->sharpness, ispConfig->gain, ispConfig->gamma, ispConfig->whiteBalance);
109 return HDF_SUCCESS;
110 }
111
ParseCameraVcmDeviceConfig(const struct DeviceResourceNode * node,struct DeviceResourceIface * drsOps,struct VcmDeviceConfig * vcmConfig)112 static int32_t ParseCameraVcmDeviceConfig(const struct DeviceResourceNode *node,
113 struct DeviceResourceIface *drsOps, struct VcmDeviceConfig *vcmConfig)
114 {
115 int32_t ret;
116
117 ret = drsOps->GetString(node, "name", &vcmConfig->name, NULL);
118 CHECK_PARSER_CONFIG_RET(ret, "name");
119 ret = drsOps->GetUint8(node, "id", &vcmConfig->id, 0);
120 CHECK_PARSER_CONFIG_RET(ret, "id");
121 ret = drsOps->GetUint8(node, "focus", &vcmConfig->focus, 0);
122 CHECK_PARSER_CONFIG_RET(ret, "focus");
123 ret = drsOps->GetUint8(node, "autoFocus", &vcmConfig->autoFocus, 0);
124 CHECK_PARSER_CONFIG_RET(ret, "autoFocus");
125 ret = drsOps->GetUint8(node, "zoom", &vcmConfig->zoom, 0);
126 CHECK_PARSER_CONFIG_RET(ret, "zoom");
127 ret = drsOps->GetUint32(node, "zoomMaxNum", &vcmConfig->zoomMaxNum, 0);
128 CHECK_PARSER_CONFIG_RET(ret, "zoomMaxNum");
129 vcmConfig->ctrlValueNum = drsOps->GetElemNum(node, "ctrlValue");
130 if (vcmConfig->ctrlValueNum > CTRL_VALUE_MAX_NUM) {
131 HDF_LOGE("%s: parser ctrlValue num failed! num = %{public}d", __func__, vcmConfig->ctrlValueNum);
132 return HDF_ERR_INVALID_PARAM;
133 }
134 ret = drsOps->GetUint32Array(node, "ctrlValue", vcmConfig->ctrlValue, vcmConfig->ctrlValueNum, 0);
135 CHECK_PARSER_CONFIG_RET(ret, "ctrlValue");
136 SetCtrlCapInfo(vcmConfig->ctrlCap, vcmConfig->ctrlValueNum, vcmConfig->ctrlValue);
137
138 HDF_LOGD("%s: name=%{public}s, id=%{public}d, focus=%{public}d, autoFocus=%{public}d, zoom=%{public}d,"
139 "zoomMaxNum=%{public}d", __func__, vcmConfig->name, vcmConfig->id, vcmConfig->focus, vcmConfig->autoFocus,
140 vcmConfig->zoom, vcmConfig->zoomMaxNum);
141
142 return HDF_SUCCESS;
143 }
144
ParseCameraLensDeviceConfig(const struct DeviceResourceNode * node,struct DeviceResourceIface * drsOps,struct LensDeviceConfig * lensConfig)145 static int32_t ParseCameraLensDeviceConfig(const struct DeviceResourceNode *node,
146 struct DeviceResourceIface *drsOps, struct LensDeviceConfig *lensConfig)
147 {
148 int32_t ret;
149
150 ret = drsOps->GetString(node, "name", &lensConfig->name, NULL);
151 CHECK_PARSER_CONFIG_RET(ret, "name");
152 ret = drsOps->GetUint8(node, "id", &lensConfig->id, 0);
153 CHECK_PARSER_CONFIG_RET(ret, "id");
154 ret = drsOps->GetUint8(node, "aperture", &lensConfig->aperture, 0);
155 CHECK_PARSER_CONFIG_RET(ret, "aperture");
156 lensConfig->ctrlValueNum = drsOps->GetElemNum(node, "ctrlValue");
157 if (lensConfig->ctrlValueNum > CTRL_VALUE_MAX_NUM) {
158 HDF_LOGE("%s: parser ctrlValue num failed! num = %{public}d", __func__, lensConfig->ctrlValueNum);
159 return HDF_ERR_INVALID_PARAM;
160 }
161 ret = drsOps->GetUint32Array(node, "ctrlValue", lensConfig->ctrlValue, lensConfig->ctrlValueNum, 0);
162 CHECK_PARSER_CONFIG_RET(ret, "ctrlValue");
163 SetCtrlCapInfo(lensConfig->ctrlCap, lensConfig->ctrlValueNum, lensConfig->ctrlValue);
164
165 HDF_LOGD("%s: name=%{public}s, id=%{public}d, aperture=%{public}d", __func__,
166 lensConfig->name, lensConfig->id, lensConfig->aperture);
167 return HDF_SUCCESS;
168 }
169
ParseCameraFlashDeviceConfig(const struct DeviceResourceNode * node,struct DeviceResourceIface * drsOps,struct FlashDeviceConfig * flashConfig)170 static int32_t ParseCameraFlashDeviceConfig(const struct DeviceResourceNode *node,
171 struct DeviceResourceIface *drsOps, struct FlashDeviceConfig *flashConfig)
172 {
173 int32_t ret;
174
175 ret = drsOps->GetString(node, "name", &flashConfig->name, NULL);
176 CHECK_PARSER_CONFIG_RET(ret, "name");
177 ret = drsOps->GetUint8(node, "id", &flashConfig->id, 0);
178 CHECK_PARSER_CONFIG_RET(ret, "id");
179 ret = drsOps->GetUint8(node, "flashMode", &flashConfig->flashMode, 0);
180 CHECK_PARSER_CONFIG_RET(ret, "flashMode");
181 ret = drsOps->GetUint8(node, "flashIntensity", &flashConfig->flashIntensity, 0);
182 CHECK_PARSER_CONFIG_RET(ret, "flashIntensity");
183 flashConfig->ctrlValueNum = drsOps->GetElemNum(node, "ctrlValue");
184 if (flashConfig->ctrlValueNum > CTRL_VALUE_MAX_NUM) {
185 HDF_LOGE("%s: parser ctrlValue num failed! num = %{public}d", __func__, flashConfig->ctrlValueNum);
186 return HDF_ERR_INVALID_PARAM;
187 }
188 ret = drsOps->GetUint32Array(node, "ctrlValue", flashConfig->ctrlValue, flashConfig->ctrlValueNum, 0);
189 CHECK_PARSER_CONFIG_RET(ret, "ctrlValue");
190 SetCtrlCapInfo(flashConfig->ctrlCap, flashConfig->ctrlValueNum, flashConfig->ctrlValue);
191
192 HDF_LOGD("%s: name=%{public}s, id=%{public}d, flashMode=%{public}d, flashIntensity=%{public}d", __func__,
193 flashConfig->name, flashConfig->id, flashConfig->flashMode, flashConfig->flashIntensity);
194 return HDF_SUCCESS;
195 }
196
ParseCameraStreamDeviceConfigs(const struct DeviceResourceNode * node,struct DeviceResourceIface * drsOps,struct StreamDeviceConfig * streamConfig)197 static int32_t ParseCameraStreamDeviceConfigs(const struct DeviceResourceNode *node,
198 struct DeviceResourceIface *drsOps, struct StreamDeviceConfig *streamConfig)
199 {
200 int32_t ret;
201
202 ret = drsOps->GetString(node, "name", &streamConfig->name, NULL);
203 CHECK_PARSER_CONFIG_RET(ret, "name");
204 ret = drsOps->GetUint8(node, "id", &streamConfig->id, 0);
205 CHECK_PARSER_CONFIG_RET(ret, "id");
206 ret = drsOps->GetUint32(node, "heightMaxNum", &streamConfig->heightMaxNum, 0);
207 CHECK_PARSER_CONFIG_RET(ret, "heightMaxNum");
208 ret = drsOps->GetUint32(node, "widthMaxNum", &streamConfig->widthMaxNum, 0);
209 CHECK_PARSER_CONFIG_RET(ret, "widthMaxNum");
210 ret = drsOps->GetUint32(node, "frameRateMaxNum", &streamConfig->frameRateMaxNum, 0);
211 CHECK_PARSER_CONFIG_RET(ret, "frameRateMaxNum");
212 ret = drsOps->GetUint8(node, "bufferCount", &streamConfig->bufferCount, 0);
213 CHECK_PARSER_CONFIG_RET(ret, "bufferCount");
214
215 return HDF_SUCCESS;
216 }
217
ParseCameraStreamDeviceConfig(const struct DeviceResourceNode * node,struct DeviceResourceIface * drsOps,struct StreamDeviceConfig * streamConfig)218 static int32_t ParseCameraStreamDeviceConfig(const struct DeviceResourceNode *node,
219 struct DeviceResourceIface *drsOps, struct StreamDeviceConfig *streamConfig)
220 {
221 int32_t i;
222 int32_t ret;
223
224 ret = ParseCameraStreamDeviceConfigs(node, drsOps, streamConfig);
225 CHECK_PARSER_CONFIG_RET(ret, "streamStatus");
226 streamConfig->bufferTypeNum = drsOps->GetElemNum(node, "bufferType");
227 if (streamConfig->bufferTypeNum == 0 || streamConfig->bufferTypeNum > BUFFER_TYPE_MAX_NUM) {
228 HDF_LOGE("%s: parser bufferType element num failed! num = %{public}d", __func__, streamConfig->bufferTypeNum);
229 return HDF_ERR_INVALID_PARAM;
230 }
231 ret = drsOps->GetUint32Array(node, "bufferType", streamConfig->bufferType, streamConfig->bufferTypeNum, 0);
232 CHECK_PARSER_CONFIG_RET(ret, "bufferType");
233
234 for (i = 0; i < streamConfig->bufferTypeNum; i++) {
235 HDF_LOGD("%s: get bufferType[%{public}d] = %{public}d", __func__, i, streamConfig->bufferType[i]);
236 }
237
238 streamConfig->formatTypeNum = drsOps->GetElemNum(node, "formatType");
239 if (streamConfig->formatTypeNum == 0 || streamConfig->formatTypeNum > FORMAT_TYPE_MAX_NUM) {
240 HDF_LOGE("%s: parser formatType element num failed! num = %{public}d", __func__, streamConfig->formatTypeNum);
241 return HDF_ERR_INVALID_PARAM;
242 }
243 ret = drsOps->GetUint32Array(node, "formatType", streamConfig->formatType, streamConfig->formatTypeNum, 0);
244 CHECK_PARSER_CONFIG_RET(ret, "formatType");
245
246 for (i = 0; i < streamConfig->formatTypeNum; i++) {
247 HDF_LOGD("%s: get formatType[%{public}d] = %{public}d", __func__, i, streamConfig->formatType[i]);
248 }
249
250 HDF_LOGD("%s: name=%{public}s, id=%{public}d, heightMaxNum=%{public}d, widthMaxNum=%{public}d, "
251 "frameRateMaxNum=%{public}d, bufferCount=%{public}d", __func__, streamConfig->name, streamConfig->id,
252 streamConfig->heightMaxNum, streamConfig->widthMaxNum, streamConfig->frameRateMaxNum,
253 streamConfig->bufferCount);
254 return HDF_SUCCESS;
255 }
256
ParseCameraSensorConfig(const struct DeviceResourceNode * node,struct DeviceResourceIface * drsOps,struct CameraSensorConfig * sensorConfig)257 static int32_t ParseCameraSensorConfig(const struct DeviceResourceNode *node,
258 struct DeviceResourceIface *drsOps, struct CameraSensorConfig *sensorConfig)
259 {
260 struct DeviceResourceNode *childNode = NULL;
261 int32_t ret;
262 uint32_t cnt = 0;
263
264 ret = drsOps->GetUint8(node, "mode", &sensorConfig->mode, 0);
265 CHECK_PARSER_CONFIG_RET(ret, "mode");
266
267 if (sensorConfig->mode == DEVICE_NOT_SUPPORT) {
268 HDF_LOGD("%s: not support sensor!", __func__);
269 return HDF_SUCCESS;
270 }
271
272 DEV_RES_NODE_FOR_EACH_CHILD_NODE(node, childNode)
273 {
274 if (ParseCameraSensorDeviceConfig(childNode, drsOps, &sensorConfig->sensor[cnt]) != HDF_SUCCESS) {
275 HDF_LOGE("%s: Parse sensor[%{public}d] failed!", __func__, cnt);
276 return HDF_FAILURE;
277 }
278 cnt++;
279 sensorConfig->sensorNum++;
280 }
281 HDF_LOGD("%s: sensorConfig->sensorNum = %{public}d!", __func__, sensorConfig->sensorNum);
282
283 return HDF_SUCCESS;
284 }
285
ParseCameraIspConfig(const struct DeviceResourceNode * node,struct DeviceResourceIface * drsOps,struct CameraIspConfig * ispConfig)286 static int32_t ParseCameraIspConfig(const struct DeviceResourceNode *node,
287 struct DeviceResourceIface *drsOps, struct CameraIspConfig *ispConfig)
288 {
289 struct DeviceResourceNode *childNode = NULL;
290 int32_t ret;
291 uint32_t cnt = 0;
292
293 ret = drsOps->GetUint8(node, "mode", &ispConfig->mode, 0);
294 CHECK_PARSER_CONFIG_RET(ret, "mode");
295
296 if (ispConfig->mode == DEVICE_NOT_SUPPORT) {
297 HDF_LOGD("%s: not support isp!", __func__);
298 return HDF_SUCCESS;
299 }
300
301 DEV_RES_NODE_FOR_EACH_CHILD_NODE(node, childNode)
302 {
303 if (ParseCameraIspDeviceConfig(childNode, drsOps, &ispConfig->isp[cnt]) != HDF_SUCCESS) {
304 HDF_LOGE("%s: Parse isp[%{public}d] failed!", __func__, cnt);
305 return HDF_FAILURE;
306 }
307 cnt++;
308 ispConfig->ispNum++;
309 }
310 HDF_LOGD("%s: ispConfig->ispNum = %{public}d!", __func__, ispConfig->ispNum);
311
312 return HDF_SUCCESS;
313 }
314
ParseCameraLensConfig(const struct DeviceResourceNode * node,struct DeviceResourceIface * drsOps,struct CameraLensConfig * lensConfig)315 static int32_t ParseCameraLensConfig(const struct DeviceResourceNode *node,
316 struct DeviceResourceIface *drsOps, struct CameraLensConfig *lensConfig)
317 {
318 struct DeviceResourceNode *childNode = NULL;
319 int32_t ret;
320 uint32_t cnt = 0;
321
322 ret = drsOps->GetUint8(node, "mode", &lensConfig->mode, 0);
323 CHECK_PARSER_CONFIG_RET(ret, "mode");
324
325 if (lensConfig->mode == DEVICE_NOT_SUPPORT) {
326 HDF_LOGD("%s: not support lens!", __func__);
327 return HDF_SUCCESS;
328 }
329
330 DEV_RES_NODE_FOR_EACH_CHILD_NODE(node, childNode)
331 {
332 if (ParseCameraLensDeviceConfig(childNode, drsOps, &lensConfig->lens[cnt]) != HDF_SUCCESS) {
333 HDF_LOGE("%s: Parse lens[%{public}d] failed!", __func__, cnt);
334 return HDF_FAILURE;
335 }
336 cnt++;
337 lensConfig->lensNum++;
338 }
339 HDF_LOGD("%s: lensConfig->lensNum = %{public}d!", __func__, lensConfig->lensNum);
340
341 return HDF_SUCCESS;
342 }
343
ParseCameraVcmConfig(const struct DeviceResourceNode * node,struct DeviceResourceIface * drsOps,struct CameraVcmConfig * vcmConfig)344 static int32_t ParseCameraVcmConfig(const struct DeviceResourceNode *node,
345 struct DeviceResourceIface *drsOps, struct CameraVcmConfig *vcmConfig)
346 {
347 struct DeviceResourceNode *childNode = NULL;
348 int32_t ret;
349 uint32_t cnt = 0;
350
351 ret = drsOps->GetUint8(node, "mode", &vcmConfig->mode, 0);
352 CHECK_PARSER_CONFIG_RET(ret, "mode");
353
354 if (vcmConfig->mode == DEVICE_NOT_SUPPORT) {
355 HDF_LOGD("%s: not support vcm!", __func__);
356 return HDF_SUCCESS;
357 }
358
359 DEV_RES_NODE_FOR_EACH_CHILD_NODE(node, childNode)
360 {
361 if (ParseCameraVcmDeviceConfig(childNode, drsOps, &vcmConfig->vcm[cnt]) != HDF_SUCCESS) {
362 HDF_LOGE("%s: Parse vcm[%{public}d] failed!", __func__, cnt);
363 return HDF_FAILURE;
364 }
365 cnt++;
366 vcmConfig->vcmNum++;
367 }
368 HDF_LOGD("%s: vcmConfig->vcmNum = %{public}d!", __func__, vcmConfig->vcmNum);
369
370 return HDF_SUCCESS;
371 }
372
ParseCameraFlashConfig(const struct DeviceResourceNode * node,struct DeviceResourceIface * drsOps,struct CameraFlashConfig * flashConfig)373 static int32_t ParseCameraFlashConfig(const struct DeviceResourceNode *node,
374 struct DeviceResourceIface *drsOps, struct CameraFlashConfig *flashConfig)
375 {
376 struct DeviceResourceNode *childNode = NULL;
377 int32_t ret;
378 uint32_t cnt = 0;
379
380 ret = drsOps->GetUint8(node, "mode", &flashConfig->mode, 0);
381 CHECK_PARSER_CONFIG_RET(ret, "mode");
382
383 if (flashConfig->mode == DEVICE_NOT_SUPPORT) {
384 HDF_LOGD("%s: not support flash!", __func__);
385 return HDF_SUCCESS;
386 }
387
388 DEV_RES_NODE_FOR_EACH_CHILD_NODE(node, childNode)
389 {
390 if (ParseCameraFlashDeviceConfig(childNode, drsOps, &flashConfig->flash[cnt]) != HDF_SUCCESS) {
391 HDF_LOGE("%s: Parse flash[%{public}d] failed!", __func__, cnt);
392 return HDF_FAILURE;
393 }
394 cnt++;
395 flashConfig->flashNum++;
396 }
397 HDF_LOGD("%s: flashConfig->flashNum = %{public}d!", __func__, flashConfig->flashNum);
398
399 return HDF_SUCCESS;
400 }
401
ParseCameraStreamConfig(const struct DeviceResourceNode * node,struct DeviceResourceIface * drsOps,struct CameraStreamConfig * streamConfig)402 static int32_t ParseCameraStreamConfig(const struct DeviceResourceNode *node,
403 struct DeviceResourceIface *drsOps, struct CameraStreamConfig *streamConfig)
404 {
405 struct DeviceResourceNode *childNode = NULL;
406 int32_t ret;
407 uint32_t cnt = 0;
408
409 ret = drsOps->GetUint8(node, "mode", &streamConfig->mode, 0);
410 CHECK_PARSER_CONFIG_RET(ret, "mode");
411
412 if (streamConfig->mode == DEVICE_NOT_SUPPORT) {
413 HDF_LOGD("%s: not support stream!", __func__);
414 return HDF_SUCCESS;
415 }
416
417 DEV_RES_NODE_FOR_EACH_CHILD_NODE(node, childNode)
418 {
419 if (ParseCameraStreamDeviceConfig(childNode, drsOps, &streamConfig->stream[cnt]) != HDF_SUCCESS) {
420 HDF_LOGE("%s: Parse stream[%{public}d] failed!", __func__, cnt);
421 return HDF_FAILURE;
422 }
423 cnt++;
424 streamConfig->streamNum++;
425 }
426 HDF_LOGD("%s: streamConfig->streamNum = %{public}d!", __func__, streamConfig->streamNum);
427
428 return HDF_SUCCESS;
429 }
430
ParseCameraDeviceConfig(const struct DeviceResourceNode * node,struct DeviceResourceIface * drsOps,struct CameraDeviceConfig * deviceConfig)431 static int32_t ParseCameraDeviceConfig(const struct DeviceResourceNode *node,
432 struct DeviceResourceIface *drsOps, struct CameraDeviceConfig *deviceConfig)
433 {
434 const struct DeviceResourceNode *sensorConfigNode = NULL;
435 const struct DeviceResourceNode *ispConfigNode = NULL;
436 const struct DeviceResourceNode *vcmConfigNode = NULL;
437 const struct DeviceResourceNode *lensConfigNode = NULL;
438 const struct DeviceResourceNode *flashConfigNode = NULL;
439 const struct DeviceResourceNode *streamConfigNode = NULL;
440
441 if (drsOps->GetString(node, "deviceName", &deviceConfig->deviceName, NULL) != HDF_SUCCESS) {
442 HDF_LOGE("%s: get deviceName fail!", __func__);
443 return HDF_FAILURE;
444 }
445 sensorConfigNode = drsOps->GetChildNode(node, "SensorConfig");
446 ispConfigNode = drsOps->GetChildNode(node, "IspConfig");
447 vcmConfigNode = drsOps->GetChildNode(node, "VcmConfig");
448 lensConfigNode = drsOps->GetChildNode(node, "LensConfig");
449 flashConfigNode = drsOps->GetChildNode(node, "FlashConfig");
450 streamConfigNode = drsOps->GetChildNode(node, "StreamConfig");
451 if (sensorConfigNode == NULL || ispConfigNode == NULL || vcmConfigNode == NULL ||
452 lensConfigNode == NULL || flashConfigNode == NULL || streamConfigNode == NULL) {
453 HDF_LOGE("%s: get child node fail!", __func__);
454 return HDF_FAILURE;
455 }
456 CHECK_PARSER_CONFIG_RET(ParseCameraSensorConfig(sensorConfigNode, drsOps, &deviceConfig->sensor), "SensorConfig");
457 CHECK_PARSER_CONFIG_RET(ParseCameraIspConfig(ispConfigNode, drsOps, &deviceConfig->isp), "IspConfig");
458 CHECK_PARSER_CONFIG_RET(ParseCameraVcmConfig(vcmConfigNode, drsOps, &deviceConfig->vcm), "VcmConfig");
459 CHECK_PARSER_CONFIG_RET(ParseCameraLensConfig(lensConfigNode, drsOps, &deviceConfig->lens), "LensConfig");
460 CHECK_PARSER_CONFIG_RET(ParseCameraFlashConfig(flashConfigNode, drsOps, &deviceConfig->flash), "FlashConfig");
461 CHECK_PARSER_CONFIG_RET(ParseCameraStreamConfig(streamConfigNode, drsOps, &deviceConfig->stream), "StreamConfig");
462
463 return HDF_SUCCESS;
464 }
465
ParseCameraConfig(const struct DeviceResourceNode * node,struct DeviceResourceIface * drsOps,struct CameraConfigRoot * cameraConfig)466 static int32_t ParseCameraConfig(const struct DeviceResourceNode *node,
467 struct DeviceResourceIface *drsOps, struct CameraConfigRoot *cameraConfig)
468 {
469 struct DeviceResourceNode *childNode = NULL;
470 uint32_t cnt = 0;
471 int32_t ret;
472
473 ret = drsOps->GetUint8(node, "uvcMode", &cameraConfig->uvcMode, 0);
474 CHECK_PARSER_CONFIG_RET(ret, "uvcMode");
475
476 if (cameraConfig->uvcMode == DEVICE_NOT_SUPPORT) {
477 HDF_LOGD("%s: not support uvc!", __func__);
478 }
479
480 DEV_RES_NODE_FOR_EACH_CHILD_NODE(node, childNode)
481 {
482 if (ParseCameraDeviceConfig(childNode, drsOps, &cameraConfig->deviceConfig[cnt]) != HDF_SUCCESS) {
483 return HDF_FAILURE;
484 }
485 cnt++;
486 cameraConfig->deviceNum++;
487 }
488 HDF_LOGD("%s: uvcMode = %{public}d, cameraConfig->deviceNum = %{public}d!", __func__,
489 cameraConfig->uvcMode, cameraConfig->deviceNum);
490
491 return HDF_SUCCESS;
492 }
493
HdfParseCameraConfig(const struct DeviceResourceNode * node)494 int32_t HdfParseCameraConfig(const struct DeviceResourceNode *node)
495 {
496 struct DeviceResourceIface *drsOps = NULL;
497 const struct DeviceResourceNode *cameraConfigNode = NULL;
498 int32_t ret;
499
500 if (node == NULL) {
501 HDF_LOGE("%s: node is null!", __func__);
502 return HDF_ERR_INVALID_PARAM;
503 }
504 drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
505 if (drsOps == NULL || drsOps->GetString == NULL || drsOps->GetUint8 == NULL ||
506 drsOps->GetUint8Array == NULL || drsOps->GetUint32 == NULL ||
507 drsOps->GetElemNum == NULL || drsOps->GetUint32Array == NULL) {
508 HDF_LOGE("%s: invalid drs ops fail!", __func__);
509 return HDF_FAILURE;
510 }
511
512 cameraConfigNode = drsOps->GetChildNode(node, "abilityConfig");
513 if (cameraConfigNode == NULL) {
514 HDF_LOGE("%s: get child node fail!", __func__);
515 return HDF_FAILURE;
516 }
517 ret = ParseCameraConfig(cameraConfigNode, drsOps, &g_configCameraRoot);
518 if (ret != HDF_SUCCESS) {
519 HDF_LOGE("%s: ParseCameraConfig failed!", __func__);
520 }
521 return ret;
522 }
523
HdfCameraGetConfigRoot(void)524 struct CameraConfigRoot *HdfCameraGetConfigRoot(void)
525 {
526 return &g_configCameraRoot;
527 }
528