USBHost_t36.h

/* USB EHCI Host for Teensy 3.6
 * Copyright 2017 Paul Stoffregen (paul@pjrc.com)
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#ifndef USB_HOST_TEENSY36_
#define USB_HOST_TEENSY36_

#include <stdint.h>
#include <FS.h>

#if !defined(__MK66FX1M0__) && !defined(__IMXRT1052__) && !defined(__IMXRT1062__)
#error "USBHost_t36 only works with Teensy 3.6 or Teensy 4.x.  Please select it in Tools > Boards"
#endif
#include "utility/imxrt_usbhs.h"
#include "utility/msc.h"

// Dear inquisitive reader, USB is a complex protocol defined with
// very specific terminology.  To have any chance of understand this
// source code, you absolutely must have solid knowledge of specific
// USB terms such as host, device, endpoint, pipe, enumeration....
// You really must also have at least a basic knowledge of the
// different USB transfers: control, bulk, interrupt, isochronous.
//
// The USB 2.0 specification explains these in chapter 4 (pages 15
// to 24), and provides more detail in the first part of chapter 5
// (pages 25 to 55).  The USB spec is published for free at
// www.usb.org.  Here is a convenient link to just the main PDF:
//
// https://www.pjrc.com/teensy/beta/usb20.pdf
//
// This is a huge file, but chapter 4 is short and easy to read.
// If you're not familiar with the USB lingo, please do yourself
// a favor by reading at least chapter 4 to get up to speed on the
// meaning of these important USB concepts and terminology.
//
// If you wish to ask questions (which belong on the forum, not
// github issues) or discuss development of this library, you
// ABSOLUTELY MUST know the basic USB terminology from chapter 4.
// Please repect other people's valuable time & effort by making
// your best effort to read chapter 4 before asking USB questions!


// Uncomment this line to see lots of debugging info!
//#define USBHOST_PRINT_DEBUG


// This can let you control where to send the debugging messages
//#define USBHDBGSerial Serial1
#ifndef USBHDBGSerial
#define USBHDBGSerial   Serial
#endif


/************************************************/
/*  Data Types                                  */
/************************************************/

// These 6 types are the key to understanding how this USB Host
// library really works.

// USBHost is a static class controlling the hardware.
// All common USB functionality is implemented here.
class USBHost;

// These 3 structures represent the actual USB entities
// USBHost manipulates.  One Device_t is created for
// each active USB device.  One Pipe_t is create for
// each endpoint.  Transfer_t structures are created
// when any data transfer is added to the EHCI work
// queues, and then returned to the free pool after the
// data transfer completes and the driver has processed
// the results.
typedef struct Device_struct       Device_t;
typedef struct Pipe_struct         Pipe_t;
typedef struct Transfer_struct     Transfer_t;
typedef enum { CLAIM_NO = 0, CLAIM_REPORT, CLAIM_INTERFACE} hidclaim_t;

// All USB device drivers inherit use these classes.
// Drivers build user-visible functionality on top
// of these classes, which receive USB events from
// USBHost.
class USBDriver;
class USBDriverTimer;
class USBHIDInput;

/************************************************/
/*  Added Defines                               */
/************************************************/
// Keyboard special Keys
#define KEYD_UP         0xDA
#define KEYD_DOWN       0xD9
#define KEYD_LEFT       0xD8
#define KEYD_RIGHT      0xD7
#define KEYD_INSERT     0xD1
#define KEYD_DELETE     0xD4
#define KEYD_PAGE_UP    0xD3
#define KEYD_PAGE_DOWN  0xD6
#define KEYD_HOME       0xD2
#define KEYD_END        0xD5
#define KEYD_F1         0xC2
#define KEYD_F2         0xC3
#define KEYD_F3         0xC4
#define KEYD_F4         0xC5
#define KEYD_F5         0xC6
#define KEYD_F6         0xC7
#define KEYD_F7         0xC8
#define KEYD_F8         0xC9
#define KEYD_F9         0xCA
#define KEYD_F10        0xCB
#define KEYD_F11        0xCC
#define KEYD_F12        0xCD


// USBSerial formats - Lets encode format into bits
// Bits: 0-4 - Number of data bits
// Bits: 5-7 - Parity (0=none, 1=odd, 2 = even)
// bits: 8-9 - Stop bits. 0=1, 1=2


#define USBHOST_SERIAL_7E1 0x047
#define USBHOST_SERIAL_7O1 0x027
#define USBHOST_SERIAL_8N1 0x08
#define USBHOST_SERIAL_8N2 0x108
#define USBHOST_SERIAL_8E1 0x048
#define USBHOST_SERIAL_8O1 0x028



/************************************************/
/*  Data Structure Definitions                  */
/************************************************/

// setup_t holds the 8 byte USB SETUP packet data.
// These unions & structs allow convenient access to
// the setup fields.
typedef union {
    struct {
        union {
            struct {
                uint8_t bmRequestType;
                uint8_t bRequest;
            };
            uint16_t wRequestAndType;
        };
        uint16_t wValue;
        uint16_t wIndex;
        uint16_t wLength;
    };
    struct {
        uint32_t word1;
        uint32_t word2;
    };
} setup_t;

typedef struct {
    enum {STRING_BUF_SIZE = 50};
    enum {STR_ID_MAN = 0, STR_ID_PROD, STR_ID_SERIAL, STR_ID_CNT};
    uint8_t iStrings[STR_ID_CNT];   // Index into array for the three indexes
    uint8_t buffer[STRING_BUF_SIZE];
} strbuf_t;

#define DEVICE_STRUCT_STRING_BUF_SIZE 50

// Device_t holds all the information about a USB device
struct Device_struct {
    Pipe_t   *control_pipe;
    Pipe_t   *data_pipes;
    Device_t *next;
    USBDriver *drivers;
    strbuf_t *strbuf;
    uint8_t  speed; // 0=12, 1=1.5, 2=480 Mbit/sec
    uint8_t  address;
    uint8_t  hub_address;
    uint8_t  hub_port;
    uint8_t  enum_state;
    uint8_t  bDeviceClass;
    uint8_t  bDeviceSubClass;
    uint8_t  bDeviceProtocol;
    uint8_t  bmAttributes;
    uint8_t  bMaxPower;
    uint16_t idVendor;
    uint16_t idProduct;
    uint16_t LanguageID;
};

// Pipe_t holes all information about each USB endpoint/pipe
// The first half is an EHCI QH structure for the pipe.
struct Pipe_struct {
    // Queue Head (QH), EHCI page 46-50
    struct {  // must be aligned to 32 byte boundary
        volatile uint32_t horizontal_link;
        volatile uint32_t capabilities[2];
        volatile uint32_t current;
        volatile uint32_t next;
        volatile uint32_t alt_next;
        volatile uint32_t token;
        volatile uint32_t buffer[5];
    } qh;
    Device_t *device;
    uint8_t  type; // 0=control, 1=isochronous, 2=bulk, 3=interrupt
    uint8_t  direction; // 0=out, 1=in (changes for control, others fixed)
    uint8_t  start_mask;
    uint8_t  complete_mask;
    Pipe_t   *next;
    void     (*callback_function)(const Transfer_t *);
    uint16_t periodic_interval;
    uint16_t periodic_offset;
    uint16_t bandwidth_interval;
    uint16_t bandwidth_offset;
    uint16_t bandwidth_shift;
    uint8_t  bandwidth_stime;
    uint8_t  bandwidth_ctime;
    uint32_t unused1;
    uint32_t unused2;
    uint32_t unused3;
    uint32_t unused4;
    uint32_t unused5;
};

// Transfer_t represents a single transaction on the USB bus.
// The first portion is an EHCI qTD structure.  Transfer_t are
// allocated as-needed from a memory pool, loaded with pointers
// to the actual data buffers, linked into a followup list,
// and placed on ECHI Queue Heads.  When the ECHI interrupt
// occurs, the followup lists are used to find the Transfer_t
// in memory.  Callbacks are made, and then the Transfer_t are
// returned to the memory pool.
struct Transfer_struct {
    // Queue Element Transfer Descriptor (qTD), EHCI pg 40-45
    struct {  // must be aligned to 32 byte boundary
        volatile uint32_t next;
        volatile uint32_t alt_next;
        volatile uint32_t token;
        volatile uint32_t buffer[5];
    } qtd;
    // Linked list of queued, not-yet-completed transfers
    Transfer_t *next_followup;
    Transfer_t *prev_followup;
    Pipe_t     *pipe;
    // Data to be used by callback function.  When a group
    // of Transfer_t are created, these fields and the
    // interrupt-on-complete bit in the qTD token are only
    // set in the last Transfer_t of the list.
    void       *buffer;
    uint32_t   length;
    setup_t    setup;
    USBDriver  *driver;
};


/************************************************/
/*  Main USB EHCI Controller                    */
/************************************************/

class USBHost {
public:
    static void begin();
    static void Task();
    static void countFree(uint32_t &devices, uint32_t &pipes, uint32_t &trans, uint32_t &strs);
protected:
    static Pipe_t * new_Pipe(Device_t *dev, uint32_t type, uint32_t endpoint,
                             uint32_t direction, uint32_t maxlen, uint32_t interval = 0);
    static bool queue_Control_Transfer(Device_t *dev, setup_t *setup,
                                       void *buf, USBDriver *driver);
    static bool queue_Data_Transfer(Pipe_t *pipe, void *buffer,
                                    uint32_t len, USBDriver *driver);
    static Device_t * new_Device(uint32_t speed, uint32_t hub_addr, uint32_t hub_port);
    static void disconnect_Device(Device_t *dev);
    static void enumeration(const Transfer_t *transfer);
    static void driver_ready_for_device(USBDriver *driver);
    static volatile bool enumeration_busy;
public: // Maybe others may want/need to contribute memory example HID devices may want to add transfers.
    static void contribute_Devices(Device_t *devices, uint32_t num);
    static void contribute_Pipes(Pipe_t *pipes, uint32_t num);
    static void contribute_Transfers(Transfer_t *transfers, uint32_t num);
    static void contribute_String_Buffers(strbuf_t *strbuf, uint32_t num);
private:
    static void isr();
    static void convertStringDescriptorToASCIIString(uint8_t string_index, Device_t *dev, const Transfer_t *transfer);
    static void claim_drivers(Device_t *dev);
    static uint32_t assign_address(void);
    static bool queue_Transfer(Pipe_t *pipe, Transfer_t *transfer);
    static void init_Device_Pipe_Transfer_memory(void);
    static Device_t * allocate_Device(void);
    static void delete_Pipe(Pipe_t *pipe);
    static void free_Device(Device_t *q);
    static Pipe_t * allocate_Pipe(void);
    static void free_Pipe(Pipe_t *q);
    static Transfer_t * allocate_Transfer(void);
    static void free_Transfer(Transfer_t *q);
    static strbuf_t * allocate_string_buffer(void);
    static void free_string_buffer(strbuf_t *strbuf);
    static bool allocate_interrupt_pipe_bandwidth(Pipe_t *pipe,
            uint32_t maxlen, uint32_t interval);
    static void add_qh_to_periodic_schedule(Pipe_t *pipe);
    static bool followup_Transfer(Transfer_t *transfer);
    static void followup_Error(void);
public: // Maybe others may want/need to contribute memory example HID devices may want to add transfers.
#ifdef USBHOST_PRINT_DEBUG
    static void print_(const Transfer_t *transfer);
    static void print_(const Transfer_t *first, const Transfer_t *last);
    static void print_token(uint32_t token);
    static void print_(const Pipe_t *pipe);
    static void print_driverlist(const char *name, const USBDriver *driver);
    static void print_qh_list(const Pipe_t *list);
    static void print_device_descriptor(const uint8_t *p);
    static void print_config_descriptor(const uint8_t *p, uint32_t maxlen);
    static void print_string_descriptor(const char *name, const uint8_t *p);
    static void print_hexbytes(const void *ptr, uint32_t len);
    static void print_(const char *s)   { USBHDBGSerial.print(s); }
    static void print_(int n)       { USBHDBGSerial.print(n); }
    static void print_(unsigned int n)  { USBHDBGSerial.print(n); }
    static void print_(long n)      { USBHDBGSerial.print(n); }
    static void print_(unsigned long n) { USBHDBGSerial.print(n); }
    static void println_(const char *s) { USBHDBGSerial.println(s); }
    static void println_(int n)     { USBHDBGSerial.println(n); }
    static void println_(unsigned int n)    { USBHDBGSerial.println(n); }
    static void println_(long n)        { USBHDBGSerial.println(n); }
    static void println_(unsigned long n)   { USBHDBGSerial.println(n); }
    static void println_()          { USBHDBGSerial.println(); }
    static void print_(uint32_t n, uint8_t b) { USBHDBGSerial.print(n, b); }
    static void println_(uint32_t n, uint8_t b) { USBHDBGSerial.println(n, b); }
    static void print_(const char *s, int n, uint8_t b = DEC) {
        USBHDBGSerial.print(s); USBHDBGSerial.print(n, b);
    }
    static void print_(const char *s, unsigned int n, uint8_t b = DEC) {
        USBHDBGSerial.print(s); USBHDBGSerial.print(n, b);
    }
    static void print_(const char *s, long n, uint8_t b = DEC) {
        USBHDBGSerial.print(s); USBHDBGSerial.print(n, b);
    }
    static void print_(const char *s, unsigned long n, uint8_t b = DEC) {
        USBHDBGSerial.print(s); USBHDBGSerial.print(n, b);
    }
    static void println_(const char *s, int n, uint8_t b = DEC) {
        USBHDBGSerial.print(s); USBHDBGSerial.println(n, b);
    }
    static void println_(const char *s, unsigned int n, uint8_t b = DEC) {
        USBHDBGSerial.print(s); USBHDBGSerial.println(n, b);
    }
    static void println_(const char *s, long n, uint8_t b = DEC) {
        USBHDBGSerial.print(s); USBHDBGSerial.println(n, b);
    }
    static void println_(const char *s, unsigned long n, uint8_t b = DEC) {
        USBHDBGSerial.print(s); USBHDBGSerial.println(n, b);
    }
    friend class USBDriverTimer; // for access to print & println
#else
    static void print_(const Transfer_t *transfer) {}
    static void print_(const Transfer_t *first, const Transfer_t *last) {}
    static void print_token(uint32_t token) {}
    static void print_(const Pipe_t *pipe) {}
    static void print_driverlist(const char *name, const USBDriver *driver) {}
    static void print_qh_list(const Pipe_t *list) {}
    static void print_device_descriptor(const uint8_t *p) {}
    static void print_config_descriptor(const uint8_t *p, uint32_t maxlen) {}
    static void print_string_descriptor(const char *name, const uint8_t *p) {}
    static void print_hexbytes(const void *ptr, uint32_t len) {}
    static void print_(const char *s) {}
    static void print_(int n) {}
    static void print_(unsigned int n) {}
    static void print_(long n) {}
    static void print_(unsigned long n) {}
    static void println_(const char *s) {}
    static void println_(int n) {}
    static void println_(unsigned int n) {}
    static void println_(long n) {}
    static void println_(unsigned long n) {}
    static void println_() {}
    static void print_(uint32_t n, uint8_t b) {}
    static void println_(uint32_t n, uint8_t b) {}
    static void print_(const char *s, int n, uint8_t b = DEC) {}
    static void print_(const char *s, unsigned int n, uint8_t b = DEC) {}
    static void print_(const char *s, long n, uint8_t b = DEC) {}
    static void print_(const char *s, unsigned long n, uint8_t b = DEC) {}
    static void println_(const char *s, int n, uint8_t b = DEC) {}
    static void println_(const char *s, unsigned int n, uint8_t b = DEC) {}
    static void println_(const char *s, long n, uint8_t b = DEC) {}
    static void println_(const char *s, unsigned long n, uint8_t b = DEC) {}
#endif
protected:
    static void mk_setup(setup_t &s, uint32_t bmRequestType, uint32_t bRequest,
                         uint32_t wValue, uint32_t wIndex, uint32_t wLength) {
        s.word1 = bmRequestType | (bRequest << 8) | (wValue << 16);
        s.word2 = wIndex | (wLength << 16);
    }
};


