Init Commit

Monorepo for Rust support of VA416XX family of radiation hardened MCUs

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;
+}

va416xx/src/can0/data3_cmb7.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA3_CMB7` reader"]
+pub type R = crate::R<Data3Cmb7Spec>;
+#[doc = "Register `DATA3_CMB7` writer"]
+pub type W = crate::W<Data3Cmb7Spec>;
+#[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<Data3Cmb7Spec> {
+        Byte8W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte7(&mut self) -> Byte7W<Data3Cmb7Spec> {
+        Byte7W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 3\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data3_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 [`data3_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 Data3Cmb7Spec;
+impl crate::RegisterSpec for Data3Cmb7Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data3_cmb7::R`](R) reader structure"]
+impl crate::Readable for Data3Cmb7Spec {}
+#[doc = "`write(|w| ..)` method takes [`data3_cmb7::W`](W) writer structure"]
+impl crate::Writable for Data3Cmb7Spec {
+    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_CMB7 to value 0"]
+impl crate::Resettable for Data3Cmb7Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data3_cmb8.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA3_CMB8` reader"]
+pub type R = crate::R<Data3Cmb8Spec>;
+#[doc = "Register `DATA3_CMB8` writer"]
+pub type W = crate::W<Data3Cmb8Spec>;
+#[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<Data3Cmb8Spec> {
+        Byte8W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte7(&mut self) -> Byte7W<Data3Cmb8Spec> {
+        Byte7W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 3\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data3_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 [`data3_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 Data3Cmb8Spec;
+impl crate::RegisterSpec for Data3Cmb8Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data3_cmb8::R`](R) reader structure"]
+impl crate::Readable for Data3Cmb8Spec {}
+#[doc = "`write(|w| ..)` method takes [`data3_cmb8::W`](W) writer structure"]
+impl crate::Writable for Data3Cmb8Spec {
+    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_CMB8 to value 0"]
+impl crate::Resettable for Data3Cmb8Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data3_cmb9.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA3_CMB9` reader"]
+pub type R = crate::R<Data3Cmb9Spec>;
+#[doc = "Register `DATA3_CMB9` writer"]
+pub type W = crate::W<Data3Cmb9Spec>;
+#[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<Data3Cmb9Spec> {
+        Byte8W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte7(&mut self) -> Byte7W<Data3Cmb9Spec> {
+        Byte7W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 3\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data3_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 [`data3_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 Data3Cmb9Spec;
+impl crate::RegisterSpec for Data3Cmb9Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data3_cmb9::R`](R) reader structure"]
+impl crate::Readable for Data3Cmb9Spec {}
+#[doc = "`write(|w| ..)` method takes [`data3_cmb9::W`](W) writer structure"]
+impl crate::Writable for Data3Cmb9Spec {
+    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_CMB9 to value 0"]
+impl crate::Resettable for Data3Cmb9Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/data3_hcmb.rs

@@ -0,0 +1,55 @@
+#[doc = "Register `DATA3_HCMB` reader"]
+pub type R = crate::R<Data3HcmbSpec>;
+#[doc = "Register `DATA3_HCMB` writer"]
+pub type W = crate::W<Data3HcmbSpec>;
+#[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<Data3HcmbSpec> {
+        Byte8W::new(self, 0)
+    }
+    #[doc = "Bits 8:15 - Data Byte 7"]
+    #[inline(always)]
+    #[must_use]
+    pub fn byte7(&mut self) -> Byte7W<Data3HcmbSpec> {
+        Byte7W::new(self, 8)
+    }
+}
+#[doc = "CAN Frame Data Word 3\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data3_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 [`data3_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 Data3HcmbSpec;
+impl crate::RegisterSpec for Data3HcmbSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`data3_hcmb::R`](R) reader structure"]
+impl crate::Readable for Data3HcmbSpec {}
+#[doc = "`write(|w| ..)` method takes [`data3_hcmb::W`](W) writer structure"]
+impl crate::Writable for Data3HcmbSpec {
+    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_HCMB to value 0"]
+impl crate::Resettable for Data3HcmbSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/gmskb.rs

@@ -0,0 +1,105 @@
+#[doc = "Register `GMSKB` reader"]
+pub type R = crate::R<GmskbSpec>;
+#[doc = "Register `GMSKB` writer"]
+pub type W = crate::W<GmskbSpec>;
+#[doc = "Field `GM0` reader - GM\\[17:15\\]
+- Unused in standard, ID\\[17:15\\]
+in extended"]
+pub type Gm0R = crate::FieldReader;
+#[doc = "Field `GM0` writer - GM\\[17:15\\]
+- Unused in standard, ID\\[17:15\\]
+in extended"]
+pub type Gm0W<'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 `GM1` reader - GM\\[28:18\\]
+- ID\\[10:0\\]
+in standard, ID\\[28:18\\]
+in extended"]
+pub type Gm1R = crate::FieldReader<u16>;
+#[doc = "Field `GM1` writer - GM\\[28:18\\]
+- ID\\[10:0\\]
+in standard, ID\\[28:18\\]
+in extended"]
+pub type Gm1W<'a, REG> = crate::FieldWriter<'a, REG, 11, u16>;
+impl R {
+    #[doc = "Bits 0:2 - GM\\[17:15\\]
+- Unused in standard, ID\\[17:15\\]
+in extended"]
+    #[inline(always)]
+    pub fn gm0(&self) -> Gm0R {
+        Gm0R::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 - GM\\[28:18\\]
+- ID\\[10:0\\]
+in standard, ID\\[28:18\\]
+in extended"]
+    #[inline(always)]
+    pub fn gm1(&self) -> Gm1R {
+        Gm1R::new(((self.bits >> 5) & 0x07ff) as u16)
+    }
+}
+impl W {
+    #[doc = "Bits 0:2 - GM\\[17:15\\]
+- Unused in standard, ID\\[17:15\\]
+in extended"]
+    #[inline(always)]
+    #[must_use]
+    pub fn gm0(&mut self) -> Gm0W<GmskbSpec> {
+        Gm0W::new(self, 0)
+    }
+    #[doc = "Bit 3 - Identifier Extension Bit"]
+    #[inline(always)]
+    #[must_use]
+    pub fn ide(&mut self) -> IdeW<GmskbSpec> {
+        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<GmskbSpec> {
+        RtrW::new(self, 4)
+    }
+    #[doc = "Bits 5:15 - GM\\[28:18\\]
+- ID\\[10:0\\]
+in standard, ID\\[28:18\\]
+in extended"]
+    #[inline(always)]
+    #[must_use]
+    pub fn gm1(&mut self) -> Gm1W<GmskbSpec> {
+        Gm1W::new(self, 5)
+    }
+}
+#[doc = "CAN Global Mask Base\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`gmskb::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 [`gmskb::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct GmskbSpec;
+impl crate::RegisterSpec for GmskbSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`gmskb::R`](R) reader structure"]
+impl crate::Readable for GmskbSpec {}
+#[doc = "`write(|w| ..)` method takes [`gmskb::W`](W) writer structure"]
+impl crate::Writable for GmskbSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets GMSKB to value 0"]
+impl crate::Resettable for GmskbSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/gmskx.rs

@@ -0,0 +1,63 @@
+#[doc = "Register `GMSKX` reader"]
+pub type R = crate::R<GmskxSpec>;
+#[doc = "Register `GMSKX` writer"]
+pub type W = crate::W<GmskxSpec>;
+#[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 `GM` reader - GM\\[14:0\\]
+used when an extended frame is received. ID\\[14:0\\]
+in extended, unused standard"]
+pub type GmR = crate::FieldReader<u16>;
+#[doc = "Field `GM` writer - GM\\[14:0\\]
+used when an extended frame is received. ID\\[14:0\\]
+in extended, unused standard"]
+pub type GmW<'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 - GM\\[14:0\\]
+used when an extended frame is received. ID\\[14:0\\]
+in extended, unused standard"]
+    #[inline(always)]
+    pub fn gm(&self) -> GmR {
+        GmR::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<GmskxSpec> {
+        XrtrW::new(self, 0)
+    }
+    #[doc = "Bits 1:15 - GM\\[14:0\\]
+used when an extended frame is received. ID\\[14:0\\]
+in extended, unused standard"]
+    #[inline(always)]
+    #[must_use]
+    pub fn gm(&mut self) -> GmW<GmskxSpec> {
+        GmW::new(self, 1)
+    }
+}
+#[doc = "CAN Global Mask Extension\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`gmskx::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 [`gmskx::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct GmskxSpec;
+impl crate::RegisterSpec for GmskxSpec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`gmskx::R`](R) reader structure"]
+impl crate::Readable for GmskxSpec {}
+#[doc = "`write(|w| ..)` method takes [`gmskx::W`](W) writer structure"]
+impl crate::Writable for GmskxSpec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets GMSKX to value 0"]
+impl crate::Resettable for GmskxSpec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/id0_cmb0.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `ID0_CMB0` reader"]
+pub type R = crate::R<Id0Cmb0Spec>;
+#[doc = "Register `ID0_CMB0` writer"]
+pub type W = crate::W<Id0Cmb0Spec>;
+#[doc = "Field `ID0` reader - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+pub type Id0R = crate::FieldReader<u16>;
+#[doc = "Field `ID0` writer - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+pub type Id0W<'a, REG> = crate::FieldWriter<'a, REG, 16, u16>;
+impl R {
+    #[doc = "Bits 0:15 - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+    #[inline(always)]
+    pub fn id0(&self) -> Id0R {
+        Id0R::new((self.bits & 0xffff) as u16)
+    }
+}
+impl W {
+    #[doc = "Bits 0:15 - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+    #[inline(always)]
+    #[must_use]
+    pub fn id0(&mut self) -> Id0W<Id0Cmb0Spec> {
+        Id0W::new(self, 0)
+    }
+}
+#[doc = "CAN Frame Identifier Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`id0_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 [`id0_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 Id0Cmb0Spec;
+impl crate::RegisterSpec for Id0Cmb0Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`id0_cmb0::R`](R) reader structure"]
+impl crate::Readable for Id0Cmb0Spec {}
+#[doc = "`write(|w| ..)` method takes [`id0_cmb0::W`](W) writer structure"]
+impl crate::Writable for Id0Cmb0Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets ID0_CMB0 to value 0"]
+impl crate::Resettable for Id0Cmb0Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/id0_cmb1.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `ID0_CMB1` reader"]
+pub type R = crate::R<Id0Cmb1Spec>;
+#[doc = "Register `ID0_CMB1` writer"]
+pub type W = crate::W<Id0Cmb1Spec>;
+#[doc = "Field `ID0` reader - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+pub type Id0R = crate::FieldReader<u16>;
+#[doc = "Field `ID0` writer - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+pub type Id0W<'a, REG> = crate::FieldWriter<'a, REG, 16, u16>;
+impl R {
+    #[doc = "Bits 0:15 - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+    #[inline(always)]
+    pub fn id0(&self) -> Id0R {
+        Id0R::new((self.bits & 0xffff) as u16)
+    }
+}
+impl W {
+    #[doc = "Bits 0:15 - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+    #[inline(always)]
+    #[must_use]
+    pub fn id0(&mut self) -> Id0W<Id0Cmb1Spec> {
+        Id0W::new(self, 0)
+    }
+}
+#[doc = "CAN Frame Identifier Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`id0_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 [`id0_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 Id0Cmb1Spec;
+impl crate::RegisterSpec for Id0Cmb1Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`id0_cmb1::R`](R) reader structure"]
+impl crate::Readable for Id0Cmb1Spec {}
+#[doc = "`write(|w| ..)` method takes [`id0_cmb1::W`](W) writer structure"]
+impl crate::Writable for Id0Cmb1Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets ID0_CMB1 to value 0"]
+impl crate::Resettable for Id0Cmb1Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/id0_cmb10.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `ID0_CMB10` reader"]
+pub type R = crate::R<Id0Cmb10Spec>;
+#[doc = "Register `ID0_CMB10` writer"]
+pub type W = crate::W<Id0Cmb10Spec>;
+#[doc = "Field `ID0` reader - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+pub type Id0R = crate::FieldReader<u16>;
+#[doc = "Field `ID0` writer - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+pub type Id0W<'a, REG> = crate::FieldWriter<'a, REG, 16, u16>;
+impl R {
+    #[doc = "Bits 0:15 - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+    #[inline(always)]
+    pub fn id0(&self) -> Id0R {
+        Id0R::new((self.bits & 0xffff) as u16)
+    }
+}
+impl W {
+    #[doc = "Bits 0:15 - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+    #[inline(always)]
+    #[must_use]
+    pub fn id0(&mut self) -> Id0W<Id0Cmb10Spec> {
+        Id0W::new(self, 0)
+    }
+}
+#[doc = "CAN Frame Identifier Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`id0_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 [`id0_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 Id0Cmb10Spec;
+impl crate::RegisterSpec for Id0Cmb10Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`id0_cmb10::R`](R) reader structure"]
+impl crate::Readable for Id0Cmb10Spec {}
+#[doc = "`write(|w| ..)` method takes [`id0_cmb10::W`](W) writer structure"]
+impl crate::Writable for Id0Cmb10Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets ID0_CMB10 to value 0"]
+impl crate::Resettable for Id0Cmb10Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/id0_cmb11.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `ID0_CMB11` reader"]
+pub type R = crate::R<Id0Cmb11Spec>;
+#[doc = "Register `ID0_CMB11` writer"]
+pub type W = crate::W<Id0Cmb11Spec>;
+#[doc = "Field `ID0` reader - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+pub type Id0R = crate::FieldReader<u16>;
+#[doc = "Field `ID0` writer - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+pub type Id0W<'a, REG> = crate::FieldWriter<'a, REG, 16, u16>;
+impl R {
+    #[doc = "Bits 0:15 - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+    #[inline(always)]
+    pub fn id0(&self) -> Id0R {
+        Id0R::new((self.bits & 0xffff) as u16)
+    }
+}
+impl W {
+    #[doc = "Bits 0:15 - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+    #[inline(always)]
+    #[must_use]
+    pub fn id0(&mut self) -> Id0W<Id0Cmb11Spec> {
+        Id0W::new(self, 0)
+    }
+}
+#[doc = "CAN Frame Identifier Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`id0_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 [`id0_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 Id0Cmb11Spec;
+impl crate::RegisterSpec for Id0Cmb11Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`id0_cmb11::R`](R) reader structure"]
+impl crate::Readable for Id0Cmb11Spec {}
+#[doc = "`write(|w| ..)` method takes [`id0_cmb11::W`](W) writer structure"]
+impl crate::Writable for Id0Cmb11Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets ID0_CMB11 to value 0"]
+impl crate::Resettable for Id0Cmb11Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/id0_cmb12.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `ID0_CMB12` reader"]
+pub type R = crate::R<Id0Cmb12Spec>;
+#[doc = "Register `ID0_CMB12` writer"]
+pub type W = crate::W<Id0Cmb12Spec>;
+#[doc = "Field `ID0` reader - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+pub type Id0R = crate::FieldReader<u16>;
+#[doc = "Field `ID0` writer - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+pub type Id0W<'a, REG> = crate::FieldWriter<'a, REG, 16, u16>;
+impl R {
+    #[doc = "Bits 0:15 - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+    #[inline(always)]
+    pub fn id0(&self) -> Id0R {
+        Id0R::new((self.bits & 0xffff) as u16)
+    }
+}
+impl W {
+    #[doc = "Bits 0:15 - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+    #[inline(always)]
+    #[must_use]
+    pub fn id0(&mut self) -> Id0W<Id0Cmb12Spec> {
+        Id0W::new(self, 0)
+    }
+}
+#[doc = "CAN Frame Identifier Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`id0_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 [`id0_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 Id0Cmb12Spec;
+impl crate::RegisterSpec for Id0Cmb12Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`id0_cmb12::R`](R) reader structure"]
+impl crate::Readable for Id0Cmb12Spec {}
+#[doc = "`write(|w| ..)` method takes [`id0_cmb12::W`](W) writer structure"]
+impl crate::Writable for Id0Cmb12Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets ID0_CMB12 to value 0"]
+impl crate::Resettable for Id0Cmb12Spec {
+    const RESET_VALUE: u32 = 0;
+}

