OSDev.org

Code: Select all

extern "x86-interrupt" fn mouse_interrupt_handler(_stack_frame: &mut InterruptStackFrame) {
    let mut port = PortReadOnly::new(0x60);
    let packet: u8 = unsafe { port.read() };
    println!("{:08b}", packet);

    unsafe {
        PICS.lock()
            .notify_end_of_interrupt(InterruptIndex::Mouse.into());
    }
}

extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: &mut InterruptStackFrame) {
    use pc_keyboard::{layouts, DecodedKey, HandleControl, Keyboard, ScancodeSet1};
    use x86_64::instructions::port::PortReadOnly;

    static KEYBOARD: Lazy<Spinlock<Keyboard<layouts::Us104Key, ScancodeSet1>>> = Lazy::new(|| {
        Spinlock::new(Keyboard::new(
            layouts::Us104Key,
            ScancodeSet1,
            HandleControl::Ignore,
        ))
    });

    let mut keyboard = KEYBOARD.lock();
    let mut port = PortReadOnly::new(0x60);

    let scancode: u8 = unsafe { port.read() };
    if let Ok(Some(key_event)) = keyboard.add_byte(scancode) {
        if let Some(key) = keyboard.process_keyevent(key_event) {
            match key {
                DecodedKey::Unicode(character) => print!("{}", character),
                DecodedKey::RawKey(key) => print!("{:?}", key),
            }
        }
    }

    unsafe {
        PICS.lock()
            .notify_end_of_interrupt(InterruptIndex::Keyboard.into());
    }
}

Code: Select all

  switch (cur_index) {
    case 0:
      if (byte & 0x08) {
        save_byte = byte;
        // extract buttons and save them
      } else
         cur_index = -1;  // we think we should be at index 0, but bit 3 isn't set, 
                          // so start the process over, ignoring all bytes until bit 3 is set.
      break;
    case 1:
      if ((save_byte & 0x40) == 0) {  //  overflow ?
        //extract the x coord
        // here is an easy way to do this using the 'sign bit'
        if (save_byte & 0x10) // is signed
           x = (int) (((unsigned int) -1 & ~0xFF) | byte);  // the (unsigned int) cast is probably redundant
        else  // is unsigned
           x = (int) (unsigned int) byte;
      }
      break;
    case 2:
      // do the same thing as above, except with 'y'
      //  and y's overflow and sign bit
      break;
    case 3:
      // even though a standard PS2 mouse may not have a forth byte, 
      //  go ahead and have code for it here because the code below
      //  will make sure to never get here if we don't have four bytes
      // 
      //  However, if we do have four bytes, the code is already here:
      //   extract z coord here
      //   if id byte == 3 use whole byte as signed integer
      //   if id byte == 4 use only the lower 4 bits
      break;
   }
   cur_index++;
   if (cur_index >= packet_size) {
     // send the current packet to our main mouse handler
     // reset the packet for the next time
     cur_index = 0;
   }

   // eoi
}

Code: Select all

extern "x86-interrupt" fn mouse_interrupt_handler(_stack_frame: &mut InterruptStackFrame) {
    let mut port = PortReadOnly::new(0x60);
    let packet = unsafe { port.read() };
    MOUSE.lock().process_packets(packet);

    unsafe {
        PICS.lock()
            .notify_end_of_interrupt(InterruptIndex::Mouse.into());
    }
}

pub fn process_packets(&mut self, packet: u8) {
    match self.current_packet {
        0 => {
            let flags = MouseFlags::from_bits_truncate(packet);
            if !flags.contains(MouseFlags::ALWAYS_ONE) {
                return;
            }
            self.data_packet = flags;
        }
        1 => self.process_x_movement(packet),
        2 => self.process_y_movement(packet),
        _ => unreachable!(),
    }

    self.current_packet = (self.current_packet + 1) % 3;
}

fn process_x_movement(&mut self, packet: u8) {
    if !self.data_packet.contains(MouseFlags::X_OVERFLOW) {
        self.x = if self.data_packet.contains(MouseFlags::X_SIGN) {
            self.sign_extend(packet)
        } else {
            packet as i16
        };
    }
}

fn process_y_movement(&mut self, packet: u8) {
    if !self.data_packet.contains(MouseFlags::Y_OVERFLOW) {
        self.y = if self.data_packet.contains(MouseFlags::Y_SIGN) {
            self.sign_extend(packet)
        } else {
            packet as i16
        };
    }
}

fn sign_extend(&self, packet: u8) -> i16 {
    ((packet as u16) | 0xFF00) as i16
}

Code: Select all

        1 => self.process_x_movement(packet),
        2 => self.process_y_movement(packet),
        _ => unreachable!(),