diff --git a/doc/plugin/Hardware-Model01.md b/doc/plugin/Hardware-Model01.md new file mode 100644 index 00000000..b0b985b8 --- /dev/null +++ b/doc/plugin/Hardware-Model01.md @@ -0,0 +1,7 @@ +# Kaleidoscope-Hardware-Model01 + +This is a plugin for [Kaleidoscope][fw], that adds hardware support for +the [Keyboardio Model01][kbdio:model01]. + + [fw]: https://github.com/keyboardio/Kaleidoscope + [kbdio:model01]: https://shop.keyboard.io/ diff --git a/src/Kaleidoscope-Hardware-Model01.h b/src/Kaleidoscope-Hardware-Model01.h new file mode 100644 index 00000000..5671a34d --- /dev/null +++ b/src/Kaleidoscope-Hardware-Model01.h @@ -0,0 +1,20 @@ +/* -*- mode: c++ -*- + * Kaleidoscope-Hardware-Model01 -- Keyboard.io Model01 hardware support for Kaleidoscope + * Copyright (C) 2017-2018 Keyboard.io, Inc + * + * This program is free software: you can redistribute it and/or modify it under + * the terms of the GNU General Public License as published by the Free Software + * Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License along with + * this program. If not, see . + */ + +#pragma once + +#include "kaleidoscope/hardware/Model01.h" diff --git a/src/kaleidoscope/hardware/Model01.cpp b/src/kaleidoscope/hardware/Model01.cpp new file mode 100644 index 00000000..7c9dc4c0 --- /dev/null +++ b/src/kaleidoscope/hardware/Model01.cpp @@ -0,0 +1,316 @@ +/* -*- mode: c++ -*- + * Kaleidoscope-Hardware-Model01 -- Keyboard.io Model01 hardware support for Kaleidoscope + * Copyright (C) 2017-2018 Keyboard.io, Inc + * + * This program is free software: you can redistribute it and/or modify it under + * the terms of the GNU General Public License as published by the Free Software + * Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License along with + * this program. If not, see . + */ + +#include +#include +#include + +namespace kaleidoscope { +namespace hardware { + +KeyboardioScanner Model01::leftHand(0); +KeyboardioScanner Model01::rightHand(3); +bool Model01::isLEDChanged = true; +keydata_t Model01::leftHandMask; +keydata_t Model01::rightHandMask; + +static constexpr uint8_t key_led_map[4][16] = { + {3, 4, 11, 12, 19, 20, 26, 27, 36, 37, 43, 44, 51, 52, 59, 60}, + {2, 5, 10, 13, 18, 21, 25, 28, 35, 38, 42, 45, 50, 53, 58, 61}, + {1, 6, 9, 14, 17, 22, 24, 29, 34, 39, 41, 46, 49, 54, 57, 62}, + {0, 7, 8, 15, 16, 23, 31, 30, 33, 32, 40, 47, 48, 55, 56, 63}, +}; + +Model01::Model01(void) { + +} + +void Model01::enableScannerPower(void) { + // PC7 + //pinMode(13, OUTPUT); + //digitalWrite(13, HIGH); + // Turn on power to the LED net + DDRC |= _BV(7); + PORTC |= _BV(7); + +} + +// This lets the keyboard pull up to 1.6 amps from +// the host. That violates the USB spec. But it sure +// is pretty looking +void Model01::enableHighPowerLeds(void) { + // PE6 + // pinMode(7, OUTPUT); + // digitalWrite(7, LOW); + DDRE |= _BV(6); + PORTE &= ~_BV(6); + + // Set B4, the overcurrent check to an input with an internal pull-up + DDRB &= ~_BV(4); // set bit, input + PORTB &= ~_BV(4); // set bit, enable pull-up resistor + + + +} + +void Model01::setup(void) { + wdt_disable(); + delay(100); + enableScannerPower(); + + // Consider not doing this until 30s after keyboard + // boot up, to make it easier to rescue things + // in case of power draw issues. + enableHighPowerLeds(); + leftHandState.all = 0; + rightHandState.all = 0; + + TWBR = 12; // This is 400mhz, which is the fastest we can drive the ATTiny +} + + +void Model01::setCrgbAt(uint8_t i, cRGB crgb) { + if (i < 32) { + cRGB oldColor = getCrgbAt(i); + isLEDChanged |= !(oldColor.r == crgb.r && oldColor.g == crgb.g && oldColor.b == crgb.b); + + leftHand.ledData.leds[i] = crgb; + } else if (i < 64) { + cRGB oldColor = getCrgbAt(i); + isLEDChanged |= !(oldColor.r == crgb.r && oldColor.g == crgb.g && oldColor.b == crgb.b); + + rightHand.ledData.leds[i - 32] = crgb; + } else { + // TODO(anyone): + // how do we want to handle debugging assertions about crazy user + // code that would overwrite other memory? + } +} + +void Model01::setCrgbAt(byte row, byte col, cRGB color) { + setCrgbAt(key_led_map[row][col], color); +} + +uint8_t Model01::getLedIndex(byte row, byte col) { + return key_led_map[row][col]; +} + +cRGB Model01::getCrgbAt(uint8_t i) { + if (i < 32) { + return leftHand.ledData.leds[i]; + } else if (i < 64) { + return rightHand.ledData.leds[i - 32] ; + } else { + return {0, 0, 0}; + } +} + +void Model01::syncLeds() { + if (!isLEDChanged) + return; + + leftHand.sendLEDData(); + rightHand.sendLEDData(); + + leftHand.sendLEDData(); + rightHand.sendLEDData(); + + leftHand.sendLEDData(); + rightHand.sendLEDData(); + + leftHand.sendLEDData(); + rightHand.sendLEDData(); + + isLEDChanged = false; +} + +boolean Model01::ledPowerFault() { + if (PINB & _BV(4)) { + return true; + } else { + return false; + } +} + +void debugKeyswitchEvent(keydata_t state, keydata_t previousState, uint8_t keynum, uint8_t row, uint8_t col) { + if (bitRead(state.all, keynum) != bitRead(previousState.all, keynum)) { + Serial.print("Looking at row "); + Serial.print(row); + Serial.print(", col "); + Serial.print(col); + Serial.print(" key # "); + Serial.print(keynum); + Serial.print(" "); + Serial.print(bitRead(previousState.all, keynum)); + Serial.print(" -> "); + Serial.print(bitRead(state.all, keynum)); + Serial.println(); + } +} + + +void Model01::readMatrix() { + //scan the Keyboard matrix looking for connections + previousLeftHandState = leftHandState; + previousRightHandState = rightHandState; + + if (leftHand.readKeys()) { + leftHandState = leftHand.getKeyData(); + } + + if (rightHand.readKeys()) { + rightHandState = rightHand.getKeyData(); + } +} + +void Model01::actOnHalfRow(byte row, byte colState, byte colPrevState, byte startPos) { + if ((colState != colPrevState) || (colState != 0)) { + for (byte col = 0; col < 8; col++) { + // Build up the key state for row, col + uint8_t keyState = ((bitRead(colPrevState, 0) << 0) | + (bitRead(colState, 0) << 1)); + if (keyState) + handleKeyswitchEvent(Key_NoKey, row, startPos - col, keyState); + + // Throw away the data we've just used, so we can read the next column + colState = colState >> 1; + colPrevState = colPrevState >> 1; + } + } +} + +void Model01::actOnMatrixScan() { + for (byte row = 0; row < 4; row++) { + actOnHalfRow(row, leftHandState.rows[row], previousLeftHandState.rows[row], 7); + actOnHalfRow(row, rightHandState.rows[row], previousRightHandState.rows[row], 15); + } +} + + +void Model01::scanMatrix() { + readMatrix(); + actOnMatrixScan(); +} + +void Model01::rebootBootloader() { + // Set the magic bits to get a Caterina-based device + // to reboot into the bootloader and stay there, rather + // than run move onward + // + // These values are the same as those defined in + // Caterina.c + + uint16_t bootKey = 0x7777; + uint16_t *const bootKeyPtr = reinterpret_cast(0x0800); + + // Stash the magic key + *bootKeyPtr = bootKey; + + // Set a watchdog timer + wdt_enable(WDTO_120MS); + + while (1) {} // This infinite loop ensures nothing else + // happens before the watchdog reboots us +} + +// In the maskKey(), unMaskKey(), and isKeyMasked() functions, we read and write bits in +// two bitfields -- one for each half of the keyboard. The fourth bit of the column number +// tells us which bitfield (right or left) to access, thus the "8" (B00001000). The row +// number tells us which element of the array to access. The last three bits of the column +// number tell us which of the eight bits to access, thus the "7" (B00000111), and we +// shift a bit starting from the left (B10000000, or 128) by that many places to get +// there. This is all nice and convenient because the keyboard has 64 keys, in symmetric +// halves, with eight keys per logical row. + +constexpr byte HIGH_BIT = B10000000; +constexpr byte HAND_BIT = B00001000; +constexpr byte ROW_BITS = B00110000; +constexpr byte COL_BITS = B00000111; + +void Model01::maskKey(byte row, byte col) { + if (row >= ROWS || col >= COLS) + return; + + if (col & HAND_BIT) { + rightHandMask.rows[row] |= (HIGH_BIT >> (col & COL_BITS)); + } else { + leftHandMask.rows[row] |= (HIGH_BIT >> (col & COL_BITS)); + } +} + +void Model01::unMaskKey(byte row, byte col) { + if (row >= ROWS || col >= COLS) + return; + + if (col & HAND_BIT) { + rightHandMask.rows[row] &= ~(HIGH_BIT >> (col & COL_BITS)); + } else { + leftHandMask.rows[row] &= ~(HIGH_BIT >> (col & COL_BITS)); + } +} + +bool Model01::isKeyMasked(byte row, byte col) { + if (row >= ROWS || col >= COLS) + return false; + + if (col & HAND_BIT) { + return rightHandMask.rows[row] & (HIGH_BIT >> (col & COL_BITS)); + } else { + return leftHandMask.rows[row] & (HIGH_BIT >> (col & COL_BITS)); + } +} + +void Model01::maskHeldKeys(void) { + memcpy(leftHandMask.rows, leftHandState.rows, sizeof(leftHandMask)); + memcpy(rightHandMask.rows, rightHandState.rows, sizeof(rightHandMask)); +} + + +void Model01::setKeyscanInterval(uint8_t interval) { + leftHand.setKeyscanInterval(interval); + rightHand.setKeyscanInterval(interval); +} + +void Model01::detachFromHost() { + UDCON |= (1 << DETACH); +} + +void Model01::attachToHost() { + UDCON &= ~(1 << DETACH); +} + +bool Model01::isKeyswitchPressed(byte row, byte col) { + if (col <= 7) { + return (bitRead(leftHandState.rows[row], 7 - col) != 0); + } else { + return (bitRead(rightHandState.rows[row], 7 - (col - 8)) != 0); + } +} + +bool Model01::isKeyswitchPressed(uint8_t keyIndex) { + keyIndex--; + return isKeyswitchPressed(keyIndex / COLS, keyIndex % COLS); +} + +uint8_t Model01::pressedKeyswitchCount() { + return __builtin_popcountl(leftHandState.all) + __builtin_popcountl(rightHandState.all); +} + +} +} + +HARDWARE_IMPLEMENTATION KeyboardHardware; diff --git a/src/kaleidoscope/hardware/Model01.h b/src/kaleidoscope/hardware/Model01.h new file mode 100644 index 00000000..7cb9717a --- /dev/null +++ b/src/kaleidoscope/hardware/Model01.h @@ -0,0 +1,322 @@ +/* -*- mode: c++ -*- + * Kaleidoscope-Hardware-Model01 -- Keyboard.io Model01 hardware support for Kaleidoscope + * Copyright (C) 2017-2018 Keyboard.io, Inc + * + * This program is free software: you can redistribute it and/or modify it under + * the terms of the GNU General Public License as published by the Free Software + * Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License along with + * this program. If not, see . + */ + +#pragma once + +#include + +#define HARDWARE_IMPLEMENTATION kaleidoscope::hardware::Model01 +#include "Kaleidoscope-HIDAdaptor-KeyboardioHID.h" +#include "KeyboardioScanner.h" + +#include "kaleidoscope/macro_helpers.h" + +#define COLS 16 +#define ROWS 4 + +#define CRGB(r,g,b) (cRGB){b, g, r} + +namespace kaleidoscope { +namespace hardware { + +class Model01 { + public: + Model01(void); + void syncLeds(void); + void setCrgbAt(byte row, byte col, cRGB color); + void setCrgbAt(uint8_t i, cRGB crgb); + cRGB getCrgbAt(uint8_t i); + uint8_t getLedIndex(byte row, byte col); + + void scanMatrix(void); + void readMatrix(void); + void actOnMatrixScan(void); + void setup(); + void rebootBootloader(); + + + /** Detaching from / attaching to the host. + * + * These two functions should detach the device from (or attach it to) the + * host, preferably without rebooting the device. Their purpose is to allow + * one to do some configuration inbetween, so the re-attach happens with + * different properties. The device remains powered between these operations, + * only the connection to the host gets severed. + */ + void detachFromHost(); + void attachToHost(); + + /* These public functions are things supported by the Model 01, but + * aren't necessarily part of the Kaleidoscope API + */ + void enableHighPowerLeds(void); + void enableScannerPower(void); + void setKeyscanInterval(uint8_t interval); + boolean ledPowerFault(void); + + /* Key masking + * ----------- + * + * There are situations when one wants to ignore key events for a while, and + * mask them out. These functions help do that. In isolation, they do nothing, + * plugins and the core firmware is expected to make use of these. + * + * See `handleKeyswitchEvent` in the Kaleidoscope sources for a use-case. + */ + void maskKey(byte row, byte col); + void unMaskKey(byte row, byte col); + bool isKeyMasked(byte row, byte col); + void maskHeldKeys(void); + + /** Key switch states + * + * These methods offer a way to peek at the key switch states, for those cases + * where we need to deal with the state closest to the hardware. Some methods + * offer a way to check if a key is pressed, others return the number of + * pressed keys. + */ + /** + * Check if a key is pressed at a given position. + * + * @param row is the row the key is located at in the matrix. + * @param col is the column the key is located at in the matrix. + * + * @returns true if the key is pressed, false otherwise. + */ + bool isKeyswitchPressed(byte row, byte col); + /** + * Check if a key is pressed at a given position. + * + * @param keyIndex is the key index, as calculated by `keyIndex`. + * + * @note Key indexes start at 1, not 0! + * + * @returns true if the key is pressed, false otherwise. + */ + bool isKeyswitchPressed(uint8_t keyIndex); + /** + * Check the number of key switches currently pressed. + * + * @returns the number of keys pressed. + */ + uint8_t pressedKeyswitchCount(); + + keydata_t leftHandState; + keydata_t rightHandState; + keydata_t previousLeftHandState; + keydata_t previousRightHandState; + + private: + static void actOnHalfRow(byte row, byte colState, byte colPrevState, byte startPos); + + static bool isLEDChanged; + static KeyboardioScanner leftHand; + static KeyboardioScanner rightHand; + + static keydata_t leftHandMask; + static keydata_t rightHandMask; +}; + +} +} + +#ifndef DOXYGEN_SHOULD_SKIP_THIS + +/* To be used by the hardware implementations, `keyIndex` tells us the index of + * a key, from which we can figure out the row and column as needed. The index + * starts at one, so that plugins that work with a list of key indexes can use + * zero as a sentinel. This is important, because when we initialize arrays with + * fewer elements than the declared array size, the remaining elements will be + * zero. We can use this to avoid having to explicitly add a sentinel in + * user-facing code. + */ +constexpr byte keyIndex(byte row, byte col) { + return row * COLS + col + 1; +} + +constexpr byte R0C0 = keyIndex(0, 0); +constexpr byte R0C1 = keyIndex(0, 1); +constexpr byte R0C2 = keyIndex(0, 2); +constexpr byte R0C3 = keyIndex(0, 3); +constexpr byte R0C4 = keyIndex(0, 4); +constexpr byte R0C5 = keyIndex(0, 5); +constexpr byte R0C6 = keyIndex(0, 6); +constexpr byte R0C7 = keyIndex(0, 7); +constexpr byte R1C0 = keyIndex(1, 0); +constexpr byte R1C1 = keyIndex(1, 1); +constexpr byte R1C2 = keyIndex(1, 2); +constexpr byte R1C3 = keyIndex(1, 3); +constexpr byte R1C4 = keyIndex(1, 4); +constexpr byte R1C5 = keyIndex(1, 5); +constexpr byte R1C6 = keyIndex(1, 6); +constexpr byte R1C7 = keyIndex(1, 7); +constexpr byte R2C0 = keyIndex(2, 0); +constexpr byte R2C1 = keyIndex(2, 1); +constexpr byte R2C2 = keyIndex(2, 2); +constexpr byte R2C3 = keyIndex(2, 3); +constexpr byte R2C4 = keyIndex(2, 4); +constexpr byte R2C5 = keyIndex(2, 5); +constexpr byte R2C6 = keyIndex(2, 6); +constexpr byte R2C7 = keyIndex(2, 7); +constexpr byte R3C0 = keyIndex(3, 0); +constexpr byte R3C1 = keyIndex(3, 1); +constexpr byte R3C2 = keyIndex(3, 2); +constexpr byte R3C3 = keyIndex(3, 3); +constexpr byte R3C4 = keyIndex(3, 4); +constexpr byte R3C5 = keyIndex(3, 5); +constexpr byte R3C6 = keyIndex(3, 6); +constexpr byte R3C7 = keyIndex(3, 7); + +constexpr byte R0C8 = keyIndex(0, 8); +constexpr byte R0C9 = keyIndex(0, 9); +constexpr byte R0C10 = keyIndex(0, 10); +constexpr byte R0C11 = keyIndex(0, 11); +constexpr byte R0C12 = keyIndex(0, 12); +constexpr byte R0C13 = keyIndex(0, 13); +constexpr byte R0C14 = keyIndex(0, 15); +constexpr byte R0C15 = keyIndex(0, 16); +constexpr byte R1C8 = keyIndex(1, 8); +constexpr byte R1C9 = keyIndex(1, 9); +constexpr byte R1C10 = keyIndex(1, 10); +constexpr byte R1C11 = keyIndex(1, 11); +constexpr byte R1C12 = keyIndex(1, 12); +constexpr byte R1C13 = keyIndex(1, 13); +constexpr byte R1C14 = keyIndex(1, 14); +constexpr byte R1C15 = keyIndex(1, 15); +constexpr byte R2C8 = keyIndex(2, 8); +constexpr byte R2C9 = keyIndex(2, 9); +constexpr byte R2C10 = keyIndex(2, 10); +constexpr byte R2C11 = keyIndex(2, 11); +constexpr byte R2C12 = keyIndex(2, 12); +constexpr byte R2C13 = keyIndex(2, 13); +constexpr byte R2C14 = keyIndex(2, 14); +constexpr byte R2C15 = keyIndex(2, 15); +constexpr byte R3C8 = keyIndex(3, 8); +constexpr byte R3C9 = keyIndex(3, 9); +constexpr byte R3C10 = keyIndex(3, 10); +constexpr byte R3C11 = keyIndex(3, 11); +constexpr byte R3C12 = keyIndex(3, 12); +constexpr byte R3C13 = keyIndex(3, 13); +constexpr byte R3C14 = keyIndex(3, 14); +constexpr byte R3C15 = keyIndex(3, 15); + + +#define LED_COUNT 64 + + +#define LED_PGDN 0 +#define LED_PGUP 1 +#define LED_BACKTICK 2 +#define LED_PROG 3 +#define LED_1 4 +#define LED_Q 5 +#define LED_A 6 +#define LED_Z 7 +#define LED_X 8 +#define LED_S 9 +#define LED_W 10 +#define LED_2 11 +#define LED_3 12 +#define LED_E 13 +#define LED_D 14 +#define LED_C 15 +#define LED_V 16 +#define LED_F 17 +#define LED_R 18 +#define LED_4 19 +#define LED_5 20 +#define LED_T 21 +#define LED_G 22 +#define LED_B 23 +#define LED_ESC 24 +#define LED_TAB 25 +#define LED_LED 26 +#define LED_L_CTRL 27 +#define LED_BKSP 28 +#define LED_CMD 29 +#define LED_L_SHIFT 30 +#define LED_L_FN 31 +#define LED_R_FN 32 +#define LED_R_SHIFT 33 +#define LED_ALT 34 +#define LED_SPACE 35 +#define LED_R_CTRL 36 +#define LED_ANY 37 +#define LED_RETURN 38 +#define LED_BUTTERFLY 39 +#define LED_N 40 +#define LED_H 41 +#define LED_Y 42 +#define LED_6 43 +#define LED_7 44 +#define LED_U 45 +#define LED_J 46 +#define LED_M 47 +#define LED_COMMA 48 +#define LED_K 49 +#define LED_I 50 +#define LED_8 51 +#define LED_9 52 +#define LED_O 53 +#define LED_L 54 +#define LED_PERIOD 55 +#define LED_SLASH 56 +#define LED_SEMICOLON 57 +#define LED_P 58 +#define LED_0 59 +#define LED_NUM 60 +#define LED_EQUALS 61 +#define LED_APOSTROPHE 62 +#define LED_MINUS 63 + +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + +#define KEYMAP_STACKED( \ + r0c0, r0c1, r0c2, r0c3, r0c4, r0c5, r0c6, \ + r1c0, r1c1, r1c2, r1c3, r1c4, r1c5, r1c6, \ + r2c0, r2c1, r2c2, r2c3, r2c4, r2c5, \ + r3c0, r3c1, r3c2, r3c3, r3c4, r3c5, r2c6, \ + r0c7, r1c7, r2c7, r3c7, \ + r3c6, \ + \ + r0c9, r0c10, r0c11, r0c12, r0c13, r0c14, r0c15, \ + r1c9, r1c10, r1c11, r1c12, r1c13, r1c14, r1c15, \ + r2c10, r2c11, r2c12, r2c13, r2c14, r2c15, \ + r2c9, r3c10, r3c11, r3c12, r3c13, r3c14, r3c15, \ + r3c8, r2c8, r1c8, r0c8, \ + r3c9, ...) \ + { \ + {r0c0, r0c1, r0c2, r0c3, r0c4, r0c5, r0c6, r0c7, r0c8, r0c9, r0c10, r0c11, r0c12, r0c13, r0c14, r0c15}, \ + {r1c0, r1c1, r1c2, r1c3, r1c4, r1c5, r1c6, r1c7, r1c8, r1c9, r1c10, r1c11, r1c12, r1c13, r1c14, r1c15}, \ + {r2c0, r2c1, r2c2, r2c3, r2c4, r2c5, r2c6, r2c7, r2c8, r2c9, r2c10, r2c11, r2c12, r2c13, r2c14, r2c15}, \ + {r3c0, r3c1, r3c2, r3c3, r3c4, r3c5, r3c6, r3c7, r3c8, r3c9, r3c10, r3c11, r3c12, r3c13, r3c14, RESTRICT_ARGS_COUNT((r3c15), 64, KEYMAP_STACKED, ##__VA_ARGS__)}, \ + } + +#define KEYMAP( \ + r0c0, r0c1, r0c2, r0c3, r0c4, r0c5, r0c6, r0c9, r0c10, r0c11, r0c12, r0c13, r0c14, r0c15, \ + r1c0, r1c1, r1c2, r1c3, r1c4, r1c5, r1c6, r1c9, r1c10, r1c11, r1c12, r1c13, r1c14, r1c15, \ + r2c0, r2c1, r2c2, r2c3, r2c4, r2c5, r2c10, r2c11, r2c12, r2c13, r2c14, r2c15, \ + r3c0, r3c1, r3c2, r3c3, r3c4, r3c5, r2c6, r2c9, r3c10, r3c11, r3c12, r3c13, r3c14, r3c15, \ + r0c7, r1c7, r2c7, r3c7, r3c8, r2c8, r1c8, r0c8, \ + r3c6, r3c9, ...) \ + { \ + {r0c0, r0c1, r0c2, r0c3, r0c4, r0c5, r0c6, r0c7, r0c8, r0c9, r0c10, r0c11, r0c12, r0c13, r0c14, r0c15}, \ + {r1c0, r1c1, r1c2, r1c3, r1c4, r1c5, r1c6, r1c7, r1c8, r1c9, r1c10, r1c11, r1c12, r1c13, r1c14, r1c15}, \ + {r2c0, r2c1, r2c2, r2c3, r2c4, r2c5, r2c6, r2c7, r2c8, r2c9, r2c10, r2c11, r2c12, r2c13, r2c14, r2c15}, \ + {r3c0, r3c1, r3c2, r3c3, r3c4, r3c5, r3c6, r3c7, r3c8, r3c9, r3c10, r3c11, r3c12, r3c13, r3c14, RESTRICT_ARGS_COUNT((r3c15), 64, KEYMAP, ##__VA_ARGS__)}, \ + }