add jtag commands, reboot after burn

This commit is contained in:
bunnie 2021-08-11 06:15:04 +08:00
parent 35e7cfe89e
commit 799bb6050e
13 changed files with 1406 additions and 8 deletions

5
Cargo.lock generated
View file

@ -868,10 +868,12 @@ dependencies = [
"log-server",
"num-derive",
"num-traits",
"rkyv 0.4.3",
"susres",
"ticktimer-server",
"utralib",
"xous",
"xous-ipc",
"xous-names",
]
@ -1449,6 +1451,7 @@ dependencies = [
"aes-xous",
"blowfish",
"cipher",
"com",
"curve25519-dalek",
"digest",
"ed25519-dalek",
@ -1457,6 +1460,7 @@ dependencies = [
"graphics-server",
"hex",
"jtag",
"llio",
"locales",
"log",
"log-server",
@ -1464,6 +1468,7 @@ dependencies = [
"num-traits",
"rand_core 0.5.1",
"rkyv 0.4.3",
"rtc",
"sha2",
"spinor",
"susres",

26
services/jtag/Cargo.toml Normal file
View file

@ -0,0 +1,26 @@
[package]
name = "jtag"
version = "0.1.0"
authors = ["bunnie <bunnie@kosagi.com>"]
edition = "2018"
description = "JTAG port server"
[dependencies]
xous = { path = "../../xous-rs" }
log-server = { path = "../log-server" }
ticktimer-server = { path = "../ticktimer-server" }
xous-names = { path = "../xous-names" }
log = "0.4"
num-derive = {version = "0.3", default-features = false}
num-traits = {version = "0.2", default-features = false}
susres = {path = "../susres"}
xous-ipc = {path = "../../xous-ipc"}
rkyv = {version = "0.4.3", default-features = false, features = ["const_generics"]}
[target.'cfg(not(any(windows,unix)))'.dependencies]
utralib = { path = "../../utralib"}
[features]
hazardous-debug = []
default = ["hazardous-debug"]

25
services/jtag/src/api.rs Normal file
View file

@ -0,0 +1,25 @@
pub(crate) const SERVER_NAME_JTAG: &str = "_JTAG Server_";
#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)]
pub struct EfuseRecord {
pub key: [u8; 32],
pub user: u32,
pub cntl: u8,
}
#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)]
pub enum EfuseResult {
Success,
Failure,
}
#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)]
pub(crate) enum Opcode {
GetId,
GetDna,
EfuseFetch,
EfuseKeyBurn,
EfuseUserBurn,
EfuseCtlBurn,
WriteIr,
}

View file

@ -0,0 +1,386 @@
/// efuse API for 7-series FPGAs
///
/// There are three fuse types to burn: USER, KEY, and CNTL
///
/// USER and KEY fuses share a similar ECC structure ,and in fact, the USER fuses partially
/// share a fuse bank with the KEY.
///
/// CNTL fuses are unique in that instead of having ECC, each fuse has two copies, and are burned
/// in duplicate for reliability.
///
/// Fuses are write-once. It's also not possible within the documented command set to read out the
/// raw fuse values once burned -- they can only be implied through a set of readback calls.
/// This means the fuse life cycle looks like this:
/// * Initial, unprogrammed factory state is all 0's
/// * USER/KEY data is coded by blowing only the 1's. An ECC code must also be blown simultaneously
/// to match the final pattern of 1's for correct readout
/// * It seems that patches to fuses can be done, so long as it only involves changing 0->1 and results
/// in a valid state after ECC is factored in. This is especially true for data values striped across
/// multiple banks.
///
/// Patching support may be particularly valuable in the case that e.g. anti-rollback fusing is desired.
///
/// This API implements the following features:
/// * retrieve the current fuse state
/// * validate if a proposed state change results in a valid operation (only 0->1 including ECC mods)
/// * perform the actual burn operation
///
/// In order to represent the fusing structure more accurately, this module models the state of fuses
/// not by their logical function, but by their physical mapping into the bank. There is then a layer
/// of code that can convert the physical bank information into the logical view. Validation code thus
/// works with a set of calls that can validate bank-by-bank, which are then called by the meta-functions
/// which will implement the logical KEY/USER/CNTL requests.
///
use crate::efuse_ecc::efuse_ecc::*;
use crate::{JtagMach, JtagChain, JtagEndian, JtagLeg};
/// There are 13 banks of fuses, 12 of which (key/user) are "hamming" ECC, 1 of which (config) is "dup" ECC.
pub struct EfusePhy {
banks: [u32; 13],
key: [u8; 32],
user: u32,
cntl: u8,
}
const FUSE_BANKS: usize = 13;
const KEY_BANKS: usize = 11;
const CMD_FUSE_USER: u32 = 0b110011;
const CMD_FUSE_KEY: u32 = 0b110001;
const CMD_FUSE_CNTL: u32 = 0b110100;
impl EfusePhy {
pub fn new() -> Self {
EfusePhy {
/// bank mapping as follows:
/// 0 - config
/// 1-11 - key (11 shared with user LSB)
/// 12 - user
banks: [0; FUSE_BANKS],
key: [0; 32],
user: 0,
cntl: 0,
}
}
pub fn user(&self) -> u32 { self.user }
pub fn cntl(&self) -> u8 { self.cntl }
pub fn key(&self) -> [u8; 32] { self.key }
/// this is a TEST FUNCTION ONLY. Unfortunately, the Rust test directive does not
/// like this no_std runtime / std test environment.
pub fn bank_patch(&mut self, index: usize, data: u32) { // this is just for test routines
self.banks[index] = data;
// re-derive key bits from bank data
for i in 0..32 {
self.key[i] = ((self.banks[((i / 3) + 1) as usize] >> ((i % 3) * 8)) & 0xFF) as u8;
}
}
/// fetch the current fuse state
pub fn fetch(&mut self, jm: &mut JtagMach) {
jm.reset();
// get the KEY fuse
jm.pause(2000);
let mut ir_leg: JtagLeg = JtagLeg::new(JtagChain::IR, "cmd");
ir_leg.push_u32(CMD_FUSE_KEY, 6, JtagEndian::Little);
jm.add(ir_leg);
jm.next();
assert!(jm.get().is_some());
let mut data_leg: JtagLeg = JtagLeg::new(JtagChain::DR, "fuse");
data_leg.push_u128(0, 128, JtagEndian::Big);
data_leg.push_u128(0, 128, JtagEndian::Big);
jm.add(data_leg);
jm.next();
if let Some(mut data) = jm.get() {
let mut bank_data: u32;
for index in 0..KEY_BANKS {
if index == 0 {
// first bank is special because it's split with the user fuse
bank_data = data.pop_u32(16, JtagEndian::Little).unwrap();
self.banks[11-index] = bank_data;
} else {
bank_data = data.pop_u32(24, JtagEndian::Little).unwrap();
self.banks[11-index] = add_ecc(bank_data);
}
}
} else {
assert!(false);
}
// derive bits from bank data, to debug any bit-order issues on readout, etc.
for index in 0..32 {
self.key[index] = ((self.banks[((index / 3) + 1) as usize] >> ((index % 3) * 8)) & 0xFF) as u8;
}
jm.pause(2000);
// get the USER fuse and populate the split bank
let mut ir_leg: JtagLeg = JtagLeg::new(JtagChain::IR, "cmd");
ir_leg.push_u32(CMD_FUSE_USER, 6, JtagEndian::Little);
jm.add(ir_leg);
jm.next();
assert!(jm.get().is_some());
let mut data_leg: JtagLeg = JtagLeg::new(JtagChain::DR, "user");
data_leg.push_u32(0, 32, JtagEndian::Little);
jm.add(data_leg);
jm.next();
if let Some(mut data) = jm.get() {
let user_data: u32 = data.pop_u32(32, JtagEndian::Little).unwrap();
self.user = user_data;
self.banks[11] |= (user_data & 0xFF) << 16;
self.banks[11] = add_ecc(self.banks[11]);
self.banks[12] = add_ecc( (user_data >> 8) & 0xFF_FF_FF);
} else {
assert!(false);
}
jm.pause(2000);
// get the CNTL fuse
let mut ir_leg: JtagLeg = JtagLeg::new(JtagChain::IR, "cmd");
ir_leg.push_u32(CMD_FUSE_CNTL, 6, JtagEndian::Little);
jm.add(ir_leg);
jm.next();
assert!(jm.get().is_some());
let mut data_leg: JtagLeg = JtagLeg::new(JtagChain::DR, "cntl");
data_leg.push_u32(0, 14, JtagEndian::Little); // cntl only has 14 bits length, but only bottom 6 bits are documented
jm.add(data_leg);
jm.next();
if let Some(mut data) = jm.get() {
let cntl_data: u32 = data.pop_u32(14, JtagEndian::Little).unwrap();
self.cntl = (cntl_data & 0x3F) as u8;
self.banks[0] = cntl_data & 0x3F;
self.banks[0] |= (cntl_data & 0x3F) << 14; // ths is the redundant value, no ECC on this bank
} else {
assert!(false);
}
}
}
pub struct EfuseApi {
key: [u8; 32],
user: u32,
cntl: u8,
phy: EfusePhy,
}
impl EfuseApi {
pub fn new() -> Self {
EfuseApi {
key: [0; 32],
user: 0,
cntl: 0,
phy: EfusePhy::new(),
}
}
/// phy_ series of calls returns the current "phy" state, that is, the actual programmed state
pub fn phy_key(&self) -> [u8; 32] { self.phy.key() }
pub fn phy_user(&self) -> u32 { self.phy.user() }
pub fn phy_cntl(&self) -> u8 { self.phy.cntl() }
/// api_ series of call returns the current "api" state, which is the intended state to be programmed if not yet programmed
#[allow(dead_code)]
pub fn api_key(&self) -> [u8; 32] { self.key }
#[allow(dead_code)]
pub fn api_user(&self) -> u32 { self.user }
#[allow(dead_code)]
pub fn api_cntl(&self) -> u8 { self.cntl }
/// this is a TEST FUNCTION ONLY. Unfortunately, the Rust test directive does not
/// like this no_std runtime / std test environment.
#[allow(dead_code)]
pub fn bank_patch(&mut self, index: usize, data: u32) { self.phy.bank_patch(index, data); }
// synchronizes the API state with the hardware. Needs to be called first.
pub fn fetch(&mut self, jm: &mut JtagMach) {
self.phy.fetch(jm);
}
pub fn set_key(&mut self, new_key: [u8; 32]) {
for i in 0..32 {
self.key[i] = new_key[i];
}
}
pub fn set_user(&mut self, new_user: u32) { self.user = new_user; }
pub fn set_cntl(&mut self, new_cntl: u8) { self.cntl = new_cntl; }
pub fn is_valid(&mut self) -> bool {
let mut valid: bool = true;
// go through each bank and check if the current configuratiion only involves 0->1 flips or no change
for index in 0..KEY_BANKS {
if index == 0 {
// handle cntl special case
if ((self.phy.banks[0] & 0x3F) as u8 ^ self.cntl) & (self.phy.banks[0] & 0x3F) as u8 != 0 {
valid = false;
}
} else if index == 12 {
// handle user special case
if ((self.phy.banks[index] ^ add_ecc(self.user >> 8)) & self.phy.banks[index]) != 0 {
valid = false;
}
} else if index == 11 {
// handle user + key special case
let raw_fuse: u32 = ((self.user & 0xFF) << 16) | (self.key[31] as u32) << 8 | self.key[30] as u32;
if ((self.phy.banks[index] ^ add_ecc(raw_fuse)) & self.phy.banks[index]) != 0 {
valid = false;
}
} else {
// handle key fuses (most of the bank)
let mut raw_fuse: u32 = 0;
for i in 0..3 {
raw_fuse <<= 8;
raw_fuse |= self.key[(index-1)*3 + 2-i] as u32;
}
if ((self.phy.banks[index] ^ add_ecc(raw_fuse)) & self.phy.banks[index]) != 0 {
valid = false;
}
}
}
valid
}
fn jtag_seq(&mut self, jm: &mut JtagMach, cmds: &[(JtagChain, usize, u64, &str)] ) -> u128 {
let mut ret: u128 = 0;
for tuple in cmds.iter() {
let (chain, count, value, comment) = *tuple;
let mut leg: JtagLeg = JtagLeg::new(chain, comment);
leg.push_u128(value as u128, count, JtagEndian::Little);
jm.add(leg);
}
while jm.has_pending() {
jm.pause(200); // 200us pause before starting a new series of commands
jm.next();
if let Some(mut data) = jm.get() {
// it's safe to just pop the "max length" because pop is "best effort only"
ret = data.pop_u128(128, JtagEndian::Little).unwrap();
}
}
// only the very last sequence value is returned
ret
}
fn burn_bank(&mut self, bank: usize, ones: u32, jm: &mut JtagMach) {
if ones == 0 { // skip the bank if nothing to burn
return;
}
jm.pause(2500); // 2.5ms pause between banks
let mut bank_select: u8 = 1; // bank 0 by default (special case)
let mut word_select: u8 = 3;
if bank > 0 { // rest of banks
bank_select = (bank as u8 - 1) * 8 + 0xA1;
word_select = bank_select | 0b10;
}
let bank_fuse: [(JtagChain, usize, u64, &str); 7] = [
(JtagChain::IR, 6, 0b001100, "JSTART"),
(JtagChain::IR, 6, 0b110000, "EFUSE"),
(JtagChain::DR, 64, 0xa08a28ac00004001, "KEY_UNLOCK1"),
(JtagChain::DR, 64, 0xa08a28ac00004001, "KEY_UNLOCK2"),
(JtagChain::IR, 6, 0b110000, "EFUSE"),
(JtagChain::DR, 64, 0xa08a28ac00000000 | bank_select as u64, "KEY_BANK"),
(JtagChain::DR, 64, 0x0, "KEY_BANK_WAIT"),
];
self.jtag_seq(jm, &bank_fuse);
let mut curbit = ones;
for i in 0..32 {
if (curbit & 0x1) == 1 {
let bit_burn: [(JtagChain, usize, u64, &str); 3] = [
(JtagChain::IR, 6, 0b110000, "EFUSE"),
(JtagChain::DR, 64, (0xa08a28ac00004000 | (word_select as u64)) + ((i as u64) << 8), "KEY_BIT"),
(JtagChain::DR, 64, 0x0, "KEY_BIT_WAIT"),
];
self.jtag_seq(jm, &bit_burn);
}
curbit >>= 1;
}
self.jtag_seq(jm, &bank_fuse);
}
// burns fuses to the FPGA bank
pub fn burn(&mut self, jm: &mut JtagMach) -> bool {
const COMMIT_SEQ: [(JtagChain, usize, u64, &str); 22] =
[
(JtagChain::DR, 64, 0xff000000ff, "EFUSE_COMMIT"),
(JtagChain::IR, 6, 0b000010, "USER1"),
(JtagChain::DR, 32, 0, "USER1"),
(JtagChain::IR, 6, 0b000010, "USER1"),
(JtagChain::DR, 17, 0xF000, "USER1"),
(JtagChain::DR, 75, 0xA9, "USER1"),
(JtagChain::IR, 6, 0b100010, "USER3"),
(JtagChain::DR, 17, 0xF000, "USER3"),
(JtagChain::DR, 75, 0xA9, "USER3"),
(JtagChain::IR, 6, 0b111111, "BYPASS"),
(JtagChain::IR, 6, 0b000011, "USER2"),
(JtagChain::DR, 32, 0x0, "USER2"),
(JtagChain::IR, 6, 0b111111, "BYPASS"),
(JtagChain::IR, 6, 0b000011, "USER2"),
(JtagChain::DR, 42, 0x69, "USER2"),
(JtagChain::IR, 6, 0b111111, "BYPASS"),
(JtagChain::IR, 6, 0b000011, "USER2"),
(JtagChain::DR, 6, 0xC, "USER2"),
(JtagChain::DR, 42, 0x69, "USER2"),
(JtagChain::IR, 6, 0b111111, "BYPASS"),
(JtagChain::IR, 6, 0b000011, "USER2"),
(JtagChain::DR, 36, 0x0, "USER2"),
];
let ok: bool = true;
// first check if we're valid
if !self.is_valid() {
return false;
}
// reset the machine before doing any burning
jm.pause(2000);
jm.reset();
jm.pause(2000);
// iterate through banks, careful to make bank 0 the last
for index in (0..FUSE_BANKS).rev() {
if index == 0 {
// handle cntl special case
if ((self.phy.banks[0] & 0x3F) as u8 ^ self.cntl) != 0 {
// 1111_1100_0000_0011_1111
let new_cntl: u32 = (self.cntl as u32) | ((self.cntl as u32) << 14);
self.burn_bank(index, ((self.phy.banks[0] & 0xFC03F) ^ new_cntl) & new_cntl, jm);
}
} else if index == 12 {
// handle user special case
if (self.phy.banks[index] ^ add_ecc(self.user >> 8)) != 0 {
// compute just the 0->1's and pass that on to burn_bank
self.burn_bank(index, self.phy.banks[index] ^ add_ecc(self.user >> 8) & add_ecc(self.user >> 8), jm);
}
} else if index == 11 {
// handle user + key special case
let raw_fuse: u32 = ((self.user & 0xFF) << 16) | (self.key[31] as u32) << 8 | self.key[30] as u32;
if (self.phy.banks[index] ^ add_ecc(raw_fuse)) != 0 {
self.burn_bank(index, (self.phy.banks[index] ^ add_ecc(raw_fuse)) & add_ecc(raw_fuse), jm);
}
} else {
// handle key fuses (most of the bank)
let mut raw_fuse: u32 = 0;
for i in 0..3 {
raw_fuse <<= 8;
raw_fuse |= self.key[(index-1)*3 + 2-i] as u32;
}
if (self.phy.banks[index] ^ add_ecc(raw_fuse)) != 0 {
self.burn_bank(index, (self.phy.banks[index] ^ add_ecc(raw_fuse)) & add_ecc(raw_fuse), jm);
}
}
}
jm.pause(2000);
self.jtag_seq(jm, &COMMIT_SEQ);
jm.pause(2000);
jm.reset();
ok
}
}

View file

@ -0,0 +1,63 @@
pub mod efuse_ecc {
/// given an unprotected 24-bit data record, return
/// a number which is the data + its 6-bit ECC code
pub fn add_ecc(data: u32) -> u32 {
assert!(data & 0xFF00_0000 == 0); // if the top 8 bits are filled in, that's an error
const GENERATOR: [u32; 6] = [16_515_312, 14_911_249, 10_180_898, 5_696_068, 3_011_720, 16_777_215];
let mut code: u32 = 0;
for (i, gen) in GENERATOR.iter().enumerate() {
let mut parity: u32 = 0;
for bit in 0..24 {
parity ^= ((gen & data) >> bit) & 0x1;
}
code ^= parity << i;
}
if (code & 0x20) != 0 {
code = (!code & 0x1F) | 0x20;
}
let secded = ((((code >> 5) ^ (code >> 4) ^ (code >> 3) ^ (code >> 2) ^ (code >> 1) ^ code) & 0x1) << 5) | code;
data | secded << 24
}
}
// run with `cargo test --target x86_64-unknown-linux-gnu`
#[cfg(test)]
mod tests {
use crate::efuse_ecc::*;
#[test]
fn it_works() {
assert_eq!(2 + 2, 4);
}
#[test]
fn vectors() {
const V: [(u32, u32); 7] = [
(0x00_FFFFFD, 0x25_FFFFFD),
(0x00_00A003, 0x24_00A003),
(0x00_00A00A, 0x36_00A00A),
(0x00_00F00A, 0x1E_00F00A),
(0x00_00F00F, 0x14_00F00F),
(0x00_00B00F, 0x37_00B00F),
(0x00_C5B000, 0x2A_C5B000),
];
for i in &V {
assert_eq!(i.1, add_ecc(i.0));
}
}
#[test]
fn gen_test() {
assert_eq!(0x2708_63C1, add_ecc(0x8_63C1));
assert_eq!(0x2C02_A541, add_ecc(0x2_A541));
assert_eq!(0x00CC_ABCD, add_ecc(0xCC_ABCD));
assert_eq!(0x03C6_DEF0, add_ecc(0xC6_DEF0));
assert_eq!(0x3944_EEEE, add_ecc(0x44_EEEE));
}
}

151
services/jtag/src/lib.rs Normal file
View file

@ -0,0 +1,151 @@
#![cfg_attr(target_os = "none", no_std)]
pub mod api;
pub use api::*;
use xous::{CID, send_message, Message};
use xous_ipc::Buffer;
use num_traits::*;
#[derive(Debug)]
pub struct Jtag {
conn: CID,
}
impl Jtag {
pub fn new(xns: &xous_names::XousNames) -> Result<Self, xous::Error> {
REFCOUNT.store(REFCOUNT.load(Ordering::Relaxed) + 1, Ordering::Relaxed);
let conn = xns.request_connection_blocking(api::SERVER_NAME_JTAG).expect("Can't connect to JTAG server");
Ok(Jtag {
conn
})
}
pub fn get_id(&self) -> Result<u32, xous::Error> {
let response = send_message(self.conn,
Message::new_blocking_scalar(Opcode::GetId.to_usize().unwrap(), 0, 0, 0, 0)
).expect("can't issue get_id message");
if let xous::Result::Scalar1(id)= response {
Ok(id as u32)
} else {
Err(xous::Error::InternalError)
}
}
pub fn get_dna(&self) -> Result<u64, xous::Error> {
let response = send_message(self.conn,
Message::new_blocking_scalar(Opcode::GetDna.to_usize().unwrap(), 0, 0, 0, 0)
).expect("can't issue get_id message");
if let xous::Result::Scalar2(v1, v2)= response {
Ok(((v1 as u64) << 32) | v2 as u64)
} else {
Err(xous::Error::InternalError)
}
}
pub fn efuse_fetch(&self) -> Result<EfuseRecord, xous::Error> {
let xmit = EfuseRecord {
key: [0; 32],
user: 0,
cntl: 0,
};
let mut buf = Buffer::into_buf(xmit).or(Err(xous::Error::InternalError))?;
buf.lend_mut(self.conn, Opcode::EfuseFetch.to_u32().unwrap()).or(Err(xous::Error::InternalError))?;
buf.to_original::<EfuseRecord, _>().or(Err(xous::Error::InternalError))
}
pub fn write_ir(&self, ir: u8) -> Result<(), xous::Error> {
send_message(self.conn,
Message::new_scalar(Opcode::WriteIr.to_usize().unwrap(), ir as usize, 0, 0, 0)
).map(|_| ())
}
pub fn efuse_key_burn(&self, key: [u8; 32]) -> Result<bool, xous::Error> {
let mut buf = Buffer::into_buf(key).or(Err(xous::Error::InternalError))?;
buf.lend_mut(self.conn, Opcode::EfuseKeyBurn.to_u32().unwrap()).or(Err(xous::Error::InternalError))?;
match buf.to_original().unwrap() {
EfuseResult::Success => Ok(true),
EfuseResult::Failure => Ok(false),
}
}
pub fn efuse_user_burn(&self, user: u32) -> Result<bool, xous::Error> {
let response = send_message(self.conn,
Message::new_blocking_scalar(Opcode::EfuseUserBurn.to_usize().unwrap(), user as usize, 0, 0, 0)
).expect("can't fetch user value");
if let xous::Result::Scalar1(res) = response {
if res == 0 {
Ok(false)
} else {
Ok(true)
}
} else {
Err(xous::Error::InternalError)
}
}
pub fn is_efuse_only_boot(&self) -> Result<bool, xous::Error> {
let erec = self.efuse_fetch().expect("couldn't read efuse record");
if (erec.cntl & 0x1) != 0 { Ok(true) } else { Ok(false) }
}
pub fn is_disable_jtag(&self) -> Result<bool, xous::Error> {
let erec = self.efuse_fetch().expect("couldn't read efuse record");
if (erec.cntl & 0x2) != 0 { Ok(true) } else { Ok(false) }
}
pub fn is_efuse_writeable(&self) -> Result<bool, xous::Error> {
let erec = self.efuse_fetch().expect("couldn't read efuse record");
if (erec.cntl & 0x4) != 0 { Ok(true) } else { Ok(false) }
}
pub fn is_key_access_protected(&self) -> Result<bool, xous::Error> {
let erec = self.efuse_fetch().expect("couldn't read efuse record");
if (erec.cntl & 0x8) != 0 { Ok(true) } else { Ok(false) }
}
pub fn is_user_and_key_access_protected(&self) -> Result<bool, xous::Error> {
let erec = self.efuse_fetch().expect("couldn't read efuse record");
if (erec.cntl & 0x10) != 0 { Ok(true) } else { Ok(false) }
}
pub fn is_control_write_protected(&self) -> Result<bool, xous::Error> {
let erec = self.efuse_fetch().expect("couldn't read efuse record");
if (erec.cntl & 0x20) != 0 { Ok(true) } else { Ok(false) }
}
fn mod_ctl_efuse(&self, bits_to_set: u8) -> Result<bool, xous::Error> {
let erec = self.efuse_fetch().expect("couldn't read efuse record");
let response = send_message(self.conn,
Message::new_blocking_scalar(Opcode::EfuseCtlBurn.to_usize().unwrap(), (erec.cntl | bits_to_set) as usize, 0, 0, 0)
).expect("can't issue config burn message");
if let xous::Result::Scalar1(r)= response {
if r != 0 { Ok(true) } else { Ok(false) }
} else {
Err(xous::Error::InternalError)
}
}
pub fn burn_efuse_only_boot(&self) -> Result<bool, xous::Error> {
self.mod_ctl_efuse(0x1)
}
pub fn burn_disable_jtag(&self) -> Result<bool, xous::Error> {
self.mod_ctl_efuse(0x2)
}
pub fn burn_efuse_write_protect(&self) -> Result<bool, xous::Error> {
self.mod_ctl_efuse(0x4)
}
pub fn burn_key_access_protect(&self) -> Result<bool, xous::Error> {
self.mod_ctl_efuse(0x8)
}
pub fn burn_user_and_key_access_protect(&self) -> Result<bool, xous::Error> {
self.mod_ctl_efuse(0x10)
}
pub fn burn_control_write_protect(&self) -> Result<bool, xous::Error> {
self.mod_ctl_efuse(0x20)
}
pub fn seal_device_forever(&self) -> Result<bool, xous::Error> {
self.mod_ctl_efuse(0x3F)
}
}
use core::sync::atomic::{AtomicU32, Ordering};
static REFCOUNT: AtomicU32 = AtomicU32::new(0);
impl Drop for Jtag {
fn drop(&mut self) {
// the connection to the server side must be reference counted, so that multiple instances of this object within
// a single process do not end up de-allocating the CID on other threads before they go out of scope.
// Note to future me: you want this. Don't get rid of it because you think, "nah, nobody will ever make more than one copy of this object".
if REFCOUNT.load(Ordering::Relaxed) == 0 {
unsafe{xous::disconnect(self.conn).unwrap();}
}
// if there was object-specific state (such as a one-time use server for async callbacks, specific to the object instance),
// de-allocate those items here. They don't need a reference count because they are object-specific
}
}

659
services/jtag/src/main.rs Normal file
View file

@ -0,0 +1,659 @@
#![cfg_attr(target_os = "none", no_std)]
#![cfg_attr(target_os = "none", no_main)]
mod api;
mod efuse_api;
mod efuse_ecc;
use api::*;
use num_traits::*;
use xous::{msg_blocking_scalar_unpack, msg_scalar_unpack};
use xous_ipc::Buffer;
use efuse_api::*;
use crate::implementation::JtagPhy;
pub enum JtagState {
TestReset,
RunIdle,
Select,
Capture,
Shift,
Exit1,
Pause,
Exit2,
Update,
}
#[derive(Copy, Clone)]
pub enum JtagChain {
DR,
IR,
}
pub enum JtagEndian {
Big, // MSB-first shiftout
Little // LSB-first shiftout
}
/// option 1: make a "leg" machine that contains the shift-in/shift-out records specific to each leg
/// option 2: make a comprehensive machine that receives meta-commands to transition between states
///
/// I think we want a machine that has a Vector which holds a set of instructions that encapsulate either
/// data to send into the IR or DR. There should be a state bit that indicates if the data has been
/// executed; after execution, there is a result vector that is now valid.
///
#[derive(Clone)]
pub struct JtagLeg {
/// which chain (DR or IR)
c: JtagChain,
/// output bit vector to device; chain length is defined by vector length
o: Vec<bool>,
/// input bit vector from device; length is dynamically allocated as leg traverses
i: Vec<bool>,
/// a tag for the leg, to be used by higher level logic to track pending/done entries
tag: String,
}
impl JtagLeg {
pub fn new(chain_type: JtagChain, mytag: &str) -> Self {
JtagLeg {
c: chain_type,
o: Vec::new(),
i: Vec::new(),
tag: String::from(mytag),
}
}
/// `push` will take data in the form of an unsigned int (either u128 or u32)
/// and append it to the JTAG input vector in preparation for sending.
/// "count" specifies the number of bits of the vector that are valid, and
/// "endian" specifies if the MSB or LSB first should be pushed into the JTAG
/// chain.
///
/// In the case that "count" is less than the full data length and MSB first
/// order is requested, `push` first discards the left-most unused bits and
/// then starts push from the remaining MSB. e.g., to push the number
/// `101100` into the JTAG chain MSB first, store 0x2C into "data" and specify
/// a "count" of 6, and an "endian" of JtagEndian::Big. Do not shift
/// data all the way to the MSB of the containing "data" parameter in this case!
pub fn push_u128(&mut self, data: u128, count: usize, endian: JtagEndian) {
assert!(count <= 128);
for i in 0..count {
match endian {
JtagEndian::Big => {
if (data & (1 << i)) == 0 { self.i.push(false) } else { self.i.push(true) }
},
JtagEndian::Little => {
if (data & (1 << (count-1-i))) == 0 { self.i.push(false) } else { self.i.push(true) }
},
}
}
}
pub fn push_u32(&mut self, data: u32, count: usize, endian: JtagEndian) {
assert!(count <= 32);
for i in 0..count {
match endian {
JtagEndian::Big => {
if (data & (1 << i)) == 0 { self.i.push(false) } else { self.i.push(true) }
},
JtagEndian::Little => {
if (data & (1 << (count-1-i))) == 0 { self.i.push(false) } else { self.i.push(true) }
},
}
}
}
pub fn push_u8(&mut self, data: u8, count: usize, endian: JtagEndian) {
assert!(count <= 8);
for i in 0..count {
match endian {
JtagEndian::Big => {
if (data & (1 << i)) == 0 { self.i.push(false) } else { self.i.push(true) }
},
JtagEndian::Little => {
if (data & (1 << (count-1-i))) == 0 { self.i.push(false) } else { self.i.push(true) }
},
}
}
}
pub fn pop_u32(&mut self, count: usize, endian: JtagEndian) -> Option<u32> {
if self.o.len() < count {
// error out before trying to touch the vector, so that in case
// of a parameter error we can try again without having lost our data
// in general, "count" should be very well specified in this protocol.
return None;
}
let mut data: u32 = 0;
for _ in 0..count {
match endian {
JtagEndian::Little => {
data <<= 1;
if self.o.pop().unwrap() { data |= 0x1; }
}
JtagEndian::Big => {
data >>= 1;
if self.o.pop().unwrap() { data |= 0x8000_0000; }
}
}
}
Some(data)
}
/// pop_u128 does a "Best effort" to return up to count_req elements, will return what is
/// available if less is available
pub fn pop_u128(&mut self, count_req: usize, endian: JtagEndian) -> Option<u128> {
let mut count: usize = count_req;
if self.o.len() == 0 {
return None;
} else if self.o.len() < count_req {
count = self.o.len();
}
let mut data: u128 = 0;
for _ in 0..count {
match endian {
JtagEndian::Little => {
data <<= 1;
if self.o.pop().unwrap() { data |= 0x1; }
},
JtagEndian::Big => {
data >>= 1;
if self.o.pop().unwrap() { data |= 0x8000_0000_0000_0000_0000_0000_0000_0000; }
}
}
}
Some(data)
}
pub fn pop_u8(&mut self, count: usize, endian: JtagEndian) -> Option<u8> {
if self.o.len() < count {
// error out before trying to touch the vector, so that in case
// of a parameter error we can try again without having lost our data
// in general, "count" should be very well specified in this protocol.
return None;
}
let mut data: u8 = 0;
for _ in 0..count {
match endian {
JtagEndian::Little => {
data <<= 1;
if self.o.pop().unwrap() { data |= 0x1; }
}
JtagEndian::Big => {
data >>= 1;
if self.o.pop().unwrap() { data |= 0x80; }
}
}
}
Some(data)
}
pub fn tag(&self) -> String {
self.tag.clone()
}
pub fn dbg_i_len(&self) -> usize {
self.i.len()
}
pub fn dbg_o_len(&self) -> usize {
self.o.len()
}
}
pub struct JtagMach {
/// current state (could be in one of two generics, or in DR/IR chain; check top of Vector for current chain)
s: JtagState,
/// a vector of legs to traverse. An entry stays in pending until the traversal is complete. Aborted
/// traversals leave the leg in place
pending: Vec<JtagLeg>,
/// a vector of legs traversed. An entry is only put into the done vector once its traversal is completed.
done: Vec<JtagLeg>,
/// the current leg being processed
current: Option<JtagLeg>,
/// an integer for debug help
debug: u32,
/// the jtag phy
phy: JtagPhy,
ticktimer: ticktimer_server::Ticktimer,
}
impl JtagMach {
pub fn new() -> Self {
JtagMach {
s: JtagState::TestReset,
pending: Vec::new(),
done: Vec::new(),
current: None,
debug: 0,
phy: implementation::JtagPhy::new(),
ticktimer: ticktimer_server::Ticktimer::new().unwrap(),
}
}
/// pause for a given number of microseconds.
pub fn pause(&mut self, us: u32) {
let mut delay: u32 = us/1000;
if delay == 0 {
delay = 1;
}
self.ticktimer.sleep_ms(delay as usize).expect("couldn't sleep");
}
/// add() -- add a leg to the pending queue
pub fn add(&mut self, leg: JtagLeg) {
self.pending.push(leg);
}
/// get() -- get the oldest result in the done queue. Returns an option.
pub fn get(&mut self) -> Option<JtagLeg> {
if self.done.len() > 0 {
Some(self.done.remove(0))
} else {
None
}
}
/// has_pending() -- tells if the jtag machine has a pending leg to traverse. Returns the tag of the pending item, or None.
pub fn has_pending(&self) -> bool {
if self.pending.len() > 0 {
true
} else {
false
}
}
/// has_done() -- tells if the jtag machine has any legs that are done to read out. Returns the tag of the done item, or None.
#[allow(dead_code)]
pub fn has_done(&self) -> bool {
if self.done.len() > 0 {
true
} else {
false
}
}
/// for debug
#[allow(dead_code)]
pub fn pending_len(&self) -> usize {
self.pending.len()
}
/// for debug
#[allow(dead_code)]
pub fn done_len(&self) -> usize {
self.done.len()
}
pub fn dbg_reset(&mut self) {
self.debug = 0;
}
pub fn dbg_get(&self) -> u32 {
self.debug
}
/// step() -- move state machine by one cycle
/// if there is nothing in the pending queue, stay in idle
/// if something in the pending queue, traverse to execute it
pub fn step(&mut self) {
self.s = match self.s {
JtagState::TestReset => {
self.phy.sync(false, false);
JtagState::RunIdle
},
JtagState::RunIdle => {
// we have a current item, traverse to the correct tree based on the type
if let Some(ref mut cur) = self.current {
match cur.c {
JtagChain::DR => {
self.debug = 2;
self.phy.sync(false, true);
},
JtagChain::IR => {
self.debug = 3;
// must be IR -- do two TMS high pulses to get to the IR leg
self.phy.sync(false, true);
self.phy.sync(false, true);
}
}
JtagState::Select
} else {
if self.pending.len() > 0 {
// nothing current, but has pending --> assign a current
// don't pop the entry, though, until we are finished traversing the leg,
// hence we make a clone of the entry
self.current = Some(self.pending[0].clone());
} else {
// nothing pending, nothing current
// stay in the current state
self.phy.sync(false, false);
}
JtagState::RunIdle
}
},
JtagState::Select => {
self.phy.sync(false, false);
JtagState::Capture
},
JtagState::Capture => {
// always move to shift, because leg structures always have data
self.phy.sync(false, false);
JtagState::Shift
},
JtagState::Shift => {
// shift data until the input vector is exhausted
if let Some(ref mut cur) = self.current {
if let Some(tdi) = cur.i.pop() {
if cur.i.len() > 0 {
let tdo: bool = self.phy.sync(tdi, false);
cur.o.push(tdo);
self.current = Some(cur.clone());
JtagState::Shift
} else {
// last element should leave the state
let tdo: bool = self.phy.sync(tdi, true);
cur.o.push(tdo);
self.current = Some(cur.clone());
JtagState::Exit1
}
} else {
// Shouldn't happen: no "i", but move on gracefully
JtagState::Exit1
}
} else {
// Shouldn't happen: No "Current", but move on gracefully
JtagState::Exit1
}
},
JtagState::Exit1 => {
self.phy.sync(false, true);
JtagState::Update
},
JtagState::Pause => {
self.phy.sync(false, true);
JtagState::Exit2
},
JtagState::Exit2 => {
self.phy.sync(false, true);
JtagState::Update
},
JtagState::Update => {
self.phy.sync(false, false);
self.pending.remove(0); // remove the oldest entry
if let Some(next) = self.current.take() {
self.done.push(next);
}
JtagState::RunIdle
}
}
}
/// reset() -- bring the state machine back to the TEST_RESET state
pub fn reset(&mut self) {
// regardless of what state we are in, 5 cycles of TMS=1 will bring us to RESET
for _ in 0..5 {
self.phy.sync(false, true);
}
self.s = JtagState::TestReset;
}
/// next() -- advance until a RUN_IDLE state. If currently RUN_IDLE, traverse the next available leg, if one exists
pub fn next(&mut self) {
match self.s {
JtagState::RunIdle | JtagState::TestReset => {
if self.has_pending() {
// if pending, step until we're into a leg
loop {
match self.s {
JtagState::RunIdle | JtagState::TestReset => self.step(),
_ => break,
}
}
// then step until we're out of the leg
loop {
match self.s {
JtagState::RunIdle | JtagState::TestReset => break,
_ => self.step(),
}
}
} else {
self.step(); // this should be a single step with no state change
}
},
_ => {
// in the case that we're not already in idle or reset, run the machine until we get to idle or reset
loop {
match self.s {
JtagState::RunIdle | JtagState::TestReset => break,
_ => self.step(),
}
}
},
}
}
}
#[cfg(any(target_os = "none", target_os = "xous"))]
mod implementation {
use utralib::generated::*;
#[allow(dead_code)]
pub(crate) struct JtagPhy {
csr: utralib::CSR<u32>,
}
impl JtagPhy {
pub fn new() -> JtagPhy {
let csr = xous::syscall::map_memory(
xous::MemoryAddress::new(utra::jtag::HW_JTAG_BASE),
None,
4096,
xous::MemoryFlags::R | xous::MemoryFlags::W,
)
.expect("couldn't map JTAG CSR range");
let jtag = JtagPhy {
csr: CSR::new(csr.as_mut_ptr() as *mut u32),
};
jtag
}
/// given a tdi and tms value, pulse the clock, and then return the tdo that comes out
pub fn sync(&mut self, tdi: bool, tms: bool) -> bool {
self.csr.wo(utra::jtag::NEXT,
self.csr.ms(utra::jtag::NEXT_TDI, if tdi {1} else {0}) |
self.csr.ms(utra::jtag::NEXT_TMS, if tms {1} else {0})
);
while self.csr.rf(utra::jtag::TDO_READY) == 0 { } // make sure we are in a ready/tdo valid state
if self.csr.rf(utra::jtag::TDO_TDO) == 0 { // this is the TDO value from /prior/ to the TCK rise
false
} else {
true
}
// note: the hardware already guarantees TDO sample timing relative to TCK edge: in other words,
// TDO is sampled before the TCK edge is allowed to rise
}
}
}
// a stub to try to avoid breaking hosted mode for as long as possible.
#[cfg(not(any(target_os = "none", target_os = "xous")))]
mod implementation {
pub struct JtagMach {
}
impl JtagMach {
pub fn new() -> JtagMach {
JtagMach {
}
}
fn sync(&mut self, tdi: bool, tms: bool) -> bool {
false
}
}
}
#[xous::xous_main]
fn xmain() -> ! {
log_server::init_wait().unwrap();
log::set_max_level(log::LevelFilter::Info);
log::info!("my PID is {}", xous::process::id());
let xns = xous_names::XousNames::new().unwrap();
// expect:
// - one connection from the key server
// - one connection from shellchat for testing
let jtag_sid = xns.register_name(api::SERVER_NAME_JTAG, Some(2)).expect("can't register server");
log::trace!("registered with NS -- {:?}", jtag_sid);
let mut jtag = JtagMach::new();
let mut efuse = EfuseApi::new();
log::trace!("ready to accept requests");
// register a suspend/resume listener
let mut susres = susres::Susres::new_without_hook(&xns).expect("couldn't create suspend/resume object");
loop {
let mut msg = xous::receive_message(jtag_sid).unwrap();
match FromPrimitive::from_usize(msg.body.id()) {
Some(Opcode::GetId) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
jtag.reset();
let mut id_leg: JtagLeg = JtagLeg::new(JtagChain::IR, "idcode");
id_leg.push_u32(0b001001, 6, JtagEndian::Little);
jtag.add(id_leg);
jtag.next();
// NOW: - check the return data on .get() before using it
if jtag.get().is_none() { // discard ID code but check that there's something
log::error!("ID instruction not in get queue!");
xous::return_scalar(msg.sender, 0xFFFF_FFFF).unwrap();
continue;
}
let mut data_leg: JtagLeg = JtagLeg::new(JtagChain::DR, "iddata");
data_leg.push_u32(0, 32, JtagEndian::Little);
jtag.add(data_leg);
jtag.dbg_reset();
jtag.next();
let d: u32 = jtag.dbg_get();
if let Some(mut iddata) = jtag.get() { // this contains the actual idcode data
let id = iddata.pop_u32(32, JtagEndian::Little).unwrap();
log::trace!("tag: {}, code: 0x{:08x}, d:{}", iddata.tag(), id, d);
xous::return_scalar(msg.sender, id as usize).unwrap();
} else {
log::trace!("ID data not in get queue!");
}
}),
Some(Opcode::GetDna) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
jtag.reset();
let mut ir_leg: JtagLeg = JtagLeg::new(JtagChain::IR, "cmd");
ir_leg.push_u32(0b110010, 6, JtagEndian::Little);
jtag.add(ir_leg);
jtag.next();
if jtag.get().is_none() { // discard ID code but check that there's something
log::error!("cmd instruction not in get queue!");
xous::return_scalar2(msg.sender, 0xFFFF_FFFF, 0xFFFF).unwrap();
}
let mut data_leg: JtagLeg = JtagLeg::new(JtagChain::DR, "dna");
data_leg.push_u128(0, 64, JtagEndian::Little);
jtag.add(data_leg);
jtag.next();
if let Some(mut data) = jtag.get() {
let dna: u128 = data.pop_u128(64, JtagEndian::Little).unwrap();
xous::return_scalar2(msg.sender, (dna >> 32) as usize, dna as usize).unwrap();
log::info!("{}/0x{:16x}", data.tag(), dna);
} else {
log::error!("cmd instruction not in get queue!");
xous::return_scalar2(msg.sender, 0xFFFF_FFFF, 0xFFFF).unwrap();
}
}),
Some(Opcode::EfuseFetch) => {
efuse.fetch(&mut jtag);
let mut buffer = unsafe{Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap())};
let mut efuse_rec = buffer.to_original::<EfuseRecord, _>().unwrap();
efuse_rec.user = efuse.phy_user();
efuse_rec.cntl = efuse.phy_cntl();
for (&src, dst) in efuse.phy_key().iter().zip(efuse_rec.key.iter_mut()) {
*dst = src;
}
buffer.replace(efuse_rec).unwrap();
}
Some(Opcode::WriteIr) => msg_scalar_unpack!(msg, ir, _, _, _, {
jtag.reset();
let mut ir_leg: JtagLeg = JtagLeg::new(JtagChain::IR, "cmd");
ir_leg.push_u32(ir as u32, 6, JtagEndian::Little); // ISC_ENABLE
jtag.add(ir_leg);
jtag.next();
if jtag.get().is_none() { // discard ID code but check that there's something
log::error!("cmd instruction not in get queue!");
}
}),
Some(Opcode::EfuseKeyBurn) => {
susres.set_suspendable(false).unwrap();
let mut buffer = unsafe{Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap())};
let key = buffer.to_original::<[u8; 32], _>().unwrap();
// refresh the efuse cache
efuse.fetch(&mut jtag);
#[cfg(feature = "hazardous-debug")]
log::info!("attempting to burn key: {:x?}", key);
efuse.set_key(key);
if efuse.is_valid() {
log::info!("efuse key is valid to burn, proceeding. There is no return...");
efuse.burn(&mut jtag);
buffer.replace(EfuseResult::Success).unwrap();
} else {
log::error!("efuses already burned, new key is unpatchable. Refusing to burn!");
buffer.replace(EfuseResult::Failure).unwrap();
}
susres.set_suspendable(true).unwrap();
}
Some(Opcode::EfuseCtlBurn) => msg_blocking_scalar_unpack!(msg, ctl, _, _, _, {
susres.set_suspendable(false).unwrap();
efuse.fetch(&mut jtag);
efuse.set_cntl(ctl as u8);
if efuse.is_valid() {
log::info!("control is valid to burn, proceeding. There is no return...");
efuse.burn(&mut jtag);
susres.set_suspendable(true).unwrap();
xous::return_scalar(msg.sender, 1).unwrap();
} else {
susres.set_suspendable(true).unwrap();
xous::return_scalar(msg.sender, 0).unwrap();
}
}),
Some(Opcode::EfuseUserBurn) => msg_blocking_scalar_unpack!(msg, user, _, _, _, {
susres.set_suspendable(false).unwrap();
efuse.fetch(&mut jtag);
efuse.set_user(user as u32);
if efuse.is_valid() {
log::info!("user fuses are valid to burn, proceeding. There is no return...");
efuse.burn(&mut jtag);
susres.set_suspendable(true).unwrap();
xous::return_scalar(msg.sender, 1).unwrap();
} else {
susres.set_suspendable(true).unwrap();
xous::return_scalar(msg.sender, 0).unwrap();
}
}),
None => {
log::error!("couldn't convert opcode");
break
}
}
}
// clean up our program
log::trace!("main loop exit, destroying servers");
xns.unregister_server(jtag_sid).unwrap();
xous::destroy_server(jtag_sid).unwrap();
log::trace!("quitting");
xous::terminate_process(0)
}

