//! The AVR ATA5505 microcontroller
//!
//! # Variants
//! |        | Pinout | Mcuage | Operating temperature | Operating voltage | Max speed |
//! |--------|--------|---------|-----------------------|-------------------|-----------|
//! | standard |  |  | 0°C - 0°C | 2.7V - 5.5V | 0 MHz |
//!

#![allow(non_upper_case_globals)]

/// LOW register
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | CKDIV8 | 10000000 |
/// | CKOUT | 1000000 |
/// | SUT_CKSEL | 111111 |
pub const LOW: *mut u8 = 0x0 as *mut u8;

/// LOCKBIT register
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | LB | 11 |
pub const LOCKBIT: *mut u8 = 0x0 as *mut u8;

/// HIGH register
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | EESAVE | 1000 |
/// | BODLEVEL | 111 |
/// | DWEN | 1000000 |
/// | RSTDISBL | 10000000 |
/// | WDTON | 10000 |
/// | SPIEN | 100000 |
pub const HIGH: *mut u8 = 0x1 as *mut u8;

/// EXTENDED register
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | SELFPRGEN | 1 |
pub const EXTENDED: *mut u8 = 0x2 as *mut u8;

/// Port A Input Pins.
pub const PINA: *mut u8 = 0x20 as *mut u8;

/// Port A Data Direction Register.
pub const DDRA: *mut u8 = 0x21 as *mut u8;

/// Port A Data Register.
pub const PORTA: *mut u8 = 0x22 as *mut u8;

/// Port B Input Pins.
pub const PINB: *mut u8 = 0x23 as *mut u8;

/// Port B Data Direction Register.
pub const DDRB: *mut u8 = 0x24 as *mut u8;

/// Port B Data Register.
pub const PORTB: *mut u8 = 0x25 as *mut u8;

/// Port Control Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | PUDA | 1 |
/// | BBMB | 100000 |
/// | PUDB | 10 |
/// | BBMA | 10000 |
pub const PORTCR: *mut u8 = 0x32 as *mut u8;

/// Timer/Counter0 Interrupt Flag Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | TOV0 | 1 |
/// | OCF0A | 10 |
pub const TIFR0: *mut u8 = 0x35 as *mut u8;

/// Timer/Counter1 Interrupt Flag register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | OCF1B | 100 |
/// | TOV1 | 1 |
/// | OCF1A | 10 |
/// | ICF1 | 100000 |
pub const TIFR1: *mut u8 = 0x36 as *mut u8;

/// Pin Change Interrupt Flag Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | PCIF | 11 |
pub const PCIFR: *mut u8 = 0x3B as *mut u8;

/// External Interrupt Flag Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | INTF | 11 |
pub const EIFR: *mut u8 = 0x3C as *mut u8;

/// External Interrupt Mask Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | INT | 11 |
pub const EIMSK: *mut u8 = 0x3D as *mut u8;

/// General purpose register 0.
pub const GPIOR0: *mut u8 = 0x3E as *mut u8;

/// EEPROM Control Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | EEPE | 10 |
/// | EERE | 1 |
/// | EERIE | 1000 |
/// | EEPM | 110000 |
/// | EEMPE | 100 |
pub const EECR: *mut u8 = 0x3F as *mut u8;

/// EEPROM Data Register.
pub const EEDR: *mut u8 = 0x40 as *mut u8;

/// EEPROM Address Register  Bytes low byte.
pub const EEARL: *mut u8 = 0x41 as *mut u8;

/// EEPROM Address Register  Bytes.
pub const EEAR: *mut u16 = 0x41 as *mut u16;

/// EEPROM Address Register  Bytes high byte.
pub const EEARH: *mut u8 = 0x42 as *mut u8;

/// General Timer Counter Control register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | PSR0 | 10 |
/// | PSR1 | 1 |
/// | TSM | 10000000 |
pub const GTCCR: *mut u8 = 0x43 as *mut u8;

/// Timer/Counter0 Control Register A.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | COM0A | 11000000 |
/// | WGM0 | 11 |
pub const TCCR0A: *mut u8 = 0x45 as *mut u8;

/// Timer/Counter0 Control Register B.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | FOC0A | 10000000 |
/// | CS0 | 111 |
pub const TCCR0B: *mut u8 = 0x46 as *mut u8;

/// Timer/Counter0.
pub const TCNT2: *mut u8 = 0x47 as *mut u8;

/// Timer/Counter0 Output Compare Register A.
pub const OCR0A: *mut u8 = 0x48 as *mut u8;

/// General Purpose register 1.
pub const GPIOR1: *mut u8 = 0x4A as *mut u8;

