Add codegen for GPIO mappings

Author: teskje

codegen/.gitignore

@@ -0,0 +1,2 @@
+/target/
+**/*.rs.bk

codegen/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "codegen"
+version = "0.1.0"
+authors = ["Jan Teske <jteske@posteo.net>"]
+edition = "2018"
+
+[dependencies]
+anyhow = "1"
+once_cell = "1"
+regex = "1"
+serde-xml-rs = "0.4"
+
+[dependencies.clap]
+version = "2"
+default-features = false
+
+[dependencies.serde]
+version = "1"
+features = ["derive"]

codegen/src/codegen/gpio.rs

@@ -0,0 +1,140 @@
+use crate::cubemx::ip::gpio;
+use anyhow::{Context, Result};
+use once_cell::sync::Lazy;
+use regex::Regex;
+use std::collections::HashMap;
+
+struct Port<'a> {
+    id: char,
+    pins: Vec<&'a gpio::Pin>,
+}
+
+pub fn gen_mappings(gpio_ips: &[gpio::Ip]) -> Result<()> {
+    for ip in gpio_ips.iter() {
+        println!();
+        gen_gpio_ip(ip)?;
+    }
+    Ok(())
+}
+
+fn gen_gpio_ip(ip: &gpio::Ip) -> Result<()> {
+    let feature = ip_version_to_feature(&ip.version)?;
+    let ports = merge_pins_by_port(&ip.pins)?;
+
+    println!(r#"#[cfg(feature = "{}")]"#, feature);
+    gen_gpio_macro_call(&ports)?;
+    Ok(())
+}
+
+fn ip_version_to_feature(ip_version: &str) -> Result<String> {
+    static VERSION: Lazy<Regex> =
+        Lazy::new(|| Regex::new(r"^STM32(?P<version>\w+)_gpio_v1_0$").unwrap());
+
+    let captures = VERSION
+        .captures(&ip_version)
+        .with_context(|| format!("invalid GPIO IP version: {}", ip_version))?;
+
+    let version = captures.name("version").unwrap().as_str();
+    let feature = format!("gpio-{}", version.to_lowercase());
+    Ok(feature)
+}
+
+fn merge_pins_by_port(pins: &[gpio::Pin]) -> Result<Vec<Port>> {
+    let mut pins_by_port = HashMap::new();
+    for pin in pins.iter() {
+        pins_by_port
+            .entry(pin.port()?)
+            .and_modify(|e: &mut Vec<_>| e.push(pin))
+            .or_insert_with(|| vec![pin]);
+    }
+
+    let mut ports = Vec::new();
+    for (id, mut pins) in pins_by_port {
+        pins.sort_by_key(|p| p.number().unwrap_or_default());
+        pins.dedup_by_key(|p| p.number().unwrap_or_default());
+        ports.push(Port { id, pins });
+    }
+    ports.sort_by_key(|p| p.id);
+
+    Ok(ports)
+}
+
+fn gen_gpio_macro_call(ports: &[Port]) -> Result<()> {
+    println!("gpio!([");
+    for port in ports {
+        gen_port(port)?;
+    }
+    println!("]);");
+    Ok(())
+}
+
+fn gen_port(port: &Port) -> Result<()> {
+    let pac_module = get_port_pac_module(port);
+
+    println!("    {{");
+    println!(
+        "        port: ({}/{}, pac: {}),",
+        port.id,
+        port.id.to_lowercase(),
+        pac_module,
+    );
+    println!("        pins: [");
+
+    for pin in port.pins.iter() {
+        gen_pin(pin)?;
+    }
+
+    println!("        ],");
+    println!("    }},");
+    Ok(())
+}
+
+fn get_port_pac_module(port: &Port) -> &'static str {
+    // The registers in ports A and B have different reset values due to the
+    // presence of debug pins, so they get dedicated PAC modules.
+    match port.id {
+        'A' => "gpioa",
+        'B' => "gpiob",
+        _ => "gpioc",
+    }
+}
+
+fn gen_pin(pin: &gpio::Pin) -> Result<()> {
+    let nr = pin.number()?;
+    let reset_mode = get_pin_reset_mode(pin)?;
+    let afr = if nr < 8 { 'L' } else { 'H' };
+    let af_numbers = get_pin_af_numbers(pin)?;
+
+    println!(
+        "            {} => {{ reset: {}, afr: {}/{}, af: {:?} }},",
+        nr,
+        reset_mode,
+        afr,
+        afr.to_lowercase(),
+        af_numbers,
+    );
+
+    Ok(())
+}
+
+fn get_pin_reset_mode(pin: &gpio::Pin) -> Result<&'static str> {
+    // Debug pins default to their debug function (AF0), everything else
+    // defaults to floating input.
+    let mode = match (pin.port()?, pin.number()?) {
+        ('A', 13) | ('A', 14) | ('A', 15) | ('B', 3) | ('B', 4) => "AF0",
+        _ => "Input<Floating>",
+    };
+    Ok(mode)
+}
+
+fn get_pin_af_numbers(pin: &gpio::Pin) -> Result<Vec<u8>> {
+    let mut numbers = Vec::new();
+    for signal in pin.pin_signals.iter() {
+        numbers.push(signal.af()?);
+    }
+
+    numbers.sort();
+    numbers.dedup();
+
+    Ok(numbers)
+}

codegen/src/codegen/mod.rs

@@ -0,0 +1 @@
+pub mod gpio;

codegen/src/cubemx/db.rs

@@ -0,0 +1,26 @@
+use anyhow::{Context, Result};
+use serde::Deserialize;
+use std::{
+    fs::File,
+    path::{Path, PathBuf},
+};
+
+pub struct Db {
+    root: PathBuf,
+}
+
+impl Db {
+    pub fn new<P: Into<PathBuf>>(root: P) -> Self {
+        Self { root: root.into() }
+    }
+
+    pub fn load<'de, P: AsRef<Path>, T: Deserialize<'de>>(&self, name: P) -> Result<T> {
+        let name = name.as_ref();
+        let mut path = self.root.join(name);
+        path.set_extension("xml");
+
+        let file = File::open(&path).with_context(|| format!("cannot open DB file: {:?}", path))?;
+        serde_xml_rs::de::from_reader(file)
+            .with_context(|| format!("cannot parse DB file: {:?}", path))
+    }
+}

codegen/src/cubemx/families.rs

@@ -0,0 +1,44 @@
+use crate::cubemx::Db;
+use anyhow::{Context, Result};
+use serde::Deserialize;
+
+pub fn load(db: &Db) -> Result<Families> {
+    db.load("families")
+}
+
+pub fn load_f3(db: &Db) -> Result<Family> {
+    load(db)?
+        .families
+        .into_iter()
+        .find(|f| f.name == "STM32F3")
+        .context("STM32F3 family not found")
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct Families {
+    #[serde(rename = "Family")]
+    pub families: Vec<Family>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct Family {
+    pub name: String,
+    #[serde(rename = "SubFamily")]
+    pub sub_families: Vec<SubFamily>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct SubFamily {
+    pub name: String,
+    #[serde(rename = "Mcu")]
+    pub mcus: Vec<Mcu>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct Mcu {
+    pub name: String,
+}

codegen/src/cubemx/ip/gpio.rs

@@ -0,0 +1,91 @@
+use super::ip_path;
+use crate::cubemx::Db;
+use anyhow::{bail, Context, Result};
+use once_cell::sync::Lazy;
+use regex::Regex;
+use serde::Deserialize;
+
+pub fn load(db: &Db, version: &str) -> Result<Ip> {
+    let name = format!("GPIO-{}_Modes", version);
+    db.load(ip_path(&name))
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct Ip {
+    pub version: String,
+    #[serde(rename = "GPIO_Pin")]
+    pub pins: Vec<Pin>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct Pin {
+    pub port_name: String,
+    pub name: String,
+    #[serde(rename = "PinSignal", default)]
+    pub pin_signals: Vec<PinSignal>,
+}
+
+impl Pin {
+    pub fn port(&self) -> Result<char> {
+        static PORT_NAME: Lazy<Regex> = Lazy::new(|| Regex::new(r"^P(?P<id>[A-Z])$").unwrap());
+
+        let captures = PORT_NAME
+            .captures(&self.port_name)
+            .with_context(|| format!("invalid GPIO port name: {}", self.port_name))?;
+
+        let id = captures.name("id").unwrap().as_str();
+        let id = id.parse()?;
+        Ok(id)
+    }
+
+    pub fn number(&self) -> Result<u8> {
+        static PIN_NAME: Lazy<Regex> =
+            Lazy::new(|| Regex::new(r"^P[A-Z](?P<nr>\d{1,2})\b.*$").unwrap());
+
+        let captures = PIN_NAME
+            .captures(&self.name)
+            .with_context(|| format!("invalid GPIO pin name: {}", self.name))?;
+
+        let id = captures.name("nr").unwrap().as_str();
+        let id = id.parse()?;
+        Ok(id)
+    }
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct PinSignal {
+    pub name: String,
+    specific_parameter: SpecificParameter,
+}
+
+impl PinSignal {
+    pub fn af(&self) -> Result<u8> {
+        let param = &self.specific_parameter;
+        if param.name == "GPIO_AF" {
+            parse_af(&param.possible_value)
+        } else {
+            bail!("PinSignal is missing a GPIO_AF parameter")
+        }
+    }
+}
+
+fn parse_af(s: &str) -> Result<u8> {
+    static AF: Lazy<Regex> = Lazy::new(|| Regex::new(r"^GPIO_AF(?P<nr>\d{1,2})_\w+$").unwrap());
+
+    let captures = AF
+        .captures(s)
+        .with_context(|| format!("invalid PinSignal AF: {}", s))?;
+
+    let nr = captures.name("nr").unwrap().as_str().parse()?;
+    Ok(nr)
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+struct SpecificParameter {
+    name: String,
+    possible_value: String,
+}

codegen/src/cubemx/ip/mod.rs

@@ -0,0 +1,7 @@
+pub mod gpio;
+
+use std::path::PathBuf;
+
+fn ip_path(name: &str) -> PathBuf {
+    ["IP", name].iter().collect()
+}

codegen/src/cubemx/mcu.rs

@@ -0,0 +1,22 @@
+use crate::cubemx::Db;
+use anyhow::Result;
+use serde::Deserialize;
+
+pub fn load(db: &Db, name: &str) -> Result<Mcu> {
+    db.load(name)
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct Mcu {
+    pub ref_name: String,
+    #[serde(rename = "IP")]
+    pub ips: Vec<Ip>,
+}
+
+#[derive(Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd)]
+#[serde(rename_all = "PascalCase")]
+pub struct Ip {
+    pub name: String,
+    pub version: String,
+}