LCOM1920-T7G03.old1

#include "mouse.h"

#include <lcom/lcf.h>

uint8_t byte;

int mouse_id=2; //KBD_AUX_IRQ is defined in interrupt.h in .minix-src folder

int (util_sys_inb)(int port, uint8_t *value) { //transform 8 bit into 32 bit

  uint32_t new_val;                           //initializing 32 bit variable

  if(sys_inb(port,&new_val)!=0){              //verifies if there is an error

      printf("Error in util_sys_inb\n");

      return 1;

  }

  *value=new_val & 0xFF;                      //dereferencing "value"

  #ifdef LAB3

  cnt++;

  #endif

  return 0;

}

void (mouse_ih)(void){

  //kbc_read_out_buf(&byte);

  uint8_t status_reg;

  for(int i=0; i<10;i++){

    if(util_sys_inb(STATUS_REG,&status_reg)!=0){ //checks if there is an error

      printf("Error reading status register in the mouse interruption\n");

      return;

    }

    if((status_reg & OUTPUT_BUF)!=0){

      if((status_reg & (STAT_REG_PAR|STAT_REG_TIMEOUT))!=0){ //checks if there is a parity or timeout error (mask -> 0xC0, bit 7 and 6 set), checks if output buffer is empty

      printf("Parity/Timeout error or output buffer is empty or data coming from the mouse\n");

      return;

      }

      if(util_sys_inb(OUTPUT_BUF,&byte)!=0){//checks if there is an error

      printf("Error reading output buffer in the mouse interruption\n");

      return;

      }

    }

    tickdelay(micros_to_ticks(DELAY_US));

  }

  return;

}

int (mouse_subscribe_int)(uint8_t *bit_no) {    //similar function to that of timer_subscribe_int

    *bit_no = BIT(mouse_id);

    if(sys_irqsetpolicy(12,(IRQ_REENABLE|IRQ_EXCLUSIVE),&mouse_id)==1){  //operation to subscribe int

        printf("Error subscribing int\n");

        return 1;

    }

  return 0;

}

int (mouse_unsubscribe_int)() {           //similar function to that of timer_unsubscribe_int

  if(sys_irqrmpolicy(&mouse_id)==1){

      printf("Error unsubscribing int\n");

      return 1;

  }

  return 0;

}

int parse_packet(struct packet *pp){

  if((pp->bytes[0]&0x80) == 0x80){

    pp->y_ov=true;

  }

  else{

    pp->y_ov=false;

  }

  if((pp->bytes[0]&0x40)==0x40){

    pp->x_ov=true;

  }

  else{

    pp->x_ov=false;

  }

  if((pp->bytes[0]&0x02)==0x02){

    pp->rb=true;

  }

  else{

    pp->rb=false;

  }

  if((pp->bytes[0]&0x04)==0x04){

    pp->mb=true;

  }

  else{

    pp->mb=false;

  }

  if((pp->bytes[0]&0x01)==0x01){

    pp->lb=true;

  }

  else{

    pp->lb=false;

  }

  if((pp->bytes[0] &0x10)==0x10){

    pp->delta_x = pp->bytes[1] -256;

  }

  else{

    pp->delta_x = pp->bytes[1];

  }

  if((pp->bytes[0]&0x20)==0x20){

    pp->delta_y = pp->bytes[2] -256;

  }

  else{

    pp->delta_y = pp->bytes[2];

  }

  return 0;

}

/*int kbc_write(int port, uint8_t cmd) {

        uint8_t status;

        int retry = 0;

        while (retry < 10) {

                if(util_sys_inb(STATUS_REG, &status)!=0){

      printf("Error in kbc_write");

      return 1;

    }

                //... Checking if IN_BUF is OK to write to

                if ((status & 0x02)!=0) {

                        //.... Writing the command

                        if (sys_outb(port, cmd)!=0) {

        printf("Error");

                                return 1;

                        }

                        return 0;

                }

                //tickdelay(micros_to_ticks(DELAY_US));        // IF NOT EMPTY wait for IN_BUF to be empty

                retry++;

        }

        return 1;

}

int read_out_buf(uint8_t *content) {

        uint8_t status;

        uint8_t content8; // 8-bit content

        int retry = 0;

        while (retry < 4) {

                util_sys_inb(STATUS_REG, &status);

                //... Checking if there is any error and if the byte came from AUX

                if (((status_reg & STAT_REG_OBF)==0) ||((status_reg&(STAT_REG_PAR|STAT_REG_TIMEOUT))!=0)||((status_reg&STAT_REG_AUX)==0)) { // Parity or Timeout error, invalid data

                        return 1;

                }

                //... Checking if OUT_BUF is FULL to read

                if (status & STAT_REG_OBF) {

                        //... Reading the Output Buffer

                        if (UTIL_sys_inb(OUTPUT_BUF, &content8)) {

                                return 1;

                        }

                        // The information in address content now contains content32 in 8-bit

                        *content = (uint8_t)content8;

                        return 0;

                }

                tickdelay(micros_to_ticks(DELAY_US));        // IF NOT EMPTY wait for IN_BUF to be empty

                retry++;

        }

        return 1;

}

int kbc_write_mouse_command(uint8_t cmd) {

        uint8_t response;

        if(kbc_write(KBC_CMD_REG, 0xD4)!=0){

    printf("Error");

    return 1;

  }

        if(kbc_write(INPUT_BUF, cmd)!=0){

    printf("Error");

    return 1;

  }

        tickdelay(micros_to_ticks(DELAY_US));

        if(kbc_read_out_buf(&response)!=0){

    printf("Error");

    return 1;

  }

        // Checking if invalid byte

        if (response != 0xFA) {

                // repeat process if invalid

                kbc_write(KBC_CTRL_REG, 0xD4);

                kbc_write(INPUT_BUF, cmd);

                tickdelay(micros_to_ticks(DELAY_US));

                kbc_read_out_buf(&response);

                // Checking if second consecutive invalid byte

                if (response == 0xFC){

                        return 1;

    }

        }

        return 0;

}*/

int write_cmd_mouse(uint8_t cmd)

{

  uint8_t status_reg, ack;

  do

  {

    if (util_sys_inb(STATUS_REG, &status_reg) != 0){

      return 1;

    }

    if ((status_reg & STAT_REG_IBF) == 0){

      if (sys_outb(KBC_CMD_REG, 0xD4) != 0){ //0xD4 -> code to write byte to mouse

        return 1;

      }

    }

    else

      continue;

    if (util_sys_inb(STATUS_REG, &status_reg) != 0){

      return 1;

    }

    if ((status_reg & STAT_REG_IBF) == 0){

      if (sys_outb(OUTPUT_BUF, cmd) != 0){

        return 1;

      }

    }

    else

      continue;

    tickdelay(micros_to_ticks(DELAY_US));

    if (util_sys_inb(INPUT_BUF, &ack) != 0){

      return 1;

    }

  } while (ack != 0xFA);            // 0xFA -> mask that checks if everything is ok

  return 0;

}