#![deny(non_shorthand_field_patterns)]
#![deny(overflowing_literals)]
#![deny(path_statements)]
#![deny(patterns_in_fns_without_body)]
#![deny(private_in_public)]
#![deny(unconditional_recursion)]
#![deny(unused_allocation)]
#![deny(unused_comparisons)]
#![deny(unused_parens)]
#![deny(while_true)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![no_std]
extern crate bare_metal;
extern crate vcell;
use core::marker::PhantomData;
use core::ops::Deref;
#[doc(hidden)]
pub mod interrupt;
pub use self::interrupt::Interrupt;
#[doc = "Analog Comparator"]
pub struct AC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for AC {}
impl AC {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ac::RegisterBlock {
0x50 as *const _
}
}
impl Deref for AC {
type Target = ac::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*AC::ptr() }
}
}
#[doc = "Analog Comparator"]
pub mod ac;
#[doc = "Analog-to-Digital Converter"]
pub struct ADC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ADC {}
impl ADC {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const adc::RegisterBlock {
0x78 as *const _
}
}
impl Deref for ADC {
type Target = adc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*ADC::ptr() }
}
}
#[doc = "Analog-to-Digital Converter"]
pub mod adc;
#[doc = "Bootloader"]
pub struct BOOT_LOAD {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BOOT_LOAD {}
impl BOOT_LOAD {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const boot_load::RegisterBlock {
0x57 as *const _
}
}
impl Deref for BOOT_LOAD {
type Target = boot_load::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*BOOT_LOAD::ptr() }
}
}
#[doc = "Bootloader"]
pub mod boot_load;
#[doc = "CPU Registers"]
pub struct CPU {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CPU {}
impl CPU {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const cpu::RegisterBlock {
0x3e as *const _
}
}
impl Deref for CPU {
type Target = cpu::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*CPU::ptr() }
}
}
#[doc = "CPU Registers"]
pub mod cpu;
#[doc = "EEPROM"]
pub struct EEPROM {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for EEPROM {}
impl EEPROM {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const eeprom::RegisterBlock {
0x3f as *const _
}
}
impl Deref for EEPROM {
type Target = eeprom::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*EEPROM::ptr() }
}
}
#[doc = "EEPROM"]
pub mod eeprom;
#[doc = "External Interrupts"]
pub struct EXINT {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for EXINT {}
impl EXINT {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const exint::RegisterBlock {
0x3b as *const _
}
}
impl Deref for EXINT {
type Target = exint::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*EXINT::ptr() }
}
}
#[doc = "External Interrupts"]
pub mod exint;
#[doc = "Fuses"]
pub struct FUSE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FUSE {}
impl FUSE {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const fuse::RegisterBlock {
0 as *const _
}
}
impl Deref for FUSE {
type Target = fuse::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*FUSE::ptr() }
}
}
#[doc = "Fuses"]
pub mod fuse;
#[doc = "JTAG Interface"]
pub struct JTAG {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for JTAG {}
impl JTAG {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const jtag::RegisterBlock {
0x51 as *const _
}
}
impl Deref for JTAG {
type Target = jtag::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*JTAG::ptr() }
}
}
#[doc = "JTAG Interface"]
pub mod jtag;
#[doc = "Lockbits"]
pub struct LOCKBIT {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LOCKBIT {}
impl LOCKBIT {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lockbit::RegisterBlock {
0 as *const _
}
}
impl Deref for LOCKBIT {
type Target = lockbit::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*LOCKBIT::ptr() }
}
}
#[doc = "Lockbits"]
pub mod lockbit;
#[doc = "I/O Port"]
pub struct PORTA {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTA {}
impl PORTA {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const porta::RegisterBlock {
0x20 as *const _
}
}
impl Deref for PORTA {
type Target = porta::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*PORTA::ptr() }
}
}
#[doc = "I/O Port"]
pub mod porta;
#[doc = "I/O Port"]
pub struct PORTB {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTB {}
impl PORTB {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const portb::RegisterBlock {
0x23 as *const _
}
}
impl Deref for PORTB {
type Target = portb::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*PORTB::ptr() }
}
}
#[doc = "I/O Port"]
pub mod portb;
#[doc = "I/O Port"]
pub struct PORTC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTC {}
impl PORTC {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const portc::RegisterBlock {
0x26 as *const _
}
}
impl Deref for PORTC {
type Target = portc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*PORTC::ptr() }
}
}
#[doc = "I/O Port"]
pub mod portc;
#[doc = "I/O Port"]
pub struct PORTD {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTD {}
impl PORTD {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const portd::RegisterBlock {
0x29 as *const _
}
}
impl Deref for PORTD {
type Target = portd::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*PORTD::ptr() }
}
}
#[doc = "I/O Port"]
pub mod portd;
#[doc = "I/O Port"]
pub struct PORTE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTE {}
impl PORTE {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const porte::RegisterBlock {
0x2c as *const _
}
}
impl Deref for PORTE {
type Target = porte::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*PORTE::ptr() }
}
}
#[doc = "I/O Port"]
pub mod porte;
#[doc = "I/O Port"]
pub struct PORTF {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTF {}
impl PORTF {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const portf::RegisterBlock {
0x2f as *const _
}
}
impl Deref for PORTF {
type Target = portf::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*PORTF::ptr() }
}
}
#[doc = "I/O Port"]
pub mod portf;
#[doc = "I/O Port"]
pub struct PORTG {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTG {}
impl PORTG {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const portg::RegisterBlock {
0x32 as *const _
}
}
impl Deref for PORTG {
type Target = portg::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*PORTG::ptr() }
}
}
#[doc = "I/O Port"]
pub mod portg;
#[doc = "I/O Port"]
pub struct PORTH {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTH {}
impl PORTH {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const porth::RegisterBlock {
0x0100 as *const _
}
}
impl Deref for PORTH {
type Target = porth::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*PORTH::ptr() }
}
}
#[doc = "I/O Port"]
pub mod porth;
#[doc = "I/O Port"]
pub struct PORTJ {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTJ {}
impl PORTJ {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const portj::RegisterBlock {
0x0103 as *const _
}
}
impl Deref for PORTJ {
type Target = portj::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*PORTJ::ptr() }
}
}
#[doc = "I/O Port"]
pub mod portj;
#[doc = "I/O Port"]
pub struct PORTK {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTK {}
impl PORTK {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const portk::RegisterBlock {
0x0106 as *const _
}
}
impl Deref for PORTK {
type Target = portk::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*PORTK::ptr() }
}
}
#[doc = "I/O Port"]
pub mod portk;
#[doc = "I/O Port"]
pub struct PORTL {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTL {}
impl PORTL {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const portl::RegisterBlock {
0x0109 as *const _
}
}
impl Deref for PORTL {
type Target = portl::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*PORTL::ptr() }
}
}
#[doc = "I/O Port"]
pub mod portl;
#[doc = "Serial Peripheral Interface"]
pub struct SPI {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI {}
impl SPI {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const spi::RegisterBlock {
0x4c as *const _
}
}
impl Deref for SPI {
type Target = spi::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*SPI::ptr() }
}
}
#[doc = "Serial Peripheral Interface"]
pub mod spi;
#[doc = "Timer/Counter, 8-bit"]
pub struct TC0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TC0 {}
impl TC0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const tc0::RegisterBlock {
0x35 as *const _
}
}
impl Deref for TC0 {
type Target = tc0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*TC0::ptr() }
}
}
#[doc = "Timer/Counter, 8-bit"]
pub mod tc0;
#[doc = "Timer/Counter, 16-bit"]
pub struct TC1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TC1 {}
impl TC1 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const tc1::RegisterBlock {
0x36 as *const _
}
}
impl Deref for TC1 {
type Target = tc1::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*TC1::ptr() }
}
}
#[doc = "Timer/Counter, 16-bit"]
pub mod tc1;
#[doc = "Timer/Counter, 8-bit Async"]
pub struct TC2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TC2 {}
impl TC2 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const tc2::RegisterBlock {
0x37 as *const _
}
}
impl Deref for TC2 {
type Target = tc2::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*TC2::ptr() }
}
}
#[doc = "Timer/Counter, 8-bit Async"]
pub mod tc2;
#[doc = "Timer/Counter, 16-bit"]
pub struct TC3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TC3 {}
impl TC3 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const tc3::RegisterBlock {
0x38 as *const _
}
}
impl Deref for TC3 {
type Target = tc3::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*TC3::ptr() }
}
}
#[doc = "Timer/Counter, 16-bit"]
pub mod tc3;
#[doc = "Timer/Counter, 16-bit"]
pub struct TC4 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TC4 {}
impl TC4 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const tc4::RegisterBlock {
0x39 as *const _
}
}
impl Deref for TC4 {
type Target = tc4::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*TC4::ptr() }
}
}
#[doc = "Timer/Counter, 16-bit"]
pub mod tc4;
#[doc = "Timer/Counter, 16-bit"]
pub struct TC5 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TC5 {}
impl TC5 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const tc5::RegisterBlock {
0x3a as *const _
}
}
impl Deref for TC5 {
type Target = tc5::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*TC5::ptr() }
}
}
#[doc = "Timer/Counter, 16-bit"]
pub mod tc5;
#[doc = "Two Wire Serial Interface"]
pub struct TWI {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TWI {}
impl TWI {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const twi::RegisterBlock {
0xb8 as *const _
}
}
impl Deref for TWI {
type Target = twi::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*TWI::ptr() }
}
}
#[doc = "Two Wire Serial Interface"]
pub mod twi;
#[doc = "USART"]
pub struct USART0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USART0 {}
impl USART0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usart0::RegisterBlock {
0xc0 as *const _
}
}
impl Deref for USART0 {
type Target = usart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*USART0::ptr() }
}
}
#[doc = "USART"]
pub mod usart0;
#[doc = "USART"]
pub struct USART1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USART1 {}
impl USART1 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usart1::RegisterBlock {
0xc8 as *const _
}
}
impl Deref for USART1 {
type Target = usart1::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*USART1::ptr() }
}
}
#[doc = "USART"]
pub mod usart1;
#[doc = "USART"]
pub struct USART2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USART2 {}
impl USART2 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usart2::RegisterBlock {
0xd0 as *const _
}
}
impl Deref for USART2 {
type Target = usart2::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*USART2::ptr() }
}
}
#[doc = "USART"]
pub mod usart2;
#[doc = "USART"]
pub struct USART3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USART3 {}
impl USART3 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usart3::RegisterBlock {
0x0130 as *const _
}
}
impl Deref for USART3 {
type Target = usart3::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*USART3::ptr() }
}
}
#[doc = "USART"]
pub mod usart3;
#[doc = "Watchdog Timer"]
pub struct WDT {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for WDT {}
impl WDT {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const wdt::RegisterBlock {
0x60 as *const _
}
}
impl Deref for WDT {
type Target = wdt::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*WDT::ptr() }
}
}
#[doc = "Watchdog Timer"]
pub mod wdt;
use crate::devices::DEVICE_PERIPHERALS;
#[doc = r"All the peripherals"]
#[allow(non_snake_case)]
pub struct Peripherals {
#[doc = "AC"]
pub AC: AC,
#[doc = "ADC"]
pub ADC: ADC,
#[doc = "BOOT_LOAD"]
pub BOOT_LOAD: BOOT_LOAD,
#[doc = "CPU"]
pub CPU: CPU,
#[doc = "EEPROM"]
pub EEPROM: EEPROM,
#[doc = "EXINT"]
pub EXINT: EXINT,
#[doc = "FUSE"]
pub FUSE: FUSE,
#[doc = "JTAG"]
pub JTAG: JTAG,
#[doc = "LOCKBIT"]
pub LOCKBIT: LOCKBIT,
#[doc = "PORTA"]
pub PORTA: PORTA,
#[doc = "PORTB"]
pub PORTB: PORTB,
#[doc = "PORTC"]
pub PORTC: PORTC,
#[doc = "PORTD"]
pub PORTD: PORTD,
#[doc = "PORTE"]
pub PORTE: PORTE,
#[doc = "PORTF"]
pub PORTF: PORTF,
#[doc = "PORTG"]
pub PORTG: PORTG,
#[doc = "PORTH"]
pub PORTH: PORTH,
#[doc = "PORTJ"]
pub PORTJ: PORTJ,
#[doc = "PORTK"]
pub PORTK: PORTK,
#[doc = "PORTL"]
pub PORTL: PORTL,
#[doc = "SPI"]
pub SPI: SPI,
#[doc = "TC0"]
pub TC0: TC0,
#[doc = "TC1"]
pub TC1: TC1,
#[doc = "TC2"]
pub TC2: TC2,
#[doc = "TC3"]
pub TC3: TC3,
#[doc = "TC4"]
pub TC4: TC4,
#[doc = "TC5"]
pub TC5: TC5,
#[doc = "TWI"]
pub TWI: TWI,
#[doc = "USART0"]
pub USART0: USART0,
#[doc = "USART1"]
pub USART1: USART1,
#[doc = "USART2"]
pub USART2: USART2,
#[doc = "USART3"]
pub USART3: USART3,
#[doc = "WDT"]
pub WDT: WDT,
}
impl Peripherals {
#[doc = r"Unchecked version of `Peripherals::take`"]
#[inline]
pub unsafe fn steal() -> Self {
DEVICE_PERIPHERALS = true;
Peripherals {
AC: AC {
_marker: PhantomData,
},
ADC: ADC {
_marker: PhantomData,
},
BOOT_LOAD: BOOT_LOAD {
_marker: PhantomData,
},
CPU: CPU {
_marker: PhantomData,
},
EEPROM: EEPROM {
_marker: PhantomData,
},
EXINT: EXINT {
_marker: PhantomData,
},
FUSE: FUSE {
_marker: PhantomData,
},
JTAG: JTAG {
_marker: PhantomData,
},
LOCKBIT: LOCKBIT {
_marker: PhantomData,
},
PORTA: PORTA {
_marker: PhantomData,
},
PORTB: PORTB {
_marker: PhantomData,
},
PORTC: PORTC {
_marker: PhantomData,
},
PORTD: PORTD {
_marker: PhantomData,
},
PORTE: PORTE {
_marker: PhantomData,
},
PORTF: PORTF {
_marker: PhantomData,
},
PORTG: PORTG {
_marker: PhantomData,
},
PORTH: PORTH {
_marker: PhantomData,
},
PORTJ: PORTJ {
_marker: PhantomData,
},
PORTK: PORTK {
_marker: PhantomData,
},
PORTL: PORTL {
_marker: PhantomData,
},
SPI: SPI {
_marker: PhantomData,
},
TC0: TC0 {
_marker: PhantomData,
},
TC1: TC1 {
_marker: PhantomData,
},
TC2: TC2 {
_marker: PhantomData,
},
TC3: TC3 {
_marker: PhantomData,
},
TC4: TC4 {
_marker: PhantomData,
},
TC5: TC5 {
_marker: PhantomData,
},
TWI: TWI {
_marker: PhantomData,
},
USART0: USART0 {
_marker: PhantomData,
},
USART1: USART1 {
_marker: PhantomData,
},
USART2: USART2 {
_marker: PhantomData,
},
USART3: USART3 {
_marker: PhantomData,
},
WDT: WDT {
_marker: PhantomData,
},
}
}
}