Subversion Repositories pentevo

Rev

Blame | Last modification | View Log | Download | RSS feed | ?url?

  1. #include <avr/io.h>
  2. #include <avr/interrupt.h>
  3. #include <avr/pgmspace.h>
  4. #include <util/delay.h>
  5.  
  6. #include "mytypes.h"
  7. #include "zx.h"
  8. #include "kbmap.h"
  9. #include "pins.h"
  10. #include "getfaraddress.h"
  11. #include "main.h"
  12. #include "spi.h"
  13. #include "rs232.h"
  14. #include "ps2.h"
  15. #include "rtc.h"
  16.  
  17. //if want Log than comment next string
  18. #undef LOGENABLE
  19.  
  20. //zx mouse registers
  21. volatile UBYTE zx_mouse_button;
  22. volatile UBYTE zx_mouse_x;
  23. volatile UBYTE zx_mouse_y;
  24.  
  25. // PS/2 keyboard control keys status (for additional functons)
  26. volatile UBYTE kb_status;
  27.  
  28. #define ZX_FIFO_SIZE 256 /* do not change this since it must be exactly byte-wise */
  29.  
  30. UBYTE zx_fifo[ZX_FIFO_SIZE];
  31.  
  32. UBYTE zx_fifo_in_ptr;
  33. UBYTE zx_fifo_out_ptr;
  34.  
  35. UBYTE zx_counters[40]; // filter ZX keystrokes here to assure every is pressed and released only once
  36. UBYTE zx_map[5]; // keys bitmap. send order: LSbit first, from [4] to [0]
  37.  
  38. volatile UBYTE shift_pause;
  39.  
  40. UBYTE zx_realkbd[11];
  41.  
  42. void zx_init(void)
  43. {
  44.         zx_fifo_in_ptr=zx_fifo_out_ptr=0;
  45.  
  46.         zx_task(ZX_TASK_INIT);
  47.  
  48.         //reset Z80
  49.         zx_spi_send(SPI_RST_REG, 0, 0);
  50. }
  51.  
  52. UBYTE zx_spi_send(UBYTE addr, UBYTE data, UBYTE mask)
  53. {
  54.         UBYTE status;
  55.         UBYTE ret;
  56.         nSPICS_PORT &= ~(1<<nSPICS); // fix for status locking
  57.         nSPICS_PORT |= (1<<nSPICS);  // set address of SPI register
  58.         status = spi_send(addr);
  59.         nSPICS_PORT &= ~(1<<nSPICS); // send data for that register
  60.         ret = spi_send(data);
  61.         nSPICS_PORT |= (1<<nSPICS);
  62.  
  63.         //if CPU waited
  64.         if ( status&mask ) zx_wait_task(status);
  65.  
  66.         return ret;
  67. }
  68.  
  69. void zx_task(UBYTE operation) // zx task, tracks when there is need to send new keymap to the fpga
  70. {
  71.         static UBYTE prev_code;
  72.         static UBYTE task_state;
  73.         static UBYTE reset_type;
  74.  
  75.         UBYTE was_data;
  76.         UBYTE code,keynum,keybit;
  77.  
  78.         if ( operation==ZX_TASK_INIT )
  79.         {
  80.                 reset_type = 0;
  81.                 prev_code = KEY_V+1; // impossible scancode
  82.                 task_state = 0;
  83.                 shift_pause = 0;
  84.  
  85.                 zx_clr_kb();
  86.  
  87.                 //detect if CTRL-ALT-DEL keys mapped
  88.                 if ( ((kbmap[0x14*2] == NO_KEY) && (kbmap[0x14*2+1] == NO_KEY)) ||
  89.                          ((kbmap[0x11*2] == NO_KEY) && (kbmap[0x11*2+1] == NO_KEY)) ||
  90.                          ((kbmap_E0[0x11*2] == NO_KEY) && (kbmap[0x11*2+1] == NO_KEY)) )
  91.                 {
  92.                         //not mapped
  93.                         kb_status &= ~KB_CTRL_ALT_DEL_MAPPED_MASK;
  94.                 }
  95.                 else
  96.                 {
  97.                         //mapped
  98.                         kb_status |= KB_CTRL_ALT_DEL_MAPPED_MASK;
  99.                 }
  100.         }
  101.         else /*if(operation==ZX_TASK_WORK)*/
  102.  
  103.         // шч ЇшЇ√ яЁшїюфшЄ: эрцрЄш  ш юЄцрЄш  ЁхёхЄют, эрцрЄш  ш юЄцрЄш  ъэюяъют, CLRKYS (Єюы№ъю эрцрэшх).
  104.         // чрфрўр: єяфхщЄшЄ№ т ёююЄтхЄёЄтшш ё ¤Єшь сшЄьря ъэюяюъ, яюё√ырЄ№ хую т Їяує, яюё√ырЄ№ ЁхёхЄ√.
  105.         // ъЁюьх Єюую, фхырЄ№ ярєчє т єяфхщЄх сшЄьряр ш яюё√ыъх хую т Їяур ьхцфє эрцрЄшхь CS|SS ш яюёыхфє■∙хщ эх-CS|SS ъэюяъш,
  106.         // Ёртэю ъръ ш ьхцфє юЄцрЄшхь эх-CS|SS ъэюяъш ш яюёыхфє■∙шь юЄцрЄшхь CS|SS.
  107.  
  108.         // ёэрўрыр фхырхь Єєяю схч эшъръшї ярєч - ўЄюс√ ЁрсюЄрыю тююс∙х ё ЇшЇющ
  109.  
  110.         {
  111.                 if( !task_state )
  112.                 {
  113.                         nSPICS_PORT |= (1<<nSPICS);
  114.  
  115.                         was_data = 0;
  116.  
  117.                         while( !zx_fifo_isempty() )
  118.                         {
  119.                                 code=zx_fifo_copy(); // don't remove byte from fifo!
  120.  
  121.                                 if( code==CLRKYS )
  122.                                 {
  123.                                         was_data = 1; // we've got something!
  124.  
  125.                                         zx_fifo_get(); // remove byte from fifo
  126.  
  127.                                         reset_type = 0;
  128.                                         prev_code  = KEY_V+1;
  129.  
  130.                                         zx_clr_kb();
  131.  
  132.                                         break; // flush changes immediately to the fpga
  133.                                 }
  134. //                              else if( (code&KEY_MASK) >= RSTSYS )
  135. //                              {
  136. //                                      was_data = 1; // we've got something!
  137.  
  138. //                                      zx_fifo_get(); // remove byte from fifo
  139.  
  140. //                                      if( code&PRESS_MASK ) // reset key pressed
  141. //                                      {
  142. //                                              reset_type      = 0x30 & ((code+1)<<4);
  143. //                                              reset_type += 2;
  144.  
  145. //                                              break; // flush immediately
  146. //                                      }
  147. //                                      else // reset key released
  148. //                                      {
  149. //                                              reset_type = 0;
  150. //                                      }
  151. //                              }
  152.                                 else /*if( (code&KEY_MASK) < 40 )*/
  153.                                 {
  154.                                         if( shift_pause ) // if we inside pause interval and need checking
  155.                                         {
  156.                                                 if( (PRESS_MASK&prev_code) && (PRESS_MASK&code) )
  157.                                                 {
  158.                                                         if( /* prev key was CS|SS down */
  159.                                                                 ( (PRESS_MASK|KEY_CS)<=prev_code && prev_code<=(PRESS_MASK|KEY_SS) ) &&
  160.                                                                 /* curr key is not-CS|SS down */
  161.                                                                 ( code<(PRESS_MASK|KEY_CS) || (PRESS_MASK|KEY_SS)<code )
  162.                                                         )
  163.                                                                 break; // while loop
  164.                                                 }
  165.  
  166.                                                 if( (!(PRESS_MASK&prev_code)) && (!(PRESS_MASK&code)) )
  167.                                                 {
  168.                                                         if( /* prev key was not-CS|SS up */
  169.                                                                 ( prev_code<KEY_CS || KEY_SS<prev_code ) &&
  170.                                                                 /* curr key is CS|SS up */
  171.                                                                 ( KEY_CS<=prev_code && prev_code<=KEY_SS )
  172.                                                         )
  173.                                                                 break;
  174.                                                 }
  175.                                         }
  176.  
  177.                                         // just normal processing out of pause interval
  178.                                         keynum = (code&KEY_MASK)>>3;
  179.  
  180.                                         keybit = 0x0080 >> (code&7); // KEY_MASK - эрфьэюцхёЄтю сшЄют 7
  181.  
  182.                                         if( code&PRESS_MASK )
  183.                                                 zx_map[keynum] |=       keybit;
  184.                                         else
  185.                                                 zx_map[keynum] &= (~keybit);
  186.  
  187.                                         prev_code = code;
  188.                                         zx_fifo_get();
  189.                                         shift_pause = SHIFT_PAUSE; // init wait timer
  190.  
  191.                                         was_data = 1;
  192.                                 }
  193.                         }
  194.  
  195.                         if ( zx_realkbd[10] )
  196.                         {
  197.                                 for (UBYTE i=0; i<5; i++)
  198.                                 {
  199.                                          UBYTE tmp;
  200.                                          tmp = zx_realkbd[i+5];
  201.                                          was_data |= zx_realkbd[i] ^ tmp;
  202.                                          zx_realkbd[i] = tmp;
  203.                                 }
  204.                                 zx_realkbd[10] = 0;
  205.                         }
  206.  
  207.                         if( was_data ) // initialize transfer
  208.                         {
  209.                                 task_state = 6;
  210.                         }
  211.                 }
  212.                 else // sending bytes one by one in each state
  213.                 {
  214.                         task_state--;
  215. #ifdef LOGENABLE
  216.         char log_task_state[] = "TS..\r\n";
  217.         log_task_state[2] = ((task_state >> 4) <= 9 )?'0'+(task_state >> 4):'A'+(task_state >> 4)-10;
  218.         log_task_state[3] = ((task_state & 0x0F) <= 9 )?'0'+(task_state & 0x0F):'A'+(task_state & 0x0F)-10;
  219.         to_log(log_task_state);
  220. #endif
  221.  
  222. //                      if( task_state==6 ) // send (or not) reset
  223. //                      {
  224. //                              if( reset_type )
  225. //                              {
  226. //                                      zx_spi_send(SPI_RST_REG, reset_type, 0x7F);
  227. //#ifdef LOGENABLE
  228. //      char log_reset_type[] = "TR..\r\n";
  229. //      log_reset_type[2] = ((reset_type >> 4) <= 9 )?'0'+(reset_type >> 4):'A'+(reset_type >> 4)-10;
  230. //      log_reset_type[3] = ((reset_type & 0x0F) <= 9 )?'0'+(reset_type & 0x0F):'A'+(reset_type & 0x0F)-10;
  231. //      to_log(log_reset_type);
  232. //#endif
  233. //                              }
  234. //                      }
  235. //                      else
  236.                         if( task_state>0 )// task_state==5..1
  237.                         {
  238.                                 UBYTE key_data;
  239.                                 key_data = zx_map[task_state-1] | ~zx_realkbd[task_state-1];
  240.                                 zx_spi_send(SPI_KBD_DAT, key_data, 0x7F);
  241. #ifdef LOGENABLE
  242.         char log_zxmap_task_state[] = "TK.. .. ..\r\n";
  243.         log_zxmap_task_state[2] = ((key_data >> 4) <= 9 )?'0'+(key_data >> 4):'A'+(key_data >> 4)-10;
  244.         log_zxmap_task_state[3] = ((key_data & 0x0F) <= 9 )?'0'+(key_data & 0x0F):'A'+(key_data & 0x0F)-10;
  245.         log_zxmap_task_state[5] = ((zx_map[task_state-1] >> 4) <= 9 )?'0'+(zx_map[task_state-1] >> 4):'A'+(zx_map[task_state-1] >> 4)-10;
  246.         log_zxmap_task_state[6] = ((zx_map[task_state-1] & 0x0F) <= 9 )?'0'+(zx_map[task_state-1] & 0x0F):'A'+(zx_map[task_state-1] & 0x0F)-10;
  247.         log_zxmap_task_state[8] = ((zx_realkbd[task_state-1] >> 4) <= 9 )?'0'+(zx_realkbd[task_state-1] >> 4):'A'+(zx_realkbd[task_state-1] >> 4)-10;
  248.         log_zxmap_task_state[9] = ((zx_realkbd[task_state-1] & 0x0F) <= 9 )?'0'+(zx_realkbd[task_state-1] & 0x0F):'A'+(zx_realkbd[task_state-1] & 0x0F)-10;
  249.         to_log(log_zxmap_task_state);
  250. #endif
  251.                         }
  252.                         else // task_state==0
  253.                         {
  254.                                 UBYTE status;
  255.                                 nSPICS_PORT |= (1<<nSPICS);
  256.                                 status = spi_send(SPI_KBD_STB);    // strobe input kbd data to the Z80 port engine
  257.                                 nSPICS_PORT &= ~(1<<nSPICS);
  258.                                 nSPICS_PORT |= (1<<nSPICS);
  259.                                 if ( status&0x7F ) zx_wait_task(status);
  260. #ifdef LOGENABLE
  261.         to_log("STB\r\n");
  262. #endif
  263.                         }
  264.                 }
  265.         }
  266.  
  267. }
  268.  
  269. void zx_clr_kb(void)
  270. {
  271.         BYTE i;
  272.  
  273.         for( i=0; i<sizeof(zx_map)/sizeof(zx_map[0]); i++ )
  274.         {
  275.                 zx_map[i] = 0;
  276.         }
  277.  
  278.         for( i=0; i<sizeof(zx_realkbd)/sizeof(zx_realkbd[0]); i++ )
  279.         {
  280.                 zx_realkbd[i] = 0xff;
  281.         }
  282.  
  283.         for( i=0; i<sizeof(zx_counters)/sizeof(zx_counters[0]); i++ )
  284.         {
  285.                 zx_counters[i] = 0;
  286.         }
  287.  
  288.         kb_status = 0;
  289. }
  290.  
  291. void to_zx(UBYTE scancode, UBYTE was_E0, UBYTE was_release)
  292. {
  293.         ULONG tbldisp;
  294.         UBYTE* tblptr;
  295.         UBYTE tbl1,tbl2;
  296.  
  297.         tbl1=tbl2=NO_KEY;
  298.  
  299.         if( was_E0 )
  300.         {
  301.                 if( (scancode>=0x60) && (scancode<=0x7F) )
  302.                 {
  303.                         tbldisp = (scancode-0x60)*2;
  304.                         tblptr = kbmap_E0 + tbldisp;
  305.                         tbl1 = *( tblptr++ );
  306.                         tbl2 = *( tblptr );
  307.                 }
  308.  
  309.                 //additional functionality from ps/2 keyboard
  310.                 switch( scancode )
  311.                 {
  312.                         // keypad /
  313.                         case 0x4A:
  314.                                 tbl1 = KEY_SS;
  315.                                 tbl2 = KEY_V;
  316.                                 break;
  317.                         // keypad enter
  318.                         case 0x5A:
  319.                                 tbl1 = KEY_EN;
  320.                                 break;
  321.                         //Print Screen
  322.                         case 0x7C:
  323.                                 //set/reset NMI
  324.                                 zx_set_config( (was_release==0)? SPI_CONFIG_NMI_FLAG : 0 );
  325.                                 break;
  326.                         //Del
  327.                         case 0x71:
  328.                                 //Ctrl-Alt-Del pressed
  329.                                 if ( ( !was_release ) &&
  330.                                      ( !(kb_status & KB_CTRL_ALT_DEL_MAPPED_MASK) ) &&
  331.                                          ( (kb_status & (KB_CTRL_MASK|KB_ALT_MASK)) == (KB_CTRL_MASK|KB_ALT_MASK) ) )
  332.                                 {
  333.                                         //hard reset
  334.                                         flags_register |= FLAG_HARD_RESET;
  335.                                         tbl1=tbl2=NO_KEY;
  336.                                 }
  337.                                 break;
  338.                 }
  339.         }
  340.         else
  341.         {
  342.                 if( scancode<=0x7F )
  343.                 {
  344.                         tbldisp = scancode*2;
  345.                         tblptr = kbmap + tbldisp;
  346.                         tbl1 = *( tblptr++ );
  347.                         tbl2 = *( tblptr );
  348.                 }
  349.  
  350.                 //additional functionality from ps/2 keyboard
  351.                 switch( scancode )
  352.                 {
  353.                         //Scroll Lock
  354.                         case 0x7E:
  355.                                 //check key of vga mode switcher
  356.                                 if ( !was_release ) zx_vga_switcher();
  357.                                 break;
  358.                         //Left Shift
  359.                         case  0x12:
  360.                                 if ( !was_release ) kb_status |= KB_LSHIFT_MASK;
  361.                                 else kb_status &= ~KB_LSHIFT_MASK;
  362.                                 break;
  363.                         //Right Shift
  364.                         case  0x59:
  365.                                 if ( !was_release ) kb_status |= KB_RSHIFT_MASK;
  366.                                 else kb_status &= ~KB_RSHIFT_MASK;
  367.                                 break;
  368.                         //Ctrl
  369.                         case  0x14:
  370.                                 if ( !was_release ) kb_status |= KB_CTRL_MASK;
  371.                                 else kb_status &= ~KB_CTRL_MASK;
  372.                                 break;
  373.                         //Alt
  374.                         case  0x11:
  375.                                 if ( !was_release ) kb_status |= KB_ALT_MASK;
  376.                                 else kb_status &= ~KB_ALT_MASK;
  377.                                 break;
  378.                         //F9
  379.                         case 0x01:
  380.                                 //set TURBO
  381.                                 zx_set_config( (was_release==0)? SPI_CONFIG_TURBO_FLAG : 0 );
  382.                                 break;
  383.                         //F10
  384.                         case 0x09:
  385.                                 //reset TURBO
  386.                                 zx_set_config( (was_release==0)? SPI_CONFIG_NOTURBO_FLAG : 0 );
  387.                                 break;
  388.                         //F12
  389.                         case  0x07:
  390.                                 if ( !was_release ) kb_status |= KB_F12_MASK;
  391.                                 else kb_status &= ~KB_F12_MASK;
  392.                                 break;
  393.                 }
  394.         }
  395.  
  396.         if( tbl1!=NO_KEY )
  397.         {
  398.                 update_keys(tbl1,was_release);
  399.  
  400.                 if( tbl2!=NO_KEY ) update_keys(tbl2,was_release);
  401.         }
  402. }
  403.  
  404. void update_keys(UBYTE zxcode, UBYTE was_release)
  405. {
  406.         BYTE i;
  407.  
  408.         if( zxcode==NO_KEY )
  409.         {
  410.                 /* NOTHING */
  411.         }
  412.         else if( (zxcode==CLRKYS) && (!was_release) ) // does not have release option
  413.         {
  414.                 i=39;
  415.                 do zx_counters[i]=0; while( (--i)>=0 );
  416.  
  417.                 if( !zx_fifo_isfull() )
  418.                         zx_fifo_put(CLRKYS);
  419.         }
  420.         else if( zxcode>=RSTSYS ) // resets - press and release
  421.         {
  422.                 if( !zx_fifo_isfull() )
  423.                         zx_fifo_put( (was_release ? 0 : PRESS_MASK) | zxcode );
  424.         }
  425.         else if( zxcode < 40 ); // ordinary keys too
  426.         {
  427.                 if( was_release )
  428.                 {
  429.                         if( zx_counters[zxcode] && !(--zx_counters[zxcode]) ) // left-to-right evaluation and shortcutting
  430.                         {
  431.                                 if( !zx_fifo_isfull() )
  432.                                         zx_fifo_put(zxcode);
  433.                         }
  434.                 }
  435.                 else // key pressed
  436.                 {
  437.                         if( !(zx_counters[zxcode]++) )
  438.                         {
  439.                                 if( !zx_fifo_isfull() )
  440.                                         zx_fifo_put( PRESS_MASK | zxcode );
  441.                         }
  442.                 }
  443.         }
  444. }
  445.  
  446. void zx_fifo_put(UBYTE input)
  447. {
  448.         zx_fifo[zx_fifo_in_ptr++] = input;
  449. }
  450.  
  451. UBYTE zx_fifo_isfull(void)
  452. {
  453.         //always one byte unused, to distinguish between totally full fifo and empty fifo
  454.         return( (zx_fifo_in_ptr+1)==zx_fifo_out_ptr );
  455. }
  456.  
  457. UBYTE zx_fifo_isempty(void)
  458. {
  459.         return (zx_fifo_in_ptr==zx_fifo_out_ptr);
  460. }
  461.  
  462. UBYTE zx_fifo_get(void)
  463. {
  464.         return zx_fifo[zx_fifo_out_ptr++]; // get byte permanently
  465. }
  466.  
  467. UBYTE zx_fifo_copy(void)
  468. {
  469.         return zx_fifo[zx_fifo_out_ptr]; // get byte but leave it in fifo
  470. }
  471.  
  472. void zx_mouse_reset(UBYTE enable)
  473. {
  474.         if ( enable )
  475.         {
  476.                 //ZX autodetecting found mouse on this values
  477.                 zx_mouse_x = 0;
  478.                 zx_mouse_y = 1;
  479.         }
  480.         else
  481.         {
  482.                 //ZX autodetecting not found mouse on this values
  483.                 zx_mouse_y = zx_mouse_x = 0xFF;
  484.         }
  485.         zx_mouse_button = 0xFF;
  486.         flags_register|=(FLAG_PS2MOUSE_ZX_READY);
  487. }
  488.  
  489. void zx_mouse_task(void)
  490. {
  491.         if ( flags_register&FLAG_PS2MOUSE_ZX_READY )
  492.         {
  493. #ifdef LOGENABLE
  494.         char log_zxmouse[] = "ZXM.. .. ..\r\n";
  495.         log_zxmouse[3] = ((zx_mouse_button >> 4) <= 9 )?'0'+(zx_mouse_button >> 4):'A'+(zx_mouse_button >> 4)-10;
  496.         log_zxmouse[4] = ((zx_mouse_button & 0x0F) <= 9 )?'0'+(zx_mouse_button & 0x0F):'A'+(zx_mouse_button & 0x0F)-10;
  497.         log_zxmouse[6] = ((zx_mouse_x >> 4) <= 9 )?'0'+(zx_mouse_x >> 4):'A'+(zx_mouse_x >> 4)-10;
  498.         log_zxmouse[7] = ((zx_mouse_x & 0x0F) <= 9 )?'0'+(zx_mouse_x & 0x0F):'A'+(zx_mouse_x & 0x0F)-10;
  499.         log_zxmouse[9] = ((zx_mouse_y >> 4) <= 9 )?'0'+(zx_mouse_y >> 4):'A'+(zx_mouse_y >> 4)-10;
  500.         log_zxmouse[10] = ((zx_mouse_y & 0x0F) <= 9 )?'0'+(zx_mouse_y & 0x0F):'A'+(zx_mouse_y & 0x0F)-10;
  501.         to_log(log_zxmouse);
  502. #endif
  503.                 //TODO: яюър ёфхыры ёъюяюь, яюЄюь ёфхырЄ№ яю юфэюьє срщЄє чр чрїюф
  504.                 zx_spi_send(SPI_MOUSE_BTN, zx_mouse_button, 0x7F);
  505.  
  506.                 zx_spi_send(SPI_MOUSE_X, zx_mouse_x, 0x7F);
  507.  
  508.                 zx_spi_send(SPI_MOUSE_Y, zx_mouse_y, 0x7F);
  509.  
  510.                 //data sended - reset flag
  511.                 flags_register&=~(FLAG_PS2MOUSE_ZX_READY);
  512.         }
  513. }
  514.  
  515. void zx_wait_task(UBYTE status)
  516. {
  517.         UBYTE addr = 0;
  518.         UBYTE data = 0xFF;
  519.  
  520.         //reset flag
  521.         flags_register &= ~FLAG_SPI_INT;
  522.  
  523.         //prepare data
  524.         switch( status&0x7F )
  525.         {
  526.         case ZXW_GLUK_CLOCK:
  527.                 {
  528.                         addr = zx_spi_send(SPI_GLUK_ADDR, data, 0);
  529.                         if ( status&0x80 ) data = gluk_get_reg(addr);
  530.                         break;
  531.                 }
  532.         case ZXW_KONDR_RS232:
  533.                 {
  534.                         addr = zx_spi_send(SPI_RS232_ADDR, data, 0);
  535.                         if ( status&0x80 ) data = rs232_zx_read(addr);
  536.                         break;
  537.                 }
  538.         }
  539.  
  540.         if ( status&0x80 ) zx_spi_send(SPI_WAIT_DATA, data, 0);
  541.         else data = zx_spi_send(SPI_WAIT_DATA, data, 0);
  542.  
  543.         if ( !(status&0x80) )
  544.         {
  545.                 //save data
  546.                 switch( status&0x7F )
  547.                 {
  548.                 case ZXW_GLUK_CLOCK:
  549.                         {
  550.                                 gluk_set_reg(addr, data);
  551.                                 break;
  552.                         }
  553.                 case ZXW_KONDR_RS232:
  554.                         {
  555.                                 rs232_zx_write(addr, data);
  556.                                 break;
  557.                         }
  558.                 }
  559.         }
  560. /*#ifdef LOGENABLE
  561.         char log_wait[] = "W..A..D..\r\n";
  562.         log_wait[1] = ((status >> 4) <= 9 )?'0'+(status >> 4):'A'+(status >> 4)-10;
  563.         log_wait[2] = ((status & 0x0F) <= 9 )?'0'+(status & 0x0F):'A'+(status & 0x0F)-10;
  564.         log_wait[4] = ((addr >> 4) <= 9 )?'0'+(addr >> 4):'A'+(addr >> 4)-10;
  565.         log_wait[5] = ((addr & 0x0F) <= 9 )?'0'+(addr & 0x0F):'A'+(addr & 0x0F)-10;
  566.         log_wait[7] = ((data >> 4) <= 9 )?'0'+(data >> 4):'A'+(data >> 4)-10;
  567.         log_wait[8] = ((data & 0x0F) <= 9 )?'0'+(data & 0x0F):'A'+(data & 0x0F)-10;
  568.         to_log(log_wait);
  569. #endif   */
  570. }
  571.  
  572. void zx_vga_switcher(void)
  573. {
  574.         //invert VGA mode
  575.         modes_register ^= MODE_VGA;
  576.  
  577.         //send configuration to FPGA
  578.         zx_spi_send(SPI_CONFIG_REG, modes_register&MODE_VGA, 0x7F);
  579.  
  580.         //save mode register to RTC NVRAM
  581.         rtc_write(RTC_COMMON_MODE_REG, modes_register);
  582.  
  583.         //set led on keyboard
  584.         ps2keyboard_send_cmd(PS2KEYBOARD_CMD_SETLED);
  585. }
  586.  
  587. void zx_set_config(UBYTE flags)
  588. {
  589.         //send configuration to FPGA
  590.         zx_spi_send(SPI_CONFIG_REG, (modes_register&MODE_VGA) | (flags & ~MODE_VGA), 0x7F);
  591. }
  592.