[BACK]Return to hifn7751.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / dev / pci

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/dev/pci/hifn7751.c between version 1.19 and 1.20

version 1.19, 2003/08/28 18:13:33 version 1.20, 2003/11/16 00:22:09
Line 1 
Line 1 
 /*      $NetBSD$        */  /*      $NetBSD$        */
 /*      $FreeBSD: hifn7751.c,v 1.5.2.6 2003/07/02 17:04:50 sam Exp $ */  /*      $FreeBSD: hifn7751.c,v 1.5.2.7 2003/10/08 23:52:00 sam Exp $ */
 /*      $OpenBSD: hifn7751.c,v 1.140 2003/08/01 17:55:54 deraadt Exp $  */  /*      $OpenBSD: hifn7751.c,v 1.140 2003/08/01 17:55:54 deraadt Exp $  */
   
 /*  /*
Line 8 
Line 8 
  * Copyright (c) 1999 Theo de Raadt   * Copyright (c) 1999 Theo de Raadt
  * Copyright (c) 2000-2001 Network Security Technologies, Inc.   * Copyright (c) 2000-2001 Network Security Technologies, Inc.
  *                      http://www.netsec.net   *                      http://www.netsec.net
    * Copyright (c) 2003 Hifn Inc.
  *   *
  * This driver is based on a previous driver by Invertex, for which they   * This driver is based on a previous driver by Invertex, for which they
  * requested:  Please send any comments, feedback, bug-fixes, or feature   * requested:  Please send any comments, feedback, bug-fixes, or feature
Line 43 
Line 44 
  */   */
   
 /*  /*
  * Driver for the Hifn 7751 encryption processor.   * Driver for various  Hifn pre-HIPP encryption processors.
  */   */
   
 #include <sys/cdefs.h>  #include <sys/cdefs.h>
