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

854 lines
26KB
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 "usb_seremu.h"

  6. #include "usb_keyboard.h"

  7. #include "usb_mouse.h"

  8. #include "usb_joystick.h"

  9. #include "usb_touch.h"

  10. #include "usb_midi.h"

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

  12. #include "avr/pgmspace.h"

  13. #include <string.h>

  14. #include "debug/printf.h"

  15. 

  16. //#define LOG_SIZE  20

  17. //uint32_t transfer_log_head=0;

  18. //uint32_t transfer_log_count=0;

  19. //uint32_t transfer_log[LOG_SIZE];

  20. 

  21. // device mode, page 3155

  22. 

  23. typedef struct endpoint_struct endpoint_t;

  24. 

  25. struct endpoint_struct {

  26. 	uint32_t config;

  27. 	uint32_t current;

  28. 	uint32_t next;

  29. 	uint32_t status;

  30. 	uint32_t pointer0;

  31. 	uint32_t pointer1;

  32. 	uint32_t pointer2;

  33. 	uint32_t pointer3;

  34. 	uint32_t pointer4;

  35. 	uint32_t reserved;

  36. 	uint32_t setup0;

  37. 	uint32_t setup1;

  38. 	transfer_t *first_transfer;

  39. 	transfer_t *last_transfer;

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

  41. 	uint32_t unused1;

  42. };

  43. 

  44. /*struct transfer_struct {

  45. 	uint32_t next;

  46. 	uint32_t status;

  47. 	uint32_t pointer0;

  48. 	uint32_t pointer1;

  49. 	uint32_t pointer2;

  50. 	uint32_t pointer3;

  51. 	uint32_t pointer4;

  52. 	uint32_t callback_param;

  53. };*/

  54. 

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

  56. 

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

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

  59. 

  60. 

  61. typedef union {

  62.  struct {

  63.   union {

  64.    struct {

  65.         uint8_t bmRequestType;

  66.         uint8_t bRequest;

  67.    };

  68.         uint16_t wRequestAndType;

  69.   };

  70.         uint16_t wValue;

  71.         uint16_t wIndex;

  72.         uint16_t wLength;

  73.  };

  74.  struct {

  75.         uint32_t word1;

  76.         uint32_t word2;

  77.  };

  78. 	uint64_t bothwords;

  79. } setup_t;

  80. 

  81. static setup_t endpoint0_setupdata;

  82. static uint32_t endpoint0_notify_mask=0;

  83. static uint32_t endpointN_notify_mask=0;

  84. //static int reset_count=0;

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

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

  87. static uint8_t endpoint0_buffer[8];

  88. static uint8_t sof_usage = 0;

  89. static uint8_t usb_reboot_timer = 0;

  90. 

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

  92. extern const uint8_t usb_config_descriptor_480[];

  93. extern const uint8_t usb_config_descriptor_12[];

  94. 

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

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

  97. 

  98. static void isr(void);

  99. static void endpoint0_setup(uint64_t setupdata);

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

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

  102. static void endpoint0_complete(void);

  103. 

  104. 

  105. static void run_callbacks(endpoint_t *ep);

  106. 

  107. 

  108. FLASHMEM void usb_init(void)

  109. {

  110. 	// TODO: only enable when VBUS detected

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

  112. 	// TODO: protect PMU access with MPU

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

  114. 		| PMU_REG_3P0_ENABLE_LINREG;

  115. 

  116. 	usb_init_serialnumber();

  117. 

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

  119. 

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

  121. 	

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

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

  124. 	USB1_BURSTSIZE = 0x0404;

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

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

  127. 

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

  129. 	// USBPHYx_CTRLn and CCM_ANALOG_USBPHYx_PLL_480_CTRLn.

  130. 

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

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

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

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

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

  136. 

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

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

  139. #if 1

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

  141. 	  | USBPHY_PWD_RXPWDENV | USBPHY_PWD_TXPWDV2I | USBPHY_PWD_TXPWDIBIAS

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

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

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

  145. 		USBPHY1_CTRL_SET = USBPHY_CTRL_SFTRST; // USBPHY1_CTRL page 3292

  146. 		USB1_USBCMD |= USB_USBCMD_RST; // reset controller

  147. 		int count=0;

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

  149. 		NVIC_CLEAR_PENDING(IRQ_USB1);

  150. 		USBPHY1_CTRL_CLR = USBPHY_CTRL_SFTRST; // reset PHY

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

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

  153. 		//delay(10);

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

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

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

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

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

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

  160. 		delay(25);

  161. 	}

  162. #endif

  163. 	// Device Controller Initialization, page 3161

  164. 	// USBCMD	pg 3216

  165. 	// USBSTS	pg 3220

  166. 	// USBINTR	pg 3224

  167. 	// DEVICEADDR	pg 3227

  168. 	// ENDPTLISTADDR   3229

  169. 	// USBMODE	pg 3244

  170. 	// ENDPTSETUPSTAT  3245

  171. 	// ENDPTPRIME	pg 3246

  172. 	// ENDPTFLUSH	pg 3247

  173. 	// ENDPTSTAT	pg 3247

  174. 	// ENDPTCOMPLETE   3248

  175. 	// ENDPTCTRL0	pg 3249

  176. 

  177. 	USBPHY1_CTRL_CLR = USBPHY_CTRL_CLKGATE;

  178. 	USBPHY1_PWD = 0;

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

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

  181. 

  182. 	USB1_USBMODE = USB_USBMODE_CM(2) | USB_USBMODE_SLOM;

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

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

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

  186. 	USB1_ENDPOINTLISTADDR = (uint32_t)&endpoint_queue_head;

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

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

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

  190. 		USB_USBINTR_URE | USB_USBINTR_SLE;

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

  192. 	attachInterruptVector(IRQ_USB1, &isr);

  193. 	NVIC_ENABLE_IRQ(IRQ_USB1);

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

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

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

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

  198. 	USB1_USBCMD = USB_USBCMD_RS;

  199. 	//transfer_log_head = 0;

  200. 	//transfer_log_count = 0;

  201. }

  202. 

  203. 

  204. static void isr(void)

  205. {

  206. 	//printf("*");

  207. 

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

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

  210. 	uint32_t status = USB1_USBSTS;

  211. 	USB1_USBSTS = status;

  212. 

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

  214. 	// USB_USBSTS_SRI - set at start of frame

  215. 	// USB_USBSTS_SRI - set when USB reset detected

  216. 

  217. 	if (status & USB_USBSTS_UI) {

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

  219. 		uint32_t setupstatus = USB1_ENDPTSETUPSTAT;

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

  221. 		while (setupstatus) {

  222. 			USB1_ENDPTSETUPSTAT = setupstatus;

  223. 			setup_t s;

  224. 			do {

  225. 				USB1_USBCMD |= USB_USBCMD_SUTW;

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

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

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

  229. 			USB1_USBCMD &= ~USB_USBCMD_SUTW;

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

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

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

  233. 			endpoint0_notify_mask = 0;

  234. 			endpoint0_setup(s.bothwords);

  235. 			setupstatus = USB1_ENDPTSETUPSTAT; // page 3175

  236. 		}

  237. 		uint32_t completestatus = USB1_ENDPTCOMPLETE;

  238. 		if (completestatus) {

  239. 			USB1_ENDPTCOMPLETE = completestatus;

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

  241. 			if (completestatus & endpoint0_notify_mask) {

  242. 				endpoint0_notify_mask = 0;

  243. 				endpoint0_complete();

  244. 			}

  245. 			completestatus &= endpointN_notify_mask;

  246. 			if (completestatus) {

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

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

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

  250. 						run_callbacks(endpoint_queue_head + i * 2);

  251. 					}

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

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

  254. 					}

  255. 				}

  256. 			}

  257. 		}

  258. 	}

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

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

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

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

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

  264. 		if ((USB1_PORTSC1 & USB_PORTSC1_PR)) {

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

  266. 		} else {

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

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

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

  270. 		}

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

  272. 		usb_serial_reset();

  273. 		#endif

  274. 		endpointN_notify_mask = 0;

  275. 		// TODO: Free all allocated dTDs

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

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

  278. 			//USB1_USBCMD &= ~USB_USBCMD_RS;

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

  280. 		//}

  281. 	}

  282. 	if (status & USB_USBSTS_TI0) {

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

  284. 	}

  285. 	if (status & USB_USBSTS_TI1) {

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

  287. 	}

  288. 	if (status & USB_USBSTS_PCI) {

  289. 		if (USB1_PORTSC1 & USB_PORTSC1_HSP) {

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

  291. 			usb_high_speed = 1;

  292. 		} else {

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

  294. 			usb_high_speed = 0;

  295. 		}

  296. 	}

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

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

  299. 	}

  300. 	if (status & USB_USBSTS_UEI) {

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

  302. 	}

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

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

  305. 		if (usb_reboot_timer) {

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

  307. 				usb_stop_sof_interrupts(NUM_INTERFACE);

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

  309. 			}

  310. 		}

  311. 		#ifdef MIDI_INTERFACE

  312. 		usb_midi_flush_output();

  313. 		#endif

  314. 		#ifdef MULTITOUCH_INTERFACE

  315. 		usb_touchscreen_update_callback();

  316. 		#endif

  317. 	}

  318. }

  319. 

  320. 

  321. void usb_start_sof_interrupts(int interface)

  322. {

  323. 	__disable_irq();

  324. 	sof_usage |= (1 << interface);

  325. 	uint32_t intr = USB1_USBINTR;

  326. 	if (!(intr & USB_USBINTR_SRE)) {

  327. 		USB1_USBSTS = USB_USBSTS_SRI; // clear prior SOF before SOF IRQ enable

  328. 		USB1_USBINTR = intr | USB_USBINTR_SRE;

  329. 	}

  330. 	__enable_irq();

  331. }

  332. 

  333. void usb_stop_sof_interrupts(int interface)

  334. {

  335. 	sof_usage &= ~(1 << interface);

  336. 	if (sof_usage == 0) {

  337. 		USB1_USBINTR &= ~USB_USBINTR_SRE;

  338. 	}

  339. }

  340. 

  341. 

  342. 

  343. 

  344. /*

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

  346. 	uint32_t next;

  347. 	uint32_t status;

  348. 	uint32_t pointer0;

  349. 	uint32_t pointer1;

  350. 	uint32_t pointer2;

  351. 	uint32_t pointer3;

  352. 	uint32_t pointer4;

  353. 	uint32_t unused1;

  354. };

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

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

  357. */

  358. 

  359. static uint8_t reply_buffer[8];

  360. 

  361. static void endpoint0_setup(uint64_t setupdata)

  362. {

  363. 	setup_t setup;

  364. 	uint32_t endpoint, dir, ctrl;

  365. 	const usb_descriptor_list_t *list;

  366. 

  367. 	setup.bothwords = setupdata;

  368. 	switch (setup.wRequestAndType) {

  369. 	  case 0x0500: // SET_ADDRESS

  370. 		endpoint0_receive(NULL, 0, 0);

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

  372. 		return;

  373. 	  case 0x0900: // SET_CONFIGURATION

  374. 		usb_configuration = setup.wValue;

  375. 		// configure all other endpoints

  376. 		#if defined(ENDPOINT2_CONFIG)

  377. 		USB1_ENDPTCTRL2 = ENDPOINT2_CONFIG;

  378. 		#endif

  379. 		#if defined(ENDPOINT3_CONFIG)

  380. 		USB1_ENDPTCTRL3 = ENDPOINT3_CONFIG;

  381. 		#endif

  382. 		#if defined(ENDPOINT4_CONFIG)

  383. 		USB1_ENDPTCTRL4 = ENDPOINT4_CONFIG;

  384. 		#endif

  385. 		#if defined(ENDPOINT5_CONFIG)

  386. 		USB1_ENDPTCTRL5 = ENDPOINT5_CONFIG;

  387. 		#endif

  388. 		#if defined(ENDPOINT6_CONFIG)

  389. 		USB1_ENDPTCTRL6 = ENDPOINT6_CONFIG;

  390. 		#endif

  391. 		#if defined(ENDPOINT7_CONFIG)

  392. 		USB1_ENDPTCTRL7 = ENDPOINT7_CONFIG;

  393. 		#endif

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

  395. 		usb_serial_configure();

  396. 		#elif defined(SEREMU_INTERFACE)

  397. 		usb_seremu_configure();

  398. 		#endif

  399. 		#if defined(RAWHID_INTERFACE)

  400. 		usb_rawhid_configure();

  401. 		#endif

  402. 		#if defined(KEYBOARD_INTERFACE)

  403. 		usb_keyboard_configure();

  404. 		#endif

  405. 		#if defined(MOUSE_INTERFACE)

  406. 		usb_mouse_configure();

  407. 		#endif

  408. 		#if defined(JOYSTICK_INTERFACE)

  409. 		usb_joystick_configure();

  410. 		#endif

  411. 		#if defined(MULTITOUCH_INTERFACE)

  412. 		usb_touchscreen_configure();

  413. 		#endif

  414. 		#if defined(MIDI_INTERFACE)

  415. 		usb_midi_configure();

  416. 		#endif

  417. 		endpoint0_receive(NULL, 0, 0);

  418. 		return;

  419. 	  case 0x0880: // GET_CONFIGURATION

  420. 		reply_buffer[0] = usb_configuration;

  421. 		endpoint0_transmit(reply_buffer, 1, 0);

  422. 		return;

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

  424. 		reply_buffer[0] = 0;

  425. 		reply_buffer[1] = 0;

  426. 		endpoint0_transmit(reply_buffer, 2, 0);

  427. 		return;

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

  429. 		endpoint = setup.wIndex & 0x7F;

  430. 		if (endpoint > 7) break;

  431. 		dir = setup.wIndex & 0x80;

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

  433. 		reply_buffer[0] = 0;

  434. 		reply_buffer[1] = 0;

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

  436. 			reply_buffer[0] = 1;

  437. 		}

  438. 		endpoint0_transmit(reply_buffer, 2, 0);

  439. 		return;

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

  441. 		endpoint = setup.wIndex & 0x7F;

  442. 		if (endpoint > 7) break;

  443. 		dir = setup.wIndex & 0x80;

  444. 		if (dir) {

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

  446. 		} else {

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

  448. 		}

  449. 		endpoint0_receive(NULL, 0, 0);

  450. 		return;

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

  452. 		endpoint = setup.wIndex & 0x7F;

  453. 		if (endpoint > 7) break;

  454. 		dir = setup.wIndex & 0x80;

  455. 		if (dir) {

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

  457. 		} else {

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

  459. 		}

  460. 		endpoint0_receive(NULL, 0, 0);

  461. 		return;

  462. 	  case 0x0680: // GET_DESCRIPTOR

  463. 	  case 0x0681:

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

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

  466. 				uint32_t datalen;

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

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

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

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

  471. 				} else {

  472. 					datalen = list->length;

  473. 				}

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

  475. 

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

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

  478. 					// config descriptor needs to adapt to speed

  479. 					const uint8_t *src = usb_config_descriptor_12;

  480. 					if (usb_high_speed) src = usb_config_descriptor_480;

  481. 					memcpy(usb_descriptor_buffer, src, datalen);

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

  483. 					// other speed config also needs to adapt

  484. 					const uint8_t *src = usb_config_descriptor_480;

  485. 					if (usb_high_speed) src = usb_config_descriptor_12;

  486. 					memcpy(usb_descriptor_buffer, src, datalen);

  487. 					usb_descriptor_buffer[1] = 7;

  488. 				} else {

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

  490. 				}

  491. 				// prep transmit

  492. 				arm_dcache_flush_delete(usb_descriptor_buffer, datalen);

  493. 				endpoint0_transmit(usb_descriptor_buffer, datalen, 0);

  494. 				return;

  495. 			}

  496. 		}

  497. 		break;

  498. #if defined(CDC_STATUS_INTERFACE)

  499. 	  case 0x2221: // CDC_SET_CONTROL_LINE_STATE

  500. 		usb_cdc_line_rtsdtr_millis = systick_millis_count;

  501. 		usb_cdc_line_rtsdtr = setup.wValue;

  502. 	  case 0x2321: // CDC_SEND_BREAK

  503. 		endpoint0_receive(NULL, 0, 0);

  504. 		return;

  505. 	  case 0x2021: // CDC_SET_LINE_CODING

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

  507. 		endpoint0_setupdata.bothwords = setupdata;

  508. 		endpoint0_receive(endpoint0_buffer, 7, 1);

  509. 		return;

  510. #endif

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

  512. 	  case 0x0921: // HID SET_REPORT

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

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

  515. 			endpoint0_setupdata.bothwords = setup.bothwords;

  516. 			endpoint0_buffer[0] = 0xE9;

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

  518. 			return;

  519. 		}

  520. 		break;

  521. #endif

  522. 	}

  523. 	USB1_ENDPTCTRL0 = 0x000010001; // stall

  524. }

  525. 

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

  527. {

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

  529. 	if (len > 0) {

  530. 		// Executing A Transfer Descriptor, page 3182

  531. 		endpoint0_transfer_data.next = 1;

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

  533. 		uint32_t addr = (uint32_t)data;

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

  535. 		endpoint0_transfer_data.pointer1 = addr + 4096;

  536. 		endpoint0_transfer_data.pointer2 = addr + 8192;

  537. 		endpoint0_transfer_data.pointer3 = addr + 12288;

  538. 		endpoint0_transfer_data.pointer4 = addr + 16384;

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

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

  541. 		endpoint_queue_head[1].status = 0;

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

  543. 		while (USB1_ENDPTPRIME) ;

  544. 	}

  545. 	endpoint0_transfer_ack.next = 1;

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

  547. 	endpoint0_transfer_ack.pointer0 = 0;

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

  549. 	endpoint_queue_head[0].status = 0;

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

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

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

  553. 	while (USB1_ENDPTPRIME) ;

  554. }

  555. 

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

  557. {

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

  559. 	if (len > 0) {

  560. 		// Executing A Transfer Descriptor, page 3182

  561. 		endpoint0_transfer_data.next = 1;

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

  563. 		uint32_t addr = (uint32_t)data;

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

  565. 		endpoint0_transfer_data.pointer1 = addr + 4096;

  566. 		endpoint0_transfer_data.pointer2 = addr + 8192;

  567. 		endpoint0_transfer_data.pointer3 = addr + 12288;

  568. 		endpoint0_transfer_data.pointer4 = addr + 16384;

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

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

  571. 		endpoint_queue_head[0].status = 0;

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

  573. 		while (USB1_ENDPTPRIME) ;

  574. 	}

  575. 	endpoint0_transfer_ack.next = 1;

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

  577. 	endpoint0_transfer_ack.pointer0 = 0;

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

  579. 	endpoint_queue_head[1].status = 0;

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

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

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

  583. 	while (USB1_ENDPTPRIME) ;

  584. }

  585. 

  586. /*typedef union {

  587.  struct {

  588.   union {

  589.    struct {

  590.         uint8_t bmRequestType;

  591.         uint8_t bRequest;

  592.    };

  593.         uint16_t wRequestAndType;

  594.   };

  595.         uint16_t wValue;

  596.         uint16_t wIndex;

  597.         uint16_t wLength;

  598.  };

  599.  struct {

  600.         uint32_t word1;

  601.         uint32_t word2;

  602.  };

  603. 	uint64_t bothwords;

  604. } setup_t; */

  605. 

  606. 

  607. static void endpoint0_complete(void)

  608. {

  609. 	setup_t setup;

  610. 

  611. 	setup.bothwords = endpoint0_setupdata.bothwords;

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

  613. #ifdef CDC_STATUS_INTERFACE

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

  615. 		memcpy(usb_cdc_line_coding, endpoint0_buffer, 7);

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

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

  618. 			usb_start_sof_interrupts(NUM_INTERFACE);

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

  620. 		}

  621. 	}

  622. #endif

  623. #ifdef KEYBOARD_INTERFACE

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

  625. 		keyboard_leds = endpoint0_buffer[0];

  626. 		usb_start_sof_interrupts(NUM_INTERFACE);

  627. 	}

  628. #endif

  629. #ifdef SEREMU_INTERFACE

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

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

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

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

  634. 		usb_start_sof_interrupts(NUM_INTERFACE);

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

  636. 	}

  637. #endif

  638. }

  639. 

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

  641. {

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

  643. 	qh->config = config;

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

  645. 	qh->callback_function = callback;

  646. }

  647. 

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

  649. {

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

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

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

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

  654. }

  655. 

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

  657. {

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

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

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

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

  662. }

  663. 

  664. 

  665. 

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

  667. {

  668. 	transfer->next = 1;

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

  670. 	uint32_t addr = (uint32_t)data;

  671. 	transfer->pointer0 = addr;

  672. 	transfer->pointer1 = addr + 4096;

  673. 	transfer->pointer2 = addr + 8192;

  674. 	transfer->pointer3 = addr + 12288;

  675. 	transfer->pointer4 = addr + 16384;

  676. 	transfer->callback_param = param;

  677. }

  678. 

  679. #if 0

  680. void usb_print_transfer_log(void)

  681. {

  682. 	uint32_t i, count;

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

  684. 	count = transfer_log_count;

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

  686. 

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

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

  689. 		transfer_log_head--;

  690. 		uint32_t log = transfer_log[transfer_log_head];

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

  692. 	}

  693. }

  694. #endif

  695. 

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

  697. {

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

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

  700. 

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

  702. 	if (endpoint->callback_function) {

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

  704. 	}

  705. 	__disable_irq();

  706. 	//digitalWriteFast(1, HIGH);

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

  708. 	transfer_t *last = endpoint->last_transfer;

  709. 	if (last) {

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

  711. 		if (USB1_ENDPTPRIME & epmask) goto end;

  712. 		//digitalWriteFast(2, HIGH);

  713. 		//ret |= 0x01;

  714. 		uint32_t status;

  715. 		do {

  716. 			USB1_USBCMD |= USB_USBCMD_ATDTW;

  717. 			status = USB1_ENDPTSTATUS;

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

  719. 		//USB1_USBCMD &= ~USB_USBCMD_ATDTW;

  720. 		if (status & epmask) goto end;

  721. 		//ret |= 0x02;

  722. 	}

  723. 	//digitalWriteFast(4, HIGH);

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

  725. 	endpoint->status = 0;

  726. 	USB1_ENDPTPRIME |= epmask;

  727. 	endpoint->first_transfer = transfer;

  728. end:

  729. 	endpoint->last_transfer = transfer;

  730. 	__enable_irq();

  731. 	//digitalWriteFast(4, LOW);

  732. 	//digitalWriteFast(3, LOW);

  733. 	//digitalWriteFast(2, LOW);

  734. 	//digitalWriteFast(1, LOW);

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

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

  737. 	//transfer_log_count++;

  738. }

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

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

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

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

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

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

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

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

  747. 

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

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

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

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

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

  753. 

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

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

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

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

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

  759. 	//		    may go unrecognized.

  760. 

  761. /*struct endpoint_struct {

  762. 	uint32_t config;

  763. 	uint32_t current;

  764. 	uint32_t next;

  765. 	uint32_t status;

  766. 	uint32_t pointer0;

  767. 	uint32_t pointer1;

  768. 	uint32_t pointer2;

  769. 	uint32_t pointer3;

  770. 	uint32_t pointer4;

  771. 	uint32_t reserved;

  772. 	uint32_t setup0;

  773. 	uint32_t setup1;

  774. 	transfer_t *first_transfer;

  775. 	transfer_t *last_transfer;

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

  777. 	uint32_t unused1;

  778. };*/

  779. 

  780. static void run_callbacks(endpoint_t *ep)

  781. {

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

  783. 	transfer_t *first = ep->first_transfer;

  784. 	if (first == NULL) return;

  785. 

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

  787. 	uint32_t count = 0;

  788. 	transfer_t *t = first;

  789. 	while (1) {

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

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

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

  793. 			ep->first_transfer = t;

  794. 			break;

  795. 		}

  796. 		count++;

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

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

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

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

  801. 			ep->first_transfer = NULL;

  802. 			ep->last_transfer = NULL;

  803. 			break;

  804. 		}

  805. 	}

  806. 	// do all the callbacks

  807. 	while (count) {

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

  809. 		ep->callback_function(first);

  810. 		first = next;

  811. 		count--;

  812. 	}

  813. }

  814. 

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

  816. {

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

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

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

  820. 	schedule_transfer(endpoint, mask, transfer);

  821. }

  822. 

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

  824. {

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

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

  827. 	uint32_t mask = 1 << endpoint_number;

  828. 	schedule_transfer(endpoint, mask, transfer);

  829. }

  830. 

  831. uint32_t usb_transfer_status(const transfer_t *transfer)

  832. {

  833. #if 0

  834. 	uint32_t status, cmd;

  835. 	//int count=0;

  836. 	cmd = USB1_USBCMD;

  837. 	while (1) {

  838. 		__disable_irq();

  839. 		USB1_USBCMD = cmd | USB_USBCMD_ATDTW;

  840. 		status = transfer->status;

  841. 		cmd = USB1_USBCMD;

  842. 		__enable_irq();

  843. 		if (cmd & USB_USBCMD_ATDTW) return status;

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

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

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

  847. 	}

  848. #else

  849. 	return transfer->status;

  850. #endif

  851. }

  852.