/************************************************/
/*  USB Device Driver Common Base Class         */
/************************************************/

// All USB device drivers inherit from this base class.
class USBDriver : public USBHost {
public:
    operator bool() {
        Device_t *dev = *(Device_t * volatile *)&device;
        return dev != nullptr;
    }
    uint16_t idVendor() {
        Device_t *dev = *(Device_t * volatile *)&device;
        return (dev != nullptr) ? dev->idVendor : 0;
    }
    uint16_t idProduct() {
        Device_t *dev = *(Device_t * volatile *)&device;
        return (dev != nullptr) ? dev->idProduct : 0;
    }
    const uint8_t *manufacturer() {
        Device_t *dev = *(Device_t * volatile *)&device;
        if (dev == nullptr || dev->strbuf == nullptr) return nullptr;
        return &dev->strbuf->buffer[dev->strbuf->iStrings[strbuf_t::STR_ID_MAN]];
    }
    const uint8_t *product() {
        Device_t *dev = *(Device_t * volatile *)&device;
        if (dev == nullptr || dev->strbuf == nullptr) return nullptr;
        return &dev->strbuf->buffer[dev->strbuf->iStrings[strbuf_t::STR_ID_PROD]];
    }
    const uint8_t *serialNumber() {
        Device_t *dev = *(Device_t * volatile *)&device;
        if (dev == nullptr || dev->strbuf == nullptr) return nullptr;
        return &dev->strbuf->buffer[dev->strbuf->iStrings[strbuf_t::STR_ID_SERIAL]];
    }
protected:
    USBDriver() : next(NULL), device(NULL) {}
    // Check if a driver wishes to claim a device or interface or group
    // of interfaces within a device.  When this function returns true,
    // the driver is considered bound or loaded for that device.  When
    // new devices are detected, enumeration.cpp calls this function on
    // all unbound driver objects, to give them an opportunity to bind
    // to the new device.
    //   device has its vid&pid, class/subclass fields initialized
    //   type is 0 for device level, 1 for interface level, 2 for IAD
    //   descriptors points to the specific descriptor data
    virtual bool claim(Device_t *device, int type, const uint8_t *descriptors, uint32_t len) = 0;

    // When an unknown (not chapter 9) control transfer completes, this
    // function is called for all drivers bound to the device.  Return
    // true means this driver originated this control transfer, so no
    // more drivers need to be offered an opportunity to process it.
    // This function is optional, only needed if the driver uses control
    // transfers and wishes to be notified when they complete.
    virtual void control(const Transfer_t *transfer) { }

    // When any of the USBDriverTimer objects a driver creates generates
    // a timer event, this function is called.
    virtual void timer_event(USBDriverTimer *whichTimer) { }

    // When the user calls USBHost::Task, this Task function for all
    // active drivers is called, so they may update state and/or call
    // any attached user callback functions.
    virtual void Task() { }

    // When a device disconnects from the USB, this function is called.
    // The driver must free all resources it allocated and update any
    // internal state necessary to deal with the possibility of user
    // code continuing to call its API.  However, pipes and transfers
    // are the handled by lower layers, so device drivers do not free
    // pipes they created or cancel transfers they had in progress.
    virtual void disconnect() = 0;

    // Drivers are managed by this single-linked list.  All inactive
    // (not bound to any device) drivers are linked from
    // available_drivers in enumeration.cpp.  When bound to a device,
    // drivers are linked from that Device_t drivers list.
    USBDriver *next;

    // The device this object instance is bound to.  In words, this
    // is the specific device this driver is using.  When not bound
    // to any device, this must be NULL.  Drivers may set this to
    // any non-NULL value if they are in a state where they do not
    // wish to claim any device or interface (eg, if getting data
    // from the HID parser).
    Device_t *device;
    friend class USBHost;
};

// Device drivers may create these timer objects to schedule a timer call
class USBDriverTimer {
public:
    USBDriverTimer() { }
    USBDriverTimer(USBDriver *d) : driver(d) { }

    void init(USBDriver *d) { driver = d; };
    void start(uint32_t microseconds);
    void stop();
    void *pointer;
    uint32_t integer;
    uint32_t started_micros; // testing only
private:
    USBDriver      *driver;
    uint32_t       usec;
    USBDriverTimer *next;
    USBDriverTimer *prev;
    friend class USBHost;
};

// Device drivers may inherit from this base class, if they wish to receive
// HID input data fully decoded by the USBHIDParser driver
class USBHIDParser;

class USBHIDInput {
public:
    operator bool() { return (mydevice != nullptr); }
    uint16_t idVendor() { return (mydevice != nullptr) ? mydevice->idVendor : 0; }
    uint16_t idProduct() { return (mydevice != nullptr) ? mydevice->idProduct : 0; }
    const uint8_t *manufacturer()
    {  return  ((mydevice == nullptr) || (mydevice->strbuf == nullptr)) ? nullptr : &mydevice->strbuf->buffer[mydevice->strbuf->iStrings[strbuf_t::STR_ID_MAN]]; }
    const uint8_t *product()
    {  return  ((mydevice == nullptr) || (mydevice->strbuf == nullptr)) ? nullptr : &mydevice->strbuf->buffer[mydevice->strbuf->iStrings[strbuf_t::STR_ID_PROD]]; }
    const uint8_t *serialNumber()
    {  return  ((mydevice == nullptr) || (mydevice->strbuf == nullptr)) ? nullptr : &mydevice->strbuf->buffer[mydevice->strbuf->iStrings[strbuf_t::STR_ID_SERIAL]]; }


private:
    virtual hidclaim_t claim_collection(USBHIDParser *driver, Device_t *dev, uint32_t topusage) = 0;
    virtual bool hid_process_in_data(const Transfer_t *transfer) {return false;}
    virtual bool hid_process_out_data(const Transfer_t *transfer) {return false;}
    virtual bool hid_process_control(const Transfer_t *transfer) {return false;}
    virtual void hid_input_begin(uint32_t topusage, uint32_t type, int lgmin, int lgmax) { }
    virtual void hid_input_data(uint32_t usage, int32_t value) { }
    virtual void hid_input_end() { }
    virtual void disconnect_collection(Device_t *dev) { }
    virtual void hid_timer_event(USBDriverTimer *whichTimer) { }
    USBHIDInput *next = NULL;
    friend class USBHIDParser;
    friend class BTHIDSupport;
protected:
    Device_t *mydevice = NULL;
};


// Device drivers may inherit from this base class, if they wish to receive
// HID input like data from Bluetooth HID device.
class BluetoothController;
class BluetoothConnection;

class BTHIDInput {
public:
    operator bool() { return (btdevice != nullptr); } // experiment to see if overriding makes sense here
    uint16_t idVendor() { return (btdevice != nullptr) ? btdevice->idVendor : 0; }
    uint16_t idProduct() { return (btdevice != nullptr) ? btdevice->idProduct : 0; }

    const uint8_t *manufacturer();
    const uint8_t *product();
    const uint8_t *serialNumber();

private:
    virtual bool claim_bluetooth(BluetoothController *driver, uint32_t bluetooth_class, uint8_t *remoteName) {return false;}
    // newer version that will allow called code to know when it is being called (0 - At the connect, 1 if NO HID...)
    // not sure if I should overload the return or not, but...
    virtual hidclaim_t claim_bluetooth(BluetoothConnection *btconnection, uint32_t bluetooth_class, uint8_t *remoteName, int type);
    virtual bool process_bluetooth_HID_data(const uint8_t *data, uint16_t length) {return false;}
    virtual void release_bluetooth() {};
    virtual bool remoteNameComplete(const uint8_t *remoteName) {return true;}
    virtual void connectionComplete(void) {};
    virtual void sdp_command_completed (bool success) {};

    virtual hidclaim_t bt_claim_collection(BluetoothConnection *btconnection, uint32_t bluetooth_class, uint32_t topusage) {return CLAIM_NO;}
    virtual void bt_hid_input_begin(uint32_t topusage, uint32_t type, int lgmin, int lgmax) {};
    virtual void bt_hid_input_data(uint32_t usage, int32_t value) {};
    virtual void bt_hid_input_end() {};
    virtual void bt_disconnect_collection(Device_t *dev) {};
    virtual void bt_hid_timer_event(USBDriverTimer *whichTimer) { }


    BTHIDInput *next = NULL;
    friend class BluetoothController;
    friend class BluetoothConnection;
    enum { TOPUSAGE_LIST_LEN = 6 };
    enum { USAGE_LIST_LEN = 24 };

protected:
    enum {SP_NEED_CONNECT = 0x1, SP_DONT_NEED_CONNECT = 0x02, SP_PS3_IDS = 0x4};
    uint8_t  special_process_required = 0;
    Device_t *btdevice = NULL;
    BluetoothConnection *btconnect = nullptr;

};


/************************************************/
/*  USB Device Drivers                          */
/************************************************/

class USBHub : public USBDriver {
public:
    USBHub(USBHost &host) : debouncetimer(this), resettimer(this) { init(); }
    USBHub(USBHost *host) : debouncetimer(this), resettimer(this) { init(); }
    // Hubs with more more than 7 ports are built from two tiers of hubs
    // using 4 or 7 port hub chips.  While the USB spec seems to allow
    // hubs to have up to 255 ports, in practice all hub chips on the
    // market are only 2, 3, 4 or 7 ports.
    enum { MAXPORTS = 7 };
    typedef uint8_t portbitmask_t;
    enum {
        PORT_OFF =        0,
        PORT_DISCONNECT = 1,
        PORT_DEBOUNCE1 =  2,
        PORT_DEBOUNCE2 =  3,
        PORT_DEBOUNCE3 =  4,
        PORT_DEBOUNCE4 =  5,
        PORT_DEBOUNCE5 =  6,
        PORT_RESET =      7,
        PORT_RECOVERY =   8,
        PORT_ACTIVE =     9
    };
protected:
    virtual bool claim(Device_t *dev, int type, const uint8_t *descriptors, uint32_t len);
    virtual void control(const Transfer_t *transfer);
    virtual void timer_event(USBDriverTimer *whichTimer);
    virtual void disconnect();
    void init();
    bool can_send_control_now();
    void send_poweron(uint32_t port);
    void send_getstatus(uint32_t port);
    void send_clearstatus_connect(uint32_t port);
    void send_clearstatus_enable(uint32_t port);
    void send_clearstatus_suspend(uint32_t port);
    void send_clearstatus_overcurrent(uint32_t port);
    void send_clearstatus_reset(uint32_t port);
    void send_setreset(uint32_t port);
    void send_setinterface();
    static void callback(const Transfer_t *transfer);
    void status_change(const Transfer_t *transfer);
    void new_port_status(uint32_t port, uint32_t status);
    void start_debounce_timer(uint32_t port);
    void stop_debounce_timer(uint32_t port);
private:
    Device_t mydevices[MAXPORTS];
    Pipe_t mypipes[2] __attribute__ ((aligned(32)));
    Transfer_t mytransfers[4] __attribute__ ((aligned(32)));
    strbuf_t mystring_bufs[1];
    USBDriverTimer debouncetimer;
    USBDriverTimer resettimer;
    setup_t setup;
    Pipe_t *changepipe;
    Device_t *devicelist[MAXPORTS];
    uint32_t changebits;
    uint32_t statusbits;
    uint8_t  hub_desc[16];
    uint8_t  interface_count;
    uint8_t  interface_number;
    uint8_t  altsetting;
    uint8_t  protocol;
    uint8_t  endpoint;
    uint8_t  interval;
    uint8_t  numports;
    uint8_t  characteristics;
    uint8_t  powertime;
    uint8_t  sending_control_transfer;
    uint8_t  port_doing_reset;
    uint8_t  port_doing_reset_speed;
    uint8_t  portstate[MAXPORTS];
    portbitmask_t send_pending_poweron;
    portbitmask_t send_pending_getstatus;
    portbitmask_t send_pending_clearstatus_connect;
    portbitmask_t send_pending_clearstatus_enable;
    portbitmask_t send_pending_clearstatus_suspend;
    portbitmask_t send_pending_clearstatus_overcurrent;
    portbitmask_t send_pending_clearstatus_reset;
    portbitmask_t send_pending_setreset;
    portbitmask_t debounce_in_use;
    static volatile bool reset_busy;
};

//--------------------------------------------------------------------------


class USBHIDParser : public USBDriver {
public:
    USBHIDParser(USBHost &host) : hidTimer(this) { init(); }
    static void driver_ready_for_hid_collection(USBHIDInput *driver);
	bool sendPacket(const uint8_t *buffer, int cb=-1);
	void setTXBuffers(uint8_t *buffer1, uint8_t *buffer2, uint8_t cb, 
		// extended to optionaly allow more buffers. 
		uint8_t *buffer3=nullptr, uint8_t* buffer4=nullptr);
	void setRXBuffers(uint8_t *buffer1, uint8_t *buffer2, uint8_t cb,
		// extended to optionaly allow more buffers. 
		uint8_t *buffer3=nullptr, uint8_t* buffer4=nullptr);

    bool sendControlPacket(uint32_t bmRequestType, uint32_t bRequest,
                           uint32_t wValue, uint32_t wIndex, uint32_t wLength, void *buf);

    // Atempt for RAWhid and SEREMU to take over processing of data
    //
    uint16_t inSize(void) {return in_size;}
    uint16_t outSize(void) {return out_size;}
    uint8_t interfaceSubClass(void) { return bInterfaceSubClass; }
    uint8_t interfaceProtocol(void) { return bInterfaceProtocol; }
    void startTimer(uint32_t microseconds) {hidTimer.start(microseconds);}
    void stopTimer() {hidTimer.stop();}
    uint8_t interfaceNumber() { return bInterfaceNumber;}
    const uint8_t * getHIDReportDescriptor() {return _bigBuffer;}
    uint16_t getHIDReportDescriptorSize() { return descsize;}
protected:
    enum { TOPUSAGE_LIST_LEN = 6 };
    enum { USAGE_LIST_LEN = 24 };
    virtual bool claim(Device_t *device, int type, const uint8_t *descriptors, uint32_t len);
    virtual void control(const Transfer_t *transfer);
    virtual void disconnect();
    static void in_callback(const Transfer_t *transfer);
    static void out_callback(const Transfer_t *transfer);
    virtual void timer_event(USBDriverTimer *whichTimer);
    void in_data(const Transfer_t *transfer);
    void out_data(const Transfer_t *transfer);
    bool check_if_using_report_id();
    void parse();
    USBHIDInput * find_driver(uint32_t topusage);
    void parse(uint16_t type_and_report_id, const uint8_t *data, uint32_t len);
    void init();


	uint8_t activeSendMask(void) {return _tx_state;} 

private:
    Pipe_t *in_pipe;
    Pipe_t *out_pipe;
    static USBHIDInput *available_hid_drivers_list;
    //uint32_t topusage_list[TOPUSAGE_LIST_LEN];
    USBHIDInput *topusage_drivers[TOPUSAGE_LIST_LEN];
    uint16_t in_size;
    uint16_t out_size;
    uint8_t bInterfaceSubClass;
    uint8_t bInterfaceProtocol;
    setup_t setup;
    uint8_t report[64];
    uint8_t report2[64];
    uint16_t descsize;
    bool use_report_id;
    Pipe_t mypipes[3] __attribute__ ((aligned(32)));
    Transfer_t mytransfers[5] __attribute__ ((aligned(32)));
    strbuf_t mystring_bufs[1];
	uint8_t *_rx1 = nullptr;
	uint8_t *_rx2 = nullptr;
	uint8_t *_rx3 = nullptr;
	uint8_t *_rx4 = nullptr;
	uint8_t *_tx[4] = {nullptr, nullptr, nullptr, nullptr};
	uint8_t _tx_state = 0;
	uint8_t _tx_mask = 3;
    bool hid_driver_claimed_control_ = false;
    USBDriverTimer hidTimer;
	uint8_t _bigBuffer[800 + 64+64];
	uint8_t *_bigBufferEnd = _bigBuffer + sizeof(_bigBuffer);
	uint16_t _big_buffer_size = sizeof(_bigBuffer);
    uint8_t bInterfaceNumber = 0;
};

