X-Git-Url: https://git.friedersdorff.com/?a=blobdiff_plain;f=tmk_core%2Fprotocol%2Fibmpc.c;h=0e3998aae6a846e5e512e078f70ecb609436cdd2;hb=0cf9dfc888755e18a88f71f40863e3dc035ab91a;hp=ab446caaedb9775b47feeb24feed39ecf2a68706;hpb=3e2900dcc87434b11d153f66146671d71f2999b8;p=max%2Ftmk_keyboard.git

diff --git a/tmk_core/protocol/ibmpc.c b/tmk_core/protocol/ibmpc.c
index ab446caa..0e3998aa 100644
--- a/tmk_core/protocol/ibmpc.c
+++ b/tmk_core/protocol/ibmpc.c
@@ -41,7 +41,7 @@ POSSIBILITY OF SUCH DAMAGE.
 
 #include <stdbool.h>
 #include <avr/interrupt.h>
-#include "ringbuf.h"
+#include <util/atomic.h>
 #include "ibmpc.h"
 #include "debug.h"
 #include "timer.h"
@@ -56,27 +56,41 @@ POSSIBILITY OF SUCH DAMAGE.
 } while (0)
 
 
-#define BUF_SIZE 16
-static uint8_t buf[BUF_SIZE];
-static ringbuf_t rb = {
-    .buffer = buf,
-    .head = 0,
-    .tail = 0,
-    .size_mask = BUF_SIZE - 1
-};
-
-volatile uint8_t ibmpc_protocol = IBMPC_PROTOCOL_AT;
+volatile uint16_t ibmpc_isr_debug = 0;
+volatile uint8_t ibmpc_protocol = IBMPC_PROTOCOL_NO;
 volatile uint8_t ibmpc_error = IBMPC_ERR_NONE;
 
+/* 2-byte buffer for data received from keyhboard
+ * buffer states:
+ *      FFFF: empty
+ *      FFss: one data
+ *      sstt: two data(full)
+ *  0xFF can not be stored as data in buffer because it means empty or no data.
+ */
+static volatile uint16_t recv_data = 0xFFFF;
+/* internal state of receiving data */
+static volatile uint16_t isr_state = 0x8000;
+static uint8_t timer_start = 0;
+
 void ibmpc_host_init(void)
 {
-    clock_init();
-    data_init();
-    idle();
+    // initialize reset pin to HiZ
+    IBMPC_RST_HIZ();
+    inhibit();
     IBMPC_INT_INIT();
+    IBMPC_INT_OFF();
+}
+
+void ibmpc_host_enable(void)
+{
     IBMPC_INT_ON();
-    // POR(150-2000ms) plus BAT(300-500ms) may take 2.5sec([3]p.20)
-    //wait_ms(2500);
+    idle();
+}
+
+void ibmpc_host_disable(void)
+{
+    IBMPC_INT_OFF();
+    inhibit();
 }
 
 int16_t ibmpc_host_send(uint8_t data)
@@ -84,8 +98,6 @@ int16_t ibmpc_host_send(uint8_t data)
     bool parity = true;
     ibmpc_error = IBMPC_ERR_NONE;
 
-    if (ibmpc_protocol == IBMPC_PROTOCOL_XT) return -1;
-
     dprintf("w%02X ", data);
 
     IBMPC_INT_OFF();
@@ -130,6 +142,10 @@ int16_t ibmpc_host_send(uint8_t data)
     WAIT(clock_hi, 50, 8);
     WAIT(data_hi, 50, 9);
 
+    // clear buffer to get response correctly
+    recv_data = 0xFFFF;
+    ibmpc_host_isr_clear();
+
     idle();
     IBMPC_INT_ON();
     return ibmpc_host_recv_response();
@@ -140,122 +156,210 @@ ERROR:
     return -1;
 }
 
