tmk_core/common/action_code.h

   1 /*
   2 Copyright 2013 Jun Wako <wakojun@gmail.com>
   3
   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.
   8
   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.
  13
  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 */
  17 #ifndef ACTION_CODE_H
  18 #define ACTION_CODE_H
  19
  20 /** \brief Action codes
  21  *
  22  * 16bit code: action_kind(4bit) + action_parameter(12bit)
  23  *
  24  * Key Actions(00xx)
  25  * -----------------
  26  * ACT_MODS(000r):
  27  * 000r|0000|0000 0000    No action code
  28  * 000r|0000|0000 0001    Transparent code
  29  * 000r|0000| keycode     Key
  30  * 000r|mods|0000 0000    Modifiers
  31  * 000r|mods| keycode     Modifiers+Key(Modified key)
  32  *   r: Left/Right flag(Left:0, Right:1)
  33  *
  34  * ACT_MODS_TAP(001r):
  35  * 001r|mods|0000 0000    Modifiers with OneShot
  36  * 001r|mods|0000 0001    Modifiers with tap toggle
  37  * 001r|mods|0000 00xx    (reserved)
  38  * 001r|mods| keycode     Modifiers with Tap Key(Dual role)
  39  *
  40  * Other Keys(01xx)
  41  * ----------------
  42  * ACT_USAGE(0100): TODO: Not needed?
  43  * 0100|00| usage(10)     System control(0x80) - General Desktop page(0x01)
  44  * 0100|01| usage(10)     Consumer control(0x01) - Consumer page(0x0C)
  45  * 0100|10| usage(10)     (reserved)
  46  * 0100|11| usage(10)     (reserved)
  47  *
  48  * ACT_MOUSEKEY(0101): TODO: Merge these two actions to conserve space?
  49  * 0101|xxxx| keycode     Mouse key
  50  *
  51  * ACT_SWAP_HANDS(0110):
  52  * 0110|xxxx| keycode     Swap hands (keycode on tap, or options)
  53  *
  54  * 0111|xxxx xxxx xxxx    (reserved)
  55  *
  56  * Layer Actions(10xx)
  57  * -------------------
  58  * ACT_LAYER(1000):
  59  * 1000|oo00|pppE BBBB   Default Layer Bitwise operation
  60  *   oo:    operation(00:AND, 01:OR, 10:XOR, 11:SET)
  61  *   ppp:   4-bit chunk part(0-7)
  62  *   EBBBB: bits and extra bit
  63  * 1000|ooee|pppE BBBB   Layer Bitwise Operation
  64  *   oo:    operation(00:AND, 01:OR, 10:XOR, 11:SET)
  65  *   ppp:   4-bit chunk part(0-7)
  66  *   EBBBB: bits and extra bit
  67  *   ee:    on event(01:press, 10:release, 11:both)
  68  *
  69  * ACT_LAYER_MODS(1001):
  70  * 1001|LLLL| mods       Layer with modifiers held
  71  *
  72  * ACT_LAYER_TAP(101x):
  73  * 101E|LLLL| keycode    On/Off with tap key    (0x00-DF)[TAP]
  74  * 101E|LLLL|1110 mods   On/Off with modifiers  (0xE0-EF)[NOT TAP]
  75  * 101E|LLLL|1111 0000   Invert with tap toggle (0xF0)   [TAP]
  76  * 101E|LLLL|1111 0001   On/Off                 (0xF1)   [NOT TAP]
  77  * 101E|LLLL|1111 0010   Off/On                 (0xF2)   [NOT TAP]
  78  * 101E|LLLL|1111 0011   Set/Clear              (0xF3)   [NOT TAP]
  79  * 101E|LLLL|1111 0100   One Shot Layer         (0xF4)   [TAP]
  80  * 101E|LLLL|1111 xxxx   Reserved               (0xF5-FF)
  81  *   ELLLL: layer 0-31(E: extra bit for layer 16-31)
  82  *
  83  * Extensions(11xx)
  84  * ----------------
  85  * ACT_MACRO(1100):
  86  * 1100|opt | id(8)      Macro play?
  87  * 1100|1111| id(8)      Macro record?
  88  *
  89  * 1101|xxxx xxxx xxxx   (reserved)
  90  *
  91  * ACT_COMMAND(1110):
  92  * 1110|opt | id(8)      Built-in Command exec
  93  *
  94  * ACT_FUNCTION(1111):
  95  * 1111| address(12)     Function?
  96  * 1111|opt | id(8)      Function?
  97  */
  98 enum action_kind_id {
  99     /* Key Actions */
 100     ACT_MODS      = 0b0000,
 101     ACT_LMODS     = 0b0000,
 102     ACT_RMODS     = 0b0001,
 103     ACT_MODS_TAP  = 0b0010,
 104     ACT_LMODS_TAP = 0b0010,
 105     ACT_RMODS_TAP = 0b0011,
 106     /* Other Keys */
 107     ACT_USAGE    = 0b0100,
 108     ACT_MOUSEKEY = 0b0101,
 109     /* One-hand Support */
 110     ACT_SWAP_HANDS = 0b0110,
 111     /* Layer Actions */
 112     ACT_LAYER         = 0b1000,
 113     ACT_LAYER_MODS    = 0b1001,
 114     ACT_LAYER_TAP     = 0b1010, /* Layer  0-15 */
 115     ACT_LAYER_TAP_EXT = 0b1011, /* Layer 16-31 */
 116     /* Extensions */
 117     ACT_MACRO    = 0b1100,
 118     ACT_COMMAND  = 0b1110,
 119     ACT_FUNCTION = 0b1111
 120 };
 121
 122 /** \brief Action Code Struct
 123  *
 124  * NOTE:
 125  * In avr-gcc bit field seems to be assigned from LSB(bit0) to MSB(bit15).
 126  * AVR looks like a little endian in avr-gcc.
 127  * Not portable across compiler/endianness?
 128  *
 129  * Byte order and bit order of 0x1234:
 130  *   Big endian:                Little endian:
 131  *   --------------------       --------------------
 132  *   FEDC BA98  7654 3210       0123 4567  89AB CDEF
 133  *   0001 0010  0011 0100       0010 1100  0100 1000
 134  *     0x12       0x34            0x34       0x12
 135  */
 136 typedef union {
 137     uint16_t code;
 138     struct action_kind {
 139         uint16_t param : 12;
 140         uint8_t  id : 4;
 141     } kind;
 142     struct action_key {
 143         uint8_t code : 8;
 144         uint8_t mods : 4;
 145         uint8_t kind : 4;
 146     } key;
 147     struct action_layer_bitop {
 148         uint8_t bits : 4;
 149         uint8_t xbit : 1;
 150         uint8_t part : 3;
 151         uint8_t on : 2;
 152         uint8_t op : 2;
 153         uint8_t kind : 4;
 154     } layer_bitop;
 155     struct action_layer_mods {
 156         uint8_t mods : 8;
 157         uint8_t layer : 4;
 158         uint8_t kind : 4;
 159     } layer_mods;
 160     struct action_layer_tap {
 161         uint8_t code : 8;
 162         uint8_t val : 5;
 163         uint8_t kind : 3;
 164     } layer_tap;
 165     struct action_usage {
 166         uint16_t code : 10;
 167         uint8_t  page : 2;
 168         uint8_t  kind : 4;
 169     } usage;
 170     struct action_command {
 171         uint8_t id : 8;
 172         uint8_t opt : 4;
 173         uint8_t kind : 4;
 174     } command;
 175     struct action_function {
 176         uint8_t id : 8;
 177         uint8_t opt : 4;
 178         uint8_t kind : 4;
 179     } func;
 180     struct action_swap {
 181         uint8_t code : 8;
 182         uint8_t opt : 4;
 183         uint8_t kind : 4;
 184     } swap;
 185 } action_t;
 186
 187 /* action utility */
 188 #define ACTION_NO 0
 189 #define ACTION_TRANSPARENT 1
 190 #define ACTION(kind, param) ((kind) << 12 | (param))
 191
 192 /** \brief Key Actions
 193  *
 194  * Mod bits:    43210
 195  *   bit 0      ||||+- Control
 196  *   bit 1      |||+-- Shift
 197  *   bit 2      ||+--- Alt
 198  *   bit 3      |+---- Gui
 199  *   bit 4      +----- LR flag(Left:0, Right:1)
 200  */
 201 enum mods_bit {
 202     MOD_LCTL = 0x01,
 203     MOD_LSFT = 0x02,
 204     MOD_LALT = 0x04,
 205     MOD_LGUI = 0x08,
 206     MOD_RCTL = 0x11,
 207     MOD_RSFT = 0x12,
 208     MOD_RALT = 0x14,
 209     MOD_RGUI = 0x18,
 210 };
 211 enum mods_codes {
 212     MODS_ONESHOT    = 0x00,
 213     MODS_TAP_TOGGLE = 0x01,
 214 };
 215 #define ACTION_KEY(key) ACTION(ACT_MODS, (key))
 216 #define ACTION_MODS(mods) ACTION(ACT_MODS, ((mods)&0x1f) << 8 | 0)
 217 #define ACTION_MODS_KEY(mods, key) ACTION(ACT_MODS, ((mods)&0x1f) << 8 | (key))
 218 #define ACTION_MODS_TAP_KEY(mods, key) ACTION(ACT_MODS_TAP, ((mods)&0x1f) << 8 | (key))
 219 #define ACTION_MODS_ONESHOT(mods) ACTION(ACT_MODS_TAP, ((mods)&0x1f) << 8 | MODS_ONESHOT)
 220 #define ACTION_MODS_TAP_TOGGLE(mods) ACTION(ACT_MODS_TAP, ((mods)&0x1f) << 8 | MODS_TAP_TOGGLE)
 221
 222 /** \brief Other Keys
 223  */
 224 enum usage_pages { PAGE_SYSTEM, PAGE_CONSUMER };
 225 #define ACTION_USAGE_SYSTEM(id) ACTION(ACT_USAGE, PAGE_SYSTEM << 10 | (id))
 226 #define ACTION_USAGE_CONSUMER(id) ACTION(ACT_USAGE, PAGE_CONSUMER << 10 | (id))
 227 #define ACTION_MOUSEKEY(key) ACTION(ACT_MOUSEKEY, key)
 228
 229 /** \brief Layer Actions
 230  */
 231 enum layer_param_on {
 232     ON_PRESS   = 1,
 233     ON_RELEASE = 2,
 234     ON_BOTH    = 3,
 235 };
 236
 237 /** \brief Layer Actions
 238  */
 239 enum layer_param_bit_op {
 240     OP_BIT_AND = 0,
 241     OP_BIT_OR  = 1,
 242     OP_BIT_XOR = 2,
 243     OP_BIT_SET = 3,
 244 };
 245
 246 /** \brief Layer Actions
 247  */
 248 enum layer_param_tap_op {
 249     OP_TAP_TOGGLE = 0xF0,
 250     OP_ON_OFF,
 251     OP_OFF_ON,
 252     OP_SET_CLEAR,
 253     OP_ONESHOT,
 254 };
 255 #define ACTION_LAYER_BITOP(op, part, bits, on) ACTION(ACT_LAYER, (op) << 10 | (on) << 8 | (part) << 5 | ((bits)&0x1f))
 256 #define ACTION_LAYER_TAP(layer, key) ACTION(ACT_LAYER_TAP, (layer) << 8 | (key))
 257 /* Default Layer */
 258 #define ACTION_DEFAULT_LAYER_SET(layer) ACTION_DEFAULT_LAYER_BIT_SET((layer) / 4, 1 << ((layer) % 4))
 259 /* Layer Operation */
 260 #define ACTION_LAYER_CLEAR(on) ACTION_LAYER_BIT_AND(0, 0, (on))
 261 #define ACTION_LAYER_MOMENTARY(layer) ACTION_LAYER_ON_OFF(layer)
 262 #define ACTION_LAYER_TOGGLE(layer) ACTION_LAYER_INVERT(layer, ON_RELEASE)
 263 #define ACTION_LAYER_INVERT(layer, on) ACTION_LAYER_BIT_XOR((layer) / 4, 1 << ((layer) % 4), (on))
 264 #define ACTION_LAYER_ON(layer, on) ACTION_LAYER_BIT_OR((layer) / 4, 1 << ((layer) % 4), (on))
 265 #define ACTION_LAYER_OFF(layer, on) ACTION_LAYER_BIT_AND((layer) / 4, ~(1 << ((layer) % 4)), (on))
 266 #define ACTION_LAYER_SET(layer, on) ACTION_LAYER_BIT_SET((layer) / 4, 1 << ((layer) % 4), (on))
 267 #define ACTION_LAYER_ON_OFF(layer) ACTION_LAYER_TAP((layer), OP_ON_OFF)
 268 #define ACTION_LAYER_OFF_ON(layer) ACTION_LAYER_TAP((layer), OP_OFF_ON)
 269 #define ACTION_LAYER_SET_CLEAR(layer) ACTION_LAYER_TAP((layer), OP_SET_CLEAR)
 270 #define ACTION_LAYER_ONESHOT(layer) ACTION_LAYER_TAP((layer), OP_ONESHOT)
 271 #define ACTION_LAYER_MODS(layer, mods) ACTION(ACT_LAYER_MODS, (layer) << 8 | (mods))
 272 /* With Tapping */
 273 #define ACTION_LAYER_TAP_KEY(layer, key) ACTION_LAYER_TAP((layer), (key))
 274 #define ACTION_LAYER_TAP_TOGGLE(layer) ACTION_LAYER_TAP((layer), OP_TAP_TOGGLE)
 275 /* Bitwise Operation */
 276 #define ACTION_LAYER_BIT_AND(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_AND, (part), (bits), (on))
 277 #define ACTION_LAYER_BIT_OR(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_OR, (part), (bits), (on))
 278 #define ACTION_LAYER_BIT_XOR(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_XOR, (part), (bits), (on))
 279 #define ACTION_LAYER_BIT_SET(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_SET, (part), (bits), (on))
 280 /* Default Layer Bitwise Operation */
 281 #define ACTION_DEFAULT_LAYER_BIT_AND(part, bits) ACTION_LAYER_BITOP(OP_BIT_AND, (part), (bits), 0)
 282 #define ACTION_DEFAULT_LAYER_BIT_OR(part, bits) ACTION_LAYER_BITOP(OP_BIT_OR, (part), (bits), 0)
 283 #define ACTION_DEFAULT_LAYER_BIT_XOR(part, bits) ACTION_LAYER_BITOP(OP_BIT_XOR, (part), (bits), 0)
 284 #define ACTION_DEFAULT_LAYER_BIT_SET(part, bits) ACTION_LAYER_BITOP(OP_BIT_SET, (part), (bits), 0)
 285
 286 /* Macro */
 287 #define ACTION_MACRO(id) ACTION(ACT_MACRO, (id))
 288 #define ACTION_MACRO_TAP(id) ACTION(ACT_MACRO, FUNC_TAP << 8 | (id))
 289 #define ACTION_MACRO_OPT(id, opt) ACTION(ACT_MACRO, (opt) << 8 | (id))
 290 /* Command */
 291 #define ACTION_COMMAND(id, opt) ACTION(ACT_COMMAND, (opt) << 8 | (id))
 292 /* Function */
 293 enum function_opts {
 294     FUNC_TAP = 0x8, /* indciates function is tappable */
 295 };
 296 #define ACTION_FUNCTION(id) ACTION(ACT_FUNCTION, (id))
 297 #define ACTION_FUNCTION_TAP(id) ACTION(ACT_FUNCTION, FUNC_TAP << 8 | (id))
 298 #define ACTION_FUNCTION_OPT(id, opt) ACTION(ACT_FUNCTION, (opt) << 8 | (id))
 299 /* OneHand Support */
 300 enum swap_hands_param_tap_op {
 301     OP_SH_TOGGLE = 0xF0,
 302     OP_SH_TAP_TOGGLE,
 303     OP_SH_ON_OFF,
 304     OP_SH_OFF_ON,
 305     OP_SH_OFF,
 306     OP_SH_ON,
 307 };
 308
 309 #define ACTION_SWAP_HANDS() ACTION_SWAP_HANDS_ON_OFF()
 310 #define ACTION_SWAP_HANDS_TOGGLE() ACTION(ACT_SWAP_HANDS, OP_SH_TOGGLE)
 311 #define ACTION_SWAP_HANDS_TAP_TOGGLE() ACTION(ACT_SWAP_HANDS, OP_SH_TAP_TOGGLE)
 312 #define ACTION_SWAP_HANDS_TAP_KEY(key) ACTION(ACT_SWAP_HANDS, key)
 313 #define ACTION_SWAP_HANDS_ON_OFF() ACTION(ACT_SWAP_HANDS, OP_SH_ON_OFF)
 314 #define ACTION_SWAP_HANDS_OFF_ON() ACTION(ACT_SWAP_HANDS, OP_SH_OFF_ON)
 315 #define ACTION_SWAP_HANDS_ON() ACTION(ACT_SWAP_HANDS, OP_SH_ON)
 316 #define ACTION_SWAP_HANDS_OFF() ACTION(ACT_SWAP_HANDS, OP_SH_OFF)
 317
 318 #endif /* ACTION_CODE_H */