/// General Purpose IO register 2.
pub const GPIOR2: *mut u8 = 0x4B as *mut u8;

/// SPI Control Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | CPOL | 1000 |
/// | SPIE | 10000000 |
/// | DORD | 100000 |
/// | SPE | 1000000 |
/// | CPHA | 100 |
/// | SPR | 11 |
/// | MSTR | 10000 |
pub const SPCR: *mut u8 = 0x4C as *mut u8;

/// SPI Status Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | WCOL | 1000000 |
/// | SPI2X | 1 |
/// | SPIF | 10000000 |
pub const SPSR: *mut u8 = 0x4D as *mut u8;

/// SPI Data Register.
pub const SPDR: *mut u8 = 0x4E as *mut u8;

/// Analog Comparator Control And Status Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | ACIC | 100 |
/// | ACIE | 1000 |
/// | ACIS | 11 |
/// | ACD | 10000000 |
/// | ACO | 100000 |
/// | ACI | 10000 |
/// | ACIRS | 1000000 |
pub const ACSR: *mut u8 = 0x50 as *mut u8;

/// debugWire communication register.
pub const DWDR: *mut u8 = 0x51 as *mut u8;

/// Sleep Mode Control Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | SM | 110 |
/// | SE | 1 |
pub const SMCR: *mut u8 = 0x53 as *mut u8;

/// MCU Status register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | EXTRF | 10 |
/// | BORF | 100 |
/// | PORF | 1 |
/// | WDRF | 1000 |
pub const MCUSR: *mut u8 = 0x54 as *mut u8;

/// MCU Control Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | BODS | 1000000 |
/// | BODSE | 100000 |
/// | PUD | 10000 |
pub const MCUCR: *mut u8 = 0x55 as *mut u8;

/// Store Program Memory Control Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | PGERS | 10 |
/// | SIGRD | 100000 |
/// | RFLB | 1000 |
/// | SPMEN | 1 |
/// | CTPB | 10000 |
/// | RWWSB | 1000000 |
/// | PGWRT | 100 |
pub const SPMCSR: *mut u8 = 0x57 as *mut u8;

/// Stack Pointer  Bytes.
pub const SP: *mut u16 = 0x5D as *mut u16;

/// Stack Pointer  Bytes low byte.
pub const SPL: *mut u8 = 0x5D as *mut u8;

/// Stack Pointer  Bytes high byte.
pub const SPH: *mut u8 = 0x5E as *mut u8;

/// Status Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | N | 100 |
/// | V | 1000 |
/// | H | 100000 |
/// | I | 10000000 |
/// | C | 1 |
/// | T | 1000000 |
/// | S | 10000 |
/// | Z | 10 |
pub const SREG: *mut u8 = 0x5F as *mut u8;

/// Watchdog Timer Control Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | WDE | 1000 |
/// | WDCE | 10000 |
/// | WDP | 100111 |
/// | WDIF | 10000000 |
/// | WDIE | 1000000 |
pub const WDTCR: *mut u8 = 0x60 as *mut u8;

/// Clock Prescale Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | CLKPCE | 10000000 |
/// | CLKPS | 1111 |
pub const CLKPR: *mut u8 = 0x61 as *mut u8;

/// Clock Control & Status Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | CLKCCE | 10000000 |
/// | CLKC | 1111 |
/// | CLKRDY | 10000 |
pub const CLKCSR: *mut u8 = 0x62 as *mut u8;

/// Clock Selection Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | CSUT | 110000 |
/// | CSEL | 1111 |
/// | COUT | 1000000 |
pub const CLKSELR: *mut u8 = 0x63 as *mut u8;

/// Power Reduction Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | PRADC | 1 |
/// | PRLIN | 100000 |
/// | PRTIM0 | 100 |
/// | PRTIM1 | 1000 |
/// | PRSPI | 10000 |
/// | PRUSI | 10 |
pub const PRR: *mut u8 = 0x64 as *mut u8;

/// Oscillator Calibration Register.
pub const OSCCAL: *mut u8 = 0x66 as *mut u8;

/// Pin Change Interrupt Control Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | PCIE | 11 |
pub const PCICR: *mut u8 = 0x68 as *mut u8;

/// External Interrupt Control Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | ISC1 | 1100 |
/// | ISC0 | 11 |
pub const EICRA: *mut u8 = 0x69 as *mut u8;

/// Pin Change Mask Register 0.
pub const PCMSK0: *mut u8 = 0x6B as *mut u8;

/// Pin Change Mask Register 1.
pub const PCMSK1: *mut u8 = 0x6C as *mut u8;

