root/dev/pci/lofn.c

DEFINITIONS

1. lofn_probe
2. lofn_attach
3. lofn_intr
4. lofn_read_reg
5. lofn_write_reg
6. lofn_zero_reg
7. lofn_dump_reg
8. lofn_kfind
9. lofn_kprocess
10. lofn_modexp_start
11. lofn_modexp_finish
12. lofn_norm_sigbits
13. lofn_feed

    1 /*      $OpenBSD: lofn.c,v 1.27 2006/06/29 21:34:51 deraadt Exp $       */
    3 /*
    4  * Copyright (c) 2001-2002 Jason L. Wright (jason@thought.net)
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  *
   16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   19  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
   20  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   21  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   22  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   24  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
   25  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   26  * POSSIBILITY OF SUCH DAMAGE.
   27  *
   28  * Effort sponsored in part by the Defense Advanced Research Projects
   29  * Agency (DARPA) and Air Force Research Laboratory, Air Force
   30  * Materiel Command, USAF, under agreement number F30602-01-2-0537.
   31  *
   32  */
   34 /*
   35  * Driver for the Hifn 6500 assymmetric encryption processor.
   36  */
   38 #include <sys/param.h>
   39 #include <sys/systm.h>
   40 #include <sys/proc.h>
   41 #include <sys/errno.h>
   42 #include <sys/malloc.h>
   43 #include <sys/kernel.h>
   44 #include <sys/mbuf.h>
   45 #include <sys/device.h>
   47 #include <crypto/cryptodev.h>
   48 #include <dev/rndvar.h>
   50 #include <dev/pci/pcireg.h>
   51 #include <dev/pci/pcivar.h>
   52 #include <dev/pci/pcidevs.h>
   54 #include <dev/pci/lofnreg.h>
   55 #include <dev/pci/lofnvar.h>
   57 /*
   58  * Prototypes and count for the pci_device structure
   59  */
   60 int lofn_probe(struct device *, void *, void *);
   61 void lofn_attach(struct device *, struct device *, void *);
   63 struct cfattach lofn_ca = {
   64         sizeof(struct lofn_softc), lofn_probe, lofn_attach,
   65 };
   67 struct cfdriver lofn_cd = {
   68         0, "lofn", DV_DULL
   69 };
   71 int lofn_intr(void *);
   72 int lofn_norm_sigbits(const u_int8_t *, u_int);
   73 void lofn_dump_reg(struct lofn_softc *, int);
   74 void lofn_zero_reg(struct lofn_softc *, int);
   75 void lofn_read_reg(struct lofn_softc *, int, union lofn_reg *);
   76 void lofn_write_reg(struct lofn_softc *, int, union lofn_reg *);
   77 int lofn_kprocess(struct cryptkop *);
   78 struct lofn_softc *lofn_kfind(struct cryptkop *);
   79 int lofn_modexp_start(struct lofn_softc *, struct lofn_q *);
   80 void lofn_modexp_finish(struct lofn_softc *, struct lofn_q *);
   82 void lofn_feed(struct lofn_softc *);
   84 int
lofn_probe(parent, match, aux)
   86         struct device *parent;
   87         void *match;
   88         void *aux;
   89 {
   90         struct pci_attach_args *pa = (struct pci_attach_args *) aux;
   92         if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_HIFN &&
PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_HIFN_6500)
   94                 return (1);
   95         return (0);
   96 }
   98 void 
