Subversion Repositories pentevo

Rev

Blame | 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.  
  16. ISR(TIMER2_OVF_vect)
  17. {
  18.         static UBYTE counter=0x00;
  19.         static BYTE dir=0x01;
  20.         static BYTE ocr=0x00;
  21.         static BYTE scankbd=0;
  22.         static BYTE cskey=0xff;
  23.  
  24. //      counter++; // just fucking shit to fadein-fadeout LED :-)))
  25. //      if( counter & 8 )
  26.         {
  27. //              counter=0;
  28.  
  29.                 ocr += dir;
  30.                 if( (ocr==(-1)) && (dir==(-1)) )
  31.                 {
  32.                         dir = -dir;
  33.                         ocr = 1;
  34.                 } else if( (ocr==0) && (dir==1) )
  35.                 {
  36.                         dir = -dir;
  37.                         ocr = 0xFF;
  38.                 }
  39.  
  40.                 OCR2 = ocr;
  41.         }
  42.  
  43.         // PS/2 keyboard timeout tracking
  44.         if( (ps2keyboard_count<12) && (ps2keyboard_count!=0) )
  45.         {
  46.                 if( ( (flags_register&FLAG_PS2KEYBOARD_DIRECTION)!=0 ) && ( ps2keyboard_count==11 ) && ( ps2keyboard_timeout<PS2KEYBOARD_TIMEOUT ) )
  47.                 {
  48.                         //release clock after first programmed interrupt
  49.                         PS2KBCLK_PORT |= (1<<PS2KBCLK);  //release ps2keyboard clk pin
  50.                         PS2KBCLK_DDR  &= ~(1<<PS2KBCLK);
  51.                 }
  52.                 if( ps2keyboard_timeout ) ps2keyboard_timeout--;
  53.         }
  54.  
  55.         // pause for keyboard CS|SS
  56.         if( shift_pause )
  57.                 shift_pause--;
  58.  
  59.         // PS/2 mouse timeout tracking
  60.         if( (ps2mouse_count<12) && (ps2mouse_count!=0) )
  61.         {
  62.                 if( ( (flags_register&FLAG_PS2MOUSE_DIRECTION)!=0 ) && ( ps2mouse_count==11 ) && ( ps2mouse_timeout<PS2MOUSE_TIMEOUT ) )
  63.                 {
  64.                         //release clock after first programmed interrupt
  65.                         PS2MSCLK_PORT |= (1<<PS2MSCLK);  //release ps2mouse clk pin
  66.                         PS2MSCLK_DDR  &= ~(1<<PS2MSCLK);
  67.                 }
  68.                 if( ps2mouse_timeout ) ps2mouse_timeout--;
  69.         }
  70.  
  71.         //check soft reset and F12 key
  72.         if ( !( SOFTRES_PIN & (1<<SOFTRES)) ||
  73.              (kb_ctrl_status & KB_F12_MASK) )
  74.         {
  75.                 //pressed
  76.                 atx_counter++;
  77.         }
  78.         else
  79.         {
  80.                 //not pressed
  81.                 atx_counter = 0;
  82.         }
  83.  
  84.         if ( scankbd==0 )
  85.         {
  86.                 UBYTE tmp;
  87.                 tmp = PINA;
  88.                 zx_realkbd[5] = tmp & cskey;
  89.                 cskey = tmp | 0xfe;
  90.                 DDRC  = 0b00010000;
  91.                 PORTC = 0b11001111;
  92.                 zx_realkbd[10] = 4;
  93.                 scankbd=4;
  94.         }
  95.         else if ( scankbd==1 )
  96.         {
  97.                 zx_realkbd[6] = PINA;
  98.                 DDRC  = 0b00000001;
  99.                 PORTC = 0b11011110;
  100.                 scankbd=0;
  101.         }
  102.         else if ( scankbd==2 )
  103.         {
  104.                 zx_realkbd[7] = PINA;
  105.                 DDRC  = 0b00000010;
  106.                 PORTC = 0b11011101;
  107.                 scankbd=1;
  108.         }
  109.         else if ( scankbd==3 )
  110.         {
  111.                 zx_realkbd[8] = PINA;
  112.                 DDRC  = 0b00000100;
  113.                 PORTC = 0b11011011;
  114.                 scankbd=2;
  115.         }
  116.         else if ( scankbd==4 )
  117.         {
  118.                 zx_realkbd[9] = PINA;
  119.                 DDRC  = 0b00001000;
  120.                 PORTC = 0b11010111;
  121.                 scankbd=3;
  122.         }
  123. }
  124.  
  125. // receive/send PS/2 keyboard data
  126. ISR(INT4_vect)
  127. {
  128.         if( (flags_register&FLAG_PS2KEYBOARD_DIRECTION) != 0 )
  129.         {
  130.                 //send mode
  131.                 if( --ps2keyboard_count )
  132.                 {
  133.                         if ( ps2keyboard_shifter&1 ) PS2KBDAT_PORT |= (1<<PS2KBDAT);
  134.                         else PS2KBDAT_PORT &= ~(1<<PS2KBDAT);
  135.  
  136.                         ps2keyboard_shifter >>= 1;
  137.  
  138.                         if( ps2keyboard_count == 11 )
  139.                         {
  140.                                 //first interrupt is programmed
  141.                                 PS2KBDAT_DDR |= (1<<PS2KBDAT);   //ps2keyboard data pin to output mode
  142.                                 //_delay_us(250);  //hold ps2keyboard clk pin ~250us
  143.                                 //PS2KBCLK_PORT |= (1<<PS2KBCLK);  //release ps2keyboard clk pin
  144.                                 //PS2KBCLK_DDR  &= ~(1<<PS2KBCLK);
  145.                         }
  146.                         else if( ps2keyboard_count == 1)
  147.                         {
  148.                                 PS2KBDAT_DDR &= ~(1<<PS2KBDAT); //ps2keyboard data pin to input mode
  149.                         }
  150.                 }
  151.                 else
  152.                 {
  153.                         //ack received
  154.                         PS2KBCLK_PORT &= ~(1<<PS2KBCLK);
  155.                         PS2KBCLK_DDR  |= (1<<PS2KBCLK);
  156.                 }
  157.         }
  158.         else
  159.         {
  160.                 //receive mode
  161.                 ps2keyboard_shifter >>= 1;
  162.                 if( (PS2KBDAT_PIN&(1<<PS2KBDAT)) ) ps2keyboard_shifter |= 0x8000;
  163.  
  164.                 if( (--ps2keyboard_count) == 1 )
  165.                 {
  166.                         PS2KBCLK_PORT &= ~(1<<PS2KBCLK);
  167.                         PS2KBCLK_DDR  |= (1<<PS2KBCLK);
  168.                         ps2keyboard_count = 0;
  169.                 }
  170.         }
  171.  
  172.         EIFR = (1<<INTF4);
  173.  
  174.         //set timeout
  175.         ps2keyboard_timeout = PS2KEYBOARD_TIMEOUT;
  176. }
  177.  
  178. // receive/send PS/2 mouse data
  179. ISR(INT5_vect)
  180. {
  181.         if( (flags_register&FLAG_PS2MOUSE_DIRECTION) != 0 )
  182.         {
  183.                 //send mode
  184.                 if( --ps2mouse_count )
  185.                 {
  186.                         if ( ps2mouse_shifter&1 ) PS2MSDAT_PORT |= (1<<PS2MSDAT);
  187.                         else PS2MSDAT_PORT &= ~(1<<PS2MSDAT);
  188.  
  189.                         ps2mouse_shifter >>= 1;
  190.  
  191.                         if( ps2mouse_count == 11 )
  192.                         {
  193.                                 //first interrupt is programmed
  194.                                 //must hold pin >250us
  195.                                 PS2MSDAT_DDR |= (1<<PS2MSDAT);   //ps2mouse data pin to output mode
  196.                                 //_delay_us(250);  //hold ps2mouse clk pin ~250us
  197.                                 //PS2MSCLK_PORT |= (1<<PS2MSCLK);  //release ps2mouse clk pin
  198.                                 //PS2MSCLK_DDR  &= ~(1<<PS2MSCLK);
  199.                         }
  200.                         else if( ps2mouse_count == 1)
  201.                         {
  202.                                 PS2MSDAT_DDR &= ~(1<<PS2MSDAT); //ps2mouse data pin to input mode
  203.                         }
  204.                 }
  205.                 else
  206.                 {
  207.                         //ack received
  208.                         PS2MSCLK_PORT &= ~(1<<PS2MSCLK);
  209.                         PS2MSCLK_DDR  |= (1<<PS2MSCLK);
  210.                 }
  211.         }
  212.         else
  213.         {
  214.                 //receive mode
  215.                 ps2mouse_shifter >>= 1;
  216.                 if( (PS2MSDAT_PIN&(1<<PS2MSDAT)) ) ps2mouse_shifter |= 0x8000;
  217.  
  218.                 if( (--ps2mouse_count) == 1 )
  219.                 {
  220.                         PS2MSCLK_PORT &= ~(1<<PS2MSCLK);
  221.                         PS2MSCLK_DDR  |= (1<<PS2MSCLK);
  222.                         ps2mouse_count = 0;
  223.                 }
  224.         }
  225.  
  226.         EIFR = (1<<INTF5);
  227.  
  228.         //set timeout
  229.         ps2mouse_timeout = PS2MOUSE_TIMEOUT;
  230. }
  231.  
  232.  // SPI_INT
  233. ISR(INT6_vect)
  234. {
  235.         flags_register |= FLAG_SPI_INT;
  236.         EIFR = (1<<INTF6);
  237. }
  238.  
  239.  // RTC up data
  240. ISR(INT7_vect)
  241. {
  242.         gluk_inc();
  243.         EIFR = (1<<INTF7);
  244. }
  245.  
  246.