vusb.c 30 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942
  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 <stdint.h>
  15. #include <avr/wdt.h>
  16. #include <usbdrv/usbdrv.h>
  17. #include "usbconfig.h"
  18. #include "host.h"
  19. #include "report.h"
  20. #include "host_driver.h"
  21. #include "vusb.h"
  22. #include "print.h"
  23. #include "debug.h"
  24. #include "wait.h"
  25. #include "usb_descriptor_common.h"
  26. #ifdef RAW_ENABLE
  27. # include "raw_hid.h"
  28. #endif
  29. #if defined(CONSOLE_ENABLE)
  30. # define RBUF_SIZE 128
  31. # include "ring_buffer.h"
  32. #endif
  33. #define NEXT_INTERFACE __COUNTER__
  34. /*
  35. * Interface indexes
  36. */
  37. enum usb_interfaces {
  38. #ifndef KEYBOARD_SHARED_EP
  39. KEYBOARD_INTERFACE = NEXT_INTERFACE,
  40. #else
  41. SHARED_INTERFACE = NEXT_INTERFACE,
  42. # define KEYBOARD_INTERFACE SHARED_INTERFACE
  43. #endif
  44. // It is important that the Raw HID interface is at a constant
  45. // interface number, to support Linux/OSX platforms and chrome.hid
  46. // If Raw HID is enabled, let it be always 1.
  47. #ifdef RAW_ENABLE
  48. RAW_INTERFACE = NEXT_INTERFACE,
  49. #endif
  50. #if defined(SHARED_EP_ENABLE) && !defined(KEYBOARD_SHARED_EP)
  51. SHARED_INTERFACE = NEXT_INTERFACE,
  52. #endif
  53. #ifdef CONSOLE_ENABLE
  54. CONSOLE_INTERFACE = NEXT_INTERFACE,
  55. #endif
  56. TOTAL_INTERFACES = NEXT_INTERFACE
  57. };
  58. #define MAX_INTERFACES 3
  59. #if (NEXT_INTERFACE - 1) > MAX_INTERFACES
  60. # error There are not enough available interfaces to support all functions. Please disable one or more of the following: Mouse Keys, Extra Keys, Raw HID, Console
  61. #endif
  62. #if (defined(MOUSE_ENABLE) || defined(EXTRAKEY_ENABLE)) && CONSOLE_ENABLE
  63. # error Mouse/Extra Keys share an endpoint with Console. Please disable one of the two.
  64. #endif
  65. static uint8_t keyboard_led_state = 0;
  66. static uint8_t vusb_idle_rate = 0;
  67. /* Keyboard report send buffer */
  68. #define KBUF_SIZE 16
  69. static report_keyboard_t kbuf[KBUF_SIZE];
  70. static uint8_t kbuf_head = 0;
  71. static uint8_t kbuf_tail = 0;
  72. static report_keyboard_t keyboard_report_sent;
  73. #define VUSB_TRANSFER_KEYBOARD_MAX_TRIES 10
  74. /* transfer keyboard report from buffer */
  75. void vusb_transfer_keyboard(void) {
  76. for (int i = 0; i < VUSB_TRANSFER_KEYBOARD_MAX_TRIES; i++) {
  77. if (usbInterruptIsReady()) {
  78. if (kbuf_head != kbuf_tail) {
  79. #ifndef KEYBOARD_SHARED_EP
  80. usbSetInterrupt((void *)&kbuf[kbuf_tail], sizeof(report_keyboard_t));
  81. #else
  82. // Ugly hack! :(
  83. usbSetInterrupt((void *)&kbuf[kbuf_tail], sizeof(report_keyboard_t) - 1);
  84. while (!usbInterruptIsReady()) {
  85. usbPoll();
  86. }
  87. usbSetInterrupt((void *)(&(kbuf[kbuf_tail].keys[5])), 1);
  88. #endif
  89. kbuf_tail = (kbuf_tail + 1) % KBUF_SIZE;
  90. if (debug_keyboard) {
  91. dprintf("V-USB: kbuf[%d->%d](%02X)\n", kbuf_tail, kbuf_head, (kbuf_head < kbuf_tail) ? (KBUF_SIZE - kbuf_tail + kbuf_head) : (kbuf_head - kbuf_tail));
  92. }
  93. }
  94. break;
  95. }
  96. usbPoll();
  97. wait_ms(1);
  98. }
  99. }
  100. /*------------------------------------------------------------------*
  101. * RAW HID
  102. *------------------------------------------------------------------*/
  103. #ifdef RAW_ENABLE
  104. # define RAW_BUFFER_SIZE 32
  105. # define RAW_EPSIZE 8
  106. static uint8_t raw_output_buffer[RAW_BUFFER_SIZE];
  107. static uint8_t raw_output_received_bytes = 0;
  108. void raw_hid_send(uint8_t *data, uint8_t length) {
  109. if (length != RAW_BUFFER_SIZE) {
  110. return;
  111. }
  112. uint8_t *temp = data;
  113. for (uint8_t i = 0; i < 4; i++) {
  114. while (!usbInterruptIsReady4()) {
  115. usbPoll();
  116. }
  117. usbSetInterrupt4(temp, 8);
  118. temp += 8;
  119. }
  120. while (!usbInterruptIsReady4()) {
  121. usbPoll();
  122. }
  123. usbSetInterrupt4(0, 0);
  124. }
  125. __attribute__((weak)) void raw_hid_receive(uint8_t *data, uint8_t length) {
  126. // Users should #include "raw_hid.h" in their own code
  127. // and implement this function there. Leave this as weak linkage
  128. // so users can opt to not handle data coming in.
  129. }
  130. void raw_hid_task(void) {
  131. if (raw_output_received_bytes == RAW_BUFFER_SIZE) {
  132. raw_hid_receive(raw_output_buffer, RAW_BUFFER_SIZE);
  133. raw_output_received_bytes = 0;
  134. }
  135. }
  136. #endif
  137. /*------------------------------------------------------------------*
  138. * Console
  139. *------------------------------------------------------------------*/
  140. #ifdef CONSOLE_ENABLE
  141. # define CONSOLE_BUFFER_SIZE 32
  142. # define CONSOLE_EPSIZE 8
  143. int8_t sendchar(uint8_t c) {
  144. rbuf_enqueue(c);
  145. return 0;
  146. }
  147. static inline bool usbSendData3(char *data, uint8_t len) {
  148. uint8_t retries = 5;
  149. while (!usbInterruptIsReady3()) {
  150. if (!(retries--)) {
  151. return false;
  152. }
  153. usbPoll();
  154. }
  155. usbSetInterrupt3((unsigned char *)data, len);
  156. return true;
  157. }
  158. void console_task(void) {
  159. if (!usbConfiguration) {
  160. return;
  161. }
  162. if (!rbuf_has_data()) {
  163. return;
  164. }
  165. // Send in chunks of 8 padded to 32
  166. char send_buf[CONSOLE_BUFFER_SIZE] = {0};
  167. uint8_t send_buf_count = 0;
  168. while (rbuf_has_data() && send_buf_count < CONSOLE_EPSIZE) {
  169. send_buf[send_buf_count++] = rbuf_dequeue();
  170. }
  171. char *temp = send_buf;
  172. for (uint8_t i = 0; i < 4; i++) {
  173. if (!usbSendData3(temp, 8)) {
  174. break;
  175. }
  176. temp += 8;
  177. }
  178. usbSendData3(0, 0);
  179. usbPoll();
  180. }
  181. #endif
  182. /*------------------------------------------------------------------*
  183. * Host driver
  184. *------------------------------------------------------------------*/
  185. static uint8_t keyboard_leds(void);
  186. static void send_keyboard(report_keyboard_t *report);
  187. static void send_mouse(report_mouse_t *report);
  188. static void send_system(uint16_t data);
  189. static void send_consumer(uint16_t data);
  190. static host_driver_t driver = {keyboard_leds, send_keyboard, send_mouse, send_system, send_consumer};
  191. host_driver_t *vusb_driver(void) { return &driver; }
  192. static uint8_t keyboard_leds(void) { return keyboard_led_state; }
  193. static void send_keyboard(report_keyboard_t *report) {
  194. uint8_t next = (kbuf_head + 1) % KBUF_SIZE;
  195. if (next != kbuf_tail) {
  196. kbuf[kbuf_head] = *report;
  197. kbuf_head = next;
  198. } else {
  199. dprint("kbuf: full\n");
  200. }
  201. // NOTE: send key strokes of Macro
  202. usbPoll();
  203. vusb_transfer_keyboard();
  204. keyboard_report_sent = *report;
  205. }
  206. #ifndef KEYBOARD_SHARED_EP
  207. # define usbInterruptIsReadyShared usbInterruptIsReady3
  208. # define usbSetInterruptShared usbSetInterrupt3
  209. #else
  210. # define usbInterruptIsReadyShared usbInterruptIsReady
  211. # define usbSetInterruptShared usbSetInterrupt
  212. #endif
  213. static void send_mouse(report_mouse_t *report) {
  214. #ifdef MOUSE_ENABLE
  215. if (usbInterruptIsReadyShared()) {
  216. usbSetInterruptShared((void *)report, sizeof(report_mouse_t));
  217. }
  218. #endif
  219. }
  220. #ifdef EXTRAKEY_ENABLE
  221. static void send_extra(uint8_t report_id, uint16_t data) {
  222. static uint8_t last_id = 0;
  223. static uint16_t last_data = 0;
  224. if ((report_id == last_id) && (data == last_data)) return;
  225. last_id = report_id;
  226. last_data = data;
  227. report_extra_t report = {.report_id = report_id, .usage = data};
  228. if (usbInterruptIsReadyShared()) {
  229. usbSetInterruptShared((void *)&report, sizeof(report_extra_t));
  230. }
  231. }
  232. #endif
  233. static void send_system(uint16_t data) {
  234. #ifdef EXTRAKEY_ENABLE
  235. send_extra(REPORT_ID_SYSTEM, data);
  236. #endif
  237. }
  238. static void send_consumer(uint16_t data) {
  239. #ifdef EXTRAKEY_ENABLE
  240. send_extra(REPORT_ID_CONSUMER, data);
  241. #endif
  242. }
  243. /*------------------------------------------------------------------*
  244. * Request from host *
  245. *------------------------------------------------------------------*/
  246. static struct {
  247. uint16_t len;
  248. enum { NONE, SET_LED } kind;
  249. } last_req;
  250. usbMsgLen_t usbFunctionSetup(uchar data[8]) {
  251. usbRequest_t *rq = (void *)data;
  252. if ((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS) { /* class request type */
  253. if (rq->bRequest == USBRQ_HID_GET_REPORT) {
  254. dprint("GET_REPORT:");
  255. if (rq->wIndex.word == KEYBOARD_INTERFACE) {
  256. usbMsgPtr = (usbMsgPtr_t)&keyboard_report_sent;
  257. return sizeof(keyboard_report_sent);
  258. }
  259. } else if (rq->bRequest == USBRQ_HID_GET_IDLE) {
  260. dprint("GET_IDLE:");
  261. usbMsgPtr = (usbMsgPtr_t)&vusb_idle_rate;
  262. return 1;
  263. } else if (rq->bRequest == USBRQ_HID_SET_IDLE) {
  264. vusb_idle_rate = rq->wValue.bytes[1];
  265. dprintf("SET_IDLE: %02X", vusb_idle_rate);
  266. } else if (rq->bRequest == USBRQ_HID_SET_REPORT) {
  267. dprint("SET_REPORT:");
  268. // Report Type: 0x02(Out)/ReportID: 0x00(none) && Interface: 0(keyboard)
  269. if (rq->wValue.word == 0x0200 && rq->wIndex.word == KEYBOARD_INTERFACE) {
  270. dprint("SET_LED:");
  271. last_req.kind = SET_LED;
  272. last_req.len = rq->wLength.word;
  273. }
  274. return USB_NO_MSG; // to get data in usbFunctionWrite
  275. } else {
  276. dprint("UNKNOWN:");
  277. }
  278. } else {
  279. dprint("VENDOR:");
  280. /* no vendor specific requests implemented */
  281. }
  282. dprint("\n");
  283. return 0; /* default for not implemented requests: return no data back to host */
  284. }
  285. uchar usbFunctionWrite(uchar *data, uchar len) {
  286. if (last_req.len == 0) {
  287. return -1;
  288. }
  289. switch (last_req.kind) {
  290. case SET_LED:
  291. dprintf("SET_LED: %02X\n", data[0]);
  292. keyboard_led_state = data[0];
  293. last_req.len = 0;
  294. return 1;
  295. break;
  296. case NONE:
  297. default:
  298. return -1;
  299. break;
  300. }
  301. return 1;
  302. }
  303. void usbFunctionWriteOut(uchar *data, uchar len) {
  304. #ifdef RAW_ENABLE
  305. // Data from host must be divided every 8bytes
  306. if (len != 8) {
  307. dprint("RAW: invalid length\n");
  308. raw_output_received_bytes = 0;
  309. return;
  310. }
  311. if (raw_output_received_bytes + len > RAW_BUFFER_SIZE) {
  312. dprint("RAW: buffer full\n");
  313. raw_output_received_bytes = 0;
  314. } else {
  315. for (uint8_t i = 0; i < 8; i++) {
  316. raw_output_buffer[raw_output_received_bytes + i] = data[i];
  317. }
  318. raw_output_received_bytes += len;
  319. }
  320. #endif
  321. }
  322. /*------------------------------------------------------------------*
  323. * Descriptors *
  324. *------------------------------------------------------------------*/
  325. #ifdef KEYBOARD_SHARED_EP
  326. const PROGMEM uchar shared_hid_report[] = {
  327. # define SHARED_REPORT_STARTED
  328. #else
  329. const PROGMEM uchar keyboard_hid_report[] = {
  330. #endif
  331. 0x05, 0x01, // Usage Page (Generic Desktop)
  332. 0x09, 0x06, // Usage (Keyboard)
  333. 0xA1, 0x01, // Collection (Application)
  334. #ifdef KEYBOARD_SHARED_EP
  335. 0x85, REPORT_ID_KEYBOARD, // Report ID
  336. #endif
  337. // Modifiers (8 bits)
  338. 0x05, 0x07, // Usage Page (Keyboard/Keypad)
  339. 0x19, 0xE0, // Usage Minimum (Keyboard Left Control)
  340. 0x29, 0xE7, // Usage Maximum (Keyboard Right GUI)
  341. 0x15, 0x00, // Logical Minimum (0)
  342. 0x25, 0x01, // Logical Maximum (1)
  343. 0x95, 0x08, // Report Count (8)
  344. 0x75, 0x01, // Report Size (1)
  345. 0x81, 0x02, // Input (Data, Variable, Absolute)
  346. // Reserved (1 byte)
  347. 0x95, 0x01, // Report Count (1)
  348. 0x75, 0x08, // Report Size (8)
  349. 0x81, 0x03, // Input (Constant)
  350. // Keycodes (6 bytes)
  351. 0x05, 0x07, // Usage Page (Keyboard/Keypad)
  352. 0x19, 0x00, // Usage Minimum (0)
  353. 0x29, 0xFF, // Usage Maximum (255)
  354. 0x15, 0x00, // Logical Minimum (0)
  355. 0x26, 0xFF, 0x00, // Logical Maximum (255)
  356. 0x95, 0x06, // Report Count (6)
  357. 0x75, 0x08, // Report Size (8)
  358. 0x81, 0x00, // Input (Data, Array, Absolute)
  359. // Status LEDs (5 bits)
  360. 0x05, 0x08, // Usage Page (LED)
  361. 0x19, 0x01, // Usage Minimum (Num Lock)
  362. 0x29, 0x05, // Usage Maximum (Kana)
  363. 0x95, 0x05, // Report Count (5)
  364. 0x75, 0x01, // Report Size (1)
  365. 0x91, 0x02, // Output (Data, Variable, Absolute)
  366. // LED padding (3 bits)
  367. 0x95, 0x01, // Report Count (1)
  368. 0x75, 0x03, // Report Size (3)
  369. 0x91, 0x03, // Output (Constant)
  370. 0xC0, // End Collection
  371. #ifndef KEYBOARD_SHARED_EP
  372. };
  373. #endif
  374. #if defined(SHARED_EP_ENABLE) && !defined(SHARED_REPORT_STARTED)
  375. const PROGMEM uchar shared_hid_report[] = {
  376. # define SHARED_REPORT_STARTED
  377. #endif
  378. #ifdef MOUSE_ENABLE
  379. // Mouse report descriptor
  380. 0x05, 0x01, // Usage Page (Generic Desktop)
  381. 0x09, 0x02, // Usage (Mouse)
  382. 0xA1, 0x01, // Collection (Application)
  383. 0x85, REPORT_ID_MOUSE, // Report ID
  384. 0x09, 0x01, // Usage (Pointer)
  385. 0xA1, 0x00, // Collection (Physical)
  386. // Buttons (8 bits)
  387. 0x05, 0x09, // Usage Page (Button)
  388. 0x19, 0x01, // Usage Minimum (Button 1)
  389. 0x29, 0x08, // Usage Maximum (Button 8)
  390. 0x15, 0x00, // Logical Minimum (0)
  391. 0x25, 0x01, // Logical Maximum (1)
  392. 0x95, 0x08, // Report Count (8)
  393. 0x75, 0x01, // Report Size (1)
  394. 0x81, 0x02, // Input (Data, Variable, Absolute)
  395. // X/Y position (2 bytes)
  396. 0x05, 0x01, // Usage Page (Generic Desktop)
  397. 0x09, 0x30, // Usage (X)
  398. 0x09, 0x31, // Usage (Y)
  399. 0x15, 0x81, // Logical Minimum (-127)
  400. 0x25, 0x7F, // Logical Maximum (127)
  401. 0x95, 0x02, // Report Count (2)
  402. 0x75, 0x08, // Report Size (8)
  403. 0x81, 0x06, // Input (Data, Variable, Relative)
  404. // Vertical wheel (1 byte)
  405. 0x09, 0x38, // Usage (Wheel)
  406. 0x15, 0x81, // Logical Minimum (-127)
  407. 0x25, 0x7F, // Logical Maximum (127)
  408. 0x95, 0x01, // Report Count (1)
  409. 0x75, 0x08, // Report Size (8)
  410. 0x81, 0x06, // Input (Data, Variable, Relative)
  411. // Horizontal wheel (1 byte)
  412. 0x05, 0x0C, // Usage Page (Consumer)
  413. 0x0A, 0x38, 0x02, // Usage (AC Pan)
  414. 0x15, 0x81, // Logical Minimum (-127)
  415. 0x25, 0x7F, // Logical Maximum (127)
  416. 0x95, 0x01, // Report Count (1)
  417. 0x75, 0x08, // Report Size (8)
  418. 0x81, 0x06, // Input (Data, Variable, Relative)
  419. 0xC0, // End Collection
  420. 0xC0, // End Collection
  421. #endif
  422. #ifdef EXTRAKEY_ENABLE
  423. // Extrakeys report descriptor
  424. 0x05, 0x01, // Usage Page (Generic Desktop)
  425. 0x09, 0x80, // Usage (System Control)
  426. 0xA1, 0x01, // Collection (Application)
  427. 0x85, REPORT_ID_SYSTEM, // Report ID
  428. 0x19, 0x01, // Usage Minimum (Pointer)
  429. 0x2A, 0xB7, 0x00, // Usage Maximum (System Display LCD Autoscale)
  430. 0x15, 0x01, // Logical Minimum
  431. 0x26, 0xB7, 0x00, // Logical Maximum
  432. 0x95, 0x01, // Report Count (1)
  433. 0x75, 0x10, // Report Size (16)
  434. 0x81, 0x00, // Input (Data, Array, Absolute)
  435. 0xC0, // End Collection
  436. 0x05, 0x0C, // Usage Page (Consumer)
  437. 0x09, 0x01, // Usage (Consumer Control)
  438. 0xA1, 0x01, // Collection (Application)
  439. 0x85, REPORT_ID_CONSUMER, // Report ID
  440. 0x19, 0x01, // Usage Minimum (Consumer Control)
  441. 0x2A, 0xA0, 0x02, // Usage Maximum (AC Desktop Show All Applications)
  442. 0x15, 0x01, // Logical Minimum
  443. 0x26, 0xA0, 0x02, // Logical Maximum
  444. 0x95, 0x01, // Report Count (1)
  445. 0x75, 0x10, // Report Size (16)
  446. 0x81, 0x00, // Input (Data, Array, Absolute)
  447. 0xC0 // End Collection
  448. #endif
  449. #ifdef SHARED_EP_ENABLE
  450. };
  451. #endif
  452. #ifdef RAW_ENABLE
  453. const PROGMEM uchar raw_hid_report[] = {
  454. 0x06, RAW_USAGE_PAGE_LO, RAW_USAGE_PAGE_HI, // Usage Page (Vendor Defined)
  455. 0x09, RAW_USAGE_ID, // Usage (Vendor Defined)
  456. 0xA1, 0x01, // Collection (Application)
  457. // Data to host
  458. 0x09, 0x62, // Usage (Vendor Defined)
  459. 0x15, 0x00, // Logical Minimum (0)
  460. 0x26, 0xFF, 0x00, // Logical Maximum (255)
  461. 0x95, RAW_BUFFER_SIZE, // Report Count
  462. 0x75, 0x08, // Report Size (8)
  463. 0x81, 0x02, // Input (Data, Variable, Absolute)
  464. // Data from host
  465. 0x09, 0x63, // Usage (Vendor Defined)
  466. 0x15, 0x00, // Logical Minimum (0)
  467. 0x26, 0xFF, 0x00, // Logical Maximum (255)
  468. 0x95, RAW_BUFFER_SIZE, // Report Count
  469. 0x75, 0x08, // Report Size (8)
  470. 0x91, 0x02, // Output (Data, Variable, Absolute)
  471. 0xC0 // End Collection
  472. };
  473. #endif
  474. #if defined(CONSOLE_ENABLE)
  475. const PROGMEM uchar console_hid_report[] = {
  476. 0x06, 0x31, 0xFF, // Usage Page (Vendor Defined - PJRC Teensy compatible)
  477. 0x09, 0x74, // Usage (Vendor Defined - PJRC Teensy compatible)
  478. 0xA1, 0x01, // Collection (Application)
  479. // Data to host
  480. 0x09, 0x75, // Usage (Vendor Defined)
  481. 0x15, 0x00, // Logical Minimum (0x00)
  482. 0x26, 0xFF, 0x00, // Logical Maximum (0x00FF)
  483. 0x95, CONSOLE_BUFFER_SIZE, // Report Count
  484. 0x75, 0x08, // Report Size (8)
  485. 0x81, 0x02, // Input (Data, Variable, Absolute)
  486. // Data from host
  487. 0x09, 0x76, // Usage (Vendor Defined)
  488. 0x15, 0x00, // Logical Minimum (0x00)
  489. 0x26, 0xFF, 0x00, // Logical Maximum (0x00FF)
  490. 0x95, CONSOLE_BUFFER_SIZE, // Report Count
  491. 0x75, 0x08, // Report Size (8)
  492. 0x91, 0x02, // Output (Data)
  493. 0xC0 // End Collection
  494. };
  495. #endif
  496. #ifndef USB_MAX_POWER_CONSUMPTION
  497. # define USB_MAX_POWER_CONSUMPTION 500
  498. #endif
  499. // TODO: change this to 10ms to match LUFA
  500. #ifndef USB_POLLING_INTERVAL_MS
  501. # define USB_POLLING_INTERVAL_MS 1
  502. #endif
  503. // clang-format off
  504. const PROGMEM usbStringDescriptor_t usbStringDescriptorZero = {
  505. .header = {
  506. .bLength = USB_STRING_LEN(1),
  507. .bDescriptorType = USBDESCR_STRING
  508. },
  509. .bString = {0x0409} // US English
  510. };
  511. const PROGMEM usbStringDescriptor_t usbStringDescriptorManufacturer = {
  512. .header = {
  513. .bLength = USB_STRING_LEN(sizeof(STR(MANUFACTURER)) - 1),
  514. .bDescriptorType = USBDESCR_STRING
  515. },
  516. .bString = LSTR(MANUFACTURER)
  517. };
  518. const PROGMEM usbStringDescriptor_t usbStringDescriptorProduct = {
  519. .header = {
  520. .bLength = USB_STRING_LEN(sizeof(STR(PRODUCT)) - 1),
  521. .bDescriptorType = USBDESCR_STRING
  522. },
  523. .bString = LSTR(PRODUCT)
  524. };
  525. #if defined(SERIAL_NUMBER)
  526. const PROGMEM usbStringDescriptor_t usbStringDescriptorSerial = {
  527. .header = {
  528. .bLength = USB_STRING_LEN(sizeof(STR(SERIAL_NUMBER)) - 1),
  529. .bDescriptorType = USBDESCR_STRING
  530. },
  531. .bString = LSTR(SERIAL_NUMBER)
  532. };
  533. #endif
  534. /*
  535. * Device descriptor
  536. */
  537. const PROGMEM usbDeviceDescriptor_t usbDeviceDescriptor = {
  538. .header = {
  539. .bLength = sizeof(usbDeviceDescriptor_t),
  540. .bDescriptorType = USBDESCR_DEVICE
  541. },
  542. .bcdUSB = 0x0110,
  543. .bDeviceClass = 0x00,
  544. .bDeviceSubClass = 0x00,
  545. .bDeviceProtocol = 0x00,
  546. .bMaxPacketSize0 = 8,
  547. .idVendor = VENDOR_ID,
  548. .idProduct = PRODUCT_ID,
  549. .bcdDevice = DEVICE_VER,
  550. .iManufacturer = 0x01,
  551. .iProduct = 0x02,
  552. #if defined(SERIAL_NUMBER)
  553. .iSerialNumber = 0x03,
  554. #else
  555. .iSerialNumber = 0x00,
  556. #endif
  557. .bNumConfigurations = 1
  558. };
  559. /*
  560. * Configuration descriptors
  561. */
  562. const PROGMEM usbConfigurationDescriptor_t usbConfigurationDescriptor = {
  563. .header = {
  564. .header = {
  565. .bLength = sizeof(usbConfigurationDescriptorHeader_t),
  566. .bDescriptorType = USBDESCR_CONFIG
  567. },
  568. .wTotalLength = sizeof(usbConfigurationDescriptor_t),
  569. .bNumInterfaces = TOTAL_INTERFACES,
  570. .bConfigurationValue = 0x01,
  571. .iConfiguration = 0x00,
  572. .bmAttributes = (1 << 7) | USBATTR_REMOTEWAKE,
  573. .bMaxPower = USB_MAX_POWER_CONSUMPTION / 2
  574. },
  575. # ifndef KEYBOARD_SHARED_EP
  576. /*
  577. * Keyboard
  578. */
  579. .keyboardInterface = {
  580. .header = {
  581. .bLength = sizeof(usbInterfaceDescriptor_t),
  582. .bDescriptorType = USBDESCR_INTERFACE
  583. },
  584. .bInterfaceNumber = KEYBOARD_INTERFACE,
  585. .bAlternateSetting = 0x00,
  586. .bNumEndpoints = 1,
  587. .bInterfaceClass = 0x03,
  588. .bInterfaceSubClass = 0x01,
  589. .bInterfaceProtocol = 0x01,
  590. .iInterface = 0x00
  591. },
  592. .keyboardHID = {
  593. .header = {
  594. .bLength = sizeof(usbHIDDescriptor_t),
  595. .bDescriptorType = USBDESCR_HID
  596. },
  597. .bcdHID = 0x0101,
  598. .bCountryCode = 0x00,
  599. .bNumDescriptors = 1,
  600. .bDescriptorType = USBDESCR_HID_REPORT,
  601. .wDescriptorLength = sizeof(keyboard_hid_report)
  602. },
  603. .keyboardINEndpoint = {
  604. .header = {
  605. .bLength = sizeof(usbEndpointDescriptor_t),
  606. .bDescriptorType = USBDESCR_ENDPOINT
  607. },
  608. .bEndpointAddress = (USBRQ_DIR_DEVICE_TO_HOST | 1),
  609. .bmAttributes = 0x03,
  610. .wMaxPacketSize = 8,
  611. .bInterval = USB_POLLING_INTERVAL_MS
  612. },
  613. # endif
  614. # if defined(RAW_ENABLE)
  615. /*
  616. * RAW HID
  617. */
  618. .rawInterface = {
  619. .header = {
  620. .bLength = sizeof(usbInterfaceDescriptor_t),
  621. .bDescriptorType = USBDESCR_INTERFACE
  622. },
  623. .bInterfaceNumber = RAW_INTERFACE,
  624. .bAlternateSetting = 0x00,
  625. .bNumEndpoints = 2,
  626. .bInterfaceClass = 0x03,
  627. .bInterfaceSubClass = 0x00,
  628. .bInterfaceProtocol = 0x00,
  629. .iInterface = 0x00
  630. },
  631. .rawHID = {
  632. .header = {
  633. .bLength = sizeof(usbHIDDescriptor_t),
  634. .bDescriptorType = USBDESCR_HID
  635. },
  636. .bcdHID = 0x0101,
  637. .bCountryCode = 0x00,
  638. .bNumDescriptors = 1,
  639. .bDescriptorType = USBDESCR_HID_REPORT,
  640. .wDescriptorLength = sizeof(raw_hid_report)
  641. },
  642. .rawINEndpoint = {
  643. .header = {
  644. .bLength = sizeof(usbEndpointDescriptor_t),
  645. .bDescriptorType = USBDESCR_ENDPOINT
  646. },
  647. .bEndpointAddress = (USBRQ_DIR_DEVICE_TO_HOST | USB_CFG_EP4_NUMBER),
  648. .bmAttributes = 0x03,
  649. .wMaxPacketSize = RAW_EPSIZE,
  650. .bInterval = USB_POLLING_INTERVAL_MS
  651. },
  652. .rawOUTEndpoint = {
  653. .header = {
  654. .bLength = sizeof(usbEndpointDescriptor_t),
  655. .bDescriptorType = USBDESCR_ENDPOINT
  656. },
  657. .bEndpointAddress = (USBRQ_DIR_HOST_TO_DEVICE | USB_CFG_EP4_NUMBER),
  658. .bmAttributes = 0x03,
  659. .wMaxPacketSize = RAW_EPSIZE,
  660. .bInterval = USB_POLLING_INTERVAL_MS
  661. },
  662. # endif
  663. # ifdef SHARED_EP_ENABLE
  664. /*
  665. * Shared
  666. */
  667. .sharedInterface = {
  668. .header = {
  669. .bLength = sizeof(usbInterfaceDescriptor_t),
  670. .bDescriptorType = USBDESCR_INTERFACE
  671. },
  672. .bInterfaceNumber = SHARED_INTERFACE,
  673. .bAlternateSetting = 0x00,
  674. .bNumEndpoints = 1,
  675. .bInterfaceClass = 0x03,
  676. # ifdef KEYBOARD_SHARED_EP
  677. .bInterfaceSubClass = 0x01,
  678. .bInterfaceProtocol = 0x01,
  679. # else
  680. .bInterfaceSubClass = 0x00,
  681. .bInterfaceProtocol = 0x00,
  682. # endif
  683. .iInterface = 0x00
  684. },
  685. .sharedHID = {
  686. .header = {
  687. .bLength = sizeof(usbHIDDescriptor_t),
  688. .bDescriptorType = USBDESCR_HID
  689. },
  690. .bcdHID = 0x0101,
  691. .bCountryCode = 0x00,
  692. .bNumDescriptors = 1,
  693. .bDescriptorType = USBDESCR_HID_REPORT,
  694. .wDescriptorLength = sizeof(shared_hid_report)
  695. },
  696. .sharedINEndpoint = {
  697. .header = {
  698. .bLength = sizeof(usbEndpointDescriptor_t),
  699. .bDescriptorType = USBDESCR_ENDPOINT
  700. },
  701. # ifdef KEYBOARD_SHARED_EP
  702. .bEndpointAddress = (USBRQ_DIR_DEVICE_TO_HOST | 1),
  703. # else
  704. .bEndpointAddress = (USBRQ_DIR_DEVICE_TO_HOST | USB_CFG_EP3_NUMBER),
  705. # endif
  706. .bmAttributes = 0x03,
  707. .wMaxPacketSize = 8,
  708. .bInterval = USB_POLLING_INTERVAL_MS
  709. },
  710. # endif
  711. # if defined(CONSOLE_ENABLE)
  712. /*
  713. * Console
  714. */
  715. .consoleInterface = {
  716. .header = {
  717. .bLength = sizeof(usbInterfaceDescriptor_t),
  718. .bDescriptorType = USBDESCR_INTERFACE
  719. },
  720. .bInterfaceNumber = CONSOLE_INTERFACE,
  721. .bAlternateSetting = 0x00,
  722. .bNumEndpoints = 2,
  723. .bInterfaceClass = 0x03,
  724. .bInterfaceSubClass = 0x00,
  725. .bInterfaceProtocol = 0x00,
  726. .iInterface = 0x00
  727. },
  728. .consoleHID = {
  729. .header = {
  730. .bLength = sizeof(usbHIDDescriptor_t),
  731. .bDescriptorType = USBDESCR_HID
  732. },
  733. .bcdHID = 0x0111,
  734. .bCountryCode = 0x00,
  735. .bNumDescriptors = 1,
  736. .bDescriptorType = USBDESCR_HID_REPORT,
  737. .wDescriptorLength = sizeof(console_hid_report)
  738. },
  739. .consoleINEndpoint = {
  740. .header = {
  741. .bLength = sizeof(usbEndpointDescriptor_t),
  742. .bDescriptorType = USBDESCR_ENDPOINT
  743. },
  744. .bEndpointAddress = (USBRQ_DIR_DEVICE_TO_HOST | USB_CFG_EP3_NUMBER),
  745. .bmAttributes = 0x03,
  746. .wMaxPacketSize = CONSOLE_EPSIZE,
  747. .bInterval = 0x01
  748. },
  749. .consoleOUTEndpoint = {
  750. .header = {
  751. .bLength = sizeof(usbEndpointDescriptor_t),
  752. .bDescriptorType = USBDESCR_ENDPOINT
  753. },
  754. .bEndpointAddress = (USBRQ_DIR_HOST_TO_DEVICE | USB_CFG_EP3_NUMBER),
  755. .bmAttributes = 0x03,
  756. .wMaxPacketSize = CONSOLE_EPSIZE,
  757. .bInterval = 0x01
  758. }
  759. # endif
  760. };
  761. // clang-format on
  762. USB_PUBLIC usbMsgLen_t usbFunctionDescriptor(struct usbRequest *rq) {
  763. usbMsgLen_t len = 0;
  764. switch (rq->wValue.bytes[1]) {
  765. case USBDESCR_DEVICE:
  766. usbMsgPtr = (usbMsgPtr_t)&usbDeviceDescriptor;
  767. len = sizeof(usbDeviceDescriptor_t);
  768. break;
  769. case USBDESCR_CONFIG:
  770. usbMsgPtr = (usbMsgPtr_t)&usbConfigurationDescriptor;
  771. len = sizeof(usbConfigurationDescriptor_t);
  772. break;
  773. case USBDESCR_STRING:
  774. switch (rq->wValue.bytes[0]) {
  775. case 0:
  776. usbMsgPtr = (usbMsgPtr_t)&usbStringDescriptorZero;
  777. len = usbStringDescriptorZero.header.bLength;
  778. break;
  779. case 1: // iManufacturer
  780. usbMsgPtr = (usbMsgPtr_t)&usbStringDescriptorManufacturer;
  781. len = usbStringDescriptorManufacturer.header.bLength;
  782. break;
  783. case 2: // iProduct
  784. usbMsgPtr = (usbMsgPtr_t)&usbStringDescriptorProduct;
  785. len = usbStringDescriptorProduct.header.bLength;
  786. break;
  787. #if defined(SERIAL_NUMBER)
  788. case 3: // iSerialNumber
  789. usbMsgPtr = (usbMsgPtr_t)&usbStringDescriptorSerial;
  790. len = usbStringDescriptorSerial.header.bLength;
  791. break;
  792. #endif
  793. }
  794. break;
  795. case USBDESCR_HID:
  796. switch (rq->wValue.bytes[0]) {
  797. #ifndef KEYBOARD_SHARED_EP
  798. case KEYBOARD_INTERFACE:
  799. usbMsgPtr = (usbMsgPtr_t)&usbConfigurationDescriptor.keyboardHID;
  800. len = sizeof(usbHIDDescriptor_t);
  801. break;
  802. #endif
  803. #if defined(RAW_ENABLE)
  804. case RAW_INTERFACE:
  805. usbMsgPtr = (usbMsgPtr_t)&usbConfigurationDescriptor.rawHID;
  806. len = sizeof(usbHIDDescriptor_t);
  807. break;
  808. #endif
  809. #ifdef SHARED_EP_ENABLE
  810. case SHARED_INTERFACE:
  811. usbMsgPtr = (usbMsgPtr_t)&usbConfigurationDescriptor.sharedHID;
  812. len = sizeof(usbHIDDescriptor_t);
  813. break;
  814. #endif
  815. #if defined(CONSOLE_ENABLE)
  816. case CONSOLE_INTERFACE:
  817. usbMsgPtr = (usbMsgPtr_t)&usbConfigurationDescriptor.consoleHID;
  818. len = sizeof(usbHIDDescriptor_t);
  819. break;
  820. #endif
  821. }
  822. break;
  823. case USBDESCR_HID_REPORT:
  824. /* interface index */
  825. switch (rq->wIndex.word) {
  826. #ifndef KEYBOARD_SHARED_EP
  827. case KEYBOARD_INTERFACE:
  828. usbMsgPtr = (usbMsgPtr_t)keyboard_hid_report;
  829. len = sizeof(keyboard_hid_report);
  830. break;
  831. #endif
  832. #if defined(RAW_ENABLE)
  833. case RAW_INTERFACE:
  834. usbMsgPtr = (usbMsgPtr_t)raw_hid_report;
  835. len = sizeof(raw_hid_report);
  836. break;
  837. #endif
  838. #ifdef SHARED_EP_ENABLE
  839. case SHARED_INTERFACE:
  840. usbMsgPtr = (usbMsgPtr_t)shared_hid_report;
  841. len = sizeof(shared_hid_report);
  842. break;
  843. #endif
  844. #if defined(CONSOLE_ENABLE)
  845. case CONSOLE_INTERFACE:
  846. usbMsgPtr = (usbMsgPtr_t)console_hid_report;
  847. len = sizeof(console_hid_report);
  848. break;
  849. #endif
  850. }
  851. break;
  852. }
  853. return len;
  854. }