xref: /freebsd/sys/crypto/ccp/ccp.c (revision 9768746b) 
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 2017 Chelsio Communications, Inc.
5  * Copyright (c) 2017 Conrad Meyer <cem@FreeBSD.org>
6  * All rights reserved.
7  * Largely borrowed from ccr(4), Written by: John Baldwin <jhb@FreeBSD.org>
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28  * SUCH DAMAGE.
29  */
30 
31 #include <sys/cdefs.h>
32 __FBSDID("$FreeBSD$");
33 
34 #include "opt_ddb.h"
35 
36 #include <sys/param.h>
37 #include <sys/bus.h>
38 #include <sys/lock.h>
39 #include <sys/kernel.h>
40 #include <sys/malloc.h>
41 #include <sys/mutex.h>
42 #include <sys/module.h>
43 #include <sys/random.h>
44 #include <sys/sglist.h>
45 #include <sys/sysctl.h>
46 
47 #ifdef DDB
48 #include <ddb/ddb.h>
49 #endif
50 
51 #include <dev/pci/pcivar.h>
52 
53 #include <dev/random/randomdev.h>
54 
55 #include <opencrypto/cryptodev.h>
56 #include <opencrypto/xform.h>
57 
58 #include "cryptodev_if.h"
59 
60 #include "ccp.h"
61 #include "ccp_hardware.h"
62 
63 MALLOC_DEFINE(M_CCP, "ccp", "AMD CCP crypto");
64 
65 /*
66  * Need a global softc available for garbage random_source API, which lacks any
67  * context pointer.  It's also handy for debugging.
68  */
69 struct ccp_softc *g_ccp_softc;
70 
71 bool g_debug_print = false;
72 SYSCTL_BOOL(_hw_ccp, OID_AUTO, debug, CTLFLAG_RWTUN, &g_debug_print, 0,
73     "Set to enable debugging log messages");
74 
75 static struct pciid {
76 	uint32_t devid;
77 	const char *desc;
78 } ccp_ids[] = {
79 	{ 0x14561022, "AMD CCP-5a" },
80 	{ 0x14681022, "AMD CCP-5b" },
81 	{ 0x15df1022, "AMD CCP-5a" },
82 };
83 
84 static struct random_source random_ccp = {
85 	.rs_ident = "AMD CCP TRNG",
86 	.rs_source = RANDOM_PURE_CCP,
87 	.rs_read = random_ccp_read,
88 };
89 
90 /*
91  * ccp_populate_sglist() generates a scatter/gather list that covers the entire
92  * crypto operation buffer.
93  */
94 static int
95 ccp_populate_sglist(struct sglist *sg, struct crypto_buffer *cb)
96 {
97 	int error;
98 
99 	sglist_reset(sg);
100 	switch (cb->cb_type) {
101 	case CRYPTO_BUF_MBUF:
102 		error = sglist_append_mbuf(sg, cb->cb_mbuf);
103 		break;
104 	case CRYPTO_BUF_SINGLE_MBUF:
105 		error = sglist_append_single_mbuf(sg, cb->cb_mbuf);
106 		break;
107 	case CRYPTO_BUF_UIO:
108 		error = sglist_append_uio(sg, cb->cb_uio);
109 		break;
110 	case CRYPTO_BUF_CONTIG:
111 		error = sglist_append(sg, cb->cb_buf, cb->cb_buf_len);
112 		break;
113 	case CRYPTO_BUF_VMPAGE:
114 		error = sglist_append_vmpages(sg, cb->cb_vm_page,
115 		    cb->cb_vm_page_offset, cb->cb_vm_page_len);
116 		break;
117 	default:
118 		error = EINVAL;
119 	}
120 	return (error);
121 }
122 
123 static int
124 ccp_probe(device_t dev)
125 {
126 	struct pciid *ip;
127 	uint32_t id;
128 
129 	id = pci_get_devid(dev);
130 	for (ip = ccp_ids; ip < &ccp_ids[nitems(ccp_ids)]; ip++) {
131 		if (id == ip->devid) {
132 			device_set_desc(dev, ip->desc);
133 			return (0);
134 		}
135 	}
136 	return (ENXIO);
137 }
138 
139 static void
140 ccp_initialize_queues(struct ccp_softc *sc)
141 {
142 	struct ccp_queue *qp;
143 	size_t i;
144 
145 	for (i = 0; i < nitems(sc->queues); i++) {
146 		qp = &sc->queues[i];
147 
148 		qp->cq_softc = sc;
149 		qp->cq_qindex = i;
150 		mtx_init(&qp->cq_lock, "ccp queue", NULL, MTX_DEF);
151 		/* XXX - arbitrarily chosen sizes */
152 		qp->cq_sg_crp = sglist_alloc(32, M_WAITOK);
153 		/* Two more SGEs than sg_crp to accommodate ipad. */
154 		qp->cq_sg_ulptx = sglist_alloc(34, M_WAITOK);
155 		qp->cq_sg_dst = sglist_alloc(2, M_WAITOK);
156 	}
157 }
158 
159 static void
160 ccp_free_queues(struct ccp_softc *sc)
161 {
162 	struct ccp_queue *qp;
163 	size_t i;
164 
165 	for (i = 0; i < nitems(sc->queues); i++) {
166 		qp = &sc->queues[i];
167 
168 		mtx_destroy(&qp->cq_lock);
169 		sglist_free(qp->cq_sg_crp);
170 		sglist_free(qp->cq_sg_ulptx);
171 		sglist_free(qp->cq_sg_dst);
172 	}
173 }
174 
175 static int
176 ccp_attach(device_t dev)
177 {
178 	struct ccp_softc *sc;
179 	int error;
180 
181 	sc = device_get_softc(dev);
182 	sc->dev = dev;
183 
184 	sc->cid = crypto_get_driverid(dev, sizeof(struct ccp_session),
185 	    CRYPTOCAP_F_HARDWARE);
186 	if (sc->cid < 0) {
187 		device_printf(dev, "could not get crypto driver id\n");
188 		return (ENXIO);
189 	}
190 
191 	error = ccp_hw_attach(dev);
192 	if (error != 0)
193 		return (error);
194 
195 	mtx_init(&sc->lock, "ccp", NULL, MTX_DEF);
196 
197 	ccp_initialize_queues(sc);
198 
199 	if (g_ccp_softc == NULL) {
200 		g_ccp_softc = sc;
201 		if ((sc->hw_features & VERSION_CAP_TRNG) != 0)
202 			random_source_register(&random_ccp);
203 	}
204 
205 	return (0);
206 }
207 
208 static int
209 ccp_detach(device_t dev)
210 {
211 	struct ccp_softc *sc;
212 
213 	sc = device_get_softc(dev);
214 
215 	mtx_lock(&sc->lock);
216 	sc->detaching = true;
217 	mtx_unlock(&sc->lock);
218 
219 	crypto_unregister_all(sc->cid);
220 	if (g_ccp_softc == sc && (sc->hw_features & VERSION_CAP_TRNG) != 0)
221 		random_source_deregister(&random_ccp);
222 
223 	ccp_hw_detach(dev);
224 	ccp_free_queues(sc);
225 
226 	if (g_ccp_softc == sc)
227 		g_ccp_softc = NULL;
228 
229 	mtx_destroy(&sc->lock);
230 	return (0);
231 }
232 
233 static void
234 ccp_init_hmac_digest(struct ccp_session *s, const char *key, int klen)
235 {
236 	union authctx auth_ctx;
237 	const struct auth_hash *axf;
238 	u_int i;
239 
240 	/*
241 	 * If the key is larger than the block size, use the digest of
242 	 * the key as the key instead.
243 	 */
244 	axf = s->hmac.auth_hash;
245 	if (klen > axf->blocksize) {
246 		axf->Init(&auth_ctx);
247 		axf->Update(&auth_ctx, key, klen);
248 		axf->Final(s->hmac.ipad, &auth_ctx);
249 		explicit_bzero(&auth_ctx, sizeof(auth_ctx));
250 		klen = axf->hashsize;
251 	} else
252 		memcpy(s->hmac.ipad, key, klen);
253 
254 	memset(s->hmac.ipad + klen, 0, axf->blocksize - klen);
255 	memcpy(s->hmac.opad, s->hmac.ipad, axf->blocksize);
256 
257 	for (i = 0; i < axf->blocksize; i++) {
258 		s->hmac.ipad[i] ^= HMAC_IPAD_VAL;
259 		s->hmac.opad[i] ^= HMAC_OPAD_VAL;
260 	}
261 }
262 
263 static bool
264 ccp_aes_check_keylen(int alg, int klen)
265 {
266 
267 	switch (klen * 8) {
268 	case 128:
269 	case 192:
270 		if (alg == CRYPTO_AES_XTS)
271 			return (false);
272 		break;
273 	case 256:
274 		break;
275 	case 512:
276 		if (alg != CRYPTO_AES_XTS)
277 			return (false);
278 		break;
279 	default:
280 		return (false);
281 	}
282 	return (true);
283 }
284 
285 static void
286 ccp_aes_setkey(struct ccp_session *s, int alg, const void *key, int klen)
287 {
288 	unsigned kbits;
289 
290 	if (alg == CRYPTO_AES_XTS)
291 		kbits = (klen / 2) * 8;
292 	else
293 		kbits = klen * 8;
294 
295 	switch (kbits) {
296 	case 128:
297 		s->blkcipher.cipher_type = CCP_AES_TYPE_128;
298 		break;
299 	case 192:
300 		s->blkcipher.cipher_type = CCP_AES_TYPE_192;
301 		break;
302 	case 256:
303 		s->blkcipher.cipher_type = CCP_AES_TYPE_256;
304 		break;
305 	default:
306 		panic("should not get here");
307 	}
308 
309 	s->blkcipher.key_len = klen;
310 	memcpy(s->blkcipher.enckey, key, s->blkcipher.key_len);
311 }
312 
313 static bool
314 ccp_auth_supported(struct ccp_softc *sc,
315     const struct crypto_session_params *csp)
316 {
317 
318 	if ((sc->hw_features & VERSION_CAP_SHA) == 0)
319 		return (false);
320 	switch (csp->csp_auth_alg) {
321 	case CRYPTO_SHA1_HMAC:
322 	case CRYPTO_SHA2_256_HMAC:
323 	case CRYPTO_SHA2_384_HMAC:
324 	case CRYPTO_SHA2_512_HMAC:
325 		if (csp->csp_auth_key == NULL)
326 			return (false);
327 		break;
328 	default:
329 		return (false);
330 	}
331 	return (true);
332 }
333 
334 static bool
335 ccp_cipher_supported(struct ccp_softc *sc,
336     const struct crypto_session_params *csp)
337 {
338 
339 	if ((sc->hw_features & VERSION_CAP_AES) == 0)
340 		return (false);
341 	switch (csp->csp_cipher_alg) {
342 	case CRYPTO_AES_CBC:
343 		if (csp->csp_ivlen != AES_BLOCK_LEN)
344 			return (false);
345 		break;
346 	case CRYPTO_AES_ICM:
347 		if (csp->csp_ivlen != AES_BLOCK_LEN)
348 			return (false);
349 		break;
350 	case CRYPTO_AES_XTS:
351 		if (csp->csp_ivlen != AES_XTS_IV_LEN)
352 			return (false);
353 		break;
354 	default:
355 		return (false);
356 	}
357 	return (ccp_aes_check_keylen(csp->csp_cipher_alg,
358 	    csp->csp_cipher_klen));
359 }
360 
361 static int
362 ccp_probesession(device_t dev, const struct crypto_session_params *csp)
363 {
364 	struct ccp_softc *sc;
365 
366 	if (csp->csp_flags != 0)
367 		return (EINVAL);
368 	sc = device_get_softc(dev);
369 	switch (csp->csp_mode) {
370 	case CSP_MODE_DIGEST:
371 		if (!ccp_auth_supported(sc, csp))
372 			return (EINVAL);
373 		break;
374 	case CSP_MODE_CIPHER:
375 		if (!ccp_cipher_supported(sc, csp))
376 			return (EINVAL);
377 		break;
378 	case CSP_MODE_AEAD:
379 		switch (csp->csp_cipher_alg) {
380 		case CRYPTO_AES_NIST_GCM_16:
381 			if ((sc->hw_features & VERSION_CAP_AES) == 0)
382 				return (EINVAL);
383 			break;
384 		default:
385 			return (EINVAL);
386 		}
387 		break;
388 	case CSP_MODE_ETA:
389 		if (!ccp_auth_supported(sc, csp) ||
390 		    !ccp_cipher_supported(sc, csp))
391 			return (EINVAL);
392 		break;
393 	default:
394 		return (EINVAL);
395 	}
396 
397 	return (CRYPTODEV_PROBE_HARDWARE);
398 }
399 
400 static int
401 ccp_newsession(device_t dev, crypto_session_t cses,
402     const struct crypto_session_params *csp)
403 {
404 	struct ccp_softc *sc;
405 	struct ccp_session *s;
406 	const struct auth_hash *auth_hash;
407 	enum ccp_aes_mode cipher_mode;
408 	unsigned auth_mode;
409 	unsigned q;
410 
411 	/* XXX reconcile auth_mode with use by ccp_sha */
412 	switch (csp->csp_auth_alg) {
413 	case CRYPTO_SHA1_HMAC:
414 		auth_hash = &auth_hash_hmac_sha1;
415 		auth_mode = SHA1;
416 		break;
417 	case CRYPTO_SHA2_256_HMAC:
418 		auth_hash = &auth_hash_hmac_sha2_256;
419 		auth_mode = SHA2_256;
420 		break;
421 	case CRYPTO_SHA2_384_HMAC:
422 		auth_hash = &auth_hash_hmac_sha2_384;
423 		auth_mode = SHA2_384;
424 		break;
425 	case CRYPTO_SHA2_512_HMAC:
426 		auth_hash = &auth_hash_hmac_sha2_512;
427 		auth_mode = SHA2_512;
428 		break;
429 	default:
430 		auth_hash = NULL;
431 		auth_mode = 0;
432 		break;
433 	}
434 
435 	switch (csp->csp_cipher_alg) {
436 	case CRYPTO_AES_CBC:
437 		cipher_mode = CCP_AES_MODE_CBC;
438 		break;
439 	case CRYPTO_AES_ICM:
440 		cipher_mode = CCP_AES_MODE_CTR;
441 		break;
442 	case CRYPTO_AES_NIST_GCM_16:
443 		cipher_mode = CCP_AES_MODE_GCTR;
444 		break;
445 	case CRYPTO_AES_XTS:
446 		cipher_mode = CCP_AES_MODE_XTS;
447 		break;
448 	default:
449 		cipher_mode = CCP_AES_MODE_ECB;
450 		break;
451 	}
452 
453 	sc = device_get_softc(dev);
454 	mtx_lock(&sc->lock);
455 	if (sc->detaching) {
456 		mtx_unlock(&sc->lock);
457 		return (ENXIO);
458 	}
459 
460 	s = crypto_get_driver_session(cses);
461 
462 	/* Just grab the first usable queue for now. */
463 	for (q = 0; q < nitems(sc->queues); q++)
464 		if ((sc->valid_queues & (1 << q)) != 0)
465 			break;
466 	if (q == nitems(sc->queues)) {
467 		mtx_unlock(&sc->lock);
468 		return (ENXIO);
469 	}
470 	s->queue = q;
471 
472 	switch (csp->csp_mode) {
473 	case CSP_MODE_AEAD:
474 		s->mode = GCM;
475 		break;
476 	case CSP_MODE_ETA:
477 		s->mode = AUTHENC;
478 		break;
479 	case CSP_MODE_DIGEST:
480 		s->mode = HMAC;
481 		break;
482 	case CSP_MODE_CIPHER:
483 		s->mode = BLKCIPHER;
484 		break;
485 	}
486 
487 	if (s->mode == GCM) {
488 		if (csp->csp_auth_mlen == 0)
489 			s->gmac.hash_len = AES_GMAC_HASH_LEN;
490 		else
491 			s->gmac.hash_len = csp->csp_auth_mlen;
492 	} else if (auth_hash != NULL) {
493 		s->hmac.auth_hash = auth_hash;
494 		s->hmac.auth_mode = auth_mode;
495 		if (csp->csp_auth_mlen == 0)
496 			s->hmac.hash_len = auth_hash->hashsize;
497 		else
498 			s->hmac.hash_len = csp->csp_auth_mlen;
499 		ccp_init_hmac_digest(s, csp->csp_auth_key, csp->csp_auth_klen);
500 	}
501 	if (cipher_mode != CCP_AES_MODE_ECB) {
502 		s->blkcipher.cipher_mode = cipher_mode;
503 		if (csp->csp_cipher_key != NULL)
504 			ccp_aes_setkey(s, csp->csp_cipher_alg,
505 			    csp->csp_cipher_key, csp->csp_cipher_klen);
506 	}
507 
508 	s->active = true;
509 	mtx_unlock(&sc->lock);
510 
511 	return (0);
512 }
513 
514 static void
515 ccp_freesession(device_t dev, crypto_session_t cses)
516 {
517 	struct ccp_session *s;
518 
519 	s = crypto_get_driver_session(cses);
520 
521 	if (s->pending != 0)
522 		device_printf(dev,
523 		    "session %p freed with %d pending requests\n", s,
524 		    s->pending);
525 	s->active = false;
526 }
527 
528 static int
529 ccp_process(device_t dev, struct cryptop *crp, int hint)
530 {
531 	const struct crypto_session_params *csp;
532 	struct ccp_softc *sc;
533 	struct ccp_queue *qp;
534 	struct ccp_session *s;
535 	int error;
536 	bool qpheld;
537 
538 	qpheld = false;
539 	qp = NULL;
540 
541 	csp = crypto_get_params(crp->crp_session);
542 	s = crypto_get_driver_session(crp->crp_session);
543 	sc = device_get_softc(dev);
544 	mtx_lock(&sc->lock);
545 	qp = &sc->queues[s->queue];
546 	mtx_unlock(&sc->lock);
547 	error = ccp_queue_acquire_reserve(qp, 1 /* placeholder */, M_NOWAIT);
548 	if (error != 0)
549 		goto out;
550 	qpheld = true;
551 
552 	error = ccp_populate_sglist(qp->cq_sg_crp, &crp->crp_buf);
553 	if (error != 0)
554 		goto out;
555 
556 	if (crp->crp_auth_key != NULL) {
557 		KASSERT(s->hmac.auth_hash != NULL, ("auth key without HMAC"));
558 		ccp_init_hmac_digest(s, crp->crp_auth_key, csp->csp_auth_klen);
559 	}
560 	if (crp->crp_cipher_key != NULL)
561 		ccp_aes_setkey(s, csp->csp_cipher_alg, crp->crp_cipher_key,
562 		    csp->csp_cipher_klen);
563 
564 	switch (s->mode) {
565 	case HMAC:
566 		if (s->pending != 0) {
567 			error = EAGAIN;
568 			break;
569 		}
570 		error = ccp_hmac(qp, s, crp);
571 		break;
572 	case BLKCIPHER:
573 		if (s->pending != 0) {
574 			error = EAGAIN;
575 			break;
576 		}
577 		error = ccp_blkcipher(qp, s, crp);
578 		break;
579 	case AUTHENC:
580 		if (s->pending != 0) {
581 			error = EAGAIN;
582 			break;
583 		}
584 		error = ccp_authenc(qp, s, crp);
585 		break;
586 	case GCM:
587 		if (s->pending != 0) {
588 			error = EAGAIN;
589 			break;
590 		}
591 		error = ccp_gcm(qp, s, crp);
592 		break;
593 	}
594 
595 	if (error == 0)
596 		s->pending++;
597 
598 out:
599 	if (qpheld) {
600 		if (error != 0) {
601 			/*
602 			 * Squash EAGAIN so callers don't uselessly and
603 			 * expensively retry if the ring was full.
604 			 */
605 			if (error == EAGAIN)
606 				error = ENOMEM;
607 			ccp_queue_abort(qp);
608 		} else
609 			ccp_queue_release(qp);
610 	}
611 
612 	if (error != 0) {
613 		DPRINTF(dev, "%s: early error:%d\n", __func__, error);
614 		crp->crp_etype = error;
615 		crypto_done(crp);
616 	}
617 	return (0);
618 }
619 
620 static device_method_t ccp_methods[] = {
621 	DEVMETHOD(device_probe,		ccp_probe),
622 	DEVMETHOD(device_attach,	ccp_attach),
623 	DEVMETHOD(device_detach,	ccp_detach),
624 
625 	DEVMETHOD(cryptodev_probesession, ccp_probesession),
626 	DEVMETHOD(cryptodev_newsession,	ccp_newsession),
627 	DEVMETHOD(cryptodev_freesession, ccp_freesession),
628 	DEVMETHOD(cryptodev_process,	ccp_process),
629 
630 	DEVMETHOD_END
631 };
632 
633 static driver_t ccp_driver = {
634 	"ccp",
635 	ccp_methods,
636 	sizeof(struct ccp_softc)
637 };
638 
639 DRIVER_MODULE(ccp, pci, ccp_driver, NULL, NULL);
640 MODULE_VERSION(ccp, 1);
641 MODULE_DEPEND(ccp, crypto, 1, 1, 1);
642 MODULE_DEPEND(ccp, random_device, 1, 1, 1);
643 #if 0	/* There are enough known issues that we shouldn't load automatically */
644 MODULE_PNP_INFO("W32:vendor/device", pci, ccp, ccp_ids,
645     nitems(ccp_ids));
646 #endif
647 
648 static int
649 ccp_queue_reserve_space(struct ccp_queue *qp, unsigned n, int mflags)
650 {
651 	struct ccp_softc *sc;
652 
653 	mtx_assert(&qp->cq_lock, MA_OWNED);
654 	sc = qp->cq_softc;
655 
656 	if (n < 1 || n >= (1 << sc->ring_size_order))
657 		return (EINVAL);
658 
659 	while (true) {
660 		if (ccp_queue_get_ring_space(qp) >= n)
661 			return (0);
662 		if ((mflags & M_WAITOK) == 0)
663 			return (EAGAIN);
664 		qp->cq_waiting = true;
665 		msleep(&qp->cq_tail, &qp->cq_lock, 0, "ccpqfull", 0);
666 	}
667 }
668 
669 int
670 ccp_queue_acquire_reserve(struct ccp_queue *qp, unsigned n, int mflags)
671 {
672 	int error;
673 
674 	mtx_lock(&qp->cq_lock);
675 	qp->cq_acq_tail = qp->cq_tail;
676 	error = ccp_queue_reserve_space(qp, n, mflags);
677 	if (error != 0)
678 		mtx_unlock(&qp->cq_lock);
679 	return (error);
680 }
681 
682 void
683 ccp_queue_release(struct ccp_queue *qp)
684 {
685 
686 	mtx_assert(&qp->cq_lock, MA_OWNED);
687 	if (qp->cq_tail != qp->cq_acq_tail) {
688 		wmb();
689 		ccp_queue_write_tail(qp);
690 	}
691 	mtx_unlock(&qp->cq_lock);
692 }
693 
694 void
695 ccp_queue_abort(struct ccp_queue *qp)
696 {
697 	unsigned i;
698 
699 	mtx_assert(&qp->cq_lock, MA_OWNED);
700 
701 	/* Wipe out any descriptors associated with this aborted txn. */
702 	for (i = qp->cq_acq_tail; i != qp->cq_tail;
703 	    i = (i + 1) % (1 << qp->cq_softc->ring_size_order)) {
704 		memset(&qp->desc_ring[i], 0, sizeof(qp->desc_ring[i]));
705 	}
706 	qp->cq_tail = qp->cq_acq_tail;
707 
708 	mtx_unlock(&qp->cq_lock);
709 }
710 
711 #ifdef DDB
712 #define	_db_show_lock(lo)	LOCK_CLASS(lo)->lc_ddb_show(lo)
713 #define	db_show_lock(lk)	_db_show_lock(&(lk)->lock_object)
714 static void
715 db_show_ccp_sc(struct ccp_softc *sc)
716 {
717 
718 	db_printf("ccp softc at %p\n", sc);
719 	db_printf(" cid: %d\n", (int)sc->cid);
720 
721 	db_printf(" lock: ");
722 	db_show_lock(&sc->lock);
723 
724 	db_printf(" detaching: %d\n", (int)sc->detaching);
725 	db_printf(" ring_size_order: %u\n", sc->ring_size_order);
726 
727 	db_printf(" hw_version: %d\n", (int)sc->hw_version);
728 	db_printf(" hw_features: %b\n", (int)sc->hw_features,
729 	    "\20\24ELFC\23TRNG\22Zip_Compress\16Zip_Decompress\13ECC\12RSA"
730 	    "\11SHA\0103DES\07AES");
731 
732 	db_printf(" hw status:\n");
733 	db_ccp_show_hw(sc);
734 }
735 
736 static void
737 db_show_ccp_qp(struct ccp_queue *qp)
738 {
739 
740 	db_printf(" lock: ");
741 	db_show_lock(&qp->cq_lock);
742 
743 	db_printf(" cq_qindex: %u\n", qp->cq_qindex);
744 	db_printf(" cq_softc: %p\n", qp->cq_softc);
745 
746 	db_printf(" head: %u\n", qp->cq_head);
747 	db_printf(" tail: %u\n", qp->cq_tail);
748 	db_printf(" acq_tail: %u\n", qp->cq_acq_tail);
749 	db_printf(" desc_ring: %p\n", qp->desc_ring);
750 	db_printf(" completions_ring: %p\n", qp->completions_ring);
751 	db_printf(" descriptors (phys): 0x%jx\n",
752 	    (uintmax_t)qp->desc_ring_bus_addr);
753 
754 	db_printf(" hw status:\n");
755 	db_ccp_show_queue_hw(qp);
756 }
757 
758 DB_SHOW_COMMAND(ccp, db_show_ccp)
759 {
760 	struct ccp_softc *sc;
761 	unsigned unit, qindex;
762 
763 	if (!have_addr)
764 		goto usage;
765 
766 	unit = (unsigned)addr;
767 
768 	sc = devclass_get_softc(devclass_find("ccp"), unit);
769 	if (sc == NULL) {
770 		db_printf("No such device ccp%u\n", unit);
771 		goto usage;
772 	}
773 
774 	if (count == -1) {
775 		db_show_ccp_sc(sc);
776 		return;
777 	}
778 
779 	qindex = (unsigned)count;
780 	if (qindex >= nitems(sc->queues)) {
781 		db_printf("No such queue %u\n", qindex);
782 		goto usage;
783 	}
784 	db_show_ccp_qp(&sc->queues[qindex]);
785 	return;
786 
787 usage:
788 	db_printf("usage: show ccp <unit>[,<qindex>]\n");
789 	return;
790 }
791 #endif /* DDB */
792