Merge git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6

Merge the crypto tree to pull in the qat adf_init_pf_wq change.

diff --combined drivers/crypto/qat/qat_common/adf_common_drv.h
index 557ea36,1555102..ff0b37b
--- 1/drivers/crypto/qat/qat_common/adf_common_drv.h
--- 2/drivers/crypto/qat/qat_common/adf_common_drv.h
+++ b/drivers/crypto/qat/qat_common/adf_common_drv.h
@@@ -67,7 -67,7 +67,7 @@@
  #define ADF_STATUS_AE_INITIALISED 4
  #define ADF_STATUS_AE_UCODE_LOADED 5
  #define ADF_STATUS_AE_STARTED 6
 -#define ADF_STATUS_ORPHAN_TH_RUNNING 7
 +#define ADF_STATUS_PF_RUNNING 7
  #define ADF_STATUS_IRQ_ALLOCATED 8
  
  enum adf_dev_reset_mode {
@@@ -103,7 -103,7 +103,7 @@@ int adf_service_unregister(struct servi
  
  int adf_dev_init(struct adf_accel_dev *accel_dev);
  int adf_dev_start(struct adf_accel_dev *accel_dev);
 -int adf_dev_stop(struct adf_accel_dev *accel_dev);
 +void adf_dev_stop(struct adf_accel_dev *accel_dev);
  void adf_dev_shutdown(struct adf_accel_dev *accel_dev);
  
  int adf_iov_putmsg(struct adf_accel_dev *accel_dev, u32 msg, u8 vf_nr);
@@@ -144,8 -144,8 +144,10 @@@ void adf_disable_aer(struct adf_accel_d
  void adf_dev_restore(struct adf_accel_dev *accel_dev);
  int adf_init_aer(void);
  void adf_exit_aer(void);
 +int adf_init_vf_wq(void);
 +void adf_exit_vf_wq(void);
+ int adf_init_pf_wq(void);
+ void adf_exit_pf_wq(void);
  int adf_init_admin_comms(struct adf_accel_dev *accel_dev);
  void adf_exit_admin_comms(struct adf_accel_dev *accel_dev);
  int adf_send_admin_init(struct adf_accel_dev *accel_dev);
@@@ -238,9 -238,6 +240,9 @@@ void adf_enable_vf2pf_interrupts(struc
                                 uint32_t vf_mask);
  void adf_enable_pf2vf_interrupts(struct adf_accel_dev *accel_dev);
  void adf_disable_pf2vf_interrupts(struct adf_accel_dev *accel_dev);
 +
 +int adf_vf2pf_init(struct adf_accel_dev *accel_dev);
 +void adf_vf2pf_shutdown(struct adf_accel_dev *accel_dev);
  #else
  static inline int adf_sriov_configure(struct pci_dev *pdev, int numvfs)
  {
@@@ -258,14 -255,5 +260,14 @@@ static inline void adf_enable_pf2vf_int
  static inline void adf_disable_pf2vf_interrupts(struct adf_accel_dev *accel_dev)
  {
  }
 +
 +static inline int adf_vf2pf_init(struct adf_accel_dev *accel_dev)
 +{
 +      return 0;
 +}
 +
 +static inline void adf_vf2pf_shutdown(struct adf_accel_dev *accel_dev)
 +{
 +}
  #endif
  #endif

diff --combined drivers/crypto/qat/qat_common/adf_ctl_drv.c
index 116ddda,3c3f948..db21b49
--- 1/drivers/crypto/qat/qat_common/adf_ctl_drv.c
--- 2/drivers/crypto/qat/qat_common/adf_ctl_drv.c
+++ b/drivers/crypto/qat/qat_common/adf_ctl_drv.c
@@@ -275,27 -275,18 +275,27 @@@ static int adf_ctl_stop_devices(uint32_
        struct adf_accel_dev *accel_dev;
        int ret = 0;
  
 -      list_for_each_entry_reverse(accel_dev, adf_devmgr_get_head(), list) {
 +      list_for_each_entry(accel_dev, adf_devmgr_get_head(), list) {
                if (id == accel_dev->accel_id || id == ADF_CFG_ALL_DEVICES) {
                        if (!adf_dev_started(accel_dev))
                                continue;
  
 -                      if (adf_dev_stop(accel_dev)) {
 -                              dev_err(&GET_DEV(accel_dev),
 -                                      "Failed to stop qat_dev%d\n", id);
 -                              ret = -EFAULT;
 -                      } else {
 -                              adf_dev_shutdown(accel_dev);
 -                      }
 +                      /* First stop all VFs */
 +                      if (!accel_dev->is_vf)
 +                              continue;
 +
 +                      adf_dev_stop(accel_dev);
 +                      adf_dev_shutdown(accel_dev);
 +              }
 +      }
 +
 +      list_for_each_entry(accel_dev, adf_devmgr_get_head(), list) {
 +              if (id == accel_dev->accel_id || id == ADF_CFG_ALL_DEVICES) {
 +                      if (!adf_dev_started(accel_dev))
 +                              continue;
 +
 +                      adf_dev_stop(accel_dev);
 +                      adf_dev_shutdown(accel_dev);
                }
        }
        return ret;
@@@ -471,17 -462,17 +471,22 @@@ static int __init adf_register_ctl_devi
        if (adf_init_aer())
                goto err_aer;
  
+       if (adf_init_pf_wq())
+               goto err_pf_wq;
+ 
 +      if (adf_init_vf_wq())
 +              goto err_vf_wq;
 +
        if (qat_crypto_register())
                goto err_crypto_register;
  
        return 0;
  
  err_crypto_register:
 +      adf_exit_vf_wq();
 +err_vf_wq:
+       adf_exit_pf_wq();
+ err_pf_wq:
        adf_exit_aer();
  err_aer:
        adf_chr_drv_destroy();
@@@ -494,7 -485,7 +499,8 @@@ static void __exit adf_unregister_ctl_d
  {
        adf_chr_drv_destroy();
        adf_exit_aer();
 +      adf_exit_vf_wq();
+       adf_exit_pf_wq();
        qat_crypto_unregister();
        adf_clean_vf_map(false);
        mutex_destroy(&adf_ctl_lock);

diff --combined drivers/crypto/qat/qat_common/adf_sriov.c
index 4479b0b,38a0415..4a526e2
--- 1/drivers/crypto/qat/qat_common/adf_sriov.c
--- 2/drivers/crypto/qat/qat_common/adf_sriov.c
+++ b/drivers/crypto/qat/qat_common/adf_sriov.c
@@@ -119,11 -119,6 +119,6 @@@ static int adf_enable_sriov(struct adf_
        int i;
        u32 reg;
  
-       /* Workqueue for PF2VF responses */
-       pf2vf_resp_wq = create_workqueue("qat_pf2vf_resp_wq");
-       if (!pf2vf_resp_wq)
-               return -ENOMEM;
- 
        for (i = 0, vf_info = accel_dev->pf.vf_info; i < totalvfs;
             i++, vf_info++) {
                /* This ptr will be populated when VFs will be created */
@@@ -216,11 -211,6 +211,6 @@@ void adf_disable_sriov(struct adf_accel
  
        kfree(accel_dev->pf.vf_info);
        accel_dev->pf.vf_info = NULL;
- 
-       if (pf2vf_resp_wq) {
-               destroy_workqueue(pf2vf_resp_wq);
-               pf2vf_resp_wq = NULL;
-       }
  }
  EXPORT_SYMBOL_GPL(adf_disable_sriov);
  
@@@ -259,7 -249,13 +249,7 @@@ int adf_sriov_configure(struct pci_dev 
                        return -EBUSY;
                }
  
 -              if (adf_dev_stop(accel_dev)) {
 -                      dev_err(&GET_DEV(accel_dev),
 -                              "Failed to stop qat_dev%d\n",
 -                              accel_dev->accel_id);
 -                      return -EFAULT;
 -              }
 -
 +              adf_dev_stop(accel_dev);
                adf_dev_shutdown(accel_dev);
        }
  
@@@ -298,3 -294,19 +288,19 @@@
        return numvfs;
  }
  EXPORT_SYMBOL_GPL(adf_sriov_configure);
+ 
+ int __init adf_init_pf_wq(void)
+ {
+       /* Workqueue for PF2VF responses */
+       pf2vf_resp_wq = create_workqueue("qat_pf2vf_resp_wq");
+ 
+       return !pf2vf_resp_wq ? -ENOMEM : 0;
+ }
+ 
+ void adf_exit_pf_wq(void)
+ {
+       if (pf2vf_resp_wq) {
+               destroy_workqueue(pf2vf_resp_wq);
+               pf2vf_resp_wq = NULL;
+       }
+ }

diff --combined drivers/crypto/talitos.c
index f3b5401,aae0554..b7ee8d3
--- 1/drivers/crypto/talitos.c
--- 2/drivers/crypto/talitos.c
+++ b/drivers/crypto/talitos.c
@@@ -63,6 -63,14 +63,14 @@@ static void to_talitos_ptr(struct talit
                ptr->eptr = upper_32_bits(dma_addr);
  }
  
+ static void copy_talitos_ptr(struct talitos_ptr *dst_ptr,
+                            struct talitos_ptr *src_ptr, bool is_sec1)
+ {
+       dst_ptr->ptr = src_ptr->ptr;
+       if (!is_sec1)
+               dst_ptr->eptr = src_ptr->eptr;
+ }
+ 
  static void to_talitos_ptr_len(struct talitos_ptr *ptr, unsigned int len,
                               bool is_sec1)
  {
@@@ -827,16 -835,6 +835,16 @@@ struct talitos_ahash_req_ctx 
        struct scatterlist *psrc;
  };
  
 +struct talitos_export_state {
 +      u32 hw_context[TALITOS_MDEU_MAX_CONTEXT_SIZE / sizeof(u32)];
 +      u8 buf[HASH_MAX_BLOCK_SIZE];
 +      unsigned int swinit;
 +      unsigned int first;
 +      unsigned int last;
 +      unsigned int to_hash_later;
 +      unsigned int nbuf;
 +};
 +
  static int aead_setkey(struct crypto_aead *authenc,
                       const u8 *key, unsigned int keylen)
  {
@@@ -1093,21 -1091,20 +1101,20 @@@ static int ipsec_esp(struct talitos_ede
        sg_count = dma_map_sg(dev, areq->src, edesc->src_nents ?: 1,
                              (areq->src == areq->dst) ? DMA_BIDIRECTIONAL
                                                           : DMA_TO_DEVICE);
- 
        /* hmac data */
        desc->ptr[1].len = cpu_to_be16(areq->assoclen);
        if (sg_count > 1 &&
            (ret = sg_to_link_tbl_offset(areq->src, sg_count, 0,
                                         areq->assoclen,
                                         &edesc->link_tbl[tbl_off])) > 1) {
-               tbl_off += ret;
- 
                to_talitos_ptr(&desc->ptr[1], edesc->dma_link_tbl + tbl_off *
                               sizeof(struct talitos_ptr), 0);
                desc->ptr[1].j_extent = DESC_PTR_LNKTBL_JUMP;
  
                dma_sync_single_for_device(dev, edesc->dma_link_tbl,
                                           edesc->dma_len, DMA_BIDIRECTIONAL);
+ 
+               tbl_off += ret;
        } else {
                to_talitos_ptr(&desc->ptr[1], sg_dma_address(areq->src), 0);
                desc->ptr[1].j_extent = 0;
@@@ -1136,11 -1133,13 +1143,13 @@@
        if (edesc->desc.hdr & DESC_HDR_MODE1_MDEU_CICV)
                sg_link_tbl_len += authsize;
  
-       if (sg_count > 1 &&
-           (ret = sg_to_link_tbl_offset(areq->src, sg_count, areq->assoclen,
-                                        sg_link_tbl_len,
-                                        &edesc->link_tbl[tbl_off])) > 1) {
-               tbl_off += ret;
+       if (sg_count == 1) {
+               to_talitos_ptr(&desc->ptr[4], sg_dma_address(areq->src) +
+                              areq->assoclen, 0);
+       } else if ((ret = sg_to_link_tbl_offset(areq->src, sg_count,
+                                               areq->assoclen, sg_link_tbl_len,
+                                               &edesc->link_tbl[tbl_off])) >
+                  1) {
                desc->ptr[4].j_extent |= DESC_PTR_LNKTBL_JUMP;
                to_talitos_ptr(&desc->ptr[4], edesc->dma_link_tbl +
                                              tbl_off *
@@@ -1148,8 -1147,10 +1157,10 @@@
                dma_sync_single_for_device(dev, edesc->dma_link_tbl,
                                           edesc->dma_len,
                                           DMA_BIDIRECTIONAL);
-       } else
-               to_talitos_ptr(&desc->ptr[4], sg_dma_address(areq->src), 0);
+               tbl_off += ret;
+       } else {
+               copy_talitos_ptr(&desc->ptr[4], &edesc->link_tbl[tbl_off], 0);
+       }
  
        /* cipher out */
        desc->ptr[5].len = cpu_to_be16(cryptlen);
@@@ -1161,11 -1162,13 +1172,13 @@@
  
        edesc->icv_ool = false;
  
-       if (sg_count > 1 &&
-           (sg_count = sg_to_link_tbl_offset(areq->dst, sg_count,
+       if (sg_count == 1) {
+               to_talitos_ptr(&desc->ptr[5], sg_dma_address(areq->dst) +
+                              areq->assoclen, 0);
+       } else if ((sg_count =
+                       sg_to_link_tbl_offset(areq->dst, sg_count,
                                              areq->assoclen, cryptlen,
-                                             &edesc->link_tbl[tbl_off])) >
-           1) {
+                                             &edesc->link_tbl[tbl_off])) > 1) {
                struct talitos_ptr *tbl_ptr = &edesc->link_tbl[tbl_off];
  
                to_talitos_ptr(&desc->ptr[5], edesc->dma_link_tbl +
@@@ -1188,8 -1191,9 +1201,9 @@@
                                           edesc->dma_len, DMA_BIDIRECTIONAL);
  
                edesc->icv_ool = true;
-       } else
-               to_talitos_ptr(&desc->ptr[5], sg_dma_address(areq->dst), 0);
+       } else {
+               copy_talitos_ptr(&desc->ptr[5], &edesc->link_tbl[tbl_off], 0);
+       }
  
        /* iv out */
        map_single_talitos_ptr(dev, &desc->ptr[6], ivsize, ctx->iv,
@@@ -1977,46 -1981,6 +1991,46 @@@ static int ahash_digest(struct ahash_re
        return ahash_process_req(areq, areq->nbytes);
  }
  
 +static int ahash_export(struct ahash_request *areq, void *out)
 +{
 +      struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq);
 +      struct talitos_export_state *export = out;
 +
 +      memcpy(export->hw_context, req_ctx->hw_context,
 +             req_ctx->hw_context_size);
 +      memcpy(export->buf, req_ctx->buf, req_ctx->nbuf);
 +      export->swinit = req_ctx->swinit;
 +      export->first = req_ctx->first;
 +      export->last = req_ctx->last;
 +      export->to_hash_later = req_ctx->to_hash_later;
 +      export->nbuf = req_ctx->nbuf;
 +
 +      return 0;
 +}
 +
 +static int ahash_import(struct ahash_request *areq, const void *in)
 +{
 +      struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq);
 +      struct crypto_ahash *tfm = crypto_ahash_reqtfm(areq);
 +      const struct talitos_export_state *export = in;
 +
 +      memset(req_ctx, 0, sizeof(*req_ctx));
 +      req_ctx->hw_context_size =
 +              (crypto_ahash_digestsize(tfm) <= SHA256_DIGEST_SIZE)
 +                      ? TALITOS_MDEU_CONTEXT_SIZE_MD5_SHA1_SHA256
 +                      : TALITOS_MDEU_CONTEXT_SIZE_SHA384_SHA512;
 +      memcpy(req_ctx->hw_context, export->hw_context,
 +             req_ctx->hw_context_size);
 +      memcpy(req_ctx->buf, export->buf, export->nbuf);
 +      req_ctx->swinit = export->swinit;
 +      req_ctx->first = export->first;
 +      req_ctx->last = export->last;
 +      req_ctx->to_hash_later = export->to_hash_later;
 +      req_ctx->nbuf = export->nbuf;
 +
 +      return 0;
 +}
 +
  struct keyhash_result {
        struct completion completion;
        int err;
@@@ -2494,7 -2458,6 +2508,7 @@@ static struct talitos_alg_template driv
        {       .type = CRYPTO_ALG_TYPE_AHASH,
                .alg.hash = {
                        .halg.digestsize = MD5_DIGEST_SIZE,
 +                      .halg.statesize = sizeof(struct talitos_export_state),
                        .halg.base = {
                                .cra_name = "md5",
                                .cra_driver_name = "md5-talitos",
@@@ -2510,7 -2473,6 +2524,7 @@@
        {       .type = CRYPTO_ALG_TYPE_AHASH,
                .alg.hash = {
                        .halg.digestsize = SHA1_DIGEST_SIZE,
 +                      .halg.statesize = sizeof(struct talitos_export_state),
                        .halg.base = {
                                .cra_name = "sha1",
                                .cra_driver_name = "sha1-talitos",
@@@ -2526,7 -2488,6 +2540,7 @@@
        {       .type = CRYPTO_ALG_TYPE_AHASH,
                .alg.hash = {
                        .halg.digestsize = SHA224_DIGEST_SIZE,
 +                      .halg.statesize = sizeof(struct talitos_export_state),
                        .halg.base = {
                                .cra_name = "sha224",
                                .cra_driver_name = "sha224-talitos",
@@@ -2542,7 -2503,6 +2556,7 @@@
        {       .type = CRYPTO_ALG_TYPE_AHASH,
                .alg.hash = {
                        .halg.digestsize = SHA256_DIGEST_SIZE,
 +                      .halg.statesize = sizeof(struct talitos_export_state),
                        .halg.base = {
                                .cra_name = "sha256",
                                .cra_driver_name = "sha256-talitos",
@@@ -2558,7 -2518,6 +2572,7 @@@
        {       .type = CRYPTO_ALG_TYPE_AHASH,
                .alg.hash = {
                        .halg.digestsize = SHA384_DIGEST_SIZE,
 +                      .halg.statesize = sizeof(struct talitos_export_state),
                        .halg.base = {
                                .cra_name = "sha384",
                                .cra_driver_name = "sha384-talitos",
@@@ -2574,7 -2533,6 +2588,7 @@@
        {       .type = CRYPTO_ALG_TYPE_AHASH,
                .alg.hash = {
                        .halg.digestsize = SHA512_DIGEST_SIZE,
 +                      .halg.statesize = sizeof(struct talitos_export_state),
                        .halg.base = {
                                .cra_name = "sha512",
                                .cra_driver_name = "sha512-talitos",
@@@ -2590,7 -2548,6 +2604,7 @@@
        {       .type = CRYPTO_ALG_TYPE_AHASH,
                .alg.hash = {
                        .halg.digestsize = MD5_DIGEST_SIZE,
 +                      .halg.statesize = sizeof(struct talitos_export_state),
                        .halg.base = {
                                .cra_name = "hmac(md5)",
                                .cra_driver_name = "hmac-md5-talitos",
@@@ -2606,7 -2563,6 +2620,7 @@@
        {       .type = CRYPTO_ALG_TYPE_AHASH,
                .alg.hash = {
                        .halg.digestsize = SHA1_DIGEST_SIZE,
 +                      .halg.statesize = sizeof(struct talitos_export_state),
                        .halg.base = {
                                .cra_name = "hmac(sha1)",
                                .cra_driver_name = "hmac-sha1-talitos",
@@@ -2622,7 -2578,6 +2636,7 @@@
        {       .type = CRYPTO_ALG_TYPE_AHASH,
                .alg.hash = {
                        .halg.digestsize = SHA224_DIGEST_SIZE,
 +                      .halg.statesize = sizeof(struct talitos_export_state),
                        .halg.base = {
                                .cra_name = "hmac(sha224)",
                                .cra_driver_name = "hmac-sha224-talitos",
@@@ -2638,7 -2593,6 +2652,7 @@@
        {       .type = CRYPTO_ALG_TYPE_AHASH,
                .alg.hash = {
                        .halg.digestsize = SHA256_DIGEST_SIZE,
 +                      .halg.statesize = sizeof(struct talitos_export_state),
                        .halg.base = {
                                .cra_name = "hmac(sha256)",
                                .cra_driver_name = "hmac-sha256-talitos",
@@@ -2654,7 -2608,6 +2668,7 @@@
        {       .type = CRYPTO_ALG_TYPE_AHASH,
                .alg.hash = {
                        .halg.digestsize = SHA384_DIGEST_SIZE,
 +                      .halg.statesize = sizeof(struct talitos_export_state),
                        .halg.base = {
                                .cra_name = "hmac(sha384)",
                                .cra_driver_name = "hmac-sha384-talitos",
@@@ -2670,7 -2623,6 +2684,7 @@@
        {       .type = CRYPTO_ALG_TYPE_AHASH,
                .alg.hash = {
                        .halg.digestsize = SHA512_DIGEST_SIZE,
 +                      .halg.statesize = sizeof(struct talitos_export_state),
                        .halg.base = {
                                .cra_name = "hmac(sha512)",
                                .cra_driver_name = "hmac-sha512-talitos",
@@@ -2691,21 -2643,11 +2705,11 @@@ struct talitos_crypto_alg 
        struct talitos_alg_template algt;
  };
  
- static int talitos_cra_init(struct crypto_tfm *tfm)
+ static int talitos_init_common(struct talitos_ctx *ctx,
+                              struct talitos_crypto_alg *talitos_alg)
  {
-       struct crypto_alg *alg = tfm->__crt_alg;
-       struct talitos_crypto_alg *talitos_alg;
-       struct talitos_ctx *ctx = crypto_tfm_ctx(tfm);
        struct talitos_private *priv;
  
-       if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_AHASH)
-               talitos_alg = container_of(__crypto_ahash_alg(alg),
-                                          struct talitos_crypto_alg,
-                                          algt.alg.hash);
-       else
-               talitos_alg = container_of(alg, struct talitos_crypto_alg,
-                                          algt.alg.crypto);
- 
        /* update context with ptr to dev */
        ctx->dev = talitos_alg->dev;
  
@@@ -2723,10 -2665,33 +2727,33 @@@
        return 0;
  }
  
+ static int talitos_cra_init(struct crypto_tfm *tfm)
+ {
+       struct crypto_alg *alg = tfm->__crt_alg;
+       struct talitos_crypto_alg *talitos_alg;
+       struct talitos_ctx *ctx = crypto_tfm_ctx(tfm);
+ 
+       if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_AHASH)
+               talitos_alg = container_of(__crypto_ahash_alg(alg),
+                                          struct talitos_crypto_alg,
+                                          algt.alg.hash);
+       else
+               talitos_alg = container_of(alg, struct talitos_crypto_alg,
+                                          algt.alg.crypto);
+ 
+       return talitos_init_common(ctx, talitos_alg);
+ }
+ 
  static int talitos_cra_init_aead(struct crypto_aead *tfm)
  {
-       talitos_cra_init(crypto_aead_tfm(tfm));
-       return 0;
+       struct aead_alg *alg = crypto_aead_alg(tfm);
+       struct talitos_crypto_alg *talitos_alg;
+       struct talitos_ctx *ctx = crypto_aead_ctx(tfm);
+ 
+       talitos_alg = container_of(alg, struct talitos_crypto_alg,
+                                  algt.alg.aead);
+ 
+       return talitos_init_common(ctx, talitos_alg);
  }
  
  static int talitos_cra_init_ahash(struct crypto_tfm *tfm)
@@@ -2849,8 -2814,6 +2876,8 @@@ static struct talitos_crypto_alg *talit
                t_alg->algt.alg.hash.finup = ahash_finup;
                t_alg->algt.alg.hash.digest = ahash_digest;
                t_alg->algt.alg.hash.setkey = ahash_setkey;
 +              t_alg->algt.alg.hash.import = ahash_import;
 +              t_alg->algt.alg.hash.export = ahash_export;
  
                if (!(priv->features & TALITOS_FTR_HMAC_OK) &&
                    !strncmp(alg->cra_name, "hmac", 4)) {