lofn_attach(parent, self, aux)
  100         struct device *parent, *self;
  101         void *aux;
  102 {
  103         struct lofn_softc *sc = (struct lofn_softc *)self;
  104         struct pci_attach_args *pa = aux;
pci_chipset_tag_t pc = pa->pa_pc;
pci_intr_handle_t ih;
  107         const char *intrstr = NULL;
bus_size_t iosize;
  109         int algs[CRK_ALGORITHM_MAX + 1];
  111         if (pci_mapreg_map(pa, LOFN_BAR0, PCI_MAPREG_TYPE_MEM, 0,
  112             &sc->sc_st, &sc->sc_sh, NULL, &iosize, 0)) {
printf(": can't map mem space\n");
  114                 return;
  115         }
sc->sc_dmat = pa->pa_dmat;
  119         if (pci_intr_map(pa, &ih)) {
printf(": couldn't map interrupt\n");
  121                 goto fail;
  122         }
intrstr = pci_intr_string(pc, ih);
sc->sc_ih = pci_intr_establish(pc, ih, IPL_NET, lofn_intr, sc,
self->dv_xname);
  126         if (sc->sc_ih == NULL) {
printf(": couldn't establish interrupt");
  128                 if (intrstr != NULL)
printf(" at %s", intrstr);
printf("\n");
  131                 goto fail;
  132         }
WRITE_REG_0(sc, LOFN_REL_RNC, LOFN_RNG_SCALAR);
  136         /* Enable RNG */
WRITE_REG_0(sc, LOFN_REL_CFG2,
READ_REG_0(sc, LOFN_REL_CFG2) | LOFN_CFG2_RNGENA);
sc->sc_ier |= LOFN_IER_RDY;
WRITE_REG(sc, LOFN_REL_IER, sc->sc_ier);
  142         /* Enable ALU */
WRITE_REG_0(sc, LOFN_REL_CFG2,
READ_REG_0(sc, LOFN_REL_CFG2) | LOFN_CFG2_PRCENA);
SIMPLEQ_INIT(&sc->sc_queue);
sc->sc_cid = crypto_get_driverid(0);
  149         if (sc->sc_cid < 0) {
printf(": failed to register cid\n");
  151                 return;
  152         }
bzero(algs, sizeof(algs));
algs[CRK_MOD_EXP] = CRYPTO_ALG_FLAG_SUPPORTED;
crypto_kregister(sc->sc_cid, algs, lofn_kprocess);
printf(": PK, %s\n", intrstr);
  161         return;
fail:
bus_space_unmap(sc->sc_st, sc->sc_sh, iosize);
  165 }
  167 int 
lofn_intr(vsc)
  169         void *vsc;
  170 {
  171         struct lofn_softc *sc = vsc;
  172         struct lofn_q *q;
u_int32_t sr;
  174         int r = 0, i;
sr = READ_REG_0(sc, LOFN_REL_SR);
  178         if (sc->sc_ier & LOFN_IER_RDY) {
  179                 if (sr & LOFN_SR_RNG_UF) {
r = 1;
printf("%s: rng underflow (disabling)\n",
sc->sc_dv.dv_xname);
WRITE_REG_0(sc, LOFN_REL_CFG2,
READ_REG_0(sc, LOFN_REL_CFG2) &
  185                             (~LOFN_CFG2_RNGENA));
sc->sc_ier &= ~LOFN_IER_RDY;
WRITE_REG_0(sc, LOFN_REL_IER, sc->sc_ier);
  188                 } else if (sr & LOFN_SR_RNG_RDY) {
r = 1;
bus_space_read_region_4(sc->sc_st, sc->sc_sh,
LOFN_REL_RNG, sc->sc_rngbuf, LOFN_RNGBUF_SIZE);
  193                         for (i = 0; i < LOFN_RNGBUF_SIZE; i++)
add_true_randomness(sc->sc_rngbuf[i]);
  195                 }
  196         }
  198         if (sc->sc_ier & LOFN_IER_DONE) {
r = 1;
  200                 if (sr & LOFN_SR_DONE && sc->sc_current != NULL) {
q = sc->sc_current;
sc->sc_current = NULL;
q->q_finish(sc, q);
free(q, M_DEVBUF);
lofn_feed(sc);
  206                 }
  207         }
  209         return (r);
  210 }
  212 void
lofn_read_reg(sc, ridx, rp)
  214         struct lofn_softc *sc;
  215         int ridx;
  216         union lofn_reg *rp;
  217 {
  218 #if BYTE_ORDER == BIG_ENDIAN
bus_space_read_region_4(sc->sc_st, sc->sc_sh,
LOFN_REGADDR(LOFN_WIN_0, ridx, 0), rp->w, 1024/32);
  221 #else
bus_space_read_region_4(sc->sc_st, sc->sc_sh,
LOFN_REGADDR(LOFN_WIN_2, ridx, 0), rp->w, 1024/32);
  224 #endif
  225 }
  227 void
