Init Commit

Monorepo for Rust support of VA416XX family of radiation hardened MCUs

va416xx/src/adc.rs

@@ -0,0 +1,127 @@
+#[repr(C)]
+#[doc = "Register block"]
+pub struct RegisterBlock {
+    ctrl: Ctrl,
+    fifo_data: FifoData,
+    status: Status,
+    irq_enb: IrqEnb,
+    irq_raw: IrqRaw,
+    irq_end: IrqEnd,
+    irq_clr: IrqClr,
+    rxfifoirqtrg: Rxfifoirqtrg,
+    fifo_clr: FifoClr,
+    _reserved9: [u8; 0x0fd8],
+    perid: Perid,
+}
+impl RegisterBlock {
+    #[doc = "0x00 - Control Register"]
+    #[inline(always)]
+    pub const fn ctrl(&self) -> &Ctrl {
+        &self.ctrl
+    }
+    #[doc = "0x04 - FIFO data"]
+    #[inline(always)]
+    pub const fn fifo_data(&self) -> &FifoData {
+        &self.fifo_data
+    }
+    #[doc = "0x08 - Status"]
+    #[inline(always)]
+    pub const fn status(&self) -> &Status {
+        &self.status
+    }
+    #[doc = "0x0c - Interrupt Enable"]
+    #[inline(always)]
+    pub const fn irq_enb(&self) -> &IrqEnb {
+        &self.irq_enb
+    }
+    #[doc = "0x10 - Raw Interrupt Status"]
+    #[inline(always)]
+    pub const fn irq_raw(&self) -> &IrqRaw {
+        &self.irq_raw
+    }
+    #[doc = "0x14 - Enabled Interrupt Status"]
+    #[inline(always)]
+    pub const fn irq_end(&self) -> &IrqEnd {
+        &self.irq_end
+    }
+    #[doc = "0x18 - Clear Interrupt"]
+    #[inline(always)]
+    pub const fn irq_clr(&self) -> &IrqClr {
+        &self.irq_clr
+    }
+    #[doc = "0x1c - Receive FIFO Interrupt Trigger Value"]
+    #[inline(always)]
+    pub const fn rxfifoirqtrg(&self) -> &Rxfifoirqtrg {
+        &self.rxfifoirqtrg
+    }
+    #[doc = "0x20 - FIFO Clear"]
+    #[inline(always)]
+    pub const fn fifo_clr(&self) -> &FifoClr {
+        &self.fifo_clr
+    }
+    #[doc = "0xffc - Peripheral ID Register"]
+    #[inline(always)]
+    pub const fn perid(&self) -> &Perid {
+        &self.perid
+    }
+}
+#[doc = "CTRL (rw) register accessor: Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`ctrl::R`].  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`ctrl::W`]. You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [`mod@ctrl`]
+module"]
+#[doc(alias = "CTRL")]
+pub type Ctrl = crate::Reg<ctrl::CtrlSpec>;
+#[doc = "Control Register"]
+pub mod ctrl;
+#[doc = "FIFO_DATA (r) register accessor: FIFO data\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`fifo_data::R`].  See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [`mod@fifo_data`]
+module"]
+#[doc(alias = "FIFO_DATA")]
+pub type FifoData = crate::Reg<fifo_data::FifoDataSpec>;
+#[doc = "FIFO data"]
+pub mod fifo_data;
+#[doc = "STATUS (r) register accessor: Status\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`status::R`].  See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [`mod@status`]
+module"]
+#[doc(alias = "STATUS")]
+pub type Status = crate::Reg<status::StatusSpec>;
+#[doc = "Status"]
+pub mod status;
+#[doc = "IRQ_ENB (rw) register accessor: Interrupt Enable\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`irq_enb::R`].  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`irq_enb::W`]. You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [`mod@irq_enb`]
+module"]
+#[doc(alias = "IRQ_ENB")]
+pub type IrqEnb = crate::Reg<irq_enb::IrqEnbSpec>;
+#[doc = "Interrupt Enable"]
+pub mod irq_enb;
+#[doc = "IRQ_RAW (r) register accessor: Raw Interrupt Status\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`irq_raw::R`].  See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [`mod@irq_raw`]
+module"]
+#[doc(alias = "IRQ_RAW")]
+pub type IrqRaw = crate::Reg<irq_raw::IrqRawSpec>;
+#[doc = "Raw Interrupt Status"]
+pub mod irq_raw;
+#[doc = "IRQ_END (r) register accessor: Enabled Interrupt Status\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`irq_end::R`].  See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [`mod@irq_end`]
+module"]
+#[doc(alias = "IRQ_END")]
+pub type IrqEnd = crate::Reg<irq_end::IrqEndSpec>;
+#[doc = "Enabled Interrupt Status"]
+pub mod irq_end;
+#[doc = "IRQ_CLR (w) register accessor: Clear Interrupt\n\nYou can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`irq_clr::W`]. See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [`mod@irq_clr`]
+module"]
+#[doc(alias = "IRQ_CLR")]
+pub type IrqClr = crate::Reg<irq_clr::IrqClrSpec>;
+#[doc = "Clear Interrupt"]
+pub mod irq_clr;
+#[doc = "RXFIFOIRQTRG (rw) register accessor: Receive FIFO Interrupt Trigger Value\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`rxfifoirqtrg::R`].  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`rxfifoirqtrg::W`]. You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [`mod@rxfifoirqtrg`]
+module"]
+#[doc(alias = "RXFIFOIRQTRG")]
+pub type Rxfifoirqtrg = crate::Reg<rxfifoirqtrg::RxfifoirqtrgSpec>;
+#[doc = "Receive FIFO Interrupt Trigger Value"]
+pub mod rxfifoirqtrg;
+#[doc = "FIFO_CLR (rw) register accessor: FIFO Clear\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`fifo_clr::R`].  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`fifo_clr::W`]. You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [`mod@fifo_clr`]
+module"]
+#[doc(alias = "FIFO_CLR")]
+pub type FifoClr = crate::Reg<fifo_clr::FifoClrSpec>;
+#[doc = "FIFO Clear"]
+pub mod fifo_clr;
+#[doc = "PERID (r) register accessor: Peripheral ID Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`perid::R`].  See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [`mod@perid`]
+module"]
+#[doc(alias = "PERID")]
+pub type Perid = crate::Reg<perid::PeridSpec>;
+#[doc = "Peripheral ID Register"]
+pub mod perid;

va416xx/src/adc/ctrl.rs

@@ -0,0 +1,115 @@
+#[doc = "Register `CTRL` reader"]
+pub type R = crate::R<CtrlSpec>;
+#[doc = "Register `CTRL` writer"]
+pub type W = crate::W<CtrlSpec>;
+#[doc = "Field `CHAN_EN` reader - Enables the channel for data collection"]
+pub type ChanEnR = crate::FieldReader<u16>;
+#[doc = "Field `CHAN_EN` writer - Enables the channel for data collection"]
+pub type ChanEnW<'a, REG> = crate::FieldWriter<'a, REG, 16, u16>;
+#[doc = "Field `CHAN_TAG_EN` reader - Enables the channel tag to be saved with the ADC data"]
+pub type ChanTagEnR = crate::BitReader;
+#[doc = "Field `CHAN_TAG_EN` writer - Enables the channel tag to be saved with the ADC data"]
+pub type ChanTagEnW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `SWEEP_EN` reader - ADC data acquisition for all enabled channel"]
+pub type SweepEnR = crate::BitReader;
+#[doc = "Field `SWEEP_EN` writer - ADC data acquisition for all enabled channel"]
+pub type SweepEnW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `EXT_TRIG_EN` reader - Allows the external trigger to start analog acquisition"]
+pub type ExtTrigEnR = crate::BitReader;
+#[doc = "Field `EXT_TRIG_EN` writer - Allows the external trigger to start analog acquisition"]
+pub type ExtTrigEnW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `MANUAL_TRIG` reader - Starts analog acquisition"]
+pub type ManualTrigR = crate::BitReader;
+#[doc = "Field `MANUAL_TRIG` writer - Starts analog acquisition"]
+pub type ManualTrigW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `CONV_CNT` reader - Conversion count describes the number of conversions to be applied for triggers/sweeps. (N+1 conversions)"]
+pub type ConvCntR = crate::FieldReader;
+#[doc = "Field `CONV_CNT` writer - Conversion count describes the number of conversions to be applied for triggers/sweeps. (N+1 conversions)"]
+pub type ConvCntW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+impl R {
+    #[doc = "Bits 0:15 - Enables the channel for data collection"]
+    #[inline(always)]
+    pub fn chan_en(&self) -> ChanEnR {
+        ChanEnR::new((self.bits & 0xffff) as u16)
+    }
+    #[doc = "Bit 16 - Enables the channel tag to be saved with the ADC data"]
+    #[inline(always)]
+    pub fn chan_tag_en(&self) -> ChanTagEnR {
+        ChanTagEnR::new(((self.bits >> 16) & 1) != 0)
+    }
+    #[doc = "Bit 17 - ADC data acquisition for all enabled channel"]
+    #[inline(always)]
+    pub fn sweep_en(&self) -> SweepEnR {
+        SweepEnR::new(((self.bits >> 17) & 1) != 0)
+    }
+    #[doc = "Bit 18 - Allows the external trigger to start analog acquisition"]
+    #[inline(always)]
+    pub fn ext_trig_en(&self) -> ExtTrigEnR {
+        ExtTrigEnR::new(((self.bits >> 18) & 1) != 0)
+    }
+    #[doc = "Bit 19 - Starts analog acquisition"]
+    #[inline(always)]
+    pub fn manual_trig(&self) -> ManualTrigR {
+        ManualTrigR::new(((self.bits >> 19) & 1) != 0)
+    }
+    #[doc = "Bits 20:23 - Conversion count describes the number of conversions to be applied for triggers/sweeps. (N+1 conversions)"]
+    #[inline(always)]
+    pub fn conv_cnt(&self) -> ConvCntR {
+        ConvCntR::new(((self.bits >> 20) & 0x0f) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:15 - Enables the channel for data collection"]
+    #[inline(always)]
+    #[must_use]
+    pub fn chan_en(&mut self) -> ChanEnW<CtrlSpec> {
+        ChanEnW::new(self, 0)
+    }
+    #[doc = "Bit 16 - Enables the channel tag to be saved with the ADC data"]
+    #[inline(always)]
+    #[must_use]
+    pub fn chan_tag_en(&mut self) -> ChanTagEnW<CtrlSpec> {
+        ChanTagEnW::new(self, 16)
+    }
+    #[doc = "Bit 17 - ADC data acquisition for all enabled channel"]
+    #[inline(always)]
+    #[must_use]
+    pub fn sweep_en(&mut self) -> SweepEnW<CtrlSpec> {
+        SweepEnW::new(self, 17)
+    }
+    #[doc = "Bit 18 - Allows the external trigger to start analog acquisition"]
+    #[inline(always)]
+    #[must_use]
+    pub fn ext_trig_en(&mut self) -> ExtTrigEnW<CtrlSpec> {
+        ExtTrigEnW::new(self, 18)
+    }
+    #[doc = "Bit 19 - Starts analog acquisition"]
+    #[inline(always)]
+    #[must_use]
+    pub fn manual_trig(&mut self) -> ManualTrigW<CtrlSpec> {
+        ManualTrigW::new(self, 19)
+    }
+    #[doc = "Bits 20:23 - Conversion count describes the number of conversions to be applied for triggers/sweeps. (N+1 conversions)"]
+    #[inline(always)]
+    #[must_use]
+    pub fn conv_cnt(&mut self) -> ConvCntW<CtrlSpec> {
+        ConvCntW::new(self, 20)
+    }
+}
+#[doc = "Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`ctrl::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`ctrl::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CtrlSpec;
+impl crate::RegisterSpec for CtrlSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`ctrl::R`](R) reader structure"]
+impl crate::Readable for CtrlSpec {}
+#[doc = "`write(|w| ..)` method takes [`ctrl::W`](W) writer structure"]
+impl crate::Writable for CtrlSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CTRL to value 0"]
+impl crate::Resettable for CtrlSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/adc/fifo_clr.rs

@@ -0,0 +1,31 @@
+#[doc = "Register `FIFO_CLR` reader"]
+pub type R = crate::R<FifoClrSpec>;
+#[doc = "Register `FIFO_CLR` writer"]
+pub type W = crate::W<FifoClrSpec>;
+#[doc = "Field `FIFO_CLR` writer - Clears the ADC FIFO. Always reads 0"]
+pub type FifoClrW<'a, REG> = crate::BitWriter<'a, REG>;
+impl W {
+    #[doc = "Bit 0 - Clears the ADC FIFO. Always reads 0"]
+    #[inline(always)]
+    #[must_use]
+    pub fn fifo_clr(&mut self) -> FifoClrW<FifoClrSpec> {
+        FifoClrW::new(self, 0)
+    }
+}
+#[doc = "FIFO Clear\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`fifo_clr::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`fifo_clr::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct FifoClrSpec;
+impl crate::RegisterSpec for FifoClrSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`fifo_clr::R`](R) reader structure"]
+impl crate::Readable for FifoClrSpec {}
+#[doc = "`write(|w| ..)` method takes [`fifo_clr::W`](W) writer structure"]
+impl crate::Writable for FifoClrSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets FIFO_CLR to value 0"]
+impl crate::Resettable for FifoClrSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/adc/fifo_data.rs

@@ -0,0 +1,29 @@
+#[doc = "Register `FIFO_DATA` reader"]
+pub type R = crate::R<FifoDataSpec>;
+#[doc = "Field `ADC_DATA` reader - ADC acquisition data from the FIFO"]
+pub type AdcDataR = crate::FieldReader<u16>;
+#[doc = "Field `CHAN_TAG` reader - If enabled, this will include the number of the channel corresponding to the measurement"]
+pub type ChanTagR = crate::FieldReader;
+impl R {
+    #[doc = "Bits 0:11 - ADC acquisition data from the FIFO"]
+    #[inline(always)]
+    pub fn adc_data(&self) -> AdcDataR {
+        AdcDataR::new((self.bits & 0x0fff) as u16)
+    }
+    #[doc = "Bits 12:15 - If enabled, this will include the number of the channel corresponding to the measurement"]
+    #[inline(always)]
+    pub fn chan_tag(&self) -> ChanTagR {
+        ChanTagR::new(((self.bits >> 12) & 0x0f) as u8)
+    }
+}
+#[doc = "FIFO data\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`fifo_data::R`](R).  See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct FifoDataSpec;
+impl crate::RegisterSpec for FifoDataSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`fifo_data::R`](R) reader structure"]
+impl crate::Readable for FifoDataSpec {}
+#[doc = "`reset()` method sets FIFO_DATA to value 0"]
+impl crate::Resettable for FifoDataSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/adc/irq_clr.rs

@@ -0,0 +1,51 @@
+#[doc = "Register `IRQ_CLR` writer"]
+pub type W = crate::W<IrqClrSpec>;
+#[doc = "Field `FIFO_OFLOW` writer - Clears the FIFO overflow interrupt status. Always reads 0"]
+pub type FifoOflowW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `FIFO_UFLOW` writer - Clears the FIFO underflow interrupt status. Always reads 0"]
+pub type FifoUflowW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `ADC_DONE` writer - Clears the ADC done interrupt status. Always reads 0"]
+pub type AdcDoneW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `TRIG_ERROR` writer - Clears the trigger error interrupt status. Always reads 0"]
+pub type TrigErrorW<'a, REG> = crate::BitWriter<'a, REG>;
+impl W {
+    #[doc = "Bit 0 - Clears the FIFO overflow interrupt status. Always reads 0"]
+    #[inline(always)]
+    #[must_use]
+    pub fn fifo_oflow(&mut self) -> FifoOflowW<IrqClrSpec> {
+        FifoOflowW::new(self, 0)
+    }
+    #[doc = "Bit 1 - Clears the FIFO underflow interrupt status. Always reads 0"]
+    #[inline(always)]
+    #[must_use]
+    pub fn fifo_uflow(&mut self) -> FifoUflowW<IrqClrSpec> {
+        FifoUflowW::new(self, 1)
+    }
+    #[doc = "Bit 2 - Clears the ADC done interrupt status. Always reads 0"]
+    #[inline(always)]
+    #[must_use]
+    pub fn adc_done(&mut self) -> AdcDoneW<IrqClrSpec> {
+        AdcDoneW::new(self, 2)
+    }
+    #[doc = "Bit 3 - Clears the trigger error interrupt status. Always reads 0"]
+    #[inline(always)]
+    #[must_use]
+    pub fn trig_error(&mut self) -> TrigErrorW<IrqClrSpec> {
+        TrigErrorW::new(self, 3)
+    }
+}
+#[doc = "Clear Interrupt\n\nYou can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`irq_clr::W`](W). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct IrqClrSpec;
+impl crate::RegisterSpec for IrqClrSpec {
+    type Ux = u32;
+}
+#[doc = "`write(|w| ..)` method takes [`irq_clr::W`](W) writer structure"]
+impl crate::Writable for IrqClrSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets IRQ_CLR to value 0"]
+impl crate::Resettable for IrqClrSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/adc/irq_enb.rs

