logo

qmk_firmware

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

myriad.c (9981B)

    

  1. // Copyright 2024 splitkb.com (support@splitkb.com)
  2. // SPDX-License-Identifier: GPL-2.0-or-later
  4. #include QMK_KEYBOARD_H
  6. #include "myriad.h"
  8. #include "i2c_master.h"
  9. #include "analog.h"
  11. typedef struct __attribute__((__packed__)) {
  12.     char magic_numbers[3];
  13.     uint8_t version_major;
  14.     uint8_t version_minor;
  15.     uint8_t version_patch;
  16.     uint32_t checksum;
  17.     uint16_t payload_length;
  18. } myriad_header_t;
  20. typedef struct __attribute__((__packed__)) {
  21.     uint16_t vendor_id;
  22.     uint16_t product_id;
  23.     uint8_t revision;
  24. } identity_record_t;
  26. static bool myriad_reader(uint8_t *data, uint16_t length) {
  27.     const uint8_t eeprom_address = 0x50; // 1010 000 - NOT shifted for R/W bit
  28.     const uint16_t i2c_timeout = 100; // in milliseconds
  30.     uint8_t num_pages = (length / 256) + 1;
  31.     uint8_t last_page_size = length % 256;
  33.     for (int i = 0; i < num_pages; i++) {
  34.         uint8_t reg = 0; // We always start on a page boundary, so this is always zero 
  35.         uint16_t read_length;
  36.         if (i == num_pages - 1) {
  37.             read_length = last_page_size;
  38.         } else {
  39.             read_length = 256;
  40.         }
  41.         i2c_status_t s = i2c_read_register((eeprom_address + i) << 1, reg, &(data[i*256]), read_length, i2c_timeout);
  42.         if (s != I2C_STATUS_SUCCESS) { return false; }
  43.     }
  44.     return true;
  45. }
  47. static bool verify_header(myriad_header_t *header) {
  48.     char magic_numbers[] = {'M', 'Y', 'R'};
  49.     uint8_t version_major = 1;
  50.     uint16_t version_minor = 0;
  52.     for (int i = 0; i < sizeof(magic_numbers); i++) {
  53.         // Check that the header starts with 'MYR', indicating that this is indeed a Myriad card.
  54.         if (header->magic_numbers[i] != magic_numbers[i]) {
  55.             return false;
  56.         }
  57.     }
  59.     if (header->version_major != version_major || header->version_minor > version_minor) {
  60.         // We obviously don't support cards with a different major version, because that indicates a breaking change.
  61.         // We also don't support cards with HIGHER minor version,
  62.         // as we are not guaranteed to be able to properly use all its features.
  63.         return false;
  64.     }
  66.     if (header->payload_length > (2048 - sizeof(myriad_header_t))) {
  67.         // The EEPROM chips are *at most* 16kb / 2kB large,
  68.         // and some of that is taken up by the header.
  69.         // We obviously can't have a payload which exceeds the EEPROM's size.
  70.         return false;
  71.     }
  73.     return true;
  74. }
  76. // Sourced from https://en.wikipedia.org/wiki/Adler-32#Example_implementation
  77. static bool verify_checksum(uint8_t *data, uint16_t length, uint32_t checksum) {
  78.     // Skip the header
  79.     data += sizeof(myriad_header_t);
  80.     length -= sizeof(myriad_header_t);
  82.     const uint32_t MOD_ADLER = 65521;
  84.     uint32_t a = 1, b = 0;
  85.     size_t index;
  86.     
  87.     // Process each byte of the data in order
  88.     for (index = 0; index < length; ++index)
  89.     {
  90.         a = (a + data[index]) % MOD_ADLER;
  91.         b = (b + a) % MOD_ADLER;
  92.     }
  93.     uint32_t calculated = ((b << 16) | a);
  94.     
  95.     return calculated == checksum;
  96. }
  98. // Locates a specific entry by type
  99. // Returns the offset of the PAYLOAD.
  100. static int16_t locate_entry(uint8_t entry_type, uint8_t entry_data_length, uint8_t *data, uint16_t minimum, uint16_t maximum) {
  101.     if (minimum < sizeof(myriad_header_t)) {
  102.         // Records must start *after* the header.
  103.         // We silently allow this so the caller can just specify `0` as minimum for the first entry.
  104.         minimum = sizeof(myriad_header_t);
  105.     }
  107.     uint16_t offset = minimum;
  108.     while (offset < maximum) {
  109.         if (data[offset] == entry_type) {
  110.             // Type matches!
  111.             if (data[offset+1] == entry_data_length) {
  112.                 // We found what we are looking for, so return payload reference.
  113.                 return offset+2;
  114.             } else {
  115.                 // The entry is the wrong length?
  116.                 return -2;
  117.             }
  118.         } else {
  119.             // No type match, so skip this one
  120.             // We skip the type byte, the length byte, and any potential data (with length stored in the length byte)
  121.             offset += 2 + data[offset+1];
  122.         }
  123.     }
  125.     // We hit the maximum and didn't find what we are looking for
  126.     return -1;
  127. }
  129. static bool read_card_identity(uint8_t *data, uint16_t length, identity_record_t *record) {
  130.     const uint8_t identity_type = 0x01;
  131.     const uint8_t entry_data_length = sizeof(identity_record_t);
  132.     int16_t result = locate_entry(identity_type, entry_data_length, data, 0, length);
  133.     if (result < 0) { return false; }
  135.     for (int i = 0; i < sizeof(identity_record_t); i++) {
  136.         ((uint8_t*)record)[i] = data[result + i];
  137.     }
  138.     return true;
  139. }
  141. static myriad_card_t _detect_myriad(void) {
  142.     gpio_set_pin_input(MYRIAD_PRESENT);
  143.     wait_ms(100);
  144.     // The pin has an external pull-up, and a Myriad card shorts it to ground.
  145.     #ifndef MYRIAD_OVERRIDE_PRESENCE
  146.     if (gpio_read_pin(MYRIAD_PRESENT)) {
  147.         return NONE;
  148.     }
  149.     #endif
  151.     // Attempt to read header
  152.     myriad_header_t header;
  153.     if (!myriad_reader((uint8_t*)&header, sizeof(header))) { return INVALID; }
  154.     if (!verify_header(&header)) { return INVALID; }
  156.     // Now that we have determined that the header is valid
  157.     // and we know the payload length, read the entire thing
  158.     uint8_t data[2048]; // Guaranteed to be large enough.
  159.     uint16_t data_size = sizeof(header)+header.payload_length;
  160.     if (!myriad_reader(data, data_size)) { return INVALID; }
  161.     if (!verify_checksum(data, data_size, header.checksum)) { return INVALID; }
  163.     identity_record_t identity;
  164.     if (!read_card_identity(data, data_size, &identity)) { return INVALID; }
  166.     if (identity.vendor_id == 0x0001 && identity.product_id == 0x0001) {
  167.         return SKB_ENCODER;
  168.     } else if (identity.vendor_id == 0x0001 && identity.product_id == 0x0002) {
  169.         return SKB_JOYSTICK;
  170.     } else if (identity.vendor_id == 0x0001 && identity.product_id == 0x0003) {
  171.         return SKB_SWITCHES;
  172.     }
  174.     return UNKNOWN;
  175. }
  177. // Determine card presence & identity
  178. // Does NOT initialize the card for use!
  179. myriad_card_t detect_myriad(void) {
  180.     static myriad_card_t card = UNINITIALIZED;
  182.     if (card == UNINITIALIZED) {
  183.         i2c_init();
  184.         card = _detect_myriad();
  185.     }
  187.     return card;
  188. }
  190. static void myr_switches_init(void) {
  191.     gpio_set_pin_input_high(MYRIAD_GPIO1); // S4
  192.     gpio_set_pin_input_high(MYRIAD_GPIO2); // S2
  193.     gpio_set_pin_input_high(MYRIAD_GPIO3); // S1
  194.     gpio_set_pin_input_high(MYRIAD_GPIO4); // S3
  195. }
  197. static void myr_encoder_init(void) {
  198.     gpio_set_pin_input_high(MYRIAD_GPIO1); // Press
  199.     gpio_set_pin_input_high(MYRIAD_GPIO2); // A
  200.     gpio_set_pin_input_high(MYRIAD_GPIO3); // B
  201. }
  203. static uint16_t myr_joystick_timer;
  204. static void myr_joystick_init(void) {
  205.     gpio_set_pin_input_high(MYRIAD_GPIO1); // Press
  207.     myr_joystick_timer = timer_read();
  208. }
  210. // Make sure any card present is ready for use
  211. static myriad_card_t myriad_card_init(void) {
  212.     static bool initialized = false;
  214.     myriad_card_t card = detect_myriad();
  215.     if (initialized) {
  216.         return card;
  217.     }
  218.     initialized = true;
  220.     switch (card) {
  221.         case SKB_SWITCHES:
  222.             myr_switches_init();
  223.             break;
  224.         case SKB_ENCODER:
  225.             myr_encoder_init();
  226.             break;
  227.         case SKB_JOYSTICK:
  228.             myr_joystick_init();
  229.             break;
  230.         default:
  231.             break;
  232.     }
  233.     return card;
  234. }
  236. bool myriad_hook_matrix(matrix_row_t current_matrix[]) {
  237.     myriad_card_t card = myriad_card_init();
  238.     uint8_t word = 0;
  240.     if (card == SKB_SWITCHES) {
  241.         word |= ((!gpio_read_pin(MYRIAD_GPIO3)) & 1) << 0;
  242.         word |= ((!gpio_read_pin(MYRIAD_GPIO2)) & 1) << 1;
  243.         word |= ((!gpio_read_pin(MYRIAD_GPIO4)) & 1) << 2;
  244.         word |= ((!gpio_read_pin(MYRIAD_GPIO1)) & 1) << 3;
  245.     } else if (card == SKB_ENCODER) {
  246.         word |= ((!gpio_read_pin(MYRIAD_GPIO1)) & 1) << 4;
  247.     } else if (card == SKB_JOYSTICK) {
  248.         word |= ((!gpio_read_pin(MYRIAD_GPIO1)) & 1) << 4;
  249.     } else {
  250.         return false;
  251.     }
  253.     // 5 bytes of on-board keys, so we are the 6th
  254.     bool matrix_has_changed = current_matrix[5] ^ word;
  255.     current_matrix[5] = word;
  257.     return matrix_has_changed;
  258. }
  260. static pin_t encoders_pad_a[NUM_ENCODERS_MAX_PER_SIDE];
  261. static pin_t encoders_pad_b[NUM_ENCODERS_MAX_PER_SIDE];
  263. uint8_t myriad_hook_encoder(uint8_t index, bool pad_b) {
  264.     if (myriad_card_init() != SKB_ENCODER) { return 0; }
  265.     // 3 onboard encoders, so we are number 4
  266.     pin_t pin = pad_b ? encoders_pad_b[index] : encoders_pad_a[index];
  267.     encoders_pad_a[3] = MYRIAD_GPIO2;
  268.     encoders_pad_b[3] = MYRIAD_GPIO3;
  269.     return gpio_read_pin(pin) ? 1 : 0;
  270. }
  272. report_mouse_t pointing_device_driver_get_report(report_mouse_t mouse_report) {
  273.     if (myriad_card_init() != SKB_JOYSTICK) { return mouse_report; }
  275.     if (timer_elapsed(myr_joystick_timer) < 10) {
  276.         wait_ms(2);
  277.         return mouse_report;
  278.     }
  280.     myr_joystick_timer = timer_read();
  282.     // `analogReadPin` returns 0..1023
  283.     int32_t y = (analogReadPin(MYRIAD_ADC1) - 512) * -1; // Note: axis is flipped
  284.     int32_t x = analogReadPin(MYRIAD_ADC2) - 512;
  285.     // Values are now -512..512
  287.     // Create a dead zone in the middle where the mouse doesn't move
  288.     const int16_t dead_zone = 10;
  289.     if ((y < 0 && y > -1*dead_zone) || (y > 0 && y < dead_zone)) {
  290.         y = 0;
  291.     }
  292.     if ((x < 0 && x > -1*dead_zone) || (x > 0 && x < dead_zone)) {
  293.         x = 0;
  294.     }
  296.     // quadratic movement
  297.     x = abs(x) * x / 5000;
  298.     y = abs(y) * y / 5000;
  300.     // Clamp final value to make sure we don't under/overflow
  301.     if (y < -127) { y = -127; }
  302.     if (y > 127) { y = 127; }
  303.     if (x < -127) { x = -127; }
  304.     if (x > 127) { x = 127; }
  306.     mouse_report.x = x;
  307.     mouse_report.y = y;
  309.     return mouse_report;
  310. }
  312. void pointing_device_driver_init(void) {
  313.     gpio_set_pin_input(MYRIAD_ADC1); // Y
  314.     gpio_set_pin_input(MYRIAD_ADC2); // X
  315. }