1 /*
2  * Copyright (c) 2020-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_wlan_config.h"
10 #include "hdf_log.h"
11 
12 #define HDF_LOG_TAG HDF_WIFI_CORE
13 static struct HdfConfigWlanRoot g_configWlanModuleRoot = { 0 };
ParseWlanStaConfig(const struct DeviceResourceNode * node,struct HdfConfigWlanStation * staConfig)14 static int32_t ParseWlanStaConfig(const struct DeviceResourceNode *node, struct HdfConfigWlanStation *staConfig)
15 {
16     struct DeviceResourceIface *drsOps = NULL;
17     int32_t ret;
18 
19     if (node == NULL || staConfig == NULL) {
20         HDF_LOGE("%s: invalid node or staConfig!", __func__);
21         return HDF_FAILURE;
22     }
23     drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
24     if (drsOps == NULL || drsOps->GetString == NULL || drsOps->GetUint8 == NULL) {
25         HDF_LOGE("%s: invalid drs ops fail!", __func__);
26         return HDF_FAILURE;
27     }
28     ret = drsOps->GetString(node, "name", &staConfig->name, NULL);
29     if (ret != HDF_SUCCESS) {
30         HDF_LOGE("%s: GetString fail!", __func__);
31         return HDF_FAILURE;
32     }
33     ret = drsOps->GetUint8(node, "mode", &staConfig->mode, 0);
34     if (ret != HDF_SUCCESS) {
35         HDF_LOGE("%s: GetUint8 fail!", __func__);
36         return HDF_FAILURE;
37     }
38     HDF_LOGD("%s: name=%s, mode=%u!", __func__, staConfig->name, staConfig->mode);
39     return HDF_SUCCESS;
40 }
41 
ParseWlanApConfig(const struct DeviceResourceNode * node,struct HdfConfigWlanHostAp * apConfig)42 static int32_t ParseWlanApConfig(const struct DeviceResourceNode *node, struct HdfConfigWlanHostAp *apConfig)
43 {
44     struct DeviceResourceIface *drsOps = NULL;
45     int32_t ret;
46 
47     if (node == NULL || apConfig == NULL) {
48         HDF_LOGE("%s: invalid node or apConfig!", __func__);
49         return HDF_FAILURE;
50     }
51     drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
52     if (drsOps == NULL || drsOps->GetString == NULL || drsOps->GetUint8 == NULL) {
53         HDF_LOGE("%s: invalid drs ops fail!", __func__);
54         return HDF_FAILURE;
55     }
56     ret = drsOps->GetString(node, "name", &apConfig->name, NULL);
57     if (ret != HDF_SUCCESS) {
58         HDF_LOGE("%s: name fail!", __func__);
59         return HDF_FAILURE;
60     }
61     ret = drsOps->GetUint8(node, "mode", &apConfig->mode, 0);
62     if (ret != HDF_SUCCESS) {
63         HDF_LOGE("%s: mode fail!", __func__);
64         return HDF_FAILURE;
65     }
66     ret = drsOps->GetUint8(node, "vapResNum", &apConfig->vapResNum, 0);
67     if (ret != HDF_SUCCESS) {
68         HDF_LOGE("%s: get vapResNnm fail!", __func__);
69         return HDF_FAILURE;
70     }
71     ret = drsOps->GetUint8(node, "userResNum", &apConfig->userResNum, 0);
72     if (ret != HDF_SUCCESS) {
73         HDF_LOGE("%s: get userResNum fail!", __func__);
74         return HDF_FAILURE;
75     }
76     HDF_LOGD("%s: name=%s, mode=%u, vapResNum=%u, userResNum=%u!", __func__, apConfig->name, apConfig->mode,
77         apConfig->vapResNum, apConfig->userResNum);
78     return HDF_SUCCESS;
79 }
80 
ParseWlanP2PConfig(const struct DeviceResourceNode * node,struct HdfConfigWlanP2P * p2pConfig)81 static int32_t ParseWlanP2PConfig(const struct DeviceResourceNode *node, struct HdfConfigWlanP2P *p2pConfig)
82 {
83     struct DeviceResourceIface *drsOps = NULL;
84     int32_t ret;
85 
86     if (node == NULL || p2pConfig == NULL) {
87         HDF_LOGE("%s: invalid node or p2pConfig!", __func__);
88         return HDF_FAILURE;
89     }
90     drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
91     if (drsOps == NULL || drsOps->GetString == NULL || drsOps->GetUint8 == NULL) {
92         HDF_LOGE("%s: invalid drs ops fail!", __func__);
93         return HDF_FAILURE;
94     }
95     ret = drsOps->GetString(node, "name", &p2pConfig->name, NULL);
96     if (ret != HDF_SUCCESS) {
97         HDF_LOGE("%s: name fail!", __func__);
98         return HDF_FAILURE;
99     }
100     ret = drsOps->GetUint8(node, "mode", &p2pConfig->mode, 0);
101     if (ret != HDF_SUCCESS) {
102         HDF_LOGE("%s: mode fail!", __func__);
103         return HDF_FAILURE;
104     }
105     HDF_LOGD("%s: name=%s, mode=%u", __func__, p2pConfig->name, p2pConfig->mode);
106     return HDF_SUCCESS;
107 }
108 
ParseWlanMac80211Config(const struct DeviceResourceNode * node,struct HdfConfigWlanMac80211 * macConfig)109 static int32_t ParseWlanMac80211Config(const struct DeviceResourceNode *node, struct HdfConfigWlanMac80211 *macConfig)
110 {
111     struct DeviceResourceIface *drsOps = NULL;
112     int32_t ret;
113 
114     if (node == NULL || macConfig == NULL) {
115         HDF_LOGE("%s: invalid node or macConfig!", __func__);
116         return HDF_FAILURE;
117     }
118     drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
119     if (drsOps == NULL || drsOps->GetUint8 == NULL) {
120         HDF_LOGE("%s: invalid drs ops fail!", __func__);
121         return HDF_FAILURE;
122     }
123     ret = drsOps->GetUint8(node, "mode", &macConfig->mode, 0);
124     if (ret != HDF_SUCCESS) {
125         HDF_LOGE("%s: mode fail!", __func__);
126         return HDF_FAILURE;
127     }
128     HDF_LOGD("%s: mode=%u", __func__, macConfig->mode);
129     return HDF_SUCCESS;
130 }
131 
ParseWlanPhyConfig(const struct DeviceResourceNode * node,struct HdfConfigWlanPhy * phyConfig)132 static int32_t ParseWlanPhyConfig(const struct DeviceResourceNode *node, struct HdfConfigWlanPhy *phyConfig)
133 {
134     struct DeviceResourceIface *drsOps = NULL;
135     int32_t ret;
136 
137     if (node == NULL || phyConfig == NULL) {
138         HDF_LOGE("%s: invalid node or macConfig!\n", __func__);
139         return HDF_FAILURE;
140     }
141     drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
142     if (drsOps == NULL || drsOps->GetUint8 == NULL) {
143         HDF_LOGE("%s: invalid drs ops fail!\n", __func__);
144         return HDF_FAILURE;
145     }
146     ret = drsOps->GetUint8(node, "mode", &phyConfig->mode, 0);
147     if (ret != HDF_SUCCESS) {
148         HDF_LOGE("%s: mode fail!\n", __func__);
149         return HDF_FAILURE;
150     }
151     HDF_LOGD("%s: mode=%d\n", __func__, phyConfig->mode);
152     return HDF_SUCCESS;
153 }
154 
ParseWlanModuleConfig(const struct DeviceResourceNode * node,struct HdfConfigWlanModuleConfig * modConfig)155 static int32_t ParseWlanModuleConfig(const struct DeviceResourceNode *node, struct HdfConfigWlanModuleConfig *modConfig)
156 {
157     struct DeviceResourceIface *drsOps = NULL;
158     int32_t ret;
159     const struct DeviceResourceNode *staConfigNode = NULL;
160     const struct DeviceResourceNode *apConfigNode = NULL;
161     const struct DeviceResourceNode *p2pConfigNode = NULL;
162     const struct DeviceResourceNode *macConfigNode = NULL;
163     const struct DeviceResourceNode *phyConfigNode = NULL;
164 
165     if (node == NULL || modConfig == NULL) {
166         HDF_LOGE("%s: invalid node or moduleConfig!", __func__);
167         return HDF_FAILURE;
168     }
169     drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
170     if (drsOps == NULL || drsOps->GetChildNode == NULL || drsOps->GetString == NULL || drsOps->GetUint32 == NULL) {
171         HDF_LOGE("%s: invalid drs ops fail!", __func__);
172         return HDF_FAILURE;
173     }
174     ret = drsOps->GetUint32(node, "featureMap", &modConfig->featureMap, 0);
175     if (ret != HDF_SUCCESS) {
176         HDF_LOGE("%s: featureMap fail!", __func__);
177         return HDF_FAILURE;
178     }
179     ret = drsOps->GetString(node, "msgName", &modConfig->msgName, NULL);
180     if (ret != HDF_SUCCESS) {
181         HDF_LOGE("%s: msgName fail!", __func__);
182         return HDF_FAILURE;
183     }
184 
185     staConfigNode = drsOps->GetChildNode(node, "Station");
186     apConfigNode = drsOps->GetChildNode(node, "HostAp");
187     p2pConfigNode = drsOps->GetChildNode(node, "P2P");
188     macConfigNode = drsOps->GetChildNode(node, "Mac80211");
189     phyConfigNode = drsOps->GetChildNode(node, "Phy");
190     if (staConfigNode == NULL || apConfigNode == NULL || p2pConfigNode == NULL || macConfigNode == NULL ||
191         phyConfigNode == NULL) {
192         HDF_LOGE("%s: get child node fail!", __func__);
193         return HDF_FAILURE;
194     }
195     if (ParseWlanStaConfig(staConfigNode, &modConfig->station) != HDF_SUCCESS) {
196         return HDF_FAILURE;
197     }
198     if (ParseWlanApConfig(apConfigNode, &modConfig->hostAp) != HDF_SUCCESS) {
199         return HDF_FAILURE;
200     }
201     if (ParseWlanP2PConfig(p2pConfigNode, &modConfig->p2p) != HDF_SUCCESS) {
202         return HDF_FAILURE;
203     }
204     if (ParseWlanMac80211Config(macConfigNode, &modConfig->mac80211) != HDF_SUCCESS) {
205         return HDF_FAILURE;
206     }
207     if (ParseWlanPhyConfig(phyConfigNode, &modConfig->Phy) != HDF_SUCCESS) {
208         return HDF_FAILURE;
209     }
210     HDF_LOGD("%s: featureMap=%0x, msgName=%s", __func__, modConfig->featureMap, modConfig->msgName);
211     return HDF_SUCCESS;
212 }
213 /* BEGIN for WLAN2.1 : Added by hdf-wlan */
ParseWlanPowerConfig(const struct DeviceResourceNode * node,struct HdfConfigWlanPower * primaryPowerConfig)214 static int32_t ParseWlanPowerConfig(const struct DeviceResourceNode *node,
215     struct HdfConfigWlanPower *primaryPowerConfig)
216 {
217     struct DeviceResourceIface *drsOps = NULL;
218     if (node == NULL || primaryPowerConfig == NULL) {
219         HDF_LOGE("%s: one of the input para is NULL!", __func__);
220         return HDF_FAILURE;
221     }
222     drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
223     if (drsOps == NULL || drsOps->GetUint8 == NULL || drsOps->GetUint16 == NULL) {
224         HDF_LOGE("%s: at least one of the paras is NULL!", __func__);
225         return HDF_FAILURE;
226     }
227 
228     if (drsOps->GetUint8(node, "powerSeqDelay", &primaryPowerConfig->powerSeqDelay, 0) != HDF_SUCCESS) {
229         HDF_LOGE("%s: powersSeqDelay fail!", __func__);
230         return HDF_FAILURE;
231     }
232 
233     if (drsOps->GetUint8(node, "powerType", &primaryPowerConfig->powerType, 0) != HDF_SUCCESS) {
234         HDF_LOGE("%s: powerType fail!", __func__);
235         return HDF_FAILURE;
236     }
237 
238     if (drsOps->GetUint16(node, "gpioId", &primaryPowerConfig->gpioId, 0) != HDF_SUCCESS) {
239         HDF_LOGE("%s: gpioId fail!", __func__);
240         return HDF_FAILURE;
241     }
242     if (drsOps->GetUint8(node, "activeLevel", &primaryPowerConfig->activeLevel, 0) != HDF_SUCCESS) {
243         HDF_LOGE("%s: activeLevel fail!", __func__);
244         return HDF_FAILURE;
245     }
246     HDF_LOGD("%s: ParseWlanPowerConfig successful!", __func__);
247     return HDF_SUCCESS;
248 }
249 
250 /* BEGIN for WLAN2.1 to get powers config: Added by hdf-wlan */
ParseWlanPowersConfig(const struct DeviceResourceNode * node,struct HdfConfWlanPowers * powersConfig)251 static int32_t ParseWlanPowersConfig(const struct DeviceResourceNode *node, struct HdfConfWlanPowers *powersConfig)
252 {
253     struct DeviceResourceIface *drsOps = NULL;
254     const struct DeviceResourceNode *fstPowerNode = NULL;
255     const struct DeviceResourceNode *secPowerNode = NULL;
256     if (node == NULL || powersConfig == NULL) {
257         HDF_LOGE("%s: at least one of the paras is NULL!", __func__);
258         return HDF_FAILURE;
259     }
260     drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
261     if (drsOps == NULL || drsOps->GetChildNode == NULL) {
262         HDF_LOGE("%s: at least one of the paras is NULL!", __func__);
263         return HDF_FAILURE;
264     }
265     fstPowerNode = drsOps->GetChildNode(node, "power0");
266     if (fstPowerNode == NULL) {
267         HDF_LOGE("%s: get power0 config fail!", __func__);
268         return HDF_FAILURE;
269     }
270     if (ParseWlanPowerConfig(fstPowerNode, &powersConfig->power0) != HDF_SUCCESS) {
271         return HDF_FAILURE;
272     }
273 
274     secPowerNode = drsOps->GetChildNode(node, "power1");
275     if (secPowerNode == NULL) {
276         HDF_LOGE("%s: get power1 config fail!", __func__);
277         return HDF_FAILURE;
278     }
279     if (ParseWlanPowerConfig(secPowerNode, &powersConfig->power1) != HDF_SUCCESS) {
280         return HDF_FAILURE;
281     }
282     HDF_LOGD("%s: ParseWlanPowersConfig successful!", __func__);
283     return HDF_SUCCESS;
284 }
285 
ParseWlanResetConfig(const struct DeviceResourceNode * node,struct HdfConfWlanRest * resetConfig)286 static int32_t ParseWlanResetConfig(const struct DeviceResourceNode *node, struct HdfConfWlanRest *resetConfig)
287 {
288     struct DeviceResourceIface *drsOps = NULL;
289     if (node == NULL || resetConfig == NULL) {
290         HDF_LOGE("%s: at least one of the paras is NULL!", __func__);
291         return HDF_FAILURE;
292     }
293 
294     drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
295     if (drsOps == NULL || drsOps->GetUint8 == NULL || drsOps->GetUint16 == NULL) {
296         HDF_LOGE("%s: at least one of the paras is NULL!", __func__);
297         return HDF_FAILURE;
298     }
299 
300     if (drsOps->GetUint8(node, "resetType", &resetConfig->resetType, 0) != HDF_SUCCESS) {
301         HDF_LOGE("%s: powersSeqDelay fail!", __func__);
302         return HDF_FAILURE;
303     }
304 
305     if (drsOps->GetUint16(node, "gpioId", &resetConfig->gpioId, 0) != HDF_SUCCESS) {
306         HDF_LOGE("%s: gpioId fail!", __func__);
307         return HDF_FAILURE;
308     }
309 
310     if (drsOps->GetUint8(node, "activeLevel", &resetConfig->activeLevel, 0) != HDF_SUCCESS) {
311         HDF_LOGE("%s: powerType fail!", __func__);
312         return HDF_FAILURE;
313     }
314 
315     if (drsOps->GetUint8(node, "resetHoldTime", &resetConfig->resetHoldTime, 0) != HDF_SUCCESS) {
316         HDF_LOGE("%s: activeLevel fail!", __func__);
317         return HDF_FAILURE;
318     }
319     HDF_LOGD("%s: ParseWlanResetConfig successful!", __func__);
320     return HDF_SUCCESS;
321 }
322 
ParseWlanBusConfig(const struct DeviceResourceNode * node,struct HdfConfigWlanBus * busConfig)323 static int32_t ParseWlanBusConfig(const struct DeviceResourceNode *node, struct HdfConfigWlanBus *busConfig)
324 {
325     struct DeviceResourceIface *drsOps = NULL;
326 
327     if (node == NULL || busConfig == NULL) {
328         HDF_LOGE("%s: at least one of the paras is NULL!", __func__);
329         return HDF_FAILURE;
330     }
331     drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
332     if (drsOps == NULL || drsOps->GetUint8 == NULL || drsOps->GetUint8Array == NULL || drsOps->GetUint16 == NULL ||
333         drsOps->GetUint32 == NULL || drsOps->GetElemNum == NULL) {
334         HDF_LOGE("%s: invalid drs ops fail!", __func__);
335         return HDF_FAILURE;
336     }
337     if (drsOps->GetUint8(node, "busType", &busConfig->busType, 0) != HDF_SUCCESS) {
338         HDF_LOGE("%s: busType fail!", __func__);
339         return HDF_FAILURE;
340     }
341     if (drsOps->GetUint8(node, "busIdx", &busConfig->busIdx, 0) != HDF_SUCCESS) {
342         HDF_LOGE("%s: busType fail!", __func__);
343         return HDF_FAILURE;
344     }
345     if (drsOps->GetUint8Array(node, "funcNum", busConfig->funcNum, BUS_FUNC_MAX, 0) != HDF_SUCCESS) {
346         HDF_LOGE("%s: funcNum fail!", __func__);
347         return HDF_FAILURE;
348     }
349     busConfig->funcNumSize = drsOps->GetElemNum(node, "funcNum");
350 
351     if (drsOps->GetUint16(node, "timeout", &busConfig->timeout, 0) != HDF_SUCCESS) {
352         HDF_LOGE("%s: timeout fail!", __func__);
353         return HDF_FAILURE;
354     }
355     if (drsOps->GetUint16(node, "blockSize", &busConfig->blockSize, 0) != HDF_SUCCESS) {
356         HDF_LOGE("%s: timeout fail!", __func__);
357         return HDF_FAILURE;
358     }
359     if (drsOps->GetUint8(node, "busEnable", &busConfig->busEnable, 0) != HDF_SUCCESS) {
360         HDF_LOGE("%s: busEnable fail!", __func__);
361         return HDF_FAILURE;
362     }
363     HDF_LOGD("%s: ParseWlanBusConfig successful!", __func__);
364     return HDF_SUCCESS;
365 }
366 
ParseWlanDevInstConfig(const struct DeviceResourceNode * node,struct HdfConfigWlanDevInst * devLstConfig)367 static int32_t ParseWlanDevInstConfig(const struct DeviceResourceNode *node, struct HdfConfigWlanDevInst *devLstConfig)
368 {
369     struct DeviceResourceIface *drsOps = NULL;
370     const struct DeviceResourceNode *devPowerNode = NULL;
371     const struct DeviceResourceNode *chipConfigNode = NULL;
372     const struct DeviceResourceNode *resetNode = NULL;
373     if (node == NULL || devLstConfig == NULL) {
374         HDF_LOGE("%s: invalid node or devLstConfig!", __func__);
375         return HDF_FAILURE;
376     }
377     drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
378     if (drsOps == NULL || drsOps->GetUint8 == NULL || drsOps->GetChildNode == NULL) {
379         HDF_LOGE("%s: at least one of the paras is NULL!", __func__);
380         return HDF_FAILURE;
381     }
382 
383     if (drsOps->GetUint8(node, "deviceInstId", &devLstConfig->deviceInstId, 0) != HDF_SUCCESS) {
384         HDF_LOGE("%s: deviceinstId fail!", __func__);
385         return HDF_FAILURE;
386     }
387 
388     if (drsOps->GetUint8(node, "bootUpTimeOut", &devLstConfig->bootUpTimeOut, 0) != HDF_SUCCESS) {
389         HDF_LOGE("%s: bootUpTimeOut fail!", __func__);
390         return HDF_FAILURE;
391     }
392 
393     devPowerNode = drsOps->GetChildNode(node, "powers");
394     if (devPowerNode == NULL) {
395         HDF_LOGE("%s: GetChildNode fail!", __func__);
396         return HDF_FAILURE;
397     }
398     if (ParseWlanPowersConfig(devPowerNode, &devLstConfig->powers) != HDF_SUCCESS) {
399         return HDF_FAILURE;
400     }
401 
402     resetNode = drsOps->GetChildNode(node, "reset");
403     if (resetNode == NULL) {
404         HDF_LOGE("%s: GetChildNode fail!", __func__);
405         return HDF_FAILURE;
406     }
407     if (ParseWlanResetConfig(resetNode, &devLstConfig->reset) != HDF_SUCCESS) {
408         return HDF_FAILURE;
409     }
410     chipConfigNode = drsOps->GetChildNode(node, "bus");
411     if (chipConfigNode == NULL) {
412         HDF_LOGE("%s: GetChildNode fail!", __func__);
413         return HDF_FAILURE;
414     }
415     if (ParseWlanBusConfig(chipConfigNode, &devLstConfig->bus) != HDF_SUCCESS) {
416         return HDF_FAILURE;
417     }
418     return HDF_SUCCESS;
419 }
420 
ParseWlanDevListConfig(const struct DeviceResourceNode * node,struct HdfConfigWlanDeviceList * devConfig)421 static int32_t ParseWlanDevListConfig(const struct DeviceResourceNode *node, struct HdfConfigWlanDeviceList *devConfig)
422 {
423     struct DeviceResourceNode *childNode = NULL;
424     uint32_t index = 0;
425     if (node == NULL || devConfig == NULL) {
426         HDF_LOGE("%s: invalid node or devConfig!", __func__);
427         return HDF_FAILURE;
428     }
429     DEV_RES_NODE_FOR_EACH_CHILD_NODE(node, childNode)
430     {
431         if (ParseWlanDevInstConfig(childNode, &devConfig->deviceInst[index]) != HDF_SUCCESS) {
432             HDF_LOGE("%s: ParseWlanDevInstConfig failed!", __func__);
433             return HDF_FAILURE;
434         }
435         index++;
436         devConfig->deviceListSize++;
437     }
438     HDF_LOGD("%s: deviceListSize=%d", __func__, devConfig->deviceListSize);
439     return HDF_SUCCESS;
440 }
441 
442 /* BEGIN for WLAN2.1 to get chips configures: Added by hdf-wlan */
ParseWlanChipBusConfig(const struct DeviceResourceNode * node,struct HdfConfWlanBusArgs * busArgs)443 static int32_t ParseWlanChipBusConfig(const struct DeviceResourceNode *node, struct HdfConfWlanBusArgs *busArgs)
444 {
445     struct DeviceResourceIface *drsOps = NULL;
446     if (node == NULL || busArgs == NULL) {
447         HDF_LOGE("%s: at least one of the paras is NULL!", __func__);
448         return HDF_FAILURE;
449     }
450     drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
451     if (drsOps == NULL || drsOps->GetUint16 == NULL || drsOps->GetUint16Array == NULL) {
452         HDF_LOGE("%s: at least one of the paras is NULL!", __func__);
453         return HDF_FAILURE;
454     }
455 
456     if (drsOps->GetUint16(node, "vendorId", &busArgs->vendorId, 0) != HDF_SUCCESS) {
457         HDF_LOGE("%s: vendorId fail!", __func__);
458         return HDF_FAILURE;
459     }
460     if (drsOps->GetUint16Array(node, "deviceId", busArgs->deviceId, CHIP_BUS_DEVICE_ID_COUNT, 0) != HDF_SUCCESS) {
461         HDF_LOGE("%s: deviceId fail!", __func__);
462         return HDF_FAILURE;
463     }
464     HDF_LOGD("%s: ParseWlanChipBusConfig successful!", __func__);
465     return HDF_SUCCESS;
466 }
467 
ParseWlanChipsCompsConfig(const struct DeviceResourceNode * node,struct HdfConfigWlanChipInst * chipInst)468 static int32_t ParseWlanChipsCompsConfig(const struct DeviceResourceNode *node, struct HdfConfigWlanChipInst *chipInst)
469 {
470     struct DeviceResourceIface *drsOps = NULL;
471     const struct DeviceResourceNode *chipBusNode = NULL;
472     if (node == NULL || chipInst == NULL) {
473         HDF_LOGE("%s: invalid node or busRegsConfig!\n", __func__);
474         return HDF_FAILURE;
475     }
476     drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
477     if (drsOps == NULL || drsOps->GetString == NULL || drsOps->GetChildNode == NULL) {
478         HDF_LOGE("%s: invalid drs ops fail!", __func__);
479         return HDF_FAILURE;
480     }
481 
482     if (drsOps->GetString(node, "driverName", &chipInst->driverName, NULL) != HDF_SUCCESS) {
483         HDF_LOGE("%s: vendorId fail!", __func__);
484         return HDF_FAILURE;
485     }
486     HDF_LOGI("%s: driverName=%s", __func__, chipInst->driverName);
487 
488     chipBusNode = drsOps->GetChildNode(node, "bus");
489     if (chipBusNode == NULL) {
490         HDF_LOGE("%s: GetChildNode fail!", __func__);
491         return HDF_FAILURE;
492     }
493     if (ParseWlanChipBusConfig(chipBusNode, &chipInst->chipBus) != HDF_SUCCESS) {
494         return HDF_FAILURE;
495     }
496     HDF_LOGD("%s: ParseWlanChipsCompsConfig successful!", __func__);
497     return HDF_SUCCESS;
498 }
499 /* parse wlan chipList config */
ParseWlanChipsConfig(const struct DeviceResourceNode * node,struct HdfConfigWlanChipList * chipList)500 static int32_t ParseWlanChipsConfig(const struct DeviceResourceNode *node, struct HdfConfigWlanChipList *chipList)
501 {
502     struct DeviceResourceNode *childNode = NULL;
503     uint32_t cnt = 0;
504     if (node == NULL || chipList == NULL) {
505         HDF_LOGE("%s: invalid node or chipList!\n", __func__);
506         return HDF_FAILURE;
507     }
508 
509     DEV_RES_NODE_FOR_EACH_CHILD_NODE(node, childNode)
510     {
511         if (ParseWlanChipsCompsConfig(childNode, &chipList->chipInst[cnt]) != HDF_SUCCESS) {
512             HDF_LOGE("%s: ParseWlanChipsCompsConfig failed!\n", __func__);
513             return HDF_FAILURE;
514         }
515         cnt++;
516         chipList->chipInstSize++;
517     }
518     HDF_LOGD("%s: chipSize=%hu", __func__, chipList->chipInstSize);
519 
520     return HDF_SUCCESS;
521 }
522 /* END for WLAN2.1 chips configuration parse : Added by hdf-wlan */
523 
ParseWlanConfig(const struct DeviceResourceNode * node,struct HdfConfigWlanConfig * wlanConfig)524 static int32_t ParseWlanConfig(const struct DeviceResourceNode *node, struct HdfConfigWlanConfig *wlanConfig)
525 {
526     int32_t ret;
527     struct DeviceResourceIface *drsOps = NULL;
528     const struct DeviceResourceNode *moduleConfigNode = NULL;
529     const struct DeviceResourceNode *devListNode = NULL;
530     const struct DeviceResourceNode *chipsNode = NULL;
531 
532     drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
533     if (drsOps == NULL || drsOps->GetChildNode == NULL) {
534         HDF_LOGE("%s: invalid drs ops fail!", __func__);
535         return HDF_FAILURE;
536     }
537     if (drsOps->GetString(node, "hostChipName", &wlanConfig->hostChipName, NULL) != HDF_SUCCESS) {
538         HDF_LOGE("%s: hostChipName fail!", __func__);
539         return HDF_FAILURE;
540     }
541     moduleConfigNode = drsOps->GetChildNode(node, "moduleConfig");
542     devListNode = drsOps->GetChildNode(node, "deviceList");
543     chipsNode = drsOps->GetChildNode(node, "chipList");
544     if (moduleConfigNode == NULL || devListNode == NULL || chipsNode == NULL) {
545         HDF_LOGE("%s: get child node fail!", __func__);
546         return HDF_FAILURE;
547     }
548     ret = ParseWlanModuleConfig(moduleConfigNode, &wlanConfig->moduleConfig);
549     if (ret != HDF_SUCCESS) {
550         return HDF_FAILURE;
551     }
552     ret = ParseWlanDevListConfig(devListNode, &wlanConfig->deviceList);
553     if (ret != HDF_SUCCESS) {
554         return HDF_FAILURE;
555     }
556     ret = ParseWlanChipsConfig(chipsNode, &wlanConfig->chipList);
557     if (ret != HDF_SUCCESS) {
558         return HDF_FAILURE;
559     }
560     HDF_LOGD("%s: ParseWlanConfig finished!", __func__);
561     return ret;
562 }
563 
HdfParseWlanConfig(const struct DeviceResourceNode * node)564 int32_t HdfParseWlanConfig(const struct DeviceResourceNode *node)
565 {
566     if (node == NULL) {
567         HDF_LOGE("%s: node = null!\n", __func__);
568         return HDF_FAILURE;
569     }
570     return ParseWlanConfig(node, &g_configWlanModuleRoot.wlanConfig);
571 }
572 
HdfWlanGetModuleConfigRoot(void)573 struct HdfConfigWlanRoot *HdfWlanGetModuleConfigRoot(void)
574 {
575     return &g_configWlanModuleRoot;
576 }
577