/// Timer/Counter0 Interrupt Mask register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | OCIE0A | 10 |
/// | TOIE0 | 1 |
pub const TIMSK0: *mut u8 = 0x6E as *mut u8;

/// Timer/Counter1 Interrupt Mask Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | OCIE1B | 100 |
/// | OCIE1A | 10 |
/// | TOIE1 | 1 |
/// | ICIE1 | 100000 |
pub const TIMSK1: *mut u8 = 0x6F as *mut u8;

/// Analog Miscellaneous Control Register (Shared with AD_CONVERTER IO_MODULE).
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | ISRCEN | 1 |
pub const AMISCR: *mut u8 = 0x77 as *mut u8;

/// ADC Data Register  Bytes low byte.
pub const ADCL: *mut u8 = 0x78 as *mut u8;

/// ADC Data Register  Bytes.
pub const ADC: *mut u16 = 0x78 as *mut u16;

/// ADC Data Register  Bytes high byte.
pub const ADCH: *mut u8 = 0x79 as *mut u8;

/// The ADC Control and Status register A.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | ADIF | 10000 |
/// | ADEN | 10000000 |
/// | ADSC | 1000000 |
/// | ADATE | 100000 |
/// | ADIE | 1000 |
/// | ADPS | 111 |
pub const ADCSRA: *mut u8 = 0x7A as *mut u8;

/// Analog Comparator & ADC Control and Status Register B (Shared with AD_CONVERTER IO_MODULE).
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | ACIR | 110000 |
/// | ACME | 1000000 |
pub const ADCSRB: *mut u8 = 0x7B as *mut u8;

/// The ADC multiplexer Selection Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | ADLAR | 100000 |
/// | MUX | 11111 |
/// | REFS | 11000000 |
pub const ADMUX: *mut u8 = 0x7C as *mut u8;

/// Digital Input Disable Register 0.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | ADC7D | 10000000 |
/// | ADC3D | 1000 |
/// | ADC4D | 10000 |
/// | ADC6D | 1000000 |
/// | ADC0D | 1 |
/// | ADC1D | 10 |
/// | ADC5D | 100000 |
/// | ADC2D | 100 |
pub const DIDR0: *mut u8 = 0x7E as *mut u8;

/// Digital Input Disable Register 1.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | ADC10D | 100 |
/// | ADC9D | 10 |
/// | ADC8D | 1 |
pub const DIDR1: *mut u8 = 0x7F as *mut u8;

/// Timer/Counter1 Control Register A.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | COM1A | 11000000 |
/// | COM1B | 110000 |
pub const TCCR1A: *mut u8 = 0x80 as *mut u8;

/// Timer/Counter1 Control Register B.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | ICNC1 | 10000000 |
/// | CS1 | 111 |
/// | ICES1 | 1000000 |
pub const TCCR1B: *mut u8 = 0x81 as *mut u8;

/// Timer/Counter1 Control Register C.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | FOC1B | 1000000 |
/// | FOC1A | 10000000 |
pub const TCCR1C: *mut u8 = 0x82 as *mut u8;

/// Timer/Counter1 Control Register D.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | OC1AX | 1000 |
/// | OC1AU | 1 |
/// | OC1BV | 100000 |
/// | OC1BU | 10000 |
/// | OC1BX | 10000000 |
/// | OC1AV | 10 |
/// | OC1AW | 100 |
/// | OC1BW | 1000000 |
pub const TCCR1D: *mut u8 = 0x83 as *mut u8;

/// Timer/Counter1  Bytes.
pub const TCNT1: *mut u16 = 0x84 as *mut u16;

/// Timer/Counter1  Bytes low byte.
pub const TCNT1L: *mut u8 = 0x84 as *mut u8;

/// Timer/Counter1  Bytes high byte.
pub const TCNT1H: *mut u8 = 0x85 as *mut u8;

/// Timer/Counter1 Input Capture Register  Bytes low byte.
pub const ICR1L: *mut u8 = 0x86 as *mut u8;

/// Timer/Counter1 Input Capture Register  Bytes.
pub const ICR1: *mut u16 = 0x86 as *mut u16;

/// Timer/Counter1 Input Capture Register  Bytes high byte.
pub const ICR1H: *mut u8 = 0x87 as *mut u8;

/// Timer/Counter1 Output Compare Register A  Bytes.
pub const OCR1A: *mut u16 = 0x88 as *mut u16;

/// Timer/Counter1 Output Compare Register A  Bytes low byte.
pub const OCR1AL: *mut u8 = 0x88 as *mut u8;

/// Timer/Counter1 Output Compare Register A  Bytes high byte.
pub const OCR1AH: *mut u8 = 0x89 as *mut u8;

