#include <system.h>
#include <hal.h>
#include "keyus.h"
#include "../irq/irq.h"

extern void reboot();

const char kbdus_map[] = {
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '\t', '`', 0,
      0, 0, 0, 0, 0, 'q', '1', 0, 0, 0, 'z', 's', 'a', 'w', '2', 0,
      0, 'c', 'x', 'd', 'e', '4', '3', 0, 0, ' ', 'v', 'f', 't', 'r', '5', 0,
      0, 'n', 'b', 'h', 'g', 'y', '6', 0, 0, 0, 'm', 'j', 'u', '7', '8', 0,
      0, ',', 'k', 'i', 'o', '0', '9', 0, 0, '.', '/', 'l', ';', 'p', '-', 0,
      0, 0, '\'', 0, '[', '=', 0, 0, 0, '\n', '\n', ']', 0, '\\', 0, 0,
      0, 0, 0x7F, 0, 0, 0, '\b', 0, 0, '1', '/', '4', '7', 0, 0, 0,
      '0', '.', '2', '5', '6', '8', 0, 0, 0, '+', '3', '-', '*', '9', 0, 0
      };

const char kbdus_map_shift[] = {
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '\t', '~', 0,
      0, 0, 0, 0, 0, 'Q', '!', 0, 0, 0, 'Z', 'S', 'A', 'W', '@', 0,
      0, 'C', 'X', 'D', 'E', '$', '#', 0, 0, ' ', 'V', 'F', 'T', 'R', '%', 0,
      0, 'N', 'B', 'H', 'G', 'Y', '^', 0, 0, 0, 'M', 'J', 'U', '&', '*', 0,
      0, '<', 'K', 'I', 'O', ')', '(', 0, 0, '>', '?', 'L', ':', 'P', '_', 0,
      0, 0, '\"', 0, '{', '+', 0, 0, 0, '\n', '\n', '}', 0, '|', 0, 0,
      0, 0, 0x7F, 0, 0, 0, '\b', 0, 0, '1', '/', '4', '7', 0, 0, 0,
      '0', '.', '2', '5', '6', '8', 0, 0, 0, '+', '3', '-', '*', '9', 0, 0
      };


volatile unsigned char kb_array[16];
volatile unsigned char kb_newdata;
volatile unsigned char kb_modifier_status;
volatile unsigned char kb_prefix;
volatile unsigned char kb_lights_status;
unsigned char kb_scancode_set;


void i86_kb_set_key(unsigned char scancode, unsigned char val)
{
      unsigned char pos = scancode/8;
      unsigned char offset = scancode%8;
      
      if (val) {
            kb_array[pos] |= 1<<offset;
            kb_newdata = scancode;
            }
      else kb_array[pos] &= 0xFF - (1<<offset);
}

unsigned char i86_kb_get_key(unsigned char scancode)
{
      unsigned char pos = scancode/8;
      unsigned char offset = scancode%8;
      return (kb_array[pos]&(1<<offset));
}


