forked from M-Labs/artiq-zynq
Compare commits
10 Commits
d0615bf965
...
062a17b9ed
| Author | SHA1 | Date |
|---|---|---|
 occheung
|
062a17b9ed | |
 Sebastien Bourdeauducq
|
e4d7ce114f | |
 mwojcik
|
63f4783687 | |
|
mwojcik
|
69a0b1bfb7 | |
|
Sebastien Bourdeauducq
|
f6bff80105 | |
|
Sébastien Bourdeauducq
|
57fd327ecb | |
 abdul124
|
69d5b11ebf | |
|
abdul124
|
bab938c563 | |
|
mwojcik
|
d51e5e60c3 | |
|
mwojcik
|
23857eef63 |
|
|
@ -0,0 +1,8 @@
|
|||
{
|
||||
"target": "kasli_soc",
|
||||
"variant": "bare_zynq",
|
||||
"hw_rev": "v1.1",
|
||||
"drtio_role": "standalone",
|
||||
"core_addr": "192.168.1.200",
|
||||
"peripherals": []
|
||||
}
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
{
|
||||
"target": "kasli_soc",
|
||||
"variant": "bare_zynq_master",
|
||||
"hw_rev": "v1.1",
|
||||
"drtio_role": "master",
|
||||
"core_addr": "192.168.1.200",
|
||||
"peripherals": []
|
||||
}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
{
|
||||
"target": "kasli_soc",
|
||||
"variant": "bare_zynq_sat1",
|
||||
"hw_rev": "v1.1",
|
||||
"drtio_role": "satellite",
|
||||
"peripherals": []
|
||||
}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
{
|
||||
"target": "kasli_soc",
|
||||
"variant": "bare_zynq_sat2",
|
||||
"hw_rev": "v1.1",
|
||||
"drtio_role": "satellite",
|
||||
"peripherals": []
|
||||
}
|
||||
21
flake.lock
21
flake.lock
|
|
@ -11,17 +11,16 @@
|
|||
"src-pythonparser": "src-pythonparser"
|
||||
},
|
||||
"locked": {
|
||||
"lastModified": 1720514025,
|
||||
"narHash": "sha256-eU9Lux5olHTxRCwSiApKSPEdNhrlZ2OJ9ZqSofqp9Uk=",
|
||||
"ref": "refs/heads/master",
|
||||
"rev": "7a50afd9a96be8e6510d5c952808f39f0b74202a",
|
||||
"revCount": 8887,
|
||||
"dirtyRev": "378d962edb37a7c2a94e963251822246be009b0e-dirty",
|
||||
"dirtyShortRev": "378d962ed-dirty",
|
||||
"lastModified": 1721962540,
|
||||
"narHash": "sha256-BJG4l1V7kJXBWgBkfYKq8xW8rCfc7fnjCSp5xMiGvsU=",
|
||||
"type": "git",
|
||||
"url": "https://github.com/m-labs/artiq.git"
|
||||
"url": "file:///home/occheung/artiq"
|
||||
},
|
||||
"original": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/m-labs/artiq.git"
|
||||
"url": "file:///home/occheung/artiq"
|
||||
}
|
||||
},
|
||||
"artiq-comtools": {
|
||||
|
|
@ -239,11 +238,11 @@
|
|||
]
|
||||
},
|
||||
"locked": {
|
||||
"lastModified": 1717654016,
|
||||
"narHash": "sha256-y/c0EZNDNlxb/yLy/D23X9PLoiQ8I9mXAA0zsVOy2t8=",
|
||||
"lastModified": 1720537402,
|
||||
"narHash": "sha256-ybvaQ48SVBqYVqgYmGUdefGZkni7PJ90qYQPHnFOwDs=",
|
||||
"ref": "refs/heads/master",
|
||||
"rev": "0efbbe39fe643c03f15e29c208bff3247a987766",
|
||||
"revCount": 647,
|
||||
"rev": "b2b3e5c933cbc4b7cb14adde480d7561a3ae71ee",
|
||||
"revCount": 648,
|
||||
"type": "git",
|
||||
"url": "https://git.m-labs.hk/m-labs/zynq-rs"
|
||||
},
|
||||
|
|
|
|||
14
flake.nix
14
flake.nix
|
|
@ -1,7 +1,8 @@
|
|||
{
|
||||
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";
|
||||
|
|
@ -18,11 +19,11 @@
|
|||
|
||||
fastnumbers = pkgs.python3Packages.buildPythonPackage rec {
|
||||
pname = "fastnumbers";
|
||||
version = "2.2.1";
|
||||
version = "5.1.0";
|
||||
|
||||
src = pkgs.python3Packages.fetchPypi {
|
||||
inherit pname version;
|
||||
sha256 = "0j15i54p7nri6hkzn1wal9pxri4pgql01wgjccig6ar0v5jjbvsy";
|
||||
sha256 = "sha256-4JLTP4uVwxcaL7NOV57+DFSwKQ3X+W/6onYkN2AdkKc=";
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -109,7 +110,7 @@
|
|||
fsblTargets = ["zc702" "zc706" "zed"];
|
||||
sat_variants = [
|
||||
# kasli-soc satellite variants
|
||||
"satellite"
|
||||
"satellite" "bare_zynq_sat1" "bare_zynq_sat2"
|
||||
# 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"
|
||||
|
|
@ -126,6 +127,7 @@
|
|||
lockFile = src/Cargo.lock;
|
||||
outputHashes = {
|
||||
"tar-no-std-0.1.8" = "sha256-xm17108v4smXOqxdLvHl9CxTCJslmeogjm4Y87IXFuM=";
|
||||
"nalgebra-0.32.6" = "sha256-L/YudkVOtfGYoNQKBD7LMk/sMYgRDzPDdpGL5rO7G2I=";
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -363,6 +365,10 @@
|
|||
(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; };
|
||||
|
|
|
|||
|
|
@ -2,6 +2,15 @@
|
|||
# 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"
|
||||
|
|
@ -246,6 +255,7 @@ dependencies = [
|
|||
"libsupport_zynq",
|
||||
"log",
|
||||
"log_buffer",
|
||||
"nalgebra",
|
||||
"nb 0.1.3",
|
||||
"unwind",
|
||||
"vcell",
|
||||
|
|
@ -382,6 +392,19 @@ 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"
|
||||
|
|
@ -397,6 +420,15 @@ 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"
|
||||
|
|
@ -408,6 +440,26 @@ 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"
|
||||
|
|
@ -415,8 +467,15 @@ 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"
|
||||
|
|
@ -500,6 +559,7 @@ name = "satman"
|
|||
version = "0.0.0"
|
||||
dependencies = [
|
||||
"build_zynq",
|
||||
"byteorder",
|
||||
"core_io",
|
||||
"cslice",
|
||||
"embedded-hal",
|
||||
|
|
@ -514,6 +574,8 @@ dependencies = [
|
|||
"libregister",
|
||||
"libsupport_zynq",
|
||||
"log",
|
||||
"num-derive",
|
||||
"num-traits",
|
||||
"unwind",
|
||||
]
|
||||
|
||||
|
|
@ -523,6 +585,18 @@ 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"
|
||||
|
|
@ -555,6 +629,12 @@ 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"
|
||||
|
|
|
|||
|
|
@ -560,7 +560,10 @@ class GenericSatellite(SoCCore):
|
|||
self.submodules.local_io = SyncRTIO(
|
||||
self.rtio_tsc, self.rtio_channels, lane_count=description["sed_lanes"]
|
||||
)
|
||||
self.comb += self.drtiosat.async_errors.eq(self.local_io.async_errors)
|
||||
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],
|
||||
|
|
|
|||
|
|
@ -487,6 +487,10 @@ 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,
|
||||
|
|
|
|||
|
|
@ -8,6 +8,11 @@ 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 {
|
||||
|
|
@ -267,12 +272,14 @@ pub enum Packet {
|
|||
exception_src: u8,
|
||||
},
|
||||
SubkernelExceptionRequest {
|
||||
source: u8,
|
||||
destination: u8,
|
||||
},
|
||||
SubkernelException {
|
||||
destination: u8,
|
||||
last: bool,
|
||||
length: u16,
|
||||
data: [u8; SAT_PAYLOAD_MAX_SIZE],
|
||||
data: [u8; MASTER_PAYLOAD_MAX_SIZE],
|
||||
},
|
||||
SubkernelMessage {
|
||||
source: u8,
|
||||
|
|
@ -285,6 +292,72 @@ 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 {
|
||||
|
|
@ -524,14 +597,17 @@ 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; SAT_PAYLOAD_MAX_SIZE] = [0; SAT_PAYLOAD_MAX_SIZE];
|
||||
let mut data: [u8; MASTER_PAYLOAD_MAX_SIZE] = [0; MASTER_PAYLOAD_MAX_SIZE];
|
||||
reader.read_exact(&mut data[0..length as usize])?;
|
||||
Packet::SubkernelException {
|
||||
destination: destination,
|
||||
last: last,
|
||||
length: length,
|
||||
data: data,
|
||||
|
|
@ -558,6 +634,111 @@ 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)),
|
||||
})
|
||||
}
|
||||
|
|
@ -896,12 +1077,19 @@ impl Packet {
|
|||
writer.write_bool(with_exception)?;
|
||||
writer.write_u8(exception_src)?;
|
||||
}
|
||||
Packet::SubkernelExceptionRequest { destination } => {
|
||||
Packet::SubkernelExceptionRequest { source, destination } => {
|
||||
writer.write_u8(0xc9)?;
|
||||
writer.write_u8(source)?;
|
||||
writer.write_u8(destination)?;
|
||||
}
|
||||
Packet::SubkernelException { last, length, data } => {
|
||||
Packet::SubkernelException {
|
||||
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])?;
|
||||
|
|
@ -926,6 +1114,87 @@ 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(())
|
||||
}
|
||||
|
|
@ -943,6 +1212,8 @@ 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,
|
||||
|
|
|
|||
|
|
@ -32,3 +32,9 @@ 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"]
|
||||
|
|
|
|||
|
|
@ -14,8 +14,10 @@
|
|||
|
||||
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;
|
||||
|
|
@ -295,6 +297,60 @@ 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);
|
||||
|
|
|
|||
|
|
@ -1,9 +1,10 @@
|
|||
use alloc::vec;
|
||||
use core::{ffi::VaList, ptr, str};
|
||||
use core::{ffi::VaList, ptr, slice, 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;
|
||||
|
|
@ -38,6 +39,26 @@ 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; }
|
||||
|
|
@ -319,6 +340,10 @@ 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)
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@ pub enum SubkernelStatus {
|
|||
Timeout,
|
||||
IncorrectState,
|
||||
CommLost,
|
||||
Exception(Vec<u8>),
|
||||
OtherError,
|
||||
}
|
||||
|
||||
|
|
@ -90,9 +91,7 @@ pub enum Message {
|
|||
timeout: i64,
|
||||
},
|
||||
#[cfg(has_drtio)]
|
||||
SubkernelAwaitFinishReply {
|
||||
status: SubkernelStatus,
|
||||
},
|
||||
SubkernelAwaitFinishReply,
|
||||
#[cfg(has_drtio)]
|
||||
SubkernelMsgSend {
|
||||
id: u32,
|
||||
|
|
@ -109,9 +108,10 @@ 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);
|
||||
|
|
|
|||
|
|
@ -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, rpc::send_args};
|
||||
use crate::{artiq_raise, eh_artiq, rpc::send_args};
|
||||
|
||||
pub extern "C" fn load_run(id: u32, destination: u8, run: bool) {
|
||||
unsafe {
|
||||
|
|
@ -36,21 +36,18 @@ pub extern "C" fn await_finish(id: u32, timeout: i64) {
|
|||
});
|
||||
}
|
||||
match unsafe { KERNEL_CHANNEL_0TO1.as_mut().unwrap() }.recv() {
|
||||
Message::SubkernelAwaitFinishReply {
|
||||
status: SubkernelStatus::NoError,
|
||||
} => (),
|
||||
Message::SubkernelAwaitFinishReply {
|
||||
status: SubkernelStatus::IncorrectState,
|
||||
} => artiq_raise!("SubkernelError", "Subkernel not running"),
|
||||
Message::SubkernelAwaitFinishReply {
|
||||
status: SubkernelStatus::Timeout,
|
||||
} => artiq_raise!("SubkernelError", "Subkernel timed out"),
|
||||
Message::SubkernelAwaitFinishReply {
|
||||
status: SubkernelStatus::CommLost,
|
||||
} => artiq_raise!("SubkernelError", "Lost communication with satellite"),
|
||||
Message::SubkernelAwaitFinishReply {
|
||||
status: SubkernelStatus::OtherError,
|
||||
} => artiq_raise!("SubkernelError", "An error occurred during subkernel operation"),
|
||||
Message::SubkernelAwaitFinishReply => (),
|
||||
Message::SubkernelError(SubkernelStatus::IncorrectState) => {
|
||||
artiq_raise!("SubkernelError", "Subkernel not running")
|
||||
}
|
||||
Message::SubkernelError(SubkernelStatus::Timeout) => artiq_raise!("SubkernelError", "Subkernel timed out"),
|
||||
Message::SubkernelError(SubkernelStatus::CommLost) => {
|
||||
artiq_raise!("SubkernelError", "Lost communication with satellite")
|
||||
}
|
||||
Message::SubkernelError(SubkernelStatus::OtherError) => {
|
||||
artiq_raise!("SubkernelError", "An error occurred during subkernel operation")
|
||||
}
|
||||
Message::SubkernelError(SubkernelStatus::Exception(raw_exception)) => eh_artiq::raise_raw(&raw_exception),
|
||||
_ => panic!("expected SubkernelAwaitFinishReply after SubkernelAwaitFinishRequest"),
|
||||
}
|
||||
}
|
||||
|
|
@ -92,30 +89,22 @@ 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 {
|
||||
status: SubkernelStatus::NoError,
|
||||
count,
|
||||
} => {
|
||||
Message::SubkernelMsgRecvReply { count } => {
|
||||
if min > count || count > max {
|
||||
artiq_raise!("SubkernelError", "Received more or less arguments than required")
|
||||
}
|
||||
}
|
||||
Message::SubkernelMsgRecvReply {
|
||||
status: SubkernelStatus::IncorrectState,
|
||||
..
|
||||
} => artiq_raise!("SubkernelError", "Subkernel not running"),
|
||||
Message::SubkernelMsgRecvReply {
|
||||
status: SubkernelStatus::Timeout,
|
||||
..
|
||||
} => artiq_raise!("SubkernelError", "Subkernel timed out"),
|
||||
Message::SubkernelMsgRecvReply {
|
||||
status: SubkernelStatus::CommLost,
|
||||
..
|
||||
} => artiq_raise!("SubkernelError", "Lost communication with satellite"),
|
||||
Message::SubkernelMsgRecvReply {
|
||||
status: SubkernelStatus::OtherError,
|
||||
..
|
||||
} => artiq_raise!("SubkernelError", "An error occurred during subkernel operation"),
|
||||
Message::SubkernelError(SubkernelStatus::IncorrectState) => {
|
||||
artiq_raise!("SubkernelError", "Subkernel not running")
|
||||
}
|
||||
Message::SubkernelError(SubkernelStatus::Timeout) => artiq_raise!("SubkernelError", "Subkernel timed out"),
|
||||
Message::SubkernelError(SubkernelStatus::CommLost) => {
|
||||
artiq_raise!("SubkernelError", "Lost communication with satellite")
|
||||
}
|
||||
Message::SubkernelError(SubkernelStatus::OtherError) => {
|
||||
artiq_raise!("SubkernelError", "An error occurred during subkernel operation")
|
||||
}
|
||||
Message::SubkernelError(SubkernelStatus::Exception(raw_exception)) => eh_artiq::raise_raw(&raw_exception),
|
||||
_ => panic!("expected SubkernelMsgRecvReply after SubkernelMsgRecvRequest"),
|
||||
}
|
||||
// RpcRecvRequest should be called after this to receive message data
|
||||
|
|
|
|||
|
|
@ -422,33 +422,23 @@ 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 status = match res {
|
||||
Ok(ref res) => {
|
||||
let response = match res {
|
||||
Ok(res) => {
|
||||
if res.status == subkernel::FinishStatus::CommLost {
|
||||
kernel::SubkernelStatus::CommLost
|
||||
} else if let Some(exception) = &res.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
|
||||
kernel::Message::SubkernelError(kernel::SubkernelStatus::CommLost)
|
||||
} else if let Some(exception) = res.exception {
|
||||
kernel::Message::SubkernelError(kernel::SubkernelStatus::Exception(exception))
|
||||
} else {
|
||||
kernel::SubkernelStatus::NoError
|
||||
kernel::Message::SubkernelAwaitFinishReply
|
||||
}
|
||||
}
|
||||
Err(SubkernelError::Timeout) => kernel::SubkernelStatus::Timeout,
|
||||
Err(SubkernelError::IncorrectState) => kernel::SubkernelStatus::IncorrectState,
|
||||
Err(_) => kernel::SubkernelStatus::OtherError,
|
||||
Err(SubkernelError::Timeout) => kernel::Message::SubkernelError(kernel::SubkernelStatus::Timeout),
|
||||
Err(SubkernelError::IncorrectState) => {
|
||||
kernel::Message::SubkernelError(kernel::SubkernelStatus::IncorrectState)
|
||||
}
|
||||
Err(_) => kernel::Message::SubkernelError(kernel::SubkernelStatus::OtherError),
|
||||
};
|
||||
control
|
||||
.borrow_mut()
|
||||
.tx
|
||||
.async_send(kernel::Message::SubkernelAwaitFinishReply { status: status })
|
||||
.await;
|
||||
control.borrow_mut().tx.async_send(response).await;
|
||||
}
|
||||
#[cfg(has_drtio)]
|
||||
kernel::Message::SubkernelMsgSend { id, destination, data } => {
|
||||
|
|
@ -469,35 +459,23 @@ 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 (status, count) = match message_received {
|
||||
Ok(ref message) => (kernel::SubkernelStatus::NoError, message.count),
|
||||
Err(SubkernelError::Timeout) => (kernel::SubkernelStatus::Timeout, 0),
|
||||
Err(SubkernelError::IncorrectState) => (kernel::SubkernelStatus::IncorrectState, 0),
|
||||
Err(SubkernelError::CommLost) => (kernel::SubkernelStatus::CommLost, 0),
|
||||
let response = match message_received {
|
||||
Ok(ref message) => kernel::Message::SubkernelMsgRecvReply { count: message.count },
|
||||
Err(SubkernelError::Timeout) => kernel::Message::SubkernelError(kernel::SubkernelStatus::Timeout),
|
||||
Err(SubkernelError::IncorrectState) => {
|
||||
kernel::Message::SubkernelError(kernel::SubkernelStatus::IncorrectState)
|
||||
}
|
||||
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();
|
||||
match stream {
|
||||
None => (),
|
||||
Some(stream) => {
|
||||
write_chunk(stream, &status.exception.unwrap()).await?;
|
||||
kernel::Message::SubkernelError(kernel::SubkernelStatus::Exception(status.exception.unwrap()))
|
||||
}
|
||||
}
|
||||
(kernel::SubkernelStatus::OtherError, 0)
|
||||
}
|
||||
Err(_) => (kernel::SubkernelStatus::OtherError, 0),
|
||||
Err(_) => kernel::Message::SubkernelError(kernel::SubkernelStatus::OtherError),
|
||||
};
|
||||
control
|
||||
.borrow_mut()
|
||||
.tx
|
||||
.async_send(kernel::Message::SubkernelMsgRecvReply {
|
||||
status: status,
|
||||
count: count,
|
||||
})
|
||||
.await;
|
||||
control.borrow_mut().tx.async_send(response).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);
|
||||
|
|
@ -529,7 +507,7 @@ async fn handle_run_kernel(
|
|||
.async_send(kernel::Message::RpcRecvReply(Ok(0)))
|
||||
.await;
|
||||
i += 1;
|
||||
if i < count {
|
||||
if i < message.count {
|
||||
current_tags = remaining_tags;
|
||||
} else {
|
||||
break;
|
||||
|
|
@ -771,7 +749,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, timer);
|
||||
rtio_mgt::startup(&aux_mutex, &drtio_routing_table, &up_destinations, &cfg, timer);
|
||||
ksupport::setup_device_map(&cfg);
|
||||
|
||||
analyzer::start(&aux_mutex, &drtio_routing_table, &up_destinations, timer);
|
||||
|
|
@ -805,7 +783,7 @@ pub fn main(timer: GlobalTimer, cfg: Config) {
|
|||
}
|
||||
}
|
||||
|
||||
mgmt::start(cfg);
|
||||
mgmt::start(cfg, &aux_mutex, &drtio_routing_table, timer);
|
||||
|
||||
task::spawn(async move {
|
||||
let connection = Rc::new(Semaphore::new(1, 1));
|
||||
|
|
@ -908,7 +886,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
|
||||
|
|
|
|||
|
|
@ -3,14 +3,16 @@ use core::cell::RefCell;
|
|||
|
||||
use futures::{future::poll_fn, task::Poll};
|
||||
use libasync::{smoltcp::TcpStream, task};
|
||||
use libboard_artiq::logger::{BufferLogger, LogBufferRef};
|
||||
use libboard_zynq::{slcr, smoltcp};
|
||||
use libboard_artiq::{logger::{BufferLogger, LogBufferRef}, drtio_routing, drtio_routing::RoutingTable};
|
||||
use libboard_zynq::{slcr, smoltcp, timer::GlobalTimer};
|
||||
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 {
|
||||
|
|
@ -18,6 +20,11 @@ pub enum Error {
|
|||
UnknownLogLevel(u8),
|
||||
UnexpectedPattern,
|
||||
UnrecognizedPacket,
|
||||
ReadConfigFail,
|
||||
WriteConfigFail,
|
||||
RemoveConfigFail,
|
||||
#[cfg(has_drtio)]
|
||||
DrtioError(drtio::Error),
|
||||
}
|
||||
|
||||
type Result<T> = core::result::Result<T, Error>;
|
||||
|
|
@ -29,6 +36,11 @@ 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),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -39,6 +51,13 @@ 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,
|
||||
|
|
@ -62,18 +81,24 @@ pub enum Reply {
|
|||
ConfigData = 7,
|
||||
}
|
||||
|
||||
async fn read_log_level_filter(stream: &mut TcpStream) -> Result<log::LevelFilter> {
|
||||
Ok(match read_i8(stream).await? {
|
||||
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 as u8)),
|
||||
lv => return Err(Error::UnknownLogLevel(lv)),
|
||||
})
|
||||
}
|
||||
|
||||
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| {
|
||||
|
|
@ -111,30 +136,21 @@ async fn read_key(stream: &mut TcpStream) -> Result<String> {
|
|||
Ok(String::from_utf8(buffer).unwrap())
|
||||
}
|
||||
|
||||
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?;
|
||||
mod local_coremgmt {
|
||||
use super::*;
|
||||
|
||||
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 => {
|
||||
pub async fn get_log() -> Result<Vec<u8>> {
|
||||
let buffer = get_logger_buffer().await.extract().as_bytes().to_vec();
|
||||
write_i8(stream, Reply::LogContent as i8).await?;
|
||||
write_chunk(stream, &buffer).await?;
|
||||
Ok(buffer)
|
||||
}
|
||||
Request::ClearLog => {
|
||||
|
||||
pub async fn clear_log() -> Result<()> {
|
||||
let mut buffer = get_logger_buffer().await;
|
||||
buffer.clear();
|
||||
write_i8(stream, Reply::Success as i8).await?;
|
||||
Ok(())
|
||||
}
|
||||
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;
|
||||
|
|
@ -159,34 +175,464 @@ async fn handle_connection(stream: &mut TcpStream, pull_id: Rc<RefCell<u32>>, cf
|
|||
logger.set_buffer_log_level(LevelFilter::Trace);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
Request::SetLogFilter => {
|
||||
let lvl = read_log_level_filter(stream).await?;
|
||||
|
||||
pub async fn set_log_filter(lvl: LevelFilter) -> Result<()> {
|
||||
info!("Changing log level to {}", lvl);
|
||||
log::set_max_level(lvl);
|
||||
write_i8(stream, Reply::Success as i8).await?;
|
||||
Ok(())
|
||||
}
|
||||
Request::SetUartLogFilter => {
|
||||
let lvl = read_log_level_filter(stream).await?;
|
||||
|
||||
pub async fn set_uart_log_filter(lvl: LevelFilter) -> Result<()> {
|
||||
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?;
|
||||
Ok(())
|
||||
}
|
||||
Request::ConfigRead => {
|
||||
let key = read_key(stream).await?;
|
||||
|
||||
pub async fn config_read(cfg: &Rc<Config>, key: &String) -> Result<Vec<u8>>{
|
||||
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?;
|
||||
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!("read error: no such key");
|
||||
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) {
|
||||
Ok(value) => {
|
||||
write_i8(stream, Reply::ConfigData as i8).await?;
|
||||
write_chunk(stream, &value).await?;
|
||||
}
|
||||
Err(_) => {
|
||||
write_i8(stream, Reply::Error as i8).await?;
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
Request::ConfigWrite => {
|
||||
let key = read_key(stream).await?;
|
||||
debug!("write key: {}", key);
|
||||
|
|
@ -197,39 +643,55 @@ async fn handle_connection(stream: &mut TcpStream, pull_id: Rc<RefCell<u32>>, cf
|
|||
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?;
|
||||
}
|
||||
match dispatch!(timer, _aux_mutex, _routing_table, destination, config_write, &cfg, &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?;
|
||||
debug!("erase key: {}", key);
|
||||
let value = cfg.remove(&key);
|
||||
let value = dispatch!(timer, _aux_mutex, _routing_table, destination, config_remove, &cfg, &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);
|
||||
|
|
@ -237,9 +699,12 @@ pub fn start(cfg: Config) {
|
|||
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 _ = handle_connection(&mut stream, pull_id, cfg)
|
||||
let routing_table = routing_table.borrow();
|
||||
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;
|
||||
|
|
|
|||
|
|
@ -3,7 +3,9 @@ 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 {
|
||||
|
|
@ -127,6 +129,8 @@ 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 {
|
||||
|
|
@ -181,10 +185,7 @@ pub mod drtio {
|
|||
|
||||
async fn drain_buffer(linkno: u8, draining_time: Milliseconds, timer: GlobalTimer) {
|
||||
let max_time = timer.get_time() + draining_time;
|
||||
loop {
|
||||
if timer.get_time() > max_time {
|
||||
return;
|
||||
}
|
||||
while timer.get_time() < max_time {
|
||||
let _ = drtioaux_async::recv(linkno).await;
|
||||
}
|
||||
}
|
||||
|
|
@ -539,7 +540,7 @@ pub mod drtio {
|
|||
}
|
||||
}
|
||||
|
||||
async fn partition_data<PacketF, HandlerF>(
|
||||
pub async fn partition_data<PacketF, HandlerF, E>(
|
||||
linkno: u8,
|
||||
aux_mutex: &Rc<Mutex<bool>>,
|
||||
routing_table: &RoutingTable,
|
||||
|
|
@ -547,10 +548,11 @@ pub mod drtio {
|
|||
data: &[u8],
|
||||
packet_f: PacketF,
|
||||
reply_handler_f: HandlerF,
|
||||
) -> Result<(), Error>
|
||||
) -> Result<(), E>
|
||||
where
|
||||
PacketF: Fn(&[u8; MASTER_PAYLOAD_MAX_SIZE], PayloadStatus, usize) -> Packet,
|
||||
HandlerF: Fn(&Packet) -> Result<(), Error>,
|
||||
HandlerF: Fn(&Packet) -> Result<(), E>,
|
||||
E: From<Error>,
|
||||
{
|
||||
let mut i = 0;
|
||||
while i < data.len() {
|
||||
|
|
@ -833,13 +835,19 @@ pub mod drtio {
|
|||
linkno,
|
||||
routing_table,
|
||||
&Packet::SubkernelExceptionRequest {
|
||||
source: 0,
|
||||
destination: destination,
|
||||
},
|
||||
timer,
|
||||
)
|
||||
.await?;
|
||||
match reply {
|
||||
Packet::SubkernelException { last, length, data } => {
|
||||
Packet::SubkernelException {
|
||||
destination: 0,
|
||||
last,
|
||||
length,
|
||||
data,
|
||||
} => {
|
||||
remote_data.extend(&data[0..length as usize]);
|
||||
if last {
|
||||
return Ok(remote_data);
|
||||
|
|
@ -880,6 +888,363 @@ 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))]
|
||||
|
|
@ -898,12 +1263,36 @@ 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);
|
||||
|
|
|
|||
|
|
@ -14,8 +14,11 @@ 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"
|
||||
|
||||
|
|
|
|||
|
|
@ -5,13 +5,17 @@
|
|||
#[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;
|
||||
|
|
@ -32,23 +36,26 @@ 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},
|
||||
drtioaux_proto::{MASTER_PAYLOAD_MAX_SIZE, SAT_PAYLOAD_MAX_SIZE, CORE_MGMT_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, time::Milliseconds, timer::GlobalTimer};
|
||||
use libboard_zynq::{i2c::I2c, print, println, slcr, 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" {
|
||||
|
|
@ -81,15 +88,37 @@ 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($packet, $timer);
|
||||
return $repeaters[repno].aux_forward(
|
||||
$packet,
|
||||
$router,
|
||||
$routing_table,
|
||||
$rank,
|
||||
$self_destination,
|
||||
$timer,
|
||||
);
|
||||
} else {
|
||||
return $repeaters[repno].aux_send($packet);
|
||||
}
|
||||
|
|
@ -102,7 +131,16 @@ 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(
|
||||
|
|
@ -116,6 +154,7 @@ 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,
|
||||
|
|
@ -183,6 +222,10 @@ fn process_aux_packet(
|
|||
&drtioaux::Packet::DestinationStatusRequest {
|
||||
destination: destination,
|
||||
},
|
||||
router,
|
||||
_routing_table,
|
||||
*rank,
|
||||
*self_destination,
|
||||
timer,
|
||||
) {
|
||||
Ok(()) => (),
|
||||
|
|
@ -244,7 +287,16 @@ fn process_aux_packet(
|
|||
channel,
|
||||
probe,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
router,
|
||||
_routing_table,
|
||||
_destination,
|
||||
*rank,
|
||||
*self_destination,
|
||||
_repeaters,
|
||||
&packet,
|
||||
timer
|
||||
);
|
||||
let value;
|
||||
#[cfg(has_rtio_moninj)]
|
||||
unsafe {
|
||||
|
|
@ -266,7 +318,16 @@ fn process_aux_packet(
|
|||
overrd,
|
||||
value,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
router,
|
||||
_routing_table,
|
||||
_destination,
|
||||
*rank,
|
||||
*self_destination,
|
||||
_repeaters,
|
||||
&packet,
|
||||
timer
|
||||
);
|
||||
#[cfg(has_rtio_moninj)]
|
||||
unsafe {
|
||||
csr::rtio_moninj::inj_chan_sel_write(channel as _);
|
||||
|
|
@ -280,7 +341,16 @@ fn process_aux_packet(
|
|||
channel,
|
||||
overrd,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
router,
|
||||
_routing_table,
|
||||
_destination,
|
||||
*rank,
|
||||
*self_destination,
|
||||
_repeaters,
|
||||
&packet,
|
||||
timer
|
||||
);
|
||||
let value;
|
||||
#[cfg(has_rtio_moninj)]
|
||||
unsafe {
|
||||
|
|
@ -299,7 +369,16 @@ fn process_aux_packet(
|
|||
destination: _destination,
|
||||
busno: _busno,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
router,
|
||||
_routing_table,
|
||||
_destination,
|
||||
*rank,
|
||||
*self_destination,
|
||||
_repeaters,
|
||||
&packet,
|
||||
timer
|
||||
);
|
||||
let succeeded = i2c.start().is_ok();
|
||||
drtioaux::send(0, &drtioaux::Packet::I2cBasicReply { succeeded: succeeded })
|
||||
}
|
||||
|
|
@ -307,7 +386,16 @@ fn process_aux_packet(
|
|||
destination: _destination,
|
||||
busno: _busno,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
router,
|
||||
_routing_table,
|
||||
_destination,
|
||||
*rank,
|
||||
*self_destination,
|
||||
_repeaters,
|
||||
&packet,
|
||||
timer
|
||||
);
|
||||
let succeeded = i2c.restart().is_ok();
|
||||
drtioaux::send(0, &drtioaux::Packet::I2cBasicReply { succeeded: succeeded })
|
||||
}
|
||||
|
|
@ -315,7 +403,16 @@ fn process_aux_packet(
|
|||
destination: _destination,
|
||||
busno: _busno,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
router,
|
||||
_routing_table,
|
||||
_destination,
|
||||
*rank,
|
||||
*self_destination,
|
||||
_repeaters,
|
||||
&packet,
|
||||
timer
|
||||
);
|
||||
let succeeded = i2c.stop().is_ok();
|
||||
drtioaux::send(0, &drtioaux::Packet::I2cBasicReply { succeeded: succeeded })
|
||||
}
|
||||
|
|
@ -324,7 +421,16 @@ fn process_aux_packet(
|
|||
busno: _busno,
|
||||
data,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
router,
|
||||
_routing_table,
|
||||
_destination,
|
||||
*rank,
|
||||
*self_destination,
|
||||
_repeaters,
|
||||
&packet,
|
||||
timer
|
||||
);
|
||||
match i2c.write(data) {
|
||||
Ok(ack) => drtioaux::send(
|
||||
0,
|
||||
|
|
@ -347,7 +453,16 @@ fn process_aux_packet(
|
|||
busno: _busno,
|
||||
ack,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
router,
|
||||
_routing_table,
|
||||
_destination,
|
||||
*rank,
|
||||
*self_destination,
|
||||
_repeaters,
|
||||
&packet,
|
||||
timer
|
||||
);
|
||||
match i2c.read(ack) {
|
||||
Ok(data) => drtioaux::send(
|
||||
0,
|
||||
|
|
@ -371,7 +486,16 @@ fn process_aux_packet(
|
|||
address,
|
||||
mask,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
router,
|
||||
_routing_table,
|
||||
_destination,
|
||||
*rank,
|
||||
*self_destination,
|
||||
_repeaters,
|
||||
&packet,
|
||||
timer
|
||||
);
|
||||
let ch = match mask {
|
||||
//decode from mainline, PCA9548-centric API
|
||||
0x00 => None,
|
||||
|
|
@ -397,7 +521,16 @@ fn process_aux_packet(
|
|||
div: _div,
|
||||
cs: _cs,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
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 })
|
||||
|
|
@ -407,7 +540,16 @@ fn process_aux_packet(
|
|||
busno: _busno,
|
||||
data: _data,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
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 })
|
||||
|
|
@ -416,7 +558,16 @@ fn process_aux_packet(
|
|||
destination: _destination,
|
||||
busno: _busno,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
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,
|
||||
|
|
@ -436,7 +587,16 @@ fn process_aux_packet(
|
|||
drtioaux::Packet::AnalyzerHeaderRequest {
|
||||
destination: _destination,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
router,
|
||||
_routing_table,
|
||||
_destination,
|
||||
*rank,
|
||||
*self_destination,
|
||||
_repeaters,
|
||||
&packet,
|
||||
timer
|
||||
);
|
||||
let header = analyzer.get_header();
|
||||
drtioaux::send(
|
||||
0,
|
||||
|
|
@ -450,7 +610,16 @@ fn process_aux_packet(
|
|||
drtioaux::Packet::AnalyzerDataRequest {
|
||||
destination: _destination,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
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(
|
||||
|
|
@ -471,7 +640,16 @@ fn process_aux_packet(
|
|||
length,
|
||||
trace,
|
||||
} => {
|
||||
forward!(_routing_table, destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
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(
|
||||
|
|
@ -492,7 +670,16 @@ fn process_aux_packet(
|
|||
id,
|
||||
succeeded,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
router,
|
||||
_routing_table,
|
||||
_destination,
|
||||
*rank,
|
||||
*self_destination,
|
||||
_repeaters,
|
||||
&packet,
|
||||
timer
|
||||
);
|
||||
dma_manager.ack_upload(
|
||||
kernel_manager,
|
||||
source,
|
||||
|
|
@ -510,7 +697,16 @@ fn process_aux_packet(
|
|||
destination: _destination,
|
||||
id,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
router,
|
||||
_routing_table,
|
||||
_destination,
|
||||
*rank,
|
||||
*self_destination,
|
||||
_repeaters,
|
||||
&packet,
|
||||
timer
|
||||
);
|
||||
let succeeded = dma_manager.erase(source, id).is_ok();
|
||||
router.send(
|
||||
drtioaux::Packet::DmaRemoveTraceReply {
|
||||
|
|
@ -526,7 +722,16 @@ fn process_aux_packet(
|
|||
destination: _destination,
|
||||
succeeded: _,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
router,
|
||||
_routing_table,
|
||||
_destination,
|
||||
*rank,
|
||||
*self_destination,
|
||||
_repeaters,
|
||||
&packet,
|
||||
timer
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
drtioaux::Packet::DmaPlaybackRequest {
|
||||
|
|
@ -535,7 +740,16 @@ fn process_aux_packet(
|
|||
id,
|
||||
timestamp,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
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 {
|
||||
|
|
@ -555,7 +769,16 @@ fn process_aux_packet(
|
|||
destination: _destination,
|
||||
succeeded,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
router,
|
||||
_routing_table,
|
||||
_destination,
|
||||
*rank,
|
||||
*self_destination,
|
||||
_repeaters,
|
||||
&packet,
|
||||
timer
|
||||
);
|
||||
if !succeeded {
|
||||
kernel_manager.ddma_nack();
|
||||
}
|
||||
|
|
@ -569,7 +792,16 @@ fn process_aux_packet(
|
|||
channel,
|
||||
timestamp,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
router,
|
||||
_routing_table,
|
||||
_destination,
|
||||
*rank,
|
||||
*self_destination,
|
||||
_repeaters,
|
||||
&packet,
|
||||
timer
|
||||
);
|
||||
dma_manager.remote_finished(kernel_manager, id, error, channel, timestamp);
|
||||
Ok(())
|
||||
}
|
||||
|
|
@ -581,7 +813,16 @@ fn process_aux_packet(
|
|||
length,
|
||||
data,
|
||||
} => {
|
||||
forward!(_routing_table, destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
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 })
|
||||
|
|
@ -592,7 +833,16 @@ fn process_aux_packet(
|
|||
id,
|
||||
run,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
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 {
|
||||
|
|
@ -617,7 +867,16 @@ fn process_aux_packet(
|
|||
destination: _destination,
|
||||
succeeded,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
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(())
|
||||
|
|
@ -628,25 +887,73 @@ fn process_aux_packet(
|
|||
with_exception,
|
||||
exception_src,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
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!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
let mut data_slice: [u8; SAT_PAYLOAD_MAX_SIZE] = [0; SAT_PAYLOAD_MAX_SIZE];
|
||||
forward!(
|
||||
router,
|
||||
_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);
|
||||
drtioaux::send(
|
||||
0,
|
||||
&drtioaux::Packet::SubkernelException {
|
||||
router.send(
|
||||
drtioaux::Packet::SubkernelException {
|
||||
destination: source,
|
||||
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,
|
||||
|
|
@ -655,7 +962,16 @@ fn process_aux_packet(
|
|||
length,
|
||||
data,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
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 },
|
||||
|
|
@ -667,7 +983,16 @@ fn process_aux_packet(
|
|||
drtioaux::Packet::SubkernelMessageAck {
|
||||
destination: _destination,
|
||||
} => {
|
||||
forward!(_routing_table, _destination, *rank, _repeaters, &packet, timer);
|
||||
forward!(
|
||||
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) {
|
||||
|
|
@ -691,6 +1016,282 @@ 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);
|
||||
|
|
@ -709,6 +1310,7 @@ 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| {
|
||||
|
|
@ -724,6 +1326,7 @@ fn process_aux_packets(
|
|||
dma_manager,
|
||||
analyzer,
|
||||
kernel_manager,
|
||||
core_manager,
|
||||
router,
|
||||
)
|
||||
} else {
|
||||
|
|
@ -920,6 +1523,28 @@ 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))]
|
||||
|
|
@ -973,6 +1598,7 @@ 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);
|
||||
|
|
@ -990,6 +1616,7 @@ pub extern "C" fn main_core0() -> i32 {
|
|||
&mut dma_manager,
|
||||
&mut analyzer,
|
||||
&mut kernel_manager,
|
||||
&mut core_manager,
|
||||
&mut router,
|
||||
);
|
||||
#[allow(unused_mut)]
|
||||
|
|
|
|||
|
|
@ -0,0 +1,307 @@
|
|||
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();
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
|
|
@ -208,10 +208,37 @@ impl Repeater {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn aux_forward(&self, request: &drtioaux::Packet, timer: &mut GlobalTimer) -> Result<(), drtioaux::Error> {
|
||||
pub fn aux_forward(
|
||||
&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(())
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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, SAT_PAYLOAD_MAX_SIZE}};
|
||||
drtioaux_proto::{PayloadStatus, MASTER_PAYLOAD_MAX_SIZE, CORE_MGMT_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.
|
||||
|
|
|
|||
|
|
@ -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, SAT_PAYLOAD_MAX_SIZE},
|
||||
drtioaux_proto::{PayloadStatus, MASTER_PAYLOAD_MAX_SIZE},
|
||||
pl::csr};
|
||||
use libboard_zynq::{time::Milliseconds, timer::GlobalTimer};
|
||||
use libcortex_a9::sync_channel::Receiver;
|
||||
|
|
@ -47,6 +47,9 @@ enum KernelState {
|
|||
DmaAwait {
|
||||
max_time: Milliseconds,
|
||||
},
|
||||
SubkernelRetrievingException {
|
||||
destination: u8,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
|
|
@ -123,10 +126,11 @@ struct MessageManager {
|
|||
struct Session {
|
||||
id: u32,
|
||||
kernel_state: KernelState,
|
||||
last_exception: Option<Sliceable>,
|
||||
last_exception: Option<Sliceable>, // exceptions raised locally
|
||||
external_exception: Option<Vec<u8>>, // exceptions from sub-subkernels
|
||||
messages: MessageManager,
|
||||
source: u8, // which destination requested running the kernel
|
||||
subkernels_finished: Vec<u32>,
|
||||
subkernels_finished: Vec<(u32, Option<u8>)>,
|
||||
}
|
||||
|
||||
impl Session {
|
||||
|
|
@ -135,6 +139,7 @@ impl Session {
|
|||
id: id,
|
||||
kernel_state: KernelState::Absent,
|
||||
last_exception: None,
|
||||
external_exception: None,
|
||||
messages: MessageManager::new(),
|
||||
source: 0,
|
||||
subkernels_finished: Vec::new(),
|
||||
|
|
@ -410,9 +415,9 @@ impl<'a> Manager<'_> {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn exception_get_slice(&mut self, data_slice: &mut [u8; SAT_PAYLOAD_MAX_SIZE]) -> SliceMeta {
|
||||
pub fn exception_get_slice(&mut self, data_slice: &mut [u8; MASTER_PAYLOAD_MAX_SIZE]) -> SliceMeta {
|
||||
match self.session.last_exception.as_mut() {
|
||||
Some(exception) => exception.get_slice_sat(data_slice),
|
||||
Some(exception) => exception.get_slice_master(data_slice),
|
||||
None => SliceMeta {
|
||||
destination: 0,
|
||||
len: 0,
|
||||
|
|
@ -540,7 +545,7 @@ impl<'a> Manager<'_> {
|
|||
return;
|
||||
}
|
||||
|
||||
match self.process_external_messages(timer) {
|
||||
match self.process_external_messages(router, routing_table, rank, destination, timer) {
|
||||
Ok(()) => (),
|
||||
Err(Error::AwaitingMessage) => return, // kernel still waiting, do not process kernel messages
|
||||
Err(Error::KernelException(exception)) => {
|
||||
|
|
@ -596,6 +601,41 @@ 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
|
||||
|
|
@ -608,16 +648,46 @@ impl<'a> Manager<'_> {
|
|||
}
|
||||
|
||||
pub fn remote_subkernel_finished(&mut self, id: u32, with_exception: bool, exception_source: u8) {
|
||||
if with_exception {
|
||||
self.kernel_stop();
|
||||
self.last_finished = Some(SubkernelFinished {
|
||||
source: self.session.source,
|
||||
id: self.session.id,
|
||||
with_exception: true,
|
||||
exception_source: exception_source,
|
||||
})
|
||||
let exception_src = if with_exception { Some(exception_source) } else { None };
|
||||
self.session.subkernels_finished.push((id, exception_src));
|
||||
}
|
||||
|
||||
pub fn received_exception(
|
||||
&mut self,
|
||||
exception_data: &[u8],
|
||||
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 {
|
||||
self.session.subkernels_finished.push(id);
|
||||
/* fetch another slice */
|
||||
router.route(
|
||||
drtioaux::Packet::SubkernelExceptionRequest {
|
||||
source: self_destination,
|
||||
destination: destination,
|
||||
},
|
||||
routing_table,
|
||||
rank,
|
||||
self_destination,
|
||||
);
|
||||
}
|
||||
} else {
|
||||
warn!("Received unsolicited exception data");
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -780,28 +850,35 @@ impl<'a> Manager<'_> {
|
|||
Ok(false)
|
||||
}
|
||||
|
||||
fn process_external_messages(&mut self, timer: &GlobalTimer) -> Result<(), Error> {
|
||||
fn process_external_messages(
|
||||
&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.tx.send(kernel::Message::SubkernelMsgRecvReply {
|
||||
status: kernel::SubkernelStatus::Timeout,
|
||||
count: 0,
|
||||
});
|
||||
self.control
|
||||
.tx
|
||||
.send(kernel::Message::SubkernelError(kernel::SubkernelStatus::Timeout));
|
||||
self.session.kernel_state = KernelState::Running;
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
if let Some(message) = self.session.messages.get_incoming(*id) {
|
||||
self.control.tx.send(kernel::Message::SubkernelMsgRecvReply {
|
||||
status: kernel::SubkernelStatus::NoError,
|
||||
count: message.count,
|
||||
});
|
||||
self.control
|
||||
.tx
|
||||
.send(kernel::Message::SubkernelMsgRecvReply { 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)
|
||||
}
|
||||
}
|
||||
|
|
@ -817,27 +894,18 @@ impl<'a> Manager<'_> {
|
|||
KernelState::SubkernelAwaitFinish { max_time, id } => {
|
||||
if let Some(max_time) = *max_time {
|
||||
if timer.get_time() > max_time {
|
||||
self.control.tx.send(kernel::Message::SubkernelAwaitFinishReply {
|
||||
status: kernel::SubkernelStatus::Timeout,
|
||||
});
|
||||
self.control
|
||||
.tx
|
||||
.send(kernel::Message::SubkernelError(kernel::SubkernelStatus::Timeout));
|
||||
self.session.kernel_state = KernelState::Running;
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
let mut i = 0;
|
||||
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;
|
||||
}
|
||||
let id = *id;
|
||||
self.check_finished_kernels(id, router, routing_table, rank, self_destination);
|
||||
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 {
|
||||
|
|
|
|||
Loading…
Reference in New Issue