satellite:

* fixing repeaters that can't exist on zc706
* fixing various warnings
* fixed timer and i2c references

src/gateware/zc706.py

@@ -412,7 +412,6 @@ class Satellite(SoCCore):
 
         drtioaux_csr_group = []
         drtioaux_memory_group = []
-        drtiorep_csr_group = []
         self.drtio_cri = []
         for i in range(len(self.drtio_transceiver.channels)):
             coreaux_name = "drtioaux" + str(i)
@@ -429,15 +428,8 @@ class Satellite(SoCCore):
                     self.rtio_tsc, self.drtio_transceiver.channels[0], self.rx_synchronizer))
                 self.submodules.drtiosat = core
                 self.csr_devices.append("drtiosat")
-            # Repeaters
+            # Repeaters - there would be for i != 0 - however zc706 only has one SFP
-            else:
+            # and no other means to connect to 
-                corerep_name = "drtiorep" + str(i-1)
-                drtiorep_csr_group.append(corerep_name)
-                core = cdr(DRTIORepeater(
-                    self.rtio_tsc, self.drtio_transceiver.channels[i]))
-                setattr(self.submodules, corerep_name, core)
-                self.drtio_cri.append(core.cri)
-                self.csr_devices.append(corerep_name)
 
             coreaux = cdr(aux_controller.DRTIOAuxControllerAxi(core.link_layer))
             setattr(self.submodules, coreaux_name, coreaux)
@@ -446,10 +438,9 @@ class Satellite(SoCCore):
             memory_address = self.mem_map["drtioaux"] + 0x800*i
             self.register_mem(memory_name, memory_address, 0x800, coreaux.bus)
         self.rustc_cfg["has_drtio"] = None
-        self.rustc_cfg["has_drtio_routing"] = None
+        # it does not have drtio routing support!
         self.add_csr_group("drtioaux", drtioaux_csr_group)
         self.add_memory_group("drtioaux_mem", drtioaux_memory_group)
-        self.add_csr_group("drtiorep", drtiorep_csr_group)
 
         self.rustc_cfg["RTIO_FREQUENCY"] = str(self.drtio_transceiver.rtio_clk_freq/1e6)
 

src/satman/main.rs

