app/src/main/jni/libusb-1.0.22/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 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 device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
 275
 276         if (dpriv->devname) {
 277                 usbi_dbg("close: fd %d", dpriv->fd);
 278
 279                 close(dpriv->fd);
 280                 dpriv->fd = -1;
 281         }
 282 }
 283
 284 int
 285 obsd_get_device_descriptor(struct libusb_device *dev, unsigned char *buf,
 286     int *host_endian)
 287 {
 288         struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
 289
 290         usbi_dbg("");
 291
 292         memcpy(buf, &dpriv->ddesc, DEVICE_DESC_LENGTH);
 293
 294         *host_endian = 0;
 295
 296         return (LIBUSB_SUCCESS);
 297 }
 298
 299 int
 300 obsd_get_active_config_descriptor(struct libusb_device *dev,
 301     unsigned char *buf, size_t len, int *host_endian)
 302 {
 303         struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
 304         usb_config_descriptor_t *ucd = (usb_config_descriptor_t *)dpriv->cdesc;
 305
 306         len = MIN(len, UGETW(ucd->wTotalLength));
 307
 308         usbi_dbg("len %d", len);
 309
 310         memcpy(buf, dpriv->cdesc, len);
 311
 312         *host_endian = 0;
 313
 314         return (len);
 315 }
 316
 317 int
 318 obsd_get_config_descriptor(struct libusb_device *dev, uint8_t idx,
 319     unsigned char *buf, size_t len, int *host_endian)
 320 {
 321         struct usb_device_fdesc udf;
 322         int fd, err;
 323
 324         if ((fd = _bus_open(dev->bus_number)) < 0)
 325                 return _errno_to_libusb(errno);
 326
 327         udf.udf_bus = dev->bus_number;
 328         udf.udf_addr = dev->device_address;
 329         udf.udf_config_index = idx;
 330         udf.udf_size = len;
 331         udf.udf_data = buf;
 332
 333         usbi_dbg("index %d, len %d", udf.udf_config_index, len);
 334
 335         if (ioctl(fd, USB_DEVICE_GET_FDESC, &udf) < 0) {
 336                 err = errno;
 337                 close(fd);
 338                 return _errno_to_libusb(err);
 339         }
 340         close(fd);
 341
 342         *host_endian = 0;
 343
 344         return (len);
 345 }
 346
 347 int
 348 obsd_get_configuration(struct libusb_device_handle *handle, int *config)
 349 {
 350         struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
 351         usb_config_descriptor_t *ucd = (usb_config_descriptor_t *)dpriv->cdesc;
 352
 353         *config = ucd->bConfigurationValue;
 354
 355         usbi_dbg("bConfigurationValue %d", *config);
 356
 357         return (LIBUSB_SUCCESS);
 358 }
 359
 360 int
 361 obsd_set_configuration(struct libusb_device_handle *handle, int config)
 362 {
 363         struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
 364
 365         if (dpriv->devname == NULL)
 366                 return (LIBUSB_ERROR_NOT_SUPPORTED);
 367
 368         usbi_dbg("bConfigurationValue %d", config);
 369
 370         if (ioctl(dpriv->fd, USB_SET_CONFIG, &config) < 0)
 371                 return _errno_to_libusb(errno);
 372
 373         return _cache_active_config_descriptor(handle->dev);
 374 }
 375
 376 int
 377 obsd_claim_interface(struct libusb_device_handle *handle, int iface)
 378 {
 379         struct handle_priv *hpriv = (struct handle_priv *)handle->os_priv;
 380         int i;
 381
 382         for (i = 0; i < USB_MAX_ENDPOINTS; i++)
 383                 hpriv->endpoints[i] = -1;
 384
 385         return (LIBUSB_SUCCESS);
 386 }
 387
 388 int
 389 obsd_release_interface(struct libusb_device_handle *handle, int iface)
 390 {
 391         struct handle_priv *hpriv = (struct handle_priv *)handle->os_priv;
 392         int i;
 393
 394         for (i = 0; i < USB_MAX_ENDPOINTS; i++)
 395                 if (hpriv->endpoints[i] >= 0)
 396                         close(hpriv->endpoints[i]);
 397
 398         return (LIBUSB_SUCCESS);
 399 }
 400
 401 int
 402 obsd_set_interface_altsetting(struct libusb_device_handle *handle, int iface,
 403     int altsetting)
 404 {
 405         struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
 406         struct usb_alt_interface intf;
 407
 408         if (dpriv->devname == NULL)
 409                 return (LIBUSB_ERROR_NOT_SUPPORTED);
 410
 411         usbi_dbg("iface %d, setting %d", iface, altsetting);
 412
 413         memset(&intf, 0, sizeof(intf));
 414
 415         intf.uai_interface_index = iface;
 416         intf.uai_alt_no = altsetting;
 417
 418         if (ioctl(dpriv->fd, USB_SET_ALTINTERFACE, &intf) < 0)
 419                 return _errno_to_libusb(errno);
 420
 421         return (LIBUSB_SUCCESS);
 422 }
 423
 424 int
 425 obsd_clear_halt(struct libusb_device_handle *handle, unsigned char endpoint)
 426 {
 427         struct usb_ctl_request req;
 428         int fd, err;
 429
 430         if ((fd = _bus_open(handle->dev->bus_number)) < 0)
 431                 return _errno_to_libusb(errno);
 432
 433         usbi_dbg("");
 434
 435         req.ucr_addr = handle->dev->device_address;
 436         req.ucr_request.bmRequestType = UT_WRITE_ENDPOINT;
 437         req.ucr_request.bRequest = UR_CLEAR_FEATURE;
 438         USETW(req.ucr_request.wValue, UF_ENDPOINT_HALT);
 439         USETW(req.ucr_request.wIndex, endpoint);
 440         USETW(req.ucr_request.wLength, 0);
 441
 442         if (ioctl(fd, USB_REQUEST, &req) < 0) {
 443                 err = errno;
 444                 close(fd);
 445                 return _errno_to_libusb(err);
 446         }
 447         close(fd);
 448
 449         return (LIBUSB_SUCCESS);
 450 }
 451
 452 int
 453 obsd_reset_device(struct libusb_device_handle *handle)
 454 {
 455         usbi_dbg("");
 456
 457         return (LIBUSB_ERROR_NOT_SUPPORTED);
 458 }
 459
 460 void
 461 obsd_destroy_device(struct libusb_device *dev)
 462 {
 463         struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
 464
 465         usbi_dbg("");
 466
 467         free(dpriv->cdesc);
 468         free(dpriv->devname);
 469 }
 470
 471 int
 472 obsd_submit_transfer(struct usbi_transfer *itransfer)
 473 {
 474         struct libusb_transfer *transfer;
 475         struct handle_priv *hpriv;
 476         int err = 0;
 477
 478         usbi_dbg("");
 479
 480         transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
 481         hpriv = (struct handle_priv *)transfer->dev_handle->os_priv;
 482
 483         switch (transfer->type) {
 484         case LIBUSB_TRANSFER_TYPE_CONTROL:
 485                 err = _sync_control_transfer(itransfer);
 486                 break;
 487         case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
 488                 if (IS_XFEROUT(transfer)) {
 489                         /* Isochronous write is not supported */
 490                         err = LIBUSB_ERROR_NOT_SUPPORTED;
 491                         break;
 492                 }
 493                 err = _sync_gen_transfer(itransfer);
 494                 break;
 495         case LIBUSB_TRANSFER_TYPE_BULK:
 496         case LIBUSB_TRANSFER_TYPE_INTERRUPT:
 497                 if (IS_XFEROUT(transfer) &&
 498                     transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET) {
 499                         err = LIBUSB_ERROR_NOT_SUPPORTED;
 500                         break;
 501                 }
 502                 err = _sync_gen_transfer(itransfer);
 503                 break;
 504         case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
 505                 err = LIBUSB_ERROR_NOT_SUPPORTED;
 506                 break;
 507         }
 508
 509         if (err)
 510                 return (err);
 511
 512         usbi_signal_transfer_completion(itransfer);
 513
 514         return (LIBUSB_SUCCESS);
 515 }
 516
 517 int
 518 obsd_cancel_transfer(struct usbi_transfer *itransfer)
 519 {
 520         usbi_dbg("");
 521
 522         return (LIBUSB_ERROR_NOT_SUPPORTED);
 523 }
 524
 525 void
 526 obsd_clear_transfer_priv(struct usbi_transfer *itransfer)
 527 {
 528         usbi_dbg("");
 529
 530         /* Nothing to do */
 531 }
 532
 533 int
 534 obsd_handle_transfer_completion(struct usbi_transfer *itransfer)
 535 {
 536         return usbi_handle_transfer_completion(itransfer, LIBUSB_TRANSFER_COMPLETED);
 537 }
 538
 539 int
 540 obsd_clock_gettime(int clkid, struct timespec *tp)
 541 {
 542         usbi_dbg("clock %d", clkid);
 543
 544         if (clkid == USBI_CLOCK_REALTIME)
 545                 return clock_gettime(CLOCK_REALTIME, tp);
 546
 547         if (clkid == USBI_CLOCK_MONOTONIC)
 548                 return clock_gettime(CLOCK_MONOTONIC, tp);
 549
 550         return (LIBUSB_ERROR_INVALID_PARAM);
 551 }
 552
 553 int
 554 _errno_to_libusb(int err)
 555 {
 556         usbi_dbg("error: %s (%d)", strerror(err), err);
 557
 558         switch (err) {
 559         case EIO:
 560                 return (LIBUSB_ERROR_IO);
 561         case EACCES:
 562                 return (LIBUSB_ERROR_ACCESS);
 563         case ENOENT:
 564                 return (LIBUSB_ERROR_NO_DEVICE);
 565         case ENOMEM:
 566                 return (LIBUSB_ERROR_NO_MEM);
 567         case ETIMEDOUT:
 568                 return (LIBUSB_ERROR_TIMEOUT);
 569         }
 570
 571         return (LIBUSB_ERROR_OTHER);
 572 }
 573
 574 int
 575 _cache_active_config_descriptor(struct libusb_device *dev)
 576 {
 577         struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
 578         struct usb_device_cdesc udc;
 579         struct usb_device_fdesc udf;
 580         unsigned char* buf;
 581         int fd, len, err;
 582
 583         if ((fd = _bus_open(dev->bus_number)) < 0)
 584                 return _errno_to_libusb(errno);
 585
 586         usbi_dbg("fd %d, addr %d", fd, dev->device_address);
 587
 588         udc.udc_bus = dev->bus_number;
 589         udc.udc_addr = dev->device_address;
 590         udc.udc_config_index = USB_CURRENT_CONFIG_INDEX;
 591         if (ioctl(fd, USB_DEVICE_GET_CDESC, &udc) < 0) {
 592                 err = errno;
 593                 close(fd);
 594                 return _errno_to_libusb(errno);
 595         }
 596
 597         usbi_dbg("active bLength %d", udc.udc_desc.bLength);
 598
 599         len = UGETW(udc.udc_desc.wTotalLength);
 600         buf = malloc(len);
 601         if (buf == NULL)
 602                 return (LIBUSB_ERROR_NO_MEM);
 603
 604         udf.udf_bus = dev->bus_number;
 605         udf.udf_addr = dev->device_address;
 606         udf.udf_config_index = udc.udc_config_index;
 607         udf.udf_size = len;
 608         udf.udf_data = buf;
 609
 610         usbi_dbg("index %d, len %d", udf.udf_config_index, len);
 611
 612         if (ioctl(fd, USB_DEVICE_GET_FDESC, &udf) < 0) {
 613                 err = errno;
 614                 close(fd);
 615                 free(buf);
 616                 return _errno_to_libusb(err);
 617         }
 618         close(fd);
 619
 620         if (dpriv->cdesc)
 621                 free(dpriv->cdesc);
 622         dpriv->cdesc = buf;
 623
 624         return (LIBUSB_SUCCESS);
 625 }
 626
 627 int
 628 _sync_control_transfer(struct usbi_transfer *itransfer)
 629 {
 630         struct libusb_transfer *transfer;
 631         struct libusb_control_setup *setup;
 632         struct device_priv *dpriv;
 633         struct usb_ctl_request req;
 634
 635         transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
 636         dpriv = (struct device_priv *)transfer->dev_handle->dev->os_priv;
 637         setup = (struct libusb_control_setup *)transfer->buffer;
 638
 639         usbi_dbg("type %x request %x value %x index %d length %d timeout %d",
 640             setup->bmRequestType, setup->bRequest,
 641             libusb_le16_to_cpu(setup->wValue),
 642             libusb_le16_to_cpu(setup->wIndex),
 643             libusb_le16_to_cpu(setup->wLength), transfer->timeout);
 644
 645         req.ucr_addr = transfer->dev_handle->dev->device_address;
 646         req.ucr_request.bmRequestType = setup->bmRequestType;
 647         req.ucr_request.bRequest = setup->bRequest;
 648         /* Don't use USETW, libusb already deals with the endianness */
 649         (*(uint16_t *)req.ucr_request.wValue) = setup->wValue;
 650         (*(uint16_t *)req.ucr_request.wIndex) = setup->wIndex;
 651         (*(uint16_t *)req.ucr_request.wLength) = setup->wLength;
 652         req.ucr_data = transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
 653
 654         if ((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
 655                 req.ucr_flags = USBD_SHORT_XFER_OK;
 656
 657         if (dpriv->devname == NULL) {
 658                 /*
 659                  * XXX If the device is not attached to ugen(4) it is
 660                  * XXX still possible to submit a control transfer but
 661                  * XXX with the default timeout only.
 662                  */
 663                 int fd, err;
 664
 665                 if ((fd = _bus_open(transfer->dev_handle->dev->bus_number)) < 0)
 666                         return _errno_to_libusb(errno);
 667
 668                 if ((ioctl(fd, USB_REQUEST, &req)) < 0) {
 669                         err = errno;
 670                         close(fd);
 671                         return _errno_to_libusb(err);
 672                 }
 673                 close(fd);
 674         } else {
 675                 if ((ioctl(dpriv->fd, USB_SET_TIMEOUT, &transfer->timeout)) < 0)
 676                         return _errno_to_libusb(errno);
 677
 678                 if ((ioctl(dpriv->fd, USB_DO_REQUEST, &req)) < 0)
 679                         return _errno_to_libusb(errno);
 680         }
 681
 682         itransfer->transferred = req.ucr_actlen;
 683
 684         usbi_dbg("transferred %d", itransfer->transferred);
 685
 686         return (0);
 687 }
 688
 689 int
 690 _access_endpoint(struct libusb_transfer *transfer)
 691 {
 692         struct handle_priv *hpriv;
 693         struct device_priv *dpriv;
 694         char devnode[16];
 695         int fd, endpt;
 696         mode_t mode;
 697
 698         hpriv = (struct handle_priv *)transfer->dev_handle->os_priv;
 699         dpriv = (struct device_priv *)transfer->dev_handle->dev->os_priv;
 700
 701         endpt = UE_GET_ADDR(transfer->endpoint);
 702         mode = IS_XFERIN(transfer) ? O_RDONLY : O_WRONLY;
 703
 704         usbi_dbg("endpoint %d mode %d", endpt, mode);
 705
 706         if (hpriv->endpoints[endpt] < 0) {
 707                 /* Pick the right endpoint node */
 708                 snprintf(devnode, sizeof(devnode), DEVPATH "%s.%02d",
 709                     dpriv->devname, endpt);
 710
 711                 /* We may need to read/write to the same endpoint later. */
 712                 if (((fd = open(devnode, O_RDWR)) < 0) && (errno == ENXIO))
 713                         if ((fd = open(devnode, mode)) < 0)
 714                                 return (-1);
 715
 716                 hpriv->endpoints[endpt] = fd;
 717         }
 718
 719         return (hpriv->endpoints[endpt]);
 720 }
 721
 722 int
 723 _sync_gen_transfer(struct usbi_transfer *itransfer)
 724 {
 725         struct libusb_transfer *transfer;
 726         struct device_priv *dpriv;
 727         int fd, nr = 1;
 728
 729         transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
 730         dpriv = (struct device_priv *)transfer->dev_handle->dev->os_priv;
 731
 732         if (dpriv->devname == NULL)
 733                 return (LIBUSB_ERROR_NOT_SUPPORTED);
 734
 735         /*
 736          * Bulk, Interrupt or Isochronous transfer depends on the
 737          * endpoint and thus the node to open.
 738          */
 739         if ((fd = _access_endpoint(transfer)) < 0)
 740                 return _errno_to_libusb(errno);
 741
 742         if ((ioctl(fd, USB_SET_TIMEOUT, &transfer->timeout)) < 0)
 743                 return _errno_to_libusb(errno);
 744
 745         if (IS_XFERIN(transfer)) {
 746                 if ((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
 747                         if ((ioctl(fd, USB_SET_SHORT_XFER, &nr)) < 0)
 748                                 return _errno_to_libusb(errno);
 749
 750                 nr = read(fd, transfer->buffer, transfer->length);
 751         } else {
 752                 nr = write(fd, transfer->buffer, transfer->length);
 753         }
 754
 755         if (nr < 0)
 756                 return _errno_to_libusb(errno);
 757
 758         itransfer->transferred = nr;
 759
 760         return (0);
 761 }
 762
 763 int
 764 _bus_open(int number)
 765 {
 766         char busnode[16];
 767
 768         snprintf(busnode, sizeof(busnode), USBDEV "%d", number);
 769
 770         return open(busnode, O_RDWR);
 771 }