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 
OsAdapterRealloc(void * ptr,size_t oldSize,size_t newSize)34 static 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 
OsDeviceCompare(struct HdfSListNode * listEntry,uint32_t searchKey)56 static 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 
OsGetDeviceHandle(struct UsbSession * session,uint8_t busNum,uint8_t usbAddr)71 static 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 
OsCallocDeviceHandle(void)92 static 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 
OsAllocDevice(struct UsbSession * session,struct UsbDeviceHandle * handle)107 static 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 
GetMmapFd(struct UsbDevice * dev)125 static 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 
GetUsbDevicePath(struct UsbDevice * dev,char * pathBuf,size_t length)143 static 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 
OsGetUsbFd(struct UsbDevice * dev,mode_t mode)169 static 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 
OsReadDescriptors(struct UsbDevice * dev)214 static 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 
OsParseConfigDescriptors(struct UsbDevice * dev)244 static 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 
OsInitDevice(struct UsbDevice * dev,uint8_t busNum,uint8_t devAddr)299 static 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 
OsGetActiveConfig(struct UsbDevice * dev,int32_t fd)340 static 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 
AdapterUsbControlMsg(const struct UsbDeviceHandle * handle,struct UsbControlRequestData * ctrlData)368 static 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 
AdapterGetUsbSpeed(const struct UsbDeviceHandle * handle)378 static 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 
OsFreeIsoUrbs(struct UsbHostRequest * request)389 static 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 
OsDiscardUrbs(const struct UsbHostRequest * request,int32_t first,int32_t last)405 static 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 
OsSubmitControlRequest(struct UsbHostRequest * request)426 static 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 
OsSubmitBulkRequestHandleUrb(struct UsbHostRequest * request,struct UsbAdapterUrb * urb,int32_t bulkBufferLen,int32_t number)465 static 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 : len;
491     } else {
492         urb->bufferLength = bulkBufferLen;
493     }
494 
495     return HDF_SUCCESS;
496 }
497 
OsSubmitBulkRequestHandle(struct UsbHostRequest * request,struct UsbAdapterUrb * urbs,int32_t bulkBufferLen)498 static 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 
OsSubmitBulkRequest(struct UsbHostRequest * request)532 static 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 ? 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 = 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 
OsAllocIsoUrbs(struct UsbHostRequest * request,int32_t numUrbs,struct UsbAdapterUrb ** urbs)591 static 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 
OsSubmitIsoUrbs(struct UsbHostRequest * request,int32_t numUrbs,struct UsbAdapterUrb ** pUrbs)626 static 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 
OsSubmitIsoRequest(struct UsbHostRequest * request)658 static 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 
OsControlCompletion(struct UsbHostRequest * request,struct UsbAdapterUrb * urb)703 static 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 
OsIsoRequestDesStatus(struct UsbHostRequest * request,struct UsbAdapterUrb * urb)740 static 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 
OsIsoCompletion(struct UsbHostRequest * request,struct UsbAdapterUrb * urb)773 static 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     }
820 OUT:
821     return 0;
822 }
823 
OsProcessAbnormalReap(struct UsbHostRequest * request,const struct UsbAdapterUrb * urb)824 static 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 
OsUrbStatusToRequestStatus(struct UsbHostRequest * request,const struct UsbAdapterUrb * urb)843 static 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 
OsBulkCompletion(struct UsbHostRequest * const request,const struct UsbAdapterUrb * urb)878 static 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 
910 CANCEL:
911     if (request->numRetired == request->numUrbs) {
912         goto COMPLETED;
913     }
914     OsDiscardUrbs(request, urbIdx + 1, request->numUrbs);
915 OUT:
916     return HDF_SUCCESS;
917 COMPLETED:
918     return RawHandleRequestCompletion(request, request->reqStatus);
919 }
920 
AdapterInit(const struct UsbSession * session)921 static int32_t AdapterInit(const struct UsbSession *session)
922 {
923     (void)session;
924     return HDF_SUCCESS;
925 }
926 
AdapterExit(const struct UsbSession * session)927 static void AdapterExit(const struct UsbSession *session)
928 {
929     (void)session;
930     return;
931 }
932 
AdapterOpenDevice(struct UsbSession * session,uint8_t busNum,uint8_t usbAddr)933 static 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 
973 ERR:
974     OsalMutexDestroy(&handle->lock);
975     RawUsbMemFree(handle);
976     return NULL;
977 }
978 
AdapterCloseDevice(struct UsbDeviceHandle * handle)979 static 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 
AdapterGetConfigDescriptor(const struct UsbDevice * dev,uint8_t configIndex,void * buffer,size_t len)1012 static 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 
AdapterGetConfiguration(const struct UsbDeviceHandle * handle,uint8_t * activeConfig)1048 static 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 
AdapterSetConfiguration(struct UsbDeviceHandle * handle,int32_t activeConfig)1068 static 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 
AdapterClaimInterface(const struct UsbDeviceHandle * handle,unsigned int interfaceNumber)1090 static 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 
AdapterDetachKernelDriver(const struct UsbDeviceHandle * handle,uint8_t interfaceNumber)1108 static 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 
AdapterAttachKernelDriver(const struct UsbDeviceHandle * handle,uint8_t interfaceNumber)1126 static 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 
AdapterDetachKernelDriverAndClaim(const struct UsbDeviceHandle * handle,uint32_t interfaceNumber)1144 static 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 
AdapterReleaseInterface(const struct UsbDeviceHandle * handle,unsigned int interfaceNumber)1188 static 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 
AdapterSetInterface(const struct UsbDeviceHandle * handle,uint8_t interface,uint8_t altSetting)1209 static 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 
AdapterClearHalt(const struct UsbDeviceHandle * handle,unsigned int endPoint)1230 static 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 
AdapterResetDevice(const struct UsbDeviceHandle * handle)1248 static int32_t AdapterResetDevice(const 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     return HDF_SUCCESS;
1271 }
1272 
AdapterAllocRequest(const struct UsbDeviceHandle * handle,int32_t isoPackets,size_t len)1273 static struct UsbHostRequest *AdapterAllocRequest(const struct UsbDeviceHandle *handle, int32_t isoPackets, size_t len)
1274 {
1275     void *memBuf = NULL;
1276     struct UsbHostRequest *request = NULL;
1277     if (handle == NULL) {
1278         HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
1279         return NULL;
1280     }
1281     size_t allocSize = sizeof(struct UsbHostRequest) + (sizeof(struct UsbIsoPacketDesc) * (size_t)isoPackets) +
1282         (sizeof(unsigned char) * len);
1283 
1284 #ifdef USB_EVENT_NOTIFY_LINUX_NATIVE_MODE
1285     memBuf = RawUsbMemCalloc(allocSize);
1286     if (memBuf == NULL) {
1287         HDF_LOGE("%{public}s: alloc UsbHostRequest failed", __func__);
1288         return NULL;
1289     }
1290 #else
1291     memBuf = mmap(NULL, allocSize, PROT_READ | PROT_WRITE, MAP_SHARED, handle->fd, 0);
1292     if (memBuf == MAP_FAILED) {
1293         HDF_LOGE("%{public}s:%{public}d mmap failed, errno=%{public}d", __func__, __LINE__, errno);
1294         return NULL;
1295     }
1296 #endif
1297     request = (struct UsbHostRequest *)memBuf;
1298     request->numIsoPackets = isoPackets;
1299     request->buffer = (unsigned char *)memBuf + allocSize - len;
1300     request->bufLen = (int32_t)len;
1301     request->bulkUrb = RawUsbMemCalloc(sizeof(struct UsbAdapterUrb));
1302     if (request->bulkUrb == NULL) {
1303         HDF_LOGE("%{public}s RawUsbMemAlloc fail", __func__);
1304 #ifdef USB_EVENT_NOTIFY_LINUX_NATIVE_MODE
1305         RawUsbMemFree(memBuf);
1306 #endif
1307         return NULL;
1308     }
1309     request->urbs = request->bulkUrb;
1310     return request;
1311 }
1312 
AdapterAllocRequestByMmap(const struct UsbDeviceHandle * handle,int32_t isoPackets,size_t len)1313 static struct UsbHostRequest *AdapterAllocRequestByMmap(
1314     const struct UsbDeviceHandle *handle, int32_t isoPackets, size_t len)
1315 {
1316     void *memBuf = NULL;
1317     struct UsbHostRequest *request = NULL;
1318     if (handle == NULL) {
1319         HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
1320         return NULL;
1321     }
1322     size_t allocSize = sizeof(struct UsbHostRequest) + (sizeof(struct UsbIsoPacketDesc) * (size_t)isoPackets);
1323 
1324     request = RawUsbMemCalloc(allocSize);
1325     if (request == NULL) {
1326         HDF_LOGE("%{public}s: alloc UsbHostRequest failed", __func__);
1327         return NULL;
1328     }
1329 
1330     int32_t fd = handle->isAshmem ? handle->ashmemFd : handle->mmapFd;
1331 
1332     ftruncate(fd, len);
1333     memBuf = mmap(
1334         NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
1335     if (memBuf == MAP_FAILED) {
1336         HDF_LOGE("%{public}s fd:%{public}d mmap failed, errno=%{public}d, len=%{public}zu",
1337             __func__, fd, errno, len);
1338         RawUsbMemFree(request);
1339         return NULL;
1340     }
1341 
1342     request->numIsoPackets = isoPackets;
1343     request->buffer = memBuf;
1344     request->bufLen = (int32_t)len;
1345     request->bulkUrb = RawUsbMemCalloc(sizeof(struct UsbAdapterUrb));
1346     if (request->bulkUrb == NULL) {
1347         HDF_LOGE("%{public}s RawUsbMemAlloc fail", __func__);
1348         return NULL;
1349     }
1350     request->urbs = request->bulkUrb;
1351     return request;
1352 }
1353 
AdapterFreeRequestByMmap(struct UsbHostRequest * request)1354 static int32_t AdapterFreeRequestByMmap(struct UsbHostRequest *request)
1355 {
1356     if (request == NULL) {
1357         HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
1358         return HDF_ERR_INVALID_PARAM;
1359     }
1360     if (request->bulkUrb) {
1361         RawUsbMemFree(request->bulkUrb);
1362         request->bulkUrb = NULL;
1363     }
1364     request->urbs = NULL;
1365 
1366     if (munmap((void *)request->buffer, request->bufLen) != 0) {
1367         HDF_LOGE("%{public}s:%{public}d munmap failed, errno=%{public}d", __func__, __LINE__, errno);
1368         return HDF_ERR_IO;
1369     }
1370     RawUsbMemFree(request);
1371     request = NULL;
1372     return HDF_SUCCESS;
1373 }
1374 
AdapterFreeRequest(struct UsbHostRequest * request)1375 static int32_t AdapterFreeRequest(struct UsbHostRequest *request)
1376 {
1377     if (request == NULL) {
1378         HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
1379         return HDF_ERR_INVALID_PARAM;
1380     }
1381     if (request->bulkUrb) {
1382         RawUsbMemFree(request->bulkUrb);
1383         request->bulkUrb = NULL;
1384     }
1385     request->urbs = NULL;
1386 #ifdef USB_EVENT_NOTIFY_LINUX_NATIVE_MODE
1387     RawUsbMemFree(request);
1388     request = NULL;
1389 #else
1390     size_t allocSize = sizeof(struct UsbHostRequest) +
1391         (sizeof(struct UsbIsoPacketDesc) * (size_t)(request->numIsoPackets)) + (size_t)request->bufLen;
1392     if (munmap((void *)request, allocSize) != 0) {
1393         HDF_LOGE("%{public}s:%{public}d munmap failed, errno=%{public}d", __func__, __LINE__, errno);
1394         return HDF_ERR_IO;
1395     }
1396 #endif
1397     return HDF_SUCCESS;
1398 }
1399 
AdapterSubmitRequest(struct UsbHostRequest * request)1400 static int32_t AdapterSubmitRequest(struct UsbHostRequest *request)
1401 {
1402     int32_t ret;
1403 
1404     if (request == NULL) {
1405         HDF_LOGE("%{public}s:%{public}d request is NULL", __func__, __LINE__);
1406         return HDF_FAILURE;
1407     }
1408 
1409     request->actualLength = 0;
1410     switch (request->requestType) {
1411         case USB_REQUEST_TYPE_CONTROL:
1412             ret = OsSubmitControlRequest(request);
1413             break;
1414         case USB_REQUEST_TYPE_ISOCHRONOUS:
1415             ret = OsSubmitIsoRequest(request);
1416             break;
1417         case USB_REQUEST_TYPE_BULK:
1418         case USB_REQUEST_TYPE_INTERRUPT:
1419             ret = OsSubmitBulkRequest(request);
1420             break;
1421         default:
1422             HDF_LOGE("%{public}s:%{public}d unknown requestType=%{public}u", __func__, __LINE__, request->requestType);
1423             ret = HDF_ERR_INVALID_PARAM;
1424             break;
1425     }
1426 
1427     return ret;
1428 }
1429 
AdapterCancelRequest(struct UsbHostRequest * const request)1430 static int32_t AdapterCancelRequest(struct UsbHostRequest * const request)
1431 {
1432     if (!request->urbs) {
1433         HDF_LOGE("%{public}s:%{public}d", __func__, __LINE__);
1434         return HDF_ERR_BAD_FD;
1435     }
1436 
1437     OsDiscardUrbs(request, 0, request->numUrbs);
1438 
1439     if (!((request->requestType == USB_REQUEST_TYPE_BULK) && (request->reqStatus == USB_REQUEST_ERROR))) {
1440         request->reqStatus = USB_REQUEST_CANCELLED;
1441     }
1442 
1443     return HDF_SUCCESS;
1444 }
1445 
AdapterUrbCompleteHandle(const struct UsbDeviceHandle * devHandle)1446 static int32_t AdapterUrbCompleteHandle(const struct UsbDeviceHandle *devHandle)
1447 {
1448     struct UsbAdapterUrb *urb = NULL;
1449     struct UsbHostRequest *request = NULL;
1450     int32_t ret;
1451 
1452     if (devHandle == NULL) {
1453         HDF_LOGE("%{public}s:%{public}d invalid parameter", __func__, __LINE__);
1454         return HDF_ERR_INVALID_PARAM;
1455     }
1456 
1457     ret = ioctl(devHandle->fd, USBDEVFS_REAPURB, &urb);
1458     if (ret < 0) {
1459         if (errno == EAGAIN) {
1460             return 1;
1461         }
1462         if (errno == ENODEV) {
1463             return HDF_DEV_ERR_NO_DEVICE;
1464         }
1465 
1466         return HDF_ERR_IO;
1467     }
1468 
1469     request = urb->userContext;
1470 
1471     switch (request->requestType) {
1472         case USB_REQUEST_TYPE_CONTROL:
1473             ret = OsControlCompletion(request, urb);
1474             break;
1475         case USB_REQUEST_TYPE_ISOCHRONOUS:
1476             ret = OsIsoCompletion(request, urb);
1477             break;
1478         case USB_REQUEST_TYPE_BULK:
1479         case USB_REQUEST_TYPE_INTERRUPT:
1480             ret = OsBulkCompletion(request, (const struct UsbAdapterUrb *)urb);
1481             break;
1482         default:
1483             HDF_LOGE("%{public}s:%{public}d unrecognised requestType %{public}u",
1484                 __func__, __LINE__, request->requestType);
1485             ret = HDF_FAILURE;
1486             break;
1487     }
1488 
1489     return ret;
1490 }
1491 
AdapterGetInterfaceActiveStatus(const struct UsbDeviceHandle * devHandle,uint8_t interfaceNumber)1492 static bool AdapterGetInterfaceActiveStatus(const struct UsbDeviceHandle *devHandle, uint8_t interfaceNumber)
1493 {
1494     int32_t ret;
1495     if (devHandle == NULL) {
1496         return false;
1497     }
1498     struct UsbAdapterGetdriver getDriver = {interfaceNumber, {0}};
1499     ret = ioctl(devHandle->fd, USBDEVFS_GETDRIVER, &getDriver);
1500     if (ret < 0 || strcmp(getDriver.driver, "usbfs") == 0) {
1501         return false;
1502     }
1503     return true;
1504 }
1505 
1506 static struct UsbOsAdapterOps g_usbAdapter = {
1507     .init = AdapterInit,
1508     .exit = AdapterExit,
1509     .openDevice = AdapterOpenDevice,
1510     .closeDevice = AdapterCloseDevice,
1511     .getConfigDescriptor = AdapterGetConfigDescriptor,
1512     .getConfiguration = AdapterGetConfiguration,
1513     .setConfiguration = AdapterSetConfiguration,
1514     .claimInterface = AdapterClaimInterface,
1515     .releaseInterface = AdapterReleaseInterface,
1516     .setInterfaceAltsetting = AdapterSetInterface,
1517     .clearHalt = AdapterClearHalt,
1518     .resetDevice = AdapterResetDevice,
1519     .allocRequest = AdapterAllocRequest,
1520     .allocRequestByMmap = AdapterAllocRequestByMmap,
1521     .freeRequest = AdapterFreeRequest,
1522     .freeRequestByMmap = AdapterFreeRequestByMmap,
1523     .submitRequest = AdapterSubmitRequest,
1524     .cancelRequest = AdapterCancelRequest,
1525     .urbCompleteHandle = AdapterUrbCompleteHandle,
1526     .detachKernelDriverAndClaim = AdapterDetachKernelDriverAndClaim,
1527     .attachKernelDriver = AdapterAttachKernelDriver,
1528     .detachKernelDriver = AdapterDetachKernelDriver,
1529     .usbControlMsg = AdapterUsbControlMsg,
1530     .getUsbSpeed = AdapterGetUsbSpeed,
1531     .getInterfaceActiveStatus = AdapterGetInterfaceActiveStatus,
1532 };
1533 
OsSignalHandler(int32_t signo)1534 static void OsSignalHandler(int32_t signo)
1535 {
1536     (void)signo;
1537     return;
1538 }
1539 
UsbAdapterGetOps(void)1540 struct UsbOsAdapterOps *UsbAdapterGetOps(void)
1541 {
1542     return &g_usbAdapter;
1543 }
1544 
UsbAdapterGetTid(void)1545 UsbRawTidType UsbAdapterGetTid(void)
1546 {
1547     return gettid();
1548 }
1549 
UsbAdapterRegisterSignal(void)1550 int32_t UsbAdapterRegisterSignal(void)
1551 {
1552     if (signal(SIGUSR1, OsSignalHandler) == SIG_ERR) {
1553         HDF_LOGE("%{public}s:%{public}d Can't set AdapterSignalHandler for SIGUSR1", __func__, __LINE__);
1554         return HDF_ERR_IO;
1555     }
1556 
1557     return HDF_SUCCESS;
1558 }
1559 
UsbAdapterKillSignal(struct UsbDeviceHandle * devHandle,UsbRawTidType tid)1560 int32_t UsbAdapterKillSignal(struct UsbDeviceHandle *devHandle, UsbRawTidType tid)
1561 {
1562     (void)devHandle;
1563     return HDF_SUCCESS;
1564 }
1565 
AdapterAtomicInc(OsalAtomic * v)1566 int32_t AdapterAtomicInc(OsalAtomic *v)
1567 {
1568     return OsalAtomicInc(v);
1569 }
1570 
AdapterAtomicDec(OsalAtomic * v)1571 int32_t AdapterAtomicDec(OsalAtomic *v)
1572 {
1573     return OsalAtomicDec(v);
1574 }
1575