occheung
/
artiq-zynq
forked from M-Labs/artiq-zynq
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

init

This commit is contained in:
occheung 2024-08-16 17:47:41 +08:00
parent e4d7ce114f
commit 062a17b9ed
15 changed files with 1898 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
bare_zynq.json Normal file
View File

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

8
bare_zynq_master.json Normal file
View File

@ -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": []
}

7
bare_zynq_sat1.json Normal file
View File

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

7
bare_zynq_sat2.json Normal file
View File

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

39
flake.lock
View File

@ -11,17 +11,16 @@
"src-pythonparser": "src-pythonparser"
},
"locked": {
"lastModified": 1722417433,
"narHash": "sha256-QEbcVdL1sUQEbMCvCUvPM8DKqwOth3gJpdiLTf4hPN8=",
"ref": "refs/heads/master",
"rev": "0623480c82c28d57e14dc4f363374758a52284d3",
"revCount": 8952,
"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": {
@ -37,11 +36,11 @@
]
},
"locked": {
"lastModified": 1720768567,
"narHash": "sha256-3VoK7o5MtHtbHLrc6Pv+eQWFtaz5Gd/YWyV5TD3c5Ss=",
"lastModified": 1717637438,
"narHash": "sha256-BXFidNm3Em8iChPGu1L0s2bY+f2yQ0VVid4MuOoTehw=",
"owner": "m-labs",
"repo": "artiq-comtools",
"rev": "f93570d8f2ed5a3cfb3e1c16ab00f2540551e994",
"rev": "78d27026efe76a13f7b4698a554f55811369ec4d",
"type": "github"
},
"original": {
@ -102,16 +101,16 @@
},
"nixpkgs": {
"locked": {
"lastModified": 1721924956,
"narHash": "sha256-Sb1jlyRO+N8jBXEX9Pg9Z1Qb8Bw9QyOgLDNMEpmjZ2M=",
"lastModified": 1720386169,
"narHash": "sha256-NGKVY4PjzwAa4upkGtAMz1npHGoRzWotlSnVlqI40mo=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "5ad6a14c6bf098e98800b091668718c336effc95",
"rev": "194846768975b7ad2c4988bdb82572c00222c0d7",
"type": "github"
},
"original": {
"owner": "NixOS",
"ref": "nixos-unstable",
"ref": "nixos-24.05",
"repo": "nixpkgs",
"type": "github"
}
@ -131,11 +130,11 @@
]
},
"locked": {
"lastModified": 1722046723,
"narHash": "sha256-G7/gHz8ORRvHd1/RIURrdcswKRPe9K0FsIYR4v5jSWo=",
"lastModified": 1720491570,
"narHash": "sha256-PHS2BcQ9kxBpu9GKlDg3uAlrX/ahQOoAiVmwGl6BjD4=",
"owner": "oxalica",
"repo": "rust-overlay",
"rev": "56baac5e6b2743d4730e664ea64f6d8a2aad0fbb",
"rev": "b970af40fdc4bd80fd764796c5f97c15e2b564eb",
"type": "github"
},
"original": {
@ -168,11 +167,11 @@
"src-migen": {
"flake": false,
"locked": {
"lastModified": 1721561053,
"narHash": "sha256-z3LRhNmKZrjr6rFD0yxtccSa/SWvFIYmb+G/D5d2Jd8=",
"lastModified": 1720332047,
"narHash": "sha256-FdYVEHVtXHrzPhBqpXOTo9uHQAtuCsDPmAPY8JrfHOY=",
"owner": "m-labs",
"repo": "migen",
"rev": "9279e8623f8433bc4f23ac51e5e2331bfe544417",
"rev": "60739a161e64630ce7ba62d1a5bac1252b66c3b9",
"type": "github"
},
"original": {

9
flake.nix
View File

@ -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";
@ -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"
@ -364,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; };

222
src/Cargo.lock generated
View File

@ -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,10 +255,10 @@ dependencies = [
"libsupport_zynq",
"log",
"log_buffer",
"nalgebra",
"nb 0.1.3",
"unwind",
"vcell",
"nalgebra",
"void",
]
@ -383,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"
@ -398,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"
@ -409,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"
@ -416,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"
@ -501,6 +559,7 @@ name = "satman"
version = "0.0.0"
dependencies = [
"build_zynq",
"byteorder",
"core_io",
"cslice",
"embedded-hal",
@ -515,6 +574,8 @@ dependencies = [
"libregister",
"libsupport_zynq",
"log",
"num-derive",
"num-traits",
"unwind",
]
@ -524,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"
@ -556,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"
@ -572,147 +651,6 @@ dependencies = [
"libc",
]
[[package]]
name = "nalgebra"
version = "0.32.6"
source = "git+https://git.m-labs.hk/M-labs/nalgebra?rev=dd00f9b#dd00f9b46046e0b931d1b470166db02fd29591be"
dependencies = [
"approx",
"matrixmultiply",
"nalgebra-macros",
"num-complex",
"num-rational",
"num-traits",
"simba",
"typenum",
]
[[package]]
name = "approx"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6"
dependencies = [
"num-traits",
]
[[package]]
name = "matrixmultiply"
version = "0.3.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7574c1cf36da4798ab73da5b215bbf444f50718207754cb522201d78d1cd0ff2"
dependencies = [
"autocfg",
"rawpointer",
]
[[package]]
name = "nalgebra-macros"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "91761aed67d03ad966ef783ae962ef9bbaca728d2dd7ceb7939ec110fffad998"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[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-rational"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d41702bd167c2df5520b384281bc111a4b5efcf7fbc4c9c222c815b07e0a6a6a"
dependencies = [
"num-bigint",
"num-integer",
"num-traits",
]
[[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",
"wide",
]
[[package]]
name = "typenum"
version = "1.17.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
[[package]]
name = "rawpointer"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
[[package]]
name = "num-bigint"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4e0d047c1062aa51e256408c560894e5251f08925980e53cf1aa5bd00eec6512"
dependencies = [
"num-integer",
"num-traits",
]
[[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 = "paste"
version = "1.0.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
[[package]]
name = "wide"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cd89cf484471f953ee84f07c0dff0ea20e9ddf976f03cabdf5dda48b221f22e7"
features = ["no_std"]
dependencies = [
"bytemuck",
"safe_arch",
]
[[package]]
name = "bytemuck"
version = "1.16.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b236fc92302c97ed75b38da1f4917b5cdda4984745740f153a5d3059e48d725e"
[[package]]
name = "safe_arch"
version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "794821e4ccb0d9f979512f9c1973480123f9bd62a90d74ab0f9426fcf8f4a529"
dependencies = [
"bytemuck",
]
[[package]]
name = "vcell"
version = "0.1.3"

257
src/libboard_artiq/src/drtioaux_proto.rs
View File

@ -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 {
@ -287,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 {
@ -563,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)),
})
}
@ -938,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(())
}

4
src/runtime/src/comms.rs
View File

@ -783,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));
@ -886,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

571
src/runtime/src/mgmt.rs
View File

@ -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;

364
src/runtime/src/rtio_mgt.rs
View File

@ -540,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,
@ -548,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() {
@ -887,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))]

