converter/adb_usb/matrix.c

   1 /*
   2 Copyright 2011 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
  18 /*
  19  * scan matrix
  20  */
  21 #include <stdint.h>
  22 #include <stdbool.h>
  23 #include <avr/io.h>
  24 #include <util/delay.h>
  25 #include "print.h"
  26 #include "util.h"
  27 #include "debug.h"
  28 #include "host.h"
  29 #include "led.h"
  30 #include "adb.h"
  31 #include "matrix.h"
  32
  33
  34 #if (MATRIX_COLS > 16)
  35 #   error "MATRIX_COLS must not exceed 16"
  36 #endif
  37 #if (MATRIX_ROWS > 255)
  38 #   error "MATRIX_ROWS must not exceed 255"
  39 #endif
  40
  41 #define CAPS        0x39
  42 #define CAPS_UP     (CAPS | 0x80)
  43 #define ROW(key)    ((key)>>3&0x0F)
  44 #define COL(key)    ((key)&0x07)
  45
  46
  47 static bool _matrix_is_modified = false;
  48
  49 // matrix state buffer(1:on, 0:off)
  50 #if (MATRIX_COLS <= 8)
  51 static uint8_t *matrix;
  52 static uint8_t _matrix0[MATRIX_ROWS];
  53 #else
  54 static uint16_t *matrix;
  55 static uint16_t _matrix0[MATRIX_ROWS];
  56 #endif
  57
  58 #ifdef MATRIX_HAS_GHOST
  59 static bool matrix_has_ghost_in_row(uint8_t row);
  60 #endif
  61 static void _register_key(uint8_t key);
  62
  63
  64 inline
  65 uint8_t matrix_rows(void)
  66 {
  67     return MATRIX_ROWS;
  68 }
  69
  70 inline
  71 uint8_t matrix_cols(void)
  72 {
  73     return MATRIX_COLS;
  74 }
  75
  76 void matrix_init(void)
  77 {
  78     adb_host_init();
  79
  80     // initialize matrix state: all keys off
  81     for (uint8_t i=0; i < MATRIX_ROWS; i++) _matrix0[i] = 0x00;
  82     matrix = _matrix0;
  83
  84     print_enable = true;
  85     debug_enable = true;
  86     debug_matrix = true;
  87     debug_keyboard = true;
  88     debug_mouse = true;
  89     print("debug enabled.\n");
  90     return;
  91 }
  92
  93 uint8_t matrix_scan(void)
  94 {
  95     uint16_t codes;
  96     uint8_t key0, key1;
  97
  98     _matrix_is_modified = false;
  99     codes = adb_host_kbd_recv();
 100     key0 = codes>>8;
 101     key1 = codes&0xFF;
 102
 103     if (debug_enable && codes) {
 104         print("adb_host_kbd_recv: "); phex16(codes); print("\n");
 105     }
 106
 107 #ifdef MATRIX_HAS_LOCKING_CAPS
 108     // Send Caps key up event
 109     if (matrix_is_on(ROW(CAPS), COL(CAPS))) {
 110         _matrix_is_modified = true;
 111         _register_key(CAPS_UP);
 112     }
 113 #endif
 114     if (codes == 0) {                           // no keys
 115         return 0;
 116     } else if (key0 == 0xFF && key1 != 0xFF) {  // error
 117         return codes&0xFF;
 118     } else {
 119 #ifdef MATRIX_HAS_LOCKING_CAPS
 120         if (host_keyboard_leds() & (1<<USB_LED_CAPS_LOCK)) {
 121             // Ignore LockingCaps key down event when CAPS LOCK is on
 122             if (key0 == CAPS && (key1 == CAPS || key1 == 0xFF)) return 0;
 123             if (key0 == CAPS) key0 = key1;
 124             if (key1 == CAPS) key1 = 0xFF;
 125             // Convert LockingCaps key up event into down event
 126             if (key0 == CAPS_UP) key0 = CAPS;
 127             if (key1 == CAPS_UP) key1 = CAPS;
 128         } else {
 129             // CAPS LOCK off:
 130             // Ignore LockingCaps key up event when CAPS LOCK is off
 131             if (key0 == CAPS_UP && (key1 == CAPS_UP || key1 == 0xFF)) return 0;
 132             if (key0 == CAPS_UP) key0 = key1;
 133             if (key1 == CAPS_UP) key1 = 0xFF;
 134         }
 135 #endif
 136         _matrix_is_modified = true;
 137         _register_key(key0);
 138         if (key1 != 0xFF)       // key1 is 0xFF when no second key.
 139             _register_key(key1);
 140     }
 141
 142     return 1;
 143 }
 144
 145 bool matrix_is_modified(void)
 146 {
 147     return _matrix_is_modified;
 148 }
 149
 150 inline
 151 bool matrix_has_ghost(void)
 152 {
 153 #ifdef MATRIX_HAS_GHOST
 154     for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 155         if (matrix_has_ghost_in_row(i))
 156             return true;
 157     }
 158 #endif
 159     return false;
 160 }
 161
 162 inline
 163 bool matrix_is_on(uint8_t row, uint8_t col)
 164 {
 165     return (matrix[row] & (1<<col));
 166 }
 167
 168 inline
 169 #if (MATRIX_COLS <= 8)
 170 uint8_t matrix_get_row(uint8_t row)
 171 #else
 172 uint16_t matrix_get_row(uint8_t row)
 173 #endif
 174 {
 175     return matrix[row];
 176 }
 177
 178 void matrix_print(void)
 179 {
 180 #if (MATRIX_COLS <= 8)
 181     print("r/c 01234567\n");
 182 #else
 183     print("r/c 0123456789ABCDEF\n");
 184 #endif
 185     for (uint8_t row = 0; row < matrix_rows(); row++) {
 186         phex(row); print(": ");
 187 #if (MATRIX_COLS <= 8)
 188         pbin_reverse(matrix_get_row(row));
 189 #else
 190         pbin_reverse16(matrix_get_row(row));
 191 #endif
 192 #ifdef MATRIX_HAS_GHOST
 193         if (matrix_has_ghost_in_row(row)) {
 194             print(" <ghost");
 195         }
 196 #endif
 197         print("\n");
 198     }
 199 }
 200
 201 uint8_t matrix_key_count(void)
 202 {
 203     uint8_t count = 0;
 204     for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 205 #if (MATRIX_COLS <= 8)
 206         count += bitpop(matrix[i]);
 207 #else
 208         count += bitpop16(matrix[i]);
 209 #endif
 210     }
 211     return count;
 212 }
 213
 214 #ifdef MATRIX_HAS_GHOST
 215 inline
 216 static bool matrix_has_ghost_in_row(uint8_t row)
 217 {
 218     // no ghost exists in case less than 2 keys on
 219     if (((matrix[row] - 1) & matrix[row]) == 0)
 220         return false;
 221
 222     // ghost exists in case same state as other row
 223     for (uint8_t i=0; i < MATRIX_ROWS; i++) {
 224         if (i != row && (matrix[i] & matrix[row]) == matrix[row])
 225             return true;
 226     }
 227     return false;
 228 }
 229 #endif
 230
 231 inline
 232 static void _register_key(uint8_t key)
 233 {
 234     uint8_t col, row;
 235     col = key&0x07;
 236     row = (key>>3)&0x0F;
 237     if (key&0x80) {
 238         matrix[row] &= ~(1<<col);
 239     } else {
 240         matrix[row] |=  (1<<col);
 241     }
 242 }