Subversion Repositories pentevo

Rev

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