visus
/
teensy-core-4.1
Sledovat 1
Oblíbit 0
Rozštěpit 0
Zdrojový kód Úkoly 0 Požadavky na natažení 0 Vydání 0 Wiki Aktivita
Teensy 4.1 core updated for C++20
Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.
1 Revize
2 Větve
Strom: 5cecdee933
Větve Značky
${ item.name }
Vytvořit větev ${ searchTerm }
z „5cecdee933“
${ noResults }
teensy-core-4.1/teensy3/usb_dev.c

969 lines
25KB
Surový Blame Historie 

  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 0x2021: // CDC_SET_LINE_CODING

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

  328. 		return;

  329. #endif

  330. 

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

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

  333. 	  case 0x0921: // HID SET_REPORT

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

  335. 		return;

  336. 	  case 0x0A21: // HID SET_IDLE

  337. 		break;

  338. 	  // case 0xC940:

  339. #endif

  340. 	  default:

  341. 		endpoint0_stall();

  342. 		return;

  343. 	}

  344. 	send:

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

  346. 	//serial_phex32(data);

  347. 	//serial_print(",");

  348. 	//serial_phex16(datalen);

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

  350. 

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

  352. 	size = datalen;

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

  354. 	endpoint0_transmit(data, size);

  355. 	data += size;

  356. 	datalen -= size;

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

  358. 

  359. 	size = datalen;

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

  361. 	endpoint0_transmit(data, size);

  362. 	data += size;

  363. 	datalen -= size;

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

  365. 

  366. 	ep0_tx_ptr = data;

  367. 	ep0_tx_len = datalen;

  368. }

  369. 

  370. 

  371. 

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

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

  374. //Sections 9.1.1.5 and 9.4.5).

  375. 

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

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

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

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

  380. 

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

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

  383. //data toggle being reinitialized to DATA0.

  384. 

  385. 

  386. 

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

  388. 

  389. static void usb_control(uint32_t stat)

  390. {

  391. 	bdt_t *b;

  392. 	uint32_t pid, size;

  393. 	uint8_t *buf;

  394. 	const uint8_t *data;

  395. 

  396. 	b = stat2bufferdescriptor(stat);

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

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

  399. 	buf = b->addr;

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

  401. 	//serial_phex(pid);

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

  403. 	//serial_phex(count);

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

  405. 

  406. 	switch (pid) {

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

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

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

  410. 		// grab the 8 byte setup info

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

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

  413. 

  414. 		// give the buffer back

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

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

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

  418. 

  419. 		// clear any leftover pending IN transactions

  420. 		ep0_tx_ptr = NULL;

  421. 		if (ep0_tx_data_toggle) {

  422. 		}

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

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

  425. 		//}

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

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

  428. 		//}

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

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

  431. 		// first IN after Setup is always DATA1

  432. 		ep0_tx_data_toggle = 1;

  433. 

  434. #if 0

  435. 		serial_print("bmRequestType:");

  436. 		serial_phex(setup.bmRequestType);

  437. 		serial_print(", bRequest:");

  438. 		serial_phex(setup.bRequest);

  439. 		serial_print(", wValue:");

  440. 		serial_phex16(setup.wValue);

  441. 		serial_print(", wIndex:");

  442. 		serial_phex16(setup.wIndex);

  443. 		serial_print(", len:");

  444. 		serial_phex16(setup.wLength);

  445. 		serial_print("\n");

  446. #endif

  447. 		// actually "do" the setup request

  448. 		usb_setup();

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

  450. 		USB0_CTL = USB_CTL_USBENSOFEN; // clear TXSUSPENDTOKENBUSY bit

  451. 		break;

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

  453. 	case 0x02:

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

  455. #ifdef CDC_STATUS_INTERFACE

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

  457. 			int i;

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

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

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

  461. 				//serial_phex(*buf);

  462. 				*dst++ = *buf++;

  463. 			}

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

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

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

  467. 			endpoint0_transmit(NULL, 0);

  468. 		}

  469. #endif

  470. #ifdef KEYBOARD_INTERFACE

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

  472. 			keyboard_leds = buf[0];

  473. 			endpoint0_transmit(NULL, 0);

  474. 		}

  475. #endif

  476. #ifdef SEREMU_INTERFACE

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

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

  479. 			usb_reboot_timer = 5;

  480. 			endpoint0_transmit(NULL, 0);

  481. 		}

  482. #endif

  483. 		// give the buffer back

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

  485. 		break;

  486. 

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

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

  489. 		//serial_phex(stat);

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

  491. 

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

  493. 		data = ep0_tx_ptr;

  494. 		if (data) {

  495. 			size = ep0_tx_len;

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

  497. 			endpoint0_transmit(data, size);

  498. 			data += size;

  499. 			ep0_tx_len -= size;

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

  501. 		}

  502. 

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

  504. 			setup.bRequest = 0;

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

  506. 			//serial_phex16(setup.wValue);

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

  508. 			USB0_ADDR = setup.wValue;

  509. 		}

  510. 

  511. 		break;

  512. 	//default:

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

  514. 		//serial_phex(pid);

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

  516. 	}

  517. 	USB0_CTL = USB_CTL_USBENSOFEN; // clear TXSUSPENDTOKENBUSY bit

  518. }

  519. 

  520. 

  521. 

  522. 

  523. 

  524. 

  525. usb_packet_t *usb_rx(uint32_t endpoint)

  526. {

  527. 	usb_packet_t *ret;

  528. 	endpoint--;

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

  530. 	__disable_irq();

  531. 	ret = rx_first[endpoint];

  532. 	if (ret) rx_first[endpoint] = ret->next;

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

  534. 	__enable_irq();

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

  536. 	//serial_phex(endpoint);

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

  538. 	//serial_phex32(ret);

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

  540. 	return ret;

  541. }

  542. 

  543. static uint32_t usb_queue_byte_count(const usb_packet_t *p)

  544. {

  545. 	uint32_t count=0;

  546. 

  547. 	__disable_irq();

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

  549. 		count += p->len;

  550. 	}

  551. 	__enable_irq();

  552. 	return count;

  553. }

  554. 

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

  556. /*

  557. uint32_t usb_rx_byte_count(uint32_t endpoint)

  558. {

  559. 	endpoint--;

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

  561. 	return usb_rx_byte_count_data[endpoint];

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

  563. }

  564. */

  565. 

  566. uint32_t usb_tx_byte_count(uint32_t endpoint)

  567. {

  568. 	endpoint--;

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

  570. 	return usb_queue_byte_count(tx_first[endpoint]);

  571. }

  572. 

  573. uint32_t usb_tx_packet_count(uint32_t endpoint)

  574. {

  575. 	const usb_packet_t *p;

  576. 	uint32_t count=0;

  577. 

  578. 	endpoint--;

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

  580. 	__disable_irq();

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

  582. 	__enable_irq();

  583. 	return count;

  584. }

  585. 

  586. 

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

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

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

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

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

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

  593. // first endpoint needing memory.

  594. //

  595. void usb_rx_memory(usb_packet_t *packet)

  596. {

  597. 	unsigned int i;

  598. 	const uint8_t *cfg;

  599. 

  600. 	cfg = usb_endpoint_config_table;

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

  602. 	__disable_irq();

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

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

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

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

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

  608. 				usb_rx_memory_needed--;

  609. 				__enable_irq();

  610. 				//serial_phex(i);

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

  612. 				return;

  613. 			}

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

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

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

  617. 				usb_rx_memory_needed--;

  618. 				__enable_irq();

  619. 				//serial_phex(i);

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

  621. 				return;

  622. 			}

  623. 		}

  624. 	}

  625. 	__enable_irq();

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

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

  628. 	// was actually needed.  

  629. 	usb_rx_memory_needed = 0;

  630. 	usb_free(packet);

  631. 	return;

  632. }

  633. 

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

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

  636. 

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

  638. {

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

  640. 	uint8_t next;

  641. 

  642. 	endpoint--;

  643. 	if (endpoint >= NUM_ENDPOINTS) return;

  644. 	__disable_irq();

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

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

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

  648. 	switch (tx_state[endpoint]) {

  649. 	  case TX_STATE_BOTH_FREE_EVEN_FIRST:

  650. 		next = TX_STATE_ODD_FREE;

  651. 		break;

  652. 	  case TX_STATE_BOTH_FREE_ODD_FIRST:

  653. 		b++;

  654. 		next = TX_STATE_EVEN_FREE;

  655. 		break;

  656. 	  case TX_STATE_EVEN_FREE:

  657. 		next = TX_STATE_NONE_FREE_ODD_FIRST;

  658. 		break;

  659. 	  case TX_STATE_ODD_FREE:

  660. 		b++;

  661. 		next = TX_STATE_NONE_FREE_EVEN_FIRST;

  662. 		break;

  663. 	  default:

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

  665. 			tx_first[endpoint] = packet;

  666. 		} else {

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

  668. 		}

  669. 		tx_last[endpoint] = packet;

  670. 		__enable_irq();

  671. 		return;

  672. 	}

  673. 	tx_state[endpoint] = next;

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

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

  676. 	__enable_irq();

  677. }

  678. 

  679. 

  680. 

  681. 

  682. 

  683. 

  684. void _reboot_Teensyduino_(void)

  685. {

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

  687. 	asm volatile("bkpt");

  688. }

  689. 

  690. 

  691. 

  692. void usb_isr(void)

  693. {

  694. 	uint8_t status, stat, t;

  695. 

  696. 	//serial_print("isr");

  697. 	//status = USB0_ISTAT;

  698. 	//serial_phex(status);

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

  700. 	restart:

  701. 	status = USB0_ISTAT;

  702. 

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

  704. 		if (usb_configuration) {

  705. 			t = usb_reboot_timer;

  706. 			if (t) {

  707. 				usb_reboot_timer = --t;

  708. 				if (!t) _reboot_Teensyduino_();

  709. 			}

  710. #ifdef CDC_DATA_INTERFACE

  711. 			t = usb_cdc_transmit_flush_timer;

  712. 			if (t) {

  713. 				usb_cdc_transmit_flush_timer = --t;

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

  715. 			}

  716. #endif

  717. #ifdef SEREMU_INTERFACE

  718. 			t = usb_seremu_transmit_flush_timer;

  719. 			if (t) {

  720. 				usb_seremu_transmit_flush_timer = --t;

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

  722. 			}

  723. #endif

  724. #ifdef MIDI_INTERFACE

  725.                         usb_midi_flush_output();

  726. #endif

  727. #ifdef FLIGHTSIM_INTERFACE

  728. 			usb_flightsim_flush_callback();

  729. #endif

  730. 		}

  731. 		USB0_ISTAT = USB_INTEN_SOFTOKEN;

  732. 	}

  733. 

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

  735. 		uint8_t endpoint;

  736. 		stat = USB0_STAT;

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

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

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

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

  741. 		endpoint = stat >> 4;

  742. 		if (endpoint == 0) {

  743. 			usb_control(stat);

  744. 		} else {

  745. 			bdt_t *b = stat2bufferdescriptor(stat);

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

  747. #if 0

  748. 			serial_print("ep:");

  749. 			serial_phex(endpoint);

  750. 			serial_print(", pid:");

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

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

  753. 			serial_print(", count:");

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

  755. 			serial_print("\n");

  756. #endif

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

  758. 

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

  760. 				usb_free(packet);

  761. 				packet = tx_first[endpoint];

  762. 				if (packet) {

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

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

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

  766. 					switch (tx_state[endpoint]) {

  767. 					  case TX_STATE_BOTH_FREE_EVEN_FIRST:

  768. 						tx_state[endpoint] = TX_STATE_ODD_FREE;

  769. 						break;

  770. 					  case TX_STATE_BOTH_FREE_ODD_FIRST:

  771. 						tx_state[endpoint] = TX_STATE_EVEN_FREE;

  772. 						break;

  773. 					  case TX_STATE_EVEN_FREE:

  774. 						tx_state[endpoint] = TX_STATE_NONE_FREE_ODD_FIRST;

  775. 						break;

  776. 					  case TX_STATE_ODD_FREE:

  777. 						tx_state[endpoint] = TX_STATE_NONE_FREE_EVEN_FIRST;

  778. 						break;

  779. 					  default:

  780. 						break;

  781. 					}

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

  783. 				} else {

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

  785. 					switch (tx_state[endpoint]) {

  786. 					  case TX_STATE_BOTH_FREE_EVEN_FIRST:

  787. 					  case TX_STATE_BOTH_FREE_ODD_FIRST:

  788. 						break;

  789. 					  case TX_STATE_EVEN_FREE:

  790. 						tx_state[endpoint] = TX_STATE_BOTH_FREE_EVEN_FIRST;

  791. 						break;

  792. 					  case TX_STATE_ODD_FREE:

  793. 						tx_state[endpoint] = TX_STATE_BOTH_FREE_ODD_FIRST;

  794. 						break;

  795. 					  default:

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

  797. 						  TX_STATE_ODD_FREE : TX_STATE_EVEN_FREE;

  798. 						break;

  799. 					}

  800. 				}

  801. 			} else { // receive

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

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

  804. 					packet->index = 0;

  805. 					packet->next = NULL;

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

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

  808. 						//serial_phex(endpoint);

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

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

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

  812. 						rx_first[endpoint] = packet;

  813. 					} else {

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

  815. 						//serial_phex(endpoint);

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

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

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

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

  820. 					}

  821. 					rx_last[endpoint] = packet;

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

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

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

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

  826. 					packet = usb_malloc();

  827. 					if (packet) {

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

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

  830. 					} else {

  831. 						//serial_print("starving ");

  832. 						//serial_phex(endpoint + 1);

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

  834. 						b->desc = 0;

  835. 						usb_rx_memory_needed++;

  836. 					}

  837. 				} else {

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

  839. 				}

  840. 			}

  841. 

  842. 

  843. 

  844. 

  845. 		}

  846. 		USB0_ISTAT = USB_ISTAT_TOKDNE;

  847. 		goto restart;

  848. 	}

  849. 

  850. 

  851. 

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

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

  854. 

  855. 		// initialize BDT toggle bits

  856. 		USB0_CTL = USB_CTL_ODDRST;

  857. 		ep0_tx_bdt_bank = 0;

  858. 

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

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

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

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

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

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

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

  866. 		

  867. 		// activate endpoint 0

  868. 		USB0_ENDPT0 = USB_ENDPT_EPRXEN | USB_ENDPT_EPTXEN | USB_ENDPT_EPHSHK;

  869. 

  870. 		// clear all ending interrupts

  871. 		USB0_ERRSTAT = 0xFF;

  872. 		USB0_ISTAT = 0xFF;

  873. 

  874. 		// set the address to zero during enumeration

  875. 		USB0_ADDR = 0;

  876. 

  877. 		// enable other interrupts

  878. 		USB0_ERREN = 0xFF;

  879. 		USB0_INTEN = USB_INTEN_TOKDNEEN |

  880. 			USB_INTEN_SOFTOKEN |

  881. 			USB_INTEN_STALLEN |

  882. 			USB_INTEN_ERROREN |

  883. 			USB_INTEN_USBRSTEN |

  884. 			USB_INTEN_SLEEPEN;

  885. 

  886. 		// is this necessary?

  887. 		USB0_CTL = USB_CTL_USBENSOFEN;

  888. 		return;

  889. 	}

  890. 

  891. 

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

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

  894. 		USB0_ENDPT0 = USB_ENDPT_EPRXEN | USB_ENDPT_EPTXEN | USB_ENDPT_EPHSHK;

  895. 		USB0_ISTAT = USB_ISTAT_STALL;

  896. 	}

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

  898. 		uint8_t err = USB0_ERRSTAT;

  899. 		USB0_ERRSTAT = err;

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

  901. 		//serial_phex(err);

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

  903. 		USB0_ISTAT = USB_ISTAT_ERROR;

  904. 	}

  905. 

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

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

  908. 		USB0_ISTAT = USB_ISTAT_SLEEP;

  909. 	}

  910. 

  911. }

  912. 

  913. 

  914. 

  915. void usb_init(void)

  916. {

  917. 	int i;

  918. 

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

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

  921. 

  922. 	usb_init_serialnumber();

  923. 

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

  925. 		table[i].desc = 0;

  926. 		table[i].addr = 0;

  927. 	}

  928. 

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

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

  931. 

  932. 	// assume 48 MHz clock already running

  933. 	// SIM - enable clock

  934. 	SIM_SCGC4 |= SIM_SCGC4_USBOTG;

  935. 

  936. 	// reset USB module

  937. 	USB0_USBTRC0 = USB_USBTRC_USBRESET;

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

  939. 

  940. 	// set desc table base addr

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

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

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

  944. 

  945. 	// clear all ISR flags

  946. 	USB0_ISTAT = 0xFF;

  947. 	USB0_ERRSTAT = 0xFF;

  948. 	USB0_OTGISTAT = 0xFF;

  949. 

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

  951. 

  952. 	// enable USB

  953. 	USB0_CTL = USB_CTL_USBENSOFEN;

  954. 	USB0_USBCTRL = 0;

  955. 

  956. 	// enable reset interrupt

  957. 	USB0_INTEN = USB_INTEN_USBRSTEN;

  958. 

  959. 	// enable interrupt in NVIC...

  960. 	NVIC_SET_PRIORITY(IRQ_USBOTG, 112);

  961. 	NVIC_ENABLE_IRQ(IRQ_USBOTG);

  962. 

  963. 	// enable d+ pullup

  964. 	USB0_CONTROL = USB_CONTROL_DPPULLUPNONOTG;

  965. }

  966. 

  967.