indexed smn

Add commands to read/write other SMN pairs, so that we can try
and access things like HSMP.

Signed-off-by: Dan Cross <cross@oxidecomputer.com>

Author: dancrossnyc

README.md

@@ -243,8 +243,12 @@ Supported commands include:
   sizes, issue mulitple `unmap` calls.
 * `rdsmn <addr>` to read a 32-bit word from the given SMN
   address.
+* `rdsmni <index> <addr>` like `rdsmn`, but using a specific
+  address/data register pair.
 * `wrsmn <addr> <value>` to write a 32-bit word to the given SMN
   address.
+* `wrsmni <index> <addr>` like `wrsmn`, but using a spcecific
+  address/data register pair.
 * `cpuid <leaf> <subleaf>` to return the results of the `CPUID`
   instruction for the given leaf and subleaf.
 * `ecamrd <b/d/f> <offset>` read a 32-bit word from PCIe

src/repl/ecam.rs

@@ -29,7 +29,7 @@ pub(super) fn read(
     env: &mut Vec<repl::Value>,
 ) -> Result<repl::Value> {
     let usage = |error| {
-        println!("usage: ecamrd <addr>");
+        println!("usage: ecamrd b/d/f <offset>");
         error
     };
     let (bus, dev, func) = repl::popenv(env)
@@ -57,7 +57,7 @@ pub(super) fn write(
     env: &mut Vec<repl::Value>,
 ) -> Result<repl::Value> {
     let usage = |error| {
-        println!("usage: ecamwr <addr> <value>");
+        println!("usage: ecamwr b/d/f <offset> <value>");
         error
     };
     let (bus, dev, func) = repl::popenv(env)

src/repl/mod.rs

@@ -264,6 +264,7 @@ fn evalcmd(
         "push" => Ok(Value::Nil),
         "rdmsr" => msr::read(config, env),
         "rdsmn" => smn::read(config, env),
+        "rdsmni" => smn::rdsmni(config, env),
         "rx" => rx::run(config, env),
         "rz" => rz::run(config, env),
         "setbits" => bits::set(config, env),
@@ -274,6 +275,7 @@ fn evalcmd(
         "umount" => mount::umount(config, env),
         "wrmsr" => msr::write(config, env),
         "wrsmn" => smn::write(config, env),
+        "wrsmni" => smn::wrsmni(config, env),
         _ => Err(Error::NoCommand),
     }
 }

src/repl/reader.rs

@@ -443,8 +443,12 @@ Supported commands include:
   sizes, issue mulitple `unmap` calls.
 * `rdsmn <addr>` to read a 32-bit word from the given SMN
   address.
+* `rdsmni <index> <addr>` like `rdsmn`, but using a specific
+  address/data register pair.
 * `wrsmn <addr> <value>` to write a 32-bit word to the given SMN
   address.
+* `wrsmni <index> <addr>` like `wrsmn`, but using a spcecific
+  address/data register pair.
 * `cpuid <leaf> <subleaf>` to return the results of the `CPUID`
   instruction for the given leaf and subleaf.
 * `ecamrd <b/d/f> <offset>` read a 32-bit word from PCIe

src/repl/smn.rs

@@ -18,7 +18,7 @@ pub(super) fn read(
         error
     };
     let addr = repl::popenv(env).as_num::<u32>().map_err(usage)?;
-    let data = smn::read(addr).map_err(usage)?;
+    let data = smn::read(smn::Index::Smn0, addr).map_err(usage)?;
     println!("{addr:#x} {data:#x}");
     Ok(repl::Value::Unsigned(data.into()))
 }
@@ -34,7 +34,45 @@ pub(super) fn write(
     let addr = repl::popenv(env).as_num::<u32>().map_err(usage)?;
     let value = repl::popenv(env).as_num::<u32>().map_err(usage)?;
     unsafe {
-        smn::write(addr, value)?;
+        smn::write(smn::Index::Smn0, addr, value)?;
+    }
+    Ok(repl::Value::Nil)
+}
+
+pub(super) fn rdsmni(
+    _config: &mut bldb::Config,
+    env: &mut Vec<repl::Value>,
+) -> Result<repl::Value> {
+    let usage = |error| {
+        println!("usage: rdsmni <index> <addr>");
+        error
+    };
+    let index = repl::popenv(env)
+        .as_num::<u8>()
+        .and_then(smn::Index::try_from)
+        .map_err(usage)?;
+    let addr = repl::popenv(env).as_num::<u32>().map_err(usage)?;
+    let data = smn::read(index, addr).map_err(usage)?;
+    println!("{addr:#x} {data:#x}");
+    Ok(repl::Value::Unsigned(data.into()))
+}
+
+pub(super) fn wrsmni(
+    _config: &mut bldb::Config,
+    env: &mut Vec<repl::Value>,
+) -> Result<repl::Value> {
+    let usage = |error| {
+        println!("usage: wrsmni <index> <addr> <value>");
+        error
+    };
+    let index = repl::popenv(env)
+        .as_num::<u8>()
+        .and_then(smn::Index::try_from)
+        .map_err(usage)?;
+    let addr = repl::popenv(env).as_num::<u32>().map_err(usage)?;
+    let value = repl::popenv(env).as_num::<u32>().map_err(usage)?;
+    unsafe {
+        smn::write(index, addr, value)?;
     }
     Ok(repl::Value::Nil)
 }

src/smn.rs

@@ -3,47 +3,85 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 use crate::pci;
-use crate::result::Result;
+use crate::result::{Error, Result};
+use core::convert::TryFrom;
+use spin::Mutex;
 
-static SMN_MUTEX: spin::Mutex<()> = spin::Mutex::new(());
-const SMN_ADDR_OFFSET: u8 = 0x60;
-const SMN_DATA_OFFSET: u8 = 0x64;
+pub(crate) enum Index {
+    Smn0 = 0,
+    Smn1 = 1,
+    Smn2 = 2,
+    Smn3 = 3,
+    Smn4 = 4,
+    Smn5 = 5,
+    Smn6 = 6,
+}
+
+impl TryFrom<u8> for Index {
+    type Error = Error;
+    fn try_from(f: u8) -> Result<Self> {
+        match f {
+            0 => Ok(Index::Smn0),
+            1 => Ok(Index::Smn1),
+            2 => Ok(Index::Smn2),
+            3 => Ok(Index::Smn3),
+            4 => Ok(Index::Smn4),
+            5 => Ok(Index::Smn5),
+            6 => Ok(Index::Smn6),
+            _ => Err(Error::NumRange),
+        }
+    }
+}
+
+const NSMN: usize = Index::Smn6 as usize + 1;
+
+static ADDR_DATA_PAIRS: [spin::Mutex<(u8, u8)>; NSMN] = [
+    Mutex::new((0x60, 0x64)),
+    Mutex::new((0xA0, 0xA4)),
+    Mutex::new((0xB8, 0xBC)),
+    Mutex::new((0xC4, 0xC8)),
+    Mutex::new((0xD0, 0xD4)),
+    Mutex::new((0xE0, 0xE4)),
+    Mutex::new((0xF8, 0xFC)),
+];
 
-pub(crate) fn read(addr: u32) -> Result<u32> {
-    let _lock = SMN_MUTEX.lock();
+pub(crate) fn read(k: Index, addr: u32) -> Result<u32> {
+    let pair = ADDR_DATA_PAIRS[k as usize].lock();
+    let (addr_off, data_off) = *pair;
     let value = unsafe {
         pci::cfg::write(
             pci::Bus(0),
             pci::Device::D0,
             pci::Function::F0,
-            SMN_ADDR_OFFSET,
+            addr_off,
             addr,
         )?;
         pci::cfg::read(
             pci::Bus(0),
             pci::Device::D0,
             pci::Function::F0,
-            SMN_DATA_OFFSET,
+            data_off,
         )
     }?;
     Ok(value)
 }
 
-pub(crate) unsafe fn write(addr: u32, data: u32) -> Result<()> {
-    let _lock = SMN_MUTEX.lock();
+pub(crate) unsafe fn write(k: Index, addr: u32, data: u32) -> Result<()> {
+    let pair = ADDR_DATA_PAIRS[k as usize].lock();
+    let (addr_off, data_off) = *pair;
     unsafe {
         pci::cfg::write(
             pci::Bus(0),
             pci::Device::D0,
             pci::Function::F0,
-            SMN_ADDR_OFFSET,
+            addr_off,
             addr,
         )?;
         pci::cfg::write(
             pci::Bus(0),
             pci::Device::D0,
             pci::Function::F0,
-            SMN_DATA_OFFSET,
+            data_off,
             data,
         )?;
     }