visus
/
teensy-usbhost
Seguir 1
Destacar 0
Fork 0
Código Incidencias 0 Pull Requests 0 Lanzamientos 0 Wiki Actividad
No puede seleccionar más de 25 temas Los temas deben comenzar con una letra o número, pueden incluir guiones ('-') y pueden tener hasta 35 caracteres de largo.
228 Commits
1 Rama
Árbol: 053ddf0718
Ramas Etiquetas
${ item.name }
Crear rama ${ searchTerm }
desde '053ddf0718'
${ noResults }
teensy-usbhost/joystick.cpp

975 líneas
32KB
Original Blame Histórico 

  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. 	if (btdevice != nullptr) return remote_name_;

  104. 	return nullptr;

  105. }

  106. 

  107. const uint8_t *JoystickController::serialNumber()

  108. {

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

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

  111. 	return nullptr;

  112. }

  113. 

  114. 

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

  116. {

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

  118. 	// joystick types. 

  119. 	rumble_lValue_ = lValue; 

  120. 	rumble_rValue_ = rValue;

  121. 	rumble_timeout_ = timeout;

  122. 

  123. 	switch (joystickType_) {

  124. 		default:

  125. 			break;

  126. 		case PS3:

  127. 			return transmitPS3UserFeedbackMsg();

  128. 		case PS4:

  129. 			return transmitPS4UserFeedbackMsg();

  130. 		case XBOXONE:

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

  132. 			txbuf_[0] = 0x9;

  133. 			txbuf_[1] = 0x0;

  134. 			txbuf_[2] = 0x0;

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

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

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

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

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

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

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

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

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

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

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

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

  147. 			}

  148. 			return true;	// 

  149. 		case XBOX360:

  150. 			txbuf_[0] = 0x00;

  151. 			txbuf_[1] = 0x01;

  152. 			txbuf_[2] = 0x0F;

  153. 			txbuf_[3] = 0xC0;

  154. 			txbuf_[4] = 0x00;

  155. 			txbuf_[5] = lValue;

  156. 			txbuf_[6] = rValue;

  157. 			txbuf_[7] = 0x00;

  158. 			txbuf_[8] = 0x00;

  159. 			txbuf_[9] = 0x00;

  160. 			txbuf_[10] = 0x00;

  161. 			txbuf_[11] = 0x00;

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

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

  164. 			}

  165. 			return true;

  166. 	} 

  167. 	return false;

  168. }

  169. 

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

  171. {

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

  173. 	// joystick types. 

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

  175. 		leds_[0] = lr;

  176. 		leds_[1] = lg;

  177. 		leds_[2] = lb;

  178. 

  179. 		switch (joystickType_) {

  180. 			case PS3:

  181. 				return transmitPS3UserFeedbackMsg();

  182. 			case PS4:

  183. 				return transmitPS4UserFeedbackMsg();

  184. 			case XBOX360:

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

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

  187. 				// 6-9() - On 

  188. 			    // ...

  189. 				txbuf_[1] = 0x00;

  190. 				txbuf_[2] = 0x08;

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

  192. 				txbuf_[4] = 0x00;

  193. 				txbuf_[5] = 0x00;

  194. 				txbuf_[6] = 0x00;

  195. 				txbuf_[7] = 0x00;

  196. 				txbuf_[8] = 0x00;

  197. 				txbuf_[9] = 0x00;

  198. 				txbuf_[10] = 0x00;

  199. 				txbuf_[11] = 0x00;

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

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

  202. 				}

  203. 				return true;

  204. 			case XBOXONE:

  205. 			default:

  206. 				return false;

  207. 		} 

  208. 	}

  209. 	return false;

  210. }

  211. 

  212. bool JoystickController::transmitPS4UserFeedbackMsg() {

  213. 	if (driver_)  {

  214. 		uint8_t packet[32];

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

  216. 

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

  218. 	    packet[1]= 0xFF;

  219. 

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

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

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

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

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

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

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

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

  228. 	} else if (btdriver_) {

  229. 		uint8_t packet[79];

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

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

  232. 	    packet[0] = 0x52; 

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

  234. 		packet[2] = 0x80;

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

  236. 		packet[4] = 0xFF;

  237. 

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

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

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

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

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

  243. 

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

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

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

  247. 

  248.      	return true;

  249. 	}

  250. 	return false;

  251. }

  252. 

  253. static const uint8_t PS3_USER_FEEDBACK_INIT[] = {

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

  255.         0x00, 0x00, 0x00, 0x00, 0x00,

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

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

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

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

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

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

  262.         0x00, 0x00, 0x00, 0x00, 0x00,

  263.         0x00, 0x00, 0x00 };

  264. 

  265. bool JoystickController::transmitPS3UserFeedbackMsg() {

  266. 	if (driver_) {

  267. 	    memcpy(txbuf_, PS3_USER_FEEDBACK_INIT, 48);

  268. 

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

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

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

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

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

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

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

  276. 	} else if (btdriver_) {

  277. 		txbuf_[0] = 0x52;

  278. 		txbuf_[1] = 0x1;

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

  280. 

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

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

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

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

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

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

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

  288.      	return true;

  289. 	}

  290. 	return false;

  291. }

  292. 

  293. //*****************************************************************************

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

  295. //*****************************************************************************

  296. 

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

  298. {

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

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

  301. 	// only claim from one physical device

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

  303. 

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

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

  306. 

  307. 	mydevice = dev;

  308. 	collections_claimed++;

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

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

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

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

  313. 

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

  315. 	joystickType_ = mapVIDPIDtoJoystickType(mydevice->idVendor, mydevice->idProduct, false);

  316. 	DBGPrintf("JoystickController::claim_collection joystickType_=%d\n", joystickType_);

  317. 	switch (joystickType_) {

  318. 		case PS3:

  319. 			additional_axis_usage_page_ = 0x1;

  320. 			additional_axis_usage_start_ = 0x100;

  321. 			additional_axis_usage_count_ = 39;

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

  323. 			break;

  324. 		case PS4:

  325. 			additional_axis_usage_page_ = 0xFF00;

  326. 			additional_axis_usage_start_ = 0x21;

  327. 			additional_axis_usage_count_ = 54;

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

  329. 			break;

  330. 		default: 

  331. 			additional_axis_usage_page_ = 0;

  332. 			additional_axis_usage_start_ = 0;

  333. 			additional_axis_usage_count_ = 0;

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

  335. 	}

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

  337. 	return CLAIM_REPORT;

  338. }

  339. 

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

  341. {

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

  343. 		mydevice = NULL;

  344. 		driver_ = nullptr;

  345. 		axis_mask_ = 0;	

  346. 		axis_changed_mask_ = 0;

  347. 	}

  348. }

  349. 

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

  351. {

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

  353. }

  354. 

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

  356. {

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

  358. 	uint32_t usage_page = usage >> 16;

  359. 	usage &= 0xFFFF;

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

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

  362. 		if (value == 0) {

  363. 			if (buttons & bit) {

  364. 				buttons &= ~bit;

  365. 				anychange = true;

  366. 			}

  367. 		} else {

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

  369. 				buttons |= bit;

  370. 				anychange = true;

  371. 			}

  372. 		}

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

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

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

  376. 		uint32_t i = usage - 0x30;

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

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

  379. 			axis[i] = value;

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

  381. 			if (axis_changed_mask_ & axis_change_notify_mask_)

  382. 				anychange = true;

  383. 		}

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

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

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

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

  388. 			// We are in the user range. 

  389. 			uint16_t usage_index = usage - additional_axis_usage_start_ + STANDARD_AXIS_COUNT;

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

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

  392. 					axis[usage_index] = value;

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

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

  395. 					if (axis_changed_mask_ & axis_change_notify_mask_)

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

  397. 				}

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

  399. 			}

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

  401. 		}

  402. 

  403. 	} else {

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

  405. 

  406. 	}

  407. 	// TODO: hat switch?

  408. }

  409. 

  410. void JoystickController::hid_input_end()

  411. {

  412. 	if (anychange) {

  413. 		joystickEvent = true;

  414. 	}

  415. }

  416. 

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

  418. {

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

  420. 	return true;

  421. }

  422. 

  423. void JoystickController::joystickDataClear() {

  424. 	joystickEvent = false;

  425. 	anychange = false;

  426. 	axis_changed_mask_ = 0;

  427. 	axis_mask_ = 0;

  428. }

  429. 

  430. //*****************************************************************************

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

  432. // Example: XBox One controller. 

  433. //*****************************************************************************

  434. 

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

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

  437. 

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

  439. {

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

  441. 

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

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

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

  445. 

  446. 	// Try claiming at the interface level.

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

  448. 	print_hexbytes(descriptors, len);

  449. 

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

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

  452. 	if (jtype == UNKNOWN)

  453. 		return false; 

  454. 

  455. 	// XBOX One

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

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

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

  459. 

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

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

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

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

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

  465. 

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

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

  468. 

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

  470. 

  471. 	// Some common stuff for both XBoxs

  472. 	uint32_t count_end_points = descriptors[4];

  473. 	if (count_end_points < 2) return false;

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

  475. 	rx_ep_ = 0;

  476. 	uint32_t txep = 0;

  477. 	uint8_t rx_interval = 0;

  478. 	uint8_t tx_interval = 0;

  479. 	rx_size_ = 0;

  480. 	tx_size_ = 0;

  481. 	uint32_t descriptor_index = 9; 

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

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

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

  485. 	}	

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

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

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

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

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

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

  492. 			// have a bulk EP size 

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

  494. 				rx_ep_ = descriptors[descriptor_index+2];

  495. 				rx_size_ = descriptors[descriptor_index+4];

  496. 				rx_interval = descriptors[descriptor_index+6];

  497. 			} else {

  498. 				txep = descriptors[descriptor_index+2]; 

  499. 				tx_size_ = descriptors[descriptor_index+4];

  500. 				tx_interval = descriptors[descriptor_index+6];

  501. 			}

  502. 		}

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

  504. 	}

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

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

  507. 	print("(", rx_size_);

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

  509. 	print("(", tx_size_);

  510. 	println(")");

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

  512. 	if (!rxpipe_) return false;

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

  514. 	if (!txpipe_) {

  515. 		//free_Pipe(rxpipe_);

  516. 		return false;

  517. 	}

  518. 	rxpipe_->callback_function = rx_callback;

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

  520. 

  521. 	txpipe_->callback_function = tx_callback;

  522. 

  523. 	if (jtype == XBOXONE) {

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

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

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

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

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

  529. 	}

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

  531. 	joystickType_ = jtype;		// remember we are an XBox One. 

  532. 	DBGPrintf("   JoystickController::claim joystickType_ %d\n", joystickType_);

  533. 	return true;

  534. }

  535. 

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

  537. {

  538. }

  539. 

  540. 

  541. /************************************************************/

  542. //  Interrupt-based Data Movement

  543. /************************************************************/

  544. 

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

  546. {

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

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

  549. }

  550. 

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

  552. {

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

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

  555. }

  556. 

  557. 

  558. 

  559. /************************************************************/

  560. //  Interrupt-based Data Movement

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

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

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

  564. /************************************************************/

  565. typedef struct {

  566. 	uint8_t type;

  567. 	uint8_t const_0;

  568. 	uint16_t id;

  569. 	// From online references button order: 

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

  571. 	//     dpad up, down left, right

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

  573. 	// Axis: 

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

  575. 	//     

  576. 	uint16_t buttons; 

  577. 	int16_t	axis[6];

  578. } xbox1data20_t;

  579. 

  580. typedef struct {

  581. 	uint8_t state;

  582. 	uint8_t id_or_type;

  583. 	uint16_t controller_status;

  584. 	uint16_t unknown;

  585. 	// From online references button order: 

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

  587. 	//     dpad up, down left, right

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

  589. 	// Axis: 

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

  591. 	//

  592. 	uint16_t buttons; 

  593. 	uint8_t lt;

  594. 	uint8_t rt;

  595. 	int16_t	axis[4];

  596. } xbox360data_t;

  597. 

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

  599. 

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

  601. {

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

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

  604. 

  605. 	if (joystickType_ == XBOXONE) {

  606. 		// Process XBOX One data

  607. 		axis_mask_ = 0x3f;	

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

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

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

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

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

  613. 				buttons = xb1d->buttons;

  614. 				anychange = true;

  615. 			}

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

  617. 				// The first two values were unsigned. 

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

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

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

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

  622. 					anychange = true;

  623. 				}

  624. 			}

  625. 			joystickEvent = true;

  626. 		}

  627. 

  628. 	} else if (joystickType_ == XBOX360) {

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

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

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

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

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

  634. 				if (connected_) {

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

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

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

  638. 

  639. 				} else {

  640. 					println("XBox360w - disconnected");

  641. 				}

  642. 			}

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

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

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

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

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

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

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

  650. 	        

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

  652. 	        	buttons = xb360d->buttons;

  653. 	        	anychange = true;

  654. 	        }

  655. 			axis_mask_ = 0x3f;	

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

  657. 

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

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

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

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

  662. 					anychange = true;

  663. 				}

  664. 			}

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

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

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

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

  669. 				anychange = true;

  670. 			}

  671. 

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

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

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

  675. 				anychange = true;

  676. 			}

  677. 

  678. 			if (anychange) joystickEvent = true;

  679. 		}

  680. 	}

  681. 

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

  683. }

  684. 

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

  686. {

  687. }

  688. 

  689. void JoystickController::disconnect()

  690. {

  691. 	axis_mask_ = 0;	

  692. 	axis_changed_mask_ = 0;

  693. 	// TODO: free resources

  694. }

  695. 

  696. bool JoystickController::claim_bluetooth(BluetoothController *driver, uint32_t bluetooth_class, uint8_t *remoteName) 

  697. {

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

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

  700. 		btdriver_ = driver;

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

  702. 		return true;

  703. 	}

  704. 	if (remoteName && (strncmp((const char *)remoteName, "PLAYSTATION(R)3", 15) == 0)) {

  705. 		DBGPrintf("JoystickController::claim_bluetooth TRUE PS3 hack...\n");

  706. 		btdriver_ = driver;

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

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

  709. 		joystickType_ = PS3;

  710. 		return true;

  711. 	}

  712. 	return false;

  713. }

  714. 

  715. 

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

  717. {

  718. 	// Example data from PS4 controller

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

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

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

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

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

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

  725. 		//print_hexbytes(data, length);

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

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

  728. 		if (joystickType_ == PS3) {

  729. 			// Quick and dirty hack to match PS3 HID data

  730. 			uint32_t cur_buttons = data[2] | ((uint16_t)data[3] << 8) | ((uint32_t)data[4] << 16); 

  731. 			if (cur_buttons != buttons) {

  732. 				buttons = cur_buttons;

  733. 				joystickEvent = true;	// something changed.

  734. 			}

  735. 

  736. 			uint64_t mask = 0x1;

  737. 			axis_mask_ = 0x27;	// assume bits 0, 1, 2, 5

  738. 			for (uint16_t i = 0; i < 3; i++) {

  739. 				if (axis[i] != data[i+6]) {

  740. 					axis_changed_mask_ |= mask;

  741. 					axis[i] = data[i+6];

  742. 				}

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

  744. 			}

  745. 			if (axis[5] != data[9]) {

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

  747. 				axis[5] = data[9];

  748. 			}

  749. 			

  750. 			if (axis[3] != data[18]) {

  751. 				axis_changed_mask_ |= (1<<3);

  752. 				axis[3] = data[18];

  753. 			}

  754. 			

  755. 			if (axis[4] != data[19]) {

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

  757. 				axis[4] = data[19];

  758. 			}

  759. 			

  760. 			// Then rest of data

  761. 			mask = 0x1 << 10;	// setup for other bits

  762. 			for (uint16_t i = 10; i < length; i++ ) {

  763. 				axis_mask_ |= mask;

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

  765. 					axis_changed_mask_ |= mask;

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

  767. 				} 

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

  769. 			}

  770. 

  771. 		} else {

  772. 			uint64_t mask = 0x1;

  773. 			axis_mask_ = 0;

  774. 

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

  776. 				axis_mask_ |= mask;

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

  778. 					axis_changed_mask_ |= mask;

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

  780. 				} 

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

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

  783. 			}

  784. 

  785. 		}

  786. 

  787. 		if (axis_changed_mask_ & axis_change_notify_mask_)

  788. 			joystickEvent = true;

  789. 		connected_ = true;

  790. 		return true;

  791. 

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

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

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

  795. 			//print_hexbytes(data, length);

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

  797. 			uint64_t mask = 0x1;

  798. 			axis_mask_ = 0;

  799. 			axis_changed_mask_ = 0;

  800. 

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

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

  803. 				axis_mask_ |= mask;

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

  805. 					axis_changed_mask_ |= mask;

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

  807. 				} 

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

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

  810. 			}

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

  812. 			joystickEvent = true;

  813. 			connected_ = true;

  814. 			return true;

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

  816. 			DBGPrintf("\n  Joystick Data: ");

  817. 			uint64_t mask = 0x1;

  818. 			axis_mask_ = 0;

  819. 			axis_changed_mask_ = 0;

  820. 			

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

  822. 			//data[0] = 0x01

  823. 			uint8_t tmp_data[length-2];

  824. 			

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

  826. 				tmp_data[i] = 0;

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

  828. 			}

  829. 			

  830. 			/*

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

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

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

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

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

  836. 			 * [10-11] Timestamp

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

  838. 			 * [13-14] acceleration x

  839. 			 * [15-16] acceleration y

  840. 			 * [17-18] acceleration z

  841. 			 * [19-20] gyro x

  842. 			 * [21-22] gyro y

  843. 			 * [23-24] gyro z

  844. 			 * [25-29] unknown

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

  846. 			 * rest is trackpad?  to do implement?

  847. 			 */

  848. 			//PS Bit

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

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

  851. 			tmp_data[10] = tmp_data[5] & ((1 << 4) - 1);

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

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

  854. 			

  855. 		

  856. 			// Quick and dirty hack to match PS4 HID data

  857. 			uint32_t cur_buttons = tmp_data[7] | (tmp_data[10]) | ((tmp_data[6]*10)) | ((uint16_t)tmp_data[5] << 16) ; 

  858. 			if (cur_buttons != buttons) {

  859. 				buttons = cur_buttons;

  860. 				joystickEvent = true;	// something changed.

  861. 			}

  862. 			

  863. 			mask = 0x1;

  864. 			axis_mask_ = 0x27;	// assume bits 0, 1, 2, 5

  865. 			for (uint16_t i = 0; i < 3; i++) {

  866. 				if (axis[i] != tmp_data[i+1]) {

  867. 					axis_changed_mask_ |= mask;

  868. 					axis[i] = tmp_data[i+1];

  869. 				}

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

  871. 			}

  872. 			if (axis[5] != tmp_data[4]) {

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

  874. 				axis[5] = tmp_data[4];

  875. 			}

  876. 			

  877. 			if (axis[3] != tmp_data[8]) {

  878. 				axis_changed_mask_ |= (1<<3);

  879. 				axis[3] = tmp_data[8];

  880. 			}

  881. 			

  882. 			if (axis[4] != tmp_data[9]) {

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

  884. 				axis[4] = tmp_data[9];

  885. 			}

  886. 			

  887. 			//limit for masking

  888. 			mask = 0x1;

  889. 			for (uint16_t i = 6; i < (64); i++ ) {

  890. 				axis_mask_ |= mask;

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

  892. 					axis_changed_mask_ |= mask;

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

  894. 				}

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

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

  897. 			}

  898. 			DBGPrintf("\n");

  899. 			//DBGPrintf("Axis Mask (axis_mask_, axis_changed_mask_; %d, %d\n", axis_mask_,axis_changed_mask_);

  900. 			joystickEvent = true;

  901. 			connected_ = true;

  902. 		}

  903. 	}

  904. 	return false;

  905. }

  906. 

  907. bool JoystickController::remoteNameComplete(const uint8_t *remoteName) 

  908. {

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

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

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

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

  913. 		joystickType_ = PS4;

  914. 	} else if (strncmp((const char *)remoteName, "PLAYSTATION(R)3", 15) == 0) {

  915. 		DBGPrintf("  JoystickController::remoteNameComplete %x %s - set to PS3\n", (uint32_t)this, remoteName);

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

  917. 		joystickType_ = PS3;

  918. 	} else {

  919. 		DBGPrintf("  JoystickController::remoteNameComplete %s - Unknown\n", remoteName);

  920. 	}

  921. 	DBGPrintf("  Joystick Type: %d\n", joystickType_);

  922. 	return true;

  923. }

  924. 

  925. void JoystickController::connectionComplete() 

  926. {

  927. 	DBGPrintf("  JoystickController::connectionComplete %x joystick type %d\n", (uint32_t)this, joystickType_);

  928. 	if (joystickType_ == PS4) {

  929. 		uint8_t packet[2];

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

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

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

  933. 		delay(1);

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

  935. 

  936. 	} else if (joystickType_ == PS3) {

  937. 	uint8_t packet[6];

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

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

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

  941. 		packet[3] = 0x03;

  942. 		packet[4] = 0x00;

  943. 		packet[5] = 0x00;

  944. 

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

  946. 		delay(1);

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

  948. 	}

  949. 

  950. }

  951. 

  952. void JoystickController::release_bluetooth() 

  953. {

  954. 	btdevice = nullptr;	// remember this way 

  955. 	btdriver_ = nullptr;

  956. 	connected_ = false;

  957. 	special_process_required = false;

  958. 

  959. }

  960. 

  961. 

  962. bool JoystickController::PS3Pair(uint8_t* bdaddr) {

  963.  	if ((joystickType_ != PS3) || !driver_) return false; // not a PS2 nor plugged into USB...

  964. 

  965.     /* Set the internal Bluetooth address */

  966.     txbuf_[0] = 0x01;

  967.     txbuf_[1] = 0x00;

  968. 

  969.     for(uint8_t i = 0; i < 6; i++)

  970.             txbuf_[i + 2] = bdaddr[5 - i]; // Copy into buffer, has to be written reversed, so it is MSB first

  971. 

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

  973. 	return driver_->sendControlPacket(0x21, 9, 0x3f5, 0, 8, txbuf_); 

  974. }