/// Timer/Counter1 Output Compare Register B  Bytes.
pub const OCR1B: *mut u16 = 0x8A as *mut u16;

/// Timer/Counter1 Output Compare Register B  Bytes low byte.
pub const OCR1BL: *mut u8 = 0x8A as *mut u8;

/// Timer/Counter1 Output Compare Register B  Bytes high byte.
pub const OCR1BH: *mut u8 = 0x8B as *mut u8;

/// Asynchronous Status Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | OCR0AUB | 1000 |
/// | TCR0AUB | 10 |
/// | TCN0UB | 10000 |
/// | TCR0BUB | 1 |
/// | EXCLK | 1000000 |
/// | AS0 | 100000 |
pub const ASSR: *mut u8 = 0xB6 as *mut u8;

/// USI Control Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | USICS | 1100 |
/// | USICLK | 10 |
/// | USISIE | 10000000 |
/// | USITC | 1 |
/// | USIOIE | 1000000 |
/// | USIWM | 110000 |
pub const USICR: *mut u8 = 0xB8 as *mut u8;

/// USI Status Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | USIPF | 100000 |
/// | USIOIF | 1000000 |
/// | USIDC | 10000 |
/// | USICNT | 1111 |
/// | USISIF | 10000000 |
pub const USISR: *mut u8 = 0xB9 as *mut u8;

/// USI Data Register.
pub const USIDR: *mut u8 = 0xBA as *mut u8;

/// USI Buffer Register.
pub const USIBR: *mut u8 = 0xBB as *mut u8;

/// USI Pin Position.
pub const USIPP: *mut u8 = 0xBC as *mut u8;

/// LIN Control Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | LCMD | 111 |
/// | LCONF | 110000 |
/// | LIN13 | 1000000 |
/// | LENA | 1000 |
/// | LSWRES | 10000000 |
pub const LINCR: *mut u8 = 0xC8 as *mut u8;

/// LIN Status and Interrupt Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | LTXOK | 10 |
/// | LIDST | 11100000 |
/// | LERR | 1000 |
/// | LIDOK | 100 |
/// | LRXOK | 1 |
/// | LBUSY | 10000 |
pub const LINSIR: *mut u8 = 0xC9 as *mut u8;

/// LIN Enable Interrupt Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | LENERR | 1000 |
/// | LENTXOK | 10 |
/// | LENRXOK | 1 |
/// | LENIDOK | 100 |
pub const LINENIR: *mut u8 = 0xCA as *mut u8;

/// LIN Error Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | LPERR | 100 |
/// | LABORT | 10000000 |
/// | LFERR | 10000 |
/// | LOVERR | 100000 |
/// | LBERR | 1 |
/// | LTOERR | 1000000 |
/// | LCERR | 10 |
/// | LSERR | 1000 |
pub const LINERR: *mut u8 = 0xCB as *mut u8;

/// LIN Bit Timing Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | LDISR | 10000000 |
/// | LBT | 111111 |
pub const LINBTR: *mut u8 = 0xCC as *mut u8;

/// LIN Baud Rate Low Register.
pub const LINBRRL: *mut u8 = 0xCD as *mut u8;

/// LIN Baud Rate High Register.
pub const LINBRRH: *mut u8 = 0xCE as *mut u8;

/// LIN Data Length Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | LRXDL | 1111 |
/// | LTXDL | 11110000 |
pub const LINDLR: *mut u8 = 0xCF as *mut u8;

/// LIN Identifier Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | LP | 11000000 |
/// | LID | 111111 |
pub const LINIDR: *mut u8 = 0xD0 as *mut u8;

/// LIN Data Buffer Selection Register.
///
/// Bitfields:
///
/// | Name | Mask (binary) |
/// | ---- | ------------- |
/// | LINDX | 111 |
/// | LAINC | 1000 |
pub const LINSEL: *mut u8 = 0xD1 as *mut u8;

/// LIN Data Register.
pub const LINDAT: *mut u8 = 0xD2 as *mut u8;

/// Bitfield on register ACSR
pub const ACIC: *mut u8 = 0x4 as *mut u8;

/// Bitfield on register ACSR
pub const ACIE: *mut u8 = 0x8 as *mut u8;

/// Bitfield on register ACSR
pub const ACIS: *mut u8 = 0x3 as *mut u8;

/// Bitfield on register ACSR
pub const ACD: *mut u8 = 0x80 as *mut u8;

/// Bitfield on register ACSR
pub const ACO: *mut u8 = 0x20 as *mut u8;

/// Bitfield on register ACSR
pub const ACI: *mut u8 = 0x10 as *mut u8;

