zephyr: Run cargo fmt

Format the source according to the default rules.  This provides a
baseline for future changes to require well-formatted source.

Signed-off-by: David Brown <[email protected]>

Author: d3zd3z

zephyr/src/align.rs

@@ -34,11 +34,12 @@ impl_alignas!(1, 2, 4, 8, 16, 32, 64, 128, 256);
 /// member of the struct.
 #[repr(transparent)]
 pub struct AlignAs<const N: usize>([<AlignAsStruct as AlignAsTrait<N>>::Aligned; 0])
-    where
+where
     AlignAsStruct: AlignAsTrait<N>;
 
 impl<const N: usize> AlignAs<N>
-    where AlignAsStruct: AlignAsTrait<N>
+where
+    AlignAsStruct: AlignAsTrait<N>,
 {
     /// Construct a new AlignAs.
     ///

zephyr/src/device.rs

@@ -10,8 +10,8 @@
 
 use crate::sync::atomic::{AtomicBool, Ordering};
 
-pub mod gpio;
 pub mod flash;
+pub mod gpio;
 
 // Allow dead code, because it isn't required for a given build to have any devices.
 /// Device uniqueness.

zephyr/src/device/flash.rs

@@ -3,8 +3,8 @@
 // Note that currently, the flash partition shares the controller, so the underlying operations
 // are not actually safe.  Need to rethink how to manage this.
 
-use crate::raw;
 use super::Unique;
+use crate::raw;
 
 /// A flash controller
 ///
@@ -20,7 +20,10 @@ pub struct FlashController {
 impl FlashController {
     /// Constructor, intended to be called by devicetree generated code.
     #[allow(dead_code)]
-    pub(crate) unsafe fn new(unique: &Unique, device: *const raw::device) -> Option<FlashController> {
+    pub(crate) unsafe fn new(
+        unique: &Unique,
+        device: *const raw::device,
+    ) -> Option<FlashController> {
         if !unique.once() {
             return None;
         }
@@ -45,7 +48,12 @@ pub struct FlashPartition {
 impl FlashPartition {
     /// Constructor, intended to be called by devicetree generated code.
     #[allow(dead_code)]
-    pub(crate) unsafe fn new(unique: &Unique, device: *const raw::device, offset: u32, size: u32) -> Option<FlashPartition> {
+    pub(crate) unsafe fn new(
+        unique: &Unique,
+        device: *const raw::device,
+        offset: u32,
+        size: u32,
+    ) -> Option<FlashPartition> {
         if !unique.once() {
             return None;
         }
@@ -54,6 +62,10 @@ impl FlashPartition {
         // but in this case, we need one for each device, so just construct it here.
         // TODO: This is not actually safe.
         let controller = FlashController { device };
-        Some(FlashPartition { controller, offset, size })
+        Some(FlashPartition {
+            controller,
+            offset,
+            size,
+        })
     }
 }

zephyr/src/device/gpio.rs

@@ -7,8 +7,8 @@
 //! pervasively throughout Zephyr device drivers.  As such, most of the calls in this module are
 //! unsafe.
 
-use crate::raw;
 use super::Unique;
+use crate::raw;
 
 /// Global instance to help make gpio in Rust slightly safer.
 ///
@@ -60,9 +60,7 @@ impl Gpio {
     /// Verify that the device is ready for use.  At a minimum, this means the device has been
     /// successfully initialized.
     pub fn is_ready(&self) -> bool {
-        unsafe {
-            raw::device_is_ready(self.device)
-        }
+        unsafe { raw::device_is_ready(self.device) }
     }
 }
 
@@ -82,7 +80,12 @@ unsafe impl Send for GpioPin {}
 impl GpioPin {
     /// Constructor, used by the devicetree generated code.
     #[allow(dead_code)]
-    pub(crate) unsafe fn new(unique: &Unique, device: *const raw::device, pin: u32, dt_flags: u32) -> Option<GpioPin> {
+    pub(crate) unsafe fn new(
+        unique: &Unique,
+        device: *const raw::device,
+        pin: u32,
+        dt_flags: u32,
+    ) -> Option<GpioPin> {
         if !unique.once() {
             return None;
         }
@@ -91,7 +94,7 @@ impl GpioPin {
                 port: device,
                 pin: pin as raw::gpio_pin_t,
                 dt_flags: dt_flags as raw::gpio_dt_flags_t,
-            }
+            },
         })
     }
 
@@ -112,9 +115,11 @@ impl GpioPin {
     pub unsafe fn configure(&mut self, _token: &mut GpioToken, extra_flags: raw::gpio_flags_t) {
         // TODO: Error?
         unsafe {
-            raw::gpio_pin_configure(self.pin.port,
+            raw::gpio_pin_configure(
+                self.pin.port,
                 self.pin.pin,
-                self.pin.dt_flags as raw::gpio_flags_t | extra_flags);
+                self.pin.dt_flags as raw::gpio_flags_t | extra_flags,
+            );
         }
     }
 

zephyr/src/lib.rs

@@ -72,7 +72,7 @@ use core::panic::PanicInfo;
 
 /// Override rust's panic.  This simplistic initial version just hangs in a loop.
 #[panic_handler]
-fn panic(info :&PanicInfo) -> ! {
+fn panic(info: &PanicInfo) -> ! {
     #[cfg(CONFIG_PRINTK)]
     {
         printkln!("panic: {}", info);

zephyr/src/logging/impl_printk.rs

@@ -24,15 +24,11 @@ impl Log for PrintkLogger {
     // printing will be racy.  Otherwise, the message will be broken into small chunks that are each
     // printed atomically.
     fn log(&self, record: &Record<'_>) {
-        printkln!("{}:{}: {}",
-                  record.level(),
-                  record.target(),
-                  record.args());
+        printkln!("{}:{}: {}", record.level(), record.target(), record.args());
     }
 
     // Flush is not needed.
-    fn flush(&self) {
-    }
+    fn flush(&self) {}
 }
 
 static PRINTK_LOGGER: PrintkLogger = PrintkLogger;

zephyr/src/logging/impl_zlog.rs

@@ -35,9 +35,7 @@ impl Log for ZlogLogger {
             // Zephyr doesn't have a separate trace, so fold that into debug.
             Level::Trace => raw::LOG_LEVEL_DBG,
         };
-        let mut msg = format!("{}: {}",
-                              record.target(),
-                              record.args());
+        let mut msg = format!("{}: {}", record.target(), record.args());
         // Append a null so this is a valid C string.  This lets us avoid an additional allocation
         // and copying.
         msg.push('\x00');
@@ -47,8 +45,7 @@ impl Log for ZlogLogger {
     }
 
     // Flush not needed.
-    fn flush(&self) {
-    }
+    fn flush(&self) {}
 }
 
 extern "C" {

zephyr/src/object.rs

@@ -188,8 +188,8 @@ where
             KOBJ_UNINITIALIZED,
             KOBJ_INITING,
             Ordering::AcqRel,
-            Ordering::Acquire)
-        {
+            Ordering::Acquire,
+        ) {
             return None;
         }
         let result = self.get_wrapped(args);
@@ -401,7 +401,7 @@ macro_rules! _kobj_stack {
                 [$crate::sys::thread::RealStaticThreadStack<{$crate::sys::thread::stack_len($size)}>; $asize] =
                 unsafe { ::core::mem::zeroed() };
 
-            $v static $name: 
+            $v static $name:
                 [$crate::_export::KStaticThreadStack; $asize] =
                 $crate::_export::KStaticThreadStack::new_from_array(&[< $name _REAL >]);
         }

zephyr/src/printk.rs

@@ -5,12 +5,7 @@
 //!
 //! This uses the `k_str_out` syscall, which is part of printk to output to the console.
 
-use core::fmt::{
-    Arguments,
-    Result,
-    Write,
-    write,
-};
+use core::fmt::{write, Arguments, Result, Write};
 
 /// Print to Zephyr's console, without a newline.
 ///

zephyr/src/sync.rs

@@ -30,17 +30,8 @@ pub use portable_atomic_util::Arc;
 
 mod mutex;
 
-pub use mutex::{
-    Mutex,
-    MutexGuard,
-    Condvar,
-    LockResult,
-    TryLockResult,
-};
+pub use mutex::{Condvar, LockResult, Mutex, MutexGuard, TryLockResult};
 
 mod spinmutex;
 
-pub use spinmutex::{
-    SpinMutex,
-    SpinMutexGuard,
-};
+pub use spinmutex::{SpinMutex, SpinMutexGuard};