visus
/
teensy-cores
Obserwuj 1
Polub 0
Forkuj 0
Kod Zgłoszenia 0 Oczekujące zmiany 0 Wydania 0 Wiki Aktywność
Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
608 Commity
1 Gałąź
Drzewo: 5c064702ba
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z '5c064702ba'
${ noResults }
teensy-cores/usb_disk/usb.c

1262 lines
34KB
Czysty Wina Historia 

  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 __attribute__ ((used));

  512. 	static uint8_t cmd_len __attribute__ ((used));

  513. 	static uint8_t status;

  514. 	static uint8_t scsi_sense, scsi_asense;

  515. 	static uint16_t sector_count;

  516. 	static uint8_t sector_chunk;

  517. 	static uint8_t previous_media_state, do_media_status;

  518. 	uint8_t cmd;

  519. 

  520. 	if (need_rx) {

  521. 		UENUM = DISK_RX_ENDPOINT;

  522. 		if (!media_lock_isr()) {

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

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

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

  526. 			// program enables it again when finished.

  527. 			//UEIENX = 0;

  528. 			return 0;

  529. 		}

  530. 		//print("rx ");

  531. 		n = UEBCLX;

  532. 		state = ms_state;

  533. 		if (state == MS_STATE_IDLE) {

  534. 			 print("CBW ");

  535. 			 //phex(n);

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

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

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

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

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

  541. 			read_dword_lsbfirst(tag, UEDATX);

  542. 			read_dword_lsbfirst(xfer_len, UEDATX);

  543. 			dir = UEDATX & 0x80;

  544. 			UEDATX; // LUN

  545. 			cmd_len = UEDATX;

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

  547. 			 //phex(cmd_len);

  548. 			status = 0;

  549. 			cmd = UEDATX;

  550. 			 print(", cmd=");

  551. 			 phex(cmd);

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

  553. 			 //phex(dir);

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

  555. 			 //phex32(xfer_len);

  556. 			 print("\n");

  557. 			do_media_status = 0;

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

  559. 				 print("REQUEST_SENSE ");

  560. 				 phex(scsi_sense);

  561. 				 phex(scsi_asense);

  562. 				 print("\n");

  563. 				if (media_state & MEDIA_STATE_CLAIMED)

  564. 					media_state |= MEDIA_STATE_CLAIMED_SENSE;

  565. 				UEINTX = 0x6B;

  566. 				UENUM = DISK_TX_ENDPOINT;

  567. 				UEDATX = 0x70;

  568. 				UEDATX = 0;

  569. 				UEDATX = scsi_sense;

  570. 				UEDATX = 0;

  571. 				UEDATX = 0;

  572. 				UEDATX = 0;

  573. 				UEDATX = 0;

  574. 				UEDATX = 10;

  575. 				UEDATX = 0;

  576. 				UEDATX = 0;

  577. 				UEDATX = 0;

  578. 				UEDATX = 0;

  579. 				UEDATX = scsi_asense;

  580. 				xfer_len -= 13;

  581. 				goto send_finishup;

  582. 			}

  583. 			scsi_sense = SCSI_SENSE_OK;

  584. 			scsi_asense = SCSI_ASENSE_NONE;

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

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

  587. 				uint16_t len;

  588. 				UEDATX;		// ignore request bits

  589. 				UEDATX;

  590. 				read_word_msbfirst(len, UEDATX);

  591. 				 print("INQUIRY\n");

  592. 				UEINTX = 0x6B;

  593. 				if (len > sizeof(scsi_inquiry_response))

  594. 					len = sizeof(scsi_inquiry_response);

  595. 				p = scsi_inquiry_response;

  596. 				UENUM = DISK_TX_ENDPOINT;

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

  598. 					pgm_read_byte_postinc(UEDATX, p);

  599. 				}

  600. 				xfer_len -= len;

  601. 				goto send_finishup;

  602. 			}

  603. 			previous_media_state = media_state;

  604. 			do_media_status = 1;

  605. 

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

  607. 

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

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

  610. 				phex(media_state);

  611. 				print("\n");

  612. 				media_poll();

  613. 				UEINTX = 0x3A;

  614. 				goto send_status;

  615. 			}

  616. 

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

  618. 			// to be present

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

  620. 				print("stall_in\n");

  621. 				UEINTX = 0x6B;

  622. 				UENUM = DISK_TX_ENDPOINT;

  623. 				//UEIENX = 0;

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

  625. 				ms_state = MS_STATE_SEND_STATUS;

  626. 				return ENABLE_MORE_RX;

  627. 			}

  628. 

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

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

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

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

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

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

  635. 				// check allocation length...

  636. 				UEINTX = 0x6B;

  637. 				UENUM = DISK_TX_ENDPOINT;

  638. 				UEDATX = 0x03;

  639. 				UEDATX = 0x00;

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

  641. 				UEDATX = 0x00;

  642. 				xfer_len -= 4;

  643. 				goto send_finishup;

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

  645. 				uint32_t capacity;

  646. 				 print("CAPACITY\n");

  647. 				UEINTX = 0x6B;

  648. 				media_poll();

  649. 				capacity = media_size();

  650. 				UENUM = DISK_TX_ENDPOINT;

  651. 				write_dword_msbfirst(capacity - 1, UEDATX);

  652. 				UEDATX = 0x00;

  653. 				UEDATX = 0x00;

  654. 				UEDATX = 0x02;

  655. 				UEDATX = 0x00;

  656. 				xfer_len -= 8;

  657. 				goto send_finishup;

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

  659. 				uint32_t capacity;

  660. 				 print("READ_FORMAT_CAPACITIES\n");

  661. 				UEINTX = 0x6B;

  662. 				media_poll();

  663. 				capacity = media_size();

  664. 				UENUM = DISK_TX_ENDPOINT;

  665. 				UEDATX = 0x00;

  666. 				UEDATX = 0x00;

  667. 				UEDATX = 0x00;

  668. 				UEDATX = 0x08;

  669. 				write_dword_msbfirst(capacity, UEDATX);

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

  671. 				UEDATX = 0x00;

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

  673. 				UEDATX = 0x00;

  674. 				xfer_len -= 12;

  675. 				goto send_finishup;

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

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

  678. 				UEDATX;

  679. 				read_dword_msbfirst(lba, UEDATX);

  680. 				UEDATX;

  681. 				read_word_msbfirst(sector_count, UEDATX);

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

  683. 				 phex32(lba);

  684. 				 print(", count=");

  685. 				 phex16(sector_count);

  686. 				 print("\n");

  687. 				UEINTX = 0x6B;

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

  689. 					UENUM = DISK_TX_ENDPOINT;

  690. 					goto send_finishup;

  691. 				}

  692. 				media_send_begin(lba);

  693. 				sector_chunk = 0;

  694. 				ms_state = MS_STATE_SEND_DATA;

  695. 				goto send_data;

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

  697. 				UEDATX;

  698. 				read_dword_msbfirst(lba, UEDATX);

  699. 				UEDATX;

  700. 				read_word_msbfirst(sector_count, UEDATX);

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

  702. 				 phex32(lba);

  703. 				 print(", count=");

  704. 				 phex16(sector_count);

  705. 				 print("\n");

  706. 				UEINTX = 0x6B;

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

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

  709. 				sector_chunk = 0;

  710. 				media_receive_begin(lba);

  711. 				ms_state = MS_STATE_RECEIVE_DATA;

  712. 				n = UEBCLX;

  713. 				if (n > 0) goto receive_data;

  714. 				return ENABLE_MORE_RX;

  715. 			} else {

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

  717. 				 phex(cmd);

  718. 				 print("\n");

  719. 				UEINTX = 0x6B;

  720. 				scsi_sense = SCSI_SENSE_ILLEGAL_REQUEST;

  721. 				scsi_asense = SCSI_ASENSE_INVALID_COMMAND;

  722. 				status = 1;

  723. 				goto send_finishup;

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

  725. 				//UENUM = DISK_TX_ENDPOINT;

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

  727. 				//state = MS_STATE_SEND_STATUS;

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

  729. 				//return ENABLE_MORE_RX;

  730. 			}

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

  732. 			receive_data:

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

  734. 			//phex16(sector_count);

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

  736. 			//phex32(lba);

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

  738. 			//phex(sector_chunk);

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

  740. 			if (sector_count > 0) {

  741. 				media_receive_chunk(lba, sector_chunk);

  742. 				xfer_len -= 64;

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

  744. 					sector_chunk = 0;

  745. 					lba++;

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

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

  748. 						media_receive_end();

  749. 						goto send_status;

  750. 					}

  751. 				}

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

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

  754. 			} else {

  755. 				UEINTX = 0x6B;

  756. 			}

  757. 			return ENABLE_MORE_RX;

  758. 		} else {

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

  760. 			//phex(n);

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

  762. 			UEINTX = 0x6B;

  763. 			return ENABLE_MORE_RX;

  764. 		}

  765. 	}

  766. 	if (need_tx) {

  767. 		UENUM = DISK_TX_ENDPOINT;

  768. 		//print("tx ");

  769. 		state = ms_state;

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

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

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

  773. 		print("unhandled tx interrupt ");

  774. 		phex(state);

  775. 		print("\n");

  776. 		return 0;

  777. 	}

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

  779. 

  780. send_data:

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

  782. 	 //phex16(sector_count);

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

  784. 	 //phex32(lba);

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

  786. 	 //phex(sector_chunk);

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

  788. 	UENUM = DISK_TX_ENDPOINT;

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

  790. 		media_send_chunk(lba, sector_chunk);

  791. 		xfer_len -= 64;

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

  793. 			sector_chunk = 0;

  794. 			lba++;

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

  796. 				media_send_end();

  797. 				ms_state = MS_STATE_SEND_STATUS;

  798. 			}

  799. 		}

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

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

  802. 	}

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

  804. 	return ENABLE_MORE_TX;

  805. send_finishup:

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

  807. 		UEDATX = 0;

  808. 		xfer_len--;

  809. 	}

  810. 	UEINTX = 0x3A;

  811. 	if (xfer_len) {

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

  813. 		ms_state = MS_STATE_SEND_ZEROPAD;

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

  815. 		return ENABLE_MORE_TX;

  816. 	}

  817. send_status:

  818. 	UENUM = DISK_TX_ENDPOINT;

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

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

  821. 		ms_state = MS_STATE_SEND_STATUS;

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

  823. 		return ENABLE_MORE_TX;

  824. 	}

  825. send_status_force:

  826. 	if (do_media_status) {

  827. 		uint8_t current_media_state = media_state;

  828. 		if (current_media_state & MEDIA_STATE_CLAIMED)

  829. 			media_state = current_media_state | MEDIA_STATE_CLAIMED_STATUS;

  830. 		if (status == 0) {

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

  832. 				scsi_sense = SCSI_SENSE_NOT_READY;

  833. 				scsi_asense = SCSI_ASENSE_MEDIUM_NOT_PRESENT;

  834. 				status = 1;

  835. 			} else {

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

  837. 					scsi_sense = SCSI_SENSE_UNIT_ATTENTION;

  838. 					scsi_asense = SCSI_ASENSE_NOT_READY_TO_READY;

  839. 					status = 1;

  840. 				}

  841. 			}

  842. 		}

  843. 		do_media_status = 0;

  844. 	}

  845. 	print("status ");

  846. 	phex(status);

  847. 	if (status) {

  848. 		phex(scsi_sense);

  849. 		phex(scsi_asense);

  850. 	}

  851. 	print("\n");

  852. 	UEDATX = 0x55;

  853. 	UEDATX = 0x53;

  854. 	UEDATX = 0x42;

  855. 	UEDATX = 0x53;

  856. 	write_dword_lsbfirst(tag, UEDATX);

  857. 	write_dword_lsbfirst(xfer_len, UEDATX);

  858. 	UEDATX = status;

  859. 	UEINTX = 0x3A;

  860. 	//UEIENX = 0;

  861. 	ms_state = MS_STATE_IDLE;

  862. 	media_unlock_isr();

  863. 	return ENABLE_MORE_RX;

  864. error_stall:

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

  866. 	ms_state = MS_STATE_STALLED;

  867. 	UENUM = DISK_RX_ENDPOINT;

  868. 	//UEIENX = 0;

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

  870. 	UENUM = DISK_TX_ENDPOINT;

  871. 	//UEIENX = 0;

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

  873. 	media_unlock_isr();

  874. 	return ENABLE_MORE_RX | ENABLE_MORE_TX;

  875. }

  876. 

  877. 

  878. 

  879. 

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

  881. static inline void usb_wait_in_ready(void)

  882. {

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

  884. }

  885. static inline void usb_send_in(void)

  886. {

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

  888. }

  889. static inline void usb_wait_receive_out(void)

  890. {

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

  892. }

  893. static inline void usb_ack_out(void)

  894. {

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

  896. }

  897. 

  898. 

  899. 

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

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

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

  903. //

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

  905. static inline void endpoint0_isr(void)

  906. {

  907. 	uint8_t intbits;

  908. 	const uint8_t *list;

  909. 	const uint8_t *cfg;

  910. 	uint8_t i, n, len, en;

  911. 	uint8_t bmRequestType;

  912. 	uint8_t bRequest;

  913. 	uint16_t wValue;

  914. 	uint16_t wIndex;

  915. 	uint16_t wLength;

  916. 	uint16_t desc_val;

  917. 	const uint8_t *desc_addr;

  918. 	uint8_t	desc_length;

  919. 

  920. 	UENUM = 0;

  921. 	intbits = UEINTX;

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

  923. 		bmRequestType = UEDATX;

  924. 		bRequest = UEDATX;

  925. 		read_word_lsbfirst(wValue, UEDATX);

  926. 		read_word_lsbfirst(wIndex, UEDATX);

  927. 		read_word_lsbfirst(wLength, UEDATX);

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

  929. 		if (bRequest == GET_DESCRIPTOR) {

  930. 			list = (const uint8_t *)descriptor_list;

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

  932. 				if (i >= NUM_DESC_LIST) {

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

  934. 					return;

  935. 				}

  936. 				pgm_read_word_postinc(desc_val, list);

  937. 				if (desc_val != wValue) {

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

  939. 					continue;

  940. 				}

  941. 				pgm_read_word_postinc(desc_val, list);

  942. 				if (desc_val != wIndex) {

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

  944. 					continue;

  945. 				}

  946. 				pgm_read_word_postinc(desc_addr, list);

  947. 				desc_length = pgm_read_byte(list);

  948. 				break;

  949. 			}

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

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

  952. 			list = desc_addr;

  953. 			do {

  954. 				// wait for host ready for IN packet

  955. 				do {

  956. 					i = UEINTX;

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

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

  959. 				// send IN packet

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

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

  962. 					pgm_read_byte_postinc(UEDATX, list);

  963. 				}

  964. 				len -= n;

  965. 				usb_send_in();

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

  967. 			return;

  968. 		}

  969. 		if (bRequest == SET_ADDRESS) {

  970. 			usb_send_in();

  971. 			usb_wait_in_ready();

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

  973. 			return;

  974. 		}

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

  976. 			usb_configuration = wValue;

  977. 			debug_flush_timer = 0;

  978. 			usb_send_in();

  979. 			cfg = endpoint_config_table;

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

  981. 				UENUM = i;

  982. 				pgm_read_byte_postinc(en, cfg);

  983. 				UECONX = en;

  984. 				if (en) {

  985. 					pgm_read_byte_postinc(UECFG0X, cfg);

  986. 					pgm_read_byte_postinc(UECFG1X, cfg);

  987. 				}

  988. 			}

  989. 			UERST = 0x1E;

  990. 			UERST = 0;

  991. 			UENUM = DISK_RX_ENDPOINT;

  992. 			UEIENX = (1<<RXOUTE);

  993. 			return;

  994. 		}

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

  996. 			usb_wait_in_ready();

  997. 			UEDATX = usb_configuration;

  998. 			usb_send_in();

  999. 			return;

  1000. 		}

  1001. 		if (bRequest == GET_STATUS) {

  1002. 			usb_wait_in_ready();

  1003. 			i = 0;

  1004. 			if (bmRequestType == 0x82) {

  1005. 				UENUM = wIndex;

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

  1007. 				UENUM = 0;

  1008. 			}

  1009. 			UEDATX = i;

  1010. 			UEDATX = 0;

  1011. 			usb_send_in();

  1012. 			return;

  1013. 		}

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

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

  1016. 			i = wIndex & 0x7F;

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

  1018. 				usb_send_in();

  1019. 				UENUM = i;

  1020. 				if (bRequest == SET_FEATURE) {

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

  1022. 				} else {

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

  1024. 					UERST = (1 << i);

  1025. 					UERST = 0;

  1026. 					if (i == DISK_TX_ENDPOINT) {

  1027. 						UEIENX = (1<<TXINE);

  1028. 					}

  1029. 				}

  1030. 				return;

  1031. 			}

  1032. 		}

  1033. 		if (wIndex == KEYBOARD_INTERFACE) {

  1034. 			if (bmRequestType == 0xA1) {

  1035. 				if (bRequest == HID_GET_REPORT) {

  1036. 					usb_wait_in_ready();

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

  1038. 						UEDATX = keyboard_report_data[i];

  1039. 					}

  1040. 					usb_send_in();

  1041. 					return;

  1042. 				}

  1043. 				if (bRequest == HID_GET_IDLE) {

  1044. 					usb_wait_in_ready();

  1045. 					UEDATX = keyboard_idle_config;

  1046. 					usb_send_in();

  1047. 					return;

  1048. 				}

  1049. 				if (bRequest == HID_GET_PROTOCOL) {

  1050. 					usb_wait_in_ready();

  1051. 					UEDATX = keyboard_protocol;

  1052. 					usb_send_in();

  1053. 					return;

  1054. 				}

  1055. 			}

  1056. 			if (bmRequestType == 0x21) {

  1057. 				if (bRequest == HID_SET_REPORT) {

  1058. 					usb_wait_receive_out();

  1059. 					keyboard_leds = UEDATX;

  1060. 					usb_ack_out();

  1061. 					usb_send_in();

  1062. 					return;

  1063. 				}

  1064. 				if (bRequest == HID_SET_IDLE) {

  1065. 					keyboard_idle_config = (wValue >> 8);

  1066. 					keyboard_idle_count = 0;

  1067. 					//usb_wait_in_ready();

  1068. 					usb_send_in();

  1069. 					return;

  1070. 				}

  1071. 				if (bRequest == HID_SET_PROTOCOL) {

  1072. 					keyboard_protocol = wValue;

  1073. 					//usb_wait_in_ready();

  1074. 					usb_send_in();

  1075. 					return;

  1076. 				}

  1077. 			}

  1078. 		}

  1079. 		if (wIndex == DEBUG_INTERFACE) {

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

  1081. 				len = wLength;

  1082. 				do {

  1083. 					// wait for host ready for IN packet

  1084. 					do {

  1085. 						i = UEINTX;

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

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

  1088. 					// send IN packet

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

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

  1091. 						UEDATX = 0;

  1092. 					}

  1093. 					len -= n;

  1094. 					usb_send_in();

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

  1096. 				return;

  1097. 			}

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

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

  1100. 					uint8_t b1, b2, b3, b4;

  1101. 					usb_wait_receive_out();

  1102. 					b1 = UEDATX;

  1103. 					b2 = UEDATX;

  1104. 					b3 = UEDATX;

  1105. 					b4 = UEDATX;

  1106. 					usb_ack_out();

  1107. 					usb_send_in();

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

  1109. 						_reboot_Teensyduino_();

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

  1111. 						_restart_Teensyduino_();

  1112. 				}

  1113. 			}

  1114. 		}

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

  1116. 			usb_send_in();

  1117. 			usb_wait_in_ready();

  1118. 			_restart_Teensyduino_();

  1119. 		}

  1120. 		if (wIndex == DISK_INTERFACE) {

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

  1122. 				usb_wait_in_ready();

  1123. 				ms_state = MS_STATE_IDLE;

  1124. 				usb_send_in();

  1125. 				return;

  1126. 			}

  1127. 		}

  1128. 	}

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

  1130. }

  1131. 

  1132. 

  1133. // USB Endpoint Interrupt

  1134. ISR(USB_COM_vect)

  1135. {

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

  1137. 

  1138. 	// first, do endpoint 0

  1139. 	epnum_save = UENUM;

  1140. 	endpoint0_isr();

  1141. 

  1142. 	// disable all USB interrupts

  1143. 	UDIEN = 0;

  1144. 	UENUM = 0;

  1145. 	UEIENX = 0;

  1146. 	UENUM = DISK_RX_ENDPOINT;

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

  1148. 		r = ENABLE_MORE_RX;

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

  1150. 	}

  1151. 	UEIENX = 0;

  1152. 	UENUM = DISK_TX_ENDPOINT;

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

  1154. 		r |= ENABLE_MORE_TX;

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

  1156. 	}

  1157. 	UEIENX = 0;

  1158. 

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

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

  1161. 	if (need_rx || need_tx) {

  1162. 		sei();

  1163. 		r = mass_storage_isr(need_rx, need_tx);

  1164. 		cli();

  1165. 	}

  1166. 

  1167. 	// re-enable USB interrupts

  1168. 	if (r & ENABLE_MORE_RX) {

  1169. 		UENUM = DISK_RX_ENDPOINT;

  1170. 		UEIENX = (1<<RXOUTE);

  1171. 	}

  1172. 	if (r & ENABLE_MORE_TX) {

  1173. 		UENUM = DISK_TX_ENDPOINT;

  1174. 		UEIENX = (1<<TXINE);

  1175. 	}

  1176. 	UENUM = 0;

  1177. 	UEIENX = (1<<RXSTPE);

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

  1179. 	UENUM = epnum_save;

  1180. }

  1181. 

  1182. 

  1183. 

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

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

  1186. //

  1187. ISR(USB_GEN_vect)

  1188. {

  1189. 	uint8_t intbits, t, i;

  1190. 	static uint8_t div4=0;

  1191. 

  1192. 	intbits = UDINT;

  1193. 	UDINT = 0;

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

  1195. 		UENUM = 0;

  1196. 		UECONX = 1;

  1197. 		UECFG0X = EP_TYPE_CONTROL;

  1198. 		UECFG1X = EP_SIZE(ENDPOINT0_SIZE) | EP_SINGLE_BUFFER;

  1199. 		UEIENX = (1<<RXSTPE);

  1200. 		usb_configuration = 0;

  1201. 		UENUM = DISK_RX_ENDPOINT;

  1202. 		UEIENX = 0;

  1203. 		UENUM = DISK_TX_ENDPOINT;

  1204. 		UEIENX = 0;

  1205. 		ms_state = MS_STATE_IDLE;

  1206. 	}

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

  1208. 		t = debug_flush_timer;

  1209. 		if (t) {

  1210. 			debug_flush_timer = -- t;

  1211. 			if (!t) {

  1212. 				UENUM = DEBUG_TX_ENDPOINT;

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

  1214. 					UEDATX = 0;

  1215. 				}

  1216. 				UEINTX = 0x3A;

  1217. 			}

  1218. 		}

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

  1220. 			UENUM = KEYBOARD_ENDPOINT;

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

  1222. 				keyboard_idle_count++;

  1223. 				if (keyboard_idle_count == keyboard_idle_config) {

  1224. 					keyboard_idle_count = 0;

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

  1226. 						UEDATX = keyboard_report_data[i];

  1227. 					}

  1228. 					UEINTX = 0x3A;

  1229. 				}

  1230. 			}

  1231. 		}

  1232. 	}

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

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

  1235. 		UDIEN = (1<<WAKEUPE);

  1236. 		usb_configuration = 0;

  1237. 		usb_suspended = 1;

  1238. 		#if (F_CPU >= 8000000L)

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

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

  1241. 		// Is this a hardware bug?

  1242. 		USB_FREEZE();			// shut off USB

  1243. 		PLLCSR = 0;			// shut off PLL

  1244. 		#endif

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

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

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

  1248. 		// user's paradigm....

  1249. 	}

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

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

  1252. 		#if (F_CPU >= 8000000L)

  1253. 		PLL_CONFIG();

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

  1255. 		USB_CONFIG();

  1256. 		#endif

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

  1258. 		usb_suspended = 0;

  1259. 		return;

  1260. 	}

  1261. }