usb_main.c 34 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861
  1. /*
  2. * (c) 2015 flabberast <s3+flabbergast@sdfeu.org>
  3. *
  4. * Based on the following work:
  5. * - Guillaume Duc's raw hid example (MIT License)
  6. * https://github.com/guiduc/usb-hid-chibios-example
  7. * - PJRC Teensy examples (MIT License)
  8. * https://www.pjrc.com/teensy/usb_keyboard.html
  9. * - hasu's TMK keyboard code (GPL v2 and some code Modified BSD)
  10. * https://github.com/tmk/tmk_keyboard/
  11. * - ChibiOS demo code (Apache 2.0 License)
  12. * http://www.chibios.org
  13. *
  14. * Since some GPL'd code is used, this work is licensed under
  15. * GPL v2 or later.
  16. */
  17. /*
  18. * Implementation notes:
  19. *
  20. * USBEndpointConfig - Configured using explicit order instead of struct member name.
  21. * This is due to ChibiOS hal LLD differences, which is dependent on hardware,
  22. * "USBv1" devices have `ep_buffers` and "OTGv1" have `in_multiplier`.
  23. * Given `USBv1/hal_usb_lld.h` marks the field as "not currently used" this code file
  24. * makes the assumption this is safe to avoid littering with preprocessor directives.
  25. */
  26. #include "ch.h"
  27. #include "hal.h"
  28. #include "usb_main.h"
  29. #include "host.h"
  30. #include "debug.h"
  31. #include "suspend.h"
  32. #ifdef SLEEP_LED_ENABLE
  33. # include "sleep_led.h"
  34. # include "led.h"
  35. #endif
  36. #include "wait.h"
  37. #include "usb_descriptor.h"
  38. #include "usb_driver.h"
  39. #ifdef NKRO_ENABLE
  40. # include "keycode_config.h"
  41. extern keymap_config_t keymap_config;
  42. #endif
  43. /* ---------------------------------------------------------
  44. * Global interface variables and declarations
  45. * ---------------------------------------------------------
  46. */
  47. #ifndef usb_lld_connect_bus
  48. # define usb_lld_connect_bus(usbp)
  49. #endif
  50. #ifndef usb_lld_disconnect_bus
  51. # define usb_lld_disconnect_bus(usbp)
  52. #endif
  53. uint8_t keyboard_idle __attribute__((aligned(2))) = 0;
  54. uint8_t keyboard_protocol __attribute__((aligned(2))) = 1;
  55. uint16_t keyboard_led_stats __attribute__((aligned(2))) = 0;
  56. volatile uint16_t keyboard_idle_count = 0;
  57. static virtual_timer_t keyboard_idle_timer;
  58. static void keyboard_idle_timer_cb(void *arg);
  59. report_keyboard_t keyboard_report_sent = {{0}};
  60. #ifdef MOUSE_ENABLE
  61. report_mouse_t mouse_report_blank = {0};
  62. #endif /* MOUSE_ENABLE */
  63. #ifdef EXTRAKEY_ENABLE
  64. uint8_t extra_report_blank[3] = {0};
  65. #endif /* EXTRAKEY_ENABLE */
  66. /* ---------------------------------------------------------
  67. * Descriptors and USB driver objects
  68. * ---------------------------------------------------------
  69. */
  70. /* HID specific constants */
  71. #define HID_GET_REPORT 0x01
  72. #define HID_GET_IDLE 0x02
  73. #define HID_GET_PROTOCOL 0x03
  74. #define HID_SET_REPORT 0x09
  75. #define HID_SET_IDLE 0x0A
  76. #define HID_SET_PROTOCOL 0x0B
  77. /*
  78. * Handles the GET_DESCRIPTOR callback
  79. *
  80. * Returns the proper descriptor
  81. */
  82. static const USBDescriptor *usb_get_descriptor_cb(USBDriver *usbp, uint8_t dtype, uint8_t dindex, uint16_t wIndex) {
  83. (void)usbp;
  84. static USBDescriptor desc;
  85. uint16_t wValue = ((uint16_t)dtype << 8) | dindex;
  86. desc.ud_string = NULL;
  87. desc.ud_size = get_usb_descriptor(wValue, wIndex, (const void **const) & desc.ud_string);
  88. if (desc.ud_string == NULL)
  89. return NULL;
  90. else
  91. return &desc;
  92. }
  93. #ifndef KEYBOARD_SHARED_EP
  94. /* keyboard endpoint state structure */
  95. static USBInEndpointState kbd_ep_state;
  96. /* keyboard endpoint initialization structure (IN) - see USBEndpointConfig comment at top of file */
  97. static const USBEndpointConfig kbd_ep_config = {
  98. USB_EP_MODE_TYPE_INTR, /* Interrupt EP */
  99. NULL, /* SETUP packet notification callback */
  100. kbd_in_cb, /* IN notification callback */
  101. NULL, /* OUT notification callback */
  102. KEYBOARD_EPSIZE, /* IN maximum packet size */
  103. 0, /* OUT maximum packet size */
  104. &kbd_ep_state, /* IN Endpoint state */
  105. NULL, /* OUT endpoint state */
  106. 2, /* IN multiplier */
  107. NULL /* SETUP buffer (not a SETUP endpoint) */
  108. };
  109. #endif
  110. #if defined(MOUSE_ENABLE) && !defined(MOUSE_SHARED_EP)
  111. /* mouse endpoint state structure */
  112. static USBInEndpointState mouse_ep_state;
  113. /* mouse endpoint initialization structure (IN) - see USBEndpointConfig comment at top of file */
  114. static const USBEndpointConfig mouse_ep_config = {
  115. USB_EP_MODE_TYPE_INTR, /* Interrupt EP */
  116. NULL, /* SETUP packet notification callback */
  117. mouse_in_cb, /* IN notification callback */
  118. NULL, /* OUT notification callback */
  119. MOUSE_EPSIZE, /* IN maximum packet size */
  120. 0, /* OUT maximum packet size */
  121. &mouse_ep_state, /* IN Endpoint state */
  122. NULL, /* OUT endpoint state */
  123. 2, /* IN multiplier */
  124. NULL /* SETUP buffer (not a SETUP endpoint) */
  125. };
  126. #endif
  127. #ifdef SHARED_EP_ENABLE
  128. /* shared endpoint state structure */
  129. static USBInEndpointState shared_ep_state;
  130. /* shared endpoint initialization structure (IN) - see USBEndpointConfig comment at top of file */
  131. static const USBEndpointConfig shared_ep_config = {
  132. USB_EP_MODE_TYPE_INTR, /* Interrupt EP */
  133. NULL, /* SETUP packet notification callback */
  134. shared_in_cb, /* IN notification callback */
  135. NULL, /* OUT notification callback */
  136. SHARED_EPSIZE, /* IN maximum packet size */
  137. 0, /* OUT maximum packet size */
  138. &shared_ep_state, /* IN Endpoint state */
  139. NULL, /* OUT endpoint state */
  140. 2, /* IN multiplier */
  141. NULL /* SETUP buffer (not a SETUP endpoint) */
  142. };
  143. #endif
  144. typedef struct {
  145. size_t queue_capacity_in;
  146. size_t queue_capacity_out;
  147. USBInEndpointState in_ep_state;
  148. USBOutEndpointState out_ep_state;
  149. USBInEndpointState int_ep_state;
  150. USBEndpointConfig in_ep_config;
  151. USBEndpointConfig out_ep_config;
  152. USBEndpointConfig int_ep_config;
  153. const QMKUSBConfig config;
  154. QMKUSBDriver driver;
  155. } usb_driver_config_t;
  156. /* Reusable initialization structure - see USBEndpointConfig comment at top of file */
  157. #define QMK_USB_DRIVER_CONFIG(stream, notification, fixedsize) \
  158. { \
  159. .queue_capacity_in = stream##_IN_CAPACITY, .queue_capacity_out = stream##_OUT_CAPACITY, \
  160. .in_ep_config = \
  161. { \
  162. stream##_IN_MODE, /* Interrupt EP */ \
  163. NULL, /* SETUP packet notification callback */ \
  164. qmkusbDataTransmitted, /* IN notification callback */ \
  165. NULL, /* OUT notification callback */ \
  166. stream##_EPSIZE, /* IN maximum packet size */ \
  167. 0, /* OUT maximum packet size */ \
  168. NULL, /* IN Endpoint state */ \
  169. NULL, /* OUT endpoint state */ \
  170. 2, /* IN multiplier */ \
  171. NULL /* SETUP buffer (not a SETUP endpoint) */ \
  172. }, \
  173. .out_ep_config = \
  174. { \
  175. stream##_OUT_MODE, /* Interrupt EP */ \
  176. NULL, /* SETUP packet notification callback */ \
  177. NULL, /* IN notification callback */ \
  178. qmkusbDataReceived, /* OUT notification callback */ \
  179. 0, /* IN maximum packet size */ \
  180. stream##_EPSIZE, /* OUT maximum packet size */ \
  181. NULL, /* IN Endpoint state */ \
  182. NULL, /* OUT endpoint state */ \
  183. 2, /* IN multiplier */ \
  184. NULL, /* SETUP buffer (not a SETUP endpoint) */ \
  185. }, \
  186. .int_ep_config = \
  187. { \
  188. USB_EP_MODE_TYPE_INTR, /* Interrupt EP */ \
  189. NULL, /* SETUP packet notification callback */ \
  190. qmkusbInterruptTransmitted, /* IN notification callback */ \
  191. NULL, /* OUT notification callback */ \
  192. CDC_NOTIFICATION_EPSIZE, /* IN maximum packet size */ \
  193. 0, /* OUT maximum packet size */ \
  194. NULL, /* IN Endpoint state */ \
  195. NULL, /* OUT endpoint state */ \
  196. 2, /* IN multiplier */ \
  197. NULL, /* SETUP buffer (not a SETUP endpoint) */ \
  198. }, \
  199. .config = { \
  200. .usbp = &USB_DRIVER, \
  201. .bulk_in = stream##_IN_EPNUM, \
  202. .bulk_out = stream##_OUT_EPNUM, \
  203. .int_in = notification, \
  204. .in_buffers = stream##_IN_CAPACITY, \
  205. .out_buffers = stream##_OUT_CAPACITY, \
  206. .in_size = stream##_EPSIZE, \
  207. .out_size = stream##_EPSIZE, \
  208. .fixed_size = fixedsize, \
  209. .ib = (uint8_t[BQ_BUFFER_SIZE(stream##_IN_CAPACITY, stream##_EPSIZE)]){}, \
  210. .ob = (uint8_t[BQ_BUFFER_SIZE(stream##_OUT_CAPACITY, stream##_EPSIZE)]){}, \
  211. } \
  212. }
  213. typedef struct {
  214. union {
  215. struct {
  216. #ifdef CONSOLE_ENABLE
  217. usb_driver_config_t console_driver;
  218. #endif
  219. #ifdef RAW_ENABLE
  220. usb_driver_config_t raw_driver;
  221. #endif
  222. #ifdef MIDI_ENABLE
  223. usb_driver_config_t midi_driver;
  224. #endif
  225. #ifdef VIRTSER_ENABLE
  226. usb_driver_config_t serial_driver;
  227. #endif
  228. };
  229. usb_driver_config_t array[0];
  230. };
  231. } usb_driver_configs_t;
  232. static usb_driver_configs_t drivers = {
  233. #ifdef CONSOLE_ENABLE
  234. # define CONSOLE_IN_CAPACITY 4
  235. # define CONSOLE_OUT_CAPACITY 4
  236. # define CONSOLE_IN_MODE USB_EP_MODE_TYPE_INTR
  237. # define CONSOLE_OUT_MODE USB_EP_MODE_TYPE_INTR
  238. .console_driver = QMK_USB_DRIVER_CONFIG(CONSOLE, 0, true),
  239. #endif
  240. #ifdef RAW_ENABLE
  241. # define RAW_IN_CAPACITY 4
  242. # define RAW_OUT_CAPACITY 4
  243. # define RAW_IN_MODE USB_EP_MODE_TYPE_INTR
  244. # define RAW_OUT_MODE USB_EP_MODE_TYPE_INTR
  245. .raw_driver = QMK_USB_DRIVER_CONFIG(RAW, 0, false),
  246. #endif
  247. #ifdef MIDI_ENABLE
  248. # define MIDI_STREAM_IN_CAPACITY 4
  249. # define MIDI_STREAM_OUT_CAPACITY 4
  250. # define MIDI_STREAM_IN_MODE USB_EP_MODE_TYPE_BULK
  251. # define MIDI_STREAM_OUT_MODE USB_EP_MODE_TYPE_BULK
  252. .midi_driver = QMK_USB_DRIVER_CONFIG(MIDI_STREAM, 0, false),
  253. #endif
  254. #ifdef VIRTSER_ENABLE
  255. # define CDC_IN_CAPACITY 4
  256. # define CDC_OUT_CAPACITY 4
  257. # define CDC_IN_MODE USB_EP_MODE_TYPE_BULK
  258. # define CDC_OUT_MODE USB_EP_MODE_TYPE_BULK
  259. .serial_driver = QMK_USB_DRIVER_CONFIG(CDC, CDC_NOTIFICATION_EPNUM, false),
  260. #endif
  261. };
  262. #define NUM_USB_DRIVERS (sizeof(drivers) / sizeof(usb_driver_config_t))
  263. /* ---------------------------------------------------------
  264. * USB driver functions
  265. * ---------------------------------------------------------
  266. */
  267. /* Handles the USB driver global events
  268. * TODO: maybe disable some things when connection is lost? */
  269. static void usb_event_cb(USBDriver *usbp, usbevent_t event) {
  270. switch (event) {
  271. case USB_EVENT_ADDRESS:
  272. return;
  273. case USB_EVENT_CONFIGURED:
  274. osalSysLockFromISR();
  275. /* Enable the endpoints specified into the configuration. */
  276. #ifndef KEYBOARD_SHARED_EP
  277. usbInitEndpointI(usbp, KEYBOARD_IN_EPNUM, &kbd_ep_config);
  278. #endif
  279. #if defined(MOUSE_ENABLE) && !defined(MOUSE_SHARED_EP)
  280. usbInitEndpointI(usbp, MOUSE_IN_EPNUM, &mouse_ep_config);
  281. #endif
  282. #ifdef SHARED_EP_ENABLE
  283. usbInitEndpointI(usbp, SHARED_IN_EPNUM, &shared_ep_config);
  284. #endif
  285. for (int i = 0; i < NUM_USB_DRIVERS; i++) {
  286. usbInitEndpointI(usbp, drivers.array[i].config.bulk_in, &drivers.array[i].in_ep_config);
  287. usbInitEndpointI(usbp, drivers.array[i].config.bulk_out, &drivers.array[i].out_ep_config);
  288. if (drivers.array[i].config.int_in) {
  289. usbInitEndpointI(usbp, drivers.array[i].config.int_in, &drivers.array[i].int_ep_config);
  290. }
  291. qmkusbConfigureHookI(&drivers.array[i].driver);
  292. }
  293. osalSysUnlockFromISR();
  294. return;
  295. case USB_EVENT_SUSPEND:
  296. #ifdef SLEEP_LED_ENABLE
  297. sleep_led_enable();
  298. #endif /* SLEEP_LED_ENABLE */
  299. /* Falls into.*/
  300. case USB_EVENT_UNCONFIGURED:
  301. /* Falls into.*/
  302. case USB_EVENT_RESET:
  303. for (int i = 0; i < NUM_USB_DRIVERS; i++) {
  304. chSysLockFromISR();
  305. /* Disconnection event on suspend.*/
  306. qmkusbSuspendHookI(&drivers.array[i].driver);
  307. chSysUnlockFromISR();
  308. }
  309. return;
  310. case USB_EVENT_WAKEUP:
  311. // TODO: from ISR! print("[W]");
  312. for (int i = 0; i < NUM_USB_DRIVERS; i++) {
  313. chSysLockFromISR();
  314. /* Disconnection event on suspend.*/
  315. qmkusbWakeupHookI(&drivers.array[i].driver);
  316. chSysUnlockFromISR();
  317. }
  318. suspend_wakeup_init();
  319. #ifdef SLEEP_LED_ENABLE
  320. sleep_led_disable();
  321. // NOTE: converters may not accept this
  322. led_set(host_keyboard_leds());
  323. #endif /* SLEEP_LED_ENABLE */
  324. return;
  325. case USB_EVENT_STALLED:
  326. return;
  327. }
  328. }
  329. /* Function used locally in os/hal/src/usb.c for getting descriptors
  330. * need it here for HID descriptor */
  331. static uint16_t get_hword(uint8_t *p) {
  332. uint16_t hw;
  333. hw = (uint16_t)*p++;
  334. hw |= (uint16_t)*p << 8U;
  335. return hw;
  336. }
  337. /*
  338. * Appendix G: HID Request Support Requirements
  339. *
  340. * The following table enumerates the requests that need to be supported by various types of HID class devices.
  341. * Device type GetReport SetReport GetIdle SetIdle GetProtocol SetProtocol
  342. * ------------------------------------------------------------------------------------------
  343. * Boot Mouse Required Optional Optional Optional Required Required
  344. * Non-Boot Mouse Required Optional Optional Optional Optional Optional
  345. * Boot Keyboard Required Optional Required Required Required Required
  346. * Non-Boot Keybrd Required Optional Required Required Optional Optional
  347. * Other Device Required Optional Optional Optional Optional Optional
  348. */
  349. #if defined(SHARED_EP_ENABLE) && !defined(KEYBOARD_SHARED_EP)
  350. static uint8_t set_report_buf[2] __attribute__((aligned(2)));
  351. static void set_led_transfer_cb(USBDriver *usbp) {
  352. if ((set_report_buf[0] == REPORT_ID_KEYBOARD) || (set_report_buf[0] == REPORT_ID_NKRO)) {
  353. keyboard_led_stats = set_report_buf[1];
  354. }
  355. }
  356. #endif
  357. /* Callback for SETUP request on the endpoint 0 (control) */
  358. static bool usb_request_hook_cb(USBDriver *usbp) {
  359. const USBDescriptor *dp;
  360. /* usbp->setup fields:
  361. * 0: bmRequestType (bitmask)
  362. * 1: bRequest
  363. * 2,3: (LSB,MSB) wValue
  364. * 4,5: (LSB,MSB) wIndex
  365. * 6,7: (LSB,MSB) wLength (number of bytes to transfer if there is a data phase) */
  366. /* Handle HID class specific requests */
  367. if (((usbp->setup[0] & USB_RTYPE_TYPE_MASK) == USB_RTYPE_TYPE_CLASS) && ((usbp->setup[0] & USB_RTYPE_RECIPIENT_MASK) == USB_RTYPE_RECIPIENT_INTERFACE)) {
  368. switch (usbp->setup[0] & USB_RTYPE_DIR_MASK) {
  369. case USB_RTYPE_DIR_DEV2HOST:
  370. switch (usbp->setup[1]) { /* bRequest */
  371. case HID_GET_REPORT:
  372. switch (usbp->setup[4]) { /* LSB(wIndex) (check MSB==0?) */
  373. case KEYBOARD_INTERFACE:
  374. usbSetupTransfer(usbp, (uint8_t *)&keyboard_report_sent, sizeof(keyboard_report_sent), NULL);
  375. return TRUE;
  376. break;
  377. #if defined(MOUSE_ENABLE) && !defined(MOUSE_SHARED_EP)
  378. case MOUSE_INTERFACE:
  379. usbSetupTransfer(usbp, (uint8_t *)&mouse_report_blank, sizeof(mouse_report_blank), NULL);
  380. return TRUE;
  381. break;
  382. #endif
  383. default:
  384. usbSetupTransfer(usbp, NULL, 0, NULL);
  385. return TRUE;
  386. break;
  387. }
  388. break;
  389. case HID_GET_PROTOCOL:
  390. if ((usbp->setup[4] == KEYBOARD_INTERFACE) && (usbp->setup[5] == 0)) { /* wIndex */
  391. usbSetupTransfer(usbp, &keyboard_protocol, 1, NULL);
  392. return TRUE;
  393. }
  394. break;
  395. case HID_GET_IDLE:
  396. usbSetupTransfer(usbp, &keyboard_idle, 1, NULL);
  397. return TRUE;
  398. break;
  399. }
  400. break;
  401. case USB_RTYPE_DIR_HOST2DEV:
  402. switch (usbp->setup[1]) { /* bRequest */
  403. case HID_SET_REPORT:
  404. switch (usbp->setup[4]) { /* LSB(wIndex) (check MSB==0 and wLength==1?) */
  405. #if defined(SHARED_EP_ENABLE) && !defined(KEYBOARD_SHARED_EP)
  406. case SHARED_INTERFACE:
  407. usbSetupTransfer(usbp, set_report_buf, sizeof(set_report_buf), set_led_transfer_cb);
  408. return TRUE;
  409. break;
  410. #endif
  411. case KEYBOARD_INTERFACE:
  412. /* keyboard_led_stats = <read byte from next OUT report>
  413. * keyboard_led_stats needs be word (or dword), otherwise we get an exception on F0 */
  414. usbSetupTransfer(usbp, (uint8_t *)&keyboard_led_stats, 1, NULL);
  415. return TRUE;
  416. break;
  417. }
  418. break;
  419. case HID_SET_PROTOCOL:
  420. if ((usbp->setup[4] == KEYBOARD_INTERFACE) && (usbp->setup[5] == 0)) { /* wIndex */
  421. keyboard_protocol = ((usbp->setup[2]) != 0x00); /* LSB(wValue) */
  422. #ifdef NKRO_ENABLE
  423. keymap_config.nkro = !!keyboard_protocol;
  424. if (!keymap_config.nkro && keyboard_idle) {
  425. #else /* NKRO_ENABLE */
  426. if (keyboard_idle) {
  427. #endif /* NKRO_ENABLE */
  428. /* arm the idle timer if boot protocol & idle */
  429. osalSysLockFromISR();
  430. chVTSetI(&keyboard_idle_timer, 4 * MS2ST(keyboard_idle), keyboard_idle_timer_cb, (void *)usbp);
  431. osalSysUnlockFromISR();
  432. }
  433. }
  434. usbSetupTransfer(usbp, NULL, 0, NULL);
  435. return TRUE;
  436. break;
  437. case HID_SET_IDLE:
  438. keyboard_idle = usbp->setup[3]; /* MSB(wValue) */
  439. /* arm the timer */
  440. #ifdef NKRO_ENABLE
  441. if (!keymap_config.nkro && keyboard_idle) {
  442. #else /* NKRO_ENABLE */
  443. if (keyboard_idle) {
  444. #endif /* NKRO_ENABLE */
  445. osalSysLockFromISR();
  446. chVTSetI(&keyboard_idle_timer, 4 * MS2ST(keyboard_idle), keyboard_idle_timer_cb, (void *)usbp);
  447. osalSysUnlockFromISR();
  448. }
  449. usbSetupTransfer(usbp, NULL, 0, NULL);
  450. return TRUE;
  451. break;
  452. }
  453. break;
  454. }
  455. }
  456. /* Handle the Get_Descriptor Request for HID class (not handled by the default hook) */
  457. if ((usbp->setup[0] == 0x81) && (usbp->setup[1] == USB_REQ_GET_DESCRIPTOR)) {
  458. dp = usbp->config->get_descriptor_cb(usbp, usbp->setup[3], usbp->setup[2], get_hword(&usbp->setup[4]));
  459. if (dp == NULL) return FALSE;
  460. usbSetupTransfer(usbp, (uint8_t *)dp->ud_string, dp->ud_size, NULL);
  461. return TRUE;
  462. }
  463. for (int i = 0; i < NUM_USB_DRIVERS; i++) {
  464. if (drivers.array[i].config.int_in) {
  465. // NOTE: Assumes that we only have one serial driver
  466. return qmkusbRequestsHook(usbp);
  467. }
  468. }
  469. return FALSE;
  470. }
  471. /* Start-of-frame callback */
  472. static void usb_sof_cb(USBDriver *usbp) {
  473. kbd_sof_cb(usbp);
  474. osalSysLockFromISR();
  475. for (int i = 0; i < NUM_USB_DRIVERS; i++) {
  476. qmkusbSOFHookI(&drivers.array[i].driver);
  477. }
  478. osalSysUnlockFromISR();
  479. }
  480. /* USB driver configuration */
  481. static const USBConfig usbcfg = {
  482. usb_event_cb, /* USB events callback */
  483. usb_get_descriptor_cb, /* Device GET_DESCRIPTOR request callback */
  484. usb_request_hook_cb, /* Requests hook callback */
  485. usb_sof_cb /* Start Of Frame callback */
  486. };
  487. /*
  488. * Initialize the USB driver
  489. */
  490. void init_usb_driver(USBDriver *usbp) {
  491. for (int i = 0; i < NUM_USB_DRIVERS; i++) {
  492. QMKUSBDriver *driver = &drivers.array[i].driver;
  493. drivers.array[i].in_ep_config.in_state = &drivers.array[i].in_ep_state;
  494. drivers.array[i].out_ep_config.out_state = &drivers.array[i].out_ep_state;
  495. drivers.array[i].int_ep_config.in_state = &drivers.array[i].int_ep_state;
  496. qmkusbObjectInit(driver, &drivers.array[i].config);
  497. qmkusbStart(driver, &drivers.array[i].config);
  498. }
  499. /*
  500. * Activates the USB driver and then the USB bus pull-up on D+.
  501. * Note, a delay is inserted in order to not have to disconnect the cable
  502. * after a reset.
  503. */
  504. usbDisconnectBus(usbp);
  505. wait_ms(1500);
  506. usbStart(usbp, &usbcfg);
  507. usbConnectBus(usbp);
  508. chVTObjectInit(&keyboard_idle_timer);
  509. }
  510. /* ---------------------------------------------------------
  511. * Keyboard functions
  512. * ---------------------------------------------------------
  513. */
  514. /* keyboard IN callback hander (a kbd report has made it IN) */
  515. #ifndef KEYBOARD_SHARED_EP
  516. void kbd_in_cb(USBDriver *usbp, usbep_t ep) {
  517. /* STUB */
  518. (void)usbp;
  519. (void)ep;
  520. }
  521. #endif
  522. /* start-of-frame handler
  523. * TODO: i guess it would be better to re-implement using timers,
  524. * so that this is not going to have to be checked every 1ms */
  525. void kbd_sof_cb(USBDriver *usbp) { (void)usbp; }
  526. /* Idle requests timer code
  527. * callback (called from ISR, unlocked state) */
  528. static void keyboard_idle_timer_cb(void *arg) {
  529. USBDriver *usbp = (USBDriver *)arg;
  530. osalSysLockFromISR();
  531. /* check that the states of things are as they're supposed to */
  532. if (usbGetDriverStateI(usbp) != USB_ACTIVE) {
  533. /* do not rearm the timer, should be enabled on IDLE request */
  534. osalSysUnlockFromISR();
  535. return;
  536. }
  537. #ifdef NKRO_ENABLE
  538. if (!keymap_config.nkro && keyboard_idle && keyboard_protocol) {
  539. #else /* NKRO_ENABLE */
  540. if (keyboard_idle && keyboard_protocol) {
  541. #endif /* NKRO_ENABLE */
  542. /* TODO: are we sure we want the KBD_ENDPOINT? */
  543. if (!usbGetTransmitStatusI(usbp, KEYBOARD_IN_EPNUM)) {
  544. usbStartTransmitI(usbp, KEYBOARD_IN_EPNUM, (uint8_t *)&keyboard_report_sent, KEYBOARD_EPSIZE);
  545. }
  546. /* rearm the timer */
  547. chVTSetI(&keyboard_idle_timer, 4 * MS2ST(keyboard_idle), keyboard_idle_timer_cb, (void *)usbp);
  548. }
  549. /* do not rearm the timer if the condition above fails
  550. * it should be enabled again on either IDLE or SET_PROTOCOL requests */
  551. osalSysUnlockFromISR();
  552. }
  553. /* LED status */
  554. uint8_t keyboard_leds(void) { return (uint8_t)(keyboard_led_stats & 0xFF); }
  555. /* prepare and start sending a report IN
  556. * not callable from ISR or locked state */
  557. void send_keyboard(report_keyboard_t *report) {
  558. osalSysLock();
  559. if (usbGetDriverStateI(&USB_DRIVER) != USB_ACTIVE) {
  560. goto unlock;
  561. }
  562. #ifdef NKRO_ENABLE
  563. if (keymap_config.nkro && keyboard_protocol) { /* NKRO protocol */
  564. /* need to wait until the previous packet has made it through */
  565. /* can rewrite this using the synchronous API, then would wait
  566. * until *after* the packet has been transmitted. I think
  567. * this is more efficient */
  568. /* busy wait, should be short and not very common */
  569. if (usbGetTransmitStatusI(&USB_DRIVER, SHARED_IN_EPNUM)) {
  570. /* Need to either suspend, or loop and call unlock/lock during
  571. * every iteration - otherwise the system will remain locked,
  572. * no interrupts served, so USB not going through as well.
  573. * Note: for suspend, need USB_USE_WAIT == TRUE in halconf.h */
  574. osalThreadSuspendS(&(&USB_DRIVER)->epc[SHARED_IN_EPNUM]->in_state->thread);
  575. /* after osalThreadSuspendS returns USB status might have changed */
  576. if (usbGetDriverStateI(&USB_DRIVER) != USB_ACTIVE) {
  577. goto unlock;
  578. }
  579. }
  580. usbStartTransmitI(&USB_DRIVER, SHARED_IN_EPNUM, (uint8_t *)report, sizeof(struct nkro_report));
  581. } else
  582. #endif /* NKRO_ENABLE */
  583. { /* regular protocol */
  584. /* need to wait until the previous packet has made it through */
  585. /* busy wait, should be short and not very common */
  586. if (usbGetTransmitStatusI(&USB_DRIVER, KEYBOARD_IN_EPNUM)) {
  587. /* Need to either suspend, or loop and call unlock/lock during
  588. * every iteration - otherwise the system will remain locked,
  589. * no interrupts served, so USB not going through as well.
  590. * Note: for suspend, need USB_USE_WAIT == TRUE in halconf.h */
  591. osalThreadSuspendS(&(&USB_DRIVER)->epc[KEYBOARD_IN_EPNUM]->in_state->thread);
  592. /* after osalThreadSuspendS returns USB status might have changed */
  593. if (usbGetDriverStateI(&USB_DRIVER) != USB_ACTIVE) {
  594. goto unlock;
  595. }
  596. }
  597. uint8_t *data, size;
  598. if (keyboard_protocol) {
  599. data = (uint8_t *)report;
  600. size = KEYBOARD_REPORT_SIZE;
  601. } else { /* boot protocol */
  602. data = &report->mods;
  603. size = 8;
  604. }
  605. usbStartTransmitI(&USB_DRIVER, KEYBOARD_IN_EPNUM, data, size);
  606. }
  607. keyboard_report_sent = *report;
  608. unlock:
  609. osalSysUnlock();
  610. }
  611. /* ---------------------------------------------------------
  612. * Mouse functions
  613. * ---------------------------------------------------------
  614. */
  615. #ifdef MOUSE_ENABLE
  616. # ifndef MOUSE_SHARED_EP
  617. /* mouse IN callback hander (a mouse report has made it IN) */
  618. void mouse_in_cb(USBDriver *usbp, usbep_t ep) {
  619. (void)usbp;
  620. (void)ep;
  621. }
  622. # endif
  623. void send_mouse(report_mouse_t *report) {
  624. osalSysLock();
  625. if (usbGetDriverStateI(&USB_DRIVER) != USB_ACTIVE) {
  626. osalSysUnlock();
  627. return;
  628. }
  629. if (usbGetTransmitStatusI(&USB_DRIVER, MOUSE_IN_EPNUM)) {
  630. /* Need to either suspend, or loop and call unlock/lock during
  631. * every iteration - otherwise the system will remain locked,
  632. * no interrupts served, so USB not going through as well.
  633. * Note: for suspend, need USB_USE_WAIT == TRUE in halconf.h */
  634. if (osalThreadSuspendTimeoutS(&(&USB_DRIVER)->epc[MOUSE_IN_EPNUM]->in_state->thread, MS2ST(10)) == MSG_TIMEOUT) {
  635. osalSysUnlock();
  636. return;
  637. }
  638. }
  639. usbStartTransmitI(&USB_DRIVER, MOUSE_IN_EPNUM, (uint8_t *)report, sizeof(report_mouse_t));
  640. osalSysUnlock();
  641. }
  642. #else /* MOUSE_ENABLE */
  643. void send_mouse(report_mouse_t *report) { (void)report; }
  644. #endif /* MOUSE_ENABLE */
  645. /* ---------------------------------------------------------
  646. * Shared EP functions
  647. * ---------------------------------------------------------
  648. */
  649. #ifdef SHARED_EP_ENABLE
  650. /* shared IN callback hander */
  651. void shared_in_cb(USBDriver *usbp, usbep_t ep) {
  652. /* STUB */
  653. (void)usbp;
  654. (void)ep;
  655. }
  656. #endif
  657. /* ---------------------------------------------------------
  658. * Extrakey functions
  659. * ---------------------------------------------------------
  660. */
  661. #ifdef EXTRAKEY_ENABLE
  662. static void send_extra_report(uint8_t report_id, uint16_t data) {
  663. osalSysLock();
  664. if (usbGetDriverStateI(&USB_DRIVER) != USB_ACTIVE) {
  665. osalSysUnlock();
  666. return;
  667. }
  668. report_extra_t report = {.report_id = report_id, .usage = data};
  669. usbStartTransmitI(&USB_DRIVER, SHARED_IN_EPNUM, (uint8_t *)&report, sizeof(report_extra_t));
  670. osalSysUnlock();
  671. }
  672. void send_system(uint16_t data) { send_extra_report(REPORT_ID_SYSTEM, data); }
  673. void send_consumer(uint16_t data) { send_extra_report(REPORT_ID_CONSUMER, data); }
  674. #else /* EXTRAKEY_ENABLE */
  675. void send_system(uint16_t data) { (void)data; }
  676. void send_consumer(uint16_t data) { (void)data; }
  677. #endif /* EXTRAKEY_ENABLE */
  678. /* ---------------------------------------------------------
  679. * Console functions
  680. * ---------------------------------------------------------
  681. */
  682. #ifdef CONSOLE_ENABLE
  683. int8_t sendchar(uint8_t c) {
  684. // The previous implmentation had timeouts, but I think it's better to just slow down
  685. // and make sure that everything is transferred, rather than dropping stuff
  686. return chnWrite(&drivers.console_driver.driver, &c, 1);
  687. }
  688. // Just a dummy function for now, this could be exposed as a weak function
  689. // Or connected to the actual QMK console
  690. static void console_receive(uint8_t *data, uint8_t length) {
  691. (void)data;
  692. (void)length;
  693. }
  694. void console_task(void) {
  695. uint8_t buffer[CONSOLE_EPSIZE];
  696. size_t size = 0;
  697. do {
  698. size_t size = chnReadTimeout(&drivers.console_driver.driver, buffer, sizeof(buffer), TIME_IMMEDIATE);
  699. if (size > 0) {
  700. console_receive(buffer, size);
  701. }
  702. } while (size > 0);
  703. }
  704. #else /* CONSOLE_ENABLE */
  705. int8_t sendchar(uint8_t c) {
  706. (void)c;
  707. return 0;
  708. }
  709. #endif /* CONSOLE_ENABLE */
  710. void sendchar_pf(void *p, char c) {
  711. (void)p;
  712. sendchar((uint8_t)c);
  713. }
  714. #ifdef RAW_ENABLE
  715. void raw_hid_send(uint8_t *data, uint8_t length) {
  716. // TODO: implement variable size packet
  717. if (length != RAW_EPSIZE) {
  718. return;
  719. }
  720. chnWrite(&drivers.raw_driver.driver, data, length);
  721. }
  722. __attribute__((weak)) void raw_hid_receive(uint8_t *data, uint8_t length) {
  723. // Users should #include "raw_hid.h" in their own code
  724. // and implement this function there. Leave this as weak linkage
  725. // so users can opt to not handle data coming in.
  726. }
  727. void raw_hid_task(void) {
  728. uint8_t buffer[RAW_EPSIZE];
  729. size_t size = 0;
  730. do {
  731. size_t size = chnReadTimeout(&drivers.raw_driver.driver, buffer, sizeof(buffer), TIME_IMMEDIATE);
  732. if (size > 0) {
  733. raw_hid_receive(buffer, size);
  734. }
  735. } while (size > 0);
  736. }
  737. #endif
  738. #ifdef MIDI_ENABLE
  739. void send_midi_packet(MIDI_EventPacket_t *event) { chnWrite(&drivers.midi_driver.driver, (uint8_t *)event, sizeof(MIDI_EventPacket_t)); }
  740. bool recv_midi_packet(MIDI_EventPacket_t *const event) {
  741. size_t size = chnReadTimeout(&drivers.midi_driver.driver, (uint8_t *)event, sizeof(MIDI_EventPacket_t), TIME_IMMEDIATE);
  742. return size == sizeof(MIDI_EventPacket_t);
  743. }
  744. #endif
  745. #ifdef VIRTSER_ENABLE
  746. void virtser_send(const uint8_t byte) { chnWrite(&drivers.serial_driver.driver, &byte, 1); }
  747. __attribute__((weak)) void virtser_recv(uint8_t c) {
  748. // Ignore by default
  749. }
  750. void virtser_task(void) {
  751. uint8_t numBytesReceived = 0;
  752. uint8_t buffer[16];
  753. do {
  754. numBytesReceived = chnReadTimeout(&drivers.serial_driver.driver, buffer, sizeof(buffer), TIME_IMMEDIATE);
  755. for (int i = 0; i < numBytesReceived; i++) {
  756. virtser_recv(buffer[i]);
  757. }
  758. } while (numBytesReceived > 0);
  759. }
  760. #endif