1/*
2 * Copyright (c) 2021-2023 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 "linux_adapter.h"
17#include <errno.h>
18#include <fcntl.h>
19#include <signal.h>
20#include <sys/ioctl.h>
21#include <sys/mman.h>
22#include <unistd.h>
23#include "usbd_wrapper.h"
24
25#define HDF_LOG_TAG USB_LINUX_ADAPTER
26#define MIN(a, b) ((a) < (b) ? (a) : (b))
27
28#define PATH_LEN             50
29#define DESC_READ_LEN        256
30#define EP_NUM_MAX           30
31#define SLEEP_TIME           500000
32#define USB_DEVICE_MMAP_PATH "/data/service/el1/public/usb/"
33
34static void *OsAdapterRealloc(void *ptr, size_t oldSize, size_t newSize)
35{
36    void *mem = RawUsbMemAlloc(newSize);
37    if (mem == NULL) {
38        HDF_LOGE("%{public}s:%{public}d RawUsbMemAlloc failed.", __func__, __LINE__);
39        return NULL;
40    }
41
42    if (oldSize > 0) {
43        if (memmove_s(mem, newSize, ptr, oldSize) != EOK) {
44            HDF_LOGE("%{public}s:%{public}d", __func__, __LINE__);
45            RawUsbMemFree(mem);
46            mem = NULL;
47            return NULL;
48        }
49    }
50
51    RawUsbMemFree(ptr);
52    ptr = NULL;
53    return mem;
54}
55
56static bool OsDeviceCompare(struct HdfSListNode *listEntry, uint32_t searchKey)
57{
58    struct UsbDevice *dev = (struct UsbDevice *)listEntry;
59    if (dev == NULL) {
60        HDF_LOGE("%{public}s:%{public}d invalid param listEntry.", __func__, __LINE__);
61        return false;
62    }
63
64    if ((dev->busNum == (searchKey >> BUS_OFFSET)) && (dev->devAddr == (searchKey & 0xFF))) {
65        return true;
66    }
67
68    return false;
69}
70
71static struct UsbDeviceHandle *OsGetDeviceHandle(struct UsbSession *session, uint8_t busNum, uint8_t usbAddr)
72{
73    struct UsbDevice *dev = NULL;
74    struct UsbDeviceHandle *handle = NULL;
75
76    if (session == NULL) {
77        HDF_LOGE("%{public}s:%{public}d invalid param session.", __func__, __LINE__);
78        return NULL;
79    }
80
81    OsalMutexLock(&session->lock);
82    dev = (struct UsbDevice *)HdfSListSearch(&session->usbDevs, (busNum << BUS_OFFSET) | usbAddr, OsDeviceCompare);
83    if (dev != NULL) {
84        handle = dev->devHandle;
85        AdapterAtomicInc(&dev->refcnt);
86    }
87    OsalMutexUnlock(&session->lock);
88
89    return handle;
90}
91
92static struct UsbDeviceHandle *OsCallocDeviceHandle(void)
93{
94    struct UsbDeviceHandle *handle = NULL;
95
96    handle = RawUsbMemCalloc(sizeof(*handle));
97    if (handle == NULL) {
98        HDF_LOGE("%{public}s:%{public}d allocate handle failed", __func__, __LINE__);
99        return NULL;
100    }
101
102    OsalMutexInit(&handle->lock);
103
104    return handle;
105}
106
107static struct UsbDevice *OsAllocDevice(struct UsbSession *session, struct UsbDeviceHandle *handle)
108{
109    struct UsbDevice *dev = RawUsbMemCalloc(sizeof(*dev));
110    if (dev == NULL) {
111        HDF_LOGE("%{public}s:%{public}d RawUsbMemCalloc failed.", __func__, __LINE__);
112        return NULL;
113    }
114
115    dev->session = session;
116    dev->devHandle = handle;
117
118    RawRequestListInit(dev);
119
120    handle->dev = dev;
121
122    return dev;
123}
124
125static int32_t GetMmapFd(struct UsbDevice *dev)
126{
127    char path[PATH_LEN] = {'\0'};
128    int32_t ret = sprintf_s(path, PATH_LEN, USB_DEVICE_MMAP_PATH "%03u_%03u", dev->busNum, dev->devAddr);
129    if (ret < HDF_SUCCESS) {
130        HDF_LOGE("%{public}s:%{public}d path error", __func__, __LINE__);
131        return HDF_FAILURE;
132    }
133
134    int32_t fd = open(path, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
135    if (fd < 0) {
136        HDF_LOGE("%{public}s: open error:%{public}s", __func__, path);
137        return HDF_FAILURE;
138    }
139    dev->devHandle->mmapFd = fd;
140    return HDF_SUCCESS;
141}
142
143static int32_t GetUsbDevicePath(struct UsbDevice *dev, char *pathBuf, size_t length)
144{
145    char path[PATH_LEN] = {'\0'};
146    int32_t ret = sprintf_s(path, sizeof(path), USB_DEV_FS_PATH "/%03u/%03u", dev->busNum, dev->devAddr);
147    if (ret < HDF_SUCCESS) {
148        HDF_LOGE("%{public}s:%{public}d path error", __func__, __LINE__);
149        return HDF_FAILURE;
150    }
151
152    if (realpath(path, pathBuf) == NULL) {
153        HDF_LOGE("%{public}s: path conversion failed, path: %{public}s", __func__, path);
154        return HDF_FAILURE;
155    }
156
157    if (length < strlen(USB_DEV_FS_PATH)) {
158        HDF_LOGE("%{public}s: invalid length, path: %{public}s", __func__, path);
159        return HDF_FAILURE;
160    }
161
162    if (strncmp(USB_DEV_FS_PATH, pathBuf, strlen(USB_DEV_FS_PATH)) != 0) {
163        HDF_LOGE("%{public}s: The file path is incorrect, path: %{public}s", __func__, path);
164        return HDF_FAILURE;
165    }
166    return HDF_SUCCESS;
167}
168
169static int32_t OsGetUsbFd(struct UsbDevice *dev, mode_t mode)
170{
171    if (dev == NULL) {
172        HDF_LOGE("%{public}s: invalid param", __func__);
173        return HDF_ERR_INVALID_PARAM;
174    }
175
176    int32_t ret = GetMmapFd(dev);
177    if (ret != HDF_SUCCESS) {
178        HDF_LOGE("%{public}s: get mmap fd failed:%{public}d", __func__, ret);
179        return ret;
180    }
181
182    char pathBuf[PATH_LEN] = {'\0'};
183    ret = GetUsbDevicePath(dev, pathBuf, PATH_LEN);
184    if (ret != HDF_SUCCESS) {
185        HDF_LOGE("%{public}s: get usb device path failed:%{public}d", __func__, ret);
186        return ret;
187    }
188
189    int32_t fd = open(pathBuf, mode | O_CLOEXEC);
190    if (fd != HDF_FAILURE) {
191        return fd;
192    }
193
194    usleep(SLEEP_TIME);
195    switch (errno) {
196        case ENOENT:
197            fd = open(pathBuf, mode | O_CLOEXEC);
198            if (fd != HDF_FAILURE) {
199                return fd;
200            }
201            ret = HDF_DEV_ERR_NO_DEVICE;
202            break;
203        case EACCES:
204            ret = HDF_ERR_BAD_FD;
205            break;
206        default:
207            ret = HDF_FAILURE;
208            break;
209    }
210
211    return ret;
212}
213
214static int32_t OsReadDescriptors(struct UsbDevice *dev)
215{
216    int32_t fd = dev->devHandle->fd;
217    size_t allocLen = 0;
218
219    do {
220        size_t oldLen = allocLen;
221        allocLen += DESC_READ_LEN;
222        dev->descriptors = OsAdapterRealloc(dev->descriptors, oldLen, allocLen);
223        if (!dev->descriptors) {
224            HDF_LOGE("%{public}s:%{public}d", __func__, __LINE__);
225            return HDF_ERR_MALLOC_FAIL;
226        }
227        uint8_t *ptr = (uint8_t *)dev->descriptors + dev->descriptorsLength;
228        if (memset_s(ptr, DESC_READ_LEN, 0, DESC_READ_LEN) != EOK) {
229            HDF_LOGE("%{public}s:%{public}d memset_s failed", __func__, __LINE__);
230            return HDF_FAILURE;
231        }
232
233        int32_t len = read(fd, ptr, DESC_READ_LEN);
234        if (len < 0) {
235            HDF_LOGE("read descriptor failed, errno=%{public}d", errno);
236            return HDF_ERR_IO;
237        }
238        dev->descriptorsLength += (size_t)len;
239    } while (dev->descriptorsLength == allocLen);
240
241    return HDF_SUCCESS;
242}
243
244static int32_t OsParseConfigDescriptors(struct UsbDevice *dev)
245{
246    struct UsbDeviceDescriptor *deviceDesc = NULL;
247    uint8_t i;
248    uint8_t numConfigs;
249    uint8_t *buffer = NULL;
250    size_t descLen;
251
252    deviceDesc = dev->descriptors;
253    numConfigs = deviceDesc->bNumConfigurations;
254    if (numConfigs == 0) {
255        return HDF_SUCCESS;
256    }
257    dev->configDescriptors = RawUsbMemAlloc(numConfigs * sizeof(struct UsbDeviceConfigDescriptor));
258    if (dev->configDescriptors == NULL) {
259        HDF_LOGE("%{public}s:%{public}d RawUsbMemAlloc failed.", __func__, __LINE__);
260        return HDF_ERR_MALLOC_FAIL;
261    }
262    buffer = (uint8_t *)dev->descriptors + USB_DDK_DT_DEVICE_SIZE;
263    descLen = dev->descriptorsLength - USB_DDK_DT_DEVICE_SIZE;
264
265    for (i = 0; i < numConfigs; i++) {
266        struct UsbConfigDescriptor *configDesc = NULL;
267        uint16_t configLen;
268
269        if (descLen < USB_DDK_DT_CONFIG_SIZE) {
270            HDF_LOGE("%{public}s:%{public}d read %{public}zu", __func__, __LINE__, descLen);
271            RawUsbMemFree(dev->configDescriptors);
272            return HDF_ERR_IO;
273        }
274        configDesc = (struct UsbConfigDescriptor *)buffer;
275        if ((configDesc->bDescriptorType != USB_DDK_DT_CONFIG) || (configDesc->bLength < USB_DDK_DT_CONFIG_SIZE)) {
276            HDF_LOGE("%{public}s:%{public}d config desc error: type 0x%{public}02x, length %{public}u",
277                __func__, __LINE__, configDesc->bDescriptorType, configDesc->bLength);
278            RawUsbMemFree(dev->configDescriptors);
279            return HDF_ERR_IO;
280        }
281        configLen = LE16_TO_CPU(configDesc->wTotalLength);
282        if (configLen < USB_DDK_DT_CONFIG_SIZE) {
283            HDF_LOGE("invalid wTotalLength value %{public}u", configLen);
284            RawUsbMemFree(dev->configDescriptors);
285            return HDF_ERR_IO;
286        }
287        if (configLen > descLen) {
288            HDF_LOGD("%{public}s:%{public}d read %{public}zu/%{public}u", __func__, __LINE__, descLen, configLen);
289            configLen = (uint16_t)descLen;
290        }
291        dev->configDescriptors[i].desc = configDesc;
292        dev->configDescriptors[i].actualLen = configLen;
293        buffer += configLen;
294        descLen -= configLen;
295    }
296    return HDF_SUCCESS;
297}
298
299static int32_t OsInitDevice(struct UsbDevice *dev, uint8_t busNum, uint8_t devAddr)
300{
301    struct UsbDeviceHandle *devHandle = dev->devHandle;
302    int32_t fd;
303    int32_t ret;
304
305    dev->busNum = busNum;
306    dev->devAddr = devAddr;
307
308    fd = OsGetUsbFd(dev, O_RDWR);
309    if (fd < 0) {
310        return fd;
311    }
312    devHandle->fd = fd;
313
314    ret = ioctl(fd, USBDEVFS_GET_CAPABILITIES, &devHandle->caps);
315    if (ret < 0) {
316        HDF_LOGE("%{public}s:%{public}d get capabilities failed, errno=%{public}d", __func__, __LINE__, errno);
317        devHandle->caps = USB_ADAPTER_CAP_BULK_CONTINUATION;
318    }
319
320    dev->descriptorsLength = 0;
321    ret = OsReadDescriptors(dev);
322    if (ret != HDF_SUCCESS) {
323        HDF_LOGE("%{public}s:%{public}d OsReadDescriptors failed ret = %{pubilc}d", __func__, __LINE__, ret);
324        return ret;
325    }
326    ret = OsParseConfigDescriptors(dev);
327    if (ret != HDF_SUCCESS) {
328        HDF_LOGE("%{public}s:%{public}d OsParseConfigDescriptors failed ret = %{pubilc}d", __func__, __LINE__, ret);
329        return ret;
330    }
331    ret =
332        memcpy_s(&dev->deviceDescriptor, sizeof(struct UsbDeviceDescriptor), dev->descriptors, USB_DDK_DT_DEVICE_SIZE);
333    if (ret != EOK) {
334        HDF_LOGE("%{public}s:%{public}d memcpy_s failed ret = %{public}d", __func__, __LINE__, ret);
335        ret = HDF_ERR_IO;
336    }
337    return ret;
338}
339
340static int32_t OsGetActiveConfig(struct UsbDevice *dev, int32_t fd)
341{
342    int32_t ret;
343    uint8_t activeConfig = 0;
344    struct UsbControlRequestData ctrlData;
345
346    if (dev == NULL) {
347        HDF_LOGE("%{public}s:%{public}d invalid param dev.", __func__, __LINE__);
348        return HDF_ERR_INVALID_PARAM;
349    }
350
351    ctrlData.requestType = USB_PIPE_DIRECTION_IN;
352    ctrlData.requestCmd = USB_REQUEST_GET_CONFIGURATION;
353    ctrlData.value = 0;
354    ctrlData.index = 0;
355    ctrlData.length = 1;
356    ctrlData.timeout = USB_RAW_REQUEST_DEFAULT_TIMEOUT;
357    ctrlData.data = &activeConfig;
358    ret = ioctl(fd, USBDEVFS_CONTROL, &ctrlData);
359    if (ret < 0) {
360        HDF_LOGE("%{public}s:%{public}d ioctl failed errno = %{public}d", __func__, __LINE__, errno);
361        return HDF_FAILURE;
362    }
363    dev->activeConfig = activeConfig;
364
365    return HDF_SUCCESS;
366}
367
368static int32_t AdapterUsbControlMsg(const struct UsbDeviceHandle *handle, struct UsbControlRequestData *ctrlData)
369{
370    if (handle == NULL || handle->dev == NULL || ctrlData == NULL) {
371        HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
372        return HDF_ERR_INVALID_PARAM;
373    }
374
375    return ioctl(handle->fd, USBDEVFS_CONTROL, ctrlData);
376}
377
378static int32_t AdapterGetUsbSpeed(const struct UsbDeviceHandle *handle)
379{
380    if (handle == NULL || handle->dev == NULL) {
381        HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
382        return HDF_ERR_INVALID_PARAM;
383    }
384    int32_t ret = ioctl(handle->fd, USBDEVFS_GET_SPEED, NULL);
385    HDF_LOGI("%{public}s:%{public}d speed = %{public}d", __func__, __LINE__, ret);
386    return ret;
387}
388
389static void OsFreeIsoUrbs(struct UsbHostRequest *request)
390{
391    struct UsbAdapterUrb *urb = NULL;
392
393    for (int32_t i = 0; i < request->numUrbs; i++) {
394        urb = request->isoUrbs[i];
395        if (urb == NULL) {
396            break;
397        }
398        RawUsbMemFree(urb);
399    }
400
401    RawUsbMemFree(request->isoUrbs);
402    request->isoUrbs = NULL;
403}
404
405static void OsDiscardUrbs(const struct UsbHostRequest *request, int32_t first, int32_t last)
406{
407    struct UsbAdapterUrb *urb = NULL;
408
409    if (request == NULL || request->devHandle == NULL || first > URBS_PER_REQUEST || first > last) {
410        HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
411        return;
412    }
413
414    for (int32_t i = last - 1; i >= first; i--) {
415        if (request->requestType == USB_REQUEST_TYPE_ISOCHRONOUS) {
416            urb = request->isoUrbs[i];
417        } else {
418            urb = &request->urbs[i];
419        }
420        if (ioctl(request->devHandle->fd, USBDEVFS_DISCARDURB, urb) == 0) {
421            continue;
422        }
423    }
424}
425
426static int32_t OsSubmitControlRequest(struct UsbHostRequest *request)
427{
428    struct UsbAdapterUrb *urb = NULL;
429    int32_t ret;
430    int32_t fd;
431
432    if (request == NULL || request->devHandle == NULL || request->length > MAX_BULK_DATA_BUFFER_LENGTH) {
433        HDF_LOGD("%{public}s:%{public}d invalid param", __func__, __LINE__);
434        return HDF_ERR_INVALID_PARAM;
435    }
436
437    fd = request->devHandle->fd;
438    urb = RawUsbMemCalloc(sizeof(*urb));
439    if (urb == NULL) {
440        HDF_LOGE("%{public}s:%{public}d RawUsbMemCalloc failed.", __func__, __LINE__);
441        return HDF_ERR_MALLOC_FAIL;
442    }
443
444    urb->type = USB_ADAPTER_URB_TYPE_CONTROL;
445    urb->endPoint = request->endPoint;
446    urb->buffer = request->buffer;
447    urb->bufferLength = (int32_t)request->length;
448    urb->userContext = request;
449    request->urbs = urb;
450    request->numUrbs = 1;
451
452    ret = ioctl(fd, USBDEVFS_SUBMITURB, urb);
453    if (ret < 0) {
454        HDF_LOGE("%{public}s:%{public}d submiturb failed, errno = %{public}d", __func__, __LINE__, errno);
455        RawUsbMemFree(urb);
456        request->urbs = NULL;
457        if (errno == ENODEV) {
458            return HDF_DEV_ERR_NO_DEVICE;
459        }
460        return HDF_ERR_IO;
461    }
462    return HDF_SUCCESS;
463}
464
465static int32_t OsSubmitBulkRequestHandleUrb(
466    struct UsbHostRequest *request, struct UsbAdapterUrb *urb, int32_t bulkBufferLen, int32_t number)
467{
468    if (bulkBufferLen == 0) {
469        HDF_LOGE("%{public}s:%{public}d bulkBufferLen can not be zero", __func__, __LINE__);
470        return HDF_ERR_INVALID_PARAM;
471    }
472
473    urb->userContext = (void *)request;
474    switch (request->requestType) {
475        case USB_REQUEST_TYPE_BULK:
476            urb->type = USB_ADAPTER_URB_TYPE_BULK;
477            break;
478        case USB_REQUEST_TYPE_INTERRUPT:
479            urb->type = USB_ADAPTER_URB_TYPE_INTERRUPT;
480            break;
481        default:
482            HDF_LOGE("%{public}s:%{public}d unknown requestType = %{public}u",
483                __func__, __LINE__, request->requestType);
484            return HDF_ERR_INVALID_PARAM;
485    }
486    urb->endPoint = request->endPoint;
487    urb->buffer = request->buffer + (number * bulkBufferLen);
488    if (number == request->numUrbs - 1) {
489        uint32_t len = request->length % (uint32_t)(bulkBufferLen);
490        urb->bufferLength = (int32_t)(len == 0) ? bulkBufferLen : (int32_t)len;
491    } else {
492        urb->bufferLength = bulkBufferLen;
493    }
494
495    return HDF_SUCCESS;
496}
497
498static int32_t OsSubmitBulkRequestHandle(
499    struct UsbHostRequest *request, struct UsbAdapterUrb *urbs, int32_t bulkBufferLen)
500{
501    int32_t fd = request->devHandle->fd;
502    int32_t numUrbs = request->numUrbs;
503
504    for (int32_t i = 0; i < numUrbs; i++) {
505        struct UsbAdapterUrb *urb = &urbs[i];
506        int32_t ret = OsSubmitBulkRequestHandleUrb(request, urb, bulkBufferLen, i);
507        if (ret != HDF_SUCCESS) {
508            return ret;
509        }
510
511        ret = ioctl(fd, USBDEVFS_SUBMITURB, urb);
512        if (ret == 0) {
513            continue;
514        }
515
516        if (i == 0) {
517            HDF_LOGD("submitUrb: ret=%{public}d errno=%{public}d length=%{public}d endPoint=%{public}d type=%{public}d",
518                ret, errno, urb->bufferLength, urb->endPoint, urb->type);
519            return HDF_ERR_IO;
520        }
521        request->numRetired += numUrbs - i;
522        if (errno != EREMOTEIO) {
523            request->reqStatus = USB_REQUEST_ERROR;
524        }
525
526        return HDF_SUCCESS;
527    }
528
529    return HDF_SUCCESS;
530}
531
532static int32_t OsSubmitBulkRequest(struct UsbHostRequest *request)
533{
534    struct UsbAdapterUrb *urbs = NULL;
535    int32_t bulkBufferLen;
536    int32_t numUrbs;
537
538    if (request == NULL) {
539        HDF_LOGE("%{public}s: invalid param", __func__);
540        return HDF_ERR_INVALID_PARAM;
541    }
542
543    if (request->length <= 0) {
544        HDF_LOGE("request->length less than the minimum");
545        return HDF_FAILURE;
546    }
547
548    if (request->length > MAX_BULK_DATA_BUFFER_LENGTH) {
549        HDF_LOGW("request->length greater than the maximum");
550    }
551
552    if (request->devHandle->caps & USB_ADAPTER_CAP_BULK_SCATTER_GATHER) {
553        // The 1 is to prevent division by zero errors
554        bulkBufferLen = (int32_t)request->length ? (int32_t)request->length : 1;
555    } else if (request->devHandle->caps & USB_ADAPTER_CAP_BULK_CONTINUATION) {
556        bulkBufferLen = MAX_BULK_DATA_BUFFER_LENGTH;
557    } else if (request->devHandle->caps & USB_ADAPTER_CAP_NO_PACKET_SIZE_LIM) {
558        // The 1 is to prevent division by zero errors
559        bulkBufferLen = (int32_t)request->length ? request->length : 1;
560    } else {
561        bulkBufferLen = MAX_BULK_DATA_BUFFER_LENGTH;
562    }
563    numUrbs = (int32_t)request->length / bulkBufferLen;
564    if ((request->length % bulkBufferLen) > 0) {
565        numUrbs++;
566    }
567
568    if (numUrbs != 1) {
569        urbs = RawUsbMemCalloc(numUrbs * sizeof(*urbs));
570        if (request->bulkUrb) {
571            RawUsbMemFree(request->bulkUrb);
572        }
573        request->bulkUrb = urbs;
574        request->urbs = NULL;
575    } else {
576        urbs = request->bulkUrb;
577    }
578
579    if (urbs == NULL) {
580        HDF_LOGE("%{public}s:%{public}d no mem", __func__, __LINE__);
581        return HDF_ERR_MALLOC_FAIL;
582    }
583    request->urbs = urbs;
584    request->numUrbs = numUrbs;
585    request->numRetired = 0;
586    request->reqStatus = USB_REQUEST_COMPLETED;
587
588    return OsSubmitBulkRequestHandle(request, urbs, bulkBufferLen);
589}
590
591static int32_t OsAllocIsoUrbs(struct UsbHostRequest *request, int32_t numUrbs, struct UsbAdapterUrb **urbs)
592{
593    struct UsbAdapterUrb *urb = NULL;
594    unsigned char *urbBuffer = request->buffer;
595    int32_t numPacketsLeft = request->numIsoPackets;
596    int32_t packetIdx = 0;
597    int32_t i, j;
598
599    for (i = 0; i < numUrbs; i++) {
600        int32_t numPackets = MIN(numPacketsLeft, MAX_ISO_PACKETS_PER_URB);
601        urb = RawUsbMemCalloc(sizeof(struct UsbAdapterUrb));
602        if (urb == NULL) {
603            OsFreeIsoUrbs(request);
604            return HDF_ERR_MALLOC_FAIL;
605        }
606        urbs[i] = urb;
607
608        for (j = 0; j < numPackets; j++) {
609            unsigned int packetLen = request->isoPacketDesc[packetIdx++].length;
610            urb->bufferLength += (int32_t)packetLen;
611            urb->isoFrameDesc[j].length = packetLen;
612        }
613        urb->type = USB_ADAPTER_URB_TYPE_ISO;
614        urb->flags = USB_ADAPTER_URB_ISO_ASAP;
615        urb->endPoint = request->endPoint;
616        urb->numberOfPackets = numPackets;
617        urb->buffer = (void *)urbBuffer;
618        urb->userContext = request;
619        urbBuffer += urb->bufferLength;
620        numPacketsLeft -= numPackets;
621    }
622
623    return HDF_SUCCESS;
624}
625
626static int32_t OsSubmitIsoUrbs(struct UsbHostRequest *request, int32_t numUrbs, struct UsbAdapterUrb **pUrbs)
627{
628    for (int32_t i = 0; i < numUrbs; i++) {
629        int32_t ret = ioctl(request->devHandle->fd, USBDEVFS_SUBMITURB, *pUrbs[i]);
630        if (ret == 0) {
631            continue;
632        }
633
634        if (errno == ENODEV) {
635            ret = HDF_DEV_ERR_NO_DEVICE;
636        } else {
637            HDF_LOGE("%{public}s:%{public}d submit iso urb failed errno=%{public}d", __func__, __LINE__, errno);
638            ret = HDF_ERR_IO;
639        }
640
641        if (i == 0) {
642            HDF_LOGE("first URB failed");
643            OsFreeIsoUrbs(request);
644            return ret;
645        }
646        request->reqStatus = USB_REQUEST_ERROR;
647        request->numRetired += numUrbs - i;
648        if (request->numRetired == numUrbs) {
649            RawUsbMemFree(pUrbs);
650            request->urbs = NULL;
651        }
652        break;
653    }
654
655    return HDF_SUCCESS;
656}
657
658static int32_t OsSubmitIsoRequest(struct UsbHostRequest *request)
659{
660    if (request == NULL || request->devHandle == NULL || request->numIsoPackets < 1) {
661        HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
662        return HDF_ERR_INVALID_PARAM;
663    }
664
665    if (request->length > MAX_ISO_DATA_BUFFER_LEN) {
666        HDF_LOGE("%{public}s:%{public}d request length exceed the maximum", __func__, __LINE__);
667        return -1;
668    }
669
670    unsigned int totalLen = 0;
671    for (int32_t i = 0; i < request->numIsoPackets; i++) {
672        unsigned int packetLen = request->isoPacketDesc[i].length;
673        if (packetLen > MAX_ISO_DATA_BUFFER_LEN) {
674            HDF_LOGE("%{public}s:%{public}d packet length: %{public}u exceeds maximum: %{public}u",
675                __func__, __LINE__, packetLen, MAX_ISO_DATA_BUFFER_LEN);
676            return HDF_ERR_INVALID_PARAM;
677        }
678        totalLen += packetLen;
679    }
680    if (request->length < totalLen) {
681        HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
682        return HDF_ERR_INVALID_PARAM;
683    }
684    int32_t numUrbs = (request->numIsoPackets + (MAX_ISO_PACKETS_PER_URB - 1)) / MAX_ISO_PACKETS_PER_URB;
685    struct UsbAdapterUrb **pUrbs = RawUsbMemCalloc(numUrbs * sizeof(struct UsbAdapterUrb *));
686    if (pUrbs == NULL) {
687        HDF_LOGE("%{public}s:%{public}d RawUsbMemCalloc pUrbs failed", __func__, __LINE__);
688        return HDF_ERR_MALLOC_FAIL;
689    }
690    request->isoUrbs = (void **)pUrbs;
691    request->numUrbs = numUrbs;
692    request->numRetired = 0;
693    request->isoPacketOffset = 0;
694    int32_t ret = OsAllocIsoUrbs(request, numUrbs, pUrbs);
695    if (ret != HDF_SUCCESS) {
696        HDF_LOGE("%{public}s:%{public}d alloc iso urbs failed", __func__, __LINE__);
697        return ret;
698    }
699
700    return OsSubmitIsoUrbs(request, numUrbs, pUrbs);
701}
702
703static int32_t OsControlCompletion(struct UsbHostRequest *request, struct UsbAdapterUrb *urb)
704{
705    int32_t status;
706
707    request->actualLength += urb->actualLength;
708    if (request->reqStatus == USB_REQUEST_CANCELLED) {
709        RawUsbMemFree(request->urbs);
710        request->urbs = NULL;
711        return RawHandleRequestCompletion(request, USB_REQUEST_CANCELLED);
712    }
713
714    switch (urb->status) {
715        case 0:
716            status = USB_REQUEST_COMPLETED;
717            break;
718        case -ENOENT:
719            status = USB_REQUEST_CANCELLED;
720            break;
721        case -EPIPE:
722            status = USB_REQUEST_STALL;
723            break;
724        case -EOVERFLOW:
725            status = USB_REQUEST_OVERFLOW;
726            break;
727        case -ENODEV:
728        case -ESHUTDOWN:
729            status = USB_REQUEST_NO_DEVICE;
730            break;
731        default:
732            status = USB_REQUEST_ERROR;
733            break;
734    }
735    RawUsbMemFree(request->urbs);
736    request->urbs = NULL;
737    return RawHandleRequestCompletion(request, status);
738}
739
740static void OsIsoRequestDesStatus(struct UsbHostRequest *request, struct UsbAdapterUrb *urb)
741{
742    int32_t i;
743    struct UsbIsoPacketDesc *urbDesc = NULL;
744    struct UsbIsoPacketDesc *requestDesc = NULL;
745
746    for (i = 0; i < urb->numberOfPackets; i++) {
747        urbDesc = &urb->isoFrameDesc[i];
748        requestDesc = &request->isoPacketDesc[request->isoPacketOffset++];
749
750        switch (urbDesc->status) {
751            case HDF_SUCCESS:
752                requestDesc->status = USB_REQUEST_COMPLETED;
753                break;
754            case -ENODEV:
755            case -ESHUTDOWN:
756                requestDesc->status = USB_REQUEST_NO_DEVICE;
757                break;
758            case -EPIPE:
759                requestDesc->status = USB_REQUEST_STALL;
760                break;
761            case -EOVERFLOW:
762                requestDesc->status = USB_REQUEST_OVERFLOW;
763                break;
764            default:
765                requestDesc->status = USB_REQUEST_ERROR;
766                break;
767        }
768
769        requestDesc->actualLength = urbDesc->actualLength;
770    }
771}
772
773static int32_t OsIsoCompletion(struct UsbHostRequest *request, struct UsbAdapterUrb *urb)
774{
775    UsbRequestStatus status;
776    int32_t urbIndex = 0;
777    int32_t numUrbs;
778
779    if (request == NULL) {
780        HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
781        return HDF_ERR_INVALID_PARAM;
782    }
783
784    numUrbs = request->numUrbs;
785
786    for (int32_t i = 0; i < numUrbs; i++) {
787        if (urb == request->isoUrbs[i]) {
788            urbIndex = i + 1;
789            break;
790        }
791    }
792    if (urbIndex == 0) {
793        HDF_LOGE("%{public}s:%{public}d urbIndex is zero", __func__, __LINE__);
794        return HDF_ERR_BAD_FD;
795    }
796
797    OsIsoRequestDesStatus(request, urb);
798    request->numRetired++;
799    if (request->reqStatus != USB_REQUEST_COMPLETED) {
800        HDF_LOGE("%{public}s:%{public}d urb status=%{public}d", __func__, __LINE__, urb->status);
801        if (request->numRetired == numUrbs) {
802            OsFreeIsoUrbs(request);
803            return RawHandleRequestCompletion(request, USB_REQUEST_ERROR);
804        }
805        goto OUT;
806    }
807
808    if (urb->status == -ESHUTDOWN) {
809        status = USB_REQUEST_NO_DEVICE;
810    } else if (!((urb->status == HDF_SUCCESS) || (urb->status == -ENOENT) || (urb->status == -ECONNRESET))) {
811        status = USB_REQUEST_ERROR;
812    } else {
813        status = USB_REQUEST_COMPLETED;
814    }
815
816    if (request->numRetired == numUrbs) {
817        OsFreeIsoUrbs(request);
818        return RawHandleRequestCompletion(request, status);
819    }
820OUT:
821    return 0;
822}
823
824static int32_t OsProcessAbnormalReap(struct UsbHostRequest *request, const struct UsbAdapterUrb *urb)
825{
826    if (urb->actualLength > 0) {
827        unsigned char *target = request->buffer + request->actualLength;
828        if (urb->buffer != target) {
829            if (memmove_s(target, urb->actualLength, urb->buffer, urb->actualLength) != EOK) {
830                HDF_LOGE("%{public}s: memmove_s failed", __func__);
831                return HDF_FAILURE;
832            }
833        }
834        request->actualLength += urb->actualLength;
835    }
836    if (request->numRetired == request->numUrbs) {
837        return HDF_SUCCESS;
838    }
839
840    return HDF_ERR_IO;
841}
842
843static int32_t OsUrbStatusToRequestStatus(struct UsbHostRequest *request, const struct UsbAdapterUrb *urb)
844{
845    int32_t ret;
846
847    switch (urb->status) {
848        case 0:
849            ret = HDF_SUCCESS;
850            break;
851        case -ESHUTDOWN:
852            request->reqStatus = USB_REQUEST_NO_DEVICE;
853            ret = HDF_DEV_ERR_NO_DEVICE;
854            break;
855        case -EPIPE:
856            if (request->reqStatus == USB_REQUEST_COMPLETED) {
857                request->reqStatus = USB_REQUEST_STALL;
858            }
859            ret = HDF_DEV_ERR_NO_DEVICE;
860            break;
861        case -EOVERFLOW:
862            if (request->reqStatus == USB_REQUEST_COMPLETED) {
863                request->reqStatus = USB_REQUEST_OVERFLOW;
864            }
865            ret = HDF_FAILURE;
866            break;
867        default:
868            if (request->reqStatus == USB_REQUEST_COMPLETED) {
869                request->reqStatus = USB_REQUEST_ERROR;
870            }
871            ret = HDF_DEV_ERR_NO_DEVICE;
872            break;
873    }
874
875    return ret;
876}
877
878static int32_t OsBulkCompletion(struct UsbHostRequest * const request, const struct UsbAdapterUrb *urb)
879{
880    int32_t ret;
881    int32_t urbIdx = urb - (struct UsbAdapterUrb *)request->urbs;
882
883    request->numRetired++;
884    if (request->reqStatus != USB_REQUEST_COMPLETED) {
885        if (OsProcessAbnormalReap(request, urb) == HDF_SUCCESS) {
886            goto COMPLETED;
887        } else {
888            goto OUT;
889        }
890    }
891    request->actualLength += urb->actualLength;
892
893    ret = OsUrbStatusToRequestStatus(request, urb);
894    if (ret == HDF_DEV_ERR_NO_DEVICE) {
895        goto CANCEL;
896    } else if (ret == HDF_FAILURE) {
897        goto COMPLETED;
898    }
899
900    if (request->numRetired == request->numUrbs) {
901        goto COMPLETED;
902    } else if (urb->actualLength < urb->bufferLength) {
903        if (request->reqStatus == USB_REQUEST_COMPLETED) {
904            request->reqStatus = USB_REQUEST_COMPLETED_SHORT;
905        }
906    } else {
907        goto OUT;
908    }
909
910CANCEL:
911    if (request->numRetired == request->numUrbs) {
912        goto COMPLETED;
913    }
914    OsDiscardUrbs(request, urbIdx + 1, request->numUrbs);
915OUT:
916    return HDF_SUCCESS;
917COMPLETED:
918    return RawHandleRequestCompletion(request, request->reqStatus);
919}
920
921static int32_t AdapterInit(const struct UsbSession *session)
922{
923    (void)session;
924    return HDF_SUCCESS;
925}
926
927static void AdapterExit(const struct UsbSession *session)
928{
929    (void)session;
930    return;
931}
932
933static struct UsbDeviceHandle *AdapterOpenDevice(struct UsbSession *session, uint8_t busNum, uint8_t usbAddr)
934{
935    int32_t ret;
936    struct UsbDevice *dev = NULL;
937    struct UsbDeviceHandle *handle = NULL;
938
939    if (session == NULL) {
940        HDF_LOGE("%{public}s:%{public}d invalid param session.", __func__, __LINE__);
941        return NULL;
942    }
943
944    handle = OsGetDeviceHandle(session, busNum, usbAddr);
945    if (handle != NULL) {
946        return handle;
947    }
948
949    handle = OsCallocDeviceHandle();
950    if (handle == NULL) {
951        return NULL;
952    }
953
954    dev = OsAllocDevice(session, handle);
955    if (dev == NULL) {
956        goto ERR;
957    }
958
959    ret = OsInitDevice(dev, busNum, usbAddr);
960    if (ret) {
961        RawUsbMemFree(dev);
962        goto ERR;
963    }
964
965    OsalAtomicSet(&dev->refcnt, 1);
966    /* add the new device to the device list on session */
967    OsalMutexLock(&session->lock);
968    HdfSListAdd(&session->usbDevs, &dev->list);
969    OsalMutexUnlock(&session->lock);
970
971    return handle;
972
973ERR:
974    OsalMutexDestroy(&handle->lock);
975    RawUsbMemFree(handle);
976    return NULL;
977}
978
979static void AdapterCloseDevice(struct UsbDeviceHandle *handle)
980{
981    struct UsbDevice *dev = NULL;
982
983    if ((handle == NULL) || (handle->dev == NULL)) {
984        HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
985        return;
986    }
987
988    dev = handle->dev;
989    if (AdapterAtomicDec(&dev->refcnt) > 0) {
990        return;
991    }
992
993    OsalMutexLock(&dev->session->lock);
994    HdfSListRemove(&dev->session->usbDevs, &dev->list);
995    OsalMutexUnlock(&dev->session->lock);
996
997    if (dev->configDescriptors) {
998        RawUsbMemFree(dev->configDescriptors);
999    }
1000    if (dev->descriptors) {
1001        RawUsbMemFree(dev->descriptors);
1002    }
1003    RawUsbMemFree(dev);
1004
1005    close(handle->fd);
1006    close(handle->mmapFd);
1007    OsalMutexDestroy(&handle->lock);
1008    RawUsbMemFree(handle);
1009    handle = NULL;
1010}
1011
1012static int32_t AdapterGetConfigDescriptor(const struct UsbDevice *dev, uint8_t configIndex, void *buffer, size_t len)
1013{
1014    struct UsbDeviceConfigDescriptor *config = NULL;
1015    uint8_t i;
1016
1017    if (dev == NULL || buffer == NULL) {
1018        HDF_LOGE("%{public}s:%{public}d Invalid param", __func__, __LINE__);
1019        return HDF_ERR_INVALID_PARAM;
1020    }
1021
1022    for (i = 0; i < dev->deviceDescriptor.bNumConfigurations; i++) {
1023        if (configIndex == dev->configDescriptors[i].desc->bConfigurationValue) {
1024            config = &dev->configDescriptors[i];
1025            break;
1026        }
1027    }
1028
1029    if (config == NULL) {
1030        if (dev->deviceDescriptor.bNumConfigurations == 1) {
1031            HDF_LOGW("%{public}s: return default config", __func__);
1032            config = &dev->configDescriptors[0];
1033        } else {
1034            HDF_LOGE("%{public}s: config is null", __func__);
1035            return HDF_ERR_BAD_FD;
1036        }
1037    }
1038
1039    len = MIN(len, config->actualLen);
1040    if (memcpy_s(buffer, len, config->desc, len) != EOK) {
1041        HDF_LOGE("%{public}s: memcpy_s failed", __func__);
1042        return HDF_ERR_IO;
1043    }
1044
1045    return (int32_t)len;
1046}
1047
1048static int32_t AdapterGetConfiguration(const struct UsbDeviceHandle *handle, uint8_t *activeConfig)
1049{
1050    if (handle == NULL || activeConfig == NULL || handle->dev == NULL) {
1051        HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
1052        return HDF_ERR_INVALID_PARAM;
1053    }
1054
1055    int32_t ret = OsGetActiveConfig(handle->dev, handle->fd);
1056    if (ret != HDF_SUCCESS) {
1057        return ret;
1058    }
1059
1060    *activeConfig = handle->dev->activeConfig;
1061    if (*activeConfig == 0) {
1062        HDF_LOGD("%{public}s:%{public}d activeConfig is zero", __func__, __LINE__);
1063    }
1064
1065    return HDF_SUCCESS;
1066}
1067
1068static int32_t AdapterSetConfiguration(struct UsbDeviceHandle *handle, int32_t activeConfig)
1069{
1070    int32_t ret;
1071
1072    if (handle == NULL || handle->dev == NULL) {
1073        HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
1074        return HDF_ERR_INVALID_PARAM;
1075    }
1076
1077    ret = ioctl(handle->fd, USBDEVFS_SETCONFIGURATION, &activeConfig);
1078    if (ret < 0) {
1079        HDF_LOGE("%{public}s:%{public}d set config failed errno=%{public}d", __func__, __LINE__, errno);
1080        return HDF_FAILURE;
1081    }
1082    if (activeConfig == HDF_FAILURE) {
1083        activeConfig = 0;
1084    }
1085    handle->dev->activeConfig = (uint8_t)activeConfig;
1086
1087    return HDF_SUCCESS;
1088}
1089
1090static int32_t AdapterClaimInterface(const struct UsbDeviceHandle *handle, unsigned int interfaceNumber)
1091{
1092    int32_t ret;
1093
1094    if (handle == NULL) {
1095        HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
1096        return HDF_ERR_INVALID_PARAM;
1097    }
1098
1099    ret = ioctl(handle->fd, USBDEVFS_CLAIMINTERFACE, &interfaceNumber);
1100    if (ret < 0) {
1101        HDF_LOGE("%{public}s;%{public}d claim failed errno=%{public}d", __func__, __LINE__, errno);
1102        return HDF_FAILURE;
1103    }
1104
1105    return HDF_SUCCESS;
1106}
1107
1108static int32_t AdapterDetachKernelDriver(const struct UsbDeviceHandle *handle, uint8_t interfaceNumber)
1109{
1110    int32_t ret;
1111    if (handle == NULL) {
1112        HDF_LOGE("%{public}s: invalid param", __func__);
1113        return HDF_ERR_INVALID_PARAM;
1114    }
1115
1116    struct UsbAdapterIoctl command = {interfaceNumber, USBDEVFS_DISCONNECT, NULL};
1117    ret = ioctl(handle->fd, USBDEVFS_IOCTL, &command);
1118    if (ret < 0) {
1119        HDF_LOGE("%{public}s connect failed, ret = %{public}d, errno:%{public}d", __func__, ret, errno);
1120        return ret;
1121    }
1122    HDF_LOGI("%{public}s ret = %{public}d, errno = %{public}d ", __func__, ret, errno);
1123    return ret;
1124}
1125
1126static int32_t AdapterAttachKernelDriver(const struct UsbDeviceHandle *handle, uint8_t interfaceNumber)
1127{
1128    int32_t ret;
1129    if (handle == NULL) {
1130        HDF_LOGE("%{public}s invalid parameter", __func__);
1131        return HDF_ERR_INVALID_PARAM;
1132    }
1133
1134    struct UsbAdapterIoctl cmd = {interfaceNumber, USBDEVFS_CONNECT, NULL};
1135    ret = ioctl(handle->fd, USBDEVFS_IOCTL, &cmd);
1136    if (ret < 0) {
1137        HDF_LOGE("%{public}s connect failed, ret = %{public}d, errno:%{public}d", __func__, ret, errno);
1138        return ret;
1139    }
1140    HDF_LOGI("%{public}s ret = %{public}d, errno = %{public}d ", __func__, ret, errno);
1141    return ret;
1142}
1143
1144static int32_t AdapterDetachKernelDriverAndClaim(const struct UsbDeviceHandle *handle, uint32_t interfaceNumber)
1145{
1146    int32_t ret;
1147    if (handle == NULL) {
1148        HDF_LOGE("%{public}s: invalid param", __func__);
1149        return HDF_ERR_INVALID_PARAM;
1150    }
1151    struct UsbAdapterDisconnectClaim dc;
1152    struct UsbAdapterGetdriver getDriver = {interfaceNumber, {0}};
1153    ret = ioctl(handle->fd, USBDEVFS_GETDRIVER, &getDriver);
1154    if (ret != 0 && errno == ENODATA) {
1155        HDF_LOGI("%{public}s: no usb driver", __func__);
1156        return AdapterClaimInterface(handle, interfaceNumber);
1157    }
1158    if (ret == 0 && strcmp(getDriver.driver, "usbfs") == 0) {
1159        HDF_LOGI("%{public}s: usbfs already claimed", __func__);
1160        return HDF_SUCCESS;
1161    }
1162
1163    dc.interface = interfaceNumber;
1164    ret = strcpy_s(dc.driver, MAX_DRIVER_NAME_LENGTH, "usbfs");
1165    if (ret != EOK) {
1166        HDF_LOGE("%{public}s: strcpy_s failed", __func__);
1167        return ret;
1168    }
1169    dc.flags = DISCONNECT_CLAIM_EXCEPT_DRIVER;
1170    ret = ioctl(handle->fd, USBDEVFS_DISCONNECT_CLAIM, &dc);
1171    if (ret == 0) {
1172        return HDF_SUCCESS;
1173    }
1174    if (errno != ENOTTY) {
1175        HDF_LOGE("%{public}s: disconnect-and-claim failed errno %{public}d", __func__, errno);
1176        return ret;
1177    }
1178
1179    struct UsbAdapterIoctl command = {interfaceNumber, USBDEVFS_DISCONNECT, NULL};
1180    ret = ioctl(handle->fd, USBDEVFS_IOCTL, &command);
1181    if (ret != 0) {
1182        HDF_LOGE("%{public}s; disconnet failed errno = %{public}d", __func__, errno);
1183        return ret;
1184    }
1185    return AdapterClaimInterface(handle, interfaceNumber);
1186}
1187
1188static int32_t AdapterReleaseInterface(const struct UsbDeviceHandle *handle, unsigned int interfaceNumber)
1189{
1190    int32_t ret;
1191
1192    if (handle == NULL) {
1193        HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
1194        return HDF_ERR_INVALID_PARAM;
1195    }
1196
1197    ret = ioctl(handle->fd, USBDEVFS_RELEASEINTERFACE, &interfaceNumber);
1198    if (ret < 0) {
1199        HDF_LOGE("%{public}s:%{public}d release failed errno=%{public}d", __func__, __LINE__, errno);
1200        if (errno == ENODEV) {
1201            return HDF_DEV_ERR_NO_DEVICE;
1202        }
1203        return HDF_FAILURE;
1204    }
1205
1206    return HDF_SUCCESS;
1207}
1208
1209static int32_t AdapterSetInterface(const struct UsbDeviceHandle *handle, uint8_t interface, uint8_t altSetting)
1210{
1211    struct UsbAdapterSetInterface setIntf;
1212    int32_t ret;
1213
1214    if (handle == NULL) {
1215        HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
1216        return HDF_ERR_INVALID_PARAM;
1217    }
1218
1219    setIntf.interface = interface;
1220    setIntf.altSetting = altSetting;
1221    ret = ioctl(handle->fd, USBDEVFS_SETINTERFACE, &setIntf);
1222    if (ret < 0) {
1223        HDF_LOGE("%{public}s:%{public}d set interface failed errno=%{public}d", __func__, __LINE__, errno);
1224        return HDF_FAILURE;
1225    }
1226
1227    return HDF_SUCCESS;
1228}
1229
1230static int32_t AdapterClearHalt(const struct UsbDeviceHandle *handle, unsigned int endPoint)
1231{
1232    int32_t ret;
1233
1234    if (handle == NULL) {
1235        HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
1236        return HDF_ERR_INVALID_PARAM;
1237    }
1238
1239    ret = ioctl(handle->fd, USBDEVFS_CLEAR_HALT, &endPoint);
1240    if (ret < 0) {
1241        HDF_LOGE("%{public}s:%{public}d clear halt failed errno=%{public}d", __func__, __LINE__, errno);
1242        return HDF_FAILURE;
1243    }
1244
1245    return HDF_SUCCESS;
1246}
1247
1248static int32_t AdapterResetDevice(struct UsbDeviceHandle *handle)
1249{
1250    int32_t ret;
1251    uint8_t i;
1252
1253    if (handle == NULL) {
1254        HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
1255        return HDF_ERR_INVALID_PARAM;
1256    }
1257
1258    for (i = 0; i < USB_MAXINTERFACES; i++) {
1259        if (handle->claimedInterfaces & (1UL << i)) {
1260            AdapterReleaseInterface(handle, i);
1261        }
1262    }
1263
1264    ret = ioctl(handle->fd, USBDEVFS_RESET, NULL);
1265    if (ret < 0) {
1266        HDF_LOGE("%{public}s:%{public}d errno=%{public}d", __func__, __LINE__, errno);
1267        return HDF_FAILURE;
1268    }
1269
1270    for (i = 0;i < USB_MAXINTERFACES; i++) {
1271        if (!(handle->claimedInterfaces & (1UL << i))) {
1272            continue;
1273        }
1274        ret = AdapterDetachKernelDriverAndClaim(handle, i);
1275        if (ret) {
1276            HDF_LOGE("%{public}s:%{public}d failed to re-claim interface %{public}u after reset errno=%{public}d",
1277                __func__, __LINE__, i, errno);
1278            handle->claimedInterfaces &= ~(1UL << i);
1279            break;
1280        }
1281    }
1282
1283    return ret;
1284}
1285
1286static struct UsbHostRequest *AdapterAllocRequest(const struct UsbDeviceHandle *handle, int32_t isoPackets, size_t len)
1287{
1288    void *memBuf = NULL;
1289    struct UsbHostRequest *request = NULL;
1290    if (handle == NULL) {
1291        HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
1292        return NULL;
1293    }
1294    size_t allocSize = sizeof(struct UsbHostRequest) + (sizeof(struct UsbIsoPacketDesc) * (size_t)isoPackets) +
1295        (sizeof(unsigned char) * len);
1296
1297#ifdef USB_EVENT_NOTIFY_LINUX_NATIVE_MODE
1298    memBuf = RawUsbMemCalloc(allocSize);
1299    if (memBuf == NULL) {
1300        HDF_LOGE("%{public}s: alloc UsbHostRequest failed", __func__);
1301        return NULL;
1302    }
1303#else
1304    memBuf = mmap(NULL, allocSize, PROT_READ | PROT_WRITE, MAP_SHARED, handle->fd, 0);
1305    if (memBuf == MAP_FAILED) {
1306        HDF_LOGE("%{public}s:%{public}d mmap failed, errno=%{public}d", __func__, __LINE__, errno);
1307        return NULL;
1308    }
1309#endif
1310    request = (struct UsbHostRequest *)memBuf;
1311    request->numIsoPackets = isoPackets;
1312    request->buffer = (unsigned char *)memBuf + allocSize - len;
1313    request->bufLen = (int32_t)len;
1314    request->bulkUrb = RawUsbMemCalloc(sizeof(struct UsbAdapterUrb));
1315    if (request->bulkUrb == NULL) {
1316        HDF_LOGE("%{public}s RawUsbMemAlloc fail", __func__);
1317#ifdef USB_EVENT_NOTIFY_LINUX_NATIVE_MODE
1318        RawUsbMemFree(memBuf);
1319#endif
1320        return NULL;
1321    }
1322    request->urbs = request->bulkUrb;
1323    return request;
1324}
1325
1326static struct UsbHostRequest *AdapterAllocRequestByMmap(
1327    const struct UsbDeviceHandle *handle, int32_t isoPackets, size_t len)
1328{
1329    void *memBuf = NULL;
1330    struct UsbHostRequest *request = NULL;
1331    if (handle == NULL) {
1332        HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
1333        return NULL;
1334    }
1335    size_t allocSize = sizeof(struct UsbHostRequest) + (sizeof(struct UsbIsoPacketDesc) * (size_t)isoPackets);
1336
1337    request = RawUsbMemCalloc(allocSize);
1338    if (request == NULL) {
1339        HDF_LOGE("%{public}s: alloc UsbHostRequest failed", __func__);
1340        return NULL;
1341    }
1342
1343    int32_t fd = handle->isAshmem ? handle->ashmemFd : handle->mmapFd;
1344
1345    ftruncate(fd, len);
1346    memBuf = mmap(
1347        NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
1348    if (memBuf == MAP_FAILED) {
1349        HDF_LOGE("%{public}s fd:%{public}d mmap failed, errno=%{public}d, len=%{public}zu",
1350            __func__, fd, errno, len);
1351        RawUsbMemFree(request);
1352        return NULL;
1353    }
1354
1355    request->numIsoPackets = isoPackets;
1356    request->buffer = memBuf;
1357    request->bufLen = (int32_t)len;
1358    request->bulkUrb = RawUsbMemCalloc(sizeof(struct UsbAdapterUrb));
1359    if (request->bulkUrb == NULL) {
1360        HDF_LOGE("%{public}s RawUsbMemAlloc fail", __func__);
1361        return NULL;
1362    }
1363    request->urbs = request->bulkUrb;
1364    return request;
1365}
1366
1367static int32_t AdapterFreeRequestByMmap(struct UsbHostRequest *request)
1368{
1369    if (request == NULL) {
1370        HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
1371        return HDF_ERR_INVALID_PARAM;
1372    }
1373    if (request->bulkUrb) {
1374        RawUsbMemFree(request->bulkUrb);
1375        request->bulkUrb = NULL;
1376    }
1377    request->urbs = NULL;
1378
1379    if (munmap((void *)request->buffer, request->bufLen) != 0) {
1380        HDF_LOGE("%{public}s:%{public}d munmap failed, errno=%{public}d", __func__, __LINE__, errno);
1381        return HDF_ERR_IO;
1382    }
1383    RawUsbMemFree(request);
1384    request = NULL;
1385    return HDF_SUCCESS;
1386}
1387
1388static int32_t AdapterFreeRequest(struct UsbHostRequest *request)
1389{
1390    if (request == NULL) {
1391        HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
1392        return HDF_ERR_INVALID_PARAM;
1393    }
1394    if (request->bulkUrb) {
1395        RawUsbMemFree(request->bulkUrb);
1396        request->bulkUrb = NULL;
1397    }
1398    request->urbs = NULL;
1399#ifdef USB_EVENT_NOTIFY_LINUX_NATIVE_MODE
1400    RawUsbMemFree(request);
1401    request = NULL;
1402#else
1403    size_t allocSize = sizeof(struct UsbHostRequest) +
1404        (sizeof(struct UsbIsoPacketDesc) * (size_t)(request->numIsoPackets)) + (size_t)request->bufLen;
1405    if (munmap((void *)request, allocSize) != 0) {
1406        HDF_LOGE("%{public}s:%{public}d munmap failed, errno=%{public}d", __func__, __LINE__, errno);
1407        return HDF_ERR_IO;
1408    }
1409#endif
1410    return HDF_SUCCESS;
1411}
1412
1413static int32_t AdapterSubmitRequest(struct UsbHostRequest *request)
1414{
1415    int32_t ret;
1416
1417    if (request == NULL) {
1418        HDF_LOGE("%{public}s:%{public}d request is NULL", __func__, __LINE__);
1419        return HDF_FAILURE;
1420    }
1421
1422    request->actualLength = 0;
1423    switch (request->requestType) {
1424        case USB_REQUEST_TYPE_CONTROL:
1425            ret = OsSubmitControlRequest(request);
1426            break;
1427        case USB_REQUEST_TYPE_ISOCHRONOUS:
1428            ret = OsSubmitIsoRequest(request);
1429            break;
1430        case USB_REQUEST_TYPE_BULK:
1431        case USB_REQUEST_TYPE_INTERRUPT:
1432            ret = OsSubmitBulkRequest(request);
1433            break;
1434        default:
1435            HDF_LOGE("%{public}s:%{public}d unknown requestType=%{public}u", __func__, __LINE__, request->requestType);
1436            ret = HDF_ERR_INVALID_PARAM;
1437            break;
1438    }
1439
1440    return ret;
1441}
1442
1443static int32_t AdapterCancelRequest(struct UsbHostRequest * const request)
1444{
1445    if (!request->urbs) {
1446        HDF_LOGE("%{public}s:%{public}d", __func__, __LINE__);
1447        return HDF_ERR_BAD_FD;
1448    }
1449
1450    OsDiscardUrbs(request, 0, request->numUrbs);
1451
1452    if (!((request->requestType == USB_REQUEST_TYPE_BULK) && (request->reqStatus == USB_REQUEST_ERROR))) {
1453        request->reqStatus = USB_REQUEST_CANCELLED;
1454    }
1455
1456    return HDF_SUCCESS;
1457}
1458
1459static int32_t AdapterUrbCompleteHandle(const struct UsbDeviceHandle *devHandle)
1460{
1461    struct UsbAdapterUrb *urb = NULL;
1462    struct UsbHostRequest *request = NULL;
1463    int32_t ret;
1464
1465    if (devHandle == NULL) {
1466        HDF_LOGE("%{public}s:%{public}d invalid parameter", __func__, __LINE__);
1467        return HDF_ERR_INVALID_PARAM;
1468    }
1469
1470    ret = ioctl(devHandle->fd, USBDEVFS_REAPURB, &urb);
1471    if (ret < 0) {
1472        if (errno == EAGAIN) {
1473            return 1;
1474        }
1475        if (errno == ENODEV) {
1476            return HDF_DEV_ERR_NO_DEVICE;
1477        }
1478
1479        return HDF_ERR_IO;
1480    }
1481
1482    request = urb->userContext;
1483
1484    switch (request->requestType) {
1485        case USB_REQUEST_TYPE_CONTROL:
1486            ret = OsControlCompletion(request, urb);
1487            break;
1488        case USB_REQUEST_TYPE_ISOCHRONOUS:
1489            ret = OsIsoCompletion(request, urb);
1490            break;
1491        case USB_REQUEST_TYPE_BULK:
1492        case USB_REQUEST_TYPE_INTERRUPT:
1493            ret = OsBulkCompletion(request, (const struct UsbAdapterUrb *)urb);
1494            break;
1495        default:
1496            HDF_LOGE("%{public}s:%{public}d unrecognised requestType %{public}u",
1497                __func__, __LINE__, request->requestType);
1498            ret = HDF_FAILURE;
1499            break;
1500    }
1501
1502    return ret;
1503}
1504
1505static bool AdapterGetInterfaceActiveStatus(const struct UsbDeviceHandle *devHandle, uint8_t interfaceNumber)
1506{
1507    int32_t ret;
1508    if (devHandle == NULL) {
1509        return false;
1510    }
1511    struct UsbAdapterGetdriver getDriver = {interfaceNumber, {0}};
1512    ret = ioctl(devHandle->fd, USBDEVFS_GETDRIVER, &getDriver);
1513    if (ret < 0 || strcmp(getDriver.driver, "usbfs") == 0) {
1514        return false;
1515    }
1516    return true;
1517}
1518
1519static struct UsbOsAdapterOps g_usbAdapter = {
1520    .init = AdapterInit,
1521    .exit = AdapterExit,
1522    .openDevice = AdapterOpenDevice,
1523    .closeDevice = AdapterCloseDevice,
1524    .getConfigDescriptor = AdapterGetConfigDescriptor,
1525    .getConfiguration = AdapterGetConfiguration,
1526    .setConfiguration = AdapterSetConfiguration,
1527    .claimInterface = AdapterClaimInterface,
1528    .releaseInterface = AdapterReleaseInterface,
1529    .setInterfaceAltsetting = AdapterSetInterface,
1530    .clearHalt = AdapterClearHalt,
1531    .resetDevice = AdapterResetDevice,
1532    .allocRequest = AdapterAllocRequest,
1533    .allocRequestByMmap = AdapterAllocRequestByMmap,
1534    .freeRequest = AdapterFreeRequest,
1535    .freeRequestByMmap = AdapterFreeRequestByMmap,
1536    .submitRequest = AdapterSubmitRequest,
1537    .cancelRequest = AdapterCancelRequest,
1538    .urbCompleteHandle = AdapterUrbCompleteHandle,
1539    .detachKernelDriverAndClaim = AdapterDetachKernelDriverAndClaim,
1540    .attachKernelDriver = AdapterAttachKernelDriver,
1541    .detachKernelDriver = AdapterDetachKernelDriver,
1542    .usbControlMsg = AdapterUsbControlMsg,
1543    .getUsbSpeed = AdapterGetUsbSpeed,
1544    .getInterfaceActiveStatus = AdapterGetInterfaceActiveStatus,
1545};
1546
1547static void OsSignalHandler(int32_t signo)
1548{
1549    (void)signo;
1550    return;
1551}
1552
1553struct UsbOsAdapterOps *UsbAdapterGetOps(void)
1554{
1555    return &g_usbAdapter;
1556}
1557
1558UsbRawTidType UsbAdapterGetTid(void)
1559{
1560    return gettid();
1561}
1562
1563int32_t UsbAdapterRegisterSignal(void)
1564{
1565    if (signal(SIGUSR1, OsSignalHandler) == SIG_ERR) {
1566        HDF_LOGE("%{public}s:%{public}d Can't set AdapterSignalHandler for SIGUSR1", __func__, __LINE__);
1567        return HDF_ERR_IO;
1568    }
1569
1570    return HDF_SUCCESS;
1571}
1572
1573int32_t UsbAdapterKillSignal(struct UsbDeviceHandle *devHandle, UsbRawTidType tid)
1574{
1575    (void)devHandle;
1576    return HDF_SUCCESS;
1577}
1578
1579int32_t AdapterAtomicInc(OsalAtomic *v)
1580{
1581    return OsalAtomicInc(v);
1582}
1583
1584int32_t AdapterAtomicDec(OsalAtomic *v)
1585{
1586    return OsalAtomicDec(v);
1587}
1588