libjaylink/transport_usb.c

   1 /*
   2  * This file is part of the libjaylink project.
   3  *
   4  * Copyright (C) 2014-2016 Marc Schink <jaylink-dev@marcschink.de>
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <stdlib.h>
  21 #include <stddef.h>
  22 #include <stdint.h>
  23 #include <string.h>
  24
  25 #include "libjaylink.h"
  26 #include "libjaylink-internal.h"
  27
  28 /**
  29  * @file
  30  *
  31  * Transport abstraction layer (USB).
  32  */
  33
  34 /** Timeout of an USB transfer in milliseconds. */
  35 #define USB_TIMEOUT     1000
  36
  37 /**
  38  * Number of consecutive timeouts before an USB transfer will be treated as
  39  * timed out.
  40  */
  41 #define NUM_TIMEOUTS    2
  42
  43 /** Chunk size in bytes in which data is transferred. */
  44 #define CHUNK_SIZE      2048
  45
  46 static int initialize_handle(struct jaylink_device_handle *devh)
  47 {
  48         int ret;
  49         struct jaylink_context *ctx;
  50         struct libusb_config_descriptor *config;
  51         const struct libusb_interface *interface;
  52         const struct libusb_interface_descriptor *desc;
  53         const struct libusb_endpoint_descriptor *epdesc;
  54         bool found_interface;
  55         bool found_endpoint_in;
  56         bool found_endpoint_out;
  57         uint8_t i;
  58
  59         ctx = devh->dev->ctx;
  60         devh->interface_number = 0;
  61
  62         /*
  63          * Retrieve active configuration descriptor to determine the endpoints
  64          * for the interface number of the device.
  65          */
  66         ret = libusb_get_active_config_descriptor(devh->dev->usb_dev, &config);
  67
  68         if (ret != LIBUSB_SUCCESS) {
  69                 log_err(ctx, "Failed to get configuration descriptor: %s.",
  70                         libusb_error_name(ret));
  71                 return JAYLINK_ERR;
  72         }
  73
  74         found_interface = false;
  75
  76         for (i = 0; i < config->bNumInterfaces; i++) {
  77                 interface = &config->interface[i];
  78                 desc = &interface->altsetting[0];
  79
  80                 if (desc->bInterfaceClass != LIBUSB_CLASS_VENDOR_SPEC)
  81                         continue;
  82
  83                 if (desc->bInterfaceSubClass != LIBUSB_CLASS_VENDOR_SPEC)
  84                         continue;
  85
  86                 if (desc->bNumEndpoints < 2)
  87                         continue;
  88
  89                 found_interface = true;
  90                 devh->interface_number = i;
  91                 break;
  92         }
  93
  94         if (!found_interface) {
  95                 log_err(ctx, "No suitable interface found.");
  96                 libusb_free_config_descriptor(config);
  97                 return JAYLINK_ERR;
  98         }
  99
 100         found_endpoint_in = false;
 101         found_endpoint_out = false;
 102
 103         for (i = 0; i < desc->bNumEndpoints; i++) {
 104                 epdesc = &desc->endpoint[i];
 105
 106                 if (epdesc->bEndpointAddress & LIBUSB_ENDPOINT_IN) {
 107                         devh->endpoint_in = epdesc->bEndpointAddress;
 108                         found_endpoint_in = true;
 109                 } else {
 110                         devh->endpoint_out = epdesc->bEndpointAddress;
 111                         found_endpoint_out = true;
 112                 }
 113         }
 114
 115         libusb_free_config_descriptor(config);
 116
 117         if (!found_endpoint_in) {
 118                 log_err(ctx, "Interface IN endpoint not found.");
 119                 return JAYLINK_ERR;
 120         }
 121
 122         if (!found_endpoint_out) {
 123                 log_err(ctx, "Interface OUT endpoint not found.");
 124                 return JAYLINK_ERR;
 125         }
 126
 127         log_dbg(ctx, "Using endpoint %02x (IN) and %02x (OUT).",
 128                 devh->endpoint_in, devh->endpoint_out);
 129
 130         /* Buffer size must be a multiple of CHUNK_SIZE bytes. */
 131         devh->buffer_size = CHUNK_SIZE;
 132         devh->buffer = malloc(devh->buffer_size);
 133
 134         if (!devh->buffer) {
 135                 log_err(ctx, "Transport buffer malloc failed.");
 136                 return JAYLINK_ERR_MALLOC;
 137         }
 138
 139         devh->read_length = 0;
 140         devh->bytes_available = 0;
 141         devh->read_pos = 0;
 142
 143         devh->write_length = 0;
 144         devh->write_pos = 0;
 145
 146         return JAYLINK_OK;
 147 }
 148
 149 static void cleanup_handle(struct jaylink_device_handle *devh)
 150 {
 151         free(devh->buffer);
 152 }
 153
 154 JAYLINK_PRIV int transport_usb_open(struct jaylink_device_handle *devh)
 155 {
 156         int ret;
 157         struct jaylink_device *dev;
 158         struct jaylink_context *ctx;
 159         struct libusb_device_handle *usb_devh;
 160
 161         dev = devh->dev;
 162         ctx = dev->ctx;
 163
 164         log_dbg(ctx, "Trying to open device (bus:address = %03u:%03u).",
 165                 libusb_get_bus_number(dev->usb_dev),
 166                 libusb_get_device_address(dev->usb_dev));
 167
 168         ret = initialize_handle(devh);
 169
 170         if (ret != JAYLINK_OK) {
 171                 log_err(ctx, "Initialize device handle failed.");
 172                 return ret;
 173         }
 174
 175         ret = libusb_open(dev->usb_dev, &usb_devh);
 176
 177         if (ret != LIBUSB_SUCCESS) {
 178                 log_err(ctx, "Failed to open device: %s.",
 179                         libusb_error_name(ret));
 180                 cleanup_handle(devh);
 181                 return JAYLINK_ERR;
 182         }
 183
 184         ret = libusb_claim_interface(usb_devh, devh->interface_number);
 185
 186         if (ret != LIBUSB_SUCCESS) {
 187                 log_err(ctx, "Failed to claim interface: %s.",
 188                         libusb_error_name(ret));
 189                 cleanup_handle(devh);
 190                 libusb_close(usb_devh);
 191                 return JAYLINK_ERR;
 192         }
 193
 194         log_dbg(ctx, "Device opened successfully.");
 195
 196         devh->usb_devh = usb_devh;
 197
 198         return JAYLINK_OK;
 199 }
 200
 201 JAYLINK_PRIV int transport_usb_close(struct jaylink_device_handle *devh)
 202 {
 203         int ret;
 204         struct jaylink_device *dev;
 205         struct jaylink_context *ctx;
 206
 207         dev = devh->dev;
 208         ctx = dev->ctx;
 209
 210         log_dbg(ctx, "Closing device (bus:address = %03u:%03u).",
 211                 libusb_get_bus_number(dev->usb_dev),
 212                 libusb_get_device_address(dev->usb_dev));
 213
 214         ret = libusb_release_interface(devh->usb_devh, devh->interface_number);
 215
 216         libusb_close(devh->usb_devh);
 217         cleanup_handle(devh);
 218
 219         if (ret != LIBUSB_SUCCESS) {
 220                 log_err(ctx, "Failed to release interface: %s.",
 221                         libusb_error_name(ret));
 222                 return JAYLINK_ERR;
 223         }
 224
 225         log_dbg(ctx, "Device closed successfully.");
 226
 227         return JAYLINK_OK;
 228 }
 229
 230 JAYLINK_PRIV int transport_usb_start_write(struct jaylink_device_handle *devh,
 231                 size_t length, bool has_command)
 232 {
 233         struct jaylink_context *ctx;
 234
 235         (void)has_command;
 236
 237         if (!length)
 238                 return JAYLINK_ERR_ARG;
 239
 240         ctx = devh->dev->ctx;
 241
 242         log_dbg(ctx, "Starting write operation (length = %zu bytes).", length);
 243
 244         if (devh->write_pos > 0)
 245                 log_warn(ctx, "Last write operation left %zu bytes in the "
 246                         "buffer.", devh->write_pos);
 247
 248         if (devh->write_length > 0)
 249                 log_warn(ctx, "Last write operation was not performed.");
 250
 251         devh->write_length = length;
 252         devh->write_pos = 0;
 253
 254         return JAYLINK_OK;
 255 }
 256
 257 JAYLINK_PRIV int transport_usb_start_read(struct jaylink_device_handle *devh,
 258                 size_t length)
 259 {
 260         struct jaylink_context *ctx;
 261
 262         if (!length)
 263                 return JAYLINK_ERR_ARG;
 264
 265         ctx = devh->dev->ctx;
 266
 267         log_dbg(ctx, "Starting read operation (length = %zu bytes).", length);
 268
 269         if (devh->bytes_available > 0)
 270                 log_dbg(ctx, "Last read operation left %zu bytes in the "
 271                         "buffer.", devh->bytes_available);
 272
 273         if (devh->read_length > 0)
 274                 log_warn(ctx, "Last read operation left %zu bytes.",
 275                         devh->read_length);
 276
 277         devh->read_length = length;
 278
 279         return JAYLINK_OK;
 280 }
 281
 282 JAYLINK_PRIV int transport_usb_start_write_read(
 283                 struct jaylink_device_handle *devh, size_t write_length,
 284                 size_t read_length, bool has_command)
 285 {
 286         struct jaylink_context *ctx;
 287
 288         (void)has_command;
 289
 290         if (!read_length || !write_length)
 291                 return JAYLINK_ERR_ARG;
 292
 293         ctx = devh->dev->ctx;
 294
 295         log_dbg(ctx, "Starting write / read operation (length = "
 296                 "%zu / %zu bytes).", write_length, read_length);
 297
 298         if (devh->write_pos > 0)
 299                 log_warn(ctx, "Last write operation left %zu bytes in the "
 300                         "buffer.", devh->write_pos);
 301
 302         if (devh->write_length > 0)
 303                 log_warn(ctx, "Last write operation was not performed.");
 304
 305         if (devh->bytes_available > 0)
 306                 log_warn(ctx, "Last read operation left %zu bytes in the "
 307                         "buffer.", devh->bytes_available);
 308
 309         if (devh->read_length > 0)
 310                 log_warn(ctx, "Last read operation left %zu bytes.",
 311                         devh->read_length);
 312
 313         devh->write_length = write_length;
 314         devh->write_pos = 0;
 315
 316         devh->read_length = read_length;
 317         devh->bytes_available = 0;
 318         devh->read_pos = 0;
 319
 320         return JAYLINK_OK;
 321 }
 322
 323 static int usb_recv(struct jaylink_device_handle *devh, uint8_t *buffer,
 324                 size_t *length)
 325 {
 326         int ret;
 327         struct jaylink_context *ctx;
 328         unsigned int tries;
 329         int transferred;
 330
 331         ctx = devh->dev->ctx;
 332
 333         tries = NUM_TIMEOUTS;
 334         transferred = 0;
 335
 336         while (tries > 0 && !transferred) {
 337                 /* Always request CHUNK_SIZE bytes from the device. */
 338                 ret = libusb_bulk_transfer(devh->usb_devh, devh->endpoint_in,
 339                         (unsigned char *)buffer, CHUNK_SIZE, &transferred,
 340                         USB_TIMEOUT);
 341
 342                 if (ret == LIBUSB_ERROR_TIMEOUT) {
 343                         log_warn(ctx, "Failed to receive data from "
 344                                 "device: %s.", libusb_error_name(ret));
 345                         tries--;
 346                         continue;
 347                 } else if (ret != LIBUSB_SUCCESS) {
 348                         log_err(ctx, "Failed to receive data from "
 349                                 "device: %s.", libusb_error_name(ret));
 350                         return JAYLINK_ERR;
 351                 }
 352
 353                 log_dbg(ctx, "Received %i bytes from device.", transferred);
 354         }
 355
 356         /* Ignore a possible timeout if at least one byte was received. */
 357         if (transferred > 0) {
 358                 *length = transferred;
 359                 return JAYLINK_OK;
 360         }
 361
 362         log_err(ctx, "Receiving data from device timed out.");
 363
 364         return JAYLINK_ERR_TIMEOUT;
 365 }
 366
 367 static bool adjust_buffer(struct jaylink_device_handle *devh, size_t size)
 368 {
 369         struct jaylink_context *ctx;
 370         size_t num_chunks;
 371         uint8_t *buffer;
 372
 373         ctx = devh->dev->ctx;
 374
 375         /* Adjust buffer size to a multiple of CHUNK_SIZE bytes. */
 376         num_chunks = size / CHUNK_SIZE;
 377
 378         if (size % CHUNK_SIZE > 0)
 379                 num_chunks++;
 380
 381         size = num_chunks * CHUNK_SIZE;
 382         buffer = realloc(devh->buffer, size);
 383
 384         if (!buffer) {
 385                 log_err(ctx, "Failed to adjust buffer size to %zu bytes.",
 386                         size);
 387                 return false;
 388         }
 389
 390         devh->buffer = buffer;
 391         devh->buffer_size = size;
 392
 393         log_dbg(ctx, "Adjusted buffer size to %zu bytes.", size);
 394
 395         return true;
 396 }
 397
 398 static int usb_send(struct jaylink_device_handle *devh, const uint8_t *buffer,
 399                 size_t length)
 400 {
 401         int ret;
 402         struct jaylink_context *ctx;
 403         unsigned int tries;
 404         int transferred;
 405
 406         ctx = devh->dev->ctx;
 407         tries = NUM_TIMEOUTS;
 408
 409         while (tries > 0 && length > 0) {
 410                 /* Send data in chunks of CHUNK_SIZE bytes to the device. */
 411                 ret = libusb_bulk_transfer(devh->usb_devh, devh->endpoint_out,
 412                         (unsigned char *)buffer, MIN(CHUNK_SIZE, length),
 413                         &transferred, USB_TIMEOUT);
 414
 415                 if (ret == LIBUSB_SUCCESS) {
 416                         tries = NUM_TIMEOUTS;
 417                 } else if (ret == LIBUSB_ERROR_TIMEOUT) {
 418                         log_warn(ctx, "Failed to send data to device: %s.",
 419                                 libusb_error_name(ret));
 420                         tries--;
 421                 } else {
 422                         log_err(ctx, "Failed to send data to device: %s.",
 423                                 libusb_error_name(ret));
 424                         return JAYLINK_ERR;
 425                 }
 426
 427                 buffer += transferred;
 428                 length -= transferred;
 429
 430                 log_dbg(ctx, "Sent %i bytes to device.", transferred);
 431         }
 432
 433         if (!length)
 434                 return JAYLINK_OK;
 435
 436         log_err(ctx, "Sending data to device timed out.");
 437
 438         return JAYLINK_ERR_TIMEOUT;
 439 }
 440
 441 JAYLINK_PRIV int transport_usb_write(struct jaylink_device_handle *devh,
 442                 const uint8_t *buffer, size_t length)
 443 {
 444         int ret;
 445         struct jaylink_context *ctx;
 446         size_t num_chunks;
 447         size_t fill_bytes;
 448         size_t tmp;
 449
 450         ctx = devh->dev->ctx;
 451
 452         if (length > devh->write_length) {
 453                 log_err(ctx, "Requested to write %zu bytes but only %zu bytes "
 454                         "are expected for the write operation.", length,
 455                         devh->write_length);
 456                 return JAYLINK_ERR_ARG;
 457         }
 458
 459         /*
 460          * Store data in the buffer if the expected number of bytes for the
 461          * write operation is not reached.
 462          */
 463         if (length < devh->write_length) {
 464                 if (devh->write_pos + length > devh->buffer_size) {
 465                         if (!adjust_buffer(devh, devh->write_pos + length))
 466                                 return JAYLINK_ERR_MALLOC;
 467                 }
 468
 469                 memcpy(devh->buffer + devh->write_pos, buffer, length);
 470
 471                 devh->write_length -= length;
 472                 devh->write_pos += length;
 473
 474                 log_dbg(ctx, "Wrote %zu bytes into buffer.", length);
 475                 return JAYLINK_OK;
 476         }
 477
 478         /*
 479          * Expected number of bytes for this write operation is reached and
 480          * therefore the write operation will be performed.
 481          */
 482         devh->write_length = 0;
 483
 484         /* Send data directly to the device if the buffer is empty. */
 485         if (!devh->write_pos)
 486                 return usb_send(devh, buffer, length);
 487
 488         /*
 489          * Calculate the number of bytes to fill up the buffer to reach a
 490          * multiple of CHUNK_SIZE bytes. This ensures that the data from the
 491          * buffer will be sent to the device in chunks of CHUNK_SIZE bytes.
 492          * Note that this is why the buffer size must be a multiple of
 493          * CHUNK_SIZE bytes.
 494          */
 495         num_chunks = devh->write_pos / CHUNK_SIZE;
 496
 497         if (devh->write_pos % CHUNK_SIZE)
 498                 num_chunks++;
 499
 500         fill_bytes = (num_chunks * CHUNK_SIZE) - devh->write_pos;
 501         tmp = MIN(length, fill_bytes);
 502
 503         if (tmp > 0) {
 504                 memcpy(devh->buffer + devh->write_pos, buffer, tmp);
 505
 506                 length -= tmp;
 507                 buffer += tmp;
 508
 509                 log_dbg(ctx, "Buffer filled up with %zu bytes.", tmp);
 510         }
 511
 512         /* Send buffered data to the device. */
 513         ret = usb_send(devh, devh->buffer, devh->write_pos + tmp);
 514         devh->write_pos = 0;
 515
 516         if (ret != JAYLINK_OK)
 517                 return ret;
 518
 519         if (!length)
 520                 return JAYLINK_OK;
 521
 522         /* Send remaining data to the device. */
 523         return usb_send(devh, buffer, length);
 524 }
 525
 526 JAYLINK_PRIV int transport_usb_read(struct jaylink_device_handle *devh,
 527                 uint8_t *buffer, size_t length)
 528 {
 529         int ret;
 530         struct jaylink_context *ctx;
 531         size_t bytes_received;
 532         size_t tmp;
 533
 534         ctx = devh->dev->ctx;
 535
 536         if (length > devh->read_length) {
 537                 log_err(ctx, "Requested to read %zu bytes but only %zu bytes "
 538                         "are expected for the read operation.", length,
 539                         devh->read_length);
 540                 return JAYLINK_ERR_ARG;
 541         }
 542
 543         if (length <= devh->bytes_available) {
 544                 memcpy(buffer, devh->buffer + devh->read_pos, length);
 545
 546                 devh->read_length -= length;
 547                 devh->bytes_available -= length;
 548                 devh->read_pos += length;
 549
 550                 log_dbg(ctx, "Read %zu bytes from buffer.", length);
 551                 return JAYLINK_OK;
 552         }
 553
 554         if (devh->bytes_available) {
 555                 memcpy(buffer, devh->buffer + devh->read_pos,
 556                         devh->bytes_available);
 557
 558                 buffer += devh->bytes_available;
 559                 length -= devh->bytes_available;
 560                 devh->read_length -= devh->bytes_available;
 561
 562                 log_dbg(ctx, "Read %zu bytes from buffer to flush it.",
 563                         devh->bytes_available);
 564
 565                 devh->bytes_available = 0;
 566                 devh->read_pos = 0;
 567         }
 568
 569         while (length > 0) {
 570                 /*
 571                  * If less than CHUNK_SIZE bytes are requested from the device,
 572                  * store the received data into the internal buffer instead of
 573                  * directly into the user provided buffer. This is necessary to
 574                  * prevent a possible buffer overflow because the number of
 575                  * requested bytes from the device is always CHUNK_SIZE and
 576                  * therefore up to CHUNK_SIZE bytes may be received.
 577                  * Note that this is why the internal buffer size must be at
 578                  * least CHUNK_SIZE bytes.
 579                  */
 580                 if (length < CHUNK_SIZE) {
 581                         ret = usb_recv(devh, devh->buffer, &bytes_received);
 582
 583                         if (ret != JAYLINK_OK)
 584                                 return ret;
 585
 586                         tmp = MIN(bytes_received, length);
 587                         memcpy(buffer, devh->buffer, tmp);
 588
 589                         /*
 590                          * Setup the buffer for the remaining data if more data
 591                          * was received from the device than was requested.
 592                          */
 593                         if (bytes_received > length) {
 594                                 devh->bytes_available = bytes_received - tmp;
 595                                 devh->read_pos = tmp;
 596                         }
 597
 598                         buffer += tmp;
 599                         length -= tmp;
 600                         devh->read_length -= tmp;
 601
 602                         log_dbg(ctx, "Read %zu bytes from buffer.", tmp);
 603                 } else {
 604                         ret = usb_recv(devh, buffer, &bytes_received);
 605
 606                         if (ret != JAYLINK_OK)
 607                                 return ret;
 608
 609                         buffer += bytes_received;
 610                         length -= bytes_received;
 611                         devh->read_length -= bytes_received;
 612
 613                         log_dbg(ctx, "Read %zu bytes from device.",
 614                                 bytes_received);
 615                 }
 616         }
 617
 618         return JAYLINK_OK;
 619 }