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

1063 lines
27KB
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.  * Trying to understand this rather complex code?

  31.  *

  32.  * Kevin Cuzner wrote a simpler version, and a great blog article:

  33.  *   http://kevincuzner.com/2014/12/12/teensy-3-1-bare-metal-writing-a-usb-driver/

  34.  *   https://github.com/kcuzner/teensy-oscilloscope/blob/master/scope-teensy/src/usb.c

  35.  *

  36.  * Andy Payne wrote another relatively simple USB example for Freescale Kinetis

  37.  *   https://github.com/payne92/bare-metal-arm

  38.  */

  39. 

  40. #include "usb_dev.h"

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

  42. 

  43. #include "kinetis.h"

  44. //#include "HardwareSerial.h"

  45. #include "usb_mem.h"

  46. 

  47. // buffer descriptor table

  48. 

  49. typedef struct {

  50. 	uint32_t desc;

  51. 	void * addr;

  52. } bdt_t;

  53. 

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

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

  56. 

  57. static usb_packet_t *rx_first[NUM_ENDPOINTS];

  58. static usb_packet_t *rx_last[NUM_ENDPOINTS];

  59. static usb_packet_t *tx_first[NUM_ENDPOINTS];

  60. static usb_packet_t *tx_last[NUM_ENDPOINTS];

  61. uint16_t usb_rx_byte_count_data[NUM_ENDPOINTS];

  62. 

  63. static uint8_t tx_state[NUM_ENDPOINTS];

  64. #define TX_STATE_BOTH_FREE_EVEN_FIRST	0

  65. #define TX_STATE_BOTH_FREE_ODD_FIRST	1

  66. #define TX_STATE_EVEN_FREE		2

  67. #define TX_STATE_ODD_FREE		3

  68. #define TX_STATE_NONE_FREE_EVEN_FIRST	4

  69. #define TX_STATE_NONE_FREE_ODD_FIRST	5

  70. 

  71. #define BDT_OWN		0x80

  72. #define BDT_DATA1	0x40

  73. #define BDT_DATA0	0x00

  74. #define BDT_DTS		0x08

  75. #define BDT_STALL	0x04

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

  77. 

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

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

  80. 				| ((count) << 16))

  81. 

  82. #define TX   1

  83. #define RX   0

  84. #define ODD  1

  85. #define EVEN 0

  86. #define DATA0 0

  87. #define DATA1 1

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

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

  90. 

  91. 

  92. static union {

  93.  struct {

  94.   union {

  95.    struct {

  96. 	uint8_t bmRequestType;

  97. 	uint8_t bRequest;

  98.    };

  99. 	uint16_t wRequestAndType;

  100.   };

  101. 	uint16_t wValue;

  102. 	uint16_t wIndex;

  103. 	uint16_t wLength;

  104.  };

  105.  struct {

  106. 	uint32_t word1;

  107. 	uint32_t word2;

  108.  };

  109. } setup;

  110. 

  111. 

  112. #define GET_STATUS		0

  113. #define CLEAR_FEATURE		1

  114. #define SET_FEATURE		3

  115. #define SET_ADDRESS		5

  116. #define GET_DESCRIPTOR		6

  117. #define SET_DESCRIPTOR		7

  118. #define GET_CONFIGURATION	8

  119. #define SET_CONFIGURATION	9

  120. #define GET_INTERFACE		10

  121. #define SET_INTERFACE		11

  122. #define SYNCH_FRAME		12

  123. 

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

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

  126. // Status stage uses a DATA1 PID.

  127. 

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

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

  130. static const uint8_t *ep0_tx_ptr = NULL;

  131. static uint16_t ep0_tx_len;

  132. static uint8_t ep0_tx_bdt_bank = 0;

  133. static uint8_t ep0_tx_data_toggle = 0;

  134. uint8_t usb_rx_memory_needed = 0;

  135. 

  136. volatile uint8_t usb_configuration = 0;

  137. volatile uint8_t usb_reboot_timer = 0;

  138. 

  139. 

  140. static void endpoint0_stall(void)

  141. {

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

  143. }

  144. 

  145. 

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

  147. {

  148. #if 0

  149. 	serial_print("tx0:");

  150. 	serial_phex32((uint32_t)data);

  151. 	serial_print(",");

  152. 	serial_phex16(len);

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

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

  155. #endif

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

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

  158. 	ep0_tx_data_toggle ^= 1;

  159. 	ep0_tx_bdt_bank ^= 1;

  160. }

  161. 

  162. static uint8_t reply_buffer[8];

  163. 

  164. static void usb_setup(void)

  165. {

  166. 	const uint8_t *data = NULL;

  167. 	uint32_t datalen = 0;

  168. 	const usb_descriptor_list_t *list;

  169. 	uint32_t size;

  170. 	volatile uint8_t *reg;

  171. 	uint8_t epconf;

  172. 	const uint8_t *cfg;

  173. 	int i;

  174. 

  175. 	switch (setup.wRequestAndType) {

  176. 	  case 0x0500: // SET_ADDRESS

  177. 		break;

  178. 	  case 0x0900: // SET_CONFIGURATION

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

  180. 		usb_configuration = setup.wValue;

  181. 		reg = &USB0_ENDPT1;

  182. 		cfg = usb_endpoint_config_table;

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

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

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

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

  187. 			}

  188. 		}

  189. 		// free all queued packets

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

  191. 			usb_packet_t *p, *n;

  192. 			p = rx_first[i];

  193. 			while (p) {

  194. 				n = p->next;

  195. 				usb_free(p);

  196. 				p = n;

  197. 			}

  198. 			rx_first[i] = NULL;

  199. 			rx_last[i] = NULL;

  200. 			p = tx_first[i];

  201. 			while (p) {

  202. 				n = p->next;

  203. 				usb_free(p);

  204. 				p = n;

  205. 			}

  206. 			tx_first[i] = NULL;

  207. 			tx_last[i] = NULL;

  208. 			usb_rx_byte_count_data[i] = 0;

  209. 			switch (tx_state[i]) {

  210. 			  case TX_STATE_EVEN_FREE:

  211. 			  case TX_STATE_NONE_FREE_EVEN_FIRST:

  212. 				tx_state[i] = TX_STATE_BOTH_FREE_EVEN_FIRST;

  213. 				break;

  214. 			  case TX_STATE_ODD_FREE:

  215. 			  case TX_STATE_NONE_FREE_ODD_FIRST:

  216. 				tx_state[i] = TX_STATE_BOTH_FREE_ODD_FIRST;

  217. 				break;

  218. 			  default:

  219. 				break;

  220. 			}

  221. 		}

  222. 		usb_rx_memory_needed = 0;

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

  224. 			epconf = *cfg++;

  225. 			*reg = epconf;

  226. 			reg += 4;

  227. 			if (epconf & USB_ENDPT_EPRXEN) {

  228. 				usb_packet_t *p;

  229. 				p = usb_malloc();

  230. 				if (p) {

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

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

  233. 				} else {

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

  235. 					usb_rx_memory_needed++;

  236. 				}

  237. 				p = usb_malloc();

  238. 				if (p) {

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

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

  241. 				} else {

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

  243. 					usb_rx_memory_needed++;

  244. 				}

  245. 			}

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

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

  248. 		}

  249. 		break;

  250. 	  case 0x0880: // GET_CONFIGURATION

  251. 		reply_buffer[0] = usb_configuration;

  252. 		datalen = 1;

  253. 		data = reply_buffer;

  254. 		break;

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

  256. 		reply_buffer[0] = 0;

  257. 		reply_buffer[1] = 0;

  258. 		datalen = 2;

  259. 		data = reply_buffer;

  260. 		break;

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

  262. 		if (setup.wIndex > NUM_ENDPOINTS) {

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

  264. 			endpoint0_stall();

  265. 			return;

  266. 		}

  267. 		reply_buffer[0] = 0;

  268. 		reply_buffer[1] = 0;

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

  270. 		data = reply_buffer;

  271. 		datalen = 2;

  272. 		break;

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

  274. 		i = setup.wIndex & 0x7F;

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

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

  277. 			endpoint0_stall();

  278. 			return;

  279. 		}

  280. 		(*(uint8_t *)(&USB0_ENDPT0 + i * 4)) &= ~0x02;

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

  282. 		break;

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

  284. 		i = setup.wIndex & 0x7F;

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

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

  287. 			endpoint0_stall();

  288. 			return;

  289. 		}

  290. 		(*(uint8_t *)(&USB0_ENDPT0 + i * 4)) |= 0x02;

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

  292. 		break;

  293. 	  case 0x0680: // GET_DESCRIPTOR

  294. 	  case 0x0681:

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

  296. 		//serial_phex16(setup.wValue);

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

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

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

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

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

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

  303. 				data = list->addr;

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

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

  306. 					// length field, allowing runtime configured

  307. 					// length.

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

  309. 				} else {

  310. 					datalen = list->length;

  311. 				}

  312. #if 0

  313. 				serial_print("Desc found, ");

  314. 				serial_phex32((uint32_t)data);

  315. 				serial_print(",");

  316. 				serial_phex16(datalen);

  317. 				serial_print(",");

  318. 				serial_phex(data[0]);

  319. 				serial_phex(data[1]);

  320. 				serial_phex(data[2]);

  321. 				serial_phex(data[3]);

  322. 				serial_phex(data[4]);

  323. 				serial_phex(data[5]);

  324. 				serial_print("\n");

  325. #endif

  326. 				goto send;

  327. 			}

  328. 		}

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

  330. 		endpoint0_stall();

  331. 		return;

  332. #if defined(CDC_STATUS_INTERFACE)

  333. 	  case 0x2221: // CDC_SET_CONTROL_LINE_STATE

  334. 		usb_cdc_line_rtsdtr_millis = systick_millis_count;

  335. 		usb_cdc_line_rtsdtr = setup.wValue;

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

  337. 		break;

  338. 	  case 0x2321: // CDC_SEND_BREAK

  339. 		break;

  340. 	  case 0x2021: // CDC_SET_LINE_CODING

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

  342. 		return;

  343. #endif

  344. 

  345. #if defined(MTP_INTERFACE)

  346. 	case 0x2164: // Cancel Request (PTP spec, 5.2.1, page 8)

  347. 		// TODO: required by PTP spec

  348. 		endpoint0_stall();

  349. 		return;

  350. 	case 0x2166: // Device Reset (PTP spec, 5.2.3, page 10)

  351. 		// TODO: required by PTP spec

  352. 		endpoint0_stall();

  353. 		return;

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

  355. 		// TODO: required by PTP spec

  356. 		endpoint0_stall();

  357. 		return;

  358. #endif

  359. 

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

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

  362. 	  case 0x0921: // HID SET_REPORT

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

  364. 		return;

  365. 	  case 0x0A21: // HID SET_IDLE

  366. 		break;

  367. 	  // case 0xC940:

  368. #endif

  369. 

  370. #if defined(AUDIO_INTERFACE)

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

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

  373. 			//audio_tx_alternate_setting = setup.wValue;

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

  375. 			//audio_rx_alternate_setting = setup.wValue;

  376. 		} else {

  377. 			endpoint0_stall();

  378. 			return;

  379. 		}

  380. 		break;

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

  382. 		datalen = 1;

  383. 		data = reply_buffer;

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

  385. 			reply_buffer[0] = 0;

  386. 			//reply_buffer[0] = audio_tx_alternate_setting;

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

  388. 			reply_buffer[0] = 0;

  389. 			//reply_buffer[0] = audio_rx_alternate_setting;

  390. 		} else {

  391. 			endpoint0_stall();

  392. 			return;

  393. 		}

  394. 		break;

  395. 	  case 0x0122: // SET_CUR (wValue=0, wIndex=interface, wLength=len)

  396. 		return;

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

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

  399. 			reply_buffer[0] = 44100 & 255;

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

  401. 			reply_buffer[2] = 0;

  402. 			datalen = 3;

  403. 			data = reply_buffer;

  404. 		} else {

  405. 			endpoint0_stall();

  406. 			return;

  407. 		}

  408. 		break;

  409. #endif

  410. 	  default:

  411. 		endpoint0_stall();

  412. 		return;

  413. 	}

  414. 	send:

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

  416. 	//serial_phex32(data);

  417. 	//serial_print(",");

  418. 	//serial_phex16(datalen);

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

  420. 

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

  422. 	size = datalen;

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

  424. 	endpoint0_transmit(data, size);

  425. 	data += size;

  426. 	datalen -= size;

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

  428. 

  429. 	size = datalen;

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

  431. 	endpoint0_transmit(data, size);

  432. 	data += size;

  433. 	datalen -= size;

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

  435. 

  436. 	ep0_tx_ptr = data;

  437. 	ep0_tx_len = datalen;

  438. }

  439. 

  440. 

  441. 

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

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

  444. //Sections 9.1.1.5 and 9.4.5).

  445. 

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

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

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

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

  450. 

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

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

  453. //data toggle being reinitialized to DATA0.

  454. 

  455. 

  456. 

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

  458. 

  459. static void usb_control(uint32_t stat)

  460. {

  461. 	bdt_t *b;

  462. 	uint32_t pid, size;

  463. 	uint8_t *buf;

  464. 	const uint8_t *data;

  465. 

  466. 	b = stat2bufferdescriptor(stat);

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

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

  469. 	buf = b->addr;

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

  471. 	//serial_phex(pid);

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

  473. 	//serial_phex(count);

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

  475. 

  476. 	switch (pid) {

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

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

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

  480. 		// grab the 8 byte setup info

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

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

  483. 

  484. 		// give the buffer back

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

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

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

  488. 

  489. 		// clear any leftover pending IN transactions

  490. 		ep0_tx_ptr = NULL;

  491. 		if (ep0_tx_data_toggle) {

  492. 		}

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

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

  495. 		//}

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

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

  498. 		//}

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

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

  501. 		// first IN after Setup is always DATA1

  502. 		ep0_tx_data_toggle = 1;

  503. 

  504. #if 0

  505. 		serial_print("bmRequestType:");

  506. 		serial_phex(setup.bmRequestType);

  507. 		serial_print(", bRequest:");

  508. 		serial_phex(setup.bRequest);

  509. 		serial_print(", wValue:");

  510. 		serial_phex16(setup.wValue);

  511. 		serial_print(", wIndex:");

  512. 		serial_phex16(setup.wIndex);

  513. 		serial_print(", len:");

  514. 		serial_phex16(setup.wLength);

  515. 		serial_print("\n");

  516. #endif

  517. 		// actually "do" the setup request

  518. 		usb_setup();

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

  520. 		USB0_CTL = USB_CTL_USBENSOFEN; // clear TXSUSPENDTOKENBUSY bit

  521. 		break;

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

  523. 	case 0x02:

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

  525. #ifdef CDC_STATUS_INTERFACE

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

  527. 			int i;

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

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

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

  531. 				//serial_phex(*buf);

  532. 				*dst++ = *buf++;

  533. 			}

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

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

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

  537. 			endpoint0_transmit(NULL, 0);

  538. 		}

  539. #endif

  540. #ifdef KEYBOARD_INTERFACE

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

  542. 			keyboard_leds = buf[0];

  543. 			endpoint0_transmit(NULL, 0);

  544. 		}

  545. #endif

  546. #ifdef SEREMU_INTERFACE

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

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

  549. 			usb_reboot_timer = 5;

  550. 			endpoint0_transmit(NULL, 0);

  551. 		}

  552. #endif

  553. #ifdef AUDIO_INTERFACE

  554. 		if (setup.wRequestAndType == 0x0122 /* SET_CUR */) {

  555. 			// TODO: actually check data, do something with it?

  556. 			endpoint0_transmit(NULL, 0);

  557. 		}

  558. #endif

  559. 		// give the buffer back

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

  561. 		break;

  562. 

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

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

  565. 		//serial_phex(stat);

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

  567. 

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

  569. 		data = ep0_tx_ptr;

  570. 		if (data) {

  571. 			size = ep0_tx_len;

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

  573. 			endpoint0_transmit(data, size);

  574. 			data += size;

  575. 			ep0_tx_len -= size;

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

  577. 		}

  578. 

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

  580. 			setup.bRequest = 0;

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

  582. 			//serial_phex16(setup.wValue);

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

  584. 			USB0_ADDR = setup.wValue;

  585. 		}

  586. 

  587. 		break;

  588. 	//default:

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

  590. 		//serial_phex(pid);

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

  592. 	}

  593. 	USB0_CTL = USB_CTL_USBENSOFEN; // clear TXSUSPENDTOKENBUSY bit

  594. }

  595. 

  596. 

  597. 

  598. 

  599. 

  600. 

  601. usb_packet_t *usb_rx(uint32_t endpoint)

  602. {

  603. 	usb_packet_t *ret;

  604. 	endpoint--;

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

  606. 	__disable_irq();

  607. 	ret = rx_first[endpoint];

  608. 	if (ret) {

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

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

  611. 	}

  612. 	__enable_irq();

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

  614. 	//serial_phex(endpoint);

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

  616. 	//serial_phex32(ret);

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

  618. 	return ret;

  619. }

  620. 

  621. static uint32_t usb_queue_byte_count(const usb_packet_t *p)

  622. {

  623. 	uint32_t count=0;

  624. 

  625. 	__disable_irq();

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

  627. 		count += p->len;

  628. 	}

  629. 	__enable_irq();

  630. 	return count;

  631. }

  632. 

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

  634. /*

  635. uint32_t usb_rx_byte_count(uint32_t endpoint)

  636. {

  637. 	endpoint--;

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

  639. 	return usb_rx_byte_count_data[endpoint];

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

  641. }

  642. */

  643. 

  644. uint32_t usb_tx_byte_count(uint32_t endpoint)

  645. {

  646. 	endpoint--;

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

  648. 	return usb_queue_byte_count(tx_first[endpoint]);

  649. }

  650. 

  651. uint32_t usb_tx_packet_count(uint32_t endpoint)

  652. {

  653. 	const usb_packet_t *p;

  654. 	uint32_t count=0;

  655. 

  656. 	endpoint--;

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

  658. 	__disable_irq();

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

  660. 	__enable_irq();

  661. 	return count;

  662. }

  663. 

  664. 

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

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

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

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

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

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

  671. // first endpoint needing memory.

  672. //

  673. void usb_rx_memory(usb_packet_t *packet)

  674. {

  675. 	unsigned int i;

  676. 	const uint8_t *cfg;

  677. 

  678. 	cfg = usb_endpoint_config_table;

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

  680. 	__disable_irq();

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

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

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

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

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

  686. 				usb_rx_memory_needed--;

  687. 				__enable_irq();

  688. 				//serial_phex(i);

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

  690. 				return;

  691. 			}

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

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

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

  695. 				usb_rx_memory_needed--;

  696. 				__enable_irq();

  697. 				//serial_phex(i);

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

  699. 				return;

  700. 			}

  701. 		}

  702. 	}

  703. 	__enable_irq();

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

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

  706. 	// was actually needed.

  707. 	usb_rx_memory_needed = 0;

  708. 	usb_free(packet);

  709. 	return;

  710. }

  711. 

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

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

  714. 

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

  716. {

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

  718. 	uint8_t next;

  719. 

  720. 	endpoint--;

  721. 	if (endpoint >= NUM_ENDPOINTS) return;

  722. 	__disable_irq();

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

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

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

  726. 	switch (tx_state[endpoint]) {

  727. 	  case TX_STATE_BOTH_FREE_EVEN_FIRST:

  728. 		next = TX_STATE_ODD_FREE;

  729. 		break;

  730. 	  case TX_STATE_BOTH_FREE_ODD_FIRST:

  731. 		b++;

  732. 		next = TX_STATE_EVEN_FREE;

  733. 		break;

  734. 	  case TX_STATE_EVEN_FREE:

  735. 		next = TX_STATE_NONE_FREE_ODD_FIRST;

  736. 		break;

  737. 	  case TX_STATE_ODD_FREE:

  738. 		b++;

  739. 		next = TX_STATE_NONE_FREE_EVEN_FIRST;

  740. 		break;

  741. 	  default:

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

  743. 			tx_first[endpoint] = packet;

  744. 		} else {

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

  746. 		}

  747. 		tx_last[endpoint] = packet;

  748. 		__enable_irq();

  749. 		return;

  750. 	}

  751. 	tx_state[endpoint] = next;

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

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

  754. 	__enable_irq();

  755. }

  756. 

  757. 

  758. 

  759. 

  760. 

  761. 

  762. void _reboot_Teensyduino_(void)

  763. {

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

  765. 	__asm__ volatile("bkpt");

  766. }

  767. 

  768. 

  769. 

  770. void usb_isr(void)

  771. {

  772. 	uint8_t status, stat, t;

  773. 

  774. 	//serial_print("isr");

  775. 	//status = USB0_ISTAT;

  776. 	//serial_phex(status);

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

  778. 	restart:

  779. 	status = USB0_ISTAT;

  780. 

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

  782. 		if (usb_configuration) {

  783. 			t = usb_reboot_timer;

  784. 			if (t) {

  785. 				usb_reboot_timer = --t;

  786. 				if (!t) _reboot_Teensyduino_();

  787. 			}

  788. #ifdef CDC_DATA_INTERFACE

  789. 			t = usb_cdc_transmit_flush_timer;

  790. 			if (t) {

  791. 				usb_cdc_transmit_flush_timer = --t;

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

  793. 			}

  794. #endif

  795. #ifdef SEREMU_INTERFACE

  796. 			t = usb_seremu_transmit_flush_timer;

  797. 			if (t) {

  798. 				usb_seremu_transmit_flush_timer = --t;

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

  800. 			}

  801. #endif

  802. #ifdef MIDI_INTERFACE

  803.                         usb_midi_flush_output();

  804. #endif

  805. #ifdef FLIGHTSIM_INTERFACE

  806. 			usb_flightsim_flush_callback();

  807. #endif

  808. 		}

  809. 		USB0_ISTAT = USB_ISTAT_SOFTOK;

  810. 	}

  811. 

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

  813. 		uint8_t endpoint;

  814. 		stat = USB0_STAT;

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

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

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

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

  819. 		endpoint = stat >> 4;

  820. 		if (endpoint == 0) {

  821. 			usb_control(stat);

  822. 		} else {

  823. 			bdt_t *b = stat2bufferdescriptor(stat);

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

  825. #if 0

  826. 			serial_print("ep:");

  827. 			serial_phex(endpoint);

  828. 			serial_print(", pid:");

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

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

  831. 			serial_print(", count:");

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

  833. 			serial_print("\n");

  834. #endif

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

  836. 

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

  838. 				usb_free(packet);

  839. 				packet = tx_first[endpoint];

  840. 				if (packet) {

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

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

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

  844. 					switch (tx_state[endpoint]) {

  845. 					  case TX_STATE_BOTH_FREE_EVEN_FIRST:

  846. 						tx_state[endpoint] = TX_STATE_ODD_FREE;

  847. 						break;

  848. 					  case TX_STATE_BOTH_FREE_ODD_FIRST:

  849. 						tx_state[endpoint] = TX_STATE_EVEN_FREE;

  850. 						break;

  851. 					  case TX_STATE_EVEN_FREE:

  852. 						tx_state[endpoint] = TX_STATE_NONE_FREE_ODD_FIRST;

  853. 						break;

  854. 					  case TX_STATE_ODD_FREE:

  855. 						tx_state[endpoint] = TX_STATE_NONE_FREE_EVEN_FIRST;

  856. 						break;

  857. 					  default:

  858. 						break;

  859. 					}

  860. #ifdef AUDIO_INTERFACE

  861. 					// isochronous does not use data toggle bit

  862. 					if (endpoint == AUDIO_TX_ENDPOINT) {

  863. 						b->desc = BDT_DESC(packet->len, DATA0);

  864. 					} else

  865. #endif

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

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

  868. 				} else {

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

  870. 					switch (tx_state[endpoint]) {

  871. 					  case TX_STATE_BOTH_FREE_EVEN_FIRST:

  872. 					  case TX_STATE_BOTH_FREE_ODD_FIRST:

  873. 						break;

  874. 					  case TX_STATE_EVEN_FREE:

  875. 						tx_state[endpoint] = TX_STATE_BOTH_FREE_EVEN_FIRST;

  876. 						break;

  877. 					  case TX_STATE_ODD_FREE:

  878. 						tx_state[endpoint] = TX_STATE_BOTH_FREE_ODD_FIRST;

  879. 						break;

  880. 					  default:

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

  882. 						  TX_STATE_ODD_FREE : TX_STATE_EVEN_FREE;

  883. 						break;

  884. 					}

  885. 				}

  886. 			} else { // receive

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

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

  889. 					packet->index = 0;

  890. 					packet->next = NULL;

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

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

  893. 						//serial_phex(endpoint);

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

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

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

  897. 						rx_first[endpoint] = packet;

  898. 					} else {

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

  900. 						//serial_phex(endpoint);

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

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

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

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

  905. 					}

  906. 					rx_last[endpoint] = packet;

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

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

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

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

  911. 					packet = usb_malloc();

  912. 					if (packet) {

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

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

  915. 					} else {

  916. 						//serial_print("starving ");

  917. 						//serial_phex(endpoint + 1);

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

  919. 						b->desc = 0;

  920. 						usb_rx_memory_needed++;

  921. 					}

  922. 				} else {

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

  924. 				}

  925. 			}

  926. 

  927. 

  928. 

  929. 

  930. 		}

  931. 		USB0_ISTAT = USB_ISTAT_TOKDNE;

  932. 		goto restart;

  933. 	}

  934. 

  935. 

  936. 

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

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

  939. 

  940. 		// initialize BDT toggle bits

  941. 		USB0_CTL = USB_CTL_ODDRST;

  942. 		ep0_tx_bdt_bank = 0;

  943. 

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

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

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

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

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

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

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

  951. 

  952. 		// activate endpoint 0

  953. 		USB0_ENDPT0 = USB_ENDPT_EPRXEN | USB_ENDPT_EPTXEN | USB_ENDPT_EPHSHK;

  954. 

  955. 		// clear all ending interrupts

  956. 		USB0_ERRSTAT = 0xFF;

  957. 		USB0_ISTAT = 0xFF;

  958. 

  959. 		// set the address to zero during enumeration

  960. 		USB0_ADDR = 0;

  961. 

  962. 		// enable other interrupts

  963. 		USB0_ERREN = 0xFF;

  964. 		USB0_INTEN = USB_INTEN_TOKDNEEN |

  965. 			USB_INTEN_SOFTOKEN |

  966. 			USB_INTEN_STALLEN |

  967. 			USB_INTEN_ERROREN |

  968. 			USB_INTEN_USBRSTEN |

  969. 			USB_INTEN_SLEEPEN;

  970. 

  971. 		// is this necessary?

  972. 		USB0_CTL = USB_CTL_USBENSOFEN;

  973. 		return;

  974. 	}

  975. 

  976. 

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

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

  979. 		USB0_ENDPT0 = USB_ENDPT_EPRXEN | USB_ENDPT_EPTXEN | USB_ENDPT_EPHSHK;

  980. 		USB0_ISTAT = USB_ISTAT_STALL;

  981. 	}

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

  983. 		uint8_t err = USB0_ERRSTAT;

  984. 		USB0_ERRSTAT = err;

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

  986. 		//serial_phex(err);

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

  988. 		USB0_ISTAT = USB_ISTAT_ERROR;

  989. 	}

  990. 

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

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

  993. 		USB0_ISTAT = USB_ISTAT_SLEEP;

  994. 	}

  995. 

  996. }

  997. 

  998. 

  999. 

  1000. void usb_init(void)

  1001. {

  1002. 	int i;

  1003. 

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

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

  1006. 

  1007. 	usb_init_serialnumber();

  1008. 

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

  1010. 		table[i].desc = 0;

  1011. 		table[i].addr = 0;

  1012. 	}

  1013. 

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

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

  1016. 

  1017. 	// assume 48 MHz clock already running

  1018. 	// SIM - enable clock

  1019. 	SIM_SCGC4 |= SIM_SCGC4_USBOTG;

  1020. #ifdef HAS_KINETIS_MPU

  1021. 	MPU_RGDAAC0 |= 0x03000000;

  1022. #endif

  1023. 

  1024. 	// reset USB module

  1025. 	//USB0_USBTRC0 = USB_USBTRC_USBRESET;

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

  1027. 

  1028. 	// set desc table base addr

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

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

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

  1032. 

  1033. 	// clear all ISR flags

  1034. 	USB0_ISTAT = 0xFF;

  1035. 	USB0_ERRSTAT = 0xFF;

  1036. 	USB0_OTGISTAT = 0xFF;

  1037. 

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

  1039. 

  1040. 	// enable USB

  1041. 	USB0_CTL = USB_CTL_USBENSOFEN;

  1042. 	USB0_USBCTRL = 0;

  1043. 

  1044. 	// enable reset interrupt

  1045. 	USB0_INTEN = USB_INTEN_USBRSTEN;

  1046. 

  1047. 	// enable interrupt in NVIC...

  1048. 	NVIC_SET_PRIORITY(IRQ_USBOTG, 112);

  1049. 	NVIC_ENABLE_IRQ(IRQ_USBOTG);

  1050. 

  1051. 	// enable d+ pullup

  1052. 	USB0_CONTROL = USB_CONTROL_DPPULLUPNONOTG;

  1053. }

  1054. 

  1055. 

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

  1057. 

  1058. void usb_init(void)

  1059. {

  1060. }

  1061. 

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