/// Bitfield on register ACSR
pub const ACIRS: *mut u8 = 0x40 as *mut u8;

/// Bitfield on register ADCSRA
pub const ADIF: *mut u8 = 0x10 as *mut u8;

/// Bitfield on register ADCSRA
pub const ADEN: *mut u8 = 0x80 as *mut u8;

/// Bitfield on register ADCSRA
pub const ADSC: *mut u8 = 0x40 as *mut u8;

/// Bitfield on register ADCSRA
pub const ADATE: *mut u8 = 0x20 as *mut u8;

/// Bitfield on register ADCSRA
pub const ADIE: *mut u8 = 0x8 as *mut u8;

/// Bitfield on register ADCSRA
pub const ADPS: *mut u8 = 0x7 as *mut u8;

/// Bitfield on register ADCSRB
pub const ACIR: *mut u8 = 0x30 as *mut u8;

/// Bitfield on register ADCSRB
pub const ACME: *mut u8 = 0x40 as *mut u8;

/// Bitfield on register ADMUX
pub const ADLAR: *mut u8 = 0x20 as *mut u8;

/// Bitfield on register ADMUX
pub const MUX: *mut u8 = 0x1F as *mut u8;

/// Bitfield on register ADMUX
pub const REFS: *mut u8 = 0xC0 as *mut u8;

/// Bitfield on register AMISCR
pub const ISRCEN: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register ASSR
pub const OCR0AUB: *mut u8 = 0x8 as *mut u8;

/// Bitfield on register ASSR
pub const TCR0AUB: *mut u8 = 0x2 as *mut u8;

/// Bitfield on register ASSR
pub const TCN0UB: *mut u8 = 0x10 as *mut u8;

/// Bitfield on register ASSR
pub const TCR0BUB: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register ASSR
pub const EXCLK: *mut u8 = 0x40 as *mut u8;

/// Bitfield on register ASSR
pub const AS0: *mut u8 = 0x20 as *mut u8;

/// Bitfield on register CLKCSR
pub const CLKCCE: *mut u8 = 0x80 as *mut u8;

/// Bitfield on register CLKCSR
pub const CLKC: *mut u8 = 0xF as *mut u8;

/// Bitfield on register CLKCSR
pub const CLKRDY: *mut u8 = 0x10 as *mut u8;

/// Bitfield on register CLKPR
pub const CLKPCE: *mut u8 = 0x80 as *mut u8;

/// Bitfield on register CLKPR
pub const CLKPS: *mut u8 = 0xF as *mut u8;

/// Bitfield on register CLKSELR
pub const CSUT: *mut u8 = 0x30 as *mut u8;

/// Bitfield on register CLKSELR
pub const CSEL: *mut u8 = 0xF as *mut u8;

/// Bitfield on register CLKSELR
pub const COUT: *mut u8 = 0x40 as *mut u8;

/// Bitfield on register DIDR0
pub const ADC7D: *mut u8 = 0x80 as *mut u8;

/// Bitfield on register DIDR0
pub const ADC3D: *mut u8 = 0x8 as *mut u8;

/// Bitfield on register DIDR0
pub const ADC4D: *mut u8 = 0x10 as *mut u8;

/// Bitfield on register DIDR0
pub const ADC6D: *mut u8 = 0x40 as *mut u8;

/// Bitfield on register DIDR0
pub const ADC0D: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register DIDR0
pub const ADC1D: *mut u8 = 0x2 as *mut u8;

/// Bitfield on register DIDR0
pub const ADC5D: *mut u8 = 0x20 as *mut u8;

/// Bitfield on register DIDR0
pub const ADC2D: *mut u8 = 0x4 as *mut u8;

/// Bitfield on register DIDR1
pub const ADC10D: *mut u8 = 0x4 as *mut u8;

/// Bitfield on register DIDR1
pub const ADC9D: *mut u8 = 0x2 as *mut u8;

/// Bitfield on register DIDR1
pub const ADC8D: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register EECR
pub const EEPE: *mut u8 = 0x2 as *mut u8;

/// Bitfield on register EECR
pub const EERE: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register EECR
pub const EERIE: *mut u8 = 0x8 as *mut u8;

/// Bitfield on register EECR
pub const EEPM: *mut u8 = 0x30 as *mut u8;

/// Bitfield on register EECR
pub const EEMPE: *mut u8 = 0x4 as *mut u8;

/// Bitfield on register EICRA
pub const ISC1: *mut u8 = 0xC as *mut u8;

/// Bitfield on register EICRA
pub const ISC0: *mut u8 = 0x3 as *mut u8;

/// Bitfield on register EIFR
pub const INTF: *mut u8 = 0x3 as *mut u8;

