diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 24734a2..d966c6e 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -117,3 +117,36 @@ jobs:
           override: true
       - name: Build
         run: cargo build --release
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - name: Install Linux build dependencies
+        shell: bash
+        run: |
+          apt-get update && apt-get install sudo
+          sudo apt update -y -qq && sudo apt install -y -qq llvm libc6-dev-i386 libclang-dev build-essential clang
+      - uses: fiam/arm-none-eabi-gcc@v1.0.4
+        with:
+          release: "9-2020-q2"
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: "1.94"
+          target: thumbv8m.main-none-eabi
+          override: true
+          components: rustfmt, clippy
+      - name: cargo fmt --check
+        run: cargo fmt --all --check
+      - name: cargo clippy (host)
+        run: cargo clippy --all-targets -- -D warnings
+      - name: cargo clippy (lpc55, board-lpcxpresso55)
+        working-directory: runners/lpc55
+        run: cargo clippy --release --features board-lpcxpresso55
+      - name: cargo clippy (lpc55, board-solo2)
+        working-directory: runners/lpc55
+        run: cargo clippy --release --features board-solo2
+      - name: cargo clippy (lpc55, provisioner)
+        working-directory: runners/lpc55
+        run: cargo clippy --release --features board-lpcxpresso55,provisioner-app,admin-app,provisioner-app/test-attestation
diff --git a/components/fm11nc08/src/device.rs b/components/fm11nc08/src/device.rs
index 73aba77..b08e13b 100644
--- a/components/fm11nc08/src/device.rs
+++ b/components/fm11nc08/src/device.rs
@@ -1,13 +1,13 @@
 use nb::block;
 
-use embedded_time::duration::{Extensions, Microseconds};
 use embedded_hal as hal;
+use embedded_time::duration::{Extensions, Microseconds};
 
 use defmt::info;
 
 use hal::{
-    spi::FullDuplex,
     digital::v2::{InputPin, OutputPin},
+    spi::FullDuplex,
     timer::CountDown,
 };
 
@@ -61,19 +61,15 @@ pub enum FifoInterrupt {
     WaterLevel = 1 << 3,
 }
 
-
-
 macro_rules! FM11_CMD {
     ($mode:expr, $addr:expr) => {
         match $mode {
-            Mode::WriteEeprom | Mode::ReadEeprom=> {
-                (( ($mode as u8) & 0x07) << 5) | (((($addr as u16) & 0x300) >> 8) as u8)
-            }
-            _ => {
-                (( ($mode as u8) & 0x07) << 5) | (($addr as u8) & 0x0f)
+            Mode::WriteEeprom | Mode::ReadEeprom => {
+                ((($mode as u8) & 0x07) << 5) | (((($addr as u16) & 0x300) >> 8) as u8)
             }
+            _ => ((($mode as u8) & 0x07) << 5) | (($addr as u8) & 0x0f),
         }
-    }
+    };
 }
 
 pub struct Configuration {
@@ -89,7 +85,7 @@ pub struct Configuration {
     pub nfc: u8,
 }
 
-pub struct FM11NC08 <SPI, CS, INT>
+pub struct FM11NC08<SPI, CS, INT>
 where
     SPI: FullDuplex<u8>,
     CS: OutputPin,
@@ -117,8 +113,7 @@ fn fsdi_to_frame_size(fsdi: u8) -> usize {
     }
 }
 
-
-impl<SPI, CS, INT> FM11NC08 <SPI, CS, INT>
+impl<SPI, CS, INT> FM11NC08<SPI, CS, INT>
 where
     SPI: FullDuplex<u8>,
     CS: OutputPin,
