protocol/m0110.c

   1 /*
   2 Copyright 2011,2012 Jun WAKO <wakojun@gmail.com>
   3
   4 This software is licensed with a Modified BSD License.
   5 All of this is supposed to be Free Software, Open Source, DFSG-free,
   6 GPL-compatible, and OK to use in both free and proprietary applications.
   7 Additions and corrections to this file are welcome.
   8
   9
  10 Redistribution and use in source and binary forms, with or without
  11 modification, are permitted provided that the following conditions are met:
  12
  13 * Redistributions of source code must retain the above copyright
  14   notice, this list of conditions and the following disclaimer.
  15
  16 * Redistributions in binary form must reproduce the above copyright
  17   notice, this list of conditions and the following disclaimer in
  18   the documentation and/or other materials provided with the
  19   distribution.
  20
  21 * Neither the name of the copyright holders nor the names of
  22   contributors may be used to endorse or promote products derived
  23   from this software without specific prior written permission.
  24
  25 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  26 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  29 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  30 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  31 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  32 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  33 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  34 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  35 POSSIBILITY OF SUCH DAMAGE.
  36 */
  37 /* M0110A Support was contributed by skagon@github */
  38
  39 #include <stdbool.h>
  40 #include <avr/io.h>
  41 #include <avr/interrupt.h>
  42 #include <util/delay.h>
  43 #include "m0110.h"
  44 #include "debug.h"
  45
  46
  47 static inline uint8_t raw2scan(uint8_t raw);
  48 static inline uint8_t inquiry(void);
  49 static inline uint8_t instant(void);
  50 static inline void clock_lo(void);
  51 static inline void clock_hi(void);
  52 static inline bool clock_in(void);
  53 static inline void data_lo(void);
  54 static inline void data_hi(void);
  55 static inline bool data_in(void);
  56 static inline uint16_t wait_clock_lo(uint16_t us);
  57 static inline uint16_t wait_clock_hi(uint16_t us);
  58 static inline uint16_t wait_data_lo(uint16_t us);
  59 static inline uint16_t wait_data_hi(uint16_t us);
  60 static inline void idle(void);
  61 static inline void request(void);
  62
  63
  64 #define WAIT_US(stat, us, err) do { \
  65     if (!wait_##stat(us)) { \
  66         m0110_error = err; \
  67         goto ERROR; \
  68     } \
  69 } while (0)
  70
  71 #define WAIT_MS(stat, ms, err) do { \
  72     uint16_t _ms = ms; \
  73     while (_ms) { \
  74         if (wait_##stat(1000)) { \
  75             break; \
  76         } \
  77         _ms--; \
  78     } \
  79     if (_ms == 0) { \
  80         m0110_error = err; \
  81         goto ERROR; \
  82     } \
  83 } while (0)
  84
  85 #define KEY(raw)        ((raw) & 0x7f)
  86 #define IS_BREAK(raw)   (((raw) & 0x80) == 0x80)
  87
  88
  89 uint8_t m0110_error = 0;
  90
  91
  92 void m0110_init(void)
  93 {
  94     idle();
  95     _delay_ms(1000);
  96
  97 /* Not needed to initialize in fact.
  98     uint8_t data;
  99     m0110_send(M0110_MODEL);
 100     data = m0110_recv();
 101     print("m0110_init model: "); phex(data); print("\n");
 102
 103     m0110_send(M0110_TEST);
 104     data = m0110_recv();
 105     print("m0110_init test: "); phex(data); print("\n");
 106 */
 107 }
 108
 109 uint8_t m0110_send(uint8_t data)
 110 {
 111     m0110_error = 0;
 112
 113     request();
 114     WAIT_MS(clock_lo, 250, 1);  // keyboard may block long time
 115     for (uint8_t bit = 0x80; bit; bit >>= 1) {
 116         WAIT_US(clock_lo, 250, 3);
 117         if (data&bit) {
 118             data_hi();
 119         } else {
 120             data_lo();
 121         }
 122         WAIT_US(clock_hi, 200, 4);
 123     }
 124     _delay_us(100); // hold last bit for 80us
 125     idle();
 126     return 1;
 127 ERROR:
 128     print("m0110_send err: "); phex(m0110_error); print("\n");
 129     _delay_ms(500);
 130     idle();
 131     return 0;
 132 }
 133
 134 uint8_t m0110_recv(void)
 135 {
 136     uint8_t data = 0;
 137     m0110_error = 0;
 138
 139     WAIT_MS(clock_lo, 250, 1);  // keyboard may block long time
 140     for (uint8_t i = 0; i < 8; i++) {
 141         data <<= 1;
 142         WAIT_US(clock_lo, 200, 2);
 143         WAIT_US(clock_hi, 200, 3);
 144         if (data_in()) {
 145             data |= 1;
 146         }
 147     }
 148     idle();
 149     return data;
 150 ERROR:
 151     print("m0110_recv err: "); phex(m0110_error); print("\n");
 152     _delay_ms(500);
 153     idle();
 154     return 0xFF;
 155 }
 156
 157 /*
 158 Handling for exceptional case of key combinations for M0110A
 159
 160 Shift and Calc/Arrow key could be operated simultaneously:
 161
 162     Case Shift   Arrow   Events          Interpret
 163     -------------------------------------------------------------------
 164     1    Down    Down    71, 79, DD      Calc(d)*a *b
 165     2    Down    Up      71, 79, UU      Arrow&Calc(u)*a
 166     3    Up      Down    F1, 79, DD      Shift(u) *c
 167     4    Up      Up      F1, 79, UU      Shift(u) and Arrow&Calc(u)*a
 168
 169     Case Shift   Calc    Events          Interpret
 170     -------------------------------------------------------------------
 171     5(1) Down    Down    71, 71, 79, DD  Shift(d) and Cacl(d)
 172     6(2) Down    Up      F1, 71, 79, UU  Shift(u) and Arrow&Calc(u)*a
 173     7(1) Up      Down    F1, 71, 79, DD  Shift(u) and Calc(d)
 174     8(4) Up      Up      F1, F1, 79, UU  Shift(ux2) and Arrow&Calc(u)*a
 175
 176 During Calc key is hold:
 177     Case Shift   Arrow   Events          Interpret
 178     -------------------------------------------------------------------
 179     A(3) ----    Down    F1, 79, DD      Shift(u) *c
 180     B    ----    Up      79, UU          Arrow&Calc(u)*a
 181     C    Down    ----    F1, 71          Shift(u) and Shift(d)
 182     D    Up      ----    F1              Shift(u)
 183     E    Hold    Down    79, DD          Normal
 184     F    Hold    Up      79, UU          Arrow&Calc(u)*a
 185     G(1) Down    Down    F1, 71, 79, DD  Shift(u)*b and Calc(d)*a
 186     H(2) Down    Up      F1, 71, 79, UU  Shift(u) and Arrow&Calc(u)*a
 187     I(3) Up      Down    F1, F1, 79, DD  Shift(ux2) *c
 188     J(4) Up      Up      F1, 79, UU      Shift(u) and Arrow&Calc(u)*a
 189
 190     Case Shift   Calc    Events          Interpret
 191     -------------------------------------------------------------------
 192     K(1) ----    Down    71, 79, DD      Calc(d)*a
 193     L(4) ----    Up      F1, 79, UU      Shift(u) and Arrow&Calc(u)*a
 194     M(1) Hold    Down    71, 79, DD      Calc(d)*a
 195     N    Hold    Up      79, UU          Arrow&Calc(u)*a
 196
 197     Where DD/UU indicates part of Keypad Down/Up event.
 198     *a: Impossible to distinguish btween Arrow and Calc event.
 199     *b: Shift(d) event is ignored.
 200     *c: Arrow/Calc(d) event is ignored.
 201 */
 202 uint8_t m0110_recv_key(void)
 203 {
 204     static uint8_t keybuf = 0x00;
 205     static uint8_t keybuf2 = 0x00;
 206     static uint8_t rawbuf = 0x00;
 207     uint8_t raw, raw2, raw3;
 208
 209     if (keybuf) {
 210         raw = keybuf;
 211         keybuf = 0x00;
 212         return raw;
 213     }
 214     if (keybuf2) {
 215         raw = keybuf2;
 216         keybuf2 = 0x00;
 217         return raw;
 218     }
 219
 220     if (rawbuf) {
 221         raw = rawbuf;
 222         rawbuf = 0x00;
 223     } else {
 224         raw = instant();  // Use INSTANT for better response. Should be INQUIRY ?
 225     }
 226     switch (KEY(raw)) {
 227         case M0110_KEYPAD:
 228             raw2 = instant();
 229             switch (KEY(raw2)) {
 230                 case M0110_ARROW_UP:
 231                 case M0110_ARROW_DOWN:
 232                 case M0110_ARROW_LEFT:
 233                 case M0110_ARROW_RIGHT:
 234                     if (IS_BREAK(raw2)) {
 235                         // Case B,F,N:
 236                         keybuf = (raw2scan(raw2) | M0110_CALC_OFFSET); // Calc(u)
 237                         return (raw2scan(raw2) | M0110_KEYPAD_OFFSET); // Arrow(u)
 238                     }
 239                     break;
 240             }
 241             // Keypad or Arrow
 242             return (raw2scan(raw2) | M0110_KEYPAD_OFFSET);
 243             break;
 244         case M0110_SHIFT:
 245             raw2 = instant();
 246             switch (KEY(raw2)) {
 247                 case M0110_SHIFT:
 248                     // Case: 5-8,C,G,H
 249                     rawbuf = raw2;
 250                     return raw2scan(raw); // Shift(d/u)
 251                     break;
 252                 case M0110_KEYPAD:
 253                     // Shift + Arrow, Calc, or etc.
 254                     raw3 = instant();
 255                     switch (KEY(raw3)) {
 256                         case M0110_ARROW_UP:
 257                         case M0110_ARROW_DOWN:
 258                         case M0110_ARROW_LEFT:
 259                         case M0110_ARROW_RIGHT:
 260                             if (IS_BREAK(raw)) {
 261                                 if (IS_BREAK(raw3)) {
 262                                     // Case 4:
 263                                     print("(4)\n");
 264                                     keybuf2 = raw2scan(raw); // Shift(u)
 265                                     keybuf  = (raw2scan(raw3) | M0110_CALC_OFFSET); // Calc(u)
 266                                     return (raw2scan(raw3) | M0110_KEYPAD_OFFSET);  // Arrow(u)
 267                                 } else {
 268                                     // Case 3:
 269                                     print("(3)\n");
 270                                     return (raw2scan(raw)); // Shift(u)
 271                                 }
 272                             } else {
 273                                 if (IS_BREAK(raw3)) {
 274                                     // Case 2:
 275                                     print("(2)\n");
 276                                     keybuf  = (raw2scan(raw3) | M0110_CALC_OFFSET); // Calc(u)
 277                                     return (raw2scan(raw3) | M0110_KEYPAD_OFFSET);  // Arrow(u)
 278                                 } else {
 279                                     // Case 1:
 280                                     print("(1)\n");
 281                                     return (raw2scan(raw3) | M0110_CALC_OFFSET); // Calc(d)
 282                                 }
 283                             }
 284                             break;
 285                         default:
 286                             // Shift + Keypad
 287                             keybuf = (raw2scan(raw3) | M0110_KEYPAD_OFFSET);
 288                             return raw2scan(raw);   // Shift(d/u)
 289                             break;
 290                     }
 291                     break;
 292                 default:
 293                     // Shift + Normal keys
 294                     keybuf = raw2scan(raw2);
 295                     return raw2scan(raw);   // Shift(d/u)
 296                     break;
 297             }
 298             break;
 299         default:
 300             // Normal keys
 301             return raw2scan(raw);
 302             break;
 303     }
 304 }
 305
 306
 307 static inline uint8_t raw2scan(uint8_t raw) {
 308     return (raw == M0110_NULL) ?  M0110_NULL : (
 309                 (raw == M0110_ERROR) ?  M0110_ERROR : (
 310                     ((raw&0x80) | ((raw&0x7F)>>1))
 311                 )
 312            );
 313 }
 314
 315 static inline uint8_t inquiry(void)
 316 {
 317     m0110_send(M0110_INQUIRY);
 318     return m0110_recv();
 319 }
 320
 321 static inline uint8_t instant(void)
 322 {
 323     m0110_send(M0110_INSTANT);
 324     uint8_t data = m0110_recv();
 325     if (data != M0110_NULL) {
 326         debug_hex(data); debug(" ");
 327     }
 328     return data;
 329 }
 330
 331 static inline void clock_lo()
 332 {
 333     M0110_CLOCK_PORT &= ~(1<<M0110_CLOCK_BIT);
 334     M0110_CLOCK_DDR  |=  (1<<M0110_CLOCK_BIT);
 335 }
 336 static inline void clock_hi()
 337 {
 338     /* input with pull up */
 339     M0110_CLOCK_DDR  &= ~(1<<M0110_CLOCK_BIT);
 340     M0110_CLOCK_PORT |=  (1<<M0110_CLOCK_BIT);
 341 }
 342 static inline bool clock_in()
 343 {
 344     M0110_CLOCK_DDR  &= ~(1<<M0110_CLOCK_BIT);
 345     M0110_CLOCK_PORT |=  (1<<M0110_CLOCK_BIT);
 346     _delay_us(1);
 347     return M0110_CLOCK_PIN&(1<<M0110_CLOCK_BIT);
 348 }
 349 static inline void data_lo()
 350 {
 351     M0110_DATA_PORT &= ~(1<<M0110_DATA_BIT);
 352     M0110_DATA_DDR  |=  (1<<M0110_DATA_BIT);
 353 }
 354 static inline void data_hi()
 355 {
 356     /* input with pull up */
 357     M0110_DATA_DDR  &= ~(1<<M0110_DATA_BIT);
 358     M0110_DATA_PORT |=  (1<<M0110_DATA_BIT);
 359 }
 360 static inline bool data_in()
 361 {
 362     M0110_DATA_DDR  &= ~(1<<M0110_DATA_BIT);
 363     M0110_DATA_PORT |=  (1<<M0110_DATA_BIT);
 364     _delay_us(1);
 365     return M0110_DATA_PIN&(1<<M0110_DATA_BIT);
 366 }
 367
 368 static inline uint16_t wait_clock_lo(uint16_t us)
 369 {
 370     while (clock_in()  && us) { asm(""); _delay_us(1); us--; }
 371     return us;
 372 }
 373 static inline uint16_t wait_clock_hi(uint16_t us)
 374 {
 375     while (!clock_in() && us) { asm(""); _delay_us(1); us--; }
 376     return us;
 377 }
 378 static inline uint16_t wait_data_lo(uint16_t us)
 379 {
 380     while (data_in() && us)  { asm(""); _delay_us(1); us--; }
 381     return us;
 382 }
 383 static inline uint16_t wait_data_hi(uint16_t us)
 384 {
 385     while (!data_in() && us)  { asm(""); _delay_us(1); us--; }
 386     return us;
 387 }
 388
 389 static inline void idle(void)
 390 {
 391     clock_hi();
 392     data_hi();
 393 }
 394
 395 static inline void request(void)
 396 {
 397     clock_hi();
 398     data_lo();
 399 }
 400
 401
 402
 403 /*
 404 Primitive M0110 Library for AVR
 405 ==============================
 406
 407
 408 Signaling
 409 ---------
 410 CLOCK is always from KEYBOARD. DATA are sent with MSB first.
 411
 412 1) IDLE: both lines are high.
 413     CLOCK ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 414     DATA  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 415
 416 2) KEYBOARD->HOST: HOST reads bit on rising edge.
 417     CLOCK ~~~~~~~~~~~~|__|~~~|__|~~~|__|~~~|__|~~~|__|~~~|__|~~~|__|~~~|__|~~~~~~~~~~~
 418     DATA  ~~~~~~~~~~~~X777777X666666X555555X444444X333333X222222X111111X000000X~~~~~~~
 419                       <--> 160us(clock low)
 420                          <---> 180us(clock high)
 421
 422 3) HOST->KEYBOARD: HOST asserts bit on falling edge.
 423     CLOCK ~~~~~~~~~~~~|__|~~~|__|~~~|__|~~~|__|~~~|__|~~~|__|~~~|__|~~~|__|~~~~~~~~~~~
 424     DATA  ~~~~~~|_____X777777X666666X555555X444444X333333X222222X111111X000000X~~~~~~~
 425                 <----> 840us(request to send by host)                     <---> 80us(hold DATA)
 426                       <--> 180us(clock low)
 427                          <---> 220us(clock high)
 428
 429
 430 Protocol
 431 --------
 432 COMMAND:
 433     Inquiry     0x10    get key event with block
 434     Instant     0x12    get key event
 435     Model       0x14    get model number(M0110 responds with 0x09)
 436                         bit 7   1 if another device connected(used when keypad exists?)
 437                         bit4-6  next device model number
 438                         bit1-3  keyboard model number
 439                         bit 0   always 1
 440     Test        0x16    test(ACK:0x7D/NAK:0x77)
 441
 442 KEY EVENT:
 443     bit 7       key state(0:press 1:release)
 444     bit 6-1     scan code(see below)
 445     bit 0       always 1
 446     To get scan code use this: ((bits&(1<<7)) | ((bits&0x7F))>>1).
 447
 448     Note: On the M0110A, Keypad keys and Arrow keys are preceded by 0x79.
 449           Moreover, some Keypad keys(=, /, * and +) are preceded by 0x71 on press and 0xF1 on release.
 450
 451 ARROW KEYS:
 452     Arrow keys and Calc keys(+,*,/,= on keypad) share same byte sequence and preceding byte of
 453     Calc keys(0x71 and 0xF1) means press and release event of SHIFT. This causes a very confusing situation,
 454     it is difficult or impossible to tell Calc key from Arrow key plus SHIFT in some cases.
 455
 456     Raw key events:
 457             press               release
 458             ----------------    ----------------
 459     Left:         0x79, 0x0D          0x79, 0x8D
 460     Right:        0x79, 0x05          0x79, 0x85
 461     Up:           0x79, 0x1B          0x79, 0x9B
 462     Down:         0x79, 0x11          0x79, 0x91
 463     Pad+:   0x71, 0x79, 0x0D    0xF1, 0x79, 0x8D
 464     Pad*:   0x71, 0x79, 0x05    0xF1, 0x79, 0x85
 465     Pad/:   0x71, 0x79, 0x1B    0xF1, 0x79, 0x9B
 466     Pad=:   0x71, 0x79, 0x11    0xF1, 0x79, 0x91
 467
 468
 469 RAW CODE:
 470     M0110A
 471     ,---------------------------------------------------------. ,---------------.
 472     |  `|  1|  2|  3|  4|  5|  6|  7|  8|  9|  0|  -|  =|Bcksp| |Clr|  =|  /|  *|
 473     |---------------------------------------------------------| |---------------|
 474     |Tab  |  Q|  W|  E|  R|  T|  Y|  U|  I|  O|  P|  [|  ]|   | |  7|  8|  9|  -|
 475     |-----------------------------------------------------'   | |---------------|
 476     |CapsLo|  A|  S|  D|  F|  G|  H|  J|  K|  L|  ;|  '|Return| |  4|  5|  6|  +|
 477     |---------------------------------------------------------| |---------------|
 478     |Shift   |  Z|  X|  C|  V|  B|  N|  M|  ,|  ,|  /|Shft|Up | |  1|  2|  3|   |
 479     |---------------------------------------------------------' |-----------|Ent|
 480     |Optio|Mac    |           Space           |  \|Lft|Rgt|Dn | |      0|  .|   |
 481     `---------------------------------------------------------' `---------------'
 482     ,---------------------------------------------------------. ,---------------.
 483     | 65| 25| 27| 29| 2B| 2F| 2D| 35| 39| 33| 3B| 37| 31|   67| |+0F|*11|*1B|*05|
 484     |---------------------------------------------------------| |---------------|
 485     |   61| 19| 1B| 1D| 1F| 23| 21| 41| 45| 3F| 47| 43| 3D|   | |+33|+37|+39|+1D|
 486     |-----------------------------------------------------'   | |---------------|
 487     |    73| 01| 03| 05| 07| 0B| 09| 4D| 51| 4B| 53| 4F|    49| |+2D|+2F|+31|*0D|
 488     |---------------------------------------------------------| |---------------|
 489     |      71| 0D| 0F| 11| 13| 17| 5B| 5D| 27| 5F| 59|  71|+1B| |+27|+29|+2B|   |
 490     |---------------------------------------------------------' |-----------|+19|
 491     |   75|     6F|            63             | 55|+0D|+05|+11| |    +25|+03|   |
 492     `---------------------------------------------------------' `---------------'
 493     + 0x79, 0xDD / 0xF1, 0xUU
 494     * 0x71, 0x79,DD / 0xF1, 0x79, 0xUU
 495
 496
 497 MODEL NUMBER:
 498     M0110:           0x09  00001001 : model number 4 (100)
 499     M0110A:          0x0B  00001011 : model number 5 (101)
 500     M0110 & M0120:   ???
 501
 502
 503 Scan Code
 504 ---------
 505     m0110_recv_key() function returns following scan codes instead of M0110 raw codes.
 506     Scan codes are 1 byte size and MSB(bit7) is set when key is released.
 507
 508         scancode = ((raw&0x80) | ((raw&0x7F)>>1))
 509
 510     M0110                                                          M0120
 511     ,---------------------------------------------------------.    ,---------------.
 512     |  `|  1|  2|  3|  4|  5|  6|  7|  8|  9|  0|  -|  =|Backs|    |Clr|  -|Lft|Rgt|
 513     |---------------------------------------------------------|    |---------------|
 514     |Tab  |  Q|  W|  E|  R|  T|  Y|  U|  I|  O|  P|  [|  ]|  \|    |  7|  8|  9|Up |
 515     |---------------------------------------------------------|    |---------------|
 516     |CapsLo|  A|  S|  D|  F|  G|  H|  J|  K|  L|  ;|  '|Return|    |  4|  5|  6|Dn |
 517     |---------------------------------------------------------|    |---------------|
 518     |Shift   |  Z|  X|  C|  V|  B|  N|  M|  ,|  ,|  /|        |    |  1|  2|  3|   |
 519     `---------------------------------------------------------'    |-----------|Ent|
 520          |Opt|Mac |         Space               |Enter|Opt|        |      0|  .|   |
 521          `------------------------------------------------'        `---------------'
 522     ,---------------------------------------------------------.    ,---------------.
 523     | 32| 12| 13| 14| 15| 17| 16| 1A| 1C| 19| 1D| 1B| 18|   33|    | 47| 4E| 46| 42|
 524     |---------------------------------------------------------|    |---------------|
 525     |   30| 0C| 0D| 0E| 0F| 10| 11| 20| 22| 1F| 23| 21| 1E| 2A|    | 59| 5B| 5C| 4D|
 526     |---------------------------------------------------------|    |---------------|
 527     |    39| 00| 01| 02| 03| 05| 04| 26| 28| 25| 29| 27|    24|    | 56| 57| 58| 48|
 528     |---------------------------------------------------------|    |---------------|
 529     |      38| 06| 07| 08| 09| 0B| 2D| 2E| 2B| 2F| 2C|      38|    | 53| 54| 55|   |
 530     `---------------------------------------------------------'    |-----------| 4C|
 531          | 3A|  37|             31              |   34| 3A|        |     52| 41|   |
 532          `------------------------------------------------'        `---------------'
 533
 534     International keyboard(See page 22 of "Technical Info for 128K/512K")
 535     ,---------------------------------------------------------.
 536     | 32| 12| 13| 14| 15| 17| 16| 1A| 1C| 19| 1D| 1B| 18|   33|
 537     |---------------------------------------------------------|
 538     |   30| 0C| 0D| 0E| 0F| 10| 11| 20| 22| 1F| 23| 21| 1E| 2A|
 539     |------------------------------------------------------   |
 540     |    39| 00| 01| 02| 03| 05| 04| 26| 28| 25| 29| 27| 24|  |
 541     |---------------------------------------------------------|
 542     |  38| 06| 07| 08| 09| 0B| 2D| 2E| 2B| 2F| 2C| 0A|      38|
 543     `---------------------------------------------------------'
 544          | 3A|  37|             34              |   31| 3A|
 545          `------------------------------------------------'
 546
 547     M0110A
 548     ,---------------------------------------------------------. ,---------------.
 549     |  `|  1|  2|  3|  4|  5|  6|  7|  8|  9|  0|  -|  =|Bcksp| |Clr|  =|  /|  *|
 550     |---------------------------------------------------------| |---------------|
 551     |Tab  |  Q|  W|  E|  R|  T|  Y|  U|  I|  O|  P|  [|  ]|   | |  7|  8|  9|  -|
 552     |-----------------------------------------------------'   | |---------------|
 553     |CapsLo|  A|  S|  D|  F|  G|  H|  J|  K|  L|  ;|  '|Return| |  4|  5|  6|  +|
 554     |---------------------------------------------------------| |---------------|
 555     |Shift   |  Z|  X|  C|  V|  B|  N|  M|  ,|  ,|  /|Shft|Up | |  1|  2|  3|   |
 556     |---------------------------------------------------------' |-----------|Ent|
 557     |Optio|Mac    |           Space           |  \|Lft|Rgt|Dn | |      0|  .|   |
 558     `---------------------------------------------------------' `---------------'
 559     ,---------------------------------------------------------. ,---------------.
 560     | 32| 12| 13| 14| 15| 17| 16| 1A| 1C| 19| 1D| 1B| 18|   33| | 47| 68| 6D| 62|
 561     |---------------------------------------------------------| |---------------|
 562     |   30| 0C| 0D| 0E| 0F| 10| 11| 20| 22| 1F| 23| 21| 1E|   | | 59| 5B| 5C| 4E|
 563     |-----------------------------------------------------'   | |---------------|
 564     |    39| 00| 01| 02| 03| 05| 04| 26| 28| 25| 29| 27|    24| | 56| 57| 58| 66|
 565     |---------------------------------------------------------| |---------------|
 566     |      38| 06| 07| 08| 09| 0B| 2D| 2E| 2B| 2F| 2C|  38| 4D| | 53| 54| 55|   |
 567     |---------------------------------------------------------' |-----------| 4C|
 568     |   3A|     37|            31             | 2A| 46| 42| 48| |     52| 41|   |
 569     `---------------------------------------------------------' `---------------'
 570
 571
 572 References
 573 ----------
 574 Technical Info for 128K/512K and Plus
 575     ftp://ftp.apple.asimov.net/pub/apple_II/documentation/macintosh/Mac%20Hardware%20Info%20-%20Mac%20128K.pdf
 576     ftp://ftp.apple.asimov.net/pub/apple_II/documentation/macintosh/Mac%20Hardware%20Info%20-%20Mac%20Plus.pdf
 577 Protocol:
 578     Page 20 of Tech Info for 128K/512K
 579     http://www.mac.linux-m68k.org/devel/plushw.php
 580 Connector:
 581     Page 20 of Tech Info for 128K/512K
 582     http://www.kbdbabel.org/conn/kbd_connector_macplus.png
 583 Signaling:
 584     http://www.kbdbabel.org/signaling/kbd_signaling_mac.png
 585     http://typematic.blog.shinobi.jp/Entry/14/
 586 M0110 raw scan codes:
 587     Page 22 of Tech Info for 128K/512K
 588     Page 07 of Tech Info for Plus
 589     http://m0115.web.fc2.com/m0110.jpg
 590     http://m0115.web.fc2.com/m0110a.jpg
 591 */