visus
/
teensy-core-4.1
Tarkkaile 1
Äänestä 0
Fork 0
Koodi Ongelmat 0 Pull-pyynnöt 0 Julkaisut 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.
106 Commitit
2 Branchit
Puu: 3b4aa6ae56
Branchit Tagit
${ item.name }
Create branch ${ searchTerm }
from '3b4aa6ae56'
${ noResults }
teensy-core-4.1/teensy3/usb_dev.c

981 lines
25KB
Raaka Blame Historia 

  1. /* Teensyduino Core Library

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

  3.  * Copyright (c) 2013 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. 

  31. #include "usb_dev.h"

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

  33. 

  34. #include "mk20dx128.h"

  35. //#include "HardwareSerial.h"

  36. #include "usb_mem.h"

  37. 

  38. // buffer descriptor table

  39. 

  40. typedef struct {

  41. 	uint32_t desc;

  42. 	void * addr;

  43. } bdt_t;

  44. 

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

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

  47. 

  48. static usb_packet_t *rx_first[NUM_ENDPOINTS];

  49. static usb_packet_t *rx_last[NUM_ENDPOINTS];

  50. static usb_packet_t *tx_first[NUM_ENDPOINTS];

  51. static usb_packet_t *tx_last[NUM_ENDPOINTS];

  52. uint16_t usb_rx_byte_count_data[NUM_ENDPOINTS];

  53. 

  54. static uint8_t tx_state[NUM_ENDPOINTS];

  55. #define TX_STATE_BOTH_FREE_EVEN_FIRST	0

  56. #define TX_STATE_BOTH_FREE_ODD_FIRST	1

  57. #define TX_STATE_EVEN_FREE		2

  58. #define TX_STATE_ODD_FREE		3

  59. #define TX_STATE_NONE_FREE_EVEN_FIRST	4

  60. #define TX_STATE_NONE_FREE_ODD_FIRST	5

  61. 

  62. #define BDT_OWN		0x80

  63. #define BDT_DATA1	0x40

  64. #define BDT_DATA0	0x00

  65. #define BDT_DTS		0x08

  66. #define BDT_STALL	0x04

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

  68. 

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

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

  71. 				| ((count) << 16))

  72. 

  73. #define TX   1

  74. #define RX   0

  75. #define ODD  1

  76. #define EVEN 0

  77. #define DATA0 0

  78. #define DATA1 1

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

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

  81. 

  82. 

  83. static union {

  84.  struct {

  85.   union {

  86.    struct {

  87. 	uint8_t bmRequestType;

  88. 	uint8_t bRequest;

  89.    };

  90. 	uint16_t wRequestAndType;

  91.   };

  92. 	uint16_t wValue;

  93. 	uint16_t wIndex;

  94. 	uint16_t wLength;

  95.  };

  96.  struct {

  97. 	uint32_t word1;

  98. 	uint32_t word2;

  99.  };

  100. } setup;

  101. 

  102. 

  103. #define GET_STATUS		0

  104. #define CLEAR_FEATURE		1

  105. #define SET_FEATURE		3

  106. #define SET_ADDRESS		5

  107. #define GET_DESCRIPTOR		6

  108. #define SET_DESCRIPTOR		7

  109. #define GET_CONFIGURATION	8

  110. #define SET_CONFIGURATION	9

  111. #define GET_INTERFACE		10

  112. #define SET_INTERFACE		11

  113. #define SYNCH_FRAME		12

  114. 

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

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

  117. // Status stage uses a DATA1 PID.

  118. 

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

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

  121. static const uint8_t *ep0_tx_ptr = NULL;

  122. static uint16_t ep0_tx_len;

  123. static uint8_t ep0_tx_bdt_bank = 0;

  124. static uint8_t ep0_tx_data_toggle = 0;

  125. uint8_t usb_rx_memory_needed = 0;

  126. 

  127. volatile uint8_t usb_configuration = 0;

  128. volatile uint8_t usb_reboot_timer = 0;

  129. 

  130. 

  131. static void endpoint0_stall(void)

  132. {

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

  134. }

  135. 

  136. 

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

  138. {

  139. #if 0

  140. 	serial_print("tx0:");

  141. 	serial_phex32((uint32_t)data);

  142. 	serial_print(",");

  143. 	serial_phex16(len);

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

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

  146. #endif

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

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

  149. 	ep0_tx_data_toggle ^= 1;

  150. 	ep0_tx_bdt_bank ^= 1;

  151. }

  152. 

  153. static uint8_t reply_buffer[8];

  154. 

  155. static void usb_setup(void)

  156. {

  157. 	const uint8_t *data = NULL;

  158. 	uint32_t datalen = 0;

  159. 	const usb_descriptor_list_t *list;

  160. 	uint32_t size;

  161. 	volatile uint8_t *reg;

  162. 	uint8_t epconf;

  163. 	const uint8_t *cfg;

  164. 	int i;

  165. 

  166. 	switch (setup.wRequestAndType) {

  167. 	  case 0x0500: // SET_ADDRESS

  168. 		break;

  169. 	  case 0x0900: // SET_CONFIGURATION

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

  171. 		usb_configuration = setup.wValue;

  172. 		reg = &USB0_ENDPT1;

  173. 		cfg = usb_endpoint_config_table;

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

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

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

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

  178. 			}

  179. 		}

  180. 		// free all queued packets

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

  182. 			usb_packet_t *p, *n;

  183. 			p = rx_first[i];

  184. 			while (p) {

  185. 				n = p->next;

  186. 				usb_free(p);

  187. 				p = n;

  188. 			}

  189. 			rx_first[i] = NULL;

  190. 			rx_last[i] = NULL;

  191. 			p = tx_first[i];

  192. 			while (p) {

  193. 				n = p->next;

  194. 				usb_free(p);

  195. 				p = n;

  196. 			}

  197. 			tx_first[i] = NULL;

  198. 			tx_last[i] = NULL;

  199. 			usb_rx_byte_count_data[i] = 0;

  200. 			switch (tx_state[i]) {

  201. 			  case TX_STATE_EVEN_FREE:

  202. 			  case TX_STATE_NONE_FREE_EVEN_FIRST:

  203. 				tx_state[i] = TX_STATE_BOTH_FREE_EVEN_FIRST;

  204. 				break;

  205. 			  case TX_STATE_ODD_FREE:

  206. 			  case TX_STATE_NONE_FREE_ODD_FIRST:

  207. 				tx_state[i] = TX_STATE_BOTH_FREE_ODD_FIRST;

  208. 				break;

  209. 			  default:

  210. 				break;

  211. 			}

  212. 		}

  213. 		usb_rx_memory_needed = 0;

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

  215. 			epconf = *cfg++;

  216. 			*reg = epconf;

  217. 			reg += 4;

  218. 			if (epconf & USB_ENDPT_EPRXEN) {

  219. 				usb_packet_t *p;

  220. 				p = usb_malloc();

  221. 				if (p) {

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

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

  224. 				} else {

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

  226. 					usb_rx_memory_needed++;

  227. 				}

  228. 				p = usb_malloc();

  229. 				if (p) {

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

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

  232. 				} else {

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

  234. 					usb_rx_memory_needed++;

  235. 				}

  236. 			}

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

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

  239. 		}

  240. 		break;

  241. 	  case 0x0880: // GET_CONFIGURATION

  242. 		reply_buffer[0] = usb_configuration;

  243. 		datalen = 1;

  244. 		data = reply_buffer;

  245. 		break;

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

  247. 		reply_buffer[0] = 0;

  248. 		reply_buffer[1] = 0;

  249. 		datalen = 2;

  250. 		data = reply_buffer;

  251. 		break;

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

  253. 		if (setup.wIndex > NUM_ENDPOINTS) {

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

  255. 			endpoint0_stall();

  256. 			return;

  257. 		}

  258. 		reply_buffer[0] = 0;

  259. 		reply_buffer[1] = 0;

  260. 		if (*(uint8_t *)(&USB0_ENDPT0 + setup.wIndex * 4) & 0x02) reply_buffer[0] = 1;

  261. 		data = reply_buffer;

  262. 		datalen = 2;

  263. 		break;

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

  265. 		i = setup.wIndex & 0x7F;

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

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

  268. 			endpoint0_stall();

  269. 			return;

  270. 		}

  271. 		(*(uint8_t *)(&USB0_ENDPT0 + setup.wIndex * 4)) &= ~0x02;

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

  273. 		break;

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

  275. 		i = setup.wIndex & 0x7F;

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

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

  278. 			endpoint0_stall();

  279. 			return;

  280. 		}

  281. 		(*(uint8_t *)(&USB0_ENDPT0 + setup.wIndex * 4)) |= 0x02;

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

  283. 		break;

  284. 	  case 0x0680: // GET_DESCRIPTOR

  285. 	  case 0x0681:

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

  287. 		//serial_phex16(setup.wValue);

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

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

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

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

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

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

  294. 				data = list->addr;

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

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

  297. 					// length field, allowing runtime configured

  298. 					// length.

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

  300. 				} else {

  301. 					datalen = list->length;

  302. 				}

  303. #if 0

  304. 				serial_print("Desc found, ");

  305. 				serial_phex32((uint32_t)data);

  306. 				serial_print(",");

  307. 				serial_phex16(datalen);

  308. 				serial_print(",");

  309. 				serial_phex(data[0]);

  310. 				serial_phex(data[1]);

  311. 				serial_phex(data[2]);

  312. 				serial_phex(data[3]);

  313. 				serial_phex(data[4]);

  314. 				serial_phex(data[5]);

  315. 				serial_print("\n");

  316. #endif

  317. 				goto send;

  318. 			}

  319. 		}

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

  321. 		endpoint0_stall();

  322. 		return;

  323. #if defined(CDC_STATUS_INTERFACE)

  324. 	  case 0x2221: // CDC_SET_CONTROL_LINE_STATE

  325. 		usb_cdc_line_rtsdtr = setup.wValue;

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

  327. 		break;

  328. 	  case 0x2321: // CDC_SEND_BREAK

  329. 		break;

  330. 	  case 0x2021: // CDC_SET_LINE_CODING

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

  332. 		return;

  333. #endif

  334. 

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

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

  337. 	  case 0x0921: // HID SET_REPORT

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

  339. 		return;

  340. 	  case 0x0A21: // HID SET_IDLE

  341. 		break;

  342. 	  // case 0xC940:

  343. #endif

  344. 	  default:

  345. 		endpoint0_stall();

  346. 		return;

  347. 	}

  348. 	send:

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

  350. 	//serial_phex32(data);

  351. 	//serial_print(",");

  352. 	//serial_phex16(datalen);

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

  354. 

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

  356. 	size = datalen;

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

  358. 	endpoint0_transmit(data, size);

  359. 	data += size;

  360. 	datalen -= size;

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

  362. 

  363. 	size = datalen;

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

  365. 	endpoint0_transmit(data, size);

  366. 	data += size;

  367. 	datalen -= size;

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

  369. 

  370. 	ep0_tx_ptr = data;

  371. 	ep0_tx_len = datalen;

  372. }

  373. 

  374. 

  375. 

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

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

  378. //Sections 9.1.1.5 and 9.4.5).

  379. 

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

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

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

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

  384. 

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

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

  387. //data toggle being reinitialized to DATA0.

  388. 

  389. 

  390. 

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

  392. 

  393. static void usb_control(uint32_t stat)

  394. {

  395. 	bdt_t *b;

  396. 	uint32_t pid, size;

  397. 	uint8_t *buf;

  398. 	const uint8_t *data;

  399. 

  400. 	b = stat2bufferdescriptor(stat);

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

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

  403. 	buf = b->addr;

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

  405. 	//serial_phex(pid);

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

  407. 	//serial_phex(count);

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

  409. 

  410. 	switch (pid) {

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

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

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

  414. 		// grab the 8 byte setup info

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

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

  417. 

  418. 		// give the buffer back

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

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

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

  422. 

  423. 		// clear any leftover pending IN transactions

  424. 		ep0_tx_ptr = NULL;

  425. 		if (ep0_tx_data_toggle) {

  426. 		}

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

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

  429. 		//}

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

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

  432. 		//}

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

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

  435. 		// first IN after Setup is always DATA1

  436. 		ep0_tx_data_toggle = 1;

  437. 

  438. #if 0

  439. 		serial_print("bmRequestType:");

  440. 		serial_phex(setup.bmRequestType);

  441. 		serial_print(", bRequest:");

  442. 		serial_phex(setup.bRequest);

  443. 		serial_print(", wValue:");

  444. 		serial_phex16(setup.wValue);

  445. 		serial_print(", wIndex:");

  446. 		serial_phex16(setup.wIndex);

  447. 		serial_print(", len:");

  448. 		serial_phex16(setup.wLength);

  449. 		serial_print("\n");

  450. #endif

  451. 		// actually "do" the setup request

  452. 		usb_setup();

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

  454. 		USB0_CTL = USB_CTL_USBENSOFEN; // clear TXSUSPENDTOKENBUSY bit

  455. 		break;

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

  457. 	case 0x02:

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

  459. #ifdef CDC_STATUS_INTERFACE

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

  461. 			int i;

  462. 			uint8_t *dst = (uint8_t *)usb_cdc_line_coding;

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

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

  465. 				//serial_phex(*buf);

  466. 				*dst++ = *buf++;

  467. 			}

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

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

  470. 			if (usb_cdc_line_coding[0] == 134) usb_reboot_timer = 15;

  471. 			endpoint0_transmit(NULL, 0);

  472. 		}

  473. #endif

  474. #ifdef KEYBOARD_INTERFACE

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

  476. 			keyboard_leds = buf[0];

  477. 			endpoint0_transmit(NULL, 0);

  478. 		}

  479. #endif

  480. #ifdef SEREMU_INTERFACE

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

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

  483. 			usb_reboot_timer = 5;

  484. 			endpoint0_transmit(NULL, 0);

  485. 		}

  486. #endif

  487. 		// give the buffer back

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

  489. 		break;

  490. 

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

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

  493. 		//serial_phex(stat);

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

  495. 

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

  497. 		data = ep0_tx_ptr;

  498. 		if (data) {

  499. 			size = ep0_tx_len;

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

  501. 			endpoint0_transmit(data, size);

  502. 			data += size;

  503. 			ep0_tx_len -= size;

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

  505. 		}

  506. 

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

  508. 			setup.bRequest = 0;

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

  510. 			//serial_phex16(setup.wValue);

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

  512. 			USB0_ADDR = setup.wValue;

  513. 		}

  514. 

  515. 		break;

  516. 	//default:

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

  518. 		//serial_phex(pid);

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

  520. 	}

  521. 	USB0_CTL = USB_CTL_USBENSOFEN; // clear TXSUSPENDTOKENBUSY bit

  522. }

  523. 

  524. 

  525. 

  526. 

  527. 

  528. 

  529. usb_packet_t *usb_rx(uint32_t endpoint)

  530. {

  531. 	usb_packet_t *ret;

  532. 	endpoint--;

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

  534. 	__disable_irq();

  535. 	ret = rx_first[endpoint];

  536. 	if (ret) {

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

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

  539. 	}

  540. 	__enable_irq();

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

  542. 	//serial_phex(endpoint);

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

  544. 	//serial_phex32(ret);

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

  546. 	return ret;

  547. }

  548. 

  549. static uint32_t usb_queue_byte_count(const usb_packet_t *p)

  550. {

  551. 	uint32_t count=0;

  552. 

  553. 	__disable_irq();

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

  555. 		count += p->len;

  556. 	}

  557. 	__enable_irq();

  558. 	return count;

  559. }

  560. 

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

  562. /*

  563. uint32_t usb_rx_byte_count(uint32_t endpoint)

  564. {

  565. 	endpoint--;

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

  567. 	return usb_rx_byte_count_data[endpoint];

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

  569. }

  570. */

  571. 

  572. uint32_t usb_tx_byte_count(uint32_t endpoint)

  573. {

  574. 	endpoint--;

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

  576. 	return usb_queue_byte_count(tx_first[endpoint]);

  577. }

  578. 

  579. uint32_t usb_tx_packet_count(uint32_t endpoint)

  580. {

  581. 	const usb_packet_t *p;

  582. 	uint32_t count=0;

  583. 

  584. 	endpoint--;

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

  586. 	__disable_irq();

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

  588. 	__enable_irq();

  589. 	return count;

  590. }

  591. 

  592. 

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

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

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

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

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

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

  599. // first endpoint needing memory.

  600. //

  601. void usb_rx_memory(usb_packet_t *packet)

  602. {

  603. 	unsigned int i;

  604. 	const uint8_t *cfg;

  605. 

  606. 	cfg = usb_endpoint_config_table;

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

  608. 	__disable_irq();

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

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

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

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

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

  614. 				usb_rx_memory_needed--;

  615. 				__enable_irq();

  616. 				//serial_phex(i);

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

  618. 				return;

  619. 			}

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

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

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

  623. 				usb_rx_memory_needed--;

  624. 				__enable_irq();

  625. 				//serial_phex(i);

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

  627. 				return;

  628. 			}

  629. 		}

  630. 	}

  631. 	__enable_irq();

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

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

  634. 	// was actually needed.

  635. 	usb_rx_memory_needed = 0;

  636. 	usb_free(packet);

  637. 	return;

  638. }

  639. 

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

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

  642. 

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

  644. {

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

  646. 	uint8_t next;

  647. 

  648. 	endpoint--;

  649. 	if (endpoint >= NUM_ENDPOINTS) return;

  650. 	__disable_irq();

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

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

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

  654. 	switch (tx_state[endpoint]) {

  655. 	  case TX_STATE_BOTH_FREE_EVEN_FIRST:

  656. 		next = TX_STATE_ODD_FREE;

  657. 		break;

  658. 	  case TX_STATE_BOTH_FREE_ODD_FIRST:

  659. 		b++;

  660. 		next = TX_STATE_EVEN_FREE;

  661. 		break;

  662. 	  case TX_STATE_EVEN_FREE:

  663. 		next = TX_STATE_NONE_FREE_ODD_FIRST;

  664. 		break;

  665. 	  case TX_STATE_ODD_FREE:

  666. 		b++;

  667. 		next = TX_STATE_NONE_FREE_EVEN_FIRST;

  668. 		break;

  669. 	  default:

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

  671. 			tx_first[endpoint] = packet;

  672. 		} else {

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

  674. 		}

  675. 		tx_last[endpoint] = packet;

  676. 		__enable_irq();

  677. 		return;

  678. 	}

  679. 	tx_state[endpoint] = next;

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

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

  682. 	__enable_irq();

  683. }

  684. 

  685. 

  686. 

  687. 

  688. 

  689. 

  690. void _reboot_Teensyduino_(void)

  691. {

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

  693. 	__asm__ volatile("bkpt");

  694. }

  695. 

  696. 

  697. 

  698. void usb_isr(void)

  699. {

  700. 	uint8_t status, stat, t;

  701. 

  702. 	//serial_print("isr");

  703. 	//status = USB0_ISTAT;

  704. 	//serial_phex(status);

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

  706. 	restart:

  707. 	status = USB0_ISTAT;

  708. 

  709. 	if ((status & USB_INTEN_SOFTOKEN /* 04 */ )) {

  710. 		if (usb_configuration) {

  711. 			t = usb_reboot_timer;

  712. 			if (t) {

  713. 				usb_reboot_timer = --t;

  714. 				if (!t) _reboot_Teensyduino_();

  715. 			}

  716. #ifdef CDC_DATA_INTERFACE

  717. 			t = usb_cdc_transmit_flush_timer;

  718. 			if (t) {

  719. 				usb_cdc_transmit_flush_timer = --t;

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

  721. 			}

  722. #endif

  723. #ifdef SEREMU_INTERFACE

  724. 			t = usb_seremu_transmit_flush_timer;

  725. 			if (t) {

  726. 				usb_seremu_transmit_flush_timer = --t;

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

  728. 			}

  729. #endif

  730. #ifdef MIDI_INTERFACE

  731.                         usb_midi_flush_output();

  732. #endif

  733. #ifdef FLIGHTSIM_INTERFACE

  734. 			usb_flightsim_flush_callback();

  735. #endif

  736. 		}

  737. 		USB0_ISTAT = USB_INTEN_SOFTOKEN;

  738. 	}

  739. 

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

  741. 		uint8_t endpoint;

  742. 		stat = USB0_STAT;

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

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

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

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

  747. 		endpoint = stat >> 4;

  748. 		if (endpoint == 0) {

  749. 			usb_control(stat);

  750. 		} else {

  751. 			bdt_t *b = stat2bufferdescriptor(stat);

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

  753. #if 0

  754. 			serial_print("ep:");

  755. 			serial_phex(endpoint);

  756. 			serial_print(", pid:");

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

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

  759. 			serial_print(", count:");

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

  761. 			serial_print("\n");

  762. #endif

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

  764. 

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

  766. 				usb_free(packet);

  767. 				packet = tx_first[endpoint];

  768. 				if (packet) {

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

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

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

  772. 					switch (tx_state[endpoint]) {

  773. 					  case TX_STATE_BOTH_FREE_EVEN_FIRST:

  774. 						tx_state[endpoint] = TX_STATE_ODD_FREE;

  775. 						break;

  776. 					  case TX_STATE_BOTH_FREE_ODD_FIRST:

  777. 						tx_state[endpoint] = TX_STATE_EVEN_FREE;

  778. 						break;

  779. 					  case TX_STATE_EVEN_FREE:

  780. 						tx_state[endpoint] = TX_STATE_NONE_FREE_ODD_FIRST;

  781. 						break;

  782. 					  case TX_STATE_ODD_FREE:

  783. 						tx_state[endpoint] = TX_STATE_NONE_FREE_EVEN_FIRST;

  784. 						break;

  785. 					  default:

  786. 						break;

  787. 					}

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

  789. 				} else {

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

  791. 					switch (tx_state[endpoint]) {

  792. 					  case TX_STATE_BOTH_FREE_EVEN_FIRST:

  793. 					  case TX_STATE_BOTH_FREE_ODD_FIRST:

  794. 						break;

  795. 					  case TX_STATE_EVEN_FREE:

  796. 						tx_state[endpoint] = TX_STATE_BOTH_FREE_EVEN_FIRST;

  797. 						break;

  798. 					  case TX_STATE_ODD_FREE:

  799. 						tx_state[endpoint] = TX_STATE_BOTH_FREE_ODD_FIRST;

  800. 						break;

  801. 					  default:

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

  803. 						  TX_STATE_ODD_FREE : TX_STATE_EVEN_FREE;

  804. 						break;

  805. 					}

  806. 				}

  807. 			} else { // receive

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

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

  810. 					packet->index = 0;

  811. 					packet->next = NULL;

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

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

  814. 						//serial_phex(endpoint);

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

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

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

  818. 						rx_first[endpoint] = packet;

  819. 					} else {

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

  821. 						//serial_phex(endpoint);

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

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

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

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

  826. 					}

  827. 					rx_last[endpoint] = packet;

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

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

  830. 					// so a flood of incoming data on 1 endpoint doesn't starve

  831. 					// the others if the user isn't reading it regularly

  832. 					packet = usb_malloc();

  833. 					if (packet) {

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

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

  836. 					} else {

  837. 						//serial_print("starving ");

  838. 						//serial_phex(endpoint + 1);

  839. 						//serial_print(((uint32_t)b & 8) ? ",odd\n" : ",even\n");

  840. 						b->desc = 0;

  841. 						usb_rx_memory_needed++;

  842. 					}

  843. 				} else {

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

  845. 				}

  846. 			}

  847. 

  848. 

  849. 

  850. 

  851. 		}

  852. 		USB0_ISTAT = USB_ISTAT_TOKDNE;

  853. 		goto restart;

  854. 	}

  855. 

  856. 

  857. 

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

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

  860. 

  861. 		// initialize BDT toggle bits

  862. 		USB0_CTL = USB_CTL_ODDRST;

  863. 		ep0_tx_bdt_bank = 0;

  864. 

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

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

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

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

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

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

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

  872. 

  873. 		// activate endpoint 0

  874. 		USB0_ENDPT0 = USB_ENDPT_EPRXEN | USB_ENDPT_EPTXEN | USB_ENDPT_EPHSHK;

  875. 

  876. 		// clear all ending interrupts

  877. 		USB0_ERRSTAT = 0xFF;

  878. 		USB0_ISTAT = 0xFF;

  879. 

  880. 		// set the address to zero during enumeration

  881. 		USB0_ADDR = 0;

  882. 

  883. 		// enable other interrupts

  884. 		USB0_ERREN = 0xFF;

  885. 		USB0_INTEN = USB_INTEN_TOKDNEEN |

  886. 			USB_INTEN_SOFTOKEN |

  887. 			USB_INTEN_STALLEN |

  888. 			USB_INTEN_ERROREN |

  889. 			USB_INTEN_USBRSTEN |

  890. 			USB_INTEN_SLEEPEN;

  891. 

  892. 		// is this necessary?

  893. 		USB0_CTL = USB_CTL_USBENSOFEN;

  894. 		return;

  895. 	}

  896. 

  897. 

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

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

  900. 		USB0_ENDPT0 = USB_ENDPT_EPRXEN | USB_ENDPT_EPTXEN | USB_ENDPT_EPHSHK;

  901. 		USB0_ISTAT = USB_ISTAT_STALL;

  902. 	}

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

  904. 		uint8_t err = USB0_ERRSTAT;

  905. 		USB0_ERRSTAT = err;

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

  907. 		//serial_phex(err);

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

  909. 		USB0_ISTAT = USB_ISTAT_ERROR;

  910. 	}

  911. 

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

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

  914. 		USB0_ISTAT = USB_ISTAT_SLEEP;

  915. 	}

  916. 

  917. }

  918. 

  919. 

  920. 

  921. void usb_init(void)

  922. {

  923. 	int i;

  924. 

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

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

  927. 

  928. 	usb_init_serialnumber();

  929. 

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

  931. 		table[i].desc = 0;

  932. 		table[i].addr = 0;

  933. 	}

  934. 

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

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

  937. 

  938. 	// assume 48 MHz clock already running

  939. 	// SIM - enable clock

  940. 	SIM_SCGC4 |= SIM_SCGC4_USBOTG;

  941. 

  942. 	// reset USB module

  943. 	USB0_USBTRC0 = USB_USBTRC_USBRESET;

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

  945. 

  946. 	// set desc table base addr

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

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

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

  950. 

  951. 	// clear all ISR flags

  952. 	USB0_ISTAT = 0xFF;

  953. 	USB0_ERRSTAT = 0xFF;

  954. 	USB0_OTGISTAT = 0xFF;

  955. 

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

  957. 

  958. 	// enable USB

  959. 	USB0_CTL = USB_CTL_USBENSOFEN;

  960. 	USB0_USBCTRL = 0;

  961. 

  962. 	// enable reset interrupt

  963. 	USB0_INTEN = USB_INTEN_USBRSTEN;

  964. 

  965. 	// enable interrupt in NVIC...

  966. 	NVIC_SET_PRIORITY(IRQ_USBOTG, 112);

  967. 	NVIC_ENABLE_IRQ(IRQ_USBOTG);

  968. 

  969. 	// enable d+ pullup

  970. 	USB0_CONTROL = USB_CONTROL_DPPULLUPNONOTG;

  971. }

  972. 

  973. 

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

  975. 

  976. void usb_init(void)

  977. {

  978. }

  979. 

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