/// Bitfield on register EIMSK
pub const INT: *mut u8 = 0x3 as *mut u8;

/// Bitfield on register EXTENDED
pub const SELFPRGEN: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register GTCCR
pub const PSR0: *mut u8 = 0x2 as *mut u8;

/// Bitfield on register GTCCR
pub const PSR1: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register GTCCR
pub const TSM: *mut u8 = 0x80 as *mut u8;

/// Bitfield on register HIGH
pub const EESAVE: *mut u8 = 0x8 as *mut u8;

/// Bitfield on register HIGH
pub const BODLEVEL: *mut u8 = 0x7 as *mut u8;

/// Bitfield on register HIGH
pub const DWEN: *mut u8 = 0x40 as *mut u8;

/// Bitfield on register HIGH
pub const RSTDISBL: *mut u8 = 0x80 as *mut u8;

/// Bitfield on register HIGH
pub const WDTON: *mut u8 = 0x10 as *mut u8;

/// Bitfield on register HIGH
pub const SPIEN: *mut u8 = 0x20 as *mut u8;

/// Bitfield on register LINBTR
pub const LDISR: *mut u8 = 0x80 as *mut u8;

/// Bitfield on register LINBTR
pub const LBT: *mut u8 = 0x3F as *mut u8;

/// Bitfield on register LINCR
pub const LCMD: *mut u8 = 0x7 as *mut u8;

/// Bitfield on register LINCR
pub const LCONF: *mut u8 = 0x30 as *mut u8;

/// Bitfield on register LINCR
pub const LIN13: *mut u8 = 0x40 as *mut u8;

/// Bitfield on register LINCR
pub const LENA: *mut u8 = 0x8 as *mut u8;

/// Bitfield on register LINCR
pub const LSWRES: *mut u8 = 0x80 as *mut u8;

/// Bitfield on register LINDLR
pub const LRXDL: *mut u8 = 0xF as *mut u8;

/// Bitfield on register LINDLR
pub const LTXDL: *mut u8 = 0xF0 as *mut u8;

/// Bitfield on register LINENIR
pub const LENERR: *mut u8 = 0x8 as *mut u8;

/// Bitfield on register LINENIR
pub const LENTXOK: *mut u8 = 0x2 as *mut u8;

/// Bitfield on register LINENIR
pub const LENRXOK: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register LINENIR
pub const LENIDOK: *mut u8 = 0x4 as *mut u8;

/// Bitfield on register LINERR
pub const LPERR: *mut u8 = 0x4 as *mut u8;

/// Bitfield on register LINERR
pub const LABORT: *mut u8 = 0x80 as *mut u8;

/// Bitfield on register LINERR
pub const LFERR: *mut u8 = 0x10 as *mut u8;

/// Bitfield on register LINERR
pub const LOVERR: *mut u8 = 0x20 as *mut u8;

/// Bitfield on register LINERR
pub const LBERR: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register LINERR
pub const LTOERR: *mut u8 = 0x40 as *mut u8;

/// Bitfield on register LINERR
pub const LCERR: *mut u8 = 0x2 as *mut u8;

/// Bitfield on register LINERR
pub const LSERR: *mut u8 = 0x8 as *mut u8;

/// Bitfield on register LINIDR
pub const LP: *mut u8 = 0xC0 as *mut u8;

/// Bitfield on register LINIDR
pub const LID: *mut u8 = 0x3F as *mut u8;

/// Bitfield on register LINSEL
pub const LINDX: *mut u8 = 0x7 as *mut u8;

/// Bitfield on register LINSEL
pub const LAINC: *mut u8 = 0x8 as *mut u8;

/// Bitfield on register LINSIR
pub const LTXOK: *mut u8 = 0x2 as *mut u8;

/// Bitfield on register LINSIR
pub const LIDST: *mut u8 = 0xE0 as *mut u8;

/// Bitfield on register LINSIR
pub const LERR: *mut u8 = 0x8 as *mut u8;

/// Bitfield on register LINSIR
pub const LIDOK: *mut u8 = 0x4 as *mut u8;

/// Bitfield on register LINSIR
pub const LRXOK: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register LINSIR
pub const LBUSY: *mut u8 = 0x10 as *mut u8;

/// Bitfield on register LOCKBIT
pub const LB: *mut u8 = 0x3 as *mut u8;

/// Bitfield on register LOW
pub const CKDIV8: *mut u8 = 0x80 as *mut u8;

/// Bitfield on register LOW
pub const CKOUT: *mut u8 = 0x40 as *mut u8;

