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

973 lines
25KB
Raw Blame History 

  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 "mk20dx128.h"

  32. //#include "HardwareSerial.h"

  33. #include "usb_dev.h"

  34. #include "usb_mem.h"

  35. 

  36. // buffer descriptor table

  37. 

  38. typedef struct {

  39. 	uint32_t desc;

  40. 	void * addr;

  41. } bdt_t;

  42. 

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

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

  45. 

  46. static usb_packet_t *rx_first[NUM_ENDPOINTS];

  47. static usb_packet_t *rx_last[NUM_ENDPOINTS];

  48. static usb_packet_t *tx_first[NUM_ENDPOINTS];

  49. static usb_packet_t *tx_last[NUM_ENDPOINTS];

  50. uint16_t usb_rx_byte_count_data[NUM_ENDPOINTS];

  51. 

  52. static uint8_t tx_state[NUM_ENDPOINTS];

  53. #define TX_STATE_BOTH_FREE_EVEN_FIRST	0

  54. #define TX_STATE_BOTH_FREE_ODD_FIRST	1

  55. #define TX_STATE_EVEN_FREE		2

  56. #define TX_STATE_ODD_FREE		3

  57. #define TX_STATE_NONE_FREE_EVEN_FIRST	4

  58. #define TX_STATE_NONE_FREE_ODD_FIRST	5

  59. 

  60. #define BDT_OWN		0x80

  61. #define BDT_DATA1	0x40

  62. #define BDT_DATA0	0x00

  63. #define BDT_DTS		0x08

  64. #define BDT_STALL	0x04

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

  66. 

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

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

  69. 				| ((count) << 16))

  70. 

  71. #define TX   1

  72. #define RX   0

  73. #define ODD  1

  74. #define EVEN 0

  75. #define DATA0 0

  76. #define DATA1 1

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

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

  79. 

  80. 

  81. static union {

  82.  struct {

  83.   union {

  84.    struct {

  85. 	uint8_t bmRequestType;

  86. 	uint8_t bRequest;

  87.    };

  88. 	uint16_t wRequestAndType;

  89.   };

  90. 	uint16_t wValue;

  91. 	uint16_t wIndex;

  92. 	uint16_t wLength;

  93.  };

  94.  struct {

  95. 	uint32_t word1;

  96. 	uint32_t word2;

  97.  };

  98. } setup;

  99. 

  100. 

  101. #define GET_STATUS		0

  102. #define CLEAR_FEATURE		1

  103. #define SET_FEATURE		3

  104. #define SET_ADDRESS		5

  105. #define GET_DESCRIPTOR		6

  106. #define SET_DESCRIPTOR		7

  107. #define GET_CONFIGURATION	8

  108. #define SET_CONFIGURATION	9

  109. #define GET_INTERFACE		10

  110. #define SET_INTERFACE		11

  111. #define SYNCH_FRAME		12

  112. 

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

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

  115. // Status stage uses a DATA1 PID.

  116. 

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

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

  119. static const uint8_t *ep0_tx_ptr = NULL;

  120. static uint16_t ep0_tx_len;

  121. static uint8_t ep0_tx_bdt_bank = 0;

  122. static uint8_t ep0_tx_data_toggle = 0;

  123. uint8_t usb_rx_memory_needed = 0;

  124. 

  125. volatile uint8_t usb_configuration = 0;

  126. volatile uint8_t usb_reboot_timer = 0;

  127. 

  128. 

  129. static void endpoint0_stall(void)

  130. {

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

  132. }

  133. 

  134. 

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

  136. {

  137. #if 0

  138. 	serial_print("tx0:");

  139. 	serial_phex32((uint32_t)data);

  140. 	serial_print(",");

  141. 	serial_phex16(len);

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

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

  144. #endif

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

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

  147. 	ep0_tx_data_toggle ^= 1;

  148. 	ep0_tx_bdt_bank ^= 1;

  149. }

  150. 

  151. static uint8_t reply_buffer[8];

  152. 

  153. static void usb_setup(void)

  154. {

  155. 	const uint8_t *data = NULL;

  156. 	uint32_t datalen = 0;

  157. 	const usb_descriptor_list_t *list;

  158. 	uint32_t size;

  159. 	volatile uint8_t *reg;

  160. 	uint8_t epconf;

  161. 	const uint8_t *cfg;

  162. 	int i;

  163. 

  164. 	switch (setup.wRequestAndType) {

  165. 	  case 0x0500: // SET_ADDRESS

  166. 		break;

  167. 	  case 0x0900: // SET_CONFIGURATION

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

  169. 		usb_configuration = setup.wValue;

  170. 		reg = &USB0_ENDPT1;

  171. 		cfg = usb_endpoint_config_table;

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

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

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

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

  176. 			}

  177. 		}

  178. 		// free all queued packets

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

  180. 			usb_packet_t *p, *n;

  181. 			p = rx_first[i];

  182. 			while (p) {

  183. 				n = p->next;

  184. 				usb_free(p);

  185. 				p = n;

  186. 			}

  187. 			rx_first[i] = NULL;

  188. 			rx_last[i] = NULL;

  189. 			p = tx_first[i];

  190. 			while (p) {

  191. 				n = p->next;

  192. 				usb_free(p);

  193. 				p = n;

  194. 			}

  195. 			tx_first[i] = NULL;

  196. 			tx_last[i] = NULL;

  197. 			usb_rx_byte_count_data[i] = 0;

  198. 			switch (tx_state[i]) {

  199. 			  case TX_STATE_EVEN_FREE:

  200. 			  case TX_STATE_NONE_FREE_EVEN_FIRST:

  201. 				tx_state[i] = TX_STATE_BOTH_FREE_EVEN_FIRST;

  202. 				break;

  203. 			  case TX_STATE_ODD_FREE:

  204. 			  case TX_STATE_NONE_FREE_ODD_FIRST:

  205. 				tx_state[i] = TX_STATE_BOTH_FREE_ODD_FIRST;

  206. 				break;

  207. 			  default:

  208. 				break;

  209. 			}

  210. 		}

  211. 		usb_rx_memory_needed = 0;

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

  213. 			epconf = *cfg++;

  214. 			*reg = epconf;

  215. 			reg += 4;

  216. 			if (epconf & USB_ENDPT_EPRXEN) {

  217. 				usb_packet_t *p;

  218. 				p = usb_malloc();

  219. 				if (p) {

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

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

  222. 				} else {

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

  224. 					usb_rx_memory_needed++;

  225. 				}

  226. 				p = usb_malloc();

  227. 				if (p) {

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

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

  230. 				} else {

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

  232. 					usb_rx_memory_needed++;

  233. 				}

  234. 			}

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

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

  237. 		}

  238. 		break;

  239. 	  case 0x0880: // GET_CONFIGURATION

  240. 		reply_buffer[0] = usb_configuration;

  241. 		datalen = 1;

  242. 		data = reply_buffer;

  243. 		break;

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

  245. 		reply_buffer[0] = 0;

  246. 		reply_buffer[1] = 0;

  247. 		datalen = 2;

  248. 		data = reply_buffer;

  249. 		break;

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

  251. 		if (setup.wIndex > NUM_ENDPOINTS) {

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

  253. 			endpoint0_stall();

  254. 			return;

  255. 		}

  256. 		reply_buffer[0] = 0;

  257. 		reply_buffer[1] = 0;

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

  259. 		data = reply_buffer;

  260. 		datalen = 2;

  261. 		break;

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

  263. 		i = setup.wIndex & 0x7F;

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

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

  266. 			endpoint0_stall();

  267. 			return;

  268. 		}

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

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

  271. 		break;

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

  273. 		i = setup.wIndex & 0x7F;

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

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

  276. 			endpoint0_stall();

  277. 			return;

  278. 		}

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

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

  281. 		break;

  282. 	  case 0x0680: // GET_DESCRIPTOR

  283. 	  case 0x0681:

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

  285. 		//serial_phex16(setup.wValue);

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

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

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

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

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

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

  292. 				data = list->addr;

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

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

  295. 					// length field, allowing runtime configured

  296. 					// length.

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

  298. 				} else {

  299. 					datalen = list->length;

  300. 				}

  301. #if 0

  302. 				serial_print("Desc found, ");

  303. 				serial_phex32((uint32_t)data);

  304. 				serial_print(",");

  305. 				serial_phex16(datalen);

  306. 				serial_print(",");

  307. 				serial_phex(data[0]);

  308. 				serial_phex(data[1]);

  309. 				serial_phex(data[2]);

  310. 				serial_phex(data[3]);

  311. 				serial_phex(data[4]);

  312. 				serial_phex(data[5]);

  313. 				serial_print("\n");

  314. #endif

  315. 				goto send;

  316. 			}

  317. 		}

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

  319. 		endpoint0_stall();

  320. 		return;

  321. #if defined(CDC_STATUS_INTERFACE)

  322. 	  case 0x2221: // CDC_SET_CONTROL_LINE_STATE

  323. 		usb_cdc_line_rtsdtr = setup.wValue;

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

  325. 		break;

  326. 	  case 0x2321: // CDC_SEND_BREAK

  327. 		break;

  328. 	  case 0x2021: // CDC_SET_LINE_CODING

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

  330. 		return;

  331. #endif

  332. 

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

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

  335. 	  case 0x0921: // HID SET_REPORT

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

  337. 		return;

  338. 	  case 0x0A21: // HID SET_IDLE

  339. 		break;

  340. 	  // case 0xC940:

  341. #endif

  342. 	  default:

  343. 		endpoint0_stall();

  344. 		return;

  345. 	}

  346. 	send:

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

  348. 	//serial_phex32(data);

  349. 	//serial_print(",");

  350. 	//serial_phex16(datalen);

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

  352. 

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

  354. 	size = datalen;

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

  356. 	endpoint0_transmit(data, size);

  357. 	data += size;

  358. 	datalen -= size;

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

  360. 

  361. 	size = datalen;

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

  363. 	endpoint0_transmit(data, size);

  364. 	data += size;

  365. 	datalen -= size;

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

  367. 

  368. 	ep0_tx_ptr = data;

  369. 	ep0_tx_len = datalen;

  370. }

  371. 

  372. 

  373. 

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

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

  376. //Sections 9.1.1.5 and 9.4.5).

  377. 

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

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

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

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

  382. 

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

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

  385. //data toggle being reinitialized to DATA0.

  386. 

  387. 

  388. 

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

  390. 

  391. static void usb_control(uint32_t stat)

  392. {

  393. 	bdt_t *b;

  394. 	uint32_t pid, size;

  395. 	uint8_t *buf;

  396. 	const uint8_t *data;

  397. 

  398. 	b = stat2bufferdescriptor(stat);

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

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

  401. 	buf = b->addr;

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

  403. 	//serial_phex(pid);

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

  405. 	//serial_phex(count);

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

  407. 

  408. 	switch (pid) {

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

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

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

  412. 		// grab the 8 byte setup info

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

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

  415. 

  416. 		// give the buffer back

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

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

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

  420. 

  421. 		// clear any leftover pending IN transactions

  422. 		ep0_tx_ptr = NULL;

  423. 		if (ep0_tx_data_toggle) {

  424. 		}

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

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

  427. 		//}

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

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

  430. 		//}

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

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

  433. 		// first IN after Setup is always DATA1

  434. 		ep0_tx_data_toggle = 1;

  435. 

  436. #if 0

  437. 		serial_print("bmRequestType:");

  438. 		serial_phex(setup.bmRequestType);

  439. 		serial_print(", bRequest:");

  440. 		serial_phex(setup.bRequest);

  441. 		serial_print(", wValue:");

  442. 		serial_phex16(setup.wValue);

  443. 		serial_print(", wIndex:");

  444. 		serial_phex16(setup.wIndex);

  445. 		serial_print(", len:");

  446. 		serial_phex16(setup.wLength);

  447. 		serial_print("\n");

  448. #endif

  449. 		// actually "do" the setup request

  450. 		usb_setup();

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

  452. 		USB0_CTL = USB_CTL_USBENSOFEN; // clear TXSUSPENDTOKENBUSY bit

  453. 		break;

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

  455. 	case 0x02:

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

  457. #ifdef CDC_STATUS_INTERFACE

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

  459. 			int i;

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

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

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

  463. 				//serial_phex(*buf);

  464. 				*dst++ = *buf++;

  465. 			}

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

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

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

  469. 			endpoint0_transmit(NULL, 0);

  470. 		}

  471. #endif

  472. #ifdef KEYBOARD_INTERFACE

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

  474. 			keyboard_leds = buf[0];

  475. 			endpoint0_transmit(NULL, 0);

  476. 		}

  477. #endif

  478. #ifdef SEREMU_INTERFACE

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

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

  481. 			usb_reboot_timer = 5;

  482. 			endpoint0_transmit(NULL, 0);

  483. 		}

  484. #endif

  485. 		// give the buffer back

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

  487. 		break;

  488. 

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

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

  491. 		//serial_phex(stat);

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

  493. 

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

  495. 		data = ep0_tx_ptr;

  496. 		if (data) {

  497. 			size = ep0_tx_len;

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

  499. 			endpoint0_transmit(data, size);

  500. 			data += size;

  501. 			ep0_tx_len -= size;

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

  503. 		}

  504. 

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

  506. 			setup.bRequest = 0;

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

  508. 			//serial_phex16(setup.wValue);

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

  510. 			USB0_ADDR = setup.wValue;

  511. 		}

  512. 

  513. 		break;

  514. 	//default:

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

  516. 		//serial_phex(pid);

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

  518. 	}

  519. 	USB0_CTL = USB_CTL_USBENSOFEN; // clear TXSUSPENDTOKENBUSY bit

  520. }

  521. 

  522. 

  523. 

  524. 

  525. 

  526. 

  527. usb_packet_t *usb_rx(uint32_t endpoint)

  528. {

  529. 	usb_packet_t *ret;

  530. 	endpoint--;

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

  532. 	__disable_irq();

  533. 	ret = rx_first[endpoint];

  534. 	if (ret) {

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

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

  537. 	}

  538. 	__enable_irq();

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

  540. 	//serial_phex(endpoint);

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

  542. 	//serial_phex32(ret);

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

  544. 	return ret;

  545. }

  546. 

  547. static uint32_t usb_queue_byte_count(const usb_packet_t *p)

  548. {

  549. 	uint32_t count=0;

  550. 

  551. 	__disable_irq();

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

  553. 		count += p->len;

  554. 	}

  555. 	__enable_irq();

  556. 	return count;

  557. }

  558. 

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

  560. /*

  561. uint32_t usb_rx_byte_count(uint32_t endpoint)

  562. {

  563. 	endpoint--;

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

  565. 	return usb_rx_byte_count_data[endpoint];

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

  567. }

  568. */

  569. 

  570. uint32_t usb_tx_byte_count(uint32_t endpoint)

  571. {

  572. 	endpoint--;

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

  574. 	return usb_queue_byte_count(tx_first[endpoint]);

  575. }

  576. 

  577. uint32_t usb_tx_packet_count(uint32_t endpoint)

  578. {

  579. 	const usb_packet_t *p;

  580. 	uint32_t count=0;

  581. 

  582. 	endpoint--;

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

  584. 	__disable_irq();

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

  586. 	__enable_irq();

  587. 	return count;

  588. }

  589. 

  590. 

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

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

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

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

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

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

  597. // first endpoint needing memory.

  598. //

  599. void usb_rx_memory(usb_packet_t *packet)

  600. {

  601. 	unsigned int i;

  602. 	const uint8_t *cfg;

  603. 

  604. 	cfg = usb_endpoint_config_table;

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

  606. 	__disable_irq();

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

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

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

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

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

  612. 				usb_rx_memory_needed--;

  613. 				__enable_irq();

  614. 				//serial_phex(i);

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

  616. 				return;

  617. 			}

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

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

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

  621. 				usb_rx_memory_needed--;

  622. 				__enable_irq();

  623. 				//serial_phex(i);

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

  625. 				return;

  626. 			}

  627. 		}

  628. 	}

  629. 	__enable_irq();

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

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

  632. 	// was actually needed.

  633. 	usb_rx_memory_needed = 0;

  634. 	usb_free(packet);

  635. 	return;

  636. }

  637. 

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

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

  640. 

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

  642. {

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

  644. 	uint8_t next;

  645. 

  646. 	endpoint--;

  647. 	if (endpoint >= NUM_ENDPOINTS) return;

  648. 	__disable_irq();

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

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

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

  652. 	switch (tx_state[endpoint]) {

  653. 	  case TX_STATE_BOTH_FREE_EVEN_FIRST:

  654. 		next = TX_STATE_ODD_FREE;

  655. 		break;

  656. 	  case TX_STATE_BOTH_FREE_ODD_FIRST:

  657. 		b++;

  658. 		next = TX_STATE_EVEN_FREE;

  659. 		break;

  660. 	  case TX_STATE_EVEN_FREE:

  661. 		next = TX_STATE_NONE_FREE_ODD_FIRST;

  662. 		break;

  663. 	  case TX_STATE_ODD_FREE:

  664. 		b++;

  665. 		next = TX_STATE_NONE_FREE_EVEN_FIRST;

  666. 		break;

  667. 	  default:

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

  669. 			tx_first[endpoint] = packet;

  670. 		} else {

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

  672. 		}

  673. 		tx_last[endpoint] = packet;

  674. 		__enable_irq();

  675. 		return;

  676. 	}

  677. 	tx_state[endpoint] = next;

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

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

  680. 	__enable_irq();

  681. }

  682. 

  683. 

  684. 

  685. 

  686. 

  687. 

  688. void _reboot_Teensyduino_(void)

  689. {

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

  691. 	__asm__ volatile("bkpt");

  692. }

  693. 

  694. 

  695. 

  696. void usb_isr(void)

  697. {

  698. 	uint8_t status, stat, t;

  699. 

  700. 	//serial_print("isr");

  701. 	//status = USB0_ISTAT;

  702. 	//serial_phex(status);

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

  704. 	restart:

  705. 	status = USB0_ISTAT;

  706. 

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

  708. 		if (usb_configuration) {

  709. 			t = usb_reboot_timer;

  710. 			if (t) {

  711. 				usb_reboot_timer = --t;

  712. 				if (!t) _reboot_Teensyduino_();

  713. 			}

  714. #ifdef CDC_DATA_INTERFACE

  715. 			t = usb_cdc_transmit_flush_timer;

  716. 			if (t) {

  717. 				usb_cdc_transmit_flush_timer = --t;

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

  719. 			}

  720. #endif

  721. #ifdef SEREMU_INTERFACE

  722. 			t = usb_seremu_transmit_flush_timer;

  723. 			if (t) {

  724. 				usb_seremu_transmit_flush_timer = --t;

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

  726. 			}

  727. #endif

  728. #ifdef MIDI_INTERFACE

  729.                         usb_midi_flush_output();

  730. #endif

  731. #ifdef FLIGHTSIM_INTERFACE

  732. 			usb_flightsim_flush_callback();

  733. #endif

  734. 		}

  735. 		USB0_ISTAT = USB_INTEN_SOFTOKEN;

  736. 	}

  737. 

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

  739. 		uint8_t endpoint;

  740. 		stat = USB0_STAT;

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

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

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

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

  745. 		endpoint = stat >> 4;

  746. 		if (endpoint == 0) {

  747. 			usb_control(stat);

  748. 		} else {

  749. 			bdt_t *b = stat2bufferdescriptor(stat);

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

  751. #if 0

  752. 			serial_print("ep:");

  753. 			serial_phex(endpoint);

  754. 			serial_print(", pid:");

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

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

  757. 			serial_print(", count:");

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

  759. 			serial_print("\n");

  760. #endif

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

  762. 

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

  764. 				usb_free(packet);

  765. 				packet = tx_first[endpoint];

  766. 				if (packet) {

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

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

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

  770. 					switch (tx_state[endpoint]) {

  771. 					  case TX_STATE_BOTH_FREE_EVEN_FIRST:

  772. 						tx_state[endpoint] = TX_STATE_ODD_FREE;

  773. 						break;

  774. 					  case TX_STATE_BOTH_FREE_ODD_FIRST:

  775. 						tx_state[endpoint] = TX_STATE_EVEN_FREE;

  776. 						break;

  777. 					  case TX_STATE_EVEN_FREE:

  778. 						tx_state[endpoint] = TX_STATE_NONE_FREE_ODD_FIRST;

  779. 						break;

  780. 					  case TX_STATE_ODD_FREE:

  781. 						tx_state[endpoint] = TX_STATE_NONE_FREE_EVEN_FIRST;

  782. 						break;

  783. 					  default:

  784. 						break;

  785. 					}

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

  787. 				} else {

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

  789. 					switch (tx_state[endpoint]) {

  790. 					  case TX_STATE_BOTH_FREE_EVEN_FIRST:

  791. 					  case TX_STATE_BOTH_FREE_ODD_FIRST:

  792. 						break;

  793. 					  case TX_STATE_EVEN_FREE:

  794. 						tx_state[endpoint] = TX_STATE_BOTH_FREE_EVEN_FIRST;

  795. 						break;

  796. 					  case TX_STATE_ODD_FREE:

  797. 						tx_state[endpoint] = TX_STATE_BOTH_FREE_ODD_FIRST;

  798. 						break;

  799. 					  default:

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

  801. 						  TX_STATE_ODD_FREE : TX_STATE_EVEN_FREE;

  802. 						break;

  803. 					}

  804. 				}

  805. 			} else { // receive

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

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

  808. 					packet->index = 0;

  809. 					packet->next = NULL;

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

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

  812. 						//serial_phex(endpoint);

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

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

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

  816. 						rx_first[endpoint] = packet;

  817. 					} else {

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

  819. 						//serial_phex(endpoint);

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

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

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

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

  824. 					}

  825. 					rx_last[endpoint] = packet;

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

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

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

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

  830. 					packet = usb_malloc();

  831. 					if (packet) {

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

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

  834. 					} else {

  835. 						//serial_print("starving ");

  836. 						//serial_phex(endpoint + 1);

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

  838. 						b->desc = 0;

  839. 						usb_rx_memory_needed++;

  840. 					}

  841. 				} else {

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

  843. 				}

  844. 			}

  845. 

  846. 

  847. 

  848. 

  849. 		}

  850. 		USB0_ISTAT = USB_ISTAT_TOKDNE;

  851. 		goto restart;

  852. 	}

  853. 

  854. 

  855. 

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

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

  858. 

  859. 		// initialize BDT toggle bits

  860. 		USB0_CTL = USB_CTL_ODDRST;

  861. 		ep0_tx_bdt_bank = 0;

  862. 

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

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

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

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

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

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

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

  870. 

  871. 		// activate endpoint 0

  872. 		USB0_ENDPT0 = USB_ENDPT_EPRXEN | USB_ENDPT_EPTXEN | USB_ENDPT_EPHSHK;

  873. 

  874. 		// clear all ending interrupts

  875. 		USB0_ERRSTAT = 0xFF;

  876. 		USB0_ISTAT = 0xFF;

  877. 

  878. 		// set the address to zero during enumeration

  879. 		USB0_ADDR = 0;

  880. 

  881. 		// enable other interrupts

  882. 		USB0_ERREN = 0xFF;

  883. 		USB0_INTEN = USB_INTEN_TOKDNEEN |

  884. 			USB_INTEN_SOFTOKEN |

  885. 			USB_INTEN_STALLEN |

  886. 			USB_INTEN_ERROREN |

  887. 			USB_INTEN_USBRSTEN |

  888. 			USB_INTEN_SLEEPEN;

  889. 

  890. 		// is this necessary?

  891. 		USB0_CTL = USB_CTL_USBENSOFEN;

  892. 		return;

  893. 	}

  894. 

  895. 

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

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

  898. 		USB0_ENDPT0 = USB_ENDPT_EPRXEN | USB_ENDPT_EPTXEN | USB_ENDPT_EPHSHK;

  899. 		USB0_ISTAT = USB_ISTAT_STALL;

  900. 	}

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

  902. 		uint8_t err = USB0_ERRSTAT;

  903. 		USB0_ERRSTAT = err;

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

  905. 		//serial_phex(err);

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

  907. 		USB0_ISTAT = USB_ISTAT_ERROR;

  908. 	}

  909. 

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

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

  912. 		USB0_ISTAT = USB_ISTAT_SLEEP;

  913. 	}

  914. 

  915. }

  916. 

  917. 

  918. 

  919. void usb_init(void)

  920. {

  921. 	int i;

  922. 

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

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

  925. 

  926. 	usb_init_serialnumber();

  927. 

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

  929. 		table[i].desc = 0;

  930. 		table[i].addr = 0;

  931. 	}

  932. 

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

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

  935. 

  936. 	// assume 48 MHz clock already running

  937. 	// SIM - enable clock

  938. 	SIM_SCGC4 |= SIM_SCGC4_USBOTG;

  939. 

  940. 	// reset USB module

  941. 	USB0_USBTRC0 = USB_USBTRC_USBRESET;

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

  943. 

  944. 	// set desc table base addr

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

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

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

  948. 

  949. 	// clear all ISR flags

  950. 	USB0_ISTAT = 0xFF;

  951. 	USB0_ERRSTAT = 0xFF;

  952. 	USB0_OTGISTAT = 0xFF;

  953. 

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

  955. 

  956. 	// enable USB

  957. 	USB0_CTL = USB_CTL_USBENSOFEN;

  958. 	USB0_USBCTRL = 0;

  959. 

  960. 	// enable reset interrupt

  961. 	USB0_INTEN = USB_INTEN_USBRSTEN;

  962. 

  963. 	// enable interrupt in NVIC...

  964. 	NVIC_SET_PRIORITY(IRQ_USBOTG, 112);

  965. 	NVIC_ENABLE_IRQ(IRQ_USBOTG);

  966. 

  967. 	// enable d+ pullup

  968. 	USB0_CONTROL = USB_CONTROL_DPPULLUPNONOTG;

  969. }

  970. 

  971.