visus
/
framework-arduinoteensy-cxx20
Tarkkaile 1
Äänestä 0
Fork 0
Koodi Ongelmat 0 Pull-pyynnöt 0 Julkaisut 0 Wiki Activity
PlatformIO package of the Teensy core framework compatible with GCC 10 & 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.
5 Commitit
1 Haara
Haara: main
Branchit Tagit
${ item.name }
Create branch ${ searchTerm }
from 'main'
${ noResults }
framework-arduinoteensy-cxx20/cores/teensy3/usb_dev.c

1231 lines
32KB
Raaka Pysyvä linkki Blame Historia 

  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. #ifdef CDC3_STATUS_INTERFACE

  371. 		  case CDC3_STATUS_INTERFACE:

  372. 			usb_cdc3_line_rtsdtr_millis = systick_millis_count;

  373. 			usb_cdc3_line_rtsdtr = setup.wValue;

  374. 			break;

  375. #endif

  376. 		}

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

  378. 		break;

  379. #ifdef CDC_STATUS_INTERFACE

  380. 	  case 0x2321: // CDC_SEND_BREAK

  381. 		break;

  382. 	  case 0x2021: // CDC_SET_LINE_CODING

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

  384. 		return;

  385. #endif

  386. 

  387. #if defined(MTP_INTERFACE)

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

  389. 		// TODO: required by PTP spec

  390. 		endpoint0_stall();

  391. 		return;

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

  393. 		// TODO: required by PTP spec

  394. 		endpoint0_stall();

  395. 		return;

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

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

  398. 		reply_buffer[0] = 0x4;

  399. 		reply_buffer[1] = 0;

  400. 		reply_buffer[2] = 0x01;

  401. 		reply_buffer[3] = 0x20;

  402. 		data = reply_buffer;

  403. 		datalen = 4;

  404. 		break;

  405. #endif

  406. 

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

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

  409. 	  case 0x0921: // HID SET_REPORT

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

  411. 		return;

  412. 	  case 0x0A21: // HID SET_IDLE

  413. 		break;

  414. 	  // case 0xC940:

  415. #endif

  416. 

  417. #if defined(AUDIO_INTERFACE)

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

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

  420. 			usb_audio_transmit_setting = setup.wValue;

  421. 			if (usb_audio_transmit_setting > 0) {

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

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

  424. 				if (state) b++;

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

  426. 					memset(usb_audio_transmit_buffer, 0, 176);

  427. 					b->addr = usb_audio_transmit_buffer;

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

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

  430. 				}

  431. 			}

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

  433. 			usb_audio_receive_setting = setup.wValue;

  434. 		} else {

  435. 			endpoint0_stall();

  436. 			return;

  437. 		}

  438. 		break;

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

  440. 		datalen = 1;

  441. 		data = reply_buffer;

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

  443. 			reply_buffer[0] = usb_audio_transmit_setting;

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

  445. 			reply_buffer[0] = usb_audio_receive_setting;

  446. 		} else {

  447. 			endpoint0_stall();

  448. 			return;

  449. 		}

  450. 		break;

  451. 	  case 0x0121: // SET FEATURE

  452. 	  case 0x0221:

  453. 	  case 0x0321:

  454. 	  case 0x0421:

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

  456. 		return;

  457. 	  case 0x81A1: // GET FEATURE

  458. 	  case 0x82A1:

  459. 	  case 0x83A1:

  460. 	  case 0x84A1:

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

  462. 	  		data = reply_buffer;

  463. 	  	}

  464. 	  	else {

  465. 	  		endpoint0_stall();

  466. 	  		return;

  467. 	  	}

  468. 		break;

  469. 

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

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

  472. 			reply_buffer[0] = 44100 & 255;

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

  474. 			reply_buffer[2] = 0;

  475. 			datalen = 3;

  476. 			data = reply_buffer;

  477. 		} else {

  478. 			endpoint0_stall();

  479. 			return;

  480. 		}

  481. 		break;

  482. #endif

  483. 

  484. #if defined(MULTITOUCH_INTERFACE)

  485. 	  case 0x01A1:

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

  487. 			reply_buffer[0] = MULTITOUCH_FINGERS;

  488. 			data = reply_buffer;

  489. 			datalen = 1;

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

  491. 			memset(reply_buffer, 0, 8);

  492. 			data = reply_buffer;

  493. 			datalen = 8;

  494. 		} else {

  495. 			endpoint0_stall();

  496. 			return;

  497. 		}

  498. 		break;

  499. #endif

  500. 	  default:

  501. 		endpoint0_stall();

  502. 		return;

  503. 	}

  504. 	send:

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

  506. 	//serial_phex32(data);

  507. 	//serial_print(",");

  508. 	//serial_phex16(datalen);

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

  510. 

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

  512. 	size = datalen;

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

  514. 	endpoint0_transmit(data, size);

  515. 	data += size;

  516. 	datalen -= size;

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

  518. 

  519. 	size = datalen;

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

  521. 	endpoint0_transmit(data, size);

  522. 	data += size;

  523. 	datalen -= size;

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

  525. 

  526. 	ep0_tx_ptr = data;

  527. 	ep0_tx_len = datalen;

  528. }

  529. 

  530. 

  531. 

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

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

  534. //Sections 9.1.1.5 and 9.4.5).

  535. 

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

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

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

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

  540. 

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

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

  543. //data toggle being reinitialized to DATA0.

  544. 

  545. 

  546. 

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

  548. 

  549. static void usb_control(uint32_t stat)

  550. {

  551. 	bdt_t *b;

  552. 	uint32_t pid, size;

  553. 	uint8_t *buf;

  554. 	const uint8_t *data;

  555. 

  556. 	b = stat2bufferdescriptor(stat);

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

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

  559. 	buf = b->addr;

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

  561. 	//serial_phex(pid);

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

  563. 	//serial_phex(count);

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

  565. 

  566. 	switch (pid) {

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

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

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

  570. 		// grab the 8 byte setup info

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

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

  573. 

  574. 		// give the buffer back

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

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

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

  578. 

  579. 		// clear any leftover pending IN transactions

  580. 		ep0_tx_ptr = NULL;

  581. 		if (ep0_tx_data_toggle) {

  582. 		}

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

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

  585. 		//}

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

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

  588. 		//}

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

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

  591. 		// first IN after Setup is always DATA1

  592. 		ep0_tx_data_toggle = 1;

  593. 

  594. #if 0

  595. 		serial_print("bmRequestType:");

  596. 		serial_phex(setup.bmRequestType);

  597. 		serial_print(", bRequest:");

  598. 		serial_phex(setup.bRequest);

  599. 		serial_print(", wValue:");

  600. 		serial_phex16(setup.wValue);

  601. 		serial_print(", wIndex:");

  602. 		serial_phex16(setup.wIndex);

  603. 		serial_print(", len:");

  604. 		serial_phex16(setup.wLength);

  605. 		serial_print("\n");

  606. #endif

  607. 		// actually "do" the setup request

  608. 		usb_setup();

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

  610. 		USB0_CTL = USB_CTL_USBENSOFEN; // clear TXSUSPENDTOKENBUSY bit

  611. 		break;

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

  613. 	case 0x02:

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

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

  616. 			int i;

  617. 			uint32_t *line_coding = NULL;

  618. 			switch (setup.wIndex) {

  619. #ifdef CDC_STATUS_INTERFACE

  620. 			  case CDC_STATUS_INTERFACE:

  621. 				line_coding = usb_cdc_line_coding;

  622. 				break;

  623. #endif

  624. #ifdef CDC2_STATUS_INTERFACE

  625. 			  case CDC2_STATUS_INTERFACE:

  626. 				line_coding = usb_cdc2_line_coding;

  627. 				break;

  628. #endif

  629. #ifdef CDC3_STATUS_INTERFACE

  630. 			  case CDC3_STATUS_INTERFACE:

  631. 				line_coding = usb_cdc3_line_coding;

  632. 				break;

  633. #endif

  634. 			}

  635. 			if (line_coding) {

  636. 				uint8_t *dst = (uint8_t *)line_coding;

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

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

  639. 					//serial_phex(*buf);

  640. 					*dst++ = *buf++;

  641. 				}

  642. 				//serial_phex32(line_coding[0]);

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

  644. 				if (line_coding[0] == 134) usb_reboot_timer = 15;

  645. 			}

  646. 			endpoint0_transmit(NULL, 0);

  647. 		}

  648. #ifdef KEYBOARD_INTERFACE

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

  650. 			keyboard_leds = buf[0];

  651. 			endpoint0_transmit(NULL, 0);

  652. 		}

  653. #endif

  654. #ifdef SEREMU_INTERFACE

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

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

  657. 			usb_reboot_timer = 5;

  658. 			endpoint0_transmit(NULL, 0);

  659. 		}

  660. #endif

  661. #ifdef AUDIO_INTERFACE

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

  663. 			endpoint0_transmit(NULL, 0);

  664. 		}

  665. #endif

  666. 		// give the buffer back

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

  668. 		break;

  669. 

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

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

  672. 		//serial_phex(stat);

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

  674. 

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

  676. 		data = ep0_tx_ptr;

  677. 		if (data) {

  678. 			size = ep0_tx_len;

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

  680. 			endpoint0_transmit(data, size);

  681. 			data += size;

  682. 			ep0_tx_len -= size;

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

  684. 		}

  685. 

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

  687. 			setup.bRequest = 0;

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

  689. 			//serial_phex16(setup.wValue);

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

  691. 			USB0_ADDR = setup.wValue;

  692. 		}

  693. 

  694. 		break;

  695. 	//default:

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

  697. 		//serial_phex(pid);

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

  699. 	}

  700. 	USB0_CTL = USB_CTL_USBENSOFEN; // clear TXSUSPENDTOKENBUSY bit

  701. }

  702. 

  703. 

  704. 

  705. 

  706. 

  707. 

  708. usb_packet_t *usb_rx(uint32_t endpoint)

  709. {

  710. 	usb_packet_t *ret;

  711. 	endpoint--;

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

  713. 	__disable_irq();

  714. 	ret = rx_first[endpoint];

  715. 	if (ret) {

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

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

  718. 	}

  719. 	__enable_irq();

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

  721. 	//serial_phex(endpoint);

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

  723. 	//serial_phex32(ret);

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

  725. 	return ret;

  726. }

  727. 

  728. static uint32_t usb_queue_byte_count(const usb_packet_t *p)

  729. {

  730. 	uint32_t count=0;

  731. 

  732. 	__disable_irq();

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

  734. 		count += p->len;

  735. 	}

  736. 	__enable_irq();

  737. 	return count;

  738. }

  739. 

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

  741. /*

  742. uint32_t usb_rx_byte_count(uint32_t endpoint)

  743. {

  744. 	endpoint--;

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

  746. 	return usb_rx_byte_count_data[endpoint];

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

  748. }

  749. */

  750. 

  751. uint32_t usb_tx_byte_count(uint32_t endpoint)

  752. {

  753. 	endpoint--;

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

  755. 	return usb_queue_byte_count(tx_first[endpoint]);

  756. }

  757. 

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

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

  760. //

  761. uint32_t usb_tx_packet_count(uint32_t endpoint)

  762. {

  763. 	const usb_packet_t *p;

  764. 	uint32_t count=0;

  765. 

  766. 	endpoint--;

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

  768. 	__disable_irq();

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

  770. 	__enable_irq();

  771. 	return count;

  772. }

  773. 

  774. 

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

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

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

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

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

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

  781. // first endpoint needing memory.

  782. //

  783. void usb_rx_memory(usb_packet_t *packet)

  784. {

  785. 	unsigned int i;

  786. 	const uint8_t *cfg;

  787. 

  788. 	cfg = usb_endpoint_config_table;

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

  790. 	__disable_irq();

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

  792. #ifdef AUDIO_INTERFACE

  793. 		if (i == AUDIO_RX_ENDPOINT) continue;

  794. #endif

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

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

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

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

  799. 				usb_rx_memory_needed--;

  800. 				__enable_irq();

  801. 				//serial_phex(i);

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

  803. 				return;

  804. 			}

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

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

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

  808. 				usb_rx_memory_needed--;

  809. 				__enable_irq();

  810. 				//serial_phex(i);

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

  812. 				return;

  813. 			}

  814. 		}

  815. 	}

  816. 	__enable_irq();

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

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

  819. 	// was actually needed.

  820. 	usb_rx_memory_needed = 0;

  821. 	usb_free(packet);

  822. 	return;

  823. }

  824. 

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

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

  827. 

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

  829. {

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

  831. 	uint8_t next;

  832. 

  833. 	endpoint--;

  834. 	if (endpoint >= NUM_ENDPOINTS) return;

  835. 	__disable_irq();

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

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

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

  839. 	switch (tx_state[endpoint]) {

  840. 	  case TX_STATE_BOTH_FREE_EVEN_FIRST:

  841. 		next = TX_STATE_ODD_FREE;

  842. 		break;

  843. 	  case TX_STATE_BOTH_FREE_ODD_FIRST:

  844. 		b++;

  845. 		next = TX_STATE_EVEN_FREE;

  846. 		break;

  847. 	  case TX_STATE_EVEN_FREE:

  848. 		next = TX_STATE_NONE_FREE_ODD_FIRST;

  849. 		break;

  850. 	  case TX_STATE_ODD_FREE:

  851. 		b++;

  852. 		next = TX_STATE_NONE_FREE_EVEN_FIRST;

  853. 		break;

  854. 	  default:

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

  856. 			tx_first[endpoint] = packet;

  857. 		} else {

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

  859. 		}

  860. 		tx_last[endpoint] = packet;

  861. 		__enable_irq();

  862. 		return;

  863. 	}

  864. 	tx_state[endpoint] = next;

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

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

  867. 	__enable_irq();

  868. }

  869. 

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

  871. {

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

  873. 	uint8_t next, state;

  874. 

  875. 	endpoint--;

  876. 	if (endpoint >= NUM_ENDPOINTS) return;

  877. 	__disable_irq();

  878. 	state = tx_state[endpoint];

  879. 	if (state == 0) {

  880. 		next = 1;

  881. 	} else {

  882. 		b++;

  883. 		next = 0;

  884. 	}

  885. 	tx_state[endpoint] = next;

  886. 	b->addr = data;

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

  888. 	__enable_irq();

  889. }

  890. 

  891. 

  892. 

  893. 

  894. void _reboot_Teensyduino_(void)

  895. {

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

  897. 	__asm__ volatile("bkpt");

  898. 	__builtin_unreachable();

  899. }

  900. 

  901. 

  902. 

  903. void usb_isr(void)

  904. {

  905. 	uint8_t status, stat, t;

  906. 

  907. 	//serial_print("isr");

  908. 	//status = USB0_ISTAT;

  909. 	//serial_phex(status);

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

  911. 	restart:

  912. 	status = USB0_ISTAT;

  913. 

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

  915. 		if (usb_configuration) {

  916. 			t = usb_reboot_timer;

  917. 			if (t) {

  918. 				usb_reboot_timer = --t;

  919. 				if (!t) _reboot_Teensyduino_();

  920. 			}

  921. #ifdef CDC_DATA_INTERFACE

  922. 			t = usb_cdc_transmit_flush_timer;

  923. 			if (t) {

  924. 				usb_cdc_transmit_flush_timer = --t;

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

  926. 			}

  927. #endif

  928. #ifdef CDC2_DATA_INTERFACE

  929. 			t = usb_cdc2_transmit_flush_timer;

  930. 			if (t) {

  931. 				usb_cdc2_transmit_flush_timer = --t;

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

  933. 			}

  934. #endif

  935. #ifdef CDC3_DATA_INTERFACE

  936. 			t = usb_cdc3_transmit_flush_timer;

  937. 			if (t) {

  938. 				usb_cdc3_transmit_flush_timer = --t;

  939. 				if (t == 0) usb_serial3_flush_callback();

  940. 			}

  941. #endif

  942. #ifdef SEREMU_INTERFACE

  943. 			t = usb_seremu_transmit_flush_timer;

  944. 			if (t) {

  945. 				usb_seremu_transmit_flush_timer = --t;

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

  947. 			}

  948. #endif

  949. #ifdef MIDI_INTERFACE

  950.                         usb_midi_flush_output();

  951. #endif

  952. #ifdef FLIGHTSIM_INTERFACE

  953. 			usb_flightsim_flush_callback();

  954. #endif

  955. #ifdef MULTITOUCH_INTERFACE

  956. 			usb_touchscreen_update_callback();

  957. #endif

  958. 		}

  959. 		USB0_ISTAT = USB_ISTAT_SOFTOK;

  960. 	}

  961. 

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

  963. 		uint8_t endpoint;

  964. 		stat = USB0_STAT;

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

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

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

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

  969. 		endpoint = stat >> 4;

  970. 		if (endpoint == 0) {

  971. 			usb_control(stat);

  972. 		} else {

  973. 			bdt_t *b = stat2bufferdescriptor(stat);

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

  975. #if 0

  976. 			serial_print("ep:");

  977. 			serial_phex(endpoint);

  978. 			serial_print(", pid:");

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

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

  981. 			serial_print(", count:");

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

  983. 			serial_print("\n");

  984. #endif

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

  986. 

  987. #ifdef AUDIO_INTERFACE

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

  989. 				unsigned int len;

  990. 				len = usb_audio_transmit_callback();

  991. 				if (len > 0) {

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

  993. 					b->addr = usb_audio_transmit_buffer;

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

  995. 					tx_state[endpoint] ^= 1;

  996. 				}

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

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

  999. 				b->addr = usb_audio_receive_buffer;

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

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

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

  1003. 				b->addr = &usb_audio_sync_feedback;

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

  1005. 				tx_state[endpoint] ^= 1;

  1006. 			} else

  1007. #endif

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

  1009. 				usb_free(packet);

  1010. 				packet = tx_first[endpoint];

  1011. 				if (packet) {

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

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

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

  1015. 					switch (tx_state[endpoint]) {

  1016. 					  case TX_STATE_BOTH_FREE_EVEN_FIRST:

  1017. 						tx_state[endpoint] = TX_STATE_ODD_FREE;

  1018. 						break;

  1019. 					  case TX_STATE_BOTH_FREE_ODD_FIRST:

  1020. 						tx_state[endpoint] = TX_STATE_EVEN_FREE;

  1021. 						break;

  1022. 					  case TX_STATE_EVEN_FREE:

  1023. 						tx_state[endpoint] = TX_STATE_NONE_FREE_ODD_FIRST;

  1024. 						break;

  1025. 					  case TX_STATE_ODD_FREE:

  1026. 						tx_state[endpoint] = TX_STATE_NONE_FREE_EVEN_FIRST;

  1027. 						break;

  1028. 					  default:

  1029. 						break;

  1030. 					}

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

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

  1033. 				} else {

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

  1035. 					switch (tx_state[endpoint]) {

  1036. 					  case TX_STATE_BOTH_FREE_EVEN_FIRST:

  1037. 					  case TX_STATE_BOTH_FREE_ODD_FIRST:

  1038. 						break;

  1039. 					  case TX_STATE_EVEN_FREE:

  1040. 						tx_state[endpoint] = TX_STATE_BOTH_FREE_EVEN_FIRST;

  1041. 						break;

  1042. 					  case TX_STATE_ODD_FREE:

  1043. 						tx_state[endpoint] = TX_STATE_BOTH_FREE_ODD_FIRST;

  1044. 						break;

  1045. 					  default:

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

  1047. 						  TX_STATE_ODD_FREE : TX_STATE_EVEN_FREE;

  1048. 						break;

  1049. 					}

  1050. 				}

  1051. 			} else { // receive

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

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

  1054. 					packet->index = 0;

  1055. 					packet->next = NULL;

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

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

  1058. 						//serial_phex(endpoint);

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

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

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

  1062. 						rx_first[endpoint] = packet;

  1063. 					} else {

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

  1065. 						//serial_phex(endpoint);

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

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

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

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

  1070. 					}

  1071. 					rx_last[endpoint] = packet;

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

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

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

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

  1076. 					// it regularly

  1077. 					packet = usb_malloc();

  1078. 					if (packet) {

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

  1080. 						b->desc = BDT_DESC(64,

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

  1082. 					} else {

  1083. 						//serial_print("starving ");

  1084. 						//serial_phex(endpoint + 1);

  1085. 						b->desc = 0;

  1086. 						usb_rx_memory_needed++;

  1087. 					}

  1088. 				} else {

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

  1090. 				}

  1091. 			}

  1092. 

  1093. 		}

  1094. 		USB0_ISTAT = USB_ISTAT_TOKDNE;

  1095. 		goto restart;

  1096. 	}

  1097. 

  1098. 

  1099. 

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

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

  1102. 

  1103. 		// initialize BDT toggle bits

  1104. 		USB0_CTL = USB_CTL_ODDRST;

  1105. 		ep0_tx_bdt_bank = 0;

  1106. 

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

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

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

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

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

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

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

  1114. 

  1115. 		// activate endpoint 0

  1116. 		USB0_ENDPT0 = USB_ENDPT_EPRXEN | USB_ENDPT_EPTXEN | USB_ENDPT_EPHSHK;

  1117. 

  1118. 		// clear all ending interrupts

  1119. 		USB0_ERRSTAT = 0xFF;

  1120. 		USB0_ISTAT = 0xFF;

  1121. 

  1122. 		// set the address to zero during enumeration

  1123. 		USB0_ADDR = 0;

  1124. 

  1125. 		// enable other interrupts

  1126. 		USB0_ERREN = 0xFF;

  1127. 		USB0_INTEN = USB_INTEN_TOKDNEEN |

  1128. 			USB_INTEN_SOFTOKEN |

  1129. 			USB_INTEN_STALLEN |

  1130. 			USB_INTEN_ERROREN |

  1131. 			USB_INTEN_USBRSTEN |

  1132. 			USB_INTEN_SLEEPEN;

  1133. 

  1134. 		// is this necessary?

  1135. 		USB0_CTL = USB_CTL_USBENSOFEN;

  1136. 		return;

  1137. 	}

  1138. 

  1139. 

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

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

  1142. 		USB0_ENDPT0 = USB_ENDPT_EPRXEN | USB_ENDPT_EPTXEN | USB_ENDPT_EPHSHK;

  1143. 		USB0_ISTAT = USB_ISTAT_STALL;

  1144. 	}

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

  1146. 		uint8_t err = USB0_ERRSTAT;

  1147. 		USB0_ERRSTAT = err;

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

  1149. 		//serial_phex(err);

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

  1151. 		USB0_ISTAT = USB_ISTAT_ERROR;

  1152. 	}

  1153. 

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

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

  1156. 		USB0_ISTAT = USB_ISTAT_SLEEP;

  1157. 	}

  1158. 

  1159. }

  1160. 

  1161. 

  1162. 

  1163. void usb_init(void)

  1164. {

  1165. 	int i;

  1166. 

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

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

  1169. 

  1170. 	usb_init_serialnumber();

  1171. 

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

  1173. 		table[i].desc = 0;

  1174. 		table[i].addr = 0;

  1175. 	}

  1176. 

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

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

  1179. 

  1180. 	// assume 48 MHz clock already running

  1181. 	// SIM - enable clock

  1182. 	SIM_SCGC4 |= SIM_SCGC4_USBOTG;

  1183. #ifdef HAS_KINETIS_MPU

  1184. 	MPU_RGDAAC0 |= 0x03000000;

  1185. #endif

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

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

  1188. 	USB0_CLK_RECOVER_IRC_EN = USB_CLK_RECOVER_IRC_EN_IRC_EN | USB_CLK_RECOVER_IRC_EN_REG_EN;

  1189. 	USB0_CLK_RECOVER_CTRL = USB_CLK_RECOVER_CTRL_CLOCK_RECOVER_EN |

  1190. 		USB_CLK_RECOVER_CTRL_RESTART_IFRTRIM_EN;

  1191. #endif

  1192. 	// reset USB module

  1193. 	//USB0_USBTRC0 = USB_USBTRC_USBRESET;

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

  1195. 

  1196. 	// set desc table base addr

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

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

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

  1200. 

  1201. 	// clear all ISR flags

  1202. 	USB0_ISTAT = 0xFF;

  1203. 	USB0_ERRSTAT = 0xFF;

  1204. 	USB0_OTGISTAT = 0xFF;

  1205. 

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

  1207. 

  1208. 	// enable USB

  1209. 	USB0_CTL = USB_CTL_USBENSOFEN;

  1210. 	USB0_USBCTRL = 0;

  1211. 

  1212. 	// enable reset interrupt

  1213. 	USB0_INTEN = USB_INTEN_USBRSTEN;

  1214. 

  1215. 	// enable interrupt in NVIC...

  1216. 	NVIC_SET_PRIORITY(IRQ_USBOTG, 112);

  1217. 	NVIC_ENABLE_IRQ(IRQ_USBOTG);

  1218. 

  1219. 	// enable d+ pullup

  1220. 	USB0_CONTROL = USB_CONTROL_DPPULLUPNONOTG;

  1221. }

  1222. 

  1223. 

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

  1225. 

  1226. void usb_init(void)

  1227. {

  1228. }

  1229. 

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