//--------------------------------------------------------------------------

class KeyboardController : public USBHIDInput, public BTHIDInput {
public:
    typedef union {
        struct {
            uint8_t numLock : 1;
            uint8_t capsLock : 1;
            uint8_t scrollLock : 1;
            uint8_t compose : 1;
            uint8_t kana : 1;
            uint8_t reserved : 3;
        };
        uint8_t byte;
    } KBDLeds_t;
public:
    KeyboardController(USBHost &host) { init(); }
    KeyboardController(USBHost *host) { init(); }
    // need their own versions as both USBDriver and USBHIDInput provide
    uint16_t idVendor();
    uint16_t idProduct();
    const uint8_t *manufacturer();
    const uint8_t *product();
    const uint8_t *serialNumber();

    operator bool() { return ((btdevice != nullptr) || (mydevice != nullptr)); }
    // Main boot keyboard functions.
    uint16_t getKey() { return keyCode; }
    uint8_t  getModifiers() { return modifiers_; }
    uint8_t  getOemKey() { return keyOEM_; }
    void     attachPress(void (*f)(int unicode)) { keyPressedFunction = f; }
    void     attachRelease(void (*f)(int unicode)) { keyReleasedFunction = f; }
    void     attachRawPress(void (*f)(uint8_t keycode)) { rawKeyPressedFunction = f; }
    void     attachRawRelease(void (*f)(uint8_t keycode)) { rawKeyReleasedFunction = f; }
    void     LEDS(uint8_t leds);
    uint8_t  LEDS() {return leds_.byte;}
    void     updateLEDS(void);
    bool     numLock() {return leds_.numLock;}
    bool     capsLock() {return leds_.capsLock;}
    bool     scrollLock() {return leds_.scrollLock;}
    void     numLock(bool f);
    void     capsLock(bool f);
    void     scrollLock(bool f);

    // return battery level in percentage.  0xff implies we don't know.
    uint8_t  batteryLevel() {return battery_level_;}
    // Added for extras information.
    void     attachExtrasPress(void (*f)(uint32_t top, uint16_t code)) { extrasKeyPressedFunction = f; }
    void     attachExtrasRelease(void (*f)(uint32_t top, uint16_t code)) { extrasKeyReleasedFunction = f; }
    void     forceBootProtocol();
    void     forceHIDProtocol();
    enum {MAX_KEYS_DOWN = 4};

protected:
    void init();

    // Bluetooth data
    virtual hidclaim_t claim_bluetooth(BluetoothConnection *btconnection, uint32_t bluetooth_class, uint8_t *remoteName, int type);
    //virtual bool claim_bluetooth(BluetoothController *driver, uint32_t bluetooth_class, uint8_t *remoteName);
    virtual bool process_bluetooth_HID_data(const uint8_t *data, uint16_t length);
    virtual bool remoteNameComplete(const uint8_t *remoteName);
    virtual void release_bluetooth();
    virtual void connectionComplete(void);
    virtual void sdp_command_completed (bool success);


protected:  // HID functions for extra keyboard data.
    virtual hidclaim_t claim_collection(USBHIDParser *driver, Device_t *dev, uint32_t topusage);
    virtual void hid_input_begin(uint32_t topusage, uint32_t type, int lgmin, int lgmax);
    virtual void hid_input_data(uint32_t usage, int32_t value);
    virtual void hid_input_end();
    virtual void disconnect_collection(Device_t *dev);
    virtual bool hid_process_in_data(const Transfer_t *transfer);
    void process_boot_keyboard_format(const uint8_t *report, bool process_mod_keys);

    virtual hidclaim_t bt_claim_collection(BluetoothConnection *btconnection, uint32_t bluetooth_class, uint32_t topusage);
    virtual void bt_hid_input_begin(uint32_t topusage, uint32_t type, int lgmin, int lgmax);
    virtual void bt_hid_input_data(uint32_t usage, int32_t value);
    virtual void bt_hid_input_end();
    virtual void bt_disconnect_collection(Device_t *dev);

private:
    void update();
    uint16_t convert_to_unicode(uint32_t mod, uint32_t key);
    void key_press(uint32_t mod, uint32_t key);
    void key_release(uint32_t mod, uint32_t key);
    bool process_hid_keyboard_data(uint32_t usage, int32_t value);
    void (*keyPressedFunction)(int unicode);
    void (*keyReleasedFunction)(int unicode);
    void (*rawKeyPressedFunction)(uint8_t keycode) = nullptr;
    void (*rawKeyReleasedFunction)(uint8_t keycode) = nullptr;
    Pipe_t *datapipe;
    setup_t setup;
    // Need two sets of structures to properly support some keyboards
    // that do N key roll-over.  They use the Boot report up to
    // 6 keys down and then they go to other format for additional
    // keys.
    // Boot format
    uint8_t report_[8];
    uint8_t prev_report_[8];

    // N Key reollover
    uint8_t key_states_[16];

    uint16_t keyCode;
    uint8_t modifiers_ = 0;
    uint8_t keyOEM_;

    KBDLeds_t leds_ = {0};

    // Added to process secondary HID data.
    void (*extrasKeyPressedFunction)(uint32_t top, uint16_t code);
    void (*extrasKeyReleasedFunction)(uint32_t top, uint16_t code);
    uint32_t topusage_ = 0;                 // What top report am I processing?
    uint32_t topusage_type_ = 0;
    int lgmin_ = 0;
    int lgmax_ = 0;
    uint32_t topusage_index_ = 0;
    uint8_t collections_claimed_ = 0;
    bool keyboard_uses_boot_format_  = false;
    volatile bool hid_input_begin_ = false;
    volatile bool hid_input_data_ = false;  // did we receive any valid data with report?

    uint8_t battery_level_ = 0xff; // battery level percent 0xff is we don't know

    uint8_t count_keys_down_ = 0;
    uint16_t keys_down[MAX_KEYS_DOWN];
    bool    force_boot_protocol;  // User or VID/PID said force boot protocol?
    bool control_queued = false;
    // keep back pointer for the three different op levels we claim
    BluetoothController *btdriver_ = nullptr;
    USBHIDParser *driver_[3] = {nullptr, nullptr, nullptr};
    static bool s_forceHIDMode;

    // Test probably temporary Bluetooth HID support object
    //BTHIDSupport bthids_;

};


class MouseController : public USBHIDInput, public BTHIDInput {
public:
    MouseController(USBHost &host) { init(); }
    bool    available() { return mouseEvent; }
    void    mouseDataClear();
    uint8_t getButtons() { return buttons; }
    int     getMouseX() { return mouseX; }
    int     getMouseY() { return mouseY; }
    int     getWheel() { return wheel; }
    int     getWheelH() { return wheelH; }
protected:
    virtual hidclaim_t claim_collection(USBHIDParser *driver, Device_t *dev, uint32_t topusage);
    virtual void hid_input_begin(uint32_t topusage, uint32_t type, int lgmin, int lgmax);
    virtual void hid_input_data(uint32_t usage, int32_t value);
    virtual void hid_input_end();
    virtual void disconnect_collection(Device_t *dev);

    // Bluetooth data
    virtual hidclaim_t claim_bluetooth(BluetoothConnection *btconnection, uint32_t bluetooth_class, uint8_t *remoteName, int type);
    //virtual bool claim_bluetooth(BluetoothController *driver, uint32_t bluetooth_class, uint8_t *remoteName);
    virtual bool process_bluetooth_HID_data(const uint8_t *data, uint16_t length);
    virtual void release_bluetooth();

    virtual hidclaim_t bt_claim_collection(BluetoothConnection *btconnection, uint32_t bluetooth_class, uint32_t topusage);
    virtual void bt_hid_input_begin(uint32_t topusage, uint32_t type, int lgmin, int lgmax);
    virtual void bt_hid_input_data(uint32_t usage, int32_t value);
    virtual void bt_hid_input_end();
    virtual void bt_disconnect_collection(Device_t *dev);


private:
    void init();
    BluetoothController *btdriver_ = nullptr;

    uint8_t collections_claimed = 0;
    volatile bool mouseEvent = false;
    volatile bool hid_input_begin_ = false;
    uint8_t buttons = 0;
    int     mouseX = 0;
    int     mouseY = 0;
    int     wheel = 0;
    int     wheelH = 0;
};

//--------------------------------------------------------------------------

class DigitizerController : public USBHIDInput, public BTHIDInput {
public:
    DigitizerController(USBHost &host) { init(); }
    bool    available() { return digitizerEvent; }
    void    digitizerDataClear();
    uint8_t getButtons() { return buttons; }
    int     getMouseX() { return mouseX; }
    int     getMouseY() { return mouseY; }
    int     getWheel() { return wheel; }
    int     getWheelH() { return wheelH; }
    int     getAxis(uint32_t index) { return (index < (sizeof(digiAxes) / sizeof(digiAxes[0]))) ? digiAxes[index] : 0; }

protected:
    virtual hidclaim_t claim_collection(USBHIDParser *driver, Device_t *dev, uint32_t topusage);
    virtual void hid_input_begin(uint32_t topusage, uint32_t type, int lgmin, int lgmax);
    virtual void hid_input_data(uint32_t usage, int32_t value);
    virtual void hid_input_end();
    virtual void disconnect_collection(Device_t *dev);


private:
    void init();

    uint8_t collections_claimed = 0;
    volatile bool digitizerEvent = false;
    volatile bool hid_input_begin_ = false;
    uint8_t buttons = 0;
    int     mouseX = 0;
    int     mouseY = 0;
    int     wheel = 0;
    int     wheelH = 0;
    int     digiAxes[16];
};


//--------------------------------------------------------------------------

class JoystickController : public USBDriver, public USBHIDInput, public BTHIDInput {
public:
    JoystickController(USBHost &host) { init(); }

    uint16_t idVendor();
    uint16_t idProduct();

    const uint8_t *manufacturer();
    const uint8_t *product();
    const uint8_t *serialNumber();
    operator bool() { return (((device != nullptr) || (mydevice != nullptr || (btdevice != nullptr))) && connected_); } // override as in both USBDriver and in USBHIDInput

    bool    available() { return joystickEvent; }
    void    joystickDataClear();

    // Returns the currently pressed buttons on the joystick
    uint32_t getButtons() { return buttons; }

    // Returns the HID Report ID
    uint8_t getReportID() { return report_id_;}

    // Returns the specified axis value
    int     getAxis(uint32_t index) { return (index < (sizeof(axis) / sizeof(axis[0]))) ? axis[index] : 0; }

    // Retuns bit mask showing which axis are defined for the current joystick
    uint64_t axisMask() {return axis_mask_;}

    // returns a bit mask showing which axis have changed since the last read. 
    uint64_t axisChangedMask() { return axis_changed_mask_;}
    uint64_t axisChangeNotifyMask() {return axis_change_notify_mask_;}
    void     axisChangeNotifyMask(uint64_t notify_mask) {axis_change_notify_mask_ = notify_mask;}

    // set functions functionality depends on underlying joystick.
    bool setRumble(uint8_t lValue, uint8_t rValue, uint8_t timeout = 0xff);
    // setLEDs on PS4(RGB), PS3 simple LED setting (only uses lb)
    bool setLEDs(uint8_t lr, uint8_t lg, uint8_t lb);  // sets Leds,
    bool inline setLEDs(uint32_t leds) {return setLEDs((leds >> 16) & 0xff, (leds >> 8) & 0xff, leds & 0xff);}  // sets Leds - passing one arg for all leds
    enum { STANDARD_AXIS_COUNT = 10, ADDITIONAL_AXIS_COUNT = 54, TOTAL_AXIS_COUNT = (STANDARD_AXIS_COUNT + ADDITIONAL_AXIS_COUNT) };
    typedef enum { UNKNOWN = 0, PS3, PS4, XBOXONE, XBOX360, PS3_MOTION, SpaceNav, SWITCH} joytype_t;
    joytype_t joystickType() {return joystickType_;}

    // PS3 pair function. hack, requires that it be connect4ed by USB and we have the address of the Bluetooth dongle...
    bool PS3Pair(uint8_t* bdaddr);

    bool PS4GetCurrentPairing(uint8_t* bdaddr);
    bool PS4Pair(uint8_t* bdaddr);
	
	void sw_sendCmd(uint8_t cmd, uint8_t *data, uint16_t size, uint32_t timeout=0);
	bool sw_getIMUCalValues(float *accel, float *gyro);

protected:
    // From USBDriver
    virtual bool claim(Device_t *device, int type, const uint8_t *descriptors, uint32_t len);
    virtual void control(const Transfer_t *transfer);
    virtual void disconnect();

    // From USBHIDInput
    virtual hidclaim_t claim_collection(USBHIDParser *driver, Device_t *dev, uint32_t topusage);
    virtual void hid_input_begin(uint32_t topusage, uint32_t type, int lgmin, int lgmax);
    virtual void hid_input_data(uint32_t usage, int32_t value);
    virtual bool hid_process_control(const Transfer_t *transfer);
    virtual void hid_input_end();
    virtual void disconnect_collection(Device_t *dev);
    virtual bool hid_process_out_data(const Transfer_t *transfer);
    virtual bool hid_process_in_data(const Transfer_t *transfer);
    virtual void hid_timer_event(USBDriverTimer *whichTimer);

    // Bluetooth data
    virtual hidclaim_t claim_bluetooth(BluetoothConnection *btconnection, uint32_t bluetooth_class, uint8_t *remoteName, int type);
    //virtual bool claim_bluetooth(BluetoothController *driver, uint32_t bluetooth_class, uint8_t *remoteName);
    virtual bool process_bluetooth_HID_data(const uint8_t *data, uint16_t length);
    virtual void release_bluetooth();
    virtual bool remoteNameComplete(const uint8_t *remoteName);
    virtual void connectionComplete(void);

    virtual hidclaim_t bt_claim_collection(BluetoothConnection *btconnection, uint32_t bluetooth_class, uint32_t topusage);
    virtual void bt_hid_input_begin(uint32_t topusage, uint32_t type, int lgmin, int lgmax);
    virtual void bt_hid_input_data(uint32_t usage, int32_t value);
    virtual void bt_hid_input_end();
    virtual void bt_disconnect_collection(Device_t *dev);
    virtual void bt_hid_timer_event(USBDriverTimer *whichTimer);



    joytype_t joystickType_ = UNKNOWN;
private:
    static bool queue_Data_Transfer_Debug(Pipe_t *pipe, void *buffer,
                                    uint32_t len, USBDriver *driver,
                                    uint32_t line);

    // Class specific
    void init();
    USBHIDParser *driver_ = nullptr;
    BluetoothController *btdriver_ = nullptr;

    joytype_t mapVIDPIDtoJoystickType(uint16_t idVendor, uint16_t idProduct, bool exclude_hid_devices);
    bool transmitPS4UserFeedbackMsg();
    bool transmitPS3UserFeedbackMsg();
    bool transmitPS3MotionUserFeedbackMsg();
    bool mapNameToJoystickType(const uint8_t *remoteName);
    //void sw_sendCmd(uint8_t cmd, uint8_t *data, uint16_t size);
	//void sw_sendCmdUSB(uint8_t cmd, uint8_t *data, uint8_t size);
    void sw_sendCmdUSB(uint8_t cmd, uint32_t timeout);
	void sw_sendSubCmdUSB(uint8_t sub_cmd, uint8_t *data, uint8_t size, uint32_t timeout = 0);
	void sw_parseAckMsg(const uint8_t *buf_);
    bool sw_handle_usb_init_of_joystick(uint8_t *buffer, uint16_t cb, bool timer_event);
    bool sw_handle_bt_init_of_joystick(const uint8_t *data, uint16_t length, bool timer_event);
    inline void sw_update_axis(uint8_t axis_index, int new_value);
    bool sw_process_HID_data(const uint8_t *data, uint16_t length);
	
