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 #ifdef MATRIX_HAS_LOCKING_CAPS
 104     // Send Caps key up event
 105     if (matrix_is_on(ROW(CAPS), COL(CAPS))) {
 106         _matrix_is_modified = true;
 107         _register_key(CAPS_UP);
 108     }
 109 #endif
 110     if (codes == 0) {                           // no keys
 111         return 0;
 112     } else if (key0 == 0xFF && key1 != 0xFF) {  // error
 113         return codes&0xFF;
 114     } else {
 115 #ifdef MATRIX_HAS_LOCKING_CAPS
 116         if (host_keyboard_leds() & (1<<USB_LED_CAPS_LOCK)) {
 117             // Ignore LockingCaps key down event when CAPS LOCK is on
 118             if (key0 == CAPS && (key1 == CAPS || key1 == 0xFF)) return 0;
 119             if (key0 == CAPS) key0 = key1;
 120             if (key1 == CAPS) key1 = 0xFF;
 121             // Convert LockingCaps key up event into down event
 122             if (key0 == CAPS_UP) key0 = CAPS;
 123             if (key1 == CAPS_UP) key1 = CAPS;
 124         } else {
 125             // CAPS LOCK off:
 126             // Ignore LockingCaps key up event when CAPS LOCK is off
 127             if (key0 == CAPS_UP && (key1 == CAPS_UP || key1 == 0xFF)) return 0;
 128             if (key0 == CAPS_UP) key0 = key1;
 129             if (key1 == CAPS_UP) key1 = 0xFF;
 130         }
 131 #endif
 132         _matrix_is_modified = true;
 133         _register_key(key0);
 134         if (key1 != 0xFF)       // key1 is 0xFF when no second key.
 135             _register_key(key1);
 136     }
 137
 138     if (debug_enable) {
 139         print("adb_host_kbd_recv: "); phex16(codes); print("\n");
 140     }
 141     return 1;
 142 }
 143
 144 bool matrix_is_modified(void)
 145 {
 146     return _matrix_is_modified;
 147 }
 148
 149 inline
 150 bool matrix_has_ghost(void)
 151 {
 152 #ifdef MATRIX_HAS_GHOST
 153     for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 154         if (matrix_has_ghost_in_row(i))
 155             return true;
 156     }
 157 #endif
 158     return false;
 159 }
 160
 161 inline
 162 bool matrix_is_on(uint8_t row, uint8_t col)
 163 {
 164     return (matrix[row] & (1<<col));
 165 }
 166
 167 inline
 168 #if (MATRIX_COLS <= 8)
 169 uint8_t matrix_get_row(uint8_t row)
 170 #else
 171 uint16_t matrix_get_row(uint8_t row)
 172 #endif
 173 {
 174     return matrix[row];
 175 }
 176
 177 void matrix_print(void)
 178 {
 179 #if (MATRIX_COLS <= 8)
 180     print("\nr/c 01234567\n");
 181 #else
 182     print("\nr/c 0123456789ABCDEF\n");
 183 #endif
 184     for (uint8_t row = 0; row < matrix_rows(); row++) {
 185         phex(row); print(": ");
 186 #if (MATRIX_COLS <= 8)
 187         pbin_reverse(matrix_get_row(row));
 188 #else
 189         pbin_reverse16(matrix_get_row(row));
 190 #endif
 191 #ifdef MATRIX_HAS_GHOST
 192         if (matrix_has_ghost_in_row(row)) {
 193             print(" <ghost");
 194         }
 195 #endif
 196         print("\n");
 197     }
 198 }
 199
 200 uint8_t matrix_key_count(void)
 201 {
 202     uint8_t count = 0;
 203     for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 204 #if (MATRIX_COLS <= 8)
 205         count += bitpop(matrix[i]);
 206 #else
 207         count += bitpop16(matrix[i]);
 208 #endif
 209     }
 210     return count;
 211 }
 212
 213 #ifdef MATRIX_HAS_GHOST
 214 inline
 215 static bool matrix_has_ghost_in_row(uint8_t row)
 216 {
 217     // no ghost exists in case less than 2 keys on
 218     if (((matrix[row] - 1) & matrix[row]) == 0)
 219         return false;
 220
 221     // ghost exists in case same state as other row
 222     for (uint8_t i=0; i < MATRIX_ROWS; i++) {
 223         if (i != row && (matrix[i] & matrix[row]) == matrix[row])
 224             return true;
 225     }
 226     return false;
 227 }
 228 #endif
 229
 230 inline
 231 static void _register_key(uint8_t key)
 232 {
 233     uint8_t col, row;
 234     col = key&0x07;
 235     row = (key>>3)&0x0F;
 236     if (key&0x80) {
 237         matrix[row] &= ~(1<<col);
 238     } else {
 239         matrix[row] |=  (1<<col);
 240     }
 241 }