@@ -82,7 +82,7 @@ macro_rules! forward {
 
 fn process_aux_packet(_repeaters: &mut [repeater::Repeater],
         _routing_table: &mut drtio_routing::RoutingTable, _rank: &mut u8,
-        packet: drtioaux::Packet, timer: GlobalTimer, i2c: I2c) -> Result<(), drtioaux::Error> {
+        packet: drtioaux::Packet, timer: &mut GlobalTimer, i2c: &mut I2c) -> Result<(), drtioaux::Error> {
     // In the code below, *_chan_sel_write takes an u8 if there are fewer than 256 channels,
     // and u16 otherwise; hence the `as _` conversion.
     match packet {
@@ -204,7 +204,7 @@ fn process_aux_packet(_repeaters: &mut [repeater::Repeater],
             drtioaux::send(0, &drtioaux::Packet::RoutingAck)
         }
 
-        drtioaux::Packet::MonitorRequest { destination: _destination, channel, probe } => {
+        drtioaux::Packet::MonitorRequest { destination: _destination, channel: _channel, probe: _probe } => {
             forward!(_routing_table, _destination, *_rank, _repeaters, &packet, timer);
             let value;
             #[cfg(has_rtio_moninj)]
@@ -221,7 +221,8 @@ fn process_aux_packet(_repeaters: &mut [repeater::Repeater],
             let reply = drtioaux::Packet::MonitorReply { value: value as u32 };
             drtioaux::send(0, &reply)
         },
-        drtioaux::Packet::InjectionRequest { destination: _destination, channel, overrd, value } => {
+        drtioaux::Packet::InjectionRequest { destination: _destination, channel: _channel, 
+                                             overrd: _overrd, value: _value } => {
             forward!(_routing_table, _destination, *_rank, _repeaters, &packet, timer);
             #[cfg(has_rtio_moninj)]
             unsafe {
@@ -231,7 +232,8 @@ fn process_aux_packet(_repeaters: &mut [repeater::Repeater],
             }
             Ok(())
         },
-        drtioaux::Packet::InjectionStatusRequest { destination: _destination, channel, overrd } => {
+        drtioaux::Packet::InjectionStatusRequest { destination: _destination, 
+                                                   channel: _channel, overrd: _overrd } => {
             forward!(_routing_table, _destination, *_rank, _repeaters, &packet, timer);
             let value;
             #[cfg(has_rtio_moninj)]
@@ -247,22 +249,22 @@ fn process_aux_packet(_repeaters: &mut [repeater::Repeater],
             drtioaux::send(0, &drtioaux::Packet::InjectionStatusReply { value: value })
         },
 
-        drtioaux::Packet::I2cStartRequest { destination: _destination, busno } => {
+        drtioaux::Packet::I2cStartRequest { destination: _destination, busno: _busno } => {
             forward!(_routing_table, _destination, *_rank, _repeaters, &packet, timer);
             let succeeded = i2c.start().is_ok();
             drtioaux::send(0, &drtioaux::Packet::I2cBasicReply { succeeded: succeeded })
         }
-        drtioaux::Packet::I2cRestartRequest { destination: _destination, busno } => {
+        drtioaux::Packet::I2cRestartRequest { destination: _destination, busno: _busno } => {
             forward!(_routing_table, _destination, *_rank, _repeaters, &packet, timer);
             let succeeded = i2c.restart().is_ok();
             drtioaux::send(0, &drtioaux::Packet::I2cBasicReply { succeeded: succeeded })
         }
-        drtioaux::Packet::I2cStopRequest { destination: _destination, busno } => {
+        drtioaux::Packet::I2cStopRequest { destination: _destination, busno: _busno } => {
             forward!(_routing_table, _destination, *_rank, _repeaters, &packet, timer);
             let succeeded = i2c.stop().is_ok();
             drtioaux::send(0, &drtioaux::Packet::I2cBasicReply { succeeded: succeeded })
         }
-        drtioaux::Packet::I2cWriteRequest { destination: _destination, busno, data } => {
+        drtioaux::Packet::I2cWriteRequest { destination: _destination, busno: _busno, data } => {
             forward!(_routing_table, _destination, *_rank, _repeaters, &packet, timer);
             match i2c.write(data) {
                 Ok(ack) => drtioaux::send(0,
@@ -271,7 +273,7 @@ fn process_aux_packet(_repeaters: &mut [repeater::Repeater],
                     &drtioaux::Packet::I2cWriteReply { succeeded: false, ack: false })
             }
         }
-        drtioaux::Packet::I2cReadRequest { destination: _destination, busno, ack } => {
+        drtioaux::Packet::I2cReadRequest { destination: _destination, busno: _busno, ack } => {
             forward!(_routing_table, _destination, *_rank, _repeaters, &packet, timer);
             match i2c.read(ack) {
                 Ok(data) => drtioaux::send(0,
@@ -281,21 +283,22 @@ fn process_aux_packet(_repeaters: &mut [repeater::Repeater],
             }
         }
 
-        drtioaux::Packet::SpiSetConfigRequest { destination: _destination, busno, flags, length, div, cs } => {
+        drtioaux::Packet::SpiSetConfigRequest { destination: _destination, busno: _busno, 
+                                                flags: _flags, length: _length, div: _div, cs: _cs } => {
             forward!(_routing_table, _destination, *_rank, _repeaters, &packet, timer);
             // todo: reimplement when SPI is available
             //let succeeded = spi::set_config(busno, flags, length, div, cs).is_ok();
             drtioaux::send(0,
                 &drtioaux::Packet::SpiBasicReply { succeeded: false})
         },
-        drtioaux::Packet::SpiWriteRequest { destination: _destination, busno, data } => {
+        drtioaux::Packet::SpiWriteRequest { destination: _destination, busno: _busno, data: _data } => {
             forward!(_routing_table, _destination, *_rank, _repeaters, &packet, timer);
             // todo: reimplement when SPI is available
             //let succeeded = spi::write(busno, data).is_ok();
             drtioaux::send(0,
                 &drtioaux::Packet::SpiBasicReply { succeeded: false })
         }
-        drtioaux::Packet::SpiReadRequest { destination: _destination, busno } => {
+        drtioaux::Packet::SpiReadRequest { destination: _destination, busno: _busno } => {
             forward!(_routing_table, _destination, *_rank, _repeaters, &packet, timer);
             // todo: reimplement when SPI is available
             // match spi::read(busno) {
@@ -325,7 +328,7 @@ fn process_aux_packet(_repeaters: &mut [repeater::Repeater],
 
 fn process_aux_packets(repeaters: &mut [repeater::Repeater],
         routing_table: &mut drtio_routing::RoutingTable, rank: &mut u8, 
-        timer: GlobalTimer, i2c: I2c) {
+        timer: &mut GlobalTimer, i2c: &mut I2c) {
     let result =
         drtioaux::recv(0).and_then(|packet| {
             if let Some(packet) = packet {
@@ -392,9 +395,9 @@ fn init_rtio_crg(timer: GlobalTimer) {
 }
 
 #[cfg(not(has_rtio_crg))]
-fn init_rtio_crg(timer: GlobalTimer) { }
+fn init_rtio_crg(_timer: GlobalTimer) { }
 
-fn hardware_tick(ts: &mut u64, timer: GlobalTimer) {
+fn hardware_tick(ts: &mut u64, timer: &mut GlobalTimer) {
     let now = timer.get_time();
     let mut ts_ms = Milliseconds(*ts);
     if now > ts_ms {
@@ -484,14 +487,9 @@ pub extern fn main_core0() -> i32 {
         while !drtiosat_link_rx_up() {
             drtiosat_process_errors();
             for mut rep in repeaters.iter_mut() {
-                rep.service(&routing_table, rank, timer);
+                rep.service(&routing_table, rank, &mut timer);
             }
-            #[cfg(all(soc_platform = "kasli", hw_rev = "v2.0"))]
+            hardware_tick(&mut hardware_tick_ts, &mut timer);
-            {
-                io_expander0.service().expect("I2C I/O expander #0 service failed");
-                io_expander1.service().expect("I2C I/O expander #1 service failed");
-            }
-            hardware_tick(&mut hardware_tick_ts, timer);
         }
 
         info!("uplink is up, switching to recovered clock");
@@ -507,20 +505,15 @@ pub extern fn main_core0() -> i32 {
 
         while drtiosat_link_rx_up() {
             drtiosat_process_errors();
-            process_aux_packets(&mut repeaters, &mut routing_table, &mut rank, timer, i2c);
+            process_aux_packets(&mut repeaters, &mut routing_table, &mut rank, &mut timer, &mut i2c);
             for mut rep in repeaters.iter_mut() {
-                rep.service(&routing_table, rank, timer);
+                rep.service(&routing_table, rank, &mut timer);
             }
-            #[cfg(all(soc_platform = "kasli", hw_rev = "v2.0"))]
+            hardware_tick(&mut hardware_tick_ts, &mut timer);
-            {
-                io_expander0.service().expect("I2C I/O expander #0 service failed");
-                io_expander1.service().expect("I2C I/O expander #1 service failed");
-            }
-            hardware_tick(&mut hardware_tick_ts, timer);
             if drtiosat_tsc_loaded() {
                 info!("TSC loaded from uplink");
                 for rep in repeaters.iter() {
-                    if let Err(e) = rep.sync_tsc(timer) {
+                    if let Err(e) = rep.sync_tsc(&mut timer) {
                         error!("failed to sync TSC ({:?})", e);
                     }
                 }
@@ -584,7 +577,7 @@ pub fn main_core1() {
 }
 
 #[no_mangle]
-pub extern fn exception(vect: u32, _regs: *const u32, pc: u32, ea: u32) {
+pub extern fn exception(_vect: u32, _regs: *const u32, pc: u32, ea: u32) {
 
     fn hexdump(addr: u32) {
         let addr = (addr - addr % 4) as *const u32;

src/satman/repeater.rs

@@ -1,10 +1,11 @@
 use libboard_artiq::{drtioaux, drtio_routing};
+use libboard_zynq::timer::GlobalTimer;
+
 #[cfg(has_drtio_routing)]
 use libboard_artiq::{pl::csr};
 #[cfg(has_drtio_routing)]
 use libboard_zynq::time::Milliseconds;
-use libboard_zynq::timer::GlobalTimer;
+#[cfg(has_drtio_routing)]
-
 use embedded_hal::prelude::_embedded_hal_blocking_delay_DelayUs;
 
 #[cfg(has_drtio_routing)]
@@ -54,7 +55,7 @@ impl Repeater {
     }
 
     pub fn service(&mut self, routing_table: &drtio_routing::RoutingTable, rank: u8,
-        timer: GlobalTimer) {
+        timer: &mut GlobalTimer) {
         self.process_local_errors();
 
         match self.state {
@@ -168,7 +169,7 @@ impl Repeater {
         }
     }
 
-    fn recv_aux_timeout(&self, timeout: u32, timer: GlobalTimer) -> Result<drtioaux::Packet, drtioaux::Error> {
+    fn recv_aux_timeout(&self, timeout: u32, timer: &mut GlobalTimer) -> Result<drtioaux::Packet, drtioaux::Error> {
         let max_time = timer.get_time() + Milliseconds(timeout.into());
         loop {
             if !rep_link_rx_up(self.repno) {
@@ -185,7 +186,7 @@ impl Repeater {
         }
     }
 
-    pub fn aux_forward(&self, request: &drtioaux::Packet, timer: GlobalTimer) -> Result<(), drtioaux::Error> {
+    pub fn aux_forward(&self, request: &drtioaux::Packet, timer: &mut GlobalTimer) -> Result<(), drtioaux::Error> {
         if self.state != RepeaterState::Up {
             return Err(drtioaux::Error::LinkDown);
         }
@@ -195,7 +196,7 @@ impl Repeater {
         Ok(())
     }
 
-    pub fn sync_tsc(&self, timer: GlobalTimer) -> Result<(), drtioaux::Error> {
+    pub fn sync_tsc(&self, timer: &mut GlobalTimer) -> Result<(), drtioaux::Error> {
         if self.state != RepeaterState::Up {
             return Ok(());
         }
@@ -216,7 +217,7 @@ impl Repeater {
         }
     }
 
-    pub fn set_path(&self, destination: u8, hops: &[u8; drtio_routing::MAX_HOPS], timer: GlobalTimer) -> Result<(), drtioaux::Error> {
+    pub fn set_path(&self, destination: u8, hops: &[u8; drtio_routing::MAX_HOPS], timer: &mut GlobalTimer) -> Result<(), drtioaux::Error> {
         if self.state != RepeaterState::Up {
             return Ok(());
         }
@@ -232,14 +233,14 @@ impl Repeater {
         Ok(())
     }
 
-    pub fn load_routing_table(&self, routing_table: &drtio_routing::RoutingTable, timer: GlobalTimer) -> Result<(), drtioaux::Error> {
+    pub fn load_routing_table(&self, routing_table: &drtio_routing::RoutingTable, timer: &mut GlobalTimer) -> Result<(), drtioaux::Error> {
         for i in 0..drtio_routing::DEST_COUNT {
             self.set_path(i as u8, &routing_table.0[i], timer)?;
         }
         Ok(())
     }
 
-    pub fn set_rank(&self, rank: u8, timer: GlobalTimer) -> Result<(), drtioaux::Error> {
+    pub fn set_rank(&self, rank: u8, timer: &mut GlobalTimer) -> Result<(), drtioaux::Error> {
         if self.state != RepeaterState::Up {
             return Ok(());
         }
@@ -253,7 +254,7 @@ impl Repeater {
         Ok(())
     }
 
-    pub fn rtio_reset(&self, timer: GlobalTimer) -> Result<(), drtioaux::Error> {
+    pub fn rtio_reset(&self, timer: &mut GlobalTimer) -> Result<(), drtioaux::Error> {
         let repno = self.repno as usize;
         unsafe { (csr::DRTIOREP[repno].reset_write)(1); }
         timer.delay_us(100);
@@ -281,9 +282,9 @@ pub struct Repeater {
 impl Repeater {
     pub fn new(_repno: u8) -> Repeater { Repeater::default() }
 
-    pub fn service(&self, _routing_table: &drtio_routing::RoutingTable, _rank: u8, timer: GlobalTimer) { }
+    pub fn service(&self, _routing_table: &drtio_routing::RoutingTable, _rank: u8, _timer: &mut GlobalTimer) { }
 
-    pub fn sync_tsc(&self) -> Result<(), drtioaux::Error<!>> { Ok(()) }
+    pub fn sync_tsc(&self, _timer: &mut GlobalTimer) -> Result<(), drtioaux::Error> { Ok(()) }
 
-    pub fn rtio_reset(&self, timer: GlobalTimer) -> Result<(), drtioaux::Error<!>> { Ok(()) }
+    pub fn rtio_reset(&self, _timer: &mut GlobalTimer) -> Result<(), drtioaux::Error> { Ok(()) }
 }