void i86_kb_handler(ISR_stack_regs *r) {
      unsigned char scancode = inportb(0x60);

      switch (scancode) {
            case 0x00:                                      // Error 0x00
            case 0xFC:                                      // Diagnostics failed (MF kb)
            case 0xFD:                                      // Diagnostics failed (AT kb)
            case 0xFF: i86_kb_waitin(); outportb(0x60, 0xF4);   // Error 0xFF
                        break;
            case 0xAA:                                      // BAT test successful.
            case 0xFA:                                      // ACKnowledge
            case 0xFE:                                      // Last command invalid or parity error
            case 0xEE: break;                              // Echo response
        // Gray or break
            case 0xE0: kb_prefix |= 1; break;
            case 0xE1: kb_prefix |= 4; break;
            case 0xF0: kb_prefix |= 2; break;

        // Alt, ctrl...
            case 0x11: if ((kb_prefix&1) == 0) {              // Left alt
                           if ((kb_prefix&2) == 0) kb_modifier_status |= 1<<2;
                           else kb_modifier_status &= 0xFF - (1<<2);
                        }
                        else {                              // Right alt
                           if ((kb_prefix&2) == 0) kb_modifier_status |= 1<<3;
                           else kb_modifier_status &= 0xFF - (1<<3);
                        }
                        kb_prefix = 0; break;
                        
            case 0x12: if ((kb_prefix&1) == 0) {              // Left shift
                           if ((kb_prefix&2) == 0) kb_modifier_status |= 1<<0;
                           else kb_modifier_status &= 0xFF - (1<<0);
                        }
                        else {                              // Fake shift
                           if ((kb_prefix&2) == 0) kb_modifier_status |= 1<<6;
                           else kb_modifier_status &= 0xFF - (1<<6);
                        }
                        kb_prefix = 0; break;
                        
            case 0x14: if (kb_prefix&4) {
                              if ((kb_prefix&2) == 0) i86_kb_set_key (0, 1);
                              else i86_kb_set_key (0, 0);
                              kb_prefix |= 8; break;
                              }
            
                        else if ((kb_prefix&1) == 0) {              // Left ctrl
                           if ((kb_prefix&2) == 0) kb_modifier_status |= 1<<4;
                           else kb_modifier_status &= 0xFF - (1<<4);
                        }
                        else {                              // Right ctrl
                           if ((kb_prefix&2) == 0) kb_modifier_status |= 1<<5;
                           else kb_modifier_status &= 0xFF - (1<<5);
                        }
                        kb_prefix = 0; break;
                        
            case 0x59:                                      // Right shift
                        if ((kb_prefix&2) == 0) kb_modifier_status |= 1<<1;
                        else kb_modifier_status &= 0xFF - (1<<1);

                        kb_prefix = 0; break;
                        
        // LEDs
            case 0x58: if ((kb_prefix&2) == 0) {
                  kb_lights_status ^= 4; i86_kb_set_LEDs(kb_lights_status);
                  } kb_prefix = 0; break; // Caps
                  
            //TO ADD BELOW: pause/break byte2
            case 0x77:
                  if ((kb_prefix&4) && (kb_prefix&8)) kb_prefix=0;
                  else if ((kb_prefix&2) == 0) {
                  kb_lights_status ^= 2; i86_kb_set_LEDs(kb_lights_status); 
                  } kb_prefix = 0; break; // Num
            case 0x7E: if ((kb_prefix&2) == 0) {
                  kb_lights_status ^= 1; i86_kb_set_LEDs(kb_lights_status); 
                  } kb_prefix = 0; break; // Scroll
                        
            case 0x83: scancode = 0x02; // Put F7 under the 0x80 (128bit) barrier
                        
            default: 
                  // Remap gray keys
                  if (kb_prefix&1) switch (scancode) {
                        case 0x7C: scancode=0x08; break;    // PrintScreen
                        case 0x4A: scancode=0x6A; break;    // Numpad /
                        case 0x5A: scancode=0x59; break;    // Numpad Enter
                        case 0x69: scancode=0x5E; break;    // End
                        case 0x6B: scancode=0x5F; break;    // Left
                        case 0x6C: scancode=0x60; break;    // Home
                        case 0x70: scancode=0x61; break;    // Insert
                        case 0x71: scancode=0x62; break;    // Delete
                        case 0x72: scancode=0x63; break;    // Down
                        case 0x74: scancode=0x64; break;    // Right
                        case 0x75: scancode=0x65; break;    // Up
                        case 0x7A: scancode=0x67; break;    // PageDown
                        case 0x7D: scancode=0x68; break;    // PageUp
                        }
                  if ((kb_prefix&2) == 0) i86_kb_set_key(scancode, 1);
                  else i86_kb_set_key(scancode, 0);
                  
                  kb_prefix = 0; break;
      }
      
      // Alt+ctrl+del = reset
      if (scancode==0x62) {
            int ok=0;
            if ((kb_modifier_status&4) || (kb_modifier_status&8)) ok++;
            if ((kb_modifier_status&16) || (kb_modifier_status&32)) ok++;
            if (ok==2) reboot();
            }
      
}



kb_key getkey()
{
      kb_key ret;
      
      kb_newdata = 0xFF;
      while (kb_newdata==0xFF);              // wait for keypress
      
      ret.scancode = kb_newdata;          // Send scancode for non-chars
      ret.status = kb_modifier_status;    // Shift, ctrl... state
      ret.lights = kb_lights_status;      // Num, caps.... state
      
      if ((ret.status & 1) || (ret.status & 2)) // Shift is on
            ret.character = kbdus_map_shift[ret.scancode];
      else ret.character = kbdus_map[ret.scancode]; // Shift is off
      
      return ret;                         // And send it.
}




