fusible 0.6.0

Electronic linter: a fuse that blows to block firmware code generation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! `decoupling_capacitor`: every active IC power pin must have a bypass capacitor.

use std::collections::{HashMap, HashSet};

use crate::linter::{Diagnostic, LintContext, Rule};

/// Verifies that integrated circuits (ICs) have decoupling/bypass capacitors
/// connected to their power supply rails to ensure power integrity.
pub struct BypassCapRule;

impl Rule for BypassCapRule {
    fn name(&self) -> &'static str {
        "decoupling_capacitor"
    }

    fn check(&self, ctx: &LintContext<'_>) -> Vec<Diagnostic> {
        let mut diagnostics = Vec::new();

        // 1. Map components by ID to their kind and designator
        let comp_kinds: HashMap<&str, (&str, &str)> = ctx
            .circuit
            .components()
            .filter_map(|c| {
                let id = c.component_id.as_deref()?;
                let name = c.name.as_deref().unwrap_or(id);
                let kind = c.kind.as_deref().unwrap_or("");
                Some((id, (name, kind)))
            })
            .collect();

        // 2. Identify all nets that have at least one capacitor attached
        let mut nets_with_caps: HashSet<&str> = HashSet::new();
        for net in &ctx.netlist.nets {
            let has_cap = net.endpoints.iter().any(|ep| {
                if let Some(cid) = ep.component_id.as_deref() {
                    if let Some(&(name, kind)) = comp_kinds.get(cid) {
                        return kind.eq_ignore_ascii_case("capacitor")
                            || name.starts_with('C')
                            || cid.starts_with('C');
                    }
                }
                false
            });
            if has_cap {
                nets_with_caps.insert(&net.id);
            }
        }

        // 3. Inspect every IC/chip power port
        let mut reported_rails: HashSet<(String, String)> = HashSet::new();

        for port in ctx.circuit.ports() {
            let comp_id = match port.source_component_id.as_deref() {
                Some(id) => id,
                None => continue,
            };

            let (comp_name, comp_kind) = match comp_kinds.get(comp_id) {
                Some(&(n, k)) => (n, k),
                None => (comp_id, ""),
            };

            let is_chip = comp_kind.eq_ignore_ascii_case("chip")
                || comp_kind.eq_ignore_ascii_case("simple_chip")
                || comp_name.starts_with('U')
                || comp_id.starts_with('U');

            if !is_chip {
                continue;
            }

            let pin_name = port.name.as_deref().unwrap_or("");
            let net_id = match port.net_id.as_deref() {
                Some(id) => id,
                None => continue,
            };

            let net_node = match ctx
                .netlist
                .port_to_net
                .get(port.port_id.as_deref().unwrap_or(""))
                .and_then(|&idx| ctx.netlist.nets.get(idx))
            {
                Some(node) => node,
                None => continue,
            };

            let net_name = net_node.display_name();

            // Check if this pin/net is a positive power supply rail
            if is_power_rail_pin(pin_name, net_name)
                && !nets_with_caps.contains(net_id)
                && !nets_with_caps.contains(net_node.id())
                && reported_rails.insert((comp_name.to_string(), net_name.to_string()))
            {
                diagnostics.push(Diagnostic {
                    rule: self.name().to_string(),
                    message: format!(
                        "IC \"{comp_name}\" power pin \"{pin_name}\" has no decoupling capacitor on rail \"{net_name}\""
                    ),
                    help: Some(format!(
                        "connect a local ceramic bypass capacitor (e.g. 100nF) between \"{net_name}\" and GND near \"{comp_name}\""
                    )),
                });
            }
        }

        diagnostics
    }
}

fn is_power_rail_pin(pin: &str, net: &str) -> bool {
    let p_upper = pin.to_ascii_uppercase();
    let n_upper = net.to_ascii_uppercase();

    // Exclude ground rails
    if p_upper.contains("GND")
        || p_upper.contains("VSS")
        || n_upper.contains("GND")
        || n_upper.contains("VSS")
    {
        return false;
    }

    p_upper.contains("VDD")
        || p_upper.contains("VCC")
        || p_upper.contains("VBAT")
        || p_upper.contains("3V3")
        || p_upper.contains("5V")
        || p_upper.contains("VBUS")
        || p_upper.contains("VIN")
        || n_upper.contains("VDD")
        || n_upper.contains("VCC")
        || n_upper.contains("VBAT")
        || n_upper.contains("3V3")
        || n_upper.contains("5V")
        || n_upper.contains("VBUS")
        || n_upper.contains("VIN")
}