lofn_write_reg(sc, ridx, rp)
  229         struct lofn_softc *sc;
  230         int ridx;
  231         union lofn_reg *rp;
  232 {
  233 #if BYTE_ORDER == BIG_ENDIAN
bus_space_write_region_4(sc->sc_st, sc->sc_sh,
LOFN_REGADDR(LOFN_WIN_0, ridx, 0), rp->w, 1024/32);
  236 #else
bus_space_write_region_4(sc->sc_st, sc->sc_sh,
LOFN_REGADDR(LOFN_WIN_2, ridx, 0), rp->w, 1024/32);
  239 #endif
  240 }
  242 void
lofn_zero_reg(sc, ridx)
  244         struct lofn_softc *sc;
  245         int ridx;
  246 {
lofn_write_reg(sc, ridx, &sc->sc_zero);
  248 }
  250 void
lofn_dump_reg(sc, ridx)
  252         struct lofn_softc *sc;
  253         int ridx;
  254 {
  255         int i;
printf("reg %d bits %4u ", ridx,
READ_REG(sc, LOFN_LENADDR(LOFN_WIN_2, ridx)) & LOFN_LENMASK);
  260         for (i = 0; i < 1024/32; i++) {
printf("%08X", READ_REG(sc, LOFN_REGADDR(LOFN_WIN_3, ridx, i)));
  262         }
printf("\n");
  264 }
  266 struct lofn_softc *
lofn_kfind(krp)
  268         struct cryptkop *krp;
  269 {
  270         struct lofn_softc *sc;
  271         int i;
  273         for (i = 0; i < lofn_cd.cd_ndevs; i++) {
sc = lofn_cd.cd_devs[i];
  275                 if (sc == NULL)
  276                         continue;
  277                 if (sc->sc_cid == krp->krp_hid)
  278                         return (sc);
  279         }
  280         return (NULL);
  281 }
  283 int
lofn_kprocess(krp)
  285         struct cryptkop *krp;
  286 {
  287         struct lofn_softc *sc;
  288         struct lofn_q *q;
  289         int s;
  291         if (krp == NULL || krp->krp_callback == NULL)
  292                 return (EINVAL);
  293         if ((sc = lofn_kfind(krp)) == NULL) {
krp->krp_status = EINVAL;
crypto_kdone(krp);
  296                 return (0);
  297         }
q = (struct lofn_q *)malloc(sizeof(*q), M_DEVBUF, M_NOWAIT);
  300         if (q == NULL) {
krp->krp_status = ENOMEM;
crypto_kdone(krp);
  303                 return (0);
  304         }
  306         switch (krp->krp_op) {
  307         case CRK_MOD_EXP:
q->q_start = lofn_modexp_start;
q->q_finish = lofn_modexp_finish;
q->q_krp = krp;
s = splnet();
SIMPLEQ_INSERT_TAIL(&sc->sc_queue, q, q_next);
lofn_feed(sc);
splx(s);
  315                 return (0);
  316         default:
printf("%s: kprocess: invalid op 0x%x\n",
sc->sc_dv.dv_xname, krp->krp_op);
krp->krp_status = EOPNOTSUPP;
crypto_kdone(krp);
free(q, M_DEVBUF);
  322                 return (0);
  323         }
  324 }
  326 int
