nvme: mi: dev: Implement Admin / Format NVM

Signed-off-by: Andrew Jeffery <andrew@codeconstruct.com.au>

Author: amboar

src/lib.rs

@@ -294,6 +294,7 @@ pub struct Controller {
     csts: FlagSet<nvme::ControllerStatusFlags>,
     lpa: FlagSet<LogPageAttributes>,
     lsaes: [FlagSet<LidSupportedAndEffectsFlags>; 130],
+    fna: FlagSet<nvme::FormatNvmAttributes>,
 }
 
 #[derive(Debug)]
@@ -334,6 +335,9 @@ impl Controller {
                     LidSupportedAndEffectsFlags::Lsupp.into();
                 arr
             },
+            fna: (nvme::FormatNvmAttributes::Fns
+                | nvme::FormatNvmAttributes::Sens
+                | nvme::FormatNvmAttributes::Fnvmbs),
         }
     }
 

src/nvme.rs

@@ -119,6 +119,54 @@ struct ControllerListRequest {
     ids: WireVec<u16, 2047>,
 }
 
+// Base v2.1, 5.1.10, Figure 189, SES
+#[derive(Debug)]
+#[repr(u8)]
+enum SecureEraseSettings {
+    NoOperation = 0b000,
+    UserDataErase = 0b001,
+    CryptographicErase = 0b010,
+}
+unsafe impl Discriminant<u8> for SecureEraseSettings {}
+
+impl TryFrom<u32> for SecureEraseSettings {
+    type Error = ();
+
+    fn try_from(value: u32) -> Result<Self, Self::Error> {
+        match value {
+            0b000 => Ok(Self::NoOperation),
+            0b001 => Ok(Self::UserDataErase),
+            0b010 => Ok(Self::CryptographicErase),
+            _ => Err(()),
+        }
+    }
+}
+
+// Base v2.1, 5.1.10, Figure 189
+#[derive(Debug)]
+#[expect(dead_code)]
+struct AdminFormatNvmConfiguration {
+    lbafi: u8,
+    mset: bool,
+    pi: u8,
+    pil: bool,
+    ses: SecureEraseSettings,
+}
+
+impl TryFrom<u32> for AdminFormatNvmConfiguration {
+    type Error = ();
+
+    fn try_from(value: u32) -> Result<Self, Self::Error> {
+        Ok(Self {
+            lbafi: ((((value >> 12) & 0x3) << 4) | (value & 0xf)) as u8,
+            mset: ((value >> 4) & 1) == 1,
+            pi: ((value >> 5) & 0x3) as u8,
+            pil: ((value >> 6) & 1) == 1,
+            ses: TryFrom::try_from((value >> 9) & 0x7)?,
+        })
+    }
+}
+
 // Base v2.1, 5.1.12, Figure 202
 // MI v2.0, 6.3, Figure 141
 #[derive(Debug, DekuRead, DekuWrite, Eq, PartialEq)]
@@ -450,6 +498,16 @@ impl Default for SanitizeCapabilities {
     }
 }
 
+// Base v2.1, 5.1.13.2.1, Figure 312, FNA
+flags! {
+    pub enum FormatNvmAttributes: u8 {
+        Fns,
+        Sens,
+        Cryes,
+        Fnvmbs,
+    }
+}
+
 // Base v2.1, 5.1.13.2.1, Figure 312
 #[derive(Debug, DekuRead, DekuWrite)]
 #[deku(endian = "little")]