@@ -0,0 +1,130 @@
+#[doc = "Register `IRQ_ENB` reader"]
+pub type R = crate::R<IrqEnbSpec>;
+#[doc = "Register `IRQ_ENB` writer"]
+pub type W = crate::W<IrqEnbSpec>;
+#[doc = "Field `FIFO_EMPTY` reader - Enables the interrupt for FIFO empty"]
+pub type FifoEmptyR = crate::BitReader;
+#[doc = "Field `FIFO_EMPTY` writer - Enables the interrupt for FIFO empty"]
+pub type FifoEmptyW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `FIFO_FULL` reader - Enables the interrupt for FIFO full"]
+pub type FifoFullR = crate::BitReader;
+#[doc = "Field `FIFO_FULL` writer - Enables the interrupt for FIFO full"]
+pub type FifoFullW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `FIFO_OFLOW` reader - Enables the interrupt for a FIFO overflow"]
+pub type FifoOflowR = crate::BitReader;
+#[doc = "Field `FIFO_OFLOW` writer - Enables the interrupt for a FIFO overflow"]
+pub type FifoOflowW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `FIFO_UFLOW` reader - Enables the interrupt for a FIFO underflow"]
+pub type FifoUflowR = crate::BitReader;
+#[doc = "Field `FIFO_UFLOW` writer - Enables the interrupt for a FIFO underflow"]
+pub type FifoUflowW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `ADC_DONE` reader - Enables the interrupt for an ADC data acquisition completion"]
+pub type AdcDoneR = crate::BitReader;
+#[doc = "Field `ADC_DONE` writer - Enables the interrupt for an ADC data acquisition completion"]
+pub type AdcDoneW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `TRIG_ERROR` reader - Enables the interrupt for a trigger error"]
+pub type TrigErrorR = crate::BitReader;
+#[doc = "Field `TRIG_ERROR` writer - Enables the interrupt for a trigger error"]
+pub type TrigErrorW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `FIFO_DEPTH_TRIG` reader - Enables the interrupt for the FIFO entry count meets or exceeds the trigger level"]
+pub type FifoDepthTrigR = crate::BitReader;
+#[doc = "Field `FIFO_DEPTH_TRIG` writer - Enables the interrupt for the FIFO entry count meets or exceeds the trigger level"]
+pub type FifoDepthTrigW<'a, REG> = crate::BitWriter<'a, REG>;
+impl R {
+    #[doc = "Bit 0 - Enables the interrupt for FIFO empty"]
+    #[inline(always)]
+    pub fn fifo_empty(&self) -> FifoEmptyR {
+        FifoEmptyR::new((self.bits & 1) != 0)
+    }
+    #[doc = "Bit 1 - Enables the interrupt for FIFO full"]
+    #[inline(always)]
+    pub fn fifo_full(&self) -> FifoFullR {
+        FifoFullR::new(((self.bits >> 1) & 1) != 0)
+    }
+    #[doc = "Bit 2 - Enables the interrupt for a FIFO overflow"]
+    #[inline(always)]
+    pub fn fifo_oflow(&self) -> FifoOflowR {
+        FifoOflowR::new(((self.bits >> 2) & 1) != 0)
+    }
+    #[doc = "Bit 3 - Enables the interrupt for a FIFO underflow"]
+    #[inline(always)]
+    pub fn fifo_uflow(&self) -> FifoUflowR {
+        FifoUflowR::new(((self.bits >> 3) & 1) != 0)
+    }
+    #[doc = "Bit 4 - Enables the interrupt for an ADC data acquisition completion"]
+    #[inline(always)]
+    pub fn adc_done(&self) -> AdcDoneR {
+        AdcDoneR::new(((self.bits >> 4) & 1) != 0)
+    }
+    #[doc = "Bit 5 - Enables the interrupt for a trigger error"]
+    #[inline(always)]
+    pub fn trig_error(&self) -> TrigErrorR {
+        TrigErrorR::new(((self.bits >> 5) & 1) != 0)
+    }
+    #[doc = "Bit 6 - Enables the interrupt for the FIFO entry count meets or exceeds the trigger level"]
+    #[inline(always)]
+    pub fn fifo_depth_trig(&self) -> FifoDepthTrigR {
+        FifoDepthTrigR::new(((self.bits >> 6) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Enables the interrupt for FIFO empty"]
+    #[inline(always)]
+    #[must_use]
+    pub fn fifo_empty(&mut self) -> FifoEmptyW<IrqEnbSpec> {
+        FifoEmptyW::new(self, 0)
+    }
+    #[doc = "Bit 1 - Enables the interrupt for FIFO full"]
+    #[inline(always)]
+    #[must_use]
+    pub fn fifo_full(&mut self) -> FifoFullW<IrqEnbSpec> {
+        FifoFullW::new(self, 1)
+    }
+    #[doc = "Bit 2 - Enables the interrupt for a FIFO overflow"]
+    #[inline(always)]
+    #[must_use]
+    pub fn fifo_oflow(&mut self) -> FifoOflowW<IrqEnbSpec> {
+        FifoOflowW::new(self, 2)
+    }
+    #[doc = "Bit 3 - Enables the interrupt for a FIFO underflow"]
+    #[inline(always)]
+    #[must_use]
+    pub fn fifo_uflow(&mut self) -> FifoUflowW<IrqEnbSpec> {
+        FifoUflowW::new(self, 3)
+    }
+    #[doc = "Bit 4 - Enables the interrupt for an ADC data acquisition completion"]
+    #[inline(always)]
+    #[must_use]
+    pub fn adc_done(&mut self) -> AdcDoneW<IrqEnbSpec> {
+        AdcDoneW::new(self, 4)
+    }
+    #[doc = "Bit 5 - Enables the interrupt for a trigger error"]
+    #[inline(always)]
+    #[must_use]
+    pub fn trig_error(&mut self) -> TrigErrorW<IrqEnbSpec> {
+        TrigErrorW::new(self, 5)
+    }
+    #[doc = "Bit 6 - Enables the interrupt for the FIFO entry count meets or exceeds the trigger level"]
+    #[inline(always)]
+    #[must_use]
+    pub fn fifo_depth_trig(&mut self) -> FifoDepthTrigW<IrqEnbSpec> {
+        FifoDepthTrigW::new(self, 6)
+    }
+}
+#[doc = "Interrupt Enable\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`irq_enb::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`irq_enb::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct IrqEnbSpec;
+impl crate::RegisterSpec for IrqEnbSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`irq_enb::R`](R) reader structure"]
+impl crate::Readable for IrqEnbSpec {}
+#[doc = "`write(|w| ..)` method takes [`irq_enb::W`](W) writer structure"]
+impl crate::Writable for IrqEnbSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets IRQ_ENB to value 0"]
+impl crate::Resettable for IrqEnbSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/adc/irq_end.rs

@@ -0,0 +1,64 @@
+#[doc = "Register `IRQ_END` reader"]
+pub type R = crate::R<IrqEndSpec>;
+#[doc = "Field `FIFO_EMPTY` reader - Indicates the FIFO is empty and the interrupt is enabled"]
+pub type FifoEmptyR = crate::BitReader;
+#[doc = "Field `FIFO_FULL` reader - Indicates the FIFO is full and the interrupt is enabled"]
+pub type FifoFullR = crate::BitReader;
+#[doc = "Field `FIFO_OFLOW` reader - Indicates a FIFO overflow occurred and the interrupt is enabled"]
+pub type FifoOflowR = crate::BitReader;
+#[doc = "Field `FIFO_UFLOW` reader - Indicates a FIFO underflow occurred and the interrupt is enabled"]
+pub type FifoUflowR = crate::BitReader;
+#[doc = "Field `ADC_DONE` reader - Indicates that a ADC conversion is done and the interrupt is enabled"]
+pub type AdcDoneR = crate::BitReader;
+#[doc = "Field `TRIG_ERROR` reader - Indicates a manual or external trigger occurred when the ADC was BUSY doing a conversion and the interrupt is enabled"]
+pub type TrigErrorR = crate::BitReader;
+#[doc = "Field `FIFO_DEPTH_TRIG` reader - Indicates the interrupt for the FIFO entry count meets or exceeds the trigger level"]
+pub type FifoDepthTrigR = crate::BitReader;
+impl R {
+    #[doc = "Bit 0 - Indicates the FIFO is empty and the interrupt is enabled"]
+    #[inline(always)]
+    pub fn fifo_empty(&self) -> FifoEmptyR {
+        FifoEmptyR::new((self.bits & 1) != 0)
+    }
+    #[doc = "Bit 1 - Indicates the FIFO is full and the interrupt is enabled"]
+    #[inline(always)]
+    pub fn fifo_full(&self) -> FifoFullR {
+        FifoFullR::new(((self.bits >> 1) & 1) != 0)
+    }
+    #[doc = "Bit 2 - Indicates a FIFO overflow occurred and the interrupt is enabled"]
+    #[inline(always)]
+    pub fn fifo_oflow(&self) -> FifoOflowR {
+        FifoOflowR::new(((self.bits >> 2) & 1) != 0)
+    }
+    #[doc = "Bit 3 - Indicates a FIFO underflow occurred and the interrupt is enabled"]
+    #[inline(always)]
+    pub fn fifo_uflow(&self) -> FifoUflowR {
+        FifoUflowR::new(((self.bits >> 3) & 1) != 0)
+    }
+    #[doc = "Bit 4 - Indicates that a ADC conversion is done and the interrupt is enabled"]
+    #[inline(always)]
+    pub fn adc_done(&self) -> AdcDoneR {
+        AdcDoneR::new(((self.bits >> 4) & 1) != 0)
+    }
+    #[doc = "Bit 5 - Indicates a manual or external trigger occurred when the ADC was BUSY doing a conversion and the interrupt is enabled"]
+    #[inline(always)]
+    pub fn trig_error(&self) -> TrigErrorR {
+        TrigErrorR::new(((self.bits >> 5) & 1) != 0)
+    }
+    #[doc = "Bit 6 - Indicates the interrupt for the FIFO entry count meets or exceeds the trigger level"]
+    #[inline(always)]
+    pub fn fifo_depth_trig(&self) -> FifoDepthTrigR {
+        FifoDepthTrigR::new(((self.bits >> 6) & 1) != 0)
+    }
+}
+#[doc = "Enabled Interrupt Status\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`irq_end::R`](R).  See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct IrqEndSpec;
+impl crate::RegisterSpec for IrqEndSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`irq_end::R`](R) reader structure"]
+impl crate::Readable for IrqEndSpec {}
+#[doc = "`reset()` method sets IRQ_END to value 0"]
+impl crate::Resettable for IrqEndSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/adc/irq_raw.rs

@@ -0,0 +1,64 @@
+#[doc = "Register `IRQ_RAW` reader"]
+pub type R = crate::R<IrqRawSpec>;
+#[doc = "Field `FIFO_EMPTY` reader - Indicates the FIFO is empty"]
+pub type FifoEmptyR = crate::BitReader;
+#[doc = "Field `FIFO_FULL` reader - Indicates the FIFO is full"]
+pub type FifoFullR = crate::BitReader;
+#[doc = "Field `FIFO_OFLOW` reader - Indicates a FIFO overflow occurred (FIFO was full when new data was written)"]
+pub type FifoOflowR = crate::BitReader;
+#[doc = "Field `FIFO_UFLOW` reader - Indicates data was unavailable when a new trigger for ADC update is received"]
+pub type FifoUflowR = crate::BitReader;
+#[doc = "Field `ADC_DONE` reader - Indicates that a ADC conversion is done"]
+pub type AdcDoneR = crate::BitReader;
+#[doc = "Field `TRIG_ERROR` reader - Indicates a manual or external trigger occurred when the ADC was BUSY doing a conversion"]
+pub type TrigErrorR = crate::BitReader;
+#[doc = "Field `FIFO_DEPTH_TRIG` reader - Indicates the interrupt for the FIFO entry count meets or exceeds the trigger level"]
+pub type FifoDepthTrigR = crate::BitReader;
+impl R {
+    #[doc = "Bit 0 - Indicates the FIFO is empty"]
+    #[inline(always)]
+    pub fn fifo_empty(&self) -> FifoEmptyR {
+        FifoEmptyR::new((self.bits & 1) != 0)
+    }
+    #[doc = "Bit 1 - Indicates the FIFO is full"]
+    #[inline(always)]
+    pub fn fifo_full(&self) -> FifoFullR {
+        FifoFullR::new(((self.bits >> 1) & 1) != 0)
+    }
+    #[doc = "Bit 2 - Indicates a FIFO overflow occurred (FIFO was full when new data was written)"]
+    #[inline(always)]
+    pub fn fifo_oflow(&self) -> FifoOflowR {
+        FifoOflowR::new(((self.bits >> 2) & 1) != 0)
+    }
+    #[doc = "Bit 3 - Indicates data was unavailable when a new trigger for ADC update is received"]
+    #[inline(always)]
+    pub fn fifo_uflow(&self) -> FifoUflowR {
+        FifoUflowR::new(((self.bits >> 3) & 1) != 0)
+    }
+    #[doc = "Bit 4 - Indicates that a ADC conversion is done"]
+    #[inline(always)]
+    pub fn adc_done(&self) -> AdcDoneR {
+        AdcDoneR::new(((self.bits >> 4) & 1) != 0)
+    }
+    #[doc = "Bit 5 - Indicates a manual or external trigger occurred when the ADC was BUSY doing a conversion"]
+    #[inline(always)]
+    pub fn trig_error(&self) -> TrigErrorR {
+        TrigErrorR::new(((self.bits >> 5) & 1) != 0)
+    }
+    #[doc = "Bit 6 - Indicates the interrupt for the FIFO entry count meets or exceeds the trigger level"]
+    #[inline(always)]
+    pub fn fifo_depth_trig(&self) -> FifoDepthTrigR {
+        FifoDepthTrigR::new(((self.bits >> 6) & 1) != 0)
+    }
+}
+#[doc = "Raw Interrupt Status\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`irq_raw::R`](R).  See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct IrqRawSpec;
+impl crate::RegisterSpec for IrqRawSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`irq_raw::R`](R) reader structure"]
+impl crate::Readable for IrqRawSpec {}
+#[doc = "`reset()` method sets IRQ_RAW to value 0x01"]
+impl crate::Resettable for IrqRawSpec {
+    const RESET_VALUE: u32 = 0x01;
+}

va416xx/src/adc/perid.rs

@@ -0,0 +1,18 @@
+#[doc = "Register `PERID` reader"]
+pub type R = crate::R<PeridSpec>;
+impl core::fmt::Debug for R {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "{}", self.bits())
+    }
+}
+#[doc = "Peripheral ID Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`perid::R`](R).  See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct PeridSpec;
+impl crate::RegisterSpec for PeridSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`perid::R`](R) reader structure"]
+impl crate::Readable for PeridSpec {}
+#[doc = "`reset()` method sets PERID to value 0x0019_07e9"]
+impl crate::Resettable for PeridSpec {
+    const RESET_VALUE: u32 = 0x0019_07e9;
+}

va416xx/src/adc/rxfifoirqtrg.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `RXFIFOIRQTRG` reader"]
+pub type R = crate::R<RxfifoirqtrgSpec>;
+#[doc = "Register `RXFIFOIRQTRG` writer"]
+pub type W = crate::W<RxfifoirqtrgSpec>;
+#[doc = "Field `LEVEL` reader - Sets the FIFO_ENTRY_CNT value that asserts the FIFO_DEPTH_TRIG interrupt"]
+pub type LevelR = crate::FieldReader;
+#[doc = "Field `LEVEL` writer - Sets the FIFO_ENTRY_CNT value that asserts the FIFO_DEPTH_TRIG interrupt"]
+pub type LevelW<'a, REG> = crate::FieldWriter<'a, REG, 5>;
+impl R {
+    #[doc = "Bits 0:4 - Sets the FIFO_ENTRY_CNT value that asserts the FIFO_DEPTH_TRIG interrupt"]
+    #[inline(always)]
+    pub fn level(&self) -> LevelR {
+        LevelR::new((self.bits & 0x1f) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:4 - Sets the FIFO_ENTRY_CNT value that asserts the FIFO_DEPTH_TRIG interrupt"]
+    #[inline(always)]
+    #[must_use]
+    pub fn level(&mut self) -> LevelW<RxfifoirqtrgSpec> {
+        LevelW::new(self, 0)
+    }
+}
+#[doc = "Receive FIFO Interrupt Trigger Value\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`rxfifoirqtrg::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`rxfifoirqtrg::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct RxfifoirqtrgSpec;
+impl crate::RegisterSpec for RxfifoirqtrgSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`rxfifoirqtrg::R`](R) reader structure"]
+impl crate::Readable for RxfifoirqtrgSpec {}
+#[doc = "`write(|w| ..)` method takes [`rxfifoirqtrg::W`](W) writer structure"]
+impl crate::Writable for RxfifoirqtrgSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets RXFIFOIRQTRG to value 0x10"]
+impl crate::Resettable for RxfifoirqtrgSpec {
+    const RESET_VALUE: u32 = 0x10;
+}

va416xx/src/adc/status.rs

@@ -0,0 +1,29 @@
+#[doc = "Register `STATUS` reader"]
+pub type R = crate::R<StatusSpec>;
+#[doc = "Field `FIFO_ENTRY_CNT` reader - Indicates the number of entries in the FIFO"]
+pub type FifoEntryCntR = crate::FieldReader;
+#[doc = "Field `ADC_BUSY` reader - Indicates an ADC data acquisition is in process"]
+pub type AdcBusyR = crate::BitReader;
+impl R {
+    #[doc = "Bits 0:5 - Indicates the number of entries in the FIFO"]
+    #[inline(always)]
+    pub fn fifo_entry_cnt(&self) -> FifoEntryCntR {
+        FifoEntryCntR::new((self.bits & 0x3f) as u8)
+    }
+    #[doc = "Bit 7 - Indicates an ADC data acquisition is in process"]
+    #[inline(always)]
+    pub fn adc_busy(&self) -> AdcBusyR {
+        AdcBusyR::new(((self.bits >> 7) & 1) != 0)
+    }
+}
+#[doc = "Status\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`status::R`](R).  See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct StatusSpec;
+impl crate::RegisterSpec for StatusSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`status::R`](R) reader structure"]
+impl crate::Readable for StatusSpec {}
+#[doc = "`reset()` method sets STATUS to value 0"]
+impl crate::Resettable for StatusSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/bmskb.rs

@@ -0,0 +1,105 @@
+#[doc = "Register `BMSKB` reader"]
+pub type R = crate::R<BmskbSpec>;
+#[doc = "Register `BMSKB` writer"]
+pub type W = crate::W<BmskbSpec>;
+#[doc = "Field `BM0` reader - BM\\[17:15\\]
+- Unused in standard, ID\\[17:15\\]
+in extended"]
+pub type Bm0R = crate::FieldReader;
+#[doc = "Field `BM0` writer - BM\\[17:15\\]
+- Unused in standard, ID\\[17:15\\]
+in extended"]
+pub type Bm0W<'a, REG> = crate::FieldWriter<'a, REG, 3>;
+#[doc = "Field `IDE` reader - Identifier Extension Bit"]
+pub type IdeR = crate::BitReader;
+#[doc = "Field `IDE` writer - Identifier Extension Bit"]
+pub type IdeW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `RTR` reader - Remote Transmission Request in Standard, Substitute Remote Request (SRR) in extended"]
+pub type RtrR = crate::BitReader;
+#[doc = "Field `RTR` writer - Remote Transmission Request in Standard, Substitute Remote Request (SRR) in extended"]
+pub type RtrW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `BM1` reader - BM\\[28:18\\]
+- ID\\[10:0\\]
+in standard, ID\\[28:18\\]
+in extended"]
+pub type Bm1R = crate::FieldReader<u16>;
+#[doc = "Field `BM1` writer - BM\\[28:18\\]
+- ID\\[10:0\\]
+in standard, ID\\[28:18\\]
+in extended"]
+pub type Bm1W<'a, REG> = crate::FieldWriter<'a, REG, 11, u16>;
+impl R {
+    #[doc = "Bits 0:2 - BM\\[17:15\\]
+- Unused in standard, ID\\[17:15\\]
+in extended"]
+    #[inline(always)]
+    pub fn bm0(&self) -> Bm0R {
+        Bm0R::new((self.bits & 7) as u8)
+    }
+    #[doc = "Bit 3 - Identifier Extension Bit"]
+    #[inline(always)]
+    pub fn ide(&self) -> IdeR {
+        IdeR::new(((self.bits >> 3) & 1) != 0)
+    }
+    #[doc = "Bit 4 - Remote Transmission Request in Standard, Substitute Remote Request (SRR) in extended"]
+    #[inline(always)]
+    pub fn rtr(&self) -> RtrR {
+        RtrR::new(((self.bits >> 4) & 1) != 0)
+    }
+    #[doc = "Bits 5:15 - BM\\[28:18\\]
+- ID\\[10:0\\]
+in standard, ID\\[28:18\\]
+in extended"]
+    #[inline(always)]
+    pub fn bm1(&self) -> Bm1R {
+        Bm1R::new(((self.bits >> 5) & 0x07ff) as u16)
+    }
+}
+impl W {
+    #[doc = "Bits 0:2 - BM\\[17:15\\]
+- Unused in standard, ID\\[17:15\\]
+in extended"]
+    #[inline(always)]
+    #[must_use]
+    pub fn bm0(&mut self) -> Bm0W<BmskbSpec> {
+        Bm0W::new(self, 0)
+    }
+    #[doc = "Bit 3 - Identifier Extension Bit"]
+    #[inline(always)]
+    #[must_use]
+    pub fn ide(&mut self) -> IdeW<BmskbSpec> {
+        IdeW::new(self, 3)
+    }
+    #[doc = "Bit 4 - Remote Transmission Request in Standard, Substitute Remote Request (SRR) in extended"]
+    #[inline(always)]
+    #[must_use]
+    pub fn rtr(&mut self) -> RtrW<BmskbSpec> {
+        RtrW::new(self, 4)
+    }
+    #[doc = "Bits 5:15 - BM\\[28:18\\]
+- ID\\[10:0\\]
+in standard, ID\\[28:18\\]
+in extended"]
+    #[inline(always)]
+    #[must_use]
+    pub fn bm1(&mut self) -> Bm1W<BmskbSpec> {
+        Bm1W::new(self, 5)
+    }
+}
+#[doc = "CAN Basic Mask Base\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`bmskb::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`bmskb::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct BmskbSpec;
+impl crate::RegisterSpec for BmskbSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`bmskb::R`](R) reader structure"]
+impl crate::Readable for BmskbSpec {}
+#[doc = "`write(|w| ..)` method takes [`bmskb::W`](W) writer structure"]
+impl crate::Writable for BmskbSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets BMSKB to value 0"]
+impl crate::Resettable for BmskbSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/bmskx.rs

