mtb_pac_psoc6_01 0.1.1

/*
(c) (2016-2024), Cypress Semiconductor Corporation (an Infineon company)

    or an affiliate of Cypress Semiconductor Corporation.



    SPDX-License-Identifier: Apache-2.0



    Licensed under the Apache License, Version 2.0 (the "License");

    you may not use this file except in compliance with the License.

    You may obtain a copy of the License at



      http://www.apache.org/licenses/LICENSE-2.0



    Unless required by applicable law or agreed to in writing, software

    distributed under the License is distributed on an "AS IS" BASIS,

    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    See the License for the specific language governing permissions and

    limitations under the License.
*/
// Generated from SVD 1.0, with svd2pac 0.6.0 on Tue, 27 May 2025 19:21:54 +0000

#![allow(clippy::identity_op)]
#![allow(clippy::module_inception)]
#![allow(clippy::derivable_impls)]
#[allow(unused_imports)]
use crate::common::sealed;
#[allow(unused_imports)]
use crate::common::*;
#[doc = r"EFUSE MXS40 registers"]
unsafe impl ::core::marker::Send for super::Efuse {}
unsafe impl ::core::marker::Sync for super::Efuse {}
impl super::Efuse {
    #[allow(unused)]
    #[inline(always)]
    pub(crate) const fn _svd2pac_as_ptr(&self) -> *mut u8 {
        self.ptr
    }

    #[doc = "Control"]
    #[inline(always)]
    pub const fn ctl(&self) -> &'static crate::common::Reg<self::Ctl_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::Ctl_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(0usize),
            )
        }
    }

    #[doc = "Command"]
    #[inline(always)]
    pub const fn cmd(&self) -> &'static crate::common::Reg<self::Cmd_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::Cmd_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(16usize),
            )
        }
    }

    #[doc = "Sequencer Default value"]
    #[inline(always)]
    pub const fn seq_default(
        &self,
    ) -> &'static crate::common::Reg<self::SeqDefault_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::SeqDefault_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(32usize),
            )
        }
    }

    #[doc = "Sequencer read control 0"]
    #[inline(always)]
    pub const fn seq_read_ctl_0(
        &self,
    ) -> &'static crate::common::Reg<self::SeqReadCtl0_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::SeqReadCtl0_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(64usize),
            )
        }
    }

    #[doc = "Sequencer read control 1"]
    #[inline(always)]
    pub const fn seq_read_ctl_1(
        &self,
    ) -> &'static crate::common::Reg<self::SeqReadCtl1_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::SeqReadCtl1_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(68usize),
            )
        }
    }

    #[doc = "Sequencer read control 2"]
    #[inline(always)]
    pub const fn seq_read_ctl_2(
        &self,
    ) -> &'static crate::common::Reg<self::SeqReadCtl2_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::SeqReadCtl2_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(72usize),
            )
        }
    }

    #[doc = "Sequencer read control 3"]
    #[inline(always)]
    pub const fn seq_read_ctl_3(
        &self,
    ) -> &'static crate::common::Reg<self::SeqReadCtl3_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::SeqReadCtl3_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(76usize),
            )
        }
    }

    #[doc = "Sequencer read control 4"]
    #[inline(always)]
    pub const fn seq_read_ctl_4(
        &self,
    ) -> &'static crate::common::Reg<self::SeqReadCtl4_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::SeqReadCtl4_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(80usize),
            )
        }
    }

    #[doc = "Sequencer read control 5"]
    #[inline(always)]
    pub const fn seq_read_ctl_5(
        &self,
    ) -> &'static crate::common::Reg<self::SeqReadCtl5_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::SeqReadCtl5_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(84usize),
            )
        }
    }

    #[doc = "Sequencer program control 0"]
    #[inline(always)]
    pub const fn seq_program_ctl_0(
        &self,
    ) -> &'static crate::common::Reg<self::SeqProgramCtl0_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::SeqProgramCtl0_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(96usize),
            )
        }
    }

    #[doc = "Sequencer program control 1"]
    #[inline(always)]
    pub const fn seq_program_ctl_1(
        &self,
    ) -> &'static crate::common::Reg<self::SeqProgramCtl1_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::SeqProgramCtl1_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(100usize),
            )
        }
    }

    #[doc = "Sequencer program control 2"]
    #[inline(always)]
    pub const fn seq_program_ctl_2(
        &self,
    ) -> &'static crate::common::Reg<self::SeqProgramCtl2_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::SeqProgramCtl2_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(104usize),
            )
        }
    }

    #[doc = "Sequencer program control 3"]
    #[inline(always)]
    pub const fn seq_program_ctl_3(
        &self,
    ) -> &'static crate::common::Reg<self::SeqProgramCtl3_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::SeqProgramCtl3_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(108usize),
            )
        }
    }

    #[doc = "Sequencer program control 4"]
    #[inline(always)]
    pub const fn seq_program_ctl_4(
        &self,
    ) -> &'static crate::common::Reg<self::SeqProgramCtl4_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::SeqProgramCtl4_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(112usize),
            )
        }
    }

    #[doc = "Sequencer program control 5"]
    #[inline(always)]
    pub const fn seq_program_ctl_5(
        &self,
    ) -> &'static crate::common::Reg<self::SeqProgramCtl5_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::SeqProgramCtl5_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(116usize),
            )
        }
    }
}
#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ctl_SPEC;
impl crate::sealed::RegSpec for Ctl_SPEC {
    type DataType = u32;
}

#[doc = "Control"]
pub type Ctl = crate::RegValueT<Ctl_SPEC>;

