Port tx_disable-related code from Kasli

Signed-off-by: Egor Savkin <es@m-labs.hk>

src/runtime/src/comms.rs

@@ -32,6 +32,7 @@ use crate::moninj;
 use crate::mgmt;
 use crate::analyzer;
 use crate::rtio_mgt::{self, resolve_channel_name};
+use crate::io_expander;
 #[cfg(has_drtio)]
 use crate::pl;
 
@@ -380,7 +381,7 @@ async fn handle_connection(stream: &mut TcpStream, control: Rc<RefCell<kernel::C
     }
 }
 
-pub fn main(timer: GlobalTimer, cfg: Config) {
+pub fn main(timer: GlobalTimer, cfg: Config, mut io_expander0: io_expander::IoExpander, mut io_expander1: io_expander::IoExpander) {
     let net_addresses = net_settings::get_addresses(&cfg);
     info!("network addresses: {}", net_addresses);
 
@@ -494,6 +495,11 @@ pub fn main(timer: GlobalTimer, cfg: Config) {
                 let _ = stream.flush().await;
                 let _ = stream.abort().await;
             });
+            #[cfg(feature = "target_kasli_soc")]
+            {
+                io_expander0.service().expect("I2C I/O expander #0 service failed");
+                io_expander1.service().expect("I2C I/O expander #1 service failed");
+            }
         }
     });
 

src/runtime/src/io_expander.rs

@@ -0,0 +1,174 @@
+use crate::i2c;
+use log::info;
+
+// Only the bare minimum registers. Bits/IO connections equivalent between IC types.
+#[cfg(feature = "target_kasli_soc")]
+struct Registers {
+    // PCA9539 equivalent register names in comments
+    iodira: u8, // Configuration Port 0
+    iodirb: u8, // Configuration Port 1
+    gpioa: u8,  // Output Port 0
+    gpiob: u8,  // Output Port 1
+}
+
+#[cfg(feature = "target_kasli_soc")]
+pub struct IoExpander {
+    busno: i32,
+    port: u8,
+    address: i32,
+    virtual_led_mapping: &'static [(u8, u8, u8)],
+    iodir: [u8; 2],
+    out_current: [u8; 2],
+    out_target: [u8; 2],
+    registers: Registers,
+}
+
+#[cfg(not(feature = "target_kasli_soc"))]
+pub struct IoExpander;
+
+#[cfg(not(feature = "target_kasli_soc"))]
+impl IoExpander {
+    pub fn new(index: u8) -> Result<Self, &'static str> {
+        Ok(IoExpander {})
+    }
+}
+
+#[cfg(feature = "target_kasli_soc")]
+impl IoExpander {
+    pub fn new(index: u8) -> Result<Self, &'static str> {
+        const VIRTUAL_LED_MAPPING0: [(u8, u8, u8); 2] = [(0, 0, 6), (1, 1, 6)];
+        const VIRTUAL_LED_MAPPING1: [(u8, u8, u8); 2] = [(2, 0, 6), (3, 1, 6)];
+
+        // Both expanders on SHARED I2C bus
+        let mut io_expander = match index {
+            0 => IoExpander {
+                busno: 0,
+                port: 11,
+                address: 0x40,
+                virtual_led_mapping: &VIRTUAL_LED_MAPPING0,
+                iodir: [0xff; 2],
+                out_current: [0; 2],
+                out_target: [0; 2],
+                registers: Registers {
+                    iodira: 0x00,
+                    iodirb: 0x01,
+                    gpioa: 0x12,
+                    gpiob: 0x13,
+                },
+            },
+            1 => IoExpander {
+                busno: 0,
+                port: 11,
+                address: 0x42,
+                virtual_led_mapping: &VIRTUAL_LED_MAPPING1,
+                iodir: [0xff; 2],
+                out_current: [0; 2],
+                out_target: [0; 2],
+                registers: Registers {
+                    iodira: 0x00,
+                    iodirb: 0x01,
+                    gpioa: 0x12,
+                    gpiob: 0x13,
+                },
+            },
+            _ => return Err("incorrect I/O expander index"),
+        };
+        if !io_expander.check_ack()? {
+            info!(
+                "MCP23017 io expander {} not found. Checking for PCA9539.",
+                index
+            );
+            io_expander.address += 0xa8; // translate to PCA9539 addresses (see schematic)
+            io_expander.registers = Registers {
+                iodira: 0x06,
+                iodirb: 0x07,
+                gpioa: 0x02,
+                gpiob: 0x03,
+            };
+            if !io_expander.check_ack()? {
+                return Err("Neither MCP23017 nor PCA9539 io expander found.");
+            };
+        }
+        Ok(io_expander)
+    }
+
+    fn select(&self) -> Result<(), &'static str> {
+        let mask: u16 = 1 << self.port;
+        i2c::switch_select(self.busno, 0x70, mask as u8 as i32);
+        i2c::switch_select(self.busno, 0x71, (mask >> 8) as u8 as i32);
+        Ok(())
+    }
+
+    fn write(&self, addr: u8, value: u8) -> Result<(), &'static str> {
+        i2c::start(self.busno);
+        i2c::write(self.busno, self.address as i32);
+        i2c::write(self.busno, addr as i32);
+        i2c::write(self.busno, value as i32);
+        i2c::stop(self.busno);
+        Ok(())
+    }
+
+    fn check_ack(&self) -> Result<bool, &'static str> {
+        // Check for ack from io expander
+        self.select()?;
+        i2c::start(self.busno);
+        let ack = i2c::write(self.busno, self.address);
+        i2c::stop(self.busno);
+        Ok(ack)
+    }
+
+    fn update_iodir(&self) -> Result<(), &'static str> {
+        self.write(self.registers.iodira, self.iodir[0])?;
+        self.write(self.registers.iodirb, self.iodir[1])?;
+        Ok(())
+    }
+
+    pub fn init(&mut self) -> Result<(), &'static str> {
+        self.select()?;
+
+        for (_led, port, bit) in self.virtual_led_mapping.iter() {
+            self.iodir[*port as usize] &= !(1 << *bit);
+        }
+        self.update_iodir()?;
+
+        self.out_current[0] = 0x00;
+        self.write(self.registers.gpioa, 0x00)?;
+        self.out_current[1] = 0x00;
+        self.write(self.registers.gpiob, 0x00)?;
+        Ok(())
+    }
+
+    pub fn set_oe(&mut self, port: u8, outputs: u8) -> Result<(), &'static str> {
+        self.iodir[port as usize] &= !outputs;
+        self.update_iodir()?;
+        Ok(())
+    }
+
+    pub fn set(&mut self, port: u8, bit: u8, high: bool) {
+        if high {
+            self.out_target[port as usize] |= 1 << bit;
+        } else {
+            self.out_target[port as usize] &= !(1 << bit);
+        }
+    }
+
+    pub fn service(&mut self) -> Result<(), &'static str> {
+        for (_led, port, bit) in self.virtual_led_mapping.iter() {
+            self.set(*port, *bit, true);
+        }
+
+        if self.out_target != self.out_current {
+            self.select()?;
+            if self.out_target[0] != self.out_current[0] {
+                self.write(self.registers.gpioa, self.out_target[0])?;
+                self.out_current[0] = self.out_target[0];
+            }
+            if self.out_target[1] != self.out_current[1] {
+                self.write(self.registers.gpiob, self.out_target[1])?;
+                self.out_current[1] = self.out_target[1];
+            }
+        }
+
+        Ok(())
+    }
+}

