Subversion Repositories pentevo

Rev

Rev 1025 | 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 "pins.h"
  8. #include "main.h"
  9. #include "ps2.h"
  10. #include "rs232.h"
  11. #include "zx.h"
  12. #include "spi.h"
  13. #include "atx.h"
  14. #include "rtc.h"
  15. #include "joystick.h"
  16.  
  17. ISR(TIMER0_COMP_vect)
  18. {
  19.         static BYTE scanjoy=12;
  20.        
  21.         switch(scanjoy)
  22.         {
  23.                 case 13:
  24.                         scanjoy=0;
  25. //                      jkey_state = 0;
  26. //                      jkey_state |= (~JOYSTICK_PIN)&0b00011111;                       // arrows
  27.                         jkey_state = (~JOYSTICK_PIN)&0b00011111;
  28.                        
  29.                         if( ( gamepad_type & JOY_WITH_KBD ) == 0 )
  30.                         {
  31.                                 jkey_state |= (~PINA) & 0b00100000;                     // EJOY_C
  32.                         }
  33.                        
  34.                         TCCR0 = 0b00111100;
  35.                 case 2:
  36.                 case 4:
  37.                         SEGA_SYNC_DOWN();
  38.                         OCR0=TCNT0+1;
  39.                         break;
  40.                        
  41.                 case 1:
  42.                         jkey_state |= ((~JOYSTICK_PIN) & 0b00010000) << 2;      // EJOY_A
  43.                        
  44.                         if( ( gamepad_type & JOY_WITH_KBD ) == 0 )
  45.                         {
  46.                                 jkey_state |= ((~PINA) & 0b00100000) << 2;                                      // EJOY_START
  47.                         }
  48.                        
  49.                         SEGA_SYNC_UP();
  50.                        
  51.                         if(gamepad_type & JOY_SEGA_8KEY)
  52.                         {//пропускаем опрос дополнительных кнопок
  53.                                 scanjoy = 6;
  54.                         }      
  55.                         OCR0=TCNT0+1;
  56.                         break;
  57.                        
  58. //              case 2:
  59. //                      SEGA_SYNC_DOWN();
  60. //                      OCR0=TCNT0+1;
  61. //                      break;
  62.  
  63.                 case 3:
  64.                 case 5:
  65.                         SEGA_SYNC_UP();
  66.                         OCR0=TCNT0+1;
  67.                         break;
  68.                        
  69. //              case 4:
  70. //                      SEGA_SYNC_DOWN();
  71. //                      OCR0=TCNT0+1;
  72. //                      break;
  73. //
  74. //              case 5:
  75. //                      SEGA_SYNC_UP();
  76. //                      OCR0=TCNT0+1;
  77. //                      break;
  78.  
  79.                 case 6:
  80.                         jkey_state |= (((UWORD)((~JOYSTICK_PIN) & 0b00001111)) << 8);
  81.                         SEGA_SYNC_DOWN();
  82.                         OCR0=TCNT0+1;
  83.                         break;
  84.                        
  85.                 case 7:
  86.                         zx_realkbd[10] = 4;
  87.                         SEGA_SYNC_UP();
  88.                         TCCR0 = 0b00111101;
  89.                 default:
  90.                         OCR0=TCNT0+255;
  91.                         break;
  92.         }
  93.        
  94.         scanjoy++;
  95. }
  96.  
  97. ISR(TIMER2_OVF_vect)
  98. {
  99.         static BYTE dir=0x01;
  100.         static BYTE ocr=0x00;
  101.         static BYTE scankbd=0;
  102.         static BYTE cskey=0xff;
  103.  
  104. //      counter++; // just fucking shit to fadein-fadeout LED :-)))
  105. //      if( counter & 8 )
  106.         {
  107. //              counter=0;
  108.  
  109.                 ocr += dir;
  110.                 if( (ocr==(-1)) && (dir==(-1)) )
  111.                 {
  112.                         dir = -dir;
  113.                         ocr = 1;
  114.                 } else if( (ocr==0) && (dir==1) )
  115.                 {
  116.                         dir = -dir;
  117.                         ocr = 0xFF;
  118.                 }
  119.  
  120.                 OCR2 = ocr;
  121.         }
  122.  
  123.         // PS/2 keyboard timeout tracking
  124.         if( (ps2keyboard_count<12) && (ps2keyboard_count!=0) )
  125.         {
  126.                 if( ( (flags_register&FLAG_PS2KEYBOARD_DIRECTION)!=0 ) && ( ps2keyboard_count==11 ) && ( ps2keyboard_timeout<PS2KEYBOARD_TIMEOUT ) )
  127.                 {
  128.                         //release clock after first programmed interrupt
  129.                         PS2KBCLK_PORT |= (1<<PS2KBCLK);  //release ps2keyboard clk pin
  130.                         PS2KBCLK_DDR  &= ~(1<<PS2KBCLK);
  131.                 }
  132.                 if( ps2keyboard_timeout ) ps2keyboard_timeout--;
  133.         }
  134.  
  135.         // pause for keyboard CS|SS
  136.         if( shift_pause )
  137.                 shift_pause--;
  138.  
  139.         // PS/2 mouse timeout tracking
  140.         if( (ps2mouse_count<12) && (ps2mouse_count!=0) )
  141.         {
  142.                 if( ( (flags_register&FLAG_PS2MOUSE_DIRECTION)!=0 ) && ( ps2mouse_count==11 ) && ( ps2mouse_timeout<PS2MOUSE_TIMEOUT ) )
  143.                 {
  144.                         //release clock after first programmed interrupt
  145.                         PS2MSCLK_PORT |= (1<<PS2MSCLK);  //release ps2mouse clk pin
  146.                         PS2MSCLK_DDR  &= ~(1<<PS2MSCLK);
  147.                 }
  148.                 if( ps2mouse_timeout ) ps2mouse_timeout--;
  149.         }
  150.  
  151.         //check soft reset and F12 key
  152.         if ( !( SOFTRES_PIN & (1<<SOFTRES)) ||
  153.              (kb_ctrl_status & KB_F12_MASK) )
  154.         {
  155.                 //pressed
  156.                 atx_counter++;
  157.         }
  158.         else
  159.         {
  160.                 //not pressed
  161.                 atx_counter = 0;
  162.         }
  163.        
  164.         if( gamepad_type != JOY_SWITCHS )// JOY_SWITCHS )
  165.         {
  166.                 return;
  167.         }
  168.  
  169.         //set next scankbd net
  170.         switch(scankbd)
  171.         {
  172.         case 0:
  173.                 {
  174.                         UBYTE tmp = PINA;
  175.                         zx_realkbd[5] = tmp & cskey;
  176.                         cskey = tmp | 0xfe;
  177.                         DDRC  = 0b00010000;
  178.                         PORTC = 0b11001111;
  179.                         zx_realkbd[10] = 4;
  180.                         //scankbd = 4;
  181.                         scankbd = 5;
  182.                 }
  183.                 break;
  184.        
  185.         case 1:
  186.                 zx_realkbd[6] = PINA;
  187.                 DDRC  = 0b00000001;
  188.                 PORTC = 0b11011110;
  189.                 //scankbd = 0;
  190.                 break;
  191.                
  192.         case 2:
  193.                 zx_realkbd[7] = PINA;
  194.                 DDRC  = 0b00000010;
  195.                 PORTC = 0b11011101;
  196.                 //scankbd = 1;
  197.                 break;
  198.                
  199.         case 3:
  200.                 zx_realkbd[8] = PINA;
  201.                 DDRC  = 0b00000100;
  202.                 PORTC = 0b11011011;
  203.                 //scankbd = 2;
  204.                 break;
  205.                
  206.         case 4:
  207.                 zx_realkbd[9] = PINA;
  208.                 DDRC  = 0b00001000;
  209.                 PORTC = 0b11010111;
  210.                 //scankbd = 3;
  211.                 break;
  212.         }
  213.        
  214.         scankbd--;
  215. }
  216.  
  217. // receive/send PS/2 keyboard data
  218. ISR(INT4_vect)
  219. {
  220.         if( (flags_register&FLAG_PS2KEYBOARD_DIRECTION) != 0 )
  221.         {
  222.                 //send mode
  223.                 if( --ps2keyboard_count )
  224.                 {
  225.                         if ( ps2keyboard_shifter&1 ) PS2KBDAT_PORT |= (1<<PS2KBDAT);
  226.                         else PS2KBDAT_PORT &= ~(1<<PS2KBDAT);
  227.  
  228.                         ps2keyboard_shifter >>= 1;
  229.  
  230.                         if( ps2keyboard_count == 11 )
  231.                         {
  232.                                 //first interrupt is programmed
  233.                                 PS2KBDAT_DDR |= (1<<PS2KBDAT);   //ps2keyboard data pin to output mode
  234.                                 //_delay_us(250);  //hold ps2keyboard clk pin ~250us
  235.                                 //PS2KBCLK_PORT |= (1<<PS2KBCLK);  //release ps2keyboard clk pin
  236.                                 //PS2KBCLK_DDR  &= ~(1<<PS2KBCLK);
  237.                         }
  238.                         else if( ps2keyboard_count == 1)
  239.                         {
  240.                                 PS2KBDAT_DDR &= ~(1<<PS2KBDAT); //ps2keyboard data pin to input mode
  241.                         }
  242.                 }
  243.                 else
  244.                 {
  245.                         //ack received
  246.                         PS2KBCLK_PORT &= ~(1<<PS2KBCLK);
  247.                         PS2KBCLK_DDR  |= (1<<PS2KBCLK);
  248.                 }
  249.         }
  250.         else
  251.         {
  252.                 //receive mode
  253.                 ps2keyboard_shifter >>= 1;
  254.                 if( (PS2KBDAT_PIN&(1<<PS2KBDAT)) ) ps2keyboard_shifter |= 0x8000;
  255.  
  256.                 if( (--ps2keyboard_count) == 1 )
  257.                 {
  258.                         PS2KBCLK_PORT &= ~(1<<PS2KBCLK);
  259.                         PS2KBCLK_DDR  |= (1<<PS2KBCLK);
  260.                         ps2keyboard_count = 0;
  261.                 }
  262.         }
  263.  
  264.         EIFR = (1<<INTF4);
  265.  
  266.         //set timeout
  267.         ps2keyboard_timeout = PS2KEYBOARD_TIMEOUT;
  268. }
  269.  
  270. // receive/send PS/2 mouse data
  271. ISR(INT5_vect)
  272. {
  273.         if( (flags_register&FLAG_PS2MOUSE_DIRECTION) != 0 )
  274.         {
  275.                 //send mode
  276.                 if( --ps2mouse_count )
  277.                 {
  278.                         if ( ps2mouse_shifter&1 ) PS2MSDAT_PORT |= (1<<PS2MSDAT);
  279.                         else PS2MSDAT_PORT &= ~(1<<PS2MSDAT);
  280.  
  281.                         ps2mouse_shifter >>= 1;
  282.  
  283.                         if( ps2mouse_count == 11 )
  284.                         {
  285.                                 //first interrupt is programmed
  286.                                 //must hold pin >250us
  287.                                 PS2MSDAT_DDR |= (1<<PS2MSDAT);   //ps2mouse data pin to output mode
  288.                                 //_delay_us(250);  //hold ps2mouse clk pin ~250us
  289.                                 //PS2MSCLK_PORT |= (1<<PS2MSCLK);  //release ps2mouse clk pin
  290.                                 //PS2MSCLK_DDR  &= ~(1<<PS2MSCLK);
  291.                         }
  292.                         else if( ps2mouse_count == 1)
  293.                         {
  294.                                 PS2MSDAT_DDR &= ~(1<<PS2MSDAT); //ps2mouse data pin to input mode
  295.                         }
  296.                 }
  297.                 else
  298.                 {
  299.                         //ack received
  300.                         PS2MSCLK_PORT &= ~(1<<PS2MSCLK);
  301.                         PS2MSCLK_DDR  |= (1<<PS2MSCLK);
  302.                 }
  303.         }
  304.         else
  305.         {
  306.                 //receive mode
  307.                 ps2mouse_shifter >>= 1;
  308.                 if( (PS2MSDAT_PIN&(1<<PS2MSDAT)) ) ps2mouse_shifter |= 0x8000;
  309.  
  310.                 if( (--ps2mouse_count) == 1 )
  311.                 {
  312.                         PS2MSCLK_PORT &= ~(1<<PS2MSCLK);
  313.                         PS2MSCLK_DDR  |= (1<<PS2MSCLK);
  314.                         ps2mouse_count = 0;
  315.                 }
  316.         }
  317.  
  318.         EIFR = (1<<INTF5);
  319.  
  320.         //set timeout
  321.         ps2mouse_timeout = PS2MOUSE_TIMEOUT;
  322. }
  323.  
  324.  // SPI_INT
  325. ISR(INT6_vect)
  326. {
  327.         flags_register |= FLAG_SPI_INT;
  328.         EIFR = (1<<INTF6);
  329. }
  330.  
  331.  // RTC up data
  332. ISR(INT7_vect)
  333. {
  334.         gluk_inc();
  335.         EIFR = (1<<INTF7);
  336. }
  337.  
  338.