diff options
| author | Nick Brassel <[email protected]> | 2021-08-29 08:20:25 +1000 | 
|---|---|---|
| committer | Nick Brassel <[email protected]> | 2021-08-29 08:20:25 +1000 | 
| commit | f061ca497464fe85284906fb163a33eaee7a91ef (patch) | |
| tree | 33ef1bfb529aed382e8526c607c4e18717f92571 /lib/usbhost/USB_Host_Shield_2.0/BTD.h | |
| parent | ff65185dec6f97be1eb49f17cea526a0d0bbf3d6 (diff) | |
| parent | 4bad375d7c09d949a9dcdd4feba147c9c7a67ec6 (diff) | |
| download | qmk_firmware-f061ca497464fe85284906fb163a33eaee7a91ef.tar.gz qmk_firmware-f061ca497464fe85284906fb163a33eaee7a91ef.zip | |
Breaking changes develop merge to master, 2021Q3 edition. (#14196)breakpoint_2021_08_280.14.0
Diffstat (limited to 'lib/usbhost/USB_Host_Shield_2.0/BTD.h')
| -rw-r--r-- | lib/usbhost/USB_Host_Shield_2.0/BTD.h | 620 | 
1 files changed, 620 insertions, 0 deletions
| diff --git a/lib/usbhost/USB_Host_Shield_2.0/BTD.h b/lib/usbhost/USB_Host_Shield_2.0/BTD.h new file mode 100644 index 0000000000..6549c30c98 --- /dev/null +++ b/lib/usbhost/USB_Host_Shield_2.0/BTD.h @@ -0,0 +1,620 @@ +/* Copyright (C) 2012 Kristian Lauszus, TKJ Electronics. All rights reserved. + + This software may be distributed and modified under the terms of the GNU + General Public License version 2 (GPL2) as published by the Free Software + Foundation and appearing in the file GPL2.TXT included in the packaging of + this file. Please note that GPL2 Section 2[b] requires that all works based + on this software must also be made publicly available under the terms of + the GPL2 ("Copyleft"). + + Contact information + ------------------- + + Kristian Lauszus, TKJ Electronics + Web      :  http://www.tkjelectronics.com + e-mail   :  [email protected] + */ + +#ifndef _btd_h_ +#define _btd_h_ + +#include "Usb.h" +#include "hid.h" + +//PID and VID of the Sony PS3 devices +#define PS3_VID                 0x054C  // Sony Corporation +#define PS3_PID                 0x0268  // PS3 Controller DualShock 3 +#define PS3NAVIGATION_PID       0x042F  // Navigation controller +#define PS3MOVE_PID             0x03D5  // Motion controller + +#define IOGEAR_GBU521_VID       0x0A5C // The IOGEAR GBU521 dongle does not presents itself correctly, so we have to check for it manually +#define IOGEAR_GBU521_PID       0x21E8 + +/* Bluetooth dongle data taken from descriptors */ +#define BULK_MAXPKTSIZE         64 // Max size for ACL data + +// Used in control endpoint header for HCI Commands +#define bmREQ_HCI_OUT USB_SETUP_HOST_TO_DEVICE|USB_SETUP_TYPE_CLASS|USB_SETUP_RECIPIENT_DEVICE + +/* Bluetooth HCI states for hci_task() */ +#define HCI_INIT_STATE                  0 +#define HCI_RESET_STATE                 1 +#define HCI_CLASS_STATE                 2 +#define HCI_BDADDR_STATE                3 +#define HCI_LOCAL_VERSION_STATE         4 +#define HCI_SET_NAME_STATE              5 +#define HCI_CHECK_DEVICE_SERVICE        6 + +#define HCI_INQUIRY_STATE               7 // These three states are only used if it should pair and connect to a device +#define HCI_CONNECT_DEVICE_STATE        8 +#define HCI_CONNECTED_DEVICE_STATE      9 + +#define HCI_SCANNING_STATE              10 +#define HCI_CONNECT_IN_STATE            11 +#define HCI_REMOTE_NAME_STATE           12 +#define HCI_CONNECTED_STATE             13 +#define HCI_DISABLE_SCAN_STATE          14 +#define HCI_DONE_STATE                  15 +#define HCI_DISCONNECT_STATE            16 + +/* HCI event flags*/ +#define HCI_FLAG_CMD_COMPLETE           (1UL << 0) +#define HCI_FLAG_CONNECT_COMPLETE       (1UL << 1) +#define HCI_FLAG_DISCONNECT_COMPLETE    (1UL << 2) +#define HCI_FLAG_REMOTE_NAME_COMPLETE   (1UL << 3) +#define HCI_FLAG_INCOMING_REQUEST       (1UL << 4) +#define HCI_FLAG_READ_BDADDR            (1UL << 5) +#define HCI_FLAG_READ_VERSION           (1UL << 6) +#define HCI_FLAG_DEVICE_FOUND           (1UL << 7) +#define HCI_FLAG_CONNECT_EVENT          (1UL << 8) + +/* Macros for HCI event flag tests */ +#define hci_check_flag(flag) (hci_event_flag & (flag)) +#define hci_set_flag(flag) (hci_event_flag |= (flag)) +#define hci_clear_flag(flag) (hci_event_flag &= ~(flag)) + +/* HCI Events managed */ +#define EV_INQUIRY_COMPLETE                             0x01 +#define EV_INQUIRY_RESULT                               0x02 +#define EV_CONNECT_COMPLETE                             0x03 +#define EV_INCOMING_CONNECT                             0x04 +#define EV_DISCONNECT_COMPLETE                          0x05 +#define EV_AUTHENTICATION_COMPLETE                      0x06 +#define EV_REMOTE_NAME_COMPLETE                         0x07 +#define EV_ENCRYPTION_CHANGE                            0x08 +#define EV_CHANGE_CONNECTION_LINK                       0x09 +#define EV_ROLE_CHANGED                                 0x12 +#define EV_NUM_COMPLETE_PKT                             0x13 +#define EV_PIN_CODE_REQUEST                             0x16 +#define EV_LINK_KEY_REQUEST                             0x17 +#define EV_LINK_KEY_NOTIFICATION                        0x18 +#define EV_DATA_BUFFER_OVERFLOW                         0x1A +#define EV_MAX_SLOTS_CHANGE                             0x1B +#define EV_READ_REMOTE_VERSION_INFORMATION_COMPLETE     0x0C +#define EV_QOS_SETUP_COMPLETE                           0x0D +#define EV_COMMAND_COMPLETE                             0x0E +#define EV_COMMAND_STATUS                               0x0F +#define EV_LOOPBACK_COMMAND                             0x19 +#define EV_PAGE_SCAN_REP_MODE                           0x20 + +/* Bluetooth states for the different Bluetooth drivers */ +#define L2CAP_WAIT                      0 +#define L2CAP_DONE                      1 + +/* Used for HID Control channel */ +#define L2CAP_CONTROL_CONNECT_REQUEST   2 +#define L2CAP_CONTROL_CONFIG_REQUEST    3 +#define L2CAP_CONTROL_SUCCESS           4 +#define L2CAP_CONTROL_DISCONNECT        5 + +/* Used for HID Interrupt channel */ +#define L2CAP_INTERRUPT_SETUP           6 +#define L2CAP_INTERRUPT_CONNECT_REQUEST 7 +#define L2CAP_INTERRUPT_CONFIG_REQUEST  8 +#define L2CAP_INTERRUPT_DISCONNECT      9 + +/* Used for SDP channel */ +#define L2CAP_SDP_WAIT                  10 +#define L2CAP_SDP_SUCCESS               11 + +/* Used for RFCOMM channel */ +#define L2CAP_RFCOMM_WAIT               12 +#define L2CAP_RFCOMM_SUCCESS            13 + +#define L2CAP_DISCONNECT_RESPONSE       14 // Used for both SDP and RFCOMM channel + +/* Bluetooth states used by some drivers */ +#define TURN_ON_LED                     17 +#define PS3_ENABLE_SIXAXIS              18 +#define WII_CHECK_MOTION_PLUS_STATE     19 +#define WII_CHECK_EXTENSION_STATE       20 +#define WII_INIT_MOTION_PLUS_STATE      21 + +/* L2CAP event flags for HID Control channel */ +#define L2CAP_FLAG_CONNECTION_CONTROL_REQUEST           (1UL << 0) +#define L2CAP_FLAG_CONFIG_CONTROL_SUCCESS               (1UL << 1) +#define L2CAP_FLAG_CONTROL_CONNECTED                    (1UL << 2) +#define L2CAP_FLAG_DISCONNECT_CONTROL_RESPONSE          (1UL << 3) + +/* L2CAP event flags for HID Interrupt channel */ +#define L2CAP_FLAG_CONNECTION_INTERRUPT_REQUEST         (1UL << 4) +#define L2CAP_FLAG_CONFIG_INTERRUPT_SUCCESS             (1UL << 5) +#define L2CAP_FLAG_INTERRUPT_CONNECTED                  (1UL << 6) +#define L2CAP_FLAG_DISCONNECT_INTERRUPT_RESPONSE        (1UL << 7) + +/* L2CAP event flags for SDP channel */ +#define L2CAP_FLAG_CONNECTION_SDP_REQUEST               (1UL << 8) +#define L2CAP_FLAG_CONFIG_SDP_SUCCESS                   (1UL << 9) +#define L2CAP_FLAG_DISCONNECT_SDP_REQUEST               (1UL << 10) + +/* L2CAP event flags for RFCOMM channel */ +#define L2CAP_FLAG_CONNECTION_RFCOMM_REQUEST            (1UL << 11) +#define L2CAP_FLAG_CONFIG_RFCOMM_SUCCESS                (1UL << 12) +#define L2CAP_FLAG_DISCONNECT_RFCOMM_REQUEST            (1UL << 13) + +#define L2CAP_FLAG_DISCONNECT_RESPONSE                  (1UL << 14) + +/* Macros for L2CAP event flag tests */ +#define l2cap_check_flag(flag) (l2cap_event_flag & (flag)) +#define l2cap_set_flag(flag) (l2cap_event_flag |= (flag)) +#define l2cap_clear_flag(flag) (l2cap_event_flag &= ~(flag)) + +/* L2CAP signaling commands */ +#define L2CAP_CMD_COMMAND_REJECT        0x01 +#define L2CAP_CMD_CONNECTION_REQUEST    0x02 +#define L2CAP_CMD_CONNECTION_RESPONSE   0x03 +#define L2CAP_CMD_CONFIG_REQUEST        0x04 +#define L2CAP_CMD_CONFIG_RESPONSE       0x05 +#define L2CAP_CMD_DISCONNECT_REQUEST    0x06 +#define L2CAP_CMD_DISCONNECT_RESPONSE   0x07 +#define L2CAP_CMD_INFORMATION_REQUEST   0x0A +#define L2CAP_CMD_INFORMATION_RESPONSE  0x0B + +// Used For Connection Response - Remember to Include High Byte +#define PENDING     0x01 +#define SUCCESSFUL  0x00 + +/* Bluetooth L2CAP PSM - see http://www.bluetooth.org/Technical/AssignedNumbers/logical_link.htm */ +#define SDP_PSM         0x01 // Service Discovery Protocol PSM Value +#define RFCOMM_PSM      0x03 // RFCOMM PSM Value +#define HID_CTRL_PSM    0x11 // HID_Control PSM Value +#define HID_INTR_PSM    0x13 // HID_Interrupt PSM Value + +// Used to determine if it is a Bluetooth dongle +#define WI_SUBCLASS_RF      0x01 // RF Controller +#define WI_PROTOCOL_BT      0x01 // Bluetooth Programming Interface + +#define BTD_MAX_ENDPOINTS   4 +#define BTD_NUM_SERVICES    4 // Max number of Bluetooth services - if you need more than 4 simply increase this number + +#define PAIR    1 + +class BluetoothService; + +/** + * The Bluetooth Dongle class will take care of all the USB communication + * and then pass the data to the BluetoothService classes. + */ +class BTD : public USBDeviceConfig, public UsbConfigXtracter { +public: +        /** +         * Constructor for the BTD class. +         * @param  p   Pointer to USB class instance. +         */ +        BTD(USB *p); + +        /** @name USBDeviceConfig implementation */ +        /** +         * Address assignment and basic initialization is done here. +         * @param  parent   Hub number. +         * @param  port     Port number on the hub. +         * @param  lowspeed Speed of the device. +         * @return          0 on success. +         */ +        uint8_t ConfigureDevice(uint8_t parent, uint8_t port, bool lowspeed); +        /** +         * Initialize the Bluetooth dongle. +         * @param  parent   Hub number. +         * @param  port     Port number on the hub. +         * @param  lowspeed Speed of the device. +         * @return          0 on success. +         */ +        uint8_t Init(uint8_t parent, uint8_t port, bool lowspeed); +        /** +         * Release the USB device. +         * @return 0 on success. +         */ +        uint8_t Release(); +        /** +         * Poll the USB Input endpoints and run the state machines. +         * @return 0 on success. +         */ +        uint8_t Poll(); + +        /** +         * Get the device address. +         * @return The device address. +         */ +        virtual uint8_t GetAddress() { +                return bAddress; +        }; + +        /** +         * Used to check if the dongle has been initialized. +         * @return True if it's ready. +         */ +        virtual bool isReady() { +                return bPollEnable; +        }; + +        /** +         * Used by the USB core to check what this driver support. +         * @param  klass The device's USB class. +         * @return       Returns true if the device's USB class matches this driver. +         */ +        virtual bool DEVCLASSOK(uint8_t klass) { +                return (klass == USB_CLASS_WIRELESS_CTRL); +        }; + +        /** +         * Used by the USB core to check what this driver support. +         * Used to set the Bluetooth address into the PS3 controllers. +         * @param  vid The device's VID. +         * @param  pid The device's PID. +         * @return     Returns true if the device's VID and PID matches this driver. +         */ +        virtual bool VIDPIDOK(uint16_t vid, uint16_t pid) { +                if(vid == IOGEAR_GBU521_VID && pid == IOGEAR_GBU521_PID) +                        return true; +                if(my_bdaddr[0] != 0x00 || my_bdaddr[1] != 0x00 || my_bdaddr[2] != 0x00 || my_bdaddr[3] != 0x00 || my_bdaddr[4] != 0x00 || my_bdaddr[5] != 0x00) { // Check if Bluetooth address is set +                        if(vid == PS3_VID && (pid == PS3_PID || pid == PS3NAVIGATION_PID || pid == PS3MOVE_PID)) +                                return true; +                } +                return false; +        }; +        /**@}*/ + +        /** @name UsbConfigXtracter implementation */ +        /** +         * UsbConfigXtracter implementation, used to extract endpoint information. +         * @param conf  Configuration value. +         * @param iface Interface number. +         * @param alt   Alternate setting. +         * @param proto Interface Protocol. +         * @param ep    Endpoint Descriptor. +         */ +        void EndpointXtract(uint8_t conf, uint8_t iface, uint8_t alt, uint8_t proto, const USB_ENDPOINT_DESCRIPTOR *ep); +        /**@}*/ + +        /** Disconnects both the L2CAP Channel and the HCI Connection for all Bluetooth services. */ +        void disconnect(); + +        /** +         * Register Bluetooth dongle members/services. +         * @param  pService Pointer to BluetoothService class instance. +         * @return          The service ID on success or -1 on fail. +         */ +        int8_t registerBluetoothService(BluetoothService *pService) { +                for(uint8_t i = 0; i < BTD_NUM_SERVICES; i++) { +                        if(!btService[i]) { +                                btService[i] = pService; +                                return i; // Return ID +                        } +                } +                return -1; // Error registering BluetoothService +        }; + +        /** @name HCI Commands */ +        /** +         * Used to send a HCI Command. +         * @param data   Data to send. +         * @param nbytes Number of bytes to send. +         */ +        void HCI_Command(uint8_t* data, uint16_t nbytes); +        /** Reset the Bluetooth dongle. */ +        void hci_reset(); +        /** Read the Bluetooth address of the dongle. */ +        void hci_read_bdaddr(); +        /** Read the HCI Version of the Bluetooth dongle. */ +        void hci_read_local_version_information(); +        /** +         * Set the local name of the Bluetooth dongle. +         * @param name Desired name. +         */ +        void hci_set_local_name(const char* name); +        /** Enable visibility to other Bluetooth devices. */ +        void hci_write_scan_enable(); +        /** Disable visibility to other Bluetooth devices. */ +        void hci_write_scan_disable(); +        /** Read the remote devices name. */ +        void hci_remote_name(); +        /** Accept the connection with the Bluetooth device. */ +        void hci_accept_connection(); +        /** +         * Disconnect the HCI connection. +         * @param handle The HCI Handle for the connection. +         */ +        void hci_disconnect(uint16_t handle); +        /** +         * Respond with the pin for the connection. +         * The pin is automatically set for the Wii library, +         * but can be customized for the SPP library. +         */ +        void hci_pin_code_request_reply(); +        /** Respons when no pin was set. */ +        void hci_pin_code_negative_request_reply(); +        /** +         * Command is used to reply to a Link Key Request event from the BR/EDR Controller +         * if the Host does not have a stored Link Key for the connection. +         */ +        void hci_link_key_request_negative_reply(); +        /** Used to try to authenticate with the remote device. */ +        void hci_authentication_request(); +        /** Start a HCI inquiry. */ +        void hci_inquiry(); +        /** Cancel a HCI inquiry. */ +        void hci_inquiry_cancel(); +        /** Connect to last device communicated with. */ +        void hci_connect(); +        /** +         * Connect to device. +         * @param bdaddr Bluetooth address of the device. +         */ +        void hci_connect(uint8_t *bdaddr); +        /** Used to a set the class of the device. */ +        void hci_write_class_of_device(); +        /**@}*/ + +        /** @name L2CAP Commands */ +        /** +         * Used to send L2CAP Commands. +         * @param handle      HCI Handle. +         * @param data        Data to send. +         * @param nbytes      Number of bytes to send. +         * @param channelLow,channelHigh  Low and high byte of channel to send to. +         * If argument is omitted then the Standard L2CAP header: Channel ID (0x01) for ACL-U will be used. +         */ +        void L2CAP_Command(uint16_t handle, uint8_t* data, uint8_t nbytes, uint8_t channelLow = 0x01, uint8_t channelHigh = 0x00); +        /** +         * L2CAP Connection Request. +         * @param handle HCI handle. +         * @param rxid   Identifier. +         * @param scid   Source Channel Identifier. +         * @param psm    Protocol/Service Multiplexer - see: https://www.bluetooth.org/Technical/AssignedNumbers/logical_link.htm. +         */ +        void l2cap_connection_request(uint16_t handle, uint8_t rxid, uint8_t* scid, uint16_t psm); +        /** +         * L2CAP Connection Response. +         * @param handle HCI handle. +         * @param rxid   Identifier. +         * @param dcid   Destination Channel Identifier. +         * @param scid   Source Channel Identifier. +         * @param result Result - First send ::PENDING and then ::SUCCESSFUL. +         */ +        void l2cap_connection_response(uint16_t handle, uint8_t rxid, uint8_t* dcid, uint8_t* scid, uint8_t result); +        /** +         * L2CAP Config Request. +         * @param handle HCI Handle. +         * @param rxid   Identifier. +         * @param dcid   Destination Channel Identifier. +         */ +        void l2cap_config_request(uint16_t handle, uint8_t rxid, uint8_t* dcid); +        /** +         * L2CAP Config Response. +         * @param handle HCI Handle. +         * @param rxid   Identifier. +         * @param scid   Source Channel Identifier. +         */ +        void l2cap_config_response(uint16_t handle, uint8_t rxid, uint8_t* scid); +        /** +         * L2CAP Disconnection Request. +         * @param handle HCI Handle. +         * @param rxid   Identifier. +         * @param dcid   Device Channel Identifier. +         * @param scid   Source Channel Identifier. +         */ +        void l2cap_disconnection_request(uint16_t handle, uint8_t rxid, uint8_t* dcid, uint8_t* scid); +        /** +         * L2CAP Disconnection Response. +         * @param handle HCI Handle. +         * @param rxid   Identifier. +         * @param dcid   Device Channel Identifier. +         * @param scid   Source Channel Identifier. +         */ +        void l2cap_disconnection_response(uint16_t handle, uint8_t rxid, uint8_t* dcid, uint8_t* scid); +        /** +         * L2CAP Information Response. +         * @param handle       HCI Handle. +         * @param rxid         Identifier. +         * @param infoTypeLow,infoTypeHigh  Infotype. +         */ +        void l2cap_information_response(uint16_t handle, uint8_t rxid, uint8_t infoTypeLow, uint8_t infoTypeHigh); +        /**@}*/ + +        /** Use this to see if it is waiting for a incoming connection. */ +        bool watingForConnection; +        /** This is used by the service to know when to store the device information. */ +        bool l2capConnectionClaimed; +        /** This is used by the SPP library to claim the current SDP incoming request. */ +        bool sdpConnectionClaimed; +        /** This is used by the SPP library to claim the current RFCOMM incoming request. */ +        bool rfcommConnectionClaimed; + +        /** The name you wish to make the dongle show up as. It is set automatically by the SPP library. */ +        const char* btdName; +        /** The pin you wish to make the dongle use for authentication. It is set automatically by the SPP and BTHID library. */ +        const char* btdPin; + +        /** The bluetooth dongles Bluetooth address. */ +        uint8_t my_bdaddr[6]; +        /** HCI handle for the last connection. */ +        uint16_t hci_handle; +        /** Last incoming devices Bluetooth address. */ +        uint8_t disc_bdaddr[6]; +        /** First 30 chars of last remote name. */ +        char remote_name[30]; +        /** +         * The supported HCI Version read from the Bluetooth dongle. +         * Used by the PS3BT library to check the HCI Version of the Bluetooth dongle, +         * it should be at least 3 to work properly with the library. +         */ +        uint8_t hci_version; + +        /** Call this function to pair with a Wiimote */ +        void pairWithWiimote() { +                pairWithWii = true; +                hci_state = HCI_CHECK_DEVICE_SERVICE; +        }; +        /** Used to only send the ACL data to the Wiimote. */ +        bool connectToWii; +        /** True if a Wiimote is connecting. */ +        bool incomingWii; +        /** True when it should pair with a Wiimote. */ +        bool pairWithWii; +        /** True if it's the new Wiimote with the Motion Plus Inside or a Wii U Pro Controller. */ +        bool motionPlusInside; +        /** True if it's a Wii U Pro Controller. */ +        bool wiiUProController; + +        /** Call this function to pair with a Wiimote */ +        void pairWithHID() { +                pairWithHIDDevice = true; +                hci_state = HCI_CHECK_DEVICE_SERVICE; +        }; +        /** Used to only send the ACL data to the Wiimote. */ +        bool connectToHIDDevice; +        /** True if a Wiimote is connecting. */ +        bool incomingHIDDevice; +        /** True when it should pair with a device like a mouse or keyboard. */ +        bool pairWithHIDDevice; + +        /** +         * Read the poll interval taken from the endpoint descriptors. +         * @return The poll interval in ms. +         */ +        uint8_t readPollInterval() { +                return pollInterval; +        }; + +protected: +        /** Pointer to USB class instance. */ +        USB *pUsb; +        /** Device address. */ +        uint8_t bAddress; +        /** Endpoint info structure. */ +        EpInfo epInfo[BTD_MAX_ENDPOINTS]; + +        /** Configuration number. */ +        uint8_t bConfNum; +        /** Total number of endpoints in the configuration. */ +        uint8_t bNumEP; +        /** Next poll time based on poll interval taken from the USB descriptor. */ +        uint32_t qNextPollTime; + +        /** Bluetooth dongle control endpoint. */ +        static const uint8_t BTD_CONTROL_PIPE; +        /** HCI event endpoint index. */ +        static const uint8_t BTD_EVENT_PIPE; +        /** ACL In endpoint index. */ +        static const uint8_t BTD_DATAIN_PIPE; +        /** ACL Out endpoint index. */ +        static const uint8_t BTD_DATAOUT_PIPE; + +        /** +         * Used to print the USB Endpoint Descriptor. +         * @param ep_ptr Pointer to USB Endpoint Descriptor. +         */ +        void PrintEndpointDescriptor(const USB_ENDPOINT_DESCRIPTOR* ep_ptr); + +private: +        void Initialize(); // Set all variables, endpoint structs etc. to default values +        BluetoothService *btService[BTD_NUM_SERVICES]; + +        uint16_t PID, VID; // PID and VID of device connected + +        uint8_t pollInterval; +        bool bPollEnable; + +        bool pairWiiUsingSync; // True if paring was done using the Wii SYNC button. +        bool checkRemoteName; // Used to check remote device's name before connecting. +        bool incomingPS4; // True if a PS4 controller is connecting +        uint8_t classOfDevice[3]; // Class of device of last device + +        /* Variables used by high level HCI task */ +        uint8_t hci_state; // Current state of Bluetooth HCI connection +        uint16_t hci_counter; // Counter used for Bluetooth HCI reset loops +        uint16_t hci_num_reset_loops; // This value indicate how many times it should read before trying to reset +        uint16_t hci_event_flag; // HCI flags of received Bluetooth events +        uint8_t inquiry_counter; + +        uint8_t hcibuf[BULK_MAXPKTSIZE]; // General purpose buffer for HCI data +        uint8_t l2capinbuf[BULK_MAXPKTSIZE]; // General purpose buffer for L2CAP in data +        uint8_t l2capoutbuf[14]; // General purpose buffer for L2CAP out data + +        /* State machines */ +        void HCI_event_task(); // Poll the HCI event pipe +        void HCI_task(); // HCI state machine +        void ACL_event_task(); // ACL input pipe + +        /* Used to set the Bluetooth Address internally to the PS3 Controllers */ +        void setBdaddr(uint8_t* BDADDR); +        void setMoveBdaddr(uint8_t* BDADDR); +}; + +/** All Bluetooth services should inherit this class. */ +class BluetoothService { +public: +        BluetoothService(BTD *p) : pBtd(p) { +                if(pBtd) +                        pBtd->registerBluetoothService(this); // Register it as a Bluetooth service +        }; +        /** +         * Used to pass acldata to the Bluetooth service. +         * @param ACLData Pointer to the incoming acldata. +         */ +        virtual void ACLData(uint8_t* ACLData) = 0; +        /** Used to run the different state machines in the Bluetooth service. */ +        virtual void Run() = 0; +        /** Used to reset the Bluetooth service. */ +        virtual void Reset() = 0; +        /** Used to disconnect both the L2CAP Channel and the HCI Connection for the Bluetooth service. */ +        virtual void disconnect() = 0; + +        /** +         * Used to call your own function when the device is successfully initialized. +         * @param funcOnInit Function to call. +         */ +        void attachOnInit(void (*funcOnInit)(void)) { +                pFuncOnInit = funcOnInit; // TODO: This really belong in a class of it's own as it is repeated several times +        }; + +protected: +        /** +         * Called when a device is successfully initialized. +         * Use attachOnInit(void (*funcOnInit)(void)) to call your own function. +         * This is useful for instance if you want to set the LEDs in a specific way. +         */ +        virtual void onInit() = 0; + +        /** Used to check if the incoming L2CAP data matches the HCI Handle */ +        bool checkHciHandle(uint8_t *buf, uint16_t handle) { +                return (buf[0] == (handle & 0xFF)) && (buf[1] == ((handle >> 8) | 0x20)); +        } + +        /** Pointer to function called in onInit(). */ +        void (*pFuncOnInit)(void); + +        /** Pointer to BTD instance. */ +        BTD *pBtd; + +        /** The HCI Handle for the connection. */ +        uint16_t hci_handle; + +        /** L2CAP flags of received Bluetooth events. */ +        uint32_t l2cap_event_flag; + +        /** Identifier for L2CAP commands. */ +        uint8_t identifier; +}; + +#endif | 
