// bit 7 : direction

/// Direction device to host

direction_in = 0x80,

/// Direction host to device

direction_out = 0x00,

// bits 6..5 : type

/// Standard request

type_standard = 0x00,

/// Class-specific request

type_class = 0x20,

/// Vendor-defined request

type_vendor = 0x40,

// bits 4..0 : recipient

/// Request for device

recipient_device = 0x00,

/// Request for interface

recipient_interface = 0x01,

/// Request for endpoint

recipient_endpoint = 0x02,

/// Request for other recipient

recipient_other = 0x03

/// Request type

uint8_t bmRequestType;

/// Specific request number

uint8_t bRequest;

/// Value (request specific)

uint16_t wValue;

/// Index (request specific)

uint16_t wIndex;

/// Number of bytes to transfer if there is a data stage

uint16_t wLength;

static uint8_t request_type(usb_request_type direction, usb_request_type type, usb_request_type recipient) {

return static_cast<uint8_t>(direction) + static_cast<uint8_t>(type) + static_cast<uint8_t>(recipient);

}

~usb_device();

/// USB vendor ID

int vendor_id() const { return vendor_id_; }

/// USB product ID

int product_id() const { return product_id_; }

/// Manufacturer name

std::string manufacturer() const { return manufacturer_; }

/// Product name

std::string product() const { return product_; }

/// Serial number

std::string serial_number() const { return serial_number_; }

/// Descriptive string including VID, PID, manufacturer, product name and serial number

std::string description() const;

/// List of interfaces

const std::vector<usb_interface>& interfaces() const;

/**

const usb_interface& get_interface(int interface_number) const;

/**

const usb_endpoint& get_endpoint(usb_direction direction, int endpoint_number) const;

/// Opens the device for communication

void open();

/// Closes the device

void close();

/// Indicates if device is open

bool is_open() const;

/**

void claim_interface(int interface_number);

/**

void release_interface(int interface_number);

/**

std::vector<uint8_t> transfer_in(int endpoint_number, int timeout = 0);

/**

void transfer_out(int endpoint_number, const std::vector<uint8_t>& data, int len = -1, int timeout = 0);

/**

void control_transfer(const usb_control_request& request, int timeout = 0);

/**

void control_transfer_out(const usb_control_request& request, const std::vector<uint8_t>& data, int timeout = 0);

/**

std::vector<uint8_t> control_transfer_in(const usb_control_request& request, int timeout = 0);

/**

std::unique_ptr<std::istream> open_input_stream(int endpoint_number);

/**

std::unique_ptr<std::ostream> open_output_stream(int endpoint_number);

usb_device(usb_registry* registry, const char* path, int vendor_id, int product_id);

void set_product_strings(const char* manufacturer, const char* product, const char* serial_number);

const char* path() const { return path_.c_str(); }

int control_transfer_core(const usb_control_request& request, uint8_t* data, int timeout);

void read_descriptor();

usb_interface* get_intf_ptr(int number);

const usb_endpoint* check_endpoint(usb_direction direction, int endpoint_number);

void submit_urb(usbdevfs_urb* urb);

void cancel_urb(usbdevfs_urb* urb);

usb_registry* registry_;

std::string path_;

int fd_;

bool uses_urbs_;

std::set<int> claimed_interfaces_;

std::vector<usb_interface> interfaces_;

int product_id_;

int vendor_id_;

std::string manufacturer_;

std::string product_;

std::string serial_number_;

friend class usb_registry;

friend class usb_istreambuf;

friend class usb_ostreambuf;