 @@ -1,16 +1,15 @@
-/*	$NetBSD: hifn7751.c,v 1.69 2020/05/17 00:50:24 riastradh Exp $	*/
+/*	$NetBSD: hifn7751.c,v 1.70 2020/05/17 00:52:31 riastradh Exp $	*/
-/*	$FreeBSD: hifn7751.c,v 1.5.2.7 2003/10/08 23:52:00 sam Exp $ */
+/*	$OpenBSD: hifn7751.c,v 1.179 2020/01/11 21:34:03 cheloha Exp $	*/
 /*	$OpenBSD: hifn7751.c,v 1.140 2003/08/01 17:55:54 deraadt Exp $	*/
 /*
  * Invertex AEON / Hifn 7751 driver
  * Copyright (c) 1999 Invertex Inc. All rights reserved.
  * Copyright (c) 1999 Theo de Raadt
  * Copyright (c) 2000-2001 Network Security Technologies, Inc.
  *			http://www.netsec.net
  * Copyright (c) 2003 Hifn Inc.
+ *
  * This driver is based on a previous driver by Invertex, for which they
  * requested:  Please send any comments, feedback, bug-fixes, or feature
  * requests to software@invertex.com.
+ *
 @@ -34,31 +33,31 @@
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
  * Effort sponsored in part by the Defense Advanced Research Projects
  * Agency (DARPA) and Air Force Research Laboratory, Air Force
  * Materiel Command, USAF, under agreement number F30602-01-2-0537.
+ *
  */
 /*
- * Driver for various  Hifn pre-HIPP encryption processors.
+ * Driver for various Hifn encryption processors.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: hifn7751.c,v 1.69 2020/05/17 00:50:24 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: hifn7751.c,v 1.70 2020/05/17 00:52:31 riastradh Exp $");
 #include <sys/param.h>
 #include <sys/cprng.h>
 #include <sys/device.h>
 #include <sys/endian.h>
 #include <sys/errno.h>
 #include <sys/kernel.h>
 #include <sys/malloc.h>
 #include <sys/mbuf.h>
 #include <sys/module.h>
 #include <sys/mutex.h>
 #include <sys/proc.h>
 #include <sys/rndsource.h>
 @@ -169,27 +168,26 @@ static const struct hifn_product {
 	  "Hifn 7951",
 	},
 	{ PCI_VENDOR_HIFN,	PCI_PRODUCT_HIFN_7955,
 	  HIFN_HAS_RNG | HIFN_HAS_PUBLIC | HIFN_IS_7956 | HIFN_HAS_AES,
 	  "Hifn 7955",
 	},
 	{ PCI_VENDOR_HIFN,	PCI_PRODUCT_HIFN_7956,
 	  HIFN_HAS_RNG | HIFN_HAS_PUBLIC | HIFN_IS_7956 | HIFN_HAS_AES,
 	  "Hifn 7956",
 	},
 	{ 0,			0,
 ,
 	  NULL
+	}
 };
 static const struct hifn_product *
 hifn_lookup(const struct pci_attach_args *pa)
+{
 	const struct hifn_product *hp;
 	for (hp = hifn_products; hp->hifn_name != NULL; hp++) {
 		if (PCI_VENDOR(pa->pa_id) == hp->hifn_vendor &&
 @@ -800,48 +798,48 @@ static struct pci2id {
 	}, {
 		PCI_VENDOR_INVERTEX,
 		PCI_PRODUCT_INVERTEX_AEON,
 		{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 x00, 0x00, 0x00, 0x00, 0x00 }
 	}, {
 		PCI_VENDOR_HIFN,
 		PCI_PRODUCT_HIFN_7811,
 		{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 x00, 0x00, 0x00, 0x00, 0x00 }
 	}, {
 		/*
 		 * Other vendors share this PCI ID as well, such as
-		 * http://www.powercrypt.com, and obviously they also
+		 * powercrypt, and obviously they also
 		 * use the same key.
 		 */
 		PCI_VENDOR_HIFN,
 		PCI_PRODUCT_HIFN_7751,
 		{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 x00, 0x00, 0x00, 0x00, 0x00 }
 	},
 };
 /*
  * Checks to see if crypto is already enabled.  If crypto isn't enable,
  * "hifn_enable_crypto" is called to enable it.  The check is important,
  * as enabling crypto twice will lock the board.
  */
 static const char *
 hifn_enable_crypto(struct hifn_softc *sc, pcireg_t pciid)
