XBOXONE.h

Go to the documentation of this file.

/* Copyright (C) 2012 Kristian Lauszus, TKJ Electronics. All rights reserved.
   Copyright (C) 2015 guruthree

 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   :  kristianl@tkjelectronics.com

 guruthree
 Web      :  https://github.com/guruthree/
 */


#ifndef _xboxone_h_
#define _xboxone_h_

#include "Usb.h"
#include "xboxEnums.h"

/* Xbox One data taken from descriptors */
#define XBOX_ONE_EP_MAXPKTSIZE                  64 // Max size for data via USB

/* Names we give to the 3 XboxONE pipes */
#define XBOX_ONE_CONTROL_PIPE                   0
#define XBOX_ONE_OUTPUT_PIPE                    1
#define XBOX_ONE_INPUT_PIPE                     2

#define XBOX_ONE_MAX_ENDPOINTS                  3

// PID and VID of the different versions of the controller - see: https://github.com/torvalds/linux/blob/master/drivers/input/joystick/xpad.c

// Official controllers
#define XBOX_VID1                               0x045E // Microsoft Corporation
#define XBOX_ONE_PID1                           0x02D1 // Microsoft X-Box One pad
#define XBOX_ONE_PID2                           0x02DD // Microsoft X-Box One pad (Firmware 2015)
#define XBOX_ONE_PID3                           0x02E3 // Microsoft X-Box One Elite pad
#define XBOX_ONE_PID4                           0x02EA // Microsoft X-Box One S pad
#define XBOX_ONE_PID13                          0x0B0A // Microsoft X-Box One Adaptive Controller

// Unofficial controllers
#define XBOX_VID2                               0x0738 // Mad Catz
#define XBOX_VID3                               0x0E6F // Afterglow
#define XBOX_VID4                               0x0F0D // HORIPAD ONE
#define XBOX_VID5                               0x1532 // Razer
#define XBOX_VID6                               0x24C6 // PowerA

#define XBOX_ONE_PID5                           0x4A01 // Mad Catz FightStick TE 2 - might have different mapping for triggers?
#define XBOX_ONE_PID6                           0x0139 // Afterglow Prismatic Wired Controller
#define XBOX_ONE_PID7                           0x0146 // Rock Candy Wired Controller for Xbox One
#define XBOX_ONE_PID8                           0x0067 // HORIPAD ONE
#define XBOX_ONE_PID9                           0x0A03 // Razer Wildcat
#define XBOX_ONE_PID10                          0x541A // PowerA Xbox One Mini Wired Controller
#define XBOX_ONE_PID11                          0x542A // Xbox ONE spectra
#define XBOX_ONE_PID12                          0x543A // PowerA Xbox One wired controller

class XBOXONE : public USBDeviceConfig, public UsbConfigXtracter {
public:
        XBOXONE(USB *pUsb);

        virtual uint8_t Init(uint8_t parent, uint8_t port, bool lowspeed);
        virtual uint8_t Release();
        virtual uint8_t Poll();

        virtual uint8_t GetAddress() {
                return bAddress;
        };

        virtual bool isReady() {
                return bPollEnable;
        };

        uint8_t readPollInterval() {
                return pollInterval;
        };

        virtual bool VIDPIDOK(uint16_t vid, uint16_t pid) {
                return ((vid == XBOX_VID1 || vid == XBOX_VID2 || vid == XBOX_VID3 || vid == XBOX_VID4 || vid == XBOX_VID5 || vid == XBOX_VID6) &&
                    (pid == XBOX_ONE_PID1 || pid == XBOX_ONE_PID2 || pid == XBOX_ONE_PID3 || pid == XBOX_ONE_PID4 ||
                        pid == XBOX_ONE_PID5 || pid == XBOX_ONE_PID6 || pid == XBOX_ONE_PID7 || pid == XBOX_ONE_PID8 ||
                        pid == XBOX_ONE_PID9 || pid == XBOX_ONE_PID10 || pid == XBOX_ONE_PID11 || pid == XBOX_ONE_PID12 || pid == XBOX_ONE_PID13));
        };
        uint16_t getButtonPress(ButtonEnum b);
        bool getButtonClick(ButtonEnum b);

        int16_t getAnalogHat(AnalogHatEnum a);

        void attachOnInit(void (*funcOnInit)(void)) {
                pFuncOnInit = funcOnInit;
        };

        void setRumbleOff();

        void setRumbleOn(uint8_t leftTrigger, uint8_t rightTrigger, uint8_t leftMotor, uint8_t rightMotor);
        bool XboxOneConnected;

protected:
        USB *pUsb;
        uint8_t bAddress;
        EpInfo epInfo[XBOX_ONE_MAX_ENDPOINTS];

        uint8_t bConfNum;
        uint8_t bNumEP;
        uint32_t qNextPollTime;

        void EndpointXtract(uint8_t conf, uint8_t iface, uint8_t alt, uint8_t proto, const USB_ENDPOINT_DESCRIPTOR *ep);
        void PrintEndpointDescriptor(const USB_ENDPOINT_DESCRIPTOR* ep_ptr);

private:
        void onInit();
        void (*pFuncOnInit)(void); // Pointer to function called in onInit()

        uint8_t pollInterval;
        bool bPollEnable;

        /* Variables to store the buttons */
        uint16_t ButtonState;
        uint16_t OldButtonState;
        uint16_t ButtonClickState;
        int16_t hatValue[4];
        uint16_t triggerValue[2];
        uint16_t triggerValueOld[2];

        bool L2Clicked; // These buttons are analog, so we use we use these bools to check if they where clicked or not
        bool R2Clicked;

        uint8_t readBuf[XBOX_ONE_EP_MAXPKTSIZE]; // General purpose buffer for input data
        uint8_t cmdCounter;

        void readReport(); // Used to read the incoming data

        /* Private commands */
        uint8_t XboxCommand(uint8_t* data, uint16_t nbytes);
};
#endif