mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-18 08:52:45 +00:00
format services/jtag
This commit is contained in:
parent
411e0ca9d8
commit
2f9f91648c
5 changed files with 330 additions and 260 deletions
|
|
@ -1,4 +1,4 @@
|
||||||
pub(crate) const SERVER_NAME_JTAG: &str = "_JTAG Server_";
|
pub(crate) const SERVER_NAME_JTAG: &str = "_JTAG Server_";
|
||||||
|
|
||||||
#[allow(dead_code)]
|
#[allow(dead_code)]
|
||||||
pub const XCS750_IDCODE: u32 = 0x362F093;
|
pub const XCS750_IDCODE: u32 = 0x362F093;
|
||||||
|
|
|
||||||
|
|
@ -12,8 +12,8 @@
|
||||||
/// raw fuse values once burned -- they can only be implied through a set of readback calls.
|
/// 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:
|
/// This means the fuse life cycle looks like this:
|
||||||
/// * Initial, unprogrammed factory state is all 0's
|
/// * 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
|
/// * USER/KEY data is coded by blowing only the 1's. An ECC code must also be blown simultaneously to
|
||||||
/// to match the final pattern of 1's for correct readout
|
/// 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
|
/// * 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
|
/// in a valid state after ECC is factored in. This is especially true for data values striped across
|
||||||
/// multiple banks.
|
/// multiple banks.
|
||||||
|
|
@ -30,10 +30,8 @@
|
||||||
/// of code that can convert the physical bank information into the logical view. Validation code thus
|
/// 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
|
/// 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.
|
/// which will implement the logical KEY/USER/CNTL requests.
|
||||||
///
|
|
||||||
|
|
||||||
use crate::efuse_ecc::efuse_ecc::*;
|
use crate::efuse_ecc::efuse_ecc::*;
|
||||||
use crate::{JtagMach, JtagChain, JtagEndian, JtagLeg};
|
use crate::{JtagChain, JtagEndian, JtagLeg, JtagMach};
|
||||||
|
|
||||||
/// There are 13 banks of fuses, 12 of which (key/user) are "hamming" ECC, 1 of which (config) is "dup" ECC.
|
/// There are 13 banks of fuses, 12 of which (key/user) are "hamming" ECC, 1 of which (config) is "dup" ECC.
|
||||||
pub struct EfusePhy {
|
pub struct EfusePhy {
|
||||||
|
|
@ -64,12 +62,15 @@ impl EfusePhy {
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn user(&self) -> u32 { self.user }
|
pub fn user(&self) -> u32 { self.user }
|
||||||
|
|
||||||
pub fn cntl(&self) -> u8 { self.cntl }
|
pub fn cntl(&self) -> u8 { self.cntl }
|
||||||
|
|
||||||
pub fn key(&self) -> [u8; 32] { self.key }
|
pub fn key(&self) -> [u8; 32] { self.key }
|
||||||
|
|
||||||
/// this is a TEST FUNCTION ONLY. Unfortunately, the Rust test directive does not
|
/// this is a TEST FUNCTION ONLY. Unfortunately, the Rust test directive does not
|
||||||
/// like this no_std runtime / std test environment.
|
/// like this no_std runtime / std test environment.
|
||||||
pub fn bank_patch(&mut self, index: usize, data: u32) { // this is just for test routines
|
pub fn bank_patch(&mut self, index: usize, data: u32) {
|
||||||
|
// this is just for test routines
|
||||||
self.banks[index] = data;
|
self.banks[index] = data;
|
||||||
// re-derive key bits from bank data
|
// re-derive key bits from bank data
|
||||||
for i in 0..32 {
|
for i in 0..32 {
|
||||||
|
|
@ -100,10 +101,10 @@ impl EfusePhy {
|
||||||
if index == 0 {
|
if index == 0 {
|
||||||
// first bank is special because it's split with the user fuse
|
// first bank is special because it's split with the user fuse
|
||||||
bank_data = data.pop_u32(16, JtagEndian::Little).unwrap();
|
bank_data = data.pop_u32(16, JtagEndian::Little).unwrap();
|
||||||
self.banks[11-index] = bank_data;
|
self.banks[11 - index] = bank_data;
|
||||||
} else {
|
} else {
|
||||||
bank_data = data.pop_u32(24, JtagEndian::Little).unwrap();
|
bank_data = data.pop_u32(24, JtagEndian::Little).unwrap();
|
||||||
self.banks[11-index] = add_ecc(bank_data);
|
self.banks[11 - index] = add_ecc(bank_data);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
|
|
@ -112,7 +113,8 @@ impl EfusePhy {
|
||||||
// derive bits from bank data, to debug any bit-order issues on readout, etc.
|
// derive bits from bank data, to debug any bit-order issues on readout, etc.
|
||||||
for index in 0..32 {
|
for index in 0..32 {
|
||||||
// key reversal from hw storage state is handled here
|
// key reversal from hw storage state is handled here
|
||||||
self.key[31 - index] = ((self.banks[((index / 3) + 1) as usize] >> ((index % 3) * 8)) & 0xFF) as u8;
|
self.key[31 - index] =
|
||||||
|
((self.banks[((index / 3) + 1) as usize] >> ((index % 3) * 8)) & 0xFF) as u8;
|
||||||
}
|
}
|
||||||
|
|
||||||
jm.pause(2000);
|
jm.pause(2000);
|
||||||
|
|
@ -133,7 +135,7 @@ impl EfusePhy {
|
||||||
self.banks[11] |= (user_data & 0xFF) << 16;
|
self.banks[11] |= (user_data & 0xFF) << 16;
|
||||||
self.banks[11] = add_ecc(self.banks[11]);
|
self.banks[11] = add_ecc(self.banks[11]);
|
||||||
|
|
||||||
self.banks[12] = add_ecc( (user_data >> 8) & 0xFF_FF_FF);
|
self.banks[12] = add_ecc((user_data >> 8) & 0xFF_FF_FF);
|
||||||
} else {
|
} else {
|
||||||
assert!(false);
|
assert!(false);
|
||||||
}
|
}
|
||||||
|
|
@ -169,24 +171,23 @@ pub struct EfuseApi {
|
||||||
}
|
}
|
||||||
|
|
||||||
impl EfuseApi {
|
impl EfuseApi {
|
||||||
pub fn new() -> Self {
|
pub fn new() -> Self { EfuseApi { key: [0; 32], user: 0, cntl: 0, phy: EfusePhy::new() } }
|
||||||
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
|
/// 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_key(&self) -> [u8; 32] { self.phy.key() }
|
||||||
|
|
||||||
pub fn phy_user(&self) -> u32 { self.phy.user() }
|
pub fn phy_user(&self) -> u32 { self.phy.user() }
|
||||||
|
|
||||||
pub fn phy_cntl(&self) -> u8 { self.phy.cntl() }
|
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
|
/// api_ series of call returns the current "api" state, which is the intended state to be programmed if
|
||||||
|
/// not yet programmed
|
||||||
#[allow(dead_code)]
|
#[allow(dead_code)]
|
||||||
pub fn api_key(&self) -> [u8; 32] { self.key }
|
pub fn api_key(&self) -> [u8; 32] { self.key }
|
||||||
|
|
||||||
#[allow(dead_code)]
|
#[allow(dead_code)]
|
||||||
pub fn api_user(&self) -> u32 { self.user }
|
pub fn api_user(&self) -> u32 { self.user }
|
||||||
|
|
||||||
#[allow(dead_code)]
|
#[allow(dead_code)]
|
||||||
pub fn api_cntl(&self) -> u8 { self.cntl }
|
pub fn api_cntl(&self) -> u8 { self.cntl }
|
||||||
|
|
||||||
|
|
@ -208,7 +209,9 @@ impl EfuseApi {
|
||||||
self.key[i] = new_key[31 - i]; // key is reversed in byte order
|
self.key[i] = new_key[31 - i]; // key is reversed in byte order
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn set_user(&mut self, new_user: u32) { self.user = new_user; }
|
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 set_cntl(&mut self, new_cntl: u8) { self.cntl = new_cntl; }
|
||||||
|
|
||||||
pub fn is_valid(&mut self) -> bool {
|
pub fn is_valid(&mut self) -> bool {
|
||||||
|
|
@ -220,19 +223,32 @@ impl EfuseApi {
|
||||||
// handle cntl special case
|
// handle cntl special case
|
||||||
if ((self.phy.banks[0] & 0x3F) as u8 ^ self.cntl) & (self.phy.banks[0] & 0x3F) as u8 != 0 {
|
if ((self.phy.banks[0] & 0x3F) as u8 ^ self.cntl) & (self.phy.banks[0] & 0x3F) as u8 != 0 {
|
||||||
valid = false;
|
valid = false;
|
||||||
log::warn!("proposed efuse cntl setting is not valid {:x?} -> {:x?}", self.phy.banks[0] & 0x3F, self.cntl);
|
log::warn!(
|
||||||
|
"proposed efuse cntl setting is not valid {:x?} -> {:x?}",
|
||||||
|
self.phy.banks[0] & 0x3F,
|
||||||
|
self.cntl
|
||||||
|
);
|
||||||
}
|
}
|
||||||
} else if index == 12 {
|
} else if index == 12 {
|
||||||
// handle user special case
|
// handle user special case
|
||||||
if ((self.phy.banks[index] ^ add_ecc(self.user >> 8)) & self.phy.banks[index]) != 0 {
|
if ((self.phy.banks[index] ^ add_ecc(self.user >> 8)) & self.phy.banks[index]) != 0 {
|
||||||
log::warn!("proposed efuse user setting is not valid {:x?} -> {:x?}", self.phy.banks[index], add_ecc(self.user >> 8));
|
log::warn!(
|
||||||
|
"proposed efuse user setting is not valid {:x?} -> {:x?}",
|
||||||
|
self.phy.banks[index],
|
||||||
|
add_ecc(self.user >> 8)
|
||||||
|
);
|
||||||
valid = false;
|
valid = false;
|
||||||
}
|
}
|
||||||
} else if index == 11 {
|
} else if index == 11 {
|
||||||
// handle user + key special case
|
// handle user + key special case
|
||||||
let raw_fuse: u32 = ((self.user & 0xFF) << 16) | (self.key[31] as u32) << 8 | self.key[30] as u32;
|
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 {
|
if ((self.phy.banks[index] ^ add_ecc(raw_fuse)) & self.phy.banks[index]) != 0 {
|
||||||
log::warn!("proposed user/key overlap area setting is not valid {:x?} -> {:x?}", self.phy.banks[index], add_ecc(raw_fuse));
|
log::warn!(
|
||||||
|
"proposed user/key overlap area setting is not valid {:x?} -> {:x?}",
|
||||||
|
self.phy.banks[index],
|
||||||
|
add_ecc(raw_fuse)
|
||||||
|
);
|
||||||
valid = false;
|
valid = false;
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
|
|
@ -240,10 +256,14 @@ impl EfuseApi {
|
||||||
let mut raw_fuse: u32 = 0;
|
let mut raw_fuse: u32 = 0;
|
||||||
for i in 0..3 {
|
for i in 0..3 {
|
||||||
raw_fuse <<= 8;
|
raw_fuse <<= 8;
|
||||||
raw_fuse |= self.key[(index-1)*3 + 2-i] as u32;
|
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 {
|
if ((self.phy.banks[index] ^ add_ecc(raw_fuse)) & self.phy.banks[index]) != 0 {
|
||||||
log::warn!("proposed key setting is not valid {:x?} -> {:x?}", self.phy.banks[index], add_ecc(raw_fuse));
|
log::warn!(
|
||||||
|
"proposed key setting is not valid {:x?} -> {:x?}",
|
||||||
|
self.phy.banks[index],
|
||||||
|
add_ecc(raw_fuse)
|
||||||
|
);
|
||||||
valid = false;
|
valid = false;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -251,7 +271,7 @@ impl EfuseApi {
|
||||||
valid
|
valid
|
||||||
}
|
}
|
||||||
|
|
||||||
fn jtag_seq(&mut self, jm: &mut JtagMach, cmds: &[(JtagChain, usize, u64, &str)] ) -> u128 {
|
fn jtag_seq(&mut self, jm: &mut JtagMach, cmds: &[(JtagChain, usize, u64, &str)]) -> u128 {
|
||||||
let mut ret: u128 = 0;
|
let mut ret: u128 = 0;
|
||||||
|
|
||||||
for tuple in cmds.iter() {
|
for tuple in cmds.iter() {
|
||||||
|
|
@ -273,14 +293,16 @@ impl EfuseApi {
|
||||||
}
|
}
|
||||||
|
|
||||||
fn burn_bank(&mut self, bank: usize, ones: u32, jm: &mut JtagMach) {
|
fn burn_bank(&mut self, bank: usize, ones: u32, jm: &mut JtagMach) {
|
||||||
if ones == 0 { // skip the bank if nothing to burn
|
if ones == 0 {
|
||||||
|
// skip the bank if nothing to burn
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
jm.pause(2500); // 2.5ms pause between banks
|
jm.pause(2500); // 2.5ms pause between banks
|
||||||
|
|
||||||
let mut bank_select: u8 = 1; // bank 0 by default (special case)
|
let mut bank_select: u8 = 1; // bank 0 by default (special case)
|
||||||
let mut word_select: u8 = 3;
|
let mut word_select: u8 = 3;
|
||||||
if bank > 0 { // rest of banks
|
if bank > 0 {
|
||||||
|
// rest of banks
|
||||||
bank_select = (bank as u8 - 1) * 8 + 0xA1;
|
bank_select = (bank as u8 - 1) * 8 + 0xA1;
|
||||||
word_select = bank_select | 0b10;
|
word_select = bank_select | 0b10;
|
||||||
}
|
}
|
||||||
|
|
@ -300,7 +322,12 @@ impl EfuseApi {
|
||||||
if (curbit & 0x1) == 1 {
|
if (curbit & 0x1) == 1 {
|
||||||
let bit_burn: [(JtagChain, usize, u64, &str); 3] = [
|
let bit_burn: [(JtagChain, usize, u64, &str); 3] = [
|
||||||
(JtagChain::IR, 6, 0b110000, "EFUSE"),
|
(JtagChain::IR, 6, 0b110000, "EFUSE"),
|
||||||
(JtagChain::DR, 64, (0xa08a28ac00004000 | (word_select as u64)) + ((i as u64) << 8), "KEY_BIT"),
|
(
|
||||||
|
JtagChain::DR,
|
||||||
|
64,
|
||||||
|
(0xa08a28ac00004000 | (word_select as u64)) + ((i as u64) << 8),
|
||||||
|
"KEY_BIT",
|
||||||
|
),
|
||||||
(JtagChain::DR, 64, 0x0, "KEY_BIT_WAIT"),
|
(JtagChain::DR, 64, 0x0, "KEY_BIT_WAIT"),
|
||||||
];
|
];
|
||||||
self.jtag_seq(jm, &bit_burn);
|
self.jtag_seq(jm, &bit_burn);
|
||||||
|
|
@ -312,31 +339,30 @@ impl EfuseApi {
|
||||||
|
|
||||||
// burns fuses to the FPGA bank
|
// burns fuses to the FPGA bank
|
||||||
pub fn burn(&mut self, jm: &mut JtagMach) -> bool {
|
pub fn burn(&mut self, jm: &mut JtagMach) -> bool {
|
||||||
const COMMIT_SEQ: [(JtagChain, usize, u64, &str); 22] =
|
const COMMIT_SEQ: [(JtagChain, usize, u64, &str); 22] = [
|
||||||
[
|
(JtagChain::DR, 64, 0xff000000ff, "EFUSE_COMMIT"),
|
||||||
(JtagChain::DR, 64, 0xff000000ff, "EFUSE_COMMIT"),
|
(JtagChain::IR, 6, 0b000010, "USER1"),
|
||||||
(JtagChain::IR, 6, 0b000010, "USER1"),
|
(JtagChain::DR, 32, 0, "USER1"),
|
||||||
(JtagChain::DR, 32, 0, "USER1"),
|
(JtagChain::IR, 6, 0b000010, "USER1"),
|
||||||
(JtagChain::IR, 6, 0b000010, "USER1"),
|
(JtagChain::DR, 17, 0xF000, "USER1"),
|
||||||
(JtagChain::DR, 17, 0xF000, "USER1"),
|
(JtagChain::DR, 75, 0xA9, "USER1"),
|
||||||
(JtagChain::DR, 75, 0xA9, "USER1"),
|
(JtagChain::IR, 6, 0b100010, "USER3"),
|
||||||
(JtagChain::IR, 6, 0b100010, "USER3"),
|
(JtagChain::DR, 17, 0xF000, "USER3"),
|
||||||
(JtagChain::DR, 17, 0xF000, "USER3"),
|
(JtagChain::DR, 75, 0xA9, "USER3"),
|
||||||
(JtagChain::DR, 75, 0xA9, "USER3"),
|
(JtagChain::IR, 6, 0b111111, "BYPASS"),
|
||||||
(JtagChain::IR, 6, 0b111111, "BYPASS"),
|
(JtagChain::IR, 6, 0b000011, "USER2"),
|
||||||
(JtagChain::IR, 6, 0b000011, "USER2"),
|
(JtagChain::DR, 32, 0x0, "USER2"),
|
||||||
(JtagChain::DR, 32, 0x0, "USER2"),
|
(JtagChain::IR, 6, 0b111111, "BYPASS"),
|
||||||
(JtagChain::IR, 6, 0b111111, "BYPASS"),
|
(JtagChain::IR, 6, 0b000011, "USER2"),
|
||||||
(JtagChain::IR, 6, 0b000011, "USER2"),
|
(JtagChain::DR, 42, 0x69, "USER2"),
|
||||||
(JtagChain::DR, 42, 0x69, "USER2"),
|
(JtagChain::IR, 6, 0b111111, "BYPASS"),
|
||||||
(JtagChain::IR, 6, 0b111111, "BYPASS"),
|
(JtagChain::IR, 6, 0b000011, "USER2"),
|
||||||
(JtagChain::IR, 6, 0b000011, "USER2"),
|
(JtagChain::DR, 6, 0xC, "USER2"),
|
||||||
(JtagChain::DR, 6, 0xC, "USER2"),
|
(JtagChain::DR, 42, 0x69, "USER2"),
|
||||||
(JtagChain::DR, 42, 0x69, "USER2"),
|
(JtagChain::IR, 6, 0b111111, "BYPASS"),
|
||||||
(JtagChain::IR, 6, 0b111111, "BYPASS"),
|
(JtagChain::IR, 6, 0b000011, "USER2"),
|
||||||
(JtagChain::IR, 6, 0b000011, "USER2"),
|
(JtagChain::DR, 36, 0x0, "USER2"),
|
||||||
(JtagChain::DR, 36, 0x0, "USER2"),
|
];
|
||||||
];
|
|
||||||
|
|
||||||
let ok: bool = true;
|
let ok: bool = true;
|
||||||
|
|
||||||
|
|
@ -363,26 +389,38 @@ impl EfuseApi {
|
||||||
// handle user special case
|
// handle user special case
|
||||||
if (self.phy.banks[index] ^ add_ecc(self.user >> 8)) != 0 {
|
if (self.phy.banks[index] ^ add_ecc(self.user >> 8)) != 0 {
|
||||||
// compute just the 0->1's and pass that on to burn_bank
|
// 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);
|
self.burn_bank(
|
||||||
|
index,
|
||||||
|
self.phy.banks[index] ^ add_ecc(self.user >> 8) & add_ecc(self.user >> 8),
|
||||||
|
jm,
|
||||||
|
);
|
||||||
}
|
}
|
||||||
} else if index == 11 {
|
} else if index == 11 {
|
||||||
// handle user + key special case
|
// handle user + key special case
|
||||||
let raw_fuse: u32 = ((self.user & 0xFF) << 16) | (self.key[31] as u32) << 8 | self.key[30] as u32;
|
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 {
|
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);
|
self.burn_bank(
|
||||||
|
index,
|
||||||
|
(self.phy.banks[index] ^ add_ecc(raw_fuse)) & add_ecc(raw_fuse),
|
||||||
|
jm,
|
||||||
|
);
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
// handle key fuses (most of the bank)
|
// handle key fuses (most of the bank)
|
||||||
let mut raw_fuse: u32 = 0;
|
let mut raw_fuse: u32 = 0;
|
||||||
for i in 0..3 {
|
for i in 0..3 {
|
||||||
raw_fuse <<= 8;
|
raw_fuse <<= 8;
|
||||||
raw_fuse |= self.key[(index-1)*3 + 2-i] as u32;
|
raw_fuse |= self.key[(index - 1) * 3 + 2 - i] as u32;
|
||||||
}
|
}
|
||||||
if (self.phy.banks[index] ^ add_ecc(raw_fuse)) != 0 {
|
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);
|
self.burn_bank(
|
||||||
|
index,
|
||||||
|
(self.phy.banks[index] ^ add_ecc(raw_fuse)) & add_ecc(raw_fuse),
|
||||||
|
jm,
|
||||||
|
);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
jm.pause(2000);
|
jm.pause(2000);
|
||||||
self.jtag_seq(jm, &COMMIT_SEQ);
|
self.jtag_seq(jm, &COMMIT_SEQ);
|
||||||
|
|
@ -390,5 +428,4 @@ impl EfuseApi {
|
||||||
jm.reset();
|
jm.reset();
|
||||||
ok
|
ok
|
||||||
}
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -19,7 +19,9 @@ pub mod efuse_ecc {
|
||||||
code = (!code & 0x1F) | 0x20;
|
code = (!code & 0x1F) | 0x20;
|
||||||
}
|
}
|
||||||
|
|
||||||
let secded = ((((code >> 5) ^ (code >> 4) ^ (code >> 3) ^ (code >> 2) ^ (code >> 1) ^ code) & 0x1) << 5) | code;
|
let secded = ((((code >> 5) ^ (code >> 4) ^ (code >> 3) ^ (code >> 2) ^ (code >> 1) ^ code) & 0x1)
|
||||||
|
<< 5)
|
||||||
|
| code;
|
||||||
|
|
||||||
data | secded << 24
|
data | secded << 24
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -2,9 +2,9 @@
|
||||||
|
|
||||||
pub mod api;
|
pub mod api;
|
||||||
pub use api::*;
|
pub use api::*;
|
||||||
use xous::{CID, send_message, Message};
|
|
||||||
use xous_ipc::Buffer;
|
|
||||||
use num_traits::*;
|
use num_traits::*;
|
||||||
|
use xous::{send_message, Message, CID};
|
||||||
|
use xous_ipc::Buffer;
|
||||||
|
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
pub struct Jtag {
|
pub struct Jtag {
|
||||||
|
|
@ -13,152 +13,167 @@ pub struct Jtag {
|
||||||
impl Jtag {
|
impl Jtag {
|
||||||
pub fn new(xns: &xous_names::XousNames) -> Result<Self, xous::Error> {
|
pub fn new(xns: &xous_names::XousNames) -> Result<Self, xous::Error> {
|
||||||
REFCOUNT.fetch_add(1, Ordering::Relaxed);
|
REFCOUNT.fetch_add(1, Ordering::Relaxed);
|
||||||
let conn = xns.request_connection_blocking(api::SERVER_NAME_JTAG).expect("Can't connect to JTAG server");
|
let conn =
|
||||||
Ok(Jtag {
|
xns.request_connection_blocking(api::SERVER_NAME_JTAG).expect("Can't connect to JTAG server");
|
||||||
conn
|
Ok(Jtag { conn })
|
||||||
})
|
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn get_id(&self) -> Result<u32, xous::Error> {
|
pub fn get_id(&self) -> Result<u32, xous::Error> {
|
||||||
let response = send_message(self.conn,
|
let response = send_message(
|
||||||
Message::new_blocking_scalar(Opcode::GetId.to_usize().unwrap(), 0, 0, 0, 0)
|
self.conn,
|
||||||
).expect("can't issue get_id message");
|
Message::new_blocking_scalar(Opcode::GetId.to_usize().unwrap(), 0, 0, 0, 0),
|
||||||
if let xous::Result::Scalar1(id)= response {
|
)
|
||||||
Ok(id as u32)
|
.expect("can't issue get_id message");
|
||||||
} else {
|
if let xous::Result::Scalar1(id) = response { Ok(id as u32) } else { Err(xous::Error::InternalError) }
|
||||||
Err(xous::Error::InternalError)
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn get_dna(&self) -> Result<u64, xous::Error> {
|
pub fn get_dna(&self) -> Result<u64, xous::Error> {
|
||||||
let response = send_message(self.conn,
|
let response = send_message(
|
||||||
Message::new_blocking_scalar(Opcode::GetDna.to_usize().unwrap(), 0, 0, 0, 0)
|
self.conn,
|
||||||
).expect("can't issue get_id message");
|
Message::new_blocking_scalar(Opcode::GetDna.to_usize().unwrap(), 0, 0, 0, 0),
|
||||||
if let xous::Result::Scalar2(v1, v2)= response {
|
)
|
||||||
|
.expect("can't issue get_id message");
|
||||||
|
if let xous::Result::Scalar2(v1, v2) = response {
|
||||||
Ok(((v1 as u64) << 32) | v2 as u64)
|
Ok(((v1 as u64) << 32) | v2 as u64)
|
||||||
} else {
|
} else {
|
||||||
Err(xous::Error::InternalError)
|
Err(xous::Error::InternalError)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn efuse_fetch(&self) -> Result<EfuseRecord, xous::Error> {
|
pub fn efuse_fetch(&self) -> Result<EfuseRecord, xous::Error> {
|
||||||
let xmit = EfuseRecord {
|
let xmit = EfuseRecord { key: [0; 32], user: 0, cntl: 0 };
|
||||||
key: [0; 32],
|
|
||||||
user: 0,
|
|
||||||
cntl: 0,
|
|
||||||
};
|
|
||||||
let mut buf = Buffer::into_buf(xmit).or(Err(xous::Error::InternalError))?;
|
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.lend_mut(self.conn, Opcode::EfuseFetch.to_u32().unwrap()).or(Err(xous::Error::InternalError))?;
|
||||||
|
|
||||||
buf.to_original::<EfuseRecord, _>().or(Err(xous::Error::InternalError))
|
buf.to_original::<EfuseRecord, _>().or(Err(xous::Error::InternalError))
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn write_ir(&self, ir: u8) -> Result<(), xous::Error> {
|
pub fn write_ir(&self, ir: u8) -> Result<(), xous::Error> {
|
||||||
send_message(self.conn,
|
send_message(
|
||||||
Message::new_scalar(Opcode::WriteIr.to_usize().unwrap(), ir as usize, 0, 0, 0)
|
self.conn,
|
||||||
).map(|_| ())
|
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> {
|
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))?;
|
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))?;
|
buf.lend_mut(self.conn, Opcode::EfuseKeyBurn.to_u32().unwrap())
|
||||||
|
.or(Err(xous::Error::InternalError))?;
|
||||||
match buf.to_original().unwrap() {
|
match buf.to_original().unwrap() {
|
||||||
EfuseResult::Success => Ok(true),
|
EfuseResult::Success => Ok(true),
|
||||||
EfuseResult::Failure => Ok(false),
|
EfuseResult::Failure => Ok(false),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn efuse_user_burn(&self, user: u32) -> Result<bool, xous::Error> {
|
pub fn efuse_user_burn(&self, user: u32) -> Result<bool, xous::Error> {
|
||||||
let response = send_message(self.conn,
|
let response = send_message(
|
||||||
Message::new_blocking_scalar(Opcode::EfuseUserBurn.to_usize().unwrap(), user as usize, 0, 0, 0)
|
self.conn,
|
||||||
).expect("can't fetch user value");
|
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 let xous::Result::Scalar1(res) = response {
|
||||||
if res == 0 {
|
if res == 0 { Ok(false) } else { Ok(true) }
|
||||||
Ok(false)
|
|
||||||
} else {
|
|
||||||
Ok(true)
|
|
||||||
}
|
|
||||||
} else {
|
} else {
|
||||||
Err(xous::Error::InternalError)
|
Err(xous::Error::InternalError)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn is_efuse_only_boot(&self) -> Result<bool, xous::Error> {
|
pub fn is_efuse_only_boot(&self) -> Result<bool, xous::Error> {
|
||||||
let erec = self.efuse_fetch().expect("couldn't read efuse record");
|
let erec = self.efuse_fetch().expect("couldn't read efuse record");
|
||||||
if (erec.cntl & 0x1) != 0 { Ok(true) } else { Ok(false) }
|
if (erec.cntl & 0x1) != 0 { Ok(true) } else { Ok(false) }
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn is_disable_jtag(&self) -> Result<bool, xous::Error> {
|
pub fn is_disable_jtag(&self) -> Result<bool, xous::Error> {
|
||||||
let erec = self.efuse_fetch().expect("couldn't read efuse record");
|
let erec = self.efuse_fetch().expect("couldn't read efuse record");
|
||||||
if (erec.cntl & 0x2) != 0 { Ok(true) } else { Ok(false) }
|
if (erec.cntl & 0x2) != 0 { Ok(true) } else { Ok(false) }
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn is_efuse_writeable(&self) -> Result<bool, xous::Error> {
|
pub fn is_efuse_writeable(&self) -> Result<bool, xous::Error> {
|
||||||
let erec = self.efuse_fetch().expect("couldn't read efuse record");
|
let erec = self.efuse_fetch().expect("couldn't read efuse record");
|
||||||
if (erec.cntl & 0x4) != 0 { Ok(true) } else { Ok(false) }
|
if (erec.cntl & 0x4) != 0 { Ok(true) } else { Ok(false) }
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn is_key_access_protected(&self) -> Result<bool, xous::Error> {
|
pub fn is_key_access_protected(&self) -> Result<bool, xous::Error> {
|
||||||
let erec = self.efuse_fetch().expect("couldn't read efuse record");
|
let erec = self.efuse_fetch().expect("couldn't read efuse record");
|
||||||
if (erec.cntl & 0x8) != 0 { Ok(true) } else { Ok(false) }
|
if (erec.cntl & 0x8) != 0 { Ok(true) } else { Ok(false) }
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn is_user_and_key_access_protected(&self) -> Result<bool, xous::Error> {
|
pub fn is_user_and_key_access_protected(&self) -> Result<bool, xous::Error> {
|
||||||
let erec = self.efuse_fetch().expect("couldn't read efuse record");
|
let erec = self.efuse_fetch().expect("couldn't read efuse record");
|
||||||
if (erec.cntl & 0x10) != 0 { Ok(true) } else { Ok(false) }
|
if (erec.cntl & 0x10) != 0 { Ok(true) } else { Ok(false) }
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn is_control_write_protected(&self) -> Result<bool, xous::Error> {
|
pub fn is_control_write_protected(&self) -> Result<bool, xous::Error> {
|
||||||
let erec = self.efuse_fetch().expect("couldn't read efuse record");
|
let erec = self.efuse_fetch().expect("couldn't read efuse record");
|
||||||
if (erec.cntl & 0x20) != 0 { Ok(true) } else { Ok(false) }
|
if (erec.cntl & 0x20) != 0 { Ok(true) } else { Ok(false) }
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn get_raw_control_bits(&self) -> Result<u8, xous::Error> {
|
pub fn get_raw_control_bits(&self) -> Result<u8, xous::Error> {
|
||||||
let erec = self.efuse_fetch().expect("couldn't read efuse record");
|
let erec = self.efuse_fetch().expect("couldn't read efuse record");
|
||||||
Ok(erec.cntl)
|
Ok(erec.cntl)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn mod_ctl_efuse(&self, bits_to_set: u8) -> Result<bool, xous::Error> {
|
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 erec = self.efuse_fetch().expect("couldn't read efuse record");
|
||||||
let response = send_message(self.conn,
|
let response = send_message(
|
||||||
Message::new_blocking_scalar(Opcode::EfuseCtlBurn.to_usize().unwrap(), (erec.cntl | bits_to_set) as usize, 0, 0, 0)
|
self.conn,
|
||||||
).expect("can't issue config burn message");
|
Message::new_blocking_scalar(
|
||||||
if let xous::Result::Scalar1(r)= response {
|
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) }
|
if r != 0 { Ok(true) } else { Ok(false) }
|
||||||
} else {
|
} else {
|
||||||
Err(xous::Error::InternalError)
|
Err(xous::Error::InternalError)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
pub fn burn_efuse_only_boot(&self) -> Result<bool, xous::Error> {
|
|
||||||
self.mod_ctl_efuse(0x1)
|
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> {
|
pub fn burn_disable_jtag(&self) -> Result<bool, xous::Error> { self.mod_ctl_efuse(0x2) }
|
||||||
self.mod_ctl_efuse(0x2)
|
|
||||||
}
|
pub fn burn_efuse_write_protect(&self) -> Result<bool, xous::Error> { self.mod_ctl_efuse(0x4) }
|
||||||
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_key_access_protect(&self) -> Result<bool, xous::Error> {
|
pub fn burn_user_and_key_access_protect(&self) -> Result<bool, xous::Error> { self.mod_ctl_efuse(0x10) }
|
||||||
self.mod_ctl_efuse(0x8)
|
|
||||||
}
|
pub fn burn_control_write_protect(&self) -> Result<bool, xous::Error> { self.mod_ctl_efuse(0x20) }
|
||||||
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)
|
|
||||||
}
|
|
||||||
/// Sets all the fuses, except `disable_jtag` and `control_write_protect`.
|
/// Sets all the fuses, except `disable_jtag` and `control_write_protect`.
|
||||||
/// This forces the device to:
|
/// This forces the device to:
|
||||||
/// - only boot from an encrypted image (so unbricking via JTAG requires you to provide an encryption key)
|
/// - only boot from an encrypted image (so unbricking via JTAG requires you to provide an encryption
|
||||||
|
/// key)
|
||||||
/// - key update disallowed
|
/// - key update disallowed
|
||||||
/// - key readback disallowed
|
/// - key readback disallowed
|
||||||
/// - user bits can be read out (but they can't be updated)
|
/// - user bits can be read out (but they can't be updated)
|
||||||
/// - control bits can still be blown (so you can still set `disable_jtag` later on;
|
/// - control bits can still be blown (so you can still set `disable_jtag` later on; however, it is
|
||||||
/// however, it is physically impossible to unset bits, so it is not possible to
|
/// physically impossible to unset bits, so it is not possible to enable key readback despite being
|
||||||
/// enable key readback despite being able to write bits)
|
/// able to write bits)
|
||||||
pub fn seal_device(&self) -> Result<bool, xous::Error> {
|
pub fn seal_device(&self) -> Result<bool, xous::Error> { self.mod_ctl_efuse(0b00_1101) }
|
||||||
self.mod_ctl_efuse(0b00_1101)
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
use core::sync::atomic::{AtomicU32, Ordering};
|
use core::sync::atomic::{AtomicU32, Ordering};
|
||||||
static REFCOUNT: AtomicU32 = AtomicU32::new(0);
|
static REFCOUNT: AtomicU32 = AtomicU32::new(0);
|
||||||
impl Drop for Jtag {
|
impl Drop for Jtag {
|
||||||
fn drop(&mut self) {
|
fn drop(&mut self) {
|
||||||
// the connection to the server side must be reference counted, so that multiple instances of this object within
|
// the connection to the server side must be reference counted, so that multiple instances of this
|
||||||
// a single process do not end up de-allocating the CID on other threads before they go out of scope.
|
// object within a single process do not end up de-allocating the CID on other threads before
|
||||||
// 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".
|
// 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.fetch_sub(1, Ordering::Relaxed) == 1 {
|
if REFCOUNT.fetch_sub(1, Ordering::Relaxed) == 1 {
|
||||||
unsafe{xous::disconnect(self.conn).unwrap();}
|
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),
|
// if there was object-specific state (such as a one-time use server for async callbacks, specific to
|
||||||
// de-allocate those items here. They don't need a reference count because they are object-specific
|
// the object instance), de-allocate those items here. They don't need a reference count
|
||||||
|
// because they are object-specific
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -6,10 +6,11 @@ mod efuse_api;
|
||||||
mod efuse_ecc;
|
mod efuse_ecc;
|
||||||
|
|
||||||
use api::*;
|
use api::*;
|
||||||
|
use efuse_api::*;
|
||||||
use num_traits::*;
|
use num_traits::*;
|
||||||
use xous::{msg_blocking_scalar_unpack, msg_scalar_unpack};
|
use xous::{msg_blocking_scalar_unpack, msg_scalar_unpack};
|
||||||
use xous_ipc::Buffer;
|
use xous_ipc::Buffer;
|
||||||
use efuse_api::*;
|
|
||||||
use crate::implementation::JtagPhy;
|
use crate::implementation::JtagPhy;
|
||||||
|
|
||||||
pub enum JtagState {
|
pub enum JtagState {
|
||||||
|
|
@ -32,7 +33,7 @@ pub enum JtagChain {
|
||||||
|
|
||||||
pub enum JtagEndian {
|
pub enum JtagEndian {
|
||||||
Big, // MSB-first shiftout
|
Big, // MSB-first shiftout
|
||||||
Little // LSB-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 1: make a "leg" machine that contains the shift-in/shift-out records specific to each leg
|
||||||
|
|
@ -41,7 +42,6 @@ pub enum JtagEndian {
|
||||||
/// I think we want a machine that has a Vector which holds a set of instructions that encapsulate either
|
/// 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
|
/// 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.
|
/// executed; after execution, there is a result vector that is now valid.
|
||||||
///
|
|
||||||
#[derive(Clone)]
|
#[derive(Clone)]
|
||||||
pub struct JtagLeg {
|
pub struct JtagLeg {
|
||||||
/// which chain (DR or IR)
|
/// which chain (DR or IR)
|
||||||
|
|
@ -56,12 +56,7 @@ pub struct JtagLeg {
|
||||||
|
|
||||||
impl JtagLeg {
|
impl JtagLeg {
|
||||||
pub fn new(chain_type: JtagChain, mytag: &str) -> Self {
|
pub fn new(chain_type: JtagChain, mytag: &str) -> Self {
|
||||||
JtagLeg {
|
JtagLeg { c: chain_type, o: Vec::new(), i: Vec::new(), tag: String::from(mytag) }
|
||||||
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)
|
/// `push` will take data in the form of an unsigned int (either u128 or u32)
|
||||||
|
|
@ -81,11 +76,19 @@ impl JtagLeg {
|
||||||
for i in 0..count {
|
for i in 0..count {
|
||||||
match endian {
|
match endian {
|
||||||
JtagEndian::Big => {
|
JtagEndian::Big => {
|
||||||
if (data & (1 << i)) == 0 { self.i.push(false) } else { self.i.push(true) }
|
if (data & (1 << i)) == 0 {
|
||||||
},
|
self.i.push(false)
|
||||||
|
} else {
|
||||||
|
self.i.push(true)
|
||||||
|
}
|
||||||
|
}
|
||||||
JtagEndian::Little => {
|
JtagEndian::Little => {
|
||||||
if (data & (1 << (count-1-i))) == 0 { self.i.push(false) } else { self.i.push(true) }
|
if (data & (1 << (count - 1 - i))) == 0 {
|
||||||
},
|
self.i.push(false)
|
||||||
|
} else {
|
||||||
|
self.i.push(true)
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -95,11 +98,19 @@ impl JtagLeg {
|
||||||
for i in 0..count {
|
for i in 0..count {
|
||||||
match endian {
|
match endian {
|
||||||
JtagEndian::Big => {
|
JtagEndian::Big => {
|
||||||
if (data & (1 << i)) == 0 { self.i.push(false) } else { self.i.push(true) }
|
if (data & (1 << i)) == 0 {
|
||||||
},
|
self.i.push(false)
|
||||||
|
} else {
|
||||||
|
self.i.push(true)
|
||||||
|
}
|
||||||
|
}
|
||||||
JtagEndian::Little => {
|
JtagEndian::Little => {
|
||||||
if (data & (1 << (count-1-i))) == 0 { self.i.push(false) } else { self.i.push(true) }
|
if (data & (1 << (count - 1 - i))) == 0 {
|
||||||
},
|
self.i.push(false)
|
||||||
|
} else {
|
||||||
|
self.i.push(true)
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -109,11 +120,19 @@ impl JtagLeg {
|
||||||
for i in 0..count {
|
for i in 0..count {
|
||||||
match endian {
|
match endian {
|
||||||
JtagEndian::Big => {
|
JtagEndian::Big => {
|
||||||
if (data & (1 << i)) == 0 { self.i.push(false) } else { self.i.push(true) }
|
if (data & (1 << i)) == 0 {
|
||||||
},
|
self.i.push(false)
|
||||||
|
} else {
|
||||||
|
self.i.push(true)
|
||||||
|
}
|
||||||
|
}
|
||||||
JtagEndian::Little => {
|
JtagEndian::Little => {
|
||||||
if (data & (1 << (count-1-i))) == 0 { self.i.push(false) } else { self.i.push(true) }
|
if (data & (1 << (count - 1 - i))) == 0 {
|
||||||
},
|
self.i.push(false)
|
||||||
|
} else {
|
||||||
|
self.i.push(true)
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -131,11 +150,15 @@ impl JtagLeg {
|
||||||
match endian {
|
match endian {
|
||||||
JtagEndian::Little => {
|
JtagEndian::Little => {
|
||||||
data <<= 1;
|
data <<= 1;
|
||||||
if self.o.pop().unwrap() { data |= 0x1; }
|
if self.o.pop().unwrap() {
|
||||||
|
data |= 0x1;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
JtagEndian::Big => {
|
JtagEndian::Big => {
|
||||||
data >>= 1;
|
data >>= 1;
|
||||||
if self.o.pop().unwrap() { data |= 0x8000_0000; }
|
if self.o.pop().unwrap() {
|
||||||
|
data |= 0x8000_0000;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -158,11 +181,15 @@ impl JtagLeg {
|
||||||
match endian {
|
match endian {
|
||||||
JtagEndian::Little => {
|
JtagEndian::Little => {
|
||||||
data <<= 1;
|
data <<= 1;
|
||||||
if self.o.pop().unwrap() { data |= 0x1; }
|
if self.o.pop().unwrap() {
|
||||||
},
|
data |= 0x1;
|
||||||
|
}
|
||||||
|
}
|
||||||
JtagEndian::Big => {
|
JtagEndian::Big => {
|
||||||
data >>= 1;
|
data >>= 1;
|
||||||
if self.o.pop().unwrap() { data |= 0x8000_0000_0000_0000_0000_0000_0000_0000; }
|
if self.o.pop().unwrap() {
|
||||||
|
data |= 0x8000_0000_0000_0000_0000_0000_0000_0000;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -183,11 +210,15 @@ impl JtagLeg {
|
||||||
match endian {
|
match endian {
|
||||||
JtagEndian::Little => {
|
JtagEndian::Little => {
|
||||||
data <<= 1;
|
data <<= 1;
|
||||||
if self.o.pop().unwrap() { data |= 0x1; }
|
if self.o.pop().unwrap() {
|
||||||
|
data |= 0x1;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
JtagEndian::Big => {
|
JtagEndian::Big => {
|
||||||
data >>= 1;
|
data >>= 1;
|
||||||
if self.o.pop().unwrap() { data |= 0x80; }
|
if self.o.pop().unwrap() {
|
||||||
|
data |= 0x80;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -195,25 +226,22 @@ impl JtagLeg {
|
||||||
Some(data)
|
Some(data)
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn tag(&self) -> String {
|
pub fn tag(&self) -> String { self.tag.clone() }
|
||||||
self.tag.clone()
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn dbg_i_len(&self) -> usize {
|
pub fn dbg_i_len(&self) -> usize { self.i.len() }
|
||||||
self.i.len()
|
|
||||||
}
|
pub fn dbg_o_len(&self) -> usize { self.o.len() }
|
||||||
pub fn dbg_o_len(&self) -> usize {
|
|
||||||
self.o.len()
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct JtagMach {
|
pub struct JtagMach {
|
||||||
/// current state (could be in one of two generics, or in DR/IR chain; check top of Vector for current chain)
|
/// current state (could be in one of two generics, or in DR/IR chain; check top of Vector for current
|
||||||
|
/// chain)
|
||||||
s: JtagState,
|
s: JtagState,
|
||||||
/// a vector of legs to traverse. An entry stays in pending until the traversal is complete. Aborted
|
/// a vector of legs to traverse. An entry stays in pending until the traversal is complete. Aborted
|
||||||
/// traversals leave the leg in place
|
/// traversals leave the leg in place
|
||||||
pending: Vec<JtagLeg>,
|
pending: Vec<JtagLeg>,
|
||||||
/// a vector of legs traversed. An entry is only put into the done vector once its traversal is completed.
|
/// a vector of legs traversed. An entry is only put into the done vector once its traversal is
|
||||||
|
/// completed.
|
||||||
done: Vec<JtagLeg>,
|
done: Vec<JtagLeg>,
|
||||||
/// the current leg being processed
|
/// the current leg being processed
|
||||||
current: Option<JtagLeg>,
|
current: Option<JtagLeg>,
|
||||||
|
|
@ -236,9 +264,10 @@ impl JtagMach {
|
||||||
ticktimer: ticktimer_server::Ticktimer::new().unwrap(),
|
ticktimer: ticktimer_server::Ticktimer::new().unwrap(),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// pause for a given number of microseconds.
|
/// pause for a given number of microseconds.
|
||||||
pub fn pause(&mut self, us: u32) {
|
pub fn pause(&mut self, us: u32) {
|
||||||
let mut delay: u32 = us/1000;
|
let mut delay: u32 = us / 1000;
|
||||||
if delay == 0 {
|
if delay == 0 {
|
||||||
delay = 1;
|
delay = 1;
|
||||||
}
|
}
|
||||||
|
|
@ -246,54 +275,33 @@ impl JtagMach {
|
||||||
}
|
}
|
||||||
|
|
||||||
/// add() -- add a leg to the pending queue
|
/// add() -- add a leg to the pending queue
|
||||||
pub fn add(&mut self, leg: JtagLeg) {
|
pub fn add(&mut self, leg: JtagLeg) { self.pending.push(leg); }
|
||||||
self.pending.push(leg);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// get() -- get the oldest result in the done queue. Returns an option.
|
/// get() -- get the oldest result in the done queue. Returns an option.
|
||||||
pub fn get(&mut self) -> Option<JtagLeg> {
|
pub fn get(&mut self) -> Option<JtagLeg> {
|
||||||
if self.done.len() > 0 {
|
if self.done.len() > 0 { Some(self.done.remove(0)) } else { None }
|
||||||
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.
|
/// has_pending() -- tells if the jtag machine has a pending leg to traverse. Returns the tag of the
|
||||||
pub fn has_pending(&self) -> bool {
|
/// pending item, or None.
|
||||||
if self.pending.len() > 0 {
|
pub fn has_pending(&self) -> bool { if self.pending.len() > 0 { true } else { false } }
|
||||||
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.
|
/// 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)]
|
#[allow(dead_code)]
|
||||||
pub fn has_done(&self) -> bool {
|
pub fn has_done(&self) -> bool { if self.done.len() > 0 { true } else { false } }
|
||||||
if self.done.len() > 0 {
|
|
||||||
true
|
|
||||||
} else {
|
|
||||||
false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// for debug
|
/// for debug
|
||||||
#[allow(dead_code)]
|
#[allow(dead_code)]
|
||||||
pub fn pending_len(&self) -> usize {
|
pub fn pending_len(&self) -> usize { self.pending.len() }
|
||||||
self.pending.len()
|
|
||||||
}
|
|
||||||
/// for debug
|
/// for debug
|
||||||
#[allow(dead_code)]
|
#[allow(dead_code)]
|
||||||
pub fn done_len(&self) -> usize {
|
pub fn done_len(&self) -> usize { self.done.len() }
|
||||||
self.done.len()
|
|
||||||
}
|
pub fn dbg_reset(&mut self) { self.debug = 0; }
|
||||||
pub fn dbg_reset(&mut self) {
|
|
||||||
self.debug = 0;
|
pub fn dbg_get(&self) -> u32 { self.debug }
|
||||||
}
|
|
||||||
pub fn dbg_get(&self) -> u32 {
|
|
||||||
self.debug
|
|
||||||
}
|
|
||||||
|
|
||||||
/// step() -- move state machine by one cycle
|
/// step() -- move state machine by one cycle
|
||||||
/// if there is nothing in the pending queue, stay in idle
|
/// if there is nothing in the pending queue, stay in idle
|
||||||
|
|
@ -303,7 +311,7 @@ impl JtagMach {
|
||||||
JtagState::TestReset => {
|
JtagState::TestReset => {
|
||||||
self.phy.sync(false, false);
|
self.phy.sync(false, false);
|
||||||
JtagState::RunIdle
|
JtagState::RunIdle
|
||||||
},
|
}
|
||||||
JtagState::RunIdle => {
|
JtagState::RunIdle => {
|
||||||
// we have a current item, traverse to the correct tree based on the type
|
// we have a current item, traverse to the correct tree based on the type
|
||||||
if let Some(ref mut cur) = self.current {
|
if let Some(ref mut cur) = self.current {
|
||||||
|
|
@ -311,7 +319,7 @@ impl JtagMach {
|
||||||
JtagChain::DR => {
|
JtagChain::DR => {
|
||||||
self.debug = 2;
|
self.debug = 2;
|
||||||
self.phy.sync(false, true);
|
self.phy.sync(false, true);
|
||||||
},
|
}
|
||||||
JtagChain::IR => {
|
JtagChain::IR => {
|
||||||
self.debug = 3;
|
self.debug = 3;
|
||||||
// must be IR -- do two TMS high pulses to get to the IR leg
|
// must be IR -- do two TMS high pulses to get to the IR leg
|
||||||
|
|
@ -333,16 +341,16 @@ impl JtagMach {
|
||||||
}
|
}
|
||||||
JtagState::RunIdle
|
JtagState::RunIdle
|
||||||
}
|
}
|
||||||
},
|
}
|
||||||
JtagState::Select => {
|
JtagState::Select => {
|
||||||
self.phy.sync(false, false);
|
self.phy.sync(false, false);
|
||||||
JtagState::Capture
|
JtagState::Capture
|
||||||
},
|
}
|
||||||
JtagState::Capture => {
|
JtagState::Capture => {
|
||||||
// always move to shift, because leg structures always have data
|
// always move to shift, because leg structures always have data
|
||||||
self.phy.sync(false, false);
|
self.phy.sync(false, false);
|
||||||
JtagState::Shift
|
JtagState::Shift
|
||||||
},
|
}
|
||||||
JtagState::Shift => {
|
JtagState::Shift => {
|
||||||
// shift data until the input vector is exhausted
|
// shift data until the input vector is exhausted
|
||||||
if let Some(ref mut cur) = self.current {
|
if let Some(ref mut cur) = self.current {
|
||||||
|
|
@ -367,19 +375,19 @@ impl JtagMach {
|
||||||
// Shouldn't happen: No "Current", but move on gracefully
|
// Shouldn't happen: No "Current", but move on gracefully
|
||||||
JtagState::Exit1
|
JtagState::Exit1
|
||||||
}
|
}
|
||||||
},
|
}
|
||||||
JtagState::Exit1 => {
|
JtagState::Exit1 => {
|
||||||
self.phy.sync(false, true);
|
self.phy.sync(false, true);
|
||||||
JtagState::Update
|
JtagState::Update
|
||||||
},
|
}
|
||||||
JtagState::Pause => {
|
JtagState::Pause => {
|
||||||
self.phy.sync(false, true);
|
self.phy.sync(false, true);
|
||||||
JtagState::Exit2
|
JtagState::Exit2
|
||||||
},
|
}
|
||||||
JtagState::Exit2 => {
|
JtagState::Exit2 => {
|
||||||
self.phy.sync(false, true);
|
self.phy.sync(false, true);
|
||||||
JtagState::Update
|
JtagState::Update
|
||||||
},
|
}
|
||||||
JtagState::Update => {
|
JtagState::Update => {
|
||||||
self.phy.sync(false, false);
|
self.phy.sync(false, false);
|
||||||
|
|
||||||
|
|
@ -401,7 +409,8 @@ impl JtagMach {
|
||||||
self.s = JtagState::TestReset;
|
self.s = JtagState::TestReset;
|
||||||
}
|
}
|
||||||
|
|
||||||
/// next() -- advance until a RUN_IDLE state. If currently RUN_IDLE, traverse the next available leg, if one exists
|
/// next() -- advance until a RUN_IDLE state. If currently RUN_IDLE, traverse the next available leg, if
|
||||||
|
/// one exists
|
||||||
pub fn next(&mut self) {
|
pub fn next(&mut self) {
|
||||||
match self.s {
|
match self.s {
|
||||||
JtagState::RunIdle | JtagState::TestReset => {
|
JtagState::RunIdle | JtagState::TestReset => {
|
||||||
|
|
@ -423,21 +432,22 @@ impl JtagMach {
|
||||||
} else {
|
} else {
|
||||||
self.step(); // this should be a single step with no state change
|
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
|
// in the case that we're not already in idle or reset, run the machine until we get to idle
|
||||||
|
// or reset
|
||||||
loop {
|
loop {
|
||||||
match self.s {
|
match self.s {
|
||||||
JtagState::RunIdle | JtagState::TestReset => break,
|
JtagState::RunIdle | JtagState::TestReset => break,
|
||||||
_ => self.step(),
|
_ => self.step(),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
},
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(any(feature="precursor", feature="renode"))]
|
#[cfg(any(feature = "precursor", feature = "renode"))]
|
||||||
mod implementation {
|
mod implementation {
|
||||||
use utralib::generated::*;
|
use utralib::generated::*;
|
||||||
|
|
||||||
|
|
@ -456,22 +466,22 @@ mod implementation {
|
||||||
)
|
)
|
||||||
.expect("couldn't map JTAG CSR range");
|
.expect("couldn't map JTAG CSR range");
|
||||||
|
|
||||||
let jtag = JtagPhy {
|
let jtag = JtagPhy { csr: CSR::new(csr.as_mut_ptr() as *mut u32) };
|
||||||
csr: CSR::new(csr.as_mut_ptr() as *mut u32),
|
|
||||||
};
|
|
||||||
|
|
||||||
jtag
|
jtag
|
||||||
}
|
}
|
||||||
|
|
||||||
/// given a tdi and tms value, pulse the clock, and then return the tdo that comes out
|
/// 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 {
|
pub fn sync(&mut self, tdi: bool, tms: bool) -> bool {
|
||||||
self.csr.wo(utra::jtag::NEXT,
|
self.csr.wo(
|
||||||
self.csr.ms(utra::jtag::NEXT_TDI, if tdi {1} else {0}) |
|
utra::jtag::NEXT,
|
||||||
self.csr.ms(utra::jtag::NEXT_TMS, if tms {1} else {0})
|
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
|
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
|
if self.csr.rf(utra::jtag::TDO_TDO) == 0 {
|
||||||
|
// this is the TDO value from /prior/ to the TCK rise
|
||||||
false
|
false
|
||||||
} else {
|
} else {
|
||||||
true
|
true
|
||||||
|
|
@ -485,21 +495,15 @@ mod implementation {
|
||||||
// a stub to try to avoid breaking hosted mode for as long as possible.
|
// a stub to try to avoid breaking hosted mode for as long as possible.
|
||||||
#[cfg(not(target_os = "xous"))]
|
#[cfg(not(target_os = "xous"))]
|
||||||
mod implementation {
|
mod implementation {
|
||||||
pub struct JtagPhy {
|
pub struct JtagPhy {}
|
||||||
}
|
|
||||||
|
|
||||||
impl JtagPhy {
|
impl JtagPhy {
|
||||||
pub fn new() -> JtagPhy {
|
pub fn new() -> JtagPhy { JtagPhy {} }
|
||||||
JtagPhy {
|
|
||||||
}
|
pub fn sync(&mut self, _tdi: bool, _tms: bool) -> bool { false }
|
||||||
}
|
|
||||||
pub fn sync(&mut self, _tdi: bool, _tms: bool) -> bool {
|
|
||||||
false
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
fn main() -> ! {
|
fn main() -> ! {
|
||||||
log_server::init_wait().unwrap();
|
log_server::init_wait().unwrap();
|
||||||
log::set_max_level(log::LevelFilter::Info);
|
log::set_max_level(log::LevelFilter::Info);
|
||||||
|
|
@ -510,9 +514,9 @@ fn main() -> ! {
|
||||||
// - one connection from the key server
|
// - one connection from the key server
|
||||||
// - one connection from shellchat for command line
|
// - one connection from shellchat for command line
|
||||||
// - another connection from shellchat for oqc testing
|
// - another connection from shellchat for oqc testing
|
||||||
#[cfg(all(any(feature="precursor", feature="renode"), not(feature="dvt")))]
|
#[cfg(all(any(feature = "precursor", feature = "renode"), not(feature = "dvt")))]
|
||||||
let jtag_sid = xns.register_name(api::SERVER_NAME_JTAG, Some(3)).expect("can't register server");
|
let jtag_sid = xns.register_name(api::SERVER_NAME_JTAG, Some(3)).expect("can't register server");
|
||||||
#[cfg(all(any(feature="precursor", feature="renode"), feature="dvt"))] // dvt build has less in it
|
#[cfg(all(any(feature = "precursor", feature = "renode"), feature = "dvt"))] // dvt build has less in it
|
||||||
let jtag_sid = xns.register_name(api::SERVER_NAME_JTAG, Some(2)).expect("can't register server");
|
let jtag_sid = xns.register_name(api::SERVER_NAME_JTAG, Some(2)).expect("can't register server");
|
||||||
#[cfg(not(target_os = "xous"))]
|
#[cfg(not(target_os = "xous"))]
|
||||||
let jtag_sid = xns.register_name(api::SERVER_NAME_JTAG, Some(2)).expect("can't register server");
|
let jtag_sid = xns.register_name(api::SERVER_NAME_JTAG, Some(2)).expect("can't register server");
|
||||||
|
|
@ -536,7 +540,8 @@ fn main() -> ! {
|
||||||
jtag.add(id_leg);
|
jtag.add(id_leg);
|
||||||
jtag.next();
|
jtag.next();
|
||||||
// NOW: - check the return data on .get() before using it
|
// NOW: - check the return data on .get() before using it
|
||||||
if jtag.get().is_none() { // discard ID code but check that there's something
|
if jtag.get().is_none() {
|
||||||
|
// discard ID code but check that there's something
|
||||||
log::error!("ID instruction not in get queue!");
|
log::error!("ID instruction not in get queue!");
|
||||||
xous::return_scalar(msg.sender, 0xFFFF_FFFF).unwrap();
|
xous::return_scalar(msg.sender, 0xFFFF_FFFF).unwrap();
|
||||||
continue;
|
continue;
|
||||||
|
|
@ -548,7 +553,8 @@ fn main() -> ! {
|
||||||
jtag.dbg_reset();
|
jtag.dbg_reset();
|
||||||
jtag.next();
|
jtag.next();
|
||||||
let d: u32 = jtag.dbg_get();
|
let d: u32 = jtag.dbg_get();
|
||||||
if let Some(mut iddata) = jtag.get() { // this contains the actual idcode data
|
if let Some(mut iddata) = jtag.get() {
|
||||||
|
// this contains the actual idcode data
|
||||||
let id = iddata.pop_u32(32, JtagEndian::Little).unwrap();
|
let id = iddata.pop_u32(32, JtagEndian::Little).unwrap();
|
||||||
log::trace!("tag: {}, code: 0x{:08x}, d:{}", iddata.tag(), id, d);
|
log::trace!("tag: {}, code: 0x{:08x}, d:{}", iddata.tag(), id, d);
|
||||||
xous::return_scalar(msg.sender, id as usize).unwrap();
|
xous::return_scalar(msg.sender, id as usize).unwrap();
|
||||||
|
|
@ -562,7 +568,8 @@ fn main() -> ! {
|
||||||
ir_leg.push_u32(0b110010, 6, JtagEndian::Little);
|
ir_leg.push_u32(0b110010, 6, JtagEndian::Little);
|
||||||
jtag.add(ir_leg);
|
jtag.add(ir_leg);
|
||||||
jtag.next();
|
jtag.next();
|
||||||
if jtag.get().is_none() { // discard ID code but check that there's something
|
if jtag.get().is_none() {
|
||||||
|
// discard ID code but check that there's something
|
||||||
log::error!("cmd instruction not in get queue!");
|
log::error!("cmd instruction not in get queue!");
|
||||||
xous::return_scalar2(msg.sender, 0xFFFF_FFFF, 0xFFFF).unwrap();
|
xous::return_scalar2(msg.sender, 0xFFFF_FFFF, 0xFFFF).unwrap();
|
||||||
}
|
}
|
||||||
|
|
@ -582,7 +589,8 @@ fn main() -> ! {
|
||||||
}),
|
}),
|
||||||
Some(Opcode::EfuseFetch) => {
|
Some(Opcode::EfuseFetch) => {
|
||||||
efuse.fetch(&mut jtag);
|
efuse.fetch(&mut jtag);
|
||||||
let mut buffer = unsafe{Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap())};
|
let mut buffer =
|
||||||
|
unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
|
||||||
let mut efuse_rec = buffer.to_original::<EfuseRecord, _>().unwrap();
|
let mut efuse_rec = buffer.to_original::<EfuseRecord, _>().unwrap();
|
||||||
|
|
||||||
efuse_rec.user = efuse.phy_user();
|
efuse_rec.user = efuse.phy_user();
|
||||||
|
|
@ -596,13 +604,15 @@ fn main() -> ! {
|
||||||
ir_leg.push_u32(ir as u32, 6, JtagEndian::Little); // ISC_ENABLE
|
ir_leg.push_u32(ir as u32, 6, JtagEndian::Little); // ISC_ENABLE
|
||||||
jtag.add(ir_leg);
|
jtag.add(ir_leg);
|
||||||
jtag.next();
|
jtag.next();
|
||||||
if jtag.get().is_none() { // discard ID code but check that there's something
|
if jtag.get().is_none() {
|
||||||
|
// discard ID code but check that there's something
|
||||||
log::error!("cmd instruction not in get queue!");
|
log::error!("cmd instruction not in get queue!");
|
||||||
}
|
}
|
||||||
}),
|
}),
|
||||||
Some(Opcode::EfuseKeyBurn) => {
|
Some(Opcode::EfuseKeyBurn) => {
|
||||||
susres.set_suspendable(false).unwrap();
|
susres.set_suspendable(false).unwrap();
|
||||||
let mut buffer = unsafe{Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap())};
|
let mut buffer =
|
||||||
|
unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
|
||||||
let key = buffer.to_original::<[u8; 32], _>().unwrap();
|
let key = buffer.to_original::<[u8; 32], _>().unwrap();
|
||||||
// refresh the efuse cache
|
// refresh the efuse cache
|
||||||
efuse.fetch(&mut jtag);
|
efuse.fetch(&mut jtag);
|
||||||
|
|
@ -614,7 +624,9 @@ fn main() -> ! {
|
||||||
if efuse.is_valid() {
|
if efuse.is_valid() {
|
||||||
log::info!("efuse key is valid to burn, proceeding. There is no return...");
|
log::info!("efuse key is valid to burn, proceeding. There is no return...");
|
||||||
if cfg!(feature = "dry-run") {
|
if cfg!(feature = "dry-run") {
|
||||||
log::info!("Dry run selected, key NOT BURNED. Device will be in an inconsistent state.");
|
log::info!(
|
||||||
|
"Dry run selected, key NOT BURNED. Device will be in an inconsistent state."
|
||||||
|
);
|
||||||
} else {
|
} else {
|
||||||
efuse.burn(&mut jtag);
|
efuse.burn(&mut jtag);
|
||||||
}
|
}
|
||||||
|
|
@ -632,7 +644,9 @@ fn main() -> ! {
|
||||||
if efuse.is_valid() {
|
if efuse.is_valid() {
|
||||||
log::info!("control is valid to burn, proceeding. There is no return...");
|
log::info!("control is valid to burn, proceeding. There is no return...");
|
||||||
if cfg!(feature = "dry-run") {
|
if cfg!(feature = "dry-run") {
|
||||||
log::info!("Dry run selected, control fuses NOT BURNED. Device will be in an inconsistent state.");
|
log::info!(
|
||||||
|
"Dry run selected, control fuses NOT BURNED. Device will be in an inconsistent state."
|
||||||
|
);
|
||||||
} else {
|
} else {
|
||||||
efuse.burn(&mut jtag);
|
efuse.burn(&mut jtag);
|
||||||
}
|
}
|
||||||
|
|
@ -650,7 +664,9 @@ fn main() -> ! {
|
||||||
if efuse.is_valid() {
|
if efuse.is_valid() {
|
||||||
log::info!("user fuses are valid to burn, proceeding. There is no return...");
|
log::info!("user fuses are valid to burn, proceeding. There is no return...");
|
||||||
if cfg!(feature = "dry-run") {
|
if cfg!(feature = "dry-run") {
|
||||||
log::info!("Dry run selected, user fuse NOT BURNED. Device will be in an inconsistent state.");
|
log::info!(
|
||||||
|
"Dry run selected, user fuse NOT BURNED. Device will be in an inconsistent state."
|
||||||
|
);
|
||||||
} else {
|
} else {
|
||||||
efuse.burn(&mut jtag);
|
efuse.burn(&mut jtag);
|
||||||
}
|
}
|
||||||
|
|
@ -663,7 +679,7 @@ fn main() -> ! {
|
||||||
}),
|
}),
|
||||||
None => {
|
None => {
|
||||||
log::error!("couldn't convert opcode");
|
log::error!("couldn't convert opcode");
|
||||||
break
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue