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.
1116 Commits
2 Branches
Tree: f9a9f867c5
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f9a9f867c5'
${ noResults }
teensy-core-4.1/teensy4/usb.c

797 lines
24KB
Raw Blame History 

  1. #include "usb_dev.h"

  2. #define USB_DESC_LIST_DEFINE

  3. #include "usb_desc.h"

  4. #include "usb_serial.h"

  5. #include "core_pins.h" // for delay()

  6. #include "avr/pgmspace.h"

  7. #include <string.h>

  8. #include "debug/printf.h"

  9. 

  10. //#define LOG_SIZE  20

  11. //uint32_t transfer_log_head=0;

  12. //uint32_t transfer_log_count=0;

  13. //uint32_t transfer_log[LOG_SIZE];

  14. 

  15. // device mode, page 3155

  16. 

  17. typedef struct endpoint_struct endpoint_t;

  18. 

  19. struct endpoint_struct {

  20. 	uint32_t config;

  21. 	uint32_t current;

  22. 	uint32_t next;

  23. 	uint32_t status;

  24. 	uint32_t pointer0;

  25. 	uint32_t pointer1;

  26. 	uint32_t pointer2;

  27. 	uint32_t pointer3;

  28. 	uint32_t pointer4;

  29. 	uint32_t reserved;

  30. 	uint32_t setup0;

  31. 	uint32_t setup1;

  32. 	transfer_t *first_transfer;

  33. 	transfer_t *last_transfer;

  34. 	void (*callback_function)(transfer_t *completed_transfer);

  35. 	uint32_t unused1;

  36. };

  37. 

  38. /*struct transfer_struct {

  39. 	uint32_t next;

  40. 	uint32_t status;

  41. 	uint32_t pointer0;

  42. 	uint32_t pointer1;

  43. 	uint32_t pointer2;

  44. 	uint32_t pointer3;

  45. 	uint32_t pointer4;

  46. 	uint32_t callback_param;

  47. };*/

  48. 

  49. endpoint_t endpoint_queue_head[(NUM_ENDPOINTS+1)*2] __attribute__ ((used, aligned(4096)));

  50. 

  51. transfer_t endpoint0_transfer_data __attribute__ ((used, aligned(32)));

  52. transfer_t endpoint0_transfer_ack  __attribute__ ((used, aligned(32)));

  53. 

  54. 

  55. typedef union {

  56.  struct {

  57.   union {

  58.    struct {

  59.         uint8_t bmRequestType;

  60.         uint8_t bRequest;

  61.    };

  62.         uint16_t wRequestAndType;

  63.   };

  64.         uint16_t wValue;

  65.         uint16_t wIndex;

  66.         uint16_t wLength;

  67.  };

  68.  struct {

  69.         uint32_t word1;

  70.         uint32_t word2;

  71.  };

  72. 	uint64_t bothwords;

  73. } setup_t;

  74. 

  75. static setup_t endpoint0_setupdata;

  76. static uint32_t endpoint0_notify_mask=0;

  77. static uint32_t endpointN_notify_mask=0;

  78. //static int reset_count=0;

  79. volatile uint8_t usb_configuration = 0; // non-zero when USB host as configured device

  80. volatile uint8_t usb_high_speed = 0;    // non-zero if running at 480 Mbit/sec speed

  81. static uint8_t endpoint0_buffer[8];

  82. static uint8_t usb_reboot_timer = 0;

  83. 

  84. extern uint8_t usb_descriptor_buffer[]; // defined in usb_desc.c

  85. extern const uint8_t usb_config_descriptor_480[];

  86. extern const uint8_t usb_config_descriptor_12[];

  87. 

  88. void (*usb_timer0_callback)(void) = NULL;

  89. void (*usb_timer1_callback)(void) = NULL;

  90. 

  91. static void isr(void);

  92. static void endpoint0_setup(uint64_t setupdata);

  93. static void endpoint0_transmit(const void *data, uint32_t len, int notify);

  94. static void endpoint0_receive(void *data, uint32_t len, int notify);

  95. static void endpoint0_complete(void);

  96. 

  97. 

  98. static void run_callbacks(endpoint_t *ep);

  99. 

  100. 

  101. FLASHMEM void usb_init(void)

  102. {

  103. 	// TODO: only enable when VBUS detected

  104. 	// TODO: return to low power mode when VBUS removed

  105. 	// TODO: protect PMU access with MPU

  106. 	PMU_REG_3P0 = PMU_REG_3P0_OUTPUT_TRG(0x0F) | PMU_REG_3P0_BO_OFFSET(6)

  107. 		| PMU_REG_3P0_ENABLE_LINREG;

  108. 

  109. 	usb_init_serialnumber();

  110. 

  111. 	// assume PLL3 is already running - already done by usb_pll_start() in main.c

  112. 

  113. 	CCM_CCGR6 |= CCM_CCGR6_USBOH3(CCM_CCGR_ON); // turn on clocks to USB peripheral

  114. 	

  115. 	printf("BURSTSIZE=%08lX\n", USB1_BURSTSIZE);

  116. 	//USB1_BURSTSIZE = USB_BURSTSIZE_TXPBURST(4) | USB_BURSTSIZE_RXPBURST(4);

  117. 	USB1_BURSTSIZE = 0x0404;

  118. 	printf("BURSTSIZE=%08lX\n", USB1_BURSTSIZE);

  119. 	printf("USB1_TXFILLTUNING=%08lX\n", USB1_TXFILLTUNING);

  120. 

  121. 	// Before programming this register, the PHY clocks must be enabled in registers

  122. 	// USBPHYx_CTRLn and CCM_ANALOG_USBPHYx_PLL_480_CTRLn.

  123. 

  124. 	//printf("USBPHY1_PWD=%08lX\n", USBPHY1_PWD);

  125. 	//printf("USBPHY1_TX=%08lX\n", USBPHY1_TX);

  126. 	//printf("USBPHY1_RX=%08lX\n", USBPHY1_RX);

  127. 	//printf("USBPHY1_CTRL=%08lX\n", USBPHY1_CTRL);

  128. 	//printf("USB1_USBMODE=%08lX\n", USB1_USBMODE);

  129. 

  130. 	// turn on PLL3, wait for 480 MHz lock?

  131. 	// turn on CCM clock gates?  CCGR6[CG0]

  132. #if 1

  133. 	if ((USBPHY1_PWD & (USBPHY_PWD_RXPWDRX | USBPHY_PWD_RXPWDDIFF | USBPHY_PWD_RXPWD1PT1

  134. 	  | USBPHY_PWD_RXPWDENV | USBPHY_PWD_TXPWDV2I | USBPHY_PWD_TXPWDIBIAS

  135. 	  | USBPHY_PWD_TXPWDFS)) || (USB1_USBMODE & USB_USBMODE_CM_MASK)) {

  136. 		// USB controller is turned on from previous use

  137. 		// reset needed to turn it off & start from clean slate

  138. 		USBPHY1_CTRL_SET = USBPHY_CTRL_SFTRST; // USBPHY1_CTRL page 3292

  139. 		USB1_USBCMD |= USB_USBCMD_RST; // reset controller

  140. 		int count=0;

  141. 		while (USB1_USBCMD & USB_USBCMD_RST) count++;

  142. 		NVIC_CLEAR_PENDING(IRQ_USB1);

  143. 		USBPHY1_CTRL_CLR = USBPHY_CTRL_SFTRST; // reset PHY

  144. 		//USB1_USBSTS = USB1_USBSTS; // TODO: is this needed?

  145. 		printf("USB reset took %d loops\n", count);

  146. 		//delay(10);

  147. 		//printf("\n");

  148. 		//printf("USBPHY1_PWD=%08lX\n", USBPHY1_PWD);

  149. 		//printf("USBPHY1_TX=%08lX\n", USBPHY1_TX);

  150. 		//printf("USBPHY1_RX=%08lX\n", USBPHY1_RX);

  151. 		//printf("USBPHY1_CTRL=%08lX\n", USBPHY1_CTRL);

  152. 		//printf("USB1_USBMODE=%08lX\n", USB1_USBMODE);

  153. 		delay(25);

  154. 	}

  155. #endif

  156. 	// Device Controller Initialization, page 3161

  157. 	// USBCMD	pg 3216

  158. 	// USBSTS	pg 3220

  159. 	// USBINTR	pg 3224

  160. 	// DEVICEADDR	pg 3227

  161. 	// ENDPTLISTADDR   3229

  162. 	// USBMODE	pg 3244

  163. 	// ENDPTSETUPSTAT  3245

  164. 	// ENDPTPRIME	pg 3246

  165. 	// ENDPTFLUSH	pg 3247

  166. 	// ENDPTSTAT	pg 3247

  167. 	// ENDPTCOMPLETE   3248

  168. 	// ENDPTCTRL0	pg 3249

  169. 

  170. 	USBPHY1_CTRL_CLR = USBPHY_CTRL_CLKGATE;

  171. 	USBPHY1_PWD = 0;

  172. 	//printf("USBPHY1_PWD=%08lX\n", USBPHY1_PWD);

  173. 	//printf("USBPHY1_CTRL=%08lX\n", USBPHY1_CTRL);

  174. 

  175. 	USB1_USBMODE = USB_USBMODE_CM(2) | USB_USBMODE_SLOM;

  176. 	memset(endpoint_queue_head, 0, sizeof(endpoint_queue_head));

  177. 	endpoint_queue_head[0].config = (64 << 16) | (1 << 15);

  178. 	endpoint_queue_head[1].config = (64 << 16);

  179. 	USB1_ENDPOINTLISTADDR = (uint32_t)&endpoint_queue_head;

  180. 	//  Recommended: enable all device interrupts including: USBINT, USBERRINT,

  181. 	// Port Change Detect, USB Reset Received, DCSuspend.

  182. 	USB1_USBINTR = USB_USBINTR_UE | USB_USBINTR_UEE | /* USB_USBINTR_PCE | */

  183. 		USB_USBINTR_URE | USB_USBINTR_SLE;

  184. 	//_VectorsRam[IRQ_USB1+16] = &isr;

  185. 	attachInterruptVector(IRQ_USB1, &isr);

  186. 	NVIC_ENABLE_IRQ(IRQ_USB1);

  187. 	//printf("USB1_ENDPTCTRL0=%08lX\n", USB1_ENDPTCTRL0);

  188. 	//printf("USB1_ENDPTCTRL1=%08lX\n", USB1_ENDPTCTRL1);

  189. 	//printf("USB1_ENDPTCTRL2=%08lX\n", USB1_ENDPTCTRL2);

  190. 	//printf("USB1_ENDPTCTRL3=%08lX\n", USB1_ENDPTCTRL3);

  191. 	USB1_USBCMD = USB_USBCMD_RS;

  192. 	//transfer_log_head = 0;

  193. 	//transfer_log_count = 0;

  194. }

  195. 

  196. 

  197. static void isr(void)

  198. {

  199. 	//printf("*");

  200. 

  201. 	//  Port control in device mode is only used for

  202. 	//  status port reset, suspend, and current connect status.

  203. 	uint32_t status = USB1_USBSTS;

  204. 	USB1_USBSTS = status;

  205. 

  206. 	// USB_USBSTS_SLI - set to 1 when enters a suspend state from an active state

  207. 	// USB_USBSTS_SRI - set at start of frame

  208. 	// USB_USBSTS_SRI - set when USB reset detected

  209. 

  210. 	if (status & USB_USBSTS_UI) {

  211. 		//printf("data\n");

  212. 		uint32_t setupstatus = USB1_ENDPTSETUPSTAT;

  213. 		//printf("USB1_ENDPTSETUPSTAT=%X\n", setupstatus);

  214. 		while (setupstatus) {

  215. 			USB1_ENDPTSETUPSTAT = setupstatus;

  216. 			setup_t s;

  217. 			do {

  218. 				USB1_USBCMD |= USB_USBCMD_SUTW;

  219. 				s.word1 = endpoint_queue_head[0].setup0;

  220. 				s.word2 = endpoint_queue_head[0].setup1;

  221. 			} while (!(USB1_USBCMD & USB_USBCMD_SUTW));

  222. 			USB1_USBCMD &= ~USB_USBCMD_SUTW;

  223. 			//printf("setup %08lX %08lX\n", s.word1, s.word2);

  224. 			USB1_ENDPTFLUSH = (1<<16) | (1<<0); // page 3174

  225. 			while (USB1_ENDPTFLUSH & ((1<<16) | (1<<0))) ;

  226. 			endpoint0_notify_mask = 0;

  227. 			endpoint0_setup(s.bothwords);

  228. 			setupstatus = USB1_ENDPTSETUPSTAT; // page 3175

  229. 		}

  230. 		uint32_t completestatus = USB1_ENDPTCOMPLETE;

  231. 		if (completestatus) {

  232. 			USB1_ENDPTCOMPLETE = completestatus;

  233. 			//printf("USB1_ENDPTCOMPLETE=%lX\n", completestatus);

  234. 			if (completestatus & endpoint0_notify_mask) {

  235. 				endpoint0_notify_mask = 0;

  236. 				endpoint0_complete();

  237. 			}

  238. 			completestatus &= endpointN_notify_mask;

  239. 			if (completestatus) {

  240. 				int i;   // TODO: optimize with __builtin_ctz()

  241. 				for (i=2; i <= NUM_ENDPOINTS; i++) {

  242. 					if (completestatus & (1 << i)) { // receive

  243. 						run_callbacks(endpoint_queue_head + i * 2);

  244. 					}

  245. 					if (completestatus & (1 << (i + 16))) { // transmit

  246. 						run_callbacks(endpoint_queue_head + i * 2 + 1);

  247. 					}

  248. 				}

  249. 			}

  250. 		}

  251. 	}

  252. 	if (status & USB_USBSTS_URI) { // page 3164

  253. 		USB1_ENDPTSETUPSTAT = USB1_ENDPTSETUPSTAT; // Clear all setup token semaphores

  254. 		USB1_ENDPTCOMPLETE = USB1_ENDPTCOMPLETE; // Clear all the endpoint complete status

  255. 		while (USB1_ENDPTPRIME != 0) ; // Wait for any endpoint priming

  256. 		USB1_ENDPTFLUSH = 0xFFFFFFFF;  // Cancel all endpoint primed status

  257. 		if ((USB1_PORTSC1 & USB_PORTSC1_PR)) {

  258. 			//printf("reset\n");

  259. 		} else {

  260. 			// we took too long to respond :(

  261. 			// TODO; is this ever really a problem?

  262. 			//printf("reset too slow\n");

  263. 		}

  264. 		#if defined(CDC_STATUS_INTERFACE) && defined(CDC_DATA_INTERFACE)

  265. 		usb_serial_reset();

  266. 		#endif

  267. 		endpointN_notify_mask = 0;

  268. 		// TODO: Free all allocated dTDs

  269. 		//if (++reset_count >= 3) {

  270. 			// shut off USB - easier to see results in protocol analyzer

  271. 			//USB1_USBCMD &= ~USB_USBCMD_RS;

  272. 			//printf("shut off USB\n");

  273. 		//}

  274. 	}

  275. 	if (status & USB_USBSTS_TI0) {

  276. 		if (usb_timer0_callback != NULL) usb_timer0_callback();

  277. 	}

  278. 	if (status & USB_USBSTS_TI1) {

  279. 		if (usb_timer1_callback != NULL) usb_timer1_callback();

  280. 	}

  281. 	if (status & USB_USBSTS_PCI) {

  282. 		if (USB1_PORTSC1 & USB_PORTSC1_HSP) {

  283. 			//printf("port at 480 Mbit\n");

  284. 			usb_high_speed = 1;

  285. 		} else {

  286. 			//printf("port at 12 Mbit\n");

  287. 			usb_high_speed = 0;

  288. 		}

  289. 	}

  290. 	if (status & USB_USBSTS_SLI) { // page 3165

  291. 		//printf("suspend\n");

  292. 	}

  293. 	if (status & USB_USBSTS_UEI) {

  294. 		//printf("error\n");

  295. 	}

  296. 	if ((USB1_USBINTR & USB_USBINTR_SRE) && (status & USB_USBSTS_SRI)) {

  297. 		printf("sof %d\n", usb_reboot_timer);

  298. 		if (usb_reboot_timer) {

  299. 			if (--usb_reboot_timer == 0) {

  300. 				asm("bkpt #251"); // run bootloader

  301. 			}

  302. 		} else {

  303. 			// turn off the SOF interrupt if nothing using it

  304. 			USB1_USBINTR &= ~USB_USBINTR_SRE;

  305. 		}

  306. 	}

  307. }

  308. 

  309. 

  310. /*

  311. struct transfer_struct { // table 55-60, pg 3159

  312. 	uint32_t next;

  313. 	uint32_t status;

  314. 	uint32_t pointer0;

  315. 	uint32_t pointer1;

  316. 	uint32_t pointer2;

  317. 	uint32_t pointer3;

  318. 	uint32_t pointer4;

  319. 	uint32_t unused1;

  320. };

  321. transfer_t endpoint0_transfer_data __attribute__ ((aligned(32)));;

  322. transfer_t endpoint0_transfer_ack  __attribute__ ((aligned(32)));;

  323. */

  324. 

  325. static uint8_t reply_buffer[8];

  326. 

  327. static void endpoint0_setup(uint64_t setupdata)

  328. {

  329. 	setup_t setup;

  330. 	uint32_t endpoint, dir, ctrl;

  331. 	const usb_descriptor_list_t *list;

  332. 

  333. 	setup.bothwords = setupdata;

  334. 	switch (setup.wRequestAndType) {

  335. 	  case 0x0500: // SET_ADDRESS

  336. 		endpoint0_receive(NULL, 0, 0);

  337. 		USB1_DEVICEADDR = USB_DEVICEADDR_USBADR(setup.wValue) | USB_DEVICEADDR_USBADRA;

  338. 		return;

  339. 	  case 0x0900: // SET_CONFIGURATION

  340. 		usb_configuration = setup.wValue;

  341. 		// configure all other endpoints

  342. 		#if defined(ENDPOINT2_CONFIG)

  343. 		USB1_ENDPTCTRL2 = ENDPOINT2_CONFIG;

  344. 		#endif

  345. 		#if defined(ENDPOINT3_CONFIG)

  346. 		USB1_ENDPTCTRL3 = ENDPOINT3_CONFIG;

  347. 		#endif

  348. 		#if defined(ENDPOINT4_CONFIG)

  349. 		USB1_ENDPTCTRL4 = ENDPOINT4_CONFIG;

  350. 		#endif

  351. 		#if defined(ENDPOINT5_CONFIG)

  352. 		USB1_ENDPTCTRL5 = ENDPOINT5_CONFIG;

  353. 		#endif

  354. 		#if defined(ENDPOINT6_CONFIG)

  355. 		USB1_ENDPTCTRL6 = ENDPOINT6_CONFIG;

  356. 		#endif

  357. 		#if defined(ENDPOINT7_CONFIG)

  358. 		USB1_ENDPTCTRL7 = ENDPOINT7_CONFIG;

  359. 		#endif

  360. 		#if defined(CDC_STATUS_INTERFACE) && defined(CDC_DATA_INTERFACE)

  361. 		usb_serial_configure();

  362. 		#endif

  363. 		#if defined(RAWHID_INTERFACE)

  364. 		usb_rawhid_configure();

  365. 		#endif

  366. 		endpoint0_receive(NULL, 0, 0);

  367. 		return;

  368. 	  case 0x0880: // GET_CONFIGURATION

  369. 		reply_buffer[0] = usb_configuration;

  370. 		endpoint0_transmit(reply_buffer, 1, 0);

  371. 		return;

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

  373. 		reply_buffer[0] = 0;

  374. 		reply_buffer[1] = 0;

  375. 		endpoint0_transmit(reply_buffer, 2, 0);

  376. 		return;

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

  378. 		endpoint = setup.wIndex & 0x7F;

  379. 		if (endpoint > 7) break;

  380. 		dir = setup.wIndex & 0x80;

  381. 		ctrl = *((uint32_t *)&USB1_ENDPTCTRL0 + endpoint);

  382. 		reply_buffer[0] = 0;

  383. 		reply_buffer[1] = 0;

  384. 		if ((dir && (ctrl & USB_ENDPTCTRL_TXS)) || (!dir && (ctrl & USB_ENDPTCTRL_RXS))) {

  385. 			reply_buffer[0] = 1;

  386. 		}

  387. 		endpoint0_transmit(reply_buffer, 2, 0);

  388. 		return;

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

  390. 		endpoint = setup.wIndex & 0x7F;

  391. 		if (endpoint > 7) break;

  392. 		dir = setup.wIndex & 0x80;

  393. 		if (dir) {

  394. 			*((volatile uint32_t *)&USB1_ENDPTCTRL0 + endpoint) |= USB_ENDPTCTRL_TXS;

  395. 		} else {

  396. 			*((volatile uint32_t *)&USB1_ENDPTCTRL0 + endpoint) |= USB_ENDPTCTRL_RXS;

  397. 		}

  398. 		endpoint0_receive(NULL, 0, 0);

  399. 		return;

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

  401. 		endpoint = setup.wIndex & 0x7F;

  402. 		if (endpoint > 7) break;

  403. 		dir = setup.wIndex & 0x80;

  404. 		if (dir) {

  405. 			*((volatile uint32_t *)&USB1_ENDPTCTRL0 + endpoint) &= ~USB_ENDPTCTRL_TXS;

  406. 		} else {

  407. 			*((volatile uint32_t *)&USB1_ENDPTCTRL0 + endpoint) &= ~USB_ENDPTCTRL_RXS;

  408. 		}

  409. 		endpoint0_receive(NULL, 0, 0);

  410. 		return;

  411. 	  case 0x0680: // GET_DESCRIPTOR

  412. 	  case 0x0681:

  413. 		for (list = usb_descriptor_list; list->addr != NULL; list++) {

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

  415. 				uint32_t datalen;

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

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

  418. 					// length field, allowing runtime configured length.

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

  420. 				} else {

  421. 					datalen = list->length;

  422. 				}

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

  424. 

  425. 				// copy the descriptor, from PROGMEM to DMAMEM

  426. 				if (setup.wValue == 0x200) {

  427. 					// config descriptor needs to adapt to speed

  428. 					const uint8_t *src = usb_config_descriptor_12;

  429. 					if (usb_high_speed) src = usb_config_descriptor_480;

  430. 					memcpy(usb_descriptor_buffer, src, datalen);

  431. 				} else if (setup.wValue == 0x700) {

  432. 					// other speed config also needs to adapt

  433. 					const uint8_t *src = usb_config_descriptor_480;

  434. 					if (usb_high_speed) src = usb_config_descriptor_12;

  435. 					memcpy(usb_descriptor_buffer, src, datalen);

  436. 					usb_descriptor_buffer[1] = 7;

  437. 				} else {

  438. 					memcpy(usb_descriptor_buffer, list->addr, datalen);

  439. 				}

  440. 				// prep transmit

  441. 				arm_dcache_flush_delete(usb_descriptor_buffer, datalen);

  442. 				endpoint0_transmit(usb_descriptor_buffer, datalen, 0);

  443. 				return;

  444. 			}

  445. 		}

  446. 		break;

  447. #if defined(CDC_STATUS_INTERFACE)

  448. 	  case 0x2221: // CDC_SET_CONTROL_LINE_STATE

  449. 		usb_cdc_line_rtsdtr_millis = systick_millis_count;

  450. 		usb_cdc_line_rtsdtr = setup.wValue;

  451. 	  case 0x2321: // CDC_SEND_BREAK

  452. 		endpoint0_receive(NULL, 0, 0);

  453. 		return;

  454. 	  case 0x2021: // CDC_SET_LINE_CODING

  455. 		if (setup.wLength != 7) break;

  456. 		endpoint0_setupdata.bothwords = setupdata;

  457. 		endpoint0_receive(endpoint0_buffer, 7, 1);

  458. 		return;

  459. #endif

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

  461. 	  case 0x0921: // HID SET_REPORT

  462. 		if (setup.wLength <= sizeof(endpoint0_buffer)) {

  463. 			//printf("hid set report %x %x\n", setup.word1, setup.word2);

  464. 			endpoint0_setupdata.bothwords = setup.bothwords;

  465. 			endpoint0_buffer[0] = 0xE9;

  466. 			endpoint0_receive(endpoint0_buffer, setup.wLength, 1);

  467. 			return;

  468. 		}

  469. 		break;

  470. #endif

  471. 	}

  472. 	USB1_ENDPTCTRL0 = 0x000010001; // stall

  473. }

  474. 

  475. static void endpoint0_transmit(const void *data, uint32_t len, int notify)

  476. {

  477. 	//printf("tx %lu\n", len);

  478. 	if (len > 0) {

  479. 		// Executing A Transfer Descriptor, page 3182

  480. 		endpoint0_transfer_data.next = 1;

  481. 		endpoint0_transfer_data.status = (len << 16) | (1<<7);

  482. 		uint32_t addr = (uint32_t)data;

  483. 		endpoint0_transfer_data.pointer0 = addr; // format: table 55-60, pg 3159

  484. 		endpoint0_transfer_data.pointer1 = addr + 4096;

  485. 		endpoint0_transfer_data.pointer2 = addr + 8192;

  486. 		endpoint0_transfer_data.pointer3 = addr + 12288;

  487. 		endpoint0_transfer_data.pointer4 = addr + 16384;

  488. 		//  Case 1: Link list is empty, page 3182

  489. 		endpoint_queue_head[1].next = (uint32_t)&endpoint0_transfer_data;

  490. 		endpoint_queue_head[1].status = 0;

  491. 		USB1_ENDPTPRIME |= (1<<16);

  492. 		while (USB1_ENDPTPRIME) ;

  493. 	}

  494. 	endpoint0_transfer_ack.next = 1;

  495. 	endpoint0_transfer_ack.status = (1<<7) | (notify ? (1 << 15) : 0);

  496. 	endpoint0_transfer_ack.pointer0 = 0;

  497. 	endpoint_queue_head[0].next = (uint32_t)&endpoint0_transfer_ack;

  498. 	endpoint_queue_head[0].status = 0;

  499. 	USB1_ENDPTCOMPLETE |= (1<<0) | (1<<16);

  500. 	USB1_ENDPTPRIME |= (1<<0);

  501. 	endpoint0_notify_mask = (notify ? (1 << 0) : 0);

  502. 	while (USB1_ENDPTPRIME) ;

  503. }

  504. 

  505. static void endpoint0_receive(void *data, uint32_t len, int notify)

  506. {

  507. 	//printf("rx %lu\n", len);

  508. 	if (len > 0) {

  509. 		// Executing A Transfer Descriptor, page 3182

  510. 		endpoint0_transfer_data.next = 1;

  511. 		endpoint0_transfer_data.status = (len << 16) | (1<<7);

  512. 		uint32_t addr = (uint32_t)data;

  513. 		endpoint0_transfer_data.pointer0 = addr; // format: table 55-60, pg 3159

  514. 		endpoint0_transfer_data.pointer1 = addr + 4096;

  515. 		endpoint0_transfer_data.pointer2 = addr + 8192;

  516. 		endpoint0_transfer_data.pointer3 = addr + 12288;

  517. 		endpoint0_transfer_data.pointer4 = addr + 16384;

  518. 		//  Case 1: Link list is empty, page 3182

  519. 		endpoint_queue_head[0].next = (uint32_t)&endpoint0_transfer_data;

  520. 		endpoint_queue_head[0].status = 0;

  521. 		USB1_ENDPTPRIME |= (1<<0);

  522. 		while (USB1_ENDPTPRIME) ;

  523. 	}

  524. 	endpoint0_transfer_ack.next = 1;

  525. 	endpoint0_transfer_ack.status = (1<<7) | (notify ? (1 << 15) : 0);

  526. 	endpoint0_transfer_ack.pointer0 = 0;

  527. 	endpoint_queue_head[1].next = (uint32_t)&endpoint0_transfer_ack;

  528. 	endpoint_queue_head[1].status = 0;

  529. 	USB1_ENDPTCOMPLETE |= (1<<0) | (1<<16);

  530. 	USB1_ENDPTPRIME |= (1<<16);

  531. 	endpoint0_notify_mask = (notify ? (1 << 16) : 0);

  532. 	while (USB1_ENDPTPRIME) ;

  533. }

  534. 

  535. /*typedef union {

  536.  struct {

  537.   union {

  538.    struct {

  539.         uint8_t bmRequestType;

  540.         uint8_t bRequest;

  541.    };

  542.         uint16_t wRequestAndType;

  543.   };

  544.         uint16_t wValue;

  545.         uint16_t wIndex;

  546.         uint16_t wLength;

  547.  };

  548.  struct {

  549.         uint32_t word1;

  550.         uint32_t word2;

  551.  };

  552. 	uint64_t bothwords;

  553. } setup_t; */

  554. 

  555. 

  556. static void endpoint0_complete(void)

  557. {

  558. 	setup_t setup;

  559. 

  560. 	setup.bothwords = endpoint0_setupdata.bothwords;

  561. 	//printf("complete %x %x %x\n", setup.word1, setup.word2, endpoint0_buffer[0]);

  562. #ifdef CDC_STATUS_INTERFACE

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

  564. 		memcpy(usb_cdc_line_coding, endpoint0_buffer, 7);

  565. 		printf("usb_cdc_line_coding, baud=%u\n", usb_cdc_line_coding[0]);

  566. 		if (usb_cdc_line_coding[0] == 134) {

  567. 			USB1_USBINTR |= USB_USBINTR_SRE;

  568. 			usb_reboot_timer = 80; // TODO: 10 if only 12 Mbit/sec

  569. 		}

  570. 	}

  571. #endif

  572. #ifdef SEREMU_INTERFACE

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

  574. 	  && endpoint0_buffer[0] == 0xA9 && endpoint0_buffer[1] == 0x45

  575. 	  && endpoint0_buffer[2] == 0xC2 && endpoint0_buffer[3] == 0x6B) {

  576. 		printf("seremu reboot request\n");

  577. 		USB1_USBINTR |= USB_USBINTR_SRE;

  578. 		usb_reboot_timer = 80; // TODO: 10 if only 12 Mbit/sec

  579. 	}

  580. #endif

  581. }

  582. 

  583. static void usb_endpoint_config(endpoint_t *qh, uint32_t config, void (*callback)(transfer_t *))

  584. {

  585. 	memset(qh, 0, sizeof(endpoint_t));

  586. 	qh->config = config;

  587. 	qh->next = 1; // Terminate bit = 1

  588. 	qh->callback_function = callback;

  589. }

  590. 

  591. void usb_config_rx(uint32_t ep, uint32_t packet_size, int do_zlp, void (*cb)(transfer_t *))

  592. {

  593. 	uint32_t config = (packet_size << 16) | (do_zlp ? 0 : (1 << 29));

  594. 	if (ep < 2 || ep > NUM_ENDPOINTS) return;

  595. 	usb_endpoint_config(endpoint_queue_head + ep * 2, config, cb);

  596. 	if (cb) endpointN_notify_mask |= (1 << ep);

  597. }

  598. 

  599. void usb_config_tx(uint32_t ep, uint32_t packet_size, int do_zlp, void (*cb)(transfer_t *))

  600. {

  601. 	uint32_t config = (packet_size << 16) | (do_zlp ? 0 : (1 << 29));

  602. 	if (ep < 2 || ep > NUM_ENDPOINTS) return;

  603. 	usb_endpoint_config(endpoint_queue_head + ep * 2 + 1, config, cb);

  604. 	if (cb) endpointN_notify_mask |= (1 << (ep + 16));

  605. }

  606. 

  607. 

  608. 

  609. void usb_prepare_transfer(transfer_t *transfer, const void *data, uint32_t len, uint32_t param)

  610. {

  611. 	transfer->next = 1;

  612. 	transfer->status = (len << 16) | (1<<7);

  613. 	uint32_t addr = (uint32_t)data;

  614. 	transfer->pointer0 = addr;

  615. 	transfer->pointer1 = addr + 4096;

  616. 	transfer->pointer2 = addr + 8192;

  617. 	transfer->pointer3 = addr + 12288;

  618. 	transfer->pointer4 = addr + 16384;

  619. 	transfer->callback_param = param;

  620. }

  621. 

  622. #if 0

  623. void usb_print_transfer_log(void)

  624. {

  625. 	uint32_t i, count;

  626. 	printf("log %d transfers\n", transfer_log_count);

  627. 	count = transfer_log_count;

  628. 	if (count > LOG_SIZE) count = LOG_SIZE;

  629. 

  630. 	for (i=0; i < count; i++) {

  631. 		if (transfer_log_head == 0) transfer_log_head = LOG_SIZE;

  632. 		transfer_log_head--;

  633. 		uint32_t log = transfer_log[transfer_log_head];

  634. 		printf(" %c %X\n", log >> 8, (int)(log & 255));

  635. 	}

  636. }

  637. #endif

  638. 

  639. static void schedule_transfer(endpoint_t *endpoint, uint32_t epmask, transfer_t *transfer)

  640. {

  641. 	// when we stop at 6, why is the last transfer missing from the USB output?

  642. 	//if (transfer_log_count >= 6) return;

  643. 

  644. 	//uint32_t ret = (*(const uint8_t *)transfer->pointer0) << 8;

  645. 	if (endpoint->callback_function) {

  646. 		transfer->status |= (1<<15);

  647. 	}

  648. 	__disable_irq();

  649. 	//digitalWriteFast(1, HIGH);

  650. 	// Executing A Transfer Descriptor, page 2468 (RT1060 manual, Rev 1, 12/2018)

  651. 	transfer_t *last = endpoint->last_transfer;

  652. 	if (last) {

  653. 		last->next = (uint32_t)transfer;

  654. 		if (USB1_ENDPTPRIME & epmask) goto end;

  655. 		//digitalWriteFast(2, HIGH);

  656. 		//ret |= 0x01;

  657. 		uint32_t status;

  658. 		do {

  659. 			USB1_USBCMD |= USB_USBCMD_ATDTW;

  660. 			status = USB1_ENDPTSTATUS;

  661. 		} while (!(USB1_USBCMD & USB_USBCMD_ATDTW));

  662. 		//USB1_USBCMD &= ~USB_USBCMD_ATDTW;

  663. 		if (status & epmask) goto end;

  664. 		//ret |= 0x02;

  665. 	}

  666. 	//digitalWriteFast(4, HIGH);

  667. 	endpoint->next = (uint32_t)transfer;

  668. 	endpoint->status = 0;

  669. 	USB1_ENDPTPRIME |= epmask;

  670. 	endpoint->first_transfer = transfer;

  671. end:

  672. 	endpoint->last_transfer = transfer;

  673. 	__enable_irq();

  674. 	//digitalWriteFast(4, LOW);

  675. 	//digitalWriteFast(3, LOW);

  676. 	//digitalWriteFast(2, LOW);

  677. 	//digitalWriteFast(1, LOW);

  678. 	//if (transfer_log_head > LOG_SIZE) transfer_log_head = 0;

  679. 	//transfer_log[transfer_log_head++] = ret;

  680. 	//transfer_log_count++;

  681. }

  682. 	// ENDPTPRIME -  Software should write a one to the corresponding bit when

  683. 	//		 posting a new transfer descriptor to an endpoint queue head.

  684. 	//		 Hardware automatically uses this bit to begin parsing for a

  685. 	//		 new transfer descriptor from the queue head and prepare a

  686. 	//		 transmit buffer. Hardware clears this bit when the associated

  687. 	//		 endpoint(s) is (are) successfully primed.

  688. 	//		 Momentarily set by hardware during hardware re-priming

  689. 	//		 operations when a dTD is retired, and the dQH is updated.

  690. 

  691. 	// ENDPTSTATUS - Transmit Buffer Ready - set to one by the hardware as a

  692. 	//		 response to receiving a command from a corresponding bit

  693. 	//		 in the ENDPTPRIME register.  . Buffer ready is cleared by

  694. 	//		 USB reset, by the USB DMA system, or through the ENDPTFLUSH

  695. 	//		 register.  (so 0=buffer ready, 1=buffer primed for transmit)

  696. 

  697. 	//  USBCMD.ATDTW - This bit is used as a semaphore to ensure proper addition

  698. 	//		   of a new dTD to an active (primed) endpoint's linked list.

  699. 	//		   This bit is set and cleared by software.

  700. 	//		   This bit would also be cleared by hardware when state machine

  701. 	//		   is hazard region for which adding a dTD to a primed endpoint

  702. 	//		    may go unrecognized.

  703. 

  704. /*struct endpoint_struct {

  705. 	uint32_t config;

  706. 	uint32_t current;

  707. 	uint32_t next;

  708. 	uint32_t status;

  709. 	uint32_t pointer0;

  710. 	uint32_t pointer1;

  711. 	uint32_t pointer2;

  712. 	uint32_t pointer3;

  713. 	uint32_t pointer4;

  714. 	uint32_t reserved;

  715. 	uint32_t setup0;

  716. 	uint32_t setup1;

  717. 	transfer_t *first_transfer;

  718. 	transfer_t *last_transfer;

  719. 	void (*callback_function)(transfer_t *completed_transfer);

  720. 	uint32_t unused1;

  721. };*/

  722. 

  723. static void run_callbacks(endpoint_t *ep)

  724. {

  725. 	//printf("run_callbacks\n");

  726. 	transfer_t *first = ep->first_transfer;

  727. 	if (first == NULL) return;

  728. 

  729. 	// count how many transfers are completed, then remove them from the endpoint's list

  730. 	uint32_t count = 0;

  731. 	transfer_t *t = first;

  732. 	while (1) {

  733. 		if (t->status & (1<<7)) {

  734. 			// found a still-active transfer, new list begins here

  735. 			//printf(" still active\n");

  736. 			ep->first_transfer = t;

  737. 			break;

  738. 		}

  739. 		count++;

  740. 		t = (transfer_t *)t->next;

  741. 		if ((uint32_t)t == 1) {

  742. 			// reached end of list, all need callbacks, new list is empty

  743. 			//printf(" end of list\n");

  744. 			ep->first_transfer = NULL;

  745. 			ep->last_transfer = NULL;

  746. 			break;

  747. 		}

  748. 	}

  749. 	// do all the callbacks

  750. 	while (count) {

  751. 		transfer_t *next = (transfer_t *)first->next;

  752. 		ep->callback_function(first);

  753. 		first = next;

  754. 		count--;

  755. 	}

  756. }

  757. 

  758. void usb_transmit(int endpoint_number, transfer_t *transfer)

  759. {

  760. 	if (endpoint_number < 2 || endpoint_number > NUM_ENDPOINTS) return;

  761. 	endpoint_t *endpoint = endpoint_queue_head + endpoint_number * 2 + 1;

  762. 	uint32_t mask = 1 << (endpoint_number + 16);

  763. 	schedule_transfer(endpoint, mask, transfer);

  764. }

  765. 

  766. void usb_receive(int endpoint_number, transfer_t *transfer)

  767. {

  768. 	if (endpoint_number < 2 || endpoint_number > NUM_ENDPOINTS) return;

  769. 	endpoint_t *endpoint = endpoint_queue_head + endpoint_number * 2;

  770. 	uint32_t mask = 1 << endpoint_number;

  771. 	schedule_transfer(endpoint, mask, transfer);

  772. }

  773. 

  774. uint32_t usb_transfer_status(const transfer_t *transfer)

  775. {

  776. #if 0

  777. 	uint32_t status, cmd;

  778. 	//int count=0;

  779. 	cmd = USB1_USBCMD;

  780. 	while (1) {

  781. 		__disable_irq();

  782. 		USB1_USBCMD = cmd | USB_USBCMD_ATDTW;

  783. 		status = transfer->status;

  784. 		cmd = USB1_USBCMD;

  785. 		__enable_irq();

  786. 		if (cmd & USB_USBCMD_ATDTW) return status;

  787. 		//if (!(cmd & USB_USBCMD_ATDTW)) continue;

  788. 		//if (status & 0x80) break; // for still active, only 1 reading needed

  789. 		//if (++count > 1) break; // for completed, check 10 times

  790. 	}

  791. #else

  792. 	return transfer->status;

  793. #endif

  794. }

  795.