visus
/
teensy-core-4.1
Vērot 1
Pievienot zvaigznīti 0
Atdalīts 0
Kods Problēmas 0 Izmaiņu pieprasījumi 0 Laidieni 0 Vikivietne Aktivitāte
Teensy 4.1 core updated for C++20
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
160 Revīzijas
2 Atzari
Koks: fd5065b48a
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no 'fd5065b48a'
${ noResults }
teensy-core-4.1/usb_disk/usb.c

1260 rindas
34KB
Neapstrādāts Vainot Vēsture 

  1. /* USB Serial Example for Teensy USB Development Board

  2.  * http://www.pjrc.com/teensy/usb_serial.html

  3.  * Copyright (c) 2008 PJRC.COM, LLC

  4.  * 

  5.  * Permission is hereby granted, free of charge, to any person obtaining a copy

  6.  * of this software and associated documentation files (the "Software"), to deal

  7.  * in the Software without restriction, including without limitation the rights

  8.  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

  9.  * copies of the Software, and to permit persons to whom the Software is

  10.  * furnished to do so, subject to the following conditions:

  11.  * 

  12.  * The above copyright notice and this permission notice shall be included in

  13.  * all copies or substantial portions of the Software.

  14.  * 

  15.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

  16.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

  17.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

  18.  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

  19.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

  20.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

  21.  * THE SOFTWARE.

  22.  */

  23. 

  24. 

  25. #include "usb_common.h"

  26. #include "usb_private.h"

  27. 

  28. #include "pauls_ugly_debug.h"

  29. 

  30. 

  31. /**************************************************************************

  32.  *

  33.  *  Endpoint Buffer Configuration

  34.  *

  35.  **************************************************************************/

  36. 

  37. 

  38. static const uint8_t PROGMEM endpoint_config_table[] = {

  39. 	1, EP_TYPE_INTERRUPT_IN,  EP_SIZE(DEBUG_TX_SIZE) | DEBUG_TX_BUFFER,

  40. 	1, EP_TYPE_INTERRUPT_OUT, EP_SIZE(DEBUG_RX_SIZE) | DEBUG_RX_BUFFER,

  41. 	1, EP_TYPE_BULK_OUT, EP_SIZE(DISK_RX_SIZE) |  DISK_RX_BUFFER,

  42. 	1, EP_TYPE_BULK_IN, EP_SIZE(DISK_TX_SIZE) | DISK_TX_BUFFER,

  43. 	1, EP_TYPE_INTERRUPT_IN,  EP_SIZE(KEYBOARD_SIZE) | KEYBOARD_BUFFER,

  44. 	0

  45. };

  46. 

  47. 

  48. /**************************************************************************

  49.  *

  50.  *  Descriptor Data

  51.  *

  52.  **************************************************************************/

  53. 

  54. // Descriptors are the data that your computer reads when it auto-detects

  55. // this USB device (called "enumeration" in USB lingo).  The most commonly

  56. // changed items are editable at the top of this file.	Changing things

  57. // in here should only be done by those who've read chapter 9 of the USB

  58. // spec and relevant portions of any USB class specifications!

  59. 

  60. static const uint8_t PROGMEM device_descriptor[] = {

  61. 	18,					// bLength

  62. 	1,					// bDescriptorType

  63. 	0x00, 0x02,				// bcdUSB

  64. 	0,					// bDeviceClass

  65. 	0,					// bDeviceSubClass

  66. 	0,					// bDeviceProtocol

  67. 	ENDPOINT0_SIZE,				// bMaxPacketSize0

  68. 	LSB(VENDOR_ID), MSB(VENDOR_ID),		// idVendor

  69. 	LSB(PRODUCT_ID), MSB(PRODUCT_ID),	// idProduct

  70. 	0x00, 0x01,				// bcdDevice

  71. 	0,					// iManufacturer

  72. 	1,					// iProduct

  73. 	2,					// iSerialNumber

  74. 	1					// bNumConfigurations

  75. };

  76. 

  77. // Keyboard Protocol 1, HID 1.11 spec, Appendix B, page 59-60

  78. static const uint8_t PROGMEM keyboard_hid_report_desc[] = {

  79. 	0x05, 0x01,	     // Usage Page (Generic Desktop),

  80. 	0x09, 0x06,	     // Usage (Keyboard),

  81. 	0xA1, 0x01,	     // Collection (Application),

  82. 	0x75, 0x01,	     //   Report Size (1),

  83. 	0x95, 0x08,	     //   Report Count (8),

  84. 	0x05, 0x07,	     //   Usage Page (Key Codes),

  85. 	0x19, 0xE0,	     //   Usage Minimum (224),

  86. 	0x29, 0xE7,	     //   Usage Maximum (231),

  87. 	0x15, 0x00,	     //   Logical Minimum (0),

  88. 	0x25, 0x01,	     //   Logical Maximum (1),

  89. 	0x81, 0x02,	     //   Input (Data, Variable, Absolute), ;Modifier byte

  90. 	0x95, 0x01,	     //   Report Count (1),

  91. 	0x75, 0x08,	     //   Report Size (8),

  92. 	0x81, 0x03,	     //   Input (Constant),		    ;Reserved byte

  93. 	0x95, 0x05,	     //   Report Count (5),

  94. 	0x75, 0x01,	     //   Report Size (1),

  95. 	0x05, 0x08,	     //   Usage Page (LEDs),

  96. 	0x19, 0x01,	     //   Usage Minimum (1),

  97. 	0x29, 0x05,	     //   Usage Maximum (5),

  98. 	0x91, 0x02,	     //   Output (Data, Variable, Absolute), ;LED report

  99. 	0x95, 0x01,	     //   Report Count (1),

  100. 	0x75, 0x03,	     //   Report Size (3),

  101. 	0x91, 0x03,	     //   Output (Constant),		     ;LED report padding

  102. 	0x95, 0x06,	     //   Report Count (6),

  103. 	0x75, 0x08,	     //   Report Size (8),

  104. 	0x15, 0x00,	     //   Logical Minimum (0),

  105. 	0x25, 0x7F,	     //   Logical Maximum(104),

  106. 	0x05, 0x07,	     //   Usage Page (Key Codes),

  107. 	0x19, 0x00,	     //   Usage Minimum (0),

  108. 	0x29, 0x7F,	     //   Usage Maximum (104),

  109. 	0x81, 0x00,	     //   Input (Data, Array),

  110. 	0xc0		     // End Collection

  111. };

  112. 

  113. static const uint8_t PROGMEM debug_hid_report_desc[] = {

  114. 	0x06, 0xC9, 0xFF,			// Usage Page 0xFFC9 (vendor defined)

  115. 	0x09, 0x04,				// Usage 0x04

  116. 	0xA1, 0x5C,				// Collection 0x5C

  117. 	0x75, 0x08,				// report size = 8 bits (global)

  118. 	0x15, 0x00,				// logical minimum = 0 (global)

  119. 	0x26, 0xFF, 0x00,			// logical maximum = 255 (global)

  120. 	0x95, DEBUG_TX_SIZE,			// report count (global)

  121. 	0x09, 0x75,				// usage (local)

  122. 	0x81, 0x02,				// Input

  123. 	0x95, DEBUG_RX_SIZE,			// report count (global)

  124. 	0x09, 0x76,				// usage (local)

  125. 	0x91, 0x02,				// Output

  126. 	0x95, 0x04,				// report count (global)

  127. 	0x09, 0x76,				// usage (local)

  128. 	0xB1, 0x02,				// Feature

  129. 	0xC0					// end collection

  130. };

  131. 

  132. 

  133. 

  134. #define CONFIG1_DESC_SIZE		( 9 + 9+7+7 + 9+9+7 + 9+9+7+7 )

  135. #define KEYBOARD_HID_DESC_OFFSET	( 9 + 9+7+7 + 9 )

  136. #define DEBUG_HID_DESC_OFFSET		( 9 + 9+7+7 + 9+9+7 + 9 )

  137. 

  138. static const uint8_t PROGMEM config1_descriptor[CONFIG1_DESC_SIZE] = {

  139. 	// configuration descriptor, USB spec 9.6.3, page 264-266, Table 9-10

  140. 	9,				// bLength;

  141. 	2,				// bDescriptorType;

  142. 	LSB(CONFIG1_DESC_SIZE),		// wTotalLength

  143. 	MSB(CONFIG1_DESC_SIZE),

  144. 	NUM_INTERFACE,			// bNumInterfaces

  145. 	1,				// bConfigurationValue

  146. 	0,				// iConfiguration

  147. 	0xC0,				// bmAttributes

  148. 	50,				// bMaxPower

  149. 

  150. 	// interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12

  151. 	9,				// bLength

  152. 	4,				// bDescriptorType

  153. 	DISK_INTERFACE,			// bInterfaceNumber

  154. 	0,				// bAlternateSetting

  155. 	2,				// bNumEndpoints

  156. 	0x08,				// bInterfaceClass (8 = Mass Storage)

  157. 	0x06,				// bInterfaceSubClass (6 = SCSI transparent)

  158. 	0x50,				// bInterfaceProtocol (0x50 = bulk only transport)

  159. 	0,				// iInterface

  160. 	// endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13

  161. 	7,				// bLength

  162. 	5,				// bDescriptorType

  163. 	DISK_RX_ENDPOINT,		// bEndpointAddress

  164. 	0x02,				// bmAttributes (0x02=bulk)

  165. 	DISK_RX_SIZE, 0,		  // wMaxPacketSize

  166. 	0,				// bInterval

  167. 	// endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13

  168. 	7,				// bLength

  169. 	5,				// bDescriptorType

  170. 	DISK_TX_ENDPOINT | 0x80,	// bEndpointAddress

  171. 	0x02,				// bmAttributes (0x02=bulk)

  172. 	DISK_TX_SIZE, 0,		// wMaxPacketSize

  173. 	0,				// bInterval

  174. 

  175. 	// interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12

  176. 	9,				// bLength

  177. 	4,				// bDescriptorType

  178. 	KEYBOARD_INTERFACE,		// bInterfaceNumber

  179. 	0,				// bAlternateSetting

  180. 	1,				// bNumEndpoints

  181. 	0x03,				// bInterfaceClass (0x03 = HID)

  182. 	0x01,				// bInterfaceSubClass (0x01 = Boot)

  183. 	0x01,				// bInterfaceProtocol (0x01 = Keyboard)

  184. 	0,				// iInterface

  185. 	// HID interface descriptor, HID 1.11 spec, section 6.2.1

  186. 	9,				// bLength

  187. 	0x21,				// bDescriptorType

  188. 	0x11, 0x01,			// bcdHID

  189. 	0,				// bCountryCode

  190. 	1,				// bNumDescriptors

  191. 	0x22,				// bDescriptorType

  192. 	sizeof(keyboard_hid_report_desc), // wDescriptorLength

  193. 	0,

  194. 	// endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13

  195. 	7,				// bLength

  196. 	5,				// bDescriptorType

  197. 	KEYBOARD_ENDPOINT | 0x80,	// bEndpointAddress

  198. 	0x03,				// bmAttributes (0x03=intr)

  199. 	KEYBOARD_SIZE, 0,		// wMaxPacketSize

  200. 	KEYBOARD_INTERVAL,		// bInterval

  201. 

  202. 	// interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12

  203. 	9,				// bLength

  204. 	4,				// bDescriptorType

  205. 	DEBUG_INTERFACE,		// bInterfaceNumber

  206. 	0,				// bAlternateSetting

  207. 	2,				// bNumEndpoints

  208. 	0x03,				// bInterfaceClass (0x03 = HID)

  209. 	0x00,				// bInterfaceSubClass

  210. 	0x00,				// bInterfaceProtocol

  211. 	0,				// iInterface

  212. 	// HID interface descriptor, HID 1.11 spec, section 6.2.1

  213. 	9,				// bLength

  214. 	0x21,				// bDescriptorType

  215. 	0x11, 0x01,			// bcdHID

  216. 	0,				// bCountryCode

  217. 	1,				// bNumDescriptors

  218. 	0x22,				// bDescriptorType

  219. 	sizeof(debug_hid_report_desc),	// wDescriptorLength

  220. 	0,

  221. 	// endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13

  222. 	7,				// bLength

  223. 	5,				// bDescriptorType

  224. 	DEBUG_TX_ENDPOINT | 0x80,	// bEndpointAddress

  225. 	0x03,				// bmAttributes (0x03=intr)

  226. 	DEBUG_TX_SIZE, 0,		// wMaxPacketSize

  227. 	DEBUG_TX_INTERVAL,		// bInterval

  228. 	// endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13

  229. 	7,				// bLength

  230. 	5,				// bDescriptorType

  231. 	DEBUG_RX_ENDPOINT,		// bEndpointAddress

  232. 	0x03,				// bmAttributes (0x03=intr)

  233. 	DEBUG_RX_SIZE, 0,		// wMaxPacketSize

  234. 	DEBUG_RX_INTERVAL,		// bInterval

  235. };

  236. 

  237. // If you're desperate for a little extra code memory, these strings

  238. // can be completely removed if iManufacturer, iProduct, iSerialNumber

  239. // in the device desciptor are changed to zeros.

  240. struct usb_string_descriptor_struct {

  241. 	uint8_t bLength;

  242. 	uint8_t bDescriptorType;

  243. 	int16_t wString[];

  244. };

  245. static const struct usb_string_descriptor_struct PROGMEM string0 = {

  246. 	4,

  247. 	3,

  248. 	{0x0409}

  249. };

  250. static const struct usb_string_descriptor_struct PROGMEM string1 = {

  251. 	sizeof(STR_PRODUCT),

  252. 	3,

  253. 	STR_PRODUCT

  254. };

  255. static const struct usb_string_descriptor_struct PROGMEM string2 = {

  256. 	sizeof(STR_SERIAL_NUMBER),

  257. 	3,

  258. 	STR_SERIAL_NUMBER

  259. };

  260. 

  261. // This table defines which descriptor data is sent for each specific

  262. // request from the host (in wValue and wIndex).

  263. static const struct descriptor_list_struct {

  264. 	uint16_t	wValue;

  265. 	uint16_t	wIndex;

  266. 	const uint8_t	*addr;

  267. 	uint8_t		length;

  268. } PROGMEM descriptor_list[] = {

  269. 	{0x0100, 0x0000, device_descriptor, sizeof(device_descriptor)},

  270. 	{0x0200, 0x0000, config1_descriptor, sizeof(config1_descriptor)},

  271. 	{0x2200, KEYBOARD_INTERFACE, keyboard_hid_report_desc, sizeof(keyboard_hid_report_desc)},

  272. 	{0x2100, KEYBOARD_INTERFACE, config1_descriptor+KEYBOARD_HID_DESC_OFFSET, 9},

  273. 	{0x2200, DEBUG_INTERFACE, debug_hid_report_desc, sizeof(debug_hid_report_desc)},

  274. 	{0x2100, DEBUG_INTERFACE, config1_descriptor+DEBUG_HID_DESC_OFFSET, 9},

  275. 	{0x0300, 0x0000, (const uint8_t *)&string0, 4},

  276. 	{0x0301, 0x0409, (const uint8_t *)&string1, sizeof(STR_PRODUCT)},

  277. 	{0x0302, 0x0409, (const uint8_t *)&string2, sizeof(STR_SERIAL_NUMBER)},

  278. };

  279. #define NUM_DESC_LIST (sizeof(descriptor_list)/sizeof(struct descriptor_list_struct))

  280. 

  281. static const uint8_t PROGMEM scsi_inquiry_response[] = {

  282. 	0x00,	// 0x00 = direct-access device

  283. 	0x80,	// 0x80 = removable media

  284. 	0x04,	// 0x04 = SPC-2 commands

  285. 	0x02,	// response format

  286. 	0x20,	// # bytes past this point

  287. 	0x00,

  288. 	0x00,

  289. 	0x00,

  290. 	'G','e','n','e','r','i','c',' ',

  291. 	'U','S','B',' ','F','l','a','s','h',' ','D','i','s','c',' ',' ',

  292. 	'1','.','0','0'

  293. };

  294. 

  295. /**************************************************************************

  296.  *

  297.  *  Variables - these are the only non-stack RAM usage

  298.  *

  299.  **************************************************************************/

  300. 

  301. // zero when we are not configured, non-zero when enumerated

  302. volatile uint8_t usb_configuration USBSTATE;

  303. volatile uint8_t usb_suspended USBSTATE;

  304. 

  305. // the time remaining before we transmit any partially full

  306. // packet, or send a zero length packet.

  307. volatile uint8_t debug_flush_timer USBSTATE;

  308. 

  309. // byte0: which modifier keys are currently pressed

  310. //  1=left ctrl,    2=left shift,   4=left alt,    8=left gui

  311. //  16=right ctrl, 32=right shift, 64=right alt, 128=right gui

  312. // byte1: media keys (TODO: document these)

  313. // bytes2-7: which keys are currently pressed, up to 6 keys may be down at once

  314. uint8_t keyboard_report_data[8] USBSTATE;

  315. 

  316. // protocol setting from the host.  We use exactly the same report

  317. // either way, so this variable only stores the setting since we

  318. // are required to be able to report which setting is in use.

  319. static uint8_t keyboard_protocol USBSTATE;

  320. 

  321. // the idle configuration, how often we send the report to the

  322. // host (ms * 4) even when it hasn't changed

  323. static uint8_t keyboard_idle_config USBSTATE;

  324. 

  325. // count until idle timeout

  326. uint8_t keyboard_idle_count USBSTATE;

  327. 

  328. // 1=num lock, 2=caps lock, 4=scroll lock, 8=compose, 16=kana

  329. volatile uint8_t keyboard_leds USBSTATE;

  330. 

  331. 

  332. static volatile uint8_t ms_state USBSTATE;

  333. 

  334. static volatile uint8_t ms_rdonly USBSTATE;

  335. 

  336. static volatile uint8_t media_lock_state USBSTATE;

  337. #define MEDIA_LOCKED_BY_USER	1	// user locked media

  338. #define MEDIA_LOCKED_BY_ISR	2	// isr locked media

  339. #define MEDIA_ISR_LOCK_PENDING	4	// isr request while user locked

  340. 

  341. 

  342. 

  343. /**************************************************************************

  344.  *

  345.  *  Public Functions - these are the API intended for the user

  346.  *

  347.  **************************************************************************/

  348. 

  349. 

  350. void media_init(void);

  351. void media_restart(void);

  352. 

  353. 

  354. // initialize USB serial

  355. void usb_init(void)

  356. {

  357. 	uint8_t u;

  358. 

  359. 	u = USBCON;

  360. 	if ((u & (1<<USBE)) && !(u & (1<<FRZCLK))) {

  361. 		media_restart();

  362. 		return;

  363. 	}

  364. 	HW_CONFIG();

  365. 	USB_FREEZE();				// enable USB

  366. 	PLL_CONFIG();				// config PLL

  367. 	while (!(PLLCSR & (1<<PLOCK))) ;	// wait for PLL lock

  368. 	USB_CONFIG();				// start USB clock

  369. 	UDCON = 0;				// enable attach resistor

  370. 	usb_configuration = 0;

  371. 	usb_suspended = 0;

  372. 	debug_flush_timer = 0;

  373.         keyboard_report_data[0] = 0;

  374.         keyboard_report_data[1] = 0;

  375.         keyboard_report_data[2] = 0;

  376.         keyboard_report_data[3] = 0;

  377.         keyboard_report_data[4] = 0;

  378.         keyboard_report_data[5] = 0;

  379.         keyboard_report_data[6] = 0;

  380.         keyboard_report_data[7] = 0;

  381. 	keyboard_protocol = 1;

  382. 	keyboard_idle_config = 125;

  383. 	keyboard_idle_count = 0;

  384. 	keyboard_leds = 0;

  385. 	ms_state = MS_STATE_IDLE;

  386. 	media_lock_state = 0;

  387. 	UDINT = 0;

  388. 	UDIEN = (1<<EORSTE)|(1<<SOFE);

  389. 	//sei();  // init() in wiring.c does this

  390. 	media_init();

  391. }

  392. 

  393. void usb_shutdown(void)

  394. {

  395. 	UDIEN = 0;		// disable interrupts

  396. 	UDCON = 1;		// disconnect attach resistor

  397. 	USBCON = 0;		// shut off USB periperal

  398. 	PLLCSR = 0;		// shut off PLL

  399. 	usb_configuration = 0;

  400. 	usb_suspended = 1;

  401. }

  402. 

  403. 

  404. // Public API functions moved to usb_api.cpp

  405. 

  406. 

  407. 

  408. 

  409. 

  410. /**************************************************************************

  411.  *

  412.  *  Storage Media Access Functions

  413.  *

  414.  **************************************************************************/

  415. 

  416. #if defined(USB_DISK_SDFLASH)

  417. #include "media_sdcard.c"

  418. #elif defined(USB_DISK)

  419. #include "media_internal.c"

  420. #else

  421. #error "No known media type specified\n"

  422. #endif

  423. 

  424. 

  425. // User program wants to use the media, which is simple

  426. // if it's available, set the lock, otherwise report

  427. // busy and the user will just have to try again later

  428. //

  429. uint8_t media_lock(void)

  430. {

  431. 	uint8_t intr_state;

  432. 

  433. 	intr_state = SREG;

  434. 	cli();

  435. 	if (media_lock_state) {

  436. 		SREG = intr_state;

  437. 		return 0;

  438. 	}

  439. 	media_lock_state = 1;

  440. 	SREG = intr_state;

  441. 	print("User program locked media\n");

  442. 	return 1;

  443. }

  444. 

  445. // User is done with the media.  If the ISR requested

  446. // media while it was locked by the user, then interrupts

  447. // need to be reenabled so the ISR can do its work.

  448. //

  449. void media_unlock(void)

  450. {

  451. 	uint8_t lock, intr_state;

  452. 

  453. 	intr_state = SREG;

  454. 	cli();

  455. 	lock = media_lock_state;

  456. 	if (lock & MEDIA_ISR_LOCK_PENDING) {

  457. 		UENUM = DISK_RX_ENDPOINT;

  458. 		UEIENX = (1<<RXOUTE);

  459. 	}

  460. 	media_lock_state = 0;

  461. 	SREG = intr_state;

  462. 	print("User program unlocking media\n");

  463. }

  464. 

  465. // Interrupt (PC access) wants to lock the media.

  466. //

  467. static inline uint8_t media_lock_isr(void)

  468. {

  469. 	uint8_t lock, intr_state;  // epnum;

  470. 

  471. 	intr_state = SREG;

  472. 	cli();

  473. 	lock = media_lock_state;

  474. 	if (lock & MEDIA_LOCKED_BY_USER) {

  475. 		lock |= MEDIA_ISR_LOCK_PENDING;

  476. 		media_lock_state = lock;

  477. 		SREG = intr_state;

  478. 		print("ISR tried to lock, but must wait\n");

  479. 		return 0;

  480. 	}

  481. 	lock |= MEDIA_LOCKED_BY_ISR;

  482. 	media_lock_state = lock;

  483. 	SREG = intr_state;

  484. 	return 1;

  485. }

  486. 

  487. // Interrupt is finished with the media.

  488. //

  489. static inline void media_unlock_isr(void)

  490. {

  491. 	media_lock_state = 0;  // 1 byte write is atomic

  492. }

  493. 

  494. 

  495. /**************************************************************************

  496.  *

  497.  *  Private Functions - not intended for general user consumption....

  498.  *

  499.  **************************************************************************/

  500. 

  501. 

  502. 

  503. #define ENABLE_MORE_RX	1

  504. #define ENABLE_MORE_TX	2

  505. static inline uint8_t mass_storage_isr(uint8_t need_rx, uint8_t need_tx) __attribute__((always_inline));

  506. static inline uint8_t mass_storage_isr(uint8_t need_rx, uint8_t need_tx)

  507. {

  508. 	uint8_t n, state;

  509. 	const uint8_t *p;

  510. 	static uint32_t tag, xfer_len, lba;

  511. 	static uint8_t dir, cmd_len, status;

  512. 	static uint8_t scsi_sense, scsi_asense;

  513. 	static uint16_t sector_count;

  514. 	static uint8_t sector_chunk;

  515. 	static uint8_t previous_media_state, do_media_status;

  516. 	uint8_t cmd;

  517. 

  518. 	if (need_rx) {

  519. 		UENUM = DISK_RX_ENDPOINT;

  520. 		if (!media_lock_isr()) {

  521. 			print("Media is locked, ISR exit\n");

  522. 			// if the user program is busy with the media

  523. 			// then disable our interrupt and hope the user

  524. 			// program enables it again when finished.

  525. 			//UEIENX = 0;

  526. 			return 0;

  527. 		}

  528. 		//print("rx ");

  529. 		n = UEBCLX;

  530. 		state = ms_state;

  531. 		if (state == MS_STATE_IDLE) {

  532. 			 print("CBW ");

  533. 			 //phex(n);

  534. 			if (n != 31) goto error_stall;

  535. 			if (UEDATX != 0x55) goto error_stall;

  536. 			if (UEDATX != 0x53) goto error_stall;

  537. 			if (UEDATX != 0x42) goto error_stall;

  538. 			if (UEDATX != 0x43) goto error_stall;

  539. 			read_dword_lsbfirst(tag, UEDATX);

  540. 			read_dword_lsbfirst(xfer_len, UEDATX);

  541. 			dir = UEDATX & 0x80;

  542. 			UEDATX; // LUN

  543. 			cmd_len = UEDATX;

  544. 			 //print(", len=");

  545. 			 //phex(cmd_len);

  546. 			status = 0;

  547. 			cmd = UEDATX;

  548. 			 print(", cmd=");

  549. 			 phex(cmd);

  550. 			 //print(", dir=");

  551. 			 //phex(dir);

  552. 			 //print(", xfer=");

  553. 			 //phex32(xfer_len);

  554. 			 print("\n");

  555. 			do_media_status = 0;

  556. 			if (cmd == SCSI_CMD_REQUEST_SENSE) { // 0x03

  557. 				 print("REQUEST_SENSE ");

  558. 				 phex(scsi_sense);

  559. 				 phex(scsi_asense);

  560. 				 print("\n");

  561. 				if (media_state & MEDIA_STATE_CLAIMED)

  562. 					media_state |= MEDIA_STATE_CLAIMED_SENSE;

  563. 				UEINTX = 0x6B;

  564. 				UENUM = DISK_TX_ENDPOINT;

  565. 				UEDATX = 0x70;

  566. 				UEDATX = 0;

  567. 				UEDATX = scsi_sense;

  568. 				UEDATX = 0;

  569. 				UEDATX = 0;

  570. 				UEDATX = 0;

  571. 				UEDATX = 0;

  572. 				UEDATX = 10;

  573. 				UEDATX = 0;

  574. 				UEDATX = 0;

  575. 				UEDATX = 0;

  576. 				UEDATX = 0;

  577. 				UEDATX = scsi_asense;

  578. 				xfer_len -= 13;

  579. 				goto send_finishup;

  580. 			}

  581. 			scsi_sense = SCSI_SENSE_OK;

  582. 			scsi_asense = SCSI_ASENSE_NONE;

  583. 			if (cmd == SCSI_CMD_INQUIRY) {	// 0x12

  584. 				// http://en.wikipedia.org/wiki/SCSI_Inquiry_Command

  585. 				uint16_t len;

  586. 				UEDATX;		// ignore request bits

  587. 				UEDATX;

  588. 				read_word_msbfirst(len, UEDATX);

  589. 				 print("INQUIRY\n");

  590. 				UEINTX = 0x6B;

  591. 				if (len > sizeof(scsi_inquiry_response))

  592. 					len = sizeof(scsi_inquiry_response);

  593. 				p = scsi_inquiry_response;

  594. 				UENUM = DISK_TX_ENDPOINT;

  595. 				for (n=len; n > 0; n--) {

  596. 					pgm_read_byte_postinc(UEDATX, p);

  597. 				}

  598. 				xfer_len -= len;

  599. 				goto send_finishup;

  600. 			}

  601. 			previous_media_state = media_state;

  602. 			do_media_status = 1;

  603. 

  604. 			// all commands below this point need media access

  605. 

  606. 			if (cmd == SCSI_CMD_TEST_UNIT_READY) { // 0x00

  607. 				print("TEST READY, ms=");

  608. 				phex(media_state);

  609. 				print("\n");

  610. 				media_poll();

  611. 				UEINTX = 0x3A;

  612. 				goto send_status;

  613. 			}

  614. 

  615. 			// all commands below this point need the media

  616. 			// to be present

  617. 			if (!(previous_media_state & MEDIA_PRESENT_MASK)) {

  618. 				print("stall_in\n");

  619. 				UEINTX = 0x6B;

  620. 				UENUM = DISK_TX_ENDPOINT;

  621. 				//UEIENX = 0;

  622. 				UECONX = (1<<STALLRQ) | (1<<EPEN);

  623. 				ms_state = MS_STATE_SEND_STATUS;

  624. 				return ENABLE_MORE_RX;

  625. 			}

  626. 

  627. 			if (cmd == SCSI_CMD_MODE_SENSE_6  // 0x1A

  628. 			  || cmd == SCSI_CMD_MODE_SENSE_10) {	 // 0x5A

  629. 				// 1A 00 1C 00 C0 00 - from disk.sys

  630. 				// 1A 00 3F 00 C0 00 - from classpnp.sys

  631. 				// 1A 00 3F 00 C0 00 - from linux kernel

  632. 				 print("MODE SENSE 6 or 10\n");

  633. 				// check allocation length...

  634. 				UEINTX = 0x6B;

  635. 				UENUM = DISK_TX_ENDPOINT;

  636. 				UEDATX = 0x03;

  637. 				UEDATX = 0x00;

  638. 				UEDATX = media_rdonly ? 0x80 : 0x00; // WP bit

  639. 				UEDATX = 0x00;

  640. 				xfer_len -= 4;

  641. 				goto send_finishup;

  642. 			} else if (cmd == SCSI_CMD_READ_CAPACITY) { // 0x25

  643. 				uint32_t capacity;

  644. 				 print("CAPACITY\n");

  645. 				UEINTX = 0x6B;

  646. 				media_poll();

  647. 				capacity = media_size();

  648. 				UENUM = DISK_TX_ENDPOINT;

  649. 				write_dword_msbfirst(capacity - 1, UEDATX);

  650. 				UEDATX = 0x00;

  651. 				UEDATX = 0x00;

  652. 				UEDATX = 0x02;

  653. 				UEDATX = 0x00;

  654. 				xfer_len -= 8;

  655. 				goto send_finishup;

  656. 			} else if (cmd == SCSI_CMD_READ_FORMAT_CAPACITIES) { // 0x23

  657. 				uint32_t capacity;

  658. 				 print("READ_FORMAT_CAPACITIES\n");

  659. 				UEINTX = 0x6B;

  660. 				media_poll();

  661. 				capacity = media_size();

  662. 				UENUM = DISK_TX_ENDPOINT;

  663. 				UEDATX = 0x00;

  664. 				UEDATX = 0x00;

  665. 				UEDATX = 0x00;

  666. 				UEDATX = 0x08;

  667. 				write_dword_msbfirst(capacity, UEDATX);

  668. 				UEDATX = 2 + status;	// 2 = formatted, 3 = no media present

  669. 				UEDATX = 0x00;

  670. 				UEDATX = 0x02;	// 512 byte blocks

  671. 				UEDATX = 0x00;

  672. 				xfer_len -= 12;

  673. 				goto send_finishup;

  674. 			} else if (cmd == SCSI_CMD_READ_10) { // 0x28

  675. 				// http://en.wikipedia.org/wiki/SCSI_Read_Commands#Read_.2810.29

  676. 				UEDATX;

  677. 				read_dword_msbfirst(lba, UEDATX);

  678. 				UEDATX;

  679. 				read_word_msbfirst(sector_count, UEDATX);

  680. 				 print("READ_10: lba=");

  681. 				 phex32(lba);

  682. 				 print(", count=");

  683. 				 phex16(sector_count);

  684. 				 print("\n");

  685. 				UEINTX = 0x6B;

  686. 				if (!(media_state & MEDIA_PRESENT_MASK)) {

  687. 					UENUM = DISK_TX_ENDPOINT;

  688. 					goto send_finishup;

  689. 				}

  690. 				media_send_begin(lba);

  691. 				sector_chunk = 0;

  692. 				ms_state = MS_STATE_SEND_DATA;

  693. 				goto send_data;

  694. 			} else if (cmd == SCSI_CMD_WRITE_10) { // 0x2A

  695. 				UEDATX;

  696. 				read_dword_msbfirst(lba, UEDATX);

  697. 				UEDATX;

  698. 				read_word_msbfirst(sector_count, UEDATX);

  699. 				 print("WRITE_10: lba=");

  700. 				 phex32(lba);

  701. 				 print(", count=");

  702. 				 phex16(sector_count);

  703. 				 print("\n");

  704. 				UEINTX = 0x6B;

  705. 				// TODO: how to handle write when media not ready

  706. 				//if (!(media_state & MEDIA_PRESENT_MASK)) goto send_finishup;

  707. 				sector_chunk = 0;

  708. 				media_receive_begin(lba);

  709. 				ms_state = MS_STATE_RECEIVE_DATA;

  710. 				n = UEBCLX;

  711. 				if (n > 0) goto receive_data;

  712. 				return ENABLE_MORE_RX;

  713. 			} else {

  714. 				 print("Unimplemented, cmd=");

  715. 				 phex(cmd);

  716. 				 print("\n");

  717. 				UEINTX = 0x6B;

  718. 				scsi_sense = SCSI_SENSE_ILLEGAL_REQUEST;

  719. 				scsi_asense = SCSI_ASENSE_INVALID_COMMAND;

  720. 				status = 1;

  721. 				goto send_finishup;

  722. 				//TODO: what is the proper way to handle this error??

  723. 				//UENUM = DISK_TX_ENDPOINT;

  724. 				//UECONX = (1<<STALLRQ) | (1<<EPEN);

  725. 				//state = MS_STATE_SEND_STATUS;

  726. 				//UEIENX = (1<<TXINE);

  727. 				//return ENABLE_MORE_RX;

  728. 			}

  729. 		} else if (state == MS_STATE_RECEIVE_DATA) {

  730. 			receive_data:

  731. 			//print("receive, count=");

  732. 			//phex16(sector_count);

  733. 			//print (", lba=");

  734. 			//phex32(lba);

  735. 			//print(", chunk=");

  736. 			//phex(sector_chunk);

  737. 			//print("\n");

  738. 			if (sector_count > 0) {

  739. 				media_receive_chunk(lba, sector_chunk);

  740. 				xfer_len -= 64;

  741. 				if (++sector_chunk >= 8) {

  742. 					sector_chunk = 0;

  743. 					lba++;

  744. 					//if (--sector_count == 0) ms_state = MS_STATE_SEND_STATUS;

  745. 					if (--sector_count == 0) {

  746. 						media_receive_end();

  747. 						goto send_status;

  748. 					}

  749. 				}

  750. 				// if another interrupt already ending, do it now

  751. 				//if (UEINTX & (1<<RXOUTI)) goto receive_data;

  752. 			} else {

  753. 				UEINTX = 0x6B;

  754. 			}

  755. 			return ENABLE_MORE_RX;

  756. 		} else {

  757. 			//print("unexpected receive: n=");

  758. 			//phex(n);

  759. 			//print("\n");

  760. 			UEINTX = 0x6B;

  761. 			return ENABLE_MORE_RX;

  762. 		}

  763. 	}

  764. 	if (need_tx) {

  765. 		UENUM = DISK_TX_ENDPOINT;

  766. 		//print("tx ");

  767. 		state = ms_state;

  768. 		if (state == MS_STATE_SEND_STATUS) goto send_status_force;

  769. 		if (state == MS_STATE_SEND_ZEROPAD) goto send_finishup;

  770. 		if (state == MS_STATE_SEND_DATA) goto send_data;

  771. 		print("unhandled tx interrupt ");

  772. 		phex(state);

  773. 		print("\n");

  774. 		return 0;

  775. 	}

  776. 	return ENABLE_MORE_RX; // should never be called with both need_rx = 0 and need_tx = 0

  777. 

  778. send_data:

  779. 	 //print("send, count=");

  780. 	 //phex16(sector_count);

  781. 	 //print (", lba=");

  782. 	 //phex32(lba);

  783. 	 //print(", chunk=");

  784. 	 //phex(sector_chunk);

  785. 	 //print("\n");

  786. 	UENUM = DISK_TX_ENDPOINT;

  787. 	if (sector_count > 0 && (UEINTX & (1<<RWAL))) {

  788. 		media_send_chunk(lba, sector_chunk);

  789. 		xfer_len -= 64;

  790. 		if (++sector_chunk >= 8) {

  791. 			sector_chunk = 0;

  792. 			lba++;

  793. 			if (--sector_count == 0) {

  794. 				media_send_end();

  795. 				ms_state = MS_STATE_SEND_STATUS;

  796. 			}

  797. 		}

  798. 		// if more buffers ready, don't wait for another interrupt

  799. 		if (UEINTX & (1<<RWAL)) goto send_data;

  800. 	}

  801. 	//UEIENX = (1<<TXINE);

  802. 	return ENABLE_MORE_TX;

  803. send_finishup:

  804. 	while (xfer_len > 0 && (UEINTX & (1<<RWAL))) {

  805. 		UEDATX = 0;

  806. 		xfer_len--;

  807. 	}

  808. 	UEINTX = 0x3A;

  809. 	if (xfer_len) {

  810. 		print("short reply\n");

  811. 		ms_state = MS_STATE_SEND_ZEROPAD;

  812. 		//UEIENX = (1<<TXINE);

  813. 		return ENABLE_MORE_TX;

  814. 	}

  815. send_status:

  816. 	UENUM = DISK_TX_ENDPOINT;

  817. 	if (!(UEINTX & (1<<RWAL))) {

  818. 		print("wait tx\n");

  819. 		ms_state = MS_STATE_SEND_STATUS;

  820. 		//UEIENX = (1<<TXINE);

  821. 		return ENABLE_MORE_TX;

  822. 	}

  823. send_status_force:

  824. 	if (do_media_status) {

  825. 		uint8_t current_media_state = media_state;

  826. 		if (current_media_state & MEDIA_STATE_CLAIMED)

  827. 			media_state = current_media_state | MEDIA_STATE_CLAIMED_STATUS;

  828. 		if (status == 0) {

  829. 			if (!(current_media_state & MEDIA_PRESENT_MASK)) {

  830. 				scsi_sense = SCSI_SENSE_NOT_READY;

  831. 				scsi_asense = SCSI_ASENSE_MEDIUM_NOT_PRESENT;

  832. 				status = 1;

  833. 			} else {

  834. 				if (!(previous_media_state & MEDIA_PRESENT_MASK)) {

  835. 					scsi_sense = SCSI_SENSE_UNIT_ATTENTION;

  836. 					scsi_asense = SCSI_ASENSE_NOT_READY_TO_READY;

  837. 					status = 1;

  838. 				}

  839. 			}

  840. 		}

  841. 		do_media_status = 0;

  842. 	}

  843. 	print("status ");

  844. 	phex(status);

  845. 	if (status) {

  846. 		phex(scsi_sense);

  847. 		phex(scsi_asense);

  848. 	}

  849. 	print("\n");

  850. 	UEDATX = 0x55;

  851. 	UEDATX = 0x53;

  852. 	UEDATX = 0x42;

  853. 	UEDATX = 0x53;

  854. 	write_dword_lsbfirst(tag, UEDATX);

  855. 	write_dword_lsbfirst(xfer_len, UEDATX);

  856. 	UEDATX = status;

  857. 	UEINTX = 0x3A;

  858. 	//UEIENX = 0;

  859. 	ms_state = MS_STATE_IDLE;

  860. 	media_unlock_isr();

  861. 	return ENABLE_MORE_RX;

  862. error_stall:

  863. 	print("\nStall\n");

  864. 	ms_state = MS_STATE_STALLED;

  865. 	UENUM = DISK_RX_ENDPOINT;

  866. 	//UEIENX = 0;

  867. 	UECONX = (1<<STALLRQ) | (1<<EPEN);

  868. 	UENUM = DISK_TX_ENDPOINT;

  869. 	//UEIENX = 0;

  870. 	UECONX = (1<<STALLRQ) | (1<<EPEN);

  871. 	media_unlock_isr();

  872. 	return ENABLE_MORE_RX | ENABLE_MORE_TX;

  873. }

  874. 

  875. 

  876. 

  877. 

  878. // Misc functions to wait for ready and send/receive packets

  879. static inline void usb_wait_in_ready(void)

  880. {

  881. 	while (!(UEINTX & (1<<TXINI))) ;

  882. }

  883. static inline void usb_send_in(void)

  884. {

  885. 	UEINTX = ~(1<<TXINI);

  886. }

  887. static inline void usb_wait_receive_out(void)

  888. {

  889. 	while (!(UEINTX & (1<<RXOUTI))) ;

  890. }

  891. static inline void usb_ack_out(void)

  892. {

  893. 	UEINTX = ~(1<<RXOUTI);

  894. }

  895. 

  896. 

  897. 

  898. // USB Endpoint Interrupt - endpoint 0 is handled here.  The

  899. // other endpoints are manipulated by the user-callable

  900. // functions, and the start-of-frame interrupt.

  901. //

  902. static inline void endpoint0_isr(void) __attribute__((always_inline));

  903. static inline void endpoint0_isr(void)

  904. {

  905. 	uint8_t intbits;

  906. 	const uint8_t *list;

  907. 	const uint8_t *cfg;

  908. 	uint8_t i, n, len, en;

  909. 	uint8_t bmRequestType;

  910. 	uint8_t bRequest;

  911. 	uint16_t wValue;

  912. 	uint16_t wIndex;

  913. 	uint16_t wLength;

  914. 	uint16_t desc_val;

  915. 	const uint8_t *desc_addr;

  916. 	uint8_t	desc_length;

  917. 

  918. 	UENUM = 0;

  919. 	intbits = UEINTX;

  920. 	if (intbits & (1<<RXSTPI)) {

  921. 		bmRequestType = UEDATX;

  922. 		bRequest = UEDATX;

  923. 		read_word_lsbfirst(wValue, UEDATX);

  924. 		read_word_lsbfirst(wIndex, UEDATX);

  925. 		read_word_lsbfirst(wLength, UEDATX);

  926. 		UEINTX = ~((1<<RXSTPI) | (1<<RXOUTI) | (1<<TXINI));

  927. 		if (bRequest == GET_DESCRIPTOR) {

  928. 			list = (const uint8_t *)descriptor_list;

  929. 			for (i=0; ; i++) {

  930. 				if (i >= NUM_DESC_LIST) {

  931. 					UECONX = (1<<STALLRQ)|(1<<EPEN);  //stall

  932. 					return;

  933. 				}

  934. 				pgm_read_word_postinc(desc_val, list);

  935. 				if (desc_val != wValue) {

  936. 					list += sizeof(struct descriptor_list_struct)-2;

  937. 					continue;

  938. 				}

  939. 				pgm_read_word_postinc(desc_val, list);

  940. 				if (desc_val != wIndex) {

  941. 					list += sizeof(struct descriptor_list_struct)-4;

  942. 					continue;

  943. 				}

  944. 				pgm_read_word_postinc(desc_addr, list);

  945. 				desc_length = pgm_read_byte(list);

  946. 				break;

  947. 			}

  948. 			len = (wLength < 256) ? wLength : 255;

  949. 			if (len > desc_length) len = desc_length;

  950. 			list = desc_addr;

  951. 			do {

  952. 				// wait for host ready for IN packet

  953. 				do {

  954. 					i = UEINTX;

  955. 				} while (!(i & ((1<<TXINI)|(1<<RXOUTI))));

  956. 				if (i & (1<<RXOUTI)) return;	// abort

  957. 				// send IN packet

  958. 				n = len < ENDPOINT0_SIZE ? len : ENDPOINT0_SIZE;

  959. 				for (i = n; i; i--) {

  960. 					pgm_read_byte_postinc(UEDATX, list);

  961. 				}

  962. 				len -= n;

  963. 				usb_send_in();

  964. 			} while (len || n == ENDPOINT0_SIZE);

  965. 			return;

  966. 		}

  967. 		if (bRequest == SET_ADDRESS) {

  968. 			usb_send_in();

  969. 			usb_wait_in_ready();

  970. 			UDADDR = wValue | (1<<ADDEN);

  971. 			return;

  972. 		}

  973. 		if (bRequest == SET_CONFIGURATION && bmRequestType == 0) {

  974. 			usb_configuration = wValue;

  975. 			debug_flush_timer = 0;

  976. 			usb_send_in();

  977. 			cfg = endpoint_config_table;

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

  979. 				UENUM = i;

  980. 				pgm_read_byte_postinc(en, cfg);

  981. 				UECONX = en;

  982. 				if (en) {

  983. 					pgm_read_byte_postinc(UECFG0X, cfg);

  984. 					pgm_read_byte_postinc(UECFG1X, cfg);

  985. 				}

  986. 			}

  987. 			UERST = 0x1E;

  988. 			UERST = 0;

  989. 			UENUM = DISK_RX_ENDPOINT;

  990. 			UEIENX = (1<<RXOUTE);

  991. 			return;

  992. 		}

  993. 		if (bRequest == GET_CONFIGURATION && bmRequestType == 0x80) {

  994. 			usb_wait_in_ready();

  995. 			UEDATX = usb_configuration;

  996. 			usb_send_in();

  997. 			return;

  998. 		}

  999. 		if (bRequest == GET_STATUS) {

  1000. 			usb_wait_in_ready();

  1001. 			i = 0;

  1002. 			if (bmRequestType == 0x82) {

  1003. 				UENUM = wIndex;

  1004. 				if (UECONX & (1<<STALLRQ)) i = 1;

  1005. 				UENUM = 0;

  1006. 			}

  1007. 			UEDATX = i;

  1008. 			UEDATX = 0;

  1009. 			usb_send_in();

  1010. 			return;

  1011. 		}

  1012. 		if ((bRequest == CLEAR_FEATURE || bRequest == SET_FEATURE)

  1013. 		  && bmRequestType == 0x02 && wValue == 0) {

  1014. 			i = wIndex & 0x7F;

  1015. 			if (i >= 1 && i <= MAX_ENDPOINT) {

  1016. 				usb_send_in();

  1017. 				UENUM = i;

  1018. 				if (bRequest == SET_FEATURE) {

  1019. 					UECONX = (1<<STALLRQ)|(1<<EPEN);

  1020. 				} else {

  1021. 					UECONX = (1<<STALLRQC)|(1<<RSTDT)|(1<<EPEN);

  1022. 					UERST = (1 << i);

  1023. 					UERST = 0;

  1024. 					if (i == DISK_TX_ENDPOINT) {

  1025. 						UEIENX = (1<<TXINE);

  1026. 					}

  1027. 				}

  1028. 				return;

  1029. 			}

  1030. 		}

  1031. 		if (wIndex == KEYBOARD_INTERFACE) {

  1032. 			if (bmRequestType == 0xA1) {

  1033. 				if (bRequest == HID_GET_REPORT) {

  1034. 					usb_wait_in_ready();

  1035. 					for (i=0; i < 8; i++) {

  1036. 						UEDATX = keyboard_report_data[i];

  1037. 					}

  1038. 					usb_send_in();

  1039. 					return;

  1040. 				}

  1041. 				if (bRequest == HID_GET_IDLE) {

  1042. 					usb_wait_in_ready();

  1043. 					UEDATX = keyboard_idle_config;

  1044. 					usb_send_in();

  1045. 					return;

  1046. 				}

  1047. 				if (bRequest == HID_GET_PROTOCOL) {

  1048. 					usb_wait_in_ready();

  1049. 					UEDATX = keyboard_protocol;

  1050. 					usb_send_in();

  1051. 					return;

  1052. 				}

  1053. 			}

  1054. 			if (bmRequestType == 0x21) {

  1055. 				if (bRequest == HID_SET_REPORT) {

  1056. 					usb_wait_receive_out();

  1057. 					keyboard_leds = UEDATX;

  1058. 					usb_ack_out();

  1059. 					usb_send_in();

  1060. 					return;

  1061. 				}

  1062. 				if (bRequest == HID_SET_IDLE) {

  1063. 					keyboard_idle_config = (wValue >> 8);

  1064. 					keyboard_idle_count = 0;

  1065. 					//usb_wait_in_ready();

  1066. 					usb_send_in();

  1067. 					return;

  1068. 				}

  1069. 				if (bRequest == HID_SET_PROTOCOL) {

  1070. 					keyboard_protocol = wValue;

  1071. 					//usb_wait_in_ready();

  1072. 					usb_send_in();

  1073. 					return;

  1074. 				}

  1075. 			}

  1076. 		}

  1077. 		if (wIndex == DEBUG_INTERFACE) {

  1078. 			if (bRequest == HID_GET_REPORT && bmRequestType == 0xA1) {

  1079. 				len = wLength;

  1080. 				do {

  1081. 					// wait for host ready for IN packet

  1082. 					do {

  1083. 						i = UEINTX;

  1084. 					} while (!(i & ((1<<TXINI)|(1<<RXOUTI))));

  1085. 					if (i & (1<<RXOUTI)) return;	// abort

  1086. 					// send IN packet

  1087. 					n = len < ENDPOINT0_SIZE ? len : ENDPOINT0_SIZE;

  1088. 					for (i = n; i; i--) {

  1089. 						UEDATX = 0;

  1090. 					}

  1091. 					len -= n;

  1092. 					usb_send_in();

  1093. 				} while (len || n == ENDPOINT0_SIZE);

  1094. 				return;

  1095. 			}

  1096. 			if (bRequest == HID_SET_REPORT && bmRequestType == 0x21) {

  1097. 				if (wValue == 0x0300 && wLength == 0x0004) {

  1098. 					uint8_t b1, b2, b3, b4;

  1099. 					usb_wait_receive_out();

  1100. 					b1 = UEDATX;

  1101. 					b2 = UEDATX;

  1102. 					b3 = UEDATX;

  1103. 					b4 = UEDATX;

  1104. 					usb_ack_out();

  1105. 					usb_send_in();

  1106. 					if (b1 == 0xA9 && b2 == 0x45 && b3 == 0xC2 && b4 == 0x6B)

  1107. 						_reboot_Teensyduino_();

  1108. 					if (b1 == 0x8B && b2 == 0xC5 && b3 == 0x1D && b4 == 0x70)

  1109. 						_restart_Teensyduino_();

  1110. 				}

  1111. 			}

  1112. 		}

  1113. 		if (bRequest == 0xC9 && bmRequestType == 0x40) {

  1114. 			usb_send_in();

  1115. 			usb_wait_in_ready();

  1116. 			_restart_Teensyduino_();

  1117. 		}

  1118. 		if (wIndex == DISK_INTERFACE) {

  1119. 			if (bRequest == MS_BULK_ONLY_RESET && bmRequestType == 0x21) {

  1120. 				usb_wait_in_ready();

  1121. 				ms_state = MS_STATE_IDLE;

  1122. 				usb_send_in();

  1123. 				return;

  1124. 			}

  1125. 		}

  1126. 	}

  1127. 	UECONX = (1<<STALLRQ) | (1<<EPEN);	// stall

  1128. }

  1129. 

  1130. 

  1131. // USB Endpoint Interrupt

  1132. ISR(USB_COM_vect)

  1133. {

  1134. 	uint8_t epnum_save, r=0, need_rx=0, need_tx=0;

  1135. 

  1136. 	// first, do endpoint 0

  1137. 	epnum_save = UENUM;

  1138. 	endpoint0_isr();

  1139. 

  1140. 	// disable all USB interrupts

  1141. 	UDIEN = 0;

  1142. 	UENUM = 0;

  1143. 	UEIENX = 0;

  1144. 	UENUM = DISK_RX_ENDPOINT;

  1145. 	if (UEIENX & (1<<RXOUTE)) {

  1146. 		r = ENABLE_MORE_RX;

  1147. 		if (UEINTX & (1<<RXOUTI)) need_rx=1;

  1148. 	}

  1149. 	UEIENX = 0;

  1150. 	UENUM = DISK_TX_ENDPOINT;

  1151. 	if (UEIENX & (1<<TXINE)) {

  1152. 		r |= ENABLE_MORE_TX;

  1153. 		if (UEINTX & (1<<TXINI)) need_tx=1;

  1154. 	}

  1155. 	UEIENX = 0;

  1156. 

  1157. 	// run the mass storage, with non-USB interrupts enabled

  1158. 	// so lengthy transfers don't starve other interrupts

  1159. 	if (need_rx || need_tx) {

  1160. 		sei();

  1161. 		r = mass_storage_isr(need_rx, need_tx);

  1162. 		cli();

  1163. 	}

  1164. 

  1165. 	// re-enable USB interrupts

  1166. 	if (r & ENABLE_MORE_RX) {

  1167. 		UENUM = DISK_RX_ENDPOINT;

  1168. 		UEIENX = (1<<RXOUTE);

  1169. 	}

  1170. 	if (r & ENABLE_MORE_TX) {

  1171. 		UENUM = DISK_TX_ENDPOINT;

  1172. 		UEIENX = (1<<TXINE);

  1173. 	}

  1174. 	UENUM = 0;

  1175. 	UEIENX = (1<<RXSTPE);

  1176. 	UDIEN = (1<<EORSTE)|(1<<SOFE);

  1177. 	UENUM = epnum_save;

  1178. }

  1179. 

  1180. 

  1181. 

  1182. // USB Device Interrupt - handle all device-level events

  1183. // the transmit buffer flushing is triggered by the start of frame

  1184. //

  1185. ISR(USB_GEN_vect)

  1186. {

  1187. 	uint8_t intbits, t, i;

  1188. 	static uint8_t div4=0;

  1189. 

  1190. 	intbits = UDINT;

  1191. 	UDINT = 0;

  1192. 	if (intbits & (1<<EORSTI)) {

  1193. 		UENUM = 0;

  1194. 		UECONX = 1;

  1195. 		UECFG0X = EP_TYPE_CONTROL;

  1196. 		UECFG1X = EP_SIZE(ENDPOINT0_SIZE) | EP_SINGLE_BUFFER;

  1197. 		UEIENX = (1<<RXSTPE);

  1198. 		usb_configuration = 0;

  1199. 		UENUM = DISK_RX_ENDPOINT;

  1200. 		UEIENX = 0;

  1201. 		UENUM = DISK_TX_ENDPOINT;

  1202. 		UEIENX = 0;

  1203. 		ms_state = MS_STATE_IDLE;

  1204. 	}

  1205. 	if ((intbits & (1<<SOFI)) && usb_configuration) {

  1206. 		t = debug_flush_timer;

  1207. 		if (t) {

  1208. 			debug_flush_timer = -- t;

  1209. 			if (!t) {

  1210. 				UENUM = DEBUG_TX_ENDPOINT;

  1211. 				while ((UEINTX & (1<<RWAL))) {

  1212. 					UEDATX = 0;

  1213. 				}

  1214. 				UEINTX = 0x3A;

  1215. 			}

  1216. 		}

  1217. 		if (keyboard_idle_config && (++div4 & 3) == 0) {

  1218. 			UENUM = KEYBOARD_ENDPOINT;

  1219. 			if (UEINTX & (1<<RWAL)) {

  1220. 				keyboard_idle_count++;

  1221. 				if (keyboard_idle_count == keyboard_idle_config) {

  1222. 					keyboard_idle_count = 0;

  1223. 					for (i=0; i < 8; i++) {

  1224. 						UEDATX = keyboard_report_data[i];

  1225. 					}

  1226. 					UEINTX = 0x3A;

  1227. 				}

  1228. 			}

  1229. 		}

  1230. 	}

  1231. 	if (intbits & (1<<SUSPI)) {

  1232. 		// USB Suspend (inactivity for 3ms)

  1233. 		UDIEN = (1<<WAKEUPE);

  1234. 		usb_configuration = 0;

  1235. 		usb_suspended = 1;

  1236. 		#if (F_CPU >= 8000000L)

  1237. 		// WAKEUPI does not work with USB clock freeze 

  1238. 		// when CPU is running less than 8 MHz.

  1239. 		// Is this a hardware bug?

  1240. 		USB_FREEZE();			// shut off USB

  1241. 		PLLCSR = 0;			// shut off PLL

  1242. 		#endif

  1243. 		// to properly meet the USB spec, current must

  1244. 		// reduce to less than 2.5 mA, which means using

  1245. 		// powerdown mode, but that breaks the Arduino

  1246. 		// user's paradigm....

  1247. 	}

  1248. 	if (usb_suspended && (intbits & (1<<WAKEUPI))) {

  1249. 		// USB Resume (pretty much any activity)

  1250. 		#if (F_CPU >= 8000000L)

  1251. 		PLL_CONFIG();

  1252. 		while (!(PLLCSR & (1<<PLOCK))) ;

  1253. 		USB_CONFIG();

  1254. 		#endif

  1255. 		UDIEN = (1<<EORSTE)|(1<<SOFE)|(1<<SUSPE);

  1256. 		usb_suspended = 0;

  1257. 		return;

  1258. 	}

  1259. }