/// Bitfield on register LOW
pub const SUT_CKSEL: *mut u8 = 0x3F as *mut u8;

/// Bitfield on register MCUCR
pub const BODS: *mut u8 = 0x40 as *mut u8;

/// Bitfield on register MCUCR
pub const BODSE: *mut u8 = 0x20 as *mut u8;

/// Bitfield on register MCUCR
pub const PUD: *mut u8 = 0x10 as *mut u8;

/// Bitfield on register MCUSR
pub const EXTRF: *mut u8 = 0x2 as *mut u8;

/// Bitfield on register MCUSR
pub const BORF: *mut u8 = 0x4 as *mut u8;

/// Bitfield on register MCUSR
pub const PORF: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register MCUSR
pub const WDRF: *mut u8 = 0x8 as *mut u8;

/// Bitfield on register PCICR
pub const PCIE: *mut u8 = 0x3 as *mut u8;

/// Bitfield on register PCIFR
pub const PCIF: *mut u8 = 0x3 as *mut u8;

/// Bitfield on register PORTCR
pub const PUDA: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register PORTCR
pub const BBMB: *mut u8 = 0x20 as *mut u8;

/// Bitfield on register PORTCR
pub const PUDB: *mut u8 = 0x2 as *mut u8;

/// Bitfield on register PORTCR
pub const BBMA: *mut u8 = 0x10 as *mut u8;

/// Bitfield on register PRR
pub const PRADC: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register PRR
pub const PRLIN: *mut u8 = 0x20 as *mut u8;

/// Bitfield on register PRR
pub const PRTIM0: *mut u8 = 0x4 as *mut u8;

/// Bitfield on register PRR
pub const PRTIM1: *mut u8 = 0x8 as *mut u8;

/// Bitfield on register PRR
pub const PRSPI: *mut u8 = 0x10 as *mut u8;

/// Bitfield on register PRR
pub const PRUSI: *mut u8 = 0x2 as *mut u8;

/// Bitfield on register SMCR
pub const SM: *mut u8 = 0x6 as *mut u8;

/// Bitfield on register SMCR
pub const SE: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register SPCR
pub const CPOL: *mut u8 = 0x8 as *mut u8;

/// Bitfield on register SPCR
pub const SPIE: *mut u8 = 0x80 as *mut u8;

/// Bitfield on register SPCR
pub const DORD: *mut u8 = 0x20 as *mut u8;

/// Bitfield on register SPCR
pub const SPE: *mut u8 = 0x40 as *mut u8;

/// Bitfield on register SPCR
pub const CPHA: *mut u8 = 0x4 as *mut u8;

/// Bitfield on register SPCR
pub const SPR: *mut u8 = 0x3 as *mut u8;

/// Bitfield on register SPCR
pub const MSTR: *mut u8 = 0x10 as *mut u8;

/// Bitfield on register SPMCSR
pub const PGERS: *mut u8 = 0x2 as *mut u8;

/// Bitfield on register SPMCSR
pub const SIGRD: *mut u8 = 0x20 as *mut u8;

/// Bitfield on register SPMCSR
pub const RFLB: *mut u8 = 0x8 as *mut u8;

/// Bitfield on register SPMCSR
pub const SPMEN: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register SPMCSR
pub const CTPB: *mut u8 = 0x10 as *mut u8;

/// Bitfield on register SPMCSR
pub const RWWSB: *mut u8 = 0x40 as *mut u8;

/// Bitfield on register SPMCSR
pub const PGWRT: *mut u8 = 0x4 as *mut u8;

/// Bitfield on register SPSR
pub const WCOL: *mut u8 = 0x40 as *mut u8;

/// Bitfield on register SPSR
pub const SPI2X: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register SPSR
pub const SPIF: *mut u8 = 0x80 as *mut u8;

/// Bitfield on register SREG
pub const N: *mut u8 = 0x4 as *mut u8;

/// Bitfield on register SREG
pub const V: *mut u8 = 0x8 as *mut u8;

/// Bitfield on register SREG
pub const H: *mut u8 = 0x20 as *mut u8;

/// Bitfield on register SREG
pub const I: *mut u8 = 0x80 as *mut u8;

/// Bitfield on register SREG
pub const C: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register SREG
pub const T: *mut u8 = 0x40 as *mut u8;

/// Bitfield on register SREG
pub const S: *mut u8 = 0x10 as *mut u8;

/// Bitfield on register SREG
pub const Z: *mut u8 = 0x2 as *mut u8;

/// Bitfield on register TCCR0A
pub const COM0A: *mut u8 = 0xC0 as *mut u8;

/// Bitfield on register TCCR0A
pub const WGM0: *mut u8 = 0x3 as *mut u8;

