nvme: mi: dev: Implement Admin / Namespace Attachment / Controller Attach

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

Author: amboar

src/lib.rs

@@ -266,9 +266,19 @@ pub struct SecondaryController {
     id: ControllerId,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq)]
+enum ControllerType {
+    Io,
+    #[expect(dead_code)]
+    Discovery,
+    #[expect(dead_code)]
+    Administrative,
+}
+
 #[derive(Debug)]
 pub struct Controller {
     id: ControllerId,
+    cntrltype: ControllerType,
     port: PortId,
     secondaries: heapless::Vec<SecondaryController, 0>,
     active_ns: heapless::Vec<NamespaceId, MAX_NAMESPACES>,
@@ -286,10 +296,17 @@ pub struct Controller {
     lsaes: [FlagSet<LidSupportedAndEffectsFlags>; 19],
 }
 
+#[derive(Debug)]
+pub enum ControllerError {
+    NamespaceAlreadyAttached,
+    NamespaceAttachmentLimitExceeded,
+}
+
 impl Controller {
     fn new(id: ControllerId, port: PortId) -> Self {
         Self {
             id,
+            cntrltype: ControllerType::Io,
             port,
             secondaries: heapless::Vec::new(),
             active_ns: heapless::Vec::new(),
@@ -338,8 +355,17 @@ impl Controller {
         self.temp = k;
     }
 
-    pub fn attach_namespace(&mut self, nsid: NamespaceId) -> Result<(), NamespaceId> {
-        self.active_ns.push(nsid)
+    pub fn attach_namespace(&mut self, nsid: NamespaceId) -> Result<(), ControllerError> {
+        debug!("Attaching NSID {} to CTLRID {}", nsid.0, self.id.0);
+        if self.active_ns.iter().any(|ns| ns.0 == nsid.0) {
+            return Err(ControllerError::NamespaceAlreadyAttached);
+        }
+
+        if self.active_ns.push(nsid).is_err() {
+            return Err(ControllerError::NamespaceAttachmentLimitExceeded);
+        }
+
+        Ok(())
     }
 }
 
@@ -404,6 +430,7 @@ impl Namespace {
 
 #[derive(Debug, Eq, PartialEq)]
 pub enum SubsystemError {
+    ControllerLimitExceeded,
     NamespaceIdentifierUnavailable,
 }
 
@@ -520,11 +547,14 @@ impl Subsystem {
         self.ports.push(p).map(|_p| self.ports.last().unwrap().id)
     }
 
-    #[expect(clippy::result_large_err)]
-    pub fn add_controller(&mut self, port: PortId) -> Result<ControllerId, Controller> {
+    pub fn add_controller(&mut self, port: PortId) -> Result<ControllerId, SubsystemError> {
         debug_assert!(self.ctlrs.len() <= u16::MAX.into());
-        let c = Controller::new(ControllerId(self.ctlrs.len() as u16), port);
-        self.ctlrs.push(c).map(|_c| self.ctlrs.last().unwrap().id)
+        let cid = ControllerId(self.ctlrs.len() as u16);
+        let c = Controller::new(cid, port);
+        self.ctlrs
+            .push(c)
+            .map_err(|_| SubsystemError::ControllerLimitExceeded)?;
+        Ok(cid)
     }
 
     pub fn controller_mut(&mut self, id: ControllerId) -> &mut Controller {

src/nvme.rs

@@ -61,7 +61,7 @@ impl From<AdminIoCqeStatus> for u32 {
         debug_assert_eq!((sct & !7), 0);
         let sc: u32 = match value.status {
             AdminIoCqeStatusType::GenericCommandStatus(s) => s.id(),
-            AdminIoCqeStatusType::CommandSpecificStatus(s) => s.id(),
+            AdminIoCqeStatusType::CommandSpecificStatus(v) => v,
             AdminIoCqeStatusType::MediaAndDataIntegrityErrors => todo!(),
             AdminIoCqeStatusType::PathRelatedStatus => todo!(),
             AdminIoCqeStatusType::VendorSpecific => todo!(),
@@ -90,7 +90,7 @@ unsafe impl Discriminant<u8> for CommandRetryDelay {}
 #[repr(u8)]
 enum AdminIoCqeStatusType {
     GenericCommandStatus(AdminIoCqeGenericCommandStatus) = 0x00,
-    CommandSpecificStatus(AdminIoCqeCommandSpecificStatus) = 0x01,
+    CommandSpecificStatus(u8) = 0x01,
     #[expect(dead_code)]
     MediaAndDataIntegrityErrors = 0x02,
     #[expect(dead_code)]
@@ -109,13 +109,15 @@ enum AdminIoCqeGenericCommandStatus {
 }
 unsafe impl Discriminant<u8> for AdminIoCqeGenericCommandStatus {}
 
-// Base v2.1, 4.2.3.2, Figure 103
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-#[repr(u8)]
-enum AdminIoCqeCommandSpecificStatus {
-    NamespaceIdentifierUnavailable = 0x16,
+// Base v2.1, 4.6.1, Figure 137
+// TODO: Unify with ControllerListResponse
+#[derive(Debug, DekuRead, Eq, PartialEq)]
+#[deku(ctx = "endian: Endian", endian = "little")]
+struct ControllerListRequest {
+    numids: u16,
+    #[deku(count = "*numids")]
+    ids: WireVec<u16, 2047>,
 }
-unsafe impl Discriminant<u8> for AdminIoCqeCommandSpecificStatus {}
 
 // Base v2.1, 5.1.12, Figure 202
 // MI v2.0, 6.3, Figure 141
@@ -298,6 +300,16 @@ enum ControllerType {
     AdministrativeController = 0x03,
 }
 
+impl From<crate::ControllerType> for ControllerType {
+    fn from(value: crate::ControllerType) -> Self {
+        match value {
+            crate::ControllerType::Io => Self::IoController,
+            crate::ControllerType::Discovery => Self::DiscoveryController,
+            crate::ControllerType::Administrative => Self::AdministrativeController,
+        }
+    }
+}
+
 // Base v2.1, 5.1.13.2.1, Figure 312, LPA
 flags! {
     #[repr(u8)]
@@ -438,7 +450,7 @@ struct AdminIdentifyAllocatedNamespaceIdListResponse {
 impl Encode<4096> for AdminIdentifyAllocatedNamespaceIdListResponse {}
 
 // Base v2.1, Section 5.1.13.2.12
-#[derive(Debug, DekuRead, DekuWrite)]
+#[derive(Debug, DekuWrite)]
 #[deku(endian = "little")]
 struct ControllerListResponse {
     #[deku(update = "self.ids.len()")]
@@ -457,6 +469,15 @@ impl ControllerListResponse {
     }
 }
 
+// Base v2.1, 5.1.20.1, Figure 364, SEL
+#[derive(Debug, DekuRead, Eq, PartialEq)]
+#[deku(ctx = "endian: Endian, sel: u8", endian = "endian", id = "sel")]
+#[repr(u8)]
+enum AdminNamespaceAttachmentSelect {
+    #[deku(id = 0x00)]
+    ControllerAttach(ControllerListRequest),
+}
+
 // Base v2.1, 5.1.21, Figure 376, SEL
 #[derive(Debug, DekuRead, DekuWrite, Eq, PartialEq)]
 #[deku(ctx = "endian: Endian, sel: u8", endian = "endian", id = "sel")]

src/nvme/mi.rs

@@ -3,7 +3,7 @@ use deku::{DekuError, DekuRead, DekuWrite};
 use flagset::{FlagSet, flags};
 use log::debug;
 
-use crate::nvme::AdminNamespaceManagementSelect;
+use crate::nvme::{AdminNamespaceAttachmentSelect, AdminNamespaceManagementSelect};
 use crate::wire::{WireFlagSet, WireVec};
 use crate::{CommandEffectError, Discriminant, Encode, MAX_CONTROLLERS};
 
@@ -726,7 +726,8 @@ struct ControllerInformationResponse {
 impl Encode<32> for ControllerInformationResponse {}
 
 // MI v2.0, 6, Figure 134
-#[derive(Debug, DekuRead, DekuWrite, PartialEq, Eq)]
+#[expect(clippy::large_enum_variant)] // FIXME
+#[derive(Debug, DekuRead, PartialEq, Eq)]
 #[deku(ctx = "endian: Endian, opcode: u8", id = "opcode", endian = "endian")]
 #[repr(u8)]
 enum AdminCommandRequestType {
@@ -743,6 +744,8 @@ enum AdminCommandRequestType {
     AsynchronousEventRequest = 0x0c, // P
     #[deku(id = 0x0d)]
     NamespaceManagement(AdminNamespaceManagementRequest),
+    #[deku(id = 0x15)]
+    NamespaceAttachement(AdminNamespaceAttachmentRequest),
     KeepAlive = 0x18,                      // P
     DirectiveSend = 0x19,                  // P
     DirectiveReceive = 0x1a,               // P
@@ -767,14 +770,13 @@ enum AdminCommandRequestType {
 unsafe impl Discriminant<u8> for AdminCommandRequestType {}
 
 // MI v2.0, 6, Figure 136
-#[derive(Debug, DekuRead, DekuWrite)]
+#[derive(Debug, DekuRead)]
 #[deku(endian = "little")]
 struct AdminCommandRequestHeader {
-    #[deku(update = "self.op.id()")]
-    opcode: u8,
+    _opcode: u8,
     cflgs: u8,
     ctlid: u16,
-    #[deku(ctx = "*opcode")]
+    #[deku(ctx = "*_opcode")]
     op: AdminCommandRequestType,
 }
 
@@ -845,6 +847,22 @@ struct AdminNamespaceManagementRequest {
     req: AdminNamespaceManagementSelect,
 }
 
+// MI v2.0, 6, Figure 136
+// Base v2.1, 5.1.20, Figure 364
+#[derive(Debug, DekuRead, Eq, PartialEq)]
+#[deku(ctx = "endian: Endian", endian = "endian")]
+struct AdminNamespaceAttachmentRequest {
+    nsid: u32,
+    #[deku(seek_from_current = "16")]
+    dofst: u32,
+    dlen: u32,
+    #[deku(seek_from_current = "8")]
+    sel: u8, // NOTE: SEL is the bottom nibble
+    #[deku(seek_from_current = "23")]
+    #[deku(ctx = "*sel")]
+    req: AdminNamespaceAttachmentSelect,
+}
+
 // MI v2.0, 6, Figure 138
 #[derive(Debug, DekuRead, DekuWrite)]
 #[deku(endian = "little")]