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