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 "usb_raw_api.h"
17  #include "usb_raw_api_library.h"
18  #include "usbd_wrapper.h"
19  
20  #define HDF_LOG_TAG USB_RAW_API
21  
UsbRawInit(struct UsbSession ** session)22  int32_t UsbRawInit(struct UsbSession **session)
23  {
24      return RawInit(session);
25  }
26  
UsbRawExit(const struct UsbSession * session)27  int32_t UsbRawExit(const struct UsbSession *session)
28  {
29      return RawExit(session);
30  }
31  
UsbRawOpenDevice(const struct UsbSession * session,uint8_t busNum,uint8_t usbAddr)32  UsbRawHandle *UsbRawOpenDevice(const struct UsbSession *session, uint8_t busNum, uint8_t usbAddr)
33  {
34      return (UsbRawHandle *)RawOpenDevice(session, busNum, usbAddr);
35  }
36  
UsbRawCloseDevice(const UsbRawHandle * devHandle)37  int32_t UsbRawCloseDevice(const UsbRawHandle *devHandle)
38  {
39      if (devHandle == NULL) {
40          HDF_LOGE("%{public}s:%{public}d devHandle is NULL", __func__, __LINE__);
41          return HDF_ERR_INVALID_PARAM;
42      }
43  
44      return RawCloseDevice((const struct UsbDeviceHandle *)devHandle);
45  }
46  
UsbRawSendControlRequest(const struct UsbRawRequest * request,const UsbRawHandle * devHandle,const struct UsbControlRequestData * requestData)47  int32_t UsbRawSendControlRequest(
48      const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbControlRequestData *requestData)
49  {
50      if ((request == NULL) || (devHandle == NULL) || (requestData == NULL)) {
51          HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
52          return HDF_ERR_INVALID_PARAM;
53      }
54  
55      return RawSendControlRequest(
56          (struct UsbHostRequest *)request, (const struct UsbDeviceHandle *)devHandle, requestData);
57  }
58  
UsbRawSendBulkRequest(const struct UsbRawRequest * request,const UsbRawHandle * devHandle,const struct UsbRequestData * requestData)59  int32_t UsbRawSendBulkRequest(
60      const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRequestData *requestData)
61  {
62      if ((request == NULL) || (devHandle == NULL) || (requestData == NULL)) {
63          HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
64          return HDF_ERR_INVALID_PARAM;
65      }
66  
67      return RawSendBulkRequest(
68          (const struct UsbHostRequest *)request, (const struct UsbDeviceHandle *)devHandle, requestData);
69  }
70  
UsbRawSendInterruptRequest(const struct UsbRawRequest * request,const UsbRawHandle * devHandle,const struct UsbRequestData * requestData)71  int32_t UsbRawSendInterruptRequest(
72      const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRequestData *requestData)
73  {
74      if ((request == NULL) || (devHandle == NULL) || (requestData == NULL)) {
75          HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
76          return HDF_ERR_INVALID_PARAM;
77      }
78  
79      return RawSendInterruptRequest(
80          (const struct UsbHostRequest *)request, (const struct UsbDeviceHandle *)devHandle, requestData);
81  }
82  
UsbRawGetConfigDescriptor(const UsbRawDevice * rawDev,uint8_t configIndex,struct UsbRawConfigDescriptor ** const config)83  int32_t UsbRawGetConfigDescriptor(
84      const UsbRawDevice *rawDev, uint8_t configIndex, struct UsbRawConfigDescriptor ** const config)
85  {
86      if ((rawDev == NULL) || (config == NULL)) {
87          HDF_LOGE("%{public}s:%{public}d rawDev or config is NULL", __func__, __LINE__);
88          return HDF_ERR_INVALID_PARAM;
89      }
90  
91      return RawGetConfigDescriptor((const struct UsbDevice *)rawDev, configIndex, config);
92  }
93  
UsbRawFreeConfigDescriptor(const struct UsbRawConfigDescriptor * config)94  void UsbRawFreeConfigDescriptor(const struct UsbRawConfigDescriptor *config)
95  {
96      if (config == NULL) {
97          HDF_LOGE("%{public}s:%{public}d config is NULL", __func__, __LINE__);
98          return;
99      }
100  
101      RawClearConfiguration((struct UsbRawConfigDescriptor *)config);
102      RawUsbMemFree((void *)config);
103  }
104  
UsbRawGetConfiguration(const UsbRawHandle * const devHandle,int32_t * config)105  int32_t UsbRawGetConfiguration(const UsbRawHandle * const devHandle, int32_t *config)
106  {
107      if ((devHandle == NULL) || (config == NULL)) {
108          HDF_LOGE("%{public}s:%{public}d dev or config is NULL", __func__, __LINE__);
109          return HDF_ERR_INVALID_PARAM;
110      }
111  
112      return RawGetConfiguration((const struct UsbDeviceHandle *)devHandle, config);
113  }
114  
UsbRawSetConfiguration(const UsbRawHandle * devHandle,int32_t config)115  int32_t UsbRawSetConfiguration(const UsbRawHandle *devHandle, int32_t config)
116  {
117      if (devHandle == NULL) {
118          HDF_LOGE("%{public}s:%{public}d dev is NULL", __func__, __LINE__);
119          return HDF_ERR_INVALID_PARAM;
120      }
121  
122      return RawSetConfiguration((const struct UsbDeviceHandle *)devHandle, config);
123  }
124  
UsbRawControlMsg(const UsbRawHandle * const devHandle,struct UsbControlRequestData * ctrlData)125  int32_t UsbRawControlMsg(const UsbRawHandle * const devHandle, struct UsbControlRequestData *ctrlData)
126  {
127      if ((devHandle == NULL) || (ctrlData == NULL)) {
128          HDF_LOGE("%{public}s:%{public}d dev or config is NULL", __func__, __LINE__);
129          return HDF_ERR_INVALID_PARAM;
130      }
131  
132      return RawUsbControlMsg((const struct UsbDeviceHandle *)devHandle, ctrlData);
133  }
134  
UsbRawGetUsbSpeed(const UsbRawHandle * const devHandle)135  int32_t UsbRawGetUsbSpeed(const UsbRawHandle * const devHandle)
136  {
137      if ((devHandle == NULL)) {
138          HDF_LOGE("%{public}s:%{public}d dev or config is NULL", __func__, __LINE__);
139          return HDF_ERR_INVALID_PARAM;
140      }
141      return RawUsbGetUsbSpeed((const struct UsbDeviceHandle *)devHandle);
142  }
143  
UsbRawGetDescriptor(const struct UsbRawRequest * request,const UsbRawHandle * devHandle,const struct UsbRawDescriptorParam * param,const unsigned char * data)144  int32_t UsbRawGetDescriptor(const struct UsbRawRequest *request, const UsbRawHandle *devHandle,
145      const struct UsbRawDescriptorParam *param, const unsigned char *data)
146  {
147      if ((request == NULL) || (devHandle == NULL) || (param == NULL) || (data == NULL)) {
148          HDF_LOGE("%{public}s:%{public}d request or devHandle is NULL", __func__, __LINE__);
149          return HDF_ERR_INVALID_PARAM;
150      }
151  
152      return RawGetDescriptor(
153          (const struct UsbHostRequest *)request, (const struct UsbDeviceHandle *)devHandle, param, data);
154  }
155  
UsbRawGetDevice(const UsbRawHandle * const devHandle)156  UsbRawDevice *UsbRawGetDevice(const UsbRawHandle * const devHandle)
157  {
158      if (devHandle == NULL) {
159          HDF_LOGE("%{public}s:%{public}d devHandle is NULL ", __func__, __LINE__);
160          return NULL;
161      }
162  
163      return (UsbRawDevice *)RawGetDevice((const struct UsbDeviceHandle *)devHandle);
164  }
165  
UsbRawGetDeviceDescriptor(const UsbRawDevice * rawDev,struct UsbDeviceDescriptor * desc)166  int32_t UsbRawGetDeviceDescriptor(const UsbRawDevice *rawDev, struct UsbDeviceDescriptor *desc)
167  {
168      if ((rawDev == NULL) || (desc == NULL)) {
169          HDF_LOGE("%{public}s:%{public}d rawDev or desc is NULL", __func__, __LINE__);
170          return HDF_ERR_INVALID_PARAM;
171      }
172  
173      return RawGetDeviceDescriptor((const struct UsbDevice *)rawDev, desc);
174  }
175  
UsbRawClaimInterface(const UsbRawHandle * devHandle,int32_t interfaceNumber)176  int32_t UsbRawClaimInterface(const UsbRawHandle *devHandle, int32_t interfaceNumber)
177  {
178      if (devHandle == NULL) {
179          HDF_LOGE("%{public}s:%{public}d devHandle is NULL", __func__, __LINE__);
180          return HDF_ERR_INVALID_PARAM;
181      }
182  
183      return RawClaimInterface((struct UsbDeviceHandle *)devHandle, interfaceNumber);
184  }
185  
UsbRawReleaseInterface(const UsbRawHandle * devHandle,int32_t interfaceNumber)186  int32_t UsbRawReleaseInterface(const UsbRawHandle *devHandle, int32_t interfaceNumber)
187  {
188      if (devHandle == NULL) {
189          HDF_LOGE("%{public}s:%{public}d devHandle is NULL", __func__, __LINE__);
190          return HDF_ERR_INVALID_PARAM;
191      }
192  
193      return RawReleaseInterface((struct UsbDeviceHandle *)devHandle, interfaceNumber);
194  }
195  
UsbRawResetDevice(const UsbRawHandle * devHandle)196  int32_t UsbRawResetDevice(const UsbRawHandle *devHandle)
197  {
198      if (devHandle == NULL) {
199          HDF_LOGE("%{public}s:%{public}d devHandle is NULL", __func__, __LINE__);
200          return HDF_ERR_INVALID_PARAM;
201      }
202  
203      return RawResetDevice((const struct UsbDeviceHandle *)devHandle);
204  }
205  
UsbRawAllocRequest(const UsbRawHandle * devHandle,int32_t isoPackets,int32_t length)206  struct UsbRawRequest *UsbRawAllocRequest(const UsbRawHandle *devHandle, int32_t isoPackets, int32_t length)
207  {
208      if (devHandle == NULL) {
209          HDF_LOGE("%{public}s:%{public}d devHandle is NULL", __func__, __LINE__);
210          return NULL;
211      }
212  
213      return (struct UsbRawRequest *)RawAllocRequest((const struct UsbDeviceHandle *)devHandle, isoPackets, length);
214  }
215  
UsbRawFreeRequest(const struct UsbRawRequest * request)216  int32_t UsbRawFreeRequest(const struct UsbRawRequest *request)
217  {
218      if (request == NULL) {
219          HDF_LOGE("%{public}s:%{public}d request is NULL", __func__, __LINE__);
220          return HDF_ERR_INVALID_PARAM;
221      }
222  
223      return RawFreeRequest((const struct UsbHostRequest *)request);
224  }
225  
UsbRawFillBulkRequest(const struct UsbRawRequest * request,const UsbRawHandle * devHandle,const struct UsbRawFillRequestData * fillData)226  int32_t UsbRawFillBulkRequest(
227      const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRawFillRequestData *fillData)
228  {
229      if ((request == NULL) || (devHandle == NULL) || (fillData == NULL)) {
230          HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
231          return HDF_ERR_INVALID_PARAM;
232      }
233  
234      return RawFillBulkRequest((struct UsbHostRequest *)request, (const struct UsbDeviceHandle *)devHandle,
235          (const struct UsbFillRequestData *)fillData);
236  }
237  
UsbRawFillControlSetup(const unsigned char * setup,const struct UsbControlRequestData * requestData)238  int32_t UsbRawFillControlSetup(const unsigned char *setup, const struct UsbControlRequestData *requestData)
239  {
240      if ((setup == NULL) || (requestData == NULL)) {
241          HDF_LOGE("%{public}s:%{public}d setup or requestData is NULL", __func__, __LINE__);
242          return HDF_ERR_INVALID_PARAM;
243      }
244  
245      return RawFillControlSetup(setup, requestData);
246  }
247  
UsbRawFillControlRequest(const struct UsbRawRequest * request,const UsbRawHandle * devHandle,const struct UsbRawFillRequestData * fillData)248  int32_t UsbRawFillControlRequest(
249      const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRawFillRequestData *fillData)
250  {
251      if ((request == NULL) || (devHandle == NULL) || (fillData == NULL)) {
252          HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
253          return HDF_ERR_INVALID_PARAM;
254      }
255  
256      return RawFillControlRequest((struct UsbHostRequest *)request, (const struct UsbDeviceHandle *)devHandle,
257          (const struct UsbFillRequestData *)fillData);
258  }
259  
UsbRawFillInterruptRequest(const struct UsbRawRequest * request,const UsbRawHandle * devHandle,const struct UsbRawFillRequestData * fillData)260  int32_t UsbRawFillInterruptRequest(
261      const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRawFillRequestData *fillData)
262  {
263      if ((request == NULL) || (devHandle == NULL) || (fillData == NULL)) {
264          HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
265          return HDF_ERR_INVALID_PARAM;
266      }
267  
268      return RawFillInterruptRequest((struct UsbHostRequest *)request, (const struct UsbDeviceHandle *)devHandle,
269          (const struct UsbFillRequestData *)fillData);
270  }
271  
UsbRawFillIsoRequest(const struct UsbRawRequest * request,const UsbRawHandle * devHandle,const struct UsbRawFillRequestData * fillData)272  int32_t UsbRawFillIsoRequest(
273      const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRawFillRequestData *fillData)
274  {
275      if ((request == NULL) || (devHandle == NULL) || (fillData == NULL)) {
276          HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
277          return HDF_ERR_INVALID_PARAM;
278      }
279  
280      return RawFillIsoRequest((struct UsbHostRequest *)request, (const struct UsbDeviceHandle *)devHandle,
281          (const struct UsbFillRequestData *)fillData);
282  }
283  
UsbRawSubmitRequest(const struct UsbRawRequest * request)284  int32_t UsbRawSubmitRequest(const struct UsbRawRequest *request)
285  {
286      if (request == NULL) {
287          HDF_LOGE("%{public}s:%{public}d request is NULL", __func__, __LINE__);
288          return HDF_ERR_INVALID_PARAM;
289      }
290  
291      return RawSubmitRequest((const struct UsbHostRequest *)request);
292  }
293  
UsbRawCancelRequest(const struct UsbRawRequest * request)294  int32_t UsbRawCancelRequest(const struct UsbRawRequest *request)
295  {
296      if (request == NULL) {
297          HDF_LOGE("%{public}s:%{public}d request is NULL", __func__, __LINE__);
298          return HDF_ERR_INVALID_PARAM;
299      }
300  
301      return RawCancelRequest((const struct UsbHostRequest *)request);
302  }
303  
UsbRawHandleRequests(const UsbRawHandle * devHandle)304  int32_t UsbRawHandleRequests(const UsbRawHandle *devHandle)
305  {
306      if (devHandle == NULL) {
307          HDF_LOGE("%{public}s:%{public}d devHandle is NULL", __func__, __LINE__);
308          return HDF_ERR_INVALID_PARAM;
309      }
310  
311      return RawHandleRequest((const struct UsbDeviceHandle *)devHandle);
312  }
313