teensy-usbhost/joystick.cpp

/* 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.
 */

#include <Arduino.h>
#include "USBHost_t36.h"  // Read this header first for key info

#define print   USBHost::print_
#define println USBHost::println_

//#define DEBUG_JOYSTICK
#ifdef  DEBUG_JOYSTICK
#define DBGPrintf USBHDBGSerial.printf
#else
#define DBGPrintf(...) 
#endif

// PID/VID to joystick mapping - Only the XBOXOne is used to claim the USB interface directly, 
// The others are used after claim-hid code to know which one we have and to use it for 
// doing other features.  
JoystickController::product_vendor_mapping_t JoystickController::pid_vid_mapping[] = {
	{ 0x045e, 0x02ea, XBOXONE, false },{ 0x045e, 0x02dd, XBOXONE, false },
	{ 0x045e, 0x0719, XBOX360, false},
	{ 0x054C, 0x0268, PS3, true}, 
	{ 0x054C, 0x05C4, PS4, true}, {0x054C, 0x09CC, PS4, true }
};



//-----------------------------------------------------------------------------
void JoystickController::init()
{
	contribute_Pipes(mypipes, sizeof(mypipes)/sizeof(Pipe_t));
	contribute_Transfers(mytransfers, sizeof(mytransfers)/sizeof(Transfer_t));
	contribute_String_Buffers(mystring_bufs, sizeof(mystring_bufs)/sizeof(strbuf_t));
	driver_ready_for_device(this);
	USBHIDParser::driver_ready_for_hid_collection(this);
	BluetoothController::driver_ready_for_bluetooth(this);
}

//-----------------------------------------------------------------------------
JoystickController::joytype_t JoystickController::mapVIDPIDtoJoystickType(uint16_t idVendor, uint16_t idProduct, bool exclude_hid_devices)
{
	for (uint8_t i = 0; i < (sizeof(pid_vid_mapping)/sizeof(pid_vid_mapping[0])); i++) {
		if ((idVendor == pid_vid_mapping[i].idVendor) && (idProduct == pid_vid_mapping[i].idProduct)) {
			println("Match PID/VID: ", i, DEC);
			if (exclude_hid_devices && pid_vid_mapping[i].hidDevice) return UNKNOWN;
			return pid_vid_mapping[i].joyType;
		}
	}  
	return UNKNOWN; 	// Not in our list
}

//*****************************************************************************
// Some simple query functions depend on which interface we are using...
//*****************************************************************************

uint16_t JoystickController::idVendor() 
{
	if (device != nullptr) return device->idVendor;
	if (mydevice != nullptr) return mydevice->idVendor;
	return 0;
}

uint16_t JoystickController::idProduct() 
{
	if (device != nullptr) return device->idProduct;
	if (mydevice != nullptr) return mydevice->idProduct;
	return 0;
}

const uint8_t *JoystickController::manufacturer()
{
	if ((device != nullptr) && (device->strbuf != nullptr)) return &device->strbuf->buffer[device->strbuf->iStrings[strbuf_t::STR_ID_MAN]];
	//if ((btdevice != nullptr) && (btdevice->strbuf != nullptr)) return &btdevice->strbuf->buffer[btdevice->strbuf->iStrings[strbuf_t::STR_ID_MAN]]; 
	if ((mydevice != nullptr) && (mydevice->strbuf != nullptr)) return &mydevice->strbuf->buffer[mydevice->strbuf->iStrings[strbuf_t::STR_ID_MAN]]; 
	return nullptr;
}

const uint8_t *JoystickController::product()
{
	if ((device != nullptr) && (device->strbuf != nullptr)) return &device->strbuf->buffer[device->strbuf->iStrings[strbuf_t::STR_ID_PROD]];
	if ((mydevice != nullptr) && (mydevice->strbuf != nullptr)) return &mydevice->strbuf->buffer[mydevice->strbuf->iStrings[strbuf_t::STR_ID_PROD]]; 
	if (btdevice != nullptr) return remote_name_;
	return nullptr;
}

const uint8_t *JoystickController::serialNumber()
{
	if ((device != nullptr) && (device->strbuf != nullptr)) return &device->strbuf->buffer[device->strbuf->iStrings[strbuf_t::STR_ID_SERIAL]];
	if ((mydevice != nullptr) && (mydevice->strbuf != nullptr)) return &mydevice->strbuf->buffer[mydevice->strbuf->iStrings[strbuf_t::STR_ID_SERIAL]]; 
	return nullptr;
}