	void CalcAnalogStick(float &pOutX, float &pOutY, int16_t x, int16_t y, bool isLeft);
	
	//kludge for switch having different button values
	bool initialPass_ = true;
	bool initialPassButton_ = true;
	bool initialPassBT_ = true;
	uint32_t buttonOffset_ = 0x00;
	
    uint8_t report_id_ = 0;
    bool anychange = false;
    volatile bool joystickEvent = false;
    uint32_t buttons = 0;
    int axis[TOTAL_AXIS_COUNT] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    uint64_t axis_mask_ = 0;    // which axis have valid data
    uint64_t axis_changed_mask_ = 0;
    uint64_t axis_change_notify_mask_ = 0x3ff;  // assume the low 10 values only.

    uint16_t additional_axis_usage_page_ = 0;
    uint16_t additional_axis_usage_start_ = 0;
    uint16_t additional_axis_usage_count_ = 0;

    // State values to output to Joystick.
    uint8_t rumble_lValue_ = 0;
    uint8_t rumble_rValue_ = 0;
    uint8_t rumble_timeout_ = 0;
    uint8_t leds_[3] = {0, 0, 0};
    uint8_t connected_ = 0; // what type of device if any is connected xbox 360...
    uint8_t connectedComplete_pending_ = 0;
    uint8_t sw_last_cmd_sent_ = 0;
    uint8_t sw_last_cmd_repeat_count = 0;
    enum {SW_CMD_TIMEOUT = 250000};
    elapsedMicros em_sw_;
    

    // Used by HID code
    uint8_t collections_claimed = 0;

    // Used by USBDriver code
    static void rx_callback(const Transfer_t *transfer);
    static void tx_callback(const Transfer_t *transfer);
    void rx_data(const Transfer_t *transfer);
    void tx_data(const Transfer_t *transfer);

    Pipe_t mypipes[3] __attribute__ ((aligned(32)));
    Transfer_t mytransfers[7] __attribute__ ((aligned(32)));
    strbuf_t mystring_bufs[1];

    uint8_t         rx_ep_ = 0; // remember which end point this object is...
    uint16_t        rx_size_ = 0;
    uint16_t        tx_size_ = 0;
    Pipe_t          *rxpipe_;
    Pipe_t          *txpipe_;
    uint8_t         rxbuf_[64]; // receive circular buffer
    uint8_t         txbuf_[64];     // buffer to use to send commands to joystick
    volatile bool       send_Control_packet_active_;
    // Mapping table to say which devices we handle
    typedef struct {
        uint16_t    idVendor;
        uint16_t    idProduct;
        joytype_t   joyType;
        bool        hidDevice;
    } product_vendor_mapping_t;
    static product_vendor_mapping_t pid_vid_mapping[];
};


//--------------------------------------------------------------------------

class MIDIDeviceBase : public USBDriver {
public:
    enum { SYSEX_MAX_LEN = 290 };

    // Message type names for compatibility with Arduino MIDI library 4.3.1
    enum MidiType {
        InvalidType           = 0x00, // For notifying errors
        NoteOff               = 0x80, // Note Off
        NoteOn                = 0x90, // Note On
        AfterTouchPoly        = 0xA0, // Polyphonic AfterTouch
        ControlChange         = 0xB0, // Control Change / Channel Mode
        ProgramChange         = 0xC0, // Program Change
        AfterTouchChannel     = 0xD0, // Channel (monophonic) AfterTouch
        PitchBend             = 0xE0, // Pitch Bend
        SystemExclusive       = 0xF0, // System Exclusive
        TimeCodeQuarterFrame  = 0xF1, // System Common - MIDI Time Code Quarter Frame
        SongPosition          = 0xF2, // System Common - Song Position Pointer
        SongSelect            = 0xF3, // System Common - Song Select
        TuneRequest           = 0xF6, // System Common - Tune Request
        Clock                 = 0xF8, // System Real Time - Timing Clock
        Start                 = 0xFA, // System Real Time - Start
        Continue              = 0xFB, // System Real Time - Continue
        Stop                  = 0xFC, // System Real Time - Stop
        ActiveSensing         = 0xFE, // System Real Time - Active Sensing
        SystemReset           = 0xFF, // System Real Time - System Reset
    };
    MIDIDeviceBase(USBHost &host, uint32_t *rx, uint32_t *tx1, uint32_t *tx2,
                   uint16_t bufsize, uint32_t *rqueue, uint16_t qsize) :
        txtimer(this), rx_buffer(rx), tx_buffer1(tx1), tx_buffer2(tx2),
        rx_queue(rqueue), max_packet_size(bufsize), rx_queue_size(qsize) {
        init();
    }
    void sendNoteOff(uint8_t note, uint8_t velocity, uint8_t channel, uint8_t cable = 0) {
        send(0x80, note, velocity, channel, cable);
    }
    void sendNoteOn(uint8_t note, uint8_t velocity, uint8_t channel, uint8_t cable = 0) {
        send(0x90, note, velocity, channel, cable);
    }
    void sendPolyPressure(uint8_t note, uint8_t pressure, uint8_t channel, uint8_t cable = 0) {
        send(0xA0, note, pressure, channel, cable);
    }
    void sendAfterTouchPoly(uint8_t note, uint8_t pressure, uint8_t channel, uint8_t cable = 0) {
        send(0xA0, note, pressure, channel, cable);
    }
    void sendControlChange(uint8_t control, uint8_t value, uint8_t channel, uint8_t cable = 0) {
        send(0xB0, control, value, channel, cable);
    }
    void sendProgramChange(uint8_t program, uint8_t channel, uint8_t cable = 0) {
        send(0xC0, program, 0, channel, cable);
    }
    void sendAfterTouch(uint8_t pressure, uint8_t channel, uint8_t cable = 0) {
        send(0xD0, pressure, 0, channel, cable);
    }
    void sendPitchBend(int value, uint8_t channel, uint8_t cable = 0) {
        if (value < -8192) {
            value = -8192;
        } else if (value > 8191) {
            value = 8191;
        }
        value += 8192;
        send(0xE0, value, value >> 7, channel, cable);
    }
    void sendSysEx(uint32_t length, const uint8_t *data, bool hasTerm = false, uint8_t cable = 0) {
        //if (cable >= MIDI_NUM_CABLES) return;
        if (hasTerm) {
            send_sysex_buffer_has_term(data, length, cable);
        } else {
            send_sysex_add_term_bytes(data, length, cable);
        }
    }
    void sendRealTime(uint8_t type, uint8_t cable = 0) {
        switch (type) {
        case 0xF8: // Clock
        case 0xFA: // Start
        case 0xFB: // Continue
        case 0xFC: // Stop
        case 0xFE: // ActiveSensing
        case 0xFF: // SystemReset
            send(type, 0, 0, 0, cable);
            break;
        default: // Invalid Real Time marker
            break;
        }
    }
    void sendTimeCodeQuarterFrame(uint8_t type, uint8_t value, uint8_t cable = 0) {
        send(0xF1, ((type & 0x07) << 4) | (value & 0x0F), 0, 0, cable);
    }
    void sendSongPosition(uint16_t beats, uint8_t cable = 0) {
        send(0xF2, beats, beats >> 7, 0, cable);
    }
    void sendSongSelect(uint8_t song, uint8_t cable = 0) {
        send(0xF3, song, 0, 0, cable);
    }
    void sendTuneRequest(uint8_t cable = 0) {
        send(0xF6, 0, 0, 0, cable);
    }
    void beginRpn(uint16_t number, uint8_t channel, uint8_t cable = 0) {
        sendControlChange(101, number >> 7, channel, cable);
        sendControlChange(100, number, channel, cable);
    }
    void sendRpnValue(uint16_t value, uint8_t channel, uint8_t cable = 0) {
        sendControlChange(6, value >> 7, channel, cable);
        sendControlChange(38, value, channel, cable);
    }
    void sendRpnIncrement(uint8_t amount, uint8_t channel, uint8_t cable = 0) {
        sendControlChange(96, amount, channel, cable);
    }
    void sendRpnDecrement(uint8_t amount, uint8_t channel, uint8_t cable = 0) {
        sendControlChange(97, amount, channel, cable);
    }
    void endRpn(uint8_t channel, uint8_t cable = 0) {
        sendControlChange(101, 0x7F, channel, cable);
        sendControlChange(100, 0x7F, channel, cable);
    }
    void beginNrpn(uint16_t number, uint8_t channel, uint8_t cable = 0) {
        sendControlChange(99, number >> 7, channel, cable);
        sendControlChange(98, number, channel, cable);
    }
    void sendNrpnValue(uint16_t value, uint8_t channel, uint8_t cable = 0) {
        sendControlChange(6, value >> 7, channel, cable);
        sendControlChange(38, value, channel, cable);
    }
    void sendNrpnIncrement(uint8_t amount, uint8_t channel, uint8_t cable = 0) {
        sendControlChange(96, amount, channel, cable);
    }
    void sendNrpnDecrement(uint8_t amount, uint8_t channel, uint8_t cable = 0) {
        sendControlChange(97, amount, channel, cable);
    }
    void endNrpn(uint8_t channel, uint8_t cable = 0) {
        sendControlChange(99, 0x7F, channel, cable);
        sendControlChange(98, 0x7F, channel, cable);
    }
    void send(uint8_t type, uint8_t data1, uint8_t data2, uint8_t channel, uint8_t cable = 0) {
        //if (cable >= MIDI_NUM_CABLES) return;
        if (type < 0xF0) {
            if (type < 0x80) return;
            type &= 0xF0;
            write_packed((type << 8) | (type >> 4) | ((cable & 0x0F) << 4)
                         | (((channel - 1) & 0x0F) << 8) | ((data1 & 0x7F) << 16)
                         | ((data2 & 0x7F) << 24));
        } else if (type >= 0xF8 || type == 0xF6) {
            write_packed((type << 8) | 0x0F | ((cable & 0x0F) << 4));
        } else if (type == 0xF1 || type == 0xF3) {
            write_packed((type << 8) | 0x02 | ((cable & 0x0F) << 4)
                         | ((data1 & 0x7F) << 16));
        } else if (type == 0xF2) {
            write_packed((type << 8) | 0x03 | ((cable & 0x0F) << 4)
                         | ((data1 & 0x7F) << 16) | ((data2 & 0x7F) << 24));
        }
    }
    void send_now(void) __attribute__((always_inline)) {
    }
    bool read(uint8_t channel = 0);
    uint8_t getType(void) {
        return msg_type;
    };
    uint8_t getCable(void) {
        return msg_cable;
    }
    uint8_t getChannel(void) {
        return msg_channel;
    };
    uint8_t getData1(void) {
        return msg_data1;
    };
    uint8_t getData2(void) {
        return msg_data2;
    };
    uint8_t * getSysExArray(void) {
        return msg_sysex;
    }
    uint16_t getSysExArrayLength(void) {
        return msg_data2 << 8 | msg_data1;
    }
    void setHandleNoteOff(void (*fptr)(uint8_t channel, uint8_t note, uint8_t velocity)) {
        // type: 0x80  NoteOff
        handleNoteOff = fptr;
    }
    void setHandleNoteOn(void (*fptr)(uint8_t channel, uint8_t note, uint8_t velocity)) {
        // type: 0x90  NoteOn
        handleNoteOn = fptr;
    }
    void setHandleVelocityChange(void (*fptr)(uint8_t channel, uint8_t note, uint8_t velocity)) {
        // type: 0xA0  AfterTouchPoly
        handleVelocityChange = fptr;
    }
    void setHandleAfterTouchPoly(void (*fptr)(uint8_t channel, uint8_t note, uint8_t pressure)) {
        // type: 0xA0  AfterTouchPoly
        handleVelocityChange = fptr;
    }
    void setHandleControlChange(void (*fptr)(uint8_t channel, uint8_t control, uint8_t value)) {
        // type: 0xB0  ControlChange
        handleControlChange = fptr;
    }
    void setHandleProgramChange(void (*fptr)(uint8_t channel, uint8_t program)) {
        // type: 0xC0  ProgramChange
        handleProgramChange = fptr;
    }
    void setHandleAfterTouch(void (*fptr)(uint8_t channel, uint8_t pressure)) {
        // type: 0xD0  AfterTouchChannel
        handleAfterTouch = fptr;
    }
    void setHandleAfterTouchChannel(void (*fptr)(uint8_t channel, uint8_t pressure)) {
        // type: 0xD0  AfterTouchChannel
        handleAfterTouch = fptr;
    }
    void setHandlePitchChange(void (*fptr)(uint8_t channel, int pitch)) {
        // type: 0xE0  PitchBend
        handlePitchChange = fptr;
    }
    void setHandleSysEx(void (*fptr)(const uint8_t *data, uint16_t length, bool complete)) {
        // type: 0xF0  SystemExclusive - multiple calls for message bigger than buffer
        handleSysExPartial = (void (*)(const uint8_t *, uint16_t, uint8_t))fptr;
    }
    void setHandleSystemExclusive(void (*fptr)(const uint8_t *data, uint16_t length, bool complete)) {
        // type: 0xF0  SystemExclusive - multiple calls for message bigger than buffer
        handleSysExPartial = (void (*)(const uint8_t *, uint16_t, uint8_t))fptr;
    }
    void setHandleSystemExclusive(void (*fptr)(uint8_t *data, unsigned int size)) {
        // type: 0xF0  SystemExclusive - single call, message larger than buffer is truncated
        handleSysExComplete = fptr;
    }
    void setHandleTimeCodeQuarterFrame(void (*fptr)(uint8_t data)) {
        // type: 0xF1  TimeCodeQuarterFrame
        handleTimeCodeQuarterFrame = fptr;
    }
    void setHandleSongPosition(void (*fptr)(uint16_t beats)) {
        // type: 0xF2  SongPosition
        handleSongPosition = fptr;
    }
    void setHandleSongSelect(void (*fptr)(uint8_t songnumber)) {
        // type: 0xF3  SongSelect
        handleSongSelect = fptr;
    }
    void setHandleTuneRequest(void (*fptr)(void)) {
        // type: 0xF6  TuneRequest
        handleTuneRequest = fptr;
    }
    void setHandleClock(void (*fptr)(void)) {
        // type: 0xF8  Clock
        handleClock = fptr;
    }
    void setHandleStart(void (*fptr)(void)) {
        // type: 0xFA  Start
        handleStart = fptr;
    }
    void setHandleContinue(void (*fptr)(void)) {
        // type: 0xFB  Continue
        handleContinue = fptr;
    }
    void setHandleStop(void (*fptr)(void)) {
        // type: 0xFC  Stop
        handleStop = fptr;
    }
    void setHandleActiveSensing(void (*fptr)(void)) {
        // type: 0xFE  ActiveSensing
        handleActiveSensing = fptr;
    }
    void setHandleSystemReset(void (*fptr)(void)) {
        // type: 0xFF  SystemReset
        handleSystemReset = fptr;
    }
    void setHandleRealTimeSystem(void (*fptr)(uint8_t realtimebyte)) {
        // type: 0xF8-0xFF - if more specific handler not configured
        handleRealTimeSystem = fptr;
    }
protected:
    virtual bool claim(Device_t *device, int type, const uint8_t *descriptors, uint32_t len);
    virtual void disconnect();
    virtual void timer_event(USBDriverTimer *timer);
    static void rx_callback(const Transfer_t *transfer);
    static void tx_callback(const Transfer_t *transfer);
    void rx_data(const Transfer_t *transfer);
    void tx_data(const Transfer_t *transfer);
    void init();
    void write_packed(uint32_t data);
    void send_sysex_buffer_has_term(const uint8_t *data, uint32_t length, uint8_t cable);
    void send_sysex_add_term_bytes(const uint8_t *data, uint32_t length, uint8_t cable);
    void sysex_byte(uint8_t b);
private:
    Pipe_t *rxpipe;
    Pipe_t *txpipe;
    USBDriverTimer txtimer;
    //enum { MAX_PACKET_SIZE = 64 };
    //enum { RX_QUEUE_SIZE = 80 }; // must be more than MAX_PACKET_SIZE/4
    //uint32_t rx_buffer[MAX_PACKET_SIZE/4];
    //uint32_t tx_buffer1[MAX_PACKET_SIZE/4];
    //uint32_t tx_buffer2[MAX_PACKET_SIZE/4];
    uint32_t * const rx_buffer;
    uint32_t * const tx_buffer1;
    uint32_t * const tx_buffer2;
    uint16_t rx_size;
    uint16_t tx_size;
    //uint32_t rx_queue[RX_QUEUE_SIZE];
    uint32_t * const rx_queue;
    volatile bool rx_packet_queued;
    const uint16_t max_packet_size;
    const uint16_t rx_queue_size;
    uint16_t rx_head;
    uint16_t rx_tail;
    volatile uint8_t tx1_count;
    volatile uint8_t tx2_count;
    uint8_t rx_ep;
    uint8_t tx_ep;
    uint8_t rx_ep_type;
    uint8_t tx_ep_type;
    uint8_t msg_cable;
    uint8_t msg_channel;
    uint8_t msg_type;
    uint8_t msg_data1;
    uint8_t msg_data2;
    uint8_t msg_sysex[SYSEX_MAX_LEN];
    uint16_t msg_sysex_len;
    void (*handleNoteOff)(uint8_t ch, uint8_t note, uint8_t vel);
    void (*handleNoteOn)(uint8_t ch, uint8_t note, uint8_t vel);
    void (*handleVelocityChange)(uint8_t ch, uint8_t note, uint8_t vel);
    void (*handleControlChange)(uint8_t ch, uint8_t control, uint8_t value);
    void (*handleProgramChange)(uint8_t ch, uint8_t program);
    void (*handleAfterTouch)(uint8_t ch, uint8_t pressure);
    void (*handlePitchChange)(uint8_t ch, int pitch);
    void (*handleSysExPartial)(const uint8_t *data, uint16_t length, uint8_t complete);
    void (*handleSysExComplete)(uint8_t *data, unsigned int size);
    void (*handleTimeCodeQuarterFrame)(uint8_t data);
    void (*handleSongPosition)(uint16_t beats);
    void (*handleSongSelect)(uint8_t songnumber);
    void (*handleTuneRequest)(void);
    void (*handleClock)(void);
    void (*handleStart)(void);
    void (*handleContinue)(void);
    void (*handleStop)(void);
    void (*handleActiveSensing)(void);
    void (*handleSystemReset)(void);
    void (*handleRealTimeSystem)(uint8_t rtb);
    Pipe_t mypipes[3] __attribute__ ((aligned(32)));
    Transfer_t mytransfers[7] __attribute__ ((aligned(32)));
    strbuf_t mystring_bufs[1];
};

