logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

host.c (8159B)

    

  1. /*
  2. Copyright 2011,2012 Jun Wako <wakojun@gmail.com>
  4. This program is free software: you can redistribute it and/or modify
  5. it under the terms of the GNU General Public License as published by
  6. the Free Software Foundation, either version 2 of the License, or
  7. (at your option) any later version.
  9. This program is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. GNU General Public License for more details.
  14. You should have received a copy of the GNU General Public License
  15. along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16. */
  18. #include <stdint.h>
  19. #include "keyboard.h"
  20. #include "keycode.h"
  21. #include "host.h"
  22. #include "util.h"
  23. #include "debug.h"
  24. #include "usb_device_state.h"
  26. #ifdef DIGITIZER_ENABLE
  27. #    include "digitizer.h"
  28. #endif
  30. #ifdef JOYSTICK_ENABLE
  31. #    include "joystick.h"
  32. #endif
  34. #ifdef CONNECTION_ENABLE
  35. #    include "connection.h"
  36. #endif
  38. #ifdef BLUETOOTH_ENABLE
  39. #    include "bluetooth.h"
  41. static void bluetooth_send_extra(report_extra_t *report) {
  42.     switch (report->report_id) {
  43.         case REPORT_ID_SYSTEM:
  44.             bluetooth_send_system(report->usage);
  45.             return;
  46.         case REPORT_ID_CONSUMER:
  47.             bluetooth_send_consumer(report->usage);
  48.             return;
  49.     }
  50. }
  52. host_driver_t bt_driver = {
  53.     .keyboard_leds = bluetooth_keyboard_leds,
  54.     .send_keyboard = bluetooth_send_keyboard,
  55.     .send_nkro     = bluetooth_send_nkro,
  56.     .send_mouse    = bluetooth_send_mouse,
  57.     .send_extra    = bluetooth_send_extra,
  58. #    ifdef RAW_ENABLE
  59.     .send_raw_hid = bluetooth_send_raw_hid,
  60. #    endif
  61. };
  62. #endif
  64. #ifdef NKRO_ENABLE
  65. #    include "keycode_config.h"
  66. extern keymap_config_t keymap_config;
  67. #endif
  69. static host_driver_t *driver;
  70. static uint16_t       last_system_usage   = 0;
  71. static uint16_t       last_consumer_usage = 0;
  73. void host_set_driver(host_driver_t *d) {
  74.     driver = d;
  75. }
  77. host_driver_t *host_get_driver(void) {
  78.     return driver;
  79. }
  81. static host_driver_t *host_get_active_driver(void) {
  82. #ifdef CONNECTION_ENABLE
  83.     switch (connection_get_host()) {
  84. #    ifdef BLUETOOTH_ENABLE
  85.         case CONNECTION_HOST_BLUETOOTH:
  86.             return &bt_driver;
  87. #    endif
  88.         case CONNECTION_HOST_NONE:
  89.             return NULL;
  90.         default:
  91.             break;
  92.     }
  93. #endif
  94.     return driver;
  95. }
  97. bool host_can_send_nkro(void) {
  98. #ifdef CONNECTION_ENABLE
  99.     switch (connection_get_host()) {
  100. #    ifdef BLUETOOTH_ENABLE
  101.         case CONNECTION_HOST_BLUETOOTH:
  102.             return bluetooth_can_send_nkro();
  103. #    endif
  104.         case CONNECTION_HOST_NONE:
  105.             return false;
  106.         default:
  107.             break;
  108.     }
  109. #endif
  111.     return usb_device_state_get_protocol() == USB_PROTOCOL_REPORT;
  112. }
  114. #ifdef SPLIT_KEYBOARD
  115. uint8_t split_led_state = 0;
  116. void    set_split_host_keyboard_leds(uint8_t led_state) {
  117.     split_led_state = led_state;
  118. }
  119. #endif
  121. uint8_t host_keyboard_leds(void) {
  122. #ifdef SPLIT_KEYBOARD
  123.     if (!is_keyboard_master()) return split_led_state;
  124. #endif
  126.     host_driver_t *driver = host_get_active_driver();
  127.     if (!driver || !driver->keyboard_leds) return 0;
  129.     return (*driver->keyboard_leds)();
  130. }
  132. led_t host_keyboard_led_state(void) {
  133.     return (led_t)host_keyboard_leds();
  134. }
  136. /* send report */
  137. void host_keyboard_send(report_keyboard_t *report) {
  138.     host_driver_t *driver = host_get_active_driver();
  139.     if (!driver || !driver->send_keyboard) return;
  141. #ifdef KEYBOARD_SHARED_EP
  142.     report->report_id = REPORT_ID_KEYBOARD;
  143. #endif
  144.     (*driver->send_keyboard)(report);
  146.     if (debug_keyboard) {
  147.         dprintf("keyboard_report: %02X | ", report->mods);
  148.         for (uint8_t i = 0; i < KEYBOARD_REPORT_KEYS; i++) {
  149.             dprintf("%02X ", report->keys[i]);
  150.         }
  151.         dprint("\n");
  152.     }
  153. }
  155. void host_nkro_send(report_nkro_t *report) {
  156.     host_driver_t *driver = host_get_active_driver();
  157.     if (!driver || !driver->send_nkro) return;
  159.     report->report_id = REPORT_ID_NKRO;
  160.     (*driver->send_nkro)(report);
  162.     if (debug_keyboard) {
  163.         dprintf("nkro_report: %02X | ", report->mods);
  164.         for (uint8_t i = 0; i < NKRO_REPORT_BITS; i++) {
  165.             dprintf("%02X ", report->bits[i]);
  166.         }
  167.         dprint("\n");
  168.     }
  169. }
  171. void host_mouse_send(report_mouse_t *report) {
  172.     host_driver_t *driver = host_get_active_driver();
  173.     if (!driver || !driver->send_mouse) return;
  175. #ifdef MOUSE_SHARED_EP
  176.     report->report_id = REPORT_ID_MOUSE;
  177. #endif
  178. #ifdef MOUSE_EXTENDED_REPORT
  179.     // clip and copy to Boot protocol XY
  180.     report->boot_x = (report->x > 127) ? 127 : ((report->x < -127) ? -127 : report->x);
  181.     report->boot_y = (report->y > 127) ? 127 : ((report->y < -127) ? -127 : report->y);
  182. #endif
  183.     (*driver->send_mouse)(report);
  184. }
  186. void host_system_send(uint16_t usage) {
  187.     if (usage == last_system_usage) return;
  188.     last_system_usage = usage;
  190.     host_driver_t *driver = host_get_active_driver();
  191.     if (!driver || !driver->send_extra) return;
  193.     report_extra_t report = {
  194.         .report_id = REPORT_ID_SYSTEM,
  195.         .usage     = usage,
  196.     };
  197.     (*driver->send_extra)(&report);
  198. }
  200. void host_consumer_send(uint16_t usage) {
  201.     if (usage == last_consumer_usage) return;
  202.     last_consumer_usage = usage;
  204.     host_driver_t *driver = host_get_active_driver();
  205.     if (!driver || !driver->send_extra) return;
  207.     report_extra_t report = {
  208.         .report_id = REPORT_ID_CONSUMER,
  209.         .usage     = usage,
  210.     };
  211.     (*driver->send_extra)(&report);
  212. }
  214. #ifdef JOYSTICK_ENABLE
  215. void host_joystick_send(joystick_t *joystick) {
  216.     if (!driver) return;
  218.     report_joystick_t report = {
  219. #    ifdef JOYSTICK_SHARED_EP
  220.         .report_id = REPORT_ID_JOYSTICK,
  221. #    endif
  222. #    if JOYSTICK_AXIS_COUNT > 0
  223.         .axes =
  224.             {
  225.                 joystick->axes[0],
  227. #        if JOYSTICK_AXIS_COUNT >= 2
  228.                 joystick->axes[1],
  229. #        endif
  230. #        if JOYSTICK_AXIS_COUNT >= 3
  231.                 joystick->axes[2],
  232. #        endif
  233. #        if JOYSTICK_AXIS_COUNT >= 4
  234.                 joystick->axes[3],
  235. #        endif
  236. #        if JOYSTICK_AXIS_COUNT >= 5
  237.                 joystick->axes[4],
  238. #        endif
  239. #        if JOYSTICK_AXIS_COUNT >= 6
  240.                 joystick->axes[5],
  241. #        endif
  242.             },
  243. #    endif
  245. #    ifdef JOYSTICK_HAS_HAT
  246.         .hat = joystick->hat,
  247. #    endif
  249. #    if JOYSTICK_BUTTON_COUNT > 0
  250.         .buttons =
  251.             {
  252.                 joystick->buttons[0],
  254. #        if JOYSTICK_BUTTON_COUNT > 8
  255.                 joystick->buttons[1],
  256. #        endif
  257. #        if JOYSTICK_BUTTON_COUNT > 16
  258.                 joystick->buttons[2],
  259. #        endif
  260. #        if JOYSTICK_BUTTON_COUNT > 24
  261.                 joystick->buttons[3],
  262. #        endif
  263.             },
  264. #    endif
  265.     };
  267.     send_joystick(&report);
  268. }
  269. #endif
  271. __attribute__((weak)) void send_joystick(report_joystick_t *report) {}
  273. #ifdef DIGITIZER_ENABLE
  274. void host_digitizer_send(digitizer_t *digitizer) {
  275.     report_digitizer_t report = {
  276. #    ifdef DIGITIZER_SHARED_EP
  277.         .report_id = REPORT_ID_DIGITIZER,
  278. #    endif
  279.         .in_range = digitizer->in_range,
  280.         .tip      = digitizer->tip,
  281.         .barrel   = digitizer->barrel,
  282.         .x        = (uint16_t)(digitizer->x * 0x7FFF),
  283.         .y        = (uint16_t)(digitizer->y * 0x7FFF),
  284.     };
  286.     send_digitizer(&report);
  287. }
  288. #endif
  290. __attribute__((weak)) void send_digitizer(report_digitizer_t *report) {}
  292. #ifdef PROGRAMMABLE_BUTTON_ENABLE
  293. void host_programmable_button_send(uint32_t data) {
  294.     report_programmable_button_t report = {
  295.         .report_id = REPORT_ID_PROGRAMMABLE_BUTTON,
  296.         .usage     = data,
  297.     };
  299.     send_programmable_button(&report);
  300. }
  301. #endif
  303. __attribute__((weak)) void send_programmable_button(report_programmable_button_t *report) {}
  305. #ifdef RAW_ENABLE
  306. void host_raw_hid_send(uint8_t *data, uint8_t length) {
  307.     host_driver_t *driver = host_get_active_driver();
  308.     if (!driver || !driver->send_raw_hid) return;
  310.     (*driver->send_raw_hid)(data, length);
  311. }
  312. #endif
  314. uint16_t host_last_system_usage(void) {
  315.     return last_system_usage;
  316. }
  318. uint16_t host_last_consumer_usage(void) {
  319.     return last_consumer_usage;
  320. }