2 * Common Source code Project -> VM -> FM-7/77AV -> Keyboard
3 * (C) 2015 K.Ohta <whatisthis.sowhat _at_ gmail.com>
6 * Feb 12, 2015 : Initial
9 #include "../../fifo.h"
10 #include "../device.h"
11 #include "fm7_keyboard.h"
14 const uint16 vk_matrix_106[0x68] = { // VK
15 // +0, +1, +2, +3, +4, +5, +6, +7
16 /* 0x00, ESC, 1 , 2, 3, 4, 5, 6 */
17 0x00, VK_PAUSE, '1', '2', '3', '4', '5', '6', // +0x00
18 /* 7, 8, 9, 0, - , ^, \|, BS */
19 '7', '8', '9', '0', 0xbd, 0xde, 0xdc, VK_BACK, // +0x08
20 /* TAB, Q, W, E, R, T, Y, U */
21 VK_TAB, 'Q', 'W', 'E', 'R', 'T', 'Y', 'U', // +0x10
22 /* I, O, P, @, [, [RET], A, S */
23 'I', 'O', 'P', 0xc0, 0xdb, VK_RETURN, 'A', 'S', //+0x18
24 /* D, F, G, H, J, K, L, ; */
25 'D', 'F', 'G', 'H', 'J', 'K', 'L', 0xbb, // +0x20
26 /* :, ], Z, X, C, V, B, N */
27 0xba, 0xdd, 'Z', 'X', 'C', 'V', 'B', 'N', // +0x28
28 /* M, , , ., / , \, RSPACE=RWIN , * , / */
29 'M', 0xbc, 0xbe, 0xbf, 0xe2, VK_RWIN, VK_MULTIPLY, VK_DIVIDE, // +0x30
30 /* + , - , 7, 8, 9, = , 4, 5 */
31 VK_ADD, VK_SUBTRACT, VK_NUMPAD7, VK_NUMPAD8, VK_NUMPAD9, 0x00, VK_NUMPAD4, VK_NUMPAD5, // +0x38
32 /* 6, NUMPADCOMMA=RMENU , 1, 2, 3, NUMPADENTER=RETURN,0, . */
33 VK_NUMPAD6, VK_RMENU, VK_NUMPAD1, VK_NUMPAD2, VK_NUMPAD3, VK_RETURN, VK_NUMPAD0, VK_DECIMAL, // +0x40
34 /* INS, HOME, PRIOR, DEL, END, ↑, ↓,← */
35 VK_INSERT, VK_HOME, VK_PRIOR, VK_DELETE, VK_END, VK_UP, VK_NEXT, VK_LEFT, // +0x48
36 /* PAgeDown, →, LCTRL, LSHIFT, RSHIFT, CAPS, Graph=Muhenkan, Lspace=LALT */
37 VK_DOWN, VK_RIGHT, 0x11, 0x10, VK_RSHIFT, 0x14, 0x1d, 0xf3, // +0x50
38 /* Cspace=Space, *Unknown*, KANA, *Unknown* , ESC(Break), F1, F2, F3 */
39 VK_SPACE, 0x00, 0x15, 0x00, VK_ESCAPE, VK_F1, VK_F2, VK_F3, // +0x58
40 /* F4, F5, F6, F7, F8, F9, F10 , *END* */
41 VK_F4, VK_F5, VK_F6, VK_F7, VK_F8, VK_F9, VK_F10, 0xffff // +0x60
49 // Key tables value from XM7.
50 const key_tbl_t standard_key[] = {
155 const key_tbl_t standard_shift_key[] = {
248 const struct key_tbl_t ctrl_key[] = {
288 const struct key_tbl_t ctrl_shift_key[] = {
328 const struct key_tbl_t graph_key[] = {
416 /* Belows is none when shift */
429 const struct key_tbl_t graph_shift_key[] = {
521 const struct key_tbl_t kana_key[] = {
628 const struct key_tbl_t kana_shift_key[] = {
694 // 0xd400(SUB) or 0xfd00(MAIN)
695 uint8 KEYBOARD::get_keycode_high(void)
698 if((keycode_7 & 0x0100) != 0) data = 0x80;
702 // 0xd401(SUB) or 0xfd01(MAIN)
703 uint8 KEYBOARD::get_keycode_low(void)
705 uint8 data = keycode_7 & 0xff;
706 mainio->write_signal(FM7_MAINIO_KEYBOARDIRQ, 0, 1);
707 display->write_signal(SIG_FM7_SUB_KEY_FIRQ, 0, 1);
712 void KEYBOARD::turn_on_ins_led(void)
714 this->write_signals(&ins_led, 0xff);
718 void KEYBOARD::turn_off_ins_led(void)
720 this->write_signals(&ins_led, 0x00);
724 uint16 KEYBOARD::vk2scancode(uint32 vk)
729 if(vk_matrix_106[i] == vk) return i;
731 } while(vk_matrix_106[i] != 0xffff);
735 bool KEYBOARD::isModifier(uint16 sc)
737 if(((sc >= 0x52) && (sc <= 0x56)) || // CTRL LSHIFT RSHIFT CAPS GRPH
738 (sc == 0x5a) || (sc == 0x5c)) { // KANA BREAK
744 void KEYBOARD::set_modifiers(uint16 sc, bool flag)
746 if(sc == 0x52) { // CTRL
748 } else if(sc == 0x53) { // LSHIFT
749 lshift_pressed = flag;
751 shift_pressed = true;
753 shift_pressed = flag;
755 } else if(sc == 0x54) { // RSHIFT
756 rshift_pressed = flag;
758 shift_pressed = true;
760 shift_pressed = flag;
762 } else if(sc == 0x56) { // GRPH
763 graph_pressed = flag;
764 } else if(sc == 0x55) { // CAPS
768 caps_pressed = false;
772 if(keymode == KEYMODE_STANDARD) this->write_signals(&caps_led, caps_pressed ? 0xff : 0x00);
774 } else if(sc == 0x5a) { // KANA
778 kana_pressed = false;
782 if(keymode == KEYMODE_STANDARD) this->write_signals(&kana_led, kana_pressed ? 0xff : 0x00);
784 } else if(sc == 0x5c) { // Break
785 break_pressed = flag;
789 uint16 KEYBOARD::scan2fmkeycode(uint16 sc)
791 const struct key_tbl_t *keyptr;
796 if((sc == 0) || (sc >= 0x67)) return 0xffff;
797 // Set repeat flag(s)
798 if(shift_pressed && ctrl_pressed) {
812 if(keymode == KEYMODE_STANDARD) {
813 bool dmy = isModifier(sc);
816 keyptr = ctrl_shift_key;
820 } else if(graph_pressed) {
822 keyptr = graph_shift_key;
826 } else if(kana_pressed) {
828 keyptr = kana_shift_key;
835 keyptr = standard_shift_key;
837 keyptr = standard_key;
840 if(keyptr == NULL) return 0xffff;
842 #if defined(_FM77AV_VARIANTS)
843 else if(shift_pressed) {
844 // DO super-impose mode:
846 // F8 : IMPOSE (High brightness)
847 // F9 : IMPOSE (Low brightness)
850 if(keymode == KEYMODE_SCAN) {
853 } else if(keymode == KEYMODE_16BETA) { // Will Implement
856 #endif //_FM77AV_VARIANTS
860 if(keyptr[i].phy == sc) {
861 retval = keyptr[i].code;
865 } while(keyptr[i].phy != 0xffff);
868 if((retval >= 'A') && (retval <= 'Z')) {
872 } else if((retval >= 'a') && (retval <= 'z')) {
881 void KEYBOARD::key_up(uint32 vk)
883 scancode = vk2scancode(vk);
884 bool stat_break = break_pressed;
887 if(scancode == 0) return;
888 if(event_ids[scancode] >= 0){
889 cancel_event(this, event_ids[scancode]);
890 event_ids[scancode] = -1;
892 if(this->isModifier(scancode)) {
893 set_modifiers(scancode, false);
894 if(break_pressed != stat_break) { // Break key UP.
895 this->write_signals(&break_line, 0x00);
898 if(key_pressed_flag[scancode] == false) return;
899 key_pressed_flag[scancode] = false;
900 if(keymode == KEYMODE_SCAN) { // Notify even key-up, when using SCAN mode.
901 //printf("UP SCAN=%04x break=%d\n", scancode, stat_break);
903 code_7 = scancode | 0x80;
904 keycode_7 = code_7 | 0x8000;
905 mainio->write_signal(FM7_MAINIO_KEYBOARDIRQ, keycode_7, 0x8000);
906 display->write_signal(SIG_FM7_SUB_KEY_FIRQ, keycode_7, 0x8000);
911 void KEYBOARD::key_down(uint32 vk)
913 if(older_vk == vk) return;
916 scancode = vk2scancode(vk);
920 void KEYBOARD::key_down_main(void)
922 double usec = (double)repeat_time_long * 1000.0;
924 bool stat_break = break_pressed;
926 if(scancode == 0) return;
927 if(this->isModifier(scancode)) { // modifiers
928 set_modifiers(scancode, true);
929 if(break_pressed != stat_break) { // Break key Down.
930 this->write_signals(&break_line, 0xff);
933 code_7 = scan2fmkeycode(scancode);
934 if(keymode == KEYMODE_SCAN) {
935 code_7 = scancode & 0x7f;
937 //printf("DOWN SCAN=%04x 7CODE=%03x break=%d\n", scancode, code_7, stat_break);
938 if(key_pressed_flag[scancode] != false) return;
940 keycode_7 = code_7 | 0x8000;
941 //mainio->write_signal(FM7_MAINIO_PUSH_KEYBOARD, code_7, 0x1ff);
942 mainio->write_signal(FM7_MAINIO_KEYBOARDIRQ, keycode_7, 0x8000);
943 display->write_signal(SIG_FM7_SUB_KEY_FIRQ, keycode_7, 0x8000);
944 key_pressed_flag[scancode] = true;
947 // If repeat && !(PF) && !(BREAK)
948 if((repeat_mode) && (scancode < 0x5c) && (code_7 != 0xffff)) {
950 ID_KEYBOARD_AUTOREPEAT_FIRST + scancode,
951 usec, false, &event_ids[scancode]);
953 if(event_ids[scancode] >= 0) cancel_event(this, event_ids[scancode]);
954 event_ids[scancode] = -1;
956 key_pressed_flag[scancode] = true;
960 #if defined(_FM77AV_VARIANTS)
961 void KEYBOARD::adjust_rtc(void)
963 p_emu->get_host_time(&cur_time);
964 rtc_yy = cur_time.year % 100;
965 rtc_mm = cur_time.month;
966 rtc_dd = cur_time.day;
968 rtc_dayofweek = cur_time.day_of_week;
970 rtc_ispm = (cur_time.hour >= 12) ? true : false;
971 rtc_hour = cur_time.hour % 12;
974 rtc_hour = cur_time.hour;
976 rtc_minute = cur_time.minute;
977 rtc_sec = cur_time.second;
978 if(event_key_rtc >= 0) {
979 cancel_event(this, event_key_rtc);
981 register_event(this, ID_KEYBOARD_RTC_COUNTUP, 1000.0 * 1000.0, true, &event_key_rtc);
985 void KEYBOARD::do_repeatkey(uint16 sc)
988 if((sc == 0) || (sc >= 0x67)) return; // scancode overrun.
990 if(event_ids[sc] >= 0) {
991 cancel_event(this, event_ids[sc]);
996 key_pressed_flag[sc] = true;
997 code_7 = scan2fmkeycode(sc);
998 if(keymode == KEYMODE_SCAN) {
1001 if(code_7 < 0x200) {
1002 keycode_7 = code_7 | 0x8000;
1003 mainio->write_signal(FM7_MAINIO_KEYBOARDIRQ, keycode_7, 0x8000);
1004 display->write_signal(SIG_FM7_SUB_KEY_FIRQ, keycode_7, 0x8000);
1008 void KEYBOARD::event_callback(int event_id, int err)
1010 #if defined(_FM77AV_VARIANTS)
1011 if(event_id == ID_KEYBOARD_RXRDY_OK) {
1012 write_signals(&rxrdy, 0xff);
1013 } else if(event_id == ID_KEYBOARD_RXRDY_BUSY) {
1014 write_signals(&rxrdy, 0x00);
1015 } else if(event_id == ID_KEYBOARD_ACK) {
1016 //key_ack_status = true;
1017 write_signals(&key_ack, 0xff);
1018 } else if(event_id == ID_KEYBOARD_RTC_COUNTUP) {
1022 if((event_id >= ID_KEYBOARD_AUTOREPEAT_FIRST) && (event_id <= (ID_KEYBOARD_AUTOREPEAT_FIRST + 0x1ff))) {
1023 uint32 sc = event_id - ID_KEYBOARD_AUTOREPEAT_FIRST;
1024 double usec = (double)repeat_time_short * 1000.0;
1026 if((sc >= 0x67) || (sc == 0)) return;
1027 do_repeatkey((uint16)sc);
1028 register_event(this,
1029 ID_KEYBOARD_AUTOREPEAT + sc,
1030 usec, true, &event_ids[sc]);
1032 } else if((event_id >= ID_KEYBOARD_AUTOREPEAT) && (event_id <= (ID_KEYBOARD_AUTOREPEAT + 0x1ff))){
1033 uint32 sc = event_id - ID_KEYBOARD_AUTOREPEAT;
1034 do_repeatkey((uint16)sc);
1039 void KEYBOARD::reset_unchange_mode(void)
1042 repeat_time_short = 70; // mS
1043 repeat_time_long = 700; // mS
1048 lshift_pressed = false;
1049 rshift_pressed = false;
1050 ctrl_pressed = false;
1051 graph_pressed = false;
1052 // ins_pressed = false;
1056 #if defined(_FM77AV_VARIANTS)
1057 if(event_key_rtc >= 0) {
1058 cancel_event(this, event_key_rtc);
1060 register_event(this,ID_KEYBOARD_RTC_COUNTUP, 1000.0 * 1000.0, true, &event_key_rtc);
1063 for(i = 0; i < 0x70; i++) {
1064 if(event_ids[i] >= 0) cancel_event(this,event_ids[i]);
1066 key_pressed_flag[i] = false;
1070 this->write_signals(&break_line, 0x00);
1071 #if defined(_FM77AV_VARIANTS)
1072 rxrdy_status = false;
1073 key_ack_status = true;
1074 this->write_signals(&rxrdy, 0x00);
1075 this->write_signals(&key_ack, 0xff);
1076 this->write_signals(&kana_led, 0x00);
1077 this->write_signals(&caps_led, 0x00);
1078 this->write_signals(&ins_led, 0x00);
1080 this->write_signals(&kana_led, 0x00);
1081 this->write_signals(&caps_led, 0x00);
1082 this->write_signals(&ins_led, 0x00);
1087 void KEYBOARD::reset(void)
1089 keymode = KEYMODE_STANDARD;
1092 reset_unchange_mode();
1093 #if defined(_FM77AV_VARIANTS)
1099 #if defined(_FM77AV_VARIANTS)
1101 uint8 KEYBOARD::read_data_reg(void)
1103 if(!data_fifo->empty()) {
1104 datareg = data_fifo->read() & 0xff;
1106 if(data_fifo->empty()) {
1107 write_signals(&rxrdy, 0x00);
1109 write_signals(&rxrdy, 0xff);
1115 uint8 KEYBOARD::read_stat_reg(void)
1121 if(!key_ack_status) {
1124 // Digityze : bit0 = '0' when waiting,
1128 void KEYBOARD::set_mode(void)
1130 int count = cmd_fifo->count();
1133 if(count < 2) return;
1134 cmd = cmd_fifo->read();
1135 mode = cmd_fifo->read();
1136 if(mode <= KEYMODE_SCAN) {
1138 reset_unchange_mode();
1141 data_fifo->clear(); // right?
1142 write_signals(&rxrdy, 0x00);
1145 void KEYBOARD::get_mode(void)
1149 cmd = cmd_fifo->read();
1150 if(data_fifo->full()) {
1151 dummy = data_fifo->read();
1153 data_fifo->write(keymode);
1154 write_signals(&rxrdy, 0xff);
1157 void KEYBOARD::set_leds(void)
1159 int count = cmd_fifo->count();
1162 if(count < 2) return;
1163 cmd = cmd_fifo->read();
1164 ledvar = cmd_fifo->read();
1166 if((ledvar & 0x02) != 0) {
1168 kana_pressed = ((ledvar & 0x01) == 0);
1169 write_signals(&kana_led, kana_pressed);
1172 caps_pressed = ((ledvar & 0x01) == 0);
1173 write_signals(&caps_led, caps_pressed);
1177 data_fifo->clear(); // right?
1178 write_signals(&rxrdy, 0x00);
1181 void KEYBOARD::get_leds(void)
1183 uint8 ledvar = 0x00;
1185 ledvar |= caps_pressed ? 0x01 : 0x00;
1186 ledvar |= kana_pressed ? 0x02 : 0x00;
1187 data_fifo->write(ledvar);
1189 write_signals(&rxrdy, 0xff);
1192 void KEYBOARD::set_repeat_type(void)
1197 cmd = cmd_fifo->read();
1198 if(!cmd_fifo->empty()) {
1199 modeval = cmd_fifo->read();
1200 if((modeval < 2) && (modeval >= 0)) {
1201 repeat_mode = (modeval == 0);
1210 write_signals(&rxrdy, 0x00);
1213 void KEYBOARD::set_repeat_time(void)
1218 cmd = cmd_fifo->read();
1219 if(cmd_fifo->empty()) goto _end;
1220 time_high = cmd_fifo->read();
1221 if(cmd_fifo->empty()) goto _end;
1222 time_low = cmd_fifo->read();
1223 // if(cmd_fifo->empty()) goto _end;
1225 if((time_high == 0) || (time_low == 0)) {
1226 repeat_time_long = 700;
1227 repeat_time_short = 70;
1229 repeat_time_long = time_high * 10;
1230 repeat_time_short = time_low * 10;
1234 write_signals(&rxrdy, 0x00);
1237 void KEYBOARD::set_rtc(void)
1242 if(cmd_fifo->count() < 9) return;
1243 cmd = cmd_fifo->read();
1244 localcmd = cmd_fifo->read();
1246 tmp = cmd_fifo->read();
1247 rtc_yy = ((tmp >> 4) * 10) | (tmp & 0x0f);
1249 tmp = cmd_fifo->read();
1250 rtc_mm = ((tmp >> 4) * 10) | (tmp & 0x0f);
1252 tmp = cmd_fifo->read();
1253 rtc_dd = (((tmp & 0x30) >> 4) * 10) | (tmp & 0x0f);
1255 tmp = cmd_fifo->read();
1256 rtc_count24h = ((tmp & 0x08) != 0);
1258 rtc_ispm = ((tmp & 0x04) != 0);
1260 rtc_dayofweek = (tmp >> 4) % 0x07;
1261 rtc_hour = ((tmp & 0x03) * 10);
1263 tmp = cmd_fifo->read();
1264 rtc_hour = rtc_hour | (tmp >> 4);
1266 rtc_ispm = (rtc_hour >= 12);
1268 rtc_minute = (tmp & 0x0f) * 10;
1270 tmp = cmd_fifo->read();
1271 rtc_minute = rtc_minute | (tmp >> 4);
1272 rtc_sec = (tmp & 0x0f) * 10;
1274 tmp = cmd_fifo->read();
1275 rtc_sec = rtc_sec | (tmp >> 4);
1279 if(event_key_rtc >= 0) {
1280 cancel_event(this, event_key_rtc);
1282 register_event(this, ID_KEYBOARD_RTC_COUNTUP, 1000.0 * 1000.0, true, &event_key_rtc);
1283 write_signals(&rxrdy, 0x00);
1286 void KEYBOARD::get_rtc(void)
1291 tmp = ((rtc_yy / 10) << 4) | (rtc_yy % 10);
1292 data_fifo->write(tmp);
1294 tmp = ((rtc_mm / 10) << 4) | (rtc_mm % 10);
1295 data_fifo->write(tmp);
1297 tmp = ((rtc_dd / 10) << 4) | (rtc_dd % 10);
1298 tmp = tmp | (0 << 6); // leap
1299 data_fifo->write(tmp);
1301 tmp = rtc_dayofweek << 4;
1302 tmp = tmp | (rtc_hour / 10);
1310 data_fifo->write(tmp);
1312 tmp = (rtc_hour % 10) << 4;
1313 tmp = tmp | (rtc_minute / 10);
1314 data_fifo->write(tmp);
1316 tmp = (rtc_minute % 10) << 4;
1317 tmp = tmp | (rtc_sec / 10);
1318 data_fifo->write(tmp);
1320 tmp = (rtc_sec % 10) << 4;
1321 data_fifo->write(tmp);
1324 write_signals(&rxrdy, 0xff);
1327 const int rtc_month_days[12] = {
1328 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
1331 void KEYBOARD::rtc_count(void)
1338 if(rtc_minute >= 60) {
1342 rtc_ispm = (rtc_hour >= 12);
1343 if(rtc_hour < 24) return;
1346 if(rtc_hour < 12) return;
1348 if(rtc_hour < 12) return;
1358 if(rtc_dayofweek >= 7) rtc_dayofweek = 0;
1359 if(rtc_dd > rtc_month_days[rtc_mm]){
1360 if((rtc_mm ==1) && (rtc_dd == 29)) {
1361 if((rtc_yy % 4) == 0) return;
1368 if(rtc_yy >= 100) rtc_yy = 0;
1374 #endif // FM77AV_VARIANTS
1376 uint32 KEYBOARD::read_signal(int id)
1378 if(id == SIG_FM7KEY_BREAK_KEY) {
1379 return break_pressed ? 0xfffffff : 0x00000000;
1385 void KEYBOARD::write_signal(int id, uint32 data, uint32 mask)
1387 if(id == SIG_FM7KEY_SET_INSLED) {
1388 write_signals(&ins_led, data & mask);
1390 #if defined(_FM77AV_VARIANTS)
1391 else if(id == SIG_FM7KEY_PUSH_TO_ENCODER) {
1393 * I refered XM7's sourcecode : VM/keyboard.c act of key-encoder.
1394 * Thanks to Ryu.Takegami and PI.
1397 if(!key_ack_status) return; // If (not(ACK)) noop.
1399 if(cmd_fifo->full()) {
1402 if(cmd_fifo->empty()) {
1403 cmd_phase = data & 0xff;
1406 cmd_fifo->write(data & 0xff);
1407 count = cmd_fifo->count();
1409 write_signals(&key_ack, 0x00);
1410 key_ack_status = false;
1415 if(keymode == KEYMODE_SCAN) key_down_main();
1421 case 2: // Set LED Phase
1424 if(keymode == KEYMODE_SCAN) key_down_main();
1427 case 3: // Get LED Phase
1431 if(count >= 2) set_repeat_type();
1434 if(count >= 3) set_repeat_time();
1436 case 0x80: // Communicate to/from RTC.
1441 if((data & 0xff) == 0) { // Get
1443 } else if((data & 0xff) == 1) { // Set
1444 rtc_set_flag = true;
1455 case 0x81: // Digitize.
1456 if(count >= 2) do_digitize(); // WILL Implement?
1459 if(count >= 2) set_screen_mode();
1465 if(count >= 2) set_brightness();
1468 //cmd_fifo->clear();
1471 register_event(this, ID_KEYBOARD_ACK, 5, false, NULL); // Delay 5us until ACK is up.
1472 } else if(id == SIG_FM7KEY_RXRDY) {
1473 rxrdy_status = ((data & mask) != 0);
1474 //write_signals(&rxrdy, (rxrdy_status) ? 0xffffffff : 0x00000000);
1475 } else if(id == SIG_FM7KEY_ACK) {
1476 key_ack_status = ((data & mask) != 0);
1477 //write_signals(&key_ack, (key_ack_status) ? 0xffffffff : 0x00000000);
1483 uint32 KEYBOARD::read_data8(uint32 addr)
1485 uint32 retval = 0xff;
1488 retval = get_keycode_high();
1491 retval = get_keycode_low();
1493 #if defined(_FM77AV_VARIANTS)
1495 retval = read_data_reg();
1498 retval = read_stat_reg();
1507 void KEYBOARD::write_data8(uint32 addr, uint32 data)
1510 #if defined(_FM77AV_VARIANTS)
1512 this->write_signal(SIG_FM7KEY_PUSH_TO_ENCODER, data, 0x000000ff);
1518 KEYBOARD::KEYBOARD(VM *parent_vm, EMU *parent_emu) : DEVICE(parent_vm, parent_emu)
1526 ctrl_pressed = false;
1527 lshift_pressed = false;
1528 rshift_pressed = false;
1529 shift_pressed = false;
1530 graph_pressed = false;
1531 caps_pressed = false;
1532 kana_pressed = false;
1533 break_pressed = false;
1535 for(i = 0; i < 0x70; i++) {
1537 key_pressed_flag[i] = false;
1540 cmd_fifo = new FIFO(16);
1541 data_fifo = new FIFO(16);
1542 keymode = KEYMODE_STANDARD;
1543 #if defined(_FM77AV_VARIANTS)
1544 rxrdy_status = false;
1545 key_ack_status = false;
1546 init_output_signals(&rxrdy);
1547 init_output_signals(&key_ack);
1549 rtc_count24h = false;
1553 rtc_set_flag = false;
1563 init_output_signals(&break_line);
1565 init_output_signals(&kana_led);
1566 init_output_signals(&caps_led);
1567 init_output_signals(&ins_led);
1570 void KEYBOARD::release(void)
1572 cmd_fifo->release();
1573 data_fifo->release();
1578 KEYBOARD::~KEYBOARD()