class MIDIDevice : public MIDIDeviceBase {
public:
    MIDIDevice(USBHost &host) :
        MIDIDeviceBase(host, rx, tx1, tx2, MAX_PACKET_SIZE, queue, RX_QUEUE_SIZE) {};
    // MIDIDevice(USBHost *host) : ....
private:
    enum { MAX_PACKET_SIZE = 64 };
    enum { RX_QUEUE_SIZE = 80 }; // must be more than MAX_PACKET_SIZE/4
    uint32_t rx[MAX_PACKET_SIZE / 4];
    uint32_t tx1[MAX_PACKET_SIZE / 4];
    uint32_t tx2[MAX_PACKET_SIZE / 4];
    uint32_t queue[RX_QUEUE_SIZE];
};

class MIDIDevice_BigBuffer : public MIDIDeviceBase {
public:
    MIDIDevice_BigBuffer(USBHost &host) :
        MIDIDeviceBase(host, rx, tx1, tx2, MAX_PACKET_SIZE, queue, RX_QUEUE_SIZE) {};
    // MIDIDevice(USBHost *host) : ....
private:
    enum { MAX_PACKET_SIZE = 512 };
    enum { RX_QUEUE_SIZE = 400 }; // must be more than MAX_PACKET_SIZE/4
    uint32_t rx[MAX_PACKET_SIZE / 4];
    uint32_t tx1[MAX_PACKET_SIZE / 4];
    uint32_t tx2[MAX_PACKET_SIZE / 4];
    uint32_t queue[RX_QUEUE_SIZE];
};


//--------------------------------------------------------------------------

class USBSerialBase: public USBDriver, public Stream {
public:

    // FIXME: need different USBSerial, with bigger buffers for 480 Mbit & faster speed
    enum { BUFFER_SIZE = 648 }; // must hold at least 6 max size packets, plus 2 extra bytes
    enum { DEFAULT_WRITE_TIMEOUT = 3500};
    // The current know serial device types
    typedef enum { UNKNOWN = 0, CDCACM, FTDI, PL2303, CH341, CP210X } sertype_t;

    USBSerialBase(USBHost &host, uint32_t *big_buffer, uint16_t buffer_size,
                  uint16_t min_pipe_rxtx, uint16_t max_pipe_rxtx,
                  uint16_t vid_to_claim, uint16_t pid_to_claim, 
                  sertype_t vid_pid_sertype, int vid_pid_claim_at_type
                ) :
        txtimer(this),
        _bigBuffer(big_buffer),
        _big_buffer_size(buffer_size),
        _min_rxtx(min_pipe_rxtx),
        _max_rxtx(max_pipe_rxtx),
        _vid_to_claim(vid_to_claim), 
        _pid_to_claim(pid_to_claim), 
        _vid_pid_sertype(vid_pid_sertype), 
        _vid_pid_claim_at_type(vid_pid_claim_at_type)

    {

        init();
    }

    void begin(uint32_t baud, uint32_t format = USBHOST_SERIAL_8N1);
    void end(void);
    uint32_t writeTimeout() {return write_timeout_;}
    void writeTimeOut(uint32_t write_timeout) {write_timeout_ = write_timeout;} // Will not impact current ones.
    virtual int available(void);
    virtual int peek(void);
    virtual int read(void);
    virtual int availableForWrite();
    virtual size_t write(uint8_t c);
    virtual void flush(void);

    bool setDTR(bool fSet);
    bool setRTS(bool fSet);
    using Print::write;

protected:
    virtual bool claim(Device_t *device, int type, const uint8_t *descriptors, uint32_t len);
    virtual void control(const Transfer_t *transfer);
    virtual void disconnect();
    virtual void timer_event(USBDriverTimer *whichTimer);



private:
    static void rx_callback(const Transfer_t *transfer);
    static void tx_callback(const Transfer_t *transfer);
    void rx_data(const Transfer_t *transfer);
    void tx_data(const Transfer_t *transfer);
    void rx_queue_packets(uint32_t head, uint32_t tail);
    void init();
    static bool check_rxtx_ep(uint32_t &rxep, uint32_t &txep);
    bool init_buffers(uint32_t rsize, uint32_t tsize);
    void ch341_setBaud(uint8_t byte_index);
private:
    Pipe_t mypipes[3] __attribute__ ((aligned(32)));
    Transfer_t mytransfers[7] __attribute__ ((aligned(32)));
    strbuf_t mystring_bufs[1];
    USBDriverTimer txtimer;
    uint32_t *_bigBuffer;
    uint16_t _big_buffer_size;
    uint16_t  _min_rxtx;
    uint16_t _max_rxtx;

    // allow sketch to specify a VID/PID/Type setting that this instance can use
    // good for new or oddball devices
    uint16_t _vid_to_claim;
    uint16_t _pid_to_claim;
    sertype_t _vid_pid_sertype;  // what it should map to.
    int _vid_pid_claim_at_type;  // how we should claim it 0 - interface 1 - whole device


    setup_t setup;
    uint8_t setupdata[16]; //
    uint32_t baudrate = 115200;  // lets give it a default in case begin is not called
    uint32_t format_  = USBHOST_SERIAL_8N1; 
    uint32_t write_timeout_ = DEFAULT_WRITE_TIMEOUT;
    Pipe_t *rxpipe;
    Pipe_t *txpipe;
    uint8_t *rx1;   // location for first incoming packet
    uint8_t *rx2;   // location for second incoming packet
    uint8_t *rxbuf; // receive circular buffer
    uint8_t *tx1;   // location for first outgoing packet
    uint8_t *tx2;   // location for second outgoing packet
    uint8_t *txbuf;
    volatile uint16_t rxhead;// receive head
    volatile uint16_t rxtail;// receive tail
    volatile uint16_t txhead;
    volatile uint16_t txtail;
    uint16_t rxsize;// size of receive circular buffer
    uint16_t txsize;// size of transmit circular buffer
    volatile uint8_t  rxstate;// bitmask: which receive packets are queued
    volatile uint8_t  txstate;
    uint8_t pending_control;
    uint8_t setup_state;    // PL2303 - has several steps... Could use pending control?
    uint8_t pl2303_v1;      // Which version do we have
    uint8_t pl2303_v2;
    uint8_t interface;
    uint8_t dtr_rts_;       // save logical state for the two of them.
    volatile bool   control_queued; // Is there already a queued control messaged

    sertype_t sertype;

    typedef struct {
        uint16_t    idVendor;
        uint16_t    idProduct;
        sertype_t   sertype;
        int         claim_at_type;
    } product_vendor_mapping_t;
    static product_vendor_mapping_t pid_vid_mapping[];

};

// USBSerial class - is setup to handle most USB to serial devices that work at USB Full speed with max of 64 byte packets
class USBSerial : public USBSerialBase {
public:
    // Constructor
    // typically you just need to pass in the reference to the host object,
    // However optionally you can also pass in a Vendor ID, Product ID, Type, and claim at interface or object level
    // This hopefully allows you to easily try out some vendor specific devices that underlying it uses one of our known
    // usb interface chips
    USBSerial(USBHost &host,
              uint16_t vid_to_claim = 0, uint16_t pid_to_claim = 0, 
              sertype_t vid_pid_sertype = USBSerial::UNKNOWN, int vid_pid_claim_at_type = 0) :
        // hard code the normal one to 1 and 64 bytes for most likely most are 64
        USBSerialBase(host, bigbuffer, sizeof(bigbuffer), 1, 64, vid_to_claim, pid_to_claim, vid_pid_sertype, vid_pid_claim_at_type) {};
private:
    enum { BUFFER_SIZE = 648 }; // must hold at least 6 max size packets, plus 2 extra bytes
    uint32_t bigbuffer[(BUFFER_SIZE + 3) / 4];
};

class USBSerial_BigBuffer: public USBSerialBase {
public:
    // USBSerial_BigBuffer: handles devices that run at USB highspeed and can read and/or write up to 512 bytes per packet,
    // Parameters:
    //  host - reference to the main USB object
    //  min_rxtx - defaults to 65, set to 1 if you wish for it to also handle all USB to Serial objects
    //  vid_to_claim - Vendor ID Normally 0, but if you have device that is not supported you might specify it here.
    //  pid_to_claim - Product ID - only used with VID above
    //  vid_pid_sertype - Again not normally used unless pid, vid - then one of the following FTDI, PL2303, CH341, CP210X
    // void_pid_claim_at_type = like above but 0 if claim at interface (default)  or 1 claim whole device
    USBSerial_BigBuffer(USBHost &host, uint16_t min_rxtx = 65,
              uint16_t vid_to_claim = 0, uint16_t pid_to_claim = 0, 
              sertype_t vid_pid_sertype = USBSerial::UNKNOWN, int vid_pid_claim_at_type = 0) :
        USBSerialBase(host, bigbuffer, sizeof(bigbuffer), min_rxtx, 512, vid_to_claim, pid_to_claim, vid_pid_sertype, vid_pid_claim_at_type) {};
private:
    enum { BUFFER_SIZE = 4096 }; // must hold at least 6 max size packets, plus 2 extra bytes
    uint32_t bigbuffer[(BUFFER_SIZE + 3) / 4];
};

//--------------------------------------------------------------------------

