Subversion Repositories pentevo

Rev

Rev 1024 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed | ?url?

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