wirtz
/
MicroDexed
mirror of https://codeberg.org/dcoredump/MicroDexed.git
1
1
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1329 Commits
2 Branches
1 Tag
401 MiB
 
 
Tag: Branch: Tree: dev
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'dev'
${ noResults }
MicroDexed/third-party/USBHost_t36/USBHost_t36.h

2885 lines
116 KiB
Raw Permalink Blame History

/* 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);
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