class AntPlus: public USBDriver {
// Please post any AntPlus feedback or contributions on this forum thread:
// https://forum.pjrc.com/threads/43110-Ant-libarary-and-USB-driver-for-Teensy-3-5-6
public:
    AntPlus(USBHost &host) : /* txtimer(this),*/  updatetimer(this) { init(); }
    void begin(const uint8_t key = 0);
    void onStatusChange(void (*function)(int channel, int status)) {
        user_onStatusChange = function;
    }
    void onDeviceID(void (*function)(int channel, int devId, int devType, int transType)) {
        user_onDeviceID = function;
    }
    void onHeartRateMonitor(void (*f)(int bpm, int msec, int seqNum), uint32_t devid = 0) {
        profileSetup_HRM(&ant.dcfg[PROFILE_HRM], devid);
        memset(&hrm, 0, sizeof(hrm));
        user_onHeartRateMonitor = f;
    }
    void onSpeedCadence(void (*f)(float speed, float distance, float rpm), uint32_t devid = 0) {
        profileSetup_SPDCAD(&ant.dcfg[PROFILE_SPDCAD], devid);
        memset(&spdcad, 0, sizeof(spdcad));
        user_onSpeedCadence = f;
    }
    void onSpeed(void (*f)(float speed, float distance), uint32_t devid = 0) {
        profileSetup_SPEED(&ant.dcfg[PROFILE_SPEED], devid);
        memset(&spd, 0, sizeof(spd));
        user_onSpeed = f;
    }
    void onCadence(void (*f)(float rpm), uint32_t devid = 0) {
        profileSetup_CADENCE(&ant.dcfg[PROFILE_CADENCE], devid);
        memset(&cad, 0, sizeof(cad));
        user_onCadence = f;
    }
    void setWheelCircumference(float meters) {
        wheelCircumference = meters * 1000.0f;
    }
protected:
    virtual void Task();
    virtual bool claim(Device_t *device, int type, const uint8_t *descriptors, uint32_t len);
    virtual void disconnect();
    virtual void timer_event(USBDriverTimer *whichTimer);
private:
    static void rx_callback(const Transfer_t *transfer);
    static void tx_callback(const Transfer_t *transfer);
    void rx_data(const Transfer_t *transfer);
    void tx_data(const Transfer_t *transfer);
    void init();
    size_t write(const void *data, const size_t size);
    int read(void *data, const size_t size);
    void transmit();
private:
    Pipe_t mypipes[2] __attribute__ ((aligned(32)));
    Transfer_t mytransfers[3] __attribute__ ((aligned(32)));
    strbuf_t mystring_bufs[1];
    //USBDriverTimer txtimer;
    USBDriverTimer updatetimer;
    Pipe_t *rxpipe;
    Pipe_t *txpipe;
    bool first_update;
    uint8_t txbuffer[240];
    uint8_t rxpacket[64];
    volatile uint16_t txhead;
    volatile uint16_t txtail;
    volatile bool     txready;
    volatile uint8_t  rxlen;
    volatile bool     do_polling;
private:
    enum _eventi {
        EVENTI_MESSAGE = 0,
        EVENTI_CHANNEL,
        EVENTI_TOTAL
    };
    enum _profiles {
        PROFILE_HRM = 0,
        PROFILE_SPDCAD,
        PROFILE_POWER,
        PROFILE_STRIDE,
        PROFILE_SPEED,
        PROFILE_CADENCE,
        PROFILE_TOTAL
    };
    typedef struct {
        uint8_t channel;
        uint8_t RFFreq;
        uint8_t networkNumber;
        uint8_t stub;
        uint8_t searchTimeout;
        uint8_t channelType;
        uint8_t deviceType;
        uint8_t transType;
        uint16_t channelPeriod;
        uint16_t searchWaveform;
        uint32_t deviceNumber; // deviceId
        struct {
            uint8_t chanIdOnce;
            uint8_t keyAccepted;
            uint8_t profileValid;
            uint8_t channelStatus;
            uint8_t channelStatusOld;
        } flags;
    } TDCONFIG;
    struct {
        uint8_t initOnce;
        uint8_t key; // key index
        int iDevice; // index to the antplus we're interested in, if > one found
        TDCONFIG dcfg[PROFILE_TOTAL]; // channel config, we're using one channel per device
    } ant;
    void (*user_onStatusChange)(int channel, int status);
    void (*user_onDeviceID)(int channel, int devId, int devType, int transType);
    void (*user_onHeartRateMonitor)(int beatsPerMinute, int milliseconds, int sequenceNumber);
    void (*user_onSpeedCadence)(float speed, float distance, float cadence);
    void (*user_onSpeed)(float speed, float distance);
    void (*user_onCadence)(float cadence);
    void dispatchPayload(TDCONFIG *cfg, const uint8_t *payload, const int len);
    static const uint8_t *getAntKey(const uint8_t keyIdx);
    static uint8_t calcMsgChecksum (const uint8_t *buffer, const uint8_t len);
    static uint8_t * findStreamSync(uint8_t *stream, const size_t rlen, int *pos);
    static int msgCheckIntegrity(uint8_t *stream, const int len);
    static int msgGetLength(uint8_t *stream);
    int handleMessages(uint8_t *buffer, int tBytes);
    void sendMessageChannelStatus(TDCONFIG *cfg, const uint32_t channelStatus);
    void message_channel(const int chan, const int eventId,
                         const uint8_t *payload, const size_t dataLength);
    void message_response(const int chan, const int msgId,
                          const uint8_t *payload, const size_t dataLength);
    void message_event(const int channel, const int msgId,
                       const uint8_t *payload, const size_t dataLength);
    int ResetSystem();
    int RequestMessage(const int channel, const int message);
    int SetNetworkKey(const int netNumber, const uint8_t *key);
    int SetChannelSearchTimeout(const int channel, const int searchTimeout);
    int SetChannelPeriod(const int channel, const int period);
    int SetChannelRFFreq(const int channel, const int freq);
    int SetSearchWaveform(const int channel, const int wave);
    int OpenChannel(const int channel);
    int CloseChannel(const int channel);
    int AssignChannel(const int channel, const int channelType, const int network);
    int SetChannelId(const int channel, const int deviceNum, const int deviceType,
                     const int transmissionType);
    int SendBurstTransferPacket(const int channelSeq, const uint8_t *data);
    int SendBurstTransfer(const int channel, const uint8_t *data, const int nunPackets);
    int SendBroadcastData(const int channel, const uint8_t *data);
    int SendAcknowledgedData(const int channel, const uint8_t *data);
    int SendExtAcknowledgedData(const int channel, const int devNum, const int devType,
                                const int TranType, const uint8_t *data);
    int SendExtBroadcastData(const int channel, const int devNum, const int devType,
                             const int TranType, const uint8_t *data);
    int SendExtBurstTransferPacket(const int chanSeq, const int devNum,
                                   const int devType, const int TranType, const uint8_t *data);
    int SendExtBurstTransfer(const int channel, const int devNum, const int devType,
                             const int tranType, const uint8_t *data, const int nunPackets);
    static void profileSetup_HRM(TDCONFIG *cfg, const uint32_t deviceId);
    static void profileSetup_SPDCAD(TDCONFIG *cfg, const uint32_t deviceId);
    static void profileSetup_POWER(TDCONFIG *cfg, const uint32_t deviceId);
    static void profileSetup_STRIDE(TDCONFIG *cfg, const uint32_t deviceId);
    static void profileSetup_SPEED(TDCONFIG *cfg, const uint32_t deviceId);
    static void profileSetup_CADENCE(TDCONFIG *cfg, const uint32_t deviceId);
    struct {
        struct {
            uint8_t bpm;
            uint8_t sequence;
            uint16_t time;
        } previous;
    } hrm;
    void payload_HRM(TDCONFIG *cfg, const uint8_t *data, const size_t dataLength);
    struct {
        struct {
            uint16_t cadenceTime;
            uint16_t cadenceCt;
            uint16_t speedTime;
            uint16_t speedCt;
        } previous;
        float distance;
    } spdcad;
    void payload_SPDCAD(TDCONFIG *cfg, const uint8_t *data, const size_t dataLength);
    /* struct {
        struct {
            uint8_t sequence;
            uint16_t pedalPowerContribution;
            uint8_t pedalPower;
            uint8_t instantCadence;
            uint16_t sumPower;
            uint16_t instantPower;
        } current;
        struct {
            uint16_t stub;
        } previous;
    } pwr; */
    void payload_POWER(TDCONFIG *cfg, const uint8_t *data, const size_t dataLength);
    /* struct {
        struct {
            uint16_t speed;
            uint16_t cadence;
            uint8_t strides;
        } current;
        struct {
            uint8_t strides;
            uint16_t speed;
            uint16_t cadence;
        } previous;
    } stride; */
    void payload_STRIDE(TDCONFIG *cfg, const uint8_t *data, const size_t dataLength);
    struct {
        struct {
            uint16_t speedTime;
            uint16_t speedCt;
        } previous;
        float distance;
    } spd;
    void payload_SPEED(TDCONFIG *cfg, const uint8_t *data, const size_t dataLength);
    struct {
        struct {
            uint16_t cadenceTime;
            uint16_t cadenceCt;
        } previous;
    } cad;
    void payload_CADENCE(TDCONFIG *cfg, const uint8_t *data, const size_t dataLength);
    uint16_t wheelCircumference; // default is WHEEL_CIRCUMFERENCE (2122cm)
};

//--------------------------------------------------------------------------

class RawHIDController : public USBHIDInput {
public:
	RawHIDController(USBHost &host, uint32_t usage = 0, uint8_t *rx_tx_buffers=nullptr, uint16_t rx_tx_buffer_size = 0) : 
			fixed_usage_(usage), rx_tx_buffers_(rx_tx_buffers), rx_tx_buffer_size_(rx_tx_buffer_size) { init(); }
    uint32_t usage(void) {return usage_;}
    void attachReceive(bool (*f)(uint32_t usage, const uint8_t *data, uint32_t len)) {receiveCB = f;}
	bool sendPacket(const uint8_t *buffer, int cb = -1);
	uint16_t rxSize() { return rx_pipe_size_;}
	uint16_t txSize() { return tx_pipe_size_;}// size of transmit circular buffer
protected:
    virtual hidclaim_t claim_collection(USBHIDParser *driver, Device_t *dev, uint32_t topusage);
    virtual bool hid_process_in_data(const Transfer_t *transfer);
    virtual bool hid_process_out_data(const Transfer_t *transfer);
    virtual void hid_input_begin(uint32_t topusage, uint32_t type, int lgmin, int lgmax);
    virtual void hid_input_data(uint32_t usage, int32_t value);
    virtual void hid_input_end();
    virtual void disconnect_collection(Device_t *dev);
private:
    void init();
    USBHIDParser *driver_;
    enum { MAX_PACKET_SIZE = 64 };
    bool (*receiveCB)(uint32_t usage, const uint8_t *data, uint32_t len) = nullptr;
    uint8_t collections_claimed = 0;
    //volatile bool hid_input_begin_ = false;
    uint32_t fixed_usage_;
    uint32_t usage_ = 0;
	uint16_t rx_pipe_size_;// size of receive circular buffer
	uint16_t tx_pipe_size_;// size of transmit circular buffer
	uint8_t  *rx_tx_buffers_;
	uint16_t rx_tx_buffer_size_; 

    // See if we can contribute transfers
	Transfer_t mytransfers[4] __attribute__ ((aligned(32)));

};

//--------------------------------------------------------------------------

class USBSerialEmu : public USBHIDInput, public Stream {
public:
    USBSerialEmu(USBHost &host) { init(); }
    uint32_t usage(void) {return usage_;}

    // begin method added to make sketch code easier to swap with real searila objects
    void begin(uint32_t baud, uint32_t format = USBHOST_SERIAL_8N1) {}
    void end(void) {};


    // Stream stuff.
    uint32_t writeTimeout() {return write_timeout_;}
    void writeTimeOut(uint32_t write_timeout) {write_timeout_ = write_timeout;} // Will not impact current ones.
    virtual int available(void);
    virtual int peek(void);
    virtual int read(void);
    virtual int availableForWrite();
    virtual size_t write(uint8_t c);
    virtual void flush(void);

    using Print::write;


protected:
    virtual hidclaim_t claim_collection(USBHIDParser *driver, Device_t *dev, uint32_t topusage);
    virtual bool hid_process_in_data(const Transfer_t *transfer);
    virtual bool hid_process_out_data(const Transfer_t *transfer);
    virtual void hid_input_begin(uint32_t topusage, uint32_t type, int lgmin, int lgmax);
    virtual void hid_input_data(uint32_t usage, int32_t value);
    virtual void hid_input_end();
    virtual void disconnect_collection(Device_t *dev);
    virtual void hid_timer_event(USBDriverTimer *whichTimer);

    bool sendPacket();

private:
    void init();
    USBHIDParser *driver_;
    enum { MAX_PACKET_SIZE = 64 };
    bool (*receiveCB)(uint32_t usage, const uint8_t *data, uint32_t len) = nullptr;
    uint8_t collections_claimed = 0;
    uint32_t usage_ = 0;

    // We have max of 512 byte packets coming in.  How about enough room for 3+3
    enum { RX_BUFFER_SIZE = 1024, TX_BUFFER_SIZE = 512 };
    enum { DEFAULT_WRITE_TIMEOUT = 3500};

    uint8_t rx_buffer_[RX_BUFFER_SIZE];
    uint8_t tx_buffer_[TX_BUFFER_SIZE];

    volatile uint8_t tx_out_data_pending_ = 0;

    volatile uint16_t rx_head_;// receive head
    volatile uint16_t rx_tail_;// receive tail
    volatile uint16_t tx_head_;
    uint16_t rx_pipe_size_;// size of receive circular buffer
    uint16_t tx_pipe_size_;// size of transmit circular buffer
    uint32_t write_timeout_ = DEFAULT_WRITE_TIMEOUT;


    // See if we can contribute transfers
    Transfer_t mytransfers[2] __attribute__ ((aligned(32)));

};




//=============================================================================
// Top level Bluetooth controller class = Main class,
//=============================================================================
// Note we are moving more of the functionality to be per connection instead of indexing
// each time... So converted from structure to class.
class BluetoothConnection  {
public:
    BluetoothConnection() {init();}
    void init() {next_ = s_first_; s_first_ = this; }

    void initializeConnection(BluetoothController *btController, uint8_t bdaddr[6], uint32_t class_of_device, bool inquire_mode);
    void remoteNameComplete(const uint8_t *remote_name);

    void parse(void);
    void parse(uint16_t type_and_report_id, const uint8_t *data, uint32_t len);
    BTHIDInput * find_driver(uint32_t topusage);
    BTHIDInput * find_driver(const uint8_t *remoteName, int type);

    void startTimer(uint32_t microseconds) {bt_connection_timer_.start(microseconds);}
    void stopTimer() {bt_connection_timer_.stop();}

    void dumpHIDReportDescriptor();
    void print_input_output_feature_bits(uint8_t val);
    void printUsageInfo(uint8_t usage_page, uint16_t usage);
    void useHIDProtocol(bool useHID) {use_hid_protocol_ = useHID;}
    void connectToSDP(); // temp to see if we can do this later...
    void timer_event(USBDriverTimer *whichTimer);

    // member variables
    BluetoothConnection *next_ = nullptr;
    BTHIDInput *    device_driver_ = nullptr;
    BluetoothController *btController_ = nullptr;
    strbuf_t *      strbuf_ = nullptr;  // possible to hold onto string if we have one 
    uint16_t        connection_rxid_ = 0;
    uint16_t        control_dcid_ = 0x70;
    uint16_t        interrupt_dcid_ = 0x71;
    uint16_t        sdp_dcid_ = 0x40;
    uint16_t        interrupt_scid_;
    uint16_t        control_scid_;
    uint16_t        sdp_scid_;
    uint8_t         device_bdaddr_[6];// remember devices address
    uint8_t         device_ps_repetion_mode_ ; // mode
    uint8_t         device_clock_offset_[2];
    uint32_t        device_class_;  // class of device.
    uint16_t        device_connection_handle_;  // handle to connection
    uint8_t         remote_ver_;
    uint16_t        remote_man_;
    uint8_t         remote_subv_;
    bool            connection_started_ = false; // probably can be combined
    volatile uint8_t connection_complete_ = 0;   //
    bool            check_for_hid_descriptor_ = false;
    bool            find_driver_type_1_called_ = false; 
    uint8_t         seq_number_ = 0;
    bool            use_hid_protocol_ = false; //
    bool            inquire_mode_ = false; // inquire mode?  or incomming connect
    bool            sdp_connected_ = false;
    bool            supports_SSP_ = false; 
    bool            connection_started_by_timer_ = false; 
    uint16_t        pending_control_tx_ = 0;

    enum {DUNKOWN=0xff, DNIL = 0, DU32, DS32, DU64, DS64, DPB, DLVL};
    enum {CONNECTION_TIMEOUT_US = 50000};
    typedef struct {
        uint8_t  element_type;
        uint8_t dtype;
        uint16_t element_size;    // size of element
        union {
            uint32_t uw;
            int32_t sw;
            uint64_t luw;
            int64_t lsw;
            uint8_t *pb;
        } data;
    } sdp_element_t;


    // More HID stuff
    // wondering if we could share some with USB HID objects?
    bool have_hid_descriptor_ = false;
    uint8_t *sdp_buffer_ = nullptr;
    uint16_t sdp_buffer_len_ = 0;
    uint8_t descriptor_[800];
    enum {REMOTE_NAME_SIZE = 32};
    uint8_t remote_name_[REMOTE_NAME_SIZE] = {0};
    uint16_t descsize_;
    bool use_report_id = true;
    enum { TOPUSAGE_LIST_LEN = 6 };
    enum { USAGE_LIST_LEN = 24 };
    BTHIDInput *topusage_drivers[TOPUSAGE_LIST_LEN];

    static BluetoothConnection *s_first_;

    bool startSDP_ServiceSearchAttributeRequest(uint16_t range_low, uint16_t range_high, uint8_t *buffer, uint32_t cb);
    bool SDPRequestCompleted() {return sdp_request_completed_;}
    uint32_t SDPRequestBufferUsed() {return sdp_request_buffer_used_cnt_;}
    // Add starts of SDP processing.

    // Allow each connection to have it's own timer
    USBDriverTimer  bt_connection_timer_;

protected:
    friend class BluetoothController;

    void rx2_data(uint8_t *rx2buf); // called from rx2_data of BluetoothController
    void tx_data(uint8_t *data, uint16_t length);

    void process_l2cap_connection_request(uint8_t *data, uint16_t length);
    void process_l2cap_connection_response(uint8_t *data, uint16_t length);
    void process_l2cap_config_request(uint8_t *data, uint16_t length);
    void process_l2cap_config_response(uint8_t *data, uint16_t length);
    void process_l2cap_command_reject(uint8_t *data, uint16_t length);
    void process_l2cap_disconnect_request(uint8_t *data, uint16_t length);
    void sendl2cap_ConnectionResponse(uint16_t handle, uint8_t rxid, uint16_t dcid, uint16_t scid, uint8_t result);
    void sendl2cap_ConnectionRequest(uint16_t handle, uint8_t rxid, uint16_t scid, uint16_t psm);
    void sendl2cap_ConfigRequest(uint16_t handle, uint8_t rxid, uint16_t dcid);
    void sendl2cap_ConfigResponse(uint16_t handle, uint8_t rxid, uint16_t scid, uint16_t mtu);
    void sendl2cap_DisconnectResponse(uint16_t handle, uint8_t rxid, uint16_t dcid, uint16_t scid);

    void process_sdp_service_search_request(uint8_t *data);
    void process_sdp_service_search_response(uint8_t *data);
    void process_sdp_service_attribute_request(uint8_t *data);
    void process_sdp_service_attribute_response(uint8_t *data);
    void process_sdp_service_search_attribute_request(uint8_t *data);
    void process_sdp_service_search_attribute_response(uint8_t *data);

