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.
1177 Commits
2 Branches
Tree: be2330ae73
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'be2330ae73'
${ noResults }
teensy-core-4.1/teensy3/usb_dev.c

1198 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. 		}

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

  366. 		break;

  367. #ifdef CDC_STATUS_INTERFACE

  368. 	  case 0x2321: // CDC_SEND_BREAK

  369. 		break;

  370. 	  case 0x2021: // CDC_SET_LINE_CODING

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

  372. 		return;

  373. #endif

  374. 

  375. #if defined(MTP_INTERFACE)

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

  377. 		// TODO: required by PTP spec

  378. 		endpoint0_stall();

  379. 		return;

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

  381. 		// TODO: required by PTP spec

  382. 		endpoint0_stall();

  383. 		return;

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

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

  386. 		reply_buffer[0] = 0x4;

  387. 		reply_buffer[1] = 0;

  388. 		reply_buffer[2] = 0x01;

  389. 		reply_buffer[3] = 0x20;

  390. 		data = reply_buffer;

  391. 		datalen = 4;

  392. 		break;

  393. #endif

  394. 

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

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

  397. 	  case 0x0921: // HID SET_REPORT

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

  399. 		return;

  400. 	  case 0x0A21: // HID SET_IDLE

  401. 		break;

  402. 	  // case 0xC940:

  403. #endif

  404. 

  405. #if defined(AUDIO_INTERFACE)

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

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

  408. 			usb_audio_transmit_setting = setup.wValue;

  409. 			if (usb_audio_transmit_setting > 0) {

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

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

  412. 				if (state) b++;

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

  414. 					memset(usb_audio_transmit_buffer, 0, 176);

  415. 					b->addr = usb_audio_transmit_buffer;

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

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

  418. 				}

  419. 			}

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

  421. 			usb_audio_receive_setting = setup.wValue;

  422. 		} else {

  423. 			endpoint0_stall();

  424. 			return;

  425. 		}

  426. 		break;

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

  428. 		datalen = 1;

  429. 		data = reply_buffer;

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

  431. 			reply_buffer[0] = usb_audio_transmit_setting;

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

  433. 			reply_buffer[0] = usb_audio_receive_setting;

  434. 		} else {

  435. 			endpoint0_stall();

  436. 			return;

  437. 		}

  438. 		break;

  439. 	  case 0x0121: // SET FEATURE

  440. 	  case 0x0221:

  441. 	  case 0x0321:

  442. 	  case 0x0421:

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

  444. 		return;

  445. 	  case 0x81A1: // GET FEATURE

  446. 	  case 0x82A1:

  447. 	  case 0x83A1:

  448. 	  case 0x84A1:

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

  450. 	  		data = reply_buffer;

  451. 	  	}

  452. 	  	else {

  453. 	  		endpoint0_stall();

  454. 	  		return;

  455. 	  	}

  456. 		break;

  457. 

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

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

  460. 			reply_buffer[0] = 44100 & 255;

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

  462. 			reply_buffer[2] = 0;

  463. 			datalen = 3;

  464. 			data = reply_buffer;

  465. 		} else {

  466. 			endpoint0_stall();

  467. 			return;

  468. 		}

  469. 		break;

  470. #endif

  471. 

  472. #if defined(MULTITOUCH_INTERFACE)

  473. 	  case 0x01A1:

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

  475. 			reply_buffer[0] = MULTITOUCH_FINGERS;

  476. 			data = reply_buffer;

  477. 			datalen = 1;

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

  479. 			memset(reply_buffer, 0, 8);

  480. 			data = reply_buffer;

  481. 			datalen = 8;

  482. 		} else {

  483. 			endpoint0_stall();

  484. 			return;

  485. 		}

  486. 		break;

  487. #endif

  488. 	  default:

  489. 		endpoint0_stall();

  490. 		return;

  491. 	}

  492. 	send:

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

  494. 	//serial_phex32(data);

  495. 	//serial_print(",");

  496. 	//serial_phex16(datalen);

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

  498. 

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

  500. 	size = datalen;

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

  502. 	endpoint0_transmit(data, size);

  503. 	data += size;

  504. 	datalen -= size;

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

  506. 

  507. 	size = datalen;

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

  509. 	endpoint0_transmit(data, size);

  510. 	data += size;

  511. 	datalen -= size;

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

  513. 

  514. 	ep0_tx_ptr = data;

  515. 	ep0_tx_len = datalen;

  516. }

  517. 

  518. 

  519. 

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

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

  522. //Sections 9.1.1.5 and 9.4.5).

  523. 

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

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

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

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

  528. 

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

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

  531. //data toggle being reinitialized to DATA0.

  532. 

  533. 

  534. 

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

  536. 

  537. static void usb_control(uint32_t stat)

  538. {

  539. 	bdt_t *b;

  540. 	uint32_t pid, size;

  541. 	uint8_t *buf;

  542. 	const uint8_t *data;

  543. 

  544. 	b = stat2bufferdescriptor(stat);

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

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

  547. 	buf = b->addr;

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

  549. 	//serial_phex(pid);

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

  551. 	//serial_phex(count);

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

  553. 

  554. 	switch (pid) {

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

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

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

  558. 		// grab the 8 byte setup info

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

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

  561. 

  562. 		// give the buffer back

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

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

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

  566. 

  567. 		// clear any leftover pending IN transactions

  568. 		ep0_tx_ptr = NULL;

  569. 		if (ep0_tx_data_toggle) {

  570. 		}

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

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

  573. 		//}

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

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

  576. 		//}

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

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

  579. 		// first IN after Setup is always DATA1

  580. 		ep0_tx_data_toggle = 1;

  581. 

  582. #if 0

  583. 		serial_print("bmRequestType:");

  584. 		serial_phex(setup.bmRequestType);

  585. 		serial_print(", bRequest:");

  586. 		serial_phex(setup.bRequest);

  587. 		serial_print(", wValue:");

  588. 		serial_phex16(setup.wValue);

  589. 		serial_print(", wIndex:");

  590. 		serial_phex16(setup.wIndex);

  591. 		serial_print(", len:");

  592. 		serial_phex16(setup.wLength);

  593. 		serial_print("\n");

  594. #endif

  595. 		// actually "do" the setup request

  596. 		usb_setup();

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

  598. 		USB0_CTL = USB_CTL_USBENSOFEN; // clear TXSUSPENDTOKENBUSY bit

  599. 		break;

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

  601. 	case 0x02:

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

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

  604. 			int i;

  605. 			uint8_t *dst = NULL;

  606. 			switch (setup.wIndex) {

  607. #ifdef CDC_STATUS_INTERFACE

  608. 			  case CDC_STATUS_INTERFACE:

  609. 				dst = (uint8_t *)usb_cdc_line_coding;

  610. 				break;

  611. #endif

  612. 			}

  613. 			if (!dst)

  614. 				break;

  615. 

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

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

  618. 				//serial_phex(*buf);

  619. 				*dst++ = *buf++;

  620. 			}

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

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

  623. #ifdef CDC_STATUS_INTERFACE

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

  625. 			    usb_cdc_line_coding[0] == 134)

  626. 				usb_reboot_timer = 15;

  627. #endif

  628. 			endpoint0_transmit(NULL, 0);

  629. 		}

  630. #ifdef KEYBOARD_INTERFACE

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

  632. 			keyboard_leds = buf[0];

  633. 			endpoint0_transmit(NULL, 0);

  634. 		}

  635. #endif

  636. #ifdef SEREMU_INTERFACE

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

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

  639. 			usb_reboot_timer = 5;

  640. 			endpoint0_transmit(NULL, 0);

  641. 		}

  642. #endif

  643. #ifdef AUDIO_INTERFACE

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

  645. 			endpoint0_transmit(NULL, 0);

  646. 		}

  647. #endif

  648. 		// give the buffer back

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

  650. 		break;

  651. 

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

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

  654. 		//serial_phex(stat);

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

  656. 

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

  658. 		data = ep0_tx_ptr;

  659. 		if (data) {

  660. 			size = ep0_tx_len;

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

  662. 			endpoint0_transmit(data, size);

  663. 			data += size;

  664. 			ep0_tx_len -= size;

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

  666. 		}

  667. 

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

  669. 			setup.bRequest = 0;

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

  671. 			//serial_phex16(setup.wValue);

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

  673. 			USB0_ADDR = setup.wValue;

  674. 		}

  675. 

  676. 		break;

  677. 	//default:

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

  679. 		//serial_phex(pid);

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

  681. 	}

  682. 	USB0_CTL = USB_CTL_USBENSOFEN; // clear TXSUSPENDTOKENBUSY bit

  683. }

  684. 

  685. 

  686. 

  687. 

  688. 

  689. 

  690. usb_packet_t *usb_rx(uint32_t endpoint)

  691. {

  692. 	usb_packet_t *ret;

  693. 	endpoint--;

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

  695. 	__disable_irq();

  696. 	ret = rx_first[endpoint];

  697. 	if (ret) {

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

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

  700. 	}

  701. 	__enable_irq();

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

  703. 	//serial_phex(endpoint);

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

  705. 	//serial_phex32(ret);

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

  707. 	return ret;

  708. }

  709. 

  710. static uint32_t usb_queue_byte_count(const usb_packet_t *p)

  711. {

  712. 	uint32_t count=0;

  713. 

  714. 	__disable_irq();

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

  716. 		count += p->len;

  717. 	}

  718. 	__enable_irq();

  719. 	return count;

  720. }

  721. 

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

  723. /*

  724. uint32_t usb_rx_byte_count(uint32_t endpoint)

  725. {

  726. 	endpoint--;

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

  728. 	return usb_rx_byte_count_data[endpoint];

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

  730. }

  731. */

  732. 

  733. uint32_t usb_tx_byte_count(uint32_t endpoint)

  734. {

  735. 	endpoint--;

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

  737. 	return usb_queue_byte_count(tx_first[endpoint]);

  738. }

  739. 

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

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

  742. //

  743. uint32_t usb_tx_packet_count(uint32_t endpoint)

  744. {

  745. 	const usb_packet_t *p;

  746. 	uint32_t count=0;

  747. 

  748. 	endpoint--;

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

  750. 	__disable_irq();

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

  752. 	__enable_irq();

  753. 	return count;

  754. }

  755. 

  756. 

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

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

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

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

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

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

  763. // first endpoint needing memory.

  764. //

  765. void usb_rx_memory(usb_packet_t *packet)

  766. {

  767. 	unsigned int i;

  768. 	const uint8_t *cfg;

  769. 

  770. 	cfg = usb_endpoint_config_table;

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

  772. 	__disable_irq();

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

  774. #ifdef AUDIO_INTERFACE

  775. 		if (i == AUDIO_RX_ENDPOINT) continue;

  776. #endif

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

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

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

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

  781. 				usb_rx_memory_needed--;

  782. 				__enable_irq();

  783. 				//serial_phex(i);

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

  785. 				return;

  786. 			}

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

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

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

  790. 				usb_rx_memory_needed--;

  791. 				__enable_irq();

  792. 				//serial_phex(i);

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

  794. 				return;

  795. 			}

  796. 		}

  797. 	}

  798. 	__enable_irq();

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

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

  801. 	// was actually needed.

  802. 	usb_rx_memory_needed = 0;

  803. 	usb_free(packet);

  804. 	return;

  805. }

  806. 

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

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

  809. 

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

  811. {

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

  813. 	uint8_t next;

  814. 

  815. 	endpoint--;

  816. 	if (endpoint >= NUM_ENDPOINTS) return;

  817. 	__disable_irq();

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

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

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

  821. 	switch (tx_state[endpoint]) {

  822. 	  case TX_STATE_BOTH_FREE_EVEN_FIRST:

  823. 		next = TX_STATE_ODD_FREE;

  824. 		break;

  825. 	  case TX_STATE_BOTH_FREE_ODD_FIRST:

  826. 		b++;

  827. 		next = TX_STATE_EVEN_FREE;

  828. 		break;

  829. 	  case TX_STATE_EVEN_FREE:

  830. 		next = TX_STATE_NONE_FREE_ODD_FIRST;

  831. 		break;

  832. 	  case TX_STATE_ODD_FREE:

  833. 		b++;

  834. 		next = TX_STATE_NONE_FREE_EVEN_FIRST;

  835. 		break;

  836. 	  default:

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

  838. 			tx_first[endpoint] = packet;

  839. 		} else {

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

  841. 		}

  842. 		tx_last[endpoint] = packet;

  843. 		__enable_irq();

  844. 		return;

  845. 	}

  846. 	tx_state[endpoint] = next;

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

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

  849. 	__enable_irq();

  850. }

  851. 

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

  853. {

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

  855. 	uint8_t next, state;

  856. 

  857. 	endpoint--;

  858. 	if (endpoint >= NUM_ENDPOINTS) return;

  859. 	__disable_irq();

  860. 	state = tx_state[endpoint];

  861. 	if (state == 0) {

  862. 		next = 1;

  863. 	} else {

  864. 		b++;

  865. 		next = 0;

  866. 	}

  867. 	tx_state[endpoint] = next;

  868. 	b->addr = data;

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

  870. 	__enable_irq();

  871. }

  872. 

  873. 

  874. 

  875. 

  876. void _reboot_Teensyduino_(void)

  877. {

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

  879. 	__asm__ volatile("bkpt");

  880. }

  881. 

  882. 

  883. 

  884. void usb_isr(void)

  885. {

  886. 	uint8_t status, stat, t;

  887. 

  888. 	//serial_print("isr");

  889. 	//status = USB0_ISTAT;

  890. 	//serial_phex(status);

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

  892. 	restart:

  893. 	status = USB0_ISTAT;

  894. 

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

  896. 		if (usb_configuration) {

  897. 			t = usb_reboot_timer;

  898. 			if (t) {

  899. 				usb_reboot_timer = --t;

  900. 				if (!t) _reboot_Teensyduino_();

  901. 			}

  902. #ifdef CDC_DATA_INTERFACE

  903. 			t = usb_cdc_transmit_flush_timer;

  904. 			if (t) {

  905. 				usb_cdc_transmit_flush_timer = --t;

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

  907. 			}

  908. #endif

  909. #ifdef SEREMU_INTERFACE

  910. 			t = usb_seremu_transmit_flush_timer;

  911. 			if (t) {

  912. 				usb_seremu_transmit_flush_timer = --t;

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

  914. 			}

  915. #endif

  916. #ifdef MIDI_INTERFACE

  917.                         usb_midi_flush_output();

  918. #endif

  919. #ifdef FLIGHTSIM_INTERFACE

  920. 			usb_flightsim_flush_callback();

  921. #endif

  922. #ifdef MULTITOUCH_INTERFACE

  923. 			usb_touchscreen_update_callback();

  924. #endif

  925. 		}

  926. 		USB0_ISTAT = USB_ISTAT_SOFTOK;

  927. 	}

  928. 

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

  930. 		uint8_t endpoint;

  931. 		stat = USB0_STAT;

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

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

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

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

  936. 		endpoint = stat >> 4;

  937. 		if (endpoint == 0) {

  938. 			usb_control(stat);

  939. 		} else {

  940. 			bdt_t *b = stat2bufferdescriptor(stat);

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

  942. #if 0

  943. 			serial_print("ep:");

  944. 			serial_phex(endpoint);

  945. 			serial_print(", pid:");

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

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

  948. 			serial_print(", count:");

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

  950. 			serial_print("\n");

  951. #endif

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

  953. 

  954. #ifdef AUDIO_INTERFACE

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

  956. 				unsigned int len;

  957. 				len = usb_audio_transmit_callback();

  958. 				if (len > 0) {

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

  960. 					b->addr = usb_audio_transmit_buffer;

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

  962. 					tx_state[endpoint] ^= 1;

  963. 				}

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

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

  966. 				b->addr = usb_audio_receive_buffer;

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

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

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

  970. 				b->addr = &usb_audio_sync_feedback;

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

  972. 				tx_state[endpoint] ^= 1;

  973. 			} else

  974. #endif

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

  976. 				usb_free(packet);

  977. 				packet = tx_first[endpoint];

  978. 				if (packet) {

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

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

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

  982. 					switch (tx_state[endpoint]) {

  983. 					  case TX_STATE_BOTH_FREE_EVEN_FIRST:

  984. 						tx_state[endpoint] = TX_STATE_ODD_FREE;

  985. 						break;

  986. 					  case TX_STATE_BOTH_FREE_ODD_FIRST:

  987. 						tx_state[endpoint] = TX_STATE_EVEN_FREE;

  988. 						break;

  989. 					  case TX_STATE_EVEN_FREE:

  990. 						tx_state[endpoint] = TX_STATE_NONE_FREE_ODD_FIRST;

  991. 						break;

  992. 					  case TX_STATE_ODD_FREE:

  993. 						tx_state[endpoint] = TX_STATE_NONE_FREE_EVEN_FIRST;

  994. 						break;

  995. 					  default:

  996. 						break;

  997. 					}

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

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

  1000. 				} else {

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

  1002. 					switch (tx_state[endpoint]) {

  1003. 					  case TX_STATE_BOTH_FREE_EVEN_FIRST:

  1004. 					  case TX_STATE_BOTH_FREE_ODD_FIRST:

  1005. 						break;

  1006. 					  case TX_STATE_EVEN_FREE:

  1007. 						tx_state[endpoint] = TX_STATE_BOTH_FREE_EVEN_FIRST;

  1008. 						break;

  1009. 					  case TX_STATE_ODD_FREE:

  1010. 						tx_state[endpoint] = TX_STATE_BOTH_FREE_ODD_FIRST;

  1011. 						break;

  1012. 					  default:

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

  1014. 						  TX_STATE_ODD_FREE : TX_STATE_EVEN_FREE;

  1015. 						break;

  1016. 					}

  1017. 				}

  1018. 			} else { // receive

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

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

  1021. 					packet->index = 0;

  1022. 					packet->next = NULL;

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

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

  1025. 						//serial_phex(endpoint);

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

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

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

  1029. 						rx_first[endpoint] = packet;

  1030. 					} else {

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

  1032. 						//serial_phex(endpoint);

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

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

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

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

  1037. 					}

  1038. 					rx_last[endpoint] = packet;

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

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

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

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

  1043. 					// it regularly

  1044. 					packet = usb_malloc();

  1045. 					if (packet) {

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

  1047. 						b->desc = BDT_DESC(64,

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

  1049. 					} else {

  1050. 						//serial_print("starving ");

  1051. 						//serial_phex(endpoint + 1);

  1052. 						b->desc = 0;

  1053. 						usb_rx_memory_needed++;

  1054. 					}

  1055. 				} else {

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

  1057. 				}

  1058. 			}

  1059. 

  1060. 		}

  1061. 		USB0_ISTAT = USB_ISTAT_TOKDNE;

  1062. 		goto restart;

  1063. 	}

  1064. 

  1065. 

  1066. 

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

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

  1069. 

  1070. 		// initialize BDT toggle bits

  1071. 		USB0_CTL = USB_CTL_ODDRST;

  1072. 		ep0_tx_bdt_bank = 0;

  1073. 

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

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

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

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

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

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

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

  1081. 

  1082. 		// activate endpoint 0

  1083. 		USB0_ENDPT0 = USB_ENDPT_EPRXEN | USB_ENDPT_EPTXEN | USB_ENDPT_EPHSHK;

  1084. 

  1085. 		// clear all ending interrupts

  1086. 		USB0_ERRSTAT = 0xFF;

  1087. 		USB0_ISTAT = 0xFF;

  1088. 

  1089. 		// set the address to zero during enumeration

  1090. 		USB0_ADDR = 0;

  1091. 

  1092. 		// enable other interrupts

  1093. 		USB0_ERREN = 0xFF;

  1094. 		USB0_INTEN = USB_INTEN_TOKDNEEN |

  1095. 			USB_INTEN_SOFTOKEN |

  1096. 			USB_INTEN_STALLEN |

  1097. 			USB_INTEN_ERROREN |

  1098. 			USB_INTEN_USBRSTEN |

  1099. 			USB_INTEN_SLEEPEN;

  1100. 

  1101. 		// is this necessary?

  1102. 		USB0_CTL = USB_CTL_USBENSOFEN;

  1103. 		return;

  1104. 	}

  1105. 

  1106. 

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

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

  1109. 		USB0_ENDPT0 = USB_ENDPT_EPRXEN | USB_ENDPT_EPTXEN | USB_ENDPT_EPHSHK;

  1110. 		USB0_ISTAT = USB_ISTAT_STALL;

  1111. 	}

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

  1113. 		uint8_t err = USB0_ERRSTAT;

  1114. 		USB0_ERRSTAT = err;

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

  1116. 		//serial_phex(err);

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

  1118. 		USB0_ISTAT = USB_ISTAT_ERROR;

  1119. 	}

  1120. 

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

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

  1123. 		USB0_ISTAT = USB_ISTAT_SLEEP;

  1124. 	}

  1125. 

  1126. }

  1127. 

  1128. 

  1129. 

  1130. void usb_init(void)

  1131. {

  1132. 	int i;

  1133. 

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

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

  1136. 

  1137. 	usb_init_serialnumber();

  1138. 

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

  1140. 		table[i].desc = 0;

  1141. 		table[i].addr = 0;

  1142. 	}

  1143. 

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

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

  1146. 

  1147. 	// assume 48 MHz clock already running

  1148. 	// SIM - enable clock

  1149. 	SIM_SCGC4 |= SIM_SCGC4_USBOTG;

  1150. #ifdef HAS_KINETIS_MPU

  1151. 	MPU_RGDAAC0 |= 0x03000000;

  1152. #endif

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

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

  1155. 	USB0_CLK_RECOVER_IRC_EN = USB_CLK_RECOVER_IRC_EN_IRC_EN | USB_CLK_RECOVER_IRC_EN_REG_EN;

  1156. 	USB0_CLK_RECOVER_CTRL = USB_CLK_RECOVER_CTRL_CLOCK_RECOVER_EN |

  1157. 		USB_CLK_RECOVER_CTRL_RESTART_IFRTRIM_EN;

  1158. #endif

  1159. 	// reset USB module

  1160. 	//USB0_USBTRC0 = USB_USBTRC_USBRESET;

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

  1162. 

  1163. 	// set desc table base addr

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

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

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

  1167. 

  1168. 	// clear all ISR flags

  1169. 	USB0_ISTAT = 0xFF;

  1170. 	USB0_ERRSTAT = 0xFF;

  1171. 	USB0_OTGISTAT = 0xFF;

  1172. 

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

  1174. 

  1175. 	// enable USB

  1176. 	USB0_CTL = USB_CTL_USBENSOFEN;

  1177. 	USB0_USBCTRL = 0;

  1178. 

  1179. 	// enable reset interrupt

  1180. 	USB0_INTEN = USB_INTEN_USBRSTEN;

  1181. 

  1182. 	// enable interrupt in NVIC...

  1183. 	NVIC_SET_PRIORITY(IRQ_USBOTG, 112);

  1184. 	NVIC_ENABLE_IRQ(IRQ_USBOTG);

  1185. 

  1186. 	// enable d+ pullup

  1187. 	USB0_CONTROL = USB_CONTROL_DPPULLUPNONOTG;

  1188. }

  1189. 

  1190. 

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

  1192. 

  1193. void usb_init(void)

  1194. {

  1195. }

  1196. 

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