lofn_modexp_start(sc, q)
  328         struct lofn_softc *sc;
  329         struct lofn_q *q;
  330 {
  331         struct cryptkop *krp = q->q_krp;
  332         int ip = 0, err = 0;
  333         int mshift, eshift, nshift;
  334         int mbits, ebits, nbits;
  336         if (krp->krp_param[LOFN_MODEXP_PAR_M].crp_nbits > 1024) {
err = ERANGE;
  338                 goto errout;
  339         }
  341         /* Zero out registers. */
lofn_zero_reg(sc, 0);
lofn_zero_reg(sc, 1);
lofn_zero_reg(sc, 2);
lofn_zero_reg(sc, 3);
  347         /* Write out N... */
nbits = lofn_norm_sigbits(krp->krp_param[LOFN_MODEXP_PAR_N].crp_p,
krp->krp_param[LOFN_MODEXP_PAR_N].crp_nbits);
  350         if (nbits > 1024) {
err = E2BIG;
  352                 goto errout;
  353         }
  354         if (nbits < 5) {
err = ERANGE;
  356                 goto errout;
  357         }
bzero(&sc->sc_tmp, sizeof(sc->sc_tmp));
bcopy(krp->krp_param[LOFN_MODEXP_PAR_N].crp_p, &sc->sc_tmp,
  360             (nbits + 7) / 8);
lofn_write_reg(sc, 2, &sc->sc_tmp);
nshift = 1024 - nbits;
WRITE_REG(sc, LOFN_LENADDR(LOFN_WIN_2, 2), 1024);
  365         if (nshift != 0) {
WRITE_REG(sc, LOFN_REL_INSTR + ip,
LOFN_INSTR2(0, OP_CODE_SL, 2, 2, nshift));
ip += 4;
WRITE_REG(sc, LOFN_REL_INSTR + ip,
LOFN_INSTR2(0, OP_CODE_TAG, 2, 2, nbits));
ip += 4;
  373         }
  375         /* Write out M... */
mbits = lofn_norm_sigbits(krp->krp_param[LOFN_MODEXP_PAR_M].crp_p,
krp->krp_param[LOFN_MODEXP_PAR_M].crp_nbits);
  378         if (mbits > 1024 || mbits > nbits) {
err = E2BIG;
  380                 goto errout;
  381         }
bzero(&sc->sc_tmp, sizeof(sc->sc_tmp));
bcopy(krp->krp_param[LOFN_MODEXP_PAR_M].crp_p, &sc->sc_tmp,
  384             (mbits + 7) / 8);
lofn_write_reg(sc, 0, &sc->sc_tmp);
mshift = 1024 - nbits;
WRITE_REG(sc, LOFN_LENADDR(LOFN_WIN_2, 0), 1024);
  389         if (mshift != 0) {
WRITE_REG(sc, LOFN_REL_INSTR + ip,
LOFN_INSTR2(0, OP_CODE_SL, 0, 0, mshift));
ip += 4;
WRITE_REG(sc, LOFN_REL_INSTR + ip,
LOFN_INSTR2(0, OP_CODE_TAG, 0, 0, nbits));
ip += 4;
  397         }
  399         /* Write out E... */
ebits = lofn_norm_sigbits(krp->krp_param[LOFN_MODEXP_PAR_E].crp_p,
krp->krp_param[LOFN_MODEXP_PAR_E].crp_nbits);
  402         if (ebits > 1024 || ebits > nbits) {
err = E2BIG;
  404                 goto errout;
  405         }
  406         if (ebits < 1) {
err = ERANGE;
  408                 goto errout;
  409         }
bzero(&sc->sc_tmp, sizeof(sc->sc_tmp));
bcopy(krp->krp_param[LOFN_MODEXP_PAR_E].crp_p, &sc->sc_tmp,
  412             (ebits + 7) / 8);
lofn_write_reg(sc, 1, &sc->sc_tmp);
eshift = 1024 - nbits;
WRITE_REG(sc, LOFN_LENADDR(LOFN_WIN_2, 1), 1024);
  417         if (eshift != 0) {
WRITE_REG(sc, LOFN_REL_INSTR + ip,
LOFN_INSTR2(0, OP_CODE_SL, 1, 1, eshift));
ip += 4;
WRITE_REG(sc, LOFN_REL_INSTR + ip,
LOFN_INSTR2(0, OP_CODE_TAG, 1, 1, nbits));
ip += 4;
  425         }
  427         if (nshift == 0) {
WRITE_REG(sc, LOFN_REL_INSTR + ip,
LOFN_INSTR(OP_DONE, OP_CODE_MODEXP, 3, 0, 1, 2));
ip += 4;
  431         } else {
WRITE_REG(sc, LOFN_REL_INSTR + ip,
LOFN_INSTR(0, OP_CODE_MODEXP, 3, 0, 1, 2));
ip += 4;
WRITE_REG(sc, LOFN_REL_INSTR + ip,
LOFN_INSTR2(0, OP_CODE_SR, 3, 3, nshift));
ip += 4;
WRITE_REG(sc, LOFN_REL_INSTR + ip,
LOFN_INSTR2(OP_DONE, OP_CODE_TAG, 3, 3, nbits));
ip += 4;
  443         }
  445         /* Start microprogram */
WRITE_REG(sc, LOFN_REL_CR, 0);
  448         return (0);
errout:
bzero(&sc->sc_tmp, sizeof(sc->sc_tmp));
lofn_zero_reg(sc, 0);
lofn_zero_reg(sc, 1);
lofn_zero_reg(sc, 2);
lofn_zero_reg(sc, 3);
krp->krp_status = err;
crypto_kdone(krp);
  458         return (1);
  459 }
  461 void