va416xx/src/can0/id0_cmb13.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `ID0_CMB13` reader"]
+pub type R = crate::R<Id0Cmb13Spec>;
+#[doc = "Register `ID0_CMB13` writer"]
+pub type W = crate::W<Id0Cmb13Spec>;
+#[doc = "Field `ID0` reader - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+pub type Id0R = crate::FieldReader<u16>;
+#[doc = "Field `ID0` writer - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+pub type Id0W<'a, REG> = crate::FieldWriter<'a, REG, 16, u16>;
+impl R {
+    #[doc = "Bits 0:15 - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+    #[inline(always)]
+    pub fn id0(&self) -> Id0R {
+        Id0R::new((self.bits & 0xffff) as u16)
+    }
+}
+impl W {
+    #[doc = "Bits 0:15 - Half of CAN Frame ID. Format Varies for Standard or Extended Frames"]
+    #[inline(always)]
+    #[must_use]
+    pub fn id0(&mut self) -> Id0W<Id0Cmb13Spec> {
+        Id0W::new(self, 0)
+    }
+}
+#[doc = "CAN Frame Identifier Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`id0_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 [`id0_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 Id0Cmb13Spec;
+impl crate::RegisterSpec for Id0Cmb13Spec {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`id0_cmb13::R`](R) reader structure"]
+impl crate::Readable for Id0Cmb13Spec {}
+#[doc = "`write(|w| ..)` method takes [`id0_cmb13::W`](W) writer structure"]
+impl crate::Writable for Id0Cmb13Spec {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets ID0_CMB13 to value 0"]
+impl crate::Resettable for Id0Cmb13Spec {
+    const RESET_VALUE: u32 = 0;
+}