    void handleHIDTHDRData(uint8_t *buffer);    // Pass the whole buffer...

    void handle_HCI_WRITE_SCAN_ENABLE_complete(uint8_t *rxbuf);
    void handle_HCI_OP_ROLE_DISCOVERY_complete(uint8_t *rxbuf);

    void send_SDP_ServiceSearchRequest(uint8_t *continue_state, uint8_t cb);
    void send_SDP_ServiceSearchAttributeRequest(uint8_t *continue_state, uint8_t cb);
    uint16_t sdp_request_range_low_ = 0;
    uint16_t sdp_reqest_range_high_ = 0xffff;
    uint8_t *sdp_request_buffer_ = nullptr;
    uint32_t sdp_request_buffer_cb_ = 0;
    uint32_t sdp_request_buffer_used_cnt_ = 0; // cnt in bytes used.
    volatile bool sdp_request_completed_ = true;

    // More SDP/HID stuff
    bool startRetrieveHIDReportDescriptor();
    bool completeSDPRequest(bool success);

    int  extract_next_SDP_Token(uint8_t *pbElement, int cb_left, sdp_element_t &sdpe);
    void print_sdpe_val(sdp_element_t &sdpe, bool verbose);
    void decode_SDP_buffer(bool verbose_output = false);
    void decode_SDP_Data(bool by_user_command);


};

//=============================================================================
// Bluetooth Pairing Callback class
//=============================================================================
class BluetoothPairingCB {
public:
    //  About to send HCI_WRITE_INQUIRY_MODE
    virtual bool writeInquiryMode(uint8_t inquiry_mode) { return true;}

    // The inquiry is complete
    virtual bool inquiryComplete(uint8_t status) {return true;}

    // we received an Inquiry result, use it?
    virtual bool useInquireResult(uint8_t bdaddr[6], uint32_t bluetooth_class, const uint8_t *name)
        {return true;}


    // These return > 0 for success, 0 for false, -1, don't want to support link keys. 
    virtual int writeLinkKey(uint8_t bdaddr[6], uint8_t link_key[16]) {return 0;}
    virtual int readLinkKey(uint8_t bdaddr[6], uint8_t link_key[16]) {return 0;}

    // Asked for PinCode?
    virtual bool sendPinCode(const char *pinCode)
        {return true;}
    virtual bool pinCodeComplete()
        {return true;}

    virtual bool authenticationComplete()
        {return true;}

};


//=============================================================================
// Bluetooth Connection class
//  Will try to handle all of the processing of one Bluetooth connection.
//=============================================================================

class BluetoothController: public USBDriver {
public:
    enum { TOPUSAGE_LIST_LEN = 6 };
    enum { USAGE_LIST_LEN = 24 };
    static const uint8_t DEFAULT_CONNECTIONS = 2;




    BluetoothController(USBHost &host, bool pair = false, const char *pin = "0000", bool pair_ssp = false) : do_pair_device_(pair), pair_pincode_(pin), do_pair_ssp_(pair_ssp), timer_(this)
    { init(); }

    enum {MAX_ENDPOINTS = 4, NUM_SERVICES = 4, }; // Max number of Bluetooth services - if you need more than 4 simply increase this number
    enum {BT_CLASS_DEVICE = 0x0804}; // Toy - Robot
    static void driver_ready_for_bluetooth(BTHIDInput *driver);

    const uint8_t*  myBDAddr(void) {return my_bdaddr_;}

    // See if we can start up pairing after sketch is running. 
    bool startDevicePairing(const char *pin, bool pair_ssp = false);
    
    // Setup a bluetooth pairing callback to receive calls for information and
    // for the sketch to be able to monitor some of the pairing progress
    void setBluetoothPairingCB(BluetoothPairingCB *pairing_cb) {pairing_cb_ = pairing_cb;}

    // method to help control where or not all pairing keys should be stored
    // Can be pointer to File system, in which case we will create a file "PairingKeys" 
    // if FS is NULL, and EEPROM start is specified will store in EEPROM starting
    // at that location.  Note if location is < -1 it will end the have the end
    // of the storage that far from the end of the EEPROM
    void setPairingKeyStorageLocation(FS *pfs = nullptr, int eeprom = -1, int max_keys = -1);

    // Note write link with NULL link_key means delete null bdaddr and null link key delete them all
    bool writeLinkKey(uint8_t bdaddr[6], uint8_t link_key[16]);
    bool readLinkKey(uint8_t bdaddr[6], uint8_t link_key[16]);

    // Experiments to enable LE scanning
    bool setLEScanEnable(uint8_t enable, uint8_t filter_duplicates);
    bool setLEScanParameters(uint8_t scan_type, uint16_t scan_interval, uint16_t scan_window, uint8_t own_address_type, uint8_t filter_policy);


    // BUGBUG version to allow some of the controlled objects to call?
    enum {CONTROL_SCID = -1, INTERRUPT_SCID = -2, SDP_SCID = -3};
    void sendL2CapCommand(uint8_t* data, uint8_t nbytes, int channel = (int)0x0001);
    void sendL2CapCommand(uint16_t handle, uint8_t* data, uint8_t nbytes, uint8_t channelLow = 0x01, uint8_t channelHigh = 0x00);

    // Force the setting one way or the other.
    void useHIDProtocol(bool useHID);
    void updateHIDProtocol(uint8_t protocol);

    bool setTimer(BluetoothConnection *connection, uint32_t ms);  // set to NULL ptr will clear:


protected:
    virtual bool claim(Device_t *device, int type, const uint8_t *descriptors, uint32_t len);
    virtual void control(const Transfer_t *transfer);
    virtual void disconnect();
    virtual void timer_event(USBDriverTimer *whichTimer);

    // Hack to allow PS3 to maybe change values
    uint16_t        next_dcid_ = 0x70;      // Lets try not hard coding control and interrupt dcid

    BluetoothConnection connections_[DEFAULT_CONNECTIONS];
    uint8_t count_connections_ = 0;
    BluetoothConnection  *current_connection_ = nullptr;    // need to figure out when this changes and/or...
    BluetoothConnection  *timer_connection_ = nullptr;    // need to figure out when this changes and/or...
    BluetoothPairingCB   *pairing_cb_ = nullptr;

private:
    friend class BTHIDInput;
    friend class BluetoothConnection;
    static void rx_callback(const Transfer_t *transfer);
    static void rx2_callback(const Transfer_t *transfer);
    static void tx_callback(const Transfer_t *transfer);
    void rx_data(const Transfer_t *transfer);
    void rx2_data(const Transfer_t *transfer);
    void tx_data(const Transfer_t *transfer);

    void init();

    static bool queue_Data_Transfer_Debug(Pipe_t *pipe, void *buffer,
                                    uint32_t len, USBDriver *driver,
                                    uint32_t line);

    // HCI support functions...
    void sendHCICommand(uint16_t hciCommand, uint16_t cParams, const uint8_t* data);
    //void sendHCIReadLocalSupportedFeatures();
    void inline sendHCI_INQUIRY();
    void inline sendHCIInquiryCancel();
    void inline sendHCICreateConnection();
    void inline sendHCIAuthenticationRequested();
    void inline sendHCIAcceptConnectionRequest();
    void inline sendHCIRejectConnectionRequest(uint8_t bdaddr[6], uint8_t error);
    void inline sendHCILinkKeyRequestReply(uint8_t link_key[16]);
    void inline sendHCILinkKeyNegativeReply();
    void inline sendHCIPinCodeReply();
    void inline sendResetHCI();
    void inline sendHDCWriteClassOfDev();
    void inline sendHCIReadBDAddr();
    void inline sendHCIReadLocalSupportedCommands();
    void inline sendHCIReadLocalSupportedFeatures();
    void inline sendHCIReadLocalVersionInfo();
    void  sendHCIWriteScanEnable(uint8_t scan_op);
    void inline sendHCIHCIWriteInquiryMode(uint8_t inquiry_mode);
    void inline sendHCISetEventMask();

    void inline sendHCIRemoteNameRequest();
    void inline sendHCIRemoteVersionInfoRequest();
    void inline sendHCIRoleDiscoveryRequest();
    void inline sendHCIReadRemoteSupportedFeatures();
    void inline sendHCIReadRemoteExtendedFeatures();
	void inline sendHCISimplePairingMode();
	void inline sendHCIReadSimplePairingMode();
    bool inline sendHCIReadStoredLinkKey(uint8_t link_key[16]);
    void inline sendHCIWriteStoredLinkKey(uint8_t link_key[16]);

	void handle_hci_encryption_change_complete();
	void sendHCISetConnectionEncryption();
    void sendInfoRequest();

    void handle_hci_command_complete();
    void handle_hci_command_status();
    void handle_hci_inquiry_result(bool fRSSI = false);
    void handle_hci_extended_inquiry_result();
    void handle_hci_inquiry_complete();
    void handle_hci_incoming_connect();
    void handle_hci_connection_complete();
    void handle_hci_disconnect_complete();
    void handle_hci_authentication_complete();
    void handle_hci_remote_name_complete();
    void handle_hci_remote_version_information_complete();
    void handle_hci_pin_code_request();
    void handle_hci_link_key_notification();
    void handle_hci_link_key_request();
    void handle_hci_return_link_keys();
    void handle_ev_meta_event(); // 0x3e
    void queue_next_hci_command();

    void handle_HCI_IO_CAPABILITY_REQUEST_REPLY();
    void handle_hci_io_capability_request();
    void handle_hci_io_capability_request_reply();
	void handle_hci_user_confirmation_request_reply();

    void setHIDProtocol(uint8_t protocol);
    static BTHIDInput *available_bthid_drivers_list;

    setup_t setup;
    Pipe_t mypipes[4] __attribute__ ((aligned(32)));
    Transfer_t mytransfers[7] __attribute__ ((aligned(32)));
    strbuf_t mystring_bufs[2];      // 2 string buffers - one for our device - one for remote device...
    uint16_t        pending_control_ = 0;
    uint16_t        rx_size_ = 0;
    uint16_t        rx2_size_ = 0;
    uint16_t        tx_size_ = 0;
    Pipe_t          *rxpipe_;
    Pipe_t          *rx2pipe_;
    Pipe_t          *txpipe_;
    uint8_t         rxbuf_[256];    // used to receive data from RX, which may come with several packets...
    uint8_t         rx_packet_data_remaining_ = 0; // how much data remaining
    uint8_t         txbuf_[256];    // buffer to use to send commands to bluetooth
    uint8_t         rx2buf_[64];    // receive buffer from Bulk end point
    uint8_t         rx2buf2_[256];   // receive buffer from Bulk end point
    uint8_t         rx2_packet_data_remaining_ = 0; // how much data remaining
    uint8_t         rx2_continue_packet_expected_ = 0; // Are we expecting a continue packet. 
    uint8_t         hciVersion;     // what version of HCI do we have?

    bool            do_pair_device_;    // Should we do a pair for a new device?
    const char      *pair_pincode_; // What pin code to use for the pairing
    bool            do_pair_ssp_;   // pair device using SSP
    USBDriverTimer  timer_;
    uint8_t         my_bdaddr_[6];  // The bluetooth dongles Bluetooth address.
    uint8_t         features[8];    // remember our local features.
	
    // key storage info
    FS              *pairing_keys_fs_ = nullptr;
    int             pairing_keys_eeprom_start_index_ = -1;
    int             pairing_keys_max_ = 5;

    typedef struct {
        uint16_t    idVendor;
        uint16_t    idProduct;
    } product_vendor_mapping_t;
    static product_vendor_mapping_t pid_vid_mapping[];

};

class ADK: public USBDriver {
public:
    ADK(USBHost &host) { init(); }
    bool ready();
    void begin(char *adk_manufacturer, char *adk_model, char *adk_desc, char *adk_version, char *adk_uri, char *adk_serial);
    void end();
    int available(void);
    int peek(void);
    int read(void);
    size_t write(size_t len, uint8_t *buf);
protected:
    virtual bool claim(Device_t *device, int type, const uint8_t *descriptors, uint32_t len);
    virtual void disconnect();
    virtual void control(const Transfer_t *transfer);
    static void rx_callback(const Transfer_t *transfer);
    static void tx_callback(const Transfer_t *transfer);
    void rx_data(const Transfer_t *transfer);
    void tx_data(const Transfer_t *transfer);
    void init();
    void rx_queue_packets(uint32_t head, uint32_t tail);
    void sendStr(Device_t *dev, uint8_t index, char *str);
private:
    int state = 0;
    Pipe_t *rxpipe;
    Pipe_t *txpipe;
    enum { MAX_PACKET_SIZE = 512 };
    enum { RX_QUEUE_SIZE = 1024 }; // must be more than MAX_PACKET_SIZE
    uint8_t rx_buffer[MAX_PACKET_SIZE];
    uint8_t tx_buffer[MAX_PACKET_SIZE];
    uint16_t rx_size;
    uint16_t tx_size;
    uint8_t rx_queue[RX_QUEUE_SIZE];
    bool rx_packet_queued;
    uint16_t rx_head;
    uint16_t rx_tail;
    uint8_t rx_ep;
    uint8_t tx_ep;
    char *manufacturer;
    char *model;
    char *desc;
    char *version;
    char *uri;
    char *serial;
    Pipe_t mypipes[3] __attribute__ ((aligned(32)));
    Transfer_t mytransfers[7] __attribute__ ((aligned(32)));
};

//--------------------------------------------------------------------------

#include <SdFat.h>
// Use FILE_READ & FILE_WRITE as defined by FS.h
#if defined(FILE_READ) && !defined(FS_H)
#undef FILE_READ
#endif
#if defined(FILE_WRITE) && !defined(FS_H)
#undef FILE_WRITE
#endif
#include <FS.h>


class USBDrive;

// Simple File System base class that maintains list and defines methods for the Drive object
// to call to each of the file system objects such that they can decide if they will claim a partition
class USBFSBase : public FS {
public:
    USBFSBase();
    operator bool() { return (mydevice != nullptr); }
    enum {USBFS_STATE_CHANGE_CONNECTION = 0x01u, USBFS_STATE_CHANGE_FORMAT = 0x02};
    inline uint8_t stateChanged() { return _state_changed; }
    inline void stateChanged(uint8_t state) { _state_changed = state; }
    uint16_t idVendor() { return (mydevice != nullptr) ? mydevice->idVendor : 0; }
    uint16_t idProduct() { return (mydevice != nullptr) ? mydevice->idProduct : 0; }
    const uint8_t *manufacturer()
    {  return  ((mydevice == nullptr) || (mydevice->strbuf == nullptr)) ? nullptr : &mydevice->strbuf->buffer[mydevice->strbuf->iStrings[strbuf_t::STR_ID_MAN]]; }
    const uint8_t *product()
    {  return  ((mydevice == nullptr) || (mydevice->strbuf == nullptr)) ? nullptr : &mydevice->strbuf->buffer[mydevice->strbuf->iStrings[strbuf_t::STR_ID_PROD]]; }
    const uint8_t *serialNumber()
    {  return  ((mydevice == nullptr) || (mydevice->strbuf == nullptr)) ? nullptr : &mydevice->strbuf->buffer[mydevice->strbuf->iStrings[strbuf_t::STR_ID_SERIAL]]; }


    virtual bool getVolumeLabel(char *volume_label, size_t cb) { return false; }

    // Class level static methods.
    // code that can walk the list
    static USBFSBase *nextFS(USBFSBase *pfs);

    static inline bool anyFSChangedState() {return s_any_fs_changed_state;}
    static inline void anyFSChangedState(bool state) {s_any_fs_changed_state = state;}
private:
    // need to define claim functions
    virtual bool claimPartition(USBDrive *device, int partition, int voltype, int type, uint32_t firstSector, uint32_t numSectors, uint8_t *guid) = 0;
    virtual void releasePartition() = 0;

//  virtual hidclaim_t claim_collection(USBHIDParser *driver, Device_t *dev, uint32_t topusage);
    friend class USBDrive;
protected:
    static USBFSBase *s_first_fs;
    USBFSBase *_next = NULL;
    Device_t *mydevice = NULL;
    uint8_t _state_changed = 0;
    static bool s_any_fs_changed_state;
};