bool JoystickController::setRumble(uint8_t lValue, uint8_t rValue, uint8_t timeout)
{
	// Need to know which joystick we are on.  Start off with XBox support - maybe need to add some enum value for the known
	// joystick types. 
	rumble_lValue_ = lValue; 
	rumble_rValue_ = rValue;
	rumble_timeout_ = timeout;

	switch (joystickType_) {
		default:
			break;
		case PS3:
			return transmitPS3UserFeedbackMsg();
		case PS4:
			return transmitPS4UserFeedbackMsg();
		case XBOXONE:
			// Lets try sending a request to the XBox 1.
			txbuf_[0] = 0x9;
			txbuf_[1] = 0x0;
			txbuf_[2] = 0x0;
			txbuf_[3] = 0x09; // Substructure (what substructure rest of this packet has)
			txbuf_[4] = 0x00; // Mode
			txbuf_[5] = 0x0f; // Rumble mask (what motors are activated) (0000 lT rT L R)
			txbuf_[6] = 0x0; // lT force
			txbuf_[7] = 0x0; // rT force
			txbuf_[8] = lValue; // L force
			txbuf_[9] = rValue; // R force
			txbuf_[10] = 0xff; // Length of pulse
			txbuf_[11] = 0x00; // Period between pulses			
			txbuf_[12] = 0x00; // Repeat			
			if (!queue_Data_Transfer(txpipe_, txbuf_, 13, this)) {
				println("XBoxOne rumble transfer fail");
			}
			return true;	// 
		case XBOX360:
			txbuf_[0] = 0x00;
			txbuf_[1] = 0x01;
			txbuf_[2] = 0x0F;
			txbuf_[3] = 0xC0;
			txbuf_[4] = 0x00;
			txbuf_[5] = lValue;
			txbuf_[6] = rValue;
			txbuf_[7] = 0x00;
			txbuf_[8] = 0x00;
			txbuf_[9] = 0x00;
			txbuf_[10] = 0x00;
			txbuf_[11] = 0x00;
			if (!queue_Data_Transfer(txpipe_, txbuf_, 12, this)) {
				println("XBox360 rumble transfer fail");
			}
			return true;
	} 
	return false;
}

bool JoystickController::setLEDs(uint8_t lr, uint8_t lg, uint8_t lb)
{
	// Need to know which joystick we are on.  Start off with XBox support - maybe need to add some enum value for the known
	// joystick types. 
	if ((leds_[0] != lr) || (leds_[1] != lg) || (leds_[2] != lb)) {
		leds_[0] = lr;
		leds_[1] = lg;
		leds_[2] = lb;

		switch (joystickType_) {
			case PS3:
				return transmitPS3UserFeedbackMsg();
			case PS4:
				return transmitPS4UserFeedbackMsg();
			case XBOX360:
				// 0: off, 1: all blink then return to before
				// 2-5(TL, TR, BL, BR) - blink on then stay on
				// 6-9() - On 
			    // ...
				txbuf_[1] = 0x00;
				txbuf_[2] = 0x08;
				txbuf_[3] = 0x40 + lr;
				txbuf_[4] = 0x00;
				txbuf_[5] = 0x00;
				txbuf_[6] = 0x00;
				txbuf_[7] = 0x00;
				txbuf_[8] = 0x00;
				txbuf_[9] = 0x00;
				txbuf_[10] = 0x00;
				txbuf_[11] = 0x00;
				if (!queue_Data_Transfer(txpipe_, txbuf_, 12, this)) {
					println("XBox360 set leds fail");
				}
				return true;
			case XBOXONE:
			default:
				return false;
		} 
	}
	return false;
}

bool JoystickController::transmitPS4UserFeedbackMsg() {
	if (driver_)  {
		uint8_t packet[32];
	    memset(packet, 0, sizeof(packet));

	    packet[0] = 0x05; // Report ID
	    packet[1]= 0xFF;

	    packet[4] = rumble_lValue_; // Small Rumble
	    packet[5] = rumble_rValue_; // Big rumble
	    packet[6] = leds_[0]; // RGB value 
	    packet[7] = leds_[1]; 
	    packet[8] = leds_[2];
	    // 9, 10 flash ON, OFF times in 100ths of second?  2.5 seconds = 255
	    DBGPrintf("Joystick update Rumble/LEDs\n");
		return driver_->sendPacket(packet, 32);
	} else if (btdriver_) {
		uint8_t packet[79];
	    memset(packet, 0, sizeof(packet));
//0xa2, 0x11, 0xc0, 0x20, 0xf0, 0x04, 0x00
	    packet[0] = 0x52; 
	    packet[1] = 0x11;      // Report ID
		packet[2] = 0x80;
		//packet[3] = 0x20;
		packet[4] = 0xFF;

	    packet[7] = rumble_lValue_; // Small Rumble
	    packet[8] = rumble_rValue_; // Big rumble
	    packet[9] = leds_[0]; // RGB value 
	    packet[10] = leds_[1]; 
	    packet[11] = leds_[2];

	    // 12, 13 flash ON, OFF times in 100ths of sedond?  2.5 seconds = 255
	    DBGPrintf("Joystick update Rumble/LEDs\n");
     	btdriver_->sendL2CapCommand(packet, sizeof(packet), 0x40);

     	return true;
	}
	return false;
}

static const uint8_t PS3_USER_FEEDBACK_INIT[] = {
        0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00,
        0xff, 0x27, 0x10, 0x00, 0x32,
        0xff, 0x27, 0x10, 0x00, 0x32,
        0xff, 0x27, 0x10, 0x00, 0x32,
        0xff, 0x27, 0x10, 0x00, 0x32,
        0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00 };

