[asic-details] Add lotnum (4-character lot number) to SwitchIdentifiers

This PR adds lotnum (4-character lot number) to SwitchIdentifiers and exposes
ASIC details via swadm (and the dpd-client API). The full lot identifier combines
fab, lot, and lotnum (e.g., FTCAK7 instead of just T).

We do keep the current fields separated however, but update the view
for the combination.

Adds v1::SwitchIdentifiers for API versions 1-4 (without lotnum), with the
latest version (v5+) including the new field.

Fixes #200: Want swadm command to print Tofino ASIC details
Fixes #202: Not reporting full lot numbers in oximeter statistics

Author: zeeshanlakhani

Cargo.lock

@@ -43,6 +43,7 @@ pub trait SidecarIdentifiers {
     fn asic_backend(&self) -> &str;
     fn fab(&self) -> Option<char>;
     fn lot(&self) -> Option<char>;
+    fn lotnum(&self) -> Option<[char; 4]>;
     fn wafer(&self) -> Option<u8>;
     fn wafer_loc(&self) -> Option<(i16, i16)>;
 }

aal/src/lib.rs

@@ -36,6 +36,12 @@ pub struct Identifiers {
     fab: Option<char>,
     /// Lot identifier.
     lot: Option<char>,
+    /// Lot number (4-character identifier within the lot).
+    ///
+    /// The 4-character size comes from the Tofino ASIC fuse layout, which
+    /// stores lotnum as four separate character fields (lotnum0-3) in
+    /// `tofino::fuse::ChipId`.
+    lotnum: Option<[char; 4]>,
     /// Wafer number within the lot.
     wafer: Option<u8>,
     /// The wafer location as (x, y) coordinates on the wafer, represented as
@@ -50,6 +56,7 @@ impl Default for Identifiers {
             asic_backend: "chaos".to_string(),
             fab: None,
             lot: None,
+            lotnum: None,
             wafer: None,
             wafer_loc: None,
         }
@@ -73,6 +80,10 @@ impl aal::SidecarIdentifiers for Identifiers {
         self.lot
     }
 
+    fn lotnum(&self) -> Option<[char; 4]> {
+        self.lotnum
+    }
+
     fn wafer(&self) -> Option<u8> {
         self.wafer
     }

asic/src/lib.rs

@@ -375,6 +375,7 @@ impl AsicOps for Handle {
             asic_backend: "softnpu".to_string(),
             fab: None,
             lot: None,
+            lotnum: None,
             wafer: None,
             wafer_loc: None,
         })

asic/src/softnpu/mod.rs