@@ -126,9 +121,9 @@ where
 {
     pub fn new(spi: SPI, cs: CS, int: INT) -> Self {
         Self {
-            spi: spi,
-            cs: cs,
-            int: int,
+            spi,
+            cs,
+            int,
             packet: [0u8; 256],
             offset: 0usize,
             current_frame_size: 128,
@@ -138,11 +133,11 @@ where
     pub fn write_reg(&mut self, addr: Register, data: u8) {
         self.cs.set_low().ok();
 
-        block!( self.spi.send(FM11_CMD!(Mode::Write, addr)) ).ok();
-        block!( self.spi.send(data) ).ok();
+        block!(self.spi.send(FM11_CMD!(Mode::Write, addr))).ok();
+        block!(self.spi.send(data)).ok();
 
-        block!( self.spi.read() ).ok();
-        block!( self.spi.read() ).ok();
+        block!(self.spi.read()).ok();
+        block!(self.spi.read()).ok();
 
         self.cs.set_high().ok();
     }
@@ -150,11 +145,11 @@ where
     pub fn read_reg(&mut self, addr: Register) -> u8 {
         self.cs.set_low().ok();
 
-        block!( self.spi.send(FM11_CMD!(Mode::Read, addr)) ).ok();
-        block!( self.spi.send(0) ).ok();
+        block!(self.spi.send(FM11_CMD!(Mode::Read, addr))).ok();
+        block!(self.spi.send(0)).ok();
 
-        block!( self.spi.read() ).ok();
-        let data = block!( self.spi.read() ).ok().unwrap();
+        block!(self.spi.read()).ok();
+        let data = block!(self.spi.read()).ok().unwrap();
 
         self.cs.set_high().ok();
 
@@ -164,45 +159,47 @@ where
     pub fn read_reg_raw(&mut self, addr: u8) -> u8 {
         self.cs.set_low().ok();
 
-        block!( self.spi.send(FM11_CMD!(Mode::Read, addr)) ).ok();
-        block!( self.spi.send(0) ).ok();
+        block!(self.spi.send(FM11_CMD!(Mode::Read, addr))).ok();
+        block!(self.spi.send(0)).ok();
 
-        block!( self.spi.read() ).ok();
-        let data = block!( self.spi.read() ).ok().unwrap();
+        block!(self.spi.read()).ok();
+        let data = block!(self.spi.read()).ok().unwrap();
 
         self.cs.set_high().ok();
 
         data
     }
 
-
-
-    fn start_write(&mut self, addr: u16){
-
-        let cmd : u8  = FM11_CMD!(Mode::WriteEeprom, addr);
+    fn start_write(&mut self, addr: u16) {
+        let cmd: u8 = FM11_CMD!(Mode::WriteEeprom, addr);
 
         self.cs.set_low().ok();
 
         // Write EEPROM magic enable sequence
-        block!( self.spi.send( 0b11001110u8 )).ok();
-        block!( self.spi.send( 0b01010101u8 )).ok();
+        block!(self.spi.send(0b11001110u8)).ok();
+        block!(self.spi.send(0b01010101u8)).ok();
 
-        for _ in 0 .. 2 { block!( self.spi.read(  )).ok().unwrap(); }
+        for _ in 0..2 {
+            block!(self.spi.read()).ok().unwrap();
+        }
 
         self.cs.set_high().ok();
         self.cs.set_low().ok();
 
-        block!( self.spi.send( cmd )).ok();
-        block!( self.spi.send( addr as u8)).ok();
+        block!(self.spi.send(cmd)).ok();
+        block!(self.spi.send(addr as u8)).ok();
 
-        for _ in 0 .. 2 { block!( self.spi.read(  )).ok().unwrap(); }
+        for _ in 0..2 {
+            block!(self.spi.read()).ok().unwrap();
+        }
     }
 
-    fn end_write(&mut self, timer: &mut impl CountDown<Time=Microseconds>) -> Result<(),()> {
+    fn end_write(&mut self, timer: &mut impl CountDown<Time = Microseconds>) -> Result<(), ()> {
         self.cs.set_high().ok();
 
         // Need to give ~10ms of unactivity for eeprom block to write
-        timer.start(10_000.microseconds()); block!(timer.wait()).ok();
+        timer.start(10_000.microseconds());
+        block!(timer.wait()).ok();
 
         let aux_irq = self.read_reg(Register::AuxIrq);
         if (aux_irq & (1 << 6)) != 0 {
@@ -219,48 +216,58 @@ where
     }
 
     /// Configure the eeprom in FM11 chip.  Should only need to do this once per device.
-    pub fn configure(&mut self, config: Configuration, timer: &mut impl CountDown<Time = Microseconds>)
-        -> Result<(),()> {
-
+    #[allow(clippy::result_unit_err)]
+    pub fn configure(
+        &mut self,
+        config: Configuration,
+        timer: &mut impl CountDown<Time = Microseconds>,
+    ) -> Result<(), ()> {
         // Clear all aux interrupts
         self.write_reg(Register::AuxIrq, 0);
 
         self.start_write(0x390 + 1);
 
-        block!( self.spi.send( config.regu )).ok();
-        block!( self.spi.send( config.regu )).ok();
-        for _ in 0 .. 2 { block!( self.spi.read(  )).ok().unwrap(); }
+        block!(self.spi.send(config.regu)).ok();
+        block!(self.spi.send(config.regu)).ok();
+        for _ in 0..2 {
+            block!(self.spi.read()).ok().unwrap();
+        }
 
         self.end_write(timer)?;
 
         self.start_write(0x3A0);
 
-        block!( self.spi.send( config.ataq.to_be_bytes()[0] )).ok();
-        block!( self.spi.send( config.ataq.to_be_bytes()[1] )).ok();
-        block!( self.spi.send( config.sak1)).ok();
-        block!( self.spi.send( config.sak2)).ok();
+        block!(self.spi.send(config.ataq.to_be_bytes()[0])).ok();
+        block!(self.spi.send(config.ataq.to_be_bytes()[1])).ok();
+        block!(self.spi.send(config.sak1)).ok();
+        block!(self.spi.send(config.sak2)).ok();
 
-        for _ in 0 .. 4 { block!( self.spi.read(  )).ok().unwrap(); }
+        for _ in 0..4 {
+            block!(self.spi.read()).ok().unwrap();
+        }
 
         self.end_write(timer)?;
 
         self.start_write(0x3b0);
 
-        block!( self.spi.send( config.tl )).ok();
-        block!( self.spi.send( config.t0 )).ok();
-        block!( self.spi.send( config.nfc )).ok();
-        block!( self.spi.send( 0xA8 )).ok();          // use I2C addr as magic marker
+        block!(self.spi.send(config.tl)).ok();
+        block!(self.spi.send(config.t0)).ok();
+        block!(self.spi.send(config.nfc)).ok();
+        block!(self.spi.send(0xA8)).ok(); // use I2C addr as magic marker
 
-        for _ in 0 .. 4 { block!( self.spi.read(  )).ok().unwrap(); }
+        for _ in 0..4 {
+            block!(self.spi.read()).ok().unwrap();
+        }
 
-        block!( self.spi.send( config.ta )).ok();
-        block!( self.spi.send( config.tb )).ok();
-        block!( self.spi.send( config.tc )).ok();
+        block!(self.spi.send(config.ta)).ok();
+        block!(self.spi.send(config.tb)).ok();
+        block!(self.spi.send(config.tc)).ok();
 
-        for _ in 0 .. 3 { block!( self.spi.read(  )).ok().unwrap(); }
+        for _ in 0..3 {
+            block!(self.spi.read()).ok().unwrap();
+        }
 
         self.end_write(timer)
-
     }
 
     pub fn read_eeprom(&mut self, addr: u16, array: &mut [u8]) {
@@ -269,24 +276,24 @@ where
         let cmd = FM11_CMD!(Mode::ReadEeprom, addr);
         let addr = (addr & 0xff) as u8;
         self.cs.set_low().ok();
-        block!( self.spi.send( cmd )).ok();
-        block!( self.spi.send( addr )).ok();
+        block!(self.spi.send(cmd)).ok();
+        block!(self.spi.send(addr)).ok();
 
-        block!( self.spi.read(  )).ok().unwrap();
-        block!( self.spi.read(  )).ok().unwrap();
+        block!(self.spi.read()).ok().unwrap();
+        block!(self.spi.read()).ok().unwrap();
 
-        for i in 0 .. array.len() {
-            block!( self.spi.send( 0 )  ).ok();
-            array[i] = block!( self.spi.read(  )).ok().unwrap();
+        for slot in array.iter_mut() {
+            block!(self.spi.send(0)).ok();
+            *slot = block!(self.spi.read()).ok().unwrap();
         }
         self.cs.set_high().ok();
     }
 
-    pub fn enabled(self,) -> Self {
+    pub fn enabled(self) -> Self {
         self
     }
 
-    pub fn has_interrupt(&mut self, ) -> nb::Result<(), nfc::Error> {
+    pub fn has_interrupt(&mut self) -> nb::Result<(), nfc::Error> {
         if self.int.is_low().ok().unwrap() {
             Ok(())
         } else {
@@ -295,57 +302,56 @@ where
     }
 
     /// Write data to NFC FIFO as fast as possible.
-    fn write_fifo(&mut self, buf: &[u8]){
-        if buf.len() == 0 {
+    fn write_fifo(&mut self, buf: &[u8]) {
+        if buf.is_empty() {
             return;
         }
         self.cs.set_low().ok();
 
-        block!( self.spi.send(FM11_CMD!(Mode::WriteFifo, 0)) ).ok();
+        block!(self.spi.send(FM11_CMD!(Mode::WriteFifo, 0))).ok();
 
         // Put extra byte in to ensure spi RX fifo operates continuously.
         // (assumes count >= 1)
-        block!( self.spi.send(buf[0]) ).ok();
+        block!(self.spi.send(buf[0])).ok();
 
-        for i in 1 .. buf.len() {
-            block!( self.spi.send(buf[i as usize]) ).ok();
-            block!( self.spi.read() ).ok().unwrap();
+        for &byte in buf.iter().skip(1) {
+            block!(self.spi.send(byte)).ok();
+            block!(self.spi.read()).ok().unwrap();
         }
 
         // for header + that extra byte.
-        block!( self.spi.read() ).ok().unwrap();
-        block!( self.spi.read() ).ok().unwrap();
+        block!(self.spi.read()).ok().unwrap();
+        block!(self.spi.read()).ok().unwrap();
 
         self.cs.set_high().ok();
     }
 
     /// Read data from NFC FIFO as fast as possible.
-    fn read_fifo(&mut self, /*buf: &mut [u8],*/ count: u8){
+    fn read_fifo(&mut self, /*buf: &mut [u8],*/ count: u8) {
         let buf: &mut [u8] = &mut self.packet[self.offset..];
         self.cs.set_low().ok();
 
-        block!( self.spi.send(FM11_CMD!(Mode::ReadFifo, 0)) ).ok();
+        block!(self.spi.send(FM11_CMD!(Mode::ReadFifo, 0))).ok();
 
         // Put extra byte in to ensure spi RX fifo operates continuously.
         // (assumes count >= 1)
-        block!( self.spi.send(0) ).ok();
+        block!(self.spi.send(0)).ok();
 
         // Skip first byte
-        block!( self.spi.read() ).ok().unwrap();
+        block!(self.spi.read()).ok().unwrap();
 
-        for i in 0 .. (count-1) {
-            block!( self.spi.send(0) ).ok();
-            buf[i as usize] = block!( self.spi.read() ).ok().unwrap();
+        for i in 0..(count - 1) {
+            block!(self.spi.send(0)).ok();
+            buf[i as usize] = block!(self.spi.read()).ok().unwrap();
         }
 
         // for that extra byte.
-        buf[(count-1) as usize] = block!( self.spi.read() ).ok().unwrap();
+        buf[(count - 1) as usize] = block!(self.spi.read()).ok().unwrap();
 
         self.cs.set_high().ok();
     }
 
-    pub fn read_packet(&mut self, buf: &mut [u8]) -> Result<nfc::State, nfc::Error>{
-
+    pub fn read_packet(&mut self, buf: &mut [u8]) -> Result<nfc::State, nfc::Error> {
         let main_irq = self.read_reg(Register::MainIrq);
         let mut new_session = false;
 
@@ -370,11 +376,7 @@ where
         // check for overflow
         if (fifo_irq & (1 << 2)) != 0 {
             // info!("!OF! {} @{}", self.read_reg(Register::FifoCount), hal::get_cycle_count()/96_00);
-            info!("{} {} {}",
-                    main_irq,
-                    fifo_irq,
-                    _aux_irq,
-                );
+            info!("{} {} {}", main_irq, fifo_irq, _aux_irq,);
 
             // self.write_reg(Register::FifoFlush, 0xff);
         }
@@ -384,7 +386,7 @@ where
             new_session = true;
         }
 
-        if main_irq & (Interrupt::RxStart as u8) != 0{
+        if main_irq & (Interrupt::RxStart as u8) != 0 {
             self.offset = 0;
             let rf_rats = self.read_reg(Register::RfRats);
             self.current_frame_size = fsdi_to_frame_size((rf_rats >> 4) & 0xf);
@@ -400,15 +402,12 @@ where
 
             if self.offset <= 2 {
                 // too few bytes, ignore..
-                info!("RxDone read too few ({=[u8]:x})", &buf[.. self.offset]);
+                info!("RxDone read too few ({=[u8]:x})", &buf[..self.offset]);
                 self.offset = 0;
-            }
-            else {
+            } else {
                 info!("RxDone");
                 let l = self.offset - 2;
-                for i in 0 .. l {
-                    buf[i] = self.packet[i];
-                }
+                buf[..l].copy_from_slice(&self.packet[..l]);
                 self.offset = 0;
                 if new_session {
                     return Ok(nfc::State::NewSession(l as u8));
@@ -418,34 +417,29 @@ where
             }
         }
 
-            /* water level */
+        /* water level */
         let rf_status = self.read_reg(Register::RfStatus);
         if (fifo_irq & (1 << 3) != 0) && (rf_status & (1 << 0)) == 0 {
             let count = self.read_reg(Register::FifoCount);
             info!("WL {}", count);
             self.read_fifo(count);
-            info!("{=[u8]:x}", &self.packet[self.offset ..][..count as usize]);
+            info!("{=[u8]:x}", &self.packet[self.offset..][..count as usize]);
             self.offset += count as usize;
             if count == 32 {
                 info!("warning: potential ovflw");
             }
         }
 
-        info!(". {},{},{}",
-            main_irq,
-            fifo_irq,
-            _aux_irq,
-        );
+        info!(". {},{},{}", main_irq, fifo_irq, _aux_irq,);
 
         if new_session {
             Err(nfc::Error::NewSession)
         } else {
             Err(nfc::Error::NoActivity)
         }
-
     }
 
-    fn wait_for_transmission(&mut self) -> Result<(), ()>{
+    fn wait_for_transmission(&mut self) -> Result<(), ()> {
         let mut i = 0;
 
         self.write_reg(Register::RfTxEn, 0x55);
@@ -461,10 +455,8 @@ where
         let initial_count = self.read_reg(Register::FifoCount);
         let mut current_count = initial_count;
         if current_count >= 8 {
-
             let mut fifo_irq = self.read_reg(Register::FifoIrq);
             if (rf_status & 1) == 1 {
-
                 while (fifo_irq & (FifoInterrupt::WaterLevel as u8)) == 0 {
                     i += 1;
                     if i > 300 {
@@ -477,72 +469,67 @@ where
                     current_count = self.read_reg(Register::FifoCount);
                     if current_count <= 7 {
                         info!("curr count <= 7 and no INT");
-                        return Ok(())
+                        return Ok(());
                     }
                     fifo_irq = self.read_reg(Register::FifoIrq);
                 }
             }
 
-            #[allow(unused_assignments)] {
+            #[allow(unused_assignments)]
+            {
                 current_count = self.read_reg(Register::FifoCount);
             }
             let _aux_irq = self.read_reg(Register::AuxIrq);
             let _rf_status = self.read_reg(Register::RfStatus);
-            info!("tx {}->{}. {:02x} {:02x} {:02x}",
-                initial_count,
-                current_count,
-                _rf_status,
-                _aux_irq,
-                fifo_irq,
+            info!(
+                "tx {}->{}. {:02x} {:02x} {:02x}",
+                initial_count, current_count, _rf_status, _aux_irq, fifo_irq,
             );
 
             if (fifo_irq & (FifoInterrupt::WaterLevel as u8)) != 0 {
-                return Ok(())
+                return Ok(());
             } else {
-                return Err(())
+                return Err(());
             }
         }
         Ok(())
     }
 
-    pub fn send_packet(&mut self, buf: &[u8]) -> Result<(), nfc::Error>{
-
+    pub fn send_packet(&mut self, buf: &[u8]) -> Result<(), nfc::Error> {
         // Write in chunks of 24
-        for i in 0 .. buf.len()/24 {
+        for i in 0..buf.len() / 24 {
             info!("24 chunk");
-            self.write_fifo(&buf[i * 24 .. i * 24 + 24]);
+            self.write_fifo(&buf[i * 24..i * 24 + 24]);
 
-            if ! self.wait_for_transmission().is_ok() {
+            if self.wait_for_transmission().is_err() {
                 return Err(nfc::Error::NoActivity);
             }
         }
 
         // Write remainder
-        self.write_fifo(&buf[ (buf.len()/24) * 24 .. buf.len() ]);
+        self.write_fifo(&buf[(buf.len() / 24) * 24..buf.len()]);
 
         self.wait_for_transmission().ok();
 
         Ok(())
-
     }
 
     pub fn release(self) -> (SPI, CS, INT) {
         (self.spi, self.cs, self.int)
     }
-
 }
 
-impl<SPI, CS, INT> nfc::Device for FM11NC08 <SPI, CS, INT>
+impl<SPI, CS, INT> nfc::Device for FM11NC08<SPI, CS, INT>
 where
     SPI: FullDuplex<u8>,
     CS: OutputPin,
     INT: InputPin,
 {
-    fn read(&mut self, buf: &mut [u8]) -> Result<nfc::State, nfc::Error>{
+    fn read(&mut self, buf: &mut [u8]) -> Result<nfc::State, nfc::Error> {
         self.read_packet(buf)
     }
 
-    fn send(&mut self,buf: &[u8]) -> Result<(), nfc::Error>{
+    fn send(&mut self, buf: &[u8]) -> Result<(), nfc::Error> {
         self.send_packet(buf)
     }
 
@@ -551,21 +538,19 @@ where
     }
 
     // fn wait(&mut self) -> nb::Result<(), NfcError> {
-        // self.wait_for_transmission_completion();
-        // Ok(())
-        // let main_irq = self.read_reg(Register::MainIrq);
-        // if (main_irq & (Interrupt::TxDone as u8)) != 0 {
-        //     // info!("wait is over. {}", logging::hex_str!(main_irq));
-        //     self.write_reg(Register::RfTxEn, 0x00);
-        //     Ok(())
-        // } else {
-        //     Err(nb::Error::WouldBlock)
-        // }
+    // self.wait_for_transmission_completion();
+    // Ok(())
+    // let main_irq = self.read_reg(Register::MainIrq);
+    // if (main_irq & (Interrupt::TxDone as u8)) != 0 {
+    //     // info!("wait is over. {}", logging::hex_str!(main_irq));
+    //     self.write_reg(Register::RfTxEn, 0x00);
+    //     Ok(())
+    // } else {
+    //     Err(nb::Error::WouldBlock)
+    // }
     // }
-
 }
 
-
 /// For logging
 #[derive(Debug)]
 pub struct Eeprom {
@@ -609,8 +594,6 @@ pub struct RegisterBlock {
     pub regu_cfg: u8,
 }
 
-
-
 // impl ufmt::uDisplay for Eeprom {
 //     fn fmt<W: ?Sized>(&self, f: &mut ufmt::Formatter<'_, W>) -> Result<(), W::Error>
 //     where
@@ -653,9 +636,6 @@ pub struct RegisterBlock {
 //     }
 // }
 
-
-
-
 // impl ufmt::uDisplay for InterruptState {
 //     fn fmt<W: ?Sized>(&self, f: &mut ufmt::Formatter<'_, W>) -> Result<(), W::Error>
 //     where
@@ -680,7 +660,6 @@ pub struct RegisterBlock {
 //             if (self.main & (Interrupt::Active as u8)) != 0 { uwriteln!(f,"  active").ok(); }
 //             if (self.main & (Interrupt::RfPower as u8)) != 0 { uwriteln!(f,"  rf_pwon").ok(); }
 
-
 //         }
 
 //         if self.fifo != 0 {
@@ -704,18 +683,17 @@ pub struct RegisterBlock {
 //     }
 // }
 
-impl<SPI, CS, INT> FM11NC08 <SPI, CS, INT>
+impl<SPI, CS, INT> FM11NC08<SPI, CS, INT>
 where
     SPI: FullDuplex<u8>,
     CS: OutputPin,
     INT: InputPin,
 {
     pub fn dump_registers(&mut self) -> RegisterBlock {
-
         let mut regs = [0u8; 15];
 
-        for i in 2 .. 15 {
-            regs[i] = self.read_reg_raw(i as u8);
+        for (i, reg) in regs.iter_mut().enumerate().skip(2) {
+            *reg = self.read_reg_raw(i as u8);
         }
 
         RegisterBlock {
@@ -745,33 +723,29 @@ where
         self.write_reg(Register::FifoIrq, 0);
         self.write_reg(Register::AuxIrq, 0);
 
-        InterruptState{
-            main:main,
-            fifo:fifo,
-            aux: aux,
-            count:count,
+        InterruptState {
+            main,
+            fifo,
+            aux,
+            count,
         }
     }
 
-
-
     pub fn dump_eeprom(&mut self) -> Eeprom {
-
-
         let mut arr = [0u8; 16];
-        let mut double_byte = [0u8 ; 2];
+        let mut double_byte = [0u8; 2];
         self.read_eeprom(0x390, &mut arr);
 
         let regu_cfg = arr[1];
 
-        self.read_eeprom(0x3a0 + 0, &mut arr);
+        self.read_eeprom(0x3a0, &mut arr);
 
-        double_byte.clone_from_slice(&arr[0 .. 2]);
+        double_byte.clone_from_slice(&arr[0..2]);
         let atqa = u16::from_be_bytes(double_byte);
         let sak1 = arr[2];
         let sak2 = arr[3];
 
-        self.read_eeprom(0x3b0 + 0, &mut arr);
+        self.read_eeprom(0x3b0, &mut arr);
         let tl = arr[0];
         let t0 = arr[1];
         let nfc_cfg = arr[2];
@@ -784,19 +758,19 @@ where
         let rblock_nack = arr[11];
 
         Eeprom {
-            regu_cfg:regu_cfg,
-            atqa:atqa,
-            sak1: sak1,
-            sak2: sak2,
-            tl: tl,
-            t0: t0,
-            ta: ta,
-            tb: tb,
-            tc: tc,
-            i2c_addr: i2c_addr,
-            nfc_cfg: nfc_cfg,
-            rblock_ack: rblock_ack,
-            rblock_nack: rblock_nack,
+            regu_cfg,
+            atqa,
+            sak1,
+            sak2,
+            tl,
+            t0,
+            ta,
+            tb,
+            tc,
+            i2c_addr,
+            nfc_cfg,
+            rblock_ack,
+            rblock_nack,
         }
     }
 }
diff --git a/components/fm11nc08/src/lib.rs b/components/fm11nc08/src/lib.rs
index 17ae642..bdad85c 100644
--- a/components/fm11nc08/src/lib.rs
+++ b/components/fm11nc08/src/lib.rs
@@ -2,8 +2,4 @@
 
 pub mod device;
 
-pub use device::{
-    FM11NC08,
-    Configuration,
-    Register,
-};
+pub use device::{Configuration, FM11NC08, Register};
diff --git a/components/ndef-app/src/lib.rs b/components/ndef-app/src/lib.rs
index af13546..94a5580 100644
--- a/components/ndef-app/src/lib.rs
+++ b/components/ndef-app/src/lib.rs
@@ -1,4 +1,4 @@
 #![no_std]
 
 pub mod ndef;
-pub use ndef::*;
\ No newline at end of file
+pub use ndef::*;
diff --git a/components/ndef-app/src/ndef.rs b/components/ndef-app/src/ndef.rs
index 97b6b73..e23446d 100644
--- a/components/ndef-app/src/ndef.rs
+++ b/components/ndef-app/src/ndef.rs
@@ -1,32 +1,35 @@
-use iso7816::{Instruction, Status};
 use apdu_dispatch::app;
 use apdu_dispatch::app::{CommandView, Interface, VecView};
+use iso7816::{Instruction, Status};
 
-pub struct App<'a>{
-    reader: &'a [u8]
+pub struct App<'a> {
+    reader: &'a [u8],
+}
+
+impl<'a> Default for App<'a> {
+    fn default() -> Self {
+        Self::new()
+    }
 }
 
 impl<'a> App<'a> {
     pub const CAPABILITY_CONTAINER: [u8; 15] = [
         0x00, 0x0f, /* CCEN_HI, CCEN_LOW */
-        0x20,       /* VERSION */
+        0x20, /* VERSION */
         0x00, 0x7f, /* MLe_HI, MLe_LOW */
         0x00, 0x7f, /* MLc_HI, MLc_LOW */
         /* TLV */
-        0x04,0x06,
-        0xe1,0x04,
-        0x00,0x7f,
-        0x00,0x00,
+        0x04, 0x06, 0xe1, 0x04, 0x00, 0x7f, 0x00, 0x00,
     ];
 
     // Externally crafted NDEF URL for "https://solokeys.com/"
-    pub const NDEF : [u8; 20] = [
-        0x00, 0x12, 0xd1, 0x01, 0x0e, 0x55, 0x04, 0x73, 0x6f, 0x6c,
-        0x6f, 0x6b, 0x65, 0x79, 0x73, 0x2e, 0x63, 0x6f, 0x6d, 0x2f
+    pub const NDEF: [u8; 20] = [
+        0x00, 0x12, 0xd1, 0x01, 0x0e, 0x55, 0x04, 0x73, 0x6f, 0x6c, 0x6f, 0x6b, 0x65, 0x79, 0x73,
+        0x2e, 0x63, 0x6f, 0x6d, 0x2f,
     ];
 
     pub fn new() -> App<'a> {
-        App{
+        App {
             reader: &Self::NDEF,
         }
     }
@@ -39,24 +42,31 @@ impl<'a> iso7816::App for App<'a> {
 }
 
 impl<'a> app::App for App<'a> {
-
-    fn select(&mut self, _interface: Interface, _apdu: CommandView<'_>, _reply: &mut VecView<u8>) -> app::Result {
+    fn select(
+        &mut self,
+        _interface: Interface,
+        _apdu: CommandView<'_>,
+        _reply: &mut VecView<u8>,
+    ) -> app::Result {
         Ok(())
     }
 
     fn deselect(&mut self) {}
 
-    fn call(&mut self, _interface: Interface, apdu: CommandView<'_>, reply: &mut VecView<u8>) -> app::Result {
+    fn call(
+        &mut self,
+        _interface: Interface,
+        apdu: CommandView<'_>,
+        reply: &mut VecView<u8>,
+    ) -> app::Result {
         let instruction = apdu.instruction();
         let p1 = apdu.p1;
         let p2 = apdu.p2;
         let expected = apdu.expected();
         let payload = apdu.data();
 
-
         match instruction {
             Instruction::Select => {
-
                 if payload.starts_with(&[0xE1u8, 0x03]) {
                     self.reader = &Self::CAPABILITY_CONTAINER;
                     Ok(())
@@ -69,24 +79,20 @@ impl<'a> app::App for App<'a> {
             }
             Instruction::ReadBinary => {
                 let offset = (((p1 & 0xef) as usize) << 8) | p2 as usize;
-                let len_to_read =
-                    if expected as usize > (self.reader.len() - offset) {
-                        self.reader.len() - offset
-                    } else {
-                        if expected > 0 {
-                            expected as usize
-                        } else {
-                            self.reader.len() - offset
-                        }
-                    };
+                let len_to_read = if expected > (self.reader.len() - offset) {
+                    self.reader.len() - offset
+                } else if expected > 0 {
+                    expected
+                } else {
+                    self.reader.len() - offset
+                };
 
-                reply.extend_from_slice(& self.reader[offset .. offset + len_to_read]).ok();
+                reply
+                    .extend_from_slice(&self.reader[offset..offset + len_to_read])
+                    .ok();
                 Ok(())
             }
-            _ => {
-                Err(Status::ConditionsOfUseNotSatisfied)
-            }
+            _ => Err(Status::ConditionsOfUseNotSatisfied),
         }
-
     }
 }
diff --git a/components/nfc-device/src/iso14443.rs b/components/nfc-device/src/iso14443.rs
index c56553e..408fe3a 100644
--- a/components/nfc-device/src/iso14443.rs
+++ b/components/nfc-device/src/iso14443.rs
@@ -1,7 +1,7 @@
 use core::mem::MaybeUninit;
 
 use apdu_dispatch::interchanges;
-use defmt::{info, debug};
+use defmt::{debug, info};
 use embedded_time::duration::Milliseconds;
 use heapless::Vec;
 use interchange;
@@ -39,11 +39,13 @@ type WtxGranted = bool;
 type Nad = Option<u8>;
 type Cid = Option<u8>;
 
-#[derive(Copy,Clone)]
+// Names follow ISO 14443-4 block type terminology (I-Block, R-Block, S-Block).
+#[allow(clippy::enum_variant_names)]
+#[derive(Copy, Clone)]
 enum Block {
     IBlock(BlockNum, Nad, Cid, Chaining, Offset),
     RBlock(BlockNum, Cid, Ack, Offset),
-    SBlock(Cid, WtxGranted, ),
+    SBlock(Cid, WtxGranted),
 }
 
 impl Block {
@@ -63,7 +65,6 @@ impl Block {
         };
 
         if (header & 0xc2) == 0x02 {
-
             // NAD included
             let nad = if (header & 0x4) != 0 {
                 offset += 1;
@@ -77,7 +78,7 @@ impl Block {
             };
             Block::IBlock(block_num, nad, cid, flag, offset)
         } else if (header & 0xe2) == 0xa2 {
-                                    // Ack or Nack
+            // Ack or Nack
             Block::RBlock(block_num, cid, !flag, offset)
         } else {
             Block::SBlock(cid, (0x30 & header) == 0x30)
@@ -106,11 +107,11 @@ pub struct Iso14443<'pipe, DEV: nfc::Device> {
 
 impl<'pipe, DEV> Iso14443<'pipe, DEV>
 where
-    DEV: nfc::Device
+    DEV: nfc::Device,
 {
     pub fn new(device: DEV, interchange: interchanges::Requester<'pipe>) -> Self {
         Self {
-            device: device,
+            device,
             state: Iso14443State::Receiving,
             cid: None,
 
@@ -119,7 +120,7 @@ where
 
             buffer: interchanges::Data::new(),
 
-            interchange: interchange,
+            interchange,
         }
     }
 
@@ -133,23 +134,17 @@ where
             length += 1;
         }
 
-        self.device.send(
-            & packet[0 .. length]
-        ).ok();
+        self.device.send(&packet[0..length]).ok();
     }
 
     fn send_wtx(&mut self) {
         // Rule 9. The PICC is allowed to send an S(WTX) block instead of an I-block or an R(ACK) block.
         match self.cid {
             Some(cid) => {
-                self.device.send(
-                    &[0xfa, cid, 0x01]
-                ).ok();
+                self.device.send(&[0xfa, cid, 0x01]).ok();
             }
             _ => {
-                self.device.send(
-                    &[0xf2, 0x01]
-                ).ok();
+                self.device.send(&[0xf2, 0x01]).ok();
             }
         }
     }
@@ -160,13 +155,12 @@ where
         let block_header = Block::new(packet);
         match block_header {
             Block::IBlock(_block_num, _nad, _cid, chaining, offset) => {
-
                 if self.state != Iso14443State::Receiving {
                     self.buffer.clear();
                 }
                 self.state = Iso14443State::Receiving;
 
-                self.buffer.extend_from_slice(& packet[offset .. ]).ok();
+                self.buffer.extend_from_slice(&packet[offset..]).ok();
 
                 // Rule D. When an I-block is received (independent of its block number),
                 // the PICC shall toggle its block number before sending a block.
@@ -181,10 +175,8 @@ where
                     self.wtx_requested = false;
                     Ok(())
                 }
-
             }
             Block::RBlock(block_num, _cid, ack, _offset) => {
-
                 // Rule 11. When an R(ACK) or an R(NAK) block is received,
                 // if its block number is equal to the PICC’s current block
                 // number, the last block shall be re-transmitted.
@@ -193,14 +185,12 @@ where
                         Iso14443State::Transmitting(last_frame_range, _remaining_data_range) => {
                             info!("Retransmission requested..");
                             self.send_frame(
-                                &Vec::from_slice(
-                                    &self.buffer[last_frame_range]
-                                ).unwrap()
-                            ).ok();
+                                &Vec::from_slice(&self.buffer[last_frame_range]).unwrap(),
+                            )
+                            .ok();
                         }
                         _ => {
                             info!("No recent transmissions! NAK");
-
                         }
                     }
                     return Err(SourceError::NoActivity);
@@ -212,41 +202,41 @@ where
                     self.ack();
                     return Err(SourceError::NoActivity);
                 } else {
-
                     // Rule 13. When an R(ACK) block is received,
                     // if its block number is not equal to the PICC’s current block number,
                     // and the PICC is in chaining, chaining shall be continued.
 
                     match self.state.clone() {
                         Iso14443State::Transmitting(_last_frame_range, remaining_data_range) => {
-                                // Rule E. When an R(ACK) block with a block number not equal
-                                // to the current PICC’s block number is received, the
-                                // PICC shall toggle its block number before sending a block.
-                                self.block_num = !self.block_num;
-
-                                if remaining_data_range.len() == 0 {
-                                    info!("Error, recieved ack when this is no more data.");
-                                    self.ack();
-                                    self.reset_state();
-                                    return Err(SourceError::NoActivity);
-                                }
-                                let msg = &self.buffer[remaining_data_range.clone()];
-                                let (next_frame, data_used) = self.construct_iblock(msg);
-                                self.send_frame(&next_frame).ok();
-                                if data_used != remaining_data_range.len() {
-                                    info!("Next frame");
-                                    self.state = Iso14443State::Transmitting(
-                                        remaining_data_range.start .. remaining_data_range.start + data_used,
-                                        remaining_data_range.start + data_used .. self.buffer.len(),
-                                    )
-                                } else {
-                                    info!("Last frame sent!");
-                                    self.state = Iso14443State::Transmitting(
-                                        remaining_data_range.start .. remaining_data_range.start + data_used,
-                                        self.buffer.len() .. self.buffer.len()
-                                    )
-                                }
+                            // Rule E. When an R(ACK) block with a block number not equal
+                            // to the current PICC’s block number is received, the
+                            // PICC shall toggle its block number before sending a block.
+                            self.block_num = !self.block_num;
 
+                            if remaining_data_range.is_empty() {
+                                info!("Error, recieved ack when this is no more data.");
+                                self.ack();
+                                self.reset_state();
+                                return Err(SourceError::NoActivity);
+                            }
+                            let msg = &self.buffer[remaining_data_range.clone()];
+                            let (next_frame, data_used) = self.construct_iblock(msg);
+                            self.send_frame(&next_frame).ok();
+                            if data_used != remaining_data_range.len() {
+                                info!("Next frame");
+                                self.state = Iso14443State::Transmitting(
+                                    remaining_data_range.start
+                                        ..remaining_data_range.start + data_used,
+                                    remaining_data_range.start + data_used..self.buffer.len(),
+                                )
+                            } else {
+                                info!("Last frame sent!");
+                                self.state = Iso14443State::Transmitting(
+                                    remaining_data_range.start
+                                        ..remaining_data_range.start + data_used,
+                                    self.buffer.len()..self.buffer.len(),
+                                )
+                            }
                         }
                         _ => {
                             // (None, Iso14443State::Idle)
@@ -254,7 +244,6 @@ where
                             self.ack();
                         }
                     };
-
                 }
                 Err(SourceError::NoActivity)
             }
@@ -268,9 +257,7 @@ where
                     self.wtx_requested = false;
                 } else {
                     info!("Deselected.");
-                    self.device.send(
-                        &[0xc2]
-                    ).ok();
+                    self.device.send(&[0xc2]).ok();
                     self.reset_state();
                 }
                 Err(SourceError::NoActivity)
@@ -278,7 +265,7 @@ where
         }
     }
 
-    pub fn borrow<F: Fn(&mut DEV) -> () >(&mut self, func: F) {
+    pub fn borrow<F: Fn(&mut DEV)>(&mut self, func: F) {
         func(&mut self.device);
     }
 
@@ -292,7 +279,7 @@ where
 
         if let Some(cid) = self.cid {
             frame.push(cid).ok();
-            frame[0]|= 0x08;
+            frame[0] |= 0x08;
             header_length += 1;
         }
 
@@ -300,7 +287,7 @@ where
         let frame_size: usize = self.device.frame_size() - 2;
         let payload_len = core::cmp::min(frame_size - header_length, data.len());
 
-        frame.extend_from_slice(&data[0 .. payload_len]).ok();
+        frame.extend_from_slice(&data[0..payload_len]).ok();
 
         if payload_len != data.len() {
             // set chaining bit.
@@ -330,24 +317,23 @@ where
                 info!("State::NewSession");
                 self.reset_state();
                 x
-            },
+            }
             Ok(nfc::State::Continue(x)) => x,
             Err(nfc::Error::NewSession) => {
                 info!("Error::NewSession");
                 self.reset_state();
-                return Err(SourceError::NoActivity)
-            },
+                return Err(SourceError::NoActivity);
+            }
             _ => {
                 // info!("nop");
-                return Err(SourceError::NoActivity)
+                return Err(SourceError::NoActivity);
             }
         };
 
-
         assert!(packet_len > 0);
 
         // let packet = &self.packet;
-        self.handle_block(&packet[.. packet_len as usize])?;
+        self.handle_block(&packet[..packet_len as usize])?;
 
         debug!(">>");
         debug!("{=[u8]:x}", &self.buffer);
@@ -355,10 +341,8 @@ where
 
         let command = interchanges::Data::from_slice(&self.buffer);
         self.buffer.clear();
-        if command.is_ok() {
-            if self.interchange.request(
-                command.unwrap()
-            ).is_ok() {
+        if let Ok(command) = command {
+            if self.interchange.request(command).is_ok() {
                 Ok(())
             } else {
                 // Would be better to try canceling and taking on this apdu.
@@ -368,10 +352,10 @@ where
         } else {
             let (frame, _) = self.construct_iblock(
                 // UnspecifiedCheckingError
-                &[0x6F, 0x00]
+                &[0x6F, 0x00],
             );
 
-            self.send_frame( &frame )?;
+            self.send_frame(&frame)?;
             Err(SourceError::NoActivity)
         }
     }
@@ -382,7 +366,6 @@ where
 
     pub fn poll(&mut self) -> Iso14443Status {
         if interchange::State::Responded == self.interchange.state() {
-
             // important to wait on wtx reply from the reader.
             // If it wasn't sent, or we start replying before it's received,
             // then we could "double-send", which isn't permitted in iso14443-4.
@@ -401,24 +384,19 @@ where
                 }
             }
 
-
             if let Some(msg) = self.interchange.take_response() {
                 // if let Some(last_iblock_recv) = self.last_iblock_recv {
-                    info!("send!");
-                    let (frame, data_used) = self.construct_iblock(&msg);
-                    self.send_frame(
-                        &frame
-                    ).ok();
-                    if data_used != msg.len() {
-                        info!("chaining response!");
-                        self.buffer = msg;
-                        self.state = Iso14443State::Transmitting(
-                            0 .. data_used,
-                            data_used .. self.buffer.len()
-                        );
-                    }
+                info!("send!");
+                let (frame, data_used) = self.construct_iblock(&msg);
+                self.send_frame(&frame).ok();
+                if data_used != msg.len() {
+                    info!("chaining response!");
+                    self.buffer = msg;
+                    self.state =
+                        Iso14443State::Transmitting(0..data_used, data_used..self.buffer.len());
+                }
                 // } else {
-                    // info!("session was dropped! dropping response.");
+                // info!("session was dropped! dropping response.");
                 // }
             }
             Iso14443Status::Idle
@@ -433,10 +411,9 @@ where
     }
 
     pub fn poll_wait_extensions(&mut self) -> Iso14443Status {
-
         if self.wtx_requested {
             info!("warning: still awaiting wtx response.");
-            return Iso14443Status::ReceivedData(Milliseconds(32))
+            return Iso14443Status::ReceivedData(Milliseconds(32));
         }
 
         match self.interchange.state() {
@@ -454,22 +431,21 @@ where
                 Iso14443Status::Idle
             }
         }
-
     }
 
     /// Write response code + APDU
-    fn send_frame(&mut self, buffer: &Iso14443Frame) -> Result<(), SourceError>
-    {
-        let r = self.device.send( buffer );
-        if !r.is_ok() {
+    fn send_frame(&mut self, buffer: &Iso14443Frame) -> Result<(), SourceError> {
+        let r = self.device.send(buffer);
+        if r.is_err() {
             // o!("FM11 not okay!");
             return Err(SourceError::NoActivity);
         }
 
-        debug!("<{}< ",buffer.len());
-        if buffer.len() > 0 { debug!("{=[u8]:x}", &buffer); }
+        debug!("<{}< ", buffer.len());
+        if !buffer.is_empty() {
+            debug!("{=[u8]:x}", &buffer);
+        }
 
         Ok(())
     }
-
 }
diff --git a/components/nfc-device/src/lib.rs b/components/nfc-device/src/lib.rs
index a195ce6..3ca8e7b 100644
--- a/components/nfc-device/src/lib.rs
+++ b/components/nfc-device/src/lib.rs
@@ -1,7 +1,7 @@
 #![no_std]
 
-pub mod types;
 pub mod traits;
+pub mod types;
 
 pub mod iso14443;
 pub use iso14443::*;
diff --git a/components/nfc-device/src/traits.rs b/components/nfc-device/src/traits.rs
index c0c1f39..8858b4c 100644
--- a/components/nfc-device/src/traits.rs
+++ b/components/nfc-device/src/traits.rs
@@ -1,4 +1,3 @@
-
 pub mod nfc {
     #[derive(Copy, Clone, Debug, PartialEq)]
     pub enum State {
@@ -14,9 +13,9 @@ pub mod nfc {
     pub trait Device {
         fn read(&mut self, buf: &mut [u8]) -> Result<State, Error>;
 
-        fn send(&mut self,buf: &[u8]) -> Result<(), Error>;
+        fn send(&mut self, buf: &[u8]) -> Result<(), Error>;
 
         fn frame_size(&self) -> usize;
         //  { 128 }
     }
-}
\ No newline at end of file
+}
diff --git a/components/provisioner-app/src/lib.rs b/components/provisioner-app/src/lib.rs
index d3d760e..e21fde9 100644
--- a/components/provisioner-app/src/lib.rs
+++ b/components/provisioner-app/src/lib.rs
@@ -12,16 +12,16 @@ use core::convert::TryFrom;
 use littlefs2::driver::Storage as LfsStorage;
 use littlefs2::path::PathBuf;
 
+use apdu_dispatch::app::{self, CommandView, Interface, VecView};
 use defmt::info;
+use heapless::Vec;
+use iso7816::{Instruction, Status};
 use trussed::{
+    Client as TrussedClient,
     store::{self, Store},
     syscall,
     types::Location,
-    Client as TrussedClient,
 };
-use heapless::Vec;
-use iso7816::{Status, Instruction};
-use apdu_dispatch::app::{self, CommandView, Interface, VecView};
 
 use lpc55_hal as hal;
 
@@ -136,27 +136,27 @@ where
     /// Build a serialized trussed secret key: flags(2 BE) + kind(2 BE) + material(32)
     fn serialize_secret_key(kind_code: u16, material: &[u8; 32]) -> heapless::Vec<u8, 36> {
         let mut bytes: heapless::Vec<u8, 36> = heapless::Vec::new();
-        bytes.extend_from_slice(&KEY_FLAGS_LOCAL_SENSITIVE.to_be_bytes()).unwrap();
+        bytes
+            .extend_from_slice(&KEY_FLAGS_LOCAL_SENSITIVE.to_be_bytes())
+            .unwrap();
         bytes.extend_from_slice(&kind_code.to_be_bytes()).unwrap();
         bytes.extend_from_slice(material).unwrap();
         bytes
     }
 
-    fn handle(
-        &mut self,
-        command: CommandView<'_>,
-        reply: &mut VecView<u8>,
-    ) -> app::Result {
+    fn handle(&mut self, command: CommandView<'_>, reply: &mut VecView<u8>) -> app::Result {
         match command.instruction() {
             Instruction::Select => self.do_select(command, reply),
             Instruction::WriteBinary => {
                 match self.selected_buffer {
-                    SelectedBuffer::Filename => {
-                        self.buffer_filename.extend_from_slice(command.data()).unwrap()
-                    }
-                    SelectedBuffer::File => {
-                        self.buffer_file_contents.extend_from_slice(command.data()).unwrap()
-                    }
+                    SelectedBuffer::Filename => self
+                        .buffer_filename
+                        .extend_from_slice(command.data())
+                        .unwrap(),
+                    SelectedBuffer::File => self
+                        .buffer_file_contents
+                        .extend_from_slice(command.data())
+                        .unwrap(),
                 };
                 Ok(())
             }
@@ -327,7 +327,9 @@ where
                             }
                             // Ed255 public key: no SENSITIVE flag
                             let mut key_bytes: heapless::Vec<u8, 36> = heapless::Vec::new();
-                            key_bytes.extend_from_slice(&0x0000u16.to_be_bytes()).unwrap();
+                            key_bytes
+                                .extend_from_slice(&0x0000u16.to_be_bytes())
+                                .unwrap();
                             key_bytes
                                 .extend_from_slice(&KEY_KIND_ED255.to_be_bytes())
                                 .unwrap();
@@ -344,10 +346,10 @@ where
                         BootToBootrom => {
                             use hal::traits::flash::WriteErase;
                             let flash = unsafe { hal::peripherals::flash::Flash::steal() }
-                                .enabled(&mut unsafe {
-                                    hal::peripherals::syscon::Syscon::steal()
-                                });
-                            hal::drivers::flash::FlashGordon::new(flash).erase_page(0).ok();
+                                .enabled(&mut unsafe { hal::peripherals::syscon::Syscon::steal() });
+                            hal::drivers::flash::FlashGordon::new(flash)
+                                .erase_page(0)
+                                .ok();
                             hal::raw::SCB::sys_reset()
                         }
                         #[cfg(feature = "test-attestation")]
@@ -364,11 +366,7 @@ where
         }
     }
 
-    fn do_select(
-        &mut self,
-        command: CommandView<'_>,
-        _reply: &mut VecView<u8>,
-    ) -> app::Result {
+    fn do_select(&mut self, command: CommandView<'_>, _reply: &mut VecView<u8>) -> app::Result {
         if command.data().starts_with(&TESTER_FILENAME_ID) {
             info!("select: filename buffer");
             self.selected_buffer = SelectedBuffer::Filename;
diff --git a/runners/lpc55/board/src/clock_controller.rs b/runners/lpc55/board/src/clock_controller.rs
index dd6ad59..6886886 100644
--- a/runners/lpc55/board/src/clock_controller.rs
+++ b/runners/lpc55/board/src/clock_controller.rs
@@ -1,16 +1,14 @@
 use crate::hal;
-use hal::prelude::*;
 use crate::hal::{
-    Adc,
-    Enabled,
-    Gpio,
-    Iocon,
+    drivers::{
+        clocks::Clocks,
+        pins::{self, Pin},
+    },
     peripherals::adc::{self, ChannelType},
-    Syscon,
-    Pmc,
-    drivers::{clocks::Clocks, pins::{self, Pin}},
-    typestates::pin::{state, gpio:: direction},
+    typestates::pin::{gpio::direction, state},
+    Adc, Enabled, Gpio, Iocon, Pmc, Syscon,
 };
+use hal::prelude::*;
 
 use defmt::info;
 
@@ -37,9 +35,9 @@ const ADC_VOLTAGE_HIGH: u16 = 12_700;
 
 impl DynamicClockController {
     pub fn adc_configuration() -> adc::Config {
-        let mut config: adc::Config = Default::default();
-        config.conversion_delay = 96;
-        config
+        adc::Config {
+            conversion_delay: 96,
+        }
     }
     pub fn new(
         adc: Adc<hal::typestates::init_state::Enabled>,
@@ -49,116 +47,131 @@ impl DynamicClockController {
         gpio: &mut Gpio<Enabled>,
         iocon: &mut Iocon<Enabled>,
     ) -> DynamicClockController {
-
-        let signal_button = SignalPin::take().unwrap().into_gpio_pin(iocon, gpio).into_output_high();
+        let signal_button = SignalPin::take()
+            .unwrap()
+            .into_gpio_pin(iocon, gpio)
+            .into_output_high();
 
         let adc = adc.release();
 
         adc.ie.write(|w| w.fwmie0().set_bit());
 
         adc.tctrl[ChannelType::Comparator as usize].write(|w| unsafe {
-            w.hten().set_bit()
-            .fifo_sel_a().fifo_sel_a_0()
-            .fifo_sel_b().fifo_sel_b_0()
-            .tcmd().bits(1)
-            .tpri().bits(0)
-            .tdly().bits(0)
+            w.hten()
+                .set_bit()
+                .fifo_sel_a()
+                .fifo_sel_a_0()
+                .fifo_sel_b()
+                .fifo_sel_b_0()
+                .tcmd()
+                .bits(1)
+                .tpri()
+                .bits(0)
+                .tdly()
+                .bits(0)
         });
 
-        adc.cmdl1.write(|w| unsafe {  w.adch().bits(13)     // 13 is internal 1v reference
-                                    .ctype().ctype_0()
-                                    .mode().mode_0()        // 12 bit resolution
-                                    } );
+        adc.cmdl1.write(|w| unsafe {
+            w.adch()
+                .bits(13) // 13 is internal 1v reference
+                .ctype()
+                .ctype_0()
+                .mode()
+                .mode_0() // 12 bit resolution
+        });
 
         // shouldn't use more than 2^2 averages or compare seems to lock up
-        adc.cmdh1.write(|w| unsafe { w.avgs().avgs_0()      // average 2^2 samples
-                                    .cmpen().bits(0b11)        // compare repeatedly until true
-                                    .loop_().bits(0)         // no loop
-                                    .next().bits(0)         // no next command
-                                    .sts().bits(2)
-                                } );
+        adc.cmdh1.write(|w| unsafe {
+            w.avgs()
+                .avgs_0() // average 2^2 samples
+                .cmpen()
+                .bits(0b11) // compare repeatedly until true
+                .loop_()
+                .bits(0) // no loop
+                .next()
+                .bits(0) // no next command
+                .sts()
+                .bits(2)
+        });
 
         DynamicClockController {
-            adc: adc,
-            signal_button: signal_button,
-            pmc: pmc,
-            clocks: clocks,
-            syscon: syscon,
+            adc,
+            signal_button,
+            pmc,
+            clocks,
+            syscon,
             decrease_count: 0,
         }
     }
 
-    pub fn start_low_voltage_compare(&mut self, ) {
-        self.adc.cv1.write(|w| unsafe {
-            w.cvl().bits(0)
-            .cvh().bits(ADC_VOLTAGE_LOW)
-        });
+    pub fn start_low_voltage_compare(&mut self) {
+        self.adc
+            .cv1
+            .write(|w| unsafe { w.cvl().bits(0).cvh().bits(ADC_VOLTAGE_LOW) });
 
-        self.adc.swtrig.write(|w| unsafe {w.bits(0)});
-        self.adc.swtrig.write(|w| unsafe {w.bits(1<<(ChannelType::Comparator as usize))});
+        self.adc.swtrig.write(|w| unsafe { w.bits(0) });
+        self.adc
+            .swtrig
+            .write(|w| unsafe { w.bits(1 << (ChannelType::Comparator as usize)) });
     }
 
+    pub fn start_high_voltage_compare(&mut self) {
+        self.adc
+            .cv1
+            .write(|w| unsafe { w.cvl().bits(ADC_VOLTAGE_HIGH).cvh().bits(0x7ff8) });
 
-
-    pub fn start_high_voltage_compare(&mut self, ) {
-        self.adc.cv1.write(|w| unsafe {
-            w.cvl().bits(ADC_VOLTAGE_HIGH)
-            .cvh().bits(0x7ff8)
-        });
-
-        self.adc.swtrig.write(|w| unsafe {w.bits(0)});
-        self.adc.swtrig.write(|w| unsafe {w.bits(1<<(ChannelType::Comparator as usize))});
+        self.adc.swtrig.write(|w| unsafe { w.bits(0) });
+        self.adc
+            .swtrig
+            .write(|w| unsafe { w.bits(1 << (ChannelType::Comparator as usize)) });
     }
 
-    fn decrease_clock(&mut self,){
+    fn decrease_clock(&mut self) {
         #[cfg(feature = "enable-clock-controller-signal-pin")]
         self.signal_button.set_low().ok();
 
-        let requirements = hal::ClockRequirements::default()
-            .system_frequency(12.MHz());
+        let requirements = hal::ClockRequirements::default().system_frequency(12.MHz());
 
-        self.clocks = unsafe { requirements.reconfigure(self.clocks, &mut self.pmc, &mut self.syscon) };
+        self.clocks =
+            unsafe { requirements.reconfigure(self.clocks, &mut self.pmc, &mut self.syscon) };
         self.decrease_count += 1;
     }
 
-    fn increase_clock(&mut self,){
+    fn increase_clock(&mut self) {
         #[cfg(feature = "enable-clock-controller-signal-pin")]
         self.signal_button.set_high().ok();
 
         let requirements = if self.decrease_count > 2 {
             // opt for slower freq if there's too many dips in power
-            hal::ClockRequirements::default()
-                .system_frequency(48.MHz())
+            hal::ClockRequirements::default().system_frequency(48.MHz())
         } else {
-            hal::ClockRequirements::default()
-                .system_frequency(96.MHz())
+            hal::ClockRequirements::default().system_frequency(96.MHz())
         };
 
-        self.clocks = unsafe { requirements.reconfigure(self.clocks, &mut self.pmc, &mut self.syscon) };
+        self.clocks =
+            unsafe { requirements.reconfigure(self.clocks, &mut self.pmc, &mut self.syscon) };
     }
 
     /// Used for debugging to tune the ADC points
-    pub fn evaluate(&mut self){
+    pub fn evaluate(&mut self) {
         info!("status = {:02X}", self.adc.stat.read().bits());
-        self.adc.cmdh1.modify(|_,w| unsafe { w
-                                    .cmpen().bits(0)
-                                } );
-        for _ in 0 .. 50 {
-            self.adc.swtrig.write(|w| unsafe {w.bits(0)});
-            self.adc.swtrig.write(|w| unsafe {w.bits(1<<(ChannelType::Comparator as usize))});
-            while self.adc.fctrl[0].read().fcount().bits() == 0 {
-            }
+        self.adc.cmdh1.modify(|_, w| unsafe { w.cmpen().bits(0) });
+        for _ in 0..50 {
+            self.adc.swtrig.write(|w| unsafe { w.bits(0) });
+            self.adc
+                .swtrig
+                .write(|w| unsafe { w.bits(1 << (ChannelType::Comparator as usize)) });
+            while self.adc.fctrl[0].read().fcount().bits() == 0 {}
             let result = self.adc.resfifo[0].read().bits();
             let _sample = (result & 0xffff) as u16;
             info!("Vref bias = {}", _sample);
         }
-        self.adc.cmdh1.modify(|_,w| unsafe { w
-                                    .cmpen().bits(0b11)
-                                } );
+        self.adc
+            .cmdh1
+            .modify(|_, w| unsafe { w.cmpen().bits(0b11) });
     }
 
     pub fn handle(&mut self) {
-
         let count = self.adc.fctrl[0].read().fcount().bits();
         if count == 0 {
             info!("Error: no sample in fifo!");
@@ -169,16 +182,17 @@ impl DynamicClockController {
             info!("Got >1 sample!");
         }
         let result = self.adc.resfifo[0].read().bits();
-        if  (result & 0x80000000) == 0 {
+        if (result & 0x80000000) == 0 {
             panic!("underflow on compare");
         }
         let sample = (result & 0xffff) as u16;
 
-        self.adc.ctrl.modify(|_,w| { w.rstfifo0().set_bit().rstfifo1().set_bit() });
+        self.adc
+            .ctrl
+            .modify(|_, w| w.rstfifo0().set_bit().rstfifo1().set_bit());
         // info!("handle ADC: {}. status: {}", sample, self.adc.stat.read().bits());
         #[cfg(not(feature = "no-clock-controller"))]
         {
-
             if sample < ADC_VOLTAGE_HIGH {
                 // info!("Voltage is high.  increase clock rate!");
                 self.increase_clock();
diff --git a/runners/lpc55/board/src/lib.rs b/runners/lpc55/board/src/lib.rs
index a7933eb..d5bbe45 100644
--- a/runners/lpc55/board/src/lib.rs
+++ b/runners/lpc55/board/src/lib.rs
@@ -19,15 +19,9 @@ pub mod solo2;
 #[cfg(feature = "solo2")]
 pub use solo2 as specifics;
 
-pub use shared::{
-    CLOCK_FREQ,
-    Reboot,
-};
+pub use shared::{Reboot, CLOCK_FREQ};
 
-pub use specifics::{
-    button::ThreeButtons,
-    led::RgbLed,
-};
+pub use specifics::{button::ThreeButtons, led::RgbLed};
 
 pub mod clock_controller;
 pub mod nfc;
diff --git a/runners/lpc55/board/src/lpcxpresso55/button.rs b/runners/lpc55/board/src/lpcxpresso55/button.rs
index 3455d30..8adee8b 100644
--- a/runners/lpc55/board/src/lpcxpresso55/button.rs
+++ b/runners/lpc55/board/src/lpcxpresso55/button.rs
@@ -1,22 +1,11 @@
-use core::convert::Infallible;
+use crate::hal::drivers::timer;
+use crate::hal::peripherals::ctimer;
 use crate::hal::traits::wg::digital::v2::InputPin;
 use crate::hal::traits::wg::timer::CountDown;
-use crate::hal::{
-    self,
-    drivers::pins,
-    typestates::pin,
-};
-use crate::hal::drivers::timer;
-use crate::hal::peripherals::{
-    ctimer,
-};
-use crate::traits::buttons::{
-    Button,State,
-    Press,Edge,
-};
-use crate::hal::typestates::{
-    init_state,
-};
+use crate::hal::typestates::init_state;
+use crate::hal::{self, drivers::pins, typestates::pin};
+use crate::traits::buttons::{Button, Edge, Press, State};
+use core::convert::Infallible;
 use hal::time::DurationExtensions;
 pub type UserButtonPin = pins::Pio1_9;
 pub type WakeupButtonPin = pins::Pio1_18;
@@ -29,8 +18,9 @@ pub type ThreeButtons = XpressoButtons<ctimer::Ctimer1<init_state::Enabled>>;
 // impl<P1,P2,P3, > TouchSensor<P1, P2, P3, >
 // where P1: PinId, P2: PinId, P3: PinId
 
-pub struct XpressoButtons <CTIMER>
-where CTIMER: ctimer::Ctimer<init_state::Enabled>
+pub struct XpressoButtons<CTIMER>
+where
+    CTIMER: ctimer::Ctimer<init_state::Enabled>,
 {
     last_state: State,
     user_button: UserButton,
@@ -38,50 +28,55 @@ where CTIMER: ctimer::Ctimer<init_state::Enabled>
     timer: timer::Timer<CTIMER>,
 }
 
-impl <CTIMER> XpressoButtons <CTIMER>
-where CTIMER: ctimer::Ctimer<init_state::Enabled>
+impl<CTIMER> XpressoButtons<CTIMER>
+where
+    CTIMER: ctimer::Ctimer<init_state::Enabled>,
 {
     // pub fn new (timer: timer::Timer<CTIMER>, user_button: UserButton, wakeup_button: WakeupButton) -> XpressoButtons<CTIMER> {
-    pub fn new (timer: timer::Timer<CTIMER>, gpio: &mut hal::Gpio<hal::Enabled>, iocon: &mut hal::Iocon<hal::Enabled>) -> XpressoButtons<CTIMER> {
-        let user_button = UserButtonPin::take().unwrap().into_gpio_pin(iocon, gpio).into_input();
-        let wakeup_button = WakeupButtonPin::take().unwrap().into_gpio_pin(iocon, gpio).into_input();
+    pub fn new(
+        timer: timer::Timer<CTIMER>,
+        gpio: &mut hal::Gpio<hal::Enabled>,
+        iocon: &mut hal::Iocon<hal::Enabled>,
+    ) -> XpressoButtons<CTIMER> {
+        let user_button = UserButtonPin::take()
+            .unwrap()
+            .into_gpio_pin(iocon, gpio)
+            .into_input();
+        let wakeup_button = WakeupButtonPin::take()
+            .unwrap()
+            .into_gpio_pin(iocon, gpio)
+            .into_input();
         let buts = State {
             a: user_button.is_high().ok().unwrap(),
             b: wakeup_button.is_high().ok().unwrap(),
             middle: wakeup_button.is_high().ok().unwrap(),
         };
         Self {
-            user_button: user_button,
-            wakeup_button: wakeup_button,
+            user_button,
+            wakeup_button,
             last_state: buts,
-            timer: timer,
+            timer,
         }
     }
 }
 
-impl<CTIMER> Press for XpressoButtons <CTIMER>
-where CTIMER: ctimer::Ctimer<init_state::Enabled>
+impl<CTIMER> Press for XpressoButtons<CTIMER>
+where
+    CTIMER: ctimer::Ctimer<init_state::Enabled>,
 {
-
     // A minimal button implementation for Xpresso
     fn is_pressed(&self, but: Button) -> bool {
         match but {
-            Button::A=> {
-                self.user_button.is_low().ok().unwrap()
-            }
-            Button::B => {
-                self.wakeup_button.is_low().ok().unwrap()
-            }
-            _ => {
-                self.wakeup_button.is_low().ok().unwrap()
-            }
+            Button::A => self.user_button.is_low().ok().unwrap(),
+            Button::B => self.wakeup_button.is_low().ok().unwrap(),
+            _ => self.wakeup_button.is_low().ok().unwrap(),
         }
     }
-
 }
 
-impl<CTIMER> XpressoButtons <CTIMER>
-where CTIMER: ctimer::Ctimer<init_state::Enabled>
+impl<CTIMER> XpressoButtons<CTIMER>
+where
+    CTIMER: ctimer::Ctimer<init_state::Enabled>,
 {
     fn get_status_debounced(&mut self) -> State {
         // first, remove jitter
@@ -93,10 +88,10 @@ where CTIMER: ctimer::Ctimer<init_state::Enabled>
         if new_state.a != new_state2.a {
             new_state.a = self.last_state.a;
         }
-        if new_state.b != new_state2.b{
+        if new_state.b != new_state2.b {
             new_state.b = self.last_state.b;
         }
-        if new_state.middle != new_state2.middle{
+        if new_state.middle != new_state2.middle {
             new_state.middle = self.last_state.middle;
         }
 
@@ -104,10 +99,10 @@ where CTIMER: ctimer::Ctimer<init_state::Enabled>
     }
 
     fn read_button_edge(&mut self, but: Button, edge_type: bool) -> bool {
-
         let new_state = self.get_status_debounced();
 
-        let mid_edge = (self.last_state.middle ^ new_state.middle) && (self.last_state.middle ^ edge_type);
+        let mid_edge =
+            (self.last_state.middle ^ new_state.middle) && (self.last_state.middle ^ edge_type);
         let top_edge = (self.last_state.a ^ new_state.a) && (self.last_state.a ^ edge_type);
         let bot_edge = (self.last_state.b ^ new_state.b) && (self.last_state.b ^ edge_type);
 
@@ -128,8 +123,9 @@ where CTIMER: ctimer::Ctimer<init_state::Enabled>
     }
 }
 
-impl<CTIMER> Edge for XpressoButtons <CTIMER>
-where CTIMER: ctimer::Ctimer<init_state::Enabled>
+impl<CTIMER> Edge for XpressoButtons<CTIMER>
+where
+    CTIMER: ctimer::Ctimer<init_state::Enabled>,
 {
     /// Non-blockingly wait for the button to be pressed.
     /// This is edge sensitive, meaning it will not complete successfully more than once
@@ -155,7 +151,7 @@ where CTIMER: ctimer::Ctimer<init_state::Enabled>
     }
 
     /// See wait_for_press
-    fn wait_for_any_new_press(&mut self, ) -> nb::Result<Button, Infallible> {
+    fn wait_for_any_new_press(&mut self) -> nb::Result<Button, Infallible> {
         if self.read_button_edge(Button::A, true) {
             Ok(Button::A)
         } else if self.read_button_edge(Button::B, true) {
@@ -168,7 +164,7 @@ where CTIMER: ctimer::Ctimer<init_state::Enabled>
     }
 
     /// See wait_for_release
-    fn wait_for_any_new_release(&mut self, ) -> nb::Result<Button, Infallible> {
+    fn wait_for_any_new_release(&mut self) -> nb::Result<Button, Infallible> {
         if self.read_button_edge(Button::A, false) {
             Ok(Button::A)
         } else if self.read_button_edge(Button::B, false) {
@@ -180,15 +176,19 @@ where CTIMER: ctimer::Ctimer<init_state::Enabled>
         }
     }
 
-    fn wait_for_new_squeeze(&mut self, ) -> nb::Result<(), Infallible> {
+    fn wait_for_new_squeeze(&mut self) -> nb::Result<(), Infallible> {
         let oldstate = self.last_state;
         let a = self.read_button_edge(Button::A, true);
         let b = self.read_button_edge(Button::B, true);
         if a && b {
             Ok(())
         } else {
-            if a { self.last_state.a = oldstate.a; }
-            if b { self.last_state.b = oldstate.b; }
+            if a {
+                self.last_state.a = oldstate.a;
+            }
+            if b {
+                self.last_state.b = oldstate.b;
+            }
             Err(nb::Error::WouldBlock)
         }
     }
diff --git a/runners/lpc55/board/src/lpcxpresso55/led.rs b/runners/lpc55/board/src/lpcxpresso55/led.rs
index 9d10278..7b91741 100644
--- a/runners/lpc55/board/src/lpcxpresso55/led.rs
+++ b/runners/lpc55/board/src/lpcxpresso55/led.rs
@@ -3,14 +3,11 @@ use crate::hal::{
     drivers::pins,
     drivers::pwm,
     peripherals::ctimer,
+    traits::wg::Pwm,
     typestates::{
         init_state,
-        pin::{
-            self,
-            function,
-        },
+        pin::{self, function},
     },
-    traits::wg::Pwm,
     Iocon,
 };
 pub enum Color {
@@ -34,10 +31,18 @@ pub type BlueLedPin = pins::Pio1_4;
 #[cfg(feature = "okdoe1")]
 pub type BlueLedPin = pins::Pio1_6;
 
-
-type RedLed = hal::Pin<RedLedPin, pin::state::Special<function::MATCH_OUTPUT1<ctimer::Ctimer2<init_state::Enabled>>>>;
-type GreenLed = hal::Pin<GreenLedPin, pin::state::Special<function::MATCH_OUTPUT2<ctimer::Ctimer2<init_state::Enabled>>>>;
-type BlueLed = hal::Pin<BlueLedPin, pin::state::Special<function::MATCH_OUTPUT1<ctimer::Ctimer2<init_state::Enabled>>>>;
+type RedLed = hal::Pin<
+    RedLedPin,
+    pin::state::Special<function::MATCH_OUTPUT1<ctimer::Ctimer2<init_state::Enabled>>>,
+>;
+type GreenLed = hal::Pin<
+    GreenLedPin,
+    pin::state::Special<function::MATCH_OUTPUT2<ctimer::Ctimer2<init_state::Enabled>>>,
+>;
+type BlueLed = hal::Pin<
+    BlueLedPin,
+    pin::state::Special<function::MATCH_OUTPUT1<ctimer::Ctimer2<init_state::Enabled>>>,
+>;
 
 type PwmDriver = pwm::Pwm<ctimer::Ctimer2<init_state::Enabled>>;
 
@@ -46,16 +51,12 @@ pub struct RgbLed {
 }
 
 impl RgbLed {
-    pub fn new(
-        mut pwm: PwmDriver,
-        iocon: &mut Iocon<init_state::Enabled>
-    ) -> RgbLed{
-
+    pub fn new(mut pwm: PwmDriver, iocon: &mut Iocon<init_state::Enabled>) -> RgbLed {
         let red = RedLedPin::take().unwrap();
         let green = GreenLedPin::take().unwrap();
         let blue = BlueLedPin::take().unwrap();
 
-        pwm.set_duty(RedLed::CHANNEL,0);
+        pwm.set_duty(RedLed::CHANNEL, 0);
         pwm.set_duty(GreenLed::CHANNEL, 0);
         pwm.set_duty(BlueLed::CHANNEL, 0);
         pwm.enable(RedLed::CHANNEL);
@@ -69,18 +70,16 @@ impl RgbLed {
 
         pwm.scale_max_duty_by(16);
 
-        Self {
-            pwm,
-        }
+        Self { pwm }
     }
 }
 
 impl rgb_led::RgbLed for RgbLed {
-    fn red(&mut self, intensity: u8){
+    fn red(&mut self, intensity: u8) {
         self.pwm.set_duty(RedLed::CHANNEL, intensity.into());
     }
 
-    fn green(&mut self, intensity: u8){
+    fn green(&mut self, intensity: u8) {
         self.pwm.set_duty(GreenLed::CHANNEL, intensity.into());
     }
 
diff --git a/runners/lpc55/board/src/nfc.rs b/runners/lpc55/board/src/nfc.rs
index 060fa67..41da4a5 100644
--- a/runners/lpc55/board/src/nfc.rs
+++ b/runners/lpc55/board/src/nfc.rs
@@ -2,25 +2,17 @@ use crate::hal::{
     self,
     drivers::{
         pins::{self, Pin},
-        SpiMaster,
-        Timer,
+        SpiMaster, Timer,
     },
-    Enabled,
     peripherals::flexcomm::Spi0,
     time::RateExtensions,
-    typestates::{
-        pin::{
-            self,
-            flexcomm::NoPio,
-        },
-    },
+    typestates::pin::{self, flexcomm::NoPio},
+    Enabled,
 };
 
 use defmt::info;
 
-use fm11nc08::{
-    FM11NC08, Configuration, Register,
-};
+use fm11nc08::{Configuration, Register, FM11NC08};
 
 pub type NfcSckPin = pins::Pio0_28;
 pub type NfcMosiPin = pins::Pio0_24;
@@ -29,22 +21,22 @@ pub type NfcCsPin = pins::Pio1_20;
 pub type NfcIrqPin = pins::Pio0_19;
 
 pub type NfcChip = FM11NC08<
-            SpiMaster<
-                NfcSckPin,
-                NfcMosiPin,
-                NfcMisoPin,
-                NoPio,
-                Spi0,
-                (
-                    Pin<NfcSckPin, pin::state::Special<pin::function::FC0_SCK>>,
-                    Pin<NfcMosiPin, pin::state::Special<pin::function::FC0_RXD_SDA_MOSI_DATA>>,
-                    Pin<NfcMisoPin, pin::state::Special<pin::function::FC0_TXD_SCL_MISO_WS>>,
-                    pin::flexcomm::NoCs,
-                )
-                >,
-                Pin<NfcCsPin, pin::state::Gpio<pin::gpio::direction::Output>>,
-                Pin<NfcIrqPin, pin::state::Gpio<pin::gpio::direction::Input>>,
-            >;
+    SpiMaster<
+        NfcSckPin,
+        NfcMosiPin,
+        NfcMisoPin,
+        NoPio,
+        Spi0,
+        (
+            Pin<NfcSckPin, pin::state::Special<pin::function::FC0_SCK>>,
+            Pin<NfcMosiPin, pin::state::Special<pin::function::FC0_RXD_SDA_MOSI_DATA>>,
+            Pin<NfcMisoPin, pin::state::Special<pin::function::FC0_TXD_SCL_MISO_WS>>,
+            pin::flexcomm::NoCs,
+        ),
+    >,
+    Pin<NfcCsPin, pin::state::Gpio<pin::gpio::direction::Output>>,
+    Pin<NfcIrqPin, pin::state::Gpio<pin::gpio::direction::Input>>,
+>;
 
 pub fn try_setup(
     spi: Spi0<Enabled>,
@@ -54,9 +46,7 @@ pub fn try_setup(
     // fm: &mut NfcChip,
     timer: &mut Timer<impl hal::peripherals::ctimer::Ctimer<hal::typestates::init_state::Enabled>>,
     always_reconfig: bool,
-    ) -> Option<NfcChip> {
-
-
+) -> Option<NfcChip> {
     let sck = NfcSckPin::take().unwrap().into_spi0_sck_pin(iocon);
     let mosi = NfcMosiPin::take().unwrap().into_spi0_mosi_pin(iocon);
     let miso = NfcMisoPin::take().unwrap().into_spi0_miso_pin(iocon);
@@ -68,21 +58,25 @@ pub fn try_setup(
         spi,
         (sck, mosi, miso, hal::typestates::pin::flexcomm::NoCs),
         2_000_000u32.Hz(),
-        spi_mode);
+        spi_mode,
+    );
 
     // Start unselected.
-    let nfc_cs = NfcCsPin::take().unwrap().into_gpio_pin(iocon, gpio).into_output_high();
+    let nfc_cs = NfcCsPin::take()
+        .unwrap()
+        .into_gpio_pin(iocon, gpio)
+        .into_output_high();
 
     let mut fm = FM11NC08::new(spi, nfc_cs, nfc_irq).enabled();
 
     //                      no limit      2mA resistor    3.3V
-    const REGU_CONFIG: u8 = (0b11 << 4) | (0b10 << 2) | (0b11 << 0);
+    const REGU_CONFIG: u8 = (0b11 << 4) | (0b10 << 2) | 0b11;
     let current_regu_config = fm.read_reg(fm11nc08::Register::ReguCfg);
     let current_nfc_config = fm.read_reg(fm11nc08::Register::NfcCfg);
 
     // regu_config gets configured by upstream vendor testing, so we need
     // to additionally test on another value to see if eeprom is configured by us.
-    let is_select_int_masked = (current_nfc_config &  1) == 1;
+    let is_select_int_masked = (current_nfc_config & 1) == 1;
 
     if current_regu_config == 0xff {
         // No nfc chip connected
@@ -90,7 +84,8 @@ pub fn try_setup(
         return None;
     }
 
-    let reconfig = always_reconfig || (current_regu_config != REGU_CONFIG) || (is_select_int_masked);
+    let reconfig =
+        always_reconfig || (current_regu_config != REGU_CONFIG) || (is_select_int_masked);
 
     if reconfig {
         // info_now!("{:?}", fm.dump_eeprom() );
@@ -98,23 +93,26 @@ pub fn try_setup(
 
         info!("writing EEPROM");
 
-        let r = fm.configure(Configuration{
-            regu: REGU_CONFIG,
-            ataq: 0x4400,
-            sak1: 0x04,
-            sak2: 0x20,
-            tl: 0x05,
-            // (x[7:4], FSDI[3:0]) . FSDI[2] == 32 byte frame, FSDI[8] == 256 byte frame, 7==128byte
-            t0: 0x78,
-            // Support different data rates for both directions
-            // Support divisor 2 / 212kbps for tx and rx
-            ta: 0b10010001,
-            // (FWI[b4], SFGI[b4]), (256 * 16 / fc) * 2 ^ value
-            tb: 0x78,
-            tc: 0x00,
+        let r = fm.configure(
+            Configuration {
+                regu: REGU_CONFIG,
+                ataq: 0x4400,
+                sak1: 0x04,
+                sak2: 0x20,
+                tl: 0x05,
+                // (x[7:4], FSDI[3:0]) . FSDI[2] == 32 byte frame, FSDI[8] == 256 byte frame, 7==128byte
+                t0: 0x78,
+                // Support different data rates for both directions
+                // Support divisor 2 / 212kbps for tx and rx
+                ta: 0b10010001,
+                // (FWI[b4], SFGI[b4]), (256 * 16 / fc) * 2 ^ value
+                tb: 0x78,
+                tc: 0x00,
                 // enable P-on IRQ    14443-4 mode
-            nfc:    (0b0 << 1) |       (0b00 << 2),
-        }, timer);
+                nfc: (0b00 << 2),
+            },
+            timer,
+        );
         if r.is_err() {
             info!("Eeprom failed.  No NFC chip connected?");
             return None;
@@ -125,20 +123,21 @@ pub fn try_setup(
 
     // disable all interrupts except RxStart
     fm.write_reg(Register::AuxIrqMask, 0x00);
-    fm.write_reg(Register::FifoIrqMask,
+    fm.write_reg(
+        Register::FifoIrqMask,
         // 0x0
         0xff
         ^ (1 << 3) /* water-level */
-        ^ (1 << 1) /* fifo-full */
+        ^ (1 << 1), /* fifo-full */
     );
-    fm.write_reg(Register::MainIrqMask,
+    fm.write_reg(
+        Register::MainIrqMask,
         // 0x0
-        0xff
-        ^ fm11nc08::device::Interrupt::RxStart as u8
-        ^ fm11nc08::device::Interrupt::RxDone as u8
-        ^ fm11nc08::device::Interrupt::TxDone as u8
-        ^ fm11nc08::device::Interrupt::Fifo as u8
-        ^ fm11nc08::device::Interrupt::Active as u8
+        0xff ^ fm11nc08::device::Interrupt::RxStart as u8
+            ^ fm11nc08::device::Interrupt::RxDone as u8
+            ^ fm11nc08::device::Interrupt::TxDone as u8
+            ^ fm11nc08::device::Interrupt::Fifo as u8
+            ^ fm11nc08::device::Interrupt::Active as u8,
     );
 
     //                    no limit    rrfcfg .      3.3V
diff --git a/runners/lpc55/board/src/shared.rs b/runners/lpc55/board/src/shared.rs
index 7df80e6..451c2e5 100644
--- a/runners/lpc55/board/src/shared.rs
+++ b/runners/lpc55/board/src/shared.rs
@@ -15,14 +15,17 @@ impl crate::traits::Reboot for Reboot {
         // Erasing the first flash page & rebooting will keep processor in bootrom persistently.
         // This is however destructive, as a valid firmware will need to be flashed.
         use hal::traits::flash::WriteErase;
-        let flash = unsafe { hal::peripherals::flash::Flash::steal() }.enabled(
-            &mut unsafe {hal::peripherals::syscon::Syscon::steal()}
-        );
-        hal::drivers::flash::FlashGordon::new(flash).erase_page(0).ok();
+        let flash = unsafe { hal::peripherals::flash::Flash::steal() }
+            .enabled(&mut unsafe { hal::peripherals::syscon::Syscon::steal() });
+        hal::drivers::flash::FlashGordon::new(flash)
+            .erase_page(0)
+            .ok();
         hal::raw::SCB::sys_reset()
     }
     fn locked() -> bool {
-        let seal = &unsafe { hal::raw::Peripherals::steal() }.FLASH_CMPA.sha256_digest;
+        let seal = &unsafe { hal::raw::Peripherals::steal() }
+            .FLASH_CMPA
+            .sha256_digest;
         seal.iter().any(|word| word.read().bits() != 0)
     }
 }
diff --git a/runners/lpc55/board/src/solo2/button.rs b/runners/lpc55/board/src/solo2/button.rs
index 7dafe44..5f5929c 100644
--- a/runners/lpc55/board/src/solo2/button.rs
+++ b/runners/lpc55/board/src/solo2/button.rs
@@ -1,9 +1,8 @@
-use core::convert::Infallible;
 use crate::hal::{
     self,
     drivers::pins,
     // drivers::Pin,
-    drivers::touch::{Compare, Edge, TouchSensor, ButtonPins, TouchSensorChannel},
+    drivers::touch::{ButtonPins, Compare, Edge, TouchSensor, TouchSensorChannel},
     peripherals::ctimer,
     typestates::{
         init_state,
@@ -11,14 +10,12 @@ use crate::hal::{
         // pin::state::{Special, Analog},
         // pin::gpio::direction,
         // pin::function,
-        ClocksSupportTouchToken
+        ClocksSupportTouchToken,
     },
 };
+use core::convert::Infallible;
 
-use crate::traits::buttons::{
-    self,
-    Button,
-};
+use crate::traits::buttons::{self, Button};
 
 pub type ChargeMatchPin = pins::Pio1_16;
 pub type ButtonTopPin = pins::Pio0_23;
@@ -37,15 +34,19 @@ type SampleTimer = ctimer::Ctimer2<init_state::Enabled>;
 
 pub type ThreeButtons = SoloThreeTouchButtons<ButtonTopPin, ButtonBotPin, ButtonMidPin>;
 
-pub struct SoloThreeTouchButtons<P1,P2,P3>
-where P1: PinId, P2: PinId, P3: PinId{
-    touch_sensor: TouchSensor<P1,P2,P3>
+pub struct SoloThreeTouchButtons<P1, P2, P3>
+where
+    P1: PinId,
+    P2: PinId,
+    P3: PinId,
+{
+    touch_sensor: TouchSensor<P1, P2, P3>,
 }
 
 impl SoloThreeTouchButtons<ButtonTopPin, ButtonBotPin, ButtonMidPin>
 // where P1: PinId, P2: PinId, P3: PinId
 {
-    pub fn new (
+    pub fn new(
         adc: Adc,
         adc_timer: AdcTimer,
         sample_timer: SampleTimer,
@@ -62,70 +63,75 @@ impl SoloThreeTouchButtons<ButtonTopPin, ButtonBotPin, ButtonMidPin>
         let mid = ButtonMidPin::take().unwrap().into_analog_input(iocon, gpio);
         let bot = ButtonBotPin::take().unwrap().into_analog_input(iocon, gpio);
         let charge_match = ChargeMatchPin::take().unwrap().into_match_output(iocon);
-        let button_pins = ButtonPins(
-            top,bot,mid,
+        let button_pins = ButtonPins(top, bot, mid);
+        let touch_sensor = TouchSensor::new(
+            [12_000, 12_000, 12_000],
+            5,
+            adc,
+            adc_timer,
+            sample_timer,
+            charge_match,
+            button_pins,
         );
-        let touch_sensor = TouchSensor::new([
-            12_000,
-            12_000,
-            12_000,
-            ], 5, adc, adc_timer, sample_timer, charge_match, button_pins);
         let touch_sensor = touch_sensor.enabled(dma, token);
-        Self {
-            touch_sensor
-        }
+        Self { touch_sensor }
     }
 
     /// Map internal cmd number to Button type
-    fn button_get_state (&self, button: buttons::Button, ctype: Compare) -> bool {
+    fn button_get_state(&self, button: buttons::Button, ctype: Compare) -> bool {
         match button {
             Button::A => {
-                self.touch_sensor.get_state(TouchSensorChannel::Channel1, ctype).is_active
+                self.touch_sensor
+                    .get_state(TouchSensorChannel::Channel1, ctype)
+                    .is_active
             }
             Button::B => {
-                self.touch_sensor.get_state(TouchSensorChannel::Channel2, ctype).is_active
+                self.touch_sensor
+                    .get_state(TouchSensorChannel::Channel2, ctype)
+                    .is_active
             }
             Button::Middle => {
-                self.touch_sensor.get_state(TouchSensorChannel::Channel3, ctype).is_active
+                self.touch_sensor
+                    .get_state(TouchSensorChannel::Channel3, ctype)
+                    .is_active
             }
         }
     }
 
     /// Map internal cmd number to Button type
-    fn button_has_edge (&self, button: Button, edge_type: Edge,) -> bool {
+    fn button_has_edge(&self, button: Button, edge_type: Edge) -> bool {
         match button {
-            Button::A => {
-                self.touch_sensor.has_edge(TouchSensorChannel::Channel1, edge_type)
-            }
-            Button::B => {
-                self.touch_sensor.has_edge(TouchSensorChannel::Channel2, edge_type)
-            }
-            Button::Middle => {
-                self.touch_sensor.has_edge(TouchSensorChannel::Channel3, edge_type)
-            }
-
+            Button::A => self
+                .touch_sensor
+                .has_edge(TouchSensorChannel::Channel1, edge_type),
+            Button::B => self
+                .touch_sensor
+                .has_edge(TouchSensorChannel::Channel2, edge_type),
+            Button::Middle => self
+                .touch_sensor
+                .has_edge(TouchSensorChannel::Channel3, edge_type),
         }
     }
 
     fn button_reset_state(&self, button: Button, offset: i32) {
         match button {
             Button::A => {
-                self.touch_sensor.reset_results(TouchSensorChannel::Channel1, offset);
+                self.touch_sensor
+                    .reset_results(TouchSensorChannel::Channel1, offset);
             }
             Button::B => {
-                self.touch_sensor.reset_results(TouchSensorChannel::Channel2, offset);
+                self.touch_sensor
+                    .reset_results(TouchSensorChannel::Channel2, offset);
             }
             Button::Middle => {
-                self.touch_sensor.reset_results(TouchSensorChannel::Channel3, offset);
+                self.touch_sensor
+                    .reset_results(TouchSensorChannel::Channel3, offset);
             }
         }
     }
-
-
 }
 
-impl buttons::Press for SoloThreeTouchButtons<ButtonTopPin, ButtonBotPin, ButtonMidPin>
-{
+impl buttons::Press for SoloThreeTouchButtons<ButtonTopPin, ButtonBotPin, ButtonMidPin> {
     fn is_pressed(&self, button: buttons::Button) -> bool {
         self.button_get_state(button, Compare::BelowThreshold)
     }
@@ -135,8 +141,7 @@ impl buttons::Press for SoloThreeTouchButtons<ButtonTopPin, ButtonBotPin, Button
     }
 }
 
-impl buttons::Edge for SoloThreeTouchButtons<ButtonTopPin, ButtonBotPin, ButtonMidPin>
-{
+impl buttons::Edge for SoloThreeTouchButtons<ButtonTopPin, ButtonBotPin, ButtonMidPin> {
     fn wait_for_new_press(&mut self, button: Button) -> nb::Result<(), Infallible> {
         let result = self.button_has_edge(button, Edge::Falling);
 
@@ -145,9 +150,8 @@ impl buttons::Edge for SoloThreeTouchButtons<ButtonTopPin, ButtonBotPin, ButtonM
             self.button_reset_state(button, -1);
             Ok(())
         } else {
-            return Err(nb::Error::WouldBlock)
+            Err(nb::Error::WouldBlock)
         }
-
     }
 
     fn wait_for_new_release(&mut self, button: Button) -> nb::Result<(), Infallible> {
@@ -157,18 +161,15 @@ impl buttons::Edge for SoloThreeTouchButtons<ButtonTopPin, ButtonBotPin, ButtonM
             self.button_reset_state(button, 1);
             Ok(())
         } else {
-            return Err(nb::Error::WouldBlock)
+            Err(nb::Error::WouldBlock)
         }
-
     }
 
     /// See wait_for_press
-    fn wait_for_any_new_press(&mut self, ) -> nb::Result<Button, Infallible> {
-
+    fn wait_for_any_new_press(&mut self) -> nb::Result<Button, Infallible> {
         if self.wait_for_new_press(Button::A).is_ok() {
             Ok(Button::A)
-        }
-        else if self.wait_for_new_press(Button::B).is_ok() {
+        } else if self.wait_for_new_press(Button::B).is_ok() {
             Ok(Button::B)
         } else if self.wait_for_new_press(Button::Middle).is_ok() {
             Ok(Button::Middle)
@@ -178,11 +179,10 @@ impl buttons::Edge for SoloThreeTouchButtons<ButtonTopPin, ButtonBotPin, ButtonM
     }
 
     /// See wait_for_release
-    fn wait_for_any_new_release(&mut self, ) -> nb::Result<Button, Infallible> {
+    fn wait_for_any_new_release(&mut self) -> nb::Result<Button, Infallible> {
         if self.wait_for_new_release(Button::A).is_ok() {
             Ok(Button::A)
-        }
-        else if self.wait_for_new_release(Button::B).is_ok() {
+        } else if self.wait_for_new_release(Button::B).is_ok() {
             Ok(Button::B)
         } else if self.wait_for_new_release(Button::Middle).is_ok() {
             Ok(Button::Middle)
@@ -200,8 +200,7 @@ impl buttons::Edge for SoloThreeTouchButtons<ButtonTopPin, ButtonBotPin, ButtonM
             self.button_reset_state(Button::B, -1);
             Ok(())
         } else {
-            return Err(nb::Error::WouldBlock)
+            Err(nb::Error::WouldBlock)
         }
     }
 }
-
diff --git a/runners/lpc55/board/src/solo2/led.rs b/runners/lpc55/board/src/solo2/led.rs
index 221daee..ca78c12 100644
--- a/runners/lpc55/board/src/solo2/led.rs
+++ b/runners/lpc55/board/src/solo2/led.rs
@@ -3,20 +3,16 @@ use crate::hal::{
     drivers::pins,
     drivers::pwm,
     peripherals::ctimer,
+    traits::wg::Pwm,
     typestates::{
         init_state,
-        pin::{
-            self,
-            function,
-        },
+        pin::{self, function},
     },
-    traits::wg::Pwm,
     Iocon,
 };
 
 use crate::traits::rgb_led;
 
-
 pub enum Color {
     Red,
     Green,
@@ -29,15 +25,15 @@ pub type BlueLedPin = pins::Pio1_19;
 
 type RedLed = hal::Pin<
     RedLedPin,
-    pin::state::Special<function::MATCH_OUTPUT0<ctimer::Ctimer3<init_state::Enabled>>>
+    pin::state::Special<function::MATCH_OUTPUT0<ctimer::Ctimer3<init_state::Enabled>>>,
 >;
 type GreenLed = hal::Pin<
     GreenLedPin,
-    pin::state::Special<function::MATCH_OUTPUT2<ctimer::Ctimer3<init_state::Enabled>>>
+    pin::state::Special<function::MATCH_OUTPUT2<ctimer::Ctimer3<init_state::Enabled>>>,
 >;
 type BlueLed = hal::Pin<
     BlueLedPin,
-    pin::state::Special<function::MATCH_OUTPUT1<ctimer::Ctimer3<init_state::Enabled>>>
+    pin::state::Special<function::MATCH_OUTPUT1<ctimer::Ctimer3<init_state::Enabled>>>,
 >;
 
 type PwmDriver = pwm::Pwm<ctimer::Ctimer3<init_state::Enabled>>;
@@ -47,16 +43,12 @@ pub struct RgbLed {
 }
 
 impl RgbLed {
-    pub fn new(
-        mut pwm: PwmDriver,
-        iocon: &mut Iocon<init_state::Enabled>
-    ) -> RgbLed{
-
+    pub fn new(mut pwm: PwmDriver, iocon: &mut Iocon<init_state::Enabled>) -> RgbLed {
         let red = RedLedPin::take().unwrap();
         let green = GreenLedPin::take().unwrap();
         let blue = BlueLedPin::take().unwrap();
 
-        pwm.set_duty(RedLed::CHANNEL,0);
+        pwm.set_duty(RedLed::CHANNEL, 0);
         pwm.set_duty(GreenLed::CHANNEL, 0);
         pwm.set_duty(BlueLed::CHANNEL, 0);
         pwm.enable(RedLed::CHANNEL);
@@ -70,18 +62,16 @@ impl RgbLed {
 
         pwm.scale_max_duty_by(8);
 
-        Self {
-            pwm,
-        }
+        Self { pwm }
     }
 }
 
 impl rgb_led::RgbLed for RgbLed {
-    fn red(&mut self, intensity: u8){
-        self.pwm.set_duty(RedLed::CHANNEL, (intensity/2) as u16);
+    fn red(&mut self, intensity: u8) {
+        self.pwm.set_duty(RedLed::CHANNEL, (intensity / 2) as u16);
     }
 
-    fn green(&mut self, intensity: u8){
+    fn green(&mut self, intensity: u8) {
         self.pwm.set_duty(GreenLed::CHANNEL, (intensity as u16) * 3);
     }
 
@@ -89,4 +79,3 @@ impl rgb_led::RgbLed for RgbLed {
         self.pwm.set_duty(BlueLed::CHANNEL, (intensity as u16) * 8);
     }
 }
-
diff --git a/runners/lpc55/board/src/traits/buttons.rs b/runners/lpc55/board/src/traits/buttons.rs
index fe7af71..456e54e 100644
--- a/runners/lpc55/board/src/traits/buttons.rs
+++ b/runners/lpc55/board/src/traits/buttons.rs
@@ -28,7 +28,6 @@ pub struct State {
 ///
 /// Only `is_pressed` needs to actually be implemented.
 pub trait Press {
-
     /// Is the specific button currently pressed
     fn is_pressed(&self, button: Button) -> bool;
 
diff --git a/runners/lpc55/board/src/traits/rgb_led.rs b/runners/lpc55/board/src/traits/rgb_led.rs
index 113fc0f..b6f3760 100644
--- a/runners/lpc55/board/src/traits/rgb_led.rs
+++ b/runners/lpc55/board/src/traits/rgb_led.rs
@@ -7,17 +7,16 @@ pub struct Intensities {
 
 impl From<u32> for Intensities {
     // set all LEDs using (R||G||B) formatted word.
-    fn from(hex: u32) -> Self{
+    fn from(hex: u32) -> Self {
         Intensities {
-            red:   ((hex & 0xff_00_00) >> 16) as _,
+            red: ((hex & 0xff_00_00) >> 16) as _,
             green: ((hex & 0x00_ff_00) >> 8) as _,
-            blue:   (hex & 0x00_00_ff) as _,
+            blue: (hex & 0x00_00_ff) as _,
         }
     }
 }
 
 pub trait RgbLed {
-
     /// Set all LEDs
     fn set(&mut self, intensities: Intensities) {
         self.red(intensities.red);
diff --git a/runners/lpc55/board/src/trussed.rs b/runners/lpc55/board/src/trussed.rs
index 72260ac..6fddfec 100644
--- a/runners/lpc55/board/src/trussed.rs
+++ b/runners/lpc55/board/src/trussed.rs
@@ -3,11 +3,8 @@
 
 use core::time::Duration;
 
-use crate::hal::{
-    peripherals::rtc::Rtc,
-    typestates::init_state,
-};
-use crate::traits::buttons::{Press, Edge};
+use crate::hal::{peripherals::rtc::Rtc, typestates::init_state};
+use crate::traits::buttons::{Edge, Press};
 use crate::traits::rgb_led::{Intensities, RgbLed};
 use defmt::debug;
 use micromath::F32;
@@ -23,15 +20,14 @@ impl UserPresenceStatus {
         unsafe { WAITING = waiting };
     }
     pub fn waiting() -> bool {
-        unsafe{ WAITING }
+        unsafe { WAITING }
     }
 }
 
-
 pub struct UserInterface<BUTTONS, RGB>
 where
-BUTTONS: Press + Edge,
-RGB: RgbLed,
+    BUTTONS: Press + Edge,
+    RGB: RgbLed,
 {
     rtc: Rtc<init_state::Enabled>,
     buttons: Option<BUTTONS>,
@@ -42,8 +38,8 @@ RGB: RgbLed,
 
 impl<BUTTONS, RGB> UserInterface<BUTTONS, RGB>
 where
-BUTTONS: Press + Edge,
-RGB: RgbLed,
+    BUTTONS: Press + Edge,
+    RGB: RgbLed,
 {
     pub fn new(rtc: Rtc<init_state::Enabled>, _buttons: Option<BUTTONS>, rgb: Option<RGB>) -> Self {
         #[allow(unused_mut)]
@@ -58,7 +54,9 @@ RGB: RgbLed,
             }
         };
         Self {
-            rtc, buttons, rgb,
+            rtc,
+            buttons,
+            rgb,
             status: ui::Status::Idle,
             wink_until: Duration::new(0, 0),
         }
@@ -66,25 +64,52 @@ RGB: RgbLed,
 }
 
 // color codes Conor picked
-const BLACK: Intensities = Intensities { red: 0, green: 0, blue: 0 };
-const RED: Intensities = Intensities { red: u8::MAX, green: 0, blue: 0 };
-const GREEN: Intensities = Intensities { red: 0, green: 15, blue: 0x02 };
-const BLUE: Intensities = Intensities { red: 0, green: 0, blue: 55 };
-const TEAL: Intensities = Intensities { red: 0, green: 55, blue: 20 };
+const BLACK: Intensities = Intensities {
+    red: 0,
+    green: 0,
+    blue: 0,
+};
+const RED: Intensities = Intensities {
+    red: u8::MAX,
+    green: 0,
+    blue: 0,
+};
+const GREEN: Intensities = Intensities {
+    red: 0,
+    green: 15,
+    blue: 0x02,
+};
+const BLUE: Intensities = Intensities {
+    red: 0,
+    green: 0,
+    blue: 55,
+};
+const TEAL: Intensities = Intensities {
+    red: 0,
+    green: 55,
+    blue: 20,
+};
 #[allow(dead_code)]
-const ORANGE: Intensities = Intensities { red: u8::MAX, green: 0x7e, blue: 0 };
+const ORANGE: Intensities = Intensities {
+    red: u8::MAX,
+    green: 0x7e,
+    blue: 0,
+};
 #[allow(dead_code)]
-const WHITE: Intensities = Intensities { red: u8::MAX, green: u8::MAX, blue: u8::MAX };
+const WHITE: Intensities = Intensities {
+    red: u8::MAX,
+    green: u8::MAX,
+    blue: u8::MAX,
+};
 
-impl<BUTTONS, RGB> trussed::platform::UserInterface for UserInterface<BUTTONS,RGB>
+impl<BUTTONS, RGB> trussed::platform::UserInterface for UserInterface<BUTTONS, RGB>
 where
-BUTTONS: Press + Edge,
-RGB: RgbLed,
+    BUTTONS: Press + Edge,
+    RGB: RgbLed,
 {
     fn check_user_presence(&mut self) -> consent::Level {
         match &mut self.buttons {
             Some(buttons) => {
-
                 // important to read state before checking for edge,
                 // since reading an edge could clear the state.
                 let state = buttons.state();
@@ -110,7 +135,6 @@ RGB: RgbLed,
     }
 
     fn set_status(&mut self, status: ui::Status) {
-
         self.status = status;
         debug!("status set to {:?}", defmt::Debug2Format(&status));
 
@@ -137,46 +161,62 @@ RGB: RgbLed,
         let uptime = self.uptime().as_millis() as u32;
 
         if let Some(rgb) = self.rgb.as_mut() {
-
             let waiting_for_user = self.status == ui::Status::WaitingForUserPresence;
             let processing = self.status == ui::Status::Processing;
             let winking = uptime < self.wink_until.as_millis() as u32;
-            let any_button = self.buttons.as_mut()
+            let any_button = self
+                .buttons
+                .as_mut()
                 .map(|buttons| buttons.state())
                 .map(|state| state.a || state.b || state.middle)
                 .unwrap_or(false);
 
             let color = if waiting_for_user {
-
                 // breathe fast, in blue
 
                 let amplitude = calculate_amplitude(uptime, 2, 4, 75);
-                Intensities { red: 0, green: 0, blue: amplitude }
-
+                Intensities {
+                    red: 0,
+                    green: 0,
+                    blue: amplitude,
+                }
             } else if processing {
-                let on = (((F32(uptime as f32) / 250.0).round().0 as u32) % 2) != 0;
-                if on { GREEN } else { BLACK }
+                let on = !((F32(uptime as f32) / 250.0).round().0 as u32).is_multiple_of(2);
+                if on {
+                    GREEN
+                } else {
+                    BLACK
+                }
             } else if winking {
-
                 // blink rapidly
 
-                let on = (((F32(uptime as f32) / 250.0).round().0 as u32) % 2) != 0;
-                if on { BLUE } else { BLACK }
+                let on = !((F32(uptime as f32) / 250.0).round().0 as u32).is_multiple_of(2);
+                if on {
+                    BLUE
+                } else {
+                    BLACK
+                }
                 // if on { WHITE } else { BLACK }
-
             } else {
-
                 // regular behaviour: breathe slowly
 
                 let amplitude = calculate_amplitude(uptime, 10, 4, 64);
 
                 if !any_button {
                     // Use green if no button is pressed.
-                    Intensities { red: 0, green: amplitude, blue: 0 }
+                    Intensities {
+                        red: 0,
+                        green: amplitude,
+                        blue: 0,
+                    }
                     // Intensities { red: amplitude, green: 0, blue: 0 }
                 } else {
                     // Use blue if button is pressed.
-                    Intensities { red: 0, green: 0, blue: amplitude }
+                    Intensities {
+                        red: 0,
+                        green: 0,
+                        blue: amplitude,
+                    }
                 }
             };
 
@@ -185,7 +225,7 @@ RGB: RgbLed,
             // crate::logger::info!("time: {}", time).ok();
             // debug_now!("amp: {:08X}", amplitude);
             // crate::logger::info!("color: {}", hex!(color)).ok();
-            rgb.set(color.into());
+            rgb.set(color);
         }
     }
 
@@ -197,16 +237,20 @@ RGB: RgbLed,
         debug!("winking for {:?}", duration);
         self.wink_until = self.uptime() + duration;
     }
-
 }
 
-fn calculate_amplitude(now_millis: u32, period_secs: u8, min_amplitude: u8, max_amplitude: u8) -> u8 {
+fn calculate_amplitude(
+    now_millis: u32,
+    period_secs: u8,
+    min_amplitude: u8,
+    max_amplitude: u8,
+) -> u8 {
     let period = Duration::new(period_secs as u64, 0).as_millis() as u32;
-    let tau = F32(6.283185);
+    let tau = F32(core::f32::consts::TAU);
     let angle = F32(now_millis as f32) * tau / (period as f32);
     let rel_amplitude = max_amplitude - min_amplitude;
 
     // sinoidal wave on top of a baseline brightness
-    let amplitude = min_amplitude + (angle.sin().abs() * (rel_amplitude as f32)).floor().0 as u8;
-    amplitude
+
+    min_amplitude + (angle.sin().abs() * (rel_amplitude as f32)).floor().0 as u8
 }
diff --git a/runners/lpc55/build.rs b/runners/lpc55/build.rs
index 557d42d..20b4c69 100644
--- a/runners/lpc55/build.rs
+++ b/runners/lpc55/build.rs
@@ -40,7 +40,7 @@ macro_rules! add_build_variable {
     };
 
     ($file:expr, $name:literal, $value:expr) => {
-        writeln!($file, "pub const {}: &'static str = \"{}\";", $name, $value)
+        writeln!($file, "pub const {}: &str = \"{}\";", $name, $value)
             .expect("Could not write build_constants.rs file");
     };
 }
@@ -116,12 +116,12 @@ fn main() -> Result<(), Box<dyn error::Error>> {
     let mut f = File::create(&dest_path).expect("Could not create file");
 
     let hash_long_cmd = Command::new("git")
-        .args(&["rev-parse", "HEAD"])
+        .args(["rev-parse", "HEAD"])
         .output()
         .unwrap()
         .stdout;
     let hash_short_cmd = Command::new("git")
-        .args(&["rev-parse", "--short", "HEAD"])
+        .args(["rev-parse", "--short", "HEAD"])
         .output()
         .unwrap()
         .stdout;
diff --git a/runners/lpc55/rust-toolchain.toml b/runners/lpc55/rust-toolchain.toml
deleted file mode 100644
index f6f27c8..0000000
--- a/runners/lpc55/rust-toolchain.toml
+++ /dev/null
@@ -1,4 +0,0 @@
-[toolchain]
-channel = "1.93.0"
-components = ["rustfmt", "llvm-tools-preview"]
-targets = ["thumbv8m.main-none-eabi"]
diff --git a/runners/lpc55/src/initializer.rs b/runners/lpc55/src/initializer.rs
index 6dc00c4..5a7fc89 100644
--- a/runners/lpc55/src/initializer.rs
+++ b/runners/lpc55/src/initializer.rs
@@ -263,6 +263,7 @@ impl Initializer {
         }
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn try_enable_fm11nc08<T: Ctimer<hal::Enabled>>(
         &mut self,
         clocks: &Clocks,
@@ -320,10 +321,10 @@ impl Initializer {
             clocks,
             iocon,
             gpio,
-            _clock: (),
         }
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn initialize_basic(
         &mut self,
         clock_stage: &mut stages::Clock,
@@ -345,11 +346,10 @@ impl Initializer {
         #[allow(unused_mut)]
         let mut adc = Some(if self.is_nfc_passive {
             // important to start Adc early in passive mode
-            hal::Adc::from(adc)
-                .configure(board::clock_controller::DynamicClockController::adc_configuration())
+            adc.configure(board::clock_controller::DynamicClockController::adc_configuration())
                 .enabled(pmc, syscon)
         } else {
-            hal::Adc::from(adc).enabled(pmc, syscon)
+            adc.enabled(pmc, syscon)
         });
 
         let mut delay_timer =
@@ -390,7 +390,7 @@ impl Initializer {
             #[cfg(feature = "board-solo2")]
             let three_buttons = {
                 // TODO this should get saved somewhere to be released later.
-                let mut dma = hal::Dma::from(_dma).enabled(syscon);
+                let mut dma = _dma.enabled(syscon);
 
                 board::ThreeButtons::new(
                     adc.take().unwrap(),
@@ -473,11 +473,8 @@ impl Initializer {
             .split()
             .expect("could not setup iso14443 ApduInterchange");
 
-        if nfc_chip.is_some() {
-            iso14443 = Some(nfc_device::Iso14443::new(
-                nfc_chip.unwrap(),
-                contactless_requester,
-            ))
+        if let Some(chip) = nfc_chip {
+            iso14443 = Some(nfc_device::Iso14443::new(chip, contactless_requester))
         } else if self.is_nfc_passive {
             info!("Shouldn't get passive signal when there's no chip!");
         }
@@ -583,7 +580,7 @@ impl Initializer {
 
             // Only 16 bits, so take the upper bits of our semver
             let device_release = ((build_constants::CARGO_PKG_VERSION_MAJOR as u16) << 8)
-                | (build_constants::CARGO_PKG_VERSION_MINOR as u16);
+                | build_constants::CARGO_PKG_VERSION_MINOR;
 
             // our composite USB device
             let product_string = match usb_config.product_name {
@@ -647,7 +644,7 @@ impl Initializer {
         #[allow(unused_mut)]
         let mut rng = rng.enabled(syscon);
 
-        let prince = prince.enabled(&mut rng);
+        let prince = prince.enabled(&rng);
         prince.disable_all_region_2();
 
         let flash_gordon = Some(FlashGordon::new(flash.enabled(syscon)));
@@ -858,6 +855,7 @@ impl Initializer {
     }
 
     #[inline(never)]
+    #[allow(clippy::too_many_arguments)]
     pub fn initialize_all(
         &mut self,
         iocon: hal::Iocon<Unknown>,
@@ -919,7 +917,7 @@ impl Initializer {
         );
 
         stages::All {
-            trussed: trussed,
+            trussed,
             filesystem: filesystem_stage,
             usb: usb_stage,
             interfaces: interfaces_stage,
@@ -963,6 +961,6 @@ impl Initializer {
 
     /// See if LPC55 will be in NFC passive operation.  Requires first initialization stage have been done.
     pub fn is_in_passive_operation(&self, _clock_stage: &stages::Clock) -> bool {
-        return self.is_nfc_passive;
+        self.is_nfc_passive
     }
 }
diff --git a/runners/lpc55/src/initializer/stages.rs b/runners/lpc55/src/initializer/stages.rs
index 6cc343d..2bdd12a 100644
--- a/runners/lpc55/src/initializer/stages.rs
+++ b/runners/lpc55/src/initializer/stages.rs
@@ -16,14 +16,12 @@ use hal::peripherals::prince::Prince;
 use hal::typestates::pin::state::Gpio;
 
 /// Initialized clocks, Nfc interrupt pin, Iocon, Gpio.
+#[non_exhaustive]
 pub struct Clock {
     pub clocks: Clocks,
     pub nfc_irq: Option<hal::Pin<board::nfc::NfcIrqPin, Gpio<direction::Input>>>,
     pub iocon: hal::Iocon<hal::Enabled>,
     pub gpio: hal::Gpio<hal::Enabled>,
-
-    // prevent outside sources from constructing
-    pub(crate) _clock: (),
 }
 
 /// Initialized delay & performance timers, Adc, Buttons, Nfc chip, RGB LED
diff --git a/runners/lpc55/src/lib.rs b/runners/lpc55/src/lib.rs
index 94f120c..b33e4d8 100644
--- a/runners/lpc55/src/lib.rs
+++ b/runners/lpc55/src/lib.rs
@@ -32,10 +32,11 @@ impl delog::Flusher for Flusher {
 // delog!(Delogger, 16*1024, 3*1024, Flusher);
 delog!(Delogger, 3, 2048, Flusher);
 
-#[cfg(any(feature = "log-defmt"))]
+#[cfg(feature = "log-defmt")]
 static FLUSHER: Flusher = Flusher {};
 
 // TODO: move board-specifics to BSPs
+#[allow(clippy::type_complexity)]
 pub fn init_board(
     device_peripherals: hal::raw::Peripherals,
 ) -> (
@@ -50,7 +51,7 @@ pub fn init_board(
     Option<clock_controller::DynamicClockController>,
     types::NfcWaitExtender,
 ) {
-    #[cfg(any(feature = "log-defmt"))]
+    #[cfg(feature = "log-defmt")]
     Delogger::init_default(delog::LevelFilter::Debug, &FLUSHER).ok();
 
     info!(
@@ -68,7 +69,7 @@ pub fn init_board(
     let config = initializer::Config {
         secure_firmware_version: Some(build_constants::CARGO_PKG_VERSION),
         nfc_enabled: true,
-        require_prince: require_prince,
+        require_prince,
         boot_to_bootrom: true,
         usb_config: Some(initializer::UsbConfig {
             manufacturer_name: "SoloKeys",
@@ -128,7 +129,7 @@ pub fn init_board(
     );
 
     #[cfg(feature = "provisioner-app")]
-    let store = everything.filesystem.store.clone();
+    let store = everything.filesystem.store;
     #[cfg(feature = "provisioner-app")]
     let internal_fs = everything.filesystem.internal_storage_fs;
 
diff --git a/runners/lpc55/src/main.rs b/runners/lpc55/src/main.rs
index cbd33e6..3a148e7 100644
--- a/runners/lpc55/src/main.rs
+++ b/runners/lpc55/src/main.rs
@@ -210,27 +210,25 @@ mod app {
 
                     usb_classes.ctaphid.check_timeout(time / 1000);
 
-                    match usb_classes.ccid.did_start_processing() {
-                        usbd_ccid::Status::ReceivedData(milliseconds) => {
-                            c.shared
-                                .ccid_wait_extension_sender
-                                .lock(|ccid_wait_extension_sender| {
-                                    ccid_wait_extension_sender.try_send(milliseconds)
-                                })
-                                .ok();
-                        }
-                        _ => {}
+                    if let usbd_ccid::Status::ReceivedData(milliseconds) =
+                        usb_classes.ccid.did_start_processing()
+                    {
+                        c.shared
+                            .ccid_wait_extension_sender
+                            .lock(|ccid_wait_extension_sender| {
+                                ccid_wait_extension_sender.try_send(milliseconds)
+                            })
+                            .ok();
                     }
-                    match usb_classes.ctaphid.did_start_processing() {
-                        usbd_ctaphid::types::Status::ReceivedData(milliseconds) => {
-                            c.shared
-                                .ctaphid_keep_alive_sender
-                                .lock(|ctaphid_keep_alive_sender| {
-                                    ctaphid_keep_alive_sender.try_send(milliseconds)
-                                })
-                                .ok();
-                        }
-                        _ => {}
+                    if let usbd_ctaphid::types::Status::ReceivedData(milliseconds) =
+                        usb_classes.ctaphid.did_start_processing()
+                    {
+                        c.shared
+                            .ctaphid_keep_alive_sender
+                            .lock(|ctaphid_keep_alive_sender| {
+                                ctaphid_keep_alive_sender.try_send(milliseconds)
+                            })
+                            .ok();
                     }
                 }
             });
@@ -268,27 +266,25 @@ mod app {
 
             usb_classes.poll();
 
-            match usb_classes.ccid.did_start_processing() {
-                usbd_ccid::Status::ReceivedData(milliseconds) => {
-                    c.shared
-                        .ccid_wait_extension_sender
-                        .lock(|ccid_wait_extension_sender| {
-                            ccid_wait_extension_sender.try_send(milliseconds)
-                        })
-                        .ok();
-                }
-                _ => {}
+            if let usbd_ccid::Status::ReceivedData(milliseconds) =
+                usb_classes.ccid.did_start_processing()
+            {
+                c.shared
+                    .ccid_wait_extension_sender
+                    .lock(|ccid_wait_extension_sender| {
+                        ccid_wait_extension_sender.try_send(milliseconds)
+                    })
+                    .ok();
             }
-            match usb_classes.ctaphid.did_start_processing() {
-                usbd_ctaphid::types::Status::ReceivedData(milliseconds) => {
-                    c.shared
-                        .ctaphid_keep_alive_sender
-                        .lock(|ctaphid_keep_alive_sender| {
-                            ctaphid_keep_alive_sender.try_send(milliseconds)
-                        })
-                        .ok();
-                }
-                _ => {}
+            if let usbd_ctaphid::types::Status::ReceivedData(milliseconds) =
+                usb_classes.ctaphid.did_start_processing()
+            {
+                c.shared
+                    .ctaphid_keep_alive_sender
+                    .lock(|ctaphid_keep_alive_sender| {
+                        ctaphid_keep_alive_sender.try_send(milliseconds)
+                    })
+                    .ok();
             }
         });
 
@@ -302,7 +298,7 @@ mod app {
         let mask = inten & intstat;
         if mask != 0 {
             for i in 0..5 {
-                if mask & (1 << 2 * i) != 0 {
+                if mask & (1 << (2 * i)) != 0 {
                     // debug!("EP{}OUT", i);
                 }
                 if mask & (1 << (2 * i + 1)) != 0 {
@@ -341,11 +337,8 @@ mod app {
                 .ccid_wait_extension_sender
                 .lock(|ccid_wait_extension_sender| {
                     c.local.ccid_wait_extension_receiver.try_recv().ok();
-                    match status {
-                        usbd_ccid::Status::ReceivedData(milliseconds) => {
-                            ccid_wait_extension_sender.try_send(milliseconds).ok();
-                        }
-                        _ => {}
+                    if let usbd_ccid::Status::ReceivedData(milliseconds) = status {
+                        ccid_wait_extension_sender.try_send(milliseconds).ok();
                     }
                 });
         }
@@ -370,11 +363,8 @@ mod app {
                 .ctaphid_keep_alive_sender
                 .lock(|ctaphid_keep_alive_sender| {
                     c.local.ctaphid_keep_alive_receiver.try_recv().ok();
-                    match status {
-                        usbd_ctaphid::types::Status::ReceivedData(milliseconds) => {
-                            ctaphid_keep_alive_sender.try_send(milliseconds).ok();
-                        }
-                        _ => {}
+                    if let usbd_ctaphid::types::Status::ReceivedData(milliseconds) = status {
+                        ctaphid_keep_alive_sender.try_send(milliseconds).ok();
                     }
                 });
         }
diff --git a/runners/lpc55/src/types.rs b/runners/lpc55/src/types.rs
index adf5bd4..b219afe 100644
--- a/runners/lpc55/src/types.rs
+++ b/runners/lpc55/src/types.rs
@@ -144,8 +144,8 @@ mod littlefs2_prince_filesystem {
         fn read(&mut self, off: usize, buf: &mut [u8]) -> littlefs2::io::Result<usize> {
             self.prince.enable_region_2_for(|| {
                 let flash: *const u8 = (Self::BASE_OFFSET + off) as *const u8;
-                for i in 0..buf.len() {
-                    buf[i] = unsafe { *flash.offset(i as isize) };
+                for (i, slot) in buf.iter_mut().enumerate() {
+                    *slot = unsafe { *flash.add(i) };
                 }
             });
             Ok(buf.len())
@@ -459,6 +459,7 @@ impl ExtensionDispatch for Dispatch {
     }
 }
 
+#[derive(Default)]
 pub struct Syscall {}
 
 impl trussed::client::Syscall for Syscall {
@@ -468,12 +469,6 @@ impl trussed::client::Syscall for Syscall {
     }
 }
 
-impl Default for Syscall {
-    fn default() -> Self {
-        Self {}
-    }
-}
-
 /// Service endpoint type for our Dispatch.
 pub type TrussedEndpoint = ServiceEndpoint<'static, BackendIds, RunnerContext>;
 /// Client type for apps — parameterized with Dispatch to get extension support.
@@ -550,19 +545,11 @@ pub type CtaphidDispatch =
 
 /// Minimal status implementation for admin-app.
 #[cfg(feature = "admin-app")]
+#[derive(Default)]
 pub struct AdminStatus {
     random_error: bool,
 }
 
-#[cfg(feature = "admin-app")]
-impl Default for AdminStatus {
-    fn default() -> Self {
-        Self {
-            random_error: false,
-        }
-    }
-}
-
 #[cfg(feature = "admin-app")]
 impl admin_app::StatusBytes for AdminStatus {
     type Serialized = [u8; 1];
diff --git a/runners/pc/src/bin/main.rs b/runners/pc/src/bin/main.rs
index d776095..e3c44a9 100644
--- a/runners/pc/src/bin/main.rs
+++ b/runners/pc/src/bin/main.rs
@@ -1,25 +1,20 @@
-use std::{fs::File, io::Write};
 pub use embedded_hal::blocking::rng;
-use littlefs2::{const_ram_storage, consts};
 use littlefs2::fs::{Allocation, Filesystem};
+use littlefs2::{const_ram_storage, consts};
+use std::{fs::File, io::Write};
 use trussed::store::DynFilesystem;
 
-use trussed::platform::{
-    ui,
-    reboot,
-    consent,
-};
 use trussed::platform;
+use trussed::platform::{consent, reboot, ui};
 
 pub use generic_array::{
-    GenericArray,
     typenum::{U16, U512},
+    GenericArray,
 };
 
-use generic_array::typenum::{U256, U1022};
+use generic_array::typenum::{U1022, U256};
 
-
-const SOLO_STATE: &'static str = "solo-state.bin";
+const SOLO_STATE: &str = "solo-state.bin";
 
 #[allow(non_camel_case_types)]
 pub mod littlefs_params {
@@ -51,15 +46,21 @@ impl FileFlash {
 
         if let Ok(contents) = std::fs::read(SOLO_STATE) {
             println!("loaded {}", SOLO_STATE);
-            state.copy_from_slice( contents.as_slice() );
-            Self {state}
+            state.copy_from_slice(contents.as_slice());
+            Self { state }
         } else {
             println!("No state yet, creating");
-            Self {state}
+            Self { state }
         }
     }
 }
 
+impl Default for FileFlash {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl littlefs2::driver::Storage for FileFlash {
     const READ_SIZE: usize = littlefs_params::READ_SIZE;
     const WRITE_SIZE: usize = littlefs_params::WRITE_SIZE;
@@ -71,49 +72,42 @@ impl littlefs2::driver::Storage for FileFlash {
     type CACHE_SIZE = littlefs_params::CACHE_SIZE;
     type LOOKAHEAD_SIZE = littlefs_params::LOOKAHEAD_SIZE;
 
-
     fn read(&mut self, off: usize, buf: &mut [u8]) -> littlefs2::io::Result<usize> {
-        for i in 0 .. buf.len() {
-            buf[i] = self.state[i + off];
-        }
+        buf.copy_from_slice(&self.state[off..off + buf.len()]);
         Ok(buf.len())
     }
 
     fn write(&mut self, off: usize, data: &[u8]) -> littlefs2::io::Result<usize> {
-        for i in 0 .. data.len() {
-            self.state[i + off] = data[i];
-        }
+        self.state[off..off + data.len()].copy_from_slice(data);
         let mut buffer = File::create(SOLO_STATE).unwrap();
-        buffer.write(&self.state).unwrap();
-
+        buffer.write_all(&self.state).unwrap();
         Ok(data.len())
     }
 
     fn erase(&mut self, off: usize, len: usize) -> littlefs2::io::Result<usize> {
-        for i in 0 .. len {
-            self.state[i + off] = 0;
+        for byte in &mut self.state[off..off + len] {
+            *byte = 0;
         }
         let mut buffer = File::create(SOLO_STATE).unwrap();
-        buffer.write(&self.state).unwrap();
+        buffer.write_all(&self.state).unwrap();
         Ok(len)
     }
-
 }
 
 // 8KB of RAM
 const_ram_storage!(
-    name=VolatileStorage,
-    erase_value=0x00,
-    read_size=1,
-    write_size=1,
-    cache_size_ty=consts::U128,
+    name = VolatileStorage,
+    erase_value = 0x00,
+    read_size = 1,
+    write_size = 1,
+    cache_size_ty = consts::U128,
     // this is a limitation of littlefs
     // https://git.io/JeHp9
-    block_size=128,
-    block_count=8192/128,
-    lookahead_size_ty=consts::U8,
-    filename_max_plus_one_ty=consts::U256,
-    path_max_plus_one_ty=consts::U256,
+    block_size = 128,
+    block_count = 8192 / 128,
+    lookahead_size_ty = consts::U8,
+    filename_max_plus_one_ty = consts::U256,
+    path_max_plus_one_ty = consts::U256,
 );
 
 // minimum: 2 blocks
@@ -128,33 +122,32 @@ pub struct RunnerStore {
 }
 
 impl trussed::store::Store for RunnerStore {
-    fn ifs(&self) -> &dyn DynFilesystem { self.ifs }
-    fn efs(&self) -> &dyn DynFilesystem { self.efs }
-    fn vfs(&self) -> &dyn DynFilesystem { self.vfs }
+    fn ifs(&self) -> &dyn DynFilesystem {
+        self.ifs
+    }
+    fn efs(&self) -> &dyn DynFilesystem {
+        self.efs
+    }
+    fn vfs(&self) -> &dyn DynFilesystem {
+        self.vfs
+    }
 }
 
 pub type Store = RunnerStore;
 
-
 #[derive(Default)]
-pub struct UserInterface {
-}
+pub struct UserInterface {}
 
-impl trussed::platform::UserInterface for UserInterface
-{
+impl trussed::platform::UserInterface for UserInterface {
     fn check_user_presence(&mut self) -> consent::Level {
         consent::Level::Normal
     }
 
     fn set_status(&mut self, status: ui::Status) {
-
         println!("Set status: {:?}", status);
-
     }
 
-    fn refresh(&mut self) {
-
-    }
+    fn refresh(&mut self) {}
 
     fn uptime(&mut self) -> core::time::Duration {
         core::time::Duration::from_millis(1000)
@@ -164,7 +157,6 @@ impl trussed::platform::UserInterface for UserInterface
         println!("Restart!  ({:?})", to);
         std::process::exit(25);
     }
-
 }
 
 platform!(Board,
@@ -173,8 +165,7 @@ platform!(Board,
     UI: UserInterface,
 );
 
-fn main () {
-
+fn main() {
     // Allocate and mount three filesystems, leaking them to obtain 'static refs.
     let internal_storage: &'static mut FileFlash = Box::leak(Box::new(FileFlash::new()));
     let internal_alloc: &'static mut Allocation<FileFlash> =
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 5929cac..a6c5ce6 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,4 +1,4 @@
 [toolchain]
 channel = "1.94"
-components = ["llvm-tools-preview"]
+components = ["clippy", "llvm-tools-preview", "rustfmt"]
 targets = ["thumbv8m.main-none-eabi"]