src/runtime/src/main.rs

@@ -46,6 +46,7 @@ mod mgmt;
 mod analyzer;
 mod irq;
 mod i2c;
+mod io_expander;
 
 static mut SEEN_ASYNC_ERRORS: u8 = 0;
 
@@ -114,6 +115,25 @@ pub fn main_core0() {
 
     i2c::init();
 
+    let (mut io_expander0, mut io_expander1) = (io_expander::IoExpander::new(0).unwrap(), io_expander::IoExpander::new(1).unwrap());
+    #[cfg(feature = "target_kasli_soc")]
+    {
+        io_expander0.init().expect("I2C I/O expander #0 initialization failed");
+        io_expander1.init().expect("I2C I/O expander #1 initialization failed");
+
+        // Actively drive TX_DISABLE to false on SFP0..3
+        io_expander0.set_oe(0, 1 << 1).unwrap();
+        io_expander0.set_oe(1, 1 << 1).unwrap();
+        io_expander1.set_oe(0, 1 << 1).unwrap();
+        io_expander1.set_oe(1, 1 << 1).unwrap();
+        io_expander0.set(0, 1, false);
+        io_expander0.set(1, 1, false);
+        io_expander1.set(0, 1, false);
+        io_expander1.set(1, 1, false);
+        io_expander0.service().unwrap();
+        io_expander1.service().unwrap();
+    }
+
     let cfg = match Config::new() {
         Ok(cfg) => cfg,
         Err(err) => {
@@ -126,5 +146,5 @@ pub fn main_core0() {
 
     task::spawn(report_async_rtio_errors());
 
-    comms::main(timer, cfg);
+    comms::main(timer, cfg, io_expander0, io_expander1);
 }