Subversion Repositories pentevo

Rev

Rev 299 | Rev 496 | 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.         "\xE6"      // set scaling 1:1
  319.         "\xF3\x64"  // set sample rate 100
  320.         "\xF4"      // enable
  321.         ;
  322.  
  323. static void ps2mouse_release_clk(void)
  324. {
  325.         ps2mouse_count = 12; //counter reinit
  326.         if( flags_register & FLAG_PS2MOUSE_DIRECTION )
  327.         {
  328.                 PS2MSDAT_DDR &= ~(1<<PS2MSDAT); //ps2 mouse data pin to input mode
  329.                 flags_register &= ~(FLAG_PS2MOUSE_DIRECTION); //set to receive mode
  330.         }
  331.  
  332.         //release ps2 receiver (disabled by now)
  333.         EIFR = (1<<INTF5); // clr any spurious int which can happen when we pulldown clock pin
  334.         PS2MSCLK_DDR  &= ~(1<<PS2MSCLK); //ps2 mouse clk pin to input mode
  335.         PS2MSCLK_PORT |= (1<<PS2MSCLK);  //release clk pin
  336. }
  337.  
  338. void ps2mouse_send(UBYTE data)
  339. {
  340. #ifdef LOGENABLE
  341. {
  342.         UBYTE b=data;
  343.         char log_ps2mouse_parse[] = "MS>..\r\n";
  344.         log_ps2mouse_parse[3] = ((b >> 4) <= 9 )?'0'+(b >> 4):'A'+(b >> 4)-10;
  345.         log_ps2mouse_parse[4] = ((b & 0x0F) <= 9 )?'0'+(b & 0x0F):'A'+(b & 0x0F)-10;
  346.         to_log(log_ps2mouse_parse);
  347. }
  348. #endif
  349.         ps2mouse_shifter = ps2_encode(data); //prepare data
  350.         flags_register |= FLAG_PS2MOUSE_DIRECTION; //set send mode
  351.         PS2MSCLK_PORT &= ~(1<<PS2MSCLK); //bring ps2 mouse clk pin -
  352.     PS2MSCLK_DDR  |= (1<<PS2MSCLK);  //generate interruption
  353. }
  354.  
  355. void ps2mouse_task(void)
  356. {
  357.         UBYTE b;
  358.  
  359.         if (  ps2mouse_count == 12  )
  360.         {
  361.                 if (  ps2mouse_init_sequence[ps2mouse_initstep] != 0  )
  362.                 {
  363.                         if ( ps2mouse_resp_count == 0 )
  364.                         {
  365.                                 //delay need for pause between release and hold clk pin
  366.                                 _delay_us(200);
  367.  
  368.                                 //initialization not complete
  369.                                 //send next command to mouse
  370.                                 ps2mouse_send(ps2mouse_init_sequence[ps2mouse_initstep]);
  371.                                 ps2mouse_resp_count++;
  372.                         }
  373.                 }
  374.                 else if ( ps2mouse_cmd != 0 )
  375.                 {
  376.                         if ( ps2mouse_resp_count == 0 )
  377.                         {
  378.                                 //delay need for pause between release and hold clk pin
  379.                                 _delay_us(200);
  380.  
  381.                                 //start command
  382.                                 flags_ex_register |= FLAG_EX_PS2MOUSE_CMD;
  383.                                 ps2mouse_send(ps2mouse_cmd);
  384.                                 ps2mouse_resp_count++;
  385.                         }
  386.                         else if( flags_ex_register & FLAG_EX_PS2MOUSE_CMD )
  387.                         {
  388.                                 switch( ps2mouse_cmd )
  389.                                 {
  390.                                         case PS2MOUSE_CMD_SET_RESOLUTION:
  391.                                                 if ( ps2mouse_resp_count == 2 )
  392.                                                 {
  393.                                                         //delay need for pause between release and hold clk pin
  394.                                                         _delay_us(200);
  395.  
  396.                                                         //send resolution
  397.                                                         ps2mouse_send(rtc_read(RTC_PS2MOUSE_RES_REG)&0x03);
  398.                                                         ps2mouse_resp_count++;
  399.                                                 }
  400.                                                 break;
  401.                                 }
  402.                         }
  403.                 }
  404.         }
  405.  
  406.         if ( ( ps2mouse_count<12 ) &&
  407.                  ( ps2mouse_timeout==0 ) )
  408.         {
  409. #ifdef LOGENABLE
  410.                 char log_ps2mouse_err[] = "MS.err.\r\n";
  411.                 if( flags_register&FLAG_PS2MOUSE_DIRECTION ) log_ps2mouse_err[2]='S';   else log_ps2mouse_err[2]='R';
  412.                 if( ps2mouse_count<10 ) log_ps2mouse_err[6]='0'+ps2mouse_count;  else log_ps2mouse_err[6]='A'+ps2mouse_count-10;
  413.                 to_log(log_ps2mouse_err);
  414. #endif
  415.                 //error due exchange data with PS/2 mouse
  416.  
  417.                 //get direction
  418.                 b = flags_register&FLAG_PS2MOUSE_DIRECTION;
  419.  
  420.                 //reset pins and states
  421.                 ps2mouse_release_clk();
  422.  
  423.                 //analizing error
  424.                 if( b && (ps2mouse_initstep==0) )
  425.                 {
  426.                         //error due send first init byte - mouse not connected to PS/2
  427.  
  428.                         //disable mouse
  429.                         zx_mouse_reset(0);
  430.                 }
  431.                 else
  432.                 {
  433.                         //error due receive or send non first byte - mouse connected to PS/2
  434.  
  435.                         //re-init mouse
  436.                         ps2mouse_initstep = 0;
  437.                 }
  438.         }
  439.  
  440.         if ( ps2mouse_count!=0 ) return; // not received anything
  441.  
  442.         if ( !(flags_register&FLAG_PS2MOUSE_DIRECTION) )
  443.         {
  444.                 //receive complete
  445.                 b = ps2_decode(ps2mouse_count, ps2mouse_shifter);
  446.  
  447. #ifdef LOGENABLE
  448. {
  449.         char log_ps2mouse_parse[] = "MS<..\r\n";
  450.         log_ps2mouse_parse[3] = ((b >> 4) <= 9 )?'0'+(b >> 4):'A'+(b >> 4)-10;
  451.         log_ps2mouse_parse[4] = ((b & 0x0F) <= 9 )?'0'+(b & 0x0F):'A'+(b & 0x0F)-10;
  452.         to_log(log_ps2mouse_parse);
  453. }
  454. #endif
  455.  
  456.                 //if command proceed than command code
  457.                 //if initialization proceed than current init code
  458.                 //else 0
  459.                 switch( (flags_ex_register&FLAG_EX_PS2MOUSE_CMD)?ps2mouse_cmd:ps2mouse_init_sequence[ps2mouse_initstep] )
  460.                 {
  461.                         //initialization complete - working mode
  462.                         case 0:
  463.                                 ps2mouse_resp_count++;
  464.                                 switch( ps2mouse_resp_count )
  465.                                 {
  466.                                 case 1:
  467.                                         //byte 1: Y overflow | X overflow | Y sign bit | X sign bit | 1 | Middle Btn | Right Btn | Left Btn
  468.                                         zx_mouse_button = (zx_mouse_button&0xF0) + ((b^0x07)&0x0F);
  469.                                         break;
  470.                                 case 2:
  471.                                         //byte 2: X movement
  472.                                         zx_mouse_x += b;
  473.                                         break;
  474.                                 case 3:
  475.                                         //byte 3: Y movement
  476.                                         zx_mouse_y += b;
  477.                                         if ( !(flags_register&FLAG_PS2MOUSE_TYPE) )
  478.                                         {
  479.                                                 //classical mouse
  480.                                                 ps2mouse_resp_count = 0;
  481.                                                 flags_register |= FLAG_PS2MOUSE_ZX_READY;
  482.                                         }
  483.                                         break;
  484.                                 case 4:
  485.                                         //byte 4: wheel movement
  486.                                         zx_mouse_button += ((b<<4)&0xF0);
  487.                                         flags_register |= FLAG_PS2MOUSE_ZX_READY;
  488.                                         ps2mouse_resp_count = 0;
  489.                                 }
  490.                                 break;
  491.  
  492.                         //reset command
  493.                         case PS2MOUSE_CMD_RESET:
  494.                                 if ( ps2mouse_resp_count==1 )
  495.                                 {
  496.                                         //must be acknowledge
  497.                                         if ( b != 0xFA )
  498.                                         {
  499.                                                 if( flags_ex_register&FLAG_EX_PS2MOUSE_CMD )
  500.                                                 {
  501.                                                         //reset command
  502.                                                         ps2mouse_cmd = 0;
  503.                                                         flags_ex_register &= ~FLAG_EX_PS2MOUSE_CMD;
  504.                                                 }
  505.                                                 else
  506.                                                 {
  507.                                                         //reset initialization
  508.                                                         ps2mouse_initstep = 0;
  509.                                                 }
  510.                                                 ps2mouse_resp_count = 0;
  511.                                                 break;
  512.                                         }
  513.                                 }
  514.                                 ps2mouse_resp_count++;
  515.                                 if ( ps2mouse_resp_count >= 4 )
  516.                                 {
  517.                                         ps2mouse_resp_count = 0;
  518.                                         if( flags_ex_register&FLAG_EX_PS2MOUSE_CMD )
  519.                                         {
  520.                                                 //reset command
  521.                                                 ps2mouse_cmd = 0;
  522.                                                 flags_ex_register &= ~FLAG_EX_PS2MOUSE_CMD;
  523.                                         }
  524.                                         else
  525.                                         {
  526.                                                 //next initialization stage
  527.                                                 ps2mouse_initstep++;
  528.                                         }
  529.                                 }
  530.                                 break;
  531.  
  532.                         //get device type
  533.                         case PS2MOUSE_CMD_GET_TYPE:
  534.                                 if ( ps2mouse_resp_count==1 )
  535.                                 {
  536.                                         ps2mouse_resp_count++;
  537.                                         //must be acknowledge
  538.                                         if ( b != 0xFA )
  539.                                         {
  540.                                                 if( flags_ex_register&FLAG_EX_PS2MOUSE_CMD )
  541.                                                 {
  542.                                                         //reset command
  543.                                                         ps2mouse_cmd = 0;
  544.                                                         flags_ex_register &= ~FLAG_EX_PS2MOUSE_CMD;
  545.                                                 }
  546.                                                 else
  547.                                                 {
  548.                                                         //reset initialization
  549.                                                         ps2mouse_initstep = 0;
  550.                                                 }
  551.                                                 ps2mouse_resp_count = 0;
  552.                                         }
  553.                                         break;
  554.                                 }
  555.                                 else
  556.                                 {
  557.                                         ps2mouse_resp_count = 0;
  558.                                         if( flags_ex_register&FLAG_EX_PS2MOUSE_CMD )
  559.                                         {
  560.                                                 //reset command
  561.                                                 ps2mouse_cmd = 0;
  562.                                                 flags_ex_register &= ~FLAG_EX_PS2MOUSE_CMD;
  563.                                         }
  564.                                         else
  565.                                         {
  566.                                                 //next initialization stage
  567.                                                 ps2mouse_initstep++;
  568.                                         }
  569.  
  570.                                         if ( b > 0 )
  571.                                         {
  572.                                                 flags_register |= FLAG_PS2MOUSE_TYPE;
  573.                                         }
  574.                                         else
  575.                                         {
  576.                                                 flags_register &= ~(FLAG_PS2MOUSE_TYPE);
  577.                                         }
  578.                                 }
  579.                                 break;
  580.  
  581.                         //set resolution
  582.                         case PS2MOUSE_CMD_SET_RESOLUTION:
  583.                                 //must be acknowledge
  584.                                 if ( b != 0xFA )
  585.                                 {
  586.                                         if( flags_ex_register&FLAG_EX_PS2MOUSE_CMD )
  587.                                         {
  588.                                                 //reset command
  589.                                                 ps2mouse_cmd = 0;
  590.                                                 flags_ex_register &= ~FLAG_EX_PS2MOUSE_CMD;
  591.                                         }
  592.                                         else
  593.                                         {
  594.                                                 //reset initialization
  595.                                                 ps2mouse_initstep = 0;
  596.                                         }
  597.                                         ps2mouse_resp_count = 0;
  598.                                 }
  599.                                 else
  600.                                 {
  601.                                         if( flags_ex_register&FLAG_EX_PS2MOUSE_CMD )
  602.                                         {
  603.                                                 if( ps2mouse_resp_count >= 3 )
  604.                                                 {
  605.                                                         ps2mouse_resp_count = 0;
  606.                                                         //reset command
  607.                                                         ps2mouse_cmd = 0;
  608.                                                         flags_ex_register &= ~FLAG_EX_PS2MOUSE_CMD;
  609.                                                 }
  610.                                                 else
  611.                                                 {
  612.                                                         ps2mouse_resp_count ++;
  613.                                                 }
  614.                                         }
  615.                                         else
  616.                                         {
  617.                                                 //next initialization stage
  618.                                                 ps2mouse_resp_count = 0;
  619.                                                 ps2mouse_initstep++;
  620.                                         }
  621.                                 }
  622.                                 break;
  623.  
  624.                         //other commands
  625.                         default:
  626.                                 if( flags_ex_register&FLAG_EX_PS2MOUSE_CMD )
  627.                                 {
  628.                                         //reset command
  629.                                         ps2mouse_cmd = 0;
  630.                                         flags_ex_register &= ~FLAG_EX_PS2MOUSE_CMD;
  631.                                 }
  632.                                 else
  633.                                 {
  634.                                         //next initialization stage
  635.                                         ps2mouse_initstep++;
  636.                                         if ( ps2mouse_resp_count==1 )
  637.                                         {
  638.                                                 //must be acknowledge
  639.                                                 if ( b != 0xFA )
  640.                                                 {
  641.                                                         //reset initialization
  642.                                                         ps2mouse_initstep = 0;
  643.                                                 }
  644.                                         }
  645.                                 }
  646.                                 ps2mouse_resp_count = 0;
  647.                                 break;
  648.                 }
  649.         }
  650. //#ifdef LOGENABLE
  651. //      else
  652. //      {
  653. //              //send complete
  654. //              char log_ps2mouse_parse[] = "MS>..\r\n";
  655. //              b = ps2mouse_init_sequence[ps2mouse_initstep];
  656. //              log_ps2mouse_parse[3] = ((b >> 4) <= 9 )?'0'+(b >> 4):'A'+(b >> 4)-10;
  657. //              log_ps2mouse_parse[4] = ((b & 0x0F) <= 9 )?'0'+(b & 0x0F):'A'+(b & 0x0F)-10;
  658. //              to_log(log_ps2mouse_parse);
  659. //      }
  660. //#endif
  661.  
  662.         ps2mouse_release_clk();
  663. }
  664.  
  665. void ps2mouse_set_resolution(UBYTE code)
  666. {
  667. #ifdef LOGENABLE
  668. {
  669.         UBYTE b = zx_mouse_button;
  670.         char log_ps2mouse_parse[] = "SS:..-..\r\n";
  671.         log_ps2mouse_parse[3] = ((b >> 4) <= 9 )?'0'+(b >> 4):'A'+(b >> 4)-10;
  672.         log_ps2mouse_parse[4] = ((b & 0x0F) <= 9 )?'0'+(b & 0x0F):'A'+(b & 0x0F)-10;
  673.         b = code;
  674.         log_ps2mouse_parse[6] = ((b >> 4) <= 9 )?'0'+(b >> 4):'A'+(b >> 4)-10;
  675.         log_ps2mouse_parse[7] = ((b & 0x0F) <= 9 )?'0'+(b & 0x0F):'A'+(b & 0x0F)-10;
  676.         to_log(log_ps2mouse_parse);
  677. }
  678. #endif
  679.  
  680.         //if pressed left and right buttons on mouse
  681.         if ( (zx_mouse_button & 0x03) == 0 )
  682.         {
  683.                 switch( code )
  684.                 {
  685.                         //keypad '*' - set default resolution
  686.                         case 0x7C:
  687.                                 rtc_write(RTC_PS2MOUSE_RES_REG,0x00);
  688.                                 ps2mouse_cmd = PS2MOUSE_CMD_SET_RESOLUTION;
  689.                                 break;
  690.  
  691.                         //keypad '+' - inc resolution
  692.                         case 0x79:
  693.                         {
  694.                                 UBYTE data = rtc_read(RTC_PS2MOUSE_RES_REG)&0x03;
  695.                                 if( data < 0x03 )
  696.                                 {
  697.                                         data++;
  698.                                 }
  699.                                 rtc_write(RTC_PS2MOUSE_RES_REG,data);
  700.                                 ps2mouse_cmd = PS2MOUSE_CMD_SET_RESOLUTION;
  701.                             break;
  702.                         }
  703.  
  704.                         //keypad '-' - dec resolution
  705.                         case 0x7B:
  706.                         {
  707.                                 UBYTE data = rtc_read(RTC_PS2MOUSE_RES_REG)&0x03;
  708.                                 if (data)
  709.                                 {
  710.                                         data--;
  711.                                 }
  712.                                 rtc_write(RTC_PS2MOUSE_RES_REG,data);
  713.                                 ps2mouse_cmd = PS2MOUSE_CMD_SET_RESOLUTION;
  714.                             break;
  715.                         }
  716.                 }
  717.         }
  718. }
  719.