+{
 	uint32_t dmacfg, ramcfg, encl, addr, i;
 	const char *offtbl = NULL;
-	for (i = 0; i < sizeof(pci2id)/sizeof(pci2id[0]); i++) {
+	for (i = 0; i < __arraycount(pci2id); i++) {
 		if (pci2id[i].pci_vendor == PCI_VENDOR(pciid) &&
 		    pci2id[i].pci_prod == PCI_PRODUCT(pciid)) {
 			offtbl = pci2id[i].card_id;
 			break;
+		}
+	}
 	if (offtbl == NULL) {
 #ifdef HIFN_DEBUG
 		aprint_debug_dev(sc->sc_dv, "Unknown card!\n");
 #endif
 		return (NULL);
+	}
 @@ -1219,27 +1217,26 @@ hifn_writeramaddr(struct hifn_softc *sc,
 		bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap,
 , sc->sc_dmamap->dm_mapsize,
 		    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
 		if ((dma->resr[resi].l & htole32(HIFN_D_VALID)) == 0)
 			break;
 		bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap,
 , sc->sc_dmamap->dm_mapsize,
 		    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
+	}
 	if (r == 0) {
 		printf("%s: writeramaddr -- "
 		    "result[%d](addr %d) still valid\n",
 		    device_xname(sc->sc_dv), resi, addr);
 		r = -1;
 		return (-1);
 	} else
 		r = 0;
 	WRITE_REG_1(sc, HIFN_1_DMA_CSR,
 	    HIFN_DMACSR_C_CTRL_DIS | HIFN_DMACSR_S_CTRL_DIS |
 	    HIFN_DMACSR_D_CTRL_DIS | HIFN_DMACSR_R_CTRL_DIS);
 	return (r);
+}
 static int
 hifn_readramaddr(struct hifn_softc *sc, int addr, uint8_t *data)
 @@ -1365,27 +1362,27 @@ hifn_write_command(struct hifn_command *
 	base_cmd = (struct hifn_base_command *)buf_pos;
 	base_cmd->masks = htole16(cmd->base_masks);
 	slen = cmd->src_map->dm_mapsize;
 	if (cmd->sloplen)
 		dlen = cmd->dst_map->dm_mapsize - cmd->sloplen +
 		    sizeof(uint32_t);
 	else
 		dlen = cmd->dst_map->dm_mapsize;
 	base_cmd->total_source_count = htole16(slen & HIFN_BASE_CMD_LENMASK_LO);
 	base_cmd->total_dest_count = htole16(dlen & HIFN_BASE_CMD_LENMASK_LO);
 	dlen >>= 16;
 	slen >>= 16;
-	base_cmd->session_num = htole16(cmd->session_num |
+	base_cmd->session_num = htole16(
 	    ((slen << HIFN_BASE_CMD_SRCLEN_S) & HIFN_BASE_CMD_SRCLEN_M) |
 	    ((dlen << HIFN_BASE_CMD_DSTLEN_S) & HIFN_BASE_CMD_DSTLEN_M));
 	buf_pos += sizeof(struct hifn_base_command);
 	if (using_comp) {
 		comp_cmd = (struct hifn_comp_command *)buf_pos;
 		dlen = cmd->compcrd->crd_len;
 		comp_cmd->source_count = htole16(dlen & 0xffff);
 		dlen >>= 16;
 		comp_cmd->masks = htole16(cmd->comp_masks |
 		    ((dlen << HIFN_COMP_CMD_SRCLEN_S) & HIFN_COMP_CMD_SRCLEN_M));
 		comp_cmd->header_skip = htole16(cmd->compcrd->crd_skip);
 		comp_cmd->reserved = 0;
 @@ -2035,53 +2032,48 @@ out:
  */
 static int
 hifn_newsession(void *arg, uint32_t *sidp, struct cryptoini *cri)
+{
 	struct cryptoini *c;
 	struct hifn_softc *sc = arg;
 	int i, mac = 0, cry = 0, comp = 0, retval = EINVAL;
 	KASSERT(sc != NULL /*, ("hifn_newsession: null softc")*/);
 	if (sidp == NULL || cri == NULL || sc == NULL)
 		return retval;
 	mutex_spin_enter(&sc->sc_mtx);
 	for (i = 0; i < sc->sc_maxses; i++)
-		if (sc->sc_sessions[i].hs_state == HS_STATE_FREE)
+		if (isclr(sc->sc_sessions, i))
 			break;
 	if (i == sc->sc_maxses) {
 		retval = ENOMEM;
 		goto out;
+	}
 	for (c = cri; c != NULL; c = c->cri_next) {
 		switch (c->cri_alg) {
 		case CRYPTO_MD5:
 		case CRYPTO_SHA1:
 		case CRYPTO_MD5_HMAC_96:
 		case CRYPTO_SHA1_HMAC_96:
 			if (mac) {
 				goto out;
+			}
 			mac = 1;
 			break;
 		case CRYPTO_DES_CBC:
 		case CRYPTO_3DES_CBC:
 		case CRYPTO_AES_CBC:
 			cprng_fast(sc->sc_sessions[i].hs_iv,
 			    c->cri_alg == CRYPTO_AES_CBC ?
 				HIFN_AES_IV_LENGTH : HIFN_IV_LENGTH);
 			/*FALLTHROUGH*/
 		case CRYPTO_ARC4:
 			if (cry) {
 				goto out;
+			}
 			cry = 1;
 			break;
 #ifdef CRYPTO_LZS_COMP
 		case CRYPTO_LZS_COMP:
 			if (comp) {
 				goto out;
+			}
 			comp = 1;
 			break;
 @@ -2093,27 +2085,27 @@ hifn_newsession(void *arg, uint32_t *sid
 	if (mac == 0 && cry == 0 && comp == 0) {
 		goto out;
+	}
 	/*
 	 * XXX only want to support compression without chaining to
 	 * MAC/crypt engine right now
 	 */
 	if ((comp && mac) || (comp && cry)) {
 		goto out;
+	}
 	*sidp = HIFN_SID(device_unit(sc->sc_dv), i);
-	sc->sc_sessions[i].hs_state = HS_STATE_USED;
+	setbit(sc->sc_sessions, i);
 	retval = 0;
 out:
 	mutex_spin_exit(&sc->sc_mtx);
 	return retval;
+}
 /*
  * Deallocate a session.
  * XXX this routine should run a zero'd mac/encrypt key into context ram.
  * XXX to blow away any keys already stored there.
  */
 static int
 @@ -2123,55 +2115,52 @@ hifn_freesession(void *arg, uint64_t tid
 	int session;
 	uint32_t sid = ((uint32_t) tid) & 0xffffffff;
 	KASSERT(sc != NULL /*, ("hifn_freesession: null softc")*/);
 	if (sc == NULL)
 		return (EINVAL);
 	mutex_spin_enter(&sc->sc_mtx);
 	session = HIFN_SESSION(sid);
 	if (session >= sc->sc_maxses) {
 		mutex_spin_exit(&sc->sc_mtx);
 		return (EINVAL);
+	}
 	clrbit(sc->sc_sessions, session);
 	memset(&sc->sc_sessions[session], 0, sizeof(sc->sc_sessions[session]));
 	mutex_spin_exit(&sc->sc_mtx);
 	return (0);
+}
 static int
 hifn_process(void *arg, struct cryptop *crp, int hint)
+{
 	struct hifn_softc *sc = arg;
 	struct hifn_command *cmd = NULL;
-	int session, err, ivlen;
+	int session, err = 0, ivlen;
 	struct cryptodesc *crd1, *crd2, *maccrd, *enccrd;
 	if (crp == NULL || crp->crp_callback == NULL) {
 		hifnstats.hst_invalid++;
 		return (EINVAL);
+	}
 	mutex_spin_enter(&sc->sc_mtx);
 	session = HIFN_SESSION(crp->crp_sid);
 	if (session >= sc->sc_maxses) {
 	if (sc == NULL || session >= sc->sc_maxses) {
 		err = EINVAL;
 		goto errout;
+	}
-	cmd = (struct hifn_command *)malloc(sizeof(struct hifn_command),
+	cmd = malloc(sizeof(*cmd), M_DEVBUF, M_NOWAIT | M_ZERO);
 	    M_DEVBUF, M_NOWAIT|M_ZERO);
 	if (cmd == NULL) {
 		hifnstats.hst_nomem++;
 		err = ENOMEM;
 		goto errout;
+	}
 	if (crp->crp_flags & CRYPTO_F_IMBUF) {
 		cmd->srcu.src_m = (struct mbuf *)crp->crp_buf;
 		cmd->dstu.dst_m = (struct mbuf *)crp->crp_buf;
 	} else if (crp->crp_flags & CRYPTO_F_IOV) {
 		cmd->srcu.src_io = (struct uio *)crp->crp_buf;
 		cmd->dstu.dst_io = (struct uio *)crp->crp_buf;
 	} else {
 @@ -2193,27 +2182,27 @@ hifn_process(void *arg, struct cryptop *
 		    crd1->crd_alg == CRYPTO_MD5) {
 			maccrd = crd1;
 			enccrd = NULL;
 		} else if (crd1->crd_alg == CRYPTO_DES_CBC ||
 			   crd1->crd_alg == CRYPTO_3DES_CBC ||
 			   crd1->crd_alg == CRYPTO_AES_CBC ||
 			   crd1->crd_alg == CRYPTO_ARC4) {
 			if ((crd1->crd_flags & CRD_F_ENCRYPT) == 0)
 				cmd->base_masks |= HIFN_BASE_CMD_DECODE;
 			maccrd = NULL;
 			enccrd = crd1;
 #ifdef CRYPTO_LZS_COMP
 		} else if (crd1->crd_alg == CRYPTO_LZS_COMP) {
-		  return (hifn_compression(sc, crp, cmd));
+			return (hifn_compression(sc, crp, cmd));
 #endif
 		} else {
 			err = EINVAL;
 			goto errout;
+		}
 	} else {
 		if ((crd1->crd_alg == CRYPTO_MD5_HMAC_96 ||
 		     crd1->crd_alg == CRYPTO_SHA1_HMAC_96 ||
 		     crd1->crd_alg == CRYPTO_MD5 ||
 		     crd1->crd_alg == CRYPTO_SHA1) &&
 		    (crd2->crd_alg == CRYPTO_DES_CBC ||
 		     crd2->crd_alg == CRYPTO_3DES_CBC ||
 		     crd2->crd_alg == CRYPTO_AES_CBC ||
 @@ -2238,30 +2227,26 @@ hifn_process(void *arg, struct cryptop *
 			 * We cannot order the 7751 as requested
 			 */
 			err = EINVAL;
 			goto errout;
+		}
+	}
 	if (enccrd) {
 		cmd->enccrd = enccrd;
 		cmd->base_masks |= HIFN_BASE_CMD_CRYPT;
 		switch (enccrd->crd_alg) {
 		case CRYPTO_ARC4:
 			cmd->cry_masks |= HIFN_CRYPT_CMD_ALG_RC4;
 			if ((enccrd->crd_flags & CRD_F_ENCRYPT)
 			    != sc->sc_sessions[session].hs_prev_op)
 				sc->sc_sessions[session].hs_state =
 				    HS_STATE_USED;
 			break;
 		case CRYPTO_DES_CBC:
 			cmd->cry_masks |= HIFN_CRYPT_CMD_ALG_DES |
 			    HIFN_CRYPT_CMD_MODE_CBC |
 			    HIFN_CRYPT_CMD_NEW_IV;
 			break;
 		case CRYPTO_3DES_CBC:
 			cmd->cry_masks |= HIFN_CRYPT_CMD_ALG_3DES |
 			    HIFN_CRYPT_CMD_MODE_CBC |
 			    HIFN_CRYPT_CMD_NEW_IV;
 			break;
 		case CRYPTO_AES_CBC:
 			cmd->cry_masks |= HIFN_CRYPT_CMD_ALG_AES |
 @@ -2269,78 +2254,76 @@ hifn_process(void *arg, struct cryptop *
 			    HIFN_CRYPT_CMD_NEW_IV;
 			break;
 		default:
 			err = EINVAL;
 			goto errout;
+		}
 		if (enccrd->crd_alg != CRYPTO_ARC4) {
 			ivlen = ((enccrd->crd_alg == CRYPTO_AES_CBC) ?
 				HIFN_AES_IV_LENGTH : HIFN_IV_LENGTH);
 			if (enccrd->crd_flags & CRD_F_ENCRYPT) {
 				if (enccrd->crd_flags & CRD_F_IV_EXPLICIT)
 					memcpy(cmd->iv, enccrd->crd_iv, ivlen);
 				else
-					bcopy(sc->sc_sessions[session].hs_iv,
+					cprng_fast(cmd->iv, ivlen);
 					    cmd->iv, ivlen);
 				if ((enccrd->crd_flags & CRD_F_IV_PRESENT)
 				    == 0) {
 					if (crp->crp_flags & CRYPTO_F_IMBUF)
 						m_copyback(cmd->srcu.src_m,
 						    enccrd->crd_inject,
 						    ivlen, cmd->iv);
 					else if (crp->crp_flags & CRYPTO_F_IOV)
 						cuio_copyback(cmd->srcu.src_io,
 						    enccrd->crd_inject,
 						    ivlen, cmd->iv);
+				}
 			} else {
 				if (enccrd->crd_flags & CRD_F_IV_EXPLICIT)
 					memcpy(cmd->iv, enccrd->crd_iv, ivlen);
 				else if (crp->crp_flags & CRYPTO_F_IMBUF)
 					m_copydata(cmd->srcu.src_m,
 					    enccrd->crd_inject, ivlen, cmd->iv);
 				else if (crp->crp_flags & CRYPTO_F_IOV)
 					cuio_copydata(cmd->srcu.src_io,
-					    enccrd->crd_inject, ivlen, cmd->iv);
+					    enccrd->crd_inject,
 					    ivlen, cmd->iv);
+			}
+		}
 		cmd->ck = enccrd->crd_key;
 		cmd->cklen = enccrd->crd_klen >> 3;
 		cmd->cry_masks |= HIFN_CRYPT_CMD_NEW_KEY;
 		/*
 		 * Need to specify the size for the AES key in the masks.
 		 */
 		if ((cmd->cry_masks & HIFN_CRYPT_CMD_ALG_MASK) ==
 		    HIFN_CRYPT_CMD_ALG_AES) {
 			switch (cmd->cklen) {
 			case 16:
 				cmd->cry_masks |= HIFN_CRYPT_CMD_KSZ_128;
 				break;
 			case 24:
 				cmd->cry_masks |= HIFN_CRYPT_CMD_KSZ_192;
 				break;
 			case 32:
 				cmd->cry_masks |= HIFN_CRYPT_CMD_KSZ_256;
 				break;
 			default:
 				err = EINVAL;
 				goto errout;
+			}
+		}
 		if (sc->sc_sessions[session].hs_state == HS_STATE_USED)
 			cmd->cry_masks |= HIFN_CRYPT_CMD_NEW_KEY;
+	}
 	if (maccrd) {
 		cmd->maccrd = maccrd;
 		cmd->base_masks |= HIFN_BASE_CMD_MAC;
 		switch (maccrd->crd_alg) {
 		case CRYPTO_MD5:
 			cmd->mac_masks |= HIFN_MAC_CMD_ALG_MD5 |
 			    HIFN_MAC_CMD_RESULT | HIFN_MAC_CMD_MODE_HASH |
 			    HIFN_MAC_CMD_POS_IPSEC;
 			break;
 		case CRYPTO_MD5_HMAC_96:
 @@ -2350,68 +2333,63 @@ hifn_process(void *arg, struct cryptop *
 			break;
 		case CRYPTO_SHA1:
 			cmd->mac_masks |= HIFN_MAC_CMD_ALG_SHA1 |
 			    HIFN_MAC_CMD_RESULT | HIFN_MAC_CMD_MODE_HASH |
 			    HIFN_MAC_CMD_POS_IPSEC;
 			break;
 		case CRYPTO_SHA1_HMAC_96:
 			cmd->mac_masks |= HIFN_MAC_CMD_ALG_SHA1 |
 			    HIFN_MAC_CMD_RESULT | HIFN_MAC_CMD_MODE_HMAC |
 			    HIFN_MAC_CMD_POS_IPSEC | HIFN_MAC_CMD_TRUNC;
 			break;
+		}
-		if ((maccrd->crd_alg == CRYPTO_SHA1_HMAC_96 ||
+		if (maccrd->crd_alg == CRYPTO_SHA1_HMAC_96 ||
-		     maccrd->crd_alg == CRYPTO_MD5_HMAC_96) &&
+		     maccrd->crd_alg == CRYPTO_MD5_HMAC_96) {
 		    sc->sc_sessions[session].hs_state == HS_STATE_USED) {
 			cmd->mac_masks |= HIFN_MAC_CMD_NEW_KEY;
 			memcpy(cmd->mac, maccrd->crd_key, maccrd->crd_klen >> 3);
 			memset(cmd->mac + (maccrd->crd_klen >> 3), 0,
 			    HIFN_MAC_KEY_LENGTH - (maccrd->crd_klen >> 3));
+		}
+	}
 	cmd->crp = crp;
 	cmd->session_num = session;
 	cmd->softc = sc;
 	err = hifn_crypto(sc, cmd, crp, hint);
 	if (err == 0) {
 		if (enccrd)
 			sc->sc_sessions[session].hs_prev_op =
 				enccrd->crd_flags & CRD_F_ENCRYPT;
 		if (sc->sc_sessions[session].hs_state == HS_STATE_USED)
 			sc->sc_sessions[session].hs_state = HS_STATE_KEY;
 		mutex_spin_exit(&sc->sc_mtx);
 		return 0;
 	} else if (err == ERESTART) {
 		/*
 		 * There weren't enough resources to dispatch the request
 		 * to the part.  Notify the caller so they'll requeue this
 		 * request and resubmit it again soon.
 		 */
 #ifdef HIFN_DEBUG
 		if (hifn_debug)
 			printf("%s: requeue request\n", device_xname(sc->sc_dv));
 #endif
 		free(cmd, M_DEVBUF);
 		sc->sc_needwakeup |= CRYPTO_SYMQ;
 		mutex_spin_exit(&sc->sc_mtx);
 		return (err);
+	}
 errout:
-	if (cmd != NULL)
+	if (cmd != NULL) {
 		explicit_memset(cmd, 0, sizeof(*cmd));
 		free(cmd, M_DEVBUF);
+	}
 	if (err == EINVAL)
 		hifnstats.hst_invalid++;
 	else
 		hifnstats.hst_nomem++;
 	crp->crp_etype = err;
 	mutex_spin_exit(&sc->sc_mtx);
 	crypto_done(crp);
 	return (0);
+}
 static void
 hifn_abort(struct hifn_softc *sc)
+{
 @@ -2455,55 +2433,51 @@ hifn_abort(struct hifn_softc *sc)
 				/*
 				 * XXX should be EAGAIN, delayed until
 				 * after the reset.
 				 */
 				crp->crp_etype = ENOMEM;
 				bus_dmamap_unload(sc->sc_dmat, cmd->dst_map);
 				bus_dmamap_destroy(sc->sc_dmat, cmd->dst_map);
 			} else
 				crp->crp_etype = ENOMEM;
 			bus_dmamap_unload(sc->sc_dmat, cmd->src_map);
 			bus_dmamap_destroy(sc->sc_dmat, cmd->src_map);
 			explicit_memset(cmd, 0, sizeof(*cmd));
 			free(cmd, M_DEVBUF);
 			if (crp->crp_etype != EAGAIN)
 				crypto_done(crp);
+		}
 		if (++i == HIFN_D_RES_RSIZE)
 			i = 0;
 		u--;
+	}
 	dma->resk = i; dma->resu = u;
 	/* Force upload of key next time */
 	for (i = 0; i < sc->sc_maxses; i++)
 		if (sc->sc_sessions[i].hs_state == HS_STATE_KEY)
 			sc->sc_sessions[i].hs_state = HS_STATE_USED;
 	hifn_reset_board(sc, 1);
 	hifn_init_dma(sc);
 	hifn_init_pci_registers(sc);
+}
 static void
 hifn_callback(struct hifn_softc *sc, struct hifn_command *cmd, uint8_t *resbuf)
+{
 	struct hifn_dma *dma = sc->sc_dma;
 	struct cryptop *crp = cmd->crp;
 	struct cryptodesc *crd;
 	struct mbuf *m;
-	int totlen, i, u, ivlen;
+	int totlen, i, u;
 	if (cmd->src_map == cmd->dst_map)
 		bus_dmamap_sync(sc->sc_dmat, cmd->src_map,
 , cmd->src_map->dm_mapsize,
 		    BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
 	else {
 		bus_dmamap_sync(sc->sc_dmat, cmd->src_map,
 , cmd->src_map->dm_mapsize, BUS_DMASYNC_POSTWRITE);
 		bus_dmamap_sync(sc->sc_dmat, cmd->dst_map,
 , cmd->dst_map->dm_mapsize, BUS_DMASYNC_POSTREAD);
+	}
 	if (crp->crp_flags & CRYPTO_F_IMBUF) {
 @@ -2517,79 +2491,54 @@ hifn_callback(struct hifn_softc *sc, str
 				} else
 					totlen -= m->m_len;
+			}
 			cmd->dstu.dst_m->m_pkthdr.len =
 			    cmd->srcu.src_m->m_pkthdr.len;
 			m_freem(cmd->srcu.src_m);
+		}
+	}
 	if (cmd->sloplen != 0) {
 		if (crp->crp_flags & CRYPTO_F_IMBUF)
 			m_copyback((struct mbuf *)crp->crp_buf,
 			    cmd->src_map->dm_mapsize - cmd->sloplen,
-			    cmd->sloplen, (void *)&dma->slop[cmd->slopidx]);
+			    cmd->sloplen, &dma->slop[cmd->slopidx]);
 		else if (crp->crp_flags & CRYPTO_F_IOV)
 			cuio_copyback((struct uio *)crp->crp_buf,
 			    cmd->src_map->dm_mapsize - cmd->sloplen,
-			    cmd->sloplen, (void *)&dma->slop[cmd->slopidx]);
+			    cmd->sloplen, &dma->slop[cmd->slopidx]);
+	}
 	i = dma->dstk; u = dma->dstu;
 	while (u != 0) {
 		bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap,
 		    offsetof(struct hifn_dma, dstr[i]), sizeof(struct hifn_desc),
 		    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
 		if (dma->dstr[i].l & htole32(HIFN_D_VALID)) {
 			bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap,
 			    offsetof(struct hifn_dma, dstr[i]),
 			    sizeof(struct hifn_desc),
 			    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 			break;
+		}
 		if (++i == (HIFN_D_DST_RSIZE + 1))
 			i = 0;
 		else
 			u--;
+	}
 	dma->dstk = i; dma->dstu = u;
 	hifnstats.hst_obytes += cmd->dst_map->dm_mapsize;
 	if ((cmd->base_masks & (HIFN_BASE_CMD_CRYPT | HIFN_BASE_CMD_DECODE)) ==
 	    HIFN_BASE_CMD_CRYPT) {
 		for (crd = crp->crp_desc; crd; crd = crd->crd_next) {
 			if (crd->crd_alg != CRYPTO_DES_CBC &&
 			    crd->crd_alg != CRYPTO_3DES_CBC &&
 			    crd->crd_alg != CRYPTO_AES_CBC)
 				continue;
 			ivlen = ((crd->crd_alg == CRYPTO_AES_CBC) ?
 				HIFN_AES_IV_LENGTH : HIFN_IV_LENGTH);
 			if (crp->crp_flags & CRYPTO_F_IMBUF)
 				m_copydata((struct mbuf *)crp->crp_buf,
 				    crd->crd_skip + crd->crd_len - ivlen,
 				    ivlen,
 				    cmd->softc->sc_sessions[cmd->session_num].hs_iv);
 			else if (crp->crp_flags & CRYPTO_F_IOV) {
 				cuio_copydata((struct uio *)crp->crp_buf,
 				    crd->crd_skip + crd->crd_len - ivlen,
 				    ivlen,
 				    cmd->softc->sc_sessions[cmd->session_num].hs_iv);
 			/* XXX We do not handle contig data */
 			break;
 	if (cmd->base_masks & HIFN_BASE_CMD_MAC) {
 		uint8_t *macbuf;
 		macbuf = resbuf + sizeof(struct hifn_base_result);
 		if (cmd->base_masks & HIFN_BASE_CMD_COMP)
 			macbuf += sizeof(struct hifn_comp_result);
 		macbuf += sizeof(struct hifn_mac_result);
 		for (crd = crp->crp_desc; crd; crd = crd->crd_next) {
 			int len;
 			if (crd->crd_alg == CRYPTO_MD5)
 				len = 16;
 @@ -2606,26 +2555,27 @@ hifn_callback(struct hifn_softc *sc, str
 				    crd->crd_inject, len, macbuf);
 			else if ((crp->crp_flags & CRYPTO_F_IOV) && crp->crp_mac)
 				memcpy(crp->crp_mac, (void *)macbuf, len);
 			break;
+		}
+	}
 	if (cmd->src_map != cmd->dst_map) {
 		bus_dmamap_unload(sc->sc_dmat, cmd->dst_map);
 		bus_dmamap_destroy(sc->sc_dmat, cmd->dst_map);
+	}
 	bus_dmamap_unload(sc->sc_dmat, cmd->src_map);
 	bus_dmamap_destroy(sc->sc_dmat, cmd->src_map);
 	explicit_memset(cmd, 0, sizeof(*cmd));
 	free(cmd, M_DEVBUF);
 	crypto_done(crp);
+}
 #ifdef CRYPTO_LZS_COMP
 static int
 hifn_compression(struct hifn_softc *sc, struct cryptop *crp,
     struct hifn_command *cmd)
+{
 	struct cryptodesc *crd = crp->crp_desc;
 	int s, err = 0;
 @@ -2730,26 +2680,27 @@ hifn_compression(struct hifn_softc *sc,
 	return (0);
 fail:
 	if (cmd->dst_map != NULL) {
 		if (cmd->dst_map->dm_nsegs > 0)
 			bus_dmamap_unload(sc->sc_dmat, cmd->dst_map);
 		bus_dmamap_destroy(sc->sc_dmat, cmd->dst_map);
+	}
 	if (cmd->src_map != NULL) {
 		if (cmd->src_map->dm_nsegs > 0)
 			bus_dmamap_unload(sc->sc_dmat, cmd->src_map);
 		bus_dmamap_destroy(sc->sc_dmat, cmd->src_map);
+	}
 	explicit_memset(cmd, 0, sizeof(*cmd));
 	free(cmd, M_DEVBUF);
 	if (err == EINVAL)
 		hifnstats.hst_invalid++;
 	else
 		hifnstats.hst_nomem++;
 	crp->crp_etype = err;
 	crypto_done(crp);
 	return (0);
+}
 static int
 hifn_compress_enter(struct hifn_softc *sc, struct hifn_command *cmd)
+{
 @@ -2779,34 +2730,33 @@ hifn_compress_enter(struct hifn_softc *s
 	/* .p for command/result already set */
 	dma->cmdr[cmdi].l = htole32(cmdlen | HIFN_D_VALID | HIFN_D_LAST |
 	    HIFN_D_MASKDONEIRQ);
 	HIFN_CMDR_SYNC(sc, cmdi,
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	dma->cmdu++;
 	if (sc->sc_c_busy == 0) {
 		WRITE_REG_1(sc, HIFN_1_DMA_CSR, HIFN_DMACSR_C_CTRL_ENA);
 		sc->sc_c_busy = 1;
 		SET_LED(sc, HIFN_MIPSRST_LED0);
+	}
 	/*
-	 * We don't worry about missing an interrupt (which a "command wait"
+	 * Always enable the command wait interrupt.  We are obviously
-	 * interrupt salvages us from), unless there is more than one command
+	 * missing an interrupt or two somewhere. Enabling the command wait
-	 * in the queue.
+	 * interrupt will guarantee we get called periodically until all
 	 * of the queues are drained and thus work around this.
 	 */
-	if (dma->cmdu > 1) {
+	sc->sc_dmaier |= HIFN_DMAIER_C_WAIT;
-		sc->sc_dmaier |= HIFN_DMAIER_C_WAIT;
+	WRITE_REG_1(sc, HIFN_1_DMA_IER, sc->sc_dmaier);
 		WRITE_REG_1(sc, HIFN_1_DMA_IER, sc->sc_dmaier);
 	hifnstats.hst_ipackets++;
 	hifnstats.hst_ibytes += cmd->src_map->dm_mapsize;
 	hifn_dmamap_load_src(sc, cmd);
 	if (sc->sc_s_busy == 0) {
 		WRITE_REG_1(sc, HIFN_1_DMA_CSR, HIFN_DMACSR_S_CTRL_ENA);
 		sc->sc_s_busy = 1;
 		SET_LED(sc, HIFN_MIPSRST_LED1);
+	}
 	/*
 	 * Unlike other descriptors, we don't mask done interrupt from
 @@ -2943,86 +2893,87 @@ hifn_callback_comp(struct hifn_softc *sc
 	if (m->m_flags & M_PKTHDR)
 		m->m_pkthdr.len = olen;
 	crp->crp_buf = (void *)m;
 	for (; m != NULL; m = m->m_next) {
 		if (olen >= m->m_len)
 			olen -= m->m_len;
 		else {
 			m->m_len = olen;
 			olen = 0;
+		}
+	}
 	m_freem(cmd->srcu.src_m);
 	explicit_memset(cmd, 0, sizeof(*cmd));
 	free(cmd, M_DEVBUF);
 	crp->crp_etype = 0;
 	crypto_done(crp);
 	return;
 out:
 	if (cmd->dst_map != NULL) {
 		if (cmd->src_map->dm_nsegs != 0)
 			bus_dmamap_unload(sc->sc_dmat, cmd->src_map);
 		bus_dmamap_destroy(sc->sc_dmat, cmd->dst_map);
+	}
 	if (cmd->src_map != NULL) {
 		if (cmd->src_map->dm_nsegs != 0)
 			bus_dmamap_unload(sc->sc_dmat, cmd->src_map);
 		bus_dmamap_destroy(sc->sc_dmat, cmd->src_map);
+	}
-	if (cmd->dstu.dst_m != NULL)
+	m_freem(cmd->dstu.dst_m);
-		m_freem(cmd->dstu.dst_m);
+	explicit_memset(cmd, 0, sizeof(*cmd));
 	free(cmd, M_DEVBUF);
 	crp->crp_etype = err;
 	crypto_done(crp);
+}
 static struct mbuf *
 hifn_mkmbuf_chain(int totlen, struct mbuf *mtemplate)
+{
 	int len;
 	struct mbuf *m, *m0, *mlast;
 	if (mtemplate->m_flags & M_PKTHDR) {
 		len = MHLEN;
 		MGETHDR(m0, M_DONTWAIT, MT_DATA);
 	} else {
 		len = MLEN;
 		MGET(m0, M_DONTWAIT, MT_DATA);
+	}
 	if (m0 == NULL)
 		return (NULL);
 	if (len == MHLEN)
 		m_copy_pkthdr(m0, mtemplate);
 	MCLGET(m0, M_DONTWAIT);
 	if (!(m0->m_flags & M_EXT)) {
- 		m_freem(m0);
+		m_freem(m0);
 		return (NULL);
+	}
 	len = MCLBYTES;
 	totlen -= len;
 	m0->m_pkthdr.len = m0->m_len = len;
 	mlast = m0;
 	while (totlen > 0) {
 		MGET(m, M_DONTWAIT, MT_DATA);
 		if (m == NULL) {
 			m_freem(m0);
 			return (NULL);
+		}
 		MCLGET(m, M_DONTWAIT);
 		if (!(m->m_flags & M_EXT)) {
-			m_freem(m);
+			m_free(m);
 			m_freem(m0);
 			return (NULL);
+		}
 		len = MCLBYTES;
 		m->m_len = len;
 		if (m0->m_flags & M_PKTHDR)
 			m0->m_pkthdr.len += len;
 		totlen -= len;
 		mlast->m_next = m;
 		mlast = m;
+	}

 @@ -1,15 +1,15 @@
-/*	$NetBSD: hifn7751var.h,v 1.14 2020/05/17 00:51:27 riastradh Exp $	*/
+/*	$NetBSD: hifn7751var.h,v 1.15 2020/05/17 00:52:31 riastradh Exp $	*/
-/*	$OpenBSD: hifn7751var.h,v 1.48 2003/02/24 20:36:02 jason Exp $	*/
+/*	$OpenBSD: hifn7751var.h,v 1.54 2020/01/11 21:34:04 cheloha Exp $	*/
 /*
  * Invertex AEON / Hifn 7751 driver
  * Copyright (c) 1999 Invertex Inc. All rights reserved.
  * Copyright (c) 1999 Theo de Raadt
  * Copyright (c) 2000-2001 Network Security Technologies, Inc.
  *			http://www.netsec.net
+ *
  * Please send any comments, feedback, bug-fixes, or feature requests to
  * software@invertex.com.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 @@ -52,28 +52,28 @@
  */
 #define	HIFN_D_CMD_RSIZE	24	/* command descriptors */
 #define	HIFN_D_SRC_RSIZE	80	/* source descriptors */
 #define	HIFN_D_DST_RSIZE	80	/* destination descriptors */
 #define	HIFN_D_RES_RSIZE	24	/* result descriptors */
 /*
  *  Length values for cryptography
  */
 #define HIFN_DES_KEY_LENGTH		8
 #define HIFN_3DES_KEY_LENGTH		24
 #define HIFN_MAX_CRYPT_KEY_LENGTH	HIFN_3DES_KEY_LENGTH
 #define HIFN_IV_LENGTH			8
-#define	HIFN_AES_IV_LENGTH		16
+#define HIFN_AES_IV_LENGTH		16
-#define HIFN_MAX_IV_LENGTH		HIFN_AES_IV_LENGTH
+#define	HIFN_MAX_IV_LENGTH		HIFN_AES_IV_LENGTH
 /*
  *  Length values for authentication
  */
 #define HIFN_MAC_KEY_LENGTH		64
 #define HIFN_MD5_LENGTH			16
 #define HIFN_SHA1_LENGTH		20
 #define HIFN_MAC_TRUNC_LENGTH		12
 #define MAX_SCATTER 64
 /*
  * Data structure to hold all 4 rings and any other ring related data.
 @@ -95,37 +95,26 @@ struct hifn_dma {
 	u_int32_t		slop[HIFN_D_CMD_RSIZE];
 	u_int64_t		test_src, test_dst;
 	/*
 	 *  Our current positions for insertion and removal from the descriptor
 	 *  rings.
 	 */
 	int			cmdi, srci, dsti, resi;
 	volatile int		cmdu, srcu, dstu, resu;
 	int			cmdk, srck, dstk, resk;
 };
 struct hifn_session {
 	int hs_state;
 	int hs_prev_op; /* XXX collapse into hs_flags? */
 	u_int8_t hs_iv[HIFN_MAX_IV_LENGTH];
 };
 /* We use a state machine on sessions */
 #define	HS_STATE_FREE	0		/* unused session entry */
 #define	HS_STATE_USED	1		/* allocated, but key not on card */
 #define	HS_STATE_KEY	2		/* allocated and key is on card */
 #define	HIFN_RING_SYNC(sc, r, i, f)					\
 	bus_dmamap_sync((sc)->sc_dmat, (sc)->sc_dmamap,		\
 	    offsetof(struct hifn_dma, r[i]), sizeof(struct hifn_desc), (f))
 #define	HIFN_CMDR_SYNC(sc, i, f)	HIFN_RING_SYNC((sc), cmdr, (i), (f))
 #define	HIFN_RESR_SYNC(sc, i, f)	HIFN_RING_SYNC((sc), resr, (i), (f))
 #define	HIFN_SRCR_SYNC(sc, i, f)	HIFN_RING_SYNC((sc), srcr, (i), (f))
 #define	HIFN_DSTR_SYNC(sc, i, f)	HIFN_RING_SYNC((sc), dstr, (i), (f))
 #define	HIFN_CMD_SYNC(sc, i, f)						\
 	bus_dmamap_sync((sc)->sc_dmat, (sc)->sc_dmamap,		\
 	    offsetof(struct hifn_dma, command_bufs[(i)][0]),		\
 	    HIFN_MAX_COMMAND, (f))
 @@ -145,61 +134,60 @@ struct hifn_softc {
 	u_int32_t	sc_drammodel;	/* 1=dram, 0=sram */
 	bus_space_handle_t	sc_sh0, sc_sh1;
 	bus_space_tag_t		sc_st0, sc_st1;
 	bus_size_t		sc_iosz0, sc_iosz1;
 	bus_dma_tag_t		sc_dmat;
 	struct hifn_dma *sc_dma;
 	bus_dmamap_t sc_dmamap;
 	bus_dma_segment_t sc_dmasegs[1];
 	int sc_dmansegs;
 	int32_t sc_cid;
 	int sc_maxses;
 	int sc_nsessions;
 	int sc_ramsize;
 	int sc_flags;
-#define	HIFN_HAS_RNG		0x01
+#define	HIFN_HAS_RNG		0x01	/* includes random number generator */
-#define	HIFN_HAS_PUBLIC		0x02
+#define	HIFN_HAS_PUBLIC		0x02	/* includes public key support */
-#define	HIFN_HAS_AES		0x04	/* includes AES support */
+#define	HIFN_IS_7811		0x04	/* Hifn 7811 part */
-#define	HIFN_IS_7811		0x08	/* Hifn 7811 part */
+#define	HIFN_NO_BURSTWRITE	0x08	/* can't handle PCI burst writes */
-#define	HIFN_IS_7956		0x10	/* Hifn 7956/7955 don't have SDRAM */
+#define	HIFN_HAS_LEDS		0x10	/* Has LEDs to blink */
-#define	HIFN_NO_BURSTWRITE	0x20
+#define	HIFN_HAS_AES		0x20	/* includes AES support */
-#define	HIFN_HAS_LEDS		0x40
+#define	HIFN_IS_7956		0x40	/* Hifn 7955/7956 part */
 #define HIFN_RNG_BITSPER	17	/* From Hifn 6500 paper: 0.06 bits
 					   of entropy per RNG register bit
 					   worst-case */
 	struct callout		sc_rngto;	/* rng timeout */
 	struct callout		sc_tickto;	/* led-clear timeout */
-	krndsource_t	sc_rnd_source;
+	krndsource_t		sc_rnd_source;
 	int			sc_rnghz;
 	int			sc_rng_need;	/* how many bytes wanted */
 	int			sc_c_busy;	/* command ring busy */
 	int			sc_s_busy;	/* source data ring busy */
 	int			sc_d_busy;	/* destination data ring busy */
 	int			sc_r_busy;	/* result ring busy */
 	int			sc_active;	/* for initial countdown */
 	int			sc_needwakeup;	/* ops q'd wating on resources */
-	int			sc_curbatch;	/* # ops submitted w/o int */
+	uint8_t			sc_sessions[2048/NBBY];
 	int			sc_suspended;
 	struct hifn_session sc_sessions[2048];
 	pci_chipset_tag_t sc_pci_pc;
 	pcitag_t sc_pci_tag;
 	bus_size_t sc_waw_lastreg;
 	int sc_waw_lastgroup;
 	kmutex_t		sc_mtx;
 };
 #define HIFN_RNG_BITSPER	17	/* From Hifn 6500 paper: 0.06 bits
 					   of entropy per RNG register bit
 					   worst-case */
 #define WRITE_REG_0(sc,reg,val)		hifn_write_4((sc), 0, (reg), (val))
 #define WRITE_REG_1(sc,reg,val)		hifn_write_4((sc), 1, (reg), (val))
 #define	READ_REG_0(sc,reg)		hifn_read_4((sc), 0, (reg))
 #define	READ_REG_1(sc,reg)		hifn_read_4((sc), 1, (reg))
 #define	SET_LED(sc,v)							\
 	if (sc->sc_flags & HIFN_HAS_LEDS)				\
 		WRITE_REG_1(sc, HIFN_1_7811_MIPSRST,			\
 		    READ_REG_1(sc, HIFN_1_7811_MIPSRST) | (v))
 #define	CLR_LED(sc,v)							\
 	if (sc->sc_flags & HIFN_HAS_LEDS)				\
 		WRITE_REG_1(sc, HIFN_1_7811_MIPSRST,			\
 		    READ_REG_1(sc, HIFN_1_7811_MIPSRST) & ~(v))