/* | |||||
* Busywait | |||||
*/ | |||||
/* Pin configuration */ | |||||
#define IBM4704_CLOCK_PORT PORTD | #define IBM4704_CLOCK_PORT PORTD | ||||
#define IBM4704_CLOCK_PIN PIND | #define IBM4704_CLOCK_PIN PIND | ||||
#define IBM4704_CLOCK_DDR DDRD | #define IBM4704_CLOCK_DDR DDRD | ||||
#define IBM4704_DATA_DDR DDRD | #define IBM4704_DATA_DDR DDRD | ||||
#define IBM4704_DATA_BIT 0 | #define IBM4704_DATA_BIT 0 | ||||
/* | |||||
* Pin interrupt | |||||
*/ | |||||
#ifdef IBM4704_USE_INT | |||||
#define IBM4704_INT_INIT() do { \ | |||||
EICRA |= ((1<<ISC11) | \ | |||||
(0<<ISC10)); \ | |||||
} while (0) | |||||
#define IBM4704_INT_ON() do { \ | |||||
EIMSK |= (1<<INT1); \ | |||||
} while (0) | |||||
#define IBM4704_INT_OFF() do { \ | |||||
EIMSK &= ~(1<<INT1); \ | |||||
} while (0) | |||||
/* Pin interrupt on rising edge */ | |||||
#define IBM4704_INT_INIT() do { EICRA |= ((1<<ISC11)|(0<<ISC10)); } while (0) | |||||
#define IBM4704_INT_ON() do { EIMSK |= (1<<INT1); } while (0) | |||||
#define IBM4704_INT_OFF() do { EIMSK &= ~(1<<INT1); } while (0) | |||||
#define IBM4704_INT_VECT INT1_vect | #define IBM4704_INT_VECT INT1_vect | ||||
#endif | |||||
#endif | #endif |
Model 100 50-key A2h | Model 100 50-key A2h | ||||
Model 200 62-key A3h | Model 200 62-key A3h | ||||
Model 300 77-key A4h | Model 300 77-key A4h | ||||
Model 400 107-key ?? | |||||
Model 400 107-key A5h | |||||
Japanese/Chinese 102-key A6h | Japanese/Chinese 102-key A6h | ||||
extern const uint16_t fn_actions[]; | extern const uint16_t fn_actions[]; | ||||
/* Original keys */ | |||||
/* 77, 107-key From Ellipse@Deskthority | |||||
* http://deskthority.net/workshop-f7/tmk-keyboard-firmware-collection-t4478-90.html#p190550 | |||||
* 77-key | |||||
K00,K18,K19,K1A,K10,K11,K12,K08,K09,K0A,K0F,K1F,K0D,K0C,K0E, K44,K45,K46, \ | |||||
K04,K05,K06,K13,K14,K15,K16,K17,K01,K02,K03,K1B,K1C,K1D, K54,K55,K56, \ | |||||
K20,K21,K22,K23,K24,K25,K26,K27,K28,K29,K2A,K2B,K2C,K2D, K64,K65,K66, \ | |||||
K30,K3E,K32,K33,K34,K35,K36,K37,K38,K39,K3A,K3B,K3C,K3D, K74,K75,K76, \ | |||||
K31,K41,K3F, K40, K42,K2F, K77,K67,K71 \ | |||||
* 107-key | |||||
K00,K18, K19,K1A,K10,K11,K12,K08,K09,K0A,K0F,K1F,K0D,K0C,K0E,K46,K64, NO, K6B,K6C, K47,K48,K49,K4A, \ | |||||
K04,K05, K06,K13,K14,K15,K16,K17,K01,K02,K03,K1B,K1C,K1D,K56,K66, K6D,K6E,K6F, K4B,K4C,K4D,K4E, \ | |||||
K20,K21, K22,K23,K24,K25,K26,K27,K28,K29,K2A,K2B,K2C,K2D,K71,K77, K70,K65,K72, K50,K51,K52,K53, \ | |||||
K30, K3E,K32,K33,K34,K35,K36,K37,K38,K39,K3A,K3B,K3C,K3D,K44, K74,K75,K76, K5E,K58,K59,K5A, \ | |||||
K31,K41, K3F,K40,K42, K2F, K54,K55, K78,K67,K79, K5B,K5C,K5D,K57 \ | |||||
* IBM4704 scancode 00-79h | |||||
{ KC_##K00, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_NO }, \ | |||||
{ KC_##K08, KC_##K09, KC_##K0A, KC_NO, KC_##K0C, KC_##K0D, KC_##K0E, KC_##K0F }, \ | |||||
{ KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \ | |||||
{ KC_##K18, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_NO, KC_##K1F }, \ | |||||
{ KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27 }, \ | |||||
{ KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_NO, KC_##K2F }, \ | |||||
{ KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, \ | |||||
{ KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_##K3F }, \ | |||||
{ KC_##K40, KC_##K41, KC_##K42, KC_NO, KC_##K44, KC_NO, KC_##K46, KC_##K47 }, \ | |||||
{ KC_##K48, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, KC_##K4E, KC_NO }, \ | |||||
{ KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \ | |||||
{ KC_##K58, KC_##K59, KC_##K5A, KC_##K5B, KC_##K5C, KC_##K5D, KC_##K5E, KC_NO }, \ | |||||
{ KC_NO, KC_NO, KC_NO, KC_NO, KC_##K64, KC_##K65, KC_##K66, KC_##K67 }, \ | |||||
{ KC_NO, KC_NO, KC_NO, KC_##K6B, KC_##K6C, KC_##K6D, KC_##K6E, KC_##K6F }, \ | |||||
{ KC_##K70, KC_##K71, KC_##K72, KC_NO, KC_##K74, KC_##K75, KC_##K76, KC_##K77 }, \ | |||||
{ KC_##K78, KC_##K79, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, | |||||
*/ | |||||
/* 62-key */ | |||||
#define KEYMAP( \ | #define KEYMAP( \ | ||||
K00,K18,K19,K1A,K10,K11,K12,K08,K09,K0A,K0F,K1F,K0D,K0C,K0E, \ | K00,K18,K19,K1A,K10,K11,K12,K08,K09,K0A,K0F,K1F,K0D,K0C,K0E, \ | ||||
K04,K05,K06,K13,K14,K15,K16,K17,K01,K02,K03,K1B,K1C,K1D, \ | K04,K05,K06,K13,K14,K15,K16,K17,K01,K02,K03,K1B,K1C,K1D, \ | ||||
} | } | ||||
#endif | #endif | ||||
/* | |||||
{ K48, K49, K4A, K4B, K4C, K4D, K4E, K4F }, \ | |||||
{ K50, K51, K52, K53, K54, K55, K56, K57 }, \ | |||||
{ K58, K59, K5A, K5B, K5C, K5D, K5E, K5F }, \ | |||||
{ K60, K61, K62, K63, K64, K65, K66, K67 }, \ | |||||
{ K68, K69, K6A, K6B, K6C, K6D, K6E, K6F }, \ | |||||
{ K70, K71, K72, K73, K74, K75, K76, K77 }, \ | |||||
{ K78, K79, K7A, K7B, K7C, K7D, K7E, K7F }, \ | |||||
*/ |
{ | { | ||||
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 = true; | ||||
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; |
#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%02X\n", state, data); | |||||
DONE: | |||||
state = INIT; | |||||
data = 0; | |||||
parity = false; | |||||
RETURN: | |||||
return; | |||||
} | } |
#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 */ |