3
src/satman/Cargo.toml.tpl
View File

@ -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"

292
src/satman/src/main.rs
View File

@ -5,8 +5,11 @@
#[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;
@ -33,24 +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" {
@ -149,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,
@ -1010,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);
@ -1028,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| {
@ -1043,6 +1326,7 @@ fn process_aux_packets(
dma_manager,
analyzer,
kernel_manager,
core_manager,
router,
)
} else {
@ -1239,7 +1523,7 @@ pub extern "C" fn main_core0() -> i32 {
#[cfg(has_si549)]
si549::helper_setup(&mut timer, &SI549_SETTINGS).expect("cannot initialize helper Si549");
let cfg = match Config::new() {
let mut cfg = match Config::new() {
Ok(cfg) => cfg,
Err(err) => {
warn!("config initialization failed: {}", err);
@ -1314,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);
@ -1331,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)]

307
src/satman/src/mgmt.rs Normal file
View File

@ -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();
// }
// }
// }
// }

3
src/satman/src/routing.rs
View File

@ -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}};
drtioaux_proto::{PayloadStatus, MASTER_PAYLOAD_MAX_SIZE, CORE_MGMT_PAYLOAD_MAX_SIZE}};
pub struct SliceMeta {
pub destination: u8,
@ -58,6 +58,7 @@ impl Sliceable {
}
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.