1 /*
2  * Copyright (c) 2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "usbfn_cfg_mgr.h"
17 
18 #include <device_resource_if.h>
19 #include <hcs_tree_if.h>
20 #include <hdf_base.h>
21 #include <hdf_log.h>
22 #include <osal_mem.h>
23 #include <osal_thread.h>
24 #include <securec.h>
25 
26 #include "adapter_if.h"
27 #include "usbfn_dev_mgr.h"
28 #include "usbd_wrapper.h"
29 
30 #define HDF_LOG_TAG usbfn_cfg
31 static struct DListHead g_cfgEntry = {0};
32 
UsbFnCfgMgrParseDevDesc(const struct DeviceResourceNode * devDescNode,struct DeviceResourceIface * drsOps,struct UsbDeviceDescriptor * devDesc)33 static uint32_t UsbFnCfgMgrParseDevDesc(const struct DeviceResourceNode *devDescNode,
34     struct DeviceResourceIface *drsOps, struct UsbDeviceDescriptor *devDesc)
35 {
36     uint16_t value;
37 
38     if (drsOps->GetUint8(devDescNode, DESC_LENGTH, &devDesc->bLength, 0) != HDF_SUCCESS) {
39         HDF_LOGE("%{public}s: read length fail", __func__);
40         return HDF_FAILURE;
41     }
42     if (devDesc->bLength != sizeof(struct UsbDeviceDescriptor)) {
43         HDF_LOGE("%{public}s: dev desc length is not ringht", __func__);
44         return HDF_FAILURE;
45     }
46     if (drsOps->GetUint8(devDescNode, DESC_TYPE, &devDesc->bDescriptorType, 0) != HDF_SUCCESS ||
47         drsOps->GetUint8(devDescNode, USBDEV_CLASS, &devDesc->bDeviceClass, 0) != HDF_SUCCESS ||
48         drsOps->GetUint8(devDescNode, USBDEV_SUBCLASS, &devDesc->bDeviceSubClass, 0) != HDF_SUCCESS ||
49         drsOps->GetUint8(devDescNode, USBDEV_PROTOCOL, &devDesc->bDeviceProtocol, 0) != HDF_SUCCESS ||
50         drsOps->GetUint8(devDescNode, USBDEV_MAXSIZE, &devDesc->bMaxPacketSize0, 0) != HDF_SUCCESS ||
51         drsOps->GetUint8(devDescNode, USBDEV_MANUFACTURER, &devDesc->iManufacturer, 0) != HDF_SUCCESS ||
52         drsOps->GetUint8(devDescNode, USBDEV_PRODUCT, &devDesc->iProduct, 0) != HDF_SUCCESS ||
53         drsOps->GetUint8(devDescNode, USBDEV_SERIALNUM, &devDesc->iSerialNumber, 0) != HDF_SUCCESS ||
54         drsOps->GetUint8(devDescNode, USBDEV_NUMCFG, &devDesc->bNumConfigurations, 0) != HDF_SUCCESS) {
55         HDF_LOGE("%{public}s: read fail", __func__);
56         return HDF_FAILURE;
57     }
58     if (devDesc->bDescriptorType != USB_DDK_DT_DEVICE) {
59         HDF_LOGE("%{public}s: dev desc length is not ringht", __func__);
60         return HDF_FAILURE;
61     }
62     if (drsOps->GetUint16(devDescNode, USBDEV_BCD, &value, 0) != HDF_SUCCESS) {
63         HDF_LOGE("%{public}s: read bcdUSB fail", __func__);
64         return HDF_FAILURE;
65     }
66     devDesc->bcdUSB = LE16_TO_CPU(value);
67     if (drsOps->GetUint16(devDescNode, USBDEV_VENDOR, &value, 0) != HDF_SUCCESS) {
68         HDF_LOGE("%{public}s: read idVendor fail", __func__);
69         return HDF_FAILURE;
70     }
71     devDesc->idVendor = LE16_TO_CPU(value);
72     if (drsOps->GetUint16(devDescNode, USBDEV_IDPRODUCT, &value, 0) != HDF_SUCCESS) {
73         HDF_LOGE("%{public}s: read idProduct fail", __func__);
74         return HDF_FAILURE;
75     }
76     devDesc->idProduct = LE16_TO_CPU(value);
77     if (drsOps->GetUint16(devDescNode, USBDEV_BCDDEVICE, &value, 0) != HDF_SUCCESS) {
78         HDF_LOGE("%{public}s: read bcdDevice fail", __func__);
79         return HDF_FAILURE;
80     }
81     devDesc->bcdDevice = LE16_TO_CPU(value);
82 
83     return HDF_SUCCESS;
84 }
85 
UsbFnCfgMgrParseUsbFnDevDesc(const struct DeviceResourceNode * node,struct UsbFnDeviceDesc * fnDevDesc)86 static int32_t UsbFnCfgMgrParseUsbFnDevDesc(const struct DeviceResourceNode *node, struct UsbFnDeviceDesc *fnDevDesc)
87 {
88     const char *childNodeName = NULL;
89     if (node == NULL || fnDevDesc == NULL) {
90         HDF_LOGE("%{public}s: node or fnDevDesc is null", __func__);
91         return HDF_FAILURE;
92     }
93     struct DeviceResourceIface *drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
94     if (drsOps == NULL || drsOps->GetChildNode == NULL) {
95         HDF_LOGE("%{public}s: invalid drs ops failed", __func__);
96         return HDF_FAILURE;
97     }
98     if (drsOps->GetString(node, "usb_dev_desc", &childNodeName, NULL) != HDF_SUCCESS) {
99         HDF_LOGE("%{public}s: get usb_dev_desc node name failed", __func__);
100         return HDF_FAILURE;
101     }
102     const struct DeviceResourceNode *devDescNode = drsOps->GetChildNode(node, childNodeName);
103     if (devDescNode == NULL) {
104         HDF_LOGE("%{public}s: childDevDescNode is null", __func__);
105         return HDF_FAILURE;
106     }
107     fnDevDesc->deviceDesc = (struct UsbDeviceDescriptor *)UsbFnMemCalloc(sizeof(struct UsbDeviceDescriptor));
108     if (fnDevDesc->deviceDesc == NULL) {
109         HDF_LOGE("%{public}s: UsbFnMemCalloc failed", __func__);
110         return HDF_FAILURE;
111     }
112     if (UsbFnCfgMgrParseDevDesc(devDescNode, drsOps, fnDevDesc->deviceDesc)) {
113         HDF_LOGE("%{public}s: UsbFnMemCalloc failed", __func__);
114         goto FAIL;
115     }
116     return HDF_SUCCESS;
117 FAIL:
118     UsbFnMemFree(fnDevDesc->deviceDesc);
119     return HDF_FAILURE;
120 }
121 
UsbFnCfgMgrParseString(const struct DeviceResourceNode * node,const struct DeviceResourceIface * drsOps,struct UsbFnStrings * fnString)122 static int32_t UsbFnCfgMgrParseString(
123     const struct DeviceResourceNode *node, const struct DeviceResourceIface *drsOps, struct UsbFnStrings *fnString)
124 {
125     int32_t iCount;
126     int32_t strCount;
127     int32_t ret;
128     const char *strNodeName = NULL;
129     const struct DeviceResourceNode *strNode = NULL;
130 
131     if (node == NULL || fnString == NULL || drsOps == NULL) {
132         return HDF_FAILURE;
133     }
134     if (drsOps->GetUint16(node, "language", &fnString->language, 0) != HDF_SUCCESS) {
135         return HDF_FAILURE;
136     }
137     strCount = drsOps->GetElemNum(node, "stringList");
138     if (strCount <= 0) {
139         HDF_LOGE("%{public}s: stringList not found", __func__);
140         return HDF_FAILURE;
141     }
142     fnString->strings = (struct UsbString *)UsbFnMemCalloc((strCount + 1) * sizeof(struct UsbString));
143     if (fnString->strings == NULL) {
144         HDF_LOGE("%{public}s: fnString->strings is null", __func__);
145         goto FREE_USB_STRING;
146     }
147     fnString->strings[strCount].s = NULL;
148     fnString->strings[strCount].id = 0xff;
149     for (iCount = 0; iCount < strCount; iCount++) {
150         ret = drsOps->GetStringArrayElem(node, "stringList", iCount, &strNodeName, NULL);
151         if (ret != HDF_SUCCESS) {
152             HDF_LOGE("%{public}s: read stringList fail", __func__);
153             goto FREE_USB_STRING;
154         }
155         strNode = drsOps->GetChildNode(node, strNodeName);
156         if (strNode == NULL) {
157             HDF_LOGE("%{public}s: StrNode is null", __func__);
158             goto FREE_USB_STRING;
159         }
160         struct UsbString *usbStr = fnString->strings + iCount;
161         if (drsOps->GetUint8(strNode, "id", &usbStr->id, 0) != HDF_SUCCESS) {
162             goto FREE_USB_STRING;
163         }
164         if (drsOps->GetString(strNode, "str", &usbStr->s, 0) != HDF_SUCCESS) {
165             goto FREE_USB_STRING;
166         }
167     }
168 
169     return HDF_SUCCESS;
170 FREE_USB_STRING:
171     UsbFnMemFree(fnString->strings);
172     return HDF_FAILURE;
173 }
174 
UsbFnCfgMgrParseStrings(const struct DeviceResourceNode * node,const struct DeviceResourceIface * drsOps)175 static struct UsbFnStrings **UsbFnCfgMgrParseStrings(
176     const struct DeviceResourceNode *node, const struct DeviceResourceIface *drsOps)
177 {
178     int32_t strTabCount;
179     int32_t count;
180     int32_t ret;
181     const char *stringNodeName = NULL;
182     const struct DeviceResourceNode *stringNode = NULL;
183     struct UsbFnStrings **fnStrings = NULL;
184 
185     if (node == NULL || drsOps == NULL) {
186         return NULL;
187     }
188     strTabCount = drsOps->GetElemNum(node, "stringTabList");
189     if (strTabCount <= 0) {
190         return NULL;
191     }
192     fnStrings = (struct UsbFnStrings **)UsbFnMemCalloc((strTabCount + 1) * sizeof(struct UsbFnStrings *));
193     if (fnStrings == NULL) {
194         return NULL;
195     }
196     fnStrings[strTabCount] = NULL;
197     for (count = 0; count < strTabCount; count++) {
198         fnStrings[count] = (struct UsbFnStrings *)UsbFnMemCalloc(sizeof(struct UsbFnStrings));
199         if (fnStrings[count] == NULL) {
200             goto FREE_STRING;
201         }
202         ret = drsOps->GetStringArrayElem(node, "stringTabList", count, &stringNodeName, NULL);
203         if (ret != HDF_SUCCESS) {
204             goto FREE_STRING;
205         }
206         stringNode = drsOps->GetChildNode(node, stringNodeName);
207         if (stringNode == NULL) {
208             goto FREE_STRING;
209         }
210         if (UsbFnCfgMgrParseString(stringNode, drsOps, fnStrings[count]) != HDF_SUCCESS) {
211             goto FREE_STRING;
212         }
213     }
214     return fnStrings;
215 FREE_STRING:
216     while ((--count) >= 0) {
217         UsbFnMemFree(fnStrings[count]);
218     }
219     UsbFnMemFree(fnStrings);
220     return NULL;
221 }
222 
UsbFnCfgMgrParseUsbFnDevStrings(const struct DeviceResourceNode * node,struct UsbFnDeviceDesc * fnDevDesc)223 static int32_t UsbFnCfgMgrParseUsbFnDevStrings(const struct DeviceResourceNode *node, struct UsbFnDeviceDesc *fnDevDesc)
224 {
225     struct DeviceResourceIface *drsOps = NULL;
226     const char *fnDevStrNodeName = NULL;
227     const struct DeviceResourceNode *fnDevStrNode = NULL;
228 
229     if (node == NULL || fnDevDesc == NULL) {
230         HDF_LOGE("%{public}s: node or fnDevDesc is null", __func__);
231         return HDF_FAILURE;
232     }
233     drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
234     if (drsOps == NULL || drsOps->GetChildNode == NULL) {
235         HDF_LOGE("%{public}s: invalid drs ops failed", __func__);
236         return HDF_FAILURE;
237     }
238     if (drsOps->GetString(node, "usb_dev_string", &fnDevStrNodeName, NULL) != HDF_SUCCESS) {
239         HDF_LOGE("%{public}s: get dev strings name failed", __func__);
240         return HDF_FAILURE;
241     }
242     fnDevStrNode = drsOps->GetChildNode(node, fnDevStrNodeName);
243     if (fnDevStrNode == NULL) {
244         HDF_LOGE("%{public}s: childDevDescNode is null", __func__);
245         return HDF_FAILURE;
246     }
247     fnDevDesc->deviceStrings = UsbFnCfgMgrParseStrings(fnDevStrNode, drsOps);
248     if (fnDevDesc->deviceStrings == NULL) {
249         HDF_LOGE("%{public}s: parse device string error", __func__);
250         return HDF_FAILURE;
251     }
252 
253     return HDF_SUCCESS;
254 }
255 
UsbFnCfgMgrParseAccocInterfaceDesc(const struct DeviceResourceNode * node,const struct DeviceResourceIface * drsOps,uint8_t * descBuff)256 static int32_t UsbFnCfgMgrParseAccocInterfaceDesc(
257     const struct DeviceResourceNode *node, const struct DeviceResourceIface *drsOps, uint8_t *descBuff)
258 {
259     struct UsbInterfaceAssocDescriptor *desc = NULL;
260 
261     if (node == NULL || drsOps == NULL || descBuff == NULL) {
262         return HDF_FAILURE;
263     }
264     desc = (struct UsbInterfaceAssocDescriptor *)descBuff;
265     if (drsOps->GetUint8(node, DESC_LENGTH, &desc->bLength, 0) != HDF_SUCCESS ||
266         drsOps->GetUint8(node, DESC_TYPE, &desc->bDescriptorType, 0) != HDF_SUCCESS ||
267         drsOps->GetUint8(node, INTERFACE_FIRST, &desc->bFirstInterface, 0) != HDF_SUCCESS ||
268         drsOps->GetUint8(node, INTERFACE_COUNT, &desc->bInterfaceCount, 0) != HDF_SUCCESS ||
269         drsOps->GetUint8(node, FUNCTION_CLASS, &desc->bFunctionClass, 0) != HDF_SUCCESS ||
270         drsOps->GetUint8(node, FUNCTION_SUBCLASS, &desc->bFunctionSubClass, 0) != HDF_SUCCESS ||
271         drsOps->GetUint8(node, FUNCTION_PROTOCOL, &desc->bFunctionProtocol, 0) != HDF_SUCCESS ||
272         drsOps->GetUint8(node, FUNCTION_INDEX, &desc->iFunction, 0) != HDF_SUCCESS) {
273         HDF_LOGE("%{public}s: read fail", __func__);
274         return HDF_FAILURE;
275     }
276 
277     return HDF_SUCCESS;
278 }
279 
UsbFnCfgMgrParseInterfaceDesc(const struct DeviceResourceNode * node,const struct DeviceResourceIface * drsOps,uint8_t * descBuff)280 static int32_t UsbFnCfgMgrParseInterfaceDesc(
281     const struct DeviceResourceNode *node, const struct DeviceResourceIface *drsOps, uint8_t *descBuff)
282 {
283     struct UsbInterfaceDescriptor *desc = NULL;
284 
285     if (node == NULL || drsOps == NULL || descBuff == NULL) {
286         return HDF_FAILURE;
287     }
288     desc = (struct UsbInterfaceDescriptor *)descBuff;
289     if (drsOps->GetUint8(node, DESC_LENGTH, &desc->bLength, 0) != HDF_SUCCESS ||
290         drsOps->GetUint8(node, DESC_TYPE, &desc->bDescriptorType, 0) != HDF_SUCCESS ||
291         drsOps->GetUint8(node, INTERFACE_NUMBER, &desc->bInterfaceNumber, 0) != HDF_SUCCESS ||
292         drsOps->GetUint8(node, INTERFACE_ALTERNATE, &desc->bAlternateSetting, 0) != HDF_SUCCESS ||
293         drsOps->GetUint8(node, INTERFACE_NENDPOINT, &desc->bNumEndpoints, 0) != HDF_SUCCESS ||
294         drsOps->GetUint8(node, INTERFACE_CLASS, &desc->bInterfaceClass, 0) != HDF_SUCCESS ||
295         drsOps->GetUint8(node, INTERFACE_SUBCLASS, &desc->bInterfaceSubClass, 0) != HDF_SUCCESS ||
296         drsOps->GetUint8(node, INTERFACE_PROTOCOL, &desc->bInterfaceProtocol, 0) != HDF_SUCCESS ||
297         drsOps->GetUint8(node, INTERFACE_INTERFACE, &desc->iInterface, 0) != HDF_SUCCESS) {
298         HDF_LOGE("%{public}s: read fail", __func__);
299         return HDF_FAILURE;
300     }
301 
302     return HDF_SUCCESS;
303 }
304 
UsbFnCfgMgrParseEndpointDesc(const struct DeviceResourceNode * node,const struct DeviceResourceIface * drsOps,uint8_t * descBuff)305 static int32_t UsbFnCfgMgrParseEndpointDesc(
306     const struct DeviceResourceNode *node, const struct DeviceResourceIface *drsOps, uint8_t *descBuff)
307 {
308     if (node == NULL || drsOps == NULL || descBuff == NULL) {
309         return HDF_FAILURE;
310     }
311 
312     uint16_t value;
313     struct UsbEndpointDescriptor *desc = (struct UsbEndpointDescriptor *)descBuff;
314     if (drsOps->GetUint8(node, DESC_LENGTH, &desc->bLength, 0) != HDF_SUCCESS ||
315         drsOps->GetUint8(node, DESC_TYPE, &desc->bDescriptorType, 0) != HDF_SUCCESS ||
316         drsOps->GetUint8(node, ENDPOINT_ADDRESS, &desc->bEndpointAddress, 0) != HDF_SUCCESS ||
317         drsOps->GetUint8(node, ENDPOINT_MATTR, &desc->bmAttributes, 0) != HDF_SUCCESS ||
318         drsOps->GetUint16(node, ENDPOINT_MAXPACKSIZE_W, &value, 0) != HDF_SUCCESS ||
319         drsOps->GetUint8(node, ENDPOINT_INTERVAL, &desc->bInterval, 0) != HDF_SUCCESS) {
320         HDF_LOGE("%{public}s: read fail", __func__);
321         return HDF_FAILURE;
322     }
323     desc->wMaxPacketSize = LE16_TO_CPU(value);
324     if (desc->bLength == USB_DDK_DT_ENDPOINT_AUDIO_SIZE) {
325         if (drsOps->GetUint8(node, ENDPOINT_REFRESH, &desc->bRefresh, 0) != HDF_SUCCESS ||
326             drsOps->GetUint8(node, ENDPOINT_SYNCADDR, &desc->bSynchAddress, 0) != HDF_SUCCESS) {
327             HDF_LOGE("%{public}s: read fail", __func__);
328             return HDF_FAILURE;
329         }
330     }
331     return HDF_SUCCESS;
332 }
333 
UsbFnCfgMgrParseStringDesc(const struct DeviceResourceNode * node,const struct DeviceResourceIface * drsOps,uint8_t * descBuff)334 static int32_t UsbFnCfgMgrParseStringDesc(
335     const struct DeviceResourceNode *node, const struct DeviceResourceIface *drsOps, uint8_t *descBuff)
336 {
337     struct UsbStringDescriptor *desc = NULL;
338     uint16_t value;
339 
340     if (node == NULL || drsOps == NULL || descBuff == NULL) {
341         return HDF_FAILURE;
342     }
343     desc = (struct UsbStringDescriptor *)descBuff;
344     if (drsOps->GetUint8(node, DESC_LENGTH, &desc->bLength, 0) != HDF_SUCCESS ||
345         drsOps->GetUint8(node, DESC_TYPE, &desc->bDescriptorType, 0) != HDF_SUCCESS ||
346         drsOps->GetUint16(node, STRING_DATA, &value, 0) != HDF_SUCCESS) {
347         HDF_LOGE("%{public}s: read fail", __func__);
348         return HDF_FAILURE;
349     }
350     desc->wData[0] = LE16_TO_CPU(value);
351 
352     return HDF_SUCCESS;
353 }
354 
UsbFnCfgMgrParseSspIsocEndpointDesc(const struct DeviceResourceNode * node,const struct DeviceResourceIface * drsOps,uint8_t * descBuff)355 static int32_t UsbFnCfgMgrParseSspIsocEndpointDesc(
356     const struct DeviceResourceNode *node, const struct DeviceResourceIface *drsOps, uint8_t *descBuff)
357 {
358     struct UsbSspIsocEpCompDescriptor *desc = NULL;
359     uint16_t sValue;
360     uint32_t iValue;
361 
362     if (node == NULL || drsOps == NULL || descBuff == NULL) {
363         return HDF_FAILURE;
364     }
365     desc = (struct UsbSspIsocEpCompDescriptor *)descBuff;
366     if (drsOps->GetUint8(node, DESC_LENGTH, &desc->bLength, 0) != HDF_SUCCESS ||
367         drsOps->GetUint8(node, DESC_TYPE, &desc->bDescriptorType, 0) != HDF_SUCCESS ||
368         drsOps->GetUint16(node, SSP_ISOC_EPCOMP_WRESEVED, &sValue, 0) != HDF_SUCCESS ||
369         drsOps->GetUint32(node, SSP_ISOC_EPCOMP_DWPERINTERVAL, &iValue, 0) != HDF_SUCCESS) {
370         HDF_LOGE("%{public}s: read fail", __func__);
371         return HDF_FAILURE;
372     }
373     desc->wReseved = LE16_TO_CPU(sValue);
374     desc->dwBytesPerInterval = LE32_TO_CPU(iValue);
375 
376     return HDF_SUCCESS;
377 }
378 
UsbFnCfgMgrParseSsEndpointDesc(const struct DeviceResourceNode * node,const struct DeviceResourceIface * drsOps,uint8_t * descBuff)379 static int32_t UsbFnCfgMgrParseSsEndpointDesc(
380     const struct DeviceResourceNode *node, const struct DeviceResourceIface *drsOps, uint8_t *descBuff)
381 {
382     struct UsbSsEpCompDescriptor *desc = NULL;
383     uint16_t sValue;
384 
385     if (node == NULL || drsOps == NULL || descBuff == NULL) {
386         return HDF_FAILURE;
387     }
388     desc = (struct UsbSsEpCompDescriptor *)descBuff;
389     if (drsOps->GetUint8(node, DESC_LENGTH, &desc->bLength, 0) != HDF_SUCCESS ||
390         drsOps->GetUint8(node, DESC_TYPE, &desc->bDescriptorType, 0) != HDF_SUCCESS ||
391         drsOps->GetUint8(node, SS_EP_COMP_MAXBURST, &desc->bMaxBurst, 0) != HDF_SUCCESS ||
392         drsOps->GetUint8(node, SS_EP_COMP_MTTRIBUTE, &desc->bmAttributes, 0) != HDF_SUCCESS ||
393         drsOps->GetUint16(node, SS_EP_COMP_WPERINTERVAL, &sValue, 0) != HDF_SUCCESS) {
394         HDF_LOGE("%{public}s: read fail", __func__);
395         return HDF_FAILURE;
396     }
397     desc->wBytesPerInterval = LE16_TO_CPU(sValue);
398 
399     return HDF_SUCCESS;
400 }
401 
UsbFnCfgMgrParseQualifierDesc(const struct DeviceResourceNode * node,const struct DeviceResourceIface * drsOps,uint8_t * descBuff)402 static int32_t UsbFnCfgMgrParseQualifierDesc(
403     const struct DeviceResourceNode *node, const struct DeviceResourceIface *drsOps, uint8_t *descBuff)
404 {
405     struct UsbQualifierDescriptor *desc = NULL;
406     uint16_t sValue;
407 
408     if (node == NULL || drsOps == NULL || descBuff == NULL) {
409         return HDF_FAILURE;
410     }
411     desc = (struct UsbQualifierDescriptor *)descBuff;
412     if (drsOps->GetUint8(node, DESC_LENGTH, &desc->bLength, 0) != HDF_SUCCESS ||
413         drsOps->GetUint8(node, DESC_TYPE, &desc->bDescriptorType, 0) != HDF_SUCCESS ||
414         drsOps->GetUint8(node, QUALIFIER_CLASS, &desc->bDeviceClass, 0) != HDF_SUCCESS ||
415         drsOps->GetUint8(node, QUALIFIER_SUBCLASS, &desc->bDeviceSubClass, 0) != HDF_SUCCESS ||
416         drsOps->GetUint8(node, QUALIFIER_PROTOCOL, &desc->bDeviceProtocol, 0) != HDF_SUCCESS ||
417         drsOps->GetUint8(node, QUALIFIER_MAXSIZE, &desc->bMaxPacketSize0, 0) != HDF_SUCCESS ||
418         drsOps->GetUint8(node, QUALIFIER_NUMCFG, &desc->bNumConfigurations, 0) != HDF_SUCCESS ||
419         drsOps->GetUint16(node, QUALIFIER_BCD, &sValue, 0) != HDF_SUCCESS) {
420         HDF_LOGE("%{public}s: read fail", __func__);
421         return HDF_FAILURE;
422     }
423     desc->bcdUSB = LE16_TO_CPU(sValue);
424 
425     return HDF_SUCCESS;
426 }
427 
UsbFnCfgMgrParseOtgDesc(const struct DeviceResourceNode * node,const struct DeviceResourceIface * drsOps,uint8_t * descBuff,uint8_t length)428 static int32_t UsbFnCfgMgrParseOtgDesc(
429     const struct DeviceResourceNode *node, const struct DeviceResourceIface *drsOps, uint8_t *descBuff, uint8_t length)
430 {
431     struct UsbOtg20Descriptor *desc2 = NULL;
432     struct UsbOtgDescriptor *desc = NULL;
433     uint16_t sValue;
434 
435     if (node == NULL || drsOps == NULL || descBuff == NULL) {
436         return HDF_FAILURE;
437     }
438     desc = (struct UsbOtgDescriptor *)descBuff;
439 
440     if (drsOps->GetUint8(node, DESC_LENGTH, &desc->bLength, 0) != HDF_SUCCESS ||
441         drsOps->GetUint8(node, DESC_TYPE, &desc->bDescriptorType, 0) != HDF_SUCCESS ||
442         drsOps->GetUint8(node, OTG_MTTRIBUTE, &desc->bmAttributes, 0) != HDF_SUCCESS) {
443         HDF_LOGE("%{public}s: read fail", __func__);
444         return HDF_FAILURE;
445     }
446     if (length == sizeof(struct UsbOtg20Descriptor)) {
447         desc2 = (struct UsbOtg20Descriptor *)descBuff;
448         if (drsOps->GetUint16(node, QUALIFIER_BCD, &sValue, 0) != HDF_SUCCESS) {
449             return HDF_FAILURE;
450         }
451         desc2->bcdOTG = LE16_TO_CPU(sValue);
452     }
453 
454     return HDF_SUCCESS;
455 }
456 
UsbFnCfgMgrParseDebugDesc(const struct DeviceResourceNode * node,const struct DeviceResourceIface * drsOps,uint8_t * descBuff)457 static int32_t UsbFnCfgMgrParseDebugDesc(
458     const struct DeviceResourceNode *node, const struct DeviceResourceIface *drsOps, uint8_t *descBuff)
459 {
460     struct UsbDebugDescriptor *desc = NULL;
461 
462     if (node == NULL || drsOps == NULL || descBuff == NULL) {
463         return HDF_FAILURE;
464     }
465     desc = (struct UsbDebugDescriptor *)descBuff;
466     if (drsOps->GetUint8(node, DESC_LENGTH, &desc->bLength, 0) != HDF_SUCCESS ||
467         drsOps->GetUint8(node, DESC_TYPE, &desc->bDescriptorType, 0) != HDF_SUCCESS ||
468         drsOps->GetUint8(node, DEBUG_IN, &desc->bDebugInEndpoint, 0) != HDF_SUCCESS ||
469         drsOps->GetUint8(node, DEBUG_OUT, &desc->bDebugOutEndpoint, 0) != HDF_SUCCESS) {
470         HDF_LOGE("%{public}s: read fail", __func__);
471         return HDF_FAILURE;
472     }
473 
474     return HDF_SUCCESS;
475 }
476 
UsbFnCfgMgrParseSecurityDesc(const struct DeviceResourceNode * node,const struct DeviceResourceIface * drsOps,uint8_t * descBuff)477 static int32_t UsbFnCfgMgrParseSecurityDesc(
478     const struct DeviceResourceNode *node, const struct DeviceResourceIface *drsOps, uint8_t *descBuff)
479 {
480     struct UsbSecurityDescriptor *desc = NULL;
481     uint16_t sValue;
482 
483     if (node == NULL || drsOps == NULL || descBuff == NULL) {
484         return HDF_FAILURE;
485     }
486     desc = (struct UsbSecurityDescriptor *)descBuff;
487     if (drsOps->GetUint8(node, DESC_LENGTH, &desc->bLength, 0) != HDF_SUCCESS ||
488         drsOps->GetUint8(node, DESC_TYPE, &desc->bDescriptorType, 0) != HDF_SUCCESS ||
489         drsOps->GetUint8(node, SECURITY_ENCRYTYPE, &desc->bNumEncryptionTypes, 0) != HDF_SUCCESS ||
490         drsOps->GetUint16(node, SECURITY_TOTALLENGTH, &sValue, 0) != HDF_SUCCESS) {
491         HDF_LOGE("%{public}s: read fail", __func__);
492         return HDF_FAILURE;
493     }
494     desc->wTotalLength = LE16_TO_CPU(sValue);
495 
496     return HDF_SUCCESS;
497 }
498 
UsbFnCfgMgrParseOtherDesc(const struct DeviceResourceNode * node,const struct DeviceResourceIface * drsOps,uint8_t * descBuff,uint8_t length)499 static int32_t UsbFnCfgMgrParseOtherDesc(
500     const struct DeviceResourceNode *node, const struct DeviceResourceIface *drsOps, uint8_t *descBuff, uint8_t length)
501 {
502     if (node == NULL || drsOps == NULL || descBuff == NULL) {
503         return HDF_FAILURE;
504     }
505     if (drsOps->GetUint8Array(node, "desc_data", descBuff, length, 0) != HDF_SUCCESS) {
506         return HDF_FAILURE;
507     }
508     if (descBuff[0] != length) {
509         return HDF_FAILURE;
510     }
511     return HDF_SUCCESS;
512 }
513 
UsbFnCfgMgrParseDescriptor(const struct DeviceResourceNode * node,const struct DeviceResourceIface * drsOps,uint8_t * descBuff,uint8_t descType,uint8_t length)514 static int32_t UsbFnCfgMgrParseDescriptor(const struct DeviceResourceNode *node,
515     const struct DeviceResourceIface *drsOps, uint8_t *descBuff, uint8_t descType, uint8_t length)
516 {
517     int32_t ret;
518 
519     if (node == NULL || drsOps == NULL || descBuff == NULL) {
520         return HDF_FAILURE;
521     }
522     switch (descType) {
523         case USB_DDK_DT_INTERFACE:
524             ret = UsbFnCfgMgrParseInterfaceDesc(node, drsOps, descBuff);
525             break;
526         case USB_DDK_DT_ENDPOINT:
527             ret = UsbFnCfgMgrParseEndpointDesc(node, drsOps, descBuff);
528             break;
529         case USB_DDK_DT_STRING:
530             ret = UsbFnCfgMgrParseStringDesc(node, drsOps, descBuff);
531             break;
532         case USB_DDK_DT_INTERFACE_ASSOCIATION:
533             ret = UsbFnCfgMgrParseAccocInterfaceDesc(node, drsOps, descBuff);
534             break;
535         case USB_DDK_DT_SSP_ISOC_ENDPOINT_COMP:
536             ret = UsbFnCfgMgrParseSspIsocEndpointDesc(node, drsOps, descBuff);
537             break;
538         case USB_DDK_DT_SS_ENDPOINT_COMP:
539             ret = UsbFnCfgMgrParseSsEndpointDesc(node, drsOps, descBuff);
540             break;
541         case USB_DDK_DT_DEVICE_QUALIFIER:
542             ret = UsbFnCfgMgrParseQualifierDesc(node, drsOps, descBuff);
543             break;
544         case USB_DDK_DT_OTG:
545             ret = UsbFnCfgMgrParseOtgDesc(node, drsOps, descBuff, length);
546             break;
547         case USB_DDK_DT_DEBUG:
548             ret = UsbFnCfgMgrParseDebugDesc(node, drsOps, descBuff);
549             break;
550         case USB_DDK_DT_SECURITY:
551             ret = UsbFnCfgMgrParseSecurityDesc(node, drsOps, descBuff);
552             break;
553         case USB_DDK_DT_ENCRYPTION_TYPE:
554             ret = UsbFnCfgMgrParseSecurityDesc(node, drsOps, descBuff);
555             break;
556         default:
557             ret = UsbFnCfgMgrParseOtherDesc(node, drsOps, descBuff, length);
558             break;
559     }
560 
561     return ret;
562 }
563 
UsbFnCfgMgrParseDesc(const struct DeviceResourceNode * node,const struct DeviceResourceIface * drsOps)564 static struct UsbDescriptorHeader *UsbFnCfgMgrParseDesc(
565     const struct DeviceResourceNode *node, const struct DeviceResourceIface *drsOps)
566 {
567     uint8_t length;
568     uint8_t descType;
569     uint8_t *descBuff = NULL;
570     int32_t ret;
571 
572     if (node == NULL || drsOps == NULL) {
573         return NULL;
574     }
575     if (drsOps->GetUint8(node, DESC_LENGTH, &length, 0) != HDF_SUCCESS) {
576         HDF_LOGE("%{public}s: read length fail", __func__);
577         return NULL;
578     }
579     if (drsOps->GetUint8(node, DESC_TYPE, &descType, 0) != HDF_SUCCESS) {
580         HDF_LOGE("%{public}s: read type fail", __func__);
581         return NULL;
582     }
583     descBuff = (uint8_t *)UsbFnMemCalloc(length * sizeof(uint8_t));
584     if (descBuff == NULL) {
585         return NULL;
586     }
587     ret = UsbFnCfgMgrParseDescriptor(node, drsOps, descBuff, descType, length);
588     if (ret != HDF_SUCCESS) {
589         HDF_LOGE("%{public}s: length = 0x%{public}x, descType = 0x%{public}x Parse fail", __func__, length, descType);
590         UsbFnMemFree(descBuff);
591         return NULL;
592     }
593 
594     return (struct UsbDescriptorHeader *)descBuff;
595 }
596 
UsbFnCfgMgrParseFunDesc(const struct DeviceResourceNode * node,const struct DeviceResourceIface * drsOps,const char * descName)597 static struct UsbDescriptorHeader **UsbFnCfgMgrParseFunDesc(
598     const struct DeviceResourceNode *node, const struct DeviceResourceIface *drsOps, const char *descName)
599 {
600     int32_t descCount;
601     int32_t iCount;
602     const char *descNodeName = NULL;
603     const struct DeviceResourceNode *descNode = NULL;
604     struct UsbDescriptorHeader **descriptors = NULL;
605 
606     if (node == NULL || descName == NULL || drsOps == NULL) {
607         return NULL;
608     }
609     descCount = drsOps->GetElemNum(node, descName);
610     if (descCount <= 0) {
611         return NULL;
612     }
613     descriptors = (struct UsbDescriptorHeader **)UsbFnMemCalloc((descCount + 1) * sizeof(struct UsbDescriptorHeader *));
614     if (descriptors == NULL) {
615         HDF_LOGE("%{public}s: UsbFnMemCalloc failed", __func__);
616         return NULL;
617     }
618     descriptors[descCount] = NULL;
619     for (iCount = 0; iCount < descCount; iCount++) {
620         if (drsOps->GetStringArrayElem(node, descName, iCount, &descNodeName, NULL) != HDF_SUCCESS) {
621             goto FREE_DESC_HEAD;
622         }
623         descNode = drsOps->GetChildNode(node, descNodeName);
624         if (descNode == NULL) {
625             goto FREE_DESC_HEAD;
626         }
627         descriptors[iCount] = UsbFnCfgMgrParseDesc(descNode, drsOps);
628         if (descriptors[iCount] == NULL) {
629             goto FREE_DESC_HEAD;
630         }
631     }
632     return descriptors;
633 FREE_DESC_HEAD:
634     while ((--iCount) >= 0) {
635         UsbFnMemFree(descriptors[iCount]);
636     }
637     UsbFnMemFree(descriptors);
638     return NULL;
639 }
640 
UsbFnCfgMgrParseUsbFnFunction(const struct DeviceResourceNode * node,const struct DeviceResourceIface * drsOps,struct UsbFnFunction * fun)641 static int32_t UsbFnCfgMgrParseUsbFnFunction(
642     const struct DeviceResourceNode *node, const struct DeviceResourceIface *drsOps, struct UsbFnFunction *fun)
643 {
644     if (node == NULL || fun == NULL) {
645         HDF_LOGE("%{public}s: node or fnDevDesc or drsOps is null", __func__);
646         return HDF_FAILURE;
647     }
648     if (drsOps->GetString(node, "funcName", &fun->funcName, NULL) != HDF_SUCCESS) {
649         HDF_LOGE("%{public}s: get function name failed", __func__);
650         return HDF_FAILURE;
651     }
652     if (strncmp(fun->funcName, FUNCTION_GENERIC, strlen(FUNCTION_GENERIC)) != 0) {
653         return HDF_SUCCESS;
654     }
655     fun->strings = UsbFnCfgMgrParseStrings(node, drsOps);
656     if (fun->strings == NULL) {
657         HDF_LOGE("%{public}s: parse device string error", __func__);
658         return HDF_FAILURE;
659     }
660     fun->fsDescriptors = UsbFnCfgMgrParseFunDesc(node, drsOps, "fsDescList");
661     if (fun->fsDescriptors == NULL) {
662         HDF_LOGE("%{public}s: parse FS_DESC error", __func__);
663     }
664     fun->hsDescriptors = UsbFnCfgMgrParseFunDesc(node, drsOps, "hsDescList");
665     if (fun->hsDescriptors == NULL) {
666         HDF_LOGE("%{public}s: parse HS_DESC error", __func__);
667     }
668     fun->ssDescriptors = UsbFnCfgMgrParseFunDesc(node, drsOps, "ssDescList");
669     if (fun->ssDescriptors == NULL) {
670         HDF_LOGE("%{public}s: parse SS_DESC error", __func__);
671     }
672     fun->sspDescriptors = UsbFnCfgMgrParseFunDesc(node, drsOps, "sspDescList");
673     if (fun->sspDescriptors == NULL) {
674         HDF_LOGE("%{public}s: parse SSP_DESC error", __func__);
675     }
676 
677     return HDF_SUCCESS;
678 }
679 
UsbFnCfgMgrParseUsbFnFunctions(const struct DeviceResourceNode * node,struct DeviceResourceIface * drsOps,struct UsbFnConfiguration * fnConfig)680 static int32_t UsbFnCfgMgrParseUsbFnFunctions(
681     const struct DeviceResourceNode *node, struct DeviceResourceIface *drsOps, struct UsbFnConfiguration *fnConfig)
682 {
683     int32_t iCount;
684     int32_t funCount;
685     int32_t ret;
686     const char *funNodeName = NULL;
687     const struct DeviceResourceNode *funNode = NULL;
688 
689     funCount = drsOps->GetElemNum(node, "functionList");
690     if (funCount <= 0) {
691         HDF_LOGE("%{public}s: get functionList num failed", __func__);
692         return HDF_FAILURE;
693     }
694     fnConfig->functions = (struct UsbFnFunction **)UsbFnMemCalloc((funCount + 1) * sizeof(struct UsbFnFunction *));
695     if (fnConfig->functions == NULL) {
696         HDF_LOGE("%{public}s: UsbFnMemCalloc failed", __func__);
697         return HDF_FAILURE;
698     }
699     fnConfig->functions[funCount] = NULL;
700     for (iCount = 0; iCount < funCount; iCount++) {
701         fnConfig->functions[iCount] = (struct UsbFnFunction *)UsbFnMemCalloc(sizeof(struct UsbFnFunction));
702         if (fnConfig->functions[iCount] == NULL) {
703             HDF_LOGE("%{public}s: UsbFnMemCalloc failed", __func__);
704             goto FREE_FUNTION;
705         }
706         ret = drsOps->GetStringArrayElem(node, "functionList", iCount, &funNodeName, NULL);
707         if (ret != HDF_SUCCESS) {
708             HDF_LOGE("%{public}s: read stringList fail", __func__);
709             goto FREE_FUNTION;
710         }
711         funNode = drsOps->GetChildNode(node, funNodeName);
712         if (funNode == NULL) {
713             HDF_LOGE("%{public}s: funNode not found", __func__);
714             goto FREE_FUNTION;
715         }
716         if (UsbFnCfgMgrParseUsbFnFunction(funNode, drsOps, fnConfig->functions[iCount]) != HDF_SUCCESS) {
717             HDF_LOGE("%{public}s: parse function error", __func__);
718             goto FREE_FUNTION;
719         }
720     }
721 
722     return HDF_SUCCESS;
723 FREE_FUNTION:
724     while ((--iCount) > 0) {
725         UsbFnMemFree((void *)fnConfig->functions[iCount]);
726         fnConfig->functions[iCount] = NULL;
727     }
728     UsbFnMemFree(fnConfig->functions);
729     fnConfig->functions = NULL;
730     return HDF_FAILURE;
731 }
732 
UsbFnCfgMgrParseUsbFnConfiguration(const struct DeviceResourceNode * node,struct DeviceResourceIface * drsOps,struct UsbFnConfiguration * fnConfig)733 static int32_t UsbFnCfgMgrParseUsbFnConfiguration(
734     const struct DeviceResourceNode *node, struct DeviceResourceIface *drsOps, struct UsbFnConfiguration *fnConfig)
735 {
736     if (node == NULL || fnConfig == NULL || drsOps == NULL) {
737         HDF_LOGE("%{public}s: node or fnDevDesc or drsOps is null", __func__);
738         return HDF_FAILURE;
739     }
740     if (drsOps->GetUint8(node, "configurationValue", &fnConfig->configurationValue, 0) != HDF_SUCCESS) {
741         HDF_LOGE("%{public}s: read strCount fail", __func__);
742         return HDF_FAILURE;
743     }
744     if (drsOps->GetUint8(node, "iConfiguration", &fnConfig->iConfiguration, 0) != HDF_SUCCESS) {
745         HDF_LOGE("%{public}s: read strCount fail", __func__);
746         return HDF_FAILURE;
747     }
748     if (drsOps->GetUint8(node, "attributes", &fnConfig->attributes, 0) != HDF_SUCCESS) {
749         HDF_LOGE("%{public}s: read strCount fail", __func__);
750         return HDF_FAILURE;
751     }
752     if (drsOps->GetUint16(node, "maxPower", &fnConfig->maxPower, 0) != HDF_SUCCESS) {
753         HDF_LOGE("%{public}s: read strCount fail", __func__);
754         return HDF_FAILURE;
755     }
756     if (UsbFnCfgMgrParseUsbFnFunctions(node, drsOps, fnConfig) != HDF_SUCCESS) {
757         HDF_LOGE("%{public}s: parse functions failed", __func__);
758         return HDF_FAILURE;
759     }
760     return HDF_SUCCESS;
761 }
762 
UsbFnCfgMgrParseUsbFnCfgLists(const struct DeviceResourceNode * configNode,struct DeviceResourceIface * drsOps,struct UsbFnDeviceDesc * fnDevDesc)763 static int32_t UsbFnCfgMgrParseUsbFnCfgLists(
764     const struct DeviceResourceNode *configNode, struct DeviceResourceIface *drsOps, struct UsbFnDeviceDesc *fnDevDesc)
765 {
766     int32_t configCount;
767     int32_t count;
768     int32_t ret;
769     const char *childConfigNodeName = NULL;
770     const struct DeviceResourceNode *childConfigNode = NULL;
771 
772     configCount = drsOps->GetElemNum(configNode, "configList");
773     if (configCount <= 0) {
774         HDF_LOGE("%{public}s: get configList num failed", __func__);
775         return HDF_FAILURE;
776     }
777     fnDevDesc->configs =
778         (struct UsbFnConfiguration **)UsbFnMemCalloc((configCount + 1) * sizeof(struct UsbFnConfiguration *));
779     if (fnDevDesc->configs == NULL) {
780         HDF_LOGE("%{public}s: UsbFnMemCalloc failed", __func__);
781         return HDF_FAILURE;
782     }
783     fnDevDesc->configs[configCount] = NULL;
784     for (count = 0; count < configCount; count++) {
785         fnDevDesc->configs[count] = (struct UsbFnConfiguration *)UsbFnMemCalloc(sizeof(struct UsbFnConfiguration));
786         if (fnDevDesc->configs[count] == NULL) {
787             HDF_LOGE("%{public}s: UsbFnMemCalloc failed", __func__);
788             goto FREE_CONFIG;
789         }
790         ret = drsOps->GetStringArrayElem(configNode, "configList", count, &childConfigNodeName, NULL);
791         if (ret != HDF_SUCCESS) {
792             HDF_LOGE("%{public}s: read stringList fail", __func__);
793             goto FREE_CONFIG;
794         }
795         childConfigNode = drsOps->GetChildNode(configNode, childConfigNodeName);
796         if (childConfigNode == NULL) {
797             HDF_LOGE("%{public}s: StrNode is null", __func__);
798             goto FREE_CONFIG;
799         }
800         if (UsbFnCfgMgrParseUsbFnConfiguration(childConfigNode, drsOps, fnDevDesc->configs[count]) != HDF_SUCCESS) {
801             HDF_LOGE("%{public}s: parse config failed", __func__);
802             goto FREE_CONFIG;
803         }
804     }
805 
806     return HDF_SUCCESS;
807 FREE_CONFIG:
808     while ((--count) >= 0) {
809         UsbFnMemFree(fnDevDesc->deviceStrings[count]);
810         fnDevDesc->deviceStrings[count] = NULL;
811     }
812     UsbFnMemFree(fnDevDesc->deviceStrings);
813     fnDevDesc->deviceStrings = NULL;
814     return HDF_FAILURE;
815 }
816 
UsbFnCfgMgrParseUsbFnConfigurations(const struct DeviceResourceNode * node,struct UsbFnDeviceDesc * fnDevDesc)817 static int32_t UsbFnCfgMgrParseUsbFnConfigurations(
818     const struct DeviceResourceNode *node, struct UsbFnDeviceDesc *fnDevDesc)
819 {
820     struct DeviceResourceIface *drsOps = NULL;
821     const char *configNodeName = NULL;
822     const struct DeviceResourceNode *configNode = NULL;
823 
824     if (node == NULL || fnDevDesc == NULL) {
825         HDF_LOGE("%{public}s: node or fnDevDesc is null", __func__);
826         return HDF_FAILURE;
827     }
828     drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
829     if (drsOps == NULL || drsOps->GetChildNode == NULL) {
830         HDF_LOGE("%{public}s: invalid drs ops failed", __func__);
831         return HDF_FAILURE;
832     }
833     if (drsOps->GetString(node, "usb_configuration", &configNodeName, NULL) != HDF_SUCCESS) {
834         HDF_LOGE("%{public}s: get config node name failed", __func__);
835         return HDF_FAILURE;
836     }
837     configNode = drsOps->GetChildNode(node, configNodeName);
838     if (configNode == NULL) {
839         HDF_LOGE("%{public}s: configNode is null", __func__);
840         return HDF_FAILURE;
841     }
842     if (UsbFnCfgMgrParseUsbFnCfgLists(configNode, drsOps, fnDevDesc) != HDF_SUCCESS) {
843         HDF_LOGE("%{public}s: parse usb config lists failed", __func__);
844         return HDF_FAILURE;
845     }
846     return HDF_SUCCESS;
847 }
848 
UsbFnCfgMgrGetInstanceFromHCS(const struct DeviceResourceNode * node)849 struct UsbFnDeviceDesc *UsbFnCfgMgrGetInstanceFromHCS(const struct DeviceResourceNode *node)
850 {
851     int32_t ret;
852     struct UsbFnDeviceDesc *usbDevDesc = NULL;
853 
854     if (node == NULL) {
855         HDF_LOGE("%{public}s: node is null", __func__);
856         return NULL;
857     }
858 
859     usbDevDesc = (struct UsbFnDeviceDesc *)UsbFnMemCalloc(sizeof(*usbDevDesc));
860     if (usbDevDesc == NULL) {
861         HDF_LOGE("%{public}s: UsbFnMemCalloc failed", __func__);
862         return NULL;
863     }
864     ret = UsbFnCfgMgrParseUsbFnDevDesc(node, usbDevDesc);
865     if (ret != HDF_SUCCESS) {
866         HDF_LOGE("%{public}s: parse device descriptor failed", __func__);
867         UsbFnMemFree(usbDevDesc);
868         return NULL;
869     }
870     ret = UsbFnCfgMgrParseUsbFnDevStrings(node, usbDevDesc);
871     if (ret != HDF_SUCCESS) {
872         HDF_LOGE("%{public}s: parse device string failed", __func__);
873         goto FAIL_DEV_STRING;
874     }
875     ret = UsbFnCfgMgrParseUsbFnConfigurations(node, usbDevDesc);
876     if (ret != HDF_SUCCESS) {
877         HDF_LOGE("%{public}s: parse config descriptor failed", __func__);
878         goto FAIL_DEV_STRING;
879     }
880 
881     return usbDevDesc;
882 
883 FAIL_DEV_STRING:
884     UsbFnMemFree(usbDevDesc->deviceDesc);
885     UsbFnMemFree(usbDevDesc);
886     return NULL;
887 }
888 
UsbFnCfgMgrFreeFnStrings(struct UsbFnStrings ** fnStrings)889 static void UsbFnCfgMgrFreeFnStrings(struct UsbFnStrings **fnStrings)
890 {
891     int8_t iCount;
892 
893     for (iCount = 0; (fnStrings[iCount] != NULL); iCount++) {
894         UsbFnMemFree(fnStrings[iCount]);
895     }
896     UsbFnMemFree(fnStrings);
897 }
898 
UsbFnCfgMgrFreeFuncDescHead(struct UsbDescriptorHeader ** descHeads)899 static void UsbFnCfgMgrFreeFuncDescHead(struct UsbDescriptorHeader **descHeads)
900 {
901     int8_t iCount;
902 
903     for (iCount = 0; (descHeads[iCount] != NULL); iCount++) {
904         UsbFnMemFree(descHeads[iCount]);
905     }
906     UsbFnMemFree(descHeads);
907 }
908 
UsbFnCfgMgrFreeFunctions(struct UsbFnFunction ** fnFunctions)909 static void UsbFnCfgMgrFreeFunctions(struct UsbFnFunction **fnFunctions)
910 {
911     int8_t iCount;
912 
913     for (iCount = 0; (fnFunctions[iCount] != NULL); iCount++) {
914         if (fnFunctions[iCount]->strings) {
915             UsbFnCfgMgrFreeFnStrings(fnFunctions[iCount]->strings);
916         }
917         if (fnFunctions[iCount]->fsDescriptors) {
918             UsbFnCfgMgrFreeFuncDescHead(fnFunctions[iCount]->fsDescriptors);
919         }
920         if (fnFunctions[iCount]->hsDescriptors) {
921             UsbFnCfgMgrFreeFuncDescHead(fnFunctions[iCount]->hsDescriptors);
922         }
923         if (fnFunctions[iCount]->ssDescriptors) {
924             UsbFnCfgMgrFreeFuncDescHead(fnFunctions[iCount]->ssDescriptors);
925         }
926         if (fnFunctions[iCount]->sspDescriptors) {
927             UsbFnCfgMgrFreeFuncDescHead(fnFunctions[iCount]->sspDescriptors);
928         }
929         UsbFnMemFree(fnFunctions[iCount]);
930     }
931     UsbFnMemFree(fnFunctions);
932 }
933 
UsbFnCfgMgrFreeConfigs(struct UsbFnConfiguration ** fnConfigs)934 static void UsbFnCfgMgrFreeConfigs(struct UsbFnConfiguration **fnConfigs)
935 {
936     int8_t iCount;
937 
938     for (iCount = 0; fnConfigs[iCount] != NULL; iCount++) {
939         if (fnConfigs[iCount]->functions) {
940             UsbFnCfgMgrFreeFunctions(fnConfigs[iCount]->functions);
941         }
942         UsbFnMemFree(fnConfigs[iCount]);
943     }
944     UsbFnMemFree(fnConfigs);
945 }
946 
UsbFnCfgMgrFreeUsbFnDeviceDesc(struct UsbFnDeviceDesc * fnDevDesc)947 void UsbFnCfgMgrFreeUsbFnDeviceDesc(struct UsbFnDeviceDesc *fnDevDesc)
948 {
949     if (fnDevDesc == NULL) {
950         HDF_LOGE("%{public}s: fnDevDesc null", __func__);
951         return;
952     }
953     if (fnDevDesc->deviceDesc) {
954         UsbFnMemFree(fnDevDesc->deviceDesc);
955     }
956     if (fnDevDesc->deviceStrings) {
957         UsbFnCfgMgrFreeFnStrings(fnDevDesc->deviceStrings);
958     }
959     if (fnDevDesc->configs) {
960         UsbFnCfgMgrFreeConfigs(fnDevDesc->configs);
961     }
962     UsbFnMemFree(fnDevDesc);
963 }
964 
IsPropRegisted(const struct UsbFnInterface * intf,const char * name)965 static uint8_t IsPropRegisted(const struct UsbFnInterface *intf, const char *name)
966 {
967     if (DListIsEmpty(&g_cfgEntry) == true) {
968         return 0;
969     }
970 
971     struct UsbFnCfgPropMgr *obj = NULL;
972     struct UsbFnCfgPropMgr *temp = NULL;
973     DLIST_FOR_EACH_ENTRY_SAFE(obj, temp, &g_cfgEntry, struct UsbFnCfgPropMgr, entry) {
974         if (obj->intf && (obj->intf == intf) && strcmp(name, obj->name) == 0) {
975             return 1;
976         }
977     }
978     return 0;
979 }
980 
IsDevDescPropAndGetValue(const struct UsbFnInterface * intf,const char * name,uint16_t * value)981 static int32_t IsDevDescPropAndGetValue(const struct UsbFnInterface *intf, const char *name, uint16_t *value)
982 {
983     if (name == NULL || intf == NULL) {
984         return 0;
985     }
986     struct UsbFnDeviceMgr *fnDevMgr = (struct UsbFnDeviceMgr *)intf->object;
987     if (fnDevMgr == NULL || fnDevMgr->des == NULL || fnDevMgr->des->deviceDesc == NULL) {
988         HDF_LOGE("%{public}s: fnDevMgr is null", __func__);
989         return 0;
990     }
991     if (strcmp(USBDEV_CLASS, name) == 0) {
992         *value = (uint16_t)fnDevMgr->des->deviceDesc->bDeviceClass;
993     } else if (strcmp(USBDEV_SUBCLASS, name) == 0) {
994         *value = (uint16_t)fnDevMgr->des->deviceDesc->bDeviceSubClass;
995     } else if (strcmp(USBDEV_PROTOCOL, name) == 0) {
996         *value = (uint16_t)fnDevMgr->des->deviceDesc->bDeviceProtocol;
997     } else if (strcmp(USBDEV_MAXSIZE, name) == 0) {
998         *value = (uint16_t)fnDevMgr->des->deviceDesc->bMaxPacketSize0;
999     } else if (strcmp(USBDEV_MANUFACTURER, name) == 0) {
1000         *value = (uint16_t)fnDevMgr->des->deviceDesc->iManufacturer;
1001     } else if (strcmp(USBDEV_PRODUCT, name) == 0) {
1002         *value = (uint16_t)fnDevMgr->des->deviceDesc->iProduct;
1003     } else if (strcmp(USBDEV_SERIALNUM, name) == 0) {
1004         *value = (uint16_t)fnDevMgr->des->deviceDesc->iSerialNumber;
1005     } else if (strcmp(USBDEV_NUMCFG, name) == 0) {
1006         *value = (uint16_t)fnDevMgr->des->deviceDesc->bNumConfigurations;
1007     } else if (strcmp(USBDEV_BCD, name) == 0) {
1008         *value = (uint16_t)fnDevMgr->des->deviceDesc->bcdUSB;
1009     } else if (strcmp(USBDEV_VENDOR, name) == 0) {
1010         *value = (uint16_t)fnDevMgr->des->deviceDesc->idVendor;
1011     } else if (strcmp(USBDEV_IDPRODUCT, name) == 0) {
1012         *value = (uint16_t)fnDevMgr->des->deviceDesc->idProduct;
1013     } else if (strcmp(USBDEV_BCDDEVICE, name) == 0) {
1014         *value = (uint16_t)fnDevMgr->des->deviceDesc->bcdDevice;
1015     } else {
1016         HDF_LOGE("%{public}s: other prop", __func__);
1017         return 0;
1018     }
1019     return 1;
1020 }
1021 
IsDevDescProp(const char * name)1022 static int32_t IsDevDescProp(const char *name)
1023 {
1024     if (name == NULL) {
1025         return 0;
1026     }
1027     if ((strcmp(USBDEV_SUBCLASS, name) == 0) || (strcmp(DESC_TYPE, name) == 0) || (strcmp(USBDEV_CLASS, name) == 0) ||
1028         (strcmp(USBDEV_PROTOCOL, name) == 0) || (strcmp(USBDEV_MAXSIZE, name) == 0) ||
1029         (strcmp(USBDEV_MANUFACTURER, name) == 0) || (strcmp(USBDEV_PRODUCT, name) == 0) ||
1030         (strcmp(USBDEV_SERIALNUM, name) == 0) || (strcmp(USBDEV_NUMCFG, name) == 0) ||
1031         (strcmp(USBDEV_BCD, name) == 0) || (strcmp(USBDEV_VENDOR, name) == 0) ||
1032         (strcmp(USBDEV_IDPRODUCT, name) == 0) || (strcmp(USBDEV_BCDDEVICE, name) == 0)) {
1033         return 1;
1034     }
1035     return 0;
1036 }
1037 
UsbFnCfgGetPropValueFromPropList(const struct UsbFnDeviceMgr * fnDevMgr,const struct UsbFnInterface * intf,const struct DeviceResourceIface * drsOps,const struct DeviceResourceNode * propListNode,const char * name)1038 static const char *UsbFnCfgGetPropValueFromPropList(const struct UsbFnDeviceMgr *fnDevMgr,
1039     const struct UsbFnInterface *intf, const struct DeviceResourceIface *drsOps,
1040     const struct DeviceResourceNode *propListNode, const char *name)
1041 {
1042     uint8_t configNum;
1043     uint8_t interfaceNum;
1044     const char *propNodeName = NULL;
1045     const char *propValue = NULL;
1046     const char *propName = NULL;
1047     (void)fnDevMgr;
1048 
1049     if (drsOps->GetUint8(propListNode, "configNum", &configNum, 0) != HDF_SUCCESS) {
1050         HDF_LOGE("%{public}s: read length fail", __func__);
1051         return NULL;
1052     }
1053     if (drsOps->GetUint8(propListNode, "interfaceNum", &interfaceNum, 0) != HDF_SUCCESS) {
1054         HDF_LOGE("%{public}s: read length fail", __func__);
1055         return NULL;
1056     }
1057     if ((intf->info.index != interfaceNum) || (intf->info.configIndex != configNum)) {
1058         HDF_LOGE("%{public}s: prop List is not ringt", __func__);
1059         return NULL;
1060     }
1061     int32_t propCount = drsOps->GetElemNum(propListNode, "propList");
1062     if (propCount <= 0) {
1063         return NULL;
1064     }
1065     for (int32_t count = 0; count < propCount; count++) {
1066         int32_t ret = drsOps->GetStringArrayElem(propListNode, "propList", count, &propNodeName, NULL);
1067         if (ret != HDF_SUCCESS) {
1068             HDF_LOGE("%{public}s: read stringList fail", __func__);
1069             return NULL;
1070         }
1071         const struct DeviceResourceNode *propNode = drsOps->GetChildNode(propListNode, propNodeName);
1072         if (propNode == NULL) {
1073             HDF_LOGE("%{public}s: propNode is null", __func__);
1074             return NULL;
1075         }
1076         if (drsOps->GetString(propNode, "name", &propName, 0) != HDF_SUCCESS) {
1077             return NULL;
1078         }
1079         if (strcmp(propName, name) == 0) {
1080             if (drsOps->GetString(propNode, "value", &propValue, 0) != HDF_SUCCESS) {
1081                 return NULL;
1082             }
1083             return propValue;
1084         }
1085     }
1086 
1087     return NULL;
1088 }
1089 
UsbFnCfgGetPropValueFromHcs(const struct UsbFnDeviceMgr * fnDevMgr,const struct UsbFnInterface * intf,const struct DeviceResourceIface * drsOps,const struct DeviceResourceNode * customNode,const char * name)1090 static const char *UsbFnCfgGetPropValueFromHcs(const struct UsbFnDeviceMgr *fnDevMgr, const struct UsbFnInterface *intf,
1091     const struct DeviceResourceIface *drsOps, const struct DeviceResourceNode *customNode, const char *name)
1092 {
1093     const struct DeviceResourceNode *propListNode = NULL;
1094     const char *propNodeName = NULL;
1095     const char *propValue = NULL;
1096 
1097     int32_t propTabCount = drsOps->GetElemNum(customNode, "propTable");
1098     if (propTabCount <= 0) {
1099         return NULL;
1100     }
1101     uint32_t totalCount = (uint32_t)propTabCount;
1102     for (uint32_t count = 0; count < totalCount; count++) {
1103         int32_t ret = drsOps->GetStringArrayElem(customNode, "propTable", count, &propNodeName, NULL);
1104         if (ret != HDF_SUCCESS) {
1105             HDF_LOGE("%{public}s: read stringList fail", __func__);
1106             return NULL;
1107         }
1108         propListNode = drsOps->GetChildNode(customNode, propNodeName);
1109         if (propListNode == NULL) {
1110             HDF_LOGE("%{public}s: propNode is null", __func__);
1111             return NULL;
1112         }
1113         propValue = UsbFnCfgGetPropValueFromPropList(fnDevMgr, intf, drsOps, propListNode, name);
1114         if (propValue) {
1115             return propValue;
1116         }
1117     }
1118 
1119     return NULL;
1120 }
1121 
UsbFnCfgFindPropFromHcs(const struct UsbFnInterface * intf,const char * name)1122 static const char *UsbFnCfgFindPropFromHcs(const struct UsbFnInterface *intf, const char *name)
1123 {
1124     struct UsbFnDeviceMgr *fnDevMgr = NULL;
1125     const struct DeviceResourceNode *customNode = NULL;
1126     struct DeviceResourceIface *drsOps = NULL;
1127     const char *propValue = NULL;
1128 
1129     if (name == NULL || intf == NULL) {
1130         return NULL;
1131     }
1132     fnDevMgr = (struct UsbFnDeviceMgr *)intf->object;
1133     if (fnDevMgr == NULL || fnDevMgr->node == NULL) {
1134         HDF_LOGE("%{public}s: node is null", __func__);
1135         return NULL;
1136     }
1137     drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
1138     if (drsOps == NULL || drsOps->GetChildNode == NULL) {
1139         HDF_LOGE("%{public}s: invalid drs ops failed", __func__);
1140         return NULL;
1141     }
1142     customNode = drsOps->GetChildNode(fnDevMgr->node, "custom_prop");
1143     if (customNode == NULL) {
1144         HDF_LOGE("%{public}s: childDevDescNode is null", __func__);
1145         return NULL;
1146     }
1147     propValue = UsbFnCfgGetPropValueFromHcs(fnDevMgr, intf, drsOps, customNode, name);
1148 
1149     return propValue;
1150 }
1151 
UsbFnCfgChangeUdcName(const struct UsbFnDeviceMgr * fnDevMgr,struct UsbFnAdapterOps * fnOps)1152 static int32_t UsbFnCfgChangeUdcName(const struct UsbFnDeviceMgr *fnDevMgr, struct UsbFnAdapterOps *fnOps)
1153 {
1154     int32_t ret;
1155 
1156     if (fnDevMgr == NULL || fnOps == NULL) {
1157         return HDF_FAILURE;
1158     }
1159     ret = fnOps->writeUDC(fnDevMgr->name, fnDevMgr->udcName, 0);
1160     if (ret) {
1161         return HDF_FAILURE;
1162     }
1163     ret = fnOps->writeUDC(fnDevMgr->name, fnDevMgr->udcName, 1);
1164     if (ret) {
1165         return HDF_FAILURE;
1166     }
1167 
1168     return HDF_SUCCESS;
1169 }
1170 
UsbFnCfgChangeStrings(const struct UsbFnDeviceMgr * fnDevMgr,struct UsbFnAdapterOps * fnOps,uint32_t index,const char * propName)1171 static int32_t UsbFnCfgChangeStrings(
1172     const struct UsbFnDeviceMgr *fnDevMgr, struct UsbFnAdapterOps *fnOps, uint32_t index, const char *propName)
1173 {
1174     if (fnDevMgr == NULL || fnDevMgr->des == NULL || fnDevMgr->des->deviceStrings == NULL) {
1175         return HDF_FAILURE;
1176     }
1177 
1178     struct UsbFnStrings **strings = fnDevMgr->des->deviceStrings;
1179     for (int32_t i = 0; strings[i] != NULL; i++) {
1180         int32_t ret =
1181             fnOps->writeDesString(fnDevMgr->name, strings[i]->language, propName, strings[i]->strings[index].s);
1182         if (ret != HDF_SUCCESS) {
1183             return HDF_FAILURE;
1184         }
1185     }
1186     return HDF_SUCCESS;
1187 }
1188 
UsbFnCfgChangeDevceDes(const struct UsbFnInterface * intf,const char * name,const char * value)1189 static int32_t UsbFnCfgChangeDevceDes(const struct UsbFnInterface *intf, const char *name, const char *value)
1190 {
1191     int32_t ret;
1192     uint32_t data;
1193     struct UsbFnAdapterOps *fnOps = UsbFnAdapterGetOps();
1194 
1195     if (name == NULL || intf == NULL || fnOps == NULL) {
1196         return HDF_FAILURE;
1197     }
1198     struct UsbFnDeviceMgr *fnDevMgr = (struct UsbFnDeviceMgr *)intf->object;
1199     if (fnDevMgr == NULL || fnDevMgr->des == NULL || fnDevMgr->des->deviceDesc == NULL ||
1200         fnDevMgr->des->deviceStrings == NULL) {
1201         HDF_LOGE("%{public}s: null", __func__);
1202         return HDF_FAILURE;
1203     }
1204     if (sscanf_s(value, "%x", &data) <= 0) {
1205         return HDF_FAILURE;
1206     }
1207     if (strcmp(name, USBDEV_MANUFACTURER) == 0 || strcmp(name, USBDEV_PRODUCT) == 0 ||
1208         strcmp(name, USBDEV_SERIALNUM) == 0) {
1209         ret = UsbFnCfgChangeStrings(fnDevMgr, fnOps, data, name);
1210         if (ret) {
1211             return HDF_ERR_INVALID_PARAM;
1212         }
1213     } else {
1214         ret = fnOps->writeProp(fnDevMgr->name, name, data);
1215         if (ret) {
1216             return HDF_ERR_INVALID_PARAM;
1217         }
1218     }
1219     if (UsbFnCfgChangeUdcName(fnDevMgr, fnOps) != HDF_SUCCESS) {
1220         return HDF_FAILURE;
1221     }
1222     return HDF_SUCCESS;
1223 }
1224 
UsbfnCfgMgrFindPropMgr(const struct UsbFnInterface * intf,const char * name)1225 static struct UsbFnCfgPropMgr *UsbfnCfgMgrFindPropMgr(const struct UsbFnInterface *intf, const char *name)
1226 {
1227     if (DListIsEmpty(&g_cfgEntry) == true) {
1228         return NULL;
1229     }
1230 
1231     struct UsbFnCfgPropMgr *obj = NULL;
1232     struct UsbFnCfgPropMgr *temp = NULL;
1233     DLIST_FOR_EACH_ENTRY_SAFE(obj, temp, &g_cfgEntry, struct UsbFnCfgPropMgr, entry) {
1234         if (obj->intf && (obj->intf == intf) && strcmp(name, obj->name) == 0) {
1235             return obj;
1236         }
1237     }
1238     return NULL;
1239 }
1240 
UsbFnCfgMgrCheckRegist(const struct UsbFnInterface * intf,const struct UsbFnRegistInfo * registInfo,uint8_t isDevProp,int32_t isRegist,struct UsbFnCfgPropMgr * fnCfgPropMgr)1241 static int32_t UsbFnCfgMgrCheckRegist(const struct UsbFnInterface *intf, const struct UsbFnRegistInfo *registInfo,
1242     uint8_t isDevProp, int32_t isRegist, struct UsbFnCfgPropMgr *fnCfgPropMgr)
1243 {
1244     if (isRegist != 0) {
1245         if (isDevProp == 0) {
1246             return HDF_FAILURE;
1247         } else {
1248             fnCfgPropMgr = UsbfnCfgMgrFindPropMgr(intf, registInfo->name);
1249             if (fnCfgPropMgr == NULL) {
1250                 HDF_LOGE("%{public}s:%{public}s not found", __func__, registInfo->name);
1251                 return HDF_FAILURE;
1252             }
1253         }
1254     } else {
1255         fnCfgPropMgr = UsbFnMemCalloc(sizeof(struct UsbFnCfgPropMgr));
1256         if (fnCfgPropMgr == NULL) {
1257             HDF_LOGE("%{public}s:%{public}d UsbFnMemCalloc failed", __func__, __LINE__);
1258             return HDF_FAILURE;
1259         }
1260     }
1261     return HDF_SUCCESS;
1262 }
1263 
UsbFnCfgMgrRegisterProp(const struct UsbFnInterface * intf,const struct UsbFnRegistInfo * registInfo)1264 int32_t UsbFnCfgMgrRegisterProp(const struct UsbFnInterface *intf, const struct UsbFnRegistInfo *registInfo)
1265 {
1266     if (intf == NULL || registInfo == NULL || registInfo->name == NULL) {
1267         return HDF_FAILURE;
1268     }
1269     if (g_cfgEntry.next == 0) {
1270         DListHeadInit(&g_cfgEntry);
1271     }
1272 
1273     struct UsbFnCfgPropMgr *fnCfgPropMgr = NULL;
1274     uint8_t isDevProp = (uint8_t)IsDevDescProp(registInfo->name);
1275     int32_t isRegist = IsPropRegisted(intf, registInfo->name);
1276     int32_t ret = UsbFnCfgMgrCheckRegist(intf, registInfo, isDevProp, isRegist, fnCfgPropMgr);
1277     if (ret != HDF_SUCCESS) {
1278         HDF_LOGE("%{public}s: UsbFnCfgMgrCheckRegist failed", __func__);
1279         return HDF_FAILURE;
1280     }
1281     fnCfgPropMgr->isDevProp = isDevProp;
1282     fnCfgPropMgr->intf = intf;
1283     ret = snprintf_s(fnCfgPropMgr->name, MAX_LEN, MAX_LEN - 1, "%s", registInfo->name);
1284     if (ret < 0) {
1285         HDF_LOGE("%{public}s: snprintf_s failed", __func__);
1286         if (isRegist == 0) {
1287             UsbFnMemFree(fnCfgPropMgr);
1288         }
1289         return HDF_FAILURE;
1290     }
1291     ret = snprintf_s(fnCfgPropMgr->value, MAX_LEN, MAX_LEN - 1, "%s", registInfo->value);
1292     if (ret < 0) {
1293         HDF_LOGE("%{public}s: snprintf_s failed", __func__);
1294         if (isRegist == 0) {
1295             UsbFnMemFree(fnCfgPropMgr);
1296         }
1297         return HDF_FAILURE;
1298     }
1299     fnCfgPropMgr->getPropCallback = registInfo->getProp;
1300     fnCfgPropMgr->setPropCallback = registInfo->setProp;
1301     if (isRegist == 0) {
1302         DListInsertTail(&fnCfgPropMgr->entry, &g_cfgEntry);
1303     }
1304 
1305     return HDF_SUCCESS;
1306 }
1307 
UsbFnCfgMgrUnRegisterAllProp(void)1308 void UsbFnCfgMgrUnRegisterAllProp(void)
1309 {
1310     if (g_cfgEntry.next == NULL) {
1311         return;
1312     }
1313 
1314     struct UsbFnCfgPropMgr *obj = NULL;
1315     struct UsbFnCfgPropMgr *temp = NULL;
1316     DLIST_FOR_EACH_ENTRY_SAFE(obj, temp, &g_cfgEntry, struct UsbFnCfgPropMgr, entry) {
1317         DListRemove(&obj->entry);
1318         UsbFnMemFree(obj);
1319     }
1320     DListHeadInit(&g_cfgEntry);
1321 }
1322 
UsbFnCfgMgrGetProp(const struct UsbFnInterface * intf,const char * name,char * value)1323 int32_t UsbFnCfgMgrGetProp(const struct UsbFnInterface *intf, const char *name, char *value)
1324 {
1325     if (intf == NULL || name == NULL) {
1326         return HDF_FAILURE;
1327     }
1328     if (g_cfgEntry.next == 0) {
1329         DListHeadInit(&g_cfgEntry);
1330     }
1331     if (IsPropRegisted(intf, name) == 0) {
1332         uint16_t val;
1333         if (IsDevDescPropAndGetValue(intf, name, &val)) {
1334             char tmp[MAX_LEN];
1335             if (snprintf_s(tmp, MAX_LEN, MAX_LEN - 1, "%x", val) < 0) {
1336                 return HDF_FAILURE;
1337             }
1338             if (memcpy_s(value, strlen(tmp), tmp, strlen(tmp)) != 0) {
1339                 return HDF_FAILURE;
1340             }
1341             return HDF_SUCCESS;
1342         } else {
1343             const char *propValue = UsbFnCfgFindPropFromHcs(intf, name);
1344             if (propValue == NULL) {
1345                 return HDF_FAILURE;
1346             }
1347             if (memcpy_s(value, strlen(propValue), propValue, strlen(propValue)) != EOK) {
1348                 HDF_LOGE("%{public}s: memcpy_s failed", __func__);
1349                 return HDF_FAILURE;
1350             }
1351             return HDF_SUCCESS;
1352         }
1353     }
1354 
1355     struct UsbFnCfgPropMgr *fnCfgPropMgr = UsbfnCfgMgrFindPropMgr(intf, name);
1356     if (fnCfgPropMgr == NULL) {
1357         return HDF_FAILURE;
1358     }
1359     if (memcpy_s(value, strlen(fnCfgPropMgr->value), fnCfgPropMgr->value, strlen(fnCfgPropMgr->value)) != EOK) {
1360         return HDF_FAILURE;
1361     }
1362     if (fnCfgPropMgr->getPropCallback) {
1363         fnCfgPropMgr->getPropCallback(intf, name, fnCfgPropMgr->value);
1364     }
1365     return HDF_SUCCESS;
1366 }
1367 
UsbFnCfgMgrSetProp(const struct UsbFnInterface * intf,const char * name,const char * value)1368 int32_t UsbFnCfgMgrSetProp(const struct UsbFnInterface *intf, const char *name, const char *value)
1369 {
1370     if (intf == NULL || name == NULL) {
1371         return HDF_FAILURE;
1372     }
1373 
1374     if (g_cfgEntry.next == 0) {
1375         DListHeadInit(&g_cfgEntry);
1376     }
1377 
1378     struct UsbFnRegistInfo registInfo;
1379     registInfo.name = name;
1380     registInfo.value = value;
1381     registInfo.setProp = NULL;
1382     registInfo.getProp = NULL;
1383     int32_t deviceProp = IsDevDescProp(name);
1384     int32_t isRegist = IsPropRegisted(intf, name);
1385     if (isRegist == 0 && deviceProp == 0) {
1386         const char *propValue = UsbFnCfgFindPropFromHcs(intf, name);
1387         if (propValue != NULL) {
1388             return UsbFnCfgMgrRegisterProp(intf, &registInfo);
1389         }
1390         return HDF_FAILURE;
1391     }
1392 
1393     struct UsbFnCfgPropMgr *fnCfgPropMgr = NULL;
1394     if (isRegist != 0) {
1395         fnCfgPropMgr = UsbfnCfgMgrFindPropMgr(intf, name);
1396         if (fnCfgPropMgr == NULL) {
1397             return HDF_FAILURE;
1398         }
1399         int32_t ret = snprintf_s(fnCfgPropMgr->value, MAX_LEN, MAX_LEN - 1, "%s", value);
1400         if (ret < 0) {
1401             return HDF_FAILURE;
1402         }
1403     }
1404     if (deviceProp != 0) {
1405         if (isRegist == 0 && UsbFnCfgMgrRegisterProp(intf, &registInfo) != HDF_SUCCESS) {
1406             return HDF_FAILURE;
1407         }
1408         if (UsbFnCfgChangeDevceDes(intf, name, value) != HDF_SUCCESS) {
1409             return HDF_FAILURE;
1410         }
1411     }
1412     if (isRegist && fnCfgPropMgr->setPropCallback) {
1413         fnCfgPropMgr->setPropCallback(intf, name, fnCfgPropMgr->value);
1414     }
1415     return HDF_SUCCESS;
1416 }
1417