Rename endpoint_type to transfer_type

Matches the USB specs more closely

diff --git a/libusb/io.c b/libusb/io.c
index 9cea4df..b3b2c98 100644 (file)
--- a/libusb/io.c
+++ b/libusb/io.c
@@ -345,9 +345,9 @@ if (r == 0 && actual_length == sizeof(data)) {
  * To perform I/O to an isochronous endpoint, allocate the transfer by calling
  * libusb_alloc_transfer() with an appropriate number of isochronous packets.
  *
- * During filling, set \ref libusb_transfer::endpoint_type "endpoint_type" to
- * \ref libusb_endpoint_type::LIBUSB_ENDPOINT_TYPE_ISOCHRONOUS
- * "LIBUSB_ENDPOINT_TYPE_ISOCHRONOUS", and set
+ * During filling, set \ref libusb_transfer::type "type" to
+ * \ref libusb_transfer_type::LIBUSB_TRANSFER_TYPE_ISOCHRONOUS
+ * "LIBUSB_TRANSFER_TYPE_ISOCHRONOUS", and set
  * \ref libusb_transfer::num_iso_packets "num_iso_packets" to a value less than
  * or equal to the number of packets you requested during allocation.
  * libusb_alloc_transfer() does not set either of these fields for you, given
@@ -656,12 +656,11 @@ static int submit_transfer(struct usbi_transfer *itransfer)
  * The returned transfer is not specially initialized for isochronous I/O;
  * you are still required to set the
  * \ref libusb_transfer::num_iso_packets "num_iso_packets" and
- * \ref libusb_transfer::endpoint_type "endpoint_type" fields accordingly.
+ * \ref libusb_transfer::type "type" fields accordingly.
  *
  * It is safe to allocate a transfer with some isochronous packets and then
  * use it on a non-isochronous endpoint. If you do this, ensure that at time
- * of submission, num_iso_packets is 0 and that endpoint_type is set
- * appropriately.
+ * of submission, num_iso_packets is 0 and that type is set appropriately.
  *
  * \param iso_packets number of isochronous packet descriptors to allocate
  * \returns a newly allocated transfer, or NULL on error
@@ -732,7 +731,7 @@ API_EXPORTED int libusb_submit_transfer(struct libusb_transfer *transfer)
        if (r < 0)
                return r;
 
-       if (transfer->endpoint_type == LIBUSB_ENDPOINT_TYPE_CONTROL) {
+       if (transfer->type == LIBUSB_TRANSFER_TYPE_CONTROL) {
                struct libusb_control_setup *setup =
                        (struct libusb_control_setup *) transfer->buffer;
        
@@ -789,7 +788,7 @@ void usbi_handle_transfer_completion(struct usbi_transfer *itransfer,
        if (status == LIBUSB_TRANSFER_COMPLETED
                        && transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) {
                int rqlen = transfer->length;
-               if (transfer->endpoint_type == LIBUSB_ENDPOINT_TYPE_CONTROL)
+               if (transfer->type == LIBUSB_TRANSFER_TYPE_CONTROL)
                        rqlen -= LIBUSB_CONTROL_SETUP_SIZE;
                if (rqlen != itransfer->transferred) {
                        usbi_dbg("interpreting short transfer as error");

diff --git a/libusb/libusb.h b/libusb/libusb.h
index d1d7894..08d256d 100644 (file)
--- a/libusb/libusb.h
+++ b/libusb/libusb.h
@@ -122,25 +122,24 @@ enum libusb_endpoint_direction {
        LIBUSB_ENDPOINT_OUT = 0x00,
 };
 
-/* FIXME: 9.6.6 calls these "transfer types", not endpoint types. */
-#define LIBUSB_ENDPOINT_TYPE_MASK                      0x03    /* in bmAttributes */
+#define LIBUSB_TRANSFER_TYPE_MASK                      0x03    /* in bmAttributes */
 
 /** \ingroup desc
  * Endpoint transfer type. Values for bits 0:1 of the
  * \ref libusb_endpoint_descriptor::bmAttributes "endpoint attributes" field.
  */
-enum libusb_endpoint_type {
+enum libusb_transfer_type {
        /** Control endpoint */
-       LIBUSB_ENDPOINT_TYPE_CONTROL = 0,
+       LIBUSB_TRANSFER_TYPE_CONTROL = 0,
 
        /** Isochronous endpoint */
-       LIBUSB_ENDPOINT_TYPE_ISOCHRONOUS = 1,
+       LIBUSB_TRANSFER_TYPE_ISOCHRONOUS = 1,
 
        /** Bulk endpoint */
-       LIBUSB_ENDPOINT_TYPE_BULK = 2,
+       LIBUSB_TRANSFER_TYPE_BULK = 2,
 
        /** Interrupt endpoint */
-       LIBUSB_ENDPOINT_TYPE_INTERRUPT = 3,
+       LIBUSB_TRANSFER_TYPE_INTERRUPT = 3,
 };
 
 /** Standard requests, as defined in table 9-3 of the USB2 specifications */
@@ -334,7 +333,7 @@ struct libusb_endpoint_descriptor {
 
        /** Attributes which apply to the endpoint when it is configured using
         * the bConfigurationValue. Bits 0:1 determine the transfer type and
-        * correspond to \ref libusb_endpoint_type. Bits 2:3 are only used for
+        * correspond to \ref libusb_transfer_type. Bits 2:3 are only used for
         * isochronous endpoints and correspond to \ref libusb_iso_sync_type.
         * Bits 4:5 are also only used for isochronous endpoints and correspond to
         * \ref libusb_iso_usage_type. Bits 6:7 are reserved.
@@ -555,8 +554,8 @@ struct libusb_transfer {
        /** Address of the endpoint where this transfer will be sent. */
        unsigned char endpoint;
 
-       /** Type of the endpoint from \ref libusb_endpoint_type */
-       unsigned char endpoint_type;
+       /** Type of the endpoint from \ref libusb_transfer_type */
+       unsigned char type;
 
        /** Timeout for this transfer in millseconds. A value of 0 indicates no
         * timeout. */
@@ -736,7 +735,7 @@ static inline void libusb_fill_control_transfer(
        struct libusb_control_setup *setup = (struct libusb_control_setup *) buffer;
        transfer->dev_handle = dev_handle;
        transfer->endpoint = 0;
-       transfer->endpoint_type = LIBUSB_ENDPOINT_TYPE_CONTROL;
+       transfer->type = LIBUSB_TRANSFER_TYPE_CONTROL;
        transfer->timeout = timeout;
        transfer->buffer = buffer;
        if (setup)
@@ -765,7 +764,7 @@ static inline void libusb_fill_bulk_transfer(struct libusb_transfer *transfer,
 {
        transfer->dev_handle = dev_handle;
        transfer->endpoint = endpoint;
-       transfer->endpoint_type = LIBUSB_ENDPOINT_TYPE_BULK;
+       transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
        transfer->timeout = timeout;
        transfer->buffer = buffer;
        transfer->length = length;
@@ -793,7 +792,7 @@ static inline void libusb_fill_interrupt_transfer(
 {
        transfer->dev_handle = dev_handle;
        transfer->endpoint = endpoint;
-       transfer->endpoint_type = LIBUSB_ENDPOINT_TYPE_INTERRUPT;
+       transfer->type = LIBUSB_TRANSFER_TYPE_INTERRUPT;
        transfer->timeout = timeout;
        transfer->buffer = buffer;
        transfer->length = length;
@@ -822,7 +821,7 @@ static inline void libusb_fill_iso_transfer(struct libusb_transfer *transfer,
 {
        transfer->dev_handle = dev_handle;
        transfer->endpoint = endpoint;
-       transfer->endpoint_type = LIBUSB_ENDPOINT_TYPE_ISOCHRONOUS;
+       transfer->type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS;
        transfer->timeout = timeout;
        transfer->buffer = buffer;
        transfer->length = length;

diff --git a/libusb/os/linux_usbfs.c b/libusb/os/linux_usbfs.c
index 2504fea..8226765 100644 (file)
--- a/libusb/os/linux_usbfs.c
+++ b/libusb/os/linux_usbfs.c
@@ -731,17 +731,17 @@ static int op_submit_transfer(struct usbi_transfer *itransfer)
        struct libusb_transfer *transfer =
                __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
 
-       switch (transfer->endpoint_type) {
-       case LIBUSB_ENDPOINT_TYPE_CONTROL:
+       switch (transfer->type) {
+       case LIBUSB_TRANSFER_TYPE_CONTROL:
                return submit_control_transfer(itransfer);
-       case LIBUSB_ENDPOINT_TYPE_BULK:
+       case LIBUSB_TRANSFER_TYPE_BULK:
                return submit_bulk_transfer(itransfer, USBFS_URB_TYPE_BULK);
-       case LIBUSB_ENDPOINT_TYPE_INTERRUPT:
+       case LIBUSB_TRANSFER_TYPE_INTERRUPT:
                return submit_bulk_transfer(itransfer, USBFS_URB_TYPE_INTERRUPT);
-       case LIBUSB_ENDPOINT_TYPE_ISOCHRONOUS:
+       case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
                return submit_iso_transfer(itransfer);
        default:
-               usbi_err("unknown endpoint type %d", transfer->endpoint_type);
+               usbi_err("unknown endpoint type %d", transfer->type);
                return -EINVAL;
        }
 }
@@ -814,18 +814,18 @@ static int op_cancel_transfer(struct usbi_transfer *itransfer)
        struct libusb_transfer *transfer =
                __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
 
-       switch (transfer->endpoint_type) {
-       case LIBUSB_ENDPOINT_TYPE_CONTROL:
+       switch (transfer->type) {
+       case LIBUSB_TRANSFER_TYPE_CONTROL:
                return cancel_control_transfer(itransfer);
-       case LIBUSB_ENDPOINT_TYPE_BULK:
-       case LIBUSB_ENDPOINT_TYPE_INTERRUPT:
+       case LIBUSB_TRANSFER_TYPE_BULK:
+       case LIBUSB_TRANSFER_TYPE_INTERRUPT:
                cancel_bulk_transfer(itransfer);
                return 0;
-       case LIBUSB_ENDPOINT_TYPE_ISOCHRONOUS:
+       case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
                cancel_iso_transfer(itransfer);
                return 0;
        default:
-               usbi_err("unknown endpoint type %d", transfer->endpoint_type);
+               usbi_err("unknown endpoint type %d", transfer->type);
                return -EINVAL;
        }
 }
@@ -1020,16 +1020,16 @@ static int reap_for_handle(struct libusb_device_handle *handle)
        usbi_dbg("urb type=%d status=%d transferred=%d", urb->type, urb->status,
                urb->actual_length);
 
-       switch (transfer->endpoint_type) {
-       case LIBUSB_ENDPOINT_TYPE_ISOCHRONOUS:
+       switch (transfer->type) {
+       case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
                return handle_iso_completion(itransfer, urb);
-       case LIBUSB_ENDPOINT_TYPE_BULK:
-       case LIBUSB_ENDPOINT_TYPE_INTERRUPT:
+       case LIBUSB_TRANSFER_TYPE_BULK:
+       case LIBUSB_TRANSFER_TYPE_INTERRUPT:
                return handle_bulk_completion(itransfer, urb);
-       case LIBUSB_ENDPOINT_TYPE_CONTROL:
+       case LIBUSB_TRANSFER_TYPE_CONTROL:
                return handle_control_completion(itransfer, urb);
        default:
-               usbi_err("unrecognised endpoint type %x", transfer->endpoint_type);
+               usbi_err("unrecognised endpoint type %x", transfer->type);
                return -EINVAL;
        }
 }

diff --git a/libusb/sync.c b/libusb/sync.c
index 3cfd013..dd8e253 100644 (file)
--- a/libusb/sync.c
+++ b/libusb/sync.c
@@ -135,7 +135,7 @@ static void bulk_transfer_cb(struct libusb_transfer *transfer)
 
 static int do_sync_bulk_transfer(struct libusb_device_handle *dev_handle,
        unsigned char endpoint, unsigned char *buffer, int length,
-       int *transferred, unsigned int timeout, unsigned char endpoint_type)
+       int *transferred, unsigned int timeout, unsigned char type)
 {
        struct libusb_transfer *transfer = libusb_alloc_transfer(0);
        int completed = 0;
@@ -146,7 +146,7 @@ static int do_sync_bulk_transfer(struct libusb_device_handle *dev_handle,
 
        libusb_fill_bulk_transfer(transfer, dev_handle, endpoint, buffer, length,
                bulk_transfer_cb, &completed, timeout);
-       transfer->endpoint_type = endpoint_type;
+       transfer->type = type;
 
        r = libusb_submit_transfer(transfer);
        if (r < 0) {
@@ -224,7 +224,7 @@ API_EXPORTED int libusb_bulk_transfer(struct libusb_device_handle *dev_handle,
        unsigned int timeout)
 {
        return do_sync_bulk_transfer(dev_handle, endpoint, data, length,
-               transferred, timeout, LIBUSB_ENDPOINT_TYPE_BULK);
+               transferred, timeout, LIBUSB_TRANSFER_TYPE_BULK);
 }
 
 /** \ingroup syncio
@@ -269,6 +269,6 @@ API_EXPORTED int libusb_interrupt_transfer(
        unsigned char *data, int length, int *transferred, unsigned int timeout)
 {
        return do_sync_bulk_transfer(dev_handle, endpoint, data, length,
-               transferred, timeout, LIBUSB_ENDPOINT_TYPE_INTERRUPT);
+               transferred, timeout, LIBUSB_TRANSFER_TYPE_INTERRUPT);
 }