* Skip this function for digest, because we use shash logic at
         * cfs_crypto_hash_alloc.
         */
-       if (key != NULL)
+       if (key)
 -              err = crypto_hash_setkey(desc->tfm, key, key_len);
 +              err = crypto_ahash_setkey(tfm, key, key_len);
        else if ((*type)->cht_key != 0)
 -              err = crypto_hash_setkey(desc->tfm,
 +              err = crypto_ahash_setkey(tfm,
                                         (unsigned char *)&((*type)->cht_key),
                                         (*type)->cht_size);
  
        int                     err;
        const struct cfs_crypto_hash_type       *type;
  
-       if (buf == NULL || buf_len == 0 || hash_len == NULL)
+       if (!buf || buf_len == 0 || !hash_len)
                return -EINVAL;
  
 -      err = cfs_crypto_hash_alloc(alg_id, &type, &hdesc, key, key_len);
 +      err = cfs_crypto_hash_alloc(alg_id, &type, &req, key, key_len);
        if (err != 0)
                return err;
  
-       if (hash == NULL || *hash_len < type->cht_size) {
+       if (!hash || *hash_len < type->cht_size) {
                *hash_len = type->cht_size;
 -              crypto_free_hash(hdesc.tfm);
 +              crypto_free_ahash(crypto_ahash_reqtfm(req));
 +              ahash_request_free(req);
                return -ENOSPC;
        }
        sg_init_one(&sl, buf, buf_len);
                          unsigned char *hash, unsigned int *hash_len)
  {
        int     err;
 -      int     size = crypto_hash_digestsize(((struct hash_desc *)hdesc)->tfm);
 +      struct ahash_request *req = (void *)hdesc;
 +      int size = crypto_ahash_digestsize(crypto_ahash_reqtfm(req));
  
-       if (hash_len == NULL) {
+       if (!hash_len) {
 -              crypto_free_hash(((struct hash_desc *)hdesc)->tfm);
 -              kfree(hdesc);
 +              crypto_free_ahash(crypto_ahash_reqtfm(req));
 +              ahash_request_free(req);
                return 0;
        }
-       if (hash == NULL || *hash_len < size) {
+       if (!hash || *hash_len < size) {
                *hash_len = size;
                return -ENOSPC;
        }