libusb/os/openbsd_usb.c

   1 /*
   2  * Copyright © 2011-2013 Martin Pieuchot <mpi@openbsd.org>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 #include <config.h>
  20
  21 #include <sys/time.h>
  22 #include <sys/types.h>
  23
  24 #include <errno.h>
  25 #include <fcntl.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <unistd.h>
  30
  31 #include <dev/usb/usb.h>
  32
  33 #include "libusbi.h"
  34
  35 struct device_priv {
  36         char *devname;                          /* name of the ugen(4) node */
  37         int fd;                                 /* device file descriptor */
  38
  39         unsigned char *cdesc;                   /* active config descriptor */
  40         usb_device_descriptor_t ddesc;          /* usb device descriptor */
  41 };
  42
  43 struct handle_priv {
  44         int endpoints[USB_MAX_ENDPOINTS];
  45 };
  46
  47 /*
  48  * Backend functions
  49  */
  50 static int obsd_get_device_list(struct libusb_context *,
  51     struct discovered_devs **);
  52 static int obsd_open(struct libusb_device_handle *);
  53 static void obsd_close(struct libusb_device_handle *);
  54
  55 static int obsd_get_device_descriptor(struct libusb_device *, unsigned char *,
  56     int *);
  57 static int obsd_get_active_config_descriptor(struct libusb_device *,
  58     unsigned char *, size_t, int *);
  59 static int obsd_get_config_descriptor(struct libusb_device *, uint8_t,
  60     unsigned char *, size_t, int *);
  61
  62 static int obsd_get_configuration(struct libusb_device_handle *, int *);
  63 static int obsd_set_configuration(struct libusb_device_handle *, int);
  64
  65 static int obsd_claim_interface(struct libusb_device_handle *, int);
  66 static int obsd_release_interface(struct libusb_device_handle *, int);
  67
  68 static int obsd_set_interface_altsetting(struct libusb_device_handle *, int,
  69     int);
  70 static int obsd_clear_halt(struct libusb_device_handle *, unsigned char);
  71 static int obsd_reset_device(struct libusb_device_handle *);
  72 static void obsd_destroy_device(struct libusb_device *);
  73
  74 static int obsd_submit_transfer(struct usbi_transfer *);
  75 static int obsd_cancel_transfer(struct usbi_transfer *);
  76 static void obsd_clear_transfer_priv(struct usbi_transfer *);
  77 static int obsd_handle_transfer_completion(struct usbi_transfer *);
  78 static int obsd_clock_gettime(int, struct timespec *);
  79
  80 /*
  81  * Private functions
  82  */
  83 static int _errno_to_libusb(int);
  84 static int _cache_active_config_descriptor(struct libusb_device *);
  85 static int _sync_control_transfer(struct usbi_transfer *);
  86 static int _sync_gen_transfer(struct usbi_transfer *);
  87 static int _access_endpoint(struct libusb_transfer *);
  88
  89 static int _bus_open(int);
  90
  91
  92 const struct usbi_os_backend usbi_backend = {
  93         "Synchronous OpenBSD backend",
  94         0,
  95         NULL,                           /* init() */
  96         NULL,                           /* exit() */
  97         obsd_get_device_list,
  98         NULL,                           /* hotplug_poll */
  99         obsd_open,
 100         obsd_close,
 101
 102         obsd_get_device_descriptor,
 103         obsd_get_active_config_descriptor,
 104         obsd_get_config_descriptor,
 105         NULL,                           /* get_config_descriptor_by_value() */
 106
 107         obsd_get_configuration,
 108         obsd_set_configuration,
 109
 110         obsd_claim_interface,
 111         obsd_release_interface,
 112
 113         obsd_set_interface_altsetting,
 114         obsd_clear_halt,
 115         obsd_reset_device,
 116
 117         NULL,                           /* alloc_streams */
 118         NULL,                           /* free_streams */
 119
 120         NULL,                           /* dev_mem_alloc() */
 121         NULL,                           /* dev_mem_free() */
 122
 123         NULL,                           /* kernel_driver_active() */
 124         NULL,                           /* detach_kernel_driver() */
 125         NULL,                           /* attach_kernel_driver() */
 126
 127         obsd_destroy_device,
 128
 129         obsd_submit_transfer,
 130         obsd_cancel_transfer,
 131         obsd_clear_transfer_priv,
 132
 133         NULL,                           /* handle_events() */
 134         obsd_handle_transfer_completion,
 135
 136         obsd_clock_gettime,
 137         0,                              /* context_priv_size */
 138         sizeof(struct device_priv),
 139         sizeof(struct handle_priv),
 140         0,                              /* transfer_priv_size */
 141 };
 142
 143 #define DEVPATH "/dev/"
 144 #define USBDEV  DEVPATH "usb"
 145
 146 int
 147 obsd_get_device_list(struct libusb_context * ctx,
 148         struct discovered_devs **discdevs)
 149 {
 150         struct discovered_devs *ddd;
 151         struct libusb_device *dev;
 152         struct device_priv *dpriv;
 153         struct usb_device_info di;
 154         struct usb_device_ddesc dd;
 155         unsigned long session_id;
 156         char devices[USB_MAX_DEVICES];
 157         char busnode[16];
 158         char *udevname;
 159         int fd, addr, i, j;
 160
 161         usbi_dbg("");
 162
 163         for (i = 0; i < 8; i++) {
 164                 snprintf(busnode, sizeof(busnode), USBDEV "%d", i);
 165
 166                 if ((fd = open(busnode, O_RDWR)) < 0) {
 167                         if (errno != ENOENT && errno != ENXIO)
 168                                 usbi_err(ctx, "could not open %s", busnode);
 169                         continue;
 170                 }
 171
 172                 bzero(devices, sizeof(devices));
 173                 for (addr = 1; addr < USB_MAX_DEVICES; addr++) {
 174                         if (devices[addr])
 175                                 continue;
 176
 177                         di.udi_addr = addr;
 178                         if (ioctl(fd, USB_DEVICEINFO, &di) < 0)
 179                                 continue;
 180
 181                         /*
 182                          * XXX If ugen(4) is attached to the USB device
 183                          * it will be used.
 184                          */
 185                         udevname = NULL;
 186                         for (j = 0; j < USB_MAX_DEVNAMES; j++)
 187                                 if (!strncmp("ugen", di.udi_devnames[j], 4)) {
 188                                         udevname = strdup(di.udi_devnames[j]);
 189                                         break;
 190                                 }
 191
 192                         session_id = (di.udi_bus << 8 | di.udi_addr);
 193                         dev = usbi_get_device_by_session_id(ctx, session_id);
 194
 195                         if (dev == NULL) {
 196                                 dev = usbi_alloc_device(ctx, session_id);
 197                                 if (dev == NULL) {
 198                                         close(fd);
 199                                         return (LIBUSB_ERROR_NO_MEM);
 200                                 }
 201
 202                                 dev->bus_number = di.udi_bus;
 203                                 dev->device_address = di.udi_addr;
 204                                 dev->speed = di.udi_speed;
 205
 206                                 dpriv = (struct device_priv *)dev->os_priv;
 207                                 dpriv->fd = -1;
 208                                 dpriv->cdesc = NULL;
 209                                 dpriv->devname = udevname;
 210
 211                                 dd.udd_bus = di.udi_bus;
 212                                 dd.udd_addr = di.udi_addr;
 213                                 if (ioctl(fd, USB_DEVICE_GET_DDESC, &dd) < 0) {
 214                                         libusb_unref_device(dev);
 215                                         continue;
 216                                 }
 217                                 dpriv->ddesc = dd.udd_desc;
 218
 219                                 if (_cache_active_config_descriptor(dev)) {
 220                                         libusb_unref_device(dev);
 221                                         continue;
 222                                 }
 223
 224                                 if (usbi_sanitize_device(dev)) {
 225                                         libusb_unref_device(dev);
 226                                         continue;
 227                                 }
 228                         }
 229
 230                         ddd = discovered_devs_append(*discdevs, dev);
 231                         if (ddd == NULL) {
 232                                 close(fd);
 233                                 return (LIBUSB_ERROR_NO_MEM);
 234                         }
 235                         libusb_unref_device(dev);
 236
 237                         *discdevs = ddd;
 238                         devices[addr] = 1;
 239                 }
 240
 241                 close(fd);
 242         }
 243
 244         return (LIBUSB_SUCCESS);
 245 }
 246
 247 int
 248 obsd_open(struct libusb_device_handle *handle)
 249 {
 250         struct handle_priv *hpriv = (struct handle_priv *)handle->os_priv;
 251         struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
 252         char devnode[16];
 253
 254         if (dpriv->devname) {
 255                 /*
 256                  * Only open ugen(4) attached devices read-write, all
 257                  * read-only operations are done through the bus node.
 258                  */
 259                 snprintf(devnode, sizeof(devnode), DEVPATH "%s.00",
 260                     dpriv->devname);
 261                 dpriv->fd = open(devnode, O_RDWR);
 262                 if (dpriv->fd < 0)
 263                         return _errno_to_libusb(errno);
 264
 265                 usbi_dbg("open %s: fd %d", devnode, dpriv->fd);
 266         }
 267
 268         return (LIBUSB_SUCCESS);
 269 }
 270
 271 void
 272 obsd_close(struct libusb_device_handle *handle)
 273 {
 274         struct handle_priv *hpriv = (struct handle_priv *)handle->os_priv;
 275         struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
 276
 277         if (dpriv->devname) {
 278                 usbi_dbg("close: fd %d", dpriv->fd);
 279
 280                 close(dpriv->fd);
 281                 dpriv->fd = -1;
 282         }
 283 }
 284
 285 int
 286 obsd_get_device_descriptor(struct libusb_device *dev, unsigned char *buf,
 287     int *host_endian)
 288 {
 289         struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
 290
 291         usbi_dbg("");
 292
 293         memcpy(buf, &dpriv->ddesc, DEVICE_DESC_LENGTH);
 294
 295         *host_endian = 0;
 296
 297         return (LIBUSB_SUCCESS);
 298 }
 299
 300 int
 301 obsd_get_active_config_descriptor(struct libusb_device *dev,
 302     unsigned char *buf, size_t len, int *host_endian)
 303 {
 304         struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
 305         usb_config_descriptor_t *ucd = (usb_config_descriptor_t *)dpriv->cdesc;
 306
 307         len = MIN(len, UGETW(ucd->wTotalLength));
 308
 309         usbi_dbg("len %d", len);
 310
 311         memcpy(buf, dpriv->cdesc, len);
 312
 313         *host_endian = 0;
 314
 315         return (len);
 316 }
 317
 318 int
 319 obsd_get_config_descriptor(struct libusb_device *dev, uint8_t idx,
 320     unsigned char *buf, size_t len, int *host_endian)
 321 {
 322         struct usb_device_fdesc udf;
 323         int fd, err;
 324
 325         if ((fd = _bus_open(dev->bus_number)) < 0)
 326                 return _errno_to_libusb(errno);
 327
 328         udf.udf_bus = dev->bus_number;
 329         udf.udf_addr = dev->device_address;
 330         udf.udf_config_index = idx;
 331         udf.udf_size = len;
 332         udf.udf_data = buf;
 333
 334         usbi_dbg("index %d, len %d", udf.udf_config_index, len);
 335
 336         if (ioctl(fd, USB_DEVICE_GET_FDESC, &udf) < 0) {
 337                 err = errno;
 338                 close(fd);
 339                 return _errno_to_libusb(err);
 340         }
 341         close(fd);
 342
 343         *host_endian = 0;
 344
 345         return (len);
 346 }
 347
 348 int
 349 obsd_get_configuration(struct libusb_device_handle *handle, int *config)
 350 {
 351         struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
 352         usb_config_descriptor_t *ucd = (usb_config_descriptor_t *)dpriv->cdesc;
 353
 354         *config = ucd->bConfigurationValue;
 355
 356         usbi_dbg("bConfigurationValue %d", *config);
 357
 358         return (LIBUSB_SUCCESS);
 359 }
 360
 361 int
 362 obsd_set_configuration(struct libusb_device_handle *handle, int config)
 363 {
 364         struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
 365
 366         if (dpriv->devname == NULL)
 367                 return (LIBUSB_ERROR_NOT_SUPPORTED);
 368
 369         usbi_dbg("bConfigurationValue %d", config);
 370
 371         if (ioctl(dpriv->fd, USB_SET_CONFIG, &config) < 0)
 372                 return _errno_to_libusb(errno);
 373
 374         return _cache_active_config_descriptor(handle->dev);
 375 }
 376
 377 int
 378 obsd_claim_interface(struct libusb_device_handle *handle, int iface)
 379 {
 380         struct handle_priv *hpriv = (struct handle_priv *)handle->os_priv;
 381         int i;
 382
 383         for (i = 0; i < USB_MAX_ENDPOINTS; i++)
 384                 hpriv->endpoints[i] = -1;
 385
 386         return (LIBUSB_SUCCESS);
 387 }
 388
 389 int
 390 obsd_release_interface(struct libusb_device_handle *handle, int iface)
 391 {
 392         struct handle_priv *hpriv = (struct handle_priv *)handle->os_priv;
 393         int i;
 394
 395         for (i = 0; i < USB_MAX_ENDPOINTS; i++)
 396                 if (hpriv->endpoints[i] >= 0)
 397                         close(hpriv->endpoints[i]);
 398
 399         return (LIBUSB_SUCCESS);
 400 }
 401
 402 int
 403 obsd_set_interface_altsetting(struct libusb_device_handle *handle, int iface,
 404     int altsetting)
 405 {
 406         struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
 407         struct usb_alt_interface intf;
 408
 409         if (dpriv->devname == NULL)
 410                 return (LIBUSB_ERROR_NOT_SUPPORTED);
 411
 412         usbi_dbg("iface %d, setting %d", iface, altsetting);
 413
 414         memset(&intf, 0, sizeof(intf));
 415
 416         intf.uai_interface_index = iface;
 417         intf.uai_alt_no = altsetting;
 418
 419         if (ioctl(dpriv->fd, USB_SET_ALTINTERFACE, &intf) < 0)
 420                 return _errno_to_libusb(errno);
 421
 422         return (LIBUSB_SUCCESS);
 423 }
 424
 425 int
 426 obsd_clear_halt(struct libusb_device_handle *handle, unsigned char endpoint)
 427 {
 428         struct usb_ctl_request req;
 429         int fd, err;
 430
 431         if ((fd = _bus_open(handle->dev->bus_number)) < 0)
 432                 return _errno_to_libusb(errno);
 433
 434         usbi_dbg("");
 435
 436         req.ucr_addr = handle->dev->device_address;
 437         req.ucr_request.bmRequestType = UT_WRITE_ENDPOINT;
 438         req.ucr_request.bRequest = UR_CLEAR_FEATURE;
 439         USETW(req.ucr_request.wValue, UF_ENDPOINT_HALT);
 440         USETW(req.ucr_request.wIndex, endpoint);
 441         USETW(req.ucr_request.wLength, 0);
 442
 443         if (ioctl(fd, USB_REQUEST, &req) < 0) {
 444                 err = errno;
 445                 close(fd);
 446                 return _errno_to_libusb(err);
 447         }
 448         close(fd);
 449
 450         return (LIBUSB_SUCCESS);
 451 }
 452
 453 int
 454 obsd_reset_device(struct libusb_device_handle *handle)
 455 {
 456         usbi_dbg("");
 457
 458         return (LIBUSB_ERROR_NOT_SUPPORTED);
 459 }
 460
 461 void
 462 obsd_destroy_device(struct libusb_device *dev)
 463 {
 464         struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
 465
 466         usbi_dbg("");
 467
 468         free(dpriv->cdesc);
 469         free(dpriv->devname);
 470 }
 471
 472 int
 473 obsd_submit_transfer(struct usbi_transfer *itransfer)
 474 {
 475         struct libusb_transfer *transfer;
 476         struct handle_priv *hpriv;
 477         int err = 0;
 478
 479         usbi_dbg("");
 480
 481         transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
 482         hpriv = (struct handle_priv *)transfer->dev_handle->os_priv;
 483
 484         switch (transfer->type) {
 485         case LIBUSB_TRANSFER_TYPE_CONTROL:
 486                 err = _sync_control_transfer(itransfer);
 487                 break;
 488         case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
 489                 if (IS_XFEROUT(transfer)) {
 490                         /* Isochronous write is not supported */
 491                         err = LIBUSB_ERROR_NOT_SUPPORTED;
 492                         break;
 493                 }
 494                 err = _sync_gen_transfer(itransfer);
 495                 break;
 496         case LIBUSB_TRANSFER_TYPE_BULK:
 497         case LIBUSB_TRANSFER_TYPE_INTERRUPT:
 498                 if (IS_XFEROUT(transfer) &&
 499                     transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET) {
 500                         err = LIBUSB_ERROR_NOT_SUPPORTED;
 501                         break;
 502                 }
 503                 err = _sync_gen_transfer(itransfer);
 504                 break;
 505         case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
 506                 err = LIBUSB_ERROR_NOT_SUPPORTED;
 507                 break;
 508         }
 509
 510         if (err)
 511                 return (err);
 512
 513         usbi_signal_transfer_completion(itransfer);
 514
 515         return (LIBUSB_SUCCESS);
 516 }
 517
 518 int
 519 obsd_cancel_transfer(struct usbi_transfer *itransfer)
 520 {
 521         usbi_dbg("");
 522
 523         return (LIBUSB_ERROR_NOT_SUPPORTED);
 524 }
 525
 526 void
 527 obsd_clear_transfer_priv(struct usbi_transfer *itransfer)
 528 {
 529         usbi_dbg("");
 530
 531         /* Nothing to do */
 532 }
 533
 534 int
 535 obsd_handle_transfer_completion(struct usbi_transfer *itransfer)
 536 {
 537         return usbi_handle_transfer_completion(itransfer, LIBUSB_TRANSFER_COMPLETED);
 538 }
 539
 540 int
 541 obsd_clock_gettime(int clkid, struct timespec *tp)
 542 {
 543         usbi_dbg("clock %d", clkid);
 544
 545         if (clkid == USBI_CLOCK_REALTIME)
 546                 return clock_gettime(CLOCK_REALTIME, tp);
 547
 548         if (clkid == USBI_CLOCK_MONOTONIC)
 549                 return clock_gettime(CLOCK_MONOTONIC, tp);
 550
 551         return (LIBUSB_ERROR_INVALID_PARAM);
 552 }
 553
 554 int
 555 _errno_to_libusb(int err)
 556 {
 557         usbi_dbg("error: %s (%d)", strerror(err), err);
 558
 559         switch (err) {
 560         case EIO:
 561                 return (LIBUSB_ERROR_IO);
 562         case EACCES:
 563                 return (LIBUSB_ERROR_ACCESS);
 564         case ENOENT:
 565                 return (LIBUSB_ERROR_NO_DEVICE);
 566         case ENOMEM:
 567                 return (LIBUSB_ERROR_NO_MEM);
 568         case ETIMEDOUT:
 569                 return (LIBUSB_ERROR_TIMEOUT);
 570         }
 571
 572         return (LIBUSB_ERROR_OTHER);
 573 }
 574
 575 int
 576 _cache_active_config_descriptor(struct libusb_device *dev)
 577 {
 578         struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
 579         struct usb_device_cdesc udc;
 580         struct usb_device_fdesc udf;
 581         unsigned char* buf;
 582         int fd, len, err;
 583
 584         if ((fd = _bus_open(dev->bus_number)) < 0)
 585                 return _errno_to_libusb(errno);
 586
 587         usbi_dbg("fd %d, addr %d", fd, dev->device_address);
 588
 589         udc.udc_bus = dev->bus_number;
 590         udc.udc_addr = dev->device_address;
 591         udc.udc_config_index = USB_CURRENT_CONFIG_INDEX;
 592         if (ioctl(fd, USB_DEVICE_GET_CDESC, &udc) < 0) {
 593                 err = errno;
 594                 close(fd);
 595                 return _errno_to_libusb(errno);
 596         }
 597
 598         usbi_dbg("active bLength %d", udc.udc_desc.bLength);
 599
 600         len = UGETW(udc.udc_desc.wTotalLength);
 601         buf = malloc(len);
 602         if (buf == NULL)
 603                 return (LIBUSB_ERROR_NO_MEM);
 604
 605         udf.udf_bus = dev->bus_number;
 606         udf.udf_addr = dev->device_address;
 607         udf.udf_config_index = udc.udc_config_index;
 608         udf.udf_size = len;
 609         udf.udf_data = buf;
 610
 611         usbi_dbg("index %d, len %d", udf.udf_config_index, len);
 612
 613         if (ioctl(fd, USB_DEVICE_GET_FDESC, &udf) < 0) {
 614                 err = errno;
 615                 close(fd);
 616                 free(buf);
 617                 return _errno_to_libusb(err);
 618         }
 619         close(fd);
 620
 621         if (dpriv->cdesc)
 622                 free(dpriv->cdesc);
 623         dpriv->cdesc = buf;
 624
 625         return (LIBUSB_SUCCESS);
 626 }
 627
 628 int
 629 _sync_control_transfer(struct usbi_transfer *itransfer)
 630 {
 631         struct libusb_transfer *transfer;
 632         struct libusb_control_setup *setup;
 633         struct device_priv *dpriv;
 634         struct usb_ctl_request req;
 635
 636         transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
 637         dpriv = (struct device_priv *)transfer->dev_handle->dev->os_priv;
 638         setup = (struct libusb_control_setup *)transfer->buffer;
 639
 640         usbi_dbg("type %x request %x value %x index %d length %d timeout %d",
 641             setup->bmRequestType, setup->bRequest,
 642             libusb_le16_to_cpu(setup->wValue),
 643             libusb_le16_to_cpu(setup->wIndex),
 644             libusb_le16_to_cpu(setup->wLength), transfer->timeout);
 645
 646         req.ucr_addr = transfer->dev_handle->dev->device_address;
 647         req.ucr_request.bmRequestType = setup->bmRequestType;
 648         req.ucr_request.bRequest = setup->bRequest;
 649         /* Don't use USETW, libusb already deals with the endianness */
 650         (*(uint16_t *)req.ucr_request.wValue) = setup->wValue;
 651         (*(uint16_t *)req.ucr_request.wIndex) = setup->wIndex;
 652         (*(uint16_t *)req.ucr_request.wLength) = setup->wLength;
 653         req.ucr_data = transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
 654
 655         if ((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
 656                 req.ucr_flags = USBD_SHORT_XFER_OK;
 657
 658         if (dpriv->devname == NULL) {
 659                 /*
 660                  * XXX If the device is not attached to ugen(4) it is
 661                  * XXX still possible to submit a control transfer but
 662                  * XXX with the default timeout only.
 663                  */
 664                 int fd, err;
 665
 666                 if ((fd = _bus_open(transfer->dev_handle->dev->bus_number)) < 0)
 667                         return _errno_to_libusb(errno);
 668
 669                 if ((ioctl(fd, USB_REQUEST, &req)) < 0) {
 670                         err = errno;
 671                         close(fd);
 672                         return _errno_to_libusb(err);
 673                 }
 674                 close(fd);
 675         } else {
 676                 if ((ioctl(dpriv->fd, USB_SET_TIMEOUT, &transfer->timeout)) < 0)
 677                         return _errno_to_libusb(errno);
 678
 679                 if ((ioctl(dpriv->fd, USB_DO_REQUEST, &req)) < 0)
 680                         return _errno_to_libusb(errno);
 681         }
 682
 683         itransfer->transferred = req.ucr_actlen;
 684
 685         usbi_dbg("transferred %d", itransfer->transferred);
 686
 687         return (0);
 688 }
 689
 690 int
 691 _access_endpoint(struct libusb_transfer *transfer)
 692 {
 693         struct handle_priv *hpriv;
 694         struct device_priv *dpriv;
 695         char devnode[16];
 696         int fd, endpt;
 697         mode_t mode;
 698
 699         hpriv = (struct handle_priv *)transfer->dev_handle->os_priv;
 700         dpriv = (struct device_priv *)transfer->dev_handle->dev->os_priv;
 701
 702         endpt = UE_GET_ADDR(transfer->endpoint);
 703         mode = IS_XFERIN(transfer) ? O_RDONLY : O_WRONLY;
 704
 705         usbi_dbg("endpoint %d mode %d", endpt, mode);
 706
 707         if (hpriv->endpoints[endpt] < 0) {
 708                 /* Pick the right endpoint node */
 709                 snprintf(devnode, sizeof(devnode), DEVPATH "%s.%02d",
 710                     dpriv->devname, endpt);
 711
 712                 /* We may need to read/write to the same endpoint later. */
 713                 if (((fd = open(devnode, O_RDWR)) < 0) && (errno == ENXIO))
 714                         if ((fd = open(devnode, mode)) < 0)
 715                                 return (-1);
 716
 717                 hpriv->endpoints[endpt] = fd;
 718         }
 719
 720         return (hpriv->endpoints[endpt]);
 721 }
 722
 723 int
 724 _sync_gen_transfer(struct usbi_transfer *itransfer)
 725 {
 726         struct libusb_transfer *transfer;
 727         struct device_priv *dpriv;
 728         int fd, nr = 1;
 729
 730         transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
 731         dpriv = (struct device_priv *)transfer->dev_handle->dev->os_priv;
 732
 733         if (dpriv->devname == NULL)
 734                 return (LIBUSB_ERROR_NOT_SUPPORTED);
 735
 736         /*
 737          * Bulk, Interrupt or Isochronous transfer depends on the
 738          * endpoint and thus the node to open.
 739          */
 740         if ((fd = _access_endpoint(transfer)) < 0)
 741                 return _errno_to_libusb(errno);
 742
 743         if ((ioctl(fd, USB_SET_TIMEOUT, &transfer->timeout)) < 0)
 744                 return _errno_to_libusb(errno);
 745
 746         if (IS_XFERIN(transfer)) {
 747                 if ((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
 748                         if ((ioctl(fd, USB_SET_SHORT_XFER, &nr)) < 0)
 749                                 return _errno_to_libusb(errno);
 750
 751                 nr = read(fd, transfer->buffer, transfer->length);
 752         } else {
 753                 nr = write(fd, transfer->buffer, transfer->length);
 754         }
 755
 756         if (nr < 0)
 757                 return _errno_to_libusb(errno);
 758
 759         itransfer->transferred = nr;
 760
 761         return (0);
 762 }
 763
 764 int
 765 _bus_open(int number)
 766 {
 767         char busnode[16];
 768
 769         snprintf(busnode, sizeof(busnode), USBDEV "%d", number);
 770
 771         return open(busnode, O_RDWR);
 772 }