bool JoystickController::transmitPS3UserFeedbackMsg() {
	if (driver_) {
	    memcpy(txbuf_, PS3_USER_FEEDBACK_INIT, 48);

	    txbuf_[1] = rumble_lValue_? rumble_timeout_ : 0;
	    txbuf_[2] = rumble_lValue_; // Small Rumble
	    txbuf_[3] = rumble_rValue_? rumble_timeout_ : 0; 
	    txbuf_[4] = rumble_rValue_; // Big rumble
	    txbuf_[9] = leds_[0] << 1; // RGB value 
	    //DBGPrintf("\nJoystick update Rumble/LEDs %d %d %d %d %d\n",  txbuf_[1], txbuf_[2],  txbuf_[3],  txbuf_[4],  txbuf_[9]);
		return driver_->sendControlPacket(0x21, 9, 0x201, 0, 48, txbuf_); 
	} else if (btdriver_) {
		txbuf_[0] = 0x52;
		txbuf_[1] = 0x1;
	    memcpy(&txbuf_[2], PS3_USER_FEEDBACK_INIT, 48);

	    txbuf_[3] = rumble_lValue_? rumble_timeout_ : 0;
	    txbuf_[4] = rumble_lValue_; // Small Rumble
	    txbuf_[5] = rumble_rValue_? rumble_timeout_ : 0; 
	    txbuf_[6] = rumble_rValue_; // Big rumble
	    txbuf_[11] = leds_[0] << 1; // RGB value 
	    DBGPrintf("\nJoystick update Rumble/LEDs %d %d %d %d %d\n",  txbuf_[3], txbuf_[4],  txbuf_[5],  txbuf_[6],  txbuf_[11]);
     	btdriver_->sendL2CapCommand(txbuf_, 50, BluetoothController::CONTROL_SCID);
     	return true;
	}
	return false;
}

//*****************************************************************************
// Support for Joysticks that Use HID data. 
//*****************************************************************************

hidclaim_t JoystickController::claim_collection(USBHIDParser *driver, Device_t *dev, uint32_t topusage)
{
	// only claim Desktop/Joystick and Desktop/Gamepad
	if (topusage != 0x10004 && topusage != 0x10005) return CLAIM_NO;
	// only claim from one physical device
	if (mydevice != NULL && dev != mydevice) return CLAIM_NO;

	// Also don't allow us to claim if it is used as a standard usb object (XBox...)
	if (device != nullptr) return CLAIM_NO;

	mydevice = dev;
	collections_claimed++;
	anychange = true; // always report values on first read
	driver_ = driver;	// remember the driver. 
	driver_->setTXBuffers(txbuf_, nullptr, sizeof(txbuf_));
	connected_ = true;		// remember that hardware is actually connected...

	// Lets see if we know what type of joystick this is. That is, is it a PS3 or PS4 or ...
	joystickType_ = mapVIDPIDtoJoystickType(mydevice->idVendor, mydevice->idProduct, false);
	DBGPrintf("JoystickController::claim_collection joystickType_=%d\n", joystickType_);
	switch (joystickType_) {
		case PS3:
			additional_axis_usage_page_ = 0x1;
			additional_axis_usage_start_ = 0x100;
			additional_axis_usage_count_ = 39;
			axis_change_notify_mask_ = (uint64_t)-1;	// Start off assume all bits 
			break;
		case PS4:
			additional_axis_usage_page_ = 0xFF00;
			additional_axis_usage_start_ = 0x21;
			additional_axis_usage_count_ = 54;
			axis_change_notify_mask_ = (uint64_t)0xfffffffffffff3ffl;	// Start off assume all bits - 10 and 11
			break;
		default: 
			additional_axis_usage_page_ = 0x09;
			additional_axis_usage_start_ = 0x21;
			additional_axis_usage_count_ = 5;
			axis_change_notify_mask_ = 0x3ff;	// Start off assume only the 10 bits...
	}
	DBGPrintf("Claim Additional axis: %x %x %d\n", additional_axis_usage_page_, additional_axis_usage_start_, additional_axis_usage_count_);
	return CLAIM_REPORT;
}

void JoystickController::disconnect_collection(Device_t *dev)
{
	if (--collections_claimed == 0) {
		mydevice = NULL;
		driver_ = nullptr;
		axis_mask_ = 0;	
		axis_changed_mask_ = 0;
	}
}

void JoystickController::hid_input_begin(uint32_t topusage, uint32_t type, int lgmin, int lgmax)
{
	// TODO: set up translation from logical min/max to consistent 16 bit scale
}