@@ -224,6 +224,12 @@ impl AsicOps for Handle {
             asic_backend: "tofino_asic".to_string(),
             fab: Some(chip_id.fab),
             lot: Some(chip_id.lot),
+            lotnum: Some([
+                chip_id.lotnum0,
+                chip_id.lotnum1,
+                chip_id.lotnum2,
+                chip_id.lotnum3,
+            ]),
             wafer: Some(chip_id.wafer),
             wafer_loc: Some(wafer_loc_from_coords(
                 chip_id.xsign,

asic/src/tofino_asic/mod.rs

@@ -226,6 +226,7 @@ impl AsicOps for StubHandle {
             asic_backend: "tofino_stub".to_string(),
             fab: None,
             lot: None,
+            lotnum: None,
             wafer: None,
             wafer_loc: None,
         })

asic/src/tofino_stub/mod.rs

@@ -12,3 +12,4 @@ oxnet.workspace = true
 schemars.workspace = true
 serde.workspace = true
 transceiver-controller.workspace = true
+uuid.workspace = true

dpd-api/Cargo.toml

@@ -59,6 +59,7 @@ api_versions!([
     // |  example for the next person.
     // v
     // (next_int, IDENT),
+    (5, SWITCH_IDENTIFIERS_LOTNUM),
     (4, V4_OVER_V6_ROUTES),
     (3, ATTACHED_SUBNETS),
     (2, DUAL_STACK_NAT_WORKFLOW),
@@ -1478,11 +1479,30 @@ pub trait DpdApi {
     #[endpoint {
         method = GET,
         path = "/switch/identifiers",
+        versions = VERSION_SWITCH_IDENTIFIERS_LOTNUM..,
     }]
     async fn switch_identifiers(
         rqctx: RequestContext<Self::Context>,
     ) -> Result<HttpResponseOk<SwitchIdentifiers>, HttpError>;
 
+    /// Get switch identifiers.
+    ///
+    /// Returns identifying information for the switch and its ASIC, including
+    /// the sidecar ID, fabrication details, and SP metadata. Does not include
+    /// the `lotnum` field.
+    #[endpoint {
+        method = GET,
+        path = "/switch/identifiers",
+        operation_id = "switch_identifiers",
+        versions = ..VERSION_SWITCH_IDENTIFIERS_LOTNUM,
+    }]
+    async fn switch_identifiers_v1(
+        rqctx: RequestContext<Self::Context>,
+    ) -> Result<HttpResponseOk<v1::SwitchIdentifiers>, HttpError> {
+        let result = Self::switch_identifiers(rqctx).await?.0;
+        Ok(HttpResponseOk(result.into()))
+    }
+
     /// Collect the link data consumed by `tfportd`.  This app-specific convenience
     /// routine is meant to reduce the time and traffic expended on this once-per-
     /// second operation, by consolidating multiple per-link requests into a single

dpd-api/src/lib.rs

@@ -4,10 +4,13 @@
 //
 // Copyright 2026 Oxide Computer Company
 
+//! Types from API version 1 (INITIAL) that changed in later versions.
+
 use dpd_types::route::Ipv4Route;
 use oxnet::Ipv4Net;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
+use uuid::Uuid;
 
 /// Represents all mappings of an IPv4 subnet to a its nexthop target(s).
 #[derive(Debug, Clone, Deserialize, Serialize, JsonSchema)]
@@ -18,3 +21,53 @@ pub struct Ipv4Routes {
     /// All RouteTargets associated with this CIDR
     pub targets: Vec<Ipv4Route>,
 }
+
+/// Identifiers for a switch.
+///
+/// Does not include the `lotnum` field, which was added in
+/// SWITCH_IDENTIFIERS_LOTNUM.
+#[derive(Clone, Debug, JsonSchema, Serialize)]
+pub struct SwitchIdentifiers {
+    /// Unique identifier for the chip.
+    pub sidecar_id: Uuid,
+    /// Asic backend (compiler target) responsible for these identifiers.
+    pub asic_backend: String,
+    /// Fabrication plant identifier.
+    pub fab: Option<char>,
+    /// Lot identifier.
+    pub lot: Option<char>,
+    /// Wafer number within the lot.
+    pub wafer: Option<u8>,
+    /// The wafer location as (x, y) coordinates on the wafer, represented as
+    /// an array due to the lack of tuple support in OpenAPI.
+    pub wafer_loc: Option<[i16; 2]>,
+    /// The model number of the switch being managed.
+    pub model: String,
+    /// The revision number of the switch being managed.
+    pub revision: u32,
+    /// The serial number of the switch being managed.
+    pub serial: String,
+    /// The slot number of the switch being managed.
+    ///
+    /// MGS uses u16 for this internally.
+    pub slot: u16,
+}
+
+impl From<dpd_types::switch_identifiers::SwitchIdentifiers>
+    for SwitchIdentifiers
+{
+    fn from(latest: dpd_types::switch_identifiers::SwitchIdentifiers) -> Self {
+        Self {
+            sidecar_id: latest.sidecar_id,
+            asic_backend: latest.asic_backend,
+            fab: latest.fab,
+            lot: latest.lot,
+            wafer: latest.wafer,
+            wafer_loc: latest.wafer_loc,
+            model: latest.model,
+            revision: latest.revision,
+            serial: latest.serial,
+            slot: latest.slot,
+        }
+    }
+}

dpd-api/src/v1.rs

@@ -359,6 +359,29 @@ impl fmt::Display for types::TfportData {
     }
 }
 
