visus
/
teensy-core-4.1
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Teensy 4.1 core updated for C++20
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1185 Commits
2 Branches
Tree: 4148e650d0
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4148e650d0'
${ noResults }
teensy-core-4.1/teensy3/usb_dev.c

1217 lines
31KB
Raw Blame History 

  1. /* Teensyduino Core Library

  2.  * http://www.pjrc.com/teensy/

  3.  * Copyright (c) 2017 PJRC.COM, LLC.

  4.  *

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

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

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

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

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

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

  11.  * the following conditions:

  12.  *

  13.  * 1. The above copyright notice and this permission notice shall be

  14.  * included in all copies or substantial portions of the Software.

  15.  *

  16.  * 2. If the Software is incorporated into a build system that allows

  17.  * selection among a list of target devices, then similar target

  18.  * devices manufactured by PJRC.COM must be included in the list of

  19.  * target devices and selectable in the same manner.

  20.  *

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

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

  23.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

  24.  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

  25.  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

  26.  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

  27.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

  28.  * SOFTWARE.

  29.  *

  30.  * Trying to understand this rather complex code?

  31.  *

  32.  * Kevin Cuzner wrote a simpler version, and a great blog article:

  33.  *   http://kevincuzner.com/2014/12/12/teensy-3-1-bare-metal-writing-a-usb-driver/

  34.  *   https://github.com/kcuzner/teensy-oscilloscope/blob/master/scope-teensy/src/usb.c

  35.  *

  36.  * Andy Payne wrote another relatively simple USB example for Freescale Kinetis

  37.  *   https://github.com/payne92/bare-metal-arm

  38.  */

  39. 

  40. #include "usb_dev.h"

  41. #if F_CPU >= 20000000 && defined(NUM_ENDPOINTS)

  42. 

  43. #include "kinetis.h"

  44. //#include "HardwareSerial.h"

  45. #include "usb_mem.h"

  46. #include <string.h> // for memset

  47. 

  48. // This code has a known bug with compiled with -O2 optimization on gcc 5.4.1

  49. // https://forum.pjrc.com/threads/53574-Teensyduino-1-43-Beta-2?p=186177&viewfull=1#post186177

  50. #if defined(__MKL26Z64__)

  51. #pragma GCC optimize ("Os")

  52. #else

  53. #pragma GCC optimize ("O3")

  54. #endif

  55. 

  56. // buffer descriptor table

  57. 

  58. typedef struct {

  59. 	uint32_t desc;

  60. 	void * addr;

  61. } bdt_t;

  62. 

  63. __attribute__ ((section(".usbdescriptortable"), used))

  64. static bdt_t table[(NUM_ENDPOINTS+1)*4];

  65. 

  66. static usb_packet_t *rx_first[NUM_ENDPOINTS];

  67. static usb_packet_t *rx_last[NUM_ENDPOINTS];

  68. static usb_packet_t *tx_first[NUM_ENDPOINTS];

  69. static usb_packet_t *tx_last[NUM_ENDPOINTS];

  70. uint16_t usb_rx_byte_count_data[NUM_ENDPOINTS];

  71. 

  72. static uint8_t tx_state[NUM_ENDPOINTS];

  73. #define TX_STATE_BOTH_FREE_EVEN_FIRST	0

  74. #define TX_STATE_BOTH_FREE_ODD_FIRST	1

  75. #define TX_STATE_EVEN_FREE		2

  76. #define TX_STATE_ODD_FREE		3

  77. #define TX_STATE_NONE_FREE_EVEN_FIRST	4

  78. #define TX_STATE_NONE_FREE_ODD_FIRST	5

  79. 

  80. #define BDT_OWN		0x80

  81. #define BDT_DATA1	0x40

  82. #define BDT_DATA0	0x00

  83. #define BDT_DTS		0x08

  84. #define BDT_STALL	0x04

  85. #define BDT_PID(n)	(((n) >> 2) & 15)

  86. 

  87. #define BDT_DESC(count, data)	(BDT_OWN | BDT_DTS \

  88. 				| ((data) ? BDT_DATA1 : BDT_DATA0) \

  89. 				| ((count) << 16))

  90. 

  91. #define TX   1

  92. #define RX   0

  93. #define ODD  1

  94. #define EVEN 0

  95. #define DATA0 0

  96. #define DATA1 1

  97. #define index(endpoint, tx, odd) (((endpoint) << 2) | ((tx) << 1) | (odd))

  98. #define stat2bufferdescriptor(stat) (table + ((stat) >> 2))

  99. 

  100. 

  101. static union {

  102.  struct {

  103.   union {

  104.    struct {

  105. 	uint8_t bmRequestType;

  106. 	uint8_t bRequest;

  107.    };

  108. 	uint16_t wRequestAndType;

  109.   };

  110. 	uint16_t wValue;

  111. 	uint16_t wIndex;

  112. 	uint16_t wLength;

  113.  };

  114.  struct {

  115. 	uint32_t word1;

  116. 	uint32_t word2;

  117.  };

  118. } setup;

  119. 

  120. 

  121. #define GET_STATUS		0

  122. #define CLEAR_FEATURE		1

  123. #define SET_FEATURE		3

  124. #define SET_ADDRESS		5

  125. #define GET_DESCRIPTOR		6

  126. #define SET_DESCRIPTOR		7

  127. #define GET_CONFIGURATION	8

  128. #define SET_CONFIGURATION	9

  129. #define GET_INTERFACE		10

  130. #define SET_INTERFACE		11

  131. #define SYNCH_FRAME		12

  132. 

  133. // SETUP always uses a DATA0 PID for the data field of the SETUP transaction.

  134. // transactions in the data phase start with DATA1 and toggle (figure 8-12, USB1.1)

  135. // Status stage uses a DATA1 PID.

  136. 

  137. static uint8_t ep0_rx0_buf[EP0_SIZE] __attribute__ ((aligned (4)));

  138. static uint8_t ep0_rx1_buf[EP0_SIZE] __attribute__ ((aligned (4)));

  139. static const uint8_t *ep0_tx_ptr = NULL;

  140. static uint16_t ep0_tx_len;

  141. static uint8_t ep0_tx_bdt_bank = 0;

  142. static uint8_t ep0_tx_data_toggle = 0;

  143. uint8_t usb_rx_memory_needed = 0;

  144. 

  145. volatile uint8_t usb_configuration = 0;

  146. volatile uint8_t usb_reboot_timer = 0;

  147. 

  148. 

  149. static void endpoint0_stall(void)

  150. {

  151. 	USB0_ENDPT0 = USB_ENDPT_EPSTALL | USB_ENDPT_EPRXEN | USB_ENDPT_EPTXEN | USB_ENDPT_EPHSHK;

  152. }

  153. 

  154. 

  155. static void endpoint0_transmit(const void *data, uint32_t len)

  156. {

  157. #if 0

  158. 	serial_print("tx0:");

  159. 	serial_phex32((uint32_t)data);

  160. 	serial_print(",");

  161. 	serial_phex16(len);

  162. 	serial_print(ep0_tx_bdt_bank ? ", odd" : ", even");

  163. 	serial_print(ep0_tx_data_toggle ? ", d1\n" : ", d0\n");

  164. #endif

  165. 	table[index(0, TX, ep0_tx_bdt_bank)].addr = (void *)data;

  166. 	table[index(0, TX, ep0_tx_bdt_bank)].desc = BDT_DESC(len, ep0_tx_data_toggle);

  167. 	ep0_tx_data_toggle ^= 1;

  168. 	ep0_tx_bdt_bank ^= 1;

  169. }

  170. 

  171. static uint8_t reply_buffer[8];

  172. 

  173. static void usb_setup(void)

  174. {

  175. 	const uint8_t *data = NULL;

  176. 	uint32_t datalen = 0;

  177. 	const usb_descriptor_list_t *list;

  178. 	uint32_t size;

  179. 	volatile uint8_t *reg;

  180. 	uint8_t epconf;

  181. 	const uint8_t *cfg;

  182. 	int i;

  183. 

  184. 	switch (setup.wRequestAndType) {

  185. 	  case 0x0500: // SET_ADDRESS

  186. 		break;

  187. 	  case 0x0900: // SET_CONFIGURATION

  188. 		//serial_print("configure\n");

  189. 		usb_configuration = setup.wValue;

  190. 		reg = &USB0_ENDPT1;

  191. 		cfg = usb_endpoint_config_table;

  192. 		// clear all BDT entries, free any allocated memory...

  193. 		for (i=4; i < (NUM_ENDPOINTS+1)*4; i++) {

  194. 			if (table[i].desc & BDT_OWN) {

  195. 				usb_free((usb_packet_t *)((uint8_t *)(table[i].addr) - 8));

  196. 			}

  197. 		}

  198. 		// free all queued packets

  199. 		for (i=0; i < NUM_ENDPOINTS; i++) {

  200. 			usb_packet_t *p, *n;

  201. 			p = rx_first[i];

  202. 			while (p) {

  203. 				n = p->next;

  204. 				usb_free(p);

  205. 				p = n;

  206. 			}

  207. 			rx_first[i] = NULL;

  208. 			rx_last[i] = NULL;

  209. 			p = tx_first[i];

  210. 			while (p) {

  211. 				n = p->next;

  212. 				usb_free(p);

  213. 				p = n;

  214. 			}

  215. 			tx_first[i] = NULL;

  216. 			tx_last[i] = NULL;

  217. 			usb_rx_byte_count_data[i] = 0;

  218. 			switch (tx_state[i]) {

  219. 			  case TX_STATE_EVEN_FREE:

  220. 			  case TX_STATE_NONE_FREE_EVEN_FIRST:

  221. 				tx_state[i] = TX_STATE_BOTH_FREE_EVEN_FIRST;

  222. 				break;

  223. 			  case TX_STATE_ODD_FREE:

  224. 			  case TX_STATE_NONE_FREE_ODD_FIRST:

  225. 				tx_state[i] = TX_STATE_BOTH_FREE_ODD_FIRST;

  226. 				break;

  227. 			  default:

  228. 				break;

  229. 			}

  230. 		}

  231. 		usb_rx_memory_needed = 0;

  232. 		for (i=1; i <= NUM_ENDPOINTS; i++) {

  233. 			epconf = *cfg++;

  234. 			*reg = epconf;

  235. 			reg += 4;

  236. #ifdef AUDIO_INTERFACE

  237. 			if (i == AUDIO_RX_ENDPOINT) {

  238. 				table[index(i, RX, EVEN)].addr = usb_audio_receive_buffer;

  239. 				table[index(i, RX, EVEN)].desc = (AUDIO_RX_SIZE<<16) | BDT_OWN;

  240. 				table[index(i, RX, ODD)].addr = usb_audio_receive_buffer;

  241. 				table[index(i, RX, ODD)].desc = (AUDIO_RX_SIZE<<16) | BDT_OWN;

  242. 			} else

  243. #endif

  244. 			if (epconf & USB_ENDPT_EPRXEN) {

  245. 				usb_packet_t *p;

  246. 				p = usb_malloc();

  247. 				if (p) {

  248. 					table[index(i, RX, EVEN)].addr = p->buf;

  249. 					table[index(i, RX, EVEN)].desc = BDT_DESC(64, 0);

  250. 				} else {

  251. 					table[index(i, RX, EVEN)].desc = 0;

  252. 					usb_rx_memory_needed++;

  253. 				}

  254. 				p = usb_malloc();

  255. 				if (p) {

  256. 					table[index(i, RX, ODD)].addr = p->buf;

  257. 					table[index(i, RX, ODD)].desc = BDT_DESC(64, 1);

  258. 				} else {

  259. 					table[index(i, RX, ODD)].desc = 0;

  260. 					usb_rx_memory_needed++;

  261. 				}

  262. 			}

  263. 			table[index(i, TX, EVEN)].desc = 0;

  264. 			table[index(i, TX, ODD)].desc = 0;

  265. #ifdef AUDIO_INTERFACE

  266. 			if (i == AUDIO_SYNC_ENDPOINT) {

  267. 				table[index(i, TX, EVEN)].addr = &usb_audio_sync_feedback;

  268. 				table[index(i, TX, EVEN)].desc = (3<<16) | BDT_OWN;

  269. 			}

  270. #endif

  271. 		}

  272. 		break;

  273. 	  case 0x0880: // GET_CONFIGURATION

  274. 		reply_buffer[0] = usb_configuration;

  275. 		datalen = 1;

  276. 		data = reply_buffer;

  277. 		break;

  278. 	  case 0x0080: // GET_STATUS (device)

  279. 		reply_buffer[0] = 0;

  280. 		reply_buffer[1] = 0;

  281. 		datalen = 2;

  282. 		data = reply_buffer;

  283. 		break;

  284. 	  case 0x0082: // GET_STATUS (endpoint)

  285. 		i = setup.wIndex & 0x7F;

  286. 		if (i > NUM_ENDPOINTS) {

  287. 			// TODO: do we need to handle IN vs OUT here?

  288. 			endpoint0_stall();

  289. 			return;

  290. 		}

  291. 		reply_buffer[0] = 0;

  292. 		reply_buffer[1] = 0;

  293. 		if (*(uint8_t *)(&USB0_ENDPT0 + i * 4) & 0x02) reply_buffer[0] = 1;

  294. 		data = reply_buffer;

  295. 		datalen = 2;

  296. 		break;

  297. 	  case 0x0102: // CLEAR_FEATURE (endpoint)

  298. 		i = setup.wIndex & 0x7F;

  299. 		if (i > NUM_ENDPOINTS || setup.wValue != 0) {

  300. 			// TODO: do we need to handle IN vs OUT here?

  301. 			endpoint0_stall();

  302. 			return;

  303. 		}

  304. 		(*(uint8_t *)(&USB0_ENDPT0 + i * 4)) &= ~0x02;

  305. 		// TODO: do we need to clear the data toggle here?

  306. 		break;

  307. 	  case 0x0302: // SET_FEATURE (endpoint)

  308. 		i = setup.wIndex & 0x7F;

  309. 		if (i > NUM_ENDPOINTS || setup.wValue != 0) {

  310. 			// TODO: do we need to handle IN vs OUT here?

  311. 			endpoint0_stall();

  312. 			return;

  313. 		}

  314. 		(*(uint8_t *)(&USB0_ENDPT0 + i * 4)) |= 0x02;

  315. 		// TODO: do we need to clear the data toggle here?

  316. 		break;

  317. 	  case 0x0680: // GET_DESCRIPTOR

  318. 	  case 0x0681:

  319. 		//serial_print("desc:");

  320. 		//serial_phex16(setup.wValue);

  321. 		//serial_print("\n");

  322. 		for (list = usb_descriptor_list; 1; list++) {

  323. 			if (list->addr == NULL) break;

  324. 			//if (setup.wValue == list->wValue &&

  325. 			//(setup.wIndex == list->wIndex) || ((setup.wValue >> 8) == 3)) {

  326. 			if (setup.wValue == list->wValue && setup.wIndex == list->wIndex) {

  327. 				data = list->addr;

  328. 				if ((setup.wValue >> 8) == 3) {

  329. 					// for string descriptors, use the descriptor's

  330. 					// length field, allowing runtime configured

  331. 					// length.

  332. 					datalen = *(list->addr);

  333. 				} else {

  334. 					datalen = list->length;

  335. 				}

  336. #if 0

  337. 				serial_print("Desc found, ");

  338. 				serial_phex32((uint32_t)data);

  339. 				serial_print(",");

  340. 				serial_phex16(datalen);

  341. 				serial_print(",");

  342. 				serial_phex(data[0]);

  343. 				serial_phex(data[1]);

  344. 				serial_phex(data[2]);

  345. 				serial_phex(data[3]);

  346. 				serial_phex(data[4]);

  347. 				serial_phex(data[5]);

  348. 				serial_print("\n");

  349. #endif

  350. 				goto send;

  351. 			}

  352. 		}

  353. 		//serial_print("desc: not found\n");

  354. 		endpoint0_stall();

  355. 		return;

  356. 	  case 0x2221: // CDC_SET_CONTROL_LINE_STATE

  357. 		switch (setup.wIndex) {

  358. #ifdef CDC_STATUS_INTERFACE

  359. 		  case CDC_STATUS_INTERFACE:

  360. 			usb_cdc_line_rtsdtr_millis = systick_millis_count;

  361. 			usb_cdc_line_rtsdtr = setup.wValue;

  362. 			break;

  363. #endif

  364. #ifdef CDC2_STATUS_INTERFACE

  365. 		  case CDC2_STATUS_INTERFACE:

  366. 			usb_cdc2_line_rtsdtr_millis = systick_millis_count;

  367. 			usb_cdc2_line_rtsdtr = setup.wValue;

  368. 			break;

  369. #endif

  370. 		}

  371. 		//serial_print("set control line state\n");

  372. 		break;

  373. #ifdef CDC_STATUS_INTERFACE

  374. 	  case 0x2321: // CDC_SEND_BREAK

  375. 		break;

  376. 	  case 0x2021: // CDC_SET_LINE_CODING

  377. 		//serial_print("set coding, waiting...\n");

  378. 		return;

  379. #endif

  380. 

  381. #if defined(MTP_INTERFACE)

  382. 	case 0x64A1: // Cancel Request (PTP spec, 5.2.1, page 8)

  383. 		// TODO: required by PTP spec

  384. 		endpoint0_stall();

  385. 		return;

  386. 	case 0x66A1: // Device Reset (PTP spec, 5.2.3, page 10)

  387. 		// TODO: required by PTP spec

  388. 		endpoint0_stall();

  389. 		return;

  390. 	case 0x67A1: // Get Device Statis (PTP spec, 5.2.4, page 10)

  391. 		// For now, always respond with status ok.

  392. 		reply_buffer[0] = 0x4;

  393. 		reply_buffer[1] = 0;

  394. 		reply_buffer[2] = 0x01;

  395. 		reply_buffer[3] = 0x20;

  396. 		data = reply_buffer;

  397. 		datalen = 4;

  398. 		break;

  399. #endif

  400. 

  401. // TODO: this does not work... why?

  402. #if defined(SEREMU_INTERFACE) || defined(KEYBOARD_INTERFACE)

  403. 	  case 0x0921: // HID SET_REPORT

  404. 		//serial_print(":)\n");

  405. 		return;

  406. 	  case 0x0A21: // HID SET_IDLE

  407. 		break;

  408. 	  // case 0xC940:

  409. #endif

  410. 

  411. #if defined(AUDIO_INTERFACE)

  412. 	  case 0x0B01: // SET_INTERFACE (alternate setting)

  413. 		if (setup.wIndex == AUDIO_INTERFACE+1) {

  414. 			usb_audio_transmit_setting = setup.wValue;

  415. 			if (usb_audio_transmit_setting > 0) {

  416. 				bdt_t *b = &table[index(AUDIO_TX_ENDPOINT, TX, EVEN)];

  417. 				uint8_t state = tx_state[AUDIO_TX_ENDPOINT-1];

  418. 				if (state) b++;

  419. 				if (!(b->desc & BDT_OWN)) {

  420. 					memset(usb_audio_transmit_buffer, 0, 176);

  421. 					b->addr = usb_audio_transmit_buffer;

  422. 					b->desc = (176 << 16) | BDT_OWN;

  423. 					tx_state[AUDIO_TX_ENDPOINT-1] = state ^ 1;

  424. 				}

  425. 			}

  426. 		} else if (setup.wIndex == AUDIO_INTERFACE+2) {

  427. 			usb_audio_receive_setting = setup.wValue;

  428. 		} else {

  429. 			endpoint0_stall();

  430. 			return;

  431. 		}

  432. 		break;

  433. 	  case 0x0A81: // GET_INTERFACE (alternate setting)

  434. 		datalen = 1;

  435. 		data = reply_buffer;

  436. 		if (setup.wIndex == AUDIO_INTERFACE+1) {

  437. 			reply_buffer[0] = usb_audio_transmit_setting;

  438. 		} else if (setup.wIndex == AUDIO_INTERFACE+2) {

  439. 			reply_buffer[0] = usb_audio_receive_setting;

  440. 		} else {

  441. 			endpoint0_stall();

  442. 			return;

  443. 		}

  444. 		break;

  445. 	  case 0x0121: // SET FEATURE

  446. 	  case 0x0221:

  447. 	  case 0x0321:

  448. 	  case 0x0421:

  449. 	  	// handle these on the next packet. See usb_audio_set_feature()

  450. 		return;

  451. 	  case 0x81A1: // GET FEATURE

  452. 	  case 0x82A1:

  453. 	  case 0x83A1:

  454. 	  case 0x84A1:

  455. 	  	if (usb_audio_get_feature(&setup, reply_buffer, &datalen)) {

  456. 	  		data = reply_buffer;

  457. 	  	}

  458. 	  	else {

  459. 	  		endpoint0_stall();

  460. 	  		return;

  461. 	  	}

  462. 		break;

  463. 

  464. 	  case 0x81A2: // GET_CUR (wValue=0, wIndex=interface, wLength=len)

  465. 		if (setup.wLength >= 3) {

  466. 			reply_buffer[0] = 44100 & 255;

  467. 			reply_buffer[1] = 44100 >> 8;

  468. 			reply_buffer[2] = 0;

  469. 			datalen = 3;

  470. 			data = reply_buffer;

  471. 		} else {

  472. 			endpoint0_stall();

  473. 			return;

  474. 		}

  475. 		break;

  476. #endif

  477. 

  478. #if defined(MULTITOUCH_INTERFACE)

  479. 	  case 0x01A1:

  480. 		if (setup.wValue == 0x0300 && setup.wIndex == MULTITOUCH_INTERFACE) {

  481. 			reply_buffer[0] = MULTITOUCH_FINGERS;

  482. 			data = reply_buffer;

  483. 			datalen = 1;

  484. 		} else if (setup.wValue == 0x0100 && setup.wIndex == MULTITOUCH_INTERFACE) {

  485. 			memset(reply_buffer, 0, 8);

  486. 			data = reply_buffer;

  487. 			datalen = 8;

  488. 		} else {

  489. 			endpoint0_stall();

  490. 			return;

  491. 		}

  492. 		break;

  493. #endif

  494. 	  default:

  495. 		endpoint0_stall();

  496. 		return;

  497. 	}

  498. 	send:

  499. 	//serial_print("setup send ");

  500. 	//serial_phex32(data);

  501. 	//serial_print(",");

  502. 	//serial_phex16(datalen);

  503. 	//serial_print("\n");

  504. 

  505. 	if (datalen > setup.wLength) datalen = setup.wLength;

  506. 	size = datalen;

  507. 	if (size > EP0_SIZE) size = EP0_SIZE;

  508. 	endpoint0_transmit(data, size);

  509. 	data += size;

  510. 	datalen -= size;

  511. 	if (datalen == 0 && size < EP0_SIZE) return;

  512. 

  513. 	size = datalen;

  514. 	if (size > EP0_SIZE) size = EP0_SIZE;

  515. 	endpoint0_transmit(data, size);

  516. 	data += size;

  517. 	datalen -= size;

  518. 	if (datalen == 0 && size < EP0_SIZE) return;

  519. 

  520. 	ep0_tx_ptr = data;

  521. 	ep0_tx_len = datalen;

  522. }

  523. 

  524. 

  525. 

  526. //A bulk endpoint's toggle sequence is initialized to DATA0 when the endpoint

  527. //experiences any configuration event (configuration events are explained in

  528. //Sections 9.1.1.5 and 9.4.5).

  529. 

  530. //Configuring a device or changing an alternate setting causes all of the status

  531. //and configuration values associated with endpoints in the affected interfaces

  532. //to be set to their default values. This includes setting the data toggle of

  533. //any endpoint using data toggles to the value DATA0.

  534. 

  535. //For endpoints using data toggle, regardless of whether an endpoint has the

  536. //Halt feature set, a ClearFeature(ENDPOINT_HALT) request always results in the

  537. //data toggle being reinitialized to DATA0.

  538. 

  539. 

  540. 

  541. // #define stat2bufferdescriptor(stat) (table + ((stat) >> 2))

  542. 

  543. static void usb_control(uint32_t stat)

  544. {

  545. 	bdt_t *b;

  546. 	uint32_t pid, size;

  547. 	uint8_t *buf;

  548. 	const uint8_t *data;

  549. 

  550. 	b = stat2bufferdescriptor(stat);

  551. 	pid = BDT_PID(b->desc);

  552. 	//count = b->desc >> 16;

  553. 	buf = b->addr;

  554. 	//serial_print("pid:");

  555. 	//serial_phex(pid);

  556. 	//serial_print(", count:");

  557. 	//serial_phex(count);

  558. 	//serial_print("\n");

  559. 

  560. 	switch (pid) {

  561. 	case 0x0D: // Setup received from host

  562. 		//serial_print("PID=Setup\n");

  563. 		//if (count != 8) ; // panic?

  564. 		// grab the 8 byte setup info

  565. 		setup.word1 = *(uint32_t *)(buf);

  566. 		setup.word2 = *(uint32_t *)(buf + 4);

  567. 

  568. 		// give the buffer back

  569. 		b->desc = BDT_DESC(EP0_SIZE, DATA1);

  570. 		//table[index(0, RX, EVEN)].desc = BDT_DESC(EP0_SIZE, 1);

  571. 		//table[index(0, RX, ODD)].desc = BDT_DESC(EP0_SIZE, 1);

  572. 

  573. 		// clear any leftover pending IN transactions

  574. 		ep0_tx_ptr = NULL;

  575. 		if (ep0_tx_data_toggle) {

  576. 		}

  577. 		//if (table[index(0, TX, EVEN)].desc & 0x80) {

  578. 			//serial_print("leftover tx even\n");

  579. 		//}

  580. 		//if (table[index(0, TX, ODD)].desc & 0x80) {

  581. 			//serial_print("leftover tx odd\n");

  582. 		//}

  583. 		table[index(0, TX, EVEN)].desc = 0;

  584. 		table[index(0, TX, ODD)].desc = 0;

  585. 		// first IN after Setup is always DATA1

  586. 		ep0_tx_data_toggle = 1;

  587. 

  588. #if 0

  589. 		serial_print("bmRequestType:");

  590. 		serial_phex(setup.bmRequestType);

  591. 		serial_print(", bRequest:");

  592. 		serial_phex(setup.bRequest);

  593. 		serial_print(", wValue:");

  594. 		serial_phex16(setup.wValue);

  595. 		serial_print(", wIndex:");

  596. 		serial_phex16(setup.wIndex);

  597. 		serial_print(", len:");

  598. 		serial_phex16(setup.wLength);

  599. 		serial_print("\n");

  600. #endif

  601. 		// actually "do" the setup request

  602. 		usb_setup();

  603. 		// unfreeze the USB, now that we're ready

  604. 		USB0_CTL = USB_CTL_USBENSOFEN; // clear TXSUSPENDTOKENBUSY bit

  605. 		break;

  606. 	case 0x01:  // OUT transaction received from host

  607. 	case 0x02:

  608. 		//serial_print("PID=OUT\n");

  609. 		if (setup.wRequestAndType == 0x2021 /*CDC_SET_LINE_CODING*/) {

  610. 			int i;

  611. 			uint8_t *dst = NULL;

  612. 			switch (setup.wIndex) {

  613. #ifdef CDC_STATUS_INTERFACE

  614. 			  case CDC_STATUS_INTERFACE:

  615. 				dst = (uint8_t *)usb_cdc_line_coding;

  616. 				break;

  617. #endif

  618. #ifdef CDC2_STATUS_INTERFACE

  619. 			  case CDC2_STATUS_INTERFACE:

  620. 				dst = (uint8_t *)usb_cdc2_line_coding;

  621. 				break;

  622. #endif

  623. 			}

  624. 			if (!dst)

  625. 				break;

  626. 

  627. 			//serial_print("set line coding ");

  628. 			for (i=0; i<7; i++) {

  629. 				//serial_phex(*buf);

  630. 				*dst++ = *buf++;

  631. 			}

  632. 			//serial_phex32(usb_cdc_line_coding[0]);

  633. 			//serial_print("\n");

  634. #ifdef CDC_STATUS_INTERFACE

  635. 			if (setup.wIndex == CDC_STATUS_INTERFACE &&

  636. 			    usb_cdc_line_coding[0] == 134)

  637. 				usb_reboot_timer = 15;

  638. #endif

  639. 			endpoint0_transmit(NULL, 0);

  640. 		}

  641. #ifdef KEYBOARD_INTERFACE

  642. 		if (setup.word1 == 0x02000921 && setup.word2 == ((1<<16)|KEYBOARD_INTERFACE)) {

  643. 			keyboard_leds = buf[0];

  644. 			endpoint0_transmit(NULL, 0);

  645. 		}

  646. #endif

  647. #ifdef SEREMU_INTERFACE

  648. 		if (setup.word1 == 0x03000921 && setup.word2 == ((4<<16)|SEREMU_INTERFACE)

  649. 		  && buf[0] == 0xA9 && buf[1] == 0x45 && buf[2] == 0xC2 && buf[3] == 0x6B) {

  650. 			usb_reboot_timer = 5;

  651. 			endpoint0_transmit(NULL, 0);

  652. 		}

  653. #endif

  654. #ifdef AUDIO_INTERFACE

  655. 		if (usb_audio_set_feature(&setup, buf)) {

  656. 			endpoint0_transmit(NULL, 0);

  657. 		}

  658. #endif

  659. 		// give the buffer back

  660. 		b->desc = BDT_DESC(EP0_SIZE, DATA1);

  661. 		break;

  662. 

  663. 	case 0x09: // IN transaction completed to host

  664. 		//serial_print("PID=IN:");

  665. 		//serial_phex(stat);

  666. 		//serial_print("\n");

  667. 

  668. 		// send remaining data, if any...

  669. 		data = ep0_tx_ptr;

  670. 		if (data) {

  671. 			size = ep0_tx_len;

  672. 			if (size > EP0_SIZE) size = EP0_SIZE;

  673. 			endpoint0_transmit(data, size);

  674. 			data += size;

  675. 			ep0_tx_len -= size;

  676. 			ep0_tx_ptr = (ep0_tx_len > 0 || size == EP0_SIZE) ? data : NULL;

  677. 		}

  678. 

  679. 		if (setup.bRequest == 5 && setup.bmRequestType == 0) {

  680. 			setup.bRequest = 0;

  681. 			//serial_print("set address: ");

  682. 			//serial_phex16(setup.wValue);

  683. 			//serial_print("\n");

  684. 			USB0_ADDR = setup.wValue;

  685. 		}

  686. 

  687. 		break;

  688. 	//default:

  689. 		//serial_print("PID=unknown:");

  690. 		//serial_phex(pid);

  691. 		//serial_print("\n");

  692. 	}

  693. 	USB0_CTL = USB_CTL_USBENSOFEN; // clear TXSUSPENDTOKENBUSY bit

  694. }

  695. 

  696. 

  697. 

  698. 

  699. 

  700. 

  701. usb_packet_t *usb_rx(uint32_t endpoint)

  702. {

  703. 	usb_packet_t *ret;

  704. 	endpoint--;

  705. 	if (endpoint >= NUM_ENDPOINTS) return NULL;

  706. 	__disable_irq();

  707. 	ret = rx_first[endpoint];

  708. 	if (ret) {

  709. 		rx_first[endpoint] = ret->next;

  710. 		usb_rx_byte_count_data[endpoint] -= ret->len;

  711. 	}

  712. 	__enable_irq();

  713. 	//serial_print("rx, epidx=");

  714. 	//serial_phex(endpoint);

  715. 	//serial_print(", packet=");

  716. 	//serial_phex32(ret);

  717. 	//serial_print("\n");

  718. 	return ret;

  719. }

  720. 

  721. static uint32_t usb_queue_byte_count(const usb_packet_t *p)

  722. {

  723. 	uint32_t count=0;

  724. 

  725. 	__disable_irq();

  726. 	for ( ; p; p = p->next) {

  727. 		count += p->len;

  728. 	}

  729. 	__enable_irq();

  730. 	return count;

  731. }

  732. 

  733. // TODO: make this an inline function...

  734. /*

  735. uint32_t usb_rx_byte_count(uint32_t endpoint)

  736. {

  737. 	endpoint--;

  738. 	if (endpoint >= NUM_ENDPOINTS) return 0;

  739. 	return usb_rx_byte_count_data[endpoint];

  740. 	//return usb_queue_byte_count(rx_first[endpoint]);

  741. }

  742. */

  743. 

  744. uint32_t usb_tx_byte_count(uint32_t endpoint)

  745. {

  746. 	endpoint--;

  747. 	if (endpoint >= NUM_ENDPOINTS) return 0;

  748. 	return usb_queue_byte_count(tx_first[endpoint]);

  749. }

  750. 

  751. // Discussion about using this function and USB transmit latency

  752. // https://forum.pjrc.com/threads/58663?p=223513&viewfull=1#post223513

  753. //

  754. uint32_t usb_tx_packet_count(uint32_t endpoint)

  755. {

  756. 	const usb_packet_t *p;

  757. 	uint32_t count=0;

  758. 

  759. 	endpoint--;

  760. 	if (endpoint >= NUM_ENDPOINTS) return 0;

  761. 	__disable_irq();

  762. 	for (p = tx_first[endpoint]; p; p = p->next) count++;

  763. 	__enable_irq();

  764. 	return count;

  765. }

  766. 

  767. 

  768. // Called from usb_free, but only when usb_rx_memory_needed > 0, indicating

  769. // receive endpoints are starving for memory.  The intention is to give

  770. // endpoints needing receive memory priority over the user's code, which is

  771. // likely calling usb_malloc to obtain memory for transmitting.  When the

  772. // user is creating data very quickly, their consumption could starve reception

  773. // without this prioritization.  The packet buffer (input) is assigned to the

  774. // first endpoint needing memory.

  775. //

  776. void usb_rx_memory(usb_packet_t *packet)

  777. {

  778. 	unsigned int i;

  779. 	const uint8_t *cfg;

  780. 

  781. 	cfg = usb_endpoint_config_table;

  782. 	//serial_print("rx_mem:");

  783. 	__disable_irq();

  784. 	for (i=1; i <= NUM_ENDPOINTS; i++) {

  785. #ifdef AUDIO_INTERFACE

  786. 		if (i == AUDIO_RX_ENDPOINT) continue;

  787. #endif

  788. 		if (*cfg++ & USB_ENDPT_EPRXEN) {

  789. 			if (table[index(i, RX, EVEN)].desc == 0) {

  790. 				table[index(i, RX, EVEN)].addr = packet->buf;

  791. 				table[index(i, RX, EVEN)].desc = BDT_DESC(64, 0);

  792. 				usb_rx_memory_needed--;

  793. 				__enable_irq();

  794. 				//serial_phex(i);

  795. 				//serial_print(",even\n");

  796. 				return;

  797. 			}

  798. 			if (table[index(i, RX, ODD)].desc == 0) {

  799. 				table[index(i, RX, ODD)].addr = packet->buf;

  800. 				table[index(i, RX, ODD)].desc = BDT_DESC(64, 1);

  801. 				usb_rx_memory_needed--;

  802. 				__enable_irq();

  803. 				//serial_phex(i);

  804. 				//serial_print(",odd\n");

  805. 				return;

  806. 			}

  807. 		}

  808. 	}

  809. 	__enable_irq();

  810. 	// we should never reach this point.  If we get here, it means

  811. 	// usb_rx_memory_needed was set greater than zero, but no memory

  812. 	// was actually needed.

  813. 	usb_rx_memory_needed = 0;

  814. 	usb_free(packet);

  815. 	return;

  816. }

  817. 

  818. //#define index(endpoint, tx, odd) (((endpoint) << 2) | ((tx) << 1) | (odd))

  819. //#define stat2bufferdescriptor(stat) (table + ((stat) >> 2))

  820. 

  821. void usb_tx(uint32_t endpoint, usb_packet_t *packet)

  822. {

  823. 	bdt_t *b = &table[index(endpoint, TX, EVEN)];

  824. 	uint8_t next;

  825. 

  826. 	endpoint--;

  827. 	if (endpoint >= NUM_ENDPOINTS) return;

  828. 	__disable_irq();

  829. 	//serial_print("txstate=");

  830. 	//serial_phex(tx_state[endpoint]);

  831. 	//serial_print("\n");

  832. 	switch (tx_state[endpoint]) {

  833. 	  case TX_STATE_BOTH_FREE_EVEN_FIRST:

  834. 		next = TX_STATE_ODD_FREE;

  835. 		break;

  836. 	  case TX_STATE_BOTH_FREE_ODD_FIRST:

  837. 		b++;

  838. 		next = TX_STATE_EVEN_FREE;

  839. 		break;

  840. 	  case TX_STATE_EVEN_FREE:

  841. 		next = TX_STATE_NONE_FREE_ODD_FIRST;

  842. 		break;

  843. 	  case TX_STATE_ODD_FREE:

  844. 		b++;

  845. 		next = TX_STATE_NONE_FREE_EVEN_FIRST;

  846. 		break;

  847. 	  default:

  848. 		if (tx_first[endpoint] == NULL) {

  849. 			tx_first[endpoint] = packet;

  850. 		} else {

  851. 			tx_last[endpoint]->next = packet;

  852. 		}

  853. 		tx_last[endpoint] = packet;

  854. 		__enable_irq();

  855. 		return;

  856. 	}

  857. 	tx_state[endpoint] = next;

  858. 	b->addr = packet->buf;

  859. 	b->desc = BDT_DESC(packet->len, ((uint32_t)b & 8) ? DATA1 : DATA0);

  860. 	__enable_irq();

  861. }

  862. 

  863. void usb_tx_isochronous(uint32_t endpoint, void *data, uint32_t len)

  864. {

  865. 	bdt_t *b = &table[index(endpoint, TX, EVEN)];

  866. 	uint8_t next, state;

  867. 

  868. 	endpoint--;

  869. 	if (endpoint >= NUM_ENDPOINTS) return;

  870. 	__disable_irq();

  871. 	state = tx_state[endpoint];

  872. 	if (state == 0) {

  873. 		next = 1;

  874. 	} else {

  875. 		b++;

  876. 		next = 0;

  877. 	}

  878. 	tx_state[endpoint] = next;

  879. 	b->addr = data;

  880. 	b->desc = (len << 16) | BDT_OWN;

  881. 	__enable_irq();

  882. }

  883. 

  884. 

  885. 

  886. 

  887. void _reboot_Teensyduino_(void)

  888. {

  889. 	// TODO: initialize R0 with a code....

  890. 	__asm__ volatile("bkpt");

  891. 	__builtin_unreachable();

  892. }

  893. 

  894. 

  895. 

  896. void usb_isr(void)

  897. {

  898. 	uint8_t status, stat, t;

  899. 

  900. 	//serial_print("isr");

  901. 	//status = USB0_ISTAT;

  902. 	//serial_phex(status);

  903. 	//serial_print("\n");

  904. 	restart:

  905. 	status = USB0_ISTAT;

  906. 

  907. 	if ((status & USB_ISTAT_SOFTOK /* 04 */ )) {

  908. 		if (usb_configuration) {

  909. 			t = usb_reboot_timer;

  910. 			if (t) {

  911. 				usb_reboot_timer = --t;

  912. 				if (!t) _reboot_Teensyduino_();

  913. 			}

  914. #ifdef CDC_DATA_INTERFACE

  915. 			t = usb_cdc_transmit_flush_timer;

  916. 			if (t) {

  917. 				usb_cdc_transmit_flush_timer = --t;

  918. 				if (t == 0) usb_serial_flush_callback();

  919. 			}

  920. #endif

  921. #ifdef CDC2_DATA_INTERFACE

  922. 			t = usb_cdc2_transmit_flush_timer;

  923. 			if (t) {

  924. 				usb_cdc2_transmit_flush_timer = --t;

  925. 				if (t == 0) usb_serial2_flush_callback();

  926. 			}

  927. #endif

  928. #ifdef SEREMU_INTERFACE

  929. 			t = usb_seremu_transmit_flush_timer;

  930. 			if (t) {

  931. 				usb_seremu_transmit_flush_timer = --t;

  932. 				if (t == 0) usb_seremu_flush_callback();

  933. 			}

  934. #endif

  935. #ifdef MIDI_INTERFACE

  936.                         usb_midi_flush_output();

  937. #endif

  938. #ifdef FLIGHTSIM_INTERFACE

  939. 			usb_flightsim_flush_callback();

  940. #endif

  941. #ifdef MULTITOUCH_INTERFACE

  942. 			usb_touchscreen_update_callback();

  943. #endif

  944. 		}

  945. 		USB0_ISTAT = USB_ISTAT_SOFTOK;

  946. 	}

  947. 

  948. 	if ((status & USB_ISTAT_TOKDNE /* 08 */ )) {

  949. 		uint8_t endpoint;

  950. 		stat = USB0_STAT;

  951. 		//serial_print("token: ep=");

  952. 		//serial_phex(stat >> 4);

  953. 		//serial_print(stat & 0x08 ? ",tx" : ",rx");

  954. 		//serial_print(stat & 0x04 ? ",odd\n" : ",even\n");

  955. 		endpoint = stat >> 4;

  956. 		if (endpoint == 0) {

  957. 			usb_control(stat);

  958. 		} else {

  959. 			bdt_t *b = stat2bufferdescriptor(stat);

  960. 			usb_packet_t *packet = (usb_packet_t *)((uint8_t *)(b->addr) - 8);

  961. #if 0

  962. 			serial_print("ep:");

  963. 			serial_phex(endpoint);

  964. 			serial_print(", pid:");

  965. 			serial_phex(BDT_PID(b->desc));

  966. 			serial_print(((uint32_t)b & 8) ? ", odd" : ", even");

  967. 			serial_print(", count:");

  968. 			serial_phex(b->desc >> 16);

  969. 			serial_print("\n");

  970. #endif

  971. 			endpoint--;	// endpoint is index to zero-based arrays

  972. 

  973. #ifdef AUDIO_INTERFACE

  974. 			if ((endpoint == AUDIO_TX_ENDPOINT-1) && (stat & 0x08)) {

  975. 				unsigned int len;

  976. 				len = usb_audio_transmit_callback();

  977. 				if (len > 0) {

  978. 					b = (bdt_t *)((uint32_t)b ^ 8);

  979. 					b->addr = usb_audio_transmit_buffer;

  980. 					b->desc = (len << 16) | BDT_OWN;

  981. 					tx_state[endpoint] ^= 1;

  982. 				}

  983. 			} else if ((endpoint == AUDIO_RX_ENDPOINT-1) && !(stat & 0x08)) {

  984. 				usb_audio_receive_callback(b->desc >> 16);

  985. 				b->addr = usb_audio_receive_buffer;

  986. 				b->desc = (AUDIO_RX_SIZE << 16) | BDT_OWN;

  987. 			} else if ((endpoint == AUDIO_SYNC_ENDPOINT-1) && (stat & 0x08)) {

  988. 				b = (bdt_t *)((uint32_t)b ^ 8);

  989. 				b->addr = &usb_audio_sync_feedback;

  990. 				b->desc = (3 << 16) | BDT_OWN;

  991. 				tx_state[endpoint] ^= 1;

  992. 			} else

  993. #endif

  994. 			if (stat & 0x08) { // transmit

  995. 				usb_free(packet);

  996. 				packet = tx_first[endpoint];

  997. 				if (packet) {

  998. 					//serial_print("tx packet\n");

  999. 					tx_first[endpoint] = packet->next;

  1000. 					b->addr = packet->buf;

  1001. 					switch (tx_state[endpoint]) {

  1002. 					  case TX_STATE_BOTH_FREE_EVEN_FIRST:

  1003. 						tx_state[endpoint] = TX_STATE_ODD_FREE;

  1004. 						break;

  1005. 					  case TX_STATE_BOTH_FREE_ODD_FIRST:

  1006. 						tx_state[endpoint] = TX_STATE_EVEN_FREE;

  1007. 						break;

  1008. 					  case TX_STATE_EVEN_FREE:

  1009. 						tx_state[endpoint] = TX_STATE_NONE_FREE_ODD_FIRST;

  1010. 						break;

  1011. 					  case TX_STATE_ODD_FREE:

  1012. 						tx_state[endpoint] = TX_STATE_NONE_FREE_EVEN_FIRST;

  1013. 						break;

  1014. 					  default:

  1015. 						break;

  1016. 					}

  1017. 					b->desc = BDT_DESC(packet->len,

  1018. 						((uint32_t)b & 8) ? DATA1 : DATA0);

  1019. 				} else {

  1020. 					//serial_print("tx no packet\n");

  1021. 					switch (tx_state[endpoint]) {

  1022. 					  case TX_STATE_BOTH_FREE_EVEN_FIRST:

  1023. 					  case TX_STATE_BOTH_FREE_ODD_FIRST:

  1024. 						break;

  1025. 					  case TX_STATE_EVEN_FREE:

  1026. 						tx_state[endpoint] = TX_STATE_BOTH_FREE_EVEN_FIRST;

  1027. 						break;

  1028. 					  case TX_STATE_ODD_FREE:

  1029. 						tx_state[endpoint] = TX_STATE_BOTH_FREE_ODD_FIRST;

  1030. 						break;

  1031. 					  default:

  1032. 						tx_state[endpoint] = ((uint32_t)b & 8) ?

  1033. 						  TX_STATE_ODD_FREE : TX_STATE_EVEN_FREE;

  1034. 						break;

  1035. 					}

  1036. 				}

  1037. 			} else { // receive

  1038. 				packet->len = b->desc >> 16;

  1039. 				if (packet->len > 0) {

  1040. 					packet->index = 0;

  1041. 					packet->next = NULL;

  1042. 					if (rx_first[endpoint] == NULL) {

  1043. 						//serial_print("rx 1st, epidx=");

  1044. 						//serial_phex(endpoint);

  1045. 						//serial_print(", packet=");

  1046. 						//serial_phex32((uint32_t)packet);

  1047. 						//serial_print("\n");

  1048. 						rx_first[endpoint] = packet;

  1049. 					} else {

  1050. 						//serial_print("rx Nth, epidx=");

  1051. 						//serial_phex(endpoint);

  1052. 						//serial_print(", packet=");

  1053. 						//serial_phex32((uint32_t)packet);

  1054. 						//serial_print("\n");

  1055. 						rx_last[endpoint]->next = packet;

  1056. 					}

  1057. 					rx_last[endpoint] = packet;

  1058. 					usb_rx_byte_count_data[endpoint] += packet->len;

  1059. 					// TODO: implement a per-endpoint maximum # of allocated

  1060. 					// packets, so a flood of incoming data on 1 endpoint

  1061. 					// doesn't starve the others if the user isn't reading

  1062. 					// it regularly

  1063. 					packet = usb_malloc();

  1064. 					if (packet) {

  1065. 						b->addr = packet->buf;

  1066. 						b->desc = BDT_DESC(64,

  1067. 							((uint32_t)b & 8) ? DATA1 : DATA0);

  1068. 					} else {

  1069. 						//serial_print("starving ");

  1070. 						//serial_phex(endpoint + 1);

  1071. 						b->desc = 0;

  1072. 						usb_rx_memory_needed++;

  1073. 					}

  1074. 				} else {

  1075. 					b->desc = BDT_DESC(64, ((uint32_t)b & 8) ? DATA1 : DATA0);

  1076. 				}

  1077. 			}

  1078. 

  1079. 		}

  1080. 		USB0_ISTAT = USB_ISTAT_TOKDNE;

  1081. 		goto restart;

  1082. 	}

  1083. 

  1084. 

  1085. 

  1086. 	if (status & USB_ISTAT_USBRST /* 01 */ ) {

  1087. 		//serial_print("reset\n");

  1088. 

  1089. 		// initialize BDT toggle bits

  1090. 		USB0_CTL = USB_CTL_ODDRST;

  1091. 		ep0_tx_bdt_bank = 0;

  1092. 

  1093. 		// set up buffers to receive Setup and OUT packets

  1094. 		table[index(0, RX, EVEN)].desc = BDT_DESC(EP0_SIZE, 0);

  1095. 		table[index(0, RX, EVEN)].addr = ep0_rx0_buf;

  1096. 		table[index(0, RX, ODD)].desc = BDT_DESC(EP0_SIZE, 0);

  1097. 		table[index(0, RX, ODD)].addr = ep0_rx1_buf;

  1098. 		table[index(0, TX, EVEN)].desc = 0;

  1099. 		table[index(0, TX, ODD)].desc = 0;

  1100. 

  1101. 		// activate endpoint 0

  1102. 		USB0_ENDPT0 = USB_ENDPT_EPRXEN | USB_ENDPT_EPTXEN | USB_ENDPT_EPHSHK;

  1103. 

  1104. 		// clear all ending interrupts

  1105. 		USB0_ERRSTAT = 0xFF;

  1106. 		USB0_ISTAT = 0xFF;

  1107. 

  1108. 		// set the address to zero during enumeration

  1109. 		USB0_ADDR = 0;

  1110. 

  1111. 		// enable other interrupts

  1112. 		USB0_ERREN = 0xFF;

  1113. 		USB0_INTEN = USB_INTEN_TOKDNEEN |

  1114. 			USB_INTEN_SOFTOKEN |

  1115. 			USB_INTEN_STALLEN |

  1116. 			USB_INTEN_ERROREN |

  1117. 			USB_INTEN_USBRSTEN |

  1118. 			USB_INTEN_SLEEPEN;

  1119. 

  1120. 		// is this necessary?

  1121. 		USB0_CTL = USB_CTL_USBENSOFEN;

  1122. 		return;

  1123. 	}

  1124. 

  1125. 

  1126. 	if ((status & USB_ISTAT_STALL /* 80 */ )) {

  1127. 		//serial_print("stall:\n");

  1128. 		USB0_ENDPT0 = USB_ENDPT_EPRXEN | USB_ENDPT_EPTXEN | USB_ENDPT_EPHSHK;

  1129. 		USB0_ISTAT = USB_ISTAT_STALL;

  1130. 	}

  1131. 	if ((status & USB_ISTAT_ERROR /* 02 */ )) {

  1132. 		uint8_t err = USB0_ERRSTAT;

  1133. 		USB0_ERRSTAT = err;

  1134. 		//serial_print("err:");

  1135. 		//serial_phex(err);

  1136. 		//serial_print("\n");

  1137. 		USB0_ISTAT = USB_ISTAT_ERROR;

  1138. 	}

  1139. 

  1140. 	if ((status & USB_ISTAT_SLEEP /* 10 */ )) {

  1141. 		//serial_print("sleep\n");

  1142. 		USB0_ISTAT = USB_ISTAT_SLEEP;

  1143. 	}

  1144. 

  1145. }

  1146. 

  1147. 

  1148. 

  1149. void usb_init(void)

  1150. {

  1151. 	int i;

  1152. 

  1153. 	//serial_begin(BAUD2DIV(115200));

  1154. 	//serial_print("usb_init\n");

  1155. 

  1156. 	usb_init_serialnumber();

  1157. 

  1158. 	for (i=0; i <= NUM_ENDPOINTS*4; i++) {

  1159. 		table[i].desc = 0;

  1160. 		table[i].addr = 0;

  1161. 	}

  1162. 

  1163. 	// this basically follows the flowchart in the Kinetis

  1164. 	// Quick Reference User Guide, Rev. 1, 03/2012, page 141

  1165. 

  1166. 	// assume 48 MHz clock already running

  1167. 	// SIM - enable clock

  1168. 	SIM_SCGC4 |= SIM_SCGC4_USBOTG;

  1169. #ifdef HAS_KINETIS_MPU

  1170. 	MPU_RGDAAC0 |= 0x03000000;

  1171. #endif

  1172. #if F_CPU == 180000000 || F_CPU == 216000000 || F_CPU == 256000000

  1173. 	// if using IRC48M, turn on the USB clock recovery hardware

  1174. 	USB0_CLK_RECOVER_IRC_EN = USB_CLK_RECOVER_IRC_EN_IRC_EN | USB_CLK_RECOVER_IRC_EN_REG_EN;

  1175. 	USB0_CLK_RECOVER_CTRL = USB_CLK_RECOVER_CTRL_CLOCK_RECOVER_EN |

  1176. 		USB_CLK_RECOVER_CTRL_RESTART_IFRTRIM_EN;

  1177. #endif

  1178. 	// reset USB module

  1179. 	//USB0_USBTRC0 = USB_USBTRC_USBRESET;

  1180. 	//while ((USB0_USBTRC0 & USB_USBTRC_USBRESET) != 0) ; // wait for reset to end

  1181. 

  1182. 	// set desc table base addr

  1183. 	USB0_BDTPAGE1 = ((uint32_t)table) >> 8;

  1184. 	USB0_BDTPAGE2 = ((uint32_t)table) >> 16;

  1185. 	USB0_BDTPAGE3 = ((uint32_t)table) >> 24;

  1186. 

  1187. 	// clear all ISR flags

  1188. 	USB0_ISTAT = 0xFF;

  1189. 	USB0_ERRSTAT = 0xFF;

  1190. 	USB0_OTGISTAT = 0xFF;

  1191. 

  1192. 	//USB0_USBTRC0 |= 0x40; // undocumented bit

  1193. 

  1194. 	// enable USB

  1195. 	USB0_CTL = USB_CTL_USBENSOFEN;

  1196. 	USB0_USBCTRL = 0;

  1197. 

  1198. 	// enable reset interrupt

  1199. 	USB0_INTEN = USB_INTEN_USBRSTEN;

  1200. 

  1201. 	// enable interrupt in NVIC...

  1202. 	NVIC_SET_PRIORITY(IRQ_USBOTG, 112);

  1203. 	NVIC_ENABLE_IRQ(IRQ_USBOTG);

  1204. 

  1205. 	// enable d+ pullup

  1206. 	USB0_CONTROL = USB_CONTROL_DPPULLUPNONOTG;

  1207. }

  1208. 

  1209. 

  1210. #else // F_CPU < 20 MHz && defined(NUM_ENDPOINTS)

  1211. 

  1212. void usb_init(void)

  1213. {

  1214. }

  1215. 

  1216. #endif // F_CPU >= 20 MHz && defined(NUM_ENDPOINTS)