/***************************************
 *       Set repeat rate/delay         *
 ***************************************
 Values for inter-character delay (bits 4-0)
 (characters per second; default is 10.9)
     |  0 |  1 |  2 |  3 |  4 |  5 |  6 |  7 
 ----+----+----+----+----+----+----+----+----
  0  |30.0|26.7|24.0|21.8|20.0|18.5|17.1|16.0
  8  |15.0|13.3|12.0|10.9|10.0|9.2 |8.6 |8.0
  16 |7.5 |6.7 |6.0 |5.5 |5.0 |4.6 |4.3 |4.0
  24 |3.7 |3.3 |3.0 |2.7 |2.5 |2.3 |2.1 |2.0
  
 Values for delay:
 (miliseconds; default is 500)
    0 |   1 |   2 |   3
 -----+-----+-----+-----
  250 | 500 | 750 | 1000
  
 ***************************************/ 
void i86_kb_set_repeat(unsigned char rate, unsigned char delay)
{
      if (rate>3 || delay>31) return;

      unsigned char out = rate<<5 | delay;
      while ((inportb(0x64)&2) != 0);
      outportb(0x60, 0xF3);
      while ((inportb(0x64)&2) != 0);
      outportb(0x60, out);
}


/***************************************
 *       Set keyboard LEDs             *
 ***************************************
 +-----------+-------+-------+--------+
 | Bits 7-3  | Bit 2 | Bit 1 | Bit 0  |
 |   0       | Caps  | Num   | Scroll |
 |(reserved) |  lock |  lock |  lock  |
 +-----------+-------+-------+--------+
 ***************************************/ 
void i86_kb_set_LEDs(unsigned char status)
{
    while ((inportb (0x64)&2)!=0);
    outportb (0x60, 0xED);
  
    while ((inportb (0x64)&2)!=0);
    outportb (0x60, status);
}

/***************************************
 *       Set scancode set              *
 ***************************************
      0  Get current scancode set
      1  Set to scancode set 1
      2  Set to scancode set 2
      3  Set to scancode set 3
 ***************************************/ 
void i86_kb_set_scancodeset(unsigned char set)
{
    if (set>3) return;
    
    while ((inportb (0x64)&2)!=0);
    outportb (0x60, 0xF0);
  
    while ((inportb (0x64)&2)!=0);
    outportb (0x60, set);
    
    kb_scancode_set = set;
}

unsigned char i86_kb_get_scancodeset() {
      return kb_scancode_set;
}

void i86_kb_waitin()
{
      int fail_safe=200000;
      while ((inportb(0x64)&2)!=0 && fail_safe>0) fail_safe--;
}

void i86_kb_waitout()
{
      int fail_safe=200000;
      while ((inportb(0x64)&1)==0 && fail_safe>0) fail_safe--;
}


void i86_kb_install_partone()
{
      i86_irq_install_handler(1, i86_kb_handler);// instali handler
      i86_kb_waitin(); outportb(0x60, 0xFF);         // Reset kb
      
      // Initialize variables
      kb_newdata = 0;
      kb_modifier_status = 0;
      kb_prefix = 0;
      kb_lights_status = 0;
      kb_scancode_set = 0;

}


int i86_kb_install_parttwo()
{
      int ret = 0;

      // Wait for BAT test results
      unsigned char temp;
      do temp = inportb(0x60);
      while (temp!=0xAA && temp!=0xFC);

      if (temp == 0xFC) ret = -1;
      
      // Set new repeat rate
      i86_kb_set_repeat(1, 11);

      // Set scancode set 2
      i86_kb_set_scancodeset(2);  // Set new scancode set

      i86_kb_waitin();
      outportb(0x64, 0x20); // Get "Command unsigned char"
      
      do {  temp = inportb(0x60);
      } while (temp==0xFA || temp==0xAA);
      
      temp &= 0xFF - (1<<6); // Set bit6 to 0: disable conversion
      i86_kb_waitin(); outportb(0x64, 0x60); // Function to write cmd unsigned char
      i86_kb_waitin(); outportb(0x60, temp); // Send it
      memset((void*)kb_array, 0, 16);

      return ret;

}