Line 204  static const struct hifn_product {
Line 205  static const struct hifn_product {
           "Hifn 7951",            "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,          { 0,                    0,
           0,            0,
Line 341  hifn_attach(struct device *parent, struc
Line 352  hifn_attach(struct device *parent, struc
         hifn_init_dma(sc);          hifn_init_dma(sc);
         hifn_init_pci_registers(sc);          hifn_init_pci_registers(sc);
   
         if (hifn_ramtype(sc))          /* XXX can't dynamically determine ram type for 795x; force dram */
           if (sc->sc_flags & HIFN_IS_7956)
                   sc->sc_drammodel = 1;
           else if (hifn_ramtype(sc))
                 goto fail_mem;                  goto fail_mem;
   
         if (sc->sc_drammodel == 0)          if (sc->sc_drammodel == 0)
Line 408  hifn_attach(struct device *parent, struc
Line 422  hifn_attach(struct device *parent, struc
                     hifn_newsession, hifn_freesession, hifn_process, sc);                      hifn_newsession, hifn_freesession, hifn_process, sc);
                 crypto_register(sc->sc_cid, CRYPTO_ARC4, 0, 0,                  crypto_register(sc->sc_cid, CRYPTO_ARC4, 0, 0,
                     hifn_newsession, hifn_freesession, hifn_process, sc);                      hifn_newsession, hifn_freesession, hifn_process, sc);
                   if (sc->sc_flags & HIFN_HAS_AES)
                           crypto_register(sc->sc_cid, CRYPTO_AES_CBC,  0, 0,
                                   hifn_newsession, hifn_freesession,
                                   hifn_process, sc);
                 /*FALLTHROUGH*/                  /*FALLTHROUGH*/
         case HIFN_PUSTAT_ENA_1:          case HIFN_PUSTAT_ENA_1:
                 crypto_register(sc->sc_cid, CRYPTO_MD5, 0, 0,                  crypto_register(sc->sc_cid, CRYPTO_MD5, 0, 0,
Line 698  struct pci2id {
Line 716  struct pci2id {
                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,                  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                   0x00, 0x00, 0x00, 0x00, 0x00 }                    0x00, 0x00, 0x00, 0x00, 0x00 }
         }, {          }, {
                   PCI_VENDOR_HIFN,
                   PCI_PRODUCT_HIFN_7955,
                   { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                     0x00, 0x00, 0x00, 0x00, 0x00 }
           }, {
                   PCI_VENDOR_HIFN,
                   PCI_PRODUCT_HIFN_7956,
                   { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                     0x00, 0x00, 0x00, 0x00, 0x00 }
           }, {
                 PCI_VENDOR_NETSEC,                  PCI_VENDOR_NETSEC,
                 PCI_PRODUCT_NETSEC_7751,                  PCI_PRODUCT_NETSEC_7751,
                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,                  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
Line 880  hifn_init_pci_registers(struct hifn_soft
Line 908  hifn_init_pci_registers(struct hifn_soft
         WRITE_REG_1(sc, HIFN_1_DMA_IER, sc->sc_dmaier);          WRITE_REG_1(sc, HIFN_1_DMA_IER, sc->sc_dmaier);
         CLR_LED(sc, HIFN_MIPSRST_LED0 | HIFN_MIPSRST_LED1 | HIFN_MIPSRST_LED2);          CLR_LED(sc, HIFN_MIPSRST_LED0 | HIFN_MIPSRST_LED1 | HIFN_MIPSRST_LED2);
   
         WRITE_REG_0(sc, HIFN_0_PUCNFG, HIFN_PUCNFG_COMPSING |          if (sc->sc_flags & HIFN_IS_7956) {
             HIFN_PUCNFG_DRFR_128 | HIFN_PUCNFG_TCALLPHASES |                  WRITE_REG_0(sc, HIFN_0_PUCNFG, HIFN_PUCNFG_COMPSING |
             HIFN_PUCNFG_TCDRVTOTEM | HIFN_PUCNFG_BUS32 |                      HIFN_PUCNFG_TCALLPHASES |
             (sc->sc_drammodel ? HIFN_PUCNFG_DRAM : HIFN_PUCNFG_SRAM));                      HIFN_PUCNFG_TCDRVTOTEM | HIFN_PUCNFG_BUS32);
                   WRITE_REG_1(sc, HIFN_1_PLL, HIFN_PLL_7956);
           } else {
                   WRITE_REG_0(sc, HIFN_0_PUCNFG, HIFN_PUCNFG_COMPSING |
                       HIFN_PUCNFG_DRFR_128 | HIFN_PUCNFG_TCALLPHASES |
                       HIFN_PUCNFG_TCDRVTOTEM | HIFN_PUCNFG_BUS32 |
                       (sc->sc_drammodel ? HIFN_PUCNFG_DRAM : HIFN_PUCNFG_SRAM));
           }
   
         WRITE_REG_0(sc, HIFN_0_PUISR, HIFN_PUISR_DSTOVER);          WRITE_REG_0(sc, HIFN_0_PUISR, HIFN_PUISR_DSTOVER);
         WRITE_REG_1(sc, HIFN_1_DMA_CNFG, HIFN_DMACNFG_MSTRESET |          WRITE_REG_1(sc, HIFN_1_DMA_CNFG, HIFN_DMACNFG_MSTRESET |
Line 912  hifn_sessions(struct hifn_softc *sc)
Line 947  hifn_sessions(struct hifn_softc *sc)
                         ctxsize = 128;                          ctxsize = 128;
                 else                  else
                         ctxsize = 512;                          ctxsize = 512;
                 sc->sc_maxses = 1 +                  /*
                     ((sc->sc_ramsize - 32768) / ctxsize);                   * 7955/7956 has internal context memory of 32K
                    */
                   if (sc->sc_flags & HIFN_IS_7956)
                           sc->sc_maxses = 32768 / ctxsize;
                   else
                           sc->sc_maxses = 1 +
                               ((sc->sc_ramsize - 32768) / ctxsize);
         }          }
         else          else
                 sc->sc_maxses = sc->sc_ramsize / 16384;                  sc->sc_maxses = sc->sc_ramsize / 16384;
Line 1001  hifn_dramsize(struct hifn_softc *sc)
Line 1042  hifn_dramsize(struct hifn_softc *sc)
 {  {
         u_int32_t cnfg;          u_int32_t cnfg;
   
         cnfg = READ_REG_0(sc, HIFN_0_PUCNFG) &          if (sc->sc_flags & HIFN_IS_7956) {
             HIFN_PUCNFG_DRAMMASK;                  /*
         sc->sc_ramsize = 1 << ((cnfg >> 13) + 18);                   * 7955/7956 have a fixed internal ram of only 32K.
                    */
                   sc->sc_ramsize = 32768;
           } else {
                   cnfg = READ_REG_0(sc, HIFN_0_PUCNFG) &
                       HIFN_PUCNFG_DRAMMASK;
                   sc->sc_ramsize = 1 << ((cnfg >> 13) + 18);
           }
         return (0);          return (0);
 }  }
   
Line 1233  hifn_write_command(struct hifn_command *
Line 1281  hifn_write_command(struct hifn_command *
         struct hifn_mac_command *mac_cmd;          struct hifn_mac_command *mac_cmd;
         struct hifn_crypt_command *cry_cmd;          struct hifn_crypt_command *cry_cmd;
         struct hifn_comp_command *comp_cmd;          struct hifn_comp_command *comp_cmd;
         int using_mac, using_crypt, using_comp, len;          int using_mac, using_crypt, using_comp, len, ivlen;
         u_int32_t dlen, slen;          u_int32_t dlen, slen;
   
         buf_pos = buf;          buf_pos = buf;
Line 1307  hifn_write_command(struct hifn_command *
Line 1355  hifn_write_command(struct hifn_command *
                         break;                          break;
                 case HIFN_CRYPT_CMD_ALG_DES:                  case HIFN_CRYPT_CMD_ALG_DES:
                         bcopy(cmd->ck, buf_pos, HIFN_DES_KEY_LENGTH);                          bcopy(cmd->ck, buf_pos, HIFN_DES_KEY_LENGTH);
                         buf_pos += cmd->cklen;                          buf_pos += HIFN_DES_KEY_LENGTH;
                         break;                          break;
                 case HIFN_CRYPT_CMD_ALG_RC4:                  case HIFN_CRYPT_CMD_ALG_RC4:
                         len = 256;                          len = 256;
Line 1322  hifn_write_command(struct hifn_command *
Line 1370  hifn_write_command(struct hifn_command *
                         bzero(buf_pos, 4);                          bzero(buf_pos, 4);
                         buf_pos += 4;                          buf_pos += 4;
                         break;                          break;
                   case HIFN_CRYPT_CMD_ALG_AES:
                           /*
                            * AES keys are variable 128, 192 and
                            * 256 bits (16, 24 and 32 bytes).
                            */
                           bcopy(cmd->ck, buf_pos, cmd->cklen);
                           buf_pos += cmd->cklen;
                           break;
                 }                  }
         }          }
   
         if (using_crypt && cmd->cry_masks & HIFN_CRYPT_CMD_NEW_IV) {          if (using_crypt && cmd->cry_masks & HIFN_CRYPT_CMD_NEW_IV) {
                 bcopy(cmd->iv, buf_pos, HIFN_IV_LENGTH);                  switch (cmd->cry_masks & HIFN_CRYPT_CMD_ALG_MASK) {
                 buf_pos += HIFN_IV_LENGTH;                  case HIFN_CRYPT_CMD_ALG_AES:
                           ivlen = HIFN_AES_IV_LENGTH;
                           break;
                   default:
                           ivlen = HIFN_IV_LENGTH;
                           break;
                   }
                   bcopy(cmd->iv, buf_pos, ivlen);
                   buf_pos += ivlen;
         }          }
   
         if ((cmd->base_masks & (HIFN_BASE_CMD_MAC | HIFN_BASE_CMD_CRYPT |          if ((cmd->base_masks & (HIFN_BASE_CMD_MAC | HIFN_BASE_CMD_CRYPT |
Line 1935  hifn_newsession(void *arg, u_int32_t *si
Line 1999  hifn_newsession(void *arg, u_int32_t *si
                         break;                          break;
                 case CRYPTO_DES_CBC:                  case CRYPTO_DES_CBC:
                 case CRYPTO_3DES_CBC:                  case CRYPTO_3DES_CBC:
                   case CRYPTO_AES_CBC:
 #ifdef __NetBSD__  #ifdef __NetBSD__
                         rnd_extract_data(sc->sc_sessions[i].hs_iv,                          rnd_extract_data(sc->sc_sessions[i].hs_iv,
                             HIFN_IV_LENGTH, RND_EXTRACT_ANY);                              c->cri_alg == CRYPTO_AES_CBC ?
                                   HIFN_AES_IV_LENGTH : HIFN_IV_LENGTH,
                               RND_EXTRACT_ANY);
 #else   /* FreeBSD and OpenBSD have get_random_bytes */  #else   /* FreeBSD and OpenBSD have get_random_bytes */
                         /* XXX this may read fewer, does it matter? */                          /* XXX this may read fewer, does it matter? */
                         get_random_bytes(sc->sc_sessions[i].hs_iv,                          get_random_bytes(sc->sc_sessions[i].hs_iv,
                             HIFN_IV_LENGTH);                                  c->cri_alg == CRYPTO_AES_CBC ?
                                           HIFN_AES_IV_LENGTH : HIFN_IV_LENGTH);
 #endif  #endif
                         /*FALLTHROUGH*/                          /*FALLTHROUGH*/
                 case CRYPTO_ARC4:                  case CRYPTO_ARC4:
Line 2005  hifn_process(void *arg, struct cryptop *
Line 2073  hifn_process(void *arg, struct cryptop *
 {  {
         struct hifn_softc *sc = arg;          struct hifn_softc *sc = arg;
         struct hifn_command *cmd = NULL;          struct hifn_command *cmd = NULL;
         int session, err;          int session, err, ivlen;
         struct cryptodesc *crd1, *crd2, *maccrd, *enccrd;          struct cryptodesc *crd1, *crd2, *maccrd, *enccrd;
   
         if (crp == NULL || crp->crp_callback == NULL) {          if (crp == NULL || crp->crp_callback == NULL) {
Line 2054  hifn_process(void *arg, struct cryptop *
Line 2122  hifn_process(void *arg, struct cryptop *
                         enccrd = NULL;                          enccrd = NULL;
                 } else if (crd1->crd_alg == CRYPTO_DES_CBC ||                  } else if (crd1->crd_alg == CRYPTO_DES_CBC ||
                            crd1->crd_alg == CRYPTO_3DES_CBC ||                             crd1->crd_alg == CRYPTO_3DES_CBC ||
                              crd1->crd_alg == CRYPTO_AES_CBC ||
                            crd1->crd_alg == CRYPTO_ARC4) {                             crd1->crd_alg == CRYPTO_ARC4) {
                         if ((crd1->crd_flags & CRD_F_ENCRYPT) == 0)                          if ((crd1->crd_flags & CRD_F_ENCRYPT) == 0)
                                 cmd->base_masks |= HIFN_BASE_CMD_DECODE;                                  cmd->base_masks |= HIFN_BASE_CMD_DECODE;
Line 2074  hifn_process(void *arg, struct cryptop *
Line 2143  hifn_process(void *arg, struct cryptop *
                      crd1->crd_alg == CRYPTO_SHA1) &&                       crd1->crd_alg == CRYPTO_SHA1) &&
                     (crd2->crd_alg == CRYPTO_DES_CBC ||                      (crd2->crd_alg == CRYPTO_DES_CBC ||
                      crd2->crd_alg == CRYPTO_3DES_CBC ||                       crd2->crd_alg == CRYPTO_3DES_CBC ||
                        crd2->crd_alg == CRYPTO_AES_CBC ||
                      crd2->crd_alg == CRYPTO_ARC4) &&                       crd2->crd_alg == CRYPTO_ARC4) &&
                     ((crd2->crd_flags & CRD_F_ENCRYPT) == 0)) {                      ((crd2->crd_flags & CRD_F_ENCRYPT) == 0)) {
                         cmd->base_masks = HIFN_BASE_CMD_DECODE;                          cmd->base_masks = HIFN_BASE_CMD_DECODE;
Line 2081  hifn_process(void *arg, struct cryptop *
Line 2151  hifn_process(void *arg, struct cryptop *
                         enccrd = crd2;                          enccrd = crd2;
                 } else if ((crd1->crd_alg == CRYPTO_DES_CBC ||                  } else if ((crd1->crd_alg == CRYPTO_DES_CBC ||
                             crd1->crd_alg == CRYPTO_ARC4 ||                              crd1->crd_alg == CRYPTO_ARC4 ||
                             crd1->crd_alg == CRYPTO_3DES_CBC) &&                              crd1->crd_alg == CRYPTO_3DES_CBC ||
                               crd1->crd_alg == CRYPTO_AES_CBC) &&
                            (crd2->crd_alg == CRYPTO_MD5_HMAC ||                             (crd2->crd_alg == CRYPTO_MD5_HMAC ||
                             crd2->crd_alg == CRYPTO_SHA1_HMAC ||                              crd2->crd_alg == CRYPTO_SHA1_HMAC ||
                             crd2->crd_alg == CRYPTO_MD5 ||                              crd2->crd_alg == CRYPTO_MD5 ||
Line 2119  hifn_process(void *arg, struct cryptop *
Line 2190  hifn_process(void *arg, struct cryptop *
                             HIFN_CRYPT_CMD_MODE_CBC |                              HIFN_CRYPT_CMD_MODE_CBC |
                             HIFN_CRYPT_CMD_NEW_IV;                              HIFN_CRYPT_CMD_NEW_IV;
                         break;                          break;
                   case CRYPTO_AES_CBC:
                           cmd->cry_masks |= HIFN_CRYPT_CMD_ALG_AES |
                               HIFN_CRYPT_CMD_MODE_CBC |
                               HIFN_CRYPT_CMD_NEW_IV;
                           break;
                 default:                  default:
                         err = EINVAL;                          err = EINVAL;
                         goto errout;                          goto errout;
                 }                  }
                 if (enccrd->crd_alg != CRYPTO_ARC4) {                  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_ENCRYPT) {
                                 if (enccrd->crd_flags & CRD_F_IV_EXPLICIT)                                  if (enccrd->crd_flags & CRD_F_IV_EXPLICIT)
                                         bcopy(enccrd->crd_iv, cmd->iv,                                          bcopy(enccrd->crd_iv, cmd->iv, ivlen);
                                             HIFN_IV_LENGTH);  
                                 else                                  else
                                         bcopy(sc->sc_sessions[session].hs_iv,                                          bcopy(sc->sc_sessions[session].hs_iv,
                                             cmd->iv, HIFN_IV_LENGTH);                                              cmd->iv, ivlen);
   
                                 if ((enccrd->crd_flags & CRD_F_IV_PRESENT)                                  if ((enccrd->crd_flags & CRD_F_IV_PRESENT)
                                     == 0) {                                      == 0) {
                                         if (crp->crp_flags & CRYPTO_F_IMBUF)                                          if (crp->crp_flags & CRYPTO_F_IMBUF)
                                                 m_copyback(cmd->srcu.src_m,                                                  m_copyback(cmd->srcu.src_m,
                                                     enccrd->crd_inject,                                                      enccrd->crd_inject,
                                                     HIFN_IV_LENGTH, cmd->iv);                                                      ivlen, cmd->iv);
                                         else if (crp->crp_flags & CRYPTO_F_IOV)                                          else if (crp->crp_flags & CRYPTO_F_IOV)
                                                 cuio_copyback(cmd->srcu.src_io,                                                  cuio_copyback(cmd->srcu.src_io,
                                                     enccrd->crd_inject,                                                      enccrd->crd_inject,
                                                     HIFN_IV_LENGTH, cmd->iv);                                                      ivlen, cmd->iv);
                                 }                                  }
                         } else {                          } else {
                                 if (enccrd->crd_flags & CRD_F_IV_EXPLICIT)                                  if (enccrd->crd_flags & CRD_F_IV_EXPLICIT)
                                         bcopy(enccrd->crd_iv, cmd->iv,                                          bcopy(enccrd->crd_iv, cmd->iv, ivlen);
                                             HIFN_IV_LENGTH);  
                                 else if (crp->crp_flags & CRYPTO_F_IMBUF)                                  else if (crp->crp_flags & CRYPTO_F_IMBUF)
                                         m_copydata(cmd->srcu.src_m,                                          m_copydata(cmd->srcu.src_m,
                                             enccrd->crd_inject,                                              enccrd->crd_inject, ivlen, cmd->iv);
                                             HIFN_IV_LENGTH, cmd->iv);  
                                 else if (crp->crp_flags & CRYPTO_F_IOV)                                  else if (crp->crp_flags & CRYPTO_F_IOV)
                                         cuio_copydata(cmd->srcu.src_io,                                          cuio_copydata(cmd->srcu.src_io,
                                             enccrd->crd_inject,                                              enccrd->crd_inject, ivlen, cmd->iv);
                                             HIFN_IV_LENGTH, cmd->iv);  
                         }                          }
                 }                  }
   
                 cmd->ck = enccrd->crd_key;                  cmd->ck = enccrd->crd_key;
                 cmd->cklen = enccrd->crd_klen >> 3;                  cmd->cklen = enccrd->crd_klen >> 3;
   
                   /*
                    * 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)                  if (sc->sc_sessions[session].hs_state == HS_STATE_USED)
                         cmd->cry_masks |= HIFN_CRYPT_CMD_NEW_KEY;                          cmd->cry_masks |= HIFN_CRYPT_CMD_NEW_KEY;
         }          }
Line 2329  hifn_callback(struct hifn_softc *sc, str
Line 2424  hifn_callback(struct hifn_softc *sc, str
         struct cryptop *crp = cmd->crp;          struct cryptop *crp = cmd->crp;
         struct cryptodesc *crd;          struct cryptodesc *crd;
         struct mbuf *m;          struct mbuf *m;
         int totlen, i, u;          int totlen, i, u, ivlen;
   
         if (cmd->src_map == cmd->dst_map)          if (cmd->src_map == cmd->dst_map)
                 bus_dmamap_sync(sc->sc_dmat, cmd->src_map,                  bus_dmamap_sync(sc->sc_dmat, cmd->src_map,
Line 2395  hifn_callback(struct hifn_softc *sc, str
Line 2490  hifn_callback(struct hifn_softc *sc, str
             HIFN_BASE_CMD_CRYPT) {              HIFN_BASE_CMD_CRYPT) {
                 for (crd = crp->crp_desc; crd; crd = crd->crd_next) {                  for (crd = crp->crp_desc; crd; crd = crd->crd_next) {
                         if (crd->crd_alg != CRYPTO_DES_CBC &&                          if (crd->crd_alg != CRYPTO_DES_CBC &&
                             crd->crd_alg != CRYPTO_3DES_CBC)                              crd->crd_alg != CRYPTO_3DES_CBC &&
                               crd->crd_alg != CRYPTO_AES_CBC)
                                 continue;                                  continue;
                           ivlen = ((crd->crd_alg == CRYPTO_AES_CBC) ?
                                   HIFN_AES_IV_LENGTH : HIFN_IV_LENGTH);
                         if (crp->crp_flags & CRYPTO_F_IMBUF)                          if (crp->crp_flags & CRYPTO_F_IMBUF)
                                 m_copydata((struct mbuf *)crp->crp_buf,                                  m_copydata((struct mbuf *)crp->crp_buf,
                                     crd->crd_skip + crd->crd_len - HIFN_IV_LENGTH,                                      crd->crd_skip + crd->crd_len - ivlen,
                                     HIFN_IV_LENGTH,                                      ivlen,
                                     cmd->softc->sc_sessions[cmd->session_num].hs_iv);                                      cmd->softc->sc_sessions[cmd->session_num].hs_iv);
                         else if (crp->crp_flags & CRYPTO_F_IOV) {                          else if (crp->crp_flags & CRYPTO_F_IOV) {
                                 cuio_copydata((struct uio *)crp->crp_buf,                                  cuio_copydata((struct uio *)crp->crp_buf,
                                     crd->crd_skip + crd->crd_len - HIFN_IV_LENGTH,                                      crd->crd_skip + crd->crd_len - ivlen,
                                     HIFN_IV_LENGTH,                                      ivlen,
                                     cmd->softc->sc_sessions[cmd->session_num].hs_iv);                                      cmd->softc->sc_sessions[cmd->session_num].hs_iv);
                         }                          }
                         /* XXX We do not handle contig data */                          /* XXX We do not handle contig data */

Legend:
Removed from v.1.19  
changed lines
  Added in v.1.20

CVSweb <webmaster@jp.NetBSD.org>