class USBDrive : public USBDriver, public FsBlockDeviceInterface {
public:
    USBDrive(USBHost &host) { init(); }
    USBDrive(USBHost *host) { init(); }


    msSCSICapacity_t msCapacity;
    msInquiryResponse_t msInquiry;
    msRequestSenseResponse_t msSense;
    msDriveInfo_t msDriveInfo;

    bool mscTransferComplete = false;
    uint8_t mscInit(void);
    void msReset(void);
    uint8_t msGetMaxLun(void);
    void msCurrentLun(uint8_t lun) {currentLUN = lun;}
    uint8_t msCurrentLun() {return currentLUN;}
    bool available() { delay(0); return deviceAvailable; }
    uint8_t checkConnectedInitialized(void);
    uint16_t getIDVendor() {return idVendor; }
    uint16_t getIDProduct() {return idProduct; }
    uint8_t getHubNumber() { return hubNumber; }
    uint8_t getHubPort() { return hubPort; }
    uint8_t getDeviceAddress() { return deviceAddress; }
    uint8_t WaitMediaReady();
    uint8_t msTestReady();
    uint8_t msReportLUNs(uint8_t *Buffer);
    uint8_t msStartStopUnit(uint8_t mode);
    uint8_t msReadDeviceCapacity(msSCSICapacity_t * const Capacity);
    uint8_t msDeviceInquiry(msInquiryResponse_t * const Inquiry);
    uint8_t msProcessError(uint8_t msStatus);
    uint8_t msRequestSense(msRequestSenseResponse_t * const Sense);
    uint8_t msRequestSense(void *Sense);

    uint8_t msReadBlocks(const uint32_t BlockAddress, const uint16_t Blocks,
                         const uint16_t BlockSize, void * sectorBuffer);
    uint8_t msReadSectorsWithCB(const uint32_t BlockAddress, const uint16_t Blocks, void (*callback)(uint32_t token, uint8_t* data), uint32_t token);
    uint8_t msWriteBlocks(const uint32_t BlockAddress, const uint16_t Blocks,
                          const uint16_t BlockSize,   const void * sectorBuffer);

    bool begin();
    // Not sure of good name here.
    // maybe startFilesystems(), enumFileSystems()...
    bool startFilesystems();
    bool filesystemsStarted() {return _drive_connect_fs_status == USBDRIVE_FS_STARTED;}

    bool updateConnectedFilesystems();

    // Schedule when the updatedConnectedFilesystems should be called
    // when = 0(manual), 1(MTP::loop)
    enum {UPDATE_MANUAL = 0, UPDATE_TASK = 1};
    void whenToUpdateConnectedFilesystems(int when) {s_when_to_update = when; }
    int whenToUpdateConnectedFilesystems() {return s_when_to_update;}

    static bool connectedFilesystemsChanged() {return s_connected_filesystems_changed;}
    static void connectedFilesystemsChanged(bool changed) {s_connected_filesystems_changed = changed;}

    void printPartionTable(Print &Serialx);
    void printExtendedPartition(MbrSector_t *mbr, uint8_t ipExt, Print &Serialx);
    uint32_t printGUIDPartitionTable(Print &Serialx);

    enum {INVALID_VOL = 0, MBR_VOL, EXT_VOL, GPT_VOL}; // what type of volume did the mapping return
    int findPartition(int partition, int &type, uint32_t &firstSector, uint32_t &numSectors,
                      uint32_t &mbrLBA, uint8_t &mbrPart, uint8_t *guid = nullptr);


public:
    // Functions for SdFat FsBlockDeviceInterface
    // return the number of 512 byte sectors for the whole drive
    uint32_t sectorCount() { return msDriveInfo.capacity.Blocks; }
    // return code for the last error.  (where is list of errors?)
    uint8_t errorCode() const { return m_errorCode; }
    // return error data for last error.
    uint32_t errorData() const { return 0; }
    // return error line for last error. Tmp function for debug.
    uint32_t errorLine() const { return m_errorLine; }
    // Check for busy
    bool isBusy() { return !m_initDone && !mscTransferComplete; }
    // Check for busy with MSC read operation
    bool isBusyRead() { return mscTransferComplete; }
    // Check for busy with MSC read operation
    bool isBusyWrite() { return mscTransferComplete; }
    // Read a USB drive's information. This contains the drive's identification
    // information such as Manufacturer ID, Product name, Product serial
    // number and Manufacturing date pluse more.
    bool readUSBDriveInfo(msDriveInfo_t * driveInfo) {
        memcpy(driveInfo, &msDriveInfo, sizeof(msDriveInfo_t));
        return true;
    }
    // Read a 512 byte sector from an USB MSC drive.
    bool readSector(uint32_t sector, uint8_t* dst);
    // Read multiple 512 byte sectors from an USB MSC drive.
    bool readSectors(uint32_t sector, uint8_t* dst, size_t numsectors);
    // return USB MSC drive status.
    uint32_t status() { return m_errorCode; }
    // return success if sync successful. Not for user apps.
    bool syncDevice() { return true; }
    // Writes a 512 byte sector to an USB MSC drive.
    bool writeSector(uint32_t sector, const uint8_t* src);
    // Write multiple 512 byte sectors to an USB MSC drive.
    bool writeSectors(uint32_t sector, const uint8_t* src, size_t ns);
    // Read multiple 512 byte sectors from an USB MSC drive, using
    // a callback per sector
    bool readSectorsWithCB(uint32_t sector, size_t ns,
                           void (*callback)(uint32_t, uint8_t *), uint32_t token);
    bool readSectorsCallback(uint32_t sector, uint8_t* dst, size_t numSectors,
                             void (*callback)(uint32_t sector, uint8_t *buf, void *context), void *context);
    //bool writeSectorsCallback(uint32_t sector, size_t numSectors,
    //  const uint8_t * (*callback)(uint32_t sector, void *context), void *context);

protected:
    virtual bool claim(Device_t *device, int type, const uint8_t *descriptors, uint32_t len);
    virtual void control(const Transfer_t *transfer);
    virtual void disconnect();
    virtual void Task();
    static void callbackIn(const Transfer_t *transfer);
    static void callbackOut(const Transfer_t *transfer);
    void new_dataIn(const Transfer_t *transfer);
    void new_dataOut(const Transfer_t *transfer);
    void init();
    uint8_t msDoCommand(msCommandBlockWrapper_t *CBW, void *buffer);
    uint8_t msGetCSW(void);
private:
    Pipe_t mypipes[3] __attribute__ ((aligned(32)));
    Transfer_t mytransfers[7] __attribute__ ((aligned(32)));
    strbuf_t mystring_bufs[1];
    uint32_t packetSizeIn;
    uint32_t packetSizeOut;
    Pipe_t *datapipeIn;
    Pipe_t *datapipeOut;
    uint8_t bInterfaceNumber;
    uint32_t endpointIn = 0;
    uint32_t endpointOut = 0;
    setup_t setup;
    uint8_t report[8];
    uint8_t maxLUN = 0;
    uint8_t currentLUN = 0;
//  msSCSICapacity_t msCapacity;
//  msInquiryResponse_t msInquiry;
//  msRequestSenseResponse_t msSense;
    uint16_t idVendor = 0;
    uint16_t idProduct = 0;
    uint8_t hubNumber = 0;
    uint8_t hubPort = 0;
    uint8_t deviceAddress = 0;
    volatile bool msOutCompleted = false;
    volatile bool msInCompleted = false;
    volatile bool msControlCompleted = false;
    uint32_t CBWTag = 0;
    bool deviceAvailable = false;
    // experiment with transfers with callbacks.
    void (*_read_sectors_callback)(uint32_t token, uint8_t* data) = nullptr;
    uint32_t _read_sectors_token = 0;
    uint16_t _read_sectors_remaining = 0;
    enum {READ_CALLBACK_TIMEOUT_MS = 250};
    elapsedMillis _emlastRead;
    uint8_t _read_sector_buffer1[512];
    uint8_t _read_sector_buffer2[512];
    bool m_initDone = false;
    uint8_t m_errorCode = MS_NO_MEDIA_ERR;
    uint32_t m_errorLine = 0;
    USBFSBase *claimed_filesystem_list = nullptr;
    enum {USBDRIVE_NOT_CONNECTED = 0, USBDRIVE_CONNECTED = 1, USBDRIVE_FS_STARTED = 2};
    int _drive_connect_fs_status = USBDRIVE_NOT_CONNECTED;
    int _cGPTParts = 0;  // if GPT cache of parts.

    static USBDrive *s_first_drive;
    static bool s_connected_filesystems_changed;
    static int s_when_to_update; // default to Task()
    USBDrive *_next_drive = nullptr;

};

#define MSC_MAX_FILENAME_LEN 256

class MSCFile : public FileImpl
{
private:
    // Classes derived from File are never meant to be constructed
    // anywhere other than open() in the parent FS class and
    // openNextFile() while traversing a directory.
    // Only the abstract File class which references these derived
    // classes is meant to have a public constructor!
    MSCFile(const FsFile &file) : mscfatfile(file), filename(nullptr) { }
    friend class USBFilesystem;
public:
    virtual ~MSCFile(void) {
        if (mscfatfile) mscfatfile.close();
        if (filename) free(filename);
    }
#ifdef FILE_WHOAMI
    virtual void whoami() {
        Serial.printf("   MSCFile this=%x, refcount=%u\n",
                      (int)this, getRefcount());
    }
#endif
    virtual size_t write(const void *buf, size_t size) {
        return mscfatfile.write(buf, size);
    }
    virtual int peek() {
        return mscfatfile.peek();
    }
    virtual int available() {
        return mscfatfile.available();
    }
    virtual void flush() {
        mscfatfile.flush();
    }
    virtual size_t read(void *buf, size_t nbyte) {
        return mscfatfile.read(buf, nbyte);
    }
    virtual bool truncate(uint64_t size = 0) {
        return mscfatfile.truncate(size);
    }
    virtual bool seek(uint64_t pos, int mode = SeekSet) {
        if (mode == SeekSet) return mscfatfile.seekSet(pos);
        if (mode == SeekCur) return mscfatfile.seekCur(pos);
        if (mode == SeekEnd) return mscfatfile.seekEnd(pos);
        return false;
    }
    virtual uint64_t position() {
        return mscfatfile.curPosition();
    }
    virtual uint64_t size() {
        return mscfatfile.size();
    }
    virtual void close() {
        if (filename) {
            free(filename);
            filename = nullptr;
        }
        mscfatfile.close();
    }
    virtual bool isOpen() {
        return mscfatfile.isOpen();
    }
    virtual const char * name() {
        if (!filename) {
            filename = (char *)malloc(MSC_MAX_FILENAME_LEN);
            if (filename) {
                mscfatfile.getName(filename, MSC_MAX_FILENAME_LEN);
            } else {
                static char zeroterm = 0;
                filename = &zeroterm;
            }
        }
        return filename;
    }
    virtual boolean isDirectory(void) {
        return mscfatfile.isDirectory();
    }
    virtual File openNextFile(uint8_t mode = 0) {
        FsFile file = mscfatfile.openNextFile();
        if (file) return File(new MSCFile(file));
        return File();
    }
    virtual void rewindDirectory(void) {
        mscfatfile.rewindDirectory();
    }
    virtual bool getCreateTime(DateTimeFields &tm) {
        uint16_t fat_date, fat_time;
        if (!mscfatfile.getCreateDateTime(&fat_date, &fat_time)) return false;
        if ((fat_date == 0) && (fat_time == 0)) return false;
        tm.sec = FS_SECOND(fat_time);
        tm.min = FS_MINUTE(fat_time);
        tm.hour = FS_HOUR(fat_time);
        tm.mday = FS_DAY(fat_date);
        tm.mon = FS_MONTH(fat_date) - 1;
        tm.year = FS_YEAR(fat_date) - 1900;
        return true;
    }
    virtual bool getModifyTime(DateTimeFields &tm) {
        uint16_t fat_date, fat_time;
        if (!mscfatfile.getModifyDateTime(&fat_date, &fat_time)) return false;
        if ((fat_date == 0) && (fat_time == 0)) return false;
        tm.sec = FS_SECOND(fat_time);
        tm.min = FS_MINUTE(fat_time);
        tm.hour = FS_HOUR(fat_time);
        tm.mday = FS_DAY(fat_date);
        tm.mon = FS_MONTH(fat_date) - 1;
        tm.year = FS_YEAR(fat_date) - 1900;
        return true;
    }
    virtual bool setCreateTime(const DateTimeFields &tm) {
        if (tm.year < 80 || tm.year > 207) return false;
        return mscfatfile.timestamp(T_CREATE, tm.year + 1900, tm.mon + 1,
                                    tm.mday, tm.hour, tm.min, tm.sec);
    }
    virtual bool setModifyTime(const DateTimeFields &tm) {
        if (tm.year < 80 || tm.year > 207) return false;
        return mscfatfile.timestamp(T_WRITE, tm.year + 1900, tm.mon + 1,
                                    tm.mday, tm.hour, tm.min, tm.sec);
    }

private:
    FsFile mscfatfile;
    char *filename;
};

class USBFilesystem : public USBFSBase
{
public:
    USBFilesystem(USBHost &host) : USBFSBase() { init(); }
    USBFilesystem(USBHost *host) : USBFSBase() { init(); }

	void end();
	void init();
	
    virtual bool getVolumeLabel(char *volume_label, size_t cb) { return mscfs.getVolumeLabel(volume_label, cb); }

    operator bool() {
        // use of volatile prevents compiler from optimizing away
        // re-reading the pointer if program repeated checks bool()
        USBDrive *dev = *(USBDrive * volatile *)&device;
        return dev != nullptr;
    }

    // will remove soon, older versions to detect formatted.
    inline bool changed() {return _state_changed == USBFS_STATE_CHANGE_FORMAT;;}
    inline void changed(bool fChanged) {
        if (fChanged) _state_changed = USBFS_STATE_CHANGE_FORMAT;
        else _state_changed &= ~USBFS_STATE_CHANGE_FORMAT;
    }

    File open(const char *filepath, uint8_t mode = FILE_READ) {
        oflag_t flags = O_READ;
        if (mode == FILE_WRITE) { flags = O_RDWR | O_CREAT | O_AT_END; }
        else if (mode == FILE_WRITE_BEGIN) { flags = O_RDWR | O_CREAT; }
        FsFile file = mscfs.open(filepath, flags);
        if (file) return File(new MSCFile(file));
        return File();
    }
    bool exists(const char *filepath) {
        return mscfs.exists(filepath);
    }
    bool mkdir(const char *filepath) {
        return mscfs.mkdir(filepath);
    }
    bool rename(const char *oldfilepath, const char *newfilepath) {
        return mscfs.rename(oldfilepath, newfilepath);
    }
    bool remove(const char *filepath) {
        return mscfs.remove(filepath);
    }
    bool rmdir(const char *filepath) {
        return mscfs.rmdir(filepath);
    }
    uint64_t usedSize() {
        return  (uint64_t)(mscfs.clusterCount() - mscfs.freeClusterCount())
                * (uint64_t)mscfs.bytesPerCluster();
    }
    uint64_t totalSize() {
        return (uint64_t)mscfs.clusterCount() * (uint64_t)mscfs.bytesPerCluster();
    }

    bool format(int type = 0, char progressChar = 0, Print& pr = Serial);

    void printError(Print &p = Serial);
protected:
    virtual bool claimPartition(USBDrive *device, int partition, int voltype, int type, uint32_t firstSector, uint32_t numSectors, uint8_t *guid = nullptr);
    virtual void releasePartition();
    bool check_voltype_guid(int voltype, uint8_t *guid);
    bool changed_ = false;

public:
    FsVolume mscfs;      // SdFat API
    USBDrive *device;
    int partition;
    int partitionType;



};


// do not expose these defines in Arduino sketches or other libraries
#undef MSC_MAX_FILENAME_LEN



#endif