Index | Thread | Search

From:
Stefan Huber <stefan.huber@stusta.de>
Subject:
Re: firmware update for intel X700 series network cards (1 of 2: kernel interface)
To:
tech@openbsd.org
Date:
Sat, 07 Nov 2026 14:16:52 +0100

Download raw body.

Thread
Sorry about the line break



commit cf3f5bac408a1b3c0988c93b59b505d29a3f17b6
Author: Stefan Huber <stefan.huber@stusta.de>
Date:   Sun Jul 5 17:05:22 2026 +0200

    ixl(4): admin-queue NVM access ioctls for firmware read and update

diff --git sys/dev/pci/if_ixl.c sys/dev/pci/if_ixl.c
index 2fe30a950a1..9bac96da3d0 100644
--- sys/dev/pci/if_ixl.c
+++ sys/dev/pci/if_ixl.c
@@ -193,6 +193,13 @@ struct ixl_aq_desc {
 #define IXL_AQ_OP_PHY_SET_EVENT_MASK	0x0613
 #define IXL_AQ_OP_PHY_SET_REGISTER	0x0628
 #define IXL_AQ_OP_PHY_GET_REGISTER	0x0629
+#define IXL_AQ_OP_NVM_READ		0x0701
+#define IXL_AQ_OP_NVM_ERASE		0x0702
+#define IXL_AQ_OP_NVM_UPDATE		0x0703
+#define IXL_AQ_OP_NVM_CFG_READ		0x0704
+#define IXL_AQ_OP_NVM_CFG_WRITE		0x0705
+#define IXL_AQ_OP_NVM_RESERVED		0x0706
+#define IXL_AQ_OP_NVM_ROLLBACK		0x0707
 #define IXL_AQ_OP_LLDP_GET_MIB		0x0a00
 #define IXL_AQ_OP_LLDP_MIB_CHG_EV	0x0a01
 #define IXL_AQ_OP_LLDP_ADD_TLV		0x0a02
@@ -206,6 +213,19 @@ struct ixl_aq_desc {
 #define IXL_AQ_OP_SET_RSS_LUT		0x0b03 /* 722 only */
 #define IXL_AQ_OP_GET_RSS_KEY		0x0b04 /* 722 only */
 #define IXL_AQ_OP_GET_RSS_LUT		0x0b05 /* 722 only */
+/* Shared resource IDs (datasheet table 7-213) */
+#define IXL_AQ_RESOURCE_NVM			0x0001
+#define IXL_AQ_RESOURCE_SDP			0x0002
+/* Shared resource access types */
+#define IXL_AQ_RESOURCE_READ			0x0001
+#define IXL_AQ_RESOURCE_WRITE			0x0002
+/* Default timeouts in ms (datasheet table 7-213) */
+#define IXL_AQ_RESOURCE_NVM_READ_TIMEOUT	  3000
+#define IXL_AQ_RESOURCE_NVM_WRITE_TIMEOUT	180000
+
+/* NVM_READ command flags (byte 16 of NVM read AQ command) */
+#define IXL_AQ_NVM_LAST_COMMAND			(1 << 0)
+#define IXL_AQ_NVM_FLASH_ONLY			(1 << 7)
 
 struct ixl_aq_mac_addresses {
 	uint8_t		pf_lan[ETHER_ADDR_LEN];
@@ -1221,6 +1241,12 @@ struct ixl_softc {
 
 	uint16_t		 sc_api_major;
 	uint16_t		 sc_api_minor;
+	uint16_t		 sc_fw_major;
+	uint16_t		 sc_fw_minor;
+	uint32_t		 sc_fw_build;
+	int			 sc_pci_bus;
+	int			 sc_pci_dev;
+	int			 sc_pci_func;
 	uint8_t			 sc_pf_id;
 	uint16_t		 sc_uplink_seid;	/* le */
 	uint16_t		 sc_downlink_seid;	/* le */
@@ -1266,6 +1292,22 @@ struct ixl_softc {
 	struct rwlock		 sc_cfg_lock;
 	unsigned int		 sc_dead;
 
+	/* NVM session state (guarded by ixl_nvm_lock) */
+	pid_t			 sc_nvm_pid;	/* 0 = no session */
+	uint8_t			 sc_nvm_access;
+
+	/*
+	 * NVM async event slot: any NVM ARQ event delivers to the
+	 * single in-flight SIOCSIFNVMCMD waiter for this softc.  The
+	 * counter is monotonic-and-nonzero so it doubles as an active-
+	 * waiter flag; cookie matching is not used because the chip
+	 * does not reliably echo the cookie on NVM completion events.
+	 */
+	struct mutex		 sc_nvm_arq_mtx;
+	uint64_t		 sc_nvm_arq_cookie;	/* 0 = no waiter */
+	int			 sc_nvm_arq_valid;	/* 1 = event arrived */
+	struct ixl_aq_desc	 sc_nvm_arq_event;
+
 	uint8_t			 sc_enaddr[ETHER_ADDR_LEN];
 
 #if NKSTAT > 0
@@ -1286,6 +1328,10 @@ static int	ixl_dmamem_alloc(struct ixl_softc *, struct ixl_dmamem *,
 		    bus_size_t, u_int);
 static void	ixl_dmamem_free(struct ixl_softc *, struct ixl_dmamem *);
 
+static int	ixl_resource_acquire(struct ixl_softc *, uint16_t, uint16_t,
+		    uint32_t, uint32_t);
+static int	ixl_resource_release(struct ixl_softc *, uint16_t, uint32_t);
+
 static int	ixl_arq_fill(struct ixl_softc *);
 static void	ixl_arq_unfill(struct ixl_softc *);
 
@@ -1366,6 +1412,7 @@ static void	ixl_rxfill(struct ixl_softc *, struct ixl_rx_ring *);
 static void	ixl_rxrefill(void *);
 static int	ixl_rxrinfo(struct ixl_softc *, struct if_rxrinfo *);
 static void	ixl_rx_checksum(struct mbuf *, uint64_t);
+static int	ixl_nvm_read(struct ixl_softc *, uint16_t, uint16_t, uint16_t *);
 
 #if NKSTAT > 0
 static void	ixl_kstat_attach(struct ixl_softc *);
@@ -1486,6 +1533,7 @@ ixl_aq_dva(struct ixl_aq_desc *iaq, bus_addr_t addr)
 #endif
 
 static struct rwlock ixl_sff_lock = RWLOCK_INITIALIZER("ixlsff");
+static struct rwlock ixl_nvm_lock = RWLOCK_INITIALIZER("ixlnvm");
 
 /* deal with differences between chips */
 
@@ -1651,6 +1699,8 @@ ixl_attach(struct device *parent, struct device *self, void *aux)
 	sc->sc_pc = pa->pa_pc;
 	sc->sc_tag = pa->pa_tag;
 	sc->sc_dmat = pa->pa_dmat;
+	pci_decompose_tag(pa->pa_pc, pa->pa_tag,
+	    &sc->sc_pci_bus, &sc->sc_pci_dev, &sc->sc_pci_func);
 	sc->sc_aq_regs = &ixl_pf_aq_regs;
 
 	sc->sc_nqueues = 0; /* 1 << 0 is 1 queue */
@@ -1692,6 +1742,7 @@ ixl_attach(struct device *parent, struct device *self, void *aux)
 	/* initialise the adminq */
 
 	mtx_init(&sc->sc_atq_mtx, IPL_NET);
+	mtx_init(&sc->sc_nvm_arq_mtx, IPL_NET);
 
 	if (ixl_dmamem_alloc(sc, &sc->sc_atq,
 	    sizeof(struct ixl_aq_desc) * IXL_AQ_NUM, IXL_AQ_ALIGN) != 0) {
@@ -2146,6 +2197,286 @@ ixl_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
 		rw_exit(&ixl_sff_lock);
 		break;
 
+	case SIOCGIFFWVER: {
+		struct if_fwver *fv = (struct if_fwver *)data;
+
+		fv->fv_fw_major = sc->sc_fw_major;
+		fv->fv_fw_minor = sc->sc_fw_minor;
+		fv->fv_fw_build = sc->sc_fw_build;
+		fv->fv_api_major = sc->sc_api_major;
+		fv->fv_api_minor = sc->sc_api_minor;
+		fv->fv_pci_bus = (uint16_t)sc->sc_pci_bus;
+		fv->fv_pci_dev = (uint16_t)sc->sc_pci_dev;
+		fv->fv_pci_func = (uint16_t)sc->sc_pci_func;
+		break;
+	}
+
+	case SIOCGIFNVM: {
+		struct if_nvmdata *nvm = (struct if_nvmdata *)data;
+		uint16_t *buf;
+		size_t buflen = nvm->nvm_words * sizeof(uint16_t);
+
+		buf = mallocarray(nvm->nvm_words, sizeof(uint16_t), M_DEVBUF,
+		    M_WAITOK | M_ZERO);
+
+		error = rw_enter(&ixl_nvm_lock, RW_WRITE | RW_INTR);
+		if (error != 0) {
+			free(buf, M_DEVBUF, buflen);
+			break;
+		}
+		if (sc->sc_nvm_pid != 0 &&
+		    prfind(sc->sc_nvm_pid) != NULL) {
+			rw_exit(&ixl_nvm_lock);
+			free(buf, M_DEVBUF, buflen);
+			error = EBUSY;
+			break;
+		}
+		error = ixl_nvm_read(sc, nvm->nvm_offset, nvm->nvm_words, buf);
+		rw_exit(&ixl_nvm_lock);
+
+		if (error == 0)
+			error = copyout(buf, nvm->nvm_data, buflen);
+		free(buf, M_DEVBUF, buflen);
+		break;
+	}
+
+	case SIOCSIFNVMOPEN: {
+		const struct if_nvmsess *ns = (struct if_nvmsess *)data;
+		uint16_t access, timeout;
+
+		if (ns->ns_access == IFNVM_ACCESS_READ) {
+			access = IXL_AQ_RESOURCE_READ;
+			timeout = IXL_AQ_RESOURCE_NVM_READ_TIMEOUT;
+		} else {
+			access = IXL_AQ_RESOURCE_WRITE;
+			timeout = IXL_AQ_RESOURCE_NVM_WRITE_TIMEOUT;
+		}
+
+		error = rw_enter(&ixl_nvm_lock, RW_WRITE | RW_INTR);
+		if (error != 0)
+			break;
+		if (sc->sc_nvm_pid != 0 &&
+		    prfind(sc->sc_nvm_pid) != NULL) {
+			rw_exit(&ixl_nvm_lock);
+			error = EBUSY;
+			break;
+		}
+		error = ixl_resource_acquire(sc, IXL_AQ_RESOURCE_NVM,
+		    access, timeout, 0);
+		if (error == 0) {
+			sc->sc_nvm_pid = curproc->p_p->ps_pid;
+			sc->sc_nvm_access = ns->ns_access;
+		}
+		rw_exit(&ixl_nvm_lock);
+		break;
+	}
+
+	case SIOCSIFNVMCLOSE:
+		error = rw_enter(&ixl_nvm_lock, RW_WRITE | RW_INTR);
+		if (error != 0)
+			break;
+		if (sc->sc_nvm_pid == 0) {
+			rw_exit(&ixl_nvm_lock);
+			error = ENOENT;
+			break;
+		}
+		if (sc->sc_nvm_pid != curproc->p_p->ps_pid &&
+		    prfind(sc->sc_nvm_pid) != NULL) {
+			rw_exit(&ixl_nvm_lock);
+			error = EPERM;
+			break;
+		}
+		(void)ixl_resource_release(sc, IXL_AQ_RESOURCE_NVM, 0);
+		sc->sc_nvm_pid = 0;
+		sc->sc_nvm_access = 0;
+		rw_exit(&ixl_nvm_lock);
+		break;
+
+	case SIOCSIFNVMCMD: {
+		struct if_nvmcmd *nc = (struct if_nvmcmd *)data;
+		struct ixl_aq_desc iaq;
+		struct ixl_dmamem idm;
+		uint16_t aqflags;
+		uint64_t cookie = 0;
+		int have_buf, write_buf;
+		int dma_alloced = 0;
+		int do_wait = (nc->nc_flags & IFNVM_CMD_F_WAIT_ARQ) != 0;
+
+		/* Opcode allowlist and buffer-direction table. */
+		switch (nc->nc_opcode) {
+		case IXL_AQ_OP_NVM_READ:
+		case IXL_AQ_OP_NVM_CFG_READ:
+			write_buf = 0;	/* chip -> host */
+			have_buf = (nc->nc_buflen != 0);
+			break;
+		case IXL_AQ_OP_NVM_UPDATE:
+		case IXL_AQ_OP_NVM_CFG_WRITE:
+			write_buf = 1;	/* host -> chip */
+			have_buf = (nc->nc_buflen != 0);
+			break;
+		case IXL_AQ_OP_NVM_ERASE:
+		case IXL_AQ_OP_NVM_ROLLBACK:
+			write_buf = 0;
+			have_buf = 0;
+			break;
+		default:
+			error = EOPNOTSUPP;
+			break;
+		}
+		if (error != 0)
+			break;
+		if (have_buf && nc->nc_buf == NULL) {
+			error = EINVAL;
+			break;
+		}
+
+		error = rw_enter(&ixl_nvm_lock, RW_WRITE | RW_INTR);
+		if (error != 0)
+			break;
+		if (sc->sc_nvm_pid != curproc->p_p->ps_pid) {
+			rw_exit(&ixl_nvm_lock);
+			error = EPERM;
+			break;
+		}
+		if (write_buf && sc->sc_nvm_access != IFNVM_ACCESS_WRITE) {
+			rw_exit(&ixl_nvm_lock);
+			error = EPERM;
+			break;
+		}
+
+		if (have_buf) {
+			if (ixl_dmamem_alloc(sc, &idm, nc->nc_buflen, 0)
+			    != 0) {
+				rw_exit(&ixl_nvm_lock);
+				error = ENOMEM;
+				break;
+			}
+			dma_alloced = 1;
+			if (write_buf) {
+				error = copyin(nc->nc_buf,
+				    IXL_DMA_KVA(&idm), nc->nc_buflen);
+				if (error != 0)
+					goto cmd_done;
+			}
+		}
+
+		aqflags = 0;
+		if (have_buf) {
+			aqflags = IXL_AQ_BUF;
+			if (nc->nc_buflen > I40E_AQ_LARGE_BUF)
+				aqflags |= IXL_AQ_LB;
+			if (write_buf)
+				aqflags |= IXL_AQ_RD;
+		}
+		/*
+		 * Datasheet 3.4.5.4 / 3.4.5.5 / 3.4.5.6: in a multi-step
+		 * NVM_UPDATE/NVM_ERASE sequence the FE (Flush on Error)
+		 * bit must be set on every command except the LAST one,
+		 * so the chip discards the remaining queued commands if
+		 * any single command fails.  Set it automatically based
+		 * on the absence of LAST_COMMAND in nc_cmdflags.
+		 */
+		if ((nc->nc_opcode == IXL_AQ_OP_NVM_UPDATE ||
+		     nc->nc_opcode == IXL_AQ_OP_NVM_ERASE ||
+		     nc->nc_opcode == IXL_AQ_OP_NVM_CFG_WRITE) &&
+		    !(nc->nc_cmdflags & IXL_AQ_NVM_LAST_COMMAND))
+			aqflags |= IXL_AQ_FE;
+
+		/* Reserve an ARQ event slot if the caller will wait. */
+		if (do_wait) {
+			mtx_enter(&sc->sc_nvm_arq_mtx);
+			do {
+				sc->sc_nvm_arq_cookie++;
+			} while (sc->sc_nvm_arq_cookie == 0);
+			cookie = sc->sc_nvm_arq_cookie;
+			sc->sc_nvm_arq_valid = 0;
+			mtx_leave(&sc->sc_nvm_arq_mtx);
+		}
+
+		memset(&iaq, 0, sizeof(iaq));
+		iaq.iaq_flags = htole16(aqflags);
+		iaq.iaq_opcode = htole16(nc->nc_opcode);
+		iaq.iaq_datalen = htole16(nc->nc_buflen);
+		iaq.iaq_cookie = cookie;
+		iaq.iaq_param[0] = htole32((uint32_t)nc->nc_cmdflags |
+		    ((uint32_t)nc->nc_module << 8) |
+		    ((uint32_t)nc->nc_aqlen << 16));
+		iaq.iaq_param[1] = htole32(nc->nc_offset);
+		if (have_buf)
+			ixl_aq_dva(&iaq, IXL_DMA_DVA(&idm));
+
+		if (have_buf) {
+			bus_dmamap_sync(sc->sc_dmat, IXL_DMA_MAP(&idm),
+			    0, IXL_DMA_LEN(&idm), write_buf ?
+			    BUS_DMASYNC_PREWRITE : BUS_DMASYNC_PREREAD);
+		}
+		error = ixl_atq_poll(sc, &iaq, 2000);
+		if (have_buf) {
+			bus_dmamap_sync(sc->sc_dmat, IXL_DMA_MAP(&idm),
+			    0, IXL_DMA_LEN(&idm), write_buf ?
+			    BUS_DMASYNC_POSTWRITE : BUS_DMASYNC_POSTREAD);
+		}
+
+		nc->nc_retval = le16toh(iaq.iaq_retval);
+		nc->nc_aqlen = (le32toh(iaq.iaq_param[0]) >> 16) & 0xffff;
+		if (error != 0)
+			goto cmd_done;
+		if (iaq.iaq_retval != htole16(IXL_AQ_RC_OK)) {
+			/*
+			 * The chip-level failure is reported via nc_retval;
+			 * the ioctl itself succeeded (delivered the command,
+			 * got a response). Userland must check nc_retval.
+			 */
+			goto cmd_done;
+		}
+
+		if (do_wait) {
+			uint16_t to_ms = nc->nc_timeout_ms;
+			uint64_t to_ns;
+
+			if (to_ms == 0)
+				to_ms = 30000;	/* 30 s default */
+			to_ns = (uint64_t)to_ms * 1000000ULL;
+
+			mtx_enter(&sc->sc_nvm_arq_mtx);
+			while (!sc->sc_nvm_arq_valid) {
+				error = msleep_nsec(&sc->sc_nvm_arq_valid,
+				    &sc->sc_nvm_arq_mtx, PRIBIO | PCATCH,
+				    "ixlnvm", to_ns);
+				if (error != 0)
+					break;
+			}
+			if (error == 0) {
+				nc->nc_retval = le16toh(
+				    sc->sc_nvm_arq_event.iaq_retval);
+				nc->nc_aqlen = (le32toh(
+				    sc->sc_nvm_arq_event.iaq_param[0]) >> 16)
+				    & 0xffff;
+			}
+			sc->sc_nvm_arq_cookie = 0;
+			sc->sc_nvm_arq_valid = 0;
+			mtx_leave(&sc->sc_nvm_arq_mtx);
+			if (error != 0)
+				goto cmd_done;
+			if (sc->sc_nvm_arq_event.iaq_retval !=
+			    htole16(IXL_AQ_RC_OK)) {
+				/* chip reported failure via nc_retval */
+				goto cmd_done;
+			}
+		}
+
+		if (!write_buf && have_buf) {
+			error = copyout(IXL_DMA_KVA(&idm), nc->nc_buf,
+			    nc->nc_buflen);
+		}
+
+ cmd_done:
+		if (dma_alloced)
+			ixl_dmamem_free(sc, &idm);
+		rw_exit(&ixl_nvm_lock);
+		break;
+	}
+
 	default:
 		error = ether_ioctl(ifp, &sc->sc_ac, cmd, data);
 		break;
@@ -3605,6 +3936,28 @@ ixl_arq(void *xsc)
 		case HTOLE16(IXL_AQ_OP_PHY_LINK_STATUS):
 			ixl_link_state_update_iaq(sc, iaq);
 			break;
+		case HTOLE16(IXL_AQ_OP_NVM_READ):
+		case HTOLE16(IXL_AQ_OP_NVM_ERASE):
+		case HTOLE16(IXL_AQ_OP_NVM_UPDATE):
+		case HTOLE16(IXL_AQ_OP_NVM_CFG_READ):
+		case HTOLE16(IXL_AQ_OP_NVM_CFG_WRITE):
+		case HTOLE16(IXL_AQ_OP_NVM_ROLLBACK):
+			/*
+			 * Observed: the chip does not echo our cookie back
+			 * on the NVM_UPDATE completion event despite the
+			 * datasheet (3.4.10.3) saying it would.  We rely on
+			 * the session model (single waiter per softc) and
+			 * deliver any pending NVM event to the active
+			 * waiter rather than matching by cookie.
+			 */
+			mtx_enter(&sc->sc_nvm_arq_mtx);
+			if (sc->sc_nvm_arq_cookie != 0) {
+				sc->sc_nvm_arq_event = *iaq;
+				sc->sc_nvm_arq_valid = 1;
+				wakeup(&sc->sc_nvm_arq_valid);
+			}
+			mtx_leave(&sc->sc_nvm_arq_mtx);
+			break;
 		}
 
 		memset(iaq, 0, sizeof(*iaq));
@@ -3804,16 +4157,103 @@ ixl_get_version(struct ixl_softc *sc)
 	fwver = lemtoh32(&iaq.iaq_param[2]);
 	apiver = lemtoh32(&iaq.iaq_param[3]);
 
+	sc->sc_fw_major = fwver & 0xffff;
+	sc->sc_fw_minor = (fwver >> 16) & 0xffff;
+	sc->sc_fw_build = fwbuild;
 	sc->sc_api_major = apiver & 0xffff;
 	sc->sc_api_minor = (apiver >> 16) & 0xffff;
 
-	printf(", FW %hu.%hu.%05u API %hu.%hu", (uint16_t)fwver,
-	    (uint16_t)(fwver >> 16), fwbuild,
+	printf(", FW %hu.%hu.%05u API %hu.%hu",
+	    sc->sc_fw_major, sc->sc_fw_minor, sc->sc_fw_build,
 	    sc->sc_api_major, sc->sc_api_minor);
 
 	return (0);
 }
 
+/*
+ * Read words from the NVM (Flash) of an Intel 700-series controller into
+ * a kernel buffer.  Issues NVM Read admin commands (opcode 0x0701) in
+ * chunks of up to 4 KB, as required by the datasheet (see Intel Ethernet
+ * Controller X710/XXV710/XL710 datasheet, sections 3.4.10.1 and 7.10.2).
+ *
+ * Caller must hold ixl_nvm_lock.
+ */
+static int
+ixl_nvm_read(struct ixl_softc *sc, uint16_t woffset, uint16_t nwords,
+    uint16_t *buf)
+{
+	struct ixl_aq_desc iaq;
+	struct ixl_dmamem idm;
+	const uint16_t bufsz = MIN(IXL_AQ_BUFLEN, nwords * sizeof(uint16_t));
+	uint16_t done = 0;
+	int rv;
+
+	rv = ixl_resource_acquire(sc, IXL_AQ_RESOURCE_NVM,
+	    IXL_AQ_RESOURCE_READ, IXL_AQ_RESOURCE_NVM_READ_TIMEOUT, 0);
+	if (rv != 0)
+		return (rv);
+
+	if (ixl_dmamem_alloc(sc, &idm, bufsz, 0) != 0) {
+		rv = ENOMEM;
+		goto release;
+	}
+
+	while (done < nwords) {
+		const uint16_t chunk = MIN(nwords - done,
+		    bufsz / sizeof(uint16_t));
+		const uint16_t len = chunk * sizeof(uint16_t);
+		uint32_t byteoff = ((uint32_t)woffset + done) * sizeof(uint16_t);
+		uint8_t cmdflags = 0;
+		uint16_t aqflags = IXL_AQ_BUF;
+
+		if (done + chunk >= nwords)
+			cmdflags |= IXL_AQ_NVM_LAST_COMMAND;
+		if (len > I40E_AQ_LARGE_BUF)
+			aqflags |= IXL_AQ_LB;
+
+		memset(&iaq, 0, sizeof(iaq));
+		iaq.iaq_flags = htole16(aqflags);
+		iaq.iaq_opcode = htole16(IXL_AQ_OP_NVM_READ);
+		iaq.iaq_datalen = htole16(len);
+		/*
+		 * Command bytes 16-19 (param[0], LE):
+		 *   byte 16    = Command Flags
+		 *   byte 17    = Module Pointer (0 = flat Flash)
+		 *   bytes 18-19 = Length in bytes
+		 */
+		iaq.iaq_param[0] = htole32(cmdflags | ((uint32_t)len << 16));
+		/* Bytes 20-23: byte offset (only 22:20 used, 23 reserved). */
+		iaq.iaq_param[1] = htole32(byteoff);
+		ixl_aq_dva(&iaq, IXL_DMA_DVA(&idm));
+
+		bus_dmamap_sync(sc->sc_dmat, IXL_DMA_MAP(&idm),
+		    0, IXL_DMA_LEN(&idm), BUS_DMASYNC_PREREAD);
+
+		rv = ixl_atq_poll(sc, &iaq, 2000);
+
+		bus_dmamap_sync(sc->sc_dmat, IXL_DMA_MAP(&idm),
+		    0, IXL_DMA_LEN(&idm), BUS_DMASYNC_POSTREAD);
+
+		if (rv != 0) {
+			rv = EIO;
+			goto free;
+		}
+		if (iaq.iaq_retval != htole16(IXL_AQ_RC_OK)) {
+			rv = EIO;
+			goto free;
+		}
+
+		memcpy(buf + done, IXL_DMA_KVA(&idm), len);
+		done += chunk;
+	}
+
+free:
+	ixl_dmamem_free(sc, &idm);
+release:
+	(void)ixl_resource_release(sc, IXL_AQ_RESOURCE_NVM, 0);
+	return (rv);
+}
+
 static int
 ixl_pxe_clear(struct ixl_softc *sc)
 {
@@ -5212,6 +5652,51 @@ ixl_dmamem_free(struct ixl_softc *sc, struct ixl_dmamem *ixm)
 	bus_dmamap_destroy(sc->sc_dmat, ixm->ixm_map);
 }
 
+/*
+ * Acquire ownership of a shared resource (datasheet 7.10.11.5).
+ * Bytes 16-17 of the command carry the resource ID, 18-19 the access type,
+ * 20-23 the requested timeout (ms), 24-27 the resource number.
+ */
+static int
+ixl_resource_acquire(struct ixl_softc *sc, uint16_t resource, uint16_t type,
+    uint32_t timeout, uint32_t number)
+{
+	struct ixl_aq_desc iaq;
+	int rv;
+
+	memset(&iaq, 0, sizeof(iaq));
+	iaq.iaq_opcode = htole16(IXL_AQ_OP_REQUEST_RESOURCE);
+	iaq.iaq_param[0] = htole32(resource | ((uint32_t)type << 16));
+	iaq.iaq_param[1] = htole32(timeout);
+	iaq.iaq_param[2] = htole32(number);
+
+	rv = ixl_atq_poll(sc, &iaq, 2000);
+	if (rv != 0)
+		return (rv);
+	if (iaq.iaq_retval != htole16(IXL_AQ_RC_OK))
+		return (EIO);
+	return (0);
+}
+
+static int
+ixl_resource_release(struct ixl_softc *sc, uint16_t resource, uint32_t number)
+{
+	struct ixl_aq_desc iaq;
+	int rv;
+
+	memset(&iaq, 0, sizeof(iaq));
+	iaq.iaq_opcode = htole16(IXL_AQ_OP_RELEASE_RESOURCE);
+	iaq.iaq_param[0] = htole32(resource);
+	iaq.iaq_param[2] = htole32(number);
+
+	rv = ixl_atq_poll(sc, &iaq, 2000);
+	if (rv != 0)
+		return (rv);
+	if (iaq.iaq_retval != htole16(IXL_AQ_RC_OK))
+		return (EIO);
+	return (0);
+}
+
 #if NKSTAT > 0
 
 CTASSERT(KSTAT_KV_U_NONE <= 0xffU);
diff --git sys/net/if.c sys/net/if.c
index 52133909fac..3b72d31e0ce 100644
--- sys/net/if.c
+++ sys/net/if.c
@@ -139,6 +139,12 @@ int	ifioctl_get(u_long, caddr_t);
 int	ifconf(caddr_t);
 static int
 	if_sffpage_check(const caddr_t);
+static int
+	if_nvmdata_check(const caddr_t);
+static int
+	if_nvmsess_check(const caddr_t);
+static int
+	if_nvmcmd_check(const caddr_t);
 
 int	if_getgroup(caddr_t, struct ifnet *);
 int	if_getgroupmembers(caddr_t);
@@ -2470,6 +2476,73 @@ forceup:
 		error = ((*ifp->if_ioctl)(ifp, cmd, data));
 		break;
 
+	case SIOCGIFNVM:
+		error = suser(p);
+		if (error != 0)
+			break;
+
+		error = if_nvmdata_check(data);
+		if (error != 0)
+			break;
+
+		/* don't take NET_LOCK because NVM reads take a long time */
+		error = ((*ifp->if_ioctl)(ifp, cmd, data));
+		break;
+
+	case SIOCSIFNVMOPEN: {
+		const struct if_nvmsess *ns = (const struct if_nvmsess *)data;
+
+		error = suser(p);
+		if (error != 0)
+			break;
+
+		error = if_nvmsess_check(data);
+		if (error != 0)
+			break;
+
+		/*
+		 * Writing firmware to the NIC must not be possible while the
+		 * system is running normally and reachable over the network:
+		 * a privileged remote attacker could otherwise flash malicious
+		 * firmware.  Allow opening a write session only at securelevel
+		 * <= 0, i.e. single-user mode, which is administered from the
+		 * local console and does not start network services.  Read
+		 * sessions are always permitted.
+		 */
+		if (ns->ns_access == IFNVM_ACCESS_WRITE && securelevel > 0) {
+			error = EPERM;
+			break;
+		}
+
+		error = ((*ifp->if_ioctl)(ifp, cmd, data));
+		break;
+	}
+
+	case SIOCSIFNVMCLOSE:
+		error = suser(p);
+		if (error != 0)
+			break;
+
+		error = ((*ifp->if_ioctl)(ifp, cmd, data));
+		break;
+
+	case SIOCSIFNVMCMD:
+		error = suser(p);
+		if (error != 0)
+			break;
+
+		error = if_nvmcmd_check(data);
+		if (error != 0)
+			break;
+
+		error = ((*ifp->if_ioctl)(ifp, cmd, data));
+		break;
+
+	case SIOCGIFFWVER:
+		/* read-only; no suser() required */
+		error = ((*ifp->if_ioctl)(ifp, cmd, data));
+		break;
+
 	case SIOCSIFMEDIA:
 		if ((error = suser(p)) != 0)
 			break;
@@ -2711,6 +2784,69 @@ if_sffpage_check(const caddr_t data)
 	return (0);
 }
 
+static int
+if_nvmdata_check(const caddr_t data)
+{
+	const struct if_nvmdata *nvm = (const struct if_nvmdata *)data;
+
+	if (nvm->nvm_words == 0 || nvm->nvm_data == NULL)
+		return (EINVAL);
+	if (nvm->nvm_words > IFNVM_MAX_WORDS)
+		return (EINVAL);
+	if ((uint32_t)nvm->nvm_offset + nvm->nvm_words > IFNVM_MAX_WORDS)
+		return (EINVAL);
+
+	return (0);
+}
+
+static int
+if_nvmsess_check(const caddr_t data)
+{
+	const struct if_nvmsess *ns = (const struct if_nvmsess *)data;
+
+	switch (ns->ns_access) {
+	case IFNVM_ACCESS_READ:
+	case IFNVM_ACCESS_WRITE:
+		return (0);
+	}
+	return (EINVAL);
+}
+
+static int
+if_nvmcmd_check(const caddr_t data)
+{
+	const struct if_nvmcmd *nc = (const struct if_nvmcmd *)data;
+
+	/*
+	 * Allowlist the admin-queue opcode: only NVM-management commands
+	 * may be issued through this channel.  This keeps it from being a
+	 * generic "run any firmware command" passthrough and is enforced
+	 * here, in MI code, so every driver inherits the same policy.
+	 */
+	switch (nc->nc_opcode) {
+	case IFNVM_OP_NVM_READ:
+	case IFNVM_OP_NVM_ERASE:
+	case IFNVM_OP_NVM_WRITE:
+	case IFNVM_OP_NVM_CFG_READ:
+	case IFNVM_OP_NVM_CFG_WRITE:
+	case IFNVM_OP_NVM_CHECKSUM:
+	case IFNVM_OP_NVM_WRITE_ACTIVATE:
+	case IFNVM_OP_NVM_UPDATE_EMPR:
+		break;
+	default:
+		return (EINVAL);
+	}
+
+	if (nc->nc_buflen > IFNVM_CMD_MAX_BUFLEN)
+		return (EINVAL);
+	if (nc->nc_buflen != 0 && nc->nc_buf == NULL)
+		return (EINVAL);
+	if ((nc->nc_flags & ~IFNVM_CMD_F_WAIT_ARQ) != 0)
+		return (EINVAL);
+
+	return (0);
+}
+
 int
 if_txhprio_l2_check(int hdrprio)
 {
diff --git sys/net/if.h sys/net/if.h
index 07cc7716881..3bfccb49c77 100644
--- sys/net/if.h
+++ sys/net/if.h
@@ -524,6 +524,88 @@ struct if_sffpage {
 	uint8_t		 sff_data[IFSFF_DATA_LEN];	/* k -> u */
 };
 
+/* SIOCGIFNVM */
+
+#define IFNVM_MAX_WORDS		(64 * 1024 / 2)	/* full NVM (32K words) */
+
+struct if_nvmdata {
+	char		 nvm_ifname[IFNAMSIZ];		/* u -> k */
+	uint16_t	 nvm_offset;			/* u -> k: word offset */
+	uint16_t	 nvm_words;			/* u -> k: word count */
+	uint16_t	*nvm_data;			/* k -> u: caller buffer */
+};
+
+/* SIOCSIFNVMOPEN / SIOCSIFNVMCLOSE */
+
+#define IFNVM_ACCESS_READ	1
+#define IFNVM_ACCESS_WRITE	2
+
+struct if_nvmsess {
+	char		 ns_ifname[IFNAMSIZ];		/* u -> k */
+	uint8_t		 ns_access;			/* u -> k: IFNVM_ACCESS_* */
+	uint8_t		 ns_pad[3];
+};
+
+/* SIOCSIFNVMCMD */
+
+#define IFNVM_CMD_MAX_BUFLEN	4096	/* per-AQ-command data limit */
+
+/* nc_flags bits */
+#define IFNVM_CMD_F_WAIT_ARQ	0x0001	/* wait for async ARQ completion */
+
+/*
+ * Admin-queue opcodes permitted through SIOCSIFNVMCMD (nc_opcode).
+ * The kernel rejects any opcode not in this set, so the command channel
+ * is a constrained NVM-management interface, not a generic firmware
+ * passthrough.  These values are shared by the i40e (ixl) and ice
+ * (E810/E830) admin queues; resource acquire/release (0x0008/0x0009)
+ * are issued by the kernel during a session, not by userland, and so
+ * are deliberately NOT reachable here.
+ */
+#define IFNVM_OP_NVM_READ		0x0701
+#define IFNVM_OP_NVM_ERASE		0x0702
+#define IFNVM_OP_NVM_WRITE		0x0703	/* a.k.a. NVM_UPDATE (i40e) */
+#define IFNVM_OP_NVM_CFG_READ		0x0704
+#define IFNVM_OP_NVM_CFG_WRITE		0x0705
+#define IFNVM_OP_NVM_CHECKSUM		0x0706
+#define IFNVM_OP_NVM_WRITE_ACTIVATE	0x0707	/* ice (E810) bank activate */
+#define IFNVM_OP_NVM_UPDATE_EMPR		0x0709	/* ice (E810) EMP reset */
+
+struct if_nvmcmd {
+	char		 nc_ifname[IFNAMSIZ];		/* u -> k */
+	uint16_t	 nc_opcode;			/* u -> k: AQ opcode */
+	uint16_t	 nc_retval;			/* k -> u: AQ retval */
+	uint8_t		 nc_module;			/* u -> k: AQ byte 17 */
+	uint8_t		 nc_cmdflags;			/* u -> k: AQ byte 16 */
+	uint16_t	 nc_flags;			/* u -> k: IFNVM_CMD_F_* */
+	uint32_t	 nc_offset;			/* u -> k: AQ bytes 20-23 */
+	uint16_t	 nc_aqlen;			/* u<->k: AQ bytes 18-19 */
+	uint16_t	 nc_buflen;			/* u -> k: data buffer length */
+	uint16_t	 nc_timeout_ms;			/* u -> k: ARQ timeout */
+	uint16_t	 nc_pad;
+	void		*nc_buf;			/* k <-> u: data buffer */
+};
+
+/* SIOCGIFFWVER: running firmware version (cached at driver attach
+ * from AQ Get Version, opcode 0x0001).  Reflects what dmesg's
+ * "FW X.Y.NNNNN" prints, separately from any NVM image version.
+ */
+struct if_fwver {
+	char		 fv_ifname[IFNAMSIZ];		/* u -> k */
+	uint16_t	 fv_fw_major;			/* k -> u */
+	uint16_t	 fv_fw_minor;			/* k -> u */
+	uint32_t	 fv_fw_build;			/* k -> u */
+	uint16_t	 fv_api_major;			/* k -> u */
+	uint16_t	 fv_api_minor;			/* k -> u */
+	/* PCIe bus:dev identifies the physical card; the function
+	 * number differs per port.  Use (bus,dev) as a card key to
+	 * group ports of the same chip. */
+	uint16_t	 fv_pci_bus;			/* k -> u */
+	uint16_t	 fv_pci_dev;			/* k -> u */
+	uint16_t	 fv_pci_func;			/* k -> u */
+	uint16_t	 fv_pad;
+};
+
 #include <net/if_arp.h>
 
 #ifdef _KERNEL
diff --git sys/sys/sockio.h sys/sys/sockio.h
index 0c790c37aa7..e6f16521db0 100644
--- sys/sys/sockio.h
+++ sys/sys/sockio.h
@@ -69,6 +69,8 @@
 #define	SIOCSIFMEDIA	_IOWR('i', 55, struct ifreq)	/* set net media */
 #define	SIOCGIFMEDIA	_IOWR('i', 56, struct ifmediareq) /* get net media */
 #define	SIOCGIFSFFPAGE	_IOWR('i', 57, struct if_sffpage) /* get SFF page */
+#define	SIOCGIFNVM	_IOWR('i', 58, struct if_nvmdata) /* get NVM contents */
+#define	SIOCSIFNVMOPEN	_IOWR('i', 59, struct if_nvmsess) /* open NVM session */
 
 #define	SIOCDIFPHYADDR	 _IOW('i', 73, struct ifreq)	/* delete gif addrs */
 #define	SIOCSLIFPHYADDR	 _IOW('i', 74, struct if_laddrreq) /* set gif addrs */
@@ -120,6 +122,10 @@
 #define SIOCBRDGSTXHC    _IOW('i', 89, struct ifbrparam)/* set tx hold count */
 #define SIOCBRDGSPROTO	 _IOW('i', 90, struct ifbrparam)/* set protocol */
 
+#define	SIOCSIFNVMCLOSE	_IOWR('i', 91, struct if_nvmsess) /* close NVM session */
+#define	SIOCSIFNVMCMD	_IOWR('i', 92, struct if_nvmcmd) /* run NVM AQ command */
+#define	SIOCGIFFWVER	_IOWR('i', 93, struct if_fwver)	/* get firmware version */
+
 #define	SIOCSIFMTU	 _IOW('i', 127, struct ifreq)	/* set ifnet mtu */
 #define	SIOCGIFMTU	_IOWR('i', 126, struct ifreq)	/* get ifnet mtu */