@@ -500,7 +558,7 @@ struct AdminIdentifyControllerResponse {
     nn: u32,
     oncs: u16,
     fuses: u16,
-    fna: u8,
+    fna: WireFlagSet<FormatNvmAttributes>,
     vwc: u8,
     awun: u16,
     awupf: u16,

src/nvme/mi.rs

@@ -765,6 +765,8 @@ enum AdminCommandRequestType {
     ControllerDataQueue = 0x45,            // P
     DoorbellBufferConfig = 0x7c,           // P
     FabricsCommands = 0x7f,                // P
+    #[deku(id = 0x80)]
+    FormatNvm(AdminFormatNvmRequest),
     #[deku(id = 0x84)]
     Sanitize(AdminSanitizeRequest),
     LoadProgram = 0x85,                 // P
@@ -784,6 +786,20 @@ struct AdminCommandRequestHeader {
     op: AdminCommandRequestType,
 }
 
+// MI v2.0, 6, Figure 136
+// Base v2.1, 5.1.10, Figure 189
+#[derive(Debug, DekuRead, DekuWrite, Eq, PartialEq)]
+#[deku(ctx = "endian: Endian", endian = "endian")]
+struct AdminFormatNvmRequest {
+    nsid: u32,
+    #[deku(seek_from_current = "16")]
+    dofst: u32,
+    dlen: u32,
+    #[deku(seek_from_current = "8")]
+    #[deku(pad_bytes_after = "20")]
+    config: u32,
+}
+
 // MI v2.0, 6, Figure 136
 // Base v2.1, 5.1.12, Figures 197-201
 #[derive(Debug, DekuRead, DekuWrite, Eq, PartialEq)]

src/nvme/mi/dev.rs

@@ -12,9 +12,10 @@ use crate::{
     CommandEffect, CommandEffectError, Controller, ControllerError, ControllerType, Discriminant,
     MAX_CONTROLLERS, MAX_NAMESPACES, NamespaceId, SubsystemError,
     nvme::{
-        AdminGetLogPageLidRequestType, AdminGetLogPageSupportedLogPagesResponse,
-        AdminIdentifyActiveNamespaceIdListResponse, AdminIdentifyAllocatedNamespaceIdListResponse,
-        AdminIdentifyCnsRequestType, AdminIdentifyControllerResponse,
+        AdminFormatNvmConfiguration, AdminGetLogPageLidRequestType,
+        AdminGetLogPageSupportedLogPagesResponse, AdminIdentifyActiveNamespaceIdListResponse,
+        AdminIdentifyAllocatedNamespaceIdListResponse, AdminIdentifyCnsRequestType,
+        AdminIdentifyControllerResponse,
         AdminIdentifyNamespaceIdentificationDescriptorListResponse,
         AdminIdentifyNvmIdentifyNamespaceResponse, AdminIoCqeGenericCommandStatus,
         AdminIoCqeStatus, AdminIoCqeStatusType, AdminSanitizeConfiguration, ControllerListResponse,
@@ -23,8 +24,8 @@ use crate::{
         SanitizeStateInformation, SanitizeStatus, SanitizeStatusLogPageResponse,
         SmartHealthInformationLogPageResponse,
         mi::{
-            AdminCommandRequestHeader, AdminCommandResponseHeader, AdminNamespaceAttachmentRequest,
-            AdminNamespaceManagementRequest, AdminSanitizeRequest,
+            AdminCommandRequestHeader, AdminCommandResponseHeader, AdminFormatNvmRequest,
+            AdminNamespaceAttachmentRequest, AdminNamespaceManagementRequest, AdminSanitizeRequest,
             CompositeControllerStatusDataStructureResponse, CompositeControllerStatusFlagSet,
             ControllerFunctionAndReportingFlags, ControllerHealthDataStructure,
             ControllerHealthStatusPollResponse, ControllerInformationResponse,
@@ -810,6 +811,9 @@ impl RequestHandler for AdminCommandRequestHeader {
             AdminCommandRequestType::NamespaceManagement(req) => {
                 req.handle(ctx, mep, subsys, rest, resp, app).await
             }
+            AdminCommandRequestType::FormatNvm(req) => {
+                req.handle(ctx, mep, subsys, rest, resp, app).await
+            }
             AdminCommandRequestType::Sanitize(req) => {
                 req.handle(ctx, mep, subsys, rest, resp, app).await
             }
@@ -1339,7 +1343,7 @@ impl RequestHandler for AdminIdentifyRequest {
                         .expect("Too many namespaces"),
                     oncs: 0,
                     fuses: 0,
-                    fna: 0,
+                    fna: ctlr.fna.into(),
                     vwc: 0,
                     awun: 0,
                     awupf: 0,
@@ -1813,6 +1817,53 @@ impl RequestHandler for AdminSanitizeRequest {
     }
 }
 
+impl RequestHandler for AdminFormatNvmRequest {
+    type Ctx = AdminCommandRequestHeader;
+
+    async fn handle<A, C>(
+        &self,
+        ctx: &Self::Ctx,
+        _mep: &mut crate::ManagementEndpoint,
+        subsys: &mut crate::Subsystem,
+        rest: &[u8],
+        resp: &mut C,
+        _app: A,
+    ) -> Result<(), ResponseStatus>
+    where
+        A: AsyncFnMut(CommandEffect) -> Result<(), CommandEffectError>,
+        C: AsyncRespChannel,
+    {
+        if !rest.is_empty() {
+            debug!("Invalid request size for Admin Format NVM");
+            return Err(ResponseStatus::InvalidCommandSize);
+        }
+
+        let Some(ctlr) = subsys.ctlrs.iter().find(|c| c.id.0 == ctx.ctlid) else {
+            debug!("Unrecognised CTLID: {}", ctx.ctlid);
+            return Err(ResponseStatus::InvalidParameter);
+        };
+
+        let Ok(config) = TryInto::<AdminFormatNvmConfiguration>::try_into(self.config) else {
+            debug!("Invalid configuration for Admin Format NVM");
+            return Err(ResponseStatus::InvalidParameter);
+        };
+
+        if config.lbafi != 0 {
+            debug!("Unsupported LBA format index: {}", config.lbafi);
+            return Err(ResponseStatus::InvalidParameter);
+        }
+
+        if !ctlr.active_ns.iter().any(|ns| ns.0 == self.nsid) && self.nsid != u32::MAX {
+            debug!("Unrecognised NSID: {}", self.nsid);
+            return Err(ResponseStatus::InvalidParameter);
+        }
+
+        // TODO: handle config.ses
+
+        admin_send_response_body(resp, &[]).await
+    }
+}
+
 impl crate::ManagementEndpoint {
     fn update(&mut self, subsys: &crate::Subsystem) {
         assert!(subsys.ctlrs.len() <= self.mecss.len());