visus
/
teensy-usbhost
Obserwuj 1
Polub 0
Forkuj 0
Kod Zgłoszenia 0 Oczekujące zmiany 0 Wydania 0 Wiki Aktywność
Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
222 Commity
1 Gałąź
Drzewo: 9e3621f111
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z '9e3621f111'
${ noResults }
teensy-usbhost/joystick.cpp

845 lines
28KB
Czysty Wina Historia 

  1. /* USB EHCI Host for Teensy 3.6

  2.  * Copyright 2017 Paul Stoffregen (paul@pjrc.com)

  3.  *

  4.  * Permission is hereby granted, free of charge, to any person obtaining a

  5.  * copy of this software and associated documentation files (the

  6.  * "Software"), to deal in the Software without restriction, including

  7.  * without limitation the rights to use, copy, modify, merge, publish,

  8.  * distribute, sublicense, and/or sell copies of the Software, and to

  9.  * permit persons to whom the Software is furnished to do so, subject to

  10.  * the following conditions:

  11.  *

  12.  * The above copyright notice and this permission notice shall be included

  13.  * in all copies or substantial portions of the Software.

  14.  *

  15.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

  16.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

  17.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

  18.  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

  19.  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

  20.  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

  21.  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

  22.  */

  23. 

  24. #include <Arduino.h>

  25. #include "USBHost_t36.h"  // Read this header first for key info

  26. 

  27. #define print   USBHost::print_

  28. #define println USBHost::println_

  29. 

  30. #define DEBUG_JOYSTICK

  31. #ifdef  DEBUG_JOYSTICK

  32. #define DBGPrintf USBHDBGSerial.printf

  33. #else

  34. #define DBGPrintf(...) 

  35. #endif

  36. 

  37. // PID/VID to joystick mapping - Only the XBOXOne is used to claim the USB interface directly, 

  38. // The others are used after claim-hid code to know which one we have and to use it for 

  39. // doing other features.  

  40. JoystickController::product_vendor_mapping_t JoystickController::pid_vid_mapping[] = {

  41. 	{ 0x045e, 0x02ea, XBOXONE, false },{ 0x045e, 0x02dd, XBOXONE, false },

  42. 	{ 0x045e, 0x0719, XBOX360, false},

  43. 	{ 0x054C, 0x0268, PS3, true}, 

  44. 	{ 0x054C, 0x05C4, PS4, true}, {0x054C, 0x09CC, PS4, true }

  45. };

  46. 

  47. 

  48. 

  49. //-----------------------------------------------------------------------------

  50. void JoystickController::init()

  51. {

  52. 	contribute_Pipes(mypipes, sizeof(mypipes)/sizeof(Pipe_t));

  53. 	contribute_Transfers(mytransfers, sizeof(mytransfers)/sizeof(Transfer_t));

  54. 	contribute_String_Buffers(mystring_bufs, sizeof(mystring_bufs)/sizeof(strbuf_t));

  55. 	driver_ready_for_device(this);

  56. 	USBHIDParser::driver_ready_for_hid_collection(this);

  57. 	BluetoothController::driver_ready_for_bluetooth(this);

  58. }

  59. 

  60. //-----------------------------------------------------------------------------

  61. JoystickController::joytype_t JoystickController::mapVIDPIDtoJoystickType(uint16_t idVendor, uint16_t idProduct, bool exclude_hid_devices)

  62. {

  63. 	for (uint8_t i = 0; i < (sizeof(pid_vid_mapping)/sizeof(pid_vid_mapping[0])); i++) {

  64. 		if ((idVendor == pid_vid_mapping[i].idVendor) && (idProduct == pid_vid_mapping[i].idProduct)) {

  65. 			println("Match PID/VID: ", i, DEC);

  66. 			if (exclude_hid_devices && pid_vid_mapping[i].hidDevice) return UNKNOWN;

  67. 			return pid_vid_mapping[i].joyType;

  68. 		}

  69. 	}  

  70. 	return UNKNOWN; 	// Not in our list

  71. }

  72. 

  73. //*****************************************************************************

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

  75. //*****************************************************************************

  76. 

  77. uint16_t JoystickController::idVendor() 

  78. {

  79. 	if (device != nullptr) return device->idVendor;

  80. 	if (mydevice != nullptr) return mydevice->idVendor;

  81. 	return 0;

  82. }

  83. 

  84. uint16_t JoystickController::idProduct() 

  85. {

  86. 	if (device != nullptr) return device->idProduct;

  87. 	if (mydevice != nullptr) return mydevice->idProduct;

  88. 	return 0;

  89. }

  90. 

  91. const uint8_t *JoystickController::manufacturer()

  92. {

  93. 	if ((device != nullptr) && (device->strbuf != nullptr)) return &device->strbuf->buffer[device->strbuf->iStrings[strbuf_t::STR_ID_MAN]];

  94. 	//if ((btdevice != nullptr) && (btdevice->strbuf != nullptr)) return &btdevice->strbuf->buffer[btdevice->strbuf->iStrings[strbuf_t::STR_ID_MAN]]; 

  95. 	if ((mydevice != nullptr) && (mydevice->strbuf != nullptr)) return &mydevice->strbuf->buffer[mydevice->strbuf->iStrings[strbuf_t::STR_ID_MAN]]; 

  96. 	return nullptr;

  97. }

  98. 

  99. const uint8_t *JoystickController::product()

  100. {

  101. 	if ((device != nullptr) && (device->strbuf != nullptr)) return &device->strbuf->buffer[device->strbuf->iStrings[strbuf_t::STR_ID_PROD]];

  102. 	if ((mydevice != nullptr) && (mydevice->strbuf != nullptr)) return &mydevice->strbuf->buffer[mydevice->strbuf->iStrings[strbuf_t::STR_ID_PROD]]; 

  103. 	return nullptr;

  104. }

  105. 

  106. const uint8_t *JoystickController::serialNumber()

  107. {

  108. 	if ((device != nullptr) && (device->strbuf != nullptr)) return &device->strbuf->buffer[device->strbuf->iStrings[strbuf_t::STR_ID_SERIAL]];

  109. 	if ((mydevice != nullptr) && (mydevice->strbuf != nullptr)) return &mydevice->strbuf->buffer[mydevice->strbuf->iStrings[strbuf_t::STR_ID_SERIAL]]; 

  110. 	return nullptr;

  111. }

  112. 

  113. 

  114. bool JoystickController::setRumble(uint8_t lValue, uint8_t rValue, uint8_t timeout)

  115. {

  116. 	// Need to know which joystick we are on.  Start off with XBox support - maybe need to add some enum value for the known

  117. 	// joystick types. 

  118. 	rumble_lValue_ = lValue; 

  119. 	rumble_rValue_ = rValue;

  120. 	rumble_timeout_ = timeout;

  121. 

  122. 	switch (joystickType) {

  123. 		default:

  124. 			break;

  125. 		case PS3:

  126. 			return transmitPS3UserFeedbackMsg();

  127. 		case PS4:

  128. 			return transmitPS4UserFeedbackMsg();

  129. 		case XBOXONE:

  130. 			// Lets try sending a request to the XBox 1.

  131. 			txbuf_[0] = 0x9;

  132. 			txbuf_[1] = 0x0;

  133. 			txbuf_[2] = 0x0;

  134. 			txbuf_[3] = 0x09; // Substructure (what substructure rest of this packet has)

  135. 			txbuf_[4] = 0x00; // Mode

  136. 			txbuf_[5] = 0x0f; // Rumble mask (what motors are activated) (0000 lT rT L R)

  137. 			txbuf_[6] = 0x0; // lT force

  138. 			txbuf_[7] = 0x0; // rT force

  139. 			txbuf_[8] = lValue; // L force

  140. 			txbuf_[9] = rValue; // R force

  141. 			txbuf_[10] = 0xff; // Length of pulse

  142. 			txbuf_[11] = 0x00; // Period between pulses			

  143. 			txbuf_[12] = 0x00; // Repeat			

  144. 			if (!queue_Data_Transfer(txpipe_, txbuf_, 13, this)) {

  145. 				println("XBoxOne rumble transfer fail");

  146. 			}

  147. 			return true;	// 

  148. 		case XBOX360:

  149. 			txbuf_[0] = 0x00;

  150. 			txbuf_[1] = 0x01;

  151. 			txbuf_[2] = 0x0F;

  152. 			txbuf_[3] = 0xC0;

  153. 			txbuf_[4] = 0x00;

  154. 			txbuf_[5] = lValue;

  155. 			txbuf_[6] = rValue;

  156. 			txbuf_[7] = 0x00;

  157. 			txbuf_[8] = 0x00;

  158. 			txbuf_[9] = 0x00;

  159. 			txbuf_[10] = 0x00;

  160. 			txbuf_[11] = 0x00;

  161. 			if (!queue_Data_Transfer(txpipe_, txbuf_, 12, this)) {

  162. 				println("XBox360 rumble transfer fail");

  163. 			}

  164. 			return true;

  165. 	} 

  166. 	return false;

  167. }

  168. 

  169. bool JoystickController::setLEDs(uint8_t lr, uint8_t lg, uint8_t lb)

  170. {

  171. 	// Need to know which joystick we are on.  Start off with XBox support - maybe need to add some enum value for the known

  172. 	// joystick types. 

  173. 	if ((leds_[0] != lr) || (leds_[1] != lg) || (leds_[2] != lb)) {

  174. 		leds_[0] = lr;

  175. 		leds_[1] = lg;

  176. 		leds_[2] = lb;

  177. 

  178. 		switch (joystickType) {

  179. 			case PS3:

  180. 				return transmitPS3UserFeedbackMsg();

  181. 			case PS4:

  182. 				return transmitPS4UserFeedbackMsg();

  183. 			case XBOX360:

  184. 				// 0: off, 1: all blink then return to before

  185. 				// 2-5(TL, TR, BL, BR) - blink on then stay on

  186. 				// 6-9() - On 

  187. 			    // ...

  188. 				txbuf_[1] = 0x00;

  189. 				txbuf_[2] = 0x08;

  190. 				txbuf_[3] = 0x40 + lr;

  191. 				txbuf_[4] = 0x00;

  192. 				txbuf_[5] = 0x00;

  193. 				txbuf_[6] = 0x00;

  194. 				txbuf_[7] = 0x00;

  195. 				txbuf_[8] = 0x00;

  196. 				txbuf_[9] = 0x00;

  197. 				txbuf_[10] = 0x00;

  198. 				txbuf_[11] = 0x00;

  199. 				if (!queue_Data_Transfer(txpipe_, txbuf_, 12, this)) {

  200. 					println("XBox360 set leds fail");

  201. 				}

  202. 				return true;

  203. 			case XBOXONE:

  204. 			default:

  205. 				return false;

  206. 		} 

  207. 	}

  208. 	return false;

  209. }

  210. 

  211. bool JoystickController::transmitPS4UserFeedbackMsg() {

  212. 	if (driver_)  {

  213. 		uint8_t packet[32];

  214. 	    memset(packet, 0, sizeof(packet));

  215. 

  216. 	    packet[0] = 0x05; // Report ID

  217. 	    packet[1]= 0xFF;

  218. 

  219. 	    packet[4] = rumble_lValue_; // Small Rumble

  220. 	    packet[5] = rumble_rValue_; // Big rumble

  221. 	    packet[6] = leds_[0]; // RGB value 

  222. 	    packet[7] = leds_[1]; 

  223. 	    packet[8] = leds_[2];

  224. 	    // 9, 10 flash ON, OFF times in 100ths of second?  2.5 seconds = 255

  225. 	    DBGPrintf("Joystick update Rumble/LEDs\n");

  226. 		return driver_->sendPacket(packet, 32);

  227. 	} else if (btdriver_) {

  228. 		uint8_t packet[79];

  229. 	    memset(packet, 0, sizeof(packet));

  230. //0xa2, 0x11, 0xc0, 0x20, 0xf0, 0x04, 0x00

  231. 	    packet[0] = 0x52; 

  232. 	    packet[1] = 0x11;      // Report ID

  233. 		packet[2] = 0x80;

  234. 		//packet[3] = 0x20;

  235. 		packet[4] = 0xFF;

  236. 

  237. 	    packet[7] = rumble_lValue_; // Small Rumble

  238. 	    packet[8] = rumble_rValue_; // Big rumble

  239. 	    packet[9] = leds_[0]; // RGB value 

  240. 	    packet[10] = leds_[1]; 

  241. 	    packet[11] = leds_[2];

  242. 

  243. 	    // 12, 13 flash ON, OFF times in 100ths of sedond?  2.5 seconds = 255

  244. 	    DBGPrintf("Joystick update Rumble/LEDs\n");

  245.      	btdriver_->sendL2CapCommand(packet, sizeof(packet), 0x40);

  246. 

  247.      	return true;

  248. 	}

  249. 	return false;

  250. }

  251. 

  252. static const uint8_t PS3_USER_FEEDBACK_INIT[] = {

  253.         0x00, 0x00, 0x00, 0x00, 0x00,

  254.         0x00, 0x00, 0x00, 0x00, 0x00,

  255.         0xff, 0x27, 0x10, 0x00, 0x32,

  256.         0xff, 0x27, 0x10, 0x00, 0x32,

  257.         0xff, 0x27, 0x10, 0x00, 0x32,

  258.         0xff, 0x27, 0x10, 0x00, 0x32,

  259.         0x00, 0x00, 0x00, 0x00, 0x00,

  260.         0x00, 0x00, 0x00, 0x00, 0x00,

  261.         0x00, 0x00, 0x00, 0x00, 0x00,

  262.         0x00, 0x00, 0x00 };

  263. 

  264. bool JoystickController::transmitPS3UserFeedbackMsg() {

  265. 	if (driver_) {

  266. 	    memcpy(txbuf_, PS3_USER_FEEDBACK_INIT, 48);

  267. 

  268. 	    txbuf_[1] = rumble_lValue_? rumble_timeout_ : 0;

  269. 	    txbuf_[2] = rumble_lValue_; // Small Rumble

  270. 	    txbuf_[3] = rumble_rValue_? rumble_timeout_ : 0; 

  271. 	    txbuf_[4] = rumble_rValue_; // Big rumble

  272. 	    txbuf_[9] = leds_[0] << 1; // RGB value 

  273. 	    //DBGPrintf("\nJoystick update Rumble/LEDs %d %d %d %d %d\n",  txbuf_[1], txbuf_[2],  txbuf_[3],  txbuf_[4],  txbuf_[9]);

  274. 		return driver_->sendControlPacket(0x21, 9, 0x201, 0, 48, txbuf_); 

  275. 	} else if (btdriver_) {

  276. 		txbuf_[0] = 0x52;

  277. 		txbuf_[1] = 0x1;

  278. 	    memcpy(&txbuf_[2], PS3_USER_FEEDBACK_INIT, 48);

  279. 

  280. 	    txbuf_[3] = rumble_lValue_? rumble_timeout_ : 0;

  281. 	    txbuf_[4] = rumble_lValue_; // Small Rumble

  282. 	    txbuf_[5] = rumble_rValue_? rumble_timeout_ : 0; 

  283. 	    txbuf_[6] = rumble_rValue_; // Big rumble

  284. 	    txbuf_[11] = leds_[0] << 1; // RGB value 

  285. 	    DBGPrintf("\nJoystick update Rumble/LEDs %d %d %d %d %d\n",  txbuf_[3], txbuf_[4],  txbuf_[5],  txbuf_[6],  txbuf_[11]);

  286.      	btdriver_->sendL2CapCommand(txbuf_, 50, BluetoothController::CONTROL_SCID);

  287.      	return true;

  288. 	}

  289. 	return false;

  290. }

  291. 

  292. //*****************************************************************************

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

  294. //*****************************************************************************

  295. 

  296. hidclaim_t JoystickController::claim_collection(USBHIDParser *driver, Device_t *dev, uint32_t topusage)

  297. {

  298. 	// only claim Desktop/Joystick and Desktop/Gamepad

  299. 	if (topusage != 0x10004 && topusage != 0x10005) return CLAIM_NO;

  300. 	// only claim from one physical device

  301. 	if (mydevice != NULL && dev != mydevice) return CLAIM_NO;

  302. 

  303. 	// Also don't allow us to claim if it is used as a standard usb object (XBox...)

  304. 	if (device != nullptr) return CLAIM_NO;

  305. 

  306. 	mydevice = dev;

  307. 	collections_claimed++;

  308. 	anychange = true; // always report values on first read

  309. 	driver_ = driver;	// remember the driver. 

  310. 	driver_->setTXBuffers(txbuf_, nullptr, sizeof(txbuf_));

  311. 	connected_ = true;		// remember that hardware is actually connected...

  312. 

  313. 	// Lets see if we know what type of joystick this is. That is, is it a PS3 or PS4 or ...

  314. 	joystickType = mapVIDPIDtoJoystickType(mydevice->idVendor, mydevice->idProduct, false);

  315. 	switch (joystickType) {

  316. 		case PS3:

  317. 			additional_axis_usage_page_ = 0x1;

  318. 			additional_axis_usage_start_ = 0x100;

  319. 			additional_axis_usage_count_ = 39;

  320. 			axis_change_notify_mask_ = (uint64_t)-1;	// Start off assume all bits 

  321. 			break;

  322. 		case PS4:

  323. 			additional_axis_usage_page_ = 0xFF00;

  324. 			additional_axis_usage_start_ = 0x21;

  325. 			additional_axis_usage_count_ = 54;

  326. 			axis_change_notify_mask_ = (uint64_t)0xfffffffffffff3ffl;	// Start off assume all bits - 10 and 11

  327. 			break;

  328. 		default: 

  329. 			additional_axis_usage_page_ = 0;

  330. 			additional_axis_usage_start_ = 0;

  331. 			additional_axis_usage_count_ = 0;

  332. 			axis_change_notify_mask_ = 0x3ff;	// Start off assume only the 10 bits...

  333. 	}

  334. 	DBGPrintf("Claim Additional axis: %x %x %d\n", additional_axis_usage_page_, additional_axis_usage_start_, additional_axis_usage_count_);

  335. 	return CLAIM_REPORT;

  336. }

  337. 

  338. void JoystickController::disconnect_collection(Device_t *dev)

  339. {

  340. 	if (--collections_claimed == 0) {

  341. 		mydevice = NULL;

  342. 		driver_ = nullptr;

  343. 		axis_mask_ = 0;	

  344. 		axis_changed_mask_ = 0;

  345. 	}

  346. }

  347. 

  348. void JoystickController::hid_input_begin(uint32_t topusage, uint32_t type, int lgmin, int lgmax)

  349. {

  350. 	// TODO: set up translation from logical min/max to consistent 16 bit scale

  351. }

  352. 

  353. void JoystickController::hid_input_data(uint32_t usage, int32_t value)

  354. {

  355. 	//DBGPrintf("Joystick: usage=%X, value=%d\n", usage, value);

  356. 	uint32_t usage_page = usage >> 16;

  357. 	usage &= 0xFFFF;

  358. 	if (usage_page == 9 && usage >= 1 && usage <= 32) {

  359. 		uint32_t bit = 1 << (usage -1);

  360. 		if (value == 0) {

  361. 			if (buttons & bit) {

  362. 				buttons &= ~bit;

  363. 				anychange = true;

  364. 			}

  365. 		} else {

  366. 			if (!(buttons & bit)) {

  367. 				buttons |= bit;

  368. 				anychange = true;

  369. 			}

  370. 		}

  371. 	} else if (usage_page == 1 && usage >= 0x30 && usage <= 0x39) {

  372. 		// TODO: need scaling of value to consistent API, 16 bit signed?

  373. 		// TODO: many joysticks repeat slider usage.  Detect & map to axis?

  374. 		uint32_t i = usage - 0x30;

  375. 		axis_mask_ |= (1 << i);		// Keep record of which axis we have data on.

  376. 		if (axis[i] != value) {

  377. 			axis[i] = value;

  378. 			axis_changed_mask_ |= (1 << i);

  379. 			if (axis_changed_mask_ & axis_change_notify_mask_)

  380. 				anychange = true;

  381. 		}

  382. 	} else if (usage_page == additional_axis_usage_page_) {

  383. 		// see if the usage is witin range.

  384. 		//DBGPrintf("UP: usage_page=%x usage=%x User: %x %d\n", usage_page, usage, user_buttons_usage_start, user_buttons_count_);

  385. 		if ((usage >= additional_axis_usage_start_) && (usage < (additional_axis_usage_start_ + additional_axis_usage_count_))) {

  386. 			// We are in the user range. 

  387. 			uint16_t usage_index = usage - additional_axis_usage_start_ + STANDARD_AXIS_COUNT;

  388. 			if (usage_index < (sizeof(axis)/sizeof(axis[0]))) {

  389. 				if (axis[usage_index] != value) {

  390. 					axis[usage_index] = value;

  391. 					if (usage_index > 63) usage_index = 63;	// don't overflow our mask

  392. 					axis_changed_mask_ |= ((uint64_t)1 << usage_index);		// Keep track of which ones changed.

  393. 					if (axis_changed_mask_ & axis_change_notify_mask_)

  394. 						anychange = true;	// We have changes... 

  395. 				}

  396. 				axis_mask_ |= ((uint64_t)1 << usage_index);		// Keep record of which axis we have data on.

  397. 			}

  398. 			//DBGPrintf("UB: index=%x value=%x\n", usage_index, value);

  399. 		}

  400. 

  401. 	} else {

  402. 		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_);

  403. 

  404. 	}

  405. 	// TODO: hat switch?

  406. }

  407. 

  408. void JoystickController::hid_input_end()

  409. {

  410. 	if (anychange) {

  411. 		joystickEvent = true;

  412. 	}

  413. }

  414. 

  415. bool JoystickController::hid_process_out_data(const Transfer_t *transfer) 

  416. {

  417. 	//DBGPrintf("JoystickController::hid_process_out_data\n");

  418. 	return true;

  419. }

  420. 

  421. void JoystickController::joystickDataClear() {

  422. 	joystickEvent = false;

  423. 	anychange = false;

  424. 	axis_changed_mask_ = 0;

  425. 	axis_mask_ = 0;

  426. }

  427. 

  428. //*****************************************************************************

  429. // Support for Joysticks that are class specific and do not use HID

  430. // Example: XBox One controller. 

  431. //*****************************************************************************

  432. 

  433. static  uint8_t xboxone_start_input[] = {0x05, 0x20, 0x00, 0x01, 0x00};

  434. static  uint8_t xbox360w_inquire_present[] = {0x08, 0x00, 0x0F, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

  435. 

  436. bool JoystickController::claim(Device_t *dev, int type, const uint8_t *descriptors, uint32_t len)

  437. {

  438. 	println("JoystickController claim this=", (uint32_t)this, HEX);

  439. 

  440. 	// Don't try to claim if it is used as USB device or HID device

  441. 	if (mydevice != NULL) return false;

  442. 	if (device != nullptr) return false;

  443. 

  444. 	// Try claiming at the interface level.

  445. 	if (type != 1) return false;

  446. 	print_hexbytes(descriptors, len);

  447. 

  448. 	JoystickController::joytype_t jtype = mapVIDPIDtoJoystickType(dev->idVendor, dev->idProduct, true);

  449. 	println("Jtype=", (uint8_t)jtype, DEC);

  450. 	if (jtype == UNKNOWN)

  451. 		return false; 

  452. 

  453. 	// XBOX One

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

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

  456. 	// Lets do some verifications to make sure. 

  457. 

  458. 	// XBOX 360 wireless... Has 8 interfaces.  4 joysticks (1, 3, 5, 7) and 4 headphones assume 2,4,6, 8... 

  459. 	// Shows data for #1 only... 

  460. 	// Also they have some unknown data type we need to ignore between interface and end points.

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

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

  463. 

  464.   	// 29 30  1  2  3  4  5  6  7  8  9 40 41 42

  465. 	// 07 05 81 03 20 00 01 07 05 01 03 20 00 08 

  466. 

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

  468. 

  469. 	// Some common stuff for both XBoxs

  470. 	uint32_t count_end_points = descriptors[4];

  471. 	if (count_end_points < 2) return false;

  472. 	if (descriptors[5] != 0xff) return false; // bInterfaceClass, 3 = HID

  473. 	rx_ep_ = 0;

  474. 	uint32_t txep = 0;

  475. 	uint8_t rx_interval = 0;

  476. 	uint8_t tx_interval = 0;

  477. 	rx_size_ = 0;

  478. 	tx_size_ = 0;

  479. 	uint32_t descriptor_index = 9; 

  480. 	if (descriptors[descriptor_index+1] == 0x22)  {

  481. 		if (descriptors[descriptor_index] != 0x14) return false; // only support specific versions...

  482. 		descriptor_index += descriptors[descriptor_index]; // XBox360w ignore this unknown setup...

  483. 	}	

  484. 	while (count_end_points-- && ((rx_ep_ == 0) || txep == 0)) {

  485. 		if (descriptors[descriptor_index] != 7) return false; // length 7

  486. 		if (descriptors[descriptor_index+1] != 5) return false; // ep desc

  487. 		if ((descriptors[descriptor_index+3] == 3) 				// Type 3...

  488. 			&& (descriptors[descriptor_index+4] <= 64)

  489. 			&& (descriptors[descriptor_index+5] == 0)) {

  490. 			// have a bulk EP size 

  491. 			if (descriptors[descriptor_index+2] & 0x80 ) {

  492. 				rx_ep_ = descriptors[descriptor_index+2];

  493. 				rx_size_ = descriptors[descriptor_index+4];

  494. 				rx_interval = descriptors[descriptor_index+6];

  495. 			} else {

  496. 				txep = descriptors[descriptor_index+2]; 

  497. 				tx_size_ = descriptors[descriptor_index+4];

  498. 				tx_interval = descriptors[descriptor_index+6];

  499. 			}

  500. 		}

  501. 		descriptor_index += 7;  // setup to look at next one...

  502. 	}

  503. 	if ((rx_ep_ == 0) || (txep == 0)) return false; // did not find two end points.

  504. 	print("JoystickController, rx_ep_=", rx_ep_ & 15);

  505. 	print("(", rx_size_);

  506. 	print("), txep=", txep);

  507. 	print("(", tx_size_);

  508. 	println(")");

  509. 	rxpipe_ = new_Pipe(dev, 3, rx_ep_ & 15, 1, rx_size_, rx_interval);

  510. 	if (!rxpipe_) return false;

  511. 	txpipe_ = new_Pipe(dev, 3, txep, 0, tx_size_, tx_interval);

  512. 	if (!txpipe_) {

  513. 		//free_Pipe(rxpipe_);

  514. 		return false;

  515. 	}

  516. 	rxpipe_->callback_function = rx_callback;

  517. 	queue_Data_Transfer(rxpipe_, rxbuf_, rx_size_, this);

  518. 

  519. 	txpipe_->callback_function = tx_callback;

  520. 

  521. 	if (jtype == XBOXONE) {

  522. 		queue_Data_Transfer(txpipe_, xboxone_start_input, sizeof(xboxone_start_input), this);

  523. 		connected_ = true;		// remember that hardware is actually connected...

  524. 	} else if (jtype == XBOX360) {

  525. 		queue_Data_Transfer(txpipe_, xbox360w_inquire_present, sizeof(xbox360w_inquire_present), this);

  526. 		connected_ = 0;		// remember that hardware is actually connected...

  527. 	}

  528. 	memset(axis, 0, sizeof(axis));	// clear out any data. 

  529. 	joystickType = jtype;		// remember we are an XBox One. 

  530. 	return true;

  531. }

  532. 

  533. void JoystickController::control(const Transfer_t *transfer)

  534. {

  535. }

  536. 

  537. 

  538. /************************************************************/

  539. //  Interrupt-based Data Movement

  540. /************************************************************/

  541. 

  542. void JoystickController::rx_callback(const Transfer_t *transfer)

  543. {

  544. 	if (!transfer->driver) return;

  545. 	((JoystickController *)(transfer->driver))->rx_data(transfer);

  546. }

  547. 

  548. void JoystickController::tx_callback(const Transfer_t *transfer)

  549. {

  550. 	if (!transfer->driver) return;

  551. 	((JoystickController *)(transfer->driver))->tx_data(transfer);

  552. }

  553. 

  554. 

  555. 

  556. /************************************************************/

  557. //  Interrupt-based Data Movement

  558. // XBox one input data when type == 0x20

  559. // Information came from several places on the web including: 

  560. // https://github.com/quantus/xbox-one-controller-protocol

  561. /************************************************************/

  562. typedef struct {

  563. 	uint8_t type;

  564. 	uint8_t const_0;

  565. 	uint16_t id;

  566. 	// From online references button order: 

  567. 	//     sync, dummy, start, back, a, b, x, y

  568. 	//     dpad up, down left, right

  569. 	//	   lb, rb, left stick, right stick

  570. 	// Axis: 

  571. 	//     lt, rt, lx, ly, rx, ry

  572. 	//     

  573. 	uint16_t buttons; 

  574. 	int16_t	axis[6];

  575. } xbox1data20_t;

  576. 

  577. typedef struct {

  578. 	uint8_t state;

  579. 	uint8_t id_or_type;

  580. 	uint16_t controller_status;

  581. 	uint16_t unknown;

  582. 	// From online references button order: 

  583. 	//     sync, dummy, start, back, a, b, x, y

  584. 	//     dpad up, down left, right

  585. 	//	   lb, rb, left stick, right stick

  586. 	// Axis: 

  587. 	//     lt, rt, lx, ly, rx, ry

  588. 	//

  589. 	uint16_t buttons; 

  590. 	uint8_t lt;

  591. 	uint8_t rt;

  592. 	int16_t	axis[4];

  593. } xbox360data_t;

  594. 

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

  596. 

  597. void JoystickController::rx_data(const Transfer_t *transfer)

  598. {

  599. 	print("JoystickController::rx_data: ");

  600. 	print_hexbytes((uint8_t*)transfer->buffer, transfer->length);

  601. 

  602. 	if (joystickType == XBOXONE) {

  603. 		// Process XBOX One data

  604. 		axis_mask_ = 0x3f;	

  605. 		axis_changed_mask_ = 0;	// assume none for now

  606. 		xbox1data20_t *xb1d = (xbox1data20_t *)transfer->buffer;

  607. 		if ((xb1d->type == 0x20) && (transfer->length >= sizeof (xbox1data20_t))) {

  608. 			// We have a data transfer.  Lets see what is new...

  609. 			if (xb1d->buttons != buttons) {

  610. 				buttons = xb1d->buttons;

  611. 				anychange = true;

  612. 			}

  613. 			for (uint8_t i = 0; i < sizeof (xbox_axis_order_mapping); i++) {

  614. 				// The first two values were unsigned. 

  615. 				int axis_value = (i < 2)? (int)(uint16_t)xb1d->axis[i] : xb1d->axis[i];

  616. 				if (axis_value != axis[xbox_axis_order_mapping[i]]) {

  617. 					axis[xbox_axis_order_mapping[i]] = axis_value;

  618. 					axis_changed_mask_ |= (1 << xbox_axis_order_mapping[i]);

  619. 					anychange = true;

  620. 				}

  621. 			}

  622. 			joystickEvent = true;

  623. 		}

  624. 

  625. 	} else if (joystickType == XBOX360) {

  626. 		// First byte appears to status - if the byte is 0x8 it is a connect or disconnect of the controller. 

  627. 		xbox360data_t  *xb360d = (xbox360data_t *)transfer->buffer;

  628. 		if (xb360d->state == 0x08) {

  629. 			if (xb360d->id_or_type != connected_) {

  630. 				connected_ = xb360d->id_or_type;	// remember it... 

  631. 				if (connected_) {

  632. 					println("XBox360w - Connected type:", connected_, HEX);

  633. 					// rx_ep_ should be 1, 3, 5, 7 for the wireless convert to 2-5 on led

  634. 					setLEDs(2+rx_ep_/2);	// Right now hard coded to first joystick...

  635. 

  636. 				} else {

  637. 					println("XBox360w - disconnected");

  638. 				}

  639. 			}

  640. 		} else if((xb360d->id_or_type == 0x00) && (xb360d->controller_status & 0x1300)) {

  641. 			  // Controller status report - Maybe we should save away and allow the user access?

  642. 	            println("XBox360w - controllerStatus: ", xb360d->controller_status, HEX);

  643.         } else if(xb360d->id_or_type == 0x01) { // Lets only process report 1.

  644. 			//const uint8_t *pbuffer = (uint8_t*)transfer->buffer;

  645.         	//for (uint8_t i = 0; i < transfer->length; i++) DBGPrintf("%02x ", pbuffer[i]);

  646.         	//DBGPrintf("\n");

  647. 	        

  648. 	        if (buttons != xb360d->buttons) {

  649. 	        	buttons = xb360d->buttons;

  650. 	        	anychange = true;

  651. 	        }

  652. 			axis_mask_ = 0x3f;	

  653. 			axis_changed_mask_ = 0;	// assume none for now

  654. 

  655. 			for (uint8_t i = 0; i < 4; i++) {

  656. 				if (axis[i] != xb360d->axis[i]) {

  657. 					axis[i] = xb360d->axis[i];

  658. 					axis_changed_mask_ |= (1 << i);

  659. 					anychange = true;

  660. 				}

  661. 			}

  662. 			// the two triggers show up as 4 and 5

  663. 			if (axis[4] != xb360d->lt) {

  664. 				axis[4] = xb360d->lt;

  665. 				axis_changed_mask_ |= (1 << 4);

  666. 				anychange = true;

  667. 			}

  668. 

  669. 			if (axis[5] != xb360d->rt) {

  670. 				axis[5] = xb360d->rt;

  671. 				axis_changed_mask_ |= (1 << 5);

  672. 				anychange = true;

  673. 			}

  674. 

  675. 			if (anychange) joystickEvent = true;

  676. 		}

  677. 	}

  678. 

  679. 	queue_Data_Transfer(rxpipe_, rxbuf_, rx_size_, this);

  680. }

  681. 

  682. void JoystickController::tx_data(const Transfer_t *transfer)

  683. {

  684. }

  685. 

  686. void JoystickController::disconnect()

  687. {

  688. 	axis_mask_ = 0;	

  689. 	axis_changed_mask_ = 0;

  690. 	// TODO: free resources

  691. }

  692. 

  693. bool JoystickController::claim_bluetooth(BluetoothController *driver, uint32_t bluetooth_class) 

  694. {

  695. 	if ((((bluetooth_class & 0xff00) == 0x2500) || (((bluetooth_class & 0xff00) == 0x500))) && ((bluetooth_class & 0x3C) == 0x08)) {

  696. 		DBGPrintf("JoystickController::claim_bluetooth TRUE\n");

  697. 		btdriver_ = driver;

  698. 		btdevice = (Device_t*)driver;	// remember this way 

  699. 		return true;

  700. 	}

  701. 	return false;

  702. }

  703. 

  704. 

  705. bool JoystickController::process_bluetooth_HID_data(const uint8_t *data, uint16_t length) 

  706. {

  707. 	// Example data from PS4 controller

  708. 	//01 7e 7f 82 84 08 00 00 00 00

  709. 	//   LX LY RX RY BT BT PS LT RT

  710. 	//DBGPrintf("JoystickController::process_bluetooth_HID_data\n");

  711. 	// May have to look at this one with other controllers...

  712. 	if (data[0] == 1) {

  713. 		//print("  Joystick Data: ");

  714. 		//print_hexbytes(data, length);

  715. //		DBGPrintf("  Joystick Data: ");

  716. 		uint64_t mask = 0x1;

  717. 		axis_mask_ = 0;

  718. 		axis_changed_mask_ = 0;

  719. 

  720. 		if (length > TOTAL_AXIS_COUNT) length = TOTAL_AXIS_COUNT;	// don't overflow arrays...

  721. 		for (uint16_t i = 0; i < length; i++ ) {

  722. 			axis_mask_ |= mask;

  723. 			if(data[i] != axis[i]) { 

  724. 				axis_changed_mask_ |= mask;

  725. 				axis[i] = data[i];

  726. 			} 

  727. 			mask <<= 1;	// shift down the mask.

  728. //			DBGPrintf("%02x ", axis[i]);

  729. 		}

  730. //		DBGPrintf("\n");

  731. 		joystickEvent = true;

  732. 		connected_ = true;

  733. 		return true;

  734. 	} else if(data[0] == 0x11){

  735. 		DBGPrintf("  Joystick Data: ");

  736. 		uint64_t mask = 0x1;

  737. 		axis_mask_ = 0;

  738. 		axis_changed_mask_ = 0;

  739. 		

  740. 		//This moves data to be equivalent to what we see for

  741. 		//data[0] = 0x01

  742. 		uint8_t tmp_data[length-2];

  743. 		for (uint16_t i = 0; i < (length-2); i++ ) {

  744. 			tmp_data[i] = data[i+2];

  745. 		}

  746. 		

  747. 		/*

  748. 		 * [1] LX, [2] = LY, [3] = RX, [4] = RY

  749. 		 * [5] combo, tri, cir, x, sqr, D-PAD (4bits, 0-3

  750. 		 * [6] R3,L3, opt, share, R2, L2, R1, L1

  751. 		 * [7] Counter (bit7-2), T-PAD, PS

  752. 		 * [8] Left Trigger, [9] Right Trigger

  753. 		 * [10-11] Timestamp

  754. 		 * [12] Battery (0 to 0xff)

  755. 		 * [13-14] acceleration x

  756. 		 * [15-16] acceleration y

  757. 		 * [17-18] acceleration z

  758. 		 * [19-20] gyro x

  759. 		 * [21-22] gyro y

  760. 		 * [23-24] gyro z

  761. 		 * [25-29] unknown

  762. 		 * [30] 0x00,phone,mic, usb, battery level (4bits)

  763. 		 * rest is trackpad?  to do implement?

  764. 		 */

  765. 		//PS Bit

  766. 		tmp_data[7] = (tmp_data[7] >> 0) & 1;

  767. 		//set arrow buttons to axis[0]

  768. 		tmp_data[0] = tmp_data[5] & ((1 << 4) - 1);

  769. 		//set buttons for last 4bits in the axis[5]

  770. 		tmp_data[5] = tmp_data[5] >> 4;

  771. 

  772. 		for (uint16_t i = 0; i < (length-2); i++ ) {

  773. 			if(tmp_data[i] != axis[i]) { 

  774. 				axis_changed_mask_ |= mask;

  775. 				axis[i] = tmp_data[i];

  776. 			} 

  777. 			mask <<= 1;	// shift down the mask.

  778. 			DBGPrintf("%02x ", axis[i]);

  779. 		}

  780. 		DBGPrintf("\n");

  781. 		joystickEvent = true;

  782. 		connected_ = true;

  783. 	}

  784. 	return false;

  785. }

  786. 

  787. void JoystickController::remoteNameComplete(const uint8_t *remoteName) 

  788. {

  789. 	// Sort of a hack, but try to map the name given from remote to a type...

  790. 	if (!remoteName) return;

  791. 

  792. 	if (strncmp((const char *)remoteName, "Wireless Controller", 19) == 0) {

  793. 		DBGPrintf("  JoystickController::remoteNameComplete %s - set to PS4\n", remoteName);

  794. 		special_process_required = SP_NEED_CONNECT; 		// We need to force this. 

  795. 		joystickType = PS4;

  796. 	} else if (strncmp((const char *)remoteName, "PLAYSTATION(R)3 Controller", 26) == 0) {

  797. 		DBGPrintf("  JoystickController::remoteNameComplete %s - set to PS3\n", remoteName);

  798. 		special_process_required = SP_PS3_IDS; 		// PS3 maybe needs different IDS. 

  799. 		joystickType = PS3;

  800. 

  801. 		// Hack to see if setting control/interrupt ids will help on PS3...

  802. //    	btdriver_->control_dcid_ = 0x40;

  803.  //   	btdriver_->interrupt_dcid_ = 0x41;

  804. 

  805. 	}

  806. 

  807. }

  808. 

  809. void JoystickController::connectionComplete() 

  810. {

  811. 	DBGPrintf("  JoystickController::connectionComplete joystick type %d\n", joystickType);

  812. 	if (joystickType == PS4) {

  813. 		uint8_t packet[2];

  814. 		packet[0] = 0x43; // HID BT Get_report (0x40) | Report Type (Feature 0x03)

  815. 		packet[1] = 0x02; // Report ID

  816. 		DBGPrintf("Set PS4 report\n");

  817. 		delay(1);

  818. 		btdriver_->sendL2CapCommand(packet, sizeof(packet), 0x40);

  819. 

  820. 	} else if (joystickType == PS3) {

  821. 	uint8_t packet[6];

  822. 		packet[0] = 0x53; // HID BT Set_report (0x50) | Report Type (Feature 0x03)

  823. 		packet[1] = 0xF4; // Report ID

  824. 		packet[2] = 0x42; // Special PS3 Controller enable commands

  825. 		packet[3] = 0x03;

  826. 		packet[4] = 0x00;

  827. 		packet[5] = 0x00;

  828. 

  829. 		DBGPrintf("enable six axis\n");

  830. 		delay(1);

  831. 		btdriver_->sendL2CapCommand(packet, sizeof(packet), BluetoothController::CONTROL_SCID);

  832. 	}

  833. 

  834. }

  835. 

  836. void JoystickController::release_bluetooth() 

  837. {

  838. 	btdevice = nullptr;	// remember this way 

  839. 	btdriver_ = nullptr;

  840. 	connected_ = false;

  841. 	special_process_required = false;

  842. 

  843. }