X-Git-Url: https://git.friedersdorff.com/?a=blobdiff_plain;f=tmk_core%2Fprotocol%2Fibmpc.c;h=2f5f70f59ac3701c89778489fe8aebc76f32f78c;hb=2c9ae5ac95734b102ad038a80857eb8446220c79;hp=f74a387da95d195c162e994204e89da7ce77793b;hpb=e89ade52e105bcdcf949b63645c3df38935011b0;p=max%2Ftmk_keyboard.git diff --git a/tmk_core/protocol/ibmpc.c b/tmk_core/protocol/ibmpc.c index f74a387d..2f5f70f5 100644 --- a/tmk_core/protocol/ibmpc.c +++ b/tmk_core/protocol/ibmpc.c @@ -42,7 +42,6 @@ POSSIBILITY OF SUCH DAMAGE. #include #include #include -#include "ringbuf.h" #include "ibmpc.h" #include "debug.h" #include "timer.h" @@ -57,18 +56,21 @@ 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 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) { // initialize reset pin to HiZ @@ -95,8 +97,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(); @@ -142,7 +142,7 @@ int16_t ibmpc_host_send(uint8_t data) WAIT(data_hi, 50, 9); // clear buffer to get response correctly - ringbuf_reset(&rb); + recv_data = 0xFFFF; ibmpc_host_isr_clear(); idle(); @@ -156,27 +156,27 @@ ERROR: } /* - * Receive data from keyboard with ISR + * Receive data from keyboard */ -static volatile int16_t recv_data = -1; -static volatile uint16_t isr_data = 0x8000; - -void ibmpc_host_isr_clear(void) -{ - isr_data = 0x8000; -} - int16_t ibmpc_host_recv(void) { - int16_t data = 0; + uint16_t data = 0; + uint8_t ret = 0xFF; + ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { data = recv_data; - recv_data = -1; - } - if (data != -1) { - dprintf("r%04X ", 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; + } } - return data; + + if (ret != 0xFF) dprintf("r%02X ", ret); + if (recv_data != 0xFFFF) dprintf("b%04X ", recv_data); + return ((ret != 0xFF) ? ret : -1); } @@ -191,71 +191,99 @@ int16_t ibmpc_host_recv_response(void) return data; } -// NOTE: to read data line early as possible: +void ibmpc_host_isr_clear(void) +{ + 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) { uint8_t dbit; dbit = IBMPC_DATA_PIN&(1<>1; - if (dbit) isr_data |= 0x8000; - - // isr_data: - // 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 - // ----------------------------------------------------- - // Initial: *1 0 0 0 0 0 0 0 | 0 0 0 0 0 0 0 0 - // XT IBM: b7 b6 b5 b4 b3 b2 b1 b0 | s1 s0 *1 0 0 0 0 0 after receiving ** - // XT Clone: b7 b6 b5 b4 b3 b2 b1 b0 | s1 *1 0 0 0 0 0 0 after receiving - // AT: st pr b7 b6 b5 b4 b3 b2 | b1 b0 s0 *1 0 0 0 0 after receiving - // AT**: pr b7 b6 b5 b4 b3 b2 b1 | b0 s0 *1 0 0 0 0 0 before stop 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; + } + } + + 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. // - // 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) - // x x x x x x x x | 0 1 0 0 0 0 0 0 XT IBM-midway or AT-midway - // x x x x x x x x | 1 1 0 0 0 0 0 0 XT Clone-done - // x x x x x x x x | 0 0 1 0 0 0 0 0 AT-midway - // x x x x x x x x | 1 0 1 0 0 0 0 0 XT IBM-done or AT-midway ** - // x x x x x x x x | x 1 1 0 0 0 0 0 illegal - // x x x x x x x x | x x 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 - // other states than avobe illegal + // 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 // - // **: AT can take same as end sate of XT IBM(1010 000) when b0 is 1, - // to discriminate between them we will have to wait a while for stop bit. + // 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) // - // mask for isr_data: - // 0x00A0(1010 0000) when XT IBM - // 0x00C0(1100 0000) when XT Clone - // 0x0010(xx01 0000) when AT + // 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 + // 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 + // 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 // - switch (isr_data & 0xFF) { + // ^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: + case 0b01000000: // ^1 case 0b00100000: // midway - return; + goto NEXT; break; case 0b11000000: - // XT Clone-done - recv_data = (isr_data>>8) & 0xFF; + // XT_Clone-done + isr_state = isr_state>>8; + ibmpc_protocol = IBMPC_PROTOCOL_XT_CLONE; goto DONE; break; - case 0b10100000: + case 0b10100000: // ^2 { - uint8_t us = 150; - // wait for rising and falling edge of AT stop bit + 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<>8) & 0xFF; + // no stop bit: XT_IBM-done + isr_state = isr_state>>8; + ibmpc_protocol = IBMPC_PROTOCOL_XT_IBM; goto DONE; } } @@ -265,7 +293,9 @@ ISR(IBMPC_INT_VECT) case 0b01010000: case 0b11010000: // AT-done - recv_data = (isr_data>>6) & 0xFF; + // TODO: parity check? + isr_state = isr_state>>6; + ibmpc_protocol = IBMPC_PROTOCOL_AT; goto DONE; break; case 0b01100000: @@ -275,12 +305,29 @@ ISR(IBMPC_INT_VECT) case 0b01110000: case 0b11110000: default: // xxxx_oooo(any 1 in low nibble) - recv_data = isr_data; + // Illegal + ibmpc_error = IBMPC_ERR_ILLEGAL; + goto ERROR; break; } + +ERROR: + isr_state = 0x8000; + recv_data = 0xFF00; // clear data and scancode of error 0x00 + return; DONE: - // TODO: buffer for recv_data - isr_data = 0x8000; // clear to next data + 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: return; }