/// Bitfield on register TCCR0B
pub const FOC0A: *mut u8 = 0x80 as *mut u8;

/// Bitfield on register TCCR0B
pub const CS0: *mut u8 = 0x7 as *mut u8;

/// Bitfield on register TCCR1A
pub const COM1A: *mut u8 = 0xC0 as *mut u8;

/// Bitfield on register TCCR1A
pub const COM1B: *mut u8 = 0x30 as *mut u8;

/// Bitfield on register TCCR1B
pub const ICNC1: *mut u8 = 0x80 as *mut u8;

/// Bitfield on register TCCR1B
pub const CS1: *mut u8 = 0x7 as *mut u8;

/// Bitfield on register TCCR1B
pub const ICES1: *mut u8 = 0x40 as *mut u8;

/// Bitfield on register TCCR1C
pub const FOC1B: *mut u8 = 0x40 as *mut u8;

/// Bitfield on register TCCR1C
pub const FOC1A: *mut u8 = 0x80 as *mut u8;

/// Bitfield on register TCCR1D
pub const OC1AX: *mut u8 = 0x8 as *mut u8;

/// Bitfield on register TCCR1D
pub const OC1AU: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register TCCR1D
pub const OC1BV: *mut u8 = 0x20 as *mut u8;

/// Bitfield on register TCCR1D
pub const OC1BU: *mut u8 = 0x10 as *mut u8;

/// Bitfield on register TCCR1D
pub const OC1BX: *mut u8 = 0x80 as *mut u8;

/// Bitfield on register TCCR1D
pub const OC1AV: *mut u8 = 0x2 as *mut u8;

/// Bitfield on register TCCR1D
pub const OC1AW: *mut u8 = 0x4 as *mut u8;

/// Bitfield on register TCCR1D
pub const OC1BW: *mut u8 = 0x40 as *mut u8;

/// Bitfield on register TIFR0
pub const TOV0: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register TIFR0
pub const OCF0A: *mut u8 = 0x2 as *mut u8;

/// Bitfield on register TIFR1
pub const OCF1B: *mut u8 = 0x4 as *mut u8;

/// Bitfield on register TIFR1
pub const TOV1: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register TIFR1
pub const OCF1A: *mut u8 = 0x2 as *mut u8;

/// Bitfield on register TIFR1
pub const ICF1: *mut u8 = 0x20 as *mut u8;

/// Bitfield on register TIMSK0
pub const OCIE0A: *mut u8 = 0x2 as *mut u8;

/// Bitfield on register TIMSK0
pub const TOIE0: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register TIMSK1
pub const OCIE1B: *mut u8 = 0x4 as *mut u8;

/// Bitfield on register TIMSK1
pub const OCIE1A: *mut u8 = 0x2 as *mut u8;

/// Bitfield on register TIMSK1
pub const TOIE1: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register TIMSK1
pub const ICIE1: *mut u8 = 0x20 as *mut u8;

/// Bitfield on register USICR
pub const USICS: *mut u8 = 0xC as *mut u8;

/// Bitfield on register USICR
pub const USICLK: *mut u8 = 0x2 as *mut u8;

/// Bitfield on register USICR
pub const USISIE: *mut u8 = 0x80 as *mut u8;

/// Bitfield on register USICR
pub const USITC: *mut u8 = 0x1 as *mut u8;

/// Bitfield on register USICR
pub const USIOIE: *mut u8 = 0x40 as *mut u8;

/// Bitfield on register USICR
pub const USIWM: *mut u8 = 0x30 as *mut u8;

/// Bitfield on register USISR
pub const USIPF: *mut u8 = 0x20 as *mut u8;

/// Bitfield on register USISR
pub const USIOIF: *mut u8 = 0x40 as *mut u8;

/// Bitfield on register USISR
pub const USIDC: *mut u8 = 0x10 as *mut u8;

/// Bitfield on register USISR
pub const USICNT: *mut u8 = 0xF as *mut u8;

/// Bitfield on register USISR
pub const USISIF: *mut u8 = 0x80 as *mut u8;

/// Bitfield on register WDTCR
pub const WDE: *mut u8 = 0x8 as *mut u8;

/// Bitfield on register WDTCR
pub const WDCE: *mut u8 = 0x10 as *mut u8;

/// Bitfield on register WDTCR
pub const WDP: *mut u8 = 0x27 as *mut u8;

/// Bitfield on register WDTCR
pub const WDIF: *mut u8 = 0x80 as *mut u8;

/// Bitfield on register WDTCR
pub const WDIE: *mut u8 = 0x40 as *mut u8;