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