sys/crypto/ccp/ccp.c

   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_UIO:
 105                 error = sglist_append_uio(sg, cb->cb_uio);
 106                 break;
 107         case CRYPTO_BUF_CONTIG:
 108                 error = sglist_append(sg, cb->cb_buf, cb->cb_buf_len);
 109                 break;
 110         case CRYPTO_BUF_VMPAGE:
 111                 error = sglist_append_vmpages(sg, cb->cb_vm_page,
 112                     cb->cb_vm_page_len, cb->cb_vm_page_offset);
 113                 break;
 114         default:
 115                 error = EINVAL;
 116         }
 117         return (error);
 118 }
 119
 120 static int
 121 ccp_probe(device_t dev)
 122 {
 123         struct pciid *ip;
 124         uint32_t id;
 125
 126         id = pci_get_devid(dev);
 127         for (ip = ccp_ids; ip < &ccp_ids[nitems(ccp_ids)]; ip++) {
 128                 if (id == ip->devid) {
 129                         device_set_desc(dev, ip->desc);
 130                         return (0);
 131                 }
 132         }
 133         return (ENXIO);
 134 }
 135
 136 static void
 137 ccp_initialize_queues(struct ccp_softc *sc)
 138 {
 139         struct ccp_queue *qp;
 140         size_t i;
 141
 142         for (i = 0; i < nitems(sc->queues); i++) {
 143                 qp = &sc->queues[i];
 144
 145                 qp->cq_softc = sc;
 146                 qp->cq_qindex = i;
 147                 mtx_init(&qp->cq_lock, "ccp queue", NULL, MTX_DEF);
 148                 /* XXX - arbitrarily chosen sizes */
 149                 qp->cq_sg_crp = sglist_alloc(32, M_WAITOK);
 150                 /* Two more SGEs than sg_crp to accommodate ipad. */
 151                 qp->cq_sg_ulptx = sglist_alloc(34, M_WAITOK);
 152                 qp->cq_sg_dst = sglist_alloc(2, M_WAITOK);
 153         }
 154 }
 155
 156 static void
 157 ccp_free_queues(struct ccp_softc *sc)
 158 {
 159         struct ccp_queue *qp;
 160         size_t i;
 161
 162         for (i = 0; i < nitems(sc->queues); i++) {
 163                 qp = &sc->queues[i];
 164
 165                 mtx_destroy(&qp->cq_lock);
 166                 sglist_free(qp->cq_sg_crp);
 167                 sglist_free(qp->cq_sg_ulptx);
 168                 sglist_free(qp->cq_sg_dst);
 169         }
 170 }
 171
 172 static int
 173 ccp_attach(device_t dev)
 174 {
 175         struct ccp_softc *sc;
 176         int error;
 177
 178         sc = device_get_softc(dev);
 179         sc->dev = dev;
 180
 181         sc->cid = crypto_get_driverid(dev, sizeof(struct ccp_session),
 182             CRYPTOCAP_F_HARDWARE);
 183         if (sc->cid < 0) {
 184                 device_printf(dev, "could not get crypto driver id\n");
 185                 return (ENXIO);
 186         }
 187
 188         error = ccp_hw_attach(dev);
 189         if (error != 0)
 190                 return (error);
 191
 192         mtx_init(&sc->lock, "ccp", NULL, MTX_DEF);
 193
 194         ccp_initialize_queues(sc);
 195
 196         if (g_ccp_softc == NULL) {
 197                 g_ccp_softc = sc;
 198                 if ((sc->hw_features & VERSION_CAP_TRNG) != 0)
 199                         random_source_register(&random_ccp);
 200         }
 201
 202         return (0);
 203 }
 204
 205 static int
 206 ccp_detach(device_t dev)
 207 {
 208         struct ccp_softc *sc;
 209
 210         sc = device_get_softc(dev);
 211
 212         mtx_lock(&sc->lock);
 213         sc->detaching = true;
 214         mtx_unlock(&sc->lock);
 215
 216         crypto_unregister_all(sc->cid);
 217         if (g_ccp_softc == sc && (sc->hw_features & VERSION_CAP_TRNG) != 0)
 218                 random_source_deregister(&random_ccp);
 219
 220         ccp_hw_detach(dev);
 221         ccp_free_queues(sc);
 222
 223         if (g_ccp_softc == sc)
 224                 g_ccp_softc = NULL;
 225
 226         mtx_destroy(&sc->lock);
 227         return (0);
 228 }
 229
 230 static void
 231 ccp_init_hmac_digest(struct ccp_session *s, const char *key, int klen)
 232 {
 233         union authctx auth_ctx;
 234         struct auth_hash *axf;
 235         u_int i;
 236
 237         /*
 238          * If the key is larger than the block size, use the digest of
 239          * the key as the key instead.
 240          */
 241         axf = s->hmac.auth_hash;
 242         if (klen > axf->blocksize) {
 243                 axf->Init(&auth_ctx);
 244                 axf->Update(&auth_ctx, key, klen);
 245                 axf->Final(s->hmac.ipad, &auth_ctx);
 246                 explicit_bzero(&auth_ctx, sizeof(auth_ctx));
 247                 klen = axf->hashsize;
 248         } else
 249                 memcpy(s->hmac.ipad, key, klen);
 250
 251         memset(s->hmac.ipad + klen, 0, axf->blocksize - klen);
 252         memcpy(s->hmac.opad, s->hmac.ipad, axf->blocksize);
 253
 254         for (i = 0; i < axf->blocksize; i++) {
 255                 s->hmac.ipad[i] ^= HMAC_IPAD_VAL;
 256                 s->hmac.opad[i] ^= HMAC_OPAD_VAL;
 257         }
 258 }
 259
 260 static bool
 261 ccp_aes_check_keylen(int alg, int klen)
 262 {
 263
 264         switch (klen * 8) {
 265         case 128:
 266         case 192:
 267                 if (alg == CRYPTO_AES_XTS)
 268                         return (false);
 269                 break;
 270         case 256:
 271                 break;
 272         case 512:
 273                 if (alg != CRYPTO_AES_XTS)
 274                         return (false);
 275                 break;
 276         default:
 277                 return (false);
 278         }
 279         return (true);
 280 }
 281
 282 static void
 283 ccp_aes_setkey(struct ccp_session *s, int alg, const void *key, int klen)
 284 {
 285         unsigned kbits;
 286
 287         if (alg == CRYPTO_AES_XTS)
 288                 kbits = (klen / 2) * 8;
 289         else
 290                 kbits = klen * 8;
 291
 292         switch (kbits) {
 293         case 128:
 294                 s->blkcipher.cipher_type = CCP_AES_TYPE_128;
 295                 break;
 296         case 192:
 297                 s->blkcipher.cipher_type = CCP_AES_TYPE_192;
 298                 break;
 299         case 256:
 300                 s->blkcipher.cipher_type = CCP_AES_TYPE_256;
 301                 break;
 302         default:
 303                 panic("should not get here");
 304         }
 305
 306         s->blkcipher.key_len = klen;
 307         memcpy(s->blkcipher.enckey, key, s->blkcipher.key_len);
 308 }
 309
 310 static bool
 311 ccp_auth_supported(struct ccp_softc *sc,
 312     const struct crypto_session_params *csp)
 313 {
 314
 315         if ((sc->hw_features & VERSION_CAP_SHA) == 0)
 316                 return (false);
 317         switch (csp->csp_auth_alg) {
 318         case CRYPTO_SHA1_HMAC:
 319         case CRYPTO_SHA2_256_HMAC:
 320         case CRYPTO_SHA2_384_HMAC:
 321         case CRYPTO_SHA2_512_HMAC:
 322                 if (csp->csp_auth_key == NULL)
 323                         return (false);
 324                 break;
 325         default:
 326                 return (false);
 327         }
 328         return (true);
 329 }
 330
 331 static bool
 332 ccp_cipher_supported(struct ccp_softc *sc,
 333     const struct crypto_session_params *csp)
 334 {
 335
 336         if ((sc->hw_features & VERSION_CAP_AES) == 0)
 337                 return (false);
 338         switch (csp->csp_cipher_alg) {
 339         case CRYPTO_AES_CBC:
 340                 if (csp->csp_ivlen != AES_BLOCK_LEN)
 341                         return (false);
 342                 break;
 343         case CRYPTO_AES_ICM:
 344                 if (csp->csp_ivlen != AES_BLOCK_LEN)
 345                         return (false);
 346                 break;
 347         case CRYPTO_AES_XTS:
 348                 if (csp->csp_ivlen != AES_XTS_IV_LEN)
 349                         return (false);
 350                 break;
 351         default:
 352                 return (false);
 353         }
 354         return (ccp_aes_check_keylen(csp->csp_cipher_alg,
 355             csp->csp_cipher_klen));
 356 }
 357
 358 static int
 359 ccp_probesession(device_t dev, const struct crypto_session_params *csp)
 360 {
 361         struct ccp_softc *sc;
 362
 363         if (csp->csp_flags != 0)
 364                 return (EINVAL);
 365         sc = device_get_softc(dev);
 366         switch (csp->csp_mode) {
 367         case CSP_MODE_DIGEST:
 368                 if (!ccp_auth_supported(sc, csp))
 369                         return (EINVAL);
 370                 break;
 371         case CSP_MODE_CIPHER:
 372                 if (!ccp_cipher_supported(sc, csp))
 373                         return (EINVAL);
 374                 break;
 375         case CSP_MODE_AEAD:
 376                 switch (csp->csp_cipher_alg) {
 377                 case CRYPTO_AES_NIST_GCM_16:
 378                         if (csp->csp_ivlen != AES_GCM_IV_LEN)
 379                                 return (EINVAL);
 380                         if (csp->csp_auth_mlen < 0 ||
 381                             csp->csp_auth_mlen > AES_GMAC_HASH_LEN)
 382                                 return (EINVAL);
 383                         if ((sc->hw_features & VERSION_CAP_AES) == 0)
 384                                 return (EINVAL);
 385                         break;
 386                 default:
 387                         return (EINVAL);
 388                 }
 389                 break;
 390         case CSP_MODE_ETA:
 391                 if (!ccp_auth_supported(sc, csp) ||
 392                     !ccp_cipher_supported(sc, csp))
 393                         return (EINVAL);
 394                 break;
 395         default:
 396                 return (EINVAL);
 397         }
 398
 399         return (CRYPTODEV_PROBE_HARDWARE);
 400 }
 401
 402 static int
 403 ccp_newsession(device_t dev, crypto_session_t cses,
 404     const struct crypto_session_params *csp)
 405 {
 406         struct ccp_softc *sc;
 407         struct ccp_session *s;
 408         struct auth_hash *auth_hash;
 409         enum ccp_aes_mode cipher_mode;
 410         unsigned auth_mode;
 411         unsigned q;
 412
 413         /* XXX reconcile auth_mode with use by ccp_sha */
 414         switch (csp->csp_auth_alg) {
 415         case CRYPTO_SHA1_HMAC:
 416                 auth_hash = &auth_hash_hmac_sha1;
 417                 auth_mode = SHA1;
 418                 break;
 419         case CRYPTO_SHA2_256_HMAC:
 420                 auth_hash = &auth_hash_hmac_sha2_256;
 421                 auth_mode = SHA2_256;
 422                 break;
 423         case CRYPTO_SHA2_384_HMAC:
 424                 auth_hash = &auth_hash_hmac_sha2_384;
 425                 auth_mode = SHA2_384;
 426                 break;
 427         case CRYPTO_SHA2_512_HMAC:
 428                 auth_hash = &auth_hash_hmac_sha2_512;
 429                 auth_mode = SHA2_512;
 430                 break;
 431         default:
 432                 auth_hash = NULL;
 433                 auth_mode = 0;
 434                 break;
 435         }
 436
 437         switch (csp->csp_cipher_alg) {
 438         case CRYPTO_AES_CBC:
 439                 cipher_mode = CCP_AES_MODE_CBC;
 440                 break;
 441         case CRYPTO_AES_ICM:
 442                 cipher_mode = CCP_AES_MODE_CTR;
 443                 break;
 444         case CRYPTO_AES_NIST_GCM_16:
 445                 cipher_mode = CCP_AES_MODE_GCTR;
 446                 break;
 447         case CRYPTO_AES_XTS:
 448                 cipher_mode = CCP_AES_MODE_XTS;
 449                 break;
 450         default:
 451                 cipher_mode = CCP_AES_MODE_ECB;
 452                 break;
 453         }
 454
 455         sc = device_get_softc(dev);
 456         mtx_lock(&sc->lock);
 457         if (sc->detaching) {
 458                 mtx_unlock(&sc->lock);
 459                 return (ENXIO);
 460         }
 461
 462         s = crypto_get_driver_session(cses);
 463
 464         /* Just grab the first usable queue for now. */
 465         for (q = 0; q < nitems(sc->queues); q++)
 466                 if ((sc->valid_queues & (1 << q)) != 0)
 467                         break;
 468         if (q == nitems(sc->queues)) {
 469                 mtx_unlock(&sc->lock);
 470                 return (ENXIO);
 471         }
 472         s->queue = q;
 473
 474         switch (csp->csp_mode) {
 475         case CSP_MODE_AEAD:
 476                 s->mode = GCM;
 477                 break;
 478         case CSP_MODE_ETA:
 479                 s->mode = AUTHENC;
 480                 break;
 481         case CSP_MODE_DIGEST:
 482                 s->mode = HMAC;
 483                 break;
 484         case CSP_MODE_CIPHER:
 485                 s->mode = BLKCIPHER;
 486                 break;
 487         }
 488
 489         if (s->mode == GCM) {
 490                 if (csp->csp_auth_mlen == 0)
 491                         s->gmac.hash_len = AES_GMAC_HASH_LEN;
 492                 else
 493                         s->gmac.hash_len = csp->csp_auth_mlen;
 494         } else if (auth_hash != NULL) {
 495                 s->hmac.auth_hash = auth_hash;
 496                 s->hmac.auth_mode = auth_mode;
 497                 if (csp->csp_auth_mlen == 0)
 498                         s->hmac.hash_len = auth_hash->hashsize;
 499                 else
 500                         s->hmac.hash_len = csp->csp_auth_mlen;
 501                 ccp_init_hmac_digest(s, csp->csp_auth_key, csp->csp_auth_klen);
 502         }
 503         if (cipher_mode != CCP_AES_MODE_ECB) {
 504                 s->blkcipher.cipher_mode = cipher_mode;
 505                 if (csp->csp_cipher_key != NULL)
 506                         ccp_aes_setkey(s, csp->csp_cipher_alg,
 507                             csp->csp_cipher_key, csp->csp_cipher_klen);
 508         }
 509
 510         s->active = true;
 511         mtx_unlock(&sc->lock);
 512
 513         return (0);
 514 }
 515
 516 static void
 517 ccp_freesession(device_t dev, crypto_session_t cses)
 518 {
 519         struct ccp_session *s;
 520
 521         s = crypto_get_driver_session(cses);
 522
 523         if (s->pending != 0)
 524                 device_printf(dev,
 525                     "session %p freed with %d pending requests\n", s,
 526                     s->pending);
 527         s->active = false;
 528 }
 529
 530 static int
 531 ccp_process(device_t dev, struct cryptop *crp, int hint)
 532 {
 533         const struct crypto_session_params *csp;
 534         struct ccp_softc *sc;
 535         struct ccp_queue *qp;
 536         struct ccp_session *s;
 537         int error;
 538         bool qpheld;
 539
 540         qpheld = false;
 541         qp = NULL;
 542
 543         csp = crypto_get_params(crp->crp_session);
 544         s = crypto_get_driver_session(crp->crp_session);
 545         sc = device_get_softc(dev);
 546         mtx_lock(&sc->lock);
 547         qp = &sc->queues[s->queue];
 548         mtx_unlock(&sc->lock);
 549         error = ccp_queue_acquire_reserve(qp, 1 /* placeholder */, M_NOWAIT);
 550         if (error != 0)
 551                 goto out;
 552         qpheld = true;
 553
 554         error = ccp_populate_sglist(qp->cq_sg_crp, &crp->crp_buf);
 555         if (error != 0)
 556                 goto out;
 557
 558         if (crp->crp_auth_key != NULL) {
 559                 KASSERT(s->hmac.auth_hash != NULL, ("auth key without HMAC"));
 560                 ccp_init_hmac_digest(s, crp->crp_auth_key, csp->csp_auth_klen);
 561         }
 562         if (crp->crp_cipher_key != NULL)
 563                 ccp_aes_setkey(s, csp->csp_cipher_alg, crp->crp_cipher_key,
 564                     csp->csp_cipher_klen);
 565
 566         switch (s->mode) {
 567         case HMAC:
 568                 if (s->pending != 0) {
 569                         error = EAGAIN;
 570                         break;
 571                 }
 572                 error = ccp_hmac(qp, s, crp);
 573                 break;
 574         case BLKCIPHER:
 575                 if (s->pending != 0) {
 576                         error = EAGAIN;
 577                         break;
 578                 }
 579                 error = ccp_blkcipher(qp, s, crp);
 580                 break;
 581         case AUTHENC:
 582                 if (s->pending != 0) {
 583                         error = EAGAIN;
 584                         break;
 585                 }
 586                 error = ccp_authenc(qp, s, crp);
 587                 break;
 588         case GCM:
 589                 if (s->pending != 0) {
 590                         error = EAGAIN;
 591                         break;
 592                 }
 593                 error = ccp_gcm(qp, s, crp);
 594                 break;
 595         }
 596
 597         if (error == 0)
 598                 s->pending++;
 599
 600 out:
 601         if (qpheld) {
 602                 if (error != 0) {
 603                         /*
 604                          * Squash EAGAIN so callers don't uselessly and
 605                          * expensively retry if the ring was full.
 606                          */
 607                         if (error == EAGAIN)
 608                                 error = ENOMEM;
 609                         ccp_queue_abort(qp);
 610                 } else
 611                         ccp_queue_release(qp);
 612         }
 613
 614         if (error != 0) {
 615                 DPRINTF(dev, "%s: early error:%d\n", __func__, error);
 616                 crp->crp_etype = error;
 617                 crypto_done(crp);
 618         }
 619         return (0);
 620 }
 621
 622 static device_method_t ccp_methods[] = {
 623         DEVMETHOD(device_probe,         ccp_probe),
 624         DEVMETHOD(device_attach,        ccp_attach),
 625         DEVMETHOD(device_detach,        ccp_detach),
 626
 627         DEVMETHOD(cryptodev_probesession, ccp_probesession),
 628         DEVMETHOD(cryptodev_newsession, ccp_newsession),
 629         DEVMETHOD(cryptodev_freesession, ccp_freesession),
 630         DEVMETHOD(cryptodev_process,    ccp_process),
 631
 632         DEVMETHOD_END
 633 };
 634
 635 static driver_t ccp_driver = {
 636         "ccp",
 637         ccp_methods,
 638         sizeof(struct ccp_softc)
 639 };
 640
 641 static devclass_t ccp_devclass;
 642 DRIVER_MODULE(ccp, pci, ccp_driver, ccp_devclass, NULL, NULL);
 643 MODULE_VERSION(ccp, 1);
 644 MODULE_DEPEND(ccp, crypto, 1, 1, 1);
 645 MODULE_DEPEND(ccp, random_device, 1, 1, 1);
 646 #if 0   /* There are enough known issues that we shouldn't load automatically */
 647 MODULE_PNP_INFO("W32:vendor/device", pci, ccp, ccp_ids,
 648     nitems(ccp_ids));
 649 #endif
 650
 651 static int
 652 ccp_queue_reserve_space(struct ccp_queue *qp, unsigned n, int mflags)
 653 {
 654         struct ccp_softc *sc;
 655
 656         mtx_assert(&qp->cq_lock, MA_OWNED);
 657         sc = qp->cq_softc;
 658
 659         if (n < 1 || n >= (1 << sc->ring_size_order))
 660                 return (EINVAL);
 661
 662         while (true) {
 663                 if (ccp_queue_get_ring_space(qp) >= n)
 664                         return (0);
 665                 if ((mflags & M_WAITOK) == 0)
 666                         return (EAGAIN);
 667                 qp->cq_waiting = true;
 668                 msleep(&qp->cq_tail, &qp->cq_lock, 0, "ccpqfull", 0);
 669         }
 670 }
 671
 672 int
 673 ccp_queue_acquire_reserve(struct ccp_queue *qp, unsigned n, int mflags)
 674 {
 675         int error;
 676
 677         mtx_lock(&qp->cq_lock);
 678         qp->cq_acq_tail = qp->cq_tail;
 679         error = ccp_queue_reserve_space(qp, n, mflags);
 680         if (error != 0)
 681                 mtx_unlock(&qp->cq_lock);
 682         return (error);
 683 }
 684
 685 void
 686 ccp_queue_release(struct ccp_queue *qp)
 687 {
 688
 689         mtx_assert(&qp->cq_lock, MA_OWNED);
 690         if (qp->cq_tail != qp->cq_acq_tail) {
 691                 wmb();
 692                 ccp_queue_write_tail(qp);
 693         }
 694         mtx_unlock(&qp->cq_lock);
 695 }
 696
 697 void
 698 ccp_queue_abort(struct ccp_queue *qp)
 699 {
 700         unsigned i;
 701
 702         mtx_assert(&qp->cq_lock, MA_OWNED);
 703
 704         /* Wipe out any descriptors associated with this aborted txn. */
 705         for (i = qp->cq_acq_tail; i != qp->cq_tail;
 706             i = (i + 1) % (1 << qp->cq_softc->ring_size_order)) {
 707                 memset(&qp->desc_ring[i], 0, sizeof(qp->desc_ring[i]));
 708         }
 709         qp->cq_tail = qp->cq_acq_tail;
 710
 711         mtx_unlock(&qp->cq_lock);
 712 }
 713
 714 #ifdef DDB
 715 #define _db_show_lock(lo)       LOCK_CLASS(lo)->lc_ddb_show(lo)
 716 #define db_show_lock(lk)        _db_show_lock(&(lk)->lock_object)
 717 static void
 718 db_show_ccp_sc(struct ccp_softc *sc)
 719 {
 720
 721         db_printf("ccp softc at %p\n", sc);
 722         db_printf(" cid: %d\n", (int)sc->cid);
 723
 724         db_printf(" lock: ");
 725         db_show_lock(&sc->lock);
 726
 727         db_printf(" detaching: %d\n", (int)sc->detaching);
 728         db_printf(" ring_size_order: %u\n", sc->ring_size_order);
 729
 730         db_printf(" hw_version: %d\n", (int)sc->hw_version);
 731         db_printf(" hw_features: %b\n", (int)sc->hw_features,
 732             "\20\24ELFC\23TRNG\22Zip_Compress\16Zip_Decompress\13ECC\12RSA"
 733             "\11SHA\0103DES\07AES");
 734
 735         db_printf(" hw status:\n");
 736         db_ccp_show_hw(sc);
 737 }
 738
 739 static void
 740 db_show_ccp_qp(struct ccp_queue *qp)
 741 {
 742
 743         db_printf(" lock: ");
 744         db_show_lock(&qp->cq_lock);
 745
 746         db_printf(" cq_qindex: %u\n", qp->cq_qindex);
 747         db_printf(" cq_softc: %p\n", qp->cq_softc);
 748
 749         db_printf(" head: %u\n", qp->cq_head);
 750         db_printf(" tail: %u\n", qp->cq_tail);
 751         db_printf(" acq_tail: %u\n", qp->cq_acq_tail);
 752         db_printf(" desc_ring: %p\n", qp->desc_ring);
 753         db_printf(" completions_ring: %p\n", qp->completions_ring);
 754         db_printf(" descriptors (phys): 0x%jx\n",
 755             (uintmax_t)qp->desc_ring_bus_addr);
 756
 757         db_printf(" hw status:\n");
 758         db_ccp_show_queue_hw(qp);
 759 }
 760
 761 DB_SHOW_COMMAND(ccp, db_show_ccp)
 762 {
 763         struct ccp_softc *sc;
 764         unsigned unit, qindex;
 765
 766         if (!have_addr)
 767                 goto usage;
 768
 769         unit = (unsigned)addr;
 770
 771         sc = devclass_get_softc(ccp_devclass, unit);
 772         if (sc == NULL) {
 773                 db_printf("No such device ccp%u\n", unit);
 774                 goto usage;
 775         }
 776
 777         if (count == -1) {
 778                 db_show_ccp_sc(sc);
 779                 return;
 780         }
 781
 782         qindex = (unsigned)count;
 783         if (qindex >= nitems(sc->queues)) {
 784                 db_printf("No such queue %u\n", qindex);
 785                 goto usage;
 786         }
 787         db_show_ccp_qp(&sc->queues[qindex]);
 788         return;
 789
 790 usage:
 791         db_printf("usage: show ccp <unit>[,<qindex>]\n");
 792         return;
 793 }
 794 #endif /* DDB */