di0ib
/
tmk_keyboard_custom
关注 1
点赞 0
派生 0
代码 版本发布 0 动态
浏览代码

Fix ibm4704 protocol with using interrupt

exp
tmk 9 年前
父节点
5ea50bfb30
当前提交
d42aa47809
共有 4 个文件被更改，包括 149 次插入 和 82 次删除
合并视图 显示文件统计
  1. 53
    0
      common/ring_buffer.h
  2. 0
    2
      converter/ibm4704_usb/config.h
  3. 18
    23
      converter/ibm4704_usb/matrix.c
  4. 78
    57
      tmk_core/protocol/ibm4704.c

+ 53
- 0
common/ring_buffer.h 查看文件

#ifndef RING_BUFFER_H
#define RING_BUFFER_H
/*--------------------------------------------------------------------
* Ring buffer to store scan codes from keyboard
*------------------------------------------------------------------*/
#define RBUF_SIZE 32
static uint8_t rbuf[RBUF_SIZE];
static uint8_t rbuf_head = 0;
static uint8_t rbuf_tail = 0;
static inline void rbuf_enqueue(uint8_t data)
{
uint8_t sreg = SREG;
cli();
uint8_t next = (rbuf_head + 1) % RBUF_SIZE;
if (next != rbuf_tail) {
rbuf[rbuf_head] = data;
rbuf_head = next;
} else {
print("rbuf: full\n");
}
SREG = sreg;
}
static inline uint8_t rbuf_dequeue(void)
{
uint8_t val = 0;

uint8_t sreg = SREG;
cli();
if (rbuf_head != rbuf_tail) {
val = rbuf[rbuf_tail];
rbuf_tail = (rbuf_tail + 1) % RBUF_SIZE;
}
SREG = sreg;

return val;
}
static inline bool rbuf_has_data(void)
{
uint8_t sreg = SREG;
cli();
bool has_data = (rbuf_head != rbuf_tail);
SREG = sreg;
return has_data;
}
static inline void rbuf_clear(void)
{
uint8_t sreg = SREG;
cli();
rbuf_head = rbuf_tail = 0;
SREG = sreg;
}

#endif /* RING_BUFFER_H */

+ 0
- 2
converter/ibm4704_usb/config.h 查看文件

/* /*
* Pin interrupt * Pin interrupt
*/ */
#ifdef IBM4704_USE_INT
#define IBM4704_INT_INIT() do { \ #define IBM4704_INT_INIT() do { \
EICRA |= ((1<<ISC11) | \ EICRA |= ((1<<ISC11) | \
(0<<ISC10)); \ (0<<ISC10)); \
EIMSK &= ~(1<<INT1); \ EIMSK &= ~(1<<INT1); \
} while (0) } while (0)
#define IBM4704_INT_VECT INT1_vect #define IBM4704_INT_VECT INT1_vect
#endif




#endif #endif

+ 18
- 23
converter/ibm4704_usb/matrix.c 查看文件

{ {
uint8_t ret; uint8_t ret;
print("Enable break: "); print("Enable break: ");
// valid scancode: 00-77h
for (uint8_t code = 0; code < 0x78; code++) {
while (ibm4704_send(0x80|code) != 0) {
print("z");
_delay_us(500);
}
_delay_us(2000);
ret = ibm4704_recv();
if (ret != 0xff) {
// valid scancode: 00-79h
for (uint8_t code = 0; code < 0x7A; code++) {
while (ibm4704_send(0x80|code)) _delay_ms(1);
// get none when ok, get FD when out of bound
_delay_ms(5);
if ((ret = ibm4704_recv()) != 0xff) {
xprintf("c%02X:r%02X ", code, ret); xprintf("c%02X:r%02X ", code, ret);
} }
_delay_us(1000);
_delay_ms(1);
} }
_delay_us(1000); _delay_us(1000);
while (ibm4704_send(0xFF) != 0) { _delay_us(500); } // End
while (ibm4704_send(0xFF)) { _delay_ms(1); } // End
print("End\n"); print("End\n");
} }


void matrix_init(void) void matrix_init(void)
{ {
uint8_t ret;
debug_enable = true;
debug_enable = false;


ibm4704_init(); ibm4704_init();
matrix_clear(); matrix_clear();


// read keyboard id
while ((ret = ibm4704_recv()) == 0xFF) {
ibm4704_send(0xFE);
_delay_us(100);
}
_delay_ms(2000); // wait for starting up debug console


_delay_ms(2000); // wait for starting up debug console
print("IBM 4704 converter\n"); print("IBM 4704 converter\n");
xprintf("Keyboard ID: %02X\n", ret);
while (ibm4704_send(0xFE)) _delay_ms(1); // resend
_delay_ms(5);
xprintf("Keyboard ID: %02X\n", ibm4704_recv());
enable_break(); enable_break();
} }


if (code==0xFF) { if (code==0xFF) {
// Not receivd // Not receivd
return 0; return 0;
} else if ((code&0x78)==0x78) {
// 0xFF-F8 and 0x7F-78 is not scancode
xprintf("Error: %0X\n", code);
} else if ((code&0x7F) >= 0x7A) {
// 0xFF-FA and 0x7F-7A is not scancode
xprintf("Error: %02X\n", code);
matrix_clear(); matrix_clear();
return 0; return 0;
} else if (code&0x80) { } else if (code&0x80) {
dprintf("%02X\n", code);
matrix_make(code); matrix_make(code);
} else { } else {
dprintf("%02X\n", code);
matrix_break(code); matrix_break(code);
} }
return 1; return 1;