void JoystickController::hid_input_data(uint32_t usage, int32_t value)
{
	DBGPrintf("Joystick: usage=%X, value=%d\n", usage, value);
	uint32_t usage_page = usage >> 16;
	usage &= 0xFFFF;
	if (usage_page == 9 && usage >= 1 && usage <= 32) {
		uint32_t bit = 1 << (usage -1);
		if (value == 0) {
			if (buttons & bit) {
				buttons &= ~bit;
				anychange = true;
			}
		} else {
			if (!(buttons & bit)) {
				buttons |= bit;
				anychange = true;
			}
		}
	} else if (usage_page == 1 && usage >= 0x30 && usage <= 0x39) {
		// TODO: need scaling of value to consistent API, 16 bit signed?
		// TODO: many joysticks repeat slider usage.  Detect & map to axis?
		uint32_t i = usage - 0x30;
		axis_mask_ |= (1 << i);		// Keep record of which axis we have data on.
		if (axis[i] != value) {
			axis[i] = value;
			axis_changed_mask_ |= (1 << i);
			if (axis_changed_mask_ & axis_change_notify_mask_)
				anychange = true;
		}
	} else if (usage_page == additional_axis_usage_page_) {
		// see if the usage is witin range.
		//DBGPrintf("UP: usage_page=%x usage=%x User: %x %d\n", usage_page, usage, user_buttons_usage_start, user_buttons_count_);
		if ((usage >= additional_axis_usage_start_) && (usage < (additional_axis_usage_start_ + additional_axis_usage_count_))) {
			// We are in the user range. 
			uint16_t usage_index = usage - additional_axis_usage_start_ + STANDARD_AXIS_COUNT;
			if (usage_index < (sizeof(axis)/sizeof(axis[0]))) {
				if (axis[usage_index] != value) {
					axis[usage_index] = value;
					if (usage_index > 63) usage_index = 63;	// don't overflow our mask
					axis_changed_mask_ |= ((uint64_t)1 << usage_index);		// Keep track of which ones changed.
					if (axis_changed_mask_ & axis_change_notify_mask_)
						anychange = true;	// We have changes... 
				}
				axis_mask_ |= ((uint64_t)1 << usage_index);		// Keep record of which axis we have data on.
			}
			//DBGPrintf("UB: index=%x value=%x\n", usage_index, value);
		}

	} else {
		DBGPrintf("UP: usage_page=%x usage=%x add: %x %x %d\n", usage_page, usage, additional_axis_usage_page_, additional_axis_usage_start_, additional_axis_usage_count_);

	}
	// TODO: hat switch?
}

void JoystickController::hid_input_end()
{
	if (anychange) {
		joystickEvent = true;
	}
}

bool JoystickController::hid_process_out_data(const Transfer_t *transfer) 
{
	//DBGPrintf("JoystickController::hid_process_out_data\n");
	return true;
}

void JoystickController::joystickDataClear() {
	joystickEvent = false;
	anychange = false;
	axis_changed_mask_ = 0;
	axis_mask_ = 0;
}

//*****************************************************************************
// Support for Joysticks that are class specific and do not use HID
// Example: XBox One controller. 
//*****************************************************************************

