tmk_core/protocol/ibmpc.c

   1 /*
   2 Copyright 2010,2011,2012,2013,2019 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
  38 /*
  39  * IBM PC keyboard protocol
  40  */
  41
  42 #include <stdbool.h>
  43 #include <avr/interrupt.h>
  44 #include <util/atomic.h>
  45 #include "ringbuf.h"
  46 #include "ibmpc.h"
  47 #include "debug.h"
  48 #include "timer.h"
  49 #include "wait.h"
  50
  51
  52 #define WAIT(stat, us, err) do { \
  53     if (!wait_##stat(us)) { \
  54         ibmpc_error = err; \
  55         goto ERROR; \
  56     } \
  57 } while (0)
  58
  59
  60 #define BUF_SIZE 16
  61 static uint8_t buf[BUF_SIZE];
  62 static ringbuf_t rb = {
  63     .buffer = buf,
  64     .head = 0,
  65     .tail = 0,
  66     .size_mask = BUF_SIZE - 1
  67 };
  68
  69 volatile uint8_t ibmpc_protocol = IBMPC_PROTOCOL_AT;
  70 volatile uint8_t ibmpc_error = IBMPC_ERR_NONE;
  71
  72 void ibmpc_host_init(void)
  73 {
  74     // initialize reset pin
  75     IBMPC_RST_PORT |=  (1<<IBMPC_RST_BIT1);
  76     IBMPC_RST_DDR  |=  (1<<IBMPC_RST_BIT1);
  77     IBMPC_RST_PORT |=  (1<<IBMPC_RST_BIT2);
  78     IBMPC_RST_DDR  |=  (1<<IBMPC_RST_BIT2);
  79     inhibit();
  80     IBMPC_INT_INIT();
  81     IBMPC_INT_OFF();
  82 }
  83
  84 void ibmpc_host_enable(void)
  85 {
  86     IBMPC_INT_ON();
  87     idle();
  88 }
  89
  90 void ibmpc_host_disable(void)
  91 {
  92     IBMPC_INT_OFF();
  93     inhibit();
  94 }
  95
  96 int16_t ibmpc_host_send(uint8_t data)
  97 {
  98     bool parity = true;
  99     ibmpc_error = IBMPC_ERR_NONE;
 100
 101     if (ibmpc_protocol == IBMPC_PROTOCOL_XT) return -1;
 102
 103     dprintf("w%02X ", data);
 104
 105     IBMPC_INT_OFF();
 106
 107     /* terminate a transmission if we have */
 108     inhibit();
 109     wait_us(100); // 100us [4]p.13, [5]p.50
 110
 111     /* 'Request to Send' and Start bit */
 112     data_lo();
 113     clock_hi();
 114     WAIT(clock_lo, 10000, 1);   // 10ms [5]p.50
 115
 116     /* Data bit[2-9] */
 117     for (uint8_t i = 0; i < 8; i++) {
 118         wait_us(15);
 119         if (data&(1<<i)) {
 120             parity = !parity;
 121             data_hi();
 122         } else {
 123             data_lo();
 124         }
 125         WAIT(clock_hi, 50, 2);
 126         WAIT(clock_lo, 50, 3);
 127     }
 128
 129     /* Parity bit */
 130     wait_us(15);
 131     if (parity) { data_hi(); } else { data_lo(); }
 132     WAIT(clock_hi, 50, 4);
 133     WAIT(clock_lo, 50, 5);
 134
 135     /* Stop bit */
 136     wait_us(15);
 137     data_hi();
 138
 139     /* Ack */
 140     WAIT(data_lo, 50, 6);
 141     WAIT(clock_lo, 50, 7);
 142
 143     /* wait for idle state */
 144     WAIT(clock_hi, 50, 8);
 145     WAIT(data_hi, 50, 9);
 146
 147     // clear buffer to get response correctly
 148     ringbuf_reset(&rb);
 149     ibmpc_host_isr_clear();
 150
 151     idle();
 152     IBMPC_INT_ON();
 153     return ibmpc_host_recv_response();
 154 ERROR:
 155     ibmpc_error |= IBMPC_ERR_SEND;
 156     idle();
 157     IBMPC_INT_ON();
 158     return -1;
 159 }
 160
 161 /*
 162  * Receive data from keyboard with ISR
 163  */
 164 static volatile int16_t recv_data = -1;
 165 static volatile uint16_t isr_data = 0x8000;
 166
 167 void ibmpc_host_isr_clear(void)
 168 {
 169     isr_data = 0x8000;
 170 }
 171
 172 int16_t ibmpc_host_recv(void)
 173 {
 174     int16_t data = 0;
 175     ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
 176         data = recv_data;
 177         recv_data = -1;
 178     }
 179     if (data != -1) {
 180         dprintf("r%04X ", data);
 181     }
 182     return data;
 183
 184 }
 185
 186 int16_t ibmpc_host_recv_response(void)
 187 {
 188     // Command may take 25ms/20ms at most([5]p.46, [3]p.21)
 189     uint8_t retry = 25;
 190     int16_t data = -1;
 191     while (retry-- && (data = ibmpc_host_recv()) == -1) {
 192         wait_ms(1);
 193     }
 194     return data;
 195 }
 196
 197 ISR(IBMPC_INT_VECT)
 198 {
 199     uint8_t dbit;
 200     dbit = IBMPC_DATA_PIN&(1<<IBMPC_DATA_BIT);
 201     isr_data = isr_data>>1;
 202     if (dbit) isr_data |= 0x8000;
 203
 204     // isr_data:
 205     //            15 14 13 12   11 10  9  8    7  6  5  4    3  2  1  0
 206     //            -----------------------------------------------------
 207     // Initial:   *1  0  0  0    0  0  0  0 |  0  0  0  0    0  0  0  0
 208     // XT IBM:    b7 b6 b5 b4   b3 b2 b1 b0 | s1 s0 *1  0    0  0  0  0     after receiving **
 209     // XT Clone:  b7 b6 b5 b4   b3 b2 b1 b0 | s1 *1  0  0    0  0  0  0     after receiving
 210     // AT:        st pr b7 b6   b5 b4 b3 b2 | b1 b0 s0 *1    0  0  0  0     after receiving
 211     // AT**:      pr b7 b6 b5   b4 b3 b2 b1 | b0 s0 *1  0    0  0  0  0     before stop bit **
 212     //
 213     //             x  x  x  x    x  x  x  x |  0  0  0  0    0  0  0  0     midway(0-7 bits received)
 214     //             x  x  x  x    x  x  x  x |  1  0  0  0    0  0  0  0     midway(8 bits received)
 215     //             x  x  x  x    x  x  x  x |  0  1  0  0    0  0  0  0     XT IBM-midway or AT-midway
 216     //             x  x  x  x    x  x  x  x |  1  1  0  0    0  0  0  0     XT Clone-done
 217     //             x  x  x  x    x  x  x  x |  0  0  1  0    0  0  0  0     AT-midway
 218     //             x  x  x  x    x  x  x  x |  1  0  1  0    0  0  0  0     XT IBM-done or AT-midway **
 219     //             x  x  x  x    x  x  x  x |  x  1  1  0    0  0  0  0     illegal
 220     //             x  x  x  x    x  x  x  x |  x  x  0  1    0  0  0  0     AT-done
 221     //             x  x  x  x    x  x  x  x |  x  x  1  1    0  0  0  0     illegal
 222     //                                          other states than avobe     illegal
 223     //
 224     // **: AT can take same as end sate of XT IBM(1010 000) when b0 is 1,
 225     // to discriminate between them we will have to wait a while for stop bit.
 226     //
 227     // mask for isr_data:
 228     // 0x00A0(1010 0000) when XT IBM
 229     // 0x00C0(1100 0000) when XT Clone
 230     // 0x0010(xx01 0000) when AT
 231     //
 232     switch (isr_data & 0xFF) {
 233         case 0b00000000:
 234         case 0b10000000:
 235         case 0b01000000:
 236         case 0b00100000:
 237             // midway
 238             return;
 239             break;
 240         case 0b11000000:
 241             // XT Clone-done
 242             recv_data = (isr_data>>8) & 0xFF;
 243             goto DONE;
 244             break;
 245         case 0b10100000:
 246             // XT IBM-done or AT-midway
 247             // wait and check for clock of AT stop bit
 248             if (wait_clock_hi(100) && wait_clock_lo(100)) { // FIXME this makes ISR prologe long
 249                 // AT-midway
 250                 return;
 251             } else {
 252                 // XT-IBM-done
 253                 recv_data = (isr_data>>8) & 0xFF;
 254                 goto DONE;
 255             }
 256             break;
 257         case 0b00010000:
 258         case 0b10010000:
 259         case 0b01010000:
 260         case 0b11010000:
 261             // AT-done
 262             recv_data = (isr_data>>6) & 0xFF;
 263             goto DONE;
 264             break;
 265         case 0b01100000:
 266         case 0b11100000:
 267         case 0b00110000:
 268         case 0b10110000:
 269         case 0b01110000:
 270         case 0b11110000:
 271         default:            // xxxx_oooo(any 1 in low nibble)
 272             recv_data = isr_data;
 273             break;
 274     }
 275 DONE:
 276     // TODO: buffer for recv_data
 277     isr_data = 0x8000;  // clear to next data
 278     return;
 279 }
 280
 281 /* send LED state to keyboard */
 282 void ibmpc_host_set_led(uint8_t led)
 283 {
 284     ibmpc_host_send(0xED);
 285     ibmpc_host_send(led);
 286 }