+/*
+ * Receive data from keyboard
+ */
+int16_t ibmpc_host_recv(void)
+{
+    uint16_t data = 0;
+    uint8_t ret = 0xFF;
+
+    ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+        data = recv_data;
+        if ((data&0xFF00) != 0xFF00) {      // recv_data:sstt -> recv_data:FFtt, ret:ss
+            ret = (data>>8)&0x00FF;
+            recv_data = data | 0xFF00;
+        } else if (data != 0xFFFF) {        // recv_data:FFss -> recv_data:FFFF, ret:ss
+            ret = data&0x00FF;
+            recv_data = data | 0x00FF;
+        }
+    }
+
+    if ((data | 0x00FF) != 0xFFFF) dprintf("b%04X ", data);
+    if (ret != 0xFF) dprintf("r%02X ", ret);
+    return ((ret != 0xFF) ? ret : -1);
+
+}
+
 int16_t ibmpc_host_recv_response(void)
 {
     // Command may take 25ms/20ms at most([5]p.46, [3]p.21)
     uint8_t retry = 25;
-    while (retry-- && ringbuf_is_empty(&rb)) {
+    int16_t data = -1;
+    while (retry-- && (data = ibmpc_host_recv()) == -1) {
         wait_ms(1);
     }
-    int16_t data = ringbuf_get(&rb);
-    if (data != -1) dprintf("r%02X ", data);
     return data;
 }
 
-/* get data received by interrupt */
-int16_t ibmpc_host_recv(void)
+void ibmpc_host_isr_clear(void)
 {
-    int16_t data = ringbuf_get(&rb);
-    if (data != -1) dprintf("r%02X ", data);
-    return data;
+    isr_state = 0x8000;
+    recv_data = 0xFFFF;
 }
 
+// NOTE: With this ISR data line can be read within 2us after clock falling edge.
+// To read data line early as possible:
+// write naked ISR with asembly code to read the line and call C func to do other job?
 ISR(IBMPC_INT_VECT)
 {
-    static uint16_t last_time = 0;
-    static enum {
-        START,
-        BIT0, BIT1, BIT2, BIT3, BIT4, BIT5, BIT6, BIT7,
-        PARITY,
-        STOP,
-    } state = START;
-    static uint8_t data = 0;
-    static uint8_t parity = 1;
-
-    uint8_t dbit = IBMPC_DATA_PIN&(1<<IBMPC_DATA_BIT);
-
-    // Reset state when taking more than 1ms
-    if (last_time && timer_elapsed(last_time) > 10) {
-        ibmpc_error = IBMPC_ERR_TIMEOUT | IBMPC_ERR_RECV | state;
-        state = START;
-        data = 0;
-        parity = 1;
+    uint8_t dbit;
+    dbit = IBMPC_DATA_PIN&(1<<IBMPC_DATA_BIT);
+
+    // Timeout check
+    uint8_t t;
+    // use only the least byte of millisecond timer
+    asm("lds %0, %1" : "=r" (t) : "p" (&timer_count));
+    //t = (uint8_t)timer_count;    // compiler uses four registers instead of one
+    if (isr_state == 0x8000) {
+        timer_start = t;
+    } else {
+        // should not take more than 1ms
+        if (timer_start != t && (uint8_t)(timer_start + 1) != t) {
+            ibmpc_error = IBMPC_ERR_TIMEOUT;
+            //goto ERROR;
+            // timeout error recovery by clearing isr_state?
+            timer_start = t;
+            isr_state = 0x8000;
+        }
     }
-    last_time = timer_read();
-
-    switch (state) {
-        case START:
-            if (ibmpc_protocol == IBMPC_PROTOCOL_XT) {
-                // ignore start(0) bit
-                if (!dbit) return;
-            } else {
-                if (dbit)
-                    goto ERROR;
-            }
-        case BIT0:
-        case BIT1:
-        case BIT2:
-        case BIT3:
-        case BIT4:
-        case BIT5:
-        case BIT6:
-        case BIT7:
-            data >>= 1;
-            if (dbit) {
-                data |= 0x80;
-                parity++;
-            }
-            if (state == BIT7 && ibmpc_protocol == IBMPC_PROTOCOL_XT) {
-                if (!ringbuf_put(&rb, data)) {
-                    ibmpc_error = IBMPC_ERR_FULL;
-                    goto ERROR;
+
+    isr_state = isr_state>>1;
+    if (dbit) isr_state |= 0x8000;
+
+    // isr_state: state of receiving data from keyboard
+    //
+    // This should be initialized with 0x8000 before receiving data and
+    // the MSB '*1' works as marker to discrimitate between protocols.
+    // It stores sampled bit at MSB after right shift on each clock falling edge.
+    //
+    // XT protocol has two variants of signaling; XT_IBM and XT_Clone.
+    // XT_IBM uses two start bits 0 and 1 while XT_Clone uses just start bit 1.
+    // https://github.com/tmk/tmk_keyboard/wiki/IBM-PC-XT-Keyboard-Protocol
+    //
+    //      15 14 13 12   11 10  9  8    7  6  5  4    3  2  1  0
+    //      -----------------------------------------------------
+    //      *1  0  0  0    0  0  0  0 |  0  0  0  0    0  0  0  0     Initial state(0x8000)
+    //
+    //       x  x  x  x    x  x  x  x |  0  0  0  0    0  0  0  0     midway(0-7 bits received)
+    //       x  x  x  x    x  x  x  x | *1  0  0  0    0  0  0  0     midway(8 bits received)
+    //      b6 b5 b4 b3   b2 b1 b0  1 |  0 *1  0  0    0  0  0  0     XT_IBM-midway ^1
+    //      b7 b6 b5 b4   b3 b2 b1 b0 |  0 *1  0  0    0  0  0  0     AT-midway ^1
+    //      b7 b6 b5 b4   b3 b2 b1 b0 |  1 *1  0  0    0  0  0  0     XT_Clone-done ^3
+    //      b6 b5 b4 b3   b2 b1 b0  1 |  1 *1  0  0    0  0  0  0     XT_IBM-error ^3
+    //      pr b7 b6 b5   b4 b3 b2 b1 |  0  0 *1  0    0  0  0  0     AT-midway[b0=0]
+    //      b7 b6 b5 b4   b3 b2 b1 b0 |  1  0 *1  0    0  0  0  0     XT_IBM-done ^2
+    //      pr b7 b6 b5   b4 b3 b2 b1 |  1  0 *1  0    0  0  0  0     AT-midway[b0=1] ^2
+    //      b7 b6 b5 b4   b3 b2 b1 b0 |  1  1 *1  0    0  0  0  0     XT_IBM-error-done
+    //       x  x  x  x    x  x  x  x |  x  1  1  0    0  0  0  0     illegal
+    //      st pr b7 b6   b5 b4 b3 b2 | b1 b0  0 *1    0  0  0  0     AT-done
+    //       x  x  x  x    x  x  x  x |  x  x  1 *1    0  0  0  0     illegal
+    //                                all other states than above     illegal
+    //
+    // ^1: AT and XT_IBM takes same state.
+    // ^2: AT and XT_IBM takes same state in case that AT b0 is 1,
+    // we have to check AT stop bit to discriminate between the two protocol.
+    switch (isr_state & 0xFF) {
+        case 0b00000000:
+        case 0b10000000:
+        case 0b01000000:    // ^1
+        case 0b00100000:
+            // midway
+            goto NEXT;
+            break;
+        case 0b11000000:    // ^3
+            {
+                uint8_t us = 100;
+                // wait for rising and falling edge of b7 of XT_IBM
+                while (!(IBMPC_CLOCK_PIN&(1<<IBMPC_CLOCK_BIT)) && us) { wait_us(1); us--; }
+                while (  IBMPC_CLOCK_PIN&(1<<IBMPC_CLOCK_BIT)  && us) { wait_us(1); us--; }
+
+                if (us) {
+                    // XT_IBM-error: read start(0) as 1
+                    goto NEXT;
+                } else {
+                    // XT_Clone-done
+                    isr_state = isr_state>>8;
+                    ibmpc_protocol = IBMPC_PROTOCOL_XT_CLONE;
+                    goto DONE;
                 }
-                ibmpc_error = IBMPC_ERR_NONE;
-                goto DONE;
             }
             break;
-        case PARITY:
-            if (dbit) {
-                if (!(parity & 0x01))
-                    goto ERROR;
-            } else {
-                if (parity & 0x01)
-                    goto ERROR;
-            }
+        case 0b11100000:
+            // XT_IBM-error-done
+            ibmpc_isr_debug = isr_state;
+            isr_state = isr_state>>8;
+            ibmpc_protocol = IBMPC_PROTOCOL_XT_ERROR;
+            goto DONE;
             break;
-        case STOP:
-            if (!dbit)
-                goto ERROR;
-            if (!ringbuf_put(&rb, data)) {
-                ibmpc_error = IBMPC_ERR_FULL;
-                goto ERROR;
-            }
-            ibmpc_error = IBMPC_ERR_NONE;
+        case 0b10100000:    // ^2
+            {
+                uint8_t us = 100;
+                // wait for rising and falling edge of AT stop bit to discriminate between XT and AT
+                while (!(IBMPC_CLOCK_PIN&(1<<IBMPC_CLOCK_BIT)) && us) { wait_us(1); us--; }
+                while (  IBMPC_CLOCK_PIN&(1<<IBMPC_CLOCK_BIT)  && us) { wait_us(1); us--; }
+
+                if (us) {
+                    // found stop bit: AT-midway - process the stop bit in next ISR
+                    goto NEXT;
+                } else {
+                    // no stop bit: XT_IBM-done
+                    isr_state = isr_state>>8;
+                    ibmpc_protocol = IBMPC_PROTOCOL_XT_IBM;
+                    goto DONE;
+                }
+             }
+            break;
+        case 0b00010000:
+        case 0b10010000:
+        case 0b01010000:
+        case 0b11010000:
+            // AT-done
+            // DO NOT check stop bit. Zenith Z-150(AT) asserts stop bit as low for no reason.
+            // https://github.com/tmk/tmk_keyboard/wiki/IBM-PC-AT-Keyboard-Protocol#zenith-z-150-beige
+            // TODO: parity check?
+            isr_state = isr_state>>6;
+            ibmpc_protocol = IBMPC_PROTOCOL_AT;
             goto DONE;
             break;
-        default:
+        case 0b01100000:
+        case 0b00110000:
+        case 0b10110000:
+        case 0b01110000:
+        case 0b11110000:
+        default:            // xxxx_oooo(any 1 in low nibble)
+            // Illegal
+            ibmpc_isr_debug = isr_state;
+            ibmpc_error = IBMPC_ERR_ILLEGAL;
             goto ERROR;
+            break;
     }
-    goto NEXT;
 
 ERROR:
-    ibmpc_error |= state;
-    ibmpc_error |= IBMPC_ERR_RECV;
-    ringbuf_reset(&rb);
-DONE:
-    last_time = 0;
-    state = START;
-    data = 0;
-    parity = 1;
+    ibmpc_isr_debug = isr_state;
+    isr_state = 0x8000;
+    recv_data = 0xFF00; // clear data and scancode of error 0x00
     return;
+DONE:
+    if ((isr_state & 0x00FF) == 0x00FF) {
+        // receive error code 0xFF
+        ibmpc_error = IBMPC_ERR_FF;
+    }
+    if ((recv_data & 0xFF00) != 0xFF00) {
+        // buffer full and overwritten
+        ibmpc_error = IBMPC_ERR_FULL;
+    }
+    recv_data = recv_data<<8;
+    recv_data |= isr_state & 0xFF;
+    isr_state = 0x8000;  // clear to next data
 NEXT:
-    state++;
     return;
 }
 
 /* send LED state to keyboard */
 void ibmpc_host_set_led(uint8_t led)
 {
-    ibmpc_host_send(0xED);
-    ibmpc_host_send(led);
+    if (0xFA == ibmpc_host_send(0xED)) {
+        ibmpc_host_send(led);
+    }
 }