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"
13 #include "keyboard_tables.h"
14 #if defined(_FM77AV_VARIANTS)
16 #include "fm77av_hidden_message_keyboard.h"
19 ID_KEYBOARD_RXRDY_OK = 1,
21 ID_KEYBOARD_RXRDY_BUSY,
22 ID_KEYBOARD_RTC_COUNTUP,
24 ID_KEYBOARD_AUTOREPEAT_FIRST,
25 ID_KEYBOARD_AUTOREPEAT,
26 ID_KEYBOARD_HIDDENMESSAGE_AV,
27 ID_KEYBOARD_HIDDEN_BEEP_ON,
28 ID_KEYBOARD_HIDDEN_BEEP_OFF,
35 // 0xd400(SUB) or 0xfd00(MAIN)
36 uint8_t KEYBOARD::get_keycode_high(void)
39 if((keycode_7 & 0x0100) != 0) data = 0x80;
43 // 0xd401(SUB) or 0xfd01(MAIN)
44 uint8_t KEYBOARD::get_keycode_low(void)
46 uint8_t data = keycode_7 & 0xff;
47 this->write_signals(&int_line, 0x00000000);
52 void KEYBOARD::turn_on_ins_led(void)
54 this->write_signals(&ins_led, 0xff);
58 void KEYBOARD::turn_off_ins_led(void)
60 this->write_signals(&ins_led, 0x00);
64 uint16_t KEYBOARD::vk2scancode(uint32_t vk)
68 if(vk == VK_PAUSE) vk = VK_KANJI; // Workaround some desktop environments for [ESC].
70 if(vk_matrix_106[i] == vk) return i;
72 } while(vk_matrix_106[i] != 0xffff);
76 bool KEYBOARD::isModifier(uint16_t sc)
78 if(((sc >= 0x52) && (sc <= 0x56)) || // CTRL LSHIFT RSHIFT CAPS GRPH
79 (sc == 0x5a) || (sc == 0x5c)) { // KANA BREAK
85 void KEYBOARD::set_modifiers(uint16_t sc, bool flag)
87 if(sc == 0x52) { // CTRL
89 } else if(sc == 0x53) { // LSHIFT
90 lshift_pressed = flag;
91 shift_pressed = lshift_pressed | rshift_pressed;
92 //printf("LSHIFT : %d\n", flag ? 1 : 0);
93 } else if(sc == 0x54) { // RSHIFT
94 rshift_pressed = flag;
95 shift_pressed = lshift_pressed | rshift_pressed;
96 //printf("RSHIFT : %d\n", flag ? 1 : 0);
97 } else if(sc == 0x56) { // GRPH
99 } else if(sc == 0x55) { // CAPS
103 caps_pressed = false;
107 if(keymode == KEYMODE_STANDARD) this->write_signals(&caps_led, caps_pressed ? 0xff : 0x00);
108 //this->write_signals(&caps_led, caps_pressed ? 0xff : 0x00);
110 } else if(sc == 0x5a) { // KANA
114 kana_pressed = false;
118 if(keymode == KEYMODE_STANDARD) this->write_signals(&kana_led, kana_pressed ? 0xff : 0x00);
120 } else if(sc == 0x5c) { // Break
121 break_pressed = flag;
125 uint16_t KEYBOARD::scan2fmkeycode(uint16_t sc)
127 const struct key_tbl_t *keyptr = NULL;
132 if((sc == 0) || (sc >= 0x67)) return 0xffff;
133 // Set repeat flag(s)
134 if(shift_pressed && ctrl_pressed) {
148 if(keymode == KEYMODE_STANDARD) {
151 keyptr = ctrl_shift_key;
155 } else if(graph_pressed) {
157 keyptr = graph_shift_key;
161 } else if(kana_pressed) {
163 keyptr = kana_shift_key;
170 keyptr = standard_shift_key;
172 keyptr = standard_key;
176 #if defined(_FM77AV_VARIANTS)
177 else if(shift_pressed) {
178 // DO super-impose mode:
180 // F8 : IMPOSE (High brightness)
181 // F9 : IMPOSE (Low brightness)
184 if(keymode == KEYMODE_SCAN) {
187 } else if(keymode == KEYMODE_16BETA) { // Will Implement
190 keyptr = ctrl_shift_key_16beta;
192 keyptr = ctrl_key_16beta;
194 } else if(graph_pressed) {
196 keyptr = graph_shift_key_16beta;
198 keyptr = graph_key_16beta;
200 } else if(kana_pressed) {
202 keyptr = kana_shift_key_16beta;
204 keyptr = kana_key_16beta;
209 keyptr = standard_shift_key_16beta;
211 keyptr = standard_key_16beta;
215 #endif //_FM77AV_VARIANTS
218 if (keyptr == NULL) return 0xffff;
220 if(keyptr[i].phy == sc) {
221 retval = keyptr[i].code;
225 } while(keyptr[i].phy != 0xffff);
226 if(keyptr[i].phy == 0xffff) return 0x00;
228 if((retval >= 'A') && (retval <= 'Z')) {
232 } else if((retval >= 'a') && (retval <= 'z')) {
241 void KEYBOARD::key_up(uint32_t vk)
243 uint16_t bak_scancode = vk2scancode(vk);
244 bool stat_break = break_pressed;
246 if(bak_scancode == 0) return;
247 if((event_keyrepeat >= 0) && (repeat_keycode == bak_scancode)) { // Not Break
248 cancel_event(this, event_keyrepeat);
249 event_keyrepeat = -1;
252 if(keymode != KEYMODE_SCAN) {
253 if(this->isModifier(bak_scancode)) {
254 set_modifiers(bak_scancode, false);
255 if(break_pressed != stat_break) { // Break key UP.
256 this->write_signals(&break_line, 0x00);
261 if((keymode == KEYMODE_SCAN) && (bak_scancode != 0)) { // Notify even key-up, when using SCAN mode.
262 uint32_t code = (bak_scancode & 0x7f) | 0x80;
263 key_fifo->write(code);
265 scancode = bak_scancode;
270 void KEYBOARD::key_down(uint32_t vk)
272 if(older_vk == vk) return;
275 scancode = vk2scancode(vk);
276 #if defined(_FM77AV_VARIANTS)
277 // Below are FM-77AV's hidden message , see :
278 // https://twitter.com/maruan/status/499558392092831745
279 //if(caps_pressed && kana_pressed) {
280 // if(ctrl_pressed && lshift_pressed && rshift_pressed && graph_pressed) {
281 if(caps_pressed && kana_pressed && graph_pressed && shift_pressed && ctrl_pressed && !did_hidden_message_av_1) { // IT's deprecated key pressing
282 if(scancode == 0x15) { // "T"
283 if(event_hidden1_av < 0) {
285 did_hidden_message_av_1 = true;
287 ID_KEYBOARD_HIDDENMESSAGE_AV,
288 130.0 * 1000, true, &event_hidden1_av);
297 void KEYBOARD::key_down_main(void)
299 bool stat_break = break_pressed;
301 if(scancode == 0) return;
302 if(keymode == KEYMODE_SCAN) {
303 code = scancode & 0x7f;
305 key_fifo->write(code);
307 // Overwrite repeat key code.
308 double usec = (double)repeat_time_long * 1000.0;
309 if(event_keyrepeat >= 0) cancel_event(this, event_keyrepeat);
310 event_keyrepeat = -1;
311 repeat_keycode = (uint8_t)code;
312 if(repeat_mode) register_event(this,
313 ID_KEYBOARD_AUTOREPEAT_FIRST,
314 usec, false, &event_keyrepeat);
318 if(this->isModifier(scancode)) { // modifiers
319 set_modifiers(scancode, true);
320 if(break_pressed != stat_break) { // Break key Down.
321 this->write_signals(&break_line, 0xff);
323 //printf("DOWN SCAN=%04x break=%d\n", scancode, break_pressed);
326 code = scan2fmkeycode(scancode);
327 if((code > 0x3ff) || (code == 0)) return;
329 key_fifo->write(code);
330 if(scancode < 0x5c) {
331 double usec = (double)repeat_time_long * 1000.0;
332 if(event_keyrepeat >= 0) cancel_event(this, event_keyrepeat);
333 event_keyrepeat = -1;
334 repeat_keycode = (uint8_t)scancode;
335 if(repeat_mode) register_event(this,
336 ID_KEYBOARD_AUTOREPEAT_FIRST,
337 usec, false, &event_keyrepeat);
343 #if defined(_FM77AV_VARIANTS)
344 void KEYBOARD::adjust_rtc(void)
346 get_host_time(&cur_time);
347 rtc_yy = cur_time.year % 100;
348 rtc_mm = cur_time.month;
349 rtc_dd = cur_time.day;
351 rtc_dayofweek = cur_time.day_of_week;
353 rtc_ispm = (cur_time.hour >= 12) ? true : false;
354 rtc_hour = cur_time.hour % 12;
357 rtc_hour = cur_time.hour;
359 rtc_minute = cur_time.minute;
360 rtc_sec = cur_time.second;
361 if(event_key_rtc >= 0) {
362 cancel_event(this, event_key_rtc);
364 register_event(this, ID_KEYBOARD_RTC_COUNTUP, 1000.0 * 1000.0, true, &event_key_rtc);
368 void KEYBOARD::do_repeatkey(uint16_t sc)
371 if((sc == 0) || (sc >= 0x5c)) return; // scancode overrun.
373 if(event_keyrepeat >= 0) {
374 cancel_event(this, event_keyrepeat);
375 event_keyrepeat = -1;
379 if(keymode == KEYMODE_SCAN) {
381 key_fifo->write((uint32_t)code); // Make
382 key_fifo->write((uint32_t)(code | 0x80)); // Break
384 code = scan2fmkeycode(sc);
386 key_fifo->write((uint32_t)code);
388 //this->write_signals(&int_line, 0xffffffff);
393 void KEYBOARD::event_callback(int event_id, int err)
395 #if defined(_FM77AV_VARIANTS)
396 if(event_id == ID_KEYBOARD_RXRDY_OK) {
398 write_signals(&rxrdy, 0xff);
399 } else if(event_id == ID_KEYBOARD_RXRDY_BUSY) {
400 rxrdy_status = false;
401 write_signals(&rxrdy, 0x00);
402 } else if(event_id == ID_KEYBOARD_ACK) {
403 key_ack_status = true;
404 write_signals(&key_ack, 0xff);
405 } else if(event_id == ID_KEYBOARD_RTC_COUNTUP) {
407 } else if(event_id == ID_KEYBOARD_HIDDENMESSAGE_AV) {
408 if(hidden_message_77av_1[hidden1_ptr] == 0x00) {
409 cancel_event(this, event_hidden1_av);
410 event_hidden1_av = -1;
413 key_fifo->write(hidden_message_77av_1[hidden1_ptr++]);
415 beep->write_signal(SIG_BEEP_MUTE, 0, 1);
416 beep->write_signal(SIG_BEEP_ON, 1, 1);
418 ID_KEYBOARD_HIDDEN_BEEP_OFF,
419 20.0 * 1000.0, false, NULL);
420 } else if(event_id == ID_KEYBOARD_HIDDEN_BEEP_ON) {
421 beep->write_signal(SIG_BEEP_MUTE, 0, 1);
422 beep->write_signal(SIG_BEEP_ON, 1, 1);
424 ID_KEYBOARD_HIDDEN_BEEP_OFF,
425 20.0 * 1000.0, false, NULL);
427 } else if(event_id == ID_KEYBOARD_HIDDEN_BEEP_OFF) {
428 beep->write_signal(SIG_BEEP_MUTE, 0, 1);
429 beep->write_signal(SIG_BEEP_ON, 0, 1);
432 if(event_id == ID_KEYBOARD_AUTOREPEAT_FIRST) {
433 uint32_t sc = (uint32_t)repeat_keycode;
434 double usec = (double)repeat_time_short * 1000.0;
436 //if((sc >= 0x67) || (sc == 0) || (sc == 0x5c)) return;
437 do_repeatkey((uint16_t)sc);
439 ID_KEYBOARD_AUTOREPEAT,
440 usec, true, &event_keyrepeat);
442 } else if(event_id == ID_KEYBOARD_AUTOREPEAT){
443 if(repeat_keycode != 0) {
444 do_repeatkey((uint16_t)repeat_keycode);
446 cancel_event(this, event_keyrepeat);
447 event_keyrepeat = -1;
449 } else if(event_id == ID_KEYBOARD_INT) {
450 if(!(key_fifo->empty())) {
451 keycode_7 = key_fifo->read();
452 this->write_signals(&int_line, 0xffffffff);
458 void KEYBOARD::reset_unchange_mode(void)
460 repeat_time_short = 70; // mS
461 repeat_time_long = 700; // mS
465 lshift_pressed = false;
466 rshift_pressed = false;
467 shift_pressed = false;
468 ctrl_pressed = false;
469 graph_pressed = false;
470 kana_pressed = false;
471 caps_pressed = false;
472 // ins_pressed = false;
474 repeat_keycode = 0x00;
476 #if defined(_FM77AV_VARIANTS)
479 if(event_key_rtc >= 0) {
480 cancel_event(this, event_key_rtc);
482 register_event(this,ID_KEYBOARD_RTC_COUNTUP, 1000.0 * 1000.0, true, &event_key_rtc);
485 if(event_keyrepeat >= 0) cancel_event(this, event_keyrepeat);
486 event_keyrepeat = -1;
488 if(event_hidden1_av >= 0) cancel_event(this, event_hidden1_av);
489 event_hidden1_av = -1;
493 this->write_signals(&break_line, 0x00);
494 #if defined(_FM77AV_VARIANTS)
495 rxrdy_status = false;
496 key_ack_status = true;
497 this->write_signals(&rxrdy, 0x00);
498 this->write_signals(&key_ack, 0xff);
500 this->write_signals(&kana_led, 0x00);
501 this->write_signals(&caps_led, 0x00);
502 this->write_signals(&ins_led, 0x00);
506 void KEYBOARD::reset(void)
508 keymode = KEYMODE_STANDARD;
511 keycode_7 = 0xffffffff;
512 reset_unchange_mode();
513 this->write_signals(&int_line, 0x00000000);
515 #if defined(_FM77AV_VARIANTS)
517 did_hidden_message_av_1 = false;
519 if(event_int >= 0) cancel_event(this, event_int);
522 20000.0, true, &event_int);
526 #if defined(_FM77AV_VARIANTS)
528 uint8 KEYBOARD::read_data_reg(void)
530 if(!data_fifo->empty()) {
531 datareg = data_fifo->read() & 0xff;
533 if(!data_fifo->empty()) {
535 write_signals(&rxrdy, 0xff);
537 rxrdy_status = false;
538 write_signals(&rxrdy, 0x00);
544 uint8_t KEYBOARD::read_stat_reg(void)
550 if(!key_ack_status) {
553 // Digityze : bit0 = '0' when waiting,
557 void KEYBOARD::set_mode(void)
559 int count = cmd_fifo->count();
562 if(count < 2) return;
563 cmd = cmd_fifo->read();
564 mode = cmd_fifo->read();
565 if(mode <= KEYMODE_SCAN) {
567 //printf("Keymode : %d\n", keymode);
568 //reset_unchange_mode();
569 if(scancode != 0) key_down_main();
572 data_fifo->clear(); // right?
573 rxrdy_status = false;
574 write_signals(&rxrdy, 0x00);
577 void KEYBOARD::get_mode(void)
581 cmd = cmd_fifo->read();
582 if(data_fifo->full()) {
583 dummy = data_fifo->read();
585 data_fifo->write(keymode);
587 write_signals(&rxrdy, 0xff);
590 void KEYBOARD::set_leds(void)
592 int count = cmd_fifo->count();
595 if(count < 2) return;
596 cmd = cmd_fifo->read();
597 ledvar = cmd_fifo->read();
599 if((ledvar & 0x02) != 0) {
601 kana_pressed = ((ledvar & 0x01) == 0);
602 write_signals(&kana_led, kana_pressed);
605 caps_pressed = ((ledvar & 0x01) == 0);
606 write_signals(&caps_led, caps_pressed);
610 data_fifo->clear(); // right?
611 rxrdy_status = false;
612 write_signals(&rxrdy, 0x00);
615 void KEYBOARD::get_leds(void)
617 uint8_t ledvar = 0x00;
619 ledvar |= caps_pressed ? 0x01 : 0x00;
620 ledvar |= kana_pressed ? 0x02 : 0x00;
621 data_fifo->write(ledvar);
624 write_signals(&rxrdy, 0xff);
627 void KEYBOARD::set_repeat_type(void)
632 cmd = cmd_fifo->read();
633 if(!cmd_fifo->empty()) {
634 modeval = cmd_fifo->read();
635 if((modeval < 2) && (modeval >= 0)) {
636 repeat_mode = (modeval == 0);
646 rxrdy_status = false;
647 write_signals(&rxrdy, 0x00);
650 void KEYBOARD::set_repeat_time(void)
653 uint32_t time_high = 0;
654 uint32_t time_low = 0;
655 cmd = cmd_fifo->read();
656 if(cmd_fifo->empty()) goto _end;
657 time_high = cmd_fifo->read();
658 if(cmd_fifo->empty()) goto _end;
659 time_low = cmd_fifo->read();
660 // if(cmd_fifo->empty()) goto _end;
662 if((time_high == 0) || (time_low == 0)) {
663 repeat_time_long = 700;
664 repeat_time_short = 70;
666 repeat_time_long = (int)time_high * 10;
667 repeat_time_short = (int)time_low * 10;
671 rxrdy_status = false;
672 write_signals(&rxrdy, 0x00);
675 void KEYBOARD::set_rtc(void)
680 if(cmd_fifo->count() < 9) return;
681 cmd = cmd_fifo->read();
682 localcmd = cmd_fifo->read();
684 tmp = cmd_fifo->read();
685 rtc_yy = ((tmp >> 4) * 10) | (tmp & 0x0f);
687 tmp = cmd_fifo->read();
688 rtc_mm = ((tmp >> 4) * 10) | (tmp & 0x0f);
690 tmp = cmd_fifo->read();
691 rtc_dd = (((tmp & 0x30) >> 4) * 10) | (tmp & 0x0f);
693 tmp = cmd_fifo->read();
694 rtc_count24h = ((tmp & 0x08) != 0);
696 rtc_ispm = ((tmp & 0x04) != 0);
698 rtc_dayofweek = (tmp >> 4) % 0x07;
699 rtc_hour = ((tmp & 0x03) * 10);
701 tmp = cmd_fifo->read();
702 rtc_hour = rtc_hour | (tmp >> 4);
704 rtc_ispm = (rtc_hour >= 12);
706 rtc_minute = (tmp & 0x0f) * 10;
708 tmp = cmd_fifo->read();
709 rtc_minute = rtc_minute | (tmp >> 4);
710 rtc_sec = (tmp & 0x0f) * 10;
712 tmp = cmd_fifo->read();
713 rtc_sec = rtc_sec | (tmp >> 4);
717 if(event_key_rtc >= 0) {
718 cancel_event(this, event_key_rtc);
720 register_event(this, ID_KEYBOARD_RTC_COUNTUP, 1000.0 * 1000.0, true, &event_key_rtc);
721 rxrdy_status = false;
722 write_signals(&rxrdy, 0x00);
725 void KEYBOARD::get_rtc(void)
730 tmp = ((rtc_yy / 10) << 4) | (rtc_yy % 10);
731 data_fifo->write(tmp);
733 tmp = ((rtc_mm / 10) << 4) | (rtc_mm % 10);
734 data_fifo->write(tmp);
736 tmp = ((rtc_dd / 10) << 4) | (rtc_dd % 10);
737 tmp = tmp | (0 << 6); // leap
738 data_fifo->write(tmp);
740 tmp = rtc_dayofweek << 4;
741 tmp = tmp | (rtc_hour / 10);
749 data_fifo->write(tmp);
751 tmp = (rtc_hour % 10) << 4;
752 tmp = tmp | (rtc_minute / 10);
753 data_fifo->write(tmp);
755 tmp = (rtc_minute % 10) << 4;
756 tmp = tmp | (rtc_sec / 10);
757 data_fifo->write(tmp);
759 tmp = (rtc_sec % 10) << 4;
760 data_fifo->write(tmp);
764 write_signals(&rxrdy, 0xff);
767 const int rtc_month_days[12] = {
768 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
771 void KEYBOARD::rtc_count(void)
778 if(rtc_minute >= 60) {
782 rtc_ispm = (rtc_hour >= 12);
783 if(rtc_hour < 24) return;
786 if(rtc_hour < 12) return;
788 if(rtc_hour < 12) return;
798 if(rtc_dayofweek >= 7) rtc_dayofweek = 0;
799 if(rtc_dd > rtc_month_days[rtc_mm]){
800 if((rtc_mm ==1) && (rtc_dd == 29)) {
801 if((rtc_yy % 4) == 0) return;
808 if(rtc_yy >= 100) rtc_yy = 0;
814 #endif // FM77AV_VARIANTS
816 uint32_t KEYBOARD::read_signal(int id)
818 if(id == SIG_FM7KEY_BREAK_KEY) {
819 return break_pressed ? 0xfffffff : 0x00000000;
825 void KEYBOARD::write_signal(int id, uint32_t data, uint32_t mask)
827 if(id == SIG_FM7KEY_SET_INSLED) {
828 write_signals(&ins_led, data & mask);
830 #if defined(_FM77AV_VARIANTS)
831 else if(id == SIG_FM7KEY_PUSH_TO_ENCODER) {
833 * I refered XM7's sourcecode : VM/keyboard.c act of key-encoder.
834 * Thanks to Ryu.Takegami and PI.
837 if(!key_ack_status) return; // If (not(ACK)) noop.
839 if(cmd_fifo->full()) {
842 if(cmd_fifo->empty()) {
843 cmd_phase = data & 0xff;
846 cmd_fifo->write(data & 0xff);
847 count = cmd_fifo->count();
849 rxrdy_status = false;
850 key_ack_status = false;
851 write_signals(&key_ack, 0x00);
852 write_signals(&rxrdy, 0x00);
858 if(keymode == KEYMODE_SCAN) key_down_main();
868 case 2: // Set LED Phase
871 if(keymode == KEYMODE_SCAN) key_down_main();
876 case 3: // Get LED Phase
895 case 0x80: // Communicate to/from RTC.
900 if((data & 0xff) == 0) { // Get
904 } else if((data & 0xff) == 1) { // Set
919 case 0x81: // Digitize.
921 do_digitize(); // WILL Implement?
928 set_screen_mode(); // WILL Implement?
934 get_screen_mode(); // WILL Implement?
940 set_brightness(); // WILL Implement?
950 register_event(this, ID_KEYBOARD_ACK, 5, false, NULL); // Delay 5us until ACK is up.
951 } else if(id == SIG_FM7KEY_RXRDY) {
952 rxrdy_status = ((data & mask) != 0);
953 //write_signals(&rxrdy, (rxrdy_status) ? 0xffffffff : 0x00000000);
954 } else if(id == SIG_FM7KEY_ACK) {
955 key_ack_status = ((data & mask) != 0);
956 //write_signals(&key_ack, (key_ack_status) ? 0xffffffff : 0x00000000);
962 uint32_t KEYBOARD::read_data8(uint32_t addr)
964 uint32_t retval = 0xff;
967 retval = get_keycode_high();
970 retval = get_keycode_low();
972 #if defined(_FM77AV_VARIANTS)
974 retval = read_data_reg();
977 retval = read_stat_reg();
986 void KEYBOARD::write_data8(uint32_t addr, uint32_t data)
989 #if defined(_FM77AV_VARIANTS)
991 this->write_signal(SIG_FM7KEY_PUSH_TO_ENCODER, data, 0x000000ff);
997 KEYBOARD::KEYBOARD(VM *parent_vm, EMU *parent_emu) : DEVICE(parent_vm, parent_emu)
1002 keycode_7 = 0xffffffff;
1004 ctrl_pressed = false;
1005 lshift_pressed = false;
1006 rshift_pressed = false;
1007 shift_pressed = false;
1008 graph_pressed = false;
1009 caps_pressed = false;
1010 kana_pressed = false;
1011 break_pressed = false;
1012 event_keyrepeat = -1;
1014 keymode = KEYMODE_STANDARD;
1015 #if defined(_FM77AV_VARIANTS)
1016 cmd_fifo = new FIFO(16);
1017 data_fifo = new FIFO(16);
1018 rxrdy_status = true;
1019 key_ack_status = false;
1020 initialize_output_signals(&rxrdy);
1021 initialize_output_signals(&key_ack);
1023 rtc_count24h = false;
1027 rtc_set_flag = false;
1035 event_hidden1_av = -1;
1038 key_fifo = new FIFO(512);
1041 initialize_output_signals(&break_line);
1042 initialize_output_signals(&int_line);
1044 initialize_output_signals(&kana_led);
1045 initialize_output_signals(&caps_led);
1046 initialize_output_signals(&ins_led);
1049 void KEYBOARD::release(void)
1051 #if defined(_FM77AV_VARIANTS)
1052 cmd_fifo->release();
1053 data_fifo->release();
1057 key_fifo->release();
1063 KEYBOARD::~KEYBOARD()
1067 #define STATE_VERSION 2
1068 void KEYBOARD::save_state(FILEIO *state_fio)
1070 state_fio->FputUint32_BE(STATE_VERSION);
1071 state_fio->FputInt32_BE(this_device_id);
1075 state_fio->FputUint32_BE(keycode_7);
1076 state_fio->FputInt32_BE(keymode);
1078 state_fio->FputBool(ctrl_pressed);
1079 state_fio->FputBool(lshift_pressed);
1080 state_fio->FputBool(rshift_pressed);
1081 state_fio->FputBool(shift_pressed);
1082 state_fio->FputBool(graph_pressed);
1083 state_fio->FputBool(caps_pressed);
1084 state_fio->FputBool(kana_pressed);
1085 state_fio->FputBool(break_pressed);
1087 state_fio->FputInt32_BE(event_keyrepeat);
1089 state_fio->FputUint32(scancode);
1090 state_fio->FputUint8(datareg);
1091 state_fio->FputUint32(older_vk);
1093 state_fio->FputBool(repeat_mode);
1094 state_fio->FputInt32_BE(repeat_time_short);
1095 state_fio->FputInt32_BE(repeat_time_long);
1096 state_fio->FputUint8(repeat_keycode);
1098 #if defined(_FM77AV_VARIANTS)
1099 state_fio->FputInt32_BE(event_key_rtc);
1101 state_fio->FputUint8(rtc_yy);
1102 state_fio->FputUint8(rtc_mm);
1103 state_fio->FputUint8(rtc_dd);
1104 state_fio->FputUint8(rtc_dayofweek);
1105 state_fio->FputUint8(rtc_hour);
1106 state_fio->FputUint8(rtc_minute);
1107 state_fio->FputUint8(rtc_sec);
1109 state_fio->FputBool(rtc_count24h);
1110 state_fio->FputBool(rtc_ispm);
1112 state_fio->FputBool(rtc_set);
1113 state_fio->FputBool(rtc_set_flag);
1114 state_fio->FputBool(rxrdy_status);
1115 state_fio->FputBool(key_ack_status);
1116 state_fio->FputInt32_BE(cmd_phase);
1118 state_fio->FputInt32_BE(event_hidden1_av);
1119 state_fio->FputUint16_BE(hidden1_ptr);
1121 cmd_fifo->save_state((void *)state_fio);
1122 data_fifo->save_state((void *)state_fio);
1123 cur_time.save_state((void *)state_fio);
1125 state_fio->FputInt32_BE(event_int);
1126 key_fifo->save_state((void *)state_fio);
1130 #if defined(_FM77AV_VARIANTS)
1131 state_fio->FputBool(did_hidden_message_av_1);
1136 bool KEYBOARD::load_state(FILEIO *state_fio)
1140 version = state_fio->FgetUint32_BE();
1141 if(this_device_id != state_fio->FgetInt32_BE()) return false;
1144 keycode_7 = state_fio->FgetUint32_BE();
1145 keymode = state_fio->FgetInt32_BE();
1147 ctrl_pressed = state_fio->FgetBool();
1148 lshift_pressed = state_fio->FgetBool();
1149 rshift_pressed = state_fio->FgetBool();
1150 shift_pressed = state_fio->FgetBool();
1151 graph_pressed = state_fio->FgetBool();
1152 caps_pressed = state_fio->FgetBool();
1153 kana_pressed = state_fio->FgetBool();
1154 break_pressed = state_fio->FgetBool();
1156 event_keyrepeat = state_fio->FgetInt32_BE();
1158 scancode = state_fio->FgetUint32();
1159 datareg = state_fio->FgetUint8();
1160 older_vk = state_fio->FgetUint32();
1162 repeat_mode = state_fio->FgetBool();
1163 repeat_time_short = state_fio->FgetInt32_BE();
1164 repeat_time_long = state_fio->FgetInt32_BE();
1165 repeat_keycode = state_fio->FgetUint8();
1167 #if defined(_FM77AV_VARIANTS)
1168 event_key_rtc = state_fio->FgetInt32_BE();
1169 rtc_yy = state_fio->FgetUint8();
1170 rtc_mm = state_fio->FgetUint8();
1171 rtc_dd = state_fio->FgetUint8();
1172 rtc_dayofweek = state_fio->FgetUint8();
1173 rtc_hour = state_fio->FgetUint8();
1174 rtc_minute = state_fio->FgetUint8();
1175 rtc_sec = state_fio->FgetUint8();
1177 rtc_count24h = state_fio->FgetBool();
1178 rtc_ispm = state_fio->FgetBool();
1180 rtc_set = state_fio->FgetBool();
1181 rtc_set_flag = state_fio->FgetBool();
1182 rxrdy_status = state_fio->FgetBool();
1183 key_ack_status = state_fio->FgetBool();
1184 cmd_phase = state_fio->FgetInt32_BE();
1186 event_hidden1_av = state_fio->FgetInt32_BE();
1187 hidden1_ptr = state_fio->FgetUint16_BE();
1189 cmd_fifo->load_state((void *)state_fio);
1190 data_fifo->load_state((void *)state_fio);
1191 cur_time.load_state((void *)state_fio);
1193 event_int = state_fio->FgetInt32_BE();
1194 key_fifo->load_state((void *)state_fio);
1195 if(version == 1) return true;
1200 #if defined(_FM77AV_VARIANTS)
1201 did_hidden_message_av_1 = state_fio->FgetBool();