Merge #167

bors[bot] · burrbull · web-flow · commit 4d18aef3dfd5 · 2021-11-08T15:51:29.000Z
167: add protection r=Emilgardis a=burrbull



Co-authored-by: Andrey Zgarbul &lt;zgarbul.andrey@gmail.com&gt;
diff --git a/svd-encoder/CHANGELOG.md b/svd-encoder/CHANGELOG.md
@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Unreleased
 
+- Add `protection` encoding
 - Add `readAction` encoding
 - Add array support for peripherals
 
diff --git a/svd-encoder/src/addressblock.rs b/svd-encoder/src/addressblock.rs
@@ -4,11 +4,14 @@ impl Encode for crate::svd::AddressBlock {
     type Error = EncodeError;
 
     fn encode(&self) -> Result<Element, EncodeError> {
-        let children = vec![
+        let mut children = vec![
             new_node("offset", format!("0x{:X}", self.offset)),
             new_node("size", format!("0x{:X}", self.size)),
             self.usage.encode_node()?,
         ];
+        if let Some(v) = &self.protection {
+            children.push(v.encode_node()?);
+        };
         let mut elem = Element::new("addressBlock");
         elem.children = children;
         Ok(elem)
diff --git a/svd-encoder/src/lib.rs b/svd-encoder/src/lib.rs
@@ -79,6 +79,7 @@ mod interrupt;
 mod modifiedwritevalues;
 mod peripheral;
 mod peripheralinfo;
+mod protection;
 mod readaction;
 mod register;
 mod registercluster;
diff --git a/svd-encoder/src/protection.rs b/svd-encoder/src/protection.rs
@@ -0,0 +1,11 @@
+use super::{Element, Encode, EncodeError, XMLNode};
+
+impl Encode for crate::svd::Protection {
+    type Error = EncodeError;
+
+    fn encode(&self) -> Result<Element, EncodeError> {
+        let mut elem = Element::new("protection");
+        elem.children.push(XMLNode::Text(self.as_str().to_string()));
+        Ok(elem)
+    }
+}
diff --git a/svd-encoder/src/registerproperties.rs b/svd-encoder/src/registerproperties.rs
@@ -16,6 +16,10 @@ impl EncodeChildren for RegisterProperties {
             children.push(v.encode_node()?);
         };
 
+        if let Some(v) = &self.protection {
+            children.push(v.encode_node()?);
+        };
+
         if let Some(v) = &self.reset_value {
             children.push(new_node(
                 "resetValue",
diff --git a/svd-parser/CHANGELOG.md b/svd-parser/CHANGELOG.md
@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Unreleased
 
+- Add `protection` parsing
 - Add `readAction` parsing
 - Add array support for peripherals
 
diff --git a/svd-parser/src/addressblock.rs b/svd-parser/src/addressblock.rs
@@ -1,5 +1,5 @@
 use super::*;
-use crate::svd::{AddressBlock, AddressBlockUsage};
+use crate::svd::{AddressBlock, AddressBlockUsage, Protection};
 
 impl Parse for AddressBlock {
     type Object = Self;
@@ -11,6 +11,7 @@ impl Parse for AddressBlock {
             offset: tree.get_child_u32("offset")?,
             size: tree.get_child_u32("size")?,
             usage: AddressBlockUsage::parse(&tree.get_child_elem("usage")?, config)?,
+            protection: optional::<Protection>("protection", tree, config)?,
         })
     }
 }
diff --git a/svd-parser/src/lib.rs b/svd-parser/src/lib.rs
@@ -163,6 +163,7 @@ mod interrupt;
 mod modifiedwritevalues;
 mod peripheral;
 mod peripheralinfo;
+mod protection;
 mod readaction;
 mod register;
 mod registercluster;
@@ -204,6 +205,8 @@ pub enum SVDError {
     InvalidModifiedWriteValues(String),
     #[error("Invalid readAction variant, found {0}")]
     InvalidReadAction(String),
+    #[error("Invalid protection variant, found {0}")]
+    InvalidProtection(String),
     #[error("The content of the element could not be parsed to a boolean value {0}: {1}")]
     InvalidBooleanValue(String, core::str::ParseBoolError),
     #[error("dimIndex tag must contain {0} indexes, found {1}")]
diff --git a/svd-parser/src/protection.rs b/svd-parser/src/protection.rs
@@ -0,0 +1,13 @@
+use super::*;
+
+impl Parse for crate::svd::Protection {
+    type Object = Self;
+    type Error = SVDErrorAt;
+    type Config = Config;
+
+    fn parse(tree: &Node, _config: &Self::Config) -> Result<Self, Self::Error> {
+        let text = tree.get_text()?;
+
+        Self::parse_str(text).ok_or_else(|| SVDError::InvalidProtection(text.into()).at(tree.id()))
+    }
+}
diff --git a/svd-parser/src/registerproperties.rs b/svd-parser/src/registerproperties.rs
@@ -1,5 +1,5 @@
 use super::*;
-use crate::svd::{Access, RegisterProperties};
+use crate::svd::{Access, Protection, RegisterProperties};
 
 impl Parse for RegisterProperties {
     type Object = Self;
@@ -10,6 +10,7 @@ impl Parse for RegisterProperties {
         RegisterProperties::new()
             .size(optional::<u32>("size", tree, &())?)
             .access(optional::<Access>("access", tree, config)?)
+            .protection(optional::<Protection>("protection", tree, config)?)
             .reset_value(optional::<u64>("resetValue", tree, &())?)
             .reset_mask(optional::<u64>("resetMask", tree, &())?)
             .build(config.validate_level)
diff --git a/svd-rs/CHANGELOG.md b/svd-rs/CHANGELOG.md
@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Unreleased
 
+- Add `protection` to `RegisterProperties` and `AddressBlock`
 - Add `readAction` to `RegisterInfo` and `FieldInfo`
 - Add `single` and `array` for `Info` types, 
   `is_single` and `is_array` for `Peripheral`, `Cluster`, `Register` and `Field`
diff --git a/svd-rs/src/addressblock.rs b/svd-rs/src/addressblock.rs
@@ -1,3 +1,5 @@
+use super::Protection;
+
 ///  An uniquely mapped address block to a peripheral
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[derive(Clone, Debug, PartialEq)]
@@ -8,6 +10,12 @@ pub struct AddressBlock {
     pub size: u32,
     /// Usage of the address block.
     pub usage: AddressBlockUsage,
+    /// Specify the security privilege to access an address region
+    #[cfg_attr(
+        feature = "serde",
+        serde(default, skip_serializing_if = "Option::is_none")
+    )]
+    pub protection: Option<Protection>,
 }
 
 /// Usage of the address block.
diff --git a/svd-rs/src/lib.rs b/svd-rs/src/lib.rs
@@ -98,6 +98,10 @@ pub use self::modifiedwritevalues::ModifiedWriteValues;
 pub mod readaction;
 pub use self::readaction::ReadAction;
 
+/// Protection objects
+pub mod protection;
+pub use self::protection::Protection;
+
 /// Level of validation
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum ValidateLevel {
diff --git a/svd-rs/src/protection.rs b/svd-rs/src/protection.rs
@@ -0,0 +1,47 @@
+/// Specify the security privilege to access an address region
+///
+/// This information is relevant for the programmer as well as the debugger
+/// when no universal access permissions have been granted.
+/// If no specific information is provided, an address region is accessible in any mode
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Protection {
+    /// Secure permission required for access
+    #[cfg_attr(feature = "serde", serde(rename = "s"))]
+    Secure,
+
+    /// Non-secure or secure permission required for access
+    #[cfg_attr(feature = "serde", serde(rename = "n"))]
+    NonSecure,
+
+    /// Privileged permission required for access
+    #[cfg_attr(feature = "serde", serde(rename = "p"))]
+    Privileged,
+}
+
+impl Default for Protection {
+    fn default() -> Self {
+        Self::NonSecure
+    }
+}
+
+impl Protection {
+    /// Parse a string into an [`Protection`] value, returning [`Option::None`] if the string is not valid.
+    pub fn parse_str(s: &str) -> Option<Self> {
+        match s {
+            "s" => Some(Self::Secure),
+            "n" => Some(Self::NonSecure),
+            "p" => Some(Self::Privileged),
+            _ => None,
+        }
+    }
+
+    /// Convert this [`Protection`] into a static string.
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::Secure => "s",
+            Self::NonSecure => "n",
+            Self::Privileged => "p",
+        }
+    }
+}
diff --git a/svd-rs/src/registerproperties.rs b/svd-rs/src/registerproperties.rs
@@ -1,4 +1,4 @@
-use super::{Access, SvdError, ValidateLevel};
+use super::{Access, Protection, SvdError, ValidateLevel};
 
 /// Errors from [`RegisterProperties::validate`]
 #[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
@@ -37,6 +37,13 @@ pub struct RegisterProperties {
     )]
     pub access: Option<Access>,
 
+    /// Specify the security privilege to access an address region
+    #[cfg_attr(
+        feature = "serde",
+        serde(default, skip_serializing_if = "Option::is_none")
+    )]
+    pub protection: Option<Protection>,
+
     /// Register value at RESET
     #[cfg_attr(
         feature = "serde",
@@ -69,6 +76,9 @@ impl RegisterProperties {
         if builder.access.is_some() {
             self.access = builder.access;
         }
+        if builder.protection.is_some() {
+            self.protection = builder.protection;
+        }
         if builder.reset_value.is_some() {
             self.reset_value = builder.reset_value;
         }
@@ -97,6 +107,11 @@ impl RegisterProperties {
         self.access = value;
         self
     }
+    /// Set the protection of the register properties.
+    pub fn protection(mut self, value: Option<Protection>) -> Self {
+        self.protection = value;
+        self
+    }
     /// Set the reset_value of the register properties.
     pub fn reset_value(mut self, value: Option<u64>) -> Self {
         self.reset_value = value;
diff --git a/tests/src/addressblock.rs b/tests/src/addressblock.rs
@@ -8,6 +8,7 @@ fn decode_encode() {
             offset: 0,
             size: 0x00000800,
             usage: AddressBlockUsage::Registers,
+            protection: None,
         },
         "<addressBlock>
             <offset>0x0</offset>

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`use super::*;`
`2`		`-use crate::svd::{AddressBlock, AddressBlockUsage};`
	`2`	`+use crate::svd::{AddressBlock, AddressBlockUsage, Protection};`
`3`	`3`
`4`	`4`	`impl Parse for AddressBlock {`
`5`	`5`	`type Object = Self;`
`@@ -11,6 +11,7 @@ impl Parse for AddressBlock {`
`11`	`11`	`offset: tree.get_child_u32("offset")?,`
`12`	`12`	`size: tree.get_child_u32("size")?,`
`13`	`13`	`usage: AddressBlockUsage::parse(&tree.get_child_elem("usage")?, config)?,`
	`14`	`+ protection: optional::<Protection>("protection", tree, config)?,`
`14`	`15`	`})`
`15`	`16`	`}`
`16`	`17`	`}`