impl Ctl {
    #[doc = "IP enable:\n\'0\': Disabled. All non-retention registers (command and status registers) are reset to their default value when the IP is disabled. All retention registers retain their value when the IP is disabled.\n\'1\': Enabled."]
    #[inline(always)]
    pub fn enabled(
        self,
    ) -> crate::common::RegisterFieldBool<31, 1, 0, Ctl_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<31, 1, 0, Ctl_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }
}
impl ::core::default::Default for Ctl {
    #[inline(always)]
    fn default() -> Ctl {
        <crate::RegValueT<Ctl_SPEC> as RegisterValue<_>>::new(0)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cmd_SPEC;
impl crate::sealed::RegSpec for Cmd_SPEC {
    type DataType = u32;
}

#[doc = "Command"]
pub type Cmd = crate::RegValueT<Cmd_SPEC>;

impl Cmd {
    #[doc = "Bit data. This field specifies the bit value that is to be programmed into the eFUSE macro array. The address of the bit is specified by the BIT_ADDR, BYTE_ADDR, and MACRO_ADDR fields. This bit is a don\'t care for the MXS40 Macro."]
    #[inline(always)]
    pub fn bit_data(
        self,
    ) -> crate::common::RegisterFieldBool<0, 1, 0, Cmd_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<0, 1, 0, Cmd_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }

    #[doc = "Bit address. This field specifies a bit within a Byte."]
    #[inline(always)]
    pub fn bit_addr(
        self,
    ) -> crate::common::RegisterField<4, 0x7, 1, 0, u8, u8, Cmd_SPEC, crate::common::RW> {
        crate::common::RegisterField::<4,0x7,1,0,u8,u8,Cmd_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Byte address. This field specifies a Byte within a eFUSE macro (each macro has 32 B)."]
    #[inline(always)]
    pub fn byte_addr(
        self,
    ) -> crate::common::RegisterField<8, 0x1f, 1, 0, u8, u8, Cmd_SPEC, crate::common::RW> {
        crate::common::RegisterField::<8,0x1f,1,0,u8,u8,Cmd_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Macro address. This field specifies an eFUSE macro."]
    #[inline(always)]
    pub fn macro_addr(
        self,
    ) -> crate::common::RegisterField<16, 0xf, 1, 0, u8, u8, Cmd_SPEC, crate::common::RW> {
        crate::common::RegisterField::<16,0xf,1,0,u8,u8,Cmd_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "FW sets this field to \'1\' to start a program operation. HW sets this field to \'0\' to indicate that the operation has completed.\n\nNote: it is good practice to verify the result of a program operation by reading back a programmed eFUSE memory location. Programming can only change an eFUSE memory bit from \'0\' to \'1\'; i.e. a programming operation is a \'one-off\' operation for each eFUSE memory bit: once a bit is changed to \'1\', it can NEVER be changed back to \'0\' as a hardware fuse is blown.\n\nProgramming a memory bit to \'1\' requires blowing a fuse and requires an eFUSE macro operation. Therefore, this programmiong operation takes time (as specified by the SEQ_PROGRAM_CTL reguisters). Programming amemory bit to \'0\' does not require an eFUSE macro operation (it is the default eFUSE macro state). Therefore, this programming operation is almost instantaneous.\n\nNote: during a program operation, a read operation can not be performed. An AHB-Lite read transfer to the eFUSE memory during a program operation results in an AHB-Lite bus error."]
    #[inline(always)]
    pub fn start(self) -> crate::common::RegisterFieldBool<31, 1, 0, Cmd_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<31, 1, 0, Cmd_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }
}
impl ::core::default::Default for Cmd {
    #[inline(always)]
    fn default() -> Cmd {
        <crate::RegValueT<Cmd_SPEC> as RegisterValue<_>>::new(1)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct SeqDefault_SPEC;
impl crate::sealed::RegSpec for SeqDefault_SPEC {
    type DataType = u32;
}

#[doc = "Sequencer Default value"]
pub type SeqDefault = crate::RegValueT<SeqDefault_SPEC>;

impl SeqDefault {
    #[doc = "Specifies value of eFUSE control signal strobe_f"]
    #[inline(always)]
    pub fn strobe_a(
        self,
    ) -> crate::common::RegisterFieldBool<16, 1, 0, SeqDefault_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<16,1,0,SeqDefault_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSEcontrol signal strobe_b"]
    #[inline(always)]
    pub fn strobe_b(
        self,
    ) -> crate::common::RegisterFieldBool<17, 1, 0, SeqDefault_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<17,1,0,SeqDefault_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_c"]
    #[inline(always)]
    pub fn strobe_c(
        self,
    ) -> crate::common::RegisterFieldBool<18, 1, 0, SeqDefault_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<18,1,0,SeqDefault_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_d"]
    #[inline(always)]
    pub fn strobe_d(
        self,
    ) -> crate::common::RegisterFieldBool<19, 1, 0, SeqDefault_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<19,1,0,SeqDefault_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_e"]
    #[inline(always)]
    pub fn strobe_e(
        self,
    ) -> crate::common::RegisterFieldBool<20, 1, 0, SeqDefault_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<20,1,0,SeqDefault_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_f"]
    #[inline(always)]
    pub fn strobe_f(
        self,
    ) -> crate::common::RegisterFieldBool<21, 1, 0, SeqDefault_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<21,1,0,SeqDefault_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_g"]
    #[inline(always)]
    pub fn strobe_g(
        self,
    ) -> crate::common::RegisterFieldBool<22, 1, 0, SeqDefault_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<22,1,0,SeqDefault_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for SeqDefault {
    #[inline(always)]
    fn default() -> SeqDefault {
        <crate::RegValueT<SeqDefault_SPEC> as RegisterValue<_>>::new(1900544)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct SeqReadCtl0_SPEC;
impl crate::sealed::RegSpec for SeqReadCtl0_SPEC {
    type DataType = u32;
}

#[doc = "Sequencer read control 0"]
pub type SeqReadCtl0 = crate::RegValueT<SeqReadCtl0_SPEC>;

impl SeqReadCtl0 {
    #[doc = "Number of IP clock cycles (minus 1). This field is in the range of \\[0, 1023\\], allowing for a time of \\[1, 1024\\] IP clock cycles."]
    #[inline(always)]
    pub fn cycles(
        self,
    ) -> crate::common::RegisterField<0, 0x3ff, 1, 0, u16, u16, SeqReadCtl0_SPEC, crate::common::RW>
    {
        crate::common::RegisterField::<0,0x3ff,1,0,u16,u16,SeqReadCtl0_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_f"]
    #[inline(always)]
    pub fn strobe_a(
        self,
    ) -> crate::common::RegisterFieldBool<16, 1, 0, SeqReadCtl0_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<16,1,0,SeqReadCtl0_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSEcontrol signal strobe_b"]
    #[inline(always)]
    pub fn strobe_b(
        self,
    ) -> crate::common::RegisterFieldBool<17, 1, 0, SeqReadCtl0_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<17,1,0,SeqReadCtl0_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_c"]
    #[inline(always)]
    pub fn strobe_c(
        self,
    ) -> crate::common::RegisterFieldBool<18, 1, 0, SeqReadCtl0_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<18,1,0,SeqReadCtl0_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_d"]
    #[inline(always)]
    pub fn strobe_d(
        self,
    ) -> crate::common::RegisterFieldBool<19, 1, 0, SeqReadCtl0_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<19,1,0,SeqReadCtl0_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_e"]
    #[inline(always)]
    pub fn strobe_e(
        self,
    ) -> crate::common::RegisterFieldBool<20, 1, 0, SeqReadCtl0_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<20,1,0,SeqReadCtl0_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_f"]
    #[inline(always)]
    pub fn strobe_f(
        self,
    ) -> crate::common::RegisterFieldBool<21, 1, 0, SeqReadCtl0_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<21,1,0,SeqReadCtl0_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_g"]
    #[inline(always)]
    pub fn strobe_g(
        self,
    ) -> crate::common::RegisterFieldBool<22, 1, 0, SeqReadCtl0_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<22,1,0,SeqReadCtl0_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "When set to 1 indicates that the Read cycle ends when the current cycle count reaches 0."]
    #[inline(always)]
    pub fn done(
        self,
    ) -> crate::common::RegisterFieldBool<31, 1, 0, SeqReadCtl0_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<31,1,0,SeqReadCtl0_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for SeqReadCtl0 {
    #[inline(always)]
    fn default() -> SeqReadCtl0 {
        <crate::RegValueT<SeqReadCtl0_SPEC> as RegisterValue<_>>::new(2153119745)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct SeqReadCtl1_SPEC;
impl crate::sealed::RegSpec for SeqReadCtl1_SPEC {
    type DataType = u32;
}

#[doc = "Sequencer read control 1"]
pub type SeqReadCtl1 = crate::RegValueT<SeqReadCtl1_SPEC>;

impl SeqReadCtl1 {
    #[doc = "Number of IP clock cycles (minus 1). This field is in the range of \\[0, 1023\\], allowing for a time of \\[1, 1024\\] IP clock cycles."]
    #[inline(always)]
    pub fn cycles(
        self,
    ) -> crate::common::RegisterField<0, 0x3ff, 1, 0, u16, u16, SeqReadCtl1_SPEC, crate::common::RW>
    {
        crate::common::RegisterField::<0,0x3ff,1,0,u16,u16,SeqReadCtl1_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_f"]
    #[inline(always)]
    pub fn strobe_a(
        self,
    ) -> crate::common::RegisterFieldBool<16, 1, 0, SeqReadCtl1_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<16,1,0,SeqReadCtl1_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSEcontrol signal strobe_b"]
    #[inline(always)]
    pub fn strobe_b(
        self,
    ) -> crate::common::RegisterFieldBool<17, 1, 0, SeqReadCtl1_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<17,1,0,SeqReadCtl1_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_c"]
    #[inline(always)]
    pub fn strobe_c(
        self,
    ) -> crate::common::RegisterFieldBool<18, 1, 0, SeqReadCtl1_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<18,1,0,SeqReadCtl1_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_d"]
    #[inline(always)]
    pub fn strobe_d(
        self,
    ) -> crate::common::RegisterFieldBool<19, 1, 0, SeqReadCtl1_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<19,1,0,SeqReadCtl1_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_e"]
    #[inline(always)]
    pub fn strobe_e(
        self,
    ) -> crate::common::RegisterFieldBool<20, 1, 0, SeqReadCtl1_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<20,1,0,SeqReadCtl1_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_f"]
    #[inline(always)]
    pub fn strobe_f(
        self,
    ) -> crate::common::RegisterFieldBool<21, 1, 0, SeqReadCtl1_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<21,1,0,SeqReadCtl1_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_g"]
    #[inline(always)]
    pub fn strobe_g(
        self,
    ) -> crate::common::RegisterFieldBool<22, 1, 0, SeqReadCtl1_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<22,1,0,SeqReadCtl1_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "When set to 1 indicates that the Read cycle ends when the current cycle count reaches 0."]
    #[inline(always)]
    pub fn done(
        self,
    ) -> crate::common::RegisterFieldBool<31, 1, 0, SeqReadCtl1_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<31,1,0,SeqReadCtl1_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for SeqReadCtl1 {
    #[inline(always)]
    fn default() -> SeqReadCtl1 {
        <crate::RegValueT<SeqReadCtl1_SPEC> as RegisterValue<_>>::new(5505028)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct SeqReadCtl2_SPEC;
impl crate::sealed::RegSpec for SeqReadCtl2_SPEC {
    type DataType = u32;
}

#[doc = "Sequencer read control 2"]
pub type SeqReadCtl2 = crate::RegValueT<SeqReadCtl2_SPEC>;

impl SeqReadCtl2 {
    #[doc = "Number of IP clock cycles (minus 1). This field is in the range of \\[0, 1023\\], allowing for a time of \\[1, 1024\\] IP clock cycles."]
    #[inline(always)]
    pub fn cycles(
        self,
    ) -> crate::common::RegisterField<0, 0x3ff, 1, 0, u16, u16, SeqReadCtl2_SPEC, crate::common::RW>
    {
        crate::common::RegisterField::<0,0x3ff,1,0,u16,u16,SeqReadCtl2_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_f"]
    #[inline(always)]
    pub fn strobe_a(
        self,
    ) -> crate::common::RegisterFieldBool<16, 1, 0, SeqReadCtl2_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<16,1,0,SeqReadCtl2_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSEcontrol signal strobe_b"]
    #[inline(always)]
    pub fn strobe_b(
        self,
    ) -> crate::common::RegisterFieldBool<17, 1, 0, SeqReadCtl2_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<17,1,0,SeqReadCtl2_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_c"]
    #[inline(always)]
    pub fn strobe_c(
        self,
    ) -> crate::common::RegisterFieldBool<18, 1, 0, SeqReadCtl2_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<18,1,0,SeqReadCtl2_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_d"]
    #[inline(always)]
    pub fn strobe_d(
        self,
    ) -> crate::common::RegisterFieldBool<19, 1, 0, SeqReadCtl2_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<19,1,0,SeqReadCtl2_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_e"]
    #[inline(always)]
    pub fn strobe_e(
        self,
    ) -> crate::common::RegisterFieldBool<20, 1, 0, SeqReadCtl2_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<20,1,0,SeqReadCtl2_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_f"]
    #[inline(always)]
    pub fn strobe_f(
        self,
    ) -> crate::common::RegisterFieldBool<21, 1, 0, SeqReadCtl2_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<21,1,0,SeqReadCtl2_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_g"]
    #[inline(always)]
    pub fn strobe_g(
        self,
    ) -> crate::common::RegisterFieldBool<22, 1, 0, SeqReadCtl2_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<22,1,0,SeqReadCtl2_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "When set to 1 indicates that the Read cycle ends when the current cycle count reaches 0."]
    #[inline(always)]
    pub fn done(
        self,
    ) -> crate::common::RegisterFieldBool<31, 1, 0, SeqReadCtl2_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<31,1,0,SeqReadCtl2_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for SeqReadCtl2 {
    #[inline(always)]
    fn default() -> SeqReadCtl2 {
        <crate::RegValueT<SeqReadCtl2_SPEC> as RegisterValue<_>>::new(5636097)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct SeqReadCtl3_SPEC;
impl crate::sealed::RegSpec for SeqReadCtl3_SPEC {
    type DataType = u32;
}

#[doc = "Sequencer read control 3"]
pub type SeqReadCtl3 = crate::RegValueT<SeqReadCtl3_SPEC>;

impl SeqReadCtl3 {
    #[doc = "Number of IP clock cycles (minus 1). This field is in the range of \\[0, 1023\\], allowing for a time of \\[1, 1024\\] IP clock cycles."]
    #[inline(always)]
    pub fn cycles(
        self,
    ) -> crate::common::RegisterField<0, 0x3ff, 1, 0, u16, u16, SeqReadCtl3_SPEC, crate::common::RW>
    {
        crate::common::RegisterField::<0,0x3ff,1,0,u16,u16,SeqReadCtl3_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_f"]
    #[inline(always)]
    pub fn strobe_a(
        self,
    ) -> crate::common::RegisterFieldBool<16, 1, 0, SeqReadCtl3_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<16,1,0,SeqReadCtl3_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSEcontrol signal strobe_b"]
    #[inline(always)]
    pub fn strobe_b(
        self,
    ) -> crate::common::RegisterFieldBool<17, 1, 0, SeqReadCtl3_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<17,1,0,SeqReadCtl3_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_c"]
    #[inline(always)]
    pub fn strobe_c(
        self,
    ) -> crate::common::RegisterFieldBool<18, 1, 0, SeqReadCtl3_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<18,1,0,SeqReadCtl3_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_d"]
    #[inline(always)]
    pub fn strobe_d(
        self,
    ) -> crate::common::RegisterFieldBool<19, 1, 0, SeqReadCtl3_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<19,1,0,SeqReadCtl3_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_e"]
    #[inline(always)]
    pub fn strobe_e(
        self,
    ) -> crate::common::RegisterFieldBool<20, 1, 0, SeqReadCtl3_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<20,1,0,SeqReadCtl3_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_f"]
    #[inline(always)]
    pub fn strobe_f(
        self,
    ) -> crate::common::RegisterFieldBool<21, 1, 0, SeqReadCtl3_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<21,1,0,SeqReadCtl3_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_g"]
    #[inline(always)]
    pub fn strobe_g(
        self,
    ) -> crate::common::RegisterFieldBool<22, 1, 0, SeqReadCtl3_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<22,1,0,SeqReadCtl3_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "When set to 1 indicates that the Read cycle ends when the current cycle count reaches 0."]
    #[inline(always)]
    pub fn done(
        self,
    ) -> crate::common::RegisterFieldBool<31, 1, 0, SeqReadCtl3_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<31,1,0,SeqReadCtl3_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for SeqReadCtl3 {
    #[inline(always)]
    fn default() -> SeqReadCtl3 {
        <crate::RegValueT<SeqReadCtl3_SPEC> as RegisterValue<_>>::new(5505027)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct SeqReadCtl4_SPEC;
impl crate::sealed::RegSpec for SeqReadCtl4_SPEC {
    type DataType = u32;
}

#[doc = "Sequencer read control 4"]
pub type SeqReadCtl4 = crate::RegValueT<SeqReadCtl4_SPEC>;

impl SeqReadCtl4 {
    #[doc = "Number of IP clock cycles (minus 1). This field is in the range of \\[0, 1023\\], allowing for a time of \\[1, 1024\\] IP clock cycles."]
    #[inline(always)]
    pub fn cycles(
        self,
    ) -> crate::common::RegisterField<0, 0x3ff, 1, 0, u16, u16, SeqReadCtl4_SPEC, crate::common::RW>
    {
        crate::common::RegisterField::<0,0x3ff,1,0,u16,u16,SeqReadCtl4_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_f"]
    #[inline(always)]
    pub fn strobe_a(
        self,
    ) -> crate::common::RegisterFieldBool<16, 1, 0, SeqReadCtl4_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<16,1,0,SeqReadCtl4_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSEcontrol signal strobe_b"]
    #[inline(always)]
    pub fn strobe_b(
        self,
    ) -> crate::common::RegisterFieldBool<17, 1, 0, SeqReadCtl4_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<17,1,0,SeqReadCtl4_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_c"]
    #[inline(always)]
    pub fn strobe_c(
        self,
    ) -> crate::common::RegisterFieldBool<18, 1, 0, SeqReadCtl4_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<18,1,0,SeqReadCtl4_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_d"]
    #[inline(always)]
    pub fn strobe_d(
        self,
    ) -> crate::common::RegisterFieldBool<19, 1, 0, SeqReadCtl4_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<19,1,0,SeqReadCtl4_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_e"]
    #[inline(always)]
    pub fn strobe_e(
        self,
    ) -> crate::common::RegisterFieldBool<20, 1, 0, SeqReadCtl4_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<20,1,0,SeqReadCtl4_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_f"]
    #[inline(always)]
    pub fn strobe_f(
        self,
    ) -> crate::common::RegisterFieldBool<21, 1, 0, SeqReadCtl4_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<21,1,0,SeqReadCtl4_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_g"]
    #[inline(always)]
    pub fn strobe_g(
        self,
    ) -> crate::common::RegisterFieldBool<22, 1, 0, SeqReadCtl4_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<22,1,0,SeqReadCtl4_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "When set to 1 indicates that the Read cycle ends when the current cycle count reaches 0."]
    #[inline(always)]
    pub fn done(
        self,
    ) -> crate::common::RegisterFieldBool<31, 1, 0, SeqReadCtl4_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<31,1,0,SeqReadCtl4_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for SeqReadCtl4 {
    #[inline(always)]
    fn default() -> SeqReadCtl4 {
        <crate::RegValueT<SeqReadCtl4_SPEC> as RegisterValue<_>>::new(2148859905)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct SeqReadCtl5_SPEC;
impl crate::sealed::RegSpec for SeqReadCtl5_SPEC {
    type DataType = u32;
}

#[doc = "Sequencer read control 5"]
pub type SeqReadCtl5 = crate::RegValueT<SeqReadCtl5_SPEC>;

impl SeqReadCtl5 {
    #[doc = "Number of IP clock cycles (minus 1). This field is in the range of \\[0, 1023\\], allowing for a time of \\[1, 1024\\] IP clock cycles."]
    #[inline(always)]
    pub fn cycles(
        self,
    ) -> crate::common::RegisterField<0, 0x3ff, 1, 0, u16, u16, SeqReadCtl5_SPEC, crate::common::RW>
    {
        crate::common::RegisterField::<0,0x3ff,1,0,u16,u16,SeqReadCtl5_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_f"]
    #[inline(always)]
    pub fn strobe_a(
        self,
    ) -> crate::common::RegisterFieldBool<16, 1, 0, SeqReadCtl5_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<16,1,0,SeqReadCtl5_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSEcontrol signal strobe_b"]
    #[inline(always)]
    pub fn strobe_b(
        self,
    ) -> crate::common::RegisterFieldBool<17, 1, 0, SeqReadCtl5_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<17,1,0,SeqReadCtl5_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_c"]
    #[inline(always)]
    pub fn strobe_c(
        self,
    ) -> crate::common::RegisterFieldBool<18, 1, 0, SeqReadCtl5_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<18,1,0,SeqReadCtl5_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_d"]
    #[inline(always)]
    pub fn strobe_d(
        self,
    ) -> crate::common::RegisterFieldBool<19, 1, 0, SeqReadCtl5_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<19,1,0,SeqReadCtl5_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_e"]
    #[inline(always)]
    pub fn strobe_e(
        self,
    ) -> crate::common::RegisterFieldBool<20, 1, 0, SeqReadCtl5_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<20,1,0,SeqReadCtl5_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_f"]
    #[inline(always)]
    pub fn strobe_f(
        self,
    ) -> crate::common::RegisterFieldBool<21, 1, 0, SeqReadCtl5_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<21,1,0,SeqReadCtl5_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_g"]
    #[inline(always)]
    pub fn strobe_g(
        self,
    ) -> crate::common::RegisterFieldBool<22, 1, 0, SeqReadCtl5_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<22,1,0,SeqReadCtl5_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "When set to 1 indicates that the Read cycle ends when the current cycle count reaches 0."]
    #[inline(always)]
    pub fn done(
        self,
    ) -> crate::common::RegisterFieldBool<31, 1, 0, SeqReadCtl5_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<31,1,0,SeqReadCtl5_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for SeqReadCtl5 {
    #[inline(always)]
    fn default() -> SeqReadCtl5 {
        <crate::RegValueT<SeqReadCtl5_SPEC> as RegisterValue<_>>::new(3211268)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct SeqProgramCtl0_SPEC;
impl crate::sealed::RegSpec for SeqProgramCtl0_SPEC {
    type DataType = u32;
}

#[doc = "Sequencer program control 0"]
pub type SeqProgramCtl0 = crate::RegValueT<SeqProgramCtl0_SPEC>;

impl SeqProgramCtl0 {
    #[doc = "Number of IP clock cycles (minus 1). This field is in the range of \\[0, 1023\\], allowing for a time of \\[1, 1024\\] IP clock cycles."]
    #[inline(always)]
    pub fn cycles(
        self,
    ) -> crate::common::RegisterField<
        0,
        0x3ff,
        1,
        0,
        u16,
        u16,
        SeqProgramCtl0_SPEC,
        crate::common::RW,
    > {
        crate::common::RegisterField::<
            0,
            0x3ff,
            1,
            0,
            u16,
            u16,
            SeqProgramCtl0_SPEC,
            crate::common::RW,
        >::from_register(self, 0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_a"]
    #[inline(always)]
    pub fn strobe_a(
        self,
    ) -> crate::common::RegisterFieldBool<16, 1, 0, SeqProgramCtl0_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<16,1,0,SeqProgramCtl0_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSEcontrol signal strobe_b"]
    #[inline(always)]
    pub fn strobe_b(
        self,
    ) -> crate::common::RegisterFieldBool<17, 1, 0, SeqProgramCtl0_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<17,1,0,SeqProgramCtl0_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_c"]
    #[inline(always)]
    pub fn strobe_c(
        self,
    ) -> crate::common::RegisterFieldBool<18, 1, 0, SeqProgramCtl0_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<18,1,0,SeqProgramCtl0_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_d"]
    #[inline(always)]
    pub fn strobe_d(
        self,
    ) -> crate::common::RegisterFieldBool<19, 1, 0, SeqProgramCtl0_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<19,1,0,SeqProgramCtl0_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_e"]
    #[inline(always)]
    pub fn strobe_e(
        self,
    ) -> crate::common::RegisterFieldBool<20, 1, 0, SeqProgramCtl0_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<20,1,0,SeqProgramCtl0_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_f"]
    #[inline(always)]
    pub fn strobe_f(
        self,
    ) -> crate::common::RegisterFieldBool<21, 1, 0, SeqProgramCtl0_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<21,1,0,SeqProgramCtl0_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_g"]
    #[inline(always)]
    pub fn strobe_g(
        self,
    ) -> crate::common::RegisterFieldBool<22, 1, 0, SeqProgramCtl0_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<22,1,0,SeqProgramCtl0_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "When set to 1 indicates that the Read cycle ends when the current cycle count reaches 0."]
    #[inline(always)]
    pub fn done(
        self,
    ) -> crate::common::RegisterFieldBool<31, 1, 0, SeqProgramCtl0_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<31,1,0,SeqProgramCtl0_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for SeqProgramCtl0 {
    #[inline(always)]
    fn default() -> SeqProgramCtl0 {
        <crate::RegValueT<SeqProgramCtl0_SPEC> as RegisterValue<_>>::new(2097153)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct SeqProgramCtl1_SPEC;
impl crate::sealed::RegSpec for SeqProgramCtl1_SPEC {
    type DataType = u32;
}

#[doc = "Sequencer program control 1"]
pub type SeqProgramCtl1 = crate::RegValueT<SeqProgramCtl1_SPEC>;

impl SeqProgramCtl1 {
    #[doc = "Number of IP clock cycles (minus 1). This field is in the range of \\[0, 1023\\], allowing for a time of \\[1, 1024\\] IP clock cycles."]
    #[inline(always)]
    pub fn cycles(
        self,
    ) -> crate::common::RegisterField<
        0,
        0x3ff,
        1,
        0,
        u16,
        u16,
        SeqProgramCtl1_SPEC,
        crate::common::RW,
    > {
        crate::common::RegisterField::<
            0,
            0x3ff,
            1,
            0,
            u16,
            u16,
            SeqProgramCtl1_SPEC,
            crate::common::RW,
        >::from_register(self, 0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_a"]
    #[inline(always)]
    pub fn strobe_a(
        self,
    ) -> crate::common::RegisterFieldBool<16, 1, 0, SeqProgramCtl1_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<16,1,0,SeqProgramCtl1_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSEcontrol signal strobe_b"]
    #[inline(always)]
    pub fn strobe_b(
        self,
    ) -> crate::common::RegisterFieldBool<17, 1, 0, SeqProgramCtl1_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<17,1,0,SeqProgramCtl1_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_c"]
    #[inline(always)]
    pub fn strobe_c(
        self,
    ) -> crate::common::RegisterFieldBool<18, 1, 0, SeqProgramCtl1_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<18,1,0,SeqProgramCtl1_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_d"]
    #[inline(always)]
    pub fn strobe_d(
        self,
    ) -> crate::common::RegisterFieldBool<19, 1, 0, SeqProgramCtl1_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<19,1,0,SeqProgramCtl1_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_e"]
    #[inline(always)]
    pub fn strobe_e(
        self,
    ) -> crate::common::RegisterFieldBool<20, 1, 0, SeqProgramCtl1_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<20,1,0,SeqProgramCtl1_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_f"]
    #[inline(always)]
    pub fn strobe_f(
        self,
    ) -> crate::common::RegisterFieldBool<21, 1, 0, SeqProgramCtl1_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<21,1,0,SeqProgramCtl1_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_g"]
    #[inline(always)]
    pub fn strobe_g(
        self,
    ) -> crate::common::RegisterFieldBool<22, 1, 0, SeqProgramCtl1_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<22,1,0,SeqProgramCtl1_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "When set to 1 indicates that the Read cycle ends when the current cycle count reaches 0."]
    #[inline(always)]
    pub fn done(
        self,
    ) -> crate::common::RegisterFieldBool<31, 1, 0, SeqProgramCtl1_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<31,1,0,SeqProgramCtl1_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for SeqProgramCtl1 {
    #[inline(always)]
    fn default() -> SeqProgramCtl1 {
        <crate::RegValueT<SeqProgramCtl1_SPEC> as RegisterValue<_>>::new(2228256)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct SeqProgramCtl2_SPEC;
impl crate::sealed::RegSpec for SeqProgramCtl2_SPEC {
    type DataType = u32;
}

#[doc = "Sequencer program control 2"]
pub type SeqProgramCtl2 = crate::RegValueT<SeqProgramCtl2_SPEC>;

impl SeqProgramCtl2 {
    #[doc = "Number of IP clock cycles (minus 1). This field is in the range of \\[0, 1023\\], allowing for a time of \\[1, 1024\\] IP clock cycles."]
    #[inline(always)]
    pub fn cycles(
        self,
    ) -> crate::common::RegisterField<
        0,
        0x3ff,
        1,
        0,
        u16,
        u16,
        SeqProgramCtl2_SPEC,
        crate::common::RW,
    > {
        crate::common::RegisterField::<
            0,
            0x3ff,
            1,
            0,
            u16,
            u16,
            SeqProgramCtl2_SPEC,
            crate::common::RW,
        >::from_register(self, 0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_a"]
    #[inline(always)]
    pub fn strobe_a(
        self,
    ) -> crate::common::RegisterFieldBool<16, 1, 0, SeqProgramCtl2_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<16,1,0,SeqProgramCtl2_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSEcontrol signal strobe_b"]
    #[inline(always)]
    pub fn strobe_b(
        self,
    ) -> crate::common::RegisterFieldBool<17, 1, 0, SeqProgramCtl2_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<17,1,0,SeqProgramCtl2_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_c"]
    #[inline(always)]
    pub fn strobe_c(
        self,
    ) -> crate::common::RegisterFieldBool<18, 1, 0, SeqProgramCtl2_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<18,1,0,SeqProgramCtl2_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_d"]
    #[inline(always)]
    pub fn strobe_d(
        self,
    ) -> crate::common::RegisterFieldBool<19, 1, 0, SeqProgramCtl2_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<19,1,0,SeqProgramCtl2_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_e"]
    #[inline(always)]
    pub fn strobe_e(
        self,
    ) -> crate::common::RegisterFieldBool<20, 1, 0, SeqProgramCtl2_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<20,1,0,SeqProgramCtl2_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_f"]
    #[inline(always)]
    pub fn strobe_f(
        self,
    ) -> crate::common::RegisterFieldBool<21, 1, 0, SeqProgramCtl2_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<21,1,0,SeqProgramCtl2_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_g"]
    #[inline(always)]
    pub fn strobe_g(
        self,
    ) -> crate::common::RegisterFieldBool<22, 1, 0, SeqProgramCtl2_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<22,1,0,SeqProgramCtl2_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "When set to 1 indicates that the Read cycle ends when the current cycle count reaches 0."]
    #[inline(always)]
    pub fn done(
        self,
    ) -> crate::common::RegisterFieldBool<31, 1, 0, SeqProgramCtl2_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<31,1,0,SeqProgramCtl2_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for SeqProgramCtl2 {
    #[inline(always)]
    fn default() -> SeqProgramCtl2 {
        <crate::RegValueT<SeqProgramCtl2_SPEC> as RegisterValue<_>>::new(2097153)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct SeqProgramCtl3_SPEC;
impl crate::sealed::RegSpec for SeqProgramCtl3_SPEC {
    type DataType = u32;
}

#[doc = "Sequencer program control 3"]
pub type SeqProgramCtl3 = crate::RegValueT<SeqProgramCtl3_SPEC>;

impl SeqProgramCtl3 {
    #[doc = "Number of IP clock cycles (minus 1). This field is in the range of \\[0, 1023\\], allowing for a time of \\[1, 1024\\] IP clock cycles."]
    #[inline(always)]
    pub fn cycles(
        self,
    ) -> crate::common::RegisterField<
        0,
        0x3ff,
        1,
        0,
        u16,
        u16,
        SeqProgramCtl3_SPEC,
        crate::common::RW,
    > {
        crate::common::RegisterField::<
            0,
            0x3ff,
            1,
            0,
            u16,
            u16,
            SeqProgramCtl3_SPEC,
            crate::common::RW,
        >::from_register(self, 0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_a"]
    #[inline(always)]
    pub fn strobe_a(
        self,
    ) -> crate::common::RegisterFieldBool<16, 1, 0, SeqProgramCtl3_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<16,1,0,SeqProgramCtl3_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSEcontrol signal strobe_b"]
    #[inline(always)]
    pub fn strobe_b(
        self,
    ) -> crate::common::RegisterFieldBool<17, 1, 0, SeqProgramCtl3_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<17,1,0,SeqProgramCtl3_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_c"]
    #[inline(always)]
    pub fn strobe_c(
        self,
    ) -> crate::common::RegisterFieldBool<18, 1, 0, SeqProgramCtl3_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<18,1,0,SeqProgramCtl3_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_d"]
    #[inline(always)]
    pub fn strobe_d(
        self,
    ) -> crate::common::RegisterFieldBool<19, 1, 0, SeqProgramCtl3_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<19,1,0,SeqProgramCtl3_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_e"]
    #[inline(always)]
    pub fn strobe_e(
        self,
    ) -> crate::common::RegisterFieldBool<20, 1, 0, SeqProgramCtl3_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<20,1,0,SeqProgramCtl3_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_f"]
    #[inline(always)]
    pub fn strobe_f(
        self,
    ) -> crate::common::RegisterFieldBool<21, 1, 0, SeqProgramCtl3_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<21,1,0,SeqProgramCtl3_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_g"]
    #[inline(always)]
    pub fn strobe_g(
        self,
    ) -> crate::common::RegisterFieldBool<22, 1, 0, SeqProgramCtl3_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<22,1,0,SeqProgramCtl3_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "When set to 1 indicates that the Read cycle ends when the current cycle count reaches 0."]
    #[inline(always)]
    pub fn done(
        self,
    ) -> crate::common::RegisterFieldBool<31, 1, 0, SeqProgramCtl3_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<31,1,0,SeqProgramCtl3_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for SeqProgramCtl3 {
    #[inline(always)]
    fn default() -> SeqProgramCtl3 {
        <crate::RegValueT<SeqProgramCtl3_SPEC> as RegisterValue<_>>::new(3211269)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct SeqProgramCtl4_SPEC;
impl crate::sealed::RegSpec for SeqProgramCtl4_SPEC {
    type DataType = u32;
}

#[doc = "Sequencer program control 4"]
pub type SeqProgramCtl4 = crate::RegValueT<SeqProgramCtl4_SPEC>;

impl SeqProgramCtl4 {
    #[doc = "Number of IP clock cycles (minus 1). This field is in the range of \\[0, 1023\\], allowing for a time of \\[1, 1024\\] IP clock cycles."]
    #[inline(always)]
    pub fn cycles(
        self,
    ) -> crate::common::RegisterField<
        0,
        0x3ff,
        1,
        0,
        u16,
        u16,
        SeqProgramCtl4_SPEC,
        crate::common::RW,
    > {
        crate::common::RegisterField::<
            0,
            0x3ff,
            1,
            0,
            u16,
            u16,
            SeqProgramCtl4_SPEC,
            crate::common::RW,
        >::from_register(self, 0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_a"]
    #[inline(always)]
    pub fn strobe_a(
        self,
    ) -> crate::common::RegisterFieldBool<16, 1, 0, SeqProgramCtl4_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<16,1,0,SeqProgramCtl4_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSEcontrol signal strobe_b"]
    #[inline(always)]
    pub fn strobe_b(
        self,
    ) -> crate::common::RegisterFieldBool<17, 1, 0, SeqProgramCtl4_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<17,1,0,SeqProgramCtl4_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_c"]
    #[inline(always)]
    pub fn strobe_c(
        self,
    ) -> crate::common::RegisterFieldBool<18, 1, 0, SeqProgramCtl4_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<18,1,0,SeqProgramCtl4_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_d"]
    #[inline(always)]
    pub fn strobe_d(
        self,
    ) -> crate::common::RegisterFieldBool<19, 1, 0, SeqProgramCtl4_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<19,1,0,SeqProgramCtl4_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_e"]
    #[inline(always)]
    pub fn strobe_e(
        self,
    ) -> crate::common::RegisterFieldBool<20, 1, 0, SeqProgramCtl4_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<20,1,0,SeqProgramCtl4_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_f"]
    #[inline(always)]
    pub fn strobe_f(
        self,
    ) -> crate::common::RegisterFieldBool<21, 1, 0, SeqProgramCtl4_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<21,1,0,SeqProgramCtl4_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_g"]
    #[inline(always)]
    pub fn strobe_g(
        self,
    ) -> crate::common::RegisterFieldBool<22, 1, 0, SeqProgramCtl4_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<22,1,0,SeqProgramCtl4_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "When set to 1 indicates that the Read cycle ends when the current cycle count reaches 0."]
    #[inline(always)]
    pub fn done(
        self,
    ) -> crate::common::RegisterFieldBool<31, 1, 0, SeqProgramCtl4_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<31,1,0,SeqProgramCtl4_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for SeqProgramCtl4 {
    #[inline(always)]
    fn default() -> SeqProgramCtl4 {
        <crate::RegValueT<SeqProgramCtl4_SPEC> as RegisterValue<_>>::new(2150957062)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct SeqProgramCtl5_SPEC;
impl crate::sealed::RegSpec for SeqProgramCtl5_SPEC {
    type DataType = u32;
}

#[doc = "Sequencer program control 5"]
pub type SeqProgramCtl5 = crate::RegValueT<SeqProgramCtl5_SPEC>;

impl SeqProgramCtl5 {
    #[doc = "Number of IP clock cycles (minus 1). This field is in the range of \\[0, 1023\\], allowing for a time of \\[1, 1024\\] IP clock cycles."]
    #[inline(always)]
    pub fn cycles(
        self,
    ) -> crate::common::RegisterField<
        0,
        0x3ff,
        1,
        0,
        u16,
        u16,
        SeqProgramCtl5_SPEC,
        crate::common::RW,
    > {
        crate::common::RegisterField::<
            0,
            0x3ff,
            1,
            0,
            u16,
            u16,
            SeqProgramCtl5_SPEC,
            crate::common::RW,
        >::from_register(self, 0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_a"]
    #[inline(always)]
    pub fn strobe_a(
        self,
    ) -> crate::common::RegisterFieldBool<16, 1, 0, SeqProgramCtl5_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<16,1,0,SeqProgramCtl5_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSEcontrol signal strobe_b"]
    #[inline(always)]
    pub fn strobe_b(
        self,
    ) -> crate::common::RegisterFieldBool<17, 1, 0, SeqProgramCtl5_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<17,1,0,SeqProgramCtl5_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_c"]
    #[inline(always)]
    pub fn strobe_c(
        self,
    ) -> crate::common::RegisterFieldBool<18, 1, 0, SeqProgramCtl5_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<18,1,0,SeqProgramCtl5_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_d"]
    #[inline(always)]
    pub fn strobe_d(
        self,
    ) -> crate::common::RegisterFieldBool<19, 1, 0, SeqProgramCtl5_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<19,1,0,SeqProgramCtl5_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_e"]
    #[inline(always)]
    pub fn strobe_e(
        self,
    ) -> crate::common::RegisterFieldBool<20, 1, 0, SeqProgramCtl5_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<20,1,0,SeqProgramCtl5_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_f"]
    #[inline(always)]
    pub fn strobe_f(
        self,
    ) -> crate::common::RegisterFieldBool<21, 1, 0, SeqProgramCtl5_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<21,1,0,SeqProgramCtl5_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Specifies value of eFUSE control signal strobe_g"]
    #[inline(always)]
    pub fn strobe_g(
        self,
    ) -> crate::common::RegisterFieldBool<22, 1, 0, SeqProgramCtl5_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<22,1,0,SeqProgramCtl5_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "When set to 1 indicates that the Read cycle ends when the current cycle count reaches 0."]
    #[inline(always)]
    pub fn done(
        self,
    ) -> crate::common::RegisterFieldBool<31, 1, 0, SeqProgramCtl5_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<31,1,0,SeqProgramCtl5_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for SeqProgramCtl5 {
    #[inline(always)]
    fn default() -> SeqProgramCtl5 {
        <crate::RegValueT<SeqProgramCtl5_SPEC> as RegisterValue<_>>::new(2151481369)
    }
}