bare_zynq.json

@@ -1,8 +0,0 @@
-{
-    "target": "kasli_soc",
-    "variant": "bare_zynq",
-    "hw_rev": "v1.1",
-    "drtio_role": "standalone",
-    "core_addr": "192.168.1.200",
-    "peripherals": []
-}

bare_zynq_master.json

@@ -1,8 +0,0 @@
-{
-    "target": "kasli_soc",
-    "variant": "bare_zynq_master",
-    "hw_rev": "v1.1",
-    "drtio_role": "master",
-    "core_addr": "192.168.1.200",
-    "peripherals": []
-}

bare_zynq_sat1.json

@@ -1,7 +0,0 @@
-{
-    "target": "kasli_soc",
-    "variant": "bare_zynq_sat1",
-    "hw_rev": "v1.1",
-    "drtio_role": "satellite",
-    "peripherals": []
-}

bare_zynq_sat2.json

@@ -1,7 +0,0 @@
-{
-    "target": "kasli_soc",
-    "variant": "bare_zynq_sat2",
-    "hw_rev": "v1.1",
-    "drtio_role": "satellite",
-    "peripherals": []
-}

flake.lock

@@ -11,16 +11,17 @@
         "src-pythonparser": "src-pythonparser"
       },
       "locked": {
-        "dirtyRev": "378d962edb37a7c2a94e963251822246be009b0e-dirty",
+        "lastModified": 1720514025,
-        "dirtyShortRev": "378d962ed-dirty",
+        "narHash": "sha256-eU9Lux5olHTxRCwSiApKSPEdNhrlZ2OJ9ZqSofqp9Uk=",
-        "lastModified": 1721962540,
+        "ref": "refs/heads/master",
-        "narHash": "sha256-BJG4l1V7kJXBWgBkfYKq8xW8rCfc7fnjCSp5xMiGvsU=",
+        "rev": "7a50afd9a96be8e6510d5c952808f39f0b74202a",
+        "revCount": 8887,
         "type": "git",
-        "url": "file:///home/occheung/artiq"
+        "url": "https://github.com/m-labs/artiq.git"
       },
       "original": {
         "type": "git",
-        "url": "file:///home/occheung/artiq"
+        "url": "https://github.com/m-labs/artiq.git"
       }
     },
     "artiq-comtools": {
@@ -238,11 +239,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1720537402,
+        "lastModified": 1717654016,
-        "narHash": "sha256-ybvaQ48SVBqYVqgYmGUdefGZkni7PJ90qYQPHnFOwDs=",
+        "narHash": "sha256-y/c0EZNDNlxb/yLy/D23X9PLoiQ8I9mXAA0zsVOy2t8=",
         "ref": "refs/heads/master",
-        "rev": "b2b3e5c933cbc4b7cb14adde480d7561a3ae71ee",
+        "rev": "0efbbe39fe643c03f15e29c208bff3247a987766",
-        "revCount": 648,
+        "revCount": 647,
         "type": "git",
         "url": "https://git.m-labs.hk/m-labs/zynq-rs"
       },

flake.nix

@@ -1,8 +1,7 @@
 {
   description = "ARTIQ port to the Zynq-7000 platform";
 
-  # inputs.artiq.url = git+https://github.com/m-labs/artiq.git;
+  inputs.artiq.url = git+https://github.com/m-labs/artiq.git;
-  inputs.artiq.url = git+file:///home/occheung/artiq;
   inputs.mozilla-overlay = { url = github:mozilla/nixpkgs-mozilla; flake = false; };
   inputs.zynq-rs.url = git+https://git.m-labs.hk/m-labs/zynq-rs;
   inputs.zynq-rs.inputs.nixpkgs.follows = "artiq/nixpkgs";
@@ -19,11 +18,11 @@
 
     fastnumbers = pkgs.python3Packages.buildPythonPackage rec {
       pname = "fastnumbers";
-      version = "5.1.0";
+      version = "2.2.1";
 
       src = pkgs.python3Packages.fetchPypi {
         inherit pname version;
-        sha256 = "sha256-4JLTP4uVwxcaL7NOV57+DFSwKQ3X+W/6onYkN2AdkKc=";
+        sha256 = "0j15i54p7nri6hkzn1wal9pxri4pgql01wgjccig6ar0v5jjbvsy";
       };
     };
 
@@ -110,7 +109,7 @@
     fsblTargets = ["zc702" "zc706" "zed"];
     sat_variants = [
       # kasli-soc satellite variants
-      "satellite" "bare_zynq_sat1" "bare_zynq_sat2"
+      "satellite"
       # zc706 satellite variants
       "nist_clock_satellite" "nist_qc2_satellite" "acpki_nist_clock_satellite" "acpki_nist_qc2_satellite" 
       "nist_clock_satellite_100mhz" "nist_qc2_satellite_100mhz" "acpki_nist_clock_satellite_100mhz" "acpki_nist_qc2_satellite_100mhz"
@@ -127,7 +126,6 @@
           lockFile = src/Cargo.lock;
           outputHashes = {
               "tar-no-std-0.1.8" = "sha256-xm17108v4smXOqxdLvHl9CxTCJslmeogjm4Y87IXFuM=";
-              "nalgebra-0.32.6" = "sha256-L/YudkVOtfGYoNQKBD7LMk/sMYgRDzPDdpGL5rO7G2I=";
             };
         };
 
@@ -365,10 +363,6 @@
       (board-package-set { target = "zc706"; variant = "acpki_nist_qc2_satellite_100mhz"; }) //
       (board-package-set { target = "kasli_soc"; variant = "demo"; json = ./demo.json; }) //
       (board-package-set { target = "kasli_soc"; variant = "master"; json = ./kasli-soc-master.json; }) //
-      (board-package-set { target = "kasli_soc"; variant = "bare_zynq"; json = ./bare_zynq.json; }) //
-      (board-package-set { target = "kasli_soc"; variant = "bare_zynq_master"; json = ./bare_zynq_master.json; }) //
-      (board-package-set { target = "kasli_soc"; variant = "bare_zynq_sat1"; json = ./bare_zynq_sat1.json; }) //
-      (board-package-set { target = "kasli_soc"; variant = "bare_zynq_sat2"; json = ./bare_zynq_sat2.json; }) //
       (board-package-set { target = "kasli_soc"; variant = "satellite"; json = ./kasli-soc-satellite.json; });
 
     hydraJobs = packages.x86_64-linux // { inherit zc706-hitl-tests; inherit gateware-sim; inherit fmt-check; };

src/Cargo.lock

@@ -2,15 +2,6 @@
 # It is not intended for manual editing.
 version = 3
 
-[[package]]
-name = "approx"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6"
-dependencies = [
- "num-traits",
-]
-
 [[package]]
 name = "arrayvec"
 version = "0.7.4"
@@ -255,7 +246,6 @@ dependencies = [
  "libsupport_zynq",
  "log",
  "log_buffer",
- "nalgebra",
  "nb 0.1.3",
  "unwind",
  "vcell",
@@ -392,19 +382,6 @@ version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c75de51135344a4f8ed3cfe2720dc27736f7711989703a0b43aadf3753c55577"
 
-[[package]]
-name = "nalgebra"
-version = "0.32.6"
-source = "git+https://git.m-labs.hk/M-labs/nalgebra?rev=dd00f9b#dd00f9b46046e0b931d1b470166db02fd29591be"
-dependencies = [
- "approx",
- "num-complex",
- "num-rational",
- "num-traits",
- "simba",
- "typenum",
-]
-
 [[package]]
 name = "nb"
 version = "0.1.3"
@@ -420,15 +397,6 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "546c37ac5d9e56f55e73b677106873d9d9f5190605e41a856503623648488cae"
 
-[[package]]
-name = "num-complex"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26873667bbbb7c5182d4a37c1add32cdf09f841af72da53318fdb81543c15085"
-dependencies = [
- "num-traits",
-]
-
 [[package]]
 name = "num-derive"
 version = "0.3.3"
@@ -440,26 +408,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "num-integer"
-version = "0.1.46"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
-dependencies = [
- "num-traits",
-]
-
-[[package]]
-name = "num-rational"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d41702bd167c2df5520b384281bc111a4b5efcf7fbc4c9c222c815b07e0a6a6a"
-dependencies = [
- "autocfg",
- "num-integer",
- "num-traits",
-]
-
 [[package]]
 name = "num-traits"
 version = "0.2.15"
@@ -467,15 +415,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
 dependencies = [
  "autocfg",
- "libm",
 ]
 
-[[package]]
-name = "paste"
-version = "1.0.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
-
 [[package]]
 name = "pin-project-lite"
 version = "0.2.9"
@@ -559,7 +500,6 @@ name = "satman"
 version = "0.0.0"
 dependencies = [
  "build_zynq",
- "byteorder",
  "core_io",
  "cslice",
  "embedded-hal",
@@ -574,8 +514,6 @@ dependencies = [
  "libregister",
  "libsupport_zynq",
  "log",
- "num-derive",
- "num-traits",
  "unwind",
 ]
 
@@ -585,18 +523,6 @@ version = "0.1.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d4f410fedcf71af0345d7607d246e7ad15faaadd49d240ee3b24e5dc21a820ac"
 
-[[package]]
-name = "simba"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50582927ed6f77e4ac020c057f37a268fc6aebc29225050365aacbb9deeeddc4"
-dependencies = [
- "approx",
- "num-complex",
- "num-traits",
- "paste",
-]
-
 [[package]]
 name = "smoltcp"
 version = "0.7.5"
@@ -629,12 +555,6 @@ dependencies = [
  "log",
 ]
 
-[[package]]
-name = "typenum"
-version = "1.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
-
 [[package]]
 name = "unicode-ident"
 version = "1.0.5"

src/gateware/kasli_soc.py

@@ -560,10 +560,7 @@ class GenericSatellite(SoCCore):
         self.submodules.local_io = SyncRTIO(
             self.rtio_tsc, self.rtio_channels, lane_count=description["sed_lanes"]
         )
-        self.comb += [
+        self.comb += self.drtiosat.async_errors.eq(self.local_io.async_errors)
-            self.drtiosat.async_errors.eq(self.local_io.async_errors),
-            self.local_io.sed_spread_enable.eq(self.drtiosat.sed_spread_enable.storage)
-        ]
 
         self.submodules.cri_con = rtio.CRIInterconnectShared(
             [self.drtiosat.cri, self.rtio_dma.cri, self.rtio.cri],

src/gateware/zc706.py

@@ -487,10 +487,6 @@ class _SatelliteBase(SoCCore):
         self.csr_devices.append("rtio_dma")
 
         self.submodules.local_io = SyncRTIO(self.rtio_tsc, rtio_channels)
-        self.comb += [
-            self.drtiosat.async_errors.eq(self.local_io.async_errors),
-            self.local_io.sed_spread_enable.eq(self.drtiosat.sed_spread_enable.storage)
-        ]
         self.submodules.cri_con = rtio.CRIInterconnectShared(
             [self.drtiosat.cri, self.rtio_dma.cri, self.rtio.cri],
             [self.local_io.cri] + self.drtio_cri,

src/libboard_artiq/src/drtioaux_proto.rs

@@ -8,11 +8,6 @@ const MAX_PACKET: usize = 1024;
 pub const SAT_PAYLOAD_MAX_SIZE: usize  = /*max size*/MAX_PACKET - /*CRC*/4 - /*packet ID*/1 - /*last*/1 - /*length*/2;
 // used by DDMA, subkernel program data (need to provide extra ID and destination)
 pub const MASTER_PAYLOAD_MAX_SIZE: usize = SAT_PAYLOAD_MAX_SIZE - /*source*/1 - /*destination*/1 - /*ID*/4;
-// used by core device management, core_mgmt packet
-// FIXME: packet size
-pub const CORE_MGMT_PAYLOAD_MAX_SIZE: usize = MASTER_PAYLOAD_MAX_SIZE;
-// pub const CORE_MGMT_CONFIG_MAX_SIZE: usize = /*max size*/MAX_PACKET - /*destination*/1 - /*last*/1 - /*length*/2;
-pub const CORE_MGMT_CONFIG_MAX_SIZE: usize = MASTER_PAYLOAD_MAX_SIZE;
 
 #[derive(Debug)]
 pub enum Error {
@@ -272,14 +267,12 @@ pub enum Packet {
         exception_src: u8,
     },
     SubkernelExceptionRequest {
-        source: u8,
         destination: u8,
     },
     SubkernelException {
-        destination: u8,
         last: bool,
         length: u16,
-        data: [u8; MASTER_PAYLOAD_MAX_SIZE],
+        data: [u8; SAT_PAYLOAD_MAX_SIZE],
     },
     SubkernelMessage {
         source: u8,
@@ -292,72 +285,6 @@ pub enum Packet {
     SubkernelMessageAck {
         destination: u8,
     },
-
-    CoreMgmtGetLogRequest {
-        destination: u8,
-    },
-    CoreMgmtGetLogReply {
-        last: bool,
-        length: u16,
-        data: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE],
-    },
-    CoreMgmtClearLogRequest {
-        destination: u8,
-    },
-    CoreMgmtPullLogRequest {
-        destination: u8,
-    },
-    CoreMgmtPullLogReply {
-        destination: u8,
-        last: bool,
-        length: u16,
-        data: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE],
-    },
-    CoreMgmtSetLogLevelRequest {
-        destination: u8,
-        log_level: u8,
-    },
-    CoreMgmtSetUartLogLevelRequest {
-        destination: u8,
-        log_level: u8,
-    },
-    CoreMgmtConfigReadRequest {
-        destination: u8,
-        length: u16,
-        key: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE],
-    },
-    CoreMgmtConfigReadContinue {
-        destination: u8,
-    },
-    CoreMgmtConfigReadReply {
-        succeeded: bool,
-        length: u16,
-        last: bool,
-        value: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE],
-    },
-    CoreMgmtConfigWriteRequest {
-        destination: u8,
-        length: u16,
-        last: bool,
-        data: [u8; CORE_MGMT_CONFIG_MAX_SIZE],
-    },
-    CoreMgmtConfigRemoveRequest {
-        destination: u8,
-        length: u16,
-        key: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE],
-    },
-    CoreMgmtConfigEraseRequest {
-        destination: u8,
-    },
-    CoreMgmtRebootRequest {
-        destination: u8,
-    },
-    CoreMgmtAllocatorDebugRequest {
-        destination: u8,
-    },
-    CoreMgmtAck {
-        succeeded: bool
-    },
 }
 
 impl Packet {
@@ -597,17 +524,14 @@ impl Packet {
                 exception_src: reader.read_u8()?,
             },
             0xc9 => Packet::SubkernelExceptionRequest {
-                source: reader.read_u8()?,
                 destination: reader.read_u8()?,
             },
             0xca => {
-                let destination = reader.read_u8()?;
                 let last = reader.read_bool()?;
                 let length = reader.read_u16()?;
-                let mut data: [u8; MASTER_PAYLOAD_MAX_SIZE] = [0; MASTER_PAYLOAD_MAX_SIZE];
+                let mut data: [u8; SAT_PAYLOAD_MAX_SIZE] = [0; SAT_PAYLOAD_MAX_SIZE];
                 reader.read_exact(&mut data[0..length as usize])?;
                 Packet::SubkernelException {
-                    destination: destination,
                     last: last,
                     length: length,
                     data: data,
@@ -634,111 +558,6 @@ impl Packet {
                 destination: reader.read_u8()?,
             },
 
-            0xd0 => Packet::CoreMgmtGetLogRequest {
-                destination: reader.read_u8()?,
-            },
-            0xd1 => {
-                let last = reader.read_bool()?;
-                let length = reader.read_u16()?;
-                let mut data: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE] = [0; CORE_MGMT_PAYLOAD_MAX_SIZE];
-                reader.read_exact(&mut data[0..length as usize])?;
-                Packet::CoreMgmtGetLogReply {
-                    last: last,
-                    length: length,
-                    data: data,
-                }
-            },
-            0xd2 => Packet::CoreMgmtClearLogRequest {
-                destination: reader.read_u8()?,
-            },
-            0xd3 => Packet::CoreMgmtPullLogRequest {
-                destination: reader.read_u8()?,
-            },
-            0xd4 => {
-                let destination = reader.read_u8()?;
-                let last = reader.read_bool()?;
-                let length = reader.read_u16()?;
-                let mut data: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE] = [0; CORE_MGMT_PAYLOAD_MAX_SIZE];
-                reader.read_exact(&mut data[0..length as usize])?;
-                Packet::CoreMgmtPullLogReply {
-                    destination: destination,
-                    last: last,
-                    length: length,
-                    data: data,
-                }
-            },
-            0xd5 => Packet::CoreMgmtSetLogLevelRequest {
-                destination: reader.read_u8()?,
-                log_level: reader.read_u8()?,
-            },
-            0xd6 => Packet::CoreMgmtSetUartLogLevelRequest {
-                destination: reader.read_u8()?,
-                log_level: reader.read_u8()?,
-            },
-            0xd7 => {
-                let destination = reader.read_u8()?;
-                let length = reader.read_u16()?;
-                let mut key: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE] = [0; CORE_MGMT_PAYLOAD_MAX_SIZE];
-                reader.read_exact(&mut key[0..length as usize])?;
-                Packet::CoreMgmtConfigReadRequest {
-                    destination: destination,
-                    length: length,
-                    key: key,
-                }
-            },
-            0xd8 => {
-                let succeeded = reader.read_bool()?;
-                let length = reader.read_u16()?;
-                let last = reader.read_bool()?;
-                let mut value: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE] = [0; CORE_MGMT_PAYLOAD_MAX_SIZE];
-                reader.read_exact(&mut value[0..length as usize])?;
-                Packet::CoreMgmtConfigReadReply {
-                    succeeded: succeeded,
-                    length: length,
-                    last: last,
-                    value: value,
-                }
-            },
-            0xd9 => {
-                let destination = reader.read_u8()?;
-                let length = reader.read_u16()?;
-                let last = reader.read_bool()?;
-                let mut data: [u8; CORE_MGMT_CONFIG_MAX_SIZE] = [0; CORE_MGMT_CONFIG_MAX_SIZE];
-                reader.read_exact(&mut data[0..length as usize])?;
-                Packet::CoreMgmtConfigWriteRequest {
-                    destination: destination,
-                    length: length,
-                    last: last,
-                    data: data,
-                }
-            },
-            0xda => {
-                let destination = reader.read_u8()?;
-                let length = reader.read_u16()?;
-                let mut key: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE] = [0; CORE_MGMT_PAYLOAD_MAX_SIZE];
-                reader.read_exact(&mut key[0..length as usize])?;
-                Packet::CoreMgmtConfigRemoveRequest {
-                    destination: destination,
-                    length: length,
-                    key: key,
-                }
-            },
-            0xdb => Packet::CoreMgmtConfigEraseRequest {
-                destination: reader.read_u8()?,
-            },
-            0xdc => Packet::CoreMgmtRebootRequest {
-                destination: reader.read_u8()?,
-            },
-            0xdd => Packet::CoreMgmtAllocatorDebugRequest {
-                destination: reader.read_u8()?,
-            },
-            0xde => Packet::CoreMgmtAck {
-                succeeded: reader.read_bool()?,
-            },
-            0xdf => Packet::CoreMgmtConfigReadContinue {
-                destination: reader.read_u8()?,
-            },
-
             ty => return Err(Error::UnknownPacket(ty)),
         })
     }