View file

@ -657,12 +657,13 @@ fn xmain() -> ! {
// - shellchat/sleep
// - shellchat/environment
// - spinor (for turning off wfi during writes)
let llio_sid = xns.register_name(api::SERVER_NAME_LLIO, Some(6)).expect("can't register server");
// - rootkeys (for reboots)
let llio_sid = xns.register_name(api::SERVER_NAME_LLIO, Some(7)).expect("can't register server");
log::trace!("registered with NS -- {:?}", llio_sid);
// create the I2C handler thread
// each connection to llio also creates an i2c connection, so it has the same expectation list
let i2c_sid = xns.register_name(api::SERVER_NAME_I2C, Some(6)).expect("can't register I2C thread");
let i2c_sid = xns.register_name(api::SERVER_NAME_I2C, Some(7)).expect("can't register I2C thread");
log::trace!("registered I2C thread with NS -- {:?}", i2c_sid);
let (sid0, sid1, sid2, sid3) = i2c_sid.to_u32();
xous::create_thread_4(i2c_thread, sid0 as usize, sid1 as usize, sid2 as usize, sid3 as usize).expect("couldn't start I2C handler thread");

View file

@ -14,6 +14,9 @@ log = "0.4"
susres = {path = "../susres"}
trng = {path= "../trng"}
spinor = {path="../spinor"}
llio = {path="../llio"}
rtc = {path="../rtc"}
com = {path="../com"}
xous-ipc = {path = "../../xous-ipc"}
num-derive = {version = "0.3", default-features = false}

View file

@ -69,10 +69,15 @@
"zh": "保存签名\n可能还要等一下\n不要重置或睡眠!\n",
"en-audio": "Committing signatures. This may take a while, don't reset or sleep the device."
},
"rootkeys.init.unplug_power": {
"en": "Please unplug the charging\ncable so I can reboot!\n\n",
"zh": "拔下充电线以允许重启!",
"en-audio": "Unplug the charging cable so I can reboot!"
},
"rootkeys.init.finished": {
"en": "Preparing to reboot...\n\n\n",
"en": "Reboot in 5 seconds...\n\n\n",
"zh": "准备重启...\n\n",
"en-audio": "Preparing to reboot."
"en-audio": "Reboot in 5 seconds."
},
"rootkeys.init.fail_verify": {
"en": "Verification failed,\naborting!",

View file

@ -23,6 +23,7 @@ pub(crate) enum Opcode {
UxGutter, // NOP for UX calls that require a destination
UxGetPolicy,
UxPolicyReturn,
UxTryReboot,
/// provision a gateware update with our secret data
UxUpdateGateware,
/// self-sign kernel/loader

View file

@ -120,6 +120,12 @@ fn xmain() -> ! {
let mut keys = RootKeys::new();
// create the servers necessary to coordinate an auto-reboot sequence...
let llio = llio::Llio::new(&xns).unwrap();
let rtc = rtc::Rtc::new(&xns).unwrap();
let ticktimer = ticktimer_server::Ticktimer::new().unwrap();
let com = com::Com::new(&xns).unwrap();
log::trace!("ready to accept requests");
// register a suspend/resume listener
@ -318,12 +324,22 @@ fn xmain() -> ! {
// the stop emoji, when sent to the slider action bar in progress mode, will cause it to close and relinquish focus
rootkeys_modal.key_event(['🛑', '\u{0000}', '\u{0000}', '\u{0000}']);
// at this point, we may want to pop up a modal indicating we are going to reboot?
// we also need to include a command that does the reboot.
match result {
Ok(_) => {
keys.finish_key_init();
// TODO: need to insert the reboot command here
// summon a modal that brings us to a reboot
dismiss_modal_action.set_action_opcode(Opcode::UxTryReboot.to_u32().unwrap());
rootkeys_modal.modify(
Some(ActionType::Notification(dismiss_modal_action)),
Some(t!("rootkeys.init.finished", xous::LANG)), false,
None, false, None);
rootkeys_modal.activate();
send_message(main_cid,
xous::Message::new_scalar(Opcode::UxTryReboot.to_usize().unwrap(), 0, 0, 0, 0)).expect("couldn't initiate dialog box");
continue;
}
Err(RootkeyResult::AlignmentError) => {
dismiss_modal_action.set_action_opcode(Opcode::UxGutter.to_u32().unwrap());
@ -371,6 +387,62 @@ fn xmain() -> ! {
log::error!("invalid UX state -- someone called init password return, but no password type was set!");
}
},
Some(Opcode::UxTryReboot) => {
// ensure the boost is off so that the reboot will not fail
com.set_boost(false).unwrap();
llio.boost_on(false).unwrap();
ticktimer.sleep_ms(50).unwrap(); // give some time for the voltage to move
let vbus = (llio.adc_vbus().unwrap() as f64) * 0.005033;
log::info!("Vbus is: {:.3}V", vbus);
if vbus > 1.5 {
// if power is plugged in, request that it be removed
dismiss_modal_action.set_action_opcode(Opcode::UxTryReboot.to_u32().unwrap());
rootkeys_modal.modify(
Some(ActionType::Notification(dismiss_modal_action)),
Some(t!("rootkeys.init.unplug_power", xous::LANG)), false,
None, false, None);
rootkeys_modal.activate();
rootkeys_modal.redraw();
xous::yield_slice();
ticktimer.sleep_ms(500).unwrap();
send_message(main_cid,
xous::Message::new_scalar(Opcode::UxTryReboot.to_usize().unwrap(), 0, 0, 0, 0)
).expect("couldn't initiate dialog box");
log::info!("vbus is high, holding off on reboot");
} else {
dismiss_modal_action.set_action_opcode(Opcode::UxGutter.to_u32().unwrap());
rootkeys_modal.modify(
Some(ActionType::Notification(dismiss_modal_action)),
Some(t!("rootkeys.init.finished", xous::LANG)), false,
None, false, None);
rootkeys_modal.activate();
rootkeys_modal.redraw();
xous::yield_slice();
// set a wakeup alarm a couple seconds from now -- this is the coldboot
rtc.set_wakeup_alarm(4).unwrap();
// allow EC to snoop, so that it can wake up the system
llio.allow_ec_snoop(true).unwrap();
// allow the EC to power me down
llio.allow_power_off(true).unwrap();
// now send the power off command
com.power_off_soc().unwrap();
log::info!("reboot in 4 seconds!");
// pause execution, nothing after this should be reachable
ticktimer.sleep_ms(5000).unwrap();
log::info!("if you can read this, reboot failed!");
// try it again, anyways...
send_message(main_cid,
xous::Message::new_scalar(Opcode::UxTryReboot.to_usize().unwrap(), 0, 0, 0, 0)
).expect("couldn't initiate dialog box");
}
}
Some(Opcode::UxUpdateGateware) => {
unimplemented!();
},

View file

@ -582,7 +582,8 @@ fn xmain() -> ! {
// - shellchat/rtc
// - shellchat/sleep x2
// - UX thread (self, created without xns, so does not count)
let rtc_sid = xns.register_name(api::SERVER_NAME_RTC, Some(4)).expect("can't register server");
// - rootkeys (for coordinating reboot)
let rtc_sid = xns.register_name(api::SERVER_NAME_RTC, Some(5)).expect("can't register server");
log::trace!("registered with NS -- {:?}", rtc_sid);
CB_TO_MAIN_CONN.store(xous::connect(rtc_sid).unwrap(), Ordering::Relaxed);