quantum/api.c

   1 #include "api.h"
   2 #include "quantum.h"
   3
   4 void dword_to_bytes(uint32_t dword, uint8_t * bytes) {
   5     bytes[0] = (dword >> 24) & 0xFF;
   6     bytes[1] = (dword >> 16) & 0xFF;
   7     bytes[2] = (dword >> 8) & 0xFF;
   8     bytes[3] = (dword >> 0) & 0xFF;
   9 }
  10
  11 uint32_t bytes_to_dword(uint8_t * bytes, uint8_t index) {
  12     return ((uint32_t)bytes[index + 0] << 24) | ((uint32_t)bytes[index + 1] << 16) | ((uint32_t)bytes[index + 2] << 8) | (uint32_t)bytes[index + 3];
  13 }
  14
  15 __attribute__ ((weak))
  16 bool process_api_quantum(uint8_t length, uint8_t * data) {
  17     return process_api_keyboard(length, data);
  18 }
  19
  20 __attribute__ ((weak))
  21 bool process_api_keyboard(uint8_t length, uint8_t * data) {
  22     return process_api_user(length, data);
  23 }
  24
  25 __attribute__ ((weak))
  26 bool process_api_user(uint8_t length, uint8_t * data) {
  27     return true;
  28 }
  29
  30 void process_api(uint16_t length, uint8_t * data) {
  31     // SEND_STRING("\nRX: ");
  32     // for (uint8_t i = 0; i < length; i++) {
  33     //     send_byte(data[i]);
  34     //     SEND_STRING(" ");
  35     // }
  36     if (!process_api_quantum(length, data))
  37         return;
  38
  39     switch (data[0]) {
  40         case MT_SET_DATA:
  41             switch (data[1]) {
  42                 case DT_DEFAULT_LAYER: {
  43                     eeconfig_update_default_layer(data[2]);
  44                     default_layer_set((uint32_t)(data[2]));
  45                     break;
  46                 }
  47                 case DT_KEYMAP_OPTIONS: {
  48                     eeconfig_update_keymap(data[2]);
  49                     break;
  50                 }
  51                 case DT_RGBLIGHT: {
  52                     #ifdef RGBLIGHT_ENABLE
  53                         uint32_t rgblight = bytes_to_dword(data, 2);
  54                         rgblight_update_dword(rgblight);
  55                     #endif
  56                     break;
  57                 }
  58             }
  59         case MT_GET_DATA:
  60             switch (data[1]) {
  61                 case DT_HANDSHAKE: {
  62                     MT_GET_DATA_ACK(DT_HANDSHAKE, NULL, 0);
  63                     break;
  64                 }
  65                 case DT_DEBUG: {
  66                     uint8_t debug_bytes[1] = { eeprom_read_byte(EECONFIG_DEBUG) };
  67                     MT_GET_DATA_ACK(DT_DEBUG, debug_bytes, 1);
  68                     break;
  69                 }
  70                 case DT_DEFAULT_LAYER: {
  71                     uint8_t default_bytes[1] = { eeprom_read_byte(EECONFIG_DEFAULT_LAYER) };
  72                     MT_GET_DATA_ACK(DT_DEFAULT_LAYER, default_bytes, 1);
  73                     break;
  74                 }
  75                 case DT_CURRENT_LAYER: {
  76                     uint8_t layer_state_bytes[4];
  77                     dword_to_bytes(layer_state, layer_state_bytes);
  78                     MT_GET_DATA_ACK(DT_CURRENT_LAYER, layer_state_bytes, 4);
  79                     break;
  80                 }
  81                 case DT_AUDIO: {
  82                     #ifdef AUDIO_ENABLE
  83                         uint8_t audio_bytes[1] = { eeprom_read_byte(EECONFIG_AUDIO) };
  84                         MT_GET_DATA_ACK(DT_AUDIO, audio_bytes, 1);
  85                     #else
  86                         MT_GET_DATA_ACK(DT_AUDIO, NULL, 0);
  87                     #endif
  88                     break;
  89                 }
  90                 case DT_BACKLIGHT: {
  91                     #ifdef BACKLIGHT_ENABLE
  92                         uint8_t backlight_bytes[1] = { eeprom_read_byte(EECONFIG_BACKLIGHT) };
  93                         MT_GET_DATA_ACK(DT_BACKLIGHT, backlight_bytes, 1);
  94                     #else
  95                         MT_GET_DATA_ACK(DT_BACKLIGHT, NULL, 0);
  96                     #endif
  97                     break;
  98                 }
  99                 case DT_RGBLIGHT: {
 100                     #ifdef RGBLIGHT_ENABLE
 101                         uint8_t rgblight_bytes[4];
 102                         dword_to_bytes(eeconfig_read_rgblight(), rgblight_bytes);
 103                         MT_GET_DATA_ACK(DT_RGBLIGHT, rgblight_bytes, 4);
 104                     #else
 105                         MT_GET_DATA_ACK(DT_RGBLIGHT, NULL, 0);
 106                     #endif
 107                     break;
 108                 }
 109                 case DT_KEYMAP_OPTIONS: {
 110                     uint8_t keymap_bytes[1] = { eeconfig_read_keymap() };
 111                     MT_GET_DATA_ACK(DT_KEYMAP_OPTIONS, keymap_bytes, 1);
 112                     break;
 113                 }
 114                 case DT_KEYMAP_SIZE: {
 115                     uint8_t keymap_size[2] = {MATRIX_ROWS, MATRIX_COLS};
 116                     MT_GET_DATA_ACK(DT_KEYMAP_SIZE, keymap_size, 2);
 117                     break;
 118                 }
 119                 // This may be too much
 120                 // case DT_KEYMAP: {
 121                 //     uint8_t keymap_data[MATRIX_ROWS * MATRIX_COLS * 4 + 3];
 122                 //     keymap_data[0] = data[2];
 123                 //     keymap_data[1] = MATRIX_ROWS;
 124                 //     keymap_data[2] = MATRIX_COLS;
 125                 //     for (int i = 0; i < MATRIX_ROWS; i++) {
 126                 //         for (int j = 0; j < MATRIX_COLS; j++) {
 127                 //             keymap_data[3 + (i*MATRIX_COLS*2) + (j*2)] = pgm_read_word(&keymaps[data[2]][i][j]) >> 8;
 128                 //             keymap_data[3 + (i*MATRIX_COLS*2) + (j*2) + 1] = pgm_read_word(&keymaps[data[2]][i][j]) & 0xFF;
 129                 //         }
 130                 //     }
 131                 //     MT_GET_DATA_ACK(DT_KEYMAP, keymap_data, MATRIX_ROWS * MATRIX_COLS * 4 + 3);
 132                 //     // uint8_t keymap_data[5];
 133                 //     // keymap_data[0] = data[2];
 134                 //     // keymap_data[1] = data[3];
 135                 //     // keymap_data[2] = data[4];
 136                 //     // keymap_data[3] = pgm_read_word(&keymaps[data[2]][data[3]][data[4]]) >> 8;
 137                 //     // keymap_data[4] = pgm_read_word(&keymaps[data[2]][data[3]][data[4]]) & 0xFF;
 138
 139                 //     // MT_GET_DATA_ACK(DT_KEYMAP, keymap_data, 5);
 140                 //     break;
 141                 // }
 142                 default:
 143                     break;
 144             }
 145             break;
 146         case MT_SET_DATA_ACK:
 147         case MT_GET_DATA_ACK:
 148             break;
 149         case MT_SEND_DATA:
 150             break;
 151         case MT_SEND_DATA_ACK:
 152             break;
 153         case MT_EXE_ACTION:
 154             break;
 155         case MT_EXE_ACTION_ACK:
 156             break;
 157         case MT_TYPE_ERROR:
 158             break;
 159         default: ; // command not recognised
 160             SEND_BYTES(MT_TYPE_ERROR, DT_NONE, data, length);
 161             break;
 162
 163         // #ifdef RGBLIGHT_ENABLE
 164         // case 0x27: ; // RGB LED functions
 165         //     switch (*data++) {
 166         //         case 0x00: ; // Update HSV
 167         //             rgblight_sethsv((data[0] << 8 | data[1]) % 360, data[2], data[3]);
 168         //             break;
 169         //         case 0x01: ; // Update RGB
 170         //             break;
 171         //         case 0x02: ; // Update mode
 172         //             rgblight_mode(data[0]);
 173         //             break;
 174         //     }
 175         //     break;
 176         // #endif
 177     }
 178
 179 }