@@ -0,0 +1,63 @@
+#[doc = "Register `BMSKX` reader"]
+pub type R = crate::R<BmskxSpec>;
+#[doc = "Register `BMSKX` writer"]
+pub type W = crate::W<BmskxSpec>;
+#[doc = "Field `XRTR` reader - Extended Remote transmission Request Bit"]
+pub type XrtrR = crate::BitReader;
+#[doc = "Field `XRTR` writer - Extended Remote transmission Request Bit"]
+pub type XrtrW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `BM` reader - BM\\[14:0\\]
+used when an extended frame is received. ID\\[14:0\\]
+in extended, unused standard"]
+pub type BmR = crate::FieldReader<u16>;
+#[doc = "Field `BM` writer - BM\\[14:0\\]
+used when an extended frame is received. ID\\[14:0\\]
+in extended, unused standard"]
+pub type BmW<'a, REG> = crate::FieldWriter<'a, REG, 15, u16>;
+impl R {
+    #[doc = "Bit 0 - Extended Remote transmission Request Bit"]
+    #[inline(always)]
+    pub fn xrtr(&self) -> XrtrR {
+        XrtrR::new((self.bits & 1) != 0)
+    }
+    #[doc = "Bits 1:15 - BM\\[14:0\\]
+used when an extended frame is received. ID\\[14:0\\]
+in extended, unused standard"]
+    #[inline(always)]
+    pub fn bm(&self) -> BmR {
+        BmR::new(((self.bits >> 1) & 0x7fff) as u16)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Extended Remote transmission Request Bit"]
+    #[inline(always)]
+    #[must_use]
+    pub fn xrtr(&mut self) -> XrtrW<BmskxSpec> {
+        XrtrW::new(self, 0)
+    }
+    #[doc = "Bits 1:15 - BM\\[14:0\\]
+used when an extended frame is received. ID\\[14:0\\]
+in extended, unused standard"]
+    #[inline(always)]
+    #[must_use]
+    pub fn bm(&mut self) -> BmW<BmskxSpec> {
+        BmW::new(self, 1)
+    }
+}
+#[doc = "CAN Basic Mask Extension\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`bmskx::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`bmskx::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct BmskxSpec;
+impl crate::RegisterSpec for BmskxSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`bmskx::R`](R) reader structure"]
+impl crate::Readable for BmskxSpec {}
+#[doc = "`write(|w| ..)` method takes [`bmskx::W`](W) writer structure"]
+impl crate::Writable for BmskxSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets BMSKX to value 0"]
+impl crate::Resettable for BmskxSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/canec.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `CANEC` reader"]
+pub type R = crate::R<CanecSpec>;
+#[doc = "Register `CANEC` writer"]
+pub type W = crate::W<CanecSpec>;
+#[doc = "Field `TEC` reader - Transmit Error Counter"]
+pub type TecR = crate::FieldReader;
+#[doc = "Field `TEC` writer - Transmit Error Counter"]
+pub type TecW<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `REC` reader - Receive Error Counter"]
+pub type RecR = crate::FieldReader;
+#[doc = "Field `REC` writer - Receive Error Counter"]
+pub type RecW<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Transmit Error Counter"]
+    #[inline(always)]
+    pub fn tec(&self) -> TecR {
+        TecR::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Receive Error Counter"]
+    #[inline(always)]
+    pub fn rec(&self) -> RecR {
+        RecR::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Transmit Error Counter"]
+    #[inline(always)]
+    #[must_use]
+    pub fn tec(&mut self) -> TecW<CanecSpec> {
+        TecW::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Receive Error Counter"]
+    #[inline(always)]
+    #[must_use]
+    pub fn rec(&mut self) -> RecW<CanecSpec> {
+        RecW::new(self, 8)
+    }
+}
+#[doc = "CAN Error Counter Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`canec::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`canec::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CanecSpec;
+impl crate::RegisterSpec for CanecSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`canec::R`](R) reader structure"]
+impl crate::Readable for CanecSpec {}
+#[doc = "`write(|w| ..)` method takes [`canec::W`](W) writer structure"]
+impl crate::Writable for CanecSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CANEC to value 0"]
+impl crate::Resettable for CanecSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cediag.rs

@@ -0,0 +1,130 @@
+#[doc = "Register `CEDIAG` reader"]
+pub type R = crate::R<CediagSpec>;
+#[doc = "Register `CEDIAG` writer"]
+pub type W = crate::W<CediagSpec>;
+#[doc = "Field `EFID` reader - Error Field Identifier"]
+pub type EfidR = crate::FieldReader;
+#[doc = "Field `EFID` writer - Error Field Identifier"]
+pub type EfidW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `EBID` reader - Error Bit Identifier"]
+pub type EbidR = crate::FieldReader;
+#[doc = "Field `EBID` writer - Error Bit Identifier"]
+pub type EbidW<'a, REG> = crate::FieldWriter<'a, REG, 6>;
+#[doc = "Field `TXE` reader - Transmit Error"]
+pub type TxeR = crate::BitReader;
+#[doc = "Field `TXE` writer - Transmit Error"]
+pub type TxeW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `STUFF` reader - Stuff Error"]
+pub type StuffR = crate::BitReader;
+#[doc = "Field `STUFF` writer - Stuff Error"]
+pub type StuffW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `CRC` reader - CRC"]
+pub type CrcR = crate::BitReader;
+#[doc = "Field `CRC` writer - CRC"]
+pub type CrcW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `MON` reader - Monitor"]
+pub type MonR = crate::BitReader;
+#[doc = "Field `MON` writer - Monitor"]
+pub type MonW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `DRIVE` reader - Drive"]
+pub type DriveR = crate::BitReader;
+#[doc = "Field `DRIVE` writer - Drive"]
+pub type DriveW<'a, REG> = crate::BitWriter<'a, REG>;
+impl R {
+    #[doc = "Bits 0:3 - Error Field Identifier"]
+    #[inline(always)]
+    pub fn efid(&self) -> EfidR {
+        EfidR::new((self.bits & 0x0f) as u8)
+    }
+    #[doc = "Bits 4:9 - Error Bit Identifier"]
+    #[inline(always)]
+    pub fn ebid(&self) -> EbidR {
+        EbidR::new(((self.bits >> 4) & 0x3f) as u8)
+    }
+    #[doc = "Bit 10 - Transmit Error"]
+    #[inline(always)]
+    pub fn txe(&self) -> TxeR {
+        TxeR::new(((self.bits >> 10) & 1) != 0)
+    }
+    #[doc = "Bit 11 - Stuff Error"]
+    #[inline(always)]
+    pub fn stuff(&self) -> StuffR {
+        StuffR::new(((self.bits >> 11) & 1) != 0)
+    }
+    #[doc = "Bit 12 - CRC"]
+    #[inline(always)]
+    pub fn crc(&self) -> CrcR {
+        CrcR::new(((self.bits >> 12) & 1) != 0)
+    }
+    #[doc = "Bit 13 - Monitor"]
+    #[inline(always)]
+    pub fn mon(&self) -> MonR {
+        MonR::new(((self.bits >> 13) & 1) != 0)
+    }
+    #[doc = "Bit 14 - Drive"]
+    #[inline(always)]
+    pub fn drive(&self) -> DriveR {
+        DriveR::new(((self.bits >> 14) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bits 0:3 - Error Field Identifier"]
+    #[inline(always)]
+    #[must_use]
+    pub fn efid(&mut self) -> EfidW<CediagSpec> {
+        EfidW::new(self, 0)
+    }
+    #[doc = "Bits 4:9 - Error Bit Identifier"]
+    #[inline(always)]
+    #[must_use]
+    pub fn ebid(&mut self) -> EbidW<CediagSpec> {
+        EbidW::new(self, 4)
+    }
+    #[doc = "Bit 10 - Transmit Error"]
+    #[inline(always)]
+    #[must_use]
+    pub fn txe(&mut self) -> TxeW<CediagSpec> {
+        TxeW::new(self, 10)
+    }
+    #[doc = "Bit 11 - Stuff Error"]
+    #[inline(always)]
+    #[must_use]
+    pub fn stuff(&mut self) -> StuffW<CediagSpec> {
+        StuffW::new(self, 11)
+    }
+    #[doc = "Bit 12 - CRC"]
+    #[inline(always)]
+    #[must_use]
+    pub fn crc(&mut self) -> CrcW<CediagSpec> {
+        CrcW::new(self, 12)
+    }
+    #[doc = "Bit 13 - Monitor"]
+    #[inline(always)]
+    #[must_use]
+    pub fn mon(&mut self) -> MonW<CediagSpec> {
+        MonW::new(self, 13)
+    }
+    #[doc = "Bit 14 - Drive"]
+    #[inline(always)]
+    #[must_use]
+    pub fn drive(&mut self) -> DriveW<CediagSpec> {
+        DriveW::new(self, 14)
+    }
+}
+#[doc = "CAN Error Diagnostic Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cediag::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cediag::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CediagSpec;
+impl crate::RegisterSpec for CediagSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cediag::R`](R) reader structure"]
+impl crate::Readable for CediagSpec {}
+#[doc = "`write(|w| ..)` method takes [`cediag::W`](W) writer structure"]
+impl crate::Writable for CediagSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CEDIAG to value 0"]
+impl crate::Resettable for CediagSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cgcr.rs

@@ -0,0 +1,205 @@
+#[doc = "Register `CGCR` reader"]
+pub type R = crate::R<CgcrSpec>;
+#[doc = "Register `CGCR` writer"]
+pub type W = crate::W<CgcrSpec>;
+#[doc = "Field `CANEN` reader - CAN Enable"]
+pub type CanenR = crate::BitReader;
+#[doc = "Field `CANEN` writer - CAN Enable"]
+pub type CanenW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `CRX` reader - RW,Control Receive"]
+pub type CrxR = crate::BitReader;
+#[doc = "Field `CRX` writer - RW,Control Receive"]
+pub type CrxW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `CTX` reader - RW,Control Transmit"]
+pub type CtxR = crate::BitReader;
+#[doc = "Field `CTX` writer - RW,Control Transmit"]
+pub type CtxW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `BUFFLOCK` reader - Buffer Lock"]
+pub type BufflockR = crate::BitReader;
+#[doc = "Field `BUFFLOCK` writer - Buffer Lock"]
+pub type BufflockW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `TSTPEN` reader - Time Sync Enable"]
+pub type TstpenR = crate::BitReader;
+#[doc = "Field `TSTPEN` writer - Time Sync Enable"]
+pub type TstpenW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `DDIR` reader - Data Direction"]
+pub type DdirR = crate::BitReader;
+#[doc = "Field `DDIR` writer - Data Direction"]
+pub type DdirW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `LO` reader - Listen Only"]
+pub type LoR = crate::BitReader;
+#[doc = "Field `LO` writer - Listen Only"]
+pub type LoW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `IGNACK` reader - Ignore Acknowledge"]
+pub type IgnackR = crate::BitReader;
+#[doc = "Field `IGNACK` writer - Ignore Acknowledge"]
+pub type IgnackW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `LOOPBACK` reader - Loopback"]
+pub type LoopbackR = crate::BitReader;
+#[doc = "Field `LOOPBACK` writer - Loopback"]
+pub type LoopbackW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `INTERNAL` reader - Internal"]
+pub type InternalR = crate::BitReader;
+#[doc = "Field `INTERNAL` writer - Internal"]
+pub type InternalW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `DIAGEN` reader - Diagnostic Enable"]
+pub type DiagenR = crate::BitReader;
+#[doc = "Field `DIAGEN` writer - Diagnostic Enable"]
+pub type DiagenW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `EIT` reader - Error Interrupt Type"]
+pub type EitR = crate::BitReader;
+#[doc = "Field `EIT` writer - Error Interrupt Type"]
+pub type EitW<'a, REG> = crate::BitWriter<'a, REG>;
+impl R {
+    #[doc = "Bit 0 - CAN Enable"]
+    #[inline(always)]
+    pub fn canen(&self) -> CanenR {
+        CanenR::new((self.bits & 1) != 0)
+    }
+    #[doc = "Bit 1 - RW,Control Receive"]
+    #[inline(always)]
+    pub fn crx(&self) -> CrxR {
+        CrxR::new(((self.bits >> 1) & 1) != 0)
+    }
+    #[doc = "Bit 2 - RW,Control Transmit"]
+    #[inline(always)]
+    pub fn ctx(&self) -> CtxR {
+        CtxR::new(((self.bits >> 2) & 1) != 0)
+    }
+    #[doc = "Bit 3 - Buffer Lock"]
+    #[inline(always)]
+    pub fn bufflock(&self) -> BufflockR {
+        BufflockR::new(((self.bits >> 3) & 1) != 0)
+    }
+    #[doc = "Bit 4 - Time Sync Enable"]
+    #[inline(always)]
+    pub fn tstpen(&self) -> TstpenR {
+        TstpenR::new(((self.bits >> 4) & 1) != 0)
+    }
+    #[doc = "Bit 5 - Data Direction"]
+    #[inline(always)]
+    pub fn ddir(&self) -> DdirR {
+        DdirR::new(((self.bits >> 5) & 1) != 0)
+    }
+    #[doc = "Bit 6 - Listen Only"]
+    #[inline(always)]
+    pub fn lo(&self) -> LoR {
+        LoR::new(((self.bits >> 6) & 1) != 0)
+    }
+    #[doc = "Bit 7 - Ignore Acknowledge"]
+    #[inline(always)]
+    pub fn ignack(&self) -> IgnackR {
+        IgnackR::new(((self.bits >> 7) & 1) != 0)
+    }
+    #[doc = "Bit 8 - Loopback"]
+    #[inline(always)]
+    pub fn loopback(&self) -> LoopbackR {
+        LoopbackR::new(((self.bits >> 8) & 1) != 0)
+    }
+    #[doc = "Bit 9 - Internal"]
+    #[inline(always)]
+    pub fn internal(&self) -> InternalR {
+        InternalR::new(((self.bits >> 9) & 1) != 0)
+    }
+    #[doc = "Bit 10 - Diagnostic Enable"]
+    #[inline(always)]
+    pub fn diagen(&self) -> DiagenR {
+        DiagenR::new(((self.bits >> 10) & 1) != 0)
+    }
+    #[doc = "Bit 11 - Error Interrupt Type"]
+    #[inline(always)]
+    pub fn eit(&self) -> EitR {
+        EitR::new(((self.bits >> 11) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - CAN Enable"]
+    #[inline(always)]
+    #[must_use]
+    pub fn canen(&mut self) -> CanenW<CgcrSpec> {
+        CanenW::new(self, 0)
+    }
+    #[doc = "Bit 1 - RW,Control Receive"]
+    #[inline(always)]
+    #[must_use]
+    pub fn crx(&mut self) -> CrxW<CgcrSpec> {
+        CrxW::new(self, 1)
+    }
+    #[doc = "Bit 2 - RW,Control Transmit"]
+    #[inline(always)]
+    #[must_use]
+    pub fn ctx(&mut self) -> CtxW<CgcrSpec> {
+        CtxW::new(self, 2)
+    }
+    #[doc = "Bit 3 - Buffer Lock"]
+    #[inline(always)]
+    #[must_use]
+    pub fn bufflock(&mut self) -> BufflockW<CgcrSpec> {
+        BufflockW::new(self, 3)
+    }
+    #[doc = "Bit 4 - Time Sync Enable"]
+    #[inline(always)]
+    #[must_use]
+    pub fn tstpen(&mut self) -> TstpenW<CgcrSpec> {
+        TstpenW::new(self, 4)
+    }
+    #[doc = "Bit 5 - Data Direction"]
+    #[inline(always)]
+    #[must_use]
+    pub fn ddir(&mut self) -> DdirW<CgcrSpec> {
+        DdirW::new(self, 5)
+    }
+    #[doc = "Bit 6 - Listen Only"]
+    #[inline(always)]
+    #[must_use]
+    pub fn lo(&mut self) -> LoW<CgcrSpec> {
+        LoW::new(self, 6)
+    }
+    #[doc = "Bit 7 - Ignore Acknowledge"]
+    #[inline(always)]
+    #[must_use]
+    pub fn ignack(&mut self) -> IgnackW<CgcrSpec> {
+        IgnackW::new(self, 7)
+    }
+    #[doc = "Bit 8 - Loopback"]
+    #[inline(always)]
+    #[must_use]
+    pub fn loopback(&mut self) -> LoopbackW<CgcrSpec> {
+        LoopbackW::new(self, 8)
+    }
+    #[doc = "Bit 9 - Internal"]
+    #[inline(always)]
+    #[must_use]
+    pub fn internal(&mut self) -> InternalW<CgcrSpec> {
+        InternalW::new(self, 9)
+    }
+    #[doc = "Bit 10 - Diagnostic Enable"]
+    #[inline(always)]
+    #[must_use]
+    pub fn diagen(&mut self) -> DiagenW<CgcrSpec> {
+        DiagenW::new(self, 10)
+    }
+    #[doc = "Bit 11 - Error Interrupt Type"]
+    #[inline(always)]
+    #[must_use]
+    pub fn eit(&mut self) -> EitW<CgcrSpec> {
+        EitW::new(self, 11)
+    }
+}
+#[doc = "CAN Global Configuration Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cgcr::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cgcr::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CgcrSpec;
+impl crate::RegisterSpec for CgcrSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cgcr::R`](R) reader structure"]
+impl crate::Readable for CgcrSpec {}
+#[doc = "`write(|w| ..)` method takes [`cgcr::W`](W) writer structure"]
+impl crate::Writable for CgcrSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CGCR to value 0"]
+impl crate::Resettable for CgcrSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cicen.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `CICEN` reader"]
+pub type R = crate::R<CicenSpec>;
+#[doc = "Register `CICEN` writer"]
+pub type W = crate::W<CicenSpec>;
+#[doc = "Field `ICEN` reader - Buffer Interrupt Code Enable\\[14:0\\]"]
+pub type IcenR = crate::FieldReader<u16>;
+#[doc = "Field `ICEN` writer - Buffer Interrupt Code Enable\\[14:0\\]"]
+pub type IcenW<'a, REG> = crate::FieldWriter<'a, REG, 15, u16>;
+#[doc = "Field `EICEN` reader - Error Interrupt Code Enable"]
+pub type EicenR = crate::BitReader;
+#[doc = "Field `EICEN` writer - Error Interrupt Code Enable"]
+pub type EicenW<'a, REG> = crate::BitWriter<'a, REG>;
+impl R {
+    #[doc = "Bits 0:14 - Buffer Interrupt Code Enable\\[14:0\\]"]
+    #[inline(always)]
+    pub fn icen(&self) -> IcenR {
+        IcenR::new((self.bits & 0x7fff) as u16)
+    }
+    #[doc = "Bit 15 - Error Interrupt Code Enable"]
+    #[inline(always)]
+    pub fn eicen(&self) -> EicenR {
+        EicenR::new(((self.bits >> 15) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bits 0:14 - Buffer Interrupt Code Enable\\[14:0\\]"]
+    #[inline(always)]
+    #[must_use]
+    pub fn icen(&mut self) -> IcenW<CicenSpec> {
+        IcenW::new(self, 0)
+    }
+    #[doc = "Bit 15 - Error Interrupt Code Enable"]
+    #[inline(always)]
+    #[must_use]
+    pub fn eicen(&mut self) -> EicenW<CicenSpec> {
+        EicenW::new(self, 15)
+    }
+}
+#[doc = "CAN Interrupt Code Enable Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cicen::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cicen::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CicenSpec;
+impl crate::RegisterSpec for CicenSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cicen::R`](R) reader structure"]
+impl crate::Readable for CicenSpec {}
+#[doc = "`write(|w| ..)` method takes [`cicen::W`](W) writer structure"]
+impl crate::Writable for CicenSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CICEN to value 0"]
+impl crate::Resettable for CicenSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/ciclr.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `CICLR` reader"]
+pub type R = crate::R<CiclrSpec>;
+#[doc = "Register `CICLR` writer"]
+pub type W = crate::W<CiclrSpec>;
+#[doc = "Field `ICLR` reader - Buffer Interrupt Clear\\[14:0\\]"]
+pub type IclrR = crate::FieldReader<u16>;
+#[doc = "Field `ICLR` writer - Buffer Interrupt Clear\\[14:0\\]"]
+pub type IclrW<'a, REG> = crate::FieldWriter<'a, REG, 15, u16>;
+#[doc = "Field `EICLR` reader - Error Interrupt Clear"]
+pub type EiclrR = crate::BitReader;
+#[doc = "Field `EICLR` writer - Error Interrupt Clear"]
+pub type EiclrW<'a, REG> = crate::BitWriter<'a, REG>;
+impl R {
+    #[doc = "Bits 0:14 - Buffer Interrupt Clear\\[14:0\\]"]
+    #[inline(always)]
+    pub fn iclr(&self) -> IclrR {
+        IclrR::new((self.bits & 0x7fff) as u16)
+    }
+    #[doc = "Bit 15 - Error Interrupt Clear"]
+    #[inline(always)]
+    pub fn eiclr(&self) -> EiclrR {
+        EiclrR::new(((self.bits >> 15) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bits 0:14 - Buffer Interrupt Clear\\[14:0\\]"]
+    #[inline(always)]
+    #[must_use]
+    pub fn iclr(&mut self) -> IclrW<CiclrSpec> {
+        IclrW::new(self, 0)
+    }
+    #[doc = "Bit 15 - Error Interrupt Clear"]
+    #[inline(always)]
+    #[must_use]
+    pub fn eiclr(&mut self) -> EiclrW<CiclrSpec> {
+        EiclrW::new(self, 15)
+    }
+}
+#[doc = "CAN Interrupt Clear Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`ciclr::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`ciclr::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CiclrSpec;
+impl crate::RegisterSpec for CiclrSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`ciclr::R`](R) reader structure"]
+impl crate::Readable for CiclrSpec {}
+#[doc = "`write(|w| ..)` method takes [`ciclr::W`](W) writer structure"]
+impl crate::Writable for CiclrSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CICLR to value 0"]
+impl crate::Resettable for CiclrSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cien.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `CIEN` reader"]
+pub type R = crate::R<CienSpec>;
+#[doc = "Register `CIEN` writer"]
+pub type W = crate::W<CienSpec>;
+#[doc = "Field `IEN` reader - Buffer Interrupt Enable\\[14:0\\]"]
+pub type IenR = crate::FieldReader<u16>;
+#[doc = "Field `IEN` writer - Buffer Interrupt Enable\\[14:0\\]"]
+pub type IenW<'a, REG> = crate::FieldWriter<'a, REG, 15, u16>;
+#[doc = "Field `EIEN` reader - Error Interrupt Enable"]
+pub type EienR = crate::BitReader;
+#[doc = "Field `EIEN` writer - Error Interrupt Enable"]
+pub type EienW<'a, REG> = crate::BitWriter<'a, REG>;
+impl R {
+    #[doc = "Bits 0:14 - Buffer Interrupt Enable\\[14:0\\]"]
+    #[inline(always)]
+    pub fn ien(&self) -> IenR {
+        IenR::new((self.bits & 0x7fff) as u16)
+    }
+    #[doc = "Bit 15 - Error Interrupt Enable"]
+    #[inline(always)]
+    pub fn eien(&self) -> EienR {
+        EienR::new(((self.bits >> 15) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bits 0:14 - Buffer Interrupt Enable\\[14:0\\]"]
+    #[inline(always)]
+    #[must_use]
+    pub fn ien(&mut self) -> IenW<CienSpec> {
+        IenW::new(self, 0)
+    }
+    #[doc = "Bit 15 - Error Interrupt Enable"]
+    #[inline(always)]
+    #[must_use]
+    pub fn eien(&mut self) -> EienW<CienSpec> {
+        EienW::new(self, 15)
+    }
+}
+#[doc = "CAN Interrupt Enable Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cien::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cien::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CienSpec;
+impl crate::RegisterSpec for CienSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cien::R`](R) reader structure"]
+impl crate::Readable for CienSpec {}
+#[doc = "`write(|w| ..)` method takes [`cien::W`](W) writer structure"]
+impl crate::Writable for CienSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CIEN to value 0"]
+impl crate::Resettable for CienSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cipnd.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `CIPND` reader"]
+pub type R = crate::R<CipndSpec>;
+#[doc = "Register `CIPND` writer"]
+pub type W = crate::W<CipndSpec>;
+#[doc = "Field `IPND` reader - Buffer Interrupt Pending\\[14:0\\]"]
+pub type IpndR = crate::FieldReader<u16>;
+#[doc = "Field `IPND` writer - Buffer Interrupt Pending\\[14:0\\]"]
+pub type IpndW<'a, REG> = crate::FieldWriter<'a, REG, 15, u16>;
+#[doc = "Field `EIPND` reader - Error Interrupt Pending"]
+pub type EipndR = crate::BitReader;
+#[doc = "Field `EIPND` writer - Error Interrupt Pending"]
+pub type EipndW<'a, REG> = crate::BitWriter<'a, REG>;
+impl R {
+    #[doc = "Bits 0:14 - Buffer Interrupt Pending\\[14:0\\]"]
+    #[inline(always)]
+    pub fn ipnd(&self) -> IpndR {
+        IpndR::new((self.bits & 0x7fff) as u16)
+    }
+    #[doc = "Bit 15 - Error Interrupt Pending"]
+    #[inline(always)]
+    pub fn eipnd(&self) -> EipndR {
+        EipndR::new(((self.bits >> 15) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bits 0:14 - Buffer Interrupt Pending\\[14:0\\]"]
+    #[inline(always)]
+    #[must_use]
+    pub fn ipnd(&mut self) -> IpndW<CipndSpec> {
+        IpndW::new(self, 0)
+    }
+    #[doc = "Bit 15 - Error Interrupt Pending"]
+    #[inline(always)]
+    #[must_use]
+    pub fn eipnd(&mut self) -> EipndW<CipndSpec> {
+        EipndW::new(self, 15)
+    }
+}
+#[doc = "CAN Interrupt Pending Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cipnd::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cipnd::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CipndSpec;
+impl crate::RegisterSpec for CipndSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cipnd::R`](R) reader structure"]
+impl crate::Readable for CipndSpec {}
+#[doc = "`write(|w| ..)` method takes [`cipnd::W`](W) writer structure"]
+impl crate::Writable for CipndSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CIPND to value 0"]
+impl crate::Resettable for CipndSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cnstat_cmb0.rs

@@ -0,0 +1,70 @@
+#[doc = "Register `CNSTAT_CMB0` reader"]
+pub type R = crate::R<CnstatCmb0Spec>;
+#[doc = "Register `CNSTAT_CMB0` writer"]
+pub type W = crate::W<CnstatCmb0Spec>;
+#[doc = "Field `ST` reader - Buffer Status"]
+pub type StR = crate::FieldReader;
+#[doc = "Field `ST` writer - Buffer Status"]
+pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `PRI` reader - Transmit Priority Code"]
+pub type PriR = crate::FieldReader;
+#[doc = "Field `PRI` writer - Transmit Priority Code"]
+pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `DLC` reader - Data Length Code"]
+pub type DlcR = crate::FieldReader;
+#[doc = "Field `DLC` writer - Data Length Code"]
+pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+impl R {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    pub fn st(&self) -> StR {
+        StR::new((self.bits & 0x0f) as u8)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    pub fn pri(&self) -> PriR {
+        PriR::new(((self.bits >> 4) & 0x0f) as u8)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    pub fn dlc(&self) -> DlcR {
+        DlcR::new(((self.bits >> 12) & 0x0f) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    #[must_use]
+    pub fn st(&mut self) -> StW<CnstatCmb0Spec> {
+        StW::new(self, 0)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn pri(&mut self) -> PriW<CnstatCmb0Spec> {
+        PriW::new(self, 4)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn dlc(&mut self) -> DlcW<CnstatCmb0Spec> {
+        DlcW::new(self, 12)
+    }
+}
+#[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb0::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb0::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CnstatCmb0Spec;
+impl crate::RegisterSpec for CnstatCmb0Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cnstat_cmb0::R`](R) reader structure"]
+impl crate::Readable for CnstatCmb0Spec {}
+#[doc = "`write(|w| ..)` method takes [`cnstat_cmb0::W`](W) writer structure"]
+impl crate::Writable for CnstatCmb0Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CNSTAT_CMB0 to value 0"]
+impl crate::Resettable for CnstatCmb0Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cnstat_cmb1.rs

@@ -0,0 +1,70 @@
+#[doc = "Register `CNSTAT_CMB1` reader"]
+pub type R = crate::R<CnstatCmb1Spec>;
+#[doc = "Register `CNSTAT_CMB1` writer"]
+pub type W = crate::W<CnstatCmb1Spec>;
+#[doc = "Field `ST` reader - Buffer Status"]
+pub type StR = crate::FieldReader;
+#[doc = "Field `ST` writer - Buffer Status"]
+pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `PRI` reader - Transmit Priority Code"]
+pub type PriR = crate::FieldReader;
+#[doc = "Field `PRI` writer - Transmit Priority Code"]
+pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `DLC` reader - Data Length Code"]
+pub type DlcR = crate::FieldReader;
+#[doc = "Field `DLC` writer - Data Length Code"]
+pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+impl R {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    pub fn st(&self) -> StR {
+        StR::new((self.bits & 0x0f) as u8)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    pub fn pri(&self) -> PriR {
+        PriR::new(((self.bits >> 4) & 0x0f) as u8)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    pub fn dlc(&self) -> DlcR {
+        DlcR::new(((self.bits >> 12) & 0x0f) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    #[must_use]
+    pub fn st(&mut self) -> StW<CnstatCmb1Spec> {
+        StW::new(self, 0)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn pri(&mut self) -> PriW<CnstatCmb1Spec> {
+        PriW::new(self, 4)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn dlc(&mut self) -> DlcW<CnstatCmb1Spec> {
+        DlcW::new(self, 12)
+    }
+}
+#[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb1::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb1::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CnstatCmb1Spec;
+impl crate::RegisterSpec for CnstatCmb1Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cnstat_cmb1::R`](R) reader structure"]
+impl crate::Readable for CnstatCmb1Spec {}
+#[doc = "`write(|w| ..)` method takes [`cnstat_cmb1::W`](W) writer structure"]
+impl crate::Writable for CnstatCmb1Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CNSTAT_CMB1 to value 0"]
+impl crate::Resettable for CnstatCmb1Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cnstat_cmb10.rs

@@ -0,0 +1,70 @@
+#[doc = "Register `CNSTAT_CMB10` reader"]
+pub type R = crate::R<CnstatCmb10Spec>;
+#[doc = "Register `CNSTAT_CMB10` writer"]
+pub type W = crate::W<CnstatCmb10Spec>;
+#[doc = "Field `ST` reader - Buffer Status"]
+pub type StR = crate::FieldReader;
+#[doc = "Field `ST` writer - Buffer Status"]
+pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `PRI` reader - Transmit Priority Code"]
+pub type PriR = crate::FieldReader;
+#[doc = "Field `PRI` writer - Transmit Priority Code"]
+pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `DLC` reader - Data Length Code"]
+pub type DlcR = crate::FieldReader;
+#[doc = "Field `DLC` writer - Data Length Code"]
+pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+impl R {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    pub fn st(&self) -> StR {
+        StR::new((self.bits & 0x0f) as u8)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    pub fn pri(&self) -> PriR {
+        PriR::new(((self.bits >> 4) & 0x0f) as u8)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    pub fn dlc(&self) -> DlcR {
+        DlcR::new(((self.bits >> 12) & 0x0f) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    #[must_use]
+    pub fn st(&mut self) -> StW<CnstatCmb10Spec> {
+        StW::new(self, 0)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn pri(&mut self) -> PriW<CnstatCmb10Spec> {
+        PriW::new(self, 4)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn dlc(&mut self) -> DlcW<CnstatCmb10Spec> {
+        DlcW::new(self, 12)
+    }
+}
+#[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb10::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb10::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CnstatCmb10Spec;
+impl crate::RegisterSpec for CnstatCmb10Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cnstat_cmb10::R`](R) reader structure"]
+impl crate::Readable for CnstatCmb10Spec {}
+#[doc = "`write(|w| ..)` method takes [`cnstat_cmb10::W`](W) writer structure"]
+impl crate::Writable for CnstatCmb10Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CNSTAT_CMB10 to value 0"]
+impl crate::Resettable for CnstatCmb10Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cnstat_cmb11.rs

@@ -0,0 +1,70 @@
+#[doc = "Register `CNSTAT_CMB11` reader"]
+pub type R = crate::R<CnstatCmb11Spec>;
+#[doc = "Register `CNSTAT_CMB11` writer"]
+pub type W = crate::W<CnstatCmb11Spec>;
+#[doc = "Field `ST` reader - Buffer Status"]
+pub type StR = crate::FieldReader;
+#[doc = "Field `ST` writer - Buffer Status"]
+pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `PRI` reader - Transmit Priority Code"]
+pub type PriR = crate::FieldReader;
+#[doc = "Field `PRI` writer - Transmit Priority Code"]
+pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `DLC` reader - Data Length Code"]
+pub type DlcR = crate::FieldReader;
+#[doc = "Field `DLC` writer - Data Length Code"]
+pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+impl R {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    pub fn st(&self) -> StR {
+        StR::new((self.bits & 0x0f) as u8)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    pub fn pri(&self) -> PriR {
+        PriR::new(((self.bits >> 4) & 0x0f) as u8)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    pub fn dlc(&self) -> DlcR {
+        DlcR::new(((self.bits >> 12) & 0x0f) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    #[must_use]
+    pub fn st(&mut self) -> StW<CnstatCmb11Spec> {
+        StW::new(self, 0)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn pri(&mut self) -> PriW<CnstatCmb11Spec> {
+        PriW::new(self, 4)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn dlc(&mut self) -> DlcW<CnstatCmb11Spec> {
+        DlcW::new(self, 12)
+    }
+}
+#[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb11::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb11::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CnstatCmb11Spec;
+impl crate::RegisterSpec for CnstatCmb11Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cnstat_cmb11::R`](R) reader structure"]
+impl crate::Readable for CnstatCmb11Spec {}
+#[doc = "`write(|w| ..)` method takes [`cnstat_cmb11::W`](W) writer structure"]
+impl crate::Writable for CnstatCmb11Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CNSTAT_CMB11 to value 0"]
+impl crate::Resettable for CnstatCmb11Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cnstat_cmb12.rs

@@ -0,0 +1,70 @@
+#[doc = "Register `CNSTAT_CMB12` reader"]
+pub type R = crate::R<CnstatCmb12Spec>;
+#[doc = "Register `CNSTAT_CMB12` writer"]
+pub type W = crate::W<CnstatCmb12Spec>;
+#[doc = "Field `ST` reader - Buffer Status"]
+pub type StR = crate::FieldReader;
+#[doc = "Field `ST` writer - Buffer Status"]
+pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `PRI` reader - Transmit Priority Code"]
+pub type PriR = crate::FieldReader;
+#[doc = "Field `PRI` writer - Transmit Priority Code"]
+pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `DLC` reader - Data Length Code"]
+pub type DlcR = crate::FieldReader;
+#[doc = "Field `DLC` writer - Data Length Code"]
+pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+impl R {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    pub fn st(&self) -> StR {
+        StR::new((self.bits & 0x0f) as u8)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    pub fn pri(&self) -> PriR {
+        PriR::new(((self.bits >> 4) & 0x0f) as u8)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    pub fn dlc(&self) -> DlcR {
+        DlcR::new(((self.bits >> 12) & 0x0f) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    #[must_use]
+    pub fn st(&mut self) -> StW<CnstatCmb12Spec> {
+        StW::new(self, 0)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn pri(&mut self) -> PriW<CnstatCmb12Spec> {
+        PriW::new(self, 4)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn dlc(&mut self) -> DlcW<CnstatCmb12Spec> {
+        DlcW::new(self, 12)
+    }
+}
+#[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb12::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb12::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CnstatCmb12Spec;
+impl crate::RegisterSpec for CnstatCmb12Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cnstat_cmb12::R`](R) reader structure"]
+impl crate::Readable for CnstatCmb12Spec {}
+#[doc = "`write(|w| ..)` method takes [`cnstat_cmb12::W`](W) writer structure"]
+impl crate::Writable for CnstatCmb12Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CNSTAT_CMB12 to value 0"]
+impl crate::Resettable for CnstatCmb12Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cnstat_cmb13.rs

@@ -0,0 +1,70 @@
+#[doc = "Register `CNSTAT_CMB13` reader"]
+pub type R = crate::R<CnstatCmb13Spec>;
+#[doc = "Register `CNSTAT_CMB13` writer"]
+pub type W = crate::W<CnstatCmb13Spec>;
+#[doc = "Field `ST` reader - Buffer Status"]
+pub type StR = crate::FieldReader;
+#[doc = "Field `ST` writer - Buffer Status"]
+pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `PRI` reader - Transmit Priority Code"]
+pub type PriR = crate::FieldReader;
+#[doc = "Field `PRI` writer - Transmit Priority Code"]
+pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `DLC` reader - Data Length Code"]
+pub type DlcR = crate::FieldReader;
+#[doc = "Field `DLC` writer - Data Length Code"]
+pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+impl R {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    pub fn st(&self) -> StR {
+        StR::new((self.bits & 0x0f) as u8)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    pub fn pri(&self) -> PriR {
+        PriR::new(((self.bits >> 4) & 0x0f) as u8)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    pub fn dlc(&self) -> DlcR {
+        DlcR::new(((self.bits >> 12) & 0x0f) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    #[must_use]
+    pub fn st(&mut self) -> StW<CnstatCmb13Spec> {
+        StW::new(self, 0)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn pri(&mut self) -> PriW<CnstatCmb13Spec> {
+        PriW::new(self, 4)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn dlc(&mut self) -> DlcW<CnstatCmb13Spec> {
+        DlcW::new(self, 12)
+    }
+}
+#[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb13::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb13::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CnstatCmb13Spec;
+impl crate::RegisterSpec for CnstatCmb13Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cnstat_cmb13::R`](R) reader structure"]
+impl crate::Readable for CnstatCmb13Spec {}
+#[doc = "`write(|w| ..)` method takes [`cnstat_cmb13::W`](W) writer structure"]
+impl crate::Writable for CnstatCmb13Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CNSTAT_CMB13 to value 0"]
+impl crate::Resettable for CnstatCmb13Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cnstat_cmb14.rs

@@ -0,0 +1,70 @@
+#[doc = "Register `CNSTAT_CMB14` reader"]
+pub type R = crate::R<CnstatCmb14Spec>;
+#[doc = "Register `CNSTAT_CMB14` writer"]
+pub type W = crate::W<CnstatCmb14Spec>;
+#[doc = "Field `ST` reader - Buffer Status"]
+pub type StR = crate::FieldReader;
+#[doc = "Field `ST` writer - Buffer Status"]
+pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `PRI` reader - Transmit Priority Code"]
+pub type PriR = crate::FieldReader;
+#[doc = "Field `PRI` writer - Transmit Priority Code"]
+pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `DLC` reader - Data Length Code"]
+pub type DlcR = crate::FieldReader;
+#[doc = "Field `DLC` writer - Data Length Code"]
+pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+impl R {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    pub fn st(&self) -> StR {
+        StR::new((self.bits & 0x0f) as u8)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    pub fn pri(&self) -> PriR {
+        PriR::new(((self.bits >> 4) & 0x0f) as u8)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    pub fn dlc(&self) -> DlcR {
+        DlcR::new(((self.bits >> 12) & 0x0f) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    #[must_use]
+    pub fn st(&mut self) -> StW<CnstatCmb14Spec> {
+        StW::new(self, 0)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn pri(&mut self) -> PriW<CnstatCmb14Spec> {
+        PriW::new(self, 4)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn dlc(&mut self) -> DlcW<CnstatCmb14Spec> {
+        DlcW::new(self, 12)
+    }
+}
+#[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb14::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb14::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CnstatCmb14Spec;
+impl crate::RegisterSpec for CnstatCmb14Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cnstat_cmb14::R`](R) reader structure"]
+impl crate::Readable for CnstatCmb14Spec {}
+#[doc = "`write(|w| ..)` method takes [`cnstat_cmb14::W`](W) writer structure"]
+impl crate::Writable for CnstatCmb14Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CNSTAT_CMB14 to value 0"]
+impl crate::Resettable for CnstatCmb14Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cnstat_cmb2.rs

@@ -0,0 +1,70 @@
+#[doc = "Register `CNSTAT_CMB2` reader"]
+pub type R = crate::R<CnstatCmb2Spec>;
+#[doc = "Register `CNSTAT_CMB2` writer"]
+pub type W = crate::W<CnstatCmb2Spec>;
+#[doc = "Field `ST` reader - Buffer Status"]
+pub type StR = crate::FieldReader;
+#[doc = "Field `ST` writer - Buffer Status"]
+pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `PRI` reader - Transmit Priority Code"]
+pub type PriR = crate::FieldReader;
+#[doc = "Field `PRI` writer - Transmit Priority Code"]
+pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `DLC` reader - Data Length Code"]
+pub type DlcR = crate::FieldReader;
+#[doc = "Field `DLC` writer - Data Length Code"]
+pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+impl R {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    pub fn st(&self) -> StR {
+        StR::new((self.bits & 0x0f) as u8)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    pub fn pri(&self) -> PriR {
+        PriR::new(((self.bits >> 4) & 0x0f) as u8)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    pub fn dlc(&self) -> DlcR {
+        DlcR::new(((self.bits >> 12) & 0x0f) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    #[must_use]
+    pub fn st(&mut self) -> StW<CnstatCmb2Spec> {
+        StW::new(self, 0)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn pri(&mut self) -> PriW<CnstatCmb2Spec> {
+        PriW::new(self, 4)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn dlc(&mut self) -> DlcW<CnstatCmb2Spec> {
+        DlcW::new(self, 12)
+    }
+}
+#[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb2::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb2::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CnstatCmb2Spec;
+impl crate::RegisterSpec for CnstatCmb2Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cnstat_cmb2::R`](R) reader structure"]
+impl crate::Readable for CnstatCmb2Spec {}
+#[doc = "`write(|w| ..)` method takes [`cnstat_cmb2::W`](W) writer structure"]
+impl crate::Writable for CnstatCmb2Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CNSTAT_CMB2 to value 0"]
+impl crate::Resettable for CnstatCmb2Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cnstat_cmb3.rs

@@ -0,0 +1,70 @@
+#[doc = "Register `CNSTAT_CMB3` reader"]
+pub type R = crate::R<CnstatCmb3Spec>;
+#[doc = "Register `CNSTAT_CMB3` writer"]
+pub type W = crate::W<CnstatCmb3Spec>;
+#[doc = "Field `ST` reader - Buffer Status"]
+pub type StR = crate::FieldReader;
+#[doc = "Field `ST` writer - Buffer Status"]
+pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `PRI` reader - Transmit Priority Code"]
+pub type PriR = crate::FieldReader;
+#[doc = "Field `PRI` writer - Transmit Priority Code"]
+pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `DLC` reader - Data Length Code"]
+pub type DlcR = crate::FieldReader;
+#[doc = "Field `DLC` writer - Data Length Code"]
+pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+impl R {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    pub fn st(&self) -> StR {
+        StR::new((self.bits & 0x0f) as u8)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    pub fn pri(&self) -> PriR {
+        PriR::new(((self.bits >> 4) & 0x0f) as u8)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    pub fn dlc(&self) -> DlcR {
+        DlcR::new(((self.bits >> 12) & 0x0f) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    #[must_use]
+    pub fn st(&mut self) -> StW<CnstatCmb3Spec> {
+        StW::new(self, 0)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn pri(&mut self) -> PriW<CnstatCmb3Spec> {
+        PriW::new(self, 4)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn dlc(&mut self) -> DlcW<CnstatCmb3Spec> {
+        DlcW::new(self, 12)
+    }
+}
+#[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb3::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb3::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CnstatCmb3Spec;
+impl crate::RegisterSpec for CnstatCmb3Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cnstat_cmb3::R`](R) reader structure"]
+impl crate::Readable for CnstatCmb3Spec {}
+#[doc = "`write(|w| ..)` method takes [`cnstat_cmb3::W`](W) writer structure"]
+impl crate::Writable for CnstatCmb3Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CNSTAT_CMB3 to value 0"]
+impl crate::Resettable for CnstatCmb3Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cnstat_cmb4.rs

@@ -0,0 +1,70 @@
+#[doc = "Register `CNSTAT_CMB4` reader"]
+pub type R = crate::R<CnstatCmb4Spec>;
+#[doc = "Register `CNSTAT_CMB4` writer"]
+pub type W = crate::W<CnstatCmb4Spec>;
+#[doc = "Field `ST` reader - Buffer Status"]
+pub type StR = crate::FieldReader;
+#[doc = "Field `ST` writer - Buffer Status"]
+pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `PRI` reader - Transmit Priority Code"]
+pub type PriR = crate::FieldReader;
+#[doc = "Field `PRI` writer - Transmit Priority Code"]
+pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `DLC` reader - Data Length Code"]
+pub type DlcR = crate::FieldReader;
+#[doc = "Field `DLC` writer - Data Length Code"]
+pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+impl R {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    pub fn st(&self) -> StR {
+        StR::new((self.bits & 0x0f) as u8)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    pub fn pri(&self) -> PriR {
+        PriR::new(((self.bits >> 4) & 0x0f) as u8)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    pub fn dlc(&self) -> DlcR {
+        DlcR::new(((self.bits >> 12) & 0x0f) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    #[must_use]
+    pub fn st(&mut self) -> StW<CnstatCmb4Spec> {
+        StW::new(self, 0)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn pri(&mut self) -> PriW<CnstatCmb4Spec> {
+        PriW::new(self, 4)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn dlc(&mut self) -> DlcW<CnstatCmb4Spec> {
+        DlcW::new(self, 12)
+    }
+}
+#[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb4::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb4::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CnstatCmb4Spec;
+impl crate::RegisterSpec for CnstatCmb4Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cnstat_cmb4::R`](R) reader structure"]
+impl crate::Readable for CnstatCmb4Spec {}
+#[doc = "`write(|w| ..)` method takes [`cnstat_cmb4::W`](W) writer structure"]
+impl crate::Writable for CnstatCmb4Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CNSTAT_CMB4 to value 0"]
+impl crate::Resettable for CnstatCmb4Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cnstat_cmb5.rs

@@ -0,0 +1,70 @@
+#[doc = "Register `CNSTAT_CMB5` reader"]
+pub type R = crate::R<CnstatCmb5Spec>;
+#[doc = "Register `CNSTAT_CMB5` writer"]
+pub type W = crate::W<CnstatCmb5Spec>;
+#[doc = "Field `ST` reader - Buffer Status"]
+pub type StR = crate::FieldReader;
+#[doc = "Field `ST` writer - Buffer Status"]
+pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `PRI` reader - Transmit Priority Code"]
+pub type PriR = crate::FieldReader;
+#[doc = "Field `PRI` writer - Transmit Priority Code"]
+pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `DLC` reader - Data Length Code"]
+pub type DlcR = crate::FieldReader;
+#[doc = "Field `DLC` writer - Data Length Code"]
+pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+impl R {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    pub fn st(&self) -> StR {
+        StR::new((self.bits & 0x0f) as u8)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    pub fn pri(&self) -> PriR {
+        PriR::new(((self.bits >> 4) & 0x0f) as u8)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    pub fn dlc(&self) -> DlcR {
+        DlcR::new(((self.bits >> 12) & 0x0f) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    #[must_use]
+    pub fn st(&mut self) -> StW<CnstatCmb5Spec> {
+        StW::new(self, 0)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn pri(&mut self) -> PriW<CnstatCmb5Spec> {
+        PriW::new(self, 4)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn dlc(&mut self) -> DlcW<CnstatCmb5Spec> {
+        DlcW::new(self, 12)
+    }
+}
+#[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb5::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb5::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CnstatCmb5Spec;
+impl crate::RegisterSpec for CnstatCmb5Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cnstat_cmb5::R`](R) reader structure"]
+impl crate::Readable for CnstatCmb5Spec {}
+#[doc = "`write(|w| ..)` method takes [`cnstat_cmb5::W`](W) writer structure"]
+impl crate::Writable for CnstatCmb5Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CNSTAT_CMB5 to value 0"]
+impl crate::Resettable for CnstatCmb5Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cnstat_cmb6.rs

@@ -0,0 +1,70 @@
+#[doc = "Register `CNSTAT_CMB6` reader"]
+pub type R = crate::R<CnstatCmb6Spec>;
+#[doc = "Register `CNSTAT_CMB6` writer"]
+pub type W = crate::W<CnstatCmb6Spec>;
+#[doc = "Field `ST` reader - Buffer Status"]
+pub type StR = crate::FieldReader;
+#[doc = "Field `ST` writer - Buffer Status"]
+pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `PRI` reader - Transmit Priority Code"]
+pub type PriR = crate::FieldReader;
+#[doc = "Field `PRI` writer - Transmit Priority Code"]
+pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `DLC` reader - Data Length Code"]
+pub type DlcR = crate::FieldReader;
+#[doc = "Field `DLC` writer - Data Length Code"]
+pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+impl R {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    pub fn st(&self) -> StR {
+        StR::new((self.bits & 0x0f) as u8)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    pub fn pri(&self) -> PriR {
+        PriR::new(((self.bits >> 4) & 0x0f) as u8)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    pub fn dlc(&self) -> DlcR {
+        DlcR::new(((self.bits >> 12) & 0x0f) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    #[must_use]
+    pub fn st(&mut self) -> StW<CnstatCmb6Spec> {
+        StW::new(self, 0)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn pri(&mut self) -> PriW<CnstatCmb6Spec> {
+        PriW::new(self, 4)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn dlc(&mut self) -> DlcW<CnstatCmb6Spec> {
+        DlcW::new(self, 12)
+    }
+}
+#[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb6::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb6::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CnstatCmb6Spec;
+impl crate::RegisterSpec for CnstatCmb6Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cnstat_cmb6::R`](R) reader structure"]
+impl crate::Readable for CnstatCmb6Spec {}
+#[doc = "`write(|w| ..)` method takes [`cnstat_cmb6::W`](W) writer structure"]
+impl crate::Writable for CnstatCmb6Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CNSTAT_CMB6 to value 0"]
+impl crate::Resettable for CnstatCmb6Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cnstat_cmb7.rs

@@ -0,0 +1,70 @@
+#[doc = "Register `CNSTAT_CMB7` reader"]
+pub type R = crate::R<CnstatCmb7Spec>;
+#[doc = "Register `CNSTAT_CMB7` writer"]
+pub type W = crate::W<CnstatCmb7Spec>;
+#[doc = "Field `ST` reader - Buffer Status"]
+pub type StR = crate::FieldReader;
+#[doc = "Field `ST` writer - Buffer Status"]
+pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `PRI` reader - Transmit Priority Code"]
+pub type PriR = crate::FieldReader;
+#[doc = "Field `PRI` writer - Transmit Priority Code"]
+pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `DLC` reader - Data Length Code"]
+pub type DlcR = crate::FieldReader;
+#[doc = "Field `DLC` writer - Data Length Code"]
+pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+impl R {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    pub fn st(&self) -> StR {
+        StR::new((self.bits & 0x0f) as u8)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    pub fn pri(&self) -> PriR {
+        PriR::new(((self.bits >> 4) & 0x0f) as u8)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    pub fn dlc(&self) -> DlcR {
+        DlcR::new(((self.bits >> 12) & 0x0f) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    #[must_use]
+    pub fn st(&mut self) -> StW<CnstatCmb7Spec> {
+        StW::new(self, 0)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn pri(&mut self) -> PriW<CnstatCmb7Spec> {
+        PriW::new(self, 4)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn dlc(&mut self) -> DlcW<CnstatCmb7Spec> {
+        DlcW::new(self, 12)
+    }
+}
+#[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb7::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb7::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CnstatCmb7Spec;
+impl crate::RegisterSpec for CnstatCmb7Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cnstat_cmb7::R`](R) reader structure"]
+impl crate::Readable for CnstatCmb7Spec {}
+#[doc = "`write(|w| ..)` method takes [`cnstat_cmb7::W`](W) writer structure"]
+impl crate::Writable for CnstatCmb7Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CNSTAT_CMB7 to value 0"]
+impl crate::Resettable for CnstatCmb7Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cnstat_cmb8.rs

@@ -0,0 +1,70 @@
+#[doc = "Register `CNSTAT_CMB8` reader"]
+pub type R = crate::R<CnstatCmb8Spec>;
+#[doc = "Register `CNSTAT_CMB8` writer"]
+pub type W = crate::W<CnstatCmb8Spec>;
+#[doc = "Field `ST` reader - Buffer Status"]
+pub type StR = crate::FieldReader;
+#[doc = "Field `ST` writer - Buffer Status"]
+pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `PRI` reader - Transmit Priority Code"]
+pub type PriR = crate::FieldReader;
+#[doc = "Field `PRI` writer - Transmit Priority Code"]
+pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `DLC` reader - Data Length Code"]
+pub type DlcR = crate::FieldReader;
+#[doc = "Field `DLC` writer - Data Length Code"]
+pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+impl R {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    pub fn st(&self) -> StR {
+        StR::new((self.bits & 0x0f) as u8)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    pub fn pri(&self) -> PriR {
+        PriR::new(((self.bits >> 4) & 0x0f) as u8)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    pub fn dlc(&self) -> DlcR {
+        DlcR::new(((self.bits >> 12) & 0x0f) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    #[must_use]
+    pub fn st(&mut self) -> StW<CnstatCmb8Spec> {
+        StW::new(self, 0)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn pri(&mut self) -> PriW<CnstatCmb8Spec> {
+        PriW::new(self, 4)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn dlc(&mut self) -> DlcW<CnstatCmb8Spec> {
+        DlcW::new(self, 12)
+    }
+}
+#[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb8::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb8::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CnstatCmb8Spec;
+impl crate::RegisterSpec for CnstatCmb8Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cnstat_cmb8::R`](R) reader structure"]
+impl crate::Readable for CnstatCmb8Spec {}
+#[doc = "`write(|w| ..)` method takes [`cnstat_cmb8::W`](W) writer structure"]
+impl crate::Writable for CnstatCmb8Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CNSTAT_CMB8 to value 0"]
+impl crate::Resettable for CnstatCmb8Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cnstat_cmb9.rs

@@ -0,0 +1,70 @@
+#[doc = "Register `CNSTAT_CMB9` reader"]
+pub type R = crate::R<CnstatCmb9Spec>;
+#[doc = "Register `CNSTAT_CMB9` writer"]
+pub type W = crate::W<CnstatCmb9Spec>;
+#[doc = "Field `ST` reader - Buffer Status"]
+pub type StR = crate::FieldReader;
+#[doc = "Field `ST` writer - Buffer Status"]
+pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `PRI` reader - Transmit Priority Code"]
+pub type PriR = crate::FieldReader;
+#[doc = "Field `PRI` writer - Transmit Priority Code"]
+pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `DLC` reader - Data Length Code"]
+pub type DlcR = crate::FieldReader;
+#[doc = "Field `DLC` writer - Data Length Code"]
+pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+impl R {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    pub fn st(&self) -> StR {
+        StR::new((self.bits & 0x0f) as u8)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    pub fn pri(&self) -> PriR {
+        PriR::new(((self.bits >> 4) & 0x0f) as u8)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    pub fn dlc(&self) -> DlcR {
+        DlcR::new(((self.bits >> 12) & 0x0f) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    #[must_use]
+    pub fn st(&mut self) -> StW<CnstatCmb9Spec> {
+        StW::new(self, 0)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn pri(&mut self) -> PriW<CnstatCmb9Spec> {
+        PriW::new(self, 4)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn dlc(&mut self) -> DlcW<CnstatCmb9Spec> {
+        DlcW::new(self, 12)
+    }
+}
+#[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb9::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb9::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CnstatCmb9Spec;
+impl crate::RegisterSpec for CnstatCmb9Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cnstat_cmb9::R`](R) reader structure"]
+impl crate::Readable for CnstatCmb9Spec {}
+#[doc = "`write(|w| ..)` method takes [`cnstat_cmb9::W`](W) writer structure"]
+impl crate::Writable for CnstatCmb9Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CNSTAT_CMB9 to value 0"]
+impl crate::Resettable for CnstatCmb9Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cnstat_hcmb.rs

@@ -0,0 +1,70 @@
+#[doc = "Register `CNSTAT_HCMB` reader"]
+pub type R = crate::R<CnstatHcmbSpec>;
+#[doc = "Register `CNSTAT_HCMB` writer"]
+pub type W = crate::W<CnstatHcmbSpec>;
+#[doc = "Field `ST` reader - Buffer Status"]
+pub type StR = crate::FieldReader;
+#[doc = "Field `ST` writer - Buffer Status"]
+pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `PRI` reader - Transmit Priority Code"]
+pub type PriR = crate::FieldReader;
+#[doc = "Field `PRI` writer - Transmit Priority Code"]
+pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `DLC` reader - Data Length Code"]
+pub type DlcR = crate::FieldReader;
+#[doc = "Field `DLC` writer - Data Length Code"]
+pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+impl R {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    pub fn st(&self) -> StR {
+        StR::new((self.bits & 0x0f) as u8)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    pub fn pri(&self) -> PriR {
+        PriR::new(((self.bits >> 4) & 0x0f) as u8)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    pub fn dlc(&self) -> DlcR {
+        DlcR::new(((self.bits >> 12) & 0x0f) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:3 - Buffer Status"]
+    #[inline(always)]
+    #[must_use]
+    pub fn st(&mut self) -> StW<CnstatHcmbSpec> {
+        StW::new(self, 0)
+    }
+    #[doc = "Bits 4:7 - Transmit Priority Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn pri(&mut self) -> PriW<CnstatHcmbSpec> {
+        PriW::new(self, 4)
+    }
+    #[doc = "Bits 12:15 - Data Length Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn dlc(&mut self) -> DlcW<CnstatHcmbSpec> {
+        DlcW::new(self, 12)
+    }
+}
+#[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_hcmb::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_hcmb::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CnstatHcmbSpec;
+impl crate::RegisterSpec for CnstatHcmbSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cnstat_hcmb::R`](R) reader structure"]
+impl crate::Readable for CnstatHcmbSpec {}
+#[doc = "`write(|w| ..)` method takes [`cnstat_hcmb::W`](W) writer structure"]
+impl crate::Writable for CnstatHcmbSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CNSTAT_HCMB to value 0"]
+impl crate::Resettable for CnstatHcmbSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/cstpnd.rs

@@ -0,0 +1,70 @@
+#[doc = "Register `CSTPND` reader"]
+pub type R = crate::R<CstpndSpec>;
+#[doc = "Register `CSTPND` writer"]
+pub type W = crate::W<CstpndSpec>;
+#[doc = "Field `IST` reader - Interrupt Source portion of Interrupt Code"]
+pub type IstR = crate::FieldReader;
+#[doc = "Field `IST` writer - Interrupt Source portion of Interrupt Code"]
+pub type IstW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `IRQ` reader - Interrupt Request portion of Interrupt Code"]
+pub type IrqR = crate::BitReader;
+#[doc = "Field `IRQ` writer - Interrupt Request portion of Interrupt Code"]
+pub type IrqW<'a, REG> = crate::BitWriter<'a, REG>;
+#[doc = "Field `NS` reader - CAN Node Status"]
+pub type NsR = crate::FieldReader;
+#[doc = "Field `NS` writer - CAN Node Status"]
+pub type NsW<'a, REG> = crate::FieldWriter<'a, REG, 3>;
+impl R {
+    #[doc = "Bits 0:3 - Interrupt Source portion of Interrupt Code"]
+    #[inline(always)]
+    pub fn ist(&self) -> IstR {
+        IstR::new((self.bits & 0x0f) as u8)
+    }
+    #[doc = "Bit 4 - Interrupt Request portion of Interrupt Code"]
+    #[inline(always)]
+    pub fn irq(&self) -> IrqR {
+        IrqR::new(((self.bits >> 4) & 1) != 0)
+    }
+    #[doc = "Bits 5:7 - CAN Node Status"]
+    #[inline(always)]
+    pub fn ns(&self) -> NsR {
+        NsR::new(((self.bits >> 5) & 7) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:3 - Interrupt Source portion of Interrupt Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn ist(&mut self) -> IstW<CstpndSpec> {
+        IstW::new(self, 0)
+    }
+    #[doc = "Bit 4 - Interrupt Request portion of Interrupt Code"]
+    #[inline(always)]
+    #[must_use]
+    pub fn irq(&mut self) -> IrqW<CstpndSpec> {
+        IrqW::new(self, 4)
+    }
+    #[doc = "Bits 5:7 - CAN Node Status"]
+    #[inline(always)]
+    #[must_use]
+    pub fn ns(&mut self) -> NsW<CstpndSpec> {
+        NsW::new(self, 5)
+    }
+}
+#[doc = "CAN Status Pending Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cstpnd::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cstpnd::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CstpndSpec;
+impl crate::RegisterSpec for CstpndSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`cstpnd::R`](R) reader structure"]
+impl crate::Readable for CstpndSpec {}
+#[doc = "`write(|w| ..)` method takes [`cstpnd::W`](W) writer structure"]
+impl crate::Writable for CstpndSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CSTPND to value 0"]
+impl crate::Resettable for CstpndSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/ctim.rs

@@ -0,0 +1,85 @@
+#[doc = "Register `CTIM` reader"]
+pub type R = crate::R<CtimSpec>;
+#[doc = "Register `CTIM` writer"]
+pub type W = crate::W<CtimSpec>;
+#[doc = "Field `TSEG2` reader - Time Segment 2"]
+pub type Tseg2R = crate::FieldReader;
+#[doc = "Field `TSEG2` writer - Time Segment 2"]
+pub type Tseg2W<'a, REG> = crate::FieldWriter<'a, REG, 3>;
+#[doc = "Field `TSEG1` reader - Time Segment 1"]
+pub type Tseg1R = crate::FieldReader;
+#[doc = "Field `TSEG1` writer - Time Segment 1"]
+pub type Tseg1W<'a, REG> = crate::FieldWriter<'a, REG, 4>;
+#[doc = "Field `SJW` reader - Synchronization Jump Width"]
+pub type SjwR = crate::FieldReader;
+#[doc = "Field `SJW` writer - Synchronization Jump Width"]
+pub type SjwW<'a, REG> = crate::FieldWriter<'a, REG, 2>;
+#[doc = "Field `PSC` reader - Prescaler Configuration"]
+pub type PscR = crate::FieldReader;
+#[doc = "Field `PSC` writer - Prescaler Configuration"]
+pub type PscW<'a, REG> = crate::FieldWriter<'a, REG, 7>;
+impl R {
+    #[doc = "Bits 0:2 - Time Segment 2"]
+    #[inline(always)]
+    pub fn tseg2(&self) -> Tseg2R {
+        Tseg2R::new((self.bits & 7) as u8)
+    }
+    #[doc = "Bits 3:6 - Time Segment 1"]
+    #[inline(always)]
+    pub fn tseg1(&self) -> Tseg1R {
+        Tseg1R::new(((self.bits >> 3) & 0x0f) as u8)
+    }
+    #[doc = "Bits 7:8 - Synchronization Jump Width"]
+    #[inline(always)]
+    pub fn sjw(&self) -> SjwR {
+        SjwR::new(((self.bits >> 7) & 3) as u8)
+    }
+    #[doc = "Bits 9:15 - Prescaler Configuration"]
+    #[inline(always)]
+    pub fn psc(&self) -> PscR {
+        PscR::new(((self.bits >> 9) & 0x7f) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:2 - Time Segment 2"]
+    #[inline(always)]
+    #[must_use]
+    pub fn tseg2(&mut self) -> Tseg2W<CtimSpec> {
+        Tseg2W::new(self, 0)
+    }
+    #[doc = "Bits 3:6 - Time Segment 1"]
+    #[inline(always)]
+    #[must_use]
+    pub fn tseg1(&mut self) -> Tseg1W<CtimSpec> {
+        Tseg1W::new(self, 3)
+    }
+    #[doc = "Bits 7:8 - Synchronization Jump Width"]
+    #[inline(always)]
+    #[must_use]
+    pub fn sjw(&mut self) -> SjwW<CtimSpec> {
+        SjwW::new(self, 7)
+    }
+    #[doc = "Bits 9:15 - Prescaler Configuration"]
+    #[inline(always)]
+    #[must_use]
+    pub fn psc(&mut self) -> PscW<CtimSpec> {
+        PscW::new(self, 9)
+    }
+}
+#[doc = "CAN Timing Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`ctim::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`ctim::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CtimSpec;
+impl crate::RegisterSpec for CtimSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`ctim::R`](R) reader structure"]
+impl crate::Readable for CtimSpec {}
+#[doc = "`write(|w| ..)` method takes [`ctim::W`](W) writer structure"]
+impl crate::Writable for CtimSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CTIM to value 0"]
+impl crate::Resettable for CtimSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/ctmr.rs

@@ -0,0 +1,31 @@
+#[doc = "Register `CTMR` reader"]
+pub type R = crate::R<CtmrSpec>;
+#[doc = "Register `CTMR` writer"]
+pub type W = crate::W<CtmrSpec>;
+#[doc = "Field `CTMR` reader - Time Stamp Counter"]
+pub type CtmrR = crate::FieldReader<u16>;
+impl R {
+    #[doc = "Bits 0:15 - Time Stamp Counter"]
+    #[inline(always)]
+    pub fn ctmr(&self) -> CtmrR {
+        CtmrR::new((self.bits & 0xffff) as u16)
+    }
+}
+impl W {}
+#[doc = "CAN Timer Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`ctmr::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`ctmr::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct CtmrSpec;
+impl crate::RegisterSpec for CtmrSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`ctmr::R`](R) reader structure"]
+impl crate::Readable for CtmrSpec {}
+#[doc = "`write(|w| ..)` method takes [`ctmr::W`](W) writer structure"]
+impl crate::Writable for CtmrSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets CTMR to value 0"]
+impl crate::Resettable for CtmrSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data0_cmb0.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA0_CMB0` reader"]
+pub type R = crate::R<Data0Cmb0Spec>;
+#[doc = "Register `DATA0_CMB0` writer"]
+pub type W = crate::W<Data0Cmb0Spec>;
+#[doc = "Field `BYTE2` reader - Data Byte 2"]
+pub type Byte2R = crate::FieldReader;
+#[doc = "Field `BYTE2` writer - Data Byte 2"]
+pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE1` reader - Data Byte 1"]
+pub type Byte1R = crate::FieldReader;
+#[doc = "Field `BYTE1` writer - Data Byte 1"]
+pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    pub fn byte2(&self) -> Byte2R {
+        Byte2R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    pub fn byte1(&self) -> Byte1R {
+        Byte1R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte2(&mut self) -> Byte2W<Data0Cmb0Spec> {
+        Byte2W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte1(&mut self) -> Byte1W<Data0Cmb0Spec> {
+        Byte1W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb0::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb0::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data0Cmb0Spec;
+impl crate::RegisterSpec for Data0Cmb0Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data0_cmb0::R`](R) reader structure"]
+impl crate::Readable for Data0Cmb0Spec {}
+#[doc = "`write(|w| ..)` method takes [`data0_cmb0::W`](W) writer structure"]
+impl crate::Writable for Data0Cmb0Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA0_CMB0 to value 0"]
+impl crate::Resettable for Data0Cmb0Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data0_cmb1.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA0_CMB1` reader"]
+pub type R = crate::R<Data0Cmb1Spec>;
+#[doc = "Register `DATA0_CMB1` writer"]
+pub type W = crate::W<Data0Cmb1Spec>;
+#[doc = "Field `BYTE2` reader - Data Byte 2"]
+pub type Byte2R = crate::FieldReader;
+#[doc = "Field `BYTE2` writer - Data Byte 2"]
+pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE1` reader - Data Byte 1"]
+pub type Byte1R = crate::FieldReader;
+#[doc = "Field `BYTE1` writer - Data Byte 1"]
+pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    pub fn byte2(&self) -> Byte2R {
+        Byte2R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    pub fn byte1(&self) -> Byte1R {
+        Byte1R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte2(&mut self) -> Byte2W<Data0Cmb1Spec> {
+        Byte2W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte1(&mut self) -> Byte1W<Data0Cmb1Spec> {
+        Byte1W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb1::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb1::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data0Cmb1Spec;
+impl crate::RegisterSpec for Data0Cmb1Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data0_cmb1::R`](R) reader structure"]
+impl crate::Readable for Data0Cmb1Spec {}
+#[doc = "`write(|w| ..)` method takes [`data0_cmb1::W`](W) writer structure"]
+impl crate::Writable for Data0Cmb1Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA0_CMB1 to value 0"]
+impl crate::Resettable for Data0Cmb1Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data0_cmb10.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA0_CMB10` reader"]
+pub type R = crate::R<Data0Cmb10Spec>;
+#[doc = "Register `DATA0_CMB10` writer"]
+pub type W = crate::W<Data0Cmb10Spec>;
+#[doc = "Field `BYTE2` reader - Data Byte 2"]
+pub type Byte2R = crate::FieldReader;
+#[doc = "Field `BYTE2` writer - Data Byte 2"]
+pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE1` reader - Data Byte 1"]
+pub type Byte1R = crate::FieldReader;
+#[doc = "Field `BYTE1` writer - Data Byte 1"]
+pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    pub fn byte2(&self) -> Byte2R {
+        Byte2R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    pub fn byte1(&self) -> Byte1R {
+        Byte1R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte2(&mut self) -> Byte2W<Data0Cmb10Spec> {
+        Byte2W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte1(&mut self) -> Byte1W<Data0Cmb10Spec> {
+        Byte1W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb10::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb10::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data0Cmb10Spec;
+impl crate::RegisterSpec for Data0Cmb10Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data0_cmb10::R`](R) reader structure"]
+impl crate::Readable for Data0Cmb10Spec {}
+#[doc = "`write(|w| ..)` method takes [`data0_cmb10::W`](W) writer structure"]
+impl crate::Writable for Data0Cmb10Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA0_CMB10 to value 0"]
+impl crate::Resettable for Data0Cmb10Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data0_cmb11.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA0_CMB11` reader"]
+pub type R = crate::R<Data0Cmb11Spec>;
+#[doc = "Register `DATA0_CMB11` writer"]
+pub type W = crate::W<Data0Cmb11Spec>;
+#[doc = "Field `BYTE2` reader - Data Byte 2"]
+pub type Byte2R = crate::FieldReader;
+#[doc = "Field `BYTE2` writer - Data Byte 2"]
+pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE1` reader - Data Byte 1"]
+pub type Byte1R = crate::FieldReader;
+#[doc = "Field `BYTE1` writer - Data Byte 1"]
+pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    pub fn byte2(&self) -> Byte2R {
+        Byte2R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    pub fn byte1(&self) -> Byte1R {
+        Byte1R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte2(&mut self) -> Byte2W<Data0Cmb11Spec> {
+        Byte2W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte1(&mut self) -> Byte1W<Data0Cmb11Spec> {
+        Byte1W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb11::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb11::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data0Cmb11Spec;
+impl crate::RegisterSpec for Data0Cmb11Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data0_cmb11::R`](R) reader structure"]
+impl crate::Readable for Data0Cmb11Spec {}
+#[doc = "`write(|w| ..)` method takes [`data0_cmb11::W`](W) writer structure"]
+impl crate::Writable for Data0Cmb11Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA0_CMB11 to value 0"]
+impl crate::Resettable for Data0Cmb11Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data0_cmb12.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA0_CMB12` reader"]
+pub type R = crate::R<Data0Cmb12Spec>;
+#[doc = "Register `DATA0_CMB12` writer"]
+pub type W = crate::W<Data0Cmb12Spec>;
+#[doc = "Field `BYTE2` reader - Data Byte 2"]
+pub type Byte2R = crate::FieldReader;
+#[doc = "Field `BYTE2` writer - Data Byte 2"]
+pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE1` reader - Data Byte 1"]
+pub type Byte1R = crate::FieldReader;
+#[doc = "Field `BYTE1` writer - Data Byte 1"]
+pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    pub fn byte2(&self) -> Byte2R {
+        Byte2R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    pub fn byte1(&self) -> Byte1R {
+        Byte1R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte2(&mut self) -> Byte2W<Data0Cmb12Spec> {
+        Byte2W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte1(&mut self) -> Byte1W<Data0Cmb12Spec> {
+        Byte1W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb12::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb12::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data0Cmb12Spec;
+impl crate::RegisterSpec for Data0Cmb12Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data0_cmb12::R`](R) reader structure"]
+impl crate::Readable for Data0Cmb12Spec {}
+#[doc = "`write(|w| ..)` method takes [`data0_cmb12::W`](W) writer structure"]
+impl crate::Writable for Data0Cmb12Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA0_CMB12 to value 0"]
+impl crate::Resettable for Data0Cmb12Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data0_cmb13.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA0_CMB13` reader"]
+pub type R = crate::R<Data0Cmb13Spec>;
+#[doc = "Register `DATA0_CMB13` writer"]
+pub type W = crate::W<Data0Cmb13Spec>;
+#[doc = "Field `BYTE2` reader - Data Byte 2"]
+pub type Byte2R = crate::FieldReader;
+#[doc = "Field `BYTE2` writer - Data Byte 2"]
+pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE1` reader - Data Byte 1"]
+pub type Byte1R = crate::FieldReader;
+#[doc = "Field `BYTE1` writer - Data Byte 1"]
+pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    pub fn byte2(&self) -> Byte2R {
+        Byte2R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    pub fn byte1(&self) -> Byte1R {
+        Byte1R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte2(&mut self) -> Byte2W<Data0Cmb13Spec> {
+        Byte2W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte1(&mut self) -> Byte1W<Data0Cmb13Spec> {
+        Byte1W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb13::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb13::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data0Cmb13Spec;
+impl crate::RegisterSpec for Data0Cmb13Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data0_cmb13::R`](R) reader structure"]
+impl crate::Readable for Data0Cmb13Spec {}
+#[doc = "`write(|w| ..)` method takes [`data0_cmb13::W`](W) writer structure"]
+impl crate::Writable for Data0Cmb13Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA0_CMB13 to value 0"]
+impl crate::Resettable for Data0Cmb13Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data0_cmb14.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA0_CMB14` reader"]
+pub type R = crate::R<Data0Cmb14Spec>;
+#[doc = "Register `DATA0_CMB14` writer"]
+pub type W = crate::W<Data0Cmb14Spec>;
+#[doc = "Field `BYTE2` reader - Data Byte 2"]
+pub type Byte2R = crate::FieldReader;
+#[doc = "Field `BYTE2` writer - Data Byte 2"]
+pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE1` reader - Data Byte 1"]
+pub type Byte1R = crate::FieldReader;
+#[doc = "Field `BYTE1` writer - Data Byte 1"]
+pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    pub fn byte2(&self) -> Byte2R {
+        Byte2R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    pub fn byte1(&self) -> Byte1R {
+        Byte1R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte2(&mut self) -> Byte2W<Data0Cmb14Spec> {
+        Byte2W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte1(&mut self) -> Byte1W<Data0Cmb14Spec> {
+        Byte1W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb14::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb14::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data0Cmb14Spec;
+impl crate::RegisterSpec for Data0Cmb14Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data0_cmb14::R`](R) reader structure"]
+impl crate::Readable for Data0Cmb14Spec {}
+#[doc = "`write(|w| ..)` method takes [`data0_cmb14::W`](W) writer structure"]
+impl crate::Writable for Data0Cmb14Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA0_CMB14 to value 0"]
+impl crate::Resettable for Data0Cmb14Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data0_cmb2.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA0_CMB2` reader"]
+pub type R = crate::R<Data0Cmb2Spec>;
+#[doc = "Register `DATA0_CMB2` writer"]
+pub type W = crate::W<Data0Cmb2Spec>;
+#[doc = "Field `BYTE2` reader - Data Byte 2"]
+pub type Byte2R = crate::FieldReader;
+#[doc = "Field `BYTE2` writer - Data Byte 2"]
+pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE1` reader - Data Byte 1"]
+pub type Byte1R = crate::FieldReader;
+#[doc = "Field `BYTE1` writer - Data Byte 1"]
+pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    pub fn byte2(&self) -> Byte2R {
+        Byte2R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    pub fn byte1(&self) -> Byte1R {
+        Byte1R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte2(&mut self) -> Byte2W<Data0Cmb2Spec> {
+        Byte2W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte1(&mut self) -> Byte1W<Data0Cmb2Spec> {
+        Byte1W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb2::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb2::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data0Cmb2Spec;
+impl crate::RegisterSpec for Data0Cmb2Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data0_cmb2::R`](R) reader structure"]
+impl crate::Readable for Data0Cmb2Spec {}
+#[doc = "`write(|w| ..)` method takes [`data0_cmb2::W`](W) writer structure"]
+impl crate::Writable for Data0Cmb2Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA0_CMB2 to value 0"]
+impl crate::Resettable for Data0Cmb2Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data0_cmb3.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA0_CMB3` reader"]
+pub type R = crate::R<Data0Cmb3Spec>;
+#[doc = "Register `DATA0_CMB3` writer"]
+pub type W = crate::W<Data0Cmb3Spec>;
+#[doc = "Field `BYTE2` reader - Data Byte 2"]
+pub type Byte2R = crate::FieldReader;
+#[doc = "Field `BYTE2` writer - Data Byte 2"]
+pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE1` reader - Data Byte 1"]
+pub type Byte1R = crate::FieldReader;
+#[doc = "Field `BYTE1` writer - Data Byte 1"]
+pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    pub fn byte2(&self) -> Byte2R {
+        Byte2R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    pub fn byte1(&self) -> Byte1R {
+        Byte1R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte2(&mut self) -> Byte2W<Data0Cmb3Spec> {
+        Byte2W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte1(&mut self) -> Byte1W<Data0Cmb3Spec> {
+        Byte1W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb3::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb3::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data0Cmb3Spec;
+impl crate::RegisterSpec for Data0Cmb3Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data0_cmb3::R`](R) reader structure"]
+impl crate::Readable for Data0Cmb3Spec {}
+#[doc = "`write(|w| ..)` method takes [`data0_cmb3::W`](W) writer structure"]
+impl crate::Writable for Data0Cmb3Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA0_CMB3 to value 0"]
+impl crate::Resettable for Data0Cmb3Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data0_cmb4.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA0_CMB4` reader"]
+pub type R = crate::R<Data0Cmb4Spec>;
+#[doc = "Register `DATA0_CMB4` writer"]
+pub type W = crate::W<Data0Cmb4Spec>;
+#[doc = "Field `BYTE2` reader - Data Byte 2"]
+pub type Byte2R = crate::FieldReader;
+#[doc = "Field `BYTE2` writer - Data Byte 2"]
+pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE1` reader - Data Byte 1"]
+pub type Byte1R = crate::FieldReader;
+#[doc = "Field `BYTE1` writer - Data Byte 1"]
+pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    pub fn byte2(&self) -> Byte2R {
+        Byte2R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    pub fn byte1(&self) -> Byte1R {
+        Byte1R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte2(&mut self) -> Byte2W<Data0Cmb4Spec> {
+        Byte2W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte1(&mut self) -> Byte1W<Data0Cmb4Spec> {
+        Byte1W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb4::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb4::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data0Cmb4Spec;
+impl crate::RegisterSpec for Data0Cmb4Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data0_cmb4::R`](R) reader structure"]
+impl crate::Readable for Data0Cmb4Spec {}
+#[doc = "`write(|w| ..)` method takes [`data0_cmb4::W`](W) writer structure"]
+impl crate::Writable for Data0Cmb4Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA0_CMB4 to value 0"]
+impl crate::Resettable for Data0Cmb4Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data0_cmb5.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA0_CMB5` reader"]
+pub type R = crate::R<Data0Cmb5Spec>;
+#[doc = "Register `DATA0_CMB5` writer"]
+pub type W = crate::W<Data0Cmb5Spec>;
+#[doc = "Field `BYTE2` reader - Data Byte 2"]
+pub type Byte2R = crate::FieldReader;
+#[doc = "Field `BYTE2` writer - Data Byte 2"]
+pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE1` reader - Data Byte 1"]
+pub type Byte1R = crate::FieldReader;
+#[doc = "Field `BYTE1` writer - Data Byte 1"]
+pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    pub fn byte2(&self) -> Byte2R {
+        Byte2R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    pub fn byte1(&self) -> Byte1R {
+        Byte1R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte2(&mut self) -> Byte2W<Data0Cmb5Spec> {
+        Byte2W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte1(&mut self) -> Byte1W<Data0Cmb5Spec> {
+        Byte1W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb5::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb5::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data0Cmb5Spec;
+impl crate::RegisterSpec for Data0Cmb5Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data0_cmb5::R`](R) reader structure"]
+impl crate::Readable for Data0Cmb5Spec {}
+#[doc = "`write(|w| ..)` method takes [`data0_cmb5::W`](W) writer structure"]
+impl crate::Writable for Data0Cmb5Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA0_CMB5 to value 0"]
+impl crate::Resettable for Data0Cmb5Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data0_cmb6.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA0_CMB6` reader"]
+pub type R = crate::R<Data0Cmb6Spec>;
+#[doc = "Register `DATA0_CMB6` writer"]
+pub type W = crate::W<Data0Cmb6Spec>;
+#[doc = "Field `BYTE2` reader - Data Byte 2"]
+pub type Byte2R = crate::FieldReader;
+#[doc = "Field `BYTE2` writer - Data Byte 2"]
+pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE1` reader - Data Byte 1"]
+pub type Byte1R = crate::FieldReader;
+#[doc = "Field `BYTE1` writer - Data Byte 1"]
+pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    pub fn byte2(&self) -> Byte2R {
+        Byte2R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    pub fn byte1(&self) -> Byte1R {
+        Byte1R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte2(&mut self) -> Byte2W<Data0Cmb6Spec> {
+        Byte2W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte1(&mut self) -> Byte1W<Data0Cmb6Spec> {
+        Byte1W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb6::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb6::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data0Cmb6Spec;
+impl crate::RegisterSpec for Data0Cmb6Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data0_cmb6::R`](R) reader structure"]
+impl crate::Readable for Data0Cmb6Spec {}
+#[doc = "`write(|w| ..)` method takes [`data0_cmb6::W`](W) writer structure"]
+impl crate::Writable for Data0Cmb6Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA0_CMB6 to value 0"]
+impl crate::Resettable for Data0Cmb6Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data0_cmb7.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA0_CMB7` reader"]
+pub type R = crate::R<Data0Cmb7Spec>;
+#[doc = "Register `DATA0_CMB7` writer"]
+pub type W = crate::W<Data0Cmb7Spec>;
+#[doc = "Field `BYTE2` reader - Data Byte 2"]
+pub type Byte2R = crate::FieldReader;
+#[doc = "Field `BYTE2` writer - Data Byte 2"]
+pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE1` reader - Data Byte 1"]
+pub type Byte1R = crate::FieldReader;
+#[doc = "Field `BYTE1` writer - Data Byte 1"]
+pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    pub fn byte2(&self) -> Byte2R {
+        Byte2R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    pub fn byte1(&self) -> Byte1R {
+        Byte1R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte2(&mut self) -> Byte2W<Data0Cmb7Spec> {
+        Byte2W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte1(&mut self) -> Byte1W<Data0Cmb7Spec> {
+        Byte1W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb7::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb7::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data0Cmb7Spec;
+impl crate::RegisterSpec for Data0Cmb7Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data0_cmb7::R`](R) reader structure"]
+impl crate::Readable for Data0Cmb7Spec {}
+#[doc = "`write(|w| ..)` method takes [`data0_cmb7::W`](W) writer structure"]
+impl crate::Writable for Data0Cmb7Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA0_CMB7 to value 0"]
+impl crate::Resettable for Data0Cmb7Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data0_cmb8.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA0_CMB8` reader"]
+pub type R = crate::R<Data0Cmb8Spec>;
+#[doc = "Register `DATA0_CMB8` writer"]
+pub type W = crate::W<Data0Cmb8Spec>;
+#[doc = "Field `BYTE2` reader - Data Byte 2"]
+pub type Byte2R = crate::FieldReader;
+#[doc = "Field `BYTE2` writer - Data Byte 2"]
+pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE1` reader - Data Byte 1"]
+pub type Byte1R = crate::FieldReader;
+#[doc = "Field `BYTE1` writer - Data Byte 1"]
+pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    pub fn byte2(&self) -> Byte2R {
+        Byte2R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    pub fn byte1(&self) -> Byte1R {
+        Byte1R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte2(&mut self) -> Byte2W<Data0Cmb8Spec> {
+        Byte2W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte1(&mut self) -> Byte1W<Data0Cmb8Spec> {
+        Byte1W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb8::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb8::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data0Cmb8Spec;
+impl crate::RegisterSpec for Data0Cmb8Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data0_cmb8::R`](R) reader structure"]
+impl crate::Readable for Data0Cmb8Spec {}
+#[doc = "`write(|w| ..)` method takes [`data0_cmb8::W`](W) writer structure"]
+impl crate::Writable for Data0Cmb8Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA0_CMB8 to value 0"]
+impl crate::Resettable for Data0Cmb8Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data0_cmb9.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA0_CMB9` reader"]
+pub type R = crate::R<Data0Cmb9Spec>;
+#[doc = "Register `DATA0_CMB9` writer"]
+pub type W = crate::W<Data0Cmb9Spec>;
+#[doc = "Field `BYTE2` reader - Data Byte 2"]
+pub type Byte2R = crate::FieldReader;
+#[doc = "Field `BYTE2` writer - Data Byte 2"]
+pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE1` reader - Data Byte 1"]
+pub type Byte1R = crate::FieldReader;
+#[doc = "Field `BYTE1` writer - Data Byte 1"]
+pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    pub fn byte2(&self) -> Byte2R {
+        Byte2R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    pub fn byte1(&self) -> Byte1R {
+        Byte1R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte2(&mut self) -> Byte2W<Data0Cmb9Spec> {
+        Byte2W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte1(&mut self) -> Byte1W<Data0Cmb9Spec> {
+        Byte1W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb9::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb9::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data0Cmb9Spec;
+impl crate::RegisterSpec for Data0Cmb9Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data0_cmb9::R`](R) reader structure"]
+impl crate::Readable for Data0Cmb9Spec {}
+#[doc = "`write(|w| ..)` method takes [`data0_cmb9::W`](W) writer structure"]
+impl crate::Writable for Data0Cmb9Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA0_CMB9 to value 0"]
+impl crate::Resettable for Data0Cmb9Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data0_hcmb.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA0_HCMB` reader"]
+pub type R = crate::R<Data0HcmbSpec>;
+#[doc = "Register `DATA0_HCMB` writer"]
+pub type W = crate::W<Data0HcmbSpec>;
+#[doc = "Field `BYTE2` reader - Data Byte 2"]
+pub type Byte2R = crate::FieldReader;
+#[doc = "Field `BYTE2` writer - Data Byte 2"]
+pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE1` reader - Data Byte 1"]
+pub type Byte1R = crate::FieldReader;
+#[doc = "Field `BYTE1` writer - Data Byte 1"]
+pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    pub fn byte2(&self) -> Byte2R {
+        Byte2R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    pub fn byte1(&self) -> Byte1R {
+        Byte1R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 2"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte2(&mut self) -> Byte2W<Data0HcmbSpec> {
+        Byte2W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 1"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte1(&mut self) -> Byte1W<Data0HcmbSpec> {
+        Byte1W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_hcmb::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_hcmb::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data0HcmbSpec;
+impl crate::RegisterSpec for Data0HcmbSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data0_hcmb::R`](R) reader structure"]
+impl crate::Readable for Data0HcmbSpec {}
+#[doc = "`write(|w| ..)` method takes [`data0_hcmb::W`](W) writer structure"]
+impl crate::Writable for Data0HcmbSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA0_HCMB to value 0"]
+impl crate::Resettable for Data0HcmbSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data1_cmb0.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA1_CMB0` reader"]
+pub type R = crate::R<Data1Cmb0Spec>;
+#[doc = "Register `DATA1_CMB0` writer"]
+pub type W = crate::W<Data1Cmb0Spec>;
+#[doc = "Field `BYTE4` reader - Data Byte 4"]
+pub type Byte4R = crate::FieldReader;
+#[doc = "Field `BYTE4` writer - Data Byte 4"]
+pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE3` reader - Data Byte 3"]
+pub type Byte3R = crate::FieldReader;
+#[doc = "Field `BYTE3` writer - Data Byte 3"]
+pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    pub fn byte4(&self) -> Byte4R {
+        Byte4R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    pub fn byte3(&self) -> Byte3R {
+        Byte3R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte4(&mut self) -> Byte4W<Data1Cmb0Spec> {
+        Byte4W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte3(&mut self) -> Byte3W<Data1Cmb0Spec> {
+        Byte3W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 1\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb0::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb0::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data1Cmb0Spec;
+impl crate::RegisterSpec for Data1Cmb0Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data1_cmb0::R`](R) reader structure"]
+impl crate::Readable for Data1Cmb0Spec {}
+#[doc = "`write(|w| ..)` method takes [`data1_cmb0::W`](W) writer structure"]
+impl crate::Writable for Data1Cmb0Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA1_CMB0 to value 0"]
+impl crate::Resettable for Data1Cmb0Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data1_cmb1.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA1_CMB1` reader"]
+pub type R = crate::R<Data1Cmb1Spec>;
+#[doc = "Register `DATA1_CMB1` writer"]
+pub type W = crate::W<Data1Cmb1Spec>;
+#[doc = "Field `BYTE4` reader - Data Byte 4"]
+pub type Byte4R = crate::FieldReader;
+#[doc = "Field `BYTE4` writer - Data Byte 4"]
+pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE3` reader - Data Byte 3"]
+pub type Byte3R = crate::FieldReader;
+#[doc = "Field `BYTE3` writer - Data Byte 3"]
+pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    pub fn byte4(&self) -> Byte4R {
+        Byte4R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    pub fn byte3(&self) -> Byte3R {
+        Byte3R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte4(&mut self) -> Byte4W<Data1Cmb1Spec> {
+        Byte4W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte3(&mut self) -> Byte3W<Data1Cmb1Spec> {
+        Byte3W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb1::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb1::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data1Cmb1Spec;
+impl crate::RegisterSpec for Data1Cmb1Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data1_cmb1::R`](R) reader structure"]
+impl crate::Readable for Data1Cmb1Spec {}
+#[doc = "`write(|w| ..)` method takes [`data1_cmb1::W`](W) writer structure"]
+impl crate::Writable for Data1Cmb1Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA1_CMB1 to value 0"]
+impl crate::Resettable for Data1Cmb1Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data1_cmb10.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA1_CMB10` reader"]
+pub type R = crate::R<Data1Cmb10Spec>;
+#[doc = "Register `DATA1_CMB10` writer"]
+pub type W = crate::W<Data1Cmb10Spec>;
+#[doc = "Field `BYTE4` reader - Data Byte 4"]
+pub type Byte4R = crate::FieldReader;
+#[doc = "Field `BYTE4` writer - Data Byte 4"]
+pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE3` reader - Data Byte 3"]
+pub type Byte3R = crate::FieldReader;
+#[doc = "Field `BYTE3` writer - Data Byte 3"]
+pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    pub fn byte4(&self) -> Byte4R {
+        Byte4R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    pub fn byte3(&self) -> Byte3R {
+        Byte3R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte4(&mut self) -> Byte4W<Data1Cmb10Spec> {
+        Byte4W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte3(&mut self) -> Byte3W<Data1Cmb10Spec> {
+        Byte3W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb10::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb10::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data1Cmb10Spec;
+impl crate::RegisterSpec for Data1Cmb10Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data1_cmb10::R`](R) reader structure"]
+impl crate::Readable for Data1Cmb10Spec {}
+#[doc = "`write(|w| ..)` method takes [`data1_cmb10::W`](W) writer structure"]
+impl crate::Writable for Data1Cmb10Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA1_CMB10 to value 0"]
+impl crate::Resettable for Data1Cmb10Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data1_cmb11.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA1_CMB11` reader"]
+pub type R = crate::R<Data1Cmb11Spec>;
+#[doc = "Register `DATA1_CMB11` writer"]
+pub type W = crate::W<Data1Cmb11Spec>;
+#[doc = "Field `BYTE4` reader - Data Byte 4"]
+pub type Byte4R = crate::FieldReader;
+#[doc = "Field `BYTE4` writer - Data Byte 4"]
+pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE3` reader - Data Byte 3"]
+pub type Byte3R = crate::FieldReader;
+#[doc = "Field `BYTE3` writer - Data Byte 3"]
+pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    pub fn byte4(&self) -> Byte4R {
+        Byte4R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    pub fn byte3(&self) -> Byte3R {
+        Byte3R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte4(&mut self) -> Byte4W<Data1Cmb11Spec> {
+        Byte4W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte3(&mut self) -> Byte3W<Data1Cmb11Spec> {
+        Byte3W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb11::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb11::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data1Cmb11Spec;
+impl crate::RegisterSpec for Data1Cmb11Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data1_cmb11::R`](R) reader structure"]
+impl crate::Readable for Data1Cmb11Spec {}
+#[doc = "`write(|w| ..)` method takes [`data1_cmb11::W`](W) writer structure"]
+impl crate::Writable for Data1Cmb11Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA1_CMB11 to value 0"]
+impl crate::Resettable for Data1Cmb11Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data1_cmb12.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA1_CMB12` reader"]
+pub type R = crate::R<Data1Cmb12Spec>;
+#[doc = "Register `DATA1_CMB12` writer"]
+pub type W = crate::W<Data1Cmb12Spec>;
+#[doc = "Field `BYTE4` reader - Data Byte 4"]
+pub type Byte4R = crate::FieldReader;
+#[doc = "Field `BYTE4` writer - Data Byte 4"]
+pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE3` reader - Data Byte 3"]
+pub type Byte3R = crate::FieldReader;
+#[doc = "Field `BYTE3` writer - Data Byte 3"]
+pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    pub fn byte4(&self) -> Byte4R {
+        Byte4R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    pub fn byte3(&self) -> Byte3R {
+        Byte3R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte4(&mut self) -> Byte4W<Data1Cmb12Spec> {
+        Byte4W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte3(&mut self) -> Byte3W<Data1Cmb12Spec> {
+        Byte3W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb12::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb12::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data1Cmb12Spec;
+impl crate::RegisterSpec for Data1Cmb12Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data1_cmb12::R`](R) reader structure"]
+impl crate::Readable for Data1Cmb12Spec {}
+#[doc = "`write(|w| ..)` method takes [`data1_cmb12::W`](W) writer structure"]
+impl crate::Writable for Data1Cmb12Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA1_CMB12 to value 0"]
+impl crate::Resettable for Data1Cmb12Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data1_cmb13.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA1_CMB13` reader"]
+pub type R = crate::R<Data1Cmb13Spec>;
+#[doc = "Register `DATA1_CMB13` writer"]
+pub type W = crate::W<Data1Cmb13Spec>;
+#[doc = "Field `BYTE4` reader - Data Byte 4"]
+pub type Byte4R = crate::FieldReader;
+#[doc = "Field `BYTE4` writer - Data Byte 4"]
+pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE3` reader - Data Byte 3"]
+pub type Byte3R = crate::FieldReader;
+#[doc = "Field `BYTE3` writer - Data Byte 3"]
+pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    pub fn byte4(&self) -> Byte4R {
+        Byte4R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    pub fn byte3(&self) -> Byte3R {
+        Byte3R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte4(&mut self) -> Byte4W<Data1Cmb13Spec> {
+        Byte4W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte3(&mut self) -> Byte3W<Data1Cmb13Spec> {
+        Byte3W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb13::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb13::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data1Cmb13Spec;
+impl crate::RegisterSpec for Data1Cmb13Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data1_cmb13::R`](R) reader structure"]
+impl crate::Readable for Data1Cmb13Spec {}
+#[doc = "`write(|w| ..)` method takes [`data1_cmb13::W`](W) writer structure"]
+impl crate::Writable for Data1Cmb13Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA1_CMB13 to value 0"]
+impl crate::Resettable for Data1Cmb13Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data1_cmb14.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA1_CMB14` reader"]
+pub type R = crate::R<Data1Cmb14Spec>;
+#[doc = "Register `DATA1_CMB14` writer"]
+pub type W = crate::W<Data1Cmb14Spec>;
+#[doc = "Field `BYTE4` reader - Data Byte 4"]
+pub type Byte4R = crate::FieldReader;
+#[doc = "Field `BYTE4` writer - Data Byte 4"]
+pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE3` reader - Data Byte 3"]
+pub type Byte3R = crate::FieldReader;
+#[doc = "Field `BYTE3` writer - Data Byte 3"]
+pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    pub fn byte4(&self) -> Byte4R {
+        Byte4R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    pub fn byte3(&self) -> Byte3R {
+        Byte3R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte4(&mut self) -> Byte4W<Data1Cmb14Spec> {
+        Byte4W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte3(&mut self) -> Byte3W<Data1Cmb14Spec> {
+        Byte3W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb14::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb14::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data1Cmb14Spec;
+impl crate::RegisterSpec for Data1Cmb14Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data1_cmb14::R`](R) reader structure"]
+impl crate::Readable for Data1Cmb14Spec {}
+#[doc = "`write(|w| ..)` method takes [`data1_cmb14::W`](W) writer structure"]
+impl crate::Writable for Data1Cmb14Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA1_CMB14 to value 0"]
+impl crate::Resettable for Data1Cmb14Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data1_cmb2.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA1_CMB2` reader"]
+pub type R = crate::R<Data1Cmb2Spec>;
+#[doc = "Register `DATA1_CMB2` writer"]
+pub type W = crate::W<Data1Cmb2Spec>;
+#[doc = "Field `BYTE4` reader - Data Byte 4"]
+pub type Byte4R = crate::FieldReader;
+#[doc = "Field `BYTE4` writer - Data Byte 4"]
+pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE3` reader - Data Byte 3"]
+pub type Byte3R = crate::FieldReader;
+#[doc = "Field `BYTE3` writer - Data Byte 3"]
+pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    pub fn byte4(&self) -> Byte4R {
+        Byte4R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    pub fn byte3(&self) -> Byte3R {
+        Byte3R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte4(&mut self) -> Byte4W<Data1Cmb2Spec> {
+        Byte4W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte3(&mut self) -> Byte3W<Data1Cmb2Spec> {
+        Byte3W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb2::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb2::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data1Cmb2Spec;
+impl crate::RegisterSpec for Data1Cmb2Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data1_cmb2::R`](R) reader structure"]
+impl crate::Readable for Data1Cmb2Spec {}
+#[doc = "`write(|w| ..)` method takes [`data1_cmb2::W`](W) writer structure"]
+impl crate::Writable for Data1Cmb2Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA1_CMB2 to value 0"]
+impl crate::Resettable for Data1Cmb2Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data1_cmb3.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA1_CMB3` reader"]
+pub type R = crate::R<Data1Cmb3Spec>;
+#[doc = "Register `DATA1_CMB3` writer"]
+pub type W = crate::W<Data1Cmb3Spec>;
+#[doc = "Field `BYTE4` reader - Data Byte 4"]
+pub type Byte4R = crate::FieldReader;
+#[doc = "Field `BYTE4` writer - Data Byte 4"]
+pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE3` reader - Data Byte 3"]
+pub type Byte3R = crate::FieldReader;
+#[doc = "Field `BYTE3` writer - Data Byte 3"]
+pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    pub fn byte4(&self) -> Byte4R {
+        Byte4R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    pub fn byte3(&self) -> Byte3R {
+        Byte3R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte4(&mut self) -> Byte4W<Data1Cmb3Spec> {
+        Byte4W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte3(&mut self) -> Byte3W<Data1Cmb3Spec> {
+        Byte3W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb3::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb3::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data1Cmb3Spec;
+impl crate::RegisterSpec for Data1Cmb3Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data1_cmb3::R`](R) reader structure"]
+impl crate::Readable for Data1Cmb3Spec {}
+#[doc = "`write(|w| ..)` method takes [`data1_cmb3::W`](W) writer structure"]
+impl crate::Writable for Data1Cmb3Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA1_CMB3 to value 0"]
+impl crate::Resettable for Data1Cmb3Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data1_cmb4.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA1_CMB4` reader"]
+pub type R = crate::R<Data1Cmb4Spec>;
+#[doc = "Register `DATA1_CMB4` writer"]
+pub type W = crate::W<Data1Cmb4Spec>;
+#[doc = "Field `BYTE4` reader - Data Byte 4"]
+pub type Byte4R = crate::FieldReader;
+#[doc = "Field `BYTE4` writer - Data Byte 4"]
+pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE3` reader - Data Byte 3"]
+pub type Byte3R = crate::FieldReader;
+#[doc = "Field `BYTE3` writer - Data Byte 3"]
+pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    pub fn byte4(&self) -> Byte4R {
+        Byte4R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    pub fn byte3(&self) -> Byte3R {
+        Byte3R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte4(&mut self) -> Byte4W<Data1Cmb4Spec> {
+        Byte4W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte3(&mut self) -> Byte3W<Data1Cmb4Spec> {
+        Byte3W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb4::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb4::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data1Cmb4Spec;
+impl crate::RegisterSpec for Data1Cmb4Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data1_cmb4::R`](R) reader structure"]
+impl crate::Readable for Data1Cmb4Spec {}
+#[doc = "`write(|w| ..)` method takes [`data1_cmb4::W`](W) writer structure"]
+impl crate::Writable for Data1Cmb4Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA1_CMB4 to value 0"]
+impl crate::Resettable for Data1Cmb4Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data1_cmb5.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA1_CMB5` reader"]
+pub type R = crate::R<Data1Cmb5Spec>;
+#[doc = "Register `DATA1_CMB5` writer"]
+pub type W = crate::W<Data1Cmb5Spec>;
+#[doc = "Field `BYTE4` reader - Data Byte 4"]
+pub type Byte4R = crate::FieldReader;
+#[doc = "Field `BYTE4` writer - Data Byte 4"]
+pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE3` reader - Data Byte 3"]
+pub type Byte3R = crate::FieldReader;
+#[doc = "Field `BYTE3` writer - Data Byte 3"]
+pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    pub fn byte4(&self) -> Byte4R {
+        Byte4R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    pub fn byte3(&self) -> Byte3R {
+        Byte3R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte4(&mut self) -> Byte4W<Data1Cmb5Spec> {
+        Byte4W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte3(&mut self) -> Byte3W<Data1Cmb5Spec> {
+        Byte3W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb5::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb5::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data1Cmb5Spec;
+impl crate::RegisterSpec for Data1Cmb5Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data1_cmb5::R`](R) reader structure"]
+impl crate::Readable for Data1Cmb5Spec {}
+#[doc = "`write(|w| ..)` method takes [`data1_cmb5::W`](W) writer structure"]
+impl crate::Writable for Data1Cmb5Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA1_CMB5 to value 0"]
+impl crate::Resettable for Data1Cmb5Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data1_cmb6.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA1_CMB6` reader"]
+pub type R = crate::R<Data1Cmb6Spec>;
+#[doc = "Register `DATA1_CMB6` writer"]
+pub type W = crate::W<Data1Cmb6Spec>;
+#[doc = "Field `BYTE4` reader - Data Byte 4"]
+pub type Byte4R = crate::FieldReader;
+#[doc = "Field `BYTE4` writer - Data Byte 4"]
+pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE3` reader - Data Byte 3"]
+pub type Byte3R = crate::FieldReader;
+#[doc = "Field `BYTE3` writer - Data Byte 3"]
+pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    pub fn byte4(&self) -> Byte4R {
+        Byte4R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    pub fn byte3(&self) -> Byte3R {
+        Byte3R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte4(&mut self) -> Byte4W<Data1Cmb6Spec> {
+        Byte4W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte3(&mut self) -> Byte3W<Data1Cmb6Spec> {
+        Byte3W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb6::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb6::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data1Cmb6Spec;
+impl crate::RegisterSpec for Data1Cmb6Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data1_cmb6::R`](R) reader structure"]
+impl crate::Readable for Data1Cmb6Spec {}
+#[doc = "`write(|w| ..)` method takes [`data1_cmb6::W`](W) writer structure"]
+impl crate::Writable for Data1Cmb6Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA1_CMB6 to value 0"]
+impl crate::Resettable for Data1Cmb6Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data1_cmb7.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA1_CMB7` reader"]
+pub type R = crate::R<Data1Cmb7Spec>;
+#[doc = "Register `DATA1_CMB7` writer"]
+pub type W = crate::W<Data1Cmb7Spec>;
+#[doc = "Field `BYTE4` reader - Data Byte 4"]
+pub type Byte4R = crate::FieldReader;
+#[doc = "Field `BYTE4` writer - Data Byte 4"]
+pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE3` reader - Data Byte 3"]
+pub type Byte3R = crate::FieldReader;
+#[doc = "Field `BYTE3` writer - Data Byte 3"]
+pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    pub fn byte4(&self) -> Byte4R {
+        Byte4R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    pub fn byte3(&self) -> Byte3R {
+        Byte3R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte4(&mut self) -> Byte4W<Data1Cmb7Spec> {
+        Byte4W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte3(&mut self) -> Byte3W<Data1Cmb7Spec> {
+        Byte3W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb7::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb7::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data1Cmb7Spec;
+impl crate::RegisterSpec for Data1Cmb7Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data1_cmb7::R`](R) reader structure"]
+impl crate::Readable for Data1Cmb7Spec {}
+#[doc = "`write(|w| ..)` method takes [`data1_cmb7::W`](W) writer structure"]
+impl crate::Writable for Data1Cmb7Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA1_CMB7 to value 0"]
+impl crate::Resettable for Data1Cmb7Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data1_cmb8.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA1_CMB8` reader"]
+pub type R = crate::R<Data1Cmb8Spec>;
+#[doc = "Register `DATA1_CMB8` writer"]
+pub type W = crate::W<Data1Cmb8Spec>;
+#[doc = "Field `BYTE4` reader - Data Byte 4"]
+pub type Byte4R = crate::FieldReader;
+#[doc = "Field `BYTE4` writer - Data Byte 4"]
+pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE3` reader - Data Byte 3"]
+pub type Byte3R = crate::FieldReader;
+#[doc = "Field `BYTE3` writer - Data Byte 3"]
+pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    pub fn byte4(&self) -> Byte4R {
+        Byte4R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    pub fn byte3(&self) -> Byte3R {
+        Byte3R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte4(&mut self) -> Byte4W<Data1Cmb8Spec> {
+        Byte4W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte3(&mut self) -> Byte3W<Data1Cmb8Spec> {
+        Byte3W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb8::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb8::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data1Cmb8Spec;
+impl crate::RegisterSpec for Data1Cmb8Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data1_cmb8::R`](R) reader structure"]
+impl crate::Readable for Data1Cmb8Spec {}
+#[doc = "`write(|w| ..)` method takes [`data1_cmb8::W`](W) writer structure"]
+impl crate::Writable for Data1Cmb8Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA1_CMB8 to value 0"]
+impl crate::Resettable for Data1Cmb8Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data1_cmb9.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA1_CMB9` reader"]
+pub type R = crate::R<Data1Cmb9Spec>;
+#[doc = "Register `DATA1_CMB9` writer"]
+pub type W = crate::W<Data1Cmb9Spec>;
+#[doc = "Field `BYTE4` reader - Data Byte 4"]
+pub type Byte4R = crate::FieldReader;
+#[doc = "Field `BYTE4` writer - Data Byte 4"]
+pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE3` reader - Data Byte 3"]
+pub type Byte3R = crate::FieldReader;
+#[doc = "Field `BYTE3` writer - Data Byte 3"]
+pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    pub fn byte4(&self) -> Byte4R {
+        Byte4R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    pub fn byte3(&self) -> Byte3R {
+        Byte3R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte4(&mut self) -> Byte4W<Data1Cmb9Spec> {
+        Byte4W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte3(&mut self) -> Byte3W<Data1Cmb9Spec> {
+        Byte3W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb9::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb9::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data1Cmb9Spec;
+impl crate::RegisterSpec for Data1Cmb9Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data1_cmb9::R`](R) reader structure"]
+impl crate::Readable for Data1Cmb9Spec {}
+#[doc = "`write(|w| ..)` method takes [`data1_cmb9::W`](W) writer structure"]
+impl crate::Writable for Data1Cmb9Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA1_CMB9 to value 0"]
+impl crate::Resettable for Data1Cmb9Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data1_hcmb.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA1_HCMB` reader"]
+pub type R = crate::R<Data1HcmbSpec>;
+#[doc = "Register `DATA1_HCMB` writer"]
+pub type W = crate::W<Data1HcmbSpec>;
+#[doc = "Field `BYTE4` reader - Data Byte 4"]
+pub type Byte4R = crate::FieldReader;
+#[doc = "Field `BYTE4` writer - Data Byte 4"]
+pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE3` reader - Data Byte 3"]
+pub type Byte3R = crate::FieldReader;
+#[doc = "Field `BYTE3` writer - Data Byte 3"]
+pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    pub fn byte4(&self) -> Byte4R {
+        Byte4R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    pub fn byte3(&self) -> Byte3R {
+        Byte3R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 4"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte4(&mut self) -> Byte4W<Data1HcmbSpec> {
+        Byte4W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 3"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte3(&mut self) -> Byte3W<Data1HcmbSpec> {
+        Byte3W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_hcmb::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_hcmb::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data1HcmbSpec;
+impl crate::RegisterSpec for Data1HcmbSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data1_hcmb::R`](R) reader structure"]
+impl crate::Readable for Data1HcmbSpec {}
+#[doc = "`write(|w| ..)` method takes [`data1_hcmb::W`](W) writer structure"]
+impl crate::Writable for Data1HcmbSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA1_HCMB to value 0"]
+impl crate::Resettable for Data1HcmbSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data2_cmb0.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA2_CMB0` reader"]
+pub type R = crate::R<Data2Cmb0Spec>;
+#[doc = "Register `DATA2_CMB0` writer"]
+pub type W = crate::W<Data2Cmb0Spec>;
+#[doc = "Field `BYTE6` reader - Data Byte 6"]
+pub type Byte6R = crate::FieldReader;
+#[doc = "Field `BYTE6` writer - Data Byte 6"]
+pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE5` reader - Data Byte 5"]
+pub type Byte5R = crate::FieldReader;
+#[doc = "Field `BYTE5` writer - Data Byte 5"]
+pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    pub fn byte6(&self) -> Byte6R {
+        Byte6R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    pub fn byte5(&self) -> Byte5R {
+        Byte5R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte6(&mut self) -> Byte6W<Data2Cmb0Spec> {
+        Byte6W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte5(&mut self) -> Byte5W<Data2Cmb0Spec> {
+        Byte5W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb0::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb0::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data2Cmb0Spec;
+impl crate::RegisterSpec for Data2Cmb0Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data2_cmb0::R`](R) reader structure"]
+impl crate::Readable for Data2Cmb0Spec {}
+#[doc = "`write(|w| ..)` method takes [`data2_cmb0::W`](W) writer structure"]
+impl crate::Writable for Data2Cmb0Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA2_CMB0 to value 0"]
+impl crate::Resettable for Data2Cmb0Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data2_cmb1.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA2_CMB1` reader"]
+pub type R = crate::R<Data2Cmb1Spec>;
+#[doc = "Register `DATA2_CMB1` writer"]
+pub type W = crate::W<Data2Cmb1Spec>;
+#[doc = "Field `BYTE6` reader - Data Byte 6"]
+pub type Byte6R = crate::FieldReader;
+#[doc = "Field `BYTE6` writer - Data Byte 6"]
+pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE5` reader - Data Byte 5"]
+pub type Byte5R = crate::FieldReader;
+#[doc = "Field `BYTE5` writer - Data Byte 5"]
+pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    pub fn byte6(&self) -> Byte6R {
+        Byte6R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    pub fn byte5(&self) -> Byte5R {
+        Byte5R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte6(&mut self) -> Byte6W<Data2Cmb1Spec> {
+        Byte6W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte5(&mut self) -> Byte5W<Data2Cmb1Spec> {
+        Byte5W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb1::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb1::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data2Cmb1Spec;
+impl crate::RegisterSpec for Data2Cmb1Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data2_cmb1::R`](R) reader structure"]
+impl crate::Readable for Data2Cmb1Spec {}
+#[doc = "`write(|w| ..)` method takes [`data2_cmb1::W`](W) writer structure"]
+impl crate::Writable for Data2Cmb1Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA2_CMB1 to value 0"]
+impl crate::Resettable for Data2Cmb1Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data2_cmb10.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA2_CMB10` reader"]
+pub type R = crate::R<Data2Cmb10Spec>;
+#[doc = "Register `DATA2_CMB10` writer"]
+pub type W = crate::W<Data2Cmb10Spec>;
+#[doc = "Field `BYTE6` reader - Data Byte 6"]
+pub type Byte6R = crate::FieldReader;
+#[doc = "Field `BYTE6` writer - Data Byte 6"]
+pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE5` reader - Data Byte 5"]
+pub type Byte5R = crate::FieldReader;
+#[doc = "Field `BYTE5` writer - Data Byte 5"]
+pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    pub fn byte6(&self) -> Byte6R {
+        Byte6R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    pub fn byte5(&self) -> Byte5R {
+        Byte5R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte6(&mut self) -> Byte6W<Data2Cmb10Spec> {
+        Byte6W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte5(&mut self) -> Byte5W<Data2Cmb10Spec> {
+        Byte5W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb10::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb10::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data2Cmb10Spec;
+impl crate::RegisterSpec for Data2Cmb10Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data2_cmb10::R`](R) reader structure"]
+impl crate::Readable for Data2Cmb10Spec {}
+#[doc = "`write(|w| ..)` method takes [`data2_cmb10::W`](W) writer structure"]
+impl crate::Writable for Data2Cmb10Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA2_CMB10 to value 0"]
+impl crate::Resettable for Data2Cmb10Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data2_cmb11.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA2_CMB11` reader"]
+pub type R = crate::R<Data2Cmb11Spec>;
+#[doc = "Register `DATA2_CMB11` writer"]
+pub type W = crate::W<Data2Cmb11Spec>;
+#[doc = "Field `BYTE6` reader - Data Byte 6"]
+pub type Byte6R = crate::FieldReader;
+#[doc = "Field `BYTE6` writer - Data Byte 6"]
+pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE5` reader - Data Byte 5"]
+pub type Byte5R = crate::FieldReader;
+#[doc = "Field `BYTE5` writer - Data Byte 5"]
+pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    pub fn byte6(&self) -> Byte6R {
+        Byte6R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    pub fn byte5(&self) -> Byte5R {
+        Byte5R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte6(&mut self) -> Byte6W<Data2Cmb11Spec> {
+        Byte6W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte5(&mut self) -> Byte5W<Data2Cmb11Spec> {
+        Byte5W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb11::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb11::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data2Cmb11Spec;
+impl crate::RegisterSpec for Data2Cmb11Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data2_cmb11::R`](R) reader structure"]
+impl crate::Readable for Data2Cmb11Spec {}
+#[doc = "`write(|w| ..)` method takes [`data2_cmb11::W`](W) writer structure"]
+impl crate::Writable for Data2Cmb11Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA2_CMB11 to value 0"]
+impl crate::Resettable for Data2Cmb11Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data2_cmb12.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA2_CMB12` reader"]
+pub type R = crate::R<Data2Cmb12Spec>;
+#[doc = "Register `DATA2_CMB12` writer"]
+pub type W = crate::W<Data2Cmb12Spec>;
+#[doc = "Field `BYTE6` reader - Data Byte 6"]
+pub type Byte6R = crate::FieldReader;
+#[doc = "Field `BYTE6` writer - Data Byte 6"]
+pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE5` reader - Data Byte 5"]
+pub type Byte5R = crate::FieldReader;
+#[doc = "Field `BYTE5` writer - Data Byte 5"]
+pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    pub fn byte6(&self) -> Byte6R {
+        Byte6R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    pub fn byte5(&self) -> Byte5R {
+        Byte5R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte6(&mut self) -> Byte6W<Data2Cmb12Spec> {
+        Byte6W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte5(&mut self) -> Byte5W<Data2Cmb12Spec> {
+        Byte5W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb12::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb12::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data2Cmb12Spec;
+impl crate::RegisterSpec for Data2Cmb12Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data2_cmb12::R`](R) reader structure"]
+impl crate::Readable for Data2Cmb12Spec {}
+#[doc = "`write(|w| ..)` method takes [`data2_cmb12::W`](W) writer structure"]
+impl crate::Writable for Data2Cmb12Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA2_CMB12 to value 0"]
+impl crate::Resettable for Data2Cmb12Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data2_cmb13.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA2_CMB13` reader"]
+pub type R = crate::R<Data2Cmb13Spec>;
+#[doc = "Register `DATA2_CMB13` writer"]
+pub type W = crate::W<Data2Cmb13Spec>;
+#[doc = "Field `BYTE6` reader - Data Byte 6"]
+pub type Byte6R = crate::FieldReader;
+#[doc = "Field `BYTE6` writer - Data Byte 6"]
+pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE5` reader - Data Byte 5"]
+pub type Byte5R = crate::FieldReader;
+#[doc = "Field `BYTE5` writer - Data Byte 5"]
+pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    pub fn byte6(&self) -> Byte6R {
+        Byte6R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    pub fn byte5(&self) -> Byte5R {
+        Byte5R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte6(&mut self) -> Byte6W<Data2Cmb13Spec> {
+        Byte6W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte5(&mut self) -> Byte5W<Data2Cmb13Spec> {
+        Byte5W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb13::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb13::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data2Cmb13Spec;
+impl crate::RegisterSpec for Data2Cmb13Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data2_cmb13::R`](R) reader structure"]
+impl crate::Readable for Data2Cmb13Spec {}
+#[doc = "`write(|w| ..)` method takes [`data2_cmb13::W`](W) writer structure"]
+impl crate::Writable for Data2Cmb13Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA2_CMB13 to value 0"]
+impl crate::Resettable for Data2Cmb13Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data2_cmb14.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA2_CMB14` reader"]
+pub type R = crate::R<Data2Cmb14Spec>;
+#[doc = "Register `DATA2_CMB14` writer"]
+pub type W = crate::W<Data2Cmb14Spec>;
+#[doc = "Field `BYTE6` reader - Data Byte 6"]
+pub type Byte6R = crate::FieldReader;
+#[doc = "Field `BYTE6` writer - Data Byte 6"]
+pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE5` reader - Data Byte 5"]
+pub type Byte5R = crate::FieldReader;
+#[doc = "Field `BYTE5` writer - Data Byte 5"]
+pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    pub fn byte6(&self) -> Byte6R {
+        Byte6R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    pub fn byte5(&self) -> Byte5R {
+        Byte5R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte6(&mut self) -> Byte6W<Data2Cmb14Spec> {
+        Byte6W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte5(&mut self) -> Byte5W<Data2Cmb14Spec> {
+        Byte5W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb14::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb14::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data2Cmb14Spec;
+impl crate::RegisterSpec for Data2Cmb14Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data2_cmb14::R`](R) reader structure"]
+impl crate::Readable for Data2Cmb14Spec {}
+#[doc = "`write(|w| ..)` method takes [`data2_cmb14::W`](W) writer structure"]
+impl crate::Writable for Data2Cmb14Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA2_CMB14 to value 0"]
+impl crate::Resettable for Data2Cmb14Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data2_cmb2.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA2_CMB2` reader"]
+pub type R = crate::R<Data2Cmb2Spec>;
+#[doc = "Register `DATA2_CMB2` writer"]
+pub type W = crate::W<Data2Cmb2Spec>;
+#[doc = "Field `BYTE6` reader - Data Byte 6"]
+pub type Byte6R = crate::FieldReader;
+#[doc = "Field `BYTE6` writer - Data Byte 6"]
+pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE5` reader - Data Byte 5"]
+pub type Byte5R = crate::FieldReader;
+#[doc = "Field `BYTE5` writer - Data Byte 5"]
+pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    pub fn byte6(&self) -> Byte6R {
+        Byte6R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    pub fn byte5(&self) -> Byte5R {
+        Byte5R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte6(&mut self) -> Byte6W<Data2Cmb2Spec> {
+        Byte6W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte5(&mut self) -> Byte5W<Data2Cmb2Spec> {
+        Byte5W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb2::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb2::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data2Cmb2Spec;
+impl crate::RegisterSpec for Data2Cmb2Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data2_cmb2::R`](R) reader structure"]
+impl crate::Readable for Data2Cmb2Spec {}
+#[doc = "`write(|w| ..)` method takes [`data2_cmb2::W`](W) writer structure"]
+impl crate::Writable for Data2Cmb2Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA2_CMB2 to value 0"]
+impl crate::Resettable for Data2Cmb2Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data2_cmb3.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA2_CMB3` reader"]
+pub type R = crate::R<Data2Cmb3Spec>;
+#[doc = "Register `DATA2_CMB3` writer"]
+pub type W = crate::W<Data2Cmb3Spec>;
+#[doc = "Field `BYTE6` reader - Data Byte 6"]
+pub type Byte6R = crate::FieldReader;
+#[doc = "Field `BYTE6` writer - Data Byte 6"]
+pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE5` reader - Data Byte 5"]
+pub type Byte5R = crate::FieldReader;
+#[doc = "Field `BYTE5` writer - Data Byte 5"]
+pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    pub fn byte6(&self) -> Byte6R {
+        Byte6R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    pub fn byte5(&self) -> Byte5R {
+        Byte5R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte6(&mut self) -> Byte6W<Data2Cmb3Spec> {
+        Byte6W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte5(&mut self) -> Byte5W<Data2Cmb3Spec> {
+        Byte5W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb3::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb3::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data2Cmb3Spec;
+impl crate::RegisterSpec for Data2Cmb3Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data2_cmb3::R`](R) reader structure"]
+impl crate::Readable for Data2Cmb3Spec {}
+#[doc = "`write(|w| ..)` method takes [`data2_cmb3::W`](W) writer structure"]
+impl crate::Writable for Data2Cmb3Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA2_CMB3 to value 0"]
+impl crate::Resettable for Data2Cmb3Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data2_cmb4.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA2_CMB4` reader"]
+pub type R = crate::R<Data2Cmb4Spec>;
+#[doc = "Register `DATA2_CMB4` writer"]
+pub type W = crate::W<Data2Cmb4Spec>;
+#[doc = "Field `BYTE6` reader - Data Byte 6"]
+pub type Byte6R = crate::FieldReader;
+#[doc = "Field `BYTE6` writer - Data Byte 6"]
+pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE5` reader - Data Byte 5"]
+pub type Byte5R = crate::FieldReader;
+#[doc = "Field `BYTE5` writer - Data Byte 5"]
+pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    pub fn byte6(&self) -> Byte6R {
+        Byte6R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    pub fn byte5(&self) -> Byte5R {
+        Byte5R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte6(&mut self) -> Byte6W<Data2Cmb4Spec> {
+        Byte6W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte5(&mut self) -> Byte5W<Data2Cmb4Spec> {
+        Byte5W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb4::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb4::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data2Cmb4Spec;
+impl crate::RegisterSpec for Data2Cmb4Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data2_cmb4::R`](R) reader structure"]
+impl crate::Readable for Data2Cmb4Spec {}
+#[doc = "`write(|w| ..)` method takes [`data2_cmb4::W`](W) writer structure"]
+impl crate::Writable for Data2Cmb4Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA2_CMB4 to value 0"]
+impl crate::Resettable for Data2Cmb4Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data2_cmb5.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA2_CMB5` reader"]
+pub type R = crate::R<Data2Cmb5Spec>;
+#[doc = "Register `DATA2_CMB5` writer"]
+pub type W = crate::W<Data2Cmb5Spec>;
+#[doc = "Field `BYTE6` reader - Data Byte 6"]
+pub type Byte6R = crate::FieldReader;
+#[doc = "Field `BYTE6` writer - Data Byte 6"]
+pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE5` reader - Data Byte 5"]
+pub type Byte5R = crate::FieldReader;
+#[doc = "Field `BYTE5` writer - Data Byte 5"]
+pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    pub fn byte6(&self) -> Byte6R {
+        Byte6R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    pub fn byte5(&self) -> Byte5R {
+        Byte5R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte6(&mut self) -> Byte6W<Data2Cmb5Spec> {
+        Byte6W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte5(&mut self) -> Byte5W<Data2Cmb5Spec> {
+        Byte5W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb5::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb5::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data2Cmb5Spec;
+impl crate::RegisterSpec for Data2Cmb5Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data2_cmb5::R`](R) reader structure"]
+impl crate::Readable for Data2Cmb5Spec {}
+#[doc = "`write(|w| ..)` method takes [`data2_cmb5::W`](W) writer structure"]
+impl crate::Writable for Data2Cmb5Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA2_CMB5 to value 0"]
+impl crate::Resettable for Data2Cmb5Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data2_cmb6.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA2_CMB6` reader"]
+pub type R = crate::R<Data2Cmb6Spec>;
+#[doc = "Register `DATA2_CMB6` writer"]
+pub type W = crate::W<Data2Cmb6Spec>;
+#[doc = "Field `BYTE6` reader - Data Byte 6"]
+pub type Byte6R = crate::FieldReader;
+#[doc = "Field `BYTE6` writer - Data Byte 6"]
+pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE5` reader - Data Byte 5"]
+pub type Byte5R = crate::FieldReader;
+#[doc = "Field `BYTE5` writer - Data Byte 5"]
+pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    pub fn byte6(&self) -> Byte6R {
+        Byte6R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    pub fn byte5(&self) -> Byte5R {
+        Byte5R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte6(&mut self) -> Byte6W<Data2Cmb6Spec> {
+        Byte6W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte5(&mut self) -> Byte5W<Data2Cmb6Spec> {
+        Byte5W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb6::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb6::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data2Cmb6Spec;
+impl crate::RegisterSpec for Data2Cmb6Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data2_cmb6::R`](R) reader structure"]
+impl crate::Readable for Data2Cmb6Spec {}
+#[doc = "`write(|w| ..)` method takes [`data2_cmb6::W`](W) writer structure"]
+impl crate::Writable for Data2Cmb6Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA2_CMB6 to value 0"]
+impl crate::Resettable for Data2Cmb6Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data2_cmb7.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA2_CMB7` reader"]
+pub type R = crate::R<Data2Cmb7Spec>;
+#[doc = "Register `DATA2_CMB7` writer"]
+pub type W = crate::W<Data2Cmb7Spec>;
+#[doc = "Field `BYTE6` reader - Data Byte 6"]
+pub type Byte6R = crate::FieldReader;
+#[doc = "Field `BYTE6` writer - Data Byte 6"]
+pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE5` reader - Data Byte 5"]
+pub type Byte5R = crate::FieldReader;
+#[doc = "Field `BYTE5` writer - Data Byte 5"]
+pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    pub fn byte6(&self) -> Byte6R {
+        Byte6R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    pub fn byte5(&self) -> Byte5R {
+        Byte5R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte6(&mut self) -> Byte6W<Data2Cmb7Spec> {
+        Byte6W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte5(&mut self) -> Byte5W<Data2Cmb7Spec> {
+        Byte5W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb7::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb7::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data2Cmb7Spec;
+impl crate::RegisterSpec for Data2Cmb7Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data2_cmb7::R`](R) reader structure"]
+impl crate::Readable for Data2Cmb7Spec {}
+#[doc = "`write(|w| ..)` method takes [`data2_cmb7::W`](W) writer structure"]
+impl crate::Writable for Data2Cmb7Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA2_CMB7 to value 0"]
+impl crate::Resettable for Data2Cmb7Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data2_cmb8.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA2_CMB8` reader"]
+pub type R = crate::R<Data2Cmb8Spec>;
+#[doc = "Register `DATA2_CMB8` writer"]
+pub type W = crate::W<Data2Cmb8Spec>;
+#[doc = "Field `BYTE6` reader - Data Byte 6"]
+pub type Byte6R = crate::FieldReader;
+#[doc = "Field `BYTE6` writer - Data Byte 6"]
+pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE5` reader - Data Byte 5"]
+pub type Byte5R = crate::FieldReader;
+#[doc = "Field `BYTE5` writer - Data Byte 5"]
+pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    pub fn byte6(&self) -> Byte6R {
+        Byte6R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    pub fn byte5(&self) -> Byte5R {
+        Byte5R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte6(&mut self) -> Byte6W<Data2Cmb8Spec> {
+        Byte6W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte5(&mut self) -> Byte5W<Data2Cmb8Spec> {
+        Byte5W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb8::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb8::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data2Cmb8Spec;
+impl crate::RegisterSpec for Data2Cmb8Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data2_cmb8::R`](R) reader structure"]
+impl crate::Readable for Data2Cmb8Spec {}
+#[doc = "`write(|w| ..)` method takes [`data2_cmb8::W`](W) writer structure"]
+impl crate::Writable for Data2Cmb8Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA2_CMB8 to value 0"]
+impl crate::Resettable for Data2Cmb8Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data2_cmb9.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA2_CMB9` reader"]
+pub type R = crate::R<Data2Cmb9Spec>;
+#[doc = "Register `DATA2_CMB9` writer"]
+pub type W = crate::W<Data2Cmb9Spec>;
+#[doc = "Field `BYTE6` reader - Data Byte 6"]
+pub type Byte6R = crate::FieldReader;
+#[doc = "Field `BYTE6` writer - Data Byte 6"]
+pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE5` reader - Data Byte 5"]
+pub type Byte5R = crate::FieldReader;
+#[doc = "Field `BYTE5` writer - Data Byte 5"]
+pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    pub fn byte6(&self) -> Byte6R {
+        Byte6R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    pub fn byte5(&self) -> Byte5R {
+        Byte5R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte6(&mut self) -> Byte6W<Data2Cmb9Spec> {
+        Byte6W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte5(&mut self) -> Byte5W<Data2Cmb9Spec> {
+        Byte5W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb9::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb9::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data2Cmb9Spec;
+impl crate::RegisterSpec for Data2Cmb9Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data2_cmb9::R`](R) reader structure"]
+impl crate::Readable for Data2Cmb9Spec {}
+#[doc = "`write(|w| ..)` method takes [`data2_cmb9::W`](W) writer structure"]
+impl crate::Writable for Data2Cmb9Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA2_CMB9 to value 0"]
+impl crate::Resettable for Data2Cmb9Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data2_hcmb.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA2_HCMB` reader"]
+pub type R = crate::R<Data2HcmbSpec>;
+#[doc = "Register `DATA2_HCMB` writer"]
+pub type W = crate::W<Data2HcmbSpec>;
+#[doc = "Field `BYTE6` reader - Data Byte 6"]
+pub type Byte6R = crate::FieldReader;
+#[doc = "Field `BYTE6` writer - Data Byte 6"]
+pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE5` reader - Data Byte 5"]
+pub type Byte5R = crate::FieldReader;
+#[doc = "Field `BYTE5` writer - Data Byte 5"]
+pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    pub fn byte6(&self) -> Byte6R {
+        Byte6R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    pub fn byte5(&self) -> Byte5R {
+        Byte5R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 6"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte6(&mut self) -> Byte6W<Data2HcmbSpec> {
+        Byte6W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 5"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte5(&mut self) -> Byte5W<Data2HcmbSpec> {
+        Byte5W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_hcmb::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_hcmb::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data2HcmbSpec;
+impl crate::RegisterSpec for Data2HcmbSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data2_hcmb::R`](R) reader structure"]
+impl crate::Readable for Data2HcmbSpec {}
+#[doc = "`write(|w| ..)` method takes [`data2_hcmb::W`](W) writer structure"]
+impl crate::Writable for Data2HcmbSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA2_HCMB to value 0"]
+impl crate::Resettable for Data2HcmbSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data3_cmb0.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA3_CMB0` reader"]
+pub type R = crate::R<Data3Cmb0Spec>;
+#[doc = "Register `DATA3_CMB0` writer"]
+pub type W = crate::W<Data3Cmb0Spec>;
+#[doc = "Field `BYTE8` reader - Data Byte 8"]
+pub type Byte8R = crate::FieldReader;
+#[doc = "Field `BYTE8` writer - Data Byte 8"]
+pub type Byte8W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE7` reader - Data Byte 7"]
+pub type Byte7R = crate::FieldReader;
+#[doc = "Field `BYTE7` writer - Data Byte 7"]
+pub type Byte7W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    pub fn byte8(&self) -> Byte8R {
+        Byte8R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    pub fn byte7(&self) -> Byte7R {
+        Byte7R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte8(&mut self) -> Byte8W<Data3Cmb0Spec> {
+        Byte8W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte7(&mut self) -> Byte7W<Data3Cmb0Spec> {
+        Byte7W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 3\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data3_cmb0::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data3_cmb0::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data3Cmb0Spec;
+impl crate::RegisterSpec for Data3Cmb0Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data3_cmb0::R`](R) reader structure"]
+impl crate::Readable for Data3Cmb0Spec {}
+#[doc = "`write(|w| ..)` method takes [`data3_cmb0::W`](W) writer structure"]
+impl crate::Writable for Data3Cmb0Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA3_CMB0 to value 0"]
+impl crate::Resettable for Data3Cmb0Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data3_cmb1.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA3_CMB1` reader"]
+pub type R = crate::R<Data3Cmb1Spec>;
+#[doc = "Register `DATA3_CMB1` writer"]
+pub type W = crate::W<Data3Cmb1Spec>;
+#[doc = "Field `BYTE8` reader - Data Byte 8"]
+pub type Byte8R = crate::FieldReader;
+#[doc = "Field `BYTE8` writer - Data Byte 8"]
+pub type Byte8W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE7` reader - Data Byte 7"]
+pub type Byte7R = crate::FieldReader;
+#[doc = "Field `BYTE7` writer - Data Byte 7"]
+pub type Byte7W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    pub fn byte8(&self) -> Byte8R {
+        Byte8R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    pub fn byte7(&self) -> Byte7R {
+        Byte7R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte8(&mut self) -> Byte8W<Data3Cmb1Spec> {
+        Byte8W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte7(&mut self) -> Byte7W<Data3Cmb1Spec> {
+        Byte7W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 3\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data3_cmb1::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data3_cmb1::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data3Cmb1Spec;
+impl crate::RegisterSpec for Data3Cmb1Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data3_cmb1::R`](R) reader structure"]
+impl crate::Readable for Data3Cmb1Spec {}
+#[doc = "`write(|w| ..)` method takes [`data3_cmb1::W`](W) writer structure"]
+impl crate::Writable for Data3Cmb1Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA3_CMB1 to value 0"]
+impl crate::Resettable for Data3Cmb1Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data3_cmb10.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA3_CMB10` reader"]
+pub type R = crate::R<Data3Cmb10Spec>;
+#[doc = "Register `DATA3_CMB10` writer"]
+pub type W = crate::W<Data3Cmb10Spec>;
+#[doc = "Field `BYTE8` reader - Data Byte 8"]
+pub type Byte8R = crate::FieldReader;
+#[doc = "Field `BYTE8` writer - Data Byte 8"]
+pub type Byte8W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE7` reader - Data Byte 7"]
+pub type Byte7R = crate::FieldReader;
+#[doc = "Field `BYTE7` writer - Data Byte 7"]
+pub type Byte7W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    pub fn byte8(&self) -> Byte8R {
+        Byte8R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    pub fn byte7(&self) -> Byte7R {
+        Byte7R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte8(&mut self) -> Byte8W<Data3Cmb10Spec> {
+        Byte8W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte7(&mut self) -> Byte7W<Data3Cmb10Spec> {
+        Byte7W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 3\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data3_cmb10::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data3_cmb10::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data3Cmb10Spec;
+impl crate::RegisterSpec for Data3Cmb10Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data3_cmb10::R`](R) reader structure"]
+impl crate::Readable for Data3Cmb10Spec {}
+#[doc = "`write(|w| ..)` method takes [`data3_cmb10::W`](W) writer structure"]
+impl crate::Writable for Data3Cmb10Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA3_CMB10 to value 0"]
+impl crate::Resettable for Data3Cmb10Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data3_cmb11.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA3_CMB11` reader"]
+pub type R = crate::R<Data3Cmb11Spec>;
+#[doc = "Register `DATA3_CMB11` writer"]
+pub type W = crate::W<Data3Cmb11Spec>;
+#[doc = "Field `BYTE8` reader - Data Byte 8"]
+pub type Byte8R = crate::FieldReader;
+#[doc = "Field `BYTE8` writer - Data Byte 8"]
+pub type Byte8W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE7` reader - Data Byte 7"]
+pub type Byte7R = crate::FieldReader;
+#[doc = "Field `BYTE7` writer - Data Byte 7"]
+pub type Byte7W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    pub fn byte8(&self) -> Byte8R {
+        Byte8R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    pub fn byte7(&self) -> Byte7R {
+        Byte7R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte8(&mut self) -> Byte8W<Data3Cmb11Spec> {
+        Byte8W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte7(&mut self) -> Byte7W<Data3Cmb11Spec> {
+        Byte7W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 3\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data3_cmb11::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data3_cmb11::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data3Cmb11Spec;
+impl crate::RegisterSpec for Data3Cmb11Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data3_cmb11::R`](R) reader structure"]
+impl crate::Readable for Data3Cmb11Spec {}
+#[doc = "`write(|w| ..)` method takes [`data3_cmb11::W`](W) writer structure"]
+impl crate::Writable for Data3Cmb11Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA3_CMB11 to value 0"]
+impl crate::Resettable for Data3Cmb11Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data3_cmb12.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA3_CMB12` reader"]
+pub type R = crate::R<Data3Cmb12Spec>;
+#[doc = "Register `DATA3_CMB12` writer"]
+pub type W = crate::W<Data3Cmb12Spec>;
+#[doc = "Field `BYTE8` reader - Data Byte 8"]
+pub type Byte8R = crate::FieldReader;
+#[doc = "Field `BYTE8` writer - Data Byte 8"]
+pub type Byte8W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE7` reader - Data Byte 7"]
+pub type Byte7R = crate::FieldReader;
+#[doc = "Field `BYTE7` writer - Data Byte 7"]
+pub type Byte7W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    pub fn byte8(&self) -> Byte8R {
+        Byte8R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    pub fn byte7(&self) -> Byte7R {
+        Byte7R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte8(&mut self) -> Byte8W<Data3Cmb12Spec> {
+        Byte8W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte7(&mut self) -> Byte7W<Data3Cmb12Spec> {
+        Byte7W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 3\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data3_cmb12::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data3_cmb12::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data3Cmb12Spec;
+impl crate::RegisterSpec for Data3Cmb12Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data3_cmb12::R`](R) reader structure"]
+impl crate::Readable for Data3Cmb12Spec {}
+#[doc = "`write(|w| ..)` method takes [`data3_cmb12::W`](W) writer structure"]
+impl crate::Writable for Data3Cmb12Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA3_CMB12 to value 0"]
+impl crate::Resettable for Data3Cmb12Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data3_cmb13.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA3_CMB13` reader"]
+pub type R = crate::R<Data3Cmb13Spec>;
+#[doc = "Register `DATA3_CMB13` writer"]
+pub type W = crate::W<Data3Cmb13Spec>;
+#[doc = "Field `BYTE8` reader - Data Byte 8"]
+pub type Byte8R = crate::FieldReader;
+#[doc = "Field `BYTE8` writer - Data Byte 8"]
+pub type Byte8W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE7` reader - Data Byte 7"]
+pub type Byte7R = crate::FieldReader;
+#[doc = "Field `BYTE7` writer - Data Byte 7"]
+pub type Byte7W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    pub fn byte8(&self) -> Byte8R {
+        Byte8R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    pub fn byte7(&self) -> Byte7R {
+        Byte7R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte8(&mut self) -> Byte8W<Data3Cmb13Spec> {
+        Byte8W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte7(&mut self) -> Byte7W<Data3Cmb13Spec> {
+        Byte7W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 3\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data3_cmb13::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data3_cmb13::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data3Cmb13Spec;
+impl crate::RegisterSpec for Data3Cmb13Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data3_cmb13::R`](R) reader structure"]
+impl crate::Readable for Data3Cmb13Spec {}
+#[doc = "`write(|w| ..)` method takes [`data3_cmb13::W`](W) writer structure"]
+impl crate::Writable for Data3Cmb13Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA3_CMB13 to value 0"]
+impl crate::Resettable for Data3Cmb13Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data3_cmb14.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA3_CMB14` reader"]
+pub type R = crate::R<Data3Cmb14Spec>;
+#[doc = "Register `DATA3_CMB14` writer"]
+pub type W = crate::W<Data3Cmb14Spec>;
+#[doc = "Field `BYTE8` reader - Data Byte 8"]
+pub type Byte8R = crate::FieldReader;
+#[doc = "Field `BYTE8` writer - Data Byte 8"]
+pub type Byte8W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE7` reader - Data Byte 7"]
+pub type Byte7R = crate::FieldReader;
+#[doc = "Field `BYTE7` writer - Data Byte 7"]
+pub type Byte7W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    pub fn byte8(&self) -> Byte8R {
+        Byte8R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    pub fn byte7(&self) -> Byte7R {
+        Byte7R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte8(&mut self) -> Byte8W<Data3Cmb14Spec> {
+        Byte8W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte7(&mut self) -> Byte7W<Data3Cmb14Spec> {
+        Byte7W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 3\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data3_cmb14::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data3_cmb14::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data3Cmb14Spec;
+impl crate::RegisterSpec for Data3Cmb14Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data3_cmb14::R`](R) reader structure"]
+impl crate::Readable for Data3Cmb14Spec {}
+#[doc = "`write(|w| ..)` method takes [`data3_cmb14::W`](W) writer structure"]
+impl crate::Writable for Data3Cmb14Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA3_CMB14 to value 0"]
+impl crate::Resettable for Data3Cmb14Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data3_cmb2.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA3_CMB2` reader"]
+pub type R = crate::R<Data3Cmb2Spec>;
+#[doc = "Register `DATA3_CMB2` writer"]
+pub type W = crate::W<Data3Cmb2Spec>;
+#[doc = "Field `BYTE8` reader - Data Byte 8"]
+pub type Byte8R = crate::FieldReader;
+#[doc = "Field `BYTE8` writer - Data Byte 8"]
+pub type Byte8W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE7` reader - Data Byte 7"]
+pub type Byte7R = crate::FieldReader;
+#[doc = "Field `BYTE7` writer - Data Byte 7"]
+pub type Byte7W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    pub fn byte8(&self) -> Byte8R {
+        Byte8R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    pub fn byte7(&self) -> Byte7R {
+        Byte7R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte8(&mut self) -> Byte8W<Data3Cmb2Spec> {
+        Byte8W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte7(&mut self) -> Byte7W<Data3Cmb2Spec> {
+        Byte7W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 3\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data3_cmb2::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data3_cmb2::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data3Cmb2Spec;
+impl crate::RegisterSpec for Data3Cmb2Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data3_cmb2::R`](R) reader structure"]
+impl crate::Readable for Data3Cmb2Spec {}
+#[doc = "`write(|w| ..)` method takes [`data3_cmb2::W`](W) writer structure"]
+impl crate::Writable for Data3Cmb2Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA3_CMB2 to value 0"]
+impl crate::Resettable for Data3Cmb2Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data3_cmb3.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA3_CMB3` reader"]
+pub type R = crate::R<Data3Cmb3Spec>;
+#[doc = "Register `DATA3_CMB3` writer"]
+pub type W = crate::W<Data3Cmb3Spec>;
+#[doc = "Field `BYTE8` reader - Data Byte 8"]
+pub type Byte8R = crate::FieldReader;
+#[doc = "Field `BYTE8` writer - Data Byte 8"]
+pub type Byte8W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE7` reader - Data Byte 7"]
+pub type Byte7R = crate::FieldReader;
+#[doc = "Field `BYTE7` writer - Data Byte 7"]
+pub type Byte7W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    pub fn byte8(&self) -> Byte8R {
+        Byte8R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    pub fn byte7(&self) -> Byte7R {
+        Byte7R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte8(&mut self) -> Byte8W<Data3Cmb3Spec> {
+        Byte8W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte7(&mut self) -> Byte7W<Data3Cmb3Spec> {
+        Byte7W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 3\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data3_cmb3::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data3_cmb3::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data3Cmb3Spec;
+impl crate::RegisterSpec for Data3Cmb3Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data3_cmb3::R`](R) reader structure"]
+impl crate::Readable for Data3Cmb3Spec {}
+#[doc = "`write(|w| ..)` method takes [`data3_cmb3::W`](W) writer structure"]
+impl crate::Writable for Data3Cmb3Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA3_CMB3 to value 0"]
+impl crate::Resettable for Data3Cmb3Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data3_cmb4.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA3_CMB4` reader"]
+pub type R = crate::R<Data3Cmb4Spec>;
+#[doc = "Register `DATA3_CMB4` writer"]
+pub type W = crate::W<Data3Cmb4Spec>;
+#[doc = "Field `BYTE8` reader - Data Byte 8"]
+pub type Byte8R = crate::FieldReader;
+#[doc = "Field `BYTE8` writer - Data Byte 8"]
+pub type Byte8W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE7` reader - Data Byte 7"]
+pub type Byte7R = crate::FieldReader;
+#[doc = "Field `BYTE7` writer - Data Byte 7"]
+pub type Byte7W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    pub fn byte8(&self) -> Byte8R {
+        Byte8R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    pub fn byte7(&self) -> Byte7R {
+        Byte7R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte8(&mut self) -> Byte8W<Data3Cmb4Spec> {
+        Byte8W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte7(&mut self) -> Byte7W<Data3Cmb4Spec> {
+        Byte7W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 3\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data3_cmb4::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data3_cmb4::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data3Cmb4Spec;
+impl crate::RegisterSpec for Data3Cmb4Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data3_cmb4::R`](R) reader structure"]
+impl crate::Readable for Data3Cmb4Spec {}
+#[doc = "`write(|w| ..)` method takes [`data3_cmb4::W`](W) writer structure"]
+impl crate::Writable for Data3Cmb4Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA3_CMB4 to value 0"]
+impl crate::Resettable for Data3Cmb4Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data3_cmb5.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA3_CMB5` reader"]
+pub type R = crate::R<Data3Cmb5Spec>;
+#[doc = "Register `DATA3_CMB5` writer"]
+pub type W = crate::W<Data3Cmb5Spec>;
+#[doc = "Field `BYTE8` reader - Data Byte 8"]
+pub type Byte8R = crate::FieldReader;
+#[doc = "Field `BYTE8` writer - Data Byte 8"]
+pub type Byte8W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE7` reader - Data Byte 7"]
+pub type Byte7R = crate::FieldReader;
+#[doc = "Field `BYTE7` writer - Data Byte 7"]
+pub type Byte7W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    pub fn byte8(&self) -> Byte8R {
+        Byte8R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    pub fn byte7(&self) -> Byte7R {
+        Byte7R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte8(&mut self) -> Byte8W<Data3Cmb5Spec> {
+        Byte8W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte7(&mut self) -> Byte7W<Data3Cmb5Spec> {
+        Byte7W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 3\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data3_cmb5::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data3_cmb5::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data3Cmb5Spec;
+impl crate::RegisterSpec for Data3Cmb5Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data3_cmb5::R`](R) reader structure"]
+impl crate::Readable for Data3Cmb5Spec {}
+#[doc = "`write(|w| ..)` method takes [`data3_cmb5::W`](W) writer structure"]
+impl crate::Writable for Data3Cmb5Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA3_CMB5 to value 0"]
+impl crate::Resettable for Data3Cmb5Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data3_cmb6.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA3_CMB6` reader"]
+pub type R = crate::R<Data3Cmb6Spec>;
+#[doc = "Register `DATA3_CMB6` writer"]
+pub type W = crate::W<Data3Cmb6Spec>;
+#[doc = "Field `BYTE8` reader - Data Byte 8"]
+pub type Byte8R = crate::FieldReader;
+#[doc = "Field `BYTE8` writer - Data Byte 8"]
+pub type Byte8W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+#[doc = "Field `BYTE7` reader - Data Byte 7"]
+pub type Byte7R = crate::FieldReader;
+#[doc = "Field `BYTE7` writer - Data Byte 7"]
+pub type Byte7W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
+impl R {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    pub fn byte8(&self) -> Byte8R {
+        Byte8R::new((self.bits & 0xff) as u8)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    pub fn byte7(&self) -> Byte7R {
+        Byte7R::new(((self.bits >> 8) & 0xff) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:7 - Data Byte 8"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte8(&mut self) -> Byte8W<Data3Cmb6Spec> {
+        Byte8W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte7(&mut self) -> Byte7W<Data3Cmb6Spec> {
+        Byte7W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 3\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data3_cmb6::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data3_cmb6::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Data3Cmb6Spec;
+impl crate::RegisterSpec for Data3Cmb6Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data3_cmb6::R`](R) reader structure"]
+impl crate::Readable for Data3Cmb6Spec {}
+#[doc = "`write(|w| ..)` method takes [`data3_cmb6::W`](W) writer structure"]
+impl crate::Writable for Data3Cmb6Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATA3_CMB6 to value 0"]
+impl crate::Resettable for Data3Cmb6Spec {
+    const RESET_VALUE: u32 = 0;
+}