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
22int32_t UsbRawInit(struct UsbSession **session)
23{
24    return RawInit(session);
25}
26
27int32_t UsbRawExit(const struct UsbSession *session)
28{
29    return RawExit(session);
30}
31
32UsbRawHandle *UsbRawOpenDevice(const struct UsbSession *session, uint8_t busNum, uint8_t usbAddr)
33{
34    return (UsbRawHandle *)RawOpenDevice(session, busNum, usbAddr);
35}
36
37int32_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
47int32_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
59int32_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
71int32_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
83int32_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
94void 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
105int32_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
115int32_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
125int32_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
135int32_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
144int32_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
156UsbRawDevice *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
166int32_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
176int32_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
186int32_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
196int32_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
206struct 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
216int32_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
226int32_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
238int32_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
248int32_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
260int32_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
272int32_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
284int32_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
294int32_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
304int32_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