vusb.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513
  1. /*
  2. Copyright 2011 Jun Wako <wakojun@gmail.com>
  3. This program is free software: you can redistribute it and/or modify
  4. it under the terms of the GNU General Public License as published by
  5. the Free Software Foundation, either version 2 of the License, or
  6. (at your option) any later version.
  7. This program is distributed in the hope that it will be useful,
  8. but WITHOUT ANY WARRANTY; without even the implied warranty of
  9. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  10. GNU General Public License for more details.
  11. You should have received a copy of the GNU General Public License
  12. along with this program. If not, see <http://www.gnu.org/licenses/>.
  13. */
  14. #include <avr/eeprom.h>
  15. #include <avr/wdt.h>
  16. #include <stdint.h>
  17. #include "usbdrv.h"
  18. #include "usbconfig.h"
  19. #include "host.h"
  20. #include "report.h"
  21. #include "print.h"
  22. #include "debug.h"
  23. #include "host_driver.h"
  24. #include "vusb.h"
  25. #include "bootloader.h"
  26. static uint8_t vusb_keyboard_leds = 0;
  27. static uint8_t vusb_idle_rate = 0;
  28. /* Keyboard report send buffer */
  29. #define KBUF_SIZE 16
  30. static report_keyboard_t kbuf[KBUF_SIZE];
  31. static uint8_t kbuf_head = 0;
  32. static uint8_t kbuf_tail = 0;
  33. typedef struct {
  34. uint8_t modifier;
  35. uint8_t reserved;
  36. uint8_t keycode[6];
  37. } keyboard_report_t;
  38. static keyboard_report_t keyboard_report; // sent to PC
  39. /* transfer keyboard report from buffer */
  40. void vusb_transfer_keyboard(void)
  41. {
  42. if (usbInterruptIsReady()) {
  43. if (kbuf_head != kbuf_tail) {
  44. usbSetInterrupt((void *)&kbuf[kbuf_tail], sizeof(report_keyboard_t));
  45. kbuf_tail = (kbuf_tail + 1) % KBUF_SIZE;
  46. if (debug_keyboard) {
  47. print("V-USB: kbuf["); pdec(kbuf_tail); print("->"); pdec(kbuf_head); print("](");
  48. phex((kbuf_head < kbuf_tail) ? (KBUF_SIZE - kbuf_tail + kbuf_head) : (kbuf_head - kbuf_tail));
  49. print(")\n");
  50. }
  51. }
  52. } else {
  53. usbPoll();
  54. vusb_transfer_keyboard();
  55. }
  56. }
  57. /*------------------------------------------------------------------*
  58. * Host driver
  59. *------------------------------------------------------------------*/
  60. static uint8_t keyboard_leds(void);
  61. static void send_keyboard(report_keyboard_t *report);
  62. static void send_mouse(report_mouse_t *report);
  63. static void send_system(uint16_t data);
  64. static void send_consumer(uint16_t data);
  65. static host_driver_t driver = {
  66. keyboard_leds,
  67. send_keyboard,
  68. send_mouse,
  69. send_system,
  70. send_consumer
  71. };
  72. host_driver_t *vusb_driver(void)
  73. {
  74. return &driver;
  75. }
  76. static uint8_t keyboard_leds(void) {
  77. return vusb_keyboard_leds;
  78. }
  79. static void send_keyboard(report_keyboard_t *report)
  80. {
  81. uint8_t next = (kbuf_head + 1) % KBUF_SIZE;
  82. if (next != kbuf_tail) {
  83. kbuf[kbuf_head] = *report;
  84. kbuf_head = next;
  85. } else {
  86. debug("kbuf: full\n");
  87. }
  88. // NOTE: send key strokes of Macro
  89. usbPoll();
  90. vusb_transfer_keyboard();
  91. }
  92. typedef struct {
  93. uint8_t report_id;
  94. report_mouse_t report;
  95. } __attribute__ ((packed)) vusb_mouse_report_t;
  96. static void send_mouse(report_mouse_t *report)
  97. {
  98. vusb_mouse_report_t r = {
  99. .report_id = REPORT_ID_MOUSE,
  100. .report = *report
  101. };
  102. if (usbInterruptIsReady3()) {
  103. usbSetInterrupt3((void *)&r, sizeof(vusb_mouse_report_t));
  104. }
  105. }
  106. typedef struct {
  107. uint8_t report_id;
  108. uint16_t usage;
  109. } __attribute__ ((packed)) report_extra_t;
  110. static void send_system(uint16_t data)
  111. {
  112. static uint16_t last_data = 0;
  113. if (data == last_data) return;
  114. last_data = data;
  115. report_extra_t report = {
  116. .report_id = REPORT_ID_SYSTEM,
  117. .usage = data
  118. };
  119. if (usbInterruptIsReady3()) {
  120. usbSetInterrupt3((void *)&report, sizeof(report));
  121. }
  122. }
  123. static void send_consumer(uint16_t data)
  124. {
  125. static uint16_t last_data = 0;
  126. if (data == last_data) return;
  127. last_data = data;
  128. report_extra_t report = {
  129. .report_id = REPORT_ID_CONSUMER,
  130. .usage = data
  131. };
  132. if (usbInterruptIsReady3()) {
  133. usbSetInterrupt3((void *)&report, sizeof(report));
  134. }
  135. }
  136. /*------------------------------------------------------------------*
  137. * Request from host *
  138. *------------------------------------------------------------------*/
  139. static struct {
  140. uint16_t len;
  141. enum {
  142. NONE,
  143. BOOTLOADER,
  144. SET_LED
  145. } kind;
  146. } last_req;
  147. usbMsgLen_t usbFunctionSetup(uchar data[8])
  148. {
  149. usbRequest_t *rq = (void *)data;
  150. if((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS){ /* class request type */
  151. if(rq->bRequest == USBRQ_HID_GET_REPORT){
  152. debug("GET_REPORT:");
  153. /* we only have one report type, so don't look at wValue */
  154. usbMsgPtr = (void *)&keyboard_report;
  155. return sizeof(keyboard_report);
  156. }else if(rq->bRequest == USBRQ_HID_GET_IDLE){
  157. debug("GET_IDLE: ");
  158. //debug_hex(vusb_idle_rate);
  159. usbMsgPtr = &vusb_idle_rate;
  160. return 1;
  161. }else if(rq->bRequest == USBRQ_HID_SET_IDLE){
  162. vusb_idle_rate = rq->wValue.bytes[1];
  163. debug("SET_IDLE: ");
  164. debug_hex(vusb_idle_rate);
  165. }else if(rq->bRequest == USBRQ_HID_SET_REPORT){
  166. debug("SET_REPORT: ");
  167. // Report Type: 0x02(Out)/ReportID: 0x00(none) && Interface: 0(keyboard)
  168. if (rq->wValue.word == 0x0200 && rq->wIndex.word == 0) {
  169. debug("SET_LED: ");
  170. last_req.kind = SET_LED;
  171. last_req.len = rq->wLength.word;
  172. #ifdef BOOTLOADER_SIZE
  173. } else if(rq->wValue.word == 0x0301) {
  174. last_req.kind = BOOTLOADER;
  175. last_req.len = rq->wLength.word;
  176. #endif
  177. }
  178. return USB_NO_MSG; // to get data in usbFunctionWrite
  179. } else {
  180. debug("UNKNOWN:");
  181. }
  182. }else{
  183. debug("VENDOR:");
  184. /* no vendor specific requests implemented */
  185. }
  186. debug("\n");
  187. return 0; /* default for not implemented requests: return no data back to host */
  188. }
  189. uchar usbFunctionWrite(uchar *data, uchar len)
  190. {
  191. if (last_req.len == 0) {
  192. return -1;
  193. }
  194. switch (last_req.kind) {
  195. case SET_LED:
  196. debug("SET_LED: ");
  197. debug_hex(data[0]);
  198. debug("\n");
  199. vusb_keyboard_leds = data[0];
  200. last_req.len = 0;
  201. return 1;
  202. break;
  203. case BOOTLOADER:
  204. usbDeviceDisconnect();
  205. bootloader_jump();
  206. return 1;
  207. break;
  208. case NONE:
  209. default:
  210. return -1;
  211. break;
  212. }
  213. return 1;
  214. }
  215. /*------------------------------------------------------------------*
  216. * Descriptors *
  217. *------------------------------------------------------------------*/
  218. /*
  219. * Report Descriptor for keyboard
  220. *
  221. * from an example in HID spec appendix
  222. */
  223. const PROGMEM uchar keyboard_hid_report[] = {
  224. 0x05, 0x01, // Usage Page (Generic Desktop),
  225. 0x09, 0x06, // Usage (Keyboard),
  226. 0xA1, 0x01, // Collection (Application),
  227. 0x75, 0x01, // Report Size (1),
  228. 0x95, 0x08, // Report Count (8),
  229. 0x05, 0x07, // Usage Page (Key Codes),
  230. 0x19, 0xE0, // Usage Minimum (224),
  231. 0x29, 0xE7, // Usage Maximum (231),
  232. 0x15, 0x00, // Logical Minimum (0),
  233. 0x25, 0x01, // Logical Maximum (1),
  234. 0x81, 0x02, // Input (Data, Variable, Absolute), ;Modifier byte
  235. 0x95, 0x01, // Report Count (1),
  236. 0x75, 0x08, // Report Size (8),
  237. 0x81, 0x03, // Input (Constant), ;Reserved byte
  238. 0x95, 0x05, // Report Count (5),
  239. 0x75, 0x01, // Report Size (1),
  240. 0x05, 0x08, // Usage Page (LEDs),
  241. 0x19, 0x01, // Usage Minimum (1),
  242. 0x29, 0x05, // Usage Maximum (5),
  243. 0x91, 0x02, // Output (Data, Variable, Absolute), ;LED report
  244. 0x95, 0x01, // Report Count (1),
  245. 0x75, 0x03, // Report Size (3),
  246. 0x91, 0x03, // Output (Constant), ;LED report padding
  247. 0x95, 0x06, // Report Count (6),
  248. 0x75, 0x08, // Report Size (8),
  249. 0x15, 0x00, // Logical Minimum (0),
  250. 0x26, 0xFF, 0x00, // Logical Maximum(255),
  251. 0x05, 0x07, // Usage Page (Key Codes),
  252. 0x19, 0x00, // Usage Minimum (0),
  253. 0x29, 0xFF, // Usage Maximum (255),
  254. 0x81, 0x00, // Input (Data, Array),
  255. 0xc0 // End Collection
  256. };
  257. /*
  258. * Report Descriptor for mouse
  259. *
  260. * Mouse Protocol 1, HID 1.11 spec, Appendix B, page 59-60, with wheel extension
  261. * http://www.microchip.com/forums/tm.aspx?high=&m=391435&mpage=1#391521
  262. * http://www.keil.com/forum/15671/
  263. * http://www.microsoft.com/whdc/device/input/wheel.mspx
  264. */
  265. const PROGMEM uchar mouse_hid_report[] = {
  266. /* mouse */
  267. 0x05, 0x01, // USAGE_PAGE (Generic Desktop)
  268. 0x09, 0x02, // USAGE (Mouse)
  269. 0xa1, 0x01, // COLLECTION (Application)
  270. 0x85, REPORT_ID_MOUSE, // REPORT_ID (1)
  271. 0x09, 0x01, // USAGE (Pointer)
  272. 0xa1, 0x00, // COLLECTION (Physical)
  273. // ---------------------------- Buttons
  274. 0x05, 0x09, // USAGE_PAGE (Button)
  275. 0x19, 0x01, // USAGE_MINIMUM (Button 1)
  276. 0x29, 0x05, // USAGE_MAXIMUM (Button 5)
  277. 0x15, 0x00, // LOGICAL_MINIMUM (0)
  278. 0x25, 0x01, // LOGICAL_MAXIMUM (1)
  279. 0x75, 0x01, // REPORT_SIZE (1)
  280. 0x95, 0x05, // REPORT_COUNT (5)
  281. 0x81, 0x02, // INPUT (Data,Var,Abs)
  282. 0x75, 0x03, // REPORT_SIZE (3)
  283. 0x95, 0x01, // REPORT_COUNT (1)
  284. 0x81, 0x03, // INPUT (Cnst,Var,Abs)
  285. // ---------------------------- X,Y position
  286. 0x05, 0x01, // USAGE_PAGE (Generic Desktop)
  287. 0x09, 0x30, // USAGE (X)
  288. 0x09, 0x31, // USAGE (Y)
  289. 0x15, 0x81, // LOGICAL_MINIMUM (-127)
  290. 0x25, 0x7f, // LOGICAL_MAXIMUM (127)
  291. 0x75, 0x08, // REPORT_SIZE (8)
  292. 0x95, 0x02, // REPORT_COUNT (2)
  293. 0x81, 0x06, // INPUT (Data,Var,Rel)
  294. // ---------------------------- Vertical wheel
  295. 0x09, 0x38, // USAGE (Wheel)
  296. 0x15, 0x81, // LOGICAL_MINIMUM (-127)
  297. 0x25, 0x7f, // LOGICAL_MAXIMUM (127)
  298. 0x35, 0x00, // PHYSICAL_MINIMUM (0) - reset physical
  299. 0x45, 0x00, // PHYSICAL_MAXIMUM (0)
  300. 0x75, 0x08, // REPORT_SIZE (8)
  301. 0x95, 0x01, // REPORT_COUNT (1)
  302. 0x81, 0x06, // INPUT (Data,Var,Rel)
  303. // ---------------------------- Horizontal wheel
  304. 0x05, 0x0c, // USAGE_PAGE (Consumer Devices)
  305. 0x0a, 0x38, 0x02, // USAGE (AC Pan)
  306. 0x15, 0x81, // LOGICAL_MINIMUM (-127)
  307. 0x25, 0x7f, // LOGICAL_MAXIMUM (127)
  308. 0x75, 0x08, // REPORT_SIZE (8)
  309. 0x95, 0x01, // REPORT_COUNT (1)
  310. 0x81, 0x06, // INPUT (Data,Var,Rel)
  311. 0xc0, // END_COLLECTION
  312. 0xc0, // END_COLLECTION
  313. /* system control */
  314. 0x05, 0x01, // USAGE_PAGE (Generic Desktop)
  315. 0x09, 0x80, // USAGE (System Control)
  316. 0xa1, 0x01, // COLLECTION (Application)
  317. 0x85, REPORT_ID_SYSTEM, // REPORT_ID (2)
  318. 0x15, 0x01, // LOGICAL_MINIMUM (0x1)
  319. 0x26, 0xb7, 0x00, // LOGICAL_MAXIMUM (0xb7)
  320. 0x19, 0x01, // USAGE_MINIMUM (0x1)
  321. 0x29, 0xb7, // USAGE_MAXIMUM (0xb7)
  322. 0x75, 0x10, // REPORT_SIZE (16)
  323. 0x95, 0x01, // REPORT_COUNT (1)
  324. 0x81, 0x00, // INPUT (Data,Array,Abs)
  325. 0xc0, // END_COLLECTION
  326. /* consumer */
  327. 0x05, 0x0c, // USAGE_PAGE (Consumer Devices)
  328. 0x09, 0x01, // USAGE (Consumer Control)
  329. 0xa1, 0x01, // COLLECTION (Application)
  330. 0x85, REPORT_ID_CONSUMER, // REPORT_ID (3)
  331. 0x15, 0x01, // LOGICAL_MINIMUM (0x1)
  332. 0x26, 0x9c, 0x02, // LOGICAL_MAXIMUM (0x29c)
  333. 0x19, 0x01, // USAGE_MINIMUM (0x1)
  334. 0x2a, 0x9c, 0x02, // USAGE_MAXIMUM (0x29c)
  335. 0x75, 0x10, // REPORT_SIZE (16)
  336. 0x95, 0x01, // REPORT_COUNT (1)
  337. 0x81, 0x00, // INPUT (Data,Array,Abs)
  338. 0xc0, // END_COLLECTION
  339. };
  340. /*
  341. * Descriptor for compite device: Keyboard + Mouse
  342. *
  343. * contains: device, interface, HID and endpoint descriptors
  344. */
  345. #if USB_CFG_DESCR_PROPS_CONFIGURATION
  346. const PROGMEM char usbDescriptorConfiguration[] = { /* USB configuration descriptor */
  347. 9, /* sizeof(usbDescriptorConfiguration): length of descriptor in bytes */
  348. USBDESCR_CONFIG, /* descriptor type */
  349. 9 + (9 + 9 + 7) + (9 + 9 + 7), 0,
  350. //18 + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT3 + 9, 0,
  351. /* total length of data returned (including inlined descriptors) */
  352. 2, /* number of interfaces in this configuration */
  353. 1, /* index of this configuration */
  354. 0, /* configuration name string index */
  355. #if USB_CFG_IS_SELF_POWERED
  356. (1 << 7) | USBATTR_SELFPOWER, /* attributes */
  357. #else
  358. (1 << 7), /* attributes */
  359. #endif
  360. USB_CFG_MAX_BUS_POWER/2, /* max USB current in 2mA units */
  361. /*
  362. * Keyboard interface
  363. */
  364. /* Interface descriptor */
  365. 9, /* sizeof(usbDescrInterface): length of descriptor in bytes */
  366. USBDESCR_INTERFACE, /* descriptor type */
  367. 0, /* index of this interface */
  368. 0, /* alternate setting for this interface */
  369. USB_CFG_HAVE_INTRIN_ENDPOINT, /* endpoints excl 0: number of endpoint descriptors to follow */
  370. USB_CFG_INTERFACE_CLASS,
  371. USB_CFG_INTERFACE_SUBCLASS,
  372. USB_CFG_INTERFACE_PROTOCOL,
  373. 0, /* string index for interface */
  374. /* HID descriptor */
  375. 9, /* sizeof(usbDescrHID): length of descriptor in bytes */
  376. USBDESCR_HID, /* descriptor type: HID */
  377. 0x01, 0x01, /* BCD representation of HID version */
  378. 0x00, /* target country code */
  379. 0x01, /* number of HID Report (or other HID class) Descriptor infos to follow */
  380. 0x22, /* descriptor type: report */
  381. sizeof(keyboard_hid_report), 0, /* total length of report descriptor */
  382. /* Endpoint descriptor */
  383. #if USB_CFG_HAVE_INTRIN_ENDPOINT /* endpoint descriptor for endpoint 1 */
  384. 7, /* sizeof(usbDescrEndpoint) */
  385. USBDESCR_ENDPOINT, /* descriptor type = endpoint */
  386. (char)0x81, /* IN endpoint number 1 */
  387. 0x03, /* attrib: Interrupt endpoint */
  388. 8, 0, /* maximum packet size */
  389. USB_CFG_INTR_POLL_INTERVAL, /* in ms */
  390. #endif
  391. /*
  392. * Mouse interface
  393. */
  394. /* Interface descriptor */
  395. 9, /* sizeof(usbDescrInterface): length of descriptor in bytes */
  396. USBDESCR_INTERFACE, /* descriptor type */
  397. 1, /* index of this interface */
  398. 0, /* alternate setting for this interface */
  399. USB_CFG_HAVE_INTRIN_ENDPOINT3, /* endpoints excl 0: number of endpoint descriptors to follow */
  400. 0x03, /* CLASS: HID */
  401. 0, /* SUBCLASS: none */
  402. 0, /* PROTOCOL: none */
  403. 0, /* string index for interface */
  404. /* HID descriptor */
  405. 9, /* sizeof(usbDescrHID): length of descriptor in bytes */
  406. USBDESCR_HID, /* descriptor type: HID */
  407. 0x01, 0x01, /* BCD representation of HID version */
  408. 0x00, /* target country code */
  409. 0x01, /* number of HID Report (or other HID class) Descriptor infos to follow */
  410. 0x22, /* descriptor type: report */
  411. sizeof(mouse_hid_report), 0, /* total length of report descriptor */
  412. #if USB_CFG_HAVE_INTRIN_ENDPOINT3 /* endpoint descriptor for endpoint 3 */
  413. /* Endpoint descriptor */
  414. 7, /* sizeof(usbDescrEndpoint) */
  415. USBDESCR_ENDPOINT, /* descriptor type = endpoint */
  416. (char)(0x80 | USB_CFG_EP3_NUMBER), /* IN endpoint number 3 */
  417. 0x03, /* attrib: Interrupt endpoint */
  418. 8, 0, /* maximum packet size */
  419. USB_CFG_INTR_POLL_INTERVAL, /* in ms */
  420. #endif
  421. };
  422. #endif
  423. USB_PUBLIC usbMsgLen_t usbFunctionDescriptor(struct usbRequest *rq)
  424. {
  425. usbMsgLen_t len = 0;
  426. /*
  427. debug("usbFunctionDescriptor: ");
  428. debug_hex(rq->bmRequestType); debug(" ");
  429. debug_hex(rq->bRequest); debug(" ");
  430. debug_hex16(rq->wValue.word); debug(" ");
  431. debug_hex16(rq->wIndex.word); debug(" ");
  432. debug_hex16(rq->wLength.word); debug("\n");
  433. */
  434. switch (rq->wValue.bytes[1]) {
  435. #if USB_CFG_DESCR_PROPS_CONFIGURATION
  436. case USBDESCR_CONFIG:
  437. usbMsgPtr = (unsigned char *)usbDescriptorConfiguration;
  438. len = sizeof(usbDescriptorConfiguration);
  439. break;
  440. #endif
  441. case USBDESCR_HID:
  442. switch (rq->wValue.bytes[0]) {
  443. case 0:
  444. usbMsgPtr = (unsigned char *)(usbDescriptorConfiguration + 9 + 9);
  445. len = 9;
  446. break;
  447. case 1:
  448. usbMsgPtr = (unsigned char *)(usbDescriptorConfiguration + 9 + (9 + 9 + 7) + 9);
  449. len = 9;
  450. break;
  451. }
  452. break;
  453. case USBDESCR_HID_REPORT:
  454. /* interface index */
  455. switch (rq->wIndex.word) {
  456. case 0:
  457. usbMsgPtr = (unsigned char *)keyboard_hid_report;
  458. len = sizeof(keyboard_hid_report);
  459. break;
  460. case 1:
  461. usbMsgPtr = (unsigned char *)mouse_hid_report;
  462. len = sizeof(mouse_hid_report);
  463. break;
  464. }
  465. break;
  466. }
  467. //debug("desc len: "); debug_hex(len); debug("\n");
  468. return len;
  469. }