Subversion Repositories pentevo

Rev

Rev 292 | Rev 494 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. #include <avr/io.h>
  2. #include <avr/interrupt.h>
  3.  
  4. #include <util/delay.h>
  5.  
  6. #include "mytypes.h"
  7. #include "main.h"
  8. #include "ps2.h"
  9. #include "zx.h"
  10. #include "pins.h"
  11. #include "spi.h"
  12. #include "rs232.h"
  13. #include "rtc.h"
  14.  
  15. //if want Log than comment next string
  16. #undef LOGENABLE
  17.  
  18. UBYTE ps2_decode(UBYTE count, UWORD shifter)
  19. {
  20.         UBYTE t,byte;
  21.  
  22.         if( count!=0 ) return 0x00; // have nothing received
  23.  
  24.         // check packet:
  25.         //shifter.hi - stp.par.7.6.5.4.3.2
  26.         //shifter.lo - 1.0.strt.x.x.x.x.x
  27.  
  28.         if( !( shifter&0x8000 ) ) return 0x00; // stopbit must be 1
  29.         if( shifter&0x0020 ) return 0x00; // startbit must be 0
  30.  
  31.  
  32.         byte = (UBYTE) ( 0x00FF & (shifter>>6) );
  33.  
  34.         t = byte ^ (byte>>4);
  35.         t = t ^ (t>>2);
  36.         t = t ^ (t>>1); // parity
  37.  
  38.         t = t ^ (UBYTE) ( shifter>>14 ); // compare parities
  39.  
  40.         if( !(t&1) ) return 0x00; // must be different
  41.  
  42.         return byte;
  43. }
  44.  
  45. UWORD ps2_encode(UBYTE byte)
  46. {
  47.         UWORD t;
  48.         t = byte ^ (byte>>4);
  49.         t = t ^ (t>>2);
  50.         t = ~(1 & (t ^ (t>>1))); // parity
  51.  
  52.         t = (((t<<8) + byte)<<1) + 0x0400;
  53.  
  54.         // prepare to shifter:
  55.         //shifter.hi - x.x.x.x.x.stp.par.7
  56.         //shifter.lo - 6.5.4.3.2.1.0.strt
  57.         return t;
  58. }
  59.  
  60. volatile UWORD ps2keyboard_shifter;
  61. volatile UBYTE ps2keyboard_count;
  62. volatile UBYTE ps2keyboard_timeout;
  63. volatile UBYTE ps2keyboard_cmd_count;
  64. volatile UBYTE ps2keyboard_cmd;
  65.  
  66. static void ps2keyboard_release_clk(void)
  67. {
  68.         ps2keyboard_count = 12; //counter reinit
  69.         if( flags_register & FLAG_PS2KEYBOARD_DIRECTION )
  70.         {
  71.                 PS2KBDAT_DDR &= ~(1<<PS2KBDAT); //ps2 keyboard data pin to input mode
  72.                 flags_register &= ~(FLAG_PS2KEYBOARD_DIRECTION); //set to receive mode
  73.         }
  74.  
  75.         //release ps2 receiver (disabled by now)
  76.         EIFR = (1<<INTF4); // clr any spurious int which can happen when we pulldown clock pin
  77.         PS2KBCLK_DDR  &= ~(1<<PS2KBCLK); //ps2 keyboard clk pin to input mode
  78.         PS2KBCLK_PORT |= (1<<PS2KBCLK);  //release clk pin
  79. }
  80.  
  81. void ps2keyboard_send(UBYTE data)
  82. {
  83. #ifdef LOGENABLE
  84. {
  85.         char log_ps2kb_parse[] = "KB>..\r\n";
  86.         UBYTE b = data;
  87.         log_ps2kb_parse[3] = ((b >> 4) <= 9 )?'0'+(b >> 4):'A'+(b >> 4)-10;
  88.         log_ps2kb_parse[4] = ((b & 0x0F) <= 9 )?'0'+(b & 0x0F):'A'+(b & 0x0F)-10;
  89.         to_log(log_ps2kb_parse);
  90. }
  91. #endif
  92.         ps2keyboard_shifter = ps2_encode(data); //prepare data
  93.         flags_register |= FLAG_PS2KEYBOARD_DIRECTION; //set send mode
  94.         PS2KBCLK_PORT &= ~(1<<PS2KBCLK); //bring ps2 keyboard clk pin -
  95.     PS2KBCLK_DDR  |= (1<<PS2KBCLK);  //generate interruption
  96. }
  97.  
  98. void ps2keyboard_task(void)
  99. {
  100.         UBYTE b;
  101.  
  102.         if ( ( ps2keyboard_count == 12 ) &&
  103.                  ( ps2keyboard_cmd != 0) &&
  104.                  ( ps2keyboard_cmd_count != 0 ) )
  105.         {
  106.                 //delay need for pause between release and hold clk pin
  107.                 _delay_us(100);
  108.  
  109.                 //if need send command on current stage
  110.                 if ( ((ps2keyboard_cmd_count == 4)&&(ps2keyboard_cmd == PS2KEYBOARD_CMD_SETLED)) ||
  111.                      ((ps2keyboard_cmd_count == 3)&&(ps2keyboard_cmd == PS2KEYBOARD_CMD_RESET)) )
  112.                 {
  113.                         ps2keyboard_send(ps2keyboard_cmd);
  114.                         ps2keyboard_cmd_count--;
  115.                 }
  116.                 else
  117.                 //if need send led data on current stage
  118.                 if ( ((ps2keyboard_cmd_count == 2)&&(ps2keyboard_cmd == PS2KEYBOARD_CMD_SETLED)) )
  119.                 {
  120.                         b = (PS2KEYBOARD_LED_SCROLLOCK|PS2KEYBOARD_LED_NUMLOCK)&modes_register;
  121.                         ps2keyboard_send(b);
  122.                         ps2keyboard_cmd_count--;
  123.                 }
  124.         }
  125.  
  126.         if ( ( ps2keyboard_count<12 ) &&
  127.                  ( ps2keyboard_timeout==0 ) )
  128.         {
  129.                 //error due send/receive
  130.                 ps2keyboard_release_clk();
  131. #ifdef LOGENABLE
  132.                 to_log("KBerr\r\n");
  133. #endif
  134.                 //TODO: ўхЄр фхырЄ№
  135.  
  136.                 //reset command
  137.                 ps2keyboard_cmd_count = 0;
  138.                 ps2keyboard_cmd = 0;
  139.  
  140.                 //reset buffer
  141.                 zx_clr_kb();
  142.         }
  143.  
  144.         if ( ps2keyboard_count!=0 ) return; // not received anything
  145.  
  146.         if ( !(flags_register&FLAG_PS2KEYBOARD_DIRECTION) )
  147.         {
  148.                 //receive complete
  149.                 b = ps2_decode(ps2keyboard_count, ps2keyboard_shifter);
  150. #ifdef LOGENABLE
  151. {
  152.         char log_ps2kb_parse[] = "KB<..\r\n";
  153.         log_ps2kb_parse[3] = ((b >> 4) <= 9 )?'0'+(b >> 4):'A'+(b >> 4)-10;
  154.         log_ps2kb_parse[4] = ((b & 0x0F) <= 9 )?'0'+(b & 0x0F):'A'+(b & 0x0F)-10;
  155.         to_log(log_ps2kb_parse);
  156. }
  157. #endif
  158.                 if ( ps2keyboard_cmd )
  159.                 {
  160.                         //wait for 0xFA on current stage
  161.                         if ( ((ps2keyboard_cmd == PS2KEYBOARD_CMD_SETLED)&&(ps2keyboard_cmd_count == 3 || ps2keyboard_cmd_count == 1)) ||
  162.                              ((ps2keyboard_cmd == PS2KEYBOARD_CMD_RESET)&&(ps2keyboard_cmd_count == 2)) )
  163.                         {
  164.                                 if( b != 0xFA )
  165.                                 {
  166.                                         ps2keyboard_cmd_count = 0;
  167.                                         //if non FA - may be scan code received
  168.                                         if ( b ) ps2keyboard_parse(b);
  169.                                 }
  170.                                 else ps2keyboard_cmd_count--;
  171.  
  172.                                 if ( ps2keyboard_cmd_count == 0 ) ps2keyboard_cmd = 0;
  173.                         }
  174.                         else
  175.                         //wait for 0xAA on current stage
  176.                         if ( ((ps2keyboard_cmd == PS2KEYBOARD_CMD_RESET)&&(ps2keyboard_cmd_count == 1)) )
  177.                         {
  178.                                 if ( b != 0xAA )
  179.                                 {
  180.                                         //if non AA - may be scan code received
  181.                                         if ( b ) ps2keyboard_parse(b);
  182.                                 }
  183.                                 ps2keyboard_cmd_count = 0;
  184.                                 ps2keyboard_cmd = 0;
  185.                         }
  186.                 }
  187.                 else
  188.                 if ( b ) // there is no zero byte in scancode tables so we can ignore and use it as 'nothing received'
  189.                 {
  190.                         ps2keyboard_parse(b);
  191.                 }
  192.         }
  193.  
  194.         ps2keyboard_release_clk();
  195. }
  196.  
  197. void ps2keyboard_send_cmd(UBYTE cmd)
  198. {
  199.         if ( ps2keyboard_cmd == 0 )
  200.         {
  201.                 ps2keyboard_cmd = cmd;
  202.                 switch ( cmd )
  203.                 {
  204.                 case PS2KEYBOARD_CMD_RESET:
  205.                         ps2keyboard_cmd_count = 3;
  206.                         break;
  207.                 case PS2KEYBOARD_CMD_SETLED:
  208.                         ps2keyboard_cmd_count = 4;
  209.                         break;
  210.                 default:
  211.                         ps2keyboard_cmd = 0;
  212.                 }
  213.         }
  214. }
  215.  
  216. void ps2keyboard_parse(UBYTE recbyte)
  217. {
  218.         static UBYTE was_release = 0;
  219.         static UBYTE was_E0 = 0;
  220.  
  221.         static UBYTE last_scancode = 0;
  222.         static UBYTE last_scancode_E0 = 1;
  223.  
  224.         static UBYTE skipshit = 0;
  225.  
  226. #ifdef LOGENABLE
  227.         char log_ps2keyboard_parse[] = "KB..\r\n";
  228.         if ( skipshit ) log_ps2keyboard_parse[1] = skipshit + '0';
  229.         log_ps2keyboard_parse[2] = ((recbyte >> 4) <= 9 )?'0'+(recbyte >> 4):'A'+(recbyte >> 4)-10;
  230.         log_ps2keyboard_parse[3] = ((recbyte & 0x0F) <= 9 )?'0'+(recbyte & 0x0F):'A'+(recbyte & 0x0F)-10;
  231.         to_log(log_ps2keyboard_parse);
  232. #endif
  233.  
  234.  
  235.         if( skipshit )
  236.         {
  237.                 skipshit--;
  238.                 return;
  239.         }
  240.  
  241.  
  242.         if( recbyte==0xFA ) return;
  243.         if( recbyte==0xFE ) return;
  244.         if( recbyte==0xEE ) return;
  245.         if( recbyte==0xAA ) return;
  246.  
  247.  
  248.         if( recbyte==0xE0 )
  249.         {
  250.                 was_E0 = 1;
  251.                 return;
  252.         }
  253.  
  254.  
  255.         if( recbyte==0xF0 )
  256.         {
  257.                 was_release = 1;
  258.                 return;
  259.         }
  260.  
  261.         if( recbyte==0xE1 ) // pause pressed
  262.         {
  263.                 skipshit=7;
  264.                 return; // skip next 7 bytes
  265.         }
  266.  
  267.  
  268.         if( (recbyte==last_scancode) && (was_E0==last_scancode_E0) )
  269.         {
  270.                 if( was_release )
  271.                 {
  272.                         last_scancode = 0x00;
  273.                         last_scancode_E0 = 1; // impossible scancode: E0 00
  274.                 }
  275.                 else // was depress
  276.                 {
  277.                         return;
  278.                 }
  279.         }
  280.  
  281.         if( !was_release )
  282.         {
  283.                 last_scancode = recbyte;
  284.                 last_scancode_E0 = was_E0;
  285.         }
  286.  
  287.         if( (recbyte==0x12) && was_E0 ) // skip E0 12
  288.         {
  289.                 was_E0 = 0;
  290.                 was_release = 0;
  291.                 return;
  292.         }
  293.  
  294.  
  295.         to_zx( recbyte, was_E0, was_release ); // send valid scancode to zx decoding stage
  296.  
  297.         was_E0 = 0;
  298.         was_release = 0;
  299.  
  300.         return;
  301. }
  302.  
  303. volatile UWORD ps2mouse_shifter;
  304. volatile UBYTE ps2mouse_count;
  305. volatile UBYTE ps2mouse_timeout;
  306. volatile UBYTE ps2mouse_initstep;
  307. volatile UBYTE ps2mouse_resp_count;
  308. volatile UBYTE ps2mouse_cmd;
  309.  
  310. const UBYTE ps2mouse_init_sequence[] =
  311.         "\xFF"      //
  312.         "\xFF"      // reset
  313.         "\xFF"      //
  314.         "\xF3\xC8"  // set sample rate 200  | switch to
  315.         "\xF3\x64"  // set sample rate 100  |     scroll
  316.         "\xF3\x50"  // set sample rate 80   |         mode
  317.         "\xF2"      // get device type
  318.         "\xF3\x0A"  // set sample rate 10
  319.         "\xF2"      // get device type
  320.         "\xE8\x02"  // set resolution
  321.         "\xE6"      // set scaling 1:1
  322.         "\xF3\x64"  // set sample rate 100
  323.         "\xF4"      // enable
  324.         ;
  325.  
  326. static void ps2mouse_release_clk(void)
  327. {
  328.         ps2mouse_count = 12; //counter reinit
  329.         if( flags_register & FLAG_PS2MOUSE_DIRECTION )
  330.         {
  331.                 PS2MSDAT_DDR &= ~(1<<PS2MSDAT); //ps2 mouse data pin to input mode
  332.                 flags_register &= ~(FLAG_PS2MOUSE_DIRECTION); //set to receive mode
  333.         }
  334.  
  335.         //release ps2 receiver (disabled by now)
  336.         EIFR = (1<<INTF5); // clr any spurious int which can happen when we pulldown clock pin
  337.         PS2MSCLK_DDR  &= ~(1<<PS2MSCLK); //ps2 mouse clk pin to input mode
  338.         PS2MSCLK_PORT |= (1<<PS2MSCLK);  //release clk pin
  339. }
  340.  
  341. void ps2mouse_send(UBYTE data)
  342. {
  343. #ifdef LOGENABLE
  344. {
  345.         UBYTE b=data;
  346.         char log_ps2mouse_parse[] = "MS>..\r\n";
  347.         log_ps2mouse_parse[3] = ((b >> 4) <= 9 )?'0'+(b >> 4):'A'+(b >> 4)-10;
  348.         log_ps2mouse_parse[4] = ((b & 0x0F) <= 9 )?'0'+(b & 0x0F):'A'+(b & 0x0F)-10;
  349.         to_log(log_ps2mouse_parse);
  350. }
  351. #endif
  352.         ps2mouse_shifter = ps2_encode(data); //prepare data
  353.         flags_register |= FLAG_PS2MOUSE_DIRECTION; //set send mode
  354.         PS2MSCLK_PORT &= ~(1<<PS2MSCLK); //bring ps2 mouse clk pin -
  355.     PS2MSCLK_DDR  |= (1<<PS2MSCLK);  //generate interruption
  356. }
  357.  
  358. void ps2mouse_task(void)
  359. {
  360.         UBYTE b;
  361.  
  362.         if (  ps2mouse_count == 12  )
  363.         {
  364.                 if (  ps2mouse_init_sequence[ps2mouse_initstep] != 0  )
  365.                 {
  366.                         if ( ps2mouse_resp_count == 0 )
  367.                         {
  368.                                 //delay need for pause between release and hold clk pin
  369.                                 _delay_us(200);
  370.  
  371.                                 //initialization not complete
  372.                                 //send next command to mouse
  373.                                 ps2mouse_send(ps2mouse_init_sequence[ps2mouse_initstep]);
  374.                                 ps2mouse_resp_count++;
  375.                         }
  376.                 }
  377.                 else if ( ps2mouse_cmd != 0 )
  378.                 {
  379.                         if ( ps2mouse_resp_count == 0 )
  380.                         {
  381.                                 //delay need for pause between release and hold clk pin
  382.                                 _delay_us(200);
  383.  
  384.                                 //start command
  385.                                 flags_ex_register |= FLAG_EX_PS2MOUSE_CMD;
  386.                                 ps2mouse_send(ps2mouse_cmd);
  387.                                 ps2mouse_resp_count++;
  388.                         }
  389.                         else if( flags_ex_register & FLAG_EX_PS2MOUSE_CMD )
  390.                         {
  391.                                 switch( ps2mouse_cmd )
  392.                                 {
  393.                                         case PS2MOUSE_CMD_SET_RESOLUTION:
  394.                                                 if ( ps2mouse_resp_count == 2 )
  395.                                                 {
  396.                                                         //delay need for pause between release and hold clk pin
  397.                                                         _delay_us(200);
  398.  
  399.                                                         //send resolution
  400.                                                         ps2mouse_send(rtc_read(RTC_PS2MOUSE_RES_REG));
  401.                                                         ps2mouse_resp_count++;
  402.                                                 }
  403.                                                 break;
  404.                                 }
  405.                         }
  406.                 }
  407.         }
  408.  
  409.         if ( ( ps2mouse_count<12 ) &&
  410.                  ( ps2mouse_timeout==0 ) )
  411.         {
  412. #ifdef LOGENABLE
  413.                 char log_ps2mouse_err[] = "MS.err.\r\n";
  414.                 if( flags_register&FLAG_PS2MOUSE_DIRECTION ) log_ps2mouse_err[2]='S';   else log_ps2mouse_err[2]='R';
  415.                 if( ps2mouse_count<10 ) log_ps2mouse_err[6]='0'+ps2mouse_count;  else log_ps2mouse_err[6]='A'+ps2mouse_count-10;
  416.                 to_log(log_ps2mouse_err);
  417. #endif
  418.                 //error due exchange data with PS/2 mouse
  419.  
  420.                 //get direction
  421.                 b = flags_register&FLAG_PS2MOUSE_DIRECTION;
  422.  
  423.                 //reset pins and states
  424.                 ps2mouse_release_clk();
  425.  
  426.                 //analizing error
  427.                 if( b && (ps2mouse_initstep==0) )
  428.                 {
  429.                         //error due send first init byte - mouse not connected to PS/2
  430.  
  431.                         //disable mouse
  432.                         zx_mouse_reset(0);
  433.                 }
  434.                 else
  435.                 {
  436.                         //error due receive or send non first byte - mouse connected to PS/2
  437.  
  438.                         //re-init mouse
  439.                         ps2mouse_initstep = 0;
  440.                 }
  441.         }
  442.  
  443.         if ( ps2mouse_count!=0 ) return; // not received anything
  444.  
  445.         if ( !(flags_register&FLAG_PS2MOUSE_DIRECTION) )
  446.         {
  447.                 //receive complete
  448.                 b = ps2_decode(ps2mouse_count, ps2mouse_shifter);
  449.  
  450. #ifdef LOGENABLE
  451. {
  452.         char log_ps2mouse_parse[] = "MS<..\r\n";
  453.         log_ps2mouse_parse[3] = ((b >> 4) <= 9 )?'0'+(b >> 4):'A'+(b >> 4)-10;
  454.         log_ps2mouse_parse[4] = ((b & 0x0F) <= 9 )?'0'+(b & 0x0F):'A'+(b & 0x0F)-10;
  455.         to_log(log_ps2mouse_parse);
  456. }
  457. #endif
  458.  
  459.                 //if command proceed than command code
  460.                 //if initialization proceed than current init code
  461.                 //else 0
  462.                 switch( (flags_ex_register&FLAG_EX_PS2MOUSE_CMD)?ps2mouse_cmd:ps2mouse_init_sequence[ps2mouse_initstep] )
  463.                 {
  464.                         //initialization complete - working mode
  465.                         case 0:
  466.                                 ps2mouse_resp_count++;
  467.                                 switch( ps2mouse_resp_count )
  468.                                 {
  469.                                 case 1:
  470.                                         //byte 1: Y overflow | X overflow | Y sign bit | X sign bit | 1 | Middle Btn | Right Btn | Left Btn
  471.                                         zx_mouse_button = (zx_mouse_button&0xF0) + ((b^0x07)&0x0F);
  472.                                         break;
  473.                                 case 2:
  474.                                         //byte 2: X movement
  475.                                         zx_mouse_x += b;
  476.                                         break;
  477.                                 case 3:
  478.                                         //byte 3: Y movement
  479.                                         zx_mouse_y += b;
  480.                                         if ( !(flags_register&FLAG_PS2MOUSE_TYPE) )
  481.                                         {
  482.                                                 //classical mouse
  483.                                                 ps2mouse_resp_count = 0;
  484.                                                 flags_register |= FLAG_PS2MOUSE_ZX_READY;
  485.                                         }
  486.                                         break;
  487.                                 case 4:
  488.                                         //byte 4: wheel movement
  489.                                         zx_mouse_button += ((b<<4)&0xF0);
  490.                                         flags_register |= FLAG_PS2MOUSE_ZX_READY;
  491.                                         ps2mouse_resp_count = 0;
  492.                                 }
  493.                                 break;
  494.  
  495.                         //reset command
  496.                         case PS2MOUSE_CMD_RESET:
  497.                                 if ( ps2mouse_resp_count==1 )
  498.                                 {
  499.                                         //must be acknowledge
  500.                                         if ( b != 0xFA )
  501.                                         {
  502.                                                 if( flags_ex_register&FLAG_EX_PS2MOUSE_CMD )
  503.                                                 {
  504.                                                         //reset command
  505.                                                         ps2mouse_cmd = 0;
  506.                                                         flags_ex_register &= ~FLAG_EX_PS2MOUSE_CMD;
  507.                                                 }
  508.                                                 else
  509.                                                 {
  510.                                                         //reset initialization
  511.                                                         ps2mouse_initstep = 0;
  512.                                                 }
  513.                                                 ps2mouse_resp_count = 0;
  514.                                                 break;
  515.                                         }
  516.                                 }
  517.                                 ps2mouse_resp_count++;
  518.                                 if ( ps2mouse_resp_count >= 4 )
  519.                                 {
  520.                                         ps2mouse_resp_count = 0;
  521.                                         if( flags_ex_register&FLAG_EX_PS2MOUSE_CMD )
  522.                                         {
  523.                                                 //reset command
  524.                                                 ps2mouse_cmd = 0;
  525.                                                 flags_ex_register &= ~FLAG_EX_PS2MOUSE_CMD;
  526.                                         }
  527.                                         else
  528.                                         {
  529.                                                 //next initialization stage
  530.                                                 ps2mouse_initstep++;
  531.                                         }
  532.                                 }
  533.                                 break;
  534.  
  535.                         //get device type
  536.                         case PS2MOUSE_CMD_GET_TYPE:
  537.                                 if ( ps2mouse_resp_count==1 )
  538.                                 {
  539.                                         ps2mouse_resp_count++;
  540.                                         //must be acknowledge
  541.                                         if ( b != 0xFA )
  542.                                         {
  543.                                                 if( flags_ex_register&FLAG_EX_PS2MOUSE_CMD )
  544.                                                 {
  545.                                                         //reset command
  546.                                                         ps2mouse_cmd = 0;
  547.                                                         flags_ex_register &= ~FLAG_EX_PS2MOUSE_CMD;
  548.                                                 }
  549.                                                 else
  550.                                                 {
  551.                                                         //reset initialization
  552.                                                         ps2mouse_initstep = 0;
  553.                                                 }
  554.                                                 ps2mouse_resp_count = 0;
  555.                                         }
  556.                                         break;
  557.                                 }
  558.                                 else
  559.                                 {
  560.                                         ps2mouse_resp_count = 0;
  561.                                         if( flags_ex_register&FLAG_EX_PS2MOUSE_CMD )
  562.                                         {
  563.                                                 //reset command
  564.                                                 ps2mouse_cmd = 0;
  565.                                                 flags_ex_register &= ~FLAG_EX_PS2MOUSE_CMD;
  566.                                         }
  567.                                         else
  568.                                         {
  569.                                                 //next initialization stage
  570.                                                 ps2mouse_initstep++;
  571.                                         }
  572.  
  573.                                         if ( b > 0 )
  574.                                         {
  575.                                                 flags_register |= FLAG_PS2MOUSE_TYPE;
  576.                                         }
  577.                                         else
  578.                                         {
  579.                                                 flags_register &= ~(FLAG_PS2MOUSE_TYPE);
  580.                                         }
  581.                                 }
  582.                                 break;
  583.  
  584.                         //set resolution
  585.                         case PS2MOUSE_CMD_SET_RESOLUTION:
  586.                                 //must be acknowledge
  587.                                 if ( b != 0xFA )
  588.                                 {
  589.                                         if( flags_ex_register&FLAG_EX_PS2MOUSE_CMD )
  590.                                         {
  591.                                                 //reset command
  592.                                                 ps2mouse_cmd = 0;
  593.                                                 flags_ex_register &= ~FLAG_EX_PS2MOUSE_CMD;
  594.                                         }
  595.                                         else
  596.                                         {
  597.                                                 //reset initialization
  598.                                                 ps2mouse_initstep = 0;
  599.                                         }
  600.                                         ps2mouse_resp_count = 0;
  601.                                 }
  602.                                 else
  603.                                 {
  604.                                         if( flags_ex_register&FLAG_EX_PS2MOUSE_CMD )
  605.                                         {
  606.                                                 if( ps2mouse_resp_count >= 3 )
  607.                                                 {
  608.                                                         ps2mouse_resp_count = 0;
  609.                                                         //reset command
  610.                                                         ps2mouse_cmd = 0;
  611.                                                         flags_ex_register &= ~FLAG_EX_PS2MOUSE_CMD;
  612.                                                 }
  613.                                                 else
  614.                                                 {
  615.                                                         ps2mouse_resp_count ++;
  616.                                                 }
  617.                                         }
  618.                                         else
  619.                                         {
  620.                                                 //next initialization stage
  621.                                                 ps2mouse_resp_count = 0;
  622.                                                 ps2mouse_initstep++;
  623.                                         }
  624.                                 }
  625.                                 break;
  626.  
  627.                         //other commands
  628.                         default:
  629.                                 if( flags_ex_register&FLAG_EX_PS2MOUSE_CMD )
  630.                                 {
  631.                                         //reset command
  632.                                         ps2mouse_cmd = 0;
  633.                                         flags_ex_register &= ~FLAG_EX_PS2MOUSE_CMD;
  634.                                 }
  635.                                 else
  636.                                 {
  637.                                         //next initialization stage
  638.                                         ps2mouse_initstep++;
  639.                                         if ( ps2mouse_resp_count==1 )
  640.                                         {
  641.                                                 //must be acknowledge
  642.                                                 if ( b != 0xFA )
  643.                                                 {
  644.                                                         //reset initialization
  645.                                                         ps2mouse_initstep = 0;
  646.                                                 }
  647.                                         }
  648.                                 }
  649.                                 ps2mouse_resp_count = 0;
  650.                                 break;
  651.                 }
  652.         }
  653. //#ifdef LOGENABLE
  654. //      else
  655. //      {
  656. //              //send complete
  657. //              char log_ps2mouse_parse[] = "MS>..\r\n";
  658. //              b = ps2mouse_init_sequence[ps2mouse_initstep];
  659. //              log_ps2mouse_parse[3] = ((b >> 4) <= 9 )?'0'+(b >> 4):'A'+(b >> 4)-10;
  660. //              log_ps2mouse_parse[4] = ((b & 0x0F) <= 9 )?'0'+(b & 0x0F):'A'+(b & 0x0F)-10;
  661. //              to_log(log_ps2mouse_parse);
  662. //      }
  663. //#endif
  664.  
  665.         ps2mouse_release_clk();
  666. }
  667.  
  668. void ps2mouse_set_resolution(UBYTE code)
  669. {
  670. #ifdef LOGENABLE
  671. {
  672.         UBYTE b = zx_mouse_button;
  673.         char log_ps2mouse_parse[] = "SS:..-..\r\n";
  674.         log_ps2mouse_parse[3] = ((b >> 4) <= 9 )?'0'+(b >> 4):'A'+(b >> 4)-10;
  675.         log_ps2mouse_parse[4] = ((b & 0x0F) <= 9 )?'0'+(b & 0x0F):'A'+(b & 0x0F)-10;
  676.         b = code;
  677.         log_ps2mouse_parse[6] = ((b >> 4) <= 9 )?'0'+(b >> 4):'A'+(b >> 4)-10;
  678.         log_ps2mouse_parse[7] = ((b & 0x0F) <= 9 )?'0'+(b & 0x0F):'A'+(b & 0x0F)-10;
  679.         to_log(log_ps2mouse_parse);
  680. }
  681. #endif
  682.  
  683.         //if pressed left and right buttons on mouse
  684.         if ( (zx_mouse_button & 0x03) == 0 )
  685.         {
  686.                 switch( code )
  687.                 {
  688.                         //keypad '*' - set default resolution
  689.                         case 0x7C:
  690.                                 rtc_write(RTC_PS2MOUSE_RES_REG,0x00);
  691.                                 ps2mouse_cmd = PS2MOUSE_CMD_SET_RESOLUTION;
  692.                                 break;
  693.  
  694.                         //keypad '+' - inc resolution
  695.                         case 0x79:
  696.                         {
  697.                                 UBYTE data = rtc_read(RTC_PS2MOUSE_RES_REG);
  698.                                 if( data < 0x03 )
  699.                                 {
  700.                                         data++;
  701.                                 }
  702.                                 else
  703.                                 {
  704.                                         data=0x03;
  705.                                 }
  706.                                 rtc_write(RTC_PS2MOUSE_RES_REG,data);
  707.                                 ps2mouse_cmd = PS2MOUSE_CMD_SET_RESOLUTION;
  708.                             break;
  709.                         }
  710.  
  711.                         //keypad '-' - dec resolution
  712.                         case 0x7B:
  713.                         {
  714.                                 UBYTE data = rtc_read(RTC_PS2MOUSE_RES_REG);
  715.                                 if( ( data > 0 ) && (data <= 0x03 ) )
  716.                                 {
  717.                                         data--;
  718.                                 }
  719.                                 else
  720.                                 {
  721.                                         data=0;
  722.                                 }
  723.                                 rtc_write(RTC_PS2MOUSE_RES_REG,data);
  724.                                 ps2mouse_cmd = PS2MOUSE_CMD_SET_RESOLUTION;
  725.                             break;
  726.                         }
  727.                 }
  728.         }
  729. }
  730.