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