Switch back to PAC as "device" instead of "stm32"

dtjones-atse · mvertescher · commit 2e3c2e9ef5c2 · 2020-03-18T18:52:23.000-04:00
diff --git a/examples/blinky.rs b/examples/blinky.rs
@@ -9,12 +9,12 @@ extern crate panic_halt;
 
 use stm32f7xx_hal as hal;
 
-use crate::hal::{stm32, prelude::*};
+use crate::hal::{device, prelude::*};
 use cortex_m_rt::entry;
 
 #[entry]
 fn main() -> ! {
-    let p = stm32::Peripherals::take().unwrap();
+    let p = device::Peripherals::take().unwrap();
 
     let gpioi = p.GPIOI.split();
     let mut led = gpioi.pi1.into_push_pull_output();
diff --git a/examples/blinky_delay.rs b/examples/blinky_delay.rs
@@ -8,11 +8,11 @@
 extern crate panic_halt;
 
 use cortex_m_rt::entry;
-use stm32f7xx_hal::{delay::Delay, stm32, prelude::*};
+use stm32f7xx_hal::{delay::Delay, device, prelude::*};
 
 #[entry]
 fn main() -> ! {
-    let p = stm32::Peripherals::take().unwrap();
+    let p = device::Peripherals::take().unwrap();
     let cp = cortex_m::Peripherals::take().unwrap();
 
     let gpioi = p.GPIOI.split();
diff --git a/examples/serial_delay.rs b/examples/serial_delay.rs
@@ -14,14 +14,14 @@ use core::fmt::Write;
 use cortex_m_rt::entry;
 use stm32f7xx_hal::{
     delay::Delay,
-    stm32,
+    device,
     prelude::*,
     serial::{self, Serial},
 };
 
 #[entry]
 fn main() -> ! {
-    let p = stm32::Peripherals::take().unwrap();
+    let p = device::Peripherals::take().unwrap();
     let cp = cortex_m::Peripherals::take().unwrap();
 
     let rcc = p.RCC.constrain();
diff --git a/examples/serial_dma.rs b/examples/serial_dma.rs
@@ -16,15 +16,15 @@ use core::pin::Pin;
 use cortex_m::{asm, interrupt};
 use cortex_m_rt::entry;
 use stm32f7xx_hal::{
-    stm32,
+    device,
     dma::{self, DMA},
     prelude::*,
     serial::{self, Serial},
 };
 
 #[entry]
 fn main() -> ! {
-    let p = stm32::Peripherals::take().unwrap();
+    let p = device::Peripherals::take().unwrap();
 
     let mut rcc = p.RCC.constrain();
 
diff --git a/examples/serial_echo.rs b/examples/serial_echo.rs
@@ -13,14 +13,14 @@ use nb::block;
 
 use cortex_m_rt::entry;
 use stm32f7xx_hal::{
-    stm32,
+    device,
     prelude::*,
     serial::{self, Serial},
 };
 
 #[entry]
 fn main() -> ! {
-    let p = stm32::Peripherals::take().unwrap();
+    let p = device::Peripherals::take().unwrap();
 
     let rcc = p.RCC.constrain();
     let clocks = rcc.cfgr.sysclk(216.mhz()).freeze();
diff --git a/examples/spi.rs b/examples/spi.rs
@@ -5,14 +5,14 @@ extern crate panic_semihosting;
 
 use cortex_m_rt::entry;
 use stm32f7xx_hal::{
-    stm32,
+    device,
     prelude::*,
     spi::{self, Spi},
 };
 
 #[entry]
 fn main() -> ! {
-    let p = stm32::Peripherals::take().unwrap();
+    let p = device::Peripherals::take().unwrap();
 
     let mut rcc = p.RCC.constrain();
 
diff --git a/examples/spi_16.rs b/examples/spi_16.rs
@@ -5,14 +5,14 @@ extern crate panic_semihosting;
 
 use cortex_m_rt::entry;
 use stm32f7xx_hal::{
-    stm32,
+    device,
     prelude::*,
     spi::{self, Spi},
 };
 
 #[entry]
 fn main() -> ! {
-    let p = stm32::Peripherals::take().unwrap();
+    let p = device::Peripherals::take().unwrap();
 
     let mut rcc = p.RCC.constrain();
 
diff --git a/examples/spi_dma.rs b/examples/spi_dma.rs
@@ -8,15 +8,15 @@ use core::pin::Pin;
 use cortex_m::{asm, interrupt};
 use cortex_m_rt::entry;
 use stm32f7xx_hal::{
-    stm32,
+    device,
     dma::{self, DMA},
     prelude::*,
     spi::{self, Spi},
 };
 
 #[entry]
 fn main() -> ! {
-    let p = stm32::Peripherals::take().unwrap();
+    let p = device::Peripherals::take().unwrap();
 
     let mut rcc = p.RCC.constrain();
 
diff --git a/examples/spi_dma_16.rs b/examples/spi_dma_16.rs
@@ -8,15 +8,15 @@ use core::pin::Pin;
 use cortex_m::{asm, interrupt};
 use cortex_m_rt::entry;
 use stm32f7xx_hal::{
-    stm32,
+    device,
     dma::{self, DMA},
     prelude::*,
     spi::{self, Spi},
 };
 
 #[entry]
 fn main() -> ! {
-    let p = stm32::Peripherals::take().unwrap();
+    let p = device::Peripherals::take().unwrap();
 
     let mut rcc = p.RCC.constrain();
 
diff --git a/examples/timer.rs b/examples/timer.rs
@@ -13,7 +13,7 @@ use cortex_m_rt::entry;
 use cortex_m_semihosting::hio;
 
 use stm32f7xx_hal::{
-    stm32, interrupt,
+    device, interrupt,
     prelude::*,
     timer::{Event, Timer},
 };
@@ -24,13 +24,13 @@ fn main() -> ! {
     writeln!(hstdout, "Starting timer...").unwrap();
 
     let cp = cortex_m::Peripherals::take().unwrap();
-    let dp = stm32::Peripherals::take().unwrap();
+    let dp = device::Peripherals::take().unwrap();
 
     let mut rcc = dp.RCC.constrain();
     let clocks = rcc.cfgr.freeze();
 
     let mut nvic = cp.NVIC;
-    nvic.enable(stm32::Interrupt::TIM2);
+    nvic.enable(device::Interrupt::TIM2);
     let mut timer = Timer::tim2(dp.TIM2, 1.hz(), clocks, &mut rcc.apb1);
     timer.listen(Event::TimeOut);
 
diff --git a/src/dma.rs b/src/dma.rs
@@ -11,7 +11,7 @@ use core::{
 use as_slice::AsSlice;
 
 use crate::{
-    stm32::{
+    device::{
         dma2::{self, st::cr},
         Interrupt, DMA1, DMA2, NVIC, SPI1, SPI2, SPI3, SPI4, SPI5, SPI6, UART4, UART5, UART7,
         UART8, USART1, USART2, USART3, USART6,
diff --git a/src/gpio.rs b/src/gpio.rs
@@ -2,7 +2,7 @@
 
 use core::marker::PhantomData;
 
-use crate::stm32::{EXTI, SYSCFG};
+use crate::device::{EXTI, SYSCFG};
 
 /// Extension trait to split a GPIO peripheral in independent pins and registers
 pub trait GpioExt {
@@ -97,9 +97,9 @@ macro_rules! gpio {
             use core::convert::Infallible;
 
             use embedded_hal::digital::v2::{InputPin, OutputPin, StatefulOutputPin, toggleable};
-            use crate::stm32::$GPIOX;
+            use crate::device::$GPIOX;
 
-            use crate::stm32::{RCC, EXTI, SYSCFG};
+            use crate::device::{RCC, EXTI, SYSCFG};
             use super::{
                 Alternate, Floating, GpioExt, Input, OpenDrain, Output, Speed,
                 PullDown, PullUp, PushPull, AF0, AF1, AF2, AF3, AF4, AF5, AF6, AF7, AF8, AF9, AF10,
diff --git a/src/lib.rs b/src/lib.rs
@@ -25,47 +25,47 @@ compile_error!(
 pub(crate) use embedded_hal as hal;
 
 #[cfg(feature = "stm32f722")]
-pub use stm32f7::stm32f7x2 as stm32;
+pub use stm32f7::stm32f7x2 as device;
 
 #[cfg(feature = "stm32f723")]
-pub use stm32f7::stm32f7x3 as stm32;
+pub use stm32f7::stm32f7x3 as device;
 
 #[cfg(feature = "stm32f732")]
-pub use stm32f7::stm32f7x2 as stm32;
+pub use stm32f7::stm32f7x2 as device;
 
 #[cfg(feature = "stm32f733")]
-pub use stm32f7::stm32f7x3 as stm32;
+pub use stm32f7::stm32f7x3 as device;
 
 #[cfg(feature = "stm32f745")]
-pub use stm32f7::stm32f745 as stm32;
+pub use stm32f7::stm32f745 as device;
 
 #[cfg(feature = "stm32f746")]
-pub use stm32f7::stm32f7x6 as stm32;
+pub use stm32f7::stm32f7x6 as device;
 
 #[cfg(feature = "stm32f756")]
-pub use stm32f7::stm32f7x6 as stm32;
+pub use stm32f7::stm32f7x6 as device;
 
 #[cfg(feature = "stm32f765")]
-pub use stm32f7::stm32f765 as stm32;
+pub use stm32f7::stm32f765 as device;
 
 #[cfg(feature = "stm32f767")]
-pub use stm32f7::stm32f7x7 as stm32;
+pub use stm32f7::stm32f7x7 as device;
 
 #[cfg(feature = "stm32f769")]
-pub use stm32f7::stm32f7x9 as stm32;
+pub use stm32f7::stm32f7x9 as device;
 
 #[cfg(feature = "stm32f777")]
-pub use stm32f7::stm32f7x7 as stm32;
+pub use stm32f7::stm32f7x7 as device;
 
 #[cfg(feature = "stm32f778")]
-pub use stm32f7::stm32f7x9 as stm32;
+pub use stm32f7::stm32f7x9 as device;
 
 #[cfg(feature = "stm32f779")]
-pub use stm32f7::stm32f7x9 as stm32;
+pub use stm32f7::stm32f7x9 as device;
 
 // Enable use of interrupt macro
 #[cfg(feature = "rt")]
-pub use crate::stm32::interrupt;
+pub use crate::device::interrupt;
 
 #[cfg(feature = "device-selected")]
 pub mod delay;
diff --git a/src/rcc.rs b/src/rcc.rs
@@ -1,4 +1,4 @@
-use crate::stm32::{rcc, FLASH, RCC};
+use crate::device::{rcc, FLASH, RCC};
 
 use crate::time::Hertz;
 
diff --git a/src/serial.rs b/src/serial.rs
@@ -6,7 +6,7 @@ use core::ptr;
 
 use as_slice::{AsMutSlice, AsSlice};
 
-use crate::stm32;
+use crate::device;
 use crate::dma;
 use crate::hal::prelude::*;
 use crate::hal::serial;
@@ -15,7 +15,7 @@ use crate::time::U32Ext;
 use nb::block;
 
 #[cfg(any(feature = "device-selected",))]
-use crate::stm32::{RCC, USART1, USART2, UART4, USART3, USART6, UART7};
+use crate::device::{RCC, USART1, USART2, UART4, USART3, USART6, UART7};
 
 #[cfg(any(feature = "device-selected",))]
 use crate::gpio::{
@@ -402,10 +402,10 @@ pub enum Event {
 }
 
 /// Implemented by all USART instances
-pub trait Instance: Deref<Target = stm32::usart1::RegisterBlock> {
-    fn ptr() -> *const stm32::usart1::RegisterBlock;
-    fn select_sysclock(rcc: &stm32::rcc::RegisterBlock);
-    fn enable_clock(rcc: &stm32::rcc::RegisterBlock);
+pub trait Instance: Deref<Target = device::usart1::RegisterBlock> {
+    fn ptr() -> *const device::usart1::RegisterBlock;
+    fn select_sysclock(rcc: &device::rcc::RegisterBlock);
+    fn enable_clock(rcc: &device::rcc::RegisterBlock);
 }
 
 macro_rules! impl_instance {
@@ -414,15 +414,15 @@ macro_rules! impl_instance {
     )+) => {
         $(
             impl Instance for $USARTX {
-                fn ptr() -> *const stm32::usart1::RegisterBlock {
+                fn ptr() -> *const device::usart1::RegisterBlock {
                     $USARTX::ptr()
                 }
 
-                fn select_sysclock(rcc: &stm32::rcc::RegisterBlock) {
+                fn select_sysclock(rcc: &device::rcc::RegisterBlock) {
                     rcc.dckcfgr2.modify(|_, w| w.$usartXsel().bits(1));
                 }
 
-                fn enable_clock(rcc: &stm32::rcc::RegisterBlock) {
+                fn enable_clock(rcc: &device::rcc::RegisterBlock) {
                     rcc.$apbXenr.modify(|_, w| w.$usartXen().set_bit());
                 }
             }
diff --git a/src/spi.rs b/src/spi.rs
@@ -2,7 +2,7 @@
 //!
 //! See chapter 32 in the STM32F746 Reference Manual.
 
-pub use crate::stm32::spi1::cr1::BR_A as ClockDivider;
+pub use crate::device::spi1::cr1::BR_A as ClockDivider;
 pub use embedded_hal::spi::{Mode, Phase, Polarity};
 
 use core::{fmt, marker::PhantomData, ops::DerefMut, pin::Pin, ptr};
@@ -14,7 +14,7 @@ use embedded_hal::{
 };
 
 use crate::{
-    stm32::{spi1::cr2, SPI1, SPI2, SPI3, SPI4, SPI5, SPI6},
+    device::{spi1::cr2, SPI1, SPI2, SPI3, SPI4, SPI5, SPI6},
     dma,
     gpio::{
         gpioa::{PA5, PA6, PA7, PA9},
diff --git a/src/timer.rs b/src/timer.rs
@@ -1,6 +1,6 @@
 //! Timers
 
-use crate::stm32::{TIM2, TIM3, TIM4, TIM5};
+use crate::device::{TIM2, TIM3, TIM4, TIM5};
 use crate::hal::timer::{CountDown, Periodic};
 use crate::rcc::{Clocks, APB1};
 use crate::time::Hertz;
