385 lines
16 KiB
Diff
385 lines
16 KiB
Diff
# P2-ps2d-improvements.patch
|
|
#
|
|
# PS/2 controller improvements: flush/retry logic, mouse state machine fixes.
|
|
#
|
|
# Covers:
|
|
# - ps2d/controller.rs: flush stale bytes, self-test with retry, AUX port test
|
|
# - ps2d/mouse.rs: ACK/RESEND/BAT constant names, resend handling, state machine fixes
|
|
# - ps2d/state.rs: non-fatal init error handling
|
|
#
|
|
diff --git a/drivers/input/ps2d/src/controller.rs b/drivers/input/ps2d/src/controller.rs
|
|
index d7af4cba..638b7cc1 100644
|
|
--- a/drivers/input/ps2d/src/controller.rs
|
|
+++ b/drivers/input/ps2d/src/controller.rs
|
|
@@ -97,6 +97,14 @@ enum KeyboardCommandData {
|
|
const DEFAULT_TIMEOUT: u64 = 50_000;
|
|
// Reset timeout in microseconds
|
|
const RESET_TIMEOUT: u64 = 1_000_000;
|
|
+// Maximum bytes to drain during flush (Linux: I8042_BUFFER_SIZE)
|
|
+const FLUSH_LIMIT: usize = 4096;
|
|
+// Controller self-test pass value (Linux: I8042_RET_CTL_TEST)
|
|
+const SELFTEST_PASS: u8 = 0x55;
|
|
+// Controller self-test retries (Linux: 5 attempts)
|
|
+const SELFTEST_RETRIES: usize = 5;
|
|
+// AUX port test pass value (Linux returns 0x00 on success)
|
|
+const AUX_TEST_PASS: u8 = 0x00;
|
|
|
|
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
|
|
pub struct Ps2 {
|
|
@@ -271,6 +279,50 @@ impl Ps2 {
|
|
}
|
|
}
|
|
|
|
+ /// Drain all pending bytes from the controller output buffer.
|
|
+ /// Borrowed from Linux i8042_flush(): stale firmware/BIOS bytes can be
|
|
+ /// misinterpreted as device responses during initialization.
|
|
+ fn flush(&mut self) -> usize {
|
|
+ let mut count = 0;
|
|
+ while self.status().contains(StatusFlags::OUTPUT_FULL) {
|
|
+ if count >= FLUSH_LIMIT {
|
|
+ warn!("flush: exceeded limit, controller may be stuck");
|
|
+ break;
|
|
+ }
|
|
+ let data = self.data.read();
|
|
+ trace!("flush: discarded {:02X}", data);
|
|
+ count += 1;
|
|
+ }
|
|
+ if count > 0 {
|
|
+ debug!("flushed {} stale bytes from controller", count);
|
|
+ }
|
|
+ count
|
|
+ }
|
|
+
|
|
+ /// Test the AUX (mouse) port via controller command 0xA9.
|
|
+ /// Borrowed from Linux: verifies electrical connectivity before
|
|
+ /// attempting to talk to the mouse. Returns true if the port passed.
|
|
+ fn test_aux_port(&mut self) -> bool {
|
|
+ if let Err(err) = self.command(Command::TestSecond) {
|
|
+ warn!("aux port test command failed: {:?}", err);
|
|
+ return false;
|
|
+ }
|
|
+ match self.read() {
|
|
+ Ok(AUX_TEST_PASS) => {
|
|
+ debug!("aux port test passed");
|
|
+ true
|
|
+ }
|
|
+ Ok(val) => {
|
|
+ warn!("aux port test failed: {:02X}", val);
|
|
+ false
|
|
+ }
|
|
+ Err(err) => {
|
|
+ warn!("aux port test read timeout: {:?}", err);
|
|
+ false
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+
|
|
pub fn init_keyboard(&mut self) -> Result<(), Error> {
|
|
let mut b;
|
|
|
|
@@ -308,66 +360,125 @@ impl Ps2 {
|
|
}
|
|
|
|
pub fn init(&mut self) -> Result<(), Error> {
|
|
+ // Linux i8042_controller_check(): verify controller is present by
|
|
+ // flushing any stale data. A stuck output buffer means no controller.
|
|
+ self.flush();
|
|
+
|
|
+ // Bare-metal controllers may be slow after firmware handoff.
|
|
+ // Give the controller a moment to finish POST before sending commands.
|
|
+ std::thread::sleep(std::time::Duration::from_millis(50));
|
|
+
|
|
{
|
|
- // Disable devices
|
|
- self.command(Command::DisableFirst)?;
|
|
- self.command(Command::DisableSecond)?;
|
|
+ // Disable both ports first — use retry because the controller
|
|
+ // may still be settling or temporarily unresponsive.
|
|
+ // Failure here is non-fatal: we continue and attempt the rest
|
|
+ // of initialization. A truly absent controller will fail later
|
|
+ // at self-test or keyboard reset.
|
|
+ if let Err(err) = self.retry(
|
|
+ format_args!("disable first port"),
|
|
+ 3,
|
|
+ |x| x.command(Command::DisableFirst),
|
|
+ ) {
|
|
+ warn!("disable first port failed: {:?}", err);
|
|
+ }
|
|
+ if let Err(err) = self.retry(
|
|
+ format_args!("disable second port"),
|
|
+ 3,
|
|
+ |x| x.command(Command::DisableSecond),
|
|
+ ) {
|
|
+ warn!("disable second port failed: {:?}", err);
|
|
+ }
|
|
}
|
|
|
|
- // Disable clocks, disable interrupts, and disable translate
|
|
+ // Flush again after disabling — firmware may have queued more bytes
|
|
+ self.flush();
|
|
+
|
|
+ // Linux i8042_controller_init() step 1: write a known-safe config
|
|
+ // (interrupts off, both ports disabled) so stale config can't cause
|
|
+ // spurious interrupts during the rest of init.
|
|
{
|
|
- // Since the default config may have interrupts enabled, and the kernel may eat up
|
|
- // our data in that case, we will write a config without reading the current one
|
|
let config = ConfigFlags::POST_PASSED
|
|
| ConfigFlags::FIRST_DISABLED
|
|
| ConfigFlags::SECOND_DISABLED;
|
|
self.set_config(config)?;
|
|
}
|
|
|
|
- // The keyboard seems to still collect bytes even when we disable
|
|
- // the port, so we must disable the keyboard too
|
|
+ // Linux i8042_controller_selftest(): retry up to 5 times with delay.
|
|
+ // "On some really fragile systems this does not take the first time."
|
|
+ {
|
|
+ let mut passed = false;
|
|
+ for attempt in 0..SELFTEST_RETRIES {
|
|
+ if let Err(err) = self.command(Command::TestController) {
|
|
+ warn!("self-test command failed (attempt {}): {:?}", attempt + 1, err);
|
|
+ continue;
|
|
+ }
|
|
+ match self.read() {
|
|
+ Ok(SELFTEST_PASS) => {
|
|
+ passed = true;
|
|
+ break;
|
|
+ }
|
|
+ Ok(val) => {
|
|
+ warn!(
|
|
+ "self-test unexpected value {:02X} (attempt {}/{})",
|
|
+ val,
|
|
+ attempt + 1,
|
|
+ SELFTEST_RETRIES
|
|
+ );
|
|
+ }
|
|
+ Err(err) => {
|
|
+ warn!("self-test read timeout (attempt {}): {:?}", attempt + 1, err);
|
|
+ }
|
|
+ }
|
|
+ // Linux: msleep(50) between retries
|
|
+ std::thread::sleep(std::time::Duration::from_millis(50));
|
|
+ }
|
|
+ if !passed {
|
|
+ // Linux on x86: "giving up on controller selftest, continuing anyway"
|
|
+ warn!("controller self-test did not pass after {} attempts, continuing", SELFTEST_RETRIES);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ // Flush any bytes the self-test may have left behind
|
|
+ self.flush();
|
|
+
|
|
+ // Linux i8042_controller_init() step 2: set keyboard defaults
|
|
+ // (disable scanning so keyboard doesn't send scancodes during init)
|
|
self.retry(format_args!("keyboard defaults"), 4, |x| {
|
|
- // Set defaults and disable scanning
|
|
let b = x.keyboard_command(KeyboardCommand::SetDefaultsDisable)?;
|
|
if b != 0xFA {
|
|
error!("keyboard failed to set defaults: {:02X}", b);
|
|
return Err(Error::CommandRetry);
|
|
}
|
|
-
|
|
Ok(b)
|
|
})?;
|
|
|
|
- {
|
|
- // Perform the self test
|
|
- self.command(Command::TestController)?;
|
|
- let r = self.read()?;
|
|
- if r != 0x55 {
|
|
- warn!("self test unexpected value: {:02X}", r);
|
|
- }
|
|
- }
|
|
-
|
|
// Initialize keyboard
|
|
if let Err(err) = self.init_keyboard() {
|
|
error!("failed to initialize keyboard: {:?}", err);
|
|
return Err(err);
|
|
}
|
|
|
|
- // Enable second device
|
|
- let enable_mouse = match self.command(Command::EnableSecond) {
|
|
- Ok(()) => true,
|
|
- Err(err) => {
|
|
- error!("failed to initialize mouse: {:?}", err);
|
|
- false
|
|
+ // Linux: test AUX port (command 0xA9) before enabling.
|
|
+ // Skips mouse init entirely if the port is not electrically present.
|
|
+ let aux_ok = self.test_aux_port();
|
|
+
|
|
+ // Enable second device (mouse) only if AUX port tested OK
|
|
+ let enable_mouse = if aux_ok {
|
|
+ match self.command(Command::EnableSecond) {
|
|
+ Ok(()) => true,
|
|
+ Err(err) => {
|
|
+ warn!("failed to enable aux port after test passed: {:?}", err);
|
|
+ false
|
|
+ }
|
|
}
|
|
+ } else {
|
|
+ info!("skipping mouse init: aux port test did not pass");
|
|
+ false
|
|
};
|
|
|
|
{
|
|
- // Enable keyboard data reporting
|
|
- // Use inner function to prevent retries
|
|
- // Response is ignored since scanning is now on
|
|
if let Err(err) = self.keyboard_command_inner(KeyboardCommand::EnableReporting as u8) {
|
|
error!("failed to initialize keyboard reporting: {:?}", err);
|
|
- //TODO: fix by using interrupts?
|
|
}
|
|
}
|
|
|
|
diff --git a/drivers/input/ps2d/src/mouse.rs b/drivers/input/ps2d/src/mouse.rs
|
|
index 9e95ab88..8087c8c4 100644
|
|
--- a/drivers/input/ps2d/src/mouse.rs
|
|
+++ b/drivers/input/ps2d/src/mouse.rs
|
|
@@ -5,6 +5,11 @@ pub const RESET_RETRIES: usize = 10;
|
|
pub const RESET_TIMEOUT: Duration = Duration::from_millis(1000);
|
|
pub const COMMAND_TIMEOUT: Duration = Duration::from_millis(100);
|
|
|
|
+const CMD_ACK: u8 = 0xFA;
|
|
+const CMD_RESEND: u8 = 0xFE;
|
|
+const BAT_COMPLETE: u8 = 0xAA;
|
|
+const BAT_FAIL: u8 = 0xFC;
|
|
+
|
|
#[derive(Clone, Copy, Debug)]
|
|
#[repr(u8)]
|
|
#[allow(dead_code)]
|
|
@@ -58,9 +63,11 @@ impl MouseTx {
|
|
|
|
fn handle(&mut self, data: u8, ps2: &mut Ps2) -> Result<bool, ()> {
|
|
if self.write_i < self.write.len() {
|
|
- if data == 0xFA {
|
|
+ if data == CMD_ACK {
|
|
self.write_i += 1;
|
|
self.try_write(ps2)?;
|
|
+ } else if data == CMD_RESEND {
|
|
+ self.try_write(ps2)?;
|
|
} else {
|
|
log::error!("unknown mouse response {:02X}", data);
|
|
return Err(());
|
|
@@ -251,25 +258,43 @@ impl MouseState {
|
|
MouseResult::None
|
|
}
|
|
MouseState::Reset => {
|
|
- if data == 0xFA {
|
|
- log::debug!("mouse reset ok");
|
|
+ if data == CMD_ACK {
|
|
+ log::debug!("mouse reset ack");
|
|
MouseResult::Timeout(RESET_TIMEOUT)
|
|
- } else if data == 0xAA {
|
|
+ } else if data == BAT_COMPLETE {
|
|
log::debug!("BAT completed");
|
|
*self = MouseState::Bat;
|
|
MouseResult::Timeout(COMMAND_TIMEOUT)
|
|
+ } else if data == CMD_RESEND {
|
|
+ // Device asks us to resend the reset command (0xFF).
|
|
+ // Resend WITHOUT incrementing the retry counter — 0xFE is
|
|
+ // a normal protocol response, not a failure.
|
|
+ log::debug!("mouse requests resend during reset, resending 0xFF");
|
|
+ match ps2.mouse_command_async(MouseCommand::Reset as u8) {
|
|
+ Ok(()) => MouseResult::Timeout(RESET_TIMEOUT),
|
|
+ Err(err) => {
|
|
+ log::error!("failed to resend mouse reset: {:?}", err);
|
|
+ self.reset(ps2)
|
|
+ }
|
|
+ }
|
|
+ } else if data == BAT_FAIL {
|
|
+ log::warn!("mouse BAT failed (0xFC)");
|
|
+ self.reset(ps2)
|
|
} else {
|
|
log::warn!("unknown mouse response {:02X} after reset", data);
|
|
self.reset(ps2)
|
|
}
|
|
}
|
|
MouseState::Bat => {
|
|
- if data == MouseId::Base as u8 {
|
|
- // Enable intellimouse features
|
|
+ if data == CMD_RESEND {
|
|
+ // 0xFE after BAT is unusual — the device may be re-issuing
|
|
+ // BAT. Wait for the next byte (device ID or another BAT).
|
|
+ log::debug!("mouse resend (0xFE) during BAT, waiting");
|
|
+ MouseResult::Timeout(COMMAND_TIMEOUT)
|
|
+ } else if data == MouseId::Base as u8 {
|
|
log::debug!("BAT mouse id {:02X} (base)", data);
|
|
self.identify_touchpad(ps2)
|
|
} else if data == MouseId::Intellimouse1 as u8 {
|
|
- // Extra packet already enabled
|
|
log::debug!("BAT mouse id {:02X} (intellimouse)", data);
|
|
self.enable_reporting(data, ps2)
|
|
} else {
|
|
@@ -320,10 +345,17 @@ impl MouseState {
|
|
}
|
|
}
|
|
MouseState::DeviceId => {
|
|
- if data == 0xFA {
|
|
- // Command OK response
|
|
- //TODO: handle this separately?
|
|
+ if data == CMD_ACK {
|
|
MouseResult::Timeout(COMMAND_TIMEOUT)
|
|
+ } else if data == CMD_RESEND {
|
|
+ log::debug!("mouse resend during DeviceId, resending GetDeviceId");
|
|
+ match ps2.mouse_command_async(MouseCommand::GetDeviceId as u8) {
|
|
+ Ok(()) => MouseResult::Timeout(COMMAND_TIMEOUT),
|
|
+ Err(err) => {
|
|
+ log::error!("failed to resend GetDeviceId: {:?}", err);
|
|
+ self.reset(ps2)
|
|
+ }
|
|
+ }
|
|
} else if data == MouseId::Base as u8 || data == MouseId::Intellimouse1 as u8 {
|
|
log::debug!("mouse id {:02X}", data);
|
|
self.enable_reporting(data, ps2)
|
|
@@ -333,10 +365,28 @@ impl MouseState {
|
|
}
|
|
}
|
|
MouseState::EnableReporting { id } => {
|
|
- log::debug!("mouse id {:02X} enable reporting {:02X}", id, data);
|
|
- //TODO: handle response ok/error
|
|
- *self = MouseState::Streaming { id };
|
|
- MouseResult::None
|
|
+ if data == CMD_ACK {
|
|
+ log::debug!("mouse id {:02X} reporting enabled", id);
|
|
+ *self = MouseState::Streaming { id };
|
|
+ MouseResult::None
|
|
+ } else if data == CMD_RESEND {
|
|
+ log::debug!("mouse resend during EnableReporting, resending 0xF4");
|
|
+ match ps2.mouse_command_async(MouseCommand::EnableReporting as u8) {
|
|
+ Ok(()) => MouseResult::Timeout(COMMAND_TIMEOUT),
|
|
+ Err(err) => {
|
|
+ log::error!("failed to resend EnableReporting: {:?}", err);
|
|
+ *self = MouseState::Streaming { id };
|
|
+ MouseResult::None
|
|
+ }
|
|
+ }
|
|
+ } else {
|
|
+ log::warn!(
|
|
+ "unexpected mouse response {:02X} during enable reporting, streaming anyway",
|
|
+ data
|
|
+ );
|
|
+ *self = MouseState::Streaming { id };
|
|
+ MouseResult::None
|
|
+ }
|
|
}
|
|
MouseState::Streaming { id } => {
|
|
MouseResult::Packet(data, id == MouseId::Intellimouse1 as u8)
|
|
diff --git a/drivers/input/ps2d/src/state.rs b/drivers/input/ps2d/src/state.rs
|
|
index 9018dc6b..da304e05 100644
|
|
--- a/drivers/input/ps2d/src/state.rs
|
|
+++ b/drivers/input/ps2d/src/state.rs
|
|
@@ -61,9 +61,11 @@ impl Ps2d {
|
|
pub fn new(input: ProducerHandle, time_file: File) -> Self {
|
|
let mut ps2 = Ps2::new();
|
|
- ps2.init().expect("failed to initialize");
|
|
+ if let Err(err) = ps2.init() {
|
|
+ log::error!("ps2d: controller init failed: {:?}", err);
|
|
+ }
|
|
|
|
// FIXME add an option for orbital to disable this when an app captures the mouse.
|
|
let vmmouse_relative = false;
|
|
let vmmouse = vm::enable(vmmouse_relative);
|
|
|
|
// TODO: QEMU hack, maybe do this when Init timed out?
|