]> git.friedersdorff.com Git - max/tmk_keyboard.git/blob - converter/xt_usb/matrix.c
xt_usb: Fix comment of scancode
[max/tmk_keyboard.git] / converter / xt_usb / matrix.c
1 /*
2 Copyright 2011 Jun Wako <wakojun@gmail.com>
3 Copyright 2016 Ethan Apodaca <papodaca@gmail.com>
4
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, either version 2 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program.  If not, see <http://www.gnu.org/licenses/>.
17 */
18
19 #include <stdint.h>
20 #include <stdbool.h>
21 #include "action.h"
22 #include "print.h"
23 #include "util.h"
24 #include "debug.h"
25 #include "xt.h"
26 #include "matrix.h"
27
28
29 static void matrix_make(uint8_t code);
30 static void matrix_break(uint8_t code);
31
32 static uint8_t matrix[MATRIX_ROWS];
33 #define ROW(code)      (code>>3)
34 #define COL(code)      (code&0x07)
35
36
37 void matrix_init(void)
38 {
39     debug_enable = true;
40     xt_host_init();
41
42     // initialize matrix state: all keys off
43     for (uint8_t i=0; i < MATRIX_ROWS; i++) matrix[i] = 0x00;
44
45     return;
46 }
47
48 // convert E0-escaped codes into unused area
49 static uint8_t move_e0code(uint8_t code) {
50     switch(code) {
51         // Original IBM XT keyboard doesn't use E0-codes probably
52         // Some XT compatilble keyobards need these keys?
53         // http://download.microsoft.com/download/1/6/1/161ba512-40e2-4cc9-843a-923143f3456c/translate.pdf
54         // https://download.microsoft.com/download/1/6/1/161ba512-40e2-4cc9-843a-923143f3456c/scancode.doc
55         case 0x37: return 0x54; // Print Screen
56         case 0x46: return 0x55; // Ctrl + Pause
57         case 0x1C: return 0x6F; // Keypad Enter
58         case 0x35: return 0x7F; // Keypad /
59         case 0x5B: return 0x5A; // Left  GUI
60         case 0x5C: return 0x5B; // Right GUI
61         case 0x5D: return 0x5C; // Application
62         case 0x5E: return 0x5D; // Power(not used)
63         case 0x5F: return 0x5E; // Sleep(not used)
64         case 0x63: return 0x5F; // Wake (not used)
65         case 0x48: return 0x60; // Up
66         case 0x4B: return 0x61; // Left
67         case 0x50: return 0x62; // Down
68         case 0x4D: return 0x63; // Right
69         case 0x52: return 0x71; // Insert
70         case 0x53: return 0x72; // Delete
71         case 0x47: return 0x74; // Home
72         case 0x4F: return 0x75; // End
73         case 0x49: return 0x77; // Home
74         case 0x51: return 0x78; // End
75         case 0x1D: return 0x7A; // Right Ctrl
76         case 0x38: return 0x7C; // Right Alt
77     }
78     return 0x00;
79 }
80
81 uint8_t matrix_scan(void)
82 {
83     static enum {
84         INIT,
85         E0,
86         // Pause: E1 1D 45, E1 9D C5
87         E1,
88         E1_1D,
89         E1_9D,
90     } state = INIT;
91
92     uint8_t code = xt_host_recv();
93     if (!code) return 0;
94     dprintf("%02X ", code);
95     switch (state) {
96         case INIT:
97             switch (code) {
98                 case 0xE0:
99                     state = E0;
100                     break;
101                 case 0xE1:
102                     state = E1;
103                     break;
104                 default:
105                     if (code < 0x80)
106                         matrix_make(code);
107                     else
108                         matrix_break(code & 0x7F);
109                     break;
110             }
111             break;
112         case E0:
113             switch (code) {
114                 case 0x2A:
115                 case 0xAA:
116                 case 0x36:
117                 case 0xB6:
118                     //ignore fake shift
119                     state = INIT;
120                     break;
121                 default:
122                     if (code < 0x80)
123                         matrix_make(move_e0code(code));
124                     else
125                         matrix_break(move_e0code(code & 0x7F));
126                     state = INIT;
127                     break;
128             }
129             break;
130         case E1:
131             switch (code) {
132                 case 0x1D:
133                     state = E1_1D;
134                     break;
135                 case 0x9D:
136                     state = E1_9D;
137                     break;
138                 default:
139                     state = INIT;
140                     break;
141             }
142             break;
143         case E1_1D:
144             switch (code) {
145                 case 0x45:
146                     matrix_make(0x55);
147                     break;
148                 default:
149                     state = INIT;
150                     break;
151             }
152             break;
153         case E1_9D:
154             switch (code) {
155                 case 0x45:
156                     matrix_break(0x55);
157                     break;
158                 default:
159                     state = INIT;
160                     break;
161             }
162             break;
163         default:
164             state = INIT;
165     }
166     return 1;
167 }
168
169 inline
170 uint8_t matrix_get_row(uint8_t row)
171 {
172     return matrix[row];
173 }
174
175 inline
176 static void matrix_make(uint8_t code)
177 {
178     if (!matrix_is_on(ROW(code), COL(code))) {
179         matrix[ROW(code)] |= 1<<COL(code);
180     }
181 }
182
183 inline
184 static void matrix_break(uint8_t code)
185 {
186     if (matrix_is_on(ROW(code), COL(code))) {
187         matrix[ROW(code)] &= ~(1<<COL(code));
188     }
189 }
190
191 void matrix_clear(void)
192 {
193     for (uint8_t i=0; i < MATRIX_ROWS; i++) matrix[i] = 0x00;
194 }
195
196 /*
197 XT Scancodes
198 ============
199 - http://download.microsoft.com/download/1/6/1/161ba512-40e2-4cc9-843a-923143f3456c/translate.pdf
200 - https://download.microsoft.com/download/1/6/1/161ba512-40e2-4cc9-843a-923143f3456c/scancode.doc
201
202 01-53: Normal codes used in original XT keyboard
203 54-7F: Not used in original XT keyboard
204
205         0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
206     50  -   -   -   -   *   *   x   x   x   x   *   *   *   o   o   o
207     60  *   *   *   *   x   x   x   x   x   x   x   x   x   x   x   *
208     70  x   *   *   x   *   *   x   *   *   x   *   x   *   x   x   *
209
210 -: codes existed in original XT keyboard
211 *: E0-escaped codes converted into unused code area(internal use in TMK)
212 x: Non-espcaped codes(not used in real keyboards probably, for CodeSet2-CodeSet1 translation purpose)
213 o: reserved
214
215 Usage in TMK:
216
217     00  (reserved) DO NOT USE
218     54  PrintScr*
219     55  Pause*
220     56  Euro2
221     57  F11
222     58  F12
223     59  Keypad =
224     5A  LGUI*
225     5B  RGUI*
226     5C  APP*
227     5D  (reserved)
228     5E  (reserved)
229     5F  (reserved)
230     60  cursor*
231     61  cursor*
232     62  cursor*
233     63  cursor*
234     64  F13
235     65  F14
236     66  F15
237     67  F16
238     68  F17
239     69  F18
240     6A  F19
241     6B  F20
242     6C  F21
243     6D  F22
244     6E  F23
245     6F  Keypad Enter*
246     70  KANA
247     71  nav*
248     72  nav*
249     73  RO
250     74  nav*
251     75  nav*
252     76  F24
253     77  nav*
254     78  nav*
255     79  HENKAN
256     7A  RCTL*
257     7B  MUHENKAN
258     7C  RALT*
259     7D  JPY
260     7E  Keypad ,
261     7F  Keypad / *
262
263 */