static  uint8_t xboxone_start_input[] = {0x05, 0x20, 0x00, 0x01, 0x00};
static  uint8_t xbox360w_inquire_present[] = {0x08, 0x00, 0x0F, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

bool JoystickController::claim(Device_t *dev, int type, const uint8_t *descriptors, uint32_t len)
{
	println("JoystickController claim this=", (uint32_t)this, HEX);

	// Don't try to claim if it is used as USB device or HID device
	if (mydevice != NULL) return false;
	if (device != nullptr) return false;

	// Try claiming at the interface level.
	if (type != 1) return false;
	print_hexbytes(descriptors, len);

	JoystickController::joytype_t jtype = mapVIDPIDtoJoystickType(dev->idVendor, dev->idProduct, true);
	println("Jtype=", (uint8_t)jtype, DEC);
	if (jtype == UNKNOWN)
		return false; 

	// XBOX One
	//  0  1  2  3  4  5  6  7  8 *9 10  1  2  3  4  5 *6  7  8  9 20  1  2  3  4  5  6  7  8  9 30  1... 
	// 09 04 00 00 02 FF 47 D0 00 07 05 02 03 40 00 04 07 05 82 03 40 00 04 09 04 01 00 00 FF 47 D0 00 
	// Lets do some verifications to make sure. 

	// XBOX 360 wireless... Has 8 interfaces.  4 joysticks (1, 3, 5, 7) and 4 headphones assume 2,4,6, 8... 
	// Shows data for #1 only... 
	// Also they have some unknown data type we need to ignore between interface and end points.
	//  0  1  2  3  4  5  6  7  8 *9 10  1  2  3  4  5 *6  7  8  9 20  1  2  3  4  5  6  7  8 
	// 09 04 00 00 02 FF 5D 81 00 14 22 00 01 13 81 1D 00 17 01 02 08 13 01 0C 00 0C 01 02 08 

  	// 29 30  1  2  3  4  5  6  7  8  9 40 41 42
	// 07 05 81 03 20 00 01 07 05 01 03 20 00 08 

	if (len < 9+7+7) return false;

	// Some common stuff for both XBoxs
	uint32_t count_end_points = descriptors[4];
	if (count_end_points < 2) return false;
	if (descriptors[5] != 0xff) return false; // bInterfaceClass, 3 = HID
	rx_ep_ = 0;
	uint32_t txep = 0;
	uint8_t rx_interval = 0;
	uint8_t tx_interval = 0;
	rx_size_ = 0;
	tx_size_ = 0;
	uint32_t descriptor_index = 9; 
	if (descriptors[descriptor_index+1] == 0x22)  {
		if (descriptors[descriptor_index] != 0x14) return false; // only support specific versions...
		descriptor_index += descriptors[descriptor_index]; // XBox360w ignore this unknown setup...
	}	
	while (count_end_points-- && ((rx_ep_ == 0) || txep == 0)) {
		if (descriptors[descriptor_index] != 7) return false; // length 7
		if (descriptors[descriptor_index+1] != 5) return false; // ep desc
		if ((descriptors[descriptor_index+3] == 3) 				// Type 3...
			&& (descriptors[descriptor_index+4] <= 64)
			&& (descriptors[descriptor_index+5] == 0)) {
			// have a bulk EP size 
			if (descriptors[descriptor_index+2] & 0x80 ) {
				rx_ep_ = descriptors[descriptor_index+2];
				rx_size_ = descriptors[descriptor_index+4];
				rx_interval = descriptors[descriptor_index+6];
			} else {
				txep = descriptors[descriptor_index+2]; 
				tx_size_ = descriptors[descriptor_index+4];
				tx_interval = descriptors[descriptor_index+6];
			}
		}
		descriptor_index += 7;  // setup to look at next one...
	}
	if ((rx_ep_ == 0) || (txep == 0)) return false; // did not find two end points.
	print("JoystickController, rx_ep_=", rx_ep_ & 15);
	print("(", rx_size_);
	print("), txep=", txep);
	print("(", tx_size_);
	println(")");
	rxpipe_ = new_Pipe(dev, 3, rx_ep_ & 15, 1, rx_size_, rx_interval);
	if (!rxpipe_) return false;
	txpipe_ = new_Pipe(dev, 3, txep, 0, tx_size_, tx_interval);
	if (!txpipe_) {
		//free_Pipe(rxpipe_);
		return false;
	}
	rxpipe_->callback_function = rx_callback;
	queue_Data_Transfer(rxpipe_, rxbuf_, rx_size_, this);

	txpipe_->callback_function = tx_callback;

	if (jtype == XBOXONE) {
		queue_Data_Transfer(txpipe_, xboxone_start_input, sizeof(xboxone_start_input), this);
		connected_ = true;		// remember that hardware is actually connected...
	} else if (jtype == XBOX360) {
		queue_Data_Transfer(txpipe_, xbox360w_inquire_present, sizeof(xbox360w_inquire_present), this);
		connected_ = 0;		// remember that hardware is actually connected...
	}
	memset(axis, 0, sizeof(axis));	// clear out any data. 
	joystickType_ = jtype;		// remember we are an XBox One. 
	DBGPrintf("   JoystickController::claim joystickType_ %d\n", joystickType_);
	return true;
}

void JoystickController::control(const Transfer_t *transfer)
{
}


/************************************************************/
//  Interrupt-based Data Movement
/************************************************************/

void JoystickController::rx_callback(const Transfer_t *transfer)
{
	if (!transfer->driver) return;
	((JoystickController *)(transfer->driver))->rx_data(transfer);
}

void JoystickController::tx_callback(const Transfer_t *transfer)
{
	if (!transfer->driver) return;
	((JoystickController *)(transfer->driver))->tx_data(transfer);
}



/************************************************************/
//  Interrupt-based Data Movement
// XBox one input data when type == 0x20
// Information came from several places on the web including: 
// https://github.com/quantus/xbox-one-controller-protocol
/************************************************************/
// 20 00 C5 0E 00 00 00 00 00 00 F0 06 AD FB 7A 0A DD F7 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
// 20 00 E0 0E 40 00 00 00 00 00 F0 06 AD FB 7A 0A DD F7 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
typedef struct {
	uint8_t type;
	uint8_t const_0;
	uint16_t id;
	// From online references button order: 
	//     sync, dummy, start, back, a, b, x, y
	//     dpad up, down left, right
	//	   lb, rb, left stick, right stick
	// Axis: 
	//     lt, rt, lx, ly, rx, ry
	//     
	uint16_t buttons; 
	int16_t	axis[6];
} xbox1data20_t;

typedef struct {
	uint8_t state;
	uint8_t id_or_type;
	uint16_t controller_status;
	uint16_t unknown;
	// From online references button order: 
	//     sync, dummy, start, back, a, b, x, y
	//     dpad up, down left, right
	//	   lb, rb, left stick, right stick
	// Axis: 
	//     lt, rt, lx, ly, rx, ry
	//
	uint16_t buttons; 
	uint8_t lt;
	uint8_t rt;
	int16_t	axis[4];
} xbox360data_t;

static const uint8_t xbox_axis_order_mapping[] = {3, 4, 0, 1, 2, 5};

void JoystickController::rx_data(const Transfer_t *transfer)
{
	print("JoystickController::rx_data (", joystickType_, DEC);
	print("): ");
	print_hexbytes((uint8_t*)transfer->buffer, transfer->length);

	if (joystickType_ == XBOXONE) {
		// Process XBOX One data
		axis_mask_ = 0x3f;	
		axis_changed_mask_ = 0;	// assume none for now
		xbox1data20_t *xb1d = (xbox1data20_t *)transfer->buffer;
		if ((xb1d->type == 0x20) && (transfer->length >= sizeof (xbox1data20_t))) {
			// We have a data transfer.  Lets see what is new...
			if (xb1d->buttons != buttons) {
				buttons = xb1d->buttons;
				anychange = true;
				joystickEvent = true;
				println("  Button Change: ", buttons, HEX);
			}
			for (uint8_t i = 0; i < sizeof (xbox_axis_order_mapping); i++) {
				// The first two values were unsigned. 
				int axis_value = (i < 2)? (int)(uint16_t)xb1d->axis[i] : xb1d->axis[i];
				if (axis_value != axis[xbox_axis_order_mapping[i]]) {
					axis[xbox_axis_order_mapping[i]] = axis_value;
					axis_changed_mask_ |= (1 << xbox_axis_order_mapping[i]);
					anychange = true;
				}
			}
			joystickEvent = true;
		}

	} else if (joystickType_ == XBOX360) {
		// First byte appears to status - if the byte is 0x8 it is a connect or disconnect of the controller. 
		xbox360data_t  *xb360d = (xbox360data_t *)transfer->buffer;
		if (xb360d->state == 0x08) {
			if (xb360d->id_or_type != connected_) {
				connected_ = xb360d->id_or_type;	// remember it... 
				if (connected_) {
					println("XBox360w - Connected type:", connected_, HEX);
					// rx_ep_ should be 1, 3, 5, 7 for the wireless convert to 2-5 on led
					setLEDs(2+rx_ep_/2);	// Right now hard coded to first joystick...

				} else {
					println("XBox360w - disconnected");
				}
			}
		} else if((xb360d->id_or_type == 0x00) && (xb360d->controller_status & 0x1300)) {
			  // Controller status report - Maybe we should save away and allow the user access?
	            println("XBox360w - controllerStatus: ", xb360d->controller_status, HEX);
        } else if(xb360d->id_or_type == 0x01) { // Lets only process report 1.
			//const uint8_t *pbuffer = (uint8_t*)transfer->buffer;
        	//for (uint8_t i = 0; i < transfer->length; i++) DBGPrintf("%02x ", pbuffer[i]);
        	//DBGPrintf("\n");
	        
	        if (buttons != xb360d->buttons) {
	        	buttons = xb360d->buttons;
	        	anychange = true;
	        }
			axis_mask_ = 0x3f;	
			axis_changed_mask_ = 0;	// assume none for now

			for (uint8_t i = 0; i < 4; i++) {
				if (axis[i] != xb360d->axis[i]) {
					axis[i] = xb360d->axis[i];
					axis_changed_mask_ |= (1 << i);
					anychange = true;
				}
			}
			// the two triggers show up as 4 and 5
			if (axis[4] != xb360d->lt) {
				axis[4] = xb360d->lt;
				axis_changed_mask_ |= (1 << 4);
				anychange = true;
			}

			if (axis[5] != xb360d->rt) {
				axis[5] = xb360d->rt;
				axis_changed_mask_ |= (1 << 5);
				anychange = true;
			}

			if (anychange) joystickEvent = true;
		}
	}

	queue_Data_Transfer(rxpipe_, rxbuf_, rx_size_, this);
}

void JoystickController::tx_data(const Transfer_t *transfer)
{
}

void JoystickController::disconnect()
{
	axis_mask_ = 0;	
	axis_changed_mask_ = 0;
	// TODO: free resources
}

bool JoystickController::claim_bluetooth(BluetoothController *driver, uint32_t bluetooth_class, uint8_t *remoteName) 
{
	if ((((bluetooth_class & 0xff00) == 0x2500) || (((bluetooth_class & 0xff00) == 0x500))) && ((bluetooth_class & 0x3C) == 0x08)) {
		DBGPrintf("JoystickController::claim_bluetooth TRUE\n");
		btdriver_ = driver;
		btdevice = (Device_t*)driver;	// remember this way 
		if (remoteName) mapNameToJoystickType(remoteName);
		return true;
	}

	if (remoteName && mapNameToJoystickType(remoteName)) {
		if (joystickType_ == PS3) {
			DBGPrintf("JoystickController::claim_bluetooth TRUE PS3 hack...\n");
			btdriver_ = driver;
			btdevice = (Device_t*)driver;	// remember this way 
			special_process_required = SP_PS3_IDS; 		// PS3 maybe needs different IDS. 
			return true;
		}
	}
	return false;
}


bool JoystickController::process_bluetooth_HID_data(const uint8_t *data, uint16_t length) 
{
	// Example data from PS4 controller
	//01 7e 7f 82 84 08 00 00 00 00
	//   LX LY RX RY BT BT PS LT RT
	//DBGPrintf("JoystickController::process_bluetooth_HID_data\n");
	// May have to look at this one with other controllers...
	if (data[0] == 1) {
		//print("  Joystick Data: ");
		//print_hexbytes(data, length);
//		DBGPrintf("  Joystick Data: ");
		if (length > TOTAL_AXIS_COUNT) length = TOTAL_AXIS_COUNT;	// don't overflow arrays...
		if (joystickType_ == PS3) {
			// Quick and dirty hack to match PS3 HID data
			uint32_t cur_buttons = data[2] | ((uint16_t)data[3] << 8) | ((uint32_t)data[4] << 16); 
			if (cur_buttons != buttons) {
				buttons = cur_buttons;
				joystickEvent = true;	// something changed.
			}

			uint64_t mask = 0x1;
			axis_mask_ = 0x27;	// assume bits 0, 1, 2, 5
			for (uint16_t i = 0; i < 3; i++) {
				if (axis[i] != data[i+6]) {
					axis_changed_mask_ |= mask;
					axis[i] = data[i+6];
				}
				mask <<= 1;	// shift down the mask.
			}
			if (axis[5] != data[9]) {
				axis_changed_mask_ |= (1<<5);
				axis[5] = data[9];
			}
			
			if (axis[3] != data[18]) {
				axis_changed_mask_ |= (1<<3);
				axis[3] = data[18];
			}
			
			if (axis[4] != data[19]) {
				axis_changed_mask_ |= (1<<4);
				axis[4] = data[19];
			}
			
			// Then rest of data
			mask = 0x1 << 10;	// setup for other bits
			for (uint16_t i = 10; i < length; i++ ) {
				axis_mask_ |= mask;
				if(data[i] != axis[i]) { 
					axis_changed_mask_ |= mask;
					axis[i] = data[i];
				} 
				mask <<= 1;	// shift down the mask.
			}

		} else {
			uint64_t mask = 0x1;
			axis_mask_ = 0;

			for (uint16_t i = 0; i < length; i++ ) {
				axis_mask_ |= mask;
				if(data[i] != axis[i]) { 
					axis_changed_mask_ |= mask;
					axis[i] = data[i];
				} 
				mask <<= 1;	// shift down the mask.
//				DBGPrintf("%02x ", axis[i]);
			}

		}

		if (axis_changed_mask_ & axis_change_notify_mask_)
			joystickEvent = true;
		connected_ = true;
		return true;

	} else if(data[0] == 0x11){
		if (data[0] == 1) {
			//print("  Joystick Data: ");
			//print_hexbytes(data, length);
	//		DBGPrintf("  Joystick Data: ");
			uint64_t mask = 0x1;
			axis_mask_ = 0;
			axis_changed_mask_ = 0;

			if (length > TOTAL_AXIS_COUNT) length = TOTAL_AXIS_COUNT;	// don't overflow arrays...
			for (uint16_t i = 0; i < length; i++ ) {
				axis_mask_ |= mask;
				if(data[i] != axis[i]) { 
					axis_changed_mask_ |= mask;
					axis[i] = data[i];
				} 
				mask <<= 1;	// shift down the mask.
	//			DBGPrintf("%02x ", axis[i]);
			}
	//		DBGPrintf("\n");
			joystickEvent = true;
			connected_ = true;
			return true;
		} else if(data[0] == 0x11){
			DBGPrintf("\n  Joystick Data: ");
			uint64_t mask = 0x1;
			axis_mask_ = 0;
			axis_changed_mask_ = 0;
			
			//This moves data to be equivalent to what we see for
			//data[0] = 0x01
			uint8_t tmp_data[length-2];
			
			for (uint16_t i = 0; i < (length-2); i++ ) {
				tmp_data[i] = 0;
				tmp_data[i] = data[i+2];
			}
			
			/*
			 * [1] LX, [2] = LY, [3] = RX, [4] = RY
			 * [5] combo, tri, cir, x, sqr, D-PAD (4bits, 0-3
			 * [6] R3,L3, opt, share, R2, L2, R1, L1
			 * [7] Counter (bit7-2), T-PAD, PS
			 * [8] Left Trigger, [9] Right Trigger
			 * [10-11] Timestamp
			 * [12] Battery (0 to 0xff)
			 * [13-14] acceleration x
			 * [15-16] acceleration y
			 * [17-18] acceleration z
			 * [19-20] gyro x
			 * [21-22] gyro y
			 * [23-24] gyro z
			 * [25-29] unknown
			 * [30] 0x00,phone,mic, usb, battery level (4bits)
			 * rest is trackpad?  to do implement?
			 */
			//PS Bit
			tmp_data[7] = (tmp_data[7] >> 0) & 1;
			//set arrow buttons to axis[0]
			tmp_data[10] = tmp_data[5] & ((1 << 4) - 1);
			//set buttons for last 4bits in the axis[5]
			tmp_data[5] = tmp_data[5] >> 4;
			
		
			// Quick and dirty hack to match PS4 HID data
			uint32_t cur_buttons = tmp_data[7] | (tmp_data[10]) | ((tmp_data[6]*10)) | ((uint16_t)tmp_data[5] << 16) ; 
			if (cur_buttons != buttons) {
				buttons = cur_buttons;
				joystickEvent = true;	// something changed.
			}
			
			mask = 0x1;
			axis_mask_ = 0x27;	// assume bits 0, 1, 2, 5
			for (uint16_t i = 0; i < 3; i++) {
				if (axis[i] != tmp_data[i+1]) {
					axis_changed_mask_ |= mask;
					axis[i] = tmp_data[i+1];
				}
				mask <<= 1;	// shift down the mask.
			}
			if (axis[5] != tmp_data[4]) {
				axis_changed_mask_ |= (1<<5);
				axis[5] = tmp_data[4];
			}
			
			if (axis[3] != tmp_data[8]) {
				axis_changed_mask_ |= (1<<3);
				axis[3] = tmp_data[8];
			}
			
			if (axis[4] != tmp_data[9]) {
				axis_changed_mask_ |= (1<<4);
				axis[4] = tmp_data[9];
			}
			
			//limit for masking
			mask = 0x1;
			for (uint16_t i = 6; i < (64); i++ ) {
				axis_mask_ |= mask;
				if(tmp_data[i] != axis[i]) { 
					axis_changed_mask_ |= mask;
					axis[i] = tmp_data[i];
				}
				mask <<= 1;	// shift down the mask.
				DBGPrintf("%02x ", axis[i]);
			}
			DBGPrintf("\n");
			//DBGPrintf("Axis Mask (axis_mask_, axis_changed_mask_; %d, %d\n", axis_mask_,axis_changed_mask_);
			joystickEvent = true;
			connected_ = true;
		}
	}
	return false;
}

bool JoystickController::mapNameToJoystickType(const uint8_t *remoteName)
{
	// Sort of a hack, but try to map the name given from remote to a type...
	if (strncmp((const char *)remoteName, "Wireless Controller", 19) == 0) {
		DBGPrintf("  JoystickController::mapNameToJoystickType %s - set to PS4\n", remoteName);
		joystickType_ = PS4;
	} else if (strncmp((const char *)remoteName, "PLAYSTATION(R)3", 15) == 0) {
		DBGPrintf("  JoystickController::mapNameToJoystickType %x %s - set to PS3\n", (uint32_t)this, remoteName);
		joystickType_ = PS3;
	} else if (strncmp((const char *)remoteName, "Xbox Wireless", 13) == 0) {
		DBGPrintf("  JoystickController::mapNameToJoystickType %x %s - set to XBOXONE\n", (uint32_t)this, remoteName);
		joystickType_ = XBOXONE;
	} else {
		DBGPrintf("  JoystickController::mapNameToJoystickType %s - Unknown\n", remoteName);
	}
	DBGPrintf("  Joystick Type: %d\n", joystickType_);
	return true;
}


bool JoystickController::remoteNameComplete(const uint8_t *remoteName) 
{
	// Sort of a hack, but try to map the name given from remote to a type...
	if (mapNameToJoystickType(remoteName)) {
		switch (joystickType_) {
			case PS4: special_process_required = SP_NEED_CONNECT; break;
			case PS3: special_process_required = SP_PS3_IDS; break;
			default: 
				break;
		}
	}
	return true;
}

void JoystickController::connectionComplete() 
{
	DBGPrintf("  JoystickController::connectionComplete %x joystick type %d\n", (uint32_t)this, joystickType_);
	if (joystickType_ == PS4) {
		uint8_t packet[2];
		packet[0] = 0x43; // HID BT Get_report (0x40) | Report Type (Feature 0x03)
		packet[1] = 0x02; // Report ID
		DBGPrintf("Set PS4 report\n");
		delay(1);
		btdriver_->sendL2CapCommand(packet, sizeof(packet), 0x40);

	} else if (joystickType_ == PS3) {
	uint8_t packet[6];
		packet[0] = 0x53; // HID BT Set_report (0x50) | Report Type (Feature 0x03)
		packet[1] = 0xF4; // Report ID
		packet[2] = 0x42; // Special PS3 Controller enable commands
		packet[3] = 0x03;
		packet[4] = 0x00;
		packet[5] = 0x00;

		DBGPrintf("enable six axis\n");
		delay(1);
		btdriver_->sendL2CapCommand(packet, sizeof(packet), BluetoothController::CONTROL_SCID);
	}

}

void JoystickController::release_bluetooth() 
{
	btdevice = nullptr;	// remember this way 
	btdriver_ = nullptr;
	connected_ = false;
	special_process_required = false;

}


bool JoystickController::PS3Pair(uint8_t* bdaddr) {
 	if ((joystickType_ != PS3) || !driver_) return false; // not a PS2 nor plugged into USB...

    /* Set the internal Bluetooth address */
    txbuf_[0] = 0x01;
    txbuf_[1] = 0x00;

    for(uint8_t i = 0; i < 6; i++)
            txbuf_[i + 2] = bdaddr[5 - i]; // Copy into buffer, has to be written reversed, so it is MSB first

    // bmRequest = Host to device (0x00) | Class (0x20) | Interface (0x01) = 0x21, bRequest = Set Report (0x09), Report ID (0xF5), Report Type (Feature 0x03), interface (0x00), datalength, datalength, data
	return driver_->sendControlPacket(0x21, 9, 0x3f5, 0, 8, txbuf_); 
}