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"Fault structures"]
unsafe impl ::core::marker::Send for super::Fault {}
unsafe impl ::core::marker::Sync for super::Fault {}
impl super::Fault {
    #[allow(unused)]
    #[inline(always)]
    pub(crate) const fn _svd2pac_as_ptr(&self) -> *mut u8 {
        self.ptr
    }
    #[doc = "Fault structure"]
    #[inline(always)]
    pub fn r#struct(
        self,
    ) -> &'static crate::common::ClusterRegisterArray<crate::fault::_Struct, 2, 0x100> {
        unsafe {
            crate::common::ClusterRegisterArray::from_ptr(self._svd2pac_as_ptr().add(0x0usize))
        }
    }
}

#[doc = "Fault structure"]
#[non_exhaustive]
pub struct _Struct;

#[doc = "Fault structure"]
pub type Struct = &'static _Struct;

unsafe impl ::core::marker::Sync for _Struct {}
impl _Struct {
    #[allow(unused)]
    #[inline(always)]
    pub(crate) const unsafe fn _svd2pac_from_ptr(ptr: *mut u8) -> &'static Self {
        &*(ptr as *const _)
    }

    #[allow(unused)]
    #[inline(always)]
    pub(crate) const fn _svd2pac_as_ptr(&self) -> *mut u8 {
        self as *const Self as *mut u8
    }

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

    #[doc = "Fault status"]
    #[inline(always)]
    pub const fn status(
        &self,
    ) -> &'static crate::common::Reg<r#struct::Status_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<r#struct::Status_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(12usize),
            )
        }
    }

    #[doc = "Fault data"]
    #[inline(always)]
    pub const fn data(
        &self,
    ) -> &'static crate::common::ClusterRegisterArray<
        crate::common::Reg<r#struct::Data_SPEC, crate::common::R>,
        4,
        0x4,
    > {
        unsafe {
            crate::common::ClusterRegisterArray::from_ptr(self._svd2pac_as_ptr().add(0x10usize))
        }
    }

    #[doc = "Fault pending 0"]
    #[inline(always)]
    pub const fn pending0(
        &self,
    ) -> &'static crate::common::Reg<r#struct::Pending0_SPEC, crate::common::R> {
        unsafe {
            crate::common::Reg::<r#struct::Pending0_SPEC, crate::common::R>::from_ptr(
                self._svd2pac_as_ptr().add(64usize),
            )
        }
    }

    #[doc = "Fault pending 1"]
    #[inline(always)]
    pub const fn pending1(
        &self,
    ) -> &'static crate::common::Reg<r#struct::Pending1_SPEC, crate::common::R> {
        unsafe {
            crate::common::Reg::<r#struct::Pending1_SPEC, crate::common::R>::from_ptr(
                self._svd2pac_as_ptr().add(68usize),
            )
        }
    }

    #[doc = "Fault pending 2"]
    #[inline(always)]
    pub const fn pending2(
        &self,
    ) -> &'static crate::common::Reg<r#struct::Pending2_SPEC, crate::common::R> {
        unsafe {
            crate::common::Reg::<r#struct::Pending2_SPEC, crate::common::R>::from_ptr(
                self._svd2pac_as_ptr().add(72usize),
            )
        }
    }

    #[doc = "Fault mask 0"]
    #[inline(always)]
    pub const fn mask0(
        &self,
    ) -> &'static crate::common::Reg<r#struct::Mask0_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<r#struct::Mask0_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(80usize),
            )
        }
    }

    #[doc = "Fault mask 1"]
    #[inline(always)]
    pub const fn mask1(
        &self,
    ) -> &'static crate::common::Reg<r#struct::Mask1_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<r#struct::Mask1_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(84usize),
            )
        }
    }

    #[doc = "Fault mask 2"]
    #[inline(always)]
    pub const fn mask2(
        &self,
    ) -> &'static crate::common::Reg<r#struct::Mask2_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<r#struct::Mask2_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(88usize),
            )
        }
    }

    #[doc = "Interrupt"]
    #[inline(always)]
    pub const fn intr(
        &self,
    ) -> &'static crate::common::Reg<r#struct::Intr_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<r#struct::Intr_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(192usize),
            )
        }
    }

    #[doc = "Interrupt set"]
    #[inline(always)]
    pub const fn intr_set(
        &self,
    ) -> &'static crate::common::Reg<r#struct::IntrSet_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<r#struct::IntrSet_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(196usize),
            )
        }
    }

    #[doc = "Interrupt mask"]
    #[inline(always)]
    pub const fn intr_mask(
        &self,
    ) -> &'static crate::common::Reg<r#struct::IntrMask_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<r#struct::IntrMask_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(200usize),
            )
        }
    }

    #[doc = "Interrupt masked"]
    #[inline(always)]
    pub const fn intr_masked(
        &self,
    ) -> &'static crate::common::Reg<r#struct::IntrMasked_SPEC, crate::common::R> {
        unsafe {
            crate::common::Reg::<r#struct::IntrMasked_SPEC, crate::common::R>::from_ptr(
                self._svd2pac_as_ptr().add(204usize),
            )
        }
    }
}
pub mod r#struct {
    #[allow(unused_imports)]
    use crate::common::*;
    #[doc(hidden)]
    #[derive(Copy, Clone, Eq, PartialEq)]
    pub struct Ctl_SPEC;
    impl crate::sealed::RegSpec for Ctl_SPEC {
        type DataType = u32;
    }

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

    impl Ctl {
        #[doc = "Trigger output enable:\n\'0\': Disabled. The trigger output \'tr_fault\' is \'0\'.\n\'1\': Enabled. The trigger output \'tr_fault\' reflects STATUS.VALID. The trigger can be used to initiate a Datawire transfer of the FAULT data (FAULT_DATA0 through FAULT_DATA3)."]
        #[inline(always)]
        pub fn tr_en(
            self,
        ) -> crate::common::RegisterFieldBool<0, 1, 0, Ctl_SPEC, crate::common::RW> {
            crate::common::RegisterFieldBool::<0, 1, 0, Ctl_SPEC, crate::common::RW>::from_register(
                self, 0,
            )
        }

        #[doc = "IO output signal enable:\n\'0\': Disabled. The IO output signal \'fault_out\' is \'0\'. The IO output enable signal \'fault_out_en\' is \'0\'.\n\'1\': Enabled. The IO output signal \'fault_out\' reflects STATUS.VALID. The IO output enable signal \'fault_out_en\' is \'1\'."]
        #[inline(always)]
        pub fn out_en(
            self,
        ) -> crate::common::RegisterFieldBool<1, 1, 0, Ctl_SPEC, crate::common::RW> {
            crate::common::RegisterFieldBool::<1, 1, 0, Ctl_SPEC, crate::common::RW>::from_register(
                self, 0,
            )
        }

        #[doc = "Reset request enable:\n\'0\': Disabled.\n\'1\': Enabled. The output reset request signal \'fault_reset_req\' reflects STATUS.VALID. This reset causes a warm/soft/core reset. This warm/soft/core reset does not affect the fault logic STATUS, DATA0, ..., DATA3 registers (allowing for post soft reset failure analysis).\n\nThe \'fault_reset_req\' signals of the individual fault report structures are combined (logically OR\'d) into a single SRSS \'fault_reset_req\' signal."]
        #[inline(always)]
        pub fn reset_req_en(
            self,
        ) -> crate::common::RegisterFieldBool<2, 1, 0, Ctl_SPEC, crate::common::RW> {
            crate::common::RegisterFieldBool::<2, 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 Status_SPEC;
    impl crate::sealed::RegSpec for Status_SPEC {
        type DataType = u32;
    }

    #[doc = "Fault status"]
    pub type Status = crate::RegValueT<Status_SPEC>;

    impl Status {
        #[doc = "The fault source index for which fault information is captured in DATA0 through DATA3. The fault information is fault source specific and described below.\n\nNote: this register field (and associated fault source data in DATA0 through DATA3) should only be considered valid, when VALID is \'1\'."]
        #[inline(always)]
        pub fn idx(
            self,
        ) -> crate::common::RegisterField<0, 0x7f, 1, 0, u8, u8, Status_SPEC, crate::common::R>
        {
            crate::common::RegisterField::<0,0x7f,1,0,u8,u8,Status_SPEC,crate::common::R>::from_register(self,0)
        }

        #[doc = "Valid indication:\n\'0\': Invalid.\n\'1\': Valid. HW sets this field to \'1\' when new fault source data is captured. New fault source data is ONLY captured when VALID is \'0\'. SW can clear this field to \'0\' when the fault is handled (by SW)."]
        #[inline(always)]
        pub fn valid(
            self,
        ) -> crate::common::RegisterFieldBool<31, 1, 0, Status_SPEC, crate::common::RW> {
            crate::common::RegisterFieldBool::<31,1,0,Status_SPEC,crate::common::RW>::from_register(self,0)
        }
    }
    impl ::core::default::Default for Status {
        #[inline(always)]
        fn default() -> Status {
            <crate::RegValueT<Status_SPEC> as RegisterValue<_>>::new(0)
        }
    }

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

    #[doc = "Fault data"]
    pub type Data = crate::RegValueT<Data_SPEC>;

    impl Data {
        #[doc = "Captured fault source data. \n\nNote: the fault source index STATUS.IDX specifies the format of the DATA registers."]
        #[inline(always)]
        pub fn data(
            self,
        ) -> crate::common::RegisterField<0, 0xffffffff, 1, 0, u32, u32, Data_SPEC, crate::common::R>
        {
            crate::common::RegisterField::<0,0xffffffff,1,0,u32,u32,Data_SPEC,crate::common::R>::from_register(self,0)
        }
    }
    impl ::core::default::Default for Data {
        #[inline(always)]
        fn default() -> Data {
            <crate::RegValueT<Data_SPEC> as RegisterValue<_>>::new(0)
        }
    }

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

    #[doc = "Fault pending 0"]
    pub type Pending0 = crate::RegValueT<Pending0_SPEC>;

    impl Pending0 {
        #[doc = "This field specifies the following sources:\nBit 0: CM0 MPU.\nBit 1: CRYPTO MPU.\nBit 2: DW 0 MPU.\nBit 3: DW 1 MPU.\n...\nBit 14: CM4 code bus MPU.\nBit 15: DAP MPU.\nBit 16: CM4 s+G92ystem bus MPU.\n\n\nBit 28: Peripheral master interface 0 PPU. \nBit 29: Peripheral master interface 1 PPU. \nBit 30: Peripheral master interface 2 PPU. \nBit 31: Peripheral master interface 3 PPU."]
        #[inline(always)]
        pub fn source(
            self,
        ) -> crate::common::RegisterField<
            0,
            0xffffffff,
            1,
            0,
            u32,
            u32,
            Pending0_SPEC,
            crate::common::R,
        > {
            crate::common::RegisterField::<
                0,
                0xffffffff,
                1,
                0,
                u32,
                u32,
                Pending0_SPEC,
                crate::common::R,
            >::from_register(self, 0)
        }
    }
    impl ::core::default::Default for Pending0 {
        #[inline(always)]
        fn default() -> Pending0 {
            <crate::RegValueT<Pending0_SPEC> as RegisterValue<_>>::new(0)
        }
    }

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

    #[doc = "Fault pending 1"]
    pub type Pending1 = crate::RegValueT<Pending1_SPEC>;

    impl Pending1 {
        #[doc = "This field specifies the following sources:\nBit 0: Peripheral group 0 PPU.\nBit 1: Peripheral group 1 PPU.\nBit 2: Peripheral group 2 PPU.\nBit 3: Peripheral group 3 PPU.\nBit 4: Peripheral group 4 PPU.\nBit 5: Peripheral group 5 PPU.\nBit 6: Peripheral group 6 PPU.\nBit 7: Peripheral group 7 PPU.\n...\nBit 15: Peripheral group 15 PPU.\n\nBit 18: Flash controller, main interface, bus error."]
        #[inline(always)]
        pub fn source(
            self,
        ) -> crate::common::RegisterField<
            0,
            0xffffffff,
            1,
            0,
            u32,
            u32,
            Pending1_SPEC,
            crate::common::R,
        > {
            crate::common::RegisterField::<
                0,
                0xffffffff,
                1,
                0,
                u32,
                u32,
                Pending1_SPEC,
                crate::common::R,
            >::from_register(self, 0)
        }
    }
    impl ::core::default::Default for Pending1 {
        #[inline(always)]
        fn default() -> Pending1 {
            <crate::RegValueT<Pending1_SPEC> as RegisterValue<_>>::new(0)
        }
    }

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

    #[doc = "Fault pending 2"]
    pub type Pending2 = crate::RegValueT<Pending2_SPEC>;

    impl Pending2 {
        #[doc = "This field specifies the following sources:\nBit 0 - 31: TBD."]
        #[inline(always)]
        pub fn source(
            self,
        ) -> crate::common::RegisterField<
            0,
            0xffffffff,
            1,
            0,
            u32,
            u32,
            Pending2_SPEC,
            crate::common::R,
        > {
            crate::common::RegisterField::<
                0,
                0xffffffff,
                1,
                0,
                u32,
                u32,
                Pending2_SPEC,
                crate::common::R,
            >::from_register(self, 0)
        }
    }
    impl ::core::default::Default for Pending2 {
        #[inline(always)]
        fn default() -> Pending2 {
            <crate::RegValueT<Pending2_SPEC> as RegisterValue<_>>::new(0)
        }
    }

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

    #[doc = "Fault mask 0"]
    pub type Mask0 = crate::RegValueT<Mask0_SPEC>;

    impl Mask0 {
        #[doc = "Fault source enables:\nBits 31-0: Fault sources 31 to 0."]
        #[inline(always)]
        pub fn source(
            self,
        ) -> crate::common::RegisterField<
            0,
            0xffffffff,
            1,
            0,
            u32,
            u32,
            Mask0_SPEC,
            crate::common::RW,
        > {
            crate::common::RegisterField::<
                0,
                0xffffffff,
                1,
                0,
                u32,
                u32,
                Mask0_SPEC,
                crate::common::RW,
            >::from_register(self, 0)
        }
    }
    impl ::core::default::Default for Mask0 {
        #[inline(always)]
        fn default() -> Mask0 {
            <crate::RegValueT<Mask0_SPEC> as RegisterValue<_>>::new(0)
        }
    }

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

    #[doc = "Fault mask 1"]
    pub type Mask1 = crate::RegValueT<Mask1_SPEC>;

    impl Mask1 {
        #[doc = "Fault source enables:\nBits 31-0: Fault sources 63 to 32."]
        #[inline(always)]
        pub fn source(
            self,
        ) -> crate::common::RegisterField<
            0,
            0xffffffff,
            1,
            0,
            u32,
            u32,
            Mask1_SPEC,
            crate::common::RW,
        > {
            crate::common::RegisterField::<
                0,
                0xffffffff,
                1,
                0,
                u32,
                u32,
                Mask1_SPEC,
                crate::common::RW,
            >::from_register(self, 0)
        }
    }
    impl ::core::default::Default for Mask1 {
        #[inline(always)]
        fn default() -> Mask1 {
            <crate::RegValueT<Mask1_SPEC> as RegisterValue<_>>::new(0)
        }
    }

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

    #[doc = "Fault mask 2"]
    pub type Mask2 = crate::RegValueT<Mask2_SPEC>;

    impl Mask2 {
        #[doc = "Fault source enables:\nBits 31-0: Fault sources 95 to 64."]
        #[inline(always)]
        pub fn source(
            self,
        ) -> crate::common::RegisterField<
            0,
            0xffffffff,
            1,
            0,
            u32,
            u32,
            Mask2_SPEC,
            crate::common::RW,
        > {
            crate::common::RegisterField::<
                0,
                0xffffffff,
                1,
                0,
                u32,
                u32,
                Mask2_SPEC,
                crate::common::RW,
            >::from_register(self, 0)
        }
    }
    impl ::core::default::Default for Mask2 {
        #[inline(always)]
        fn default() -> Mask2 {
            <crate::RegValueT<Mask2_SPEC> as RegisterValue<_>>::new(0)
        }
    }

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

    #[doc = "Interrupt"]
    pub type Intr = crate::RegValueT<Intr_SPEC>;

    impl Intr {
        #[doc = "This interrupt cause field is activated (HW sets the field to \'1\') when an enabled (MASK0/MASK1/MASK2) pending fault source is captured:\n- STATUS.VALID is set to \'1\'.\n- STATUS.IDX specifies the fault source index.\n- DATA0 through DATA3 captures the fault source data.\n\nSW writes a \'1\' to these field to clear the interrupt cause to \'0\'."]
        #[inline(always)]
        pub fn fault(
            self,
        ) -> crate::common::RegisterFieldBool<0, 1, 0, Intr_SPEC, crate::common::RW> {
            crate::common::RegisterFieldBool::<0, 1, 0, Intr_SPEC, crate::common::RW>::from_register(
                self, 0,
            )
        }
    }
    impl ::core::default::Default for Intr {
        #[inline(always)]
        fn default() -> Intr {
            <crate::RegValueT<Intr_SPEC> as RegisterValue<_>>::new(0)
        }
    }

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

    #[doc = "Interrupt set"]
    pub type IntrSet = crate::RegValueT<IntrSet_SPEC>;

    impl IntrSet {
        #[doc = "SW writes a \'1\' to this field to set the corresponding field in the INTR register."]
        #[inline(always)]
        pub fn fault(
            self,
        ) -> crate::common::RegisterFieldBool<0, 1, 0, IntrSet_SPEC, crate::common::RW> {
            crate::common::RegisterFieldBool::<0,1,0,IntrSet_SPEC,crate::common::RW>::from_register(self,0)
        }
    }
    impl ::core::default::Default for IntrSet {
        #[inline(always)]
        fn default() -> IntrSet {
            <crate::RegValueT<IntrSet_SPEC> as RegisterValue<_>>::new(0)
        }
    }

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

    #[doc = "Interrupt mask"]
    pub type IntrMask = crate::RegValueT<IntrMask_SPEC>;

    impl IntrMask {
        #[doc = "Mask bit for corresponding field in the INTR register."]
        #[inline(always)]
        pub fn fault(
            self,
        ) -> crate::common::RegisterFieldBool<0, 1, 0, IntrMask_SPEC, crate::common::RW> {
            crate::common::RegisterFieldBool::<0,1,0,IntrMask_SPEC,crate::common::RW>::from_register(self,0)
        }
    }
    impl ::core::default::Default for IntrMask {
        #[inline(always)]
        fn default() -> IntrMask {
            <crate::RegValueT<IntrMask_SPEC> as RegisterValue<_>>::new(0)
        }
    }

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

    #[doc = "Interrupt masked"]
    pub type IntrMasked = crate::RegValueT<IntrMasked_SPEC>;

    impl IntrMasked {
        #[doc = "Logical and of corresponding INTR and INTR_MASK fields."]
        #[inline(always)]
        pub fn fault(
            self,
        ) -> crate::common::RegisterFieldBool<0, 1, 0, IntrMasked_SPEC, crate::common::R> {
            crate::common::RegisterFieldBool::<0,1,0,IntrMasked_SPEC,crate::common::R>::from_register(self,0)
        }
    }
    impl ::core::default::Default for IntrMasked {
        #[inline(always)]
        fn default() -> IntrMasked {
            <crate::RegValueT<IntrMasked_SPEC> as RegisterValue<_>>::new(0)
        }
    }
}