@@ -1077,19 +896,12 @@ impl Packet {
                 writer.write_bool(with_exception)?;
                 writer.write_u8(exception_src)?;
             }
-            Packet::SubkernelExceptionRequest { source, destination } => {
+            Packet::SubkernelExceptionRequest { destination } => {
                 writer.write_u8(0xc9)?;
-                writer.write_u8(source)?;
                 writer.write_u8(destination)?;
             }
-            Packet::SubkernelException {
+            Packet::SubkernelException { last, length, data } => {
-                destination,
-                last,
-                length,
-                data,
-            } => {
                 writer.write_u8(0xca)?;
-                writer.write_u8(destination)?;
                 writer.write_bool(last)?;
                 writer.write_u16(length)?;
                 writer.write_all(&data[0..length as usize])?;
@@ -1114,87 +926,6 @@ impl Packet {
                 writer.write_u8(0xcc)?;
                 writer.write_u8(destination)?;
             }
-            Packet::CoreMgmtGetLogRequest { destination } => {
-                writer.write_u8(0xd0)?;
-                writer.write_u8(destination)?;
-            }
-            Packet::CoreMgmtGetLogReply { last, length, data } => {
-                writer.write_u8(0xd1)?;
-                writer.write_bool(last)?;
-                writer.write_u16(length)?;
-                writer.write_all(&data[0..length as usize])?;
-            }
-            Packet::CoreMgmtClearLogRequest { destination } => {
-                writer.write_u8(0xd2)?;
-                writer.write_u8(destination)?;
-            }
-            Packet::CoreMgmtPullLogRequest { destination } => {
-                writer.write_u8(0xd3)?;
-                writer.write_u8(destination)?;
-            }
-            Packet::CoreMgmtPullLogReply { destination, last, length, data } => {
-                writer.write_u8(0xd4)?;
-                writer.write_u8(destination)?;
-                writer.write_bool(last)?;
-                writer.write_u16(length)?;
-                writer.write_all(&data[0..length as usize])?;
-            }
-            Packet::CoreMgmtSetLogLevelRequest { destination, log_level } => {
-                writer.write_u8(0xd5)?;
-                writer.write_u8(destination)?;
-                writer.write_u8(log_level)?;
-            }
-            Packet::CoreMgmtSetUartLogLevelRequest { destination, log_level } => {
-                writer.write_u8(0xd6)?;
-                writer.write_u8(destination)?;
-                writer.write_u8(log_level)?;
-            }
-            Packet::CoreMgmtConfigReadRequest { destination, length, key } => {
-                writer.write_u8(0xd7)?;
-                writer.write_u8(destination)?;
-                writer.write_u16(length)?;
-                writer.write_all(&key[0..length as usize])?;
-            }
-            Packet::CoreMgmtConfigReadReply { succeeded, length, last, value } => {
-                writer.write_u8(0xd8)?;
-                writer.write_bool(succeeded)?;
-                writer.write_u16(length)?;
-                writer.write_bool(last)?;
-                writer.write_all(&value[0..length as usize])?;
-            }
-            Packet::CoreMgmtConfigWriteRequest { destination, length, last, data } => {
-                writer.write_u8(0xd9)?;
-                writer.write_u8(destination)?;
-                writer.write_u16(length)?;
-                writer.write_bool(last)?;
-                writer.write_all(&data[0..length as usize])?;
-            }
-            Packet::CoreMgmtConfigRemoveRequest { destination, length, key } => {
-                writer.write_u8(0xda)?;
-                writer.write_u8(destination)?;
-                writer.write_u16(length)?;
-                writer.write_all(&key[0..length as usize])?;
-            }
-            Packet::CoreMgmtConfigEraseRequest { destination } => {
-                writer.write_u8(0xdb)?;
-                writer.write_u8(destination)?;
-            }
-            Packet::CoreMgmtRebootRequest { destination } => {
-                writer.write_u8(0xdc)?;
-                writer.write_u8(destination)?;
-            }
-            Packet::CoreMgmtAllocatorDebugRequest { destination } => {
-                writer.write_u8(0xdd)?;
-                writer.write_u8(destination)?;
-            }
-            Packet::CoreMgmtAck { succeeded } => {
-                writer.write_u8(0xde)?;
-                writer.write_bool(succeeded)?;
-            }
-            Packet::CoreMgmtConfigReadContinue { destination } => {
-                writer.write_u8(0xdf)?;
-                writer.write_u8(destination)?;
-            }
         }
         Ok(())
     }
@@ -1212,8 +943,6 @@ impl Packet {
             Packet::SubkernelLoadRunReply { destination, .. } => Some(*destination),
             Packet::SubkernelMessage { destination, .. } => Some(*destination),
             Packet::SubkernelMessageAck { destination } => Some(*destination),
-            Packet::SubkernelExceptionRequest { destination, .. } => Some(*destination),
-            Packet::SubkernelException { destination, .. } => Some(*destination),
             Packet::DmaPlaybackStatus { destination, .. } => Some(*destination),
             Packet::SubkernelFinished { destination, .. } => Some(*destination),
             _ => None,

src/libksupport/Cargo.toml.tpl

@@ -32,9 +32,3 @@ unwind = { path = "../libunwind" }
 libc = { path = "../libc" }
 io = { path = "../libio" }
 libboard_artiq = { path = "../libboard_artiq" }
-
-[dependencies.nalgebra]
-git = "https://git.m-labs.hk/M-labs/nalgebra.git"
-rev = "dd00f9b"
-default-features = false
-features = ["libm", "alloc"]

src/libksupport/src/eh_artiq.rs

@@ -14,10 +14,8 @@
 
 use core::mem;
 
-use core_io::Error as ReadError;
 use cslice::CSlice;
 use dwarf::eh::{self, EHAction, EHContext};
-use io::{Cursor, ProtoRead};
 use libc::{c_int, c_void, uintptr_t};
 use log::{error, trace};
 use unwind as uw;
@@ -297,60 +295,6 @@ pub unsafe extern "C" fn raise(exception: *const Exception) -> ! {
     unreachable!();
 }
 
-fn read_exception_string<'a>(reader: &mut Cursor<&[u8]>) -> Result<CSlice<'a, u8>, ReadError> {
-    let len = reader.read_u32()? as usize;
-    if len == usize::MAX {
-        let data = reader.read_u32()?;
-        Ok(unsafe { CSlice::new(data as *const u8, len) })
-    } else {
-        let pos = reader.position();
-        let slice = unsafe {
-            let ptr = reader.get_ref().as_ptr().offset(pos as isize);
-            CSlice::new(ptr, len)
-        };
-        reader.set_position(pos + len);
-        Ok(slice)
-    }
-}
-
-fn read_exception(raw_exception: &[u8]) -> Result<Exception, ReadError> {
-    let mut reader = Cursor::new(raw_exception);
-
-    let mut byte = reader.read_u8()?;
-    // to sync
-    while byte != 0x5a {
-        byte = reader.read_u8()?;
-    }
-    // skip sync bytes, 0x09 indicates exception
-    while byte != 0x09 {
-        byte = reader.read_u8()?;
-    }
-    let _len = reader.read_u32()?;
-    // ignore the remaining exceptions, stack traces etc. - unwinding from another device would be unwise anyway
-    Ok(Exception {
-        id: reader.read_u32()?,
-        message: read_exception_string(&mut reader)?,
-        param: [
-            reader.read_u64()? as i64,
-            reader.read_u64()? as i64,
-            reader.read_u64()? as i64,
-        ],
-        file: read_exception_string(&mut reader)?,
-        line: reader.read_u32()?,
-        column: reader.read_u32()?,
-        function: read_exception_string(&mut reader)?,
-    })
-}
-
-pub fn raise_raw(raw_exception: &[u8]) -> ! {
-    use crate::artiq_raise;
-    if let Ok(exception) = read_exception(raw_exception) {
-        unsafe { raise(&exception) };
-    } else {
-        artiq_raise!("SubkernelError", "Error passing exception");
-    }
-}
-
 pub unsafe extern "C" fn resume() -> ! {
     trace!("resume");
     assert!(EXCEPTION_BUFFER.exception_count != 0);

src/libksupport/src/kernel/api.rs

@@ -1,10 +1,9 @@
 use alloc::vec;
-use core::{ffi::VaList, ptr, slice, str};
+use core::{ffi::VaList, ptr, str};
 
 use libc::{c_char, c_int, size_t};
 use libm;
 use log::{info, warn};
-use nalgebra::{linalg, DMatrix};
 
 #[cfg(has_drtio)]
 use super::subkernel;
@@ -39,26 +38,6 @@ unsafe extern "C" fn rtio_log(fmt: *const c_char, mut args: ...) {
     rtio::write_log(buf.as_slice());
 }
 
-unsafe extern "C" fn linalg_try_invert_to(dim0: usize, dim1: usize, data: *mut f64) -> i8 {
-    let data_slice = unsafe { slice::from_raw_parts_mut(data, dim0 * dim1) };
-    let matrix = DMatrix::from_row_slice(dim0, dim1, data_slice);
-    let mut inverted_matrix = DMatrix::<f64>::zeros(dim0, dim1);
-
-    if linalg::try_invert_to(matrix, &mut inverted_matrix) {
-        data_slice.copy_from_slice(inverted_matrix.transpose().as_slice());
-        1
-    } else {
-        0
-    }
-}
-
-unsafe extern "C" fn linalg_wilkinson_shift(dim0: usize, dim1: usize, data: *mut f64) -> f64 {
-    let data_slice = slice::from_raw_parts_mut(data, dim0 * dim1);
-    let matrix = DMatrix::from_row_slice(dim0, dim1, data_slice);
-
-    linalg::wilkinson_shift(matrix[(0, 0)], matrix[(1, 1)], matrix[(0, 1)])
-}
-
 macro_rules! api {
     ($i:ident) => ({
         extern { static $i: u8; }
@@ -340,10 +319,6 @@ pub fn resolve(required: &[u8]) -> Option<u32> {
             }
             api!(yn = yn)
         },
-
-        // linalg
-        api!(linalg_try_invert_to = linalg_try_invert_to),
-        api!(linalg_wilkinson_shift = linalg_wilkinson_shift),
     ];
     api.iter()
         .find(|&&(exported, _)| exported.as_bytes() == required)

src/libksupport/src/kernel/mod.rs

@@ -23,7 +23,6 @@ pub enum SubkernelStatus {
     Timeout,
     IncorrectState,
     CommLost,
-    Exception(Vec<u8>),
     OtherError,
 }
 
@@ -91,7 +90,9 @@ pub enum Message {
         timeout: i64,
     },
     #[cfg(has_drtio)]
-    SubkernelAwaitFinishReply,
+    SubkernelAwaitFinishReply {
+        status: SubkernelStatus,
+    },
     #[cfg(has_drtio)]
     SubkernelMsgSend {
         id: u32,
@@ -108,10 +109,9 @@ pub enum Message {
     },
     #[cfg(has_drtio)]
     SubkernelMsgRecvReply {
+        status: SubkernelStatus,
         count: u8,
     },
-    #[cfg(has_drtio)]
-    SubkernelError(SubkernelStatus),
 }
 
 static CHANNEL_0TO1: Mutex<Option<sync_channel::Sender<'static, Message>>> = Mutex::new(None);

src/libksupport/src/kernel/subkernel.rs

@@ -3,7 +3,7 @@ use alloc::vec::Vec;
 use cslice::CSlice;
 
 use super::{Message, SubkernelStatus, KERNEL_CHANNEL_0TO1, KERNEL_CHANNEL_1TO0};
-use crate::{artiq_raise, eh_artiq, rpc::send_args};
+use crate::{artiq_raise, rpc::send_args};
 
 pub extern "C" fn load_run(id: u32, destination: u8, run: bool) {
     unsafe {
@@ -36,18 +36,21 @@ pub extern "C" fn await_finish(id: u32, timeout: i64) {
             });
     }
     match unsafe { KERNEL_CHANNEL_0TO1.as_mut().unwrap() }.recv() {
-        Message::SubkernelAwaitFinishReply => (),
+        Message::SubkernelAwaitFinishReply {
-        Message::SubkernelError(SubkernelStatus::IncorrectState) => {
+            status: SubkernelStatus::NoError,
-            artiq_raise!("SubkernelError", "Subkernel not running")
+        } => (),
-        }
+        Message::SubkernelAwaitFinishReply {
-        Message::SubkernelError(SubkernelStatus::Timeout) => artiq_raise!("SubkernelError", "Subkernel timed out"),
+            status: SubkernelStatus::IncorrectState,
-        Message::SubkernelError(SubkernelStatus::CommLost) => {
+        } => artiq_raise!("SubkernelError", "Subkernel not running"),
-            artiq_raise!("SubkernelError", "Lost communication with satellite")
+        Message::SubkernelAwaitFinishReply {
-        }
+            status: SubkernelStatus::Timeout,
-        Message::SubkernelError(SubkernelStatus::OtherError) => {
+        } => artiq_raise!("SubkernelError", "Subkernel timed out"),
-            artiq_raise!("SubkernelError", "An error occurred during subkernel operation")
+        Message::SubkernelAwaitFinishReply {
-        }
+            status: SubkernelStatus::CommLost,
-        Message::SubkernelError(SubkernelStatus::Exception(raw_exception)) => eh_artiq::raise_raw(&raw_exception),
+        } => artiq_raise!("SubkernelError", "Lost communication with satellite"),
+        Message::SubkernelAwaitFinishReply {
+            status: SubkernelStatus::OtherError,
+        } => artiq_raise!("SubkernelError", "An error occurred during subkernel operation"),
         _ => panic!("expected SubkernelAwaitFinishReply after SubkernelAwaitFinishRequest"),
     }
 }
@@ -89,22 +92,30 @@ pub extern "C" fn await_message(id: i32, timeout: i64, tags: &CSlice<u8>, min: u
             });
     }
     match unsafe { KERNEL_CHANNEL_0TO1.as_mut().unwrap() }.recv() {
-        Message::SubkernelMsgRecvReply { count } => {
+        Message::SubkernelMsgRecvReply {
+            status: SubkernelStatus::NoError,
+            count,
+        } => {
             if min > count || count > max {
                 artiq_raise!("SubkernelError", "Received more or less arguments than required")
             }
         }
-        Message::SubkernelError(SubkernelStatus::IncorrectState) => {
+        Message::SubkernelMsgRecvReply {
-            artiq_raise!("SubkernelError", "Subkernel not running")
+            status: SubkernelStatus::IncorrectState,
-        }
+            ..
-        Message::SubkernelError(SubkernelStatus::Timeout) => artiq_raise!("SubkernelError", "Subkernel timed out"),
+        } => artiq_raise!("SubkernelError", "Subkernel not running"),
-        Message::SubkernelError(SubkernelStatus::CommLost) => {
+        Message::SubkernelMsgRecvReply {
-            artiq_raise!("SubkernelError", "Lost communication with satellite")
+            status: SubkernelStatus::Timeout,
-        }
+            ..
-        Message::SubkernelError(SubkernelStatus::OtherError) => {
+        } => artiq_raise!("SubkernelError", "Subkernel timed out"),
-            artiq_raise!("SubkernelError", "An error occurred during subkernel operation")
+        Message::SubkernelMsgRecvReply {
-        }
+            status: SubkernelStatus::CommLost,
-        Message::SubkernelError(SubkernelStatus::Exception(raw_exception)) => eh_artiq::raise_raw(&raw_exception),
+            ..
+        } => artiq_raise!("SubkernelError", "Lost communication with satellite"),
+        Message::SubkernelMsgRecvReply {
+            status: SubkernelStatus::OtherError,
+            ..
+        } => artiq_raise!("SubkernelError", "An error occurred during subkernel operation"),
         _ => panic!("expected SubkernelMsgRecvReply after SubkernelMsgRecvRequest"),
     }
     // RpcRecvRequest should be called after this to receive message data

src/runtime/src/comms.rs

@@ -422,23 +422,33 @@ async fn handle_run_kernel(
             #[cfg(has_drtio)]
             kernel::Message::SubkernelAwaitFinishRequest { id, timeout } => {
                 let res = subkernel::await_finish(aux_mutex, routing_table, timer, id, timeout).await;
-                let response = match res {
+                let status = match res {
-                    Ok(res) => {
+                    Ok(ref res) => {
                         if res.status == subkernel::FinishStatus::CommLost {
-                            kernel::Message::SubkernelError(kernel::SubkernelStatus::CommLost)
+                            kernel::SubkernelStatus::CommLost
-                        } else if let Some(exception) = res.exception {
+                        } else if let Some(exception) = &res.exception {
-                            kernel::Message::SubkernelError(kernel::SubkernelStatus::Exception(exception))
+                            error!("Exception in subkernel");
+                            match stream {
+                                None => (),
+                                Some(stream) => {
+                                    write_chunk(stream, exception).await?;
+                                }
+                            }
+                            // will not be called after exception is served
+                            kernel::SubkernelStatus::OtherError
                         } else {
-                            kernel::Message::SubkernelAwaitFinishReply
+                            kernel::SubkernelStatus::NoError
                         }
                     }
-                    Err(SubkernelError::Timeout) => kernel::Message::SubkernelError(kernel::SubkernelStatus::Timeout),
+                    Err(SubkernelError::Timeout) => kernel::SubkernelStatus::Timeout,
-                    Err(SubkernelError::IncorrectState) => {
+                    Err(SubkernelError::IncorrectState) => kernel::SubkernelStatus::IncorrectState,
-                        kernel::Message::SubkernelError(kernel::SubkernelStatus::IncorrectState)
+                    Err(_) => kernel::SubkernelStatus::OtherError,
-                    }
-                    Err(_) => kernel::Message::SubkernelError(kernel::SubkernelStatus::OtherError),
                 };
-                control.borrow_mut().tx.async_send(response).await;
+                control
+                    .borrow_mut()
+                    .tx
+                    .async_send(kernel::Message::SubkernelAwaitFinishReply { status: status })
+                    .await;
             }
             #[cfg(has_drtio)]
             kernel::Message::SubkernelMsgSend { id, destination, data } => {
@@ -459,23 +469,35 @@ async fn handle_run_kernel(
             #[cfg(has_drtio)]
             kernel::Message::SubkernelMsgRecvRequest { id, timeout, tags } => {
                 let message_received = subkernel::message_await(id as u32, timeout, timer).await;
-                let response = match message_received {
+                let (status, count) = match message_received {
-                    Ok(ref message) => kernel::Message::SubkernelMsgRecvReply { count: message.count },
+                    Ok(ref message) => (kernel::SubkernelStatus::NoError, message.count),
-                    Err(SubkernelError::Timeout) => kernel::Message::SubkernelError(kernel::SubkernelStatus::Timeout),
+                    Err(SubkernelError::Timeout) => (kernel::SubkernelStatus::Timeout, 0),
-                    Err(SubkernelError::IncorrectState) => {
+                    Err(SubkernelError::IncorrectState) => (kernel::SubkernelStatus::IncorrectState, 0),
-                        kernel::Message::SubkernelError(kernel::SubkernelStatus::IncorrectState)
+                    Err(SubkernelError::CommLost) => (kernel::SubkernelStatus::CommLost, 0),
-                    }
-                    Err(SubkernelError::CommLost) => kernel::Message::SubkernelError(kernel::SubkernelStatus::CommLost),
                     Err(SubkernelError::SubkernelException) => {
+                        error!("Exception in subkernel");
                         // just retrieve the exception
                         let status = subkernel::await_finish(aux_mutex, routing_table, timer, id as u32, timeout)
                             .await
                             .unwrap();
-                        kernel::Message::SubkernelError(kernel::SubkernelStatus::Exception(status.exception.unwrap()))
+                        match stream {
+                            None => (),
+                            Some(stream) => {
+                                write_chunk(stream, &status.exception.unwrap()).await?;
                             }
-                    Err(_) => kernel::Message::SubkernelError(kernel::SubkernelStatus::OtherError),
+                        }
+                        (kernel::SubkernelStatus::OtherError, 0)
+                    }
+                    Err(_) => (kernel::SubkernelStatus::OtherError, 0),
                 };
-                control.borrow_mut().tx.async_send(response).await;
+                control
+                    .borrow_mut()
+                    .tx
+                    .async_send(kernel::Message::SubkernelMsgRecvReply {
+                        status: status,
+                        count: count,
+                    })
+                    .await;
                 if let Ok(message) = message_received {
                     // receive code almost identical to RPC recv, except we are not reading from a stream
                     let mut reader = Cursor::new(message.data);
@@ -507,7 +529,7 @@ async fn handle_run_kernel(
                             .async_send(kernel::Message::RpcRecvReply(Ok(0)))
                             .await;
                         i += 1;
-                        if i < message.count {
+                        if i < count {
                             current_tags = remaining_tags;
                         } else {
                             break;
@@ -749,7 +771,7 @@ pub fn main(timer: GlobalTimer, cfg: Config) {
     #[cfg(has_drtio_routing)]
     drtio_routing::interconnect_disable_all();
 
-    rtio_mgt::startup(&aux_mutex, &drtio_routing_table, &up_destinations, &cfg, timer);
+    rtio_mgt::startup(&aux_mutex, &drtio_routing_table, &up_destinations, timer);
     ksupport::setup_device_map(&cfg);
 
     analyzer::start(&aux_mutex, &drtio_routing_table, &up_destinations, timer);
@@ -783,7 +805,7 @@ pub fn main(timer: GlobalTimer, cfg: Config) {
         }
     }
 
-    mgmt::start(cfg, &aux_mutex, &drtio_routing_table, timer);
+    mgmt::start(cfg);
 
     task::spawn(async move {
         let connection = Rc::new(Semaphore::new(1, 1));
@@ -886,7 +908,7 @@ pub fn soft_panic_main(timer: GlobalTimer, cfg: Config) -> ! {
 
     Sockets::init(32);
 
-    // mgmt::start(cfg);
+    mgmt::start(cfg);
 
     // getting eth settings disables the LED as it resets GPIO
     // need to re-enable it here

src/runtime/src/mgmt.rs

@@ -3,16 +3,14 @@ use core::cell::RefCell;
 
 use futures::{future::poll_fn, task::Poll};
 use libasync::{smoltcp::TcpStream, task};
-use libboard_artiq::{logger::{BufferLogger, LogBufferRef}, drtio_routing, drtio_routing::RoutingTable};
+use libboard_artiq::logger::{BufferLogger, LogBufferRef};
-use libboard_zynq::{slcr, smoltcp, timer::GlobalTimer};
+use libboard_zynq::{slcr, smoltcp};
 use libconfig::Config;
-use libcortex_a9::mutex::Mutex;
 use log::{self, debug, error, info, warn, LevelFilter};
 use num_derive::FromPrimitive;
 use num_traits::FromPrimitive;
 
 use crate::proto_async::*;
-use crate::rtio_mgt::*;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Error {
@@ -20,11 +18,6 @@ pub enum Error {
     UnknownLogLevel(u8),
     UnexpectedPattern,
     UnrecognizedPacket,
-    ReadConfigFail,
-    WriteConfigFail,
-    RemoveConfigFail,
-    #[cfg(has_drtio)]
-    DrtioError(drtio::Error),
 }
 
 type Result<T> = core::result::Result<T, Error>;
@@ -36,11 +29,6 @@ impl core::fmt::Display for Error {
             &Error::UnknownLogLevel(lvl) => write!(f, "unknown log level {}", lvl),
             &Error::UnexpectedPattern => write!(f, "unexpected pattern"),
             &Error::UnrecognizedPacket => write!(f, "unrecognized packet"),
-            &Error::ReadConfigFail => write!(f, "error reading config"),
-            &Error::WriteConfigFail => write!(f, "error writing config"),
-            &Error::RemoveConfigFail => write!(f, "error removing config"),
-            #[cfg(has_drtio)]
-            &Error::DrtioError(error) => write!(f, "drtio error: {}", error),
         }
     }
 }
@@ -51,13 +39,6 @@ impl From<smoltcp::Error> for Error {
     }
 }
 
-#[cfg(has_drtio)]
-impl From<drtio::Error> for Error {
-    fn from(error: drtio::Error) -> Self {
-        Error::DrtioError(error)
-    }
-}
-
 #[derive(Debug, FromPrimitive)]
 pub enum Request {
     GetLog = 1,
@@ -81,24 +62,18 @@ pub enum Reply {
     ConfigData = 7,
 }
 
-pub fn byte_to_level_filter(level_byte: u8) -> Result<log::LevelFilter> {
+async fn read_log_level_filter(stream: &mut TcpStream) -> Result<log::LevelFilter> {
-    Ok(match level_byte {
+    Ok(match read_i8(stream).await? {
         0 => log::LevelFilter::Off,
         1 => log::LevelFilter::Error,
         2 => log::LevelFilter::Warn,
         3 => log::LevelFilter::Info,
         4 => log::LevelFilter::Debug,
         5 => log::LevelFilter::Trace,
-        lv => return Err(Error::UnknownLogLevel(lv)),
+        lv => return Err(Error::UnknownLogLevel(lv as u8)),
     })
 }
 
-async fn read_log_level_filter(stream: &mut TcpStream) -> Result<log::LevelFilter> {
-    let level_byte = read_i8(stream).await? as u8;
-    
-    byte_to_level_filter(level_byte)
-}
-
 async fn get_logger_buffer_pred<F>(f: F) -> LogBufferRef<'static>
 where F: Fn(&LogBufferRef) -> bool {
     poll_fn(|ctx| {
@@ -136,21 +111,30 @@ async fn read_key(stream: &mut TcpStream) -> Result<String> {
     Ok(String::from_utf8(buffer).unwrap())
 }
 
-mod local_coremgmt {
+async fn handle_connection(stream: &mut TcpStream, pull_id: Rc<RefCell<u32>>, cfg: Rc<Config>) -> Result<()> {
-    use super::*;
+    if !expect(&stream, b"ARTIQ management\n").await? {
-
+        return Err(Error::UnexpectedPattern);
-    pub async fn get_log() -> Result<Vec<u8>> {
-        let buffer = get_logger_buffer().await.extract().as_bytes().to_vec();
-        Ok(buffer)
     }
+    stream.send_slice("e".as_bytes()).await?;
 
-    pub async fn clear_log() -> Result<()> {
+    loop {
+        let msg = read_i8(stream).await;
+        if let Err(smoltcp::Error::Finished) = msg {
+            return Ok(());
+        }
+        let msg: Request = FromPrimitive::from_i8(msg?).ok_or(Error::UnrecognizedPacket)?;
+        match msg {
+            Request::GetLog => {
+                let buffer = get_logger_buffer().await.extract().as_bytes().to_vec();
+                write_i8(stream, Reply::LogContent as i8).await?;
+                write_chunk(stream, &buffer).await?;
+            }
+            Request::ClearLog => {
                 let mut buffer = get_logger_buffer().await;
                 buffer.clear();
-        Ok(())
+                write_i8(stream, Reply::Success as i8).await?;
             }
-
+            Request::PullLog => {
-    pub async fn pull_log<'a>(stream: &'a mut TcpStream, pull_id: Rc<RefCell<u32>>) -> Result<()> {
                 let id = {
                     let mut guard = pull_id.borrow_mut();
                     *guard += 1;
@@ -175,464 +159,34 @@ mod local_coremgmt {
                         logger.set_buffer_log_level(LevelFilter::Trace);
                     }
                 }
-        Ok(())
             }
-
+            Request::SetLogFilter => {
-    pub async fn set_log_filter(lvl: LevelFilter) -> Result<()> {
+                let lvl = read_log_level_filter(stream).await?;
                 info!("Changing log level to {}", lvl);
                 log::set_max_level(lvl);
-        Ok(())
+                write_i8(stream, Reply::Success as i8).await?;
             }
-
+            Request::SetUartLogFilter => {
-    pub async fn set_uart_log_filter(lvl: LevelFilter) -> Result<()> {
+                let lvl = read_log_level_filter(stream).await?;
                 info!("Changing UART log level to {}", lvl);
                 unsafe {
                     BufferLogger::get_logger().as_ref().unwrap().set_uart_log_level(lvl);
                 }
-        Ok(())
-    }
-
-    pub async fn config_read(cfg: &Rc<Config>, key: &String) -> Result<Vec<u8>>{
-        debug!("read key: {}", key);
-        cfg.read(&key).map_err(|_| Error::ReadConfigFail)
-    }
-
-    pub async fn config_write<'a>(cfg: &Rc<Config>, key: &'a String, value: Vec<u8>) -> Result<()> {
-        cfg.write(&key, value).map_err(|_| Error::WriteConfigFail)
-    }
-
-    pub async fn config_remove<'a>(cfg: &Rc<Config>, key: &'a String) -> Result<()> {
-        debug!("erase key: {}", key);
-        let value = cfg.remove(&key);
-        if value.is_ok() {
-            debug!("erase success");
-            Ok(())
-        } else {
-            warn!("erase failed");
-            Err(Error::RemoveConfigFail)
-        }
-    }
-}
-
-#[cfg(has_drtio)]
-mod remote_coremgmt {
-    use crate::rtio_mgt::drtio;
-    use super::*;
-    use libboard_artiq::drtioaux_proto::{Packet, CORE_MGMT_PAYLOAD_MAX_SIZE};
-    use io::{Cursor, ProtoWrite};
-
-    pub async fn get_log(
-        aux_mutex: &Rc<Mutex<bool>>,
-        routing_table: &drtio_routing::RoutingTable,
-        timer: GlobalTimer,
-        linkno: u8,
-        destination: u8,
-    ) -> Result<Vec<u8>> {
-        let mut buffer = Vec::new();
-        loop {
-            match drtio::aux_transact(
-                aux_mutex,
-                linkno,
-                routing_table,
-                &Packet::CoreMgmtGetLogRequest {
-                    destination
-                },
-                timer,
-            ).await? {
-                Packet::CoreMgmtGetLogReply {
-                    last, length, data,
-                } => {
-                    buffer.extend(&data[..length as usize]);
-                    if last {
-                        return Ok(buffer);
-                    }
-                },
-                _ => return Err(drtio::Error::UnexpectedReply.into()),
-            }
-        }
-    }
-
-    pub async fn clear_log(
-        aux_mutex: &Rc<Mutex<bool>>,
-        routing_table: &drtio_routing::RoutingTable,
-        timer: GlobalTimer,
-        linkno: u8,
-        destination: u8,
-    ) -> Result<()> {
-        let reply = drtio::aux_transact(
-            aux_mutex,
-            linkno,
-            routing_table,
-            &Packet::CoreMgmtClearLogRequest {
-                destination
-            },
-            timer,
-        ).await?;
-        
-        match reply {
-            Packet::CoreMgmtAck {
-                succeeded: true
-            } => Ok(()),
-            _ => Err(drtio::Error::UnexpectedReply.into()),
-        }
-    }
-
-    pub async fn pull_log(
-        aux_mutex: &Rc<Mutex<bool>>,
-        routing_table: &drtio_routing::RoutingTable,
-        timer: GlobalTimer,
-        linkno: u8,
-        destination: u8,
-        stream: &mut TcpStream,
-    ) -> Result<()> {
-        todo!()
-    }
-
-    pub async fn set_log_filter(
-        aux_mutex: &Rc<Mutex<bool>>,
-        routing_table: &drtio_routing::RoutingTable,
-        timer: GlobalTimer,
-        linkno: u8,
-        destination: u8,
-        level: LevelFilter,
-    ) -> Result<()> {
-        let reply = drtio::aux_transact(
-            aux_mutex,
-            linkno,
-            routing_table,
-            &Packet::CoreMgmtSetLogLevelRequest {
-                destination,
-                log_level: level as u8,
-            },
-            timer,
-        ).await?;
-
-        match reply {
-            Packet::CoreMgmtAck {
-                succeeded: true
-            } => Ok(()),
-            Packet::CoreMgmtAck {
-                succeeded: false
-            } => {
-                error!("satellite misinterpret log level, corrupted packet?");
-                Err(drtio::Error::AuxError.into())
-            },
-            _ => Err(drtio::Error::UnexpectedReply.into()),
-        }
-    }
-
-    pub async fn set_uart_log_filter(
-        aux_mutex: &Rc<Mutex<bool>>,
-        routing_table: &drtio_routing::RoutingTable,
-        timer: GlobalTimer,
-        linkno: u8,
-        destination: u8,
-        level: LevelFilter,
-    ) -> Result<()> {
-        let reply = drtio::aux_transact(
-            aux_mutex,
-            linkno,
-            routing_table,
-            &Packet::CoreMgmtSetUartLogLevelRequest {
-                destination,
-                log_level: level as u8,
-            },
-            timer,
-        ).await?;
-        
-        match reply {
-            Packet::CoreMgmtAck {
-                succeeded: true
-            } => Ok(()),
-            Packet::CoreMgmtAck {
-                succeeded: false
-            } => {
-                error!("satellite misinterpret log level, corrupted packet?");
-                Err(drtio::Error::AuxError.into())
-            },
-            _ => Err(drtio::Error::UnexpectedReply.into()),
-        }
-    }
-
-    pub async fn config_read(
-        aux_mutex: &Rc<Mutex<bool>>,
-        routing_table: &drtio_routing::RoutingTable,
-        timer: GlobalTimer,
-        linkno: u8,
-        destination: u8,
-        _cfg: &Rc<Config>,
-        key: &String,
-    ) -> Result<Vec<u8>> {
-        let mut config_key: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE] = [0; CORE_MGMT_PAYLOAD_MAX_SIZE];
-        let len = key.len();
-        if len > CORE_MGMT_PAYLOAD_MAX_SIZE {
-            error!("key is too long");
-            return Err(Error::ReadConfigFail);
-        }
-        config_key[..len].clone_from_slice(key.as_bytes());
-
-        let mut reply = drtio::aux_transact(
-            aux_mutex,
-            linkno,
-            routing_table,
-            &Packet::CoreMgmtConfigReadRequest {
-                destination: destination,
-                length: len as u16,
-                key: config_key,
-            },
-            timer,
-        ).await?;
-
-        let mut buffer = Vec::new();
-        loop {
-            match reply {
-                Packet::CoreMgmtConfigReadReply {
-                    succeeded: true,
-                    length,
-                    last,
-                    value,
-                } => {
-                    buffer.extend(&value[..length as usize]);
-
-                    if last {
-                        return Ok(buffer);
-                    }
-
-                    reply = drtio::aux_transact(
-                        aux_mutex,
-                        linkno,
-                        routing_table,
-                        &Packet::CoreMgmtConfigReadContinue {
-                            destination: destination,
-                        },
-                        timer,
-                    ).await?;
-                }
-
-                Packet::CoreMgmtConfigReadReply {
-                    succeeded:false, ..
-                } => {
-                    return Err(Error::ReadConfigFail);
-                }
-
-                _ => return Err(drtio::Error::UnexpectedReply.into()),
-            }
-        }
-    }
-
-    pub async fn config_write(
-        aux_mutex: &Rc<Mutex<bool>>,
-        routing_table: &drtio_routing::RoutingTable,
-        timer: GlobalTimer,
-        linkno: u8,
-        destination: u8,
-        _cfg: &Rc<Config>,
-        key: &String,
-        value: Vec<u8>,
-    ) -> Result<()> {
-        let mut message = Cursor::new(Vec::with_capacity(key.len() + value.len() + 4 * 2));
-        message.write_string(key).unwrap();
-        message.write_bytes(&value).unwrap();
-
-        drtio::partition_data(
-            linkno,
-            aux_mutex,
-            routing_table,
-            timer,
-            message.get_ref(),
-            |slice, status, len: usize| Packet::CoreMgmtConfigWriteRequest {
-                destination: destination,
-                length: len as u16,
-                last: status.is_last(),
-                data: *slice
-            },
-            |reply| match reply {
-                Packet::CoreMgmtAck { succeeded: true } => {
-                    Ok(())
-                },
-                Packet::CoreMgmtAck { succeeded: false } => {
-                    error!("config write failed");
-                    Err(Error::WriteConfigFail)
-                },
-                _ => {
-                    error!("received unknown packet");
-                    Err(drtio::Error::UnexpectedReply.into())
-                },
-            }
-        ).await
-    }
-
-    pub async fn config_remove(
-        aux_mutex: &Rc<Mutex<bool>>,
-        routing_table: &drtio_routing::RoutingTable,
-        timer: GlobalTimer,
-        linkno: u8,
-        destination: u8,
-        _cfg: &Rc<Config>,
-        key: &String,
-    ) -> Result<()> {
-        let mut config_key: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE] = [0; CORE_MGMT_PAYLOAD_MAX_SIZE];
-        let len = key.len();
-        if len > CORE_MGMT_PAYLOAD_MAX_SIZE {
-            error!("key is too long");
-            return Err(Error::RemoveConfigFail);
-        }
-        config_key[..len].clone_from_slice(key.as_bytes());
-
-        let reply = drtio::aux_transact(
-            aux_mutex,
-            linkno,
-            routing_table,
-            &Packet::CoreMgmtConfigRemoveRequest {
-                destination: destination,
-                length: len as u16,
-                key: config_key,
-            },
-            timer,
-        ).await?;
-
-        match reply {
-            Packet::CoreMgmtAck { succeeded: true } => Ok(()),
-            Packet::CoreMgmtAck { succeeded: false } => Err(Error::RemoveConfigFail),
-            _ => Err(drtio::Error::UnexpectedReply.into()),
-        }
-    }
-
-    pub async fn reboot(
-        aux_mutex: &Rc<Mutex<bool>>,
-        routing_table: &drtio_routing::RoutingTable,
-        timer: GlobalTimer,
-        linkno: u8,
-        destination: u8,
-    ) -> Result<()> {
-        info!("initited reboot request to satellite destination {}", destination);
-        let reply = drtio::aux_transact(
-            aux_mutex,
-            linkno,
-            routing_table,
-            &Packet::CoreMgmtRebootRequest {
-                destination: destination,
-            },
-            timer,
-        ).await?;
-
-        match reply {
-            Packet::CoreMgmtAck { succeeded: true } => Ok(()),
-            _ => {
-                error!("received unknown packet");
-                Err(drtio::Error::UnexpectedReply.into())
-            },
-        }
-    }
-}
-
-#[cfg(has_drtio)]
-macro_rules! process {
-    ($timer:ident, $aux_mutex:ident, $routing_table:ident, $destination:expr, $func:ident $(, $param:expr)*) => {{
-        if $destination == 0 {
-            local_coremgmt::$func($($param, )*).await
-        } else {
-            let linkno = $routing_table.0[$destination as usize][0] - 1 as u8;
-            remote_coremgmt::$func($aux_mutex, $routing_table, $timer, linkno, $destination, $($param, )*).await
-        }
-    }}
-}
-
-#[cfg(not(has_drtio))]
-macro_rules! process {
-    ($timer:ident, $aux_mutex:ident, $routing_table:ident, $destination:expr, $func:ident $(, $param:expr)*) => {{
-        local_coremgmt::$func($($param, )*).await
-    }}
-}
-
-
-async fn handle_connection(
-    stream: &mut TcpStream,
-    pull_id: Rc<RefCell<u32>>,
-    cfg: Rc<Config>,
-    _aux_mutex: &Rc<Mutex<bool>>,
-    _routing_table: &RoutingTable,
-    timer: GlobalTimer,
-) -> Result<()> {
-    if !expect(&stream, b"ARTIQ management\n").await? {
-        return Err(Error::UnexpectedPattern);
-    }
-
-    let destination: u8 = read_i8(stream).await? as u8;
-    stream.send_slice("e".as_bytes()).await?;
-
-    loop {
-        let msg = read_i8(stream).await;
-        if let Err(smoltcp::Error::Finished) = msg {
-            return Ok(());
-        }
-        let msg: Request = FromPrimitive::from_i8(msg?).ok_or(Error::UnrecognizedPacket)?;
-        match msg {
-            Request::GetLog => {
-                match dispatch!(timer, _aux_mutex, _routing_table, destination, get_log) {
-                    Ok(buffer) => {
-                        write_i8(stream, Reply::LogContent as i8).await?;
-                        write_chunk(stream, &buffer).await?;
-                    }
-                    Err(_) => {
-                        write_i8(stream, Reply::Error as i8).await?;
-                    }
-                }
-            },
-
-            Request::ClearLog => {
-                match dispatch!(timer, _aux_mutex, _routing_table, destination, clear_log) {
-                    Ok(()) => {
                 write_i8(stream, Reply::Success as i8).await?;
             }
-                    Err(_) => {
-                        write_i8(stream, Reply::Error as i8).await?;
-                    }
-                }
-            },
-
-            Request::PullLog => {
-                todo!()
-            }
-
-            Request::SetLogFilter => {
-                let lvl = read_log_level_filter(stream).await?;
-                match dispatch!(timer, _aux_mutex, _routing_table, destination, set_log_filter, lvl) {
-                    Ok(()) => {
-                        write_i8(stream, Reply::Success as i8).await?;
-                    }
-                    Err(_) => {
-                        write_i8(stream, Reply::Error as i8).await?;
-                    }
-                }
-            },
-
-            Request::SetUartLogFilter => {
-                let lvl = read_log_level_filter(stream).await?;
-                match dispatch!(timer, _aux_mutex, _routing_table, destination, set_uart_log_filter, lvl) {
-                    Ok(()) => {
-                        write_i8(stream, Reply::Success as i8).await?;
-                    }
-                    Err(_) => {
-                        write_i8(stream, Reply::Error as i8).await?;
-                    }
-                }
-            },
-
             Request::ConfigRead => {
                 let key = read_key(stream).await?;
                 debug!("read key: {}", key);
-                match dispatch!(timer, _aux_mutex, _routing_table, destination, config_read, &cfg, &key) {
+                let value = cfg.read(&key);
-                    Ok(value) => {
+                if let Ok(value) = value {
+                    debug!("got value");
                     write_i8(stream, Reply::ConfigData as i8).await?;
                     write_chunk(stream, &value).await?;
-                    }
+                } else {
-                    Err(_) => {
+                    warn!("read error: no such key");
                     write_i8(stream, Reply::Error as i8).await?;
                 }
             }
-            },
-
             Request::ConfigWrite => {
                 let key = read_key(stream).await?;
                 debug!("write key: {}", key);
@@ -643,55 +197,39 @@ async fn handle_connection(
                     buffer.set_len(len);
                 }
                 read_chunk(stream, &mut buffer).await?;
-                match dispatch!(timer, _aux_mutex, _routing_table, destination, config_write, &cfg, &key, buffer) {
+                let value = cfg.write(&key, buffer);
-                    Ok(()) => write_i8(stream, Reply::Success as i8).await?,
-                    Err(_) => write_i8(stream, Reply::Error as i8).await?,
-                }
-            },
-
-            Request::ConfigRemove => {
-                let key = read_key(stream).await?;
-                let value = dispatch!(timer, _aux_mutex, _routing_table, destination, config_remove, &cfg, &key);
                 if value.is_ok() {
+                    debug!("write success");
                     write_i8(stream, Reply::Success as i8).await?;
                 } else {
+                    // this is an error because we do not expect write to fail
+                    error!("failed to write: {:?}", value);
                     write_i8(stream, Reply::Error as i8).await?;
                 }
-            },
+            }
-
+            Request::ConfigRemove => {
+                let key = read_key(stream).await?;
+                debug!("erase key: {}", key);
+                let value = cfg.remove(&key);
+                if value.is_ok() {
+                    debug!("erase success");
+                    write_i8(stream, Reply::Success as i8).await?;
+                } else {
+                    warn!("erase failed");
+                    write_i8(stream, Reply::Error as i8).await?;
+                }
+            }
             Request::Reboot => {
-                if destination == 0 {
                 info!("rebooting");
                 write_i8(stream, Reply::RebootImminent as i8).await?;
                 stream.flush().await?;
                 slcr::reboot();
             }
-
-                #[cfg(has_drtio)]
-                {
-                    let linkno = _routing_table.0[destination as usize][0] - 1;
-                    match remote_coremgmt::reboot(
-                        _aux_mutex, _routing_table, timer, linkno, destination
-                    ).await {
-                        Ok(()) => write_i8(stream, Reply::Success as i8).await?,
-                        Err(_) => write_i8(stream, Reply::Error as i8).await?,
-                    }
-                }
-            },
-            _ => todo!()
         }
     }
 }
 
-
+pub fn start(cfg: Config) {
-pub fn start(
-    cfg: Config,
-    aux_mutex: &Rc<Mutex<bool>>,
-    routing_table: &Rc<RefCell<drtio_routing::RoutingTable>>,
-    timer: GlobalTimer,
-) {
-    let aux_mutex = aux_mutex.clone();
-    let routing_table = routing_table.clone();
     task::spawn(async move {
         let pull_id = Rc::new(RefCell::new(0u32));
         let cfg = Rc::new(cfg);
@@ -699,12 +237,9 @@ pub fn start(
             let mut stream = TcpStream::accept(1380, 2048, 2048).await.unwrap();
             let pull_id = pull_id.clone();
             let cfg = cfg.clone();
-            let aux_mutex = aux_mutex.clone();
-            let routing_table = routing_table.clone();
             task::spawn(async move {
                 info!("received connection");
-                let routing_table = routing_table.borrow();
+                let _ = handle_connection(&mut stream, pull_id, cfg)
-                let _ = handle_connection(&mut stream, pull_id, cfg, &aux_mutex, &routing_table, timer)
                     .await
                     .map_err(|e| warn!("connection terminated: {:?}", e));
                 let _ = stream.flush().await;

src/runtime/src/rtio_mgt.rs

@@ -3,9 +3,7 @@ use core::cell::RefCell;
 
 use libboard_artiq::{drtio_routing, drtio_routing::RoutingTable, pl::csr};
 use libboard_zynq::timer::GlobalTimer;
-use libconfig::Config;
 use libcortex_a9::mutex::Mutex;
-use log::{info, warn};
 
 #[cfg(has_drtio)]
 pub mod drtio {
@@ -129,8 +127,6 @@ pub mod drtio {
             | Packet::SubkernelLoadRunReply { destination, .. }
             | Packet::SubkernelMessage { destination, .. }
             | Packet::SubkernelMessageAck { destination, .. }
-            | Packet::SubkernelException { destination, .. }
-            | Packet::SubkernelExceptionRequest { destination, .. }
             | Packet::DmaPlaybackStatus { destination, .. }
             | Packet::SubkernelFinished { destination, .. } => {
                 if destination == 0 {
@@ -185,7 +181,10 @@ pub mod drtio {
 
     async fn drain_buffer(linkno: u8, draining_time: Milliseconds, timer: GlobalTimer) {
         let max_time = timer.get_time() + draining_time;
-        while timer.get_time() < max_time {
+        loop {
+            if timer.get_time() > max_time {
+                return;
+            }
             let _ = drtioaux_async::recv(linkno).await;
         }
     }
@@ -540,7 +539,7 @@ pub mod drtio {
         }
     }
 
-    pub async fn partition_data<PacketF, HandlerF, E>(
+    async fn partition_data<PacketF, HandlerF>(
         linkno: u8,
         aux_mutex: &Rc<Mutex<bool>>,
         routing_table: &RoutingTable,
@@ -548,11 +547,10 @@ pub mod drtio {
         data: &[u8],
         packet_f: PacketF,
         reply_handler_f: HandlerF,
-    ) -> Result<(), E>
+    ) -> Result<(), Error>
     where
         PacketF: Fn(&[u8; MASTER_PAYLOAD_MAX_SIZE], PayloadStatus, usize) -> Packet,
-        HandlerF: Fn(&Packet) -> Result<(), E>,
+        HandlerF: Fn(&Packet) -> Result<(), Error>,
-        E: From<Error>,
     {
         let mut i = 0;
         while i < data.len() {
@@ -835,19 +833,13 @@ pub mod drtio {
                 linkno,
                 routing_table,
                 &Packet::SubkernelExceptionRequest {
-                    source: 0,
                     destination: destination,
                 },
                 timer,
             )
             .await?;
             match reply {
-                Packet::SubkernelException {
+                Packet::SubkernelException { last, length, data } => {
-                    destination: 0,
-                    last,
-                    length,
-                    data,
-                } => {
                     remote_data.extend(&data[0..length as usize]);
                     if last {
                         return Ok(remote_data);
@@ -888,363 +880,6 @@ pub mod drtio {
         )
         .await
     }
-
-    // pub async fn destination_get_log(
-    //     aux_mutex: &Rc<Mutex<bool>>,
-    //     routing_table: &RoutingTable,
-    //     timer: GlobalTimer,
-    //     destination: u8,
-    // ) -> Result<Vec<u8>, Error> {
-    //     let linkno = routing_table.0[destination as usize][0] - 1;
-    //     let mut remote_log: Vec<u8> = Vec::new();
-    //     loop {
-    //         let reply = aux_transact(
-    //             aux_mutex,
-    //             linkno,
-    //             routing_table,
-    //             &Packet::DestinationGetLogRequest {
-    //                 destination: destination,
-    //             },
-    //             timer,
-    //         )
-    //         .await?;
-    //         match reply {
-    //             Packet::DestinationGetLogReply {
-    //                 last,
-    //                 length,
-    //                 data,
-    //             } => {
-    //                 remote_log.extend(&data[0..length as usize]);
-    //                 if last {
-    //                     return Ok(remote_log);
-    //                 }
-    //             }
-    //             _ => return Err(Error::UnexpectedReply),
-    //         }
-    //     }
-    // }
-
-    // pub async fn destination_clear_log(
-    //     aux_mutex: &Rc<Mutex<bool>>,
-    //     routing_table: &RoutingTable,
-    //     timer: GlobalTimer,
-    //     destination: u8,
-    // ) -> Result<(), Error> {
-    //     let linkno = routing_table.0[destination as usize][0] - 1;
-    //     let reply = aux_transact(
-    //         aux_mutex,
-    //         linkno,
-    //         routing_table,
-    //         &Packet::DestinationClearLogRequest {
-    //             destination: destination,
-    //         },
-    //         timer,
-    //     )
-    //     .await?;
-    //     match reply {
-    //         Packet::DestinationMgmtAck {
-    //             succeeded: true,
-    //         } => Ok(()),
-    //         Packet::DestinationMgmtAck {
-    //             succeeded: false,
-    //         } => return Err(Error::ClearLogFail(destination)),
-    //         _ => Err(Error::UnexpectedReply),
-    //     }
-    // }
-
-    // pub async fn destination_pull_log(
-    //     aux_mutex: &Rc<Mutex<bool>>,
-    //     routing_table: &RoutingTable,
-    //     timer: GlobalTimer,
-    //     destination: u8,
-    // ) -> Result<Vec<u8>, Error> {
-    //     let linkno = routing_table.0[destination as usize][0] - 1;
-    //     let mut remote_log: Vec<u8> = Vec::new();
-    //     loop {
-    //         let reply = aux_transact(
-    //             aux_mutex,
-    //             linkno,
-    //             routing_table,
-    //             &Packet::DestinationPullLogRequest {
-    //                 destination: destination,
-    //             },
-    //             timer,
-    //         )
-    //         .await?;
-    //         match reply {
-    //             Packet::DestinationPullLogReply {
-    //                 destination: 0,
-    //                 last,
-    //                 length,
-    //                 data,
-    //             } => {
-    //                 remote_log.extend(&data[0..length as usize]);
-    //                 if last {
-    //                     return Ok(remote_log);
-    //                 }
-    //             }
-    //             _ => return Err(Error::UnexpectedReply),
-    //         }
-    //     }
-    // }
-
-    // pub async fn destination_set_log_level(
-    //     aux_mutex: &Rc<Mutex<bool>>,
-    //     routing_table: &RoutingTable,
-    //     timer: GlobalTimer,
-    //     destination: u8,
-    //     log_level: log::LevelFilter,
-    // ) -> Result<(), Error> {
-    //     let linkno = routing_table.0[destination as usize][0] - 1;
-    //     let reply = aux_transact(
-    //         aux_mutex,
-    //         linkno,
-    //         routing_table,
-    //         &Packet::DestinationSetLogLevelRequest {
-    //             destination: destination,
-    //             log_level: log_level as u8,
-    //         },
-    //         timer,
-    //     )
-    //     .await?;
-    //     match reply {
-    //         Packet::DestinationMgmtAck {
-    //             succeeded: true,
-    //         } => Ok(()),
-    //         Packet::DestinationMgmtAck {
-    //             succeeded: false,
-    //         } => return Err(Error::SetLogLevelFail(destination)),
-    //         _ => Err(Error::UnexpectedReply),
-    //     }
-    // }
-
-    // pub async fn destination_set_uart_log_level(
-    //     aux_mutex: &Rc<Mutex<bool>>,
-    //     routing_table: &RoutingTable,
-    //     timer: GlobalTimer,
-    //     destination: u8,
-    //     log_level: log::LevelFilter,
-    // ) -> Result<(), Error> {
-    //     let linkno = routing_table.0[destination as usize][0] - 1;
-    //     let reply = aux_transact(
-    //         aux_mutex,
-    //         linkno,
-    //         routing_table,
-    //         &Packet::DestinationSetUartLogLevelRequest {
-    //             destination: destination,
-    //             log_level: log_level as u8,
-    //         },
-    //         timer,
-    //     )
-    //     .await?;
-    //     match reply {
-    //         Packet::DestinationMgmtAck {
-    //             succeeded: true,
-    //         } => Ok(()),
-    //         Packet::DestinationMgmtAck {
-    //             succeeded: false,
-    //         } => return Err(Error::SetUartLogLevelFail(destination)),
-    //         _ => Err(Error::UnexpectedReply),
-    //     }
-    // }
-
-    // pub async fn destination_read_config(
-    //     aux_mutex: &Rc<Mutex<bool>>,
-    //     routing_table: &RoutingTable,
-    //     timer: GlobalTimer,
-    //     destination: u8,
-    //     key: &[u8],
-    // ) -> Result<Vec<u8>, Error> {
-    //     let linkno = routing_table.0[destination as usize][0] - 1;
-    //     let length = key.len();
-    //     // Assume key and value can fit within a DRTIO AUX packet together
-    //     let mut key_slice: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE] = [0; CORE_MGMT_PAYLOAD_MAX_SIZE];
-    //     key_slice[..length].clone_from_slice(key);
-
-    //     let reply = aux_transact(
-    //         aux_mutex,
-    //         linkno,
-    //         routing_table,
-    //         &Packet::DestinationConfigReadRequest {
-    //             destination: destination,
-    //             length: length as u16,
-    //             key: key_slice,
-    //         },
-    //         timer,
-    //     )
-    //     .await?;
-    //     match reply {
-    //         Packet::DestinationConfigReadReply {
-    //             destination: 0,
-    //             succeeded: true,
-    //             length,
-    //             value,
-    //         } => Ok(Vec::from(&value[..length as usize])),
-    //         Packet::DestinationConfigReadReply {
-    //             destination: 0,
-    //             succeeded: false,
-    //             ..
-    //         } => Err(Error::ReadConfigFail(destination)),
-    //         _ => Err(Error::UnexpectedReply),
-    //     }
-    // }
-
-    // pub async fn destination_write_config(
-    //     aux_mutex: &Rc<Mutex<bool>>,
-    //     routing_table: &RoutingTable,
-    //     timer: GlobalTimer,
-    //     destination: u8,
-    //     key: &str,
-    //     value: &[u8],
-    // ) -> Result<(), Error> {
-    //     let linkno = routing_table.0[destination as usize][0] - 1;
-
-    //     let total_len = 4 + key.len() + 4 + value.len();
-    //     let mut payload = Cursor::new(Vec::with_capacity(total_len));
-
-    //     payload.write_string(key).unwrap();
-    //     payload.write_bytes(value).unwrap();
-    //     assert_eq!(value[value.len()-1], payload.get_ref()[total_len-1]);
-
-    //     partition_data(
-    //         linkno,
-    //         aux_mutex,
-    //         routing_table,
-    //         timer,
-    //         &payload.get_ref(),
-    //         |slice, status, len| Packet::DestinationConfigWriteRequest {
-    //             destination: destination,
-    //             length: len as u16,
-    //             last: status.is_last(),
-    //             data: *slice,
-    //         },
-    //         |reply| match reply {
-    //             Packet::DestinationMgmtAck {
-    //                 succeeded: true,
-    //             } => Ok(()),
-    //             Packet::DestinationMgmtAck {
-    //                 succeeded: false,
-    //             } => Err(Error::WriteConfigFail(destination)),
-    //             _ => Err(Error::UnexpectedReply),
-    //         },
-    //     ).await
-    // }
-
-    // pub async fn destination_remove_config(
-    //     aux_mutex: &Rc<Mutex<bool>>,
-    //     routing_table: &RoutingTable,
-    //     timer: GlobalTimer,
-    //     destination: u8,
-    //     key: &[u8],
-    // ) -> Result<(), Error> {
-    //     let linkno = routing_table.0[destination as usize][0] - 1;
-    //     let length = key.len();
-    //     let mut key_slice: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE] = [0; CORE_MGMT_PAYLOAD_MAX_SIZE];
-    //     key_slice[..length].clone_from_slice(key);
-
-    //     let reply = aux_transact(
-    //         aux_mutex,
-    //         linkno,
-    //         routing_table,
-    //         &Packet::DestinationConfigRemoveRequest {
-    //             destination: destination,
-    //             length: length as u16,
-    //             key: key_slice,
-    //         },
-    //         timer,
-    //     )
-    //     .await?;
-    //     match reply {
-    //         Packet::DestinationMgmtAck {
-    //             succeeded: true,
-    //         } => Ok(()),
-    //         Packet::DestinationMgmtAck {
-    //             succeeded: false,
-    //         } => Err(Error::RemoveConfigFail(destination)),
-    //         _ => Err(Error::UnexpectedReply),
-    //     }
-    // }
-
-    // pub async fn destination_erase_config(
-    //     aux_mutex: &Rc<Mutex<bool>>,
-    //     routing_table: &RoutingTable,
-    //     timer: GlobalTimer,
-    //     destination: u8,
-    // ) -> Result<(), Error> {
-    //     let linkno = routing_table.0[destination as usize][0] - 1;
-    //     let reply = aux_transact(
-    //         aux_mutex,
-    //         linkno,
-    //         routing_table,
-    //         &Packet::DestinationConfigEraseRequest {
-    //             destination: destination,
-    //         },
-    //         timer,
-    //     )
-    //     .await?;
-    //     match reply {
-    //         Packet::DestinationMgmtAck {
-    //             succeeded: true,
-    //         } => Ok(()),
-    //         Packet::DestinationMgmtAck {
-    //             succeeded: false,
-    //         } => Err(Error::EraseConfigFail(destination)),
-    //         _ => Err(Error::UnexpectedReply),
-    //     }
-    // }
-
-    // pub async fn destination_reboot(
-    //     aux_mutex: &Rc<Mutex<bool>>,
-    //     routing_table: &RoutingTable,
-    //     timer: GlobalTimer,
-    //     destination: u8,
-    // ) -> Result<(), Error> {
-    //     let linkno = routing_table.0[destination as usize][0] - 1;
-    //     let reply = aux_transact(
-    //         aux_mutex,
-    //         linkno,
-    //         routing_table,
-    //         &Packet::DestinationRebootRequest {
-    //             destination: destination,
-    //         },
-    //         timer,
-    //     )
-    //     .await?;
-    //     match reply {
-    //         Packet::DestinationMgmtAck {
-    //             succeeded: true,
-    //         } => Ok(()),
-    //         Packet::DestinationMgmtAck {
-    //             succeeded: false,
-    //         } => Err(Error::RebootFail(destination)),
-    //         _ => Err(Error::UnexpectedReply),
-    //     }
-    // }
-
-    // pub async fn destination_allocator_debug(
-    //     aux_mutex: &Rc<Mutex<bool>>,
-    //     routing_table: &RoutingTable,
-    //     timer: GlobalTimer,
-    //     destination: u8,
-    // ) -> Result<(), Error> {
-    //     let linkno = routing_table.0[destination as usize][0] - 1;
-    //     let reply = aux_transact(
-    //         aux_mutex,
-    //         linkno,
-    //         routing_table,
-    //         &Packet::DestinationAllocatorDebugRequest {
-    //             destination: destination,
-    //         },
-    //         timer,
-    //     )
-    //     .await?;
-    //     match reply {
-    //         Packet::DestinationMgmtAck {
-    //             succeeded: true,
-    //         } => Ok(()),
-    //         _ => Err(Error::UnexpectedReply),
-    //     }
-    // }
 }
 
 #[cfg(not(has_drtio))]
@@ -1263,36 +898,12 @@ pub mod drtio {
     pub fn reset(_aux_mutex: Rc<Mutex<bool>>, _routing_table: &RoutingTable, mut _timer: GlobalTimer) {}
 }
 
-fn toggle_sed_spread(val: u8) {
-    unsafe {
-        csr::rtio_core::sed_spread_enable_write(val);
-    }
-}
-
-fn setup_sed_spread(cfg: &Config) {
-    if let Ok(spread_enable) = cfg.read_str("sed_spread_enable") {
-        match spread_enable.as_ref() {
-            "1" => toggle_sed_spread(1),
-            "0" => toggle_sed_spread(0),
-            _ => {
-                warn!("sed_spread_enable value not supported (only 1, 0 allowed), disabling by default");
-                toggle_sed_spread(0)
-            }
-        };
-    } else {
-        info!("SED spreading disabled by default");
-        toggle_sed_spread(0);
-    }
-}
-
 pub fn startup(
     aux_mutex: &Rc<Mutex<bool>>,
     routing_table: &Rc<RefCell<RoutingTable>>,
     up_destinations: &Rc<RefCell<[bool; drtio_routing::DEST_COUNT]>>,
-    cfg: &Config,
     timer: GlobalTimer,
 ) {
-    setup_sed_spread(cfg);
     drtio::startup(aux_mutex, routing_table, up_destinations, timer);
     unsafe {
         csr::rtio_core::reset_phy_write(1);

src/satman/Cargo.toml.tpl

@@ -14,11 +14,8 @@ default = ["target_zc706", ]
 build_zynq = { path = "../libbuild_zynq" }
 
 [dependencies]
-num-traits = { version = "0.2", default-features = false }
-num-derive = "0.3"
 log = { version = "0.4", default-features = false }
 core_io = { version = "0.1", features = ["collections"] }
-byteorder = { version = "1.3", default-features = false }
 cslice = "0.3"
 embedded-hal = "0.2"
 

src/satman/src/main.rs

@@ -5,17 +5,13 @@
 #[macro_use]
 extern crate log;
 extern crate core_io;
-extern crate byteorder;
 extern crate cslice;
 extern crate embedded_hal;
-extern crate num_derive;
-extern crate num_traits;
 
 extern crate io;
 extern crate ksupport;
 extern crate libboard_artiq;
 extern crate libboard_zynq;
-extern crate libconfig;
 extern crate libcortex_a9;
 extern crate libregister;
 extern crate libsupport_zynq;
@@ -36,26 +32,23 @@ use libboard_artiq::si5324;
 #[cfg(has_si549)]
 use libboard_artiq::si549;
 use libboard_artiq::{drtio_routing, drtioaux,
-                     drtioaux_proto::{MASTER_PAYLOAD_MAX_SIZE, SAT_PAYLOAD_MAX_SIZE, CORE_MGMT_PAYLOAD_MAX_SIZE},
+                     drtioaux_proto::{MASTER_PAYLOAD_MAX_SIZE, SAT_PAYLOAD_MAX_SIZE},
                      identifier_read, logger,
                      pl::csr};
 #[cfg(feature = "target_kasli_soc")]
 use libboard_zynq::error_led::ErrorLED;
-use libboard_zynq::{i2c::I2c, print, println, slcr, time::Milliseconds, timer::GlobalTimer};
+use libboard_zynq::{i2c::I2c, print, println, time::Milliseconds, timer::GlobalTimer};
-use libconfig::Config;
 use libcortex_a9::{l2c::enable_l2_cache, regs::MPIDR};
 use libregister::RegisterR;
 use libsupport_zynq::{exception_vectors, ram};
 use routing::Router;
 use subkernel::Manager as KernelManager;
-use mgmt::Manager as CoreManager;
 
 mod analyzer;
 mod dma;
 mod repeater;
 mod routing;
 mod subkernel;
-mod mgmt;
 
 // linker symbols
 extern "C" {
@@ -88,37 +81,15 @@ fn drtiosat_tsc_loaded() -> bool {
     }
 }
 
-fn toggle_sed_spread(val: u8) {
-    unsafe {
-        csr::drtiosat::sed_spread_enable_write(val);
-    }
-}
-
 #[cfg(has_drtio_routing)]
 macro_rules! forward {
-    (
+    ($routing_table:expr, $destination:expr, $rank:expr, $repeaters:expr, $packet:expr, $timer:expr) => {{
-        $router:expr,
-        $routing_table:expr,
-        $destination:expr,
-        $rank:expr,
-        $self_destination:expr,
-        $repeaters:expr,
-        $packet:expr,
-        $timer:expr
-    ) => {{
         let hop = $routing_table.0[$destination as usize][$rank as usize];
         if hop != 0 {
             let repno = (hop - 1) as usize;
             if repno < $repeaters.len() {
                 if $packet.expects_response() {
-                    return $repeaters[repno].aux_forward(
+                    return $repeaters[repno].aux_forward($packet, $timer);
-                        $packet,
-                        $router,
-                        $routing_table,
-                        $rank,
-                        $self_destination,
-                        $timer,
-                    );
                 } else {
                     return $repeaters[repno].aux_send($packet);
                 }
@@ -131,16 +102,7 @@ macro_rules! forward {
 
 #[cfg(not(has_drtio_routing))]
 macro_rules! forward {
-    (
+    ($routing_table:expr, $destination:expr, $rank:expr, $repeaters:expr, $packet:expr, $timer:expr) => {};
-        $router:expr,
-        $routing_table:expr,
-        $destination:expr,
-        $rank:expr,
-        $self_destination:expr,
-        $repeaters:expr,
-        $packet:expr,
-        $timer:expr
-    ) => {};
 }
 
 fn process_aux_packet(
@@ -154,7 +116,6 @@ fn process_aux_packet(
     dma_manager: &mut DmaManager,
     analyzer: &mut Analyzer,
     kernel_manager: &mut KernelManager,
-    core_manager: &mut CoreManager,
     router: &mut Router,
 ) -> Result<(), drtioaux::Error> {
     // In the code below, *_chan_sel_write takes an u8 if there are fewer than 256 channels,
@@ -222,10 +183,6 @@ fn process_aux_packet(
                             &drtioaux::Packet::DestinationStatusRequest {
                                 destination: destination,
                             },
-                            router,
-                            _routing_table,
-                            *rank,
-                            *self_destination,
                             timer,
                         ) {
                             Ok(()) => (),
@@ -287,16 +244,7 @@ fn process_aux_packet(
             channel,
             probe,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             let value;
             #[cfg(has_rtio_moninj)]
             unsafe {
@@ -318,16 +266,7 @@ fn process_aux_packet(
             overrd,
             value,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             #[cfg(has_rtio_moninj)]
             unsafe {
                 csr::rtio_moninj::inj_chan_sel_write(channel as _);
@@ -341,16 +280,7 @@ fn process_aux_packet(
             channel,
             overrd,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             let value;
             #[cfg(has_rtio_moninj)]
             unsafe {
@@ -369,16 +299,7 @@ fn process_aux_packet(
             destination: _destination,
             busno: _busno,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             let succeeded = i2c.start().is_ok();
             drtioaux::send(0, &drtioaux::Packet::I2cBasicReply { succeeded: succeeded })
         }
@@ -386,16 +307,7 @@ fn process_aux_packet(
             destination: _destination,
             busno: _busno,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             let succeeded = i2c.restart().is_ok();
             drtioaux::send(0, &drtioaux::Packet::I2cBasicReply { succeeded: succeeded })
         }
@@ -403,16 +315,7 @@ fn process_aux_packet(
             destination: _destination,
             busno: _busno,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             let succeeded = i2c.stop().is_ok();
             drtioaux::send(0, &drtioaux::Packet::I2cBasicReply { succeeded: succeeded })
         }
@@ -421,16 +324,7 @@ fn process_aux_packet(
             busno: _busno,
             data,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             match i2c.write(data) {
                 Ok(ack) => drtioaux::send(
                     0,
@@ -453,16 +347,7 @@ fn process_aux_packet(
             busno: _busno,
             ack,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             match i2c.read(ack) {
                 Ok(data) => drtioaux::send(
                     0,
@@ -486,16 +371,7 @@ fn process_aux_packet(
             address,
             mask,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             let ch = match mask {
                 //decode from mainline, PCA9548-centric API
                 0x00 => None,
@@ -521,16 +397,7 @@ fn process_aux_packet(
             div: _div,
             cs: _cs,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             // todo: reimplement when/if SPI is available
             //let succeeded = spi::set_config(busno, flags, length, div, cs).is_ok();
             drtioaux::send(0, &drtioaux::Packet::SpiBasicReply { succeeded: false })
@@ -540,16 +407,7 @@ fn process_aux_packet(
             busno: _busno,
             data: _data,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             // todo: reimplement when/if SPI is available
             //let succeeded = spi::write(busno, data).is_ok();
             drtioaux::send(0, &drtioaux::Packet::SpiBasicReply { succeeded: false })
@@ -558,16 +416,7 @@ fn process_aux_packet(
             destination: _destination,
             busno: _busno,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             // todo: reimplement when/if SPI is available
             // match spi::read(busno) {
             //     Ok(data) => drtioaux::send(0,
@@ -587,16 +436,7 @@ fn process_aux_packet(
         drtioaux::Packet::AnalyzerHeaderRequest {
             destination: _destination,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             let header = analyzer.get_header();
             drtioaux::send(
                 0,
@@ -610,16 +450,7 @@ fn process_aux_packet(
         drtioaux::Packet::AnalyzerDataRequest {
             destination: _destination,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             let mut data_slice: [u8; SAT_PAYLOAD_MAX_SIZE] = [0; SAT_PAYLOAD_MAX_SIZE];
             let meta = analyzer.get_data(&mut data_slice);
             drtioaux::send(
@@ -640,16 +471,7 @@ fn process_aux_packet(
             length,
             trace,
         } => {
-            forward!(
+            forward!(_routing_table, destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             *self_destination = destination;
             let succeeded = dma_manager.add(source, id, status, &trace, length as usize).is_ok();
             router.send(
@@ -670,16 +492,7 @@ fn process_aux_packet(
             id,
             succeeded,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             dma_manager.ack_upload(
                 kernel_manager,
                 source,
@@ -697,16 +510,7 @@ fn process_aux_packet(
             destination: _destination,
             id,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             let succeeded = dma_manager.erase(source, id).is_ok();
             router.send(
                 drtioaux::Packet::DmaRemoveTraceReply {
@@ -722,16 +526,7 @@ fn process_aux_packet(
             destination: _destination,
             succeeded: _,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             Ok(())
         }
         drtioaux::Packet::DmaPlaybackRequest {
@@ -740,16 +535,7 @@ fn process_aux_packet(
             id,
             timestamp,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             let succeeded = if !kernel_manager.running() {
                 dma_manager.playback(source, id, timestamp).is_ok()
             } else {
@@ -769,16 +555,7 @@ fn process_aux_packet(
             destination: _destination,
             succeeded,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             if !succeeded {
                 kernel_manager.ddma_nack();
             }
@@ -792,16 +569,7 @@ fn process_aux_packet(
             channel,
             timestamp,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             dma_manager.remote_finished(kernel_manager, id, error, channel, timestamp);
             Ok(())
         }
@@ -813,16 +581,7 @@ fn process_aux_packet(
             length,
             data,
         } => {
-            forward!(
+            forward!(_routing_table, destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             *self_destination = destination;
             let succeeded = kernel_manager.add(id, status, &data, length as usize).is_ok();
             drtioaux::send(0, &drtioaux::Packet::SubkernelAddDataReply { succeeded: succeeded })
@@ -833,16 +592,7 @@ fn process_aux_packet(
             id,
             run,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             let mut succeeded = kernel_manager.load(id).is_ok();
             // allow preloading a kernel with delayed run
             if run {
@@ -867,16 +617,7 @@ fn process_aux_packet(
             destination: _destination,
             succeeded,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             // received if local subkernel started another, remote subkernel
             kernel_manager.subkernel_load_run_reply(succeeded);
             Ok(())
@@ -887,73 +628,25 @@ fn process_aux_packet(
             with_exception,
             exception_src,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             kernel_manager.remote_subkernel_finished(id, with_exception, exception_src);
             Ok(())
         }
         drtioaux::Packet::SubkernelExceptionRequest {
-            source,
             destination: _destination,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
+            let mut data_slice: [u8; SAT_PAYLOAD_MAX_SIZE] = [0; SAT_PAYLOAD_MAX_SIZE];
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
-            let mut data_slice: [u8; MASTER_PAYLOAD_MAX_SIZE] = [0; MASTER_PAYLOAD_MAX_SIZE];
             let meta = kernel_manager.exception_get_slice(&mut data_slice);
-            router.send(
+            drtioaux::send(
-                drtioaux::Packet::SubkernelException {
+                0,
-                    destination: source,
+                &drtioaux::Packet::SubkernelException {
                     last: meta.status.is_last(),
                     length: meta.len,
                     data: data_slice,
                 },
-                _routing_table,
-                *rank,
-                *self_destination,
             )
         }
-        drtioaux::Packet::SubkernelException {
-            destination: _destination,
-            last,
-            length,
-            data,
-        } => {
-            forward!(
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
-            kernel_manager.received_exception(
-                &data[..length as usize],
-                last,
-                router,
-                _routing_table,
-                *rank,
-                *self_destination,
-            );
-            Ok(())
-        }
         drtioaux::Packet::SubkernelMessage {
             source,
             destination: _destination,
@@ -962,16 +655,7 @@ fn process_aux_packet(
             length,
             data,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             kernel_manager.message_handle_incoming(status, id, length as usize, &data);
             router.send(
                 drtioaux::Packet::SubkernelMessageAck { destination: source },
@@ -983,16 +667,7 @@ fn process_aux_packet(
         drtioaux::Packet::SubkernelMessageAck {
             destination: _destination,
         } => {
-            forward!(
+            forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
             if kernel_manager.message_ack_slice() {
                 let mut data_slice: [u8; MASTER_PAYLOAD_MAX_SIZE] = [0; MASTER_PAYLOAD_MAX_SIZE];
                 if let Some(meta) = kernel_manager.message_get_slice(&mut data_slice) {
@@ -1016,282 +691,6 @@ fn process_aux_packet(
             }
             Ok(())
         }
-        drtioaux::Packet::CoreMgmtGetLogRequest {
-            destination: _destination,
-        } => {
-            forward!(
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
-            let mut data_slice: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE] = [0; CORE_MGMT_PAYLOAD_MAX_SIZE];
-            let meta = core_manager.log_get_slice(&mut data_slice);
-            drtioaux::send(0,
-                &drtioaux::Packet::CoreMgmtGetLogReply {
-                    last: meta.status.is_last(),
-                    length: meta.len as u16,
-                    data: data_slice,
-                },
-            )
-        }
-        drtioaux::Packet::CoreMgmtClearLogRequest {
-            destination: _destination,
-        } => {
-            forward!(
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
-            mgmt::clear_log();
-            drtioaux::send(0, &drtioaux::Packet::CoreMgmtAck {
-                succeeded: true
-            })
-        }
-        drtioaux::Packet::CoreMgmtSetLogLevelRequest {
-            destination: _destination,
-            log_level,
-        } => {
-            forward!(
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
-            
-            match mgmt::byte_to_level_filter(log_level) {
-                Ok(level_filter) => {
-                    info!("Changing log level to {}", log_level);
-                    log::set_max_level(level_filter);
-                    drtioaux::send(0, &drtioaux::Packet::CoreMgmtAck {
-                        succeeded: true
-                    })
-                }
-                Err(_) => {
-                    error!("Unknown log level: {}", log_level);
-                    drtioaux::send(0, &drtioaux::Packet::CoreMgmtAck {
-                        succeeded: false
-                    })
-                }
-            }
-        }
-        drtioaux::Packet::CoreMgmtSetUartLogLevelRequest {
-            destination: _destination,
-            log_level,
-        } => {
-            forward!(
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
-            
-            match mgmt::byte_to_level_filter(log_level) {
-                Ok(level_filter) => {
-                    info!("Changing UART log level to {}", log_level);
-                    unsafe {
-                        logger::BufferLogger::get_logger().as_ref().unwrap().set_uart_log_level(level_filter);
-                    }
-                    drtioaux::send(0, &drtioaux::Packet::CoreMgmtAck {
-                        succeeded: true
-                    })
-                }
-                Err(_) => {
-                    error!("Unknown log level: {}", log_level);
-                    drtioaux::send(0, &drtioaux::Packet::CoreMgmtAck {
-                        succeeded: false
-                    })
-                }
-            }
-        }
-        drtioaux::Packet::CoreMgmtConfigReadRequest {
-            destination: _destination,
-            length,
-            key,
-        } => {
-            forward!(
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
-
-            let mut value_slice = [0; CORE_MGMT_PAYLOAD_MAX_SIZE];
-
-            let key_slice = &key[..length as usize];
-            if !key_slice.is_ascii() {
-                error!("invalid key");
-                drtioaux::send(0, &drtioaux::Packet::CoreMgmtConfigReadReply {
-                    succeeded: false,
-                    length: 0,
-                    last: true,
-                    value: value_slice,
-                })
-            } else {
-                let key = core::str::from_utf8(key_slice).unwrap();
-                if !core_manager.fetch_config_value(key) {
-                    warn!("read error: no such key");
-                    drtioaux::send(0, &drtioaux::Packet::CoreMgmtConfigReadReply {
-                        succeeded: false,
-                        length: 0,
-                        last: true,
-                        value: value_slice,
-                    })
-                } else {
-                    let meta = core_manager.get_config_value_slice(&mut value_slice);
-                    drtioaux::send(0,
-                        &drtioaux::Packet::CoreMgmtConfigReadReply {
-                            succeeded: true,
-                            length: meta.len as u16,
-                            last: meta.status.is_last(),
-                            value: value_slice,
-                        },
-                    )
-                }
-            }
-        }
-        drtioaux::Packet::CoreMgmtConfigReadContinue {
-            destination: _destination,
-        } => {
-            forward!(
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
-
-            let mut value_slice = [0; CORE_MGMT_PAYLOAD_MAX_SIZE];
-            let meta = core_manager.get_config_value_slice(&mut value_slice);
-            drtioaux::send(0,
-                &drtioaux::Packet::CoreMgmtConfigReadReply {
-                    succeeded: true,
-                    length: meta.len as u16,
-                    last: meta.status.is_last(),
-                    value: value_slice,
-                },
-            )
-        }
-        drtioaux::Packet::CoreMgmtConfigWriteRequest {
-            destination: _destination,
-            length,
-            last,
-            data,
-        } => {
-            forward!(
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
-
-            core_manager.add_data(&data, length as usize);
-
-            let mut succeeded = true;
-            if last {
-                if !core_manager.write_config() {
-                    succeeded = false;
-                }
-            }
-
-            drtioaux::send(0, 
-                &drtioaux::Packet::CoreMgmtAck {
-                    succeeded: succeeded,
-                },
-            )?;
-
-            Ok(())
-        }
-        drtioaux::Packet::CoreMgmtConfigRemoveRequest {
-            destination: _destination,
-            length,
-            key,
-        } => {
-            forward!(
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
-
-            let key_slice = &key[..length as usize];
-            if !key_slice.is_ascii() {
-                error!("invalid key");
-                drtioaux::send(0, &drtioaux::Packet::CoreMgmtAck {
-                    succeeded: false,
-                })
-            } else {
-                let key = core::str::from_utf8(key_slice).unwrap();
-                debug!("erase key: {}", key);
-                if core_manager.remove_config(key) {
-                    debug!("erase success");
-                    drtioaux::send(0, &drtioaux::Packet::CoreMgmtAck {
-                        succeeded: true,
-                    })
-                } else {
-                    warn!("erase failed");
-                    drtioaux::send(0, &drtioaux::Packet::CoreMgmtAck {
-                        succeeded: false,
-                    })
-                }
-            }
-        }
-        drtioaux::Packet::CoreMgmtRebootRequest {
-            destination: _destination,
-        } => {
-            info!("received reboot request");
-            forward!(
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
-
-            drtioaux::send(0, 
-                &drtioaux::Packet::CoreMgmtAck {
-                    succeeded: true,
-                },
-            )?;
-            info!("reboot imminent");
-            slcr::reboot();
-            Ok(())
-        }
 
         p => {
             warn!("received unexpected aux packet: {:?}", p);
@@ -1310,7 +709,6 @@ fn process_aux_packets(
     dma_manager: &mut DmaManager,
     analyzer: &mut Analyzer,
     kernel_manager: &mut KernelManager,
-    core_manager: &mut CoreManager,
     router: &mut Router,
 ) {
     let result = drtioaux::recv(0).and_then(|packet| {
@@ -1326,7 +724,6 @@ fn process_aux_packets(
                 dma_manager,
                 analyzer,
                 kernel_manager,
-                core_manager,
                 router,
             )
         } else {
@@ -1523,28 +920,6 @@ pub extern "C" fn main_core0() -> i32 {
     #[cfg(has_si549)]
     si549::helper_setup(&mut timer, &SI549_SETTINGS).expect("cannot initialize helper Si549");
 
-    let mut cfg = match Config::new() {
-        Ok(cfg) => cfg,
-        Err(err) => {
-            warn!("config initialization failed: {}", err);
-            Config::new_dummy()
-        }
-    };
-
-    if let Ok(spread_enable) = cfg.read_str("sed_spread_enable") {
-        match spread_enable.as_ref() {
-            "1" => toggle_sed_spread(1),
-            "0" => toggle_sed_spread(0),
-            _ => {
-                warn!("sed_spread_enable value not supported (only 1, 0 allowed), disabling by default");
-                toggle_sed_spread(0)
-            }
-        };
-    } else {
-        info!("SED spreading disabled by default");
-        toggle_sed_spread(0);
-    }
-
     #[cfg(has_drtio_routing)]
     let mut repeaters = [repeater::Repeater::default(); csr::DRTIOREP.len()];
     #[cfg(not(has_drtio_routing))]
@@ -1598,7 +973,6 @@ pub extern "C" fn main_core0() -> i32 {
         let mut dma_manager = DmaManager::new();
         let mut analyzer = Analyzer::new();
         let mut kernel_manager = KernelManager::new(&mut control);
-        let mut core_manager = CoreManager::new(&mut cfg);
 
         drtioaux::reset(0);
         drtiosat_reset(false);
@@ -1616,7 +990,6 @@ pub extern "C" fn main_core0() -> i32 {
                 &mut dma_manager,
                 &mut analyzer,
                 &mut kernel_manager,
-                &mut core_manager,
                 &mut router,
             );
             #[allow(unused_mut)]

src/satman/src/mgmt.rs

@@ -1,307 +0,0 @@
-use alloc::vec::Vec;
-
-use libboard_artiq::logger::{BufferLogger, LogBufferRef};
-use libboard_zynq::smoltcp;
-use libconfig::Config;
-use log::{self, debug, error, info, warn, LevelFilter};
-use libboard_artiq::drtioaux_proto::CORE_MGMT_PAYLOAD_MAX_SIZE;
-
-use crate::routing::{Sliceable, SliceMeta};
-use io::{Cursor, ProtoRead, ProtoWrite};
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Error {
-    NetworkError(smoltcp::Error),
-    UnknownLogLevel(u8),
-    UnexpectedPattern,
-    UnrecognizedPacket,
-}
-
-type Result<T> = core::result::Result<T, Error>;
-
-impl core::fmt::Display for Error {
-    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
-        match self {
-            &Error::NetworkError(error) => write!(f, "network error: {}", error),
-            &Error::UnknownLogLevel(lvl) => write!(f, "unknown log level {}", lvl),
-            &Error::UnexpectedPattern => write!(f, "unexpected pattern"),
-            &Error::UnrecognizedPacket => write!(f, "unrecognized packet"),
-        }
-    }
-}
-
-// impl From<smoltcp::Error> for Error {
-//     fn from(error: smoltcp::Error) -> Self {
-//         Error::NetworkError(error)
-//     }
-// }
-
-// #[derive(Debug, FromPrimitive)]
-// pub enum Request {
-//     GetLog = 1,
-//     ClearLog = 2,
-//     PullLog = 7,
-//     SetLogFilter = 3,
-//     Reboot = 5,
-//     SetUartLogFilter = 6,
-
-//     ConfigRead = 12,
-//     ConfigWrite = 13,
-//     ConfigRemove = 14,
-// }
-
-// #[repr(i8)]
-// pub enum Reply {
-//     Success = 1,
-//     LogContent = 2,
-//     RebootImminent = 3,
-//     Error = 6,
-//     ConfigData = 7,
-// }
-
-pub fn byte_to_level_filter(level_byte: u8) -> Result<log::LevelFilter> {
-    Ok(match level_byte {
-        0 => log::LevelFilter::Off,
-        1 => log::LevelFilter::Error,
-        2 => log::LevelFilter::Warn,
-        3 => log::LevelFilter::Info,
-        4 => log::LevelFilter::Debug,
-        5 => log::LevelFilter::Trace,
-        lv => return Err(Error::UnknownLogLevel(lv)),
-    })
-}
-
-fn get_logger_buffer_pred() -> LogBufferRef<'static> {
-    let logger = unsafe { BufferLogger::get_logger().as_mut().unwrap() };
-    loop {
-        if let Some(buffer_ref) = logger.buffer() {
-            return buffer_ref;
-        }
-    }
-}
-
-fn get_logger_buffer() -> LogBufferRef<'static> {
-    get_logger_buffer_pred()
-}
-
-pub fn clear_log() {
-    let mut buffer = get_logger_buffer();
-    buffer.clear();
-}
-
-// async fn read_key(stream: &mut TcpStream) -> Result<String> {
-//     let len = read_i32(stream).await?;
-//     if len <= 0 {
-//         write_i8(stream, Reply::Error as i8).await?;
-//         return Err(Error::UnexpectedPattern);
-//     }
-//     let mut buffer = Vec::with_capacity(len as usize);
-//     for _ in 0..len {
-//         buffer.push(0);
-//     }
-//     read_chunk(stream, &mut buffer).await?;
-//     if !buffer.is_ascii() {
-//         write_i8(stream, Reply::Error as i8).await?;
-//         return Err(Error::UnexpectedPattern);
-//     }
-//     Ok(String::from_utf8(buffer).unwrap())
-// }
-
-pub struct Manager<'a> {
-    cfg: &'a mut Config,
-    last_log: Sliceable,
-    current_payload: Cursor<Vec<u8>>,
-    last_value: Sliceable,
-}
-
-impl<'a> Manager<'_> {
-    pub fn new(cfg: &mut Config) -> Manager {
-        Manager {
-            cfg: cfg,
-            last_log: Sliceable::new(0, Vec::new()),
-            current_payload: Cursor::new(Vec::new()),
-            last_value: Sliceable::new(0, Vec::new()),
-        }
-    }
-
-    pub fn log_get_slice(&mut self, data_slice: &mut [u8; CORE_MGMT_PAYLOAD_MAX_SIZE]) -> SliceMeta {
-        // Populate buffer if depleted
-        if self.last_log.at_end() {
-            self.last_log.extend(get_logger_buffer().extract().as_bytes());
-        }
-
-        self.last_log.get_slice_core_mgmt(data_slice)
-    }
-
-    pub fn fetch_config_value(&mut self, key: &str) -> bool {
-        let value = self.cfg.read(&key);
-        if let Ok(value) = value {
-            debug!("got value");
-            self.last_value = Sliceable::new(0, value);
-            true
-        } else {
-            warn!("read error: no such key");
-            false
-        }
-    }
-
-    pub fn get_config_value_slice(&mut self, data_slice: &mut [u8; CORE_MGMT_PAYLOAD_MAX_SIZE]) -> SliceMeta {
-        self.last_value.get_slice_core_mgmt(data_slice)
-    }
-
-    pub fn add_data(&mut self, data: &[u8], data_len: usize) {
-        self.current_payload.write_all(&data[..data_len]).unwrap();
-    }
-
-    pub fn clear_data(&mut self) {
-        self.current_payload.get_mut().clear();
-        self.current_payload.set_position(0);
-    }
-
-    pub fn write_config(&mut self) -> bool {
-        let key = self.current_payload.read_string().unwrap();
-        let value = self.current_payload.read_bytes().unwrap();
-
-        let status = self.cfg.write(&key, value);
-        if status.is_ok() {
-            debug!("write success");
-        } else {
-            // this is an error because we do not expect write to fail
-            error!("failed to write: {:?}", status);
-        }
-
-        self.clear_data();
-        status.is_ok()
-    }
-
-    pub fn remove_config(&mut self, key: &str) -> bool {
-        debug!("erase key: {}", key);
-        let status = self.cfg.remove(&key);
-        if status.is_ok() {
-            debug!("erase success");
-        } else {
-            warn!("erase failed");
-        }
-        status.is_ok()
-    }
-}
-
-
-
-// async fn handle_connection(stream: &mut TcpStream, pull_id: Rc<RefCell<u32>>, cfg: Rc<Config>) -> Result<()> {
-//     if !expect(&stream, b"ARTIQ management\n").await? {
-//         return Err(Error::UnexpectedPattern);
-//     }
-//     stream.send_slice("e".as_bytes()).await?;
-
-//     loop {
-//         let msg = read_i8(stream).await;
-//         if let Err(smoltcp::Error::Finished) = msg {
-//             return Ok(());
-//         }
-//         let msg: Request = FromPrimitive::from_i8(msg?).ok_or(Error::UnrecognizedPacket)?;
-//         match msg {
-//             Request::GetLog => {
-//                 let buffer = get_logger_buffer().await.extract().as_bytes().to_vec();
-//                 write_i8(stream, Reply::LogContent as i8).await?;
-//                 write_chunk(stream, &buffer).await?;
-//             }
-//             Request::ClearLog => {
-//                 let mut buffer = get_logger_buffer().await;
-//                 buffer.clear();
-//                 write_i8(stream, Reply::Success as i8).await?;
-//             }
-//             Request::PullLog => {
-//                 let id = {
-//                     let mut guard = pull_id.borrow_mut();
-//                     *guard += 1;
-//                     *guard
-//                 };
-//                 loop {
-//                     let mut buffer = get_logger_buffer_pred(|b| !b.is_empty()).await;
-//                     if id != *pull_id.borrow() {
-//                         // another connection attempts to pull the log...
-//                         // abort this connection...
-//                         break;
-//                     }
-//                     let bytes = buffer.extract().as_bytes().to_vec();
-//                     buffer.clear();
-//                     core::mem::drop(buffer);
-//                     write_chunk(stream, &bytes).await?;
-//                     if log::max_level() == LevelFilter::Trace {
-//                         // temporarily discard all trace level log
-//                         let logger = unsafe { BufferLogger::get_logger().as_mut().unwrap() };
-//                         logger.set_buffer_log_level(LevelFilter::Debug);
-//                         stream.flush().await?;
-//                         logger.set_buffer_log_level(LevelFilter::Trace);
-//                     }
-//                 }
-//             }
-//             Request::SetLogFilter => {
-//                 let lvl = read_log_level_filter(stream).await?;
-//                 info!("Changing log level to {}", lvl);
-//                 log::set_max_level(lvl);
-//                 write_i8(stream, Reply::Success as i8).await?;
-//             }
-//             Request::SetUartLogFilter => {
-//                 let lvl = read_log_level_filter(stream).await?;
-//                 info!("Changing UART log level to {}", lvl);
-//                 unsafe {
-//                     BufferLogger::get_logger().as_ref().unwrap().set_uart_log_level(lvl);
-//                 }
-//                 write_i8(stream, Reply::Success as i8).await?;
-//             }
-//             Request::ConfigRead => {
-//                 let key = read_key(stream).await?;
-//                 debug!("read key: {}", key);
-//                 let value = cfg.read(&key);
-//                 if let Ok(value) = value {
-//                     debug!("got value");
-//                     write_i8(stream, Reply::ConfigData as i8).await?;
-//                     write_chunk(stream, &value).await?;
-//                 } else {
-//                     warn!("read error: no such key");
-//                     write_i8(stream, Reply::Error as i8).await?;
-//                 }
-//             }
-//             Request::ConfigWrite => {
-//                 let key = read_key(stream).await?;
-//                 debug!("write key: {}", key);
-//                 let len = read_i32(stream).await?;
-//                 let len = if len <= 0 { 0 } else { len as usize };
-//                 let mut buffer = Vec::with_capacity(len);
-//                 unsafe {
-//                     buffer.set_len(len);
-//                 }
-//                 read_chunk(stream, &mut buffer).await?;
-//                 let value = cfg.write(&key, buffer);
-//                 if value.is_ok() {
-//                     debug!("write success");
-//                     write_i8(stream, Reply::Success as i8).await?;
-//                 } else {
-//                     // this is an error because we do not expect write to fail
-//                     error!("failed to write: {:?}", value);
-//                     write_i8(stream, Reply::Error as i8).await?;
-//                 }
-//             }
-//             Request::ConfigRemove => {
-//                 let key = read_key(stream).await?;
-//                 debug!("erase key: {}", key);
-//                 let value = cfg.remove(&key);
-//                 if value.is_ok() {
-//                     debug!("erase success");
-//                     write_i8(stream, Reply::Success as i8).await?;
-//                 } else {
-//                     warn!("erase failed");
-//                     write_i8(stream, Reply::Error as i8).await?;
-//                 }
-//             }
-//             Request::Reboot => {
-//                 info!("rebooting");
-//                 write_i8(stream, Reply::RebootImminent as i8).await?;
-//                 stream.flush().await?;
-//                 slcr::reboot();
-//             }
-//         }
-//     }
-// }

src/satman/src/repeater.rs

@@ -208,37 +208,10 @@ impl Repeater {
         }
     }
 
-    pub fn aux_forward(
+    pub fn aux_forward(&self, request: &drtioaux::Packet, timer: &mut GlobalTimer) -> Result<(), drtioaux::Error> {
-        &self,
-        request: &drtioaux::Packet,
-        router: &mut Router,
-        routing_table: &drtio_routing::RoutingTable,
-        rank: u8,
-        self_destination: u8,
-        timer: &mut GlobalTimer,
-    ) -> Result<(), drtioaux::Error> {
         self.aux_send(request)?;
-        loop {
         let reply = self.recv_aux_timeout(200, timer)?;
-            match reply {
-                // async/locally requested packets to be consumed or routed
-                // these may come while a packet would be forwarded
-                drtioaux::Packet::DmaPlaybackStatus { .. }
-                | drtioaux::Packet::SubkernelFinished { .. }
-                | drtioaux::Packet::SubkernelMessage { .. }
-                | drtioaux::Packet::SubkernelMessageAck { .. }
-                | drtioaux::Packet::SubkernelLoadRunReply { .. }
-                | drtioaux::Packet::SubkernelException { .. }
-                | drtioaux::Packet::DmaAddTraceReply { .. }
-                | drtioaux::Packet::DmaPlaybackReply { .. } => {
-                    router.route(reply, routing_table, rank, self_destination);
-                }
-                _ => {
         drtioaux::send(0, &reply).unwrap();
-                    break;
-                }
-            }
-        }
         Ok(())
     }
 

src/satman/src/routing.rs

@@ -4,7 +4,7 @@ use core::cmp::min;
 #[cfg(has_drtio_routing)]
 use libboard_artiq::pl::csr;
 use libboard_artiq::{drtio_routing, drtioaux,
-                     drtioaux_proto::{PayloadStatus, MASTER_PAYLOAD_MAX_SIZE, CORE_MGMT_PAYLOAD_MAX_SIZE}};
+                     drtioaux_proto::{PayloadStatus, MASTER_PAYLOAD_MAX_SIZE, SAT_PAYLOAD_MAX_SIZE}};
 
 pub struct SliceMeta {
     pub destination: u8,
@@ -57,8 +57,8 @@ impl Sliceable {
         self.data.extend(data);
     }
 
+    get_slice_fn!(get_slice_sat, SAT_PAYLOAD_MAX_SIZE);
     get_slice_fn!(get_slice_master, MASTER_PAYLOAD_MAX_SIZE);
-    get_slice_fn!(get_slice_core_mgmt, CORE_MGMT_PAYLOAD_MAX_SIZE);
 }
 
 // Packets from downstream (further satellites) are received and routed appropriately.

src/satman/src/subkernel.rs

@@ -11,7 +11,7 @@ use io::{Cursor, ProtoWrite};
 use ksupport::{eh_artiq, kernel, rpc};
 use libboard_artiq::{drtio_routing::RoutingTable,
                      drtioaux,
-                     drtioaux_proto::{PayloadStatus, MASTER_PAYLOAD_MAX_SIZE},
+                     drtioaux_proto::{PayloadStatus, MASTER_PAYLOAD_MAX_SIZE, SAT_PAYLOAD_MAX_SIZE},
                      pl::csr};
 use libboard_zynq::{time::Milliseconds, timer::GlobalTimer};
 use libcortex_a9::sync_channel::Receiver;
@@ -47,9 +47,6 @@ enum KernelState {
     DmaAwait {
         max_time: Milliseconds,
     },
-    SubkernelRetrievingException {
-        destination: u8,
-    },
 }
 
 #[derive(Debug)]
@@ -126,11 +123,10 @@ struct MessageManager {
 struct Session {
     id: u32,
     kernel_state: KernelState,
-    last_exception: Option<Sliceable>,   // exceptions raised locally
+    last_exception: Option<Sliceable>,
-    external_exception: Option<Vec<u8>>, // exceptions from sub-subkernels
     messages: MessageManager,
     source: u8, // which destination requested running the kernel
-    subkernels_finished: Vec<(u32, Option<u8>)>,
+    subkernels_finished: Vec<u32>,
 }
 
 impl Session {
@@ -139,7 +135,6 @@ impl Session {
             id: id,
             kernel_state: KernelState::Absent,
             last_exception: None,
-            external_exception: None,
             messages: MessageManager::new(),
             source: 0,
             subkernels_finished: Vec::new(),
@@ -415,9 +410,9 @@ impl<'a> Manager<'_> {
         }
     }
 
-    pub fn exception_get_slice(&mut self, data_slice: &mut [u8; MASTER_PAYLOAD_MAX_SIZE]) -> SliceMeta {
+    pub fn exception_get_slice(&mut self, data_slice: &mut [u8; SAT_PAYLOAD_MAX_SIZE]) -> SliceMeta {
         match self.session.last_exception.as_mut() {
-            Some(exception) => exception.get_slice_master(data_slice),
+            Some(exception) => exception.get_slice_sat(data_slice),
             None => SliceMeta {
                 destination: 0,
                 len: 0,
@@ -545,7 +540,7 @@ impl<'a> Manager<'_> {
             return;
         }
 
-        match self.process_external_messages(router, routing_table, rank, destination, timer) {
+        match self.process_external_messages(timer) {
             Ok(()) => (),
             Err(Error::AwaitingMessage) => return, // kernel still waiting, do not process kernel messages
             Err(Error::KernelException(exception)) => {
@@ -601,41 +596,6 @@ impl<'a> Manager<'_> {
         }
     }
 
-    fn check_finished_kernels(
-        &mut self,
-        id: u32,
-        router: &mut Router,
-        routing_table: &RoutingTable,
-        rank: u8,
-        self_destination: u8,
-    ) {
-        for (i, (status, exception_source)) in self.session.subkernels_finished.iter().enumerate() {
-            if *status == id {
-                if exception_source.is_none() {
-                    self.control.tx.send(kernel::Message::SubkernelAwaitFinishReply);
-                    self.session.kernel_state = KernelState::Running;
-                    self.session.subkernels_finished.swap_remove(i);
-                } else {
-                    let destination = exception_source.unwrap();
-                    self.session.external_exception = Some(Vec::new());
-                    self.session.kernel_state = KernelState::SubkernelRetrievingException {
-                        destination: destination,
-                    };
-                    router.route(
-                        drtioaux::Packet::SubkernelExceptionRequest {
-                            source: self_destination,
-                            destination: destination,
-                        },
-                        &routing_table,
-                        rank,
-                        self_destination,
-                    );
-                }
-                break;
-            }
-        }
-    }
-
     pub fn subkernel_load_run_reply(&mut self, succeeded: bool) {
         if self.session.kernel_state == KernelState::SubkernelAwaitLoad {
             self.control
@@ -648,46 +608,16 @@ impl<'a> Manager<'_> {
     }
 
     pub fn remote_subkernel_finished(&mut self, id: u32, with_exception: bool, exception_source: u8) {
-        let exception_src = if with_exception { Some(exception_source) } else { None };
+        if with_exception {
-        self.session.subkernels_finished.push((id, exception_src));
+            self.kernel_stop();
-    }
+            self.last_finished = Some(SubkernelFinished {
-
+                source: self.session.source,
-    pub fn received_exception(
+                id: self.session.id,
-        &mut self,
+                with_exception: true,
-        exception_data: &[u8],
+                exception_source: exception_source,
-        last: bool,
+            })
-        router: &mut Router,
-        routing_table: &RoutingTable,
-        rank: u8,
-        self_destination: u8,
-    ) {
-        if let KernelState::SubkernelRetrievingException { destination } = self.session.kernel_state {
-            self.session
-                .external_exception
-                .as_mut()
-                .unwrap()
-                .extend_from_slice(exception_data);
-            if last {
-                self.control
-                    .tx
-                    .send(kernel::Message::SubkernelError(kernel::SubkernelStatus::Exception(
-                        self.session.external_exception.take().unwrap(),
-                    )));
-                self.session.kernel_state = KernelState::Running;
         } else {
-                /* fetch another slice */
+            self.session.subkernels_finished.push(id);
-                router.route(
-                    drtioaux::Packet::SubkernelExceptionRequest {
-                        source: self_destination,
-                        destination: destination,
-                    },
-                    routing_table,
-                    rank,
-                    self_destination,
-                );
-            }
-        } else {
-            warn!("Received unsolicited exception data");
         }
     }
 
@@ -850,35 +780,28 @@ impl<'a> Manager<'_> {
         Ok(false)
     }
 
-    fn process_external_messages(
+    fn process_external_messages(&mut self, timer: &GlobalTimer) -> Result<(), Error> {
-        &mut self,
-        router: &mut Router,
-        routing_table: &RoutingTable,
-        rank: u8,
-        self_destination: u8,
-        timer: &GlobalTimer,
-    ) -> Result<(), Error> {
         match &self.session.kernel_state {
             KernelState::MsgAwait { max_time, id, tags } => {
                 if let Some(max_time) = *max_time {
                     if timer.get_time() > max_time {
-                        self.control
+                        self.control.tx.send(kernel::Message::SubkernelMsgRecvReply {
-                            .tx
+                            status: kernel::SubkernelStatus::Timeout,
-                            .send(kernel::Message::SubkernelError(kernel::SubkernelStatus::Timeout));
+                            count: 0,
+                        });
                         self.session.kernel_state = KernelState::Running;
                         return Ok(());
                     }
                 }
                 if let Some(message) = self.session.messages.get_incoming(*id) {
-                    self.control
+                    self.control.tx.send(kernel::Message::SubkernelMsgRecvReply {
-                        .tx
+                        status: kernel::SubkernelStatus::NoError,
-                        .send(kernel::Message::SubkernelMsgRecvReply { count: message.count });
+                        count: message.count,
+                    });
                     let tags = tags.clone();
                     self.session.kernel_state = KernelState::Running;
                     self.pass_message_to_kernel(&message, tags, timer)
                 } else {
-                    let id = *id;
-                    self.check_finished_kernels(id, router, routing_table, rank, self_destination);
                     Err(Error::AwaitingMessage)
                 }
             }
@@ -894,18 +817,27 @@ impl<'a> Manager<'_> {
             KernelState::SubkernelAwaitFinish { max_time, id } => {
                 if let Some(max_time) = *max_time {
                     if timer.get_time() > max_time {
-                        self.control
+                        self.control.tx.send(kernel::Message::SubkernelAwaitFinishReply {
-                            .tx
+                            status: kernel::SubkernelStatus::Timeout,
-                            .send(kernel::Message::SubkernelError(kernel::SubkernelStatus::Timeout));
+                        });
                         self.session.kernel_state = KernelState::Running;
                         return Ok(());
                     }
                 }
-                let id = *id;
+                let mut i = 0;
-                self.check_finished_kernels(id, router, routing_table, rank, self_destination);
+                for status in &self.session.subkernels_finished {
+                    if *status == *id {
+                        self.control.tx.send(kernel::Message::SubkernelAwaitFinishReply {
+                            status: kernel::SubkernelStatus::NoError,
+                        });
+                        self.session.kernel_state = KernelState::Running;
+                        self.session.subkernels_finished.swap_remove(i);
+                        break;
+                    }
+                    i += 1;
+                }
                 Ok(())
             }
-            KernelState::SubkernelRetrievingException { .. } => Err(Error::AwaitingMessage),
             KernelState::DmaAwait { max_time } | KernelState::DmaPendingAwait { max_time, .. } => {
                 if timer.get_time() > *max_time {
                     self.control.tx.send(kernel::Message::DmaAwaitRemoteReply {