lofn_modexp_finish(sc, q)
  463         struct lofn_softc *sc;
  464         struct lofn_q *q;
  465 {
  466         struct cryptkop *krp = q->q_krp;
  467         int reglen, crplen;
lofn_read_reg(sc, 3, &sc->sc_tmp);
reglen = ((READ_REG(sc, LOFN_LENADDR(LOFN_WIN_2, 3)) & LOFN_LENMASK) +
  472             7) / 8;
crplen = (krp->krp_param[krp->krp_iparams].crp_nbits + 7) / 8;
  475         if (crplen <= reglen)
bcopy(sc->sc_tmp.b, krp->krp_param[krp->krp_iparams].crp_p,
reglen);
  478         else {
bcopy(sc->sc_tmp.b, krp->krp_param[krp->krp_iparams].crp_p,
reglen);
bzero(krp->krp_param[krp->krp_iparams].crp_p + reglen,
crplen - reglen);
  483         }
bzero(&sc->sc_tmp, sizeof(sc->sc_tmp));
lofn_zero_reg(sc, 0);
lofn_zero_reg(sc, 1);
lofn_zero_reg(sc, 2);
lofn_zero_reg(sc, 3);
crypto_kdone(krp);
  490 }
  492 /*
  493  * Return the number of significant bits of a big number.
  494  */
  495 int
lofn_norm_sigbits(const u_int8_t *p, u_int pbits)
  497 {
u_int plen = (pbits + 7) / 8;
  499         int i, sig = plen * 8;
u_int8_t c;
  502         for (i = plen - 1; i >= 0; i--) {
c = p[i];
  504                 if (c != 0) {
  505                         while ((c & 0x80) == 0) {
sig--;
c <<= 1;
  508                         }
  509                         break;
  510                 }
sig -= 8;
  512         }
  513         return (sig);
  514 }
  516 void
lofn_feed(sc)
  518         struct lofn_softc *sc;
  519 {
  520         struct lofn_q *q;
  522         /* Queue is empty and nothing being processed, turn off interrupt */
  523         if (SIMPLEQ_EMPTY(&sc->sc_queue) &&
sc->sc_current == NULL) {
sc->sc_ier &= ~LOFN_IER_DONE;
WRITE_REG(sc, LOFN_REL_IER, sc->sc_ier);
  527                 return;
  528         }
  530         /* Operation already pending, wait. */
  531         if (sc->sc_current != NULL)
  532                 return;
  534         while (!SIMPLEQ_EMPTY(&sc->sc_queue)) {
q = SIMPLEQ_FIRST(&sc->sc_queue);
  536                 if (q->q_start(sc, q) == 0) {
sc->sc_current = q;
SIMPLEQ_REMOVE_HEAD(&sc->sc_queue, q_next);
sc->sc_ier |= LOFN_IER_DONE;
WRITE_REG(sc, LOFN_REL_IER, sc->sc_ier);
  541                         break;
  542                 } else {
SIMPLEQ_REMOVE_HEAD(&sc->sc_queue, q_next);
free(q, M_DEVBUF);
  545                 }
  546         }
  547 }