+impl types::SwitchIdentifiers {
+    /// Returns the full lot identifier by combining `fab`, `lot`, and `lotnum`.
+    pub fn full_lot_id(&self) -> Option<String> {
+        let mut lot = String::new();
+        let has_lot_data = self.lot.is_some() || self.lotnum.is_some();
+        if has_lot_data
+            && let Some(fab) = &self.fab
+        {
+            lot.push_str(fab.as_str());
+        }
+        if let Some(lot_char) = &self.lot {
+            lot.push_str(lot_char.as_str());
+        }
+        if let Some(lotnum) = &self.lotnum {
+            lot.push_str(
+                lotnum.iter().map(|c| c.as_str()).collect::<String>().as_str(),
+            );
+        }
+
+        if lot.is_empty() { None } else { Some(lot) }
+    }
+}
+
 impl fmt::Display for types::SffComplianceCode {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
@@ -388,8 +411,93 @@ impl fmt::Display for types::MediaInterfaceId {
 
 #[cfg(test)]
 mod tests {
+    use super::types::SwitchIdentifiers;
     use common::ports::PortId;
 
+    #[test]
+    fn test_full_lot_id_both_present() {
+        let idents: SwitchIdentifiers = serde_json::from_str(
+            r#"{
+                "sidecar_id": "00000000-0000-0000-0000-000000000000",
+                "asic_backend": "test",
+                "fab": "F",
+                "lot": "T",
+                "lotnum": ["C", "A", "K", "7"],
+                "wafer": 1,
+                "wafer_loc": [10, 20],
+                "model": "test-model",
+                "revision": 1,
+                "serial": "test-serial",
+                "slot": 0
+            }"#,
+        )
+        .unwrap();
+        assert_eq!(idents.full_lot_id(), Some("FTCAK7".to_string()));
+    }
+
+    #[test]
+    fn test_full_lot_id_lot_only() {
+        let idents: SwitchIdentifiers = serde_json::from_str(
+            r#"{
+                "sidecar_id": "00000000-0000-0000-0000-000000000000",
+                "asic_backend": "test",
+                "fab": "F",
+                "lot": "T",
+                "lotnum": null,
+                "wafer": 1,
+                "wafer_loc": [10, 20],
+                "model": "test-model",
+                "revision": 1,
+                "serial": "test-serial",
+                "slot": 0
+            }"#,
+        )
+        .unwrap();
+        assert_eq!(idents.full_lot_id(), Some("FT".to_string()));
+    }
+
+    #[test]
+    fn test_full_lot_id_lotnum_only() {
+        let idents: SwitchIdentifiers = serde_json::from_str(
+            r#"{
+                "sidecar_id": "00000000-0000-0000-0000-000000000000",
+                "asic_backend": "test",
+                "fab": null,
+                "lot": null,
+                "lotnum": ["C", "A", "K", "7"],
+                "wafer": 1,
+                "wafer_loc": [10, 20],
+                "model": "test-model",
+                "revision": 1,
+                "serial": "test-serial",
+                "slot": 0
+            }"#,
+        )
+        .unwrap();
+        assert_eq!(idents.full_lot_id(), Some("CAK7".to_string()));
+    }
+
+    #[test]
+    fn test_full_lot_id_neither_present() {
+        let idents: SwitchIdentifiers = serde_json::from_str(
+            r#"{
+                "sidecar_id": "00000000-0000-0000-0000-000000000000",
+                "asic_backend": "test",
+                "fab": null,
+                "lot": null,
+                "lotnum": null,
+                "wafer": 1,
+                "wafer_loc": [10, 20],
+                "model": "test-model",
+                "revision": 1,
+                "serial": "test-serial",
+                "slot": 0
+            }"#,
+        )
+        .unwrap();
+        assert_eq!(idents.full_lot_id(), None);
+    }
+
     #[test]
     fn test_parse_client_port_id() {
         assert!("rear3".parse::<PortId>().is_ok());