Fmt

src/fadt.rs

@@ -92,7 +92,8 @@ where
 
     // Parse the DSDT
     let dsdt_header = sdt::peek_at_sdt_header(handler, dsdt_physical_address);
-    let dsdt_mapping = handler.map_physical_region::<AmlTable>(dsdt_physical_address, dsdt_header.length() as usize);
+    let dsdt_mapping = handler
+        .map_physical_region::<AmlTable>(dsdt_physical_address, dsdt_header.length() as usize);
     if let Err(error) = parse_aml_table(acpi, handler, &dsdt_mapping, b"DSDT") {
         error!("Failed to parse DSDT: {:?}. At this stage, this is expected, but should be fatal in the future", error);
     }

src/lib.rs

@@ -23,7 +23,7 @@ mod sdt;
 
 pub use rsdp_search::search_for_rsdp_bios;
 
-use alloc::{collections::BTreeMap, vec::Vec, string::String};
+use alloc::{collections::BTreeMap, string::String, vec::Vec};
 use aml::{AmlError, AmlValue};
 use core::mem;
 use core::ops::Deref;
@@ -142,8 +142,7 @@ pub trait AcpiHandler {
 }
 
 #[derive(Debug)]
-pub struct Acpi
-{
+pub struct Acpi {
     acpi_revision: u8,
     namespace: BTreeMap<String, AmlValue>,
     boot_processor: Option<Processor>,
@@ -238,7 +237,8 @@ where
     };
 
     let header = sdt::peek_at_sdt_header(handler, physical_address);
-    let mapping = handler.map_physical_region::<SdtHeader>(physical_address, header.length() as usize);
+    let mapping =
+        handler.map_physical_region::<SdtHeader>(physical_address, header.length() as usize);
 
     if revision == 0 {
         /*
@@ -252,8 +252,11 @@ where
             ((mapping.virtual_start.as_ptr() as usize) + mem::size_of::<SdtHeader>()) as *const u32;
 
         for i in 0..num_tables {
-            sdt::dispatch_sdt(&mut acpi, handler, unsafe { *tables_base.offset(i as isize) }
-                as usize)?;
+            sdt::dispatch_sdt(
+                &mut acpi,
+                handler,
+                unsafe { *tables_base.offset(i as isize) } as usize,
+            )?;
         }
     } else {
         /*
@@ -267,8 +270,11 @@ where
             ((mapping.virtual_start.as_ptr() as usize) + mem::size_of::<SdtHeader>()) as *const u64;
 
         for i in 0..num_tables {
-            sdt::dispatch_sdt(&mut acpi, handler, unsafe { *tables_base.offset(i as isize) }
-                as usize)?;
+            sdt::dispatch_sdt(
+                &mut acpi,
+                handler,
+                unsafe { *tables_base.offset(i as isize) } as usize,
+            )?;
         }
     }
 

src/madt.rs

@@ -2,7 +2,9 @@ use alloc::vec::Vec;
 use bit_field::BitField;
 use core::marker::PhantomData;
 use core::mem;
-use interrupt::{InterruptModel, IoApic, Polarity, TriggerMode, InterruptSourceOverride, NmiSource};
+use interrupt::{
+    InterruptModel, InterruptSourceOverride, IoApic, NmiSource, Polarity, TriggerMode,
+};
 use sdt::SdtHeader;
 use {Acpi, AcpiError, AcpiHandler, PhysicalMapping, Processor, ProcessorState};
 
@@ -461,12 +463,7 @@ fn parse_apic_model(
                     (false, false) => ProcessorState::Running,
                 };
 
-                let processor = Processor::new(
-                    entry.processor_id,
-                    entry.apic_id,
-                    state,
-                    is_ap,
-                );
+                let processor = Processor::new(entry.processor_id, entry.apic_id, state, is_ap);
 
                 if is_ap {
                     acpi.application_processors.push(processor);
@@ -485,7 +482,9 @@ fn parse_apic_model(
 
             MadtEntry::InterruptSourceOverride(ref entry) => {
                 if entry.bus != 0 {
-                    return Err(AcpiError::MalformedMadt("APIC: interrupt override on unsupported bus"));
+                    return Err(AcpiError::MalformedMadt(
+                        "APIC: interrupt override on unsupported bus",
+                    ));
                 }
 
                 let (polarity, trigger_mode) = parse_mps_inti_flags(entry.flags)?;
@@ -529,7 +528,9 @@ fn parse_apic_model(
     Ok(InterruptModel::Apic {
         local_apic_address,
         io_apics,
-        local_apic_nmi_line: local_apic_nmi_line.ok_or(AcpiError::MalformedMadt("APIC: no local NMI line specified"))?,
+        local_apic_nmi_line: local_apic_nmi_line.ok_or(AcpiError::MalformedMadt(
+            "APIC: no local NMI line specified",
+        ))?,
         interrupt_source_overrides,
         nmi_sources,
         also_has_legacy_pics: (*mapping).supports_8259(),

src/sdt.rs

@@ -177,19 +177,22 @@ where
      */
     match header.signature() {
         "FACP" => {
-            let fadt_mapping = handler.map_physical_region::<Fadt>(physical_address, mem::size_of::<Fadt>());
+            let fadt_mapping =
+                handler.map_physical_region::<Fadt>(physical_address, mem::size_of::<Fadt>());
             ::fadt::parse_fadt(acpi, handler, &fadt_mapping)?;
             handler.unmap_physical_region(fadt_mapping);
         }
 
         "HPET" => {
-            let hpet_mapping = handler.map_physical_region::<Hpet>(physical_address, mem::size_of::<Hpet>());
+            let hpet_mapping =
+                handler.map_physical_region::<Hpet>(physical_address, mem::size_of::<Hpet>());
             ::hpet::parse_hpet(&hpet_mapping)?;
             handler.unmap_physical_region(hpet_mapping);
         }
 
         "APIC" => {
-            let madt_mapping = handler.map_physical_region::<Madt>(physical_address, header.length() as usize);
+            let madt_mapping =
+                handler.map_physical_region::<Madt>(physical_address, header.length() as usize);
             ::madt::parse_madt(acpi, handler, &madt_mapping)?;
             handler.unmap_physical_region(madt_mapping);
         }