+ 78
- 57
tmk_core/protocol/ibm4704.c 查看文件

#include <stdbool.h> #include <stdbool.h>
#include <util/delay.h> #include <util/delay.h>
#include "debug.h" #include "debug.h"
#include "ring_buffer.h"
#include "ibm4704.h" #include "ibm4704.h"






void ibm4704_init(void) void ibm4704_init(void)
{ {
inhibit();
IBM4704_INT_INIT();
IBM4704_INT_ON();
idle();
} }


/* /*
bool parity = true; // odd parity bool parity = true; // odd parity
ibm4704_error = 0; ibm4704_error = 0;


IBM4704_INT_OFF();

/* Request to send */ /* Request to send */
idle(); idle();
clock_lo(); clock_lo();
/* Data bit */ /* Data bit */
for (uint8_t i = 0; i < 8; i++) { for (uint8_t i = 0; i < 8; i++) {
WAIT(clock_hi, 100, 0x40+i); WAIT(clock_hi, 100, 0x40+i);
//_delay_us(5);
if (data&(1<<i)) { if (data&(1<<i)) {
parity = !parity; parity = !parity;
data_hi(); data_hi();
/* End */ /* End */
WAIT(data_lo, 100, 0x36); WAIT(data_lo, 100, 0x36);


inhibit();
_delay_us(200); // wait to recover clock to hi
idle();
IBM4704_INT_ON();
return 0; return 0;
ERROR: ERROR:
inhibit();
if (ibm4704_error >= 0x30) {
xprintf("x%02X ", ibm4704_error);
idle();
if (ibm4704_error > 0x30) {
xprintf("S:%02X ", ibm4704_error);
} }
_delay_us(200); // wait to recover clock to hi
IBM4704_INT_ON();
return -1; return -1;
} }


/* receive data when host want else inhibit communication */
/* wait forever to receive data */
uint8_t ibm4704_recv_response(void) uint8_t ibm4704_recv_response(void)
{ {
// 250 * 100us(wait start bit in ibm4704_recv)
uint8_t data = 0;
uint8_t try = 250;
do {
data = ibm4704_recv();
} while (try-- && ibm4704_error);
return data;
while (!rbuf_has_data()) {
_delay_ms(1);
}
return rbuf_dequeue();
} }


/* /*
*/ */
uint8_t ibm4704_recv(void) uint8_t ibm4704_recv(void)
{ {
uint8_t data = 0;
bool parity = true; // odd parity
ibm4704_error = IBM4704_ERR_NONE;

idle();
_delay_us(5); // wait for line settles

/* start bit */
WAIT(clock_lo, 100, 0x11); // wait for keyboard to send
WAIT(data_hi, 100, 0x12); // can be delayed that long

WAIT(clock_hi, 100, 0x13); // first rising edge which can take longer
/* data */
for (uint8_t i = 0; i < 8; i++) {
WAIT(clock_hi, 100, 0x20+i);
//_delay_us(5);
if (data_in()) {
parity = !parity;
data |= (1<<i);
}
WAIT(clock_lo, 150, 0x28+i);
if (rbuf_has_data()) {
return rbuf_dequeue();
} else {
return -1;
} }
}


/* parity */
WAIT(clock_hi, 100, 0x17);
if (data_in() != parity) {
ibm4704_error = IBM4704_ERR_PARITY;
goto ERROR;
}
WAIT(clock_lo, 150, 0x18);

/* stop bit */
WAIT(clock_hi, 100, 0x19);
WAIT(data_lo, 1, 0x19);
ISR(IBM4704_INT_VECT)
{
static enum {
INIT, START, BIT0, BIT1, BIT2, BIT3, BIT4, BIT5, BIT6, BIT7, PARITY,
} state = INIT;
// LSB first
static uint8_t data = 0;
// Odd parity
static uint8_t parity = false;


inhibit();
_delay_us(200); // wait to recover clock to hi
return data;
ERROR:
if (ibm4704_error > 0x12) {
xprintf("x%02X ", ibm4704_error);
ibm4704_error = 0;
// return unless falling edge
if (clock_in()) { goto RETURN; } // why this occurs?

state++;
switch (state) {
case START:
// Data:Low
WAIT(data_hi, 10, state);
break;
case BIT0:
case BIT1:
case BIT2:
case BIT3:
case BIT4:
case BIT5:
case BIT6:
case BIT7:
data >>= 1;
if (data_in()) {
data |= 0x80;
parity = !parity;
}
break;
case PARITY:
if (data_in()) {
parity = !parity;
}
if (!parity)
goto ERROR;
rbuf_enqueue(data);
ibm4704_error = IBM4704_ERR_NONE;
goto DONE;
break;
default:
goto ERROR;
} }
inhibit();
_delay_us(200); // wait to recover clock to hi
return -1;
goto RETURN;
ERROR:
ibm4704_error = state;
while (ibm4704_send(0xFE)) _delay_ms(1); // resend
xprintf("R:%02X\n", data);
DONE:
state = INIT;
data = 0;
parity = false;
RETURN:
return;
} }