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