Merge pull request #31 from richardanaya/spinlock-read-write

Make spinlock registers read-write

Fixes #18

Author: 9names

src/sio/spinlock0.rs

@@ -13,6 +13,35 @@ impl From<crate::R<SPINLOCK0_SPEC>> for R {
         R(reader)
     }
 }
+#[doc = "Register `SPINLOCK0` writer"]
+pub struct W(crate::W<SPINLOCK0_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<SPINLOCK0_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<SPINLOCK0_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<SPINLOCK0_SPEC>) -> Self {
+        W(writer)
+    }
+}
+impl W {
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
 #[doc = "Reading from a spinlock address will:  
  - Return 0 if lock is already locked  
  - Otherwise return nonzero, and simultaneously claim the lock  
@@ -21,7 +50,7 @@ impl From<crate::R<SPINLOCK0_SPEC>> for R {
  If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.  
  The value returned on success is 0x1 << lock number.  
 
-This register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).  
+This register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).  
 
 For information about available fields see [spinlock0](index.html) module"]
 pub struct SPINLOCK0_SPEC;
@@ -32,6 +61,10 @@ impl crate::RegisterSpec for SPINLOCK0_SPEC {
 impl crate::Readable for SPINLOCK0_SPEC {
     type Reader = R;
 }
+#[doc = "`write(|w| ..)` method takes [spinlock0::W](W) writer structure"]
+impl crate::Writable for SPINLOCK0_SPEC {
+    type Writer = W;
+}
 #[doc = "`reset()` method sets SPINLOCK0 to value 0"]
 impl crate::Resettable for SPINLOCK0_SPEC {
     #[inline(always)]

src/sio/spinlock1.rs

@@ -13,6 +13,35 @@ impl From<crate::R<SPINLOCK1_SPEC>> for R {
         R(reader)
     }
 }
+#[doc = "Register `SPINLOCK1` writer"]
+pub struct W(crate::W<SPINLOCK1_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<SPINLOCK1_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<SPINLOCK1_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<SPINLOCK1_SPEC>) -> Self {
+        W(writer)
+    }
+}
+impl W {
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
 #[doc = "Reading from a spinlock address will:  
  - Return 0 if lock is already locked  
  - Otherwise return nonzero, and simultaneously claim the lock  
@@ -21,7 +50,7 @@ impl From<crate::R<SPINLOCK1_SPEC>> for R {
  If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.  
  The value returned on success is 0x1 << lock number.  
 
-This register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).  
+This register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).  
 
 For information about available fields see [spinlock1](index.html) module"]
 pub struct SPINLOCK1_SPEC;
@@ -32,6 +61,10 @@ impl crate::RegisterSpec for SPINLOCK1_SPEC {
 impl crate::Readable for SPINLOCK1_SPEC {
     type Reader = R;
 }
+#[doc = "`write(|w| ..)` method takes [spinlock1::W](W) writer structure"]
+impl crate::Writable for SPINLOCK1_SPEC {
+    type Writer = W;
+}
 #[doc = "`reset()` method sets SPINLOCK1 to value 0"]
 impl crate::Resettable for SPINLOCK1_SPEC {
     #[inline(always)]

src/sio/spinlock10.rs

@@ -13,6 +13,35 @@ impl From<crate::R<SPINLOCK10_SPEC>> for R {
         R(reader)
     }
 }
+#[doc = "Register `SPINLOCK10` writer"]
+pub struct W(crate::W<SPINLOCK10_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<SPINLOCK10_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<SPINLOCK10_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<SPINLOCK10_SPEC>) -> Self {
+        W(writer)
+    }
+}
+impl W {
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
 #[doc = "Reading from a spinlock address will:  
  - Return 0 if lock is already locked  
  - Otherwise return nonzero, and simultaneously claim the lock  
@@ -21,7 +50,7 @@ impl From<crate::R<SPINLOCK10_SPEC>> for R {
  If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.  
  The value returned on success is 0x1 << lock number.  
 
-This register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).  
+This register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).  
 
 For information about available fields see [spinlock10](index.html) module"]
 pub struct SPINLOCK10_SPEC;
@@ -32,6 +61,10 @@ impl crate::RegisterSpec for SPINLOCK10_SPEC {
 impl crate::Readable for SPINLOCK10_SPEC {
     type Reader = R;
 }
+#[doc = "`write(|w| ..)` method takes [spinlock10::W](W) writer structure"]
+impl crate::Writable for SPINLOCK10_SPEC {
+    type Writer = W;
+}
 #[doc = "`reset()` method sets SPINLOCK10 to value 0"]
 impl crate::Resettable for SPINLOCK10_SPEC {
     #[inline(always)]

src/sio/spinlock11.rs

@@ -13,6 +13,35 @@ impl From<crate::R<SPINLOCK11_SPEC>> for R {
         R(reader)
     }
 }
+#[doc = "Register `SPINLOCK11` writer"]
+pub struct W(crate::W<SPINLOCK11_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<SPINLOCK11_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<SPINLOCK11_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<SPINLOCK11_SPEC>) -> Self {
+        W(writer)
+    }
+}
+impl W {
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
 #[doc = "Reading from a spinlock address will:  
  - Return 0 if lock is already locked  
  - Otherwise return nonzero, and simultaneously claim the lock  
@@ -21,7 +50,7 @@ impl From<crate::R<SPINLOCK11_SPEC>> for R {
  If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.  
  The value returned on success is 0x1 << lock number.  
 
-This register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).  
+This register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).  
 
 For information about available fields see [spinlock11](index.html) module"]
 pub struct SPINLOCK11_SPEC;
@@ -32,6 +61,10 @@ impl crate::RegisterSpec for SPINLOCK11_SPEC {
 impl crate::Readable for SPINLOCK11_SPEC {
     type Reader = R;
 }
+#[doc = "`write(|w| ..)` method takes [spinlock11::W](W) writer structure"]
+impl crate::Writable for SPINLOCK11_SPEC {
+    type Writer = W;
+}
 #[doc = "`reset()` method sets SPINLOCK11 to value 0"]
 impl crate::Resettable for SPINLOCK11_SPEC {
     #[inline(always)]

src/sio/spinlock12.rs

@@ -13,6 +13,35 @@ impl From<crate::R<SPINLOCK12_SPEC>> for R {
         R(reader)
     }
 }
+#[doc = "Register `SPINLOCK12` writer"]
+pub struct W(crate::W<SPINLOCK12_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<SPINLOCK12_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<SPINLOCK12_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<SPINLOCK12_SPEC>) -> Self {
+        W(writer)
+    }
+}
+impl W {
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
 #[doc = "Reading from a spinlock address will:  
  - Return 0 if lock is already locked  
  - Otherwise return nonzero, and simultaneously claim the lock  
@@ -21,7 +50,7 @@ impl From<crate::R<SPINLOCK12_SPEC>> for R {
  If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.  
  The value returned on success is 0x1 << lock number.  
 
-This register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).  
+This register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).  
 
 For information about available fields see [spinlock12](index.html) module"]
 pub struct SPINLOCK12_SPEC;
@@ -32,6 +61,10 @@ impl crate::RegisterSpec for SPINLOCK12_SPEC {
 impl crate::Readable for SPINLOCK12_SPEC {
     type Reader = R;
 }
+#[doc = "`write(|w| ..)` method takes [spinlock12::W](W) writer structure"]
+impl crate::Writable for SPINLOCK12_SPEC {
+    type Writer = W;
+}
 #[doc = "`reset()` method sets SPINLOCK12 to value 0"]
 impl crate::Resettable for SPINLOCK12_SPEC {
     #[inline(always)]

src/sio/spinlock13.rs

@@ -13,6 +13,35 @@ impl From<crate::R<SPINLOCK13_SPEC>> for R {
         R(reader)
     }
 }
+#[doc = "Register `SPINLOCK13` writer"]
+pub struct W(crate::W<SPINLOCK13_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<SPINLOCK13_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<SPINLOCK13_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<SPINLOCK13_SPEC>) -> Self {
+        W(writer)
+    }
+}
+impl W {
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
 #[doc = "Reading from a spinlock address will:  
  - Return 0 if lock is already locked  
  - Otherwise return nonzero, and simultaneously claim the lock  
@@ -21,7 +50,7 @@ impl From<crate::R<SPINLOCK13_SPEC>> for R {
  If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.  
  The value returned on success is 0x1 << lock number.  
 
-This register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).  
+This register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).  
 
 For information about available fields see [spinlock13](index.html) module"]
 pub struct SPINLOCK13_SPEC;
@@ -32,6 +61,10 @@ impl crate::RegisterSpec for SPINLOCK13_SPEC {
 impl crate::Readable for SPINLOCK13_SPEC {
     type Reader = R;
 }
+#[doc = "`write(|w| ..)` method takes [spinlock13::W](W) writer structure"]
+impl crate::Writable for SPINLOCK13_SPEC {
+    type Writer = W;
+}
 #[doc = "`reset()` method sets SPINLOCK13 to value 0"]
 impl crate::Resettable for SPINLOCK13_SPEC {
     #[inline(always)]

src/sio/spinlock14.rs

@@ -13,6 +13,35 @@ impl From<crate::R<SPINLOCK14_SPEC>> for R {
         R(reader)
     }
 }
+#[doc = "Register `SPINLOCK14` writer"]
+pub struct W(crate::W<SPINLOCK14_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<SPINLOCK14_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<SPINLOCK14_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<SPINLOCK14_SPEC>) -> Self {
+        W(writer)
+    }
+}
+impl W {
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
 #[doc = "Reading from a spinlock address will:  
  - Return 0 if lock is already locked  
  - Otherwise return nonzero, and simultaneously claim the lock  
@@ -21,7 +50,7 @@ impl From<crate::R<SPINLOCK14_SPEC>> for R {
  If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.  
  The value returned on success is 0x1 << lock number.  
 
-This register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).  
+This register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).  
 
 For information about available fields see [spinlock14](index.html) module"]
 pub struct SPINLOCK14_SPEC;
@@ -32,6 +61,10 @@ impl crate::RegisterSpec for SPINLOCK14_SPEC {
 impl crate::Readable for SPINLOCK14_SPEC {
     type Reader = R;
 }
+#[doc = "`write(|w| ..)` method takes [spinlock14::W](W) writer structure"]
+impl crate::Writable for SPINLOCK14_SPEC {
+    type Writer = W;
+}
 #[doc = "`reset()` method sets SPINLOCK14 to value 0"]
 impl crate::Resettable for SPINLOCK14_SPEC {
     #[inline(always)]