696 lines
20 KiB
C
696 lines
20 KiB
C
/*
|
|
* Copyright (C) 2010 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
// #define DEBUG 1
|
|
#if DEBUG
|
|
|
|
#ifdef USE_LIBLOG
|
|
#define LOG_TAG "usbhost"
|
|
#include "utils/Log.h"
|
|
#define D ALOGD
|
|
#else
|
|
#define D printf
|
|
#endif
|
|
|
|
#else
|
|
#define D(...)
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <stddef.h>
|
|
|
|
#include <sys/ioctl.h>
|
|
#include <sys/types.h>
|
|
#include <sys/time.h>
|
|
#include <sys/inotify.h>
|
|
#include <dirent.h>
|
|
#include <fcntl.h>
|
|
#include <errno.h>
|
|
#include <ctype.h>
|
|
#include <pthread.h>
|
|
|
|
#include <linux/usbdevice_fs.h>
|
|
#include <asm/byteorder.h>
|
|
|
|
#include "usbhost/usbhost.h"
|
|
|
|
#define DEV_DIR "/dev"
|
|
#define DEV_BUS_DIR DEV_DIR "/bus"
|
|
#define USB_FS_DIR DEV_BUS_DIR "/usb"
|
|
#define USB_FS_ID_SCANNER USB_FS_DIR "/%d/%d"
|
|
#define USB_FS_ID_FORMAT USB_FS_DIR "/%03d/%03d"
|
|
|
|
// From drivers/usb/core/devio.c
|
|
// I don't know why this isn't in a kernel header
|
|
#define MAX_USBFS_BUFFER_SIZE 16384
|
|
|
|
#define MAX_USBFS_WD_COUNT 10
|
|
|
|
struct usb_host_context {
|
|
int fd;
|
|
usb_device_added_cb cb_added;
|
|
usb_device_removed_cb cb_removed;
|
|
void *data;
|
|
int wds[MAX_USBFS_WD_COUNT];
|
|
int wdd;
|
|
int wddbus;
|
|
};
|
|
|
|
struct usb_device {
|
|
char dev_name[64];
|
|
unsigned char desc[4096];
|
|
int desc_length;
|
|
int fd;
|
|
int writeable;
|
|
};
|
|
|
|
static inline int badname(const char *name)
|
|
{
|
|
while(*name) {
|
|
if(!isdigit(*name++)) return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int find_existing_devices_bus(char *busname,
|
|
usb_device_added_cb added_cb,
|
|
void *client_data)
|
|
{
|
|
char devname[32];
|
|
DIR *devdir;
|
|
struct dirent *de;
|
|
int done = 0;
|
|
|
|
devdir = opendir(busname);
|
|
if(devdir == 0) return 0;
|
|
|
|
while ((de = readdir(devdir)) && !done) {
|
|
if(badname(de->d_name)) continue;
|
|
|
|
snprintf(devname, sizeof(devname), "%s/%s", busname, de->d_name);
|
|
done = added_cb(devname, client_data);
|
|
} // end of devdir while
|
|
closedir(devdir);
|
|
|
|
return done;
|
|
}
|
|
|
|
/* returns true if one of the callbacks indicates we are done */
|
|
static int find_existing_devices(usb_device_added_cb added_cb,
|
|
void *client_data)
|
|
{
|
|
char busname[32];
|
|
DIR *busdir;
|
|
struct dirent *de;
|
|
int done = 0;
|
|
|
|
busdir = opendir(USB_FS_DIR);
|
|
if(busdir == 0) return 0;
|
|
|
|
while ((de = readdir(busdir)) != 0 && !done) {
|
|
if(badname(de->d_name)) continue;
|
|
|
|
snprintf(busname, sizeof(busname), USB_FS_DIR "/%s", de->d_name);
|
|
done = find_existing_devices_bus(busname, added_cb,
|
|
client_data);
|
|
} //end of busdir while
|
|
closedir(busdir);
|
|
|
|
return done;
|
|
}
|
|
|
|
static void watch_existing_subdirs(struct usb_host_context *context,
|
|
int *wds, int wd_count)
|
|
{
|
|
char path[100];
|
|
int i, ret;
|
|
|
|
wds[0] = inotify_add_watch(context->fd, USB_FS_DIR, IN_CREATE | IN_DELETE);
|
|
if (wds[0] < 0)
|
|
return;
|
|
|
|
/* watch existing subdirectories of USB_FS_DIR */
|
|
for (i = 1; i < wd_count; i++) {
|
|
snprintf(path, sizeof(path), USB_FS_DIR "/%03d", i);
|
|
ret = inotify_add_watch(context->fd, path, IN_CREATE | IN_DELETE);
|
|
if (ret >= 0)
|
|
wds[i] = ret;
|
|
}
|
|
}
|
|
|
|
struct usb_host_context *usb_host_init()
|
|
{
|
|
struct usb_host_context *context = calloc(1, sizeof(struct usb_host_context));
|
|
if (!context) {
|
|
fprintf(stderr, "out of memory in usb_host_context\n");
|
|
return NULL;
|
|
}
|
|
context->fd = inotify_init();
|
|
if (context->fd < 0) {
|
|
fprintf(stderr, "inotify_init failed\n");
|
|
free(context);
|
|
return NULL;
|
|
}
|
|
return context;
|
|
}
|
|
|
|
void usb_host_cleanup(struct usb_host_context *context)
|
|
{
|
|
close(context->fd);
|
|
free(context);
|
|
}
|
|
|
|
int usb_host_get_fd(struct usb_host_context *context)
|
|
{
|
|
return context->fd;
|
|
} /* usb_host_get_fd() */
|
|
|
|
int usb_host_load(struct usb_host_context *context,
|
|
usb_device_added_cb added_cb,
|
|
usb_device_removed_cb removed_cb,
|
|
usb_discovery_done_cb discovery_done_cb,
|
|
void *client_data)
|
|
{
|
|
int done = 0;
|
|
int i;
|
|
|
|
context->cb_added = added_cb;
|
|
context->cb_removed = removed_cb;
|
|
context->data = client_data;
|
|
|
|
D("Created device discovery thread\n");
|
|
|
|
/* watch for files added and deleted within USB_FS_DIR */
|
|
context->wddbus = -1;
|
|
for (i = 0; i < MAX_USBFS_WD_COUNT; i++)
|
|
context->wds[i] = -1;
|
|
|
|
/* watch the root for new subdirectories */
|
|
context->wdd = inotify_add_watch(context->fd, DEV_DIR, IN_CREATE | IN_DELETE);
|
|
if (context->wdd < 0) {
|
|
fprintf(stderr, "inotify_add_watch failed\n");
|
|
if (discovery_done_cb)
|
|
discovery_done_cb(client_data);
|
|
return done;
|
|
}
|
|
|
|
watch_existing_subdirs(context, context->wds, MAX_USBFS_WD_COUNT);
|
|
|
|
/* check for existing devices first, after we have inotify set up */
|
|
done = find_existing_devices(added_cb, client_data);
|
|
if (discovery_done_cb)
|
|
done |= discovery_done_cb(client_data);
|
|
|
|
return done;
|
|
} /* usb_host_load() */
|
|
|
|
int usb_host_read_event(struct usb_host_context *context)
|
|
{
|
|
struct inotify_event* event;
|
|
char event_buf[512];
|
|
char path[100];
|
|
int i, ret, done = 0;
|
|
int offset = 0;
|
|
int wd;
|
|
|
|
ret = read(context->fd, event_buf, sizeof(event_buf));
|
|
if (ret >= (int)sizeof(struct inotify_event)) {
|
|
while (offset < ret && !done) {
|
|
event = (struct inotify_event*)&event_buf[offset];
|
|
done = 0;
|
|
wd = event->wd;
|
|
if (wd == context->wdd) {
|
|
if ((event->mask & IN_CREATE) && !strcmp(event->name, "bus")) {
|
|
context->wddbus = inotify_add_watch(context->fd, DEV_BUS_DIR, IN_CREATE | IN_DELETE);
|
|
if (context->wddbus < 0) {
|
|
done = 1;
|
|
} else {
|
|
watch_existing_subdirs(context, context->wds, MAX_USBFS_WD_COUNT);
|
|
done = find_existing_devices(context->cb_added, context->data);
|
|
}
|
|
}
|
|
} else if (wd == context->wddbus) {
|
|
if ((event->mask & IN_CREATE) && !strcmp(event->name, "usb")) {
|
|
watch_existing_subdirs(context, context->wds, MAX_USBFS_WD_COUNT);
|
|
done = find_existing_devices(context->cb_added, context->data);
|
|
} else if ((event->mask & IN_DELETE) && !strcmp(event->name, "usb")) {
|
|
for (i = 0; i < MAX_USBFS_WD_COUNT; i++) {
|
|
if (context->wds[i] >= 0) {
|
|
inotify_rm_watch(context->fd, context->wds[i]);
|
|
context->wds[i] = -1;
|
|
}
|
|
}
|
|
}
|
|
} else if (wd == context->wds[0]) {
|
|
i = atoi(event->name);
|
|
snprintf(path, sizeof(path), USB_FS_DIR "/%s", event->name);
|
|
D("%s subdirectory %s: index: %d\n", (event->mask & IN_CREATE) ?
|
|
"new" : "gone", path, i);
|
|
if (i > 0 && i < MAX_USBFS_WD_COUNT) {
|
|
int local_ret = 0;
|
|
if (event->mask & IN_CREATE) {
|
|
local_ret = inotify_add_watch(context->fd, path,
|
|
IN_CREATE | IN_DELETE);
|
|
if (local_ret >= 0)
|
|
context->wds[i] = local_ret;
|
|
done = find_existing_devices_bus(path, context->cb_added,
|
|
context->data);
|
|
} else if (event->mask & IN_DELETE) {
|
|
inotify_rm_watch(context->fd, context->wds[i]);
|
|
context->wds[i] = -1;
|
|
}
|
|
}
|
|
} else {
|
|
for (i = 1; (i < MAX_USBFS_WD_COUNT) && !done; i++) {
|
|
if (wd == context->wds[i]) {
|
|
snprintf(path, sizeof(path), USB_FS_DIR "/%03d/%s", i, event->name);
|
|
if (event->mask == IN_CREATE) {
|
|
D("new device %s\n", path);
|
|
done = context->cb_added(path, context->data);
|
|
} else if (event->mask == IN_DELETE) {
|
|
D("gone device %s\n", path);
|
|
done = context->cb_removed(path, context->data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
offset += sizeof(struct inotify_event) + event->len;
|
|
}
|
|
}
|
|
|
|
return done;
|
|
} /* usb_host_read_event() */
|
|
|
|
void usb_host_run(struct usb_host_context *context,
|
|
usb_device_added_cb added_cb,
|
|
usb_device_removed_cb removed_cb,
|
|
usb_discovery_done_cb discovery_done_cb,
|
|
void *client_data)
|
|
{
|
|
int done;
|
|
|
|
done = usb_host_load(context, added_cb, removed_cb, discovery_done_cb, client_data);
|
|
|
|
while (!done) {
|
|
|
|
done = usb_host_read_event(context);
|
|
}
|
|
} /* usb_host_run() */
|
|
|
|
struct usb_device *usb_device_open(const char *dev_name)
|
|
{
|
|
int fd, did_retry = 0, writeable = 1;
|
|
|
|
D("usb_device_open %s\n", dev_name);
|
|
|
|
retry:
|
|
fd = open(dev_name, O_RDWR);
|
|
if (fd < 0) {
|
|
/* if we fail, see if have read-only access */
|
|
fd = open(dev_name, O_RDONLY);
|
|
D("usb_device_open open returned %d errno %d\n", fd, errno);
|
|
if (fd < 0 && (errno == EACCES || errno == ENOENT) && !did_retry) {
|
|
/* work around race condition between inotify and permissions management */
|
|
sleep(1);
|
|
did_retry = 1;
|
|
goto retry;
|
|
}
|
|
|
|
if (fd < 0)
|
|
return NULL;
|
|
writeable = 0;
|
|
D("[ usb open read-only %s fd = %d]\n", dev_name, fd);
|
|
}
|
|
|
|
struct usb_device* result = usb_device_new(dev_name, fd);
|
|
if (result)
|
|
result->writeable = writeable;
|
|
return result;
|
|
}
|
|
|
|
void usb_device_close(struct usb_device *device)
|
|
{
|
|
close(device->fd);
|
|
free(device);
|
|
}
|
|
|
|
struct usb_device *usb_device_new(const char *dev_name, int fd)
|
|
{
|
|
struct usb_device *device = calloc(1, sizeof(struct usb_device));
|
|
int length;
|
|
|
|
D("usb_device_new %s fd: %d\n", dev_name, fd);
|
|
|
|
if (lseek(fd, 0, SEEK_SET) != 0)
|
|
goto failed;
|
|
length = read(fd, device->desc, sizeof(device->desc));
|
|
D("usb_device_new read returned %d errno %d\n", length, errno);
|
|
if (length < 0)
|
|
goto failed;
|
|
|
|
strncpy(device->dev_name, dev_name, sizeof(device->dev_name) - 1);
|
|
device->fd = fd;
|
|
device->desc_length = length;
|
|
// assume we are writeable, since usb_device_get_fd will only return writeable fds
|
|
device->writeable = 1;
|
|
return device;
|
|
|
|
failed:
|
|
close(fd);
|
|
free(device);
|
|
return NULL;
|
|
}
|
|
|
|
static int usb_device_reopen_writeable(struct usb_device *device)
|
|
{
|
|
if (device->writeable)
|
|
return 1;
|
|
|
|
int fd = open(device->dev_name, O_RDWR);
|
|
if (fd >= 0) {
|
|
close(device->fd);
|
|
device->fd = fd;
|
|
device->writeable = 1;
|
|
return 1;
|
|
}
|
|
D("usb_device_reopen_writeable failed errno %d\n", errno);
|
|
return 0;
|
|
}
|
|
|
|
int usb_device_get_fd(struct usb_device *device)
|
|
{
|
|
if (!usb_device_reopen_writeable(device))
|
|
return -1;
|
|
return device->fd;
|
|
}
|
|
|
|
const char* usb_device_get_name(struct usb_device *device)
|
|
{
|
|
return device->dev_name;
|
|
}
|
|
|
|
int usb_device_get_unique_id(struct usb_device *device)
|
|
{
|
|
int bus = 0, dev = 0;
|
|
sscanf(device->dev_name, USB_FS_ID_SCANNER, &bus, &dev);
|
|
return bus * 1000 + dev;
|
|
}
|
|
|
|
int usb_device_get_unique_id_from_name(const char* name)
|
|
{
|
|
int bus = 0, dev = 0;
|
|
sscanf(name, USB_FS_ID_SCANNER, &bus, &dev);
|
|
return bus * 1000 + dev;
|
|
}
|
|
|
|
char* usb_device_get_name_from_unique_id(int id)
|
|
{
|
|
int bus = id / 1000;
|
|
int dev = id % 1000;
|
|
char* result = (char *)calloc(1, strlen(USB_FS_ID_FORMAT));
|
|
snprintf(result, strlen(USB_FS_ID_FORMAT) - 1, USB_FS_ID_FORMAT, bus, dev);
|
|
return result;
|
|
}
|
|
|
|
uint16_t usb_device_get_vendor_id(struct usb_device *device)
|
|
{
|
|
struct usb_device_descriptor* desc = (struct usb_device_descriptor*)device->desc;
|
|
return __le16_to_cpu(desc->idVendor);
|
|
}
|
|
|
|
uint16_t usb_device_get_product_id(struct usb_device *device)
|
|
{
|
|
struct usb_device_descriptor* desc = (struct usb_device_descriptor*)device->desc;
|
|
return __le16_to_cpu(desc->idProduct);
|
|
}
|
|
|
|
const struct usb_device_descriptor* usb_device_get_device_descriptor(struct usb_device *device)
|
|
{
|
|
return (struct usb_device_descriptor*)device->desc;
|
|
}
|
|
|
|
char* usb_device_get_string(struct usb_device *device, int id)
|
|
{
|
|
char string[256];
|
|
__u16 buffer[128];
|
|
__u16 languages[128];
|
|
int i, result;
|
|
int languageCount = 0;
|
|
|
|
string[0] = 0;
|
|
memset(languages, 0, sizeof(languages));
|
|
|
|
// read list of supported languages
|
|
result = usb_device_control_transfer(device,
|
|
USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE, USB_REQ_GET_DESCRIPTOR,
|
|
(USB_DT_STRING << 8) | 0, 0, languages, sizeof(languages), 0);
|
|
if (result > 0)
|
|
languageCount = (result - 2) / 2;
|
|
|
|
for (i = 1; i <= languageCount; i++) {
|
|
memset(buffer, 0, sizeof(buffer));
|
|
|
|
result = usb_device_control_transfer(device,
|
|
USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE, USB_REQ_GET_DESCRIPTOR,
|
|
(USB_DT_STRING << 8) | id, languages[i], buffer, sizeof(buffer), 0);
|
|
if (result > 0) {
|
|
int i;
|
|
// skip first word, and copy the rest to the string, changing shorts to bytes.
|
|
result /= 2;
|
|
for (i = 1; i < result; i++)
|
|
string[i - 1] = buffer[i];
|
|
string[i - 1] = 0;
|
|
return strdup(string);
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
char* usb_device_get_manufacturer_name(struct usb_device *device)
|
|
{
|
|
struct usb_device_descriptor *desc = (struct usb_device_descriptor *)device->desc;
|
|
|
|
if (desc->iManufacturer)
|
|
return usb_device_get_string(device, desc->iManufacturer);
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
char* usb_device_get_product_name(struct usb_device *device)
|
|
{
|
|
struct usb_device_descriptor *desc = (struct usb_device_descriptor *)device->desc;
|
|
|
|
if (desc->iProduct)
|
|
return usb_device_get_string(device, desc->iProduct);
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
char* usb_device_get_serial(struct usb_device *device)
|
|
{
|
|
struct usb_device_descriptor *desc = (struct usb_device_descriptor *)device->desc;
|
|
|
|
if (desc->iSerialNumber)
|
|
return usb_device_get_string(device, desc->iSerialNumber);
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
int usb_device_is_writeable(struct usb_device *device)
|
|
{
|
|
return device->writeable;
|
|
}
|
|
|
|
void usb_descriptor_iter_init(struct usb_device *device, struct usb_descriptor_iter *iter)
|
|
{
|
|
iter->config = device->desc;
|
|
iter->config_end = device->desc + device->desc_length;
|
|
iter->curr_desc = device->desc;
|
|
}
|
|
|
|
struct usb_descriptor_header *usb_descriptor_iter_next(struct usb_descriptor_iter *iter)
|
|
{
|
|
struct usb_descriptor_header* next;
|
|
if (iter->curr_desc >= iter->config_end)
|
|
return NULL;
|
|
next = (struct usb_descriptor_header*)iter->curr_desc;
|
|
iter->curr_desc += next->bLength;
|
|
return next;
|
|
}
|
|
|
|
int usb_device_claim_interface(struct usb_device *device, unsigned int interface)
|
|
{
|
|
return ioctl(device->fd, USBDEVFS_CLAIMINTERFACE, &interface);
|
|
}
|
|
|
|
int usb_device_release_interface(struct usb_device *device, unsigned int interface)
|
|
{
|
|
return ioctl(device->fd, USBDEVFS_RELEASEINTERFACE, &interface);
|
|
}
|
|
|
|
int usb_device_connect_kernel_driver(struct usb_device *device,
|
|
unsigned int interface, int connect)
|
|
{
|
|
struct usbdevfs_ioctl ctl;
|
|
|
|
ctl.ifno = interface;
|
|
ctl.ioctl_code = (connect ? USBDEVFS_CONNECT : USBDEVFS_DISCONNECT);
|
|
ctl.data = NULL;
|
|
return ioctl(device->fd, USBDEVFS_IOCTL, &ctl);
|
|
}
|
|
|
|
int usb_device_control_transfer(struct usb_device *device,
|
|
int requestType,
|
|
int request,
|
|
int value,
|
|
int index,
|
|
void* buffer,
|
|
int length,
|
|
unsigned int timeout)
|
|
{
|
|
struct usbdevfs_ctrltransfer ctrl;
|
|
|
|
// this usually requires read/write permission
|
|
if (!usb_device_reopen_writeable(device))
|
|
return -1;
|
|
|
|
memset(&ctrl, 0, sizeof(ctrl));
|
|
ctrl.bRequestType = requestType;
|
|
ctrl.bRequest = request;
|
|
ctrl.wValue = value;
|
|
ctrl.wIndex = index;
|
|
ctrl.wLength = length;
|
|
ctrl.data = buffer;
|
|
ctrl.timeout = timeout;
|
|
return ioctl(device->fd, USBDEVFS_CONTROL, &ctrl);
|
|
}
|
|
|
|
int usb_device_bulk_transfer(struct usb_device *device,
|
|
int endpoint,
|
|
void* buffer,
|
|
int length,
|
|
unsigned int timeout)
|
|
{
|
|
struct usbdevfs_bulktransfer ctrl;
|
|
|
|
// need to limit request size to avoid EINVAL
|
|
if (length > MAX_USBFS_BUFFER_SIZE)
|
|
length = MAX_USBFS_BUFFER_SIZE;
|
|
|
|
memset(&ctrl, 0, sizeof(ctrl));
|
|
ctrl.ep = endpoint;
|
|
ctrl.len = length;
|
|
ctrl.data = buffer;
|
|
ctrl.timeout = timeout;
|
|
return ioctl(device->fd, USBDEVFS_BULK, &ctrl);
|
|
}
|
|
|
|
struct usb_request *usb_request_new(struct usb_device *dev,
|
|
const struct usb_endpoint_descriptor *ep_desc)
|
|
{
|
|
struct usbdevfs_urb *urb = calloc(1, sizeof(struct usbdevfs_urb));
|
|
if (!urb)
|
|
return NULL;
|
|
|
|
if ((ep_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK)
|
|
urb->type = USBDEVFS_URB_TYPE_BULK;
|
|
else if ((ep_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)
|
|
urb->type = USBDEVFS_URB_TYPE_INTERRUPT;
|
|
else {
|
|
D("Unsupported endpoint type %d", ep_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK);
|
|
free(urb);
|
|
return NULL;
|
|
}
|
|
urb->endpoint = ep_desc->bEndpointAddress;
|
|
|
|
struct usb_request *req = calloc(1, sizeof(struct usb_request));
|
|
if (!req) {
|
|
free(urb);
|
|
return NULL;
|
|
}
|
|
|
|
req->dev = dev;
|
|
req->max_packet_size = __le16_to_cpu(ep_desc->wMaxPacketSize);
|
|
req->private_data = urb;
|
|
req->endpoint = urb->endpoint;
|
|
urb->usercontext = req;
|
|
|
|
return req;
|
|
}
|
|
|
|
void usb_request_free(struct usb_request *req)
|
|
{
|
|
free(req->private_data);
|
|
free(req);
|
|
}
|
|
|
|
int usb_request_queue(struct usb_request *req)
|
|
{
|
|
struct usbdevfs_urb *urb = (struct usbdevfs_urb*)req->private_data;
|
|
int res;
|
|
|
|
urb->status = -1;
|
|
urb->buffer = req->buffer;
|
|
// need to limit request size to avoid EINVAL
|
|
if (req->buffer_length > MAX_USBFS_BUFFER_SIZE)
|
|
urb->buffer_length = MAX_USBFS_BUFFER_SIZE;
|
|
else
|
|
urb->buffer_length = req->buffer_length;
|
|
|
|
do {
|
|
res = ioctl(req->dev->fd, USBDEVFS_SUBMITURB, urb);
|
|
} while((res < 0) && (errno == EINTR));
|
|
|
|
return res;
|
|
}
|
|
|
|
struct usb_request *usb_request_wait(struct usb_device *dev)
|
|
{
|
|
struct usbdevfs_urb *urb = NULL;
|
|
struct usb_request *req = NULL;
|
|
|
|
while (1) {
|
|
int res = ioctl(dev->fd, USBDEVFS_REAPURB, &urb);
|
|
D("USBDEVFS_REAPURB returned %d\n", res);
|
|
if (res < 0) {
|
|
if(errno == EINTR) {
|
|
continue;
|
|
}
|
|
D("[ reap urb - error ]\n");
|
|
return NULL;
|
|
} else {
|
|
D("[ urb @%p status = %d, actual = %d ]\n",
|
|
urb, urb->status, urb->actual_length);
|
|
req = (struct usb_request*)urb->usercontext;
|
|
req->actual_length = urb->actual_length;
|
|
}
|
|
break;
|
|
}
|
|
return req;
|
|
}
|
|
|
|
int usb_request_cancel(struct usb_request *req)
|
|
{
|
|
struct usbdevfs_urb *urb = ((struct usbdevfs_urb*)req->private_data);
|
|
return ioctl(req->dev->fd, USBDEVFS_DISCARDURB, urb);
|
|
}
|
|
|