gpl-source-mybooklive-010002-update.zipgpl-source-mybooklive-010103-update.zipgpl-source-mybooklive-010002-update.zip

1 files changed, 2857 insertions, 42 deletions

diff --git a/drivers/crypto/amcc/crypto4xx_core.c b/drivers/crypto/amcc/crypto4xx_core.c
index 46e899ac924..8c00e30e9e6 100644
--- a/drivers/crypto/amcc/crypto4xx_core.c
+++ b/drivers/crypto/amcc/crypto4xx_core.c
@@ -28,17 +28,40 @@
 #include <linux/platform_device.h>
 #include <linux/init.h>
 #include <linux/of_platform.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/highmem.h>
 #include <asm/dcr.h>
 #include <asm/dcr-regs.h>
 #include <asm/cacheflush.h>
+#include <crypto/internal/hash.h>
+#include <crypto/algapi.h>
+#include <asm/ppc4xx_ocm.h>
+#include <crypto/internal/hash.h>
+#include <crypto/algapi.h>
 #include <crypto/aes.h>
+#include <crypto/des.h>
 #include <crypto/sha.h>
+#include <crypto/ctr.h>
 #include "crypto4xx_reg_def.h"
 #include "crypto4xx_core.h"
 #include "crypto4xx_sa.h"
 
 #define PPC4XX_SEC_VERSION_STR			"0.5"
-
+void my_dump_Data(const u_char* dptr, u_int size)
+{
+	int i;
+	for (i = 0; i < size; i++) {
+		printk("0x%02x, ", dptr[i]);
+		if ((i+1) % 8 == 0)
+			printk(" ");
+		if ((i+1) % 16 == 0)
+			printk("\n");
+	}
+	printk("\n");
+}
+static struct proc_dir_entry *proc_crypto4xx  = NULL;
+struct proc_dir_entry *entry;
 /**
  * PPC4xx Crypto Engine Initialization Routine
  */
@@ -72,16 +95,24 @@ static void crypto4xx_hw_init(struct crypto4xx_device *dev)
 	writel(pe_dma_cfg.w, dev->ce_base + CRYPTO4XX_PE_DMA_CFG);
 	writel(dev->pdr_pa, dev->ce_base + CRYPTO4XX_PDR_BASE);
 	writel(dev->pdr_pa, dev->ce_base + CRYPTO4XX_RDR_BASE);
-	writel(PPC4XX_PRNG_CTRL_AUTO_EN, dev->ce_base + CRYPTO4XX_PRNG_CTRL);
 	get_random_bytes(&rand_num, sizeof(rand_num));
 	writel(rand_num, dev->ce_base + CRYPTO4XX_PRNG_SEED_L);
 	get_random_bytes(&rand_num, sizeof(rand_num));
 	writel(rand_num, dev->ce_base + CRYPTO4XX_PRNG_SEED_H);
+	writel(PPC4XX_PRNG_CTRL_AUTO_EN, dev->ce_base + CRYPTO4XX_PRNG_CTRL);	
+
 	ring_size.w = 0;
 	ring_size.bf.ring_offset = PPC4XX_PD_SIZE;
 	ring_size.bf.ring_size   = PPC4XX_NUM_PD;
 	writel(ring_size.w, dev->ce_base + CRYPTO4XX_RING_SIZE);
 	ring_ctrl.w = 0;
+
+	if (dev->core_dev->revb_ver == 1) {
+#ifdef CONFIG_SEC_HW_POLL
+		ring_ctrl.bf.ring_retry_divisor = CONFIG_SEC_HW_POLL_RETRY_FREQ;
+		ring_ctrl.bf.ring_poll_divisor = CONFIG_SEC_HW_RING_POLL_FREQ;
+#endif
+	}
 	writel(ring_ctrl.w, dev->ce_base + CRYPTO4XX_RING_CTRL);
 	writel(PPC4XX_DC_3DES_EN, dev->ce_base + CRYPTO4XX_DEVICE_CTRL);
 	writel(dev->gdr_pa, dev->ce_base + CRYPTO4XX_GATH_RING_BASE);
@@ -95,11 +126,19 @@ static void crypto4xx_hw_init(struct crypto4xx_device *dev)
 	io_threshold.bf.output_threshold = PPC4XX_OUTPUT_THRESHOLD;
 	io_threshold.bf.input_threshold  = PPC4XX_INPUT_THRESHOLD;
 	writel(io_threshold.w, dev->ce_base + CRYPTO4XX_IO_THRESHOLD);
+
+#ifdef CONFIG_SEC_PD_OCM
+	writel((dev->pdr_ocm_addr >> 32), dev->ce_base + CRYPTO4XX_PDR_BASE_UADDR);
+	writel((dev->pdr_ocm_addr >> 32), dev->ce_base + CRYPTO4XX_RDR_BASE_UADDR);
+#else
 	writel(0, dev->ce_base + CRYPTO4XX_PDR_BASE_UADDR);
 	writel(0, dev->ce_base + CRYPTO4XX_RDR_BASE_UADDR);
+#endif
 	writel(0, dev->ce_base + CRYPTO4XX_PKT_SRC_UADDR);
 	writel(0, dev->ce_base + CRYPTO4XX_PKT_DEST_UADDR);
+
 	writel(0, dev->ce_base + CRYPTO4XX_SA_UADDR);
+
 	writel(0, dev->ce_base + CRYPTO4XX_GATH_RING_BASE_UADDR);
 	writel(0, dev->ce_base + CRYPTO4XX_SCAT_RING_BASE_UADDR);
 	/* un reset pe,sg and pdr */
@@ -112,13 +151,108 @@ static void crypto4xx_hw_init(struct crypto4xx_device *dev)
 	/*clear all pending interrupt*/
 	writel(PPC4XX_INTERRUPT_CLR, dev->ce_base + CRYPTO4XX_INT_CLR);
 	writel(PPC4XX_INT_DESCR_CNT, dev->ce_base + CRYPTO4XX_INT_DESCR_CNT);
-	writel(PPC4XX_INT_DESCR_CNT, dev->ce_base + CRYPTO4XX_INT_DESCR_CNT);
-	writel(PPC4XX_INT_CFG, dev->ce_base + CRYPTO4XX_INT_CFG);
-	writel(PPC4XX_PD_DONE_INT, dev->ce_base + CRYPTO4XX_INT_EN);
+	
+	if (dev->core_dev->revb_ver == 1) {
+		writel(PPC4XX_INT_TIMEOUT_CNT_REVB << 10,
+			dev->ce_base + CRYPTO4XX_INT_TIMEOUT_CNT);
+		 /* For RevB, 460EX and 460ExR Rev B */
+		writel(PPC4XX_PD_DONE_INT | PPC4XX_TMO_ERR_INT,
+		dev->ce_base + CRYPTO4XX_INT_EN);
+	} else 
+		writel(PPC4XX_PD_DONE_INT, dev->ce_base + CRYPTO4XX_INT_EN);
+}
+
+void crypto4xx_dump_regs(struct crypto4xx_core_device* core_dev)
+{
+	u32 reg_dump;
+
+	reg_dump = readl(core_dev->dev->ce_base + CRYPTO4XX_CTRL_STAT);
+	printk("crypto4xx_dump_regs: CRYPTO4XX_PD_CTRL_STAT = 0x%08x\n", reg_dump);
+
+	reg_dump = readl(core_dev->dev->ce_base + CRYPTO4XX_SOURCE);
+	printk("crypto4xx_dump_regs: CRYPTO4XX_Source_REG = 0x%08x\n", reg_dump);
+	
+	reg_dump = readl(core_dev->dev->ce_base + CRYPTO4XX_DEST);
+	printk("crypto4xx_dump_regs: CRYPTO4XX_Des_REG= 0x%08x\n", reg_dump);
+	
+	reg_dump = readl(core_dev->dev->ce_base + CRYPTO4XX_SA);
+	printk("crypto4xx_dump_regs: CRYPTO4XX_SA_REG= 0x%08x\n", reg_dump);
+	
+	reg_dump = readl(core_dev->dev->ce_base + CRYPTO4XX_PE_DMA_CFG);
+	printk("crypto4xx_dump_regs: CRYPTO4XX_PE_DMA_CFG = 0x%08x\n", reg_dump);
+	
+	reg_dump = readl(core_dev->dev->ce_base + CRYPTO4XX_RING_SIZE);
+	printk("crypto4xx_dump_regs: CRYPTO4XX_RING_SIZE  = 0x%08x\n", reg_dump);
+	
+	reg_dump = readl(core_dev->dev->ce_base + CRYPTO4XX_RING_CTRL);
+	printk("crypto4xx_dump_regs: CRYPTO4XX_RING_CTRL  = 0x%08x\n", reg_dump);
+	
+	reg_dump = readl(core_dev->dev->ce_base + CRYPTO4XX_IO_THRESHOLD);
+	printk("crypto4xx_dump_regs: CRYPTO4XX_IO_THRESHOLD   = 0x%08x\n", reg_dump);
+	
+	reg_dump = readl(core_dev->dev->ce_base + CRYPTO4XX_PE_DMA_STAT);
+	printk("crypto4xx_dump_regs: CRYPTO4XX_PE_DMA_STAT= 0x%08x\n", reg_dump);
+	
+	reg_dump = readl(core_dev->dev->ce_base + CRYPTO4XX_PDR_BASE);
+	printk("crypto4xx_dump_regs: CRYPTO4XX_PDR_BASE   = 0x%08x\n", reg_dump);
+	
+	reg_dump = readl(core_dev->dev->ce_base + CRYPTO4XX_STATE_PTR);
+	printk("crypto4xx_dump_regs: CRYPTO4XX_STATE_PTR  = 0x%08x\n", reg_dump);
+	
+	reg_dump = readl(core_dev->dev->ce_base + CRYPTO4XX_SA_CMD_0);
+	printk("crypto4xx_dump_regs: CRYPTO4XX_SA_CMD_0   = 0x%08x\n", reg_dump);
+	
+	reg_dump = readl(core_dev->dev->ce_base + CRYPTO4XX_SA_CMD_1);
+	printk("crypto4xx_dump_regs: CRYPTO4XX_SA_CMD_1   = 0x%08x\n", reg_dump);
+	
+	reg_dump = readl(core_dev->dev->ce_base + CRYPTO4XX_SPI);
+	printk("crypto4xx_dump_regs: CRYPTO4XX_SPI   = 0x%08x\n", reg_dump);
+
+	reg_dump = readl(core_dev->dev->ce_base + CRYPTO4XX_SEQ_NUM0);
+	printk("crypto4xx_dump_regs: CRYPTO4XX_SEQ_NUM_0   = 0x%08x\n", reg_dump);
+
+	reg_dump = readl(core_dev->dev->ce_base + CRYPTO4XX_SEQ_NUM1);
+	printk("crypto4xx_dump_regs: CRYPTO4XX_SEQ_NUM_1   = 0x%08x\n", reg_dump);
+
+	reg_dump = readl(core_dev->dev->ce_base + CRYPTO4XX_STATE_IV + 0);
+	printk("crypto4xx_dump_regs: CRYPTO4XX_STATE_IV + 0   = 0x%08x\n", reg_dump);
+	
+	reg_dump = readl(core_dev->dev->ce_base + CRYPTO4XX_STATE_IV + 4);
+	printk("crypto4xx_dump_regs: CRYPTO4XX_STATE_IV + 4   = 0x%08x\n", reg_dump);
+	
+	reg_dump = readl(core_dev->dev->ce_base +CRYPTO4XX_STATE_IV + 8);
+	printk("crypto4xx_dump_regs: CRYPTO4XX_STATE_IV + 8   = 0x%08x\n", reg_dump);
+	
+	reg_dump = readl(core_dev->dev->ce_base + CRYPTO4XX_STATE_IV + 12);
+	printk("crypto4xx_dump_regs: CRYPTO4XX_STATE_IV + 12  = 0x%08x\n", reg_dump);
+	
+	reg_dump = readl(core_dev->dev->ce_base + CRYPTO4XX_STATE_HASH_BYTE_CNT_0);
+	printk("crypto4xx_dump_regs: CRYPTO4XX_STATE_HASH_BYTE_CNT_0  = 0x%08x\n", reg_dump);
+	
 }
 
 int crypto4xx_alloc_sa(struct crypto4xx_ctx *ctx, u32 size)
 {
+#ifdef CONFIG_SEC_SA_OCM
+	ctx->sa_out = ocm_alloc(&ctx->sa_out_ocm_addr, size * 4, 4,
+				 OCM_NON_CACHED, "sec_sa_out");
+	ctx->sa_out_dma_addr = (u32)ctx->sa_out_ocm_addr;
+	printk("OCM Allocation done for SA Out %llx\n", (unsigned long long)ctx->sa_out_ocm_addr);
+	if (ctx->sa_out == NULL)
+		return -ENOMEM;
+	ctx->sa_in = ocm_alloc(&ctx->sa_in_ocm_addr, size * 4, 4,
+				OCM_NON_CACHED, "sec_sa_in");
+	if (ctx->sa_in == NULL) {
+		ocm_free(ctx->sa_out);
+		return -ENOMEM;
+	}
+	ctx->sa_in_dma_addr = (u32)ctx->sa_in_ocm_addr;
+	//printk("OCM Allocation done for SA In %llx\n", (unsigned long long)ctx->sa_in_ocm_addr);
+	memset(ctx->sa_in, 0, size * 4);
+	memset(ctx->sa_out, 0, size * 4);
+	ctx->sa_len = size;
+	return 0;
+#endif
 	ctx->sa_in = dma_alloc_coherent(ctx->dev->core_dev->device, size * 4,
 					&ctx->sa_in_dma_addr, GFP_ATOMIC);
 	if (ctx->sa_in == NULL)
@@ -142,6 +276,14 @@ int crypto4xx_alloc_sa(struct crypto4xx_ctx *ctx, u32 size)
 
 void crypto4xx_free_sa(struct crypto4xx_ctx *ctx)
 {
+#ifdef CONFIG_SEC_SA_OCM
+	ocm_free(ctx->sa_out);
+	ocm_free(ctx->sa_in);
+	ctx->sa_in_dma_addr = 0;
+	ctx->sa_out_dma_addr = 0;
+	ctx->sa_len = 0;
+	return;
+#endif
 	if (ctx->sa_in != NULL)
 		dma_free_coherent(ctx->dev->core_dev->device, ctx->sa_len * 4,
 				  ctx->sa_in, ctx->sa_in_dma_addr);
@@ -151,16 +293,28 @@ void crypto4xx_free_sa(struct crypto4xx_ctx *ctx)
 
 	ctx->sa_in_dma_addr = 0;
 	ctx->sa_out_dma_addr = 0;
+	ctx->sa_in = NULL;
+	ctx->sa_out = NULL;
 	ctx->sa_len = 0;
 }
 
 u32 crypto4xx_alloc_state_record(struct crypto4xx_ctx *ctx)
 {
+#ifdef CONFIG_SEC_SA_OCM
+	ctx->state_record = ocm_alloc(&ctx->state_record_ocm_addr,
+				       sizeof(struct sa_state_record), 4,
+				       OCM_NON_CACHED, "sec_state_record");
+	if (ctx->state_record == NULL)
+		return -ENOMEM;
+	ctx->state_record_dma_addr = (u32)ctx->state_record_ocm_addr;
+#else
 	ctx->state_record = dma_alloc_coherent(ctx->dev->core_dev->device,
 				sizeof(struct sa_state_record),
 				&ctx->state_record_dma_addr, GFP_ATOMIC);
-	if (!ctx->state_record_dma_addr)
+
+	if (!ctx->state_record_dma_addr || !ctx->state_record)
 		return -ENOMEM;
+#endif
 	memset(ctx->state_record, 0, sizeof(struct sa_state_record));
 
 	return 0;
@@ -168,14 +322,82 @@ u32 crypto4xx_alloc_state_record(struct crypto4xx_ctx *ctx)
 
 void crypto4xx_free_state_record(struct crypto4xx_ctx *ctx)
 {
+#ifdef CONFIG_SEC_SA_OCM
+	if (ctx->state_record != NULL)
+		ocm_free(ctx->state_record);
+#else
 	if (ctx->state_record != NULL)
 		dma_free_coherent(ctx->dev->core_dev->device,
 				  sizeof(struct sa_state_record),
 				  ctx->state_record,
 				  ctx->state_record_dma_addr);
+#endif
+	ctx->state_record = NULL;
 	ctx->state_record_dma_addr = 0;
 }
 
+u32 crypto4xx_alloc_arc4_state_record(struct crypto4xx_ctx *ctx)
+{
+#ifdef CONFIG_SEC_SA_OCM
+	ctx->arc4_state_record = ocm_alloc(&ctx->arc4_state_ocm_addr,
+				       sizeof(struct arc4_sr), 4,
+				       OCM_NON_CACHED, "sec_state_arc4_record");
+	if (ctx->arc4_state_record == NULL)
+		return -ENOMEM;
+	ctx->arc4_state_record_dma_addr = (u32)ctx->arc4_state_ocm_addr;
+#else
+	ctx->arc4_state_record = dma_alloc_coherent(ctx->dev->core_dev->device,
+			sizeof(struct arc4_sr),
+			/* &dma_addr */ &ctx->arc4_state_record_dma_addr,
+			GFP_ATOMIC);
+
+	if (!ctx->arc4_state_record_dma_addr)
+		return -ENOMEM;
+#endif
+	memset(ctx->arc4_state_record, 0, sizeof(struct arc4_sr));
+
+	return 0;
+}
+
+void crypto4xx_free_arc4_state_record(struct crypto4xx_ctx *ctx)
+{
+
+	if (ctx->arc4_state_record != NULL) {
+#ifdef CONFIG_SEC_SA_OCM
+	ocm_free(ctx->arc4_state_record);
+	
+#else
+	dma_free_coherent(ctx->dev->core_dev->device,
+			  sizeof(struct arc4_sr),
+			  ctx->arc4_state_record,
+			  ctx->arc4_state_record_dma_addr);
+#endif
+	}
+	ctx->arc4_state_record = NULL;
+	ctx->arc4_state_record_dma_addr = 0;
+}
+
+int datalen_check;
+static int crypto4xx_device_read_procmem(char *buffer, char **start, off_t offset,
+			      int count, int *eof, void *data)
+{
+	struct crypto4xx_core_device *core_dev = (struct crypto4xx_core_device *)data;
+	int len = 0;
+	u32 ring_ctrl_val;
+
+	ring_ctrl_val = readl(core_dev->dev->ce_base + CRYPTO4XX_RING_CTRL);
+
+	len += sprintf(buffer + len, "ring_ctrl_val = 0x%08x\n", ring_ctrl_val);
+	len += sprintf(buffer + len,
+		       "Crypto4xx Controller on AMCC PPC 460EX Canyonlands Board\n");
+	len += sprintf(buffer + len,
+		       "%u packets received for packetsize = %d\n", core_dev->dev->pkt_cnt,
+		       datalen_check);
+	len += sprintf(buffer + len,
+		       "%lld interrupts received\n", core_dev->irq_cnt);
+	*eof = 1;
+	return len;
+}
 /**
  * alloc memory for the gather ring
  * no need to alloc buf for the ring
@@ -185,20 +407,37 @@ static u32 crypto4xx_build_pdr(struct crypto4xx_device *dev)
 {
 	int i;
 	struct pd_uinfo *pd_uinfo;
+
+#ifdef CONFIG_SEC_PD_OCM
+	int pd_size;
+	pd_size = sizeof(struct ce_pd) * PPC4XX_NUM_PD;
+	dev->pdr = ocm_alloc(&dev->pdr_ocm_addr, pd_size, 4,
+				 OCM_NON_CACHED, "sec_pd");
+	dev->pdr_pa = (u32)dev->pdr_ocm_addr;
+	printk(KERN_INFO "Security OCM Allocation done for packet Descriptor: %llx,\n"
+			"Virtual OCM Address: %p, OCM Allocation size: %d\n",
+			(unsigned long long)dev->pdr_ocm_addr, dev->pdr, pd_size);
+	if (dev->pdr == NULL) {
+		printk("PD Allocation failed on OCM\n");
+		return -ENOMEM;
+	}
+#else
 	dev->pdr = dma_alloc_coherent(dev->core_dev->device,
 				      sizeof(struct ce_pd) * PPC4XX_NUM_PD,
 				      &dev->pdr_pa, GFP_ATOMIC);
 	if (!dev->pdr)
 		return -ENOMEM;
-
+#endif
 	dev->pdr_uinfo = kzalloc(sizeof(struct pd_uinfo) * PPC4XX_NUM_PD,
 				GFP_KERNEL);
 	if (!dev->pdr_uinfo) {
+#ifndef CONFIG_SEC_PD_OCM
 		dma_free_coherent(dev->core_dev->device,
 				  sizeof(struct ce_pd) * PPC4XX_NUM_PD,
 				  dev->pdr,
 				  dev->pdr_pa);
 		return -ENOMEM;
+#endif
 	}
 	memset(dev->pdr, 0,  sizeof(struct ce_pd) * PPC4XX_NUM_PD);
 	dev->shadow_sa_pool = dma_alloc_coherent(dev->core_dev->device,
@@ -233,10 +472,14 @@ static u32 crypto4xx_build_pdr(struct crypto4xx_device *dev)
 
 static void crypto4xx_destroy_pdr(struct crypto4xx_device *dev)
 {
+#ifndef CONFIG_SEC_PD_OCM
 	if (dev->pdr != NULL)
 		dma_free_coherent(dev->core_dev->device,
 				  sizeof(struct ce_pd) * PPC4XX_NUM_PD,
 				  dev->pdr, dev->pdr_pa);
+#else
+	ocm_free(dev->pdr);
+#endif
 	if (dev->shadow_sa_pool)
 		dma_free_coherent(dev->core_dev->device, 256 * PPC4XX_NUM_PD,
 				  dev->shadow_sa_pool, dev->shadow_sa_pool_pa);
@@ -245,6 +488,7 @@ static void crypto4xx_destroy_pdr(struct crypto4xx_device *dev)
 			sizeof(struct sa_state_record) * PPC4XX_NUM_PD,
 			dev->shadow_sr_pool, dev->shadow_sr_pool_pa);
 
+	dev->pkt_cnt = 0;
 	kfree(dev->pdr_uinfo);
 }
 
@@ -526,7 +770,7 @@ static u32 crypto4xx_fill_one_page(struct crypto4xx_device *dev,
 			(*idx)++;
 
 		return 0;
-    }
+	}
 }
 
 static void crypto4xx_copy_pkt_to_dst(struct crypto4xx_device *dev,
@@ -589,9 +833,25 @@ static u32 crypto4xx_copy_digest_to_dst(struct pd_uinfo *pd_uinfo,
 	struct sa_state_record *state_record =
 				(struct sa_state_record *) pd_uinfo->sr_va;
 
-	if (sa->sa_command_0.bf.hash_alg == SA_HASH_ALG_SHA1) {
-		memcpy((void *) pd_uinfo->dest_va, state_record->save_digest,
-		       SA_HASH_ALG_SHA1_DIGEST_SIZE);
+	switch (sa->sa_command_0.bf.hash_alg) {
+	case SA_HASH_ALG_KASUMI_f9:
+		crypto4xx_memcpy_le((void *)pd_uinfo->dest_va,
+				     (u8 *)state_record->save_digest, 8);
+		break;
+	case SA_HASH_ALG_AES_XCBC_MAC_128:
+		crypto4xx_memcpy_le((void *)pd_uinfo->dest_va,
+				     (u8 *) state_record->save_digest, 16);
+		break;
+	case SA_HASH_ALG_MD5:
+		crypto4xx_memcpy_le((void *)pd_uinfo->dest_va,
+				     (u8 *) state_record->save_digest,
+				     SA_HASH_ALG_MD5_DIGEST_SIZE);
+		break;
+	default:
+		memcpy((void *)pd_uinfo->dest_va,
+			state_record->save_digest,
+			crypto4xx_sa_hash_tbl[1][sa->sa_command_0.bf.hash_alg]);
+		break;
 	}
 
 	return 0;
@@ -616,6 +876,57 @@ static void crypto4xx_ret_sg_desc(struct crypto4xx_device *dev,
 	}
 }
 
+void crypto4xx_append_icv_to_end(struct crypto4xx_device *dev,
+				 struct scatterlist *dst,
+				 struct sa_state_record *sr,
+				 u32 offset,
+				 u32 len)
+{
+	struct scatterlist *sg;
+	int i = 0;
+	u32 cp_len;
+	dma_addr_t addr;
+
+	sg = &dst[i];
+	while (len) {
+		while (sg->length < offset) {
+			offset -= sg->length;
+			i++;
+			sg = &sg[i];
+		}
+		/* at here, icv could be in this sg,
+		* or icv could be in the next sg
+		*/
+		if (sg->length > offset) {
+			/* icv should be in middle of this sg */
+			addr = dma_map_page(dev->core_dev->device, sg_page(sg),
+					    sg->offset,
+					    sg->length, DMA_TO_DEVICE);
+			cp_len = (sg->length-offset >= len) ? len :
+					sg->length-offset;
+			len -= cp_len;
+			crypto4xx_memcpy_le((u32 *)(phys_to_virt(addr)
+					+ offset),
+					(u8 *)sr->save_digest, cp_len);
+		} else {
+			/* start from begin of next sg*/
+			i++;
+			sg = &sg[i];
+			offset = 0;
+			addr = dma_map_page(dev->core_dev->device, sg_page(sg),
+					    sg->offset,
+					    sg->length, DMA_FROM_DEVICE);
+			cp_len = (sg->length >= len) ? len : sg->length;
+			len -= cp_len;
+			crypto4xx_memcpy_le((u32 *) (phys_to_virt(addr)
+					+ offset),
+					(u8 *) sr->save_digest, cp_len);
+		}
+		i++;
+		sg = &sg[i];
+	}
+}
+
 static u32 crypto4xx_ablkcipher_done(struct crypto4xx_device *dev,
 				     struct pd_uinfo *pd_uinfo,
 				     struct ce_pd *pd)
@@ -637,6 +948,11 @@ static u32 crypto4xx_ablkcipher_done(struct crypto4xx_device *dev,
 				    dst->offset, dst->length, DMA_FROM_DEVICE);
 	}
 	crypto4xx_ret_sg_desc(dev, pd_uinfo);
+
+	if (pd->pd_ctl.bf.status & 0xff) {
+		printk("ablkcipher return err status = 0x%08x\n",
+		       pd->pd_ctl.bf.status & 0xff);
+	}
 	if (ablk_req->base.complete != NULL)
 		ablk_req->base.complete(&ablk_req->base, 0);
 
@@ -644,7 +960,8 @@ static u32 crypto4xx_ablkcipher_done(struct crypto4xx_device *dev,
 }
 
 static u32 crypto4xx_ahash_done(struct crypto4xx_device *dev,
-				struct pd_uinfo *pd_uinfo)
+				struct pd_uinfo *pd_uinfo,
+				struct ce_pd *pd)
 {
 	struct crypto4xx_ctx *ctx;
 	struct ahash_request *ahash_req;
@@ -656,24 +973,101 @@ static u32 crypto4xx_ahash_done(struct crypto4xx_device *dev,
 				     crypto_tfm_ctx(ahash_req->base.tfm));
 	crypto4xx_ret_sg_desc(dev, pd_uinfo);
 	/* call user provided callback function x */
+	if (pd->pd_ctl.bf.status & 0xff) {
+		printk("ahash return err status = 0x%08x\n",
+		       pd->pd_ctl.bf.status & 0xff);
+	}
 	if (ahash_req->base.complete != NULL)
 		ahash_req->base.complete(&ahash_req->base, 0);
 
 	return 0;
 }
 
-static u32 crypto4xx_pd_done(struct crypto4xx_device *dev, u32 idx)
+static u32 crypto4xx_aead_done(struct crypto4xx_device *dev,
+			struct pd_uinfo *pd_uinfo,
+			struct ce_pd *pd)
+{
+	struct aead_request *aead_req;
+	struct crypto4xx_ctx *ctx;
+	struct scatterlist *dst;
+	dma_addr_t addr;
+	struct crypto_aead *aead;
+
+	aead_req = container_of(pd_uinfo->async_req,
+				struct aead_request, base);
+	aead = crypto_aead_reqtfm(aead_req);
+	ctx  = crypto_tfm_ctx(aead_req->base.tfm);
+
+	if (pd_uinfo->using_sd) {
+		crypto4xx_copy_pkt_to_dst(dev, pd, pd_uinfo,
+					  pd->pd_ctl_len.bf.pkt_len,
+					  aead_req->dst);
+	} else {
+		dst = pd_uinfo->dest_va;
+		addr = dma_map_page(dev->core_dev->device, sg_page(dst),
+				    dst->offset,
+				    dst->length, DMA_FROM_DEVICE);
+	}
+
+	if (ctx->append_icv != 0) {
+		dst = pd_uinfo->dest_va;
+		crypto4xx_append_icv_to_end(dev, dst,
+					    (struct sa_state_record *)
+					    pd_uinfo->sr_va,
+					    aead_req->cryptlen,
+					    crypto_aead_authsize(aead));
+	}
+	crypto4xx_ret_sg_desc(dev, pd_uinfo);
+	/* call user provided callback function x */
+
+	if (pd->pd_ctl.bf.status & 0xff) {
+		if (pd->pd_ctl.bf.status & 1)
+			printk("authentication error\n");
+		if (pd->pd_ctl.bf.status & 2)
+			printk("pad fail error\n");
+		if (pd->pd_ctl.bf.status & 4)
+			printk("seqnum fail\n");
+		if (pd->pd_ctl.bf.status & 8)
+			printk("error _notify\n");
+		printk("aead return err status = 0x%08x\n",
+		       pd->pd_ctl.bf.status & 0xff);
+		printk("pd pad_ctl = 0x%08x\n", pd->pd_ctl.bf.pd_pad_ctl);
+	}
+	
+#if 0
+	void * saddr;
+	dst = pd_uinfo->dest_va;
+	printk("dumping aead_done length = %d\n", dst->length);
+	saddr = kmap_atomic(sg_page(dst), KM_SOFTIRQ1);
+	print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
+		       16, 1,
+		       (void*)saddr+dst->offset, dst->length, false);
+	kunmap_atomic(saddr, KM_SOFTIRQ1);
+#endif
+	if (aead_req->base.complete != NULL)
+		aead_req->base.complete(&aead_req->base, 0);
+	return 0;
+}
+
+u32 crypto4xx_pd_done(struct crypto4xx_device *dev, u32 idx)
 {
 	struct ce_pd *pd;
 	struct pd_uinfo *pd_uinfo;
 
 	pd =  dev->pdr + sizeof(struct ce_pd)*idx;
 	pd_uinfo = dev->pdr_uinfo + sizeof(struct pd_uinfo)*idx;
+
 	if (crypto_tfm_alg_type(pd_uinfo->async_req->tfm) ==
+			CRYPTO_ALG_TYPE_AEAD)
+		return crypto4xx_aead_done(dev, pd_uinfo, pd);
+	else if (crypto_tfm_alg_type(pd_uinfo->async_req->tfm) ==
 			CRYPTO_ALG_TYPE_ABLKCIPHER)
 		return crypto4xx_ablkcipher_done(dev, pd_uinfo, pd);
-	else
-		return crypto4xx_ahash_done(dev, pd_uinfo);
+	else if (crypto_tfm_alg_type(pd_uinfo->async_req->tfm) ==
+			CRYPTO_ALG_TYPE_AHASH)
+		return crypto4xx_ahash_done(dev, pd_uinfo, pd);
+
+	return 0;
 }
 
 /**
@@ -769,18 +1163,23 @@ static u32 get_next_sd(u32 current)
 	else
 		return 0;
 }
-
+extern int ssl_arc4;
+extern int tls;
+int var = 0;
 u32 crypto4xx_build_pd(struct crypto_async_request *req,
 		       struct crypto4xx_ctx *ctx,
 		       struct scatterlist *src,
 		       struct scatterlist *dst,
 		       unsigned int datalen,
+		       struct scatterlist *assoc,
+		       u32 aad_len,
 		       void *iv, u32 iv_len)
 {
 	struct crypto4xx_device *dev = ctx->dev;
 	dma_addr_t addr, pd_dma, sd_dma, gd_dma;
 	struct dynamic_sa_ctl *sa;
 	struct scatterlist *sg;
+	struct scatterlist *aad;
 	struct ce_gd *gd;
 	struct ce_pd *pd;
 	u32 num_gd, num_sd;
@@ -790,13 +1189,19 @@ u32 crypto4xx_build_pd(struct crypto_async_request *req,
 	unsigned long flags;
 	struct pd_uinfo *pd_uinfo = NULL;
 	unsigned int nbytes = datalen, idx;
-	unsigned int ivlen = 0;
 	u32 gd_idx = 0;
+	unsigned int aadlen = 0;
 
+	datalen_check = datalen;
 	/* figure how many gd is needed */
-	num_gd = get_sg_count(src, datalen);
-	if (num_gd == 1)
-		num_gd = 0;
+	if (aad_len) {
+		num_gd = get_sg_count(assoc, aad_len) +
+				get_sg_count(src, datalen);
+	} else {
+		num_gd = get_sg_count(src, datalen);
+		if (num_gd == 1)
+			num_gd = 0;
+	}
 
 	/* figure how many sd is needed */
 	if (sg_is_last(dst) || ctx->is_hash) {
@@ -852,8 +1257,8 @@ u32 crypto4xx_build_pd(struct crypto_async_request *req,
 	pd_uinfo->num_gd = num_gd;
 	pd_uinfo->num_sd = num_sd;
 
+	writel(0, ctx->dev->ce_base + CRYPTO4XX_SA_UADDR);
 	if (iv_len || ctx->is_hash) {
-		ivlen = iv_len;
 		pd->sa = pd_uinfo->sa_pa;
 		sa = (struct dynamic_sa_ctl *) pd_uinfo->sa_va;
 		if (ctx->direction == DIR_INBOUND)
@@ -864,17 +1269,48 @@ u32 crypto4xx_build_pd(struct crypto_async_request *req,
 		memcpy((void *) sa + ctx->offset_to_sr_ptr,
 			&pd_uinfo->sr_pa, 4);
 
-		if (iv_len)
-			crypto4xx_memcpy_le(pd_uinfo->sr_va, iv, iv_len);
+		if (iv_len) {
+			if (ctx->ctr_aes) {
+				/* First the nonce */
+				memcpy(pd_uinfo->sr_va, ctx->state_record,
+				       CTR_RFC3686_NONCE_SIZE);
+				/* Copy the IV that is passed through
+				 * each operation
+				 */
+				crypto4xx_memcpy_le(pd_uinfo->sr_va +
+					CTR_RFC3686_NONCE_SIZE, iv, iv_len);
+			} else
+				crypto4xx_memcpy_le(pd_uinfo->sr_va,
+						iv, iv_len);
+		}
+		if (ctx->is_gcm || ctx->ctr_aes) {
+			u32 seq = 1;
+			/*For GCM and CTR(AES) algs adding the counter value*/
+			crypto4xx_memcpy_le(pd_uinfo->sr_va + 12,
+					    (void *)&seq,  4);
+		}
 	} else {
 		if (ctx->direction == DIR_INBOUND) {
+#ifdef CONFIG_SEC_SA_OCM
+			writel((ctx->sa_in_ocm_addr >> 32),
+				ctx->dev->ce_base + CRYPTO4XX_SA_UADDR);
+#endif
 			pd->sa = ctx->sa_in_dma_addr;
 			sa = (struct dynamic_sa_ctl *) ctx->sa_in;
-		} else {
+			} else {
+#ifdef CONFIG_SEC_SA_OCM
+			writel((ctx->sa_out_ocm_addr >> 32),
+				ctx->dev->ce_base + CRYPTO4XX_SA_UADDR);
+#endif
 			pd->sa = ctx->sa_out_dma_addr;
 			sa = (struct dynamic_sa_ctl *) ctx->sa_out;
 		}
 	}
+
+	//u32 sa_upper = readl(ctx->dev->ce_base + CRYPTO4XX_SA_UADDR);
+	//printk("Dumping the Upper SA address = 0x%x\n", sa_upper);
+	//printk("Dumping the lower SA address = 0x%x\n", pd->sa);
+
 	pd->sa_len = ctx->sa_len;
 	if (num_gd) {
 		/* get first gd we are going to use */
@@ -886,6 +1322,35 @@ u32 crypto4xx_build_pd(struct crypto_async_request *req,
 		/* enable gather */
 		sa->sa_command_0.bf.gather = 1;
 		idx = 0;
+		if (aad_len) {
+			aadlen = aad_len;
+			aad = assoc;
+			/* walk the sg, and setup gather array for aad*/
+			while (aadlen) {
+				sg = &aad[idx];
+				addr = dma_map_page(dev->core_dev->device,
+						sg_page(sg), sg->offset,
+						sg->length, DMA_TO_DEVICE);
+
+				gd->ptr = addr;
+				gd->ctl_len.len = sg->length;
+				gd->ctl_len.done = 0;
+				gd->ctl_len.ready = 1;
+
+				if (sg->length >= aadlen)
+					break;
+
+				aadlen -= sg->length;
+
+				gd_idx = get_next_gd(gd_idx);
+				gd = crypto4xx_get_gdp(dev, &gd_dma, gd_idx);
+				idx++;
+			}
+			/* prepare gd for src */
+			gd_idx = get_next_gd(gd_idx);
+			gd = crypto4xx_get_gdp(dev, &gd_dma, gd_idx);
+		}
+		idx = 0;
 		src = &src[0];
 		/* walk the sg, and setup gather array */
 		while (nbytes) {
@@ -970,13 +1435,24 @@ u32 crypto4xx_build_pd(struct crypto_async_request *req,
 		}
 	}
 
-	sa->sa_command_1.bf.hash_crypto_offset = 0;
+	sa->sa_command_1.bf.hash_crypto_offset = (aad_len >> 2);
 	pd->pd_ctl.w = ctx->pd_ctl;
-	pd->pd_ctl_len.w = 0x00400000 | (ctx->bypass << 24) | datalen;
+	pd->pd_ctl_len.w = 0x00400000 | (ctx->bypass << 24) |
+			(datalen + aad_len);
+	if (ctx->next_hdr)
+		pd->pd_ctl.bf.next_hdr = ctx->next_hdr;
 	pd_uinfo->state = PD_ENTRY_INUSE;
 	wmb();
 	/* write any value to push engine to read a pd */
-	writel(1, dev->ce_base + CRYPTO4XX_INT_DESCR_RD);
+	if (dev->core_dev->revb_ver == 1) {
+#ifndef CONFIG_SEC_HW_POLL
+		writel(1, dev->ce_base + CRYPTO4XX_INT_DESCR_RD);
+#endif
+	} else 
+		writel(1, dev->ce_base + CRYPTO4XX_INT_DESCR_RD);
+
+		
+	dev->pkt_cnt++;
 	return -EINPROGRESS;
 }
 
@@ -995,6 +1471,8 @@ static int crypto4xx_alg_init(struct crypto_tfm *tfm)
 	ctx->sa_in_dma_addr = 0;
 	ctx->sa_out_dma_addr = 0;
 	ctx->sa_len = 0;
+	ctx->is_gcm = 0;
+	ctx->append_icv = 0;
 
 	switch (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) {
 	default:
@@ -1004,6 +1482,9 @@ static int crypto4xx_alg_init(struct crypto_tfm *tfm)
 		crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),
 					 sizeof(struct crypto4xx_ctx));
 		break;
+	case CRYPTO_ALG_TYPE_AEAD:
+		tfm->crt_aead.reqsize = sizeof(struct crypto4xx_ctx);
+		break;
 	}
 
 	return 0;
@@ -1015,6 +1496,7 @@ static void crypto4xx_alg_exit(struct crypto_tfm *tfm)
 
 	crypto4xx_free_sa(ctx);
 	crypto4xx_free_state_record(ctx);
+	crypto4xx_free_arc4_state_record(ctx);
 }
 
 int crypto4xx_register_alg(struct crypto4xx_device *sec_dev,
@@ -1098,6 +1580,14 @@ static void crypto4xx_bh_tasklet_cb(unsigned long data)
 		}
 	}
 }
+#define SRAM_OCM_ADDR_ERR		0x0B4
+#define SRAM_OCM_STATUS0		0x0B5
+#define SRAM_OCM_STATUS1		0X0B6
+
+#define PLBA0_ESRL			0x0082
+#define PLBA0_ESRH			0x0083
+#define PLBA0_EARL			0x0084
+#define PLBA0_EARH			0x0085
 
 /**
  * Top Half of isr.
@@ -1106,33 +1596,140 @@ static irqreturn_t crypto4xx_ce_interrupt_handler(int irq, void *data)
 {
 	struct device *dev = (struct device *)data;
 	struct crypto4xx_core_device *core_dev = dev_get_drvdata(dev);
+	//u32 int_status;
 
 	if (core_dev->dev->ce_base == 0)
 		return 0;
 
-	writel(PPC4XX_INTERRUPT_CLR,
-	       core_dev->dev->ce_base + CRYPTO4XX_INT_CLR);
+	//int_status = readl(core_dev->dev->ce_base + CRYPTO4XX_INT_UNMASK_STAT);
+	//printk("Interrupt status = 0x%08x\n", int_status);
+
+	/* For RevB, 460EX and 460ExR Rev B */
+	if (core_dev->revb_ver == 1) {
+		writel(PPC4XX_INTERRUPT_CLR_REVB,
+			core_dev->dev->ce_base + CRYPTO4XX_INT_CLR);
+	} else {
+		writel(PPC4XX_INTERRUPT_CLR,
+			core_dev->dev->ce_base + CRYPTO4XX_INT_CLR);
+	}
+
+	core_dev->irq_cnt++;
 	tasklet_schedule(&core_dev->tasklet);
 
 	return IRQ_HANDLED;
 }
 
+
 /**
  * Supported Crypto Algorithms
  */
 struct crypto4xx_alg_common crypto4xx_alg[] = {
+		/* Crypto DES ECB, CBC,  modes */
+#if 1
+        { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, .u.cipher = {
+		.cra_name 		= "cbc(des)",
+ 		.cra_driver_name 	= "ppc4xx-cbc-des",
+ 		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+ 		.cra_flags 		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
+ 		.cra_blocksize 		= DES_BLOCK_SIZE,
+ 		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+ 		.cra_alignmask 		= 0,
+ 		.cra_type 		= &crypto_ablkcipher_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+ 		.cra_module 		= THIS_MODULE,
+ 		.cra_u 		= {
+			.ablkcipher = {
+				.min_keysize 	= DES_KEY_SIZE,
+				.max_keysize 	= DES_KEY_SIZE,
+				.ivsize 	= DES_BLOCK_SIZE,
+				.setkey 	= crypto4xx_setkey_3des_cbc,
+				.encrypt 	= crypto4xx_encrypt,
+				.decrypt 	= crypto4xx_decrypt,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, .u.cipher = {
+		.cra_name 		= "ecb(des)",
+		.cra_driver_name 	= "ppc4xx-ecb-des",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= DES_BLOCK_SIZE,
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_ablkcipher_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 		= {
+			.ablkcipher = {
+				.min_keysize 	= DES_KEY_SIZE,
+				.max_keysize 	= DES_KEY_SIZE,
+				.setkey 	= crypto4xx_setkey_3des_ecb,
+				.encrypt 	= crypto4xx_encrypt,
+				.decrypt 	= crypto4xx_decrypt,
+			}
+		}
+	}},
+
+	/* Crypto 3DES ECB, CBC, CFB, and OFB modes */
+        { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, .u.cipher = {
+			.cra_name 		= "cbc(des3_ede)",
+		.cra_driver_name 	= "ppc4xx-cbc-3des",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= DES3_EDE_BLOCK_SIZE,
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_ablkcipher_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 		= {
+			.ablkcipher = {
+				.min_keysize 	= DES3_EDE_KEY_SIZE,
+				.max_keysize 	= DES3_EDE_KEY_SIZE,
+				.ivsize 	= DES3_EDE_BLOCK_SIZE,
+				.setkey 	= crypto4xx_setkey_3des_cbc,
+				.encrypt 	= crypto4xx_encrypt,
+				.decrypt 	= crypto4xx_decrypt,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, .u.cipher = {
+		.cra_name 		= "ecb(des3_ede)",
+ 		.cra_driver_name 	= "ppc4xx-ecb-3des",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= DES3_EDE_BLOCK_SIZE,
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_ablkcipher_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 		= {
+			.ablkcipher = {
+				.min_keysize 	= DES3_EDE_KEY_SIZE,
+				.max_keysize 	= DES3_EDE_KEY_SIZE,
+				.setkey 	= crypto4xx_setkey_3des_ecb,
+				.encrypt 	= crypto4xx_encrypt,
+				.decrypt 	= crypto4xx_decrypt,
+			}
+		}
+	}},
 	/* Crypto AES modes */
 	{ .type = CRYPTO_ALG_TYPE_ABLKCIPHER, .u.cipher = {
-		.cra_name 	= "cbc(aes)",
-		.cra_driver_name = "cbc-aes-ppc4xx",
-		.cra_priority 	= CRYPTO4XX_CRYPTO_PRIORITY,
-		.cra_flags 	= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
-		.cra_blocksize 	= AES_BLOCK_SIZE,
-		.cra_ctxsize 	= sizeof(struct crypto4xx_ctx),
-		.cra_type 	= &crypto_ablkcipher_type,
-		.cra_init	= crypto4xx_alg_init,
-		.cra_exit	= crypto4xx_alg_exit,
-		.cra_module 	= THIS_MODULE,
+		.cra_name 		= "cbc(aes)",
+		.cra_driver_name 	= "cbc-aes-ppc4xx",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= AES_BLOCK_SIZE,
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_type 		= &crypto_ablkcipher_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
 		.cra_u 		= {
 			.ablkcipher = {
 				.min_keysize 	= AES_MIN_KEY_SIZE,
@@ -1144,8 +1741,2184 @@ struct crypto4xx_alg_common crypto4xx_alg[] = {
 			}
 		}
 	}},
-};
+        { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, .u.cipher = {
+		.cra_name 		= "ofb(aes)",
+		.cra_driver_name 	= "ppc4xx-ofb-aes",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
+		.cra_blocksize		= AES_BLOCK_SIZE,
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_ablkcipher_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 		= {
+			.ablkcipher = {
+				.min_keysize 	= AES_MIN_KEY_SIZE,
+				.max_keysize 	= AES_MAX_KEY_SIZE,
+				.ivsize 	= AES_BLOCK_SIZE,
+				.setkey 	= crypto4xx_setkey_aes_ofb,
+				.encrypt 	= crypto4xx_encrypt,
+				.decrypt 	= crypto4xx_decrypt,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, .u.cipher = {
+		.cra_name 		= "cfb(aes)",
+		.cra_driver_name 	= "ppc4xx-cfb-aes",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
+		.cra_blocksize		= AES_BLOCK_SIZE,
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_ablkcipher_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 		= {
+			.ablkcipher = {
+				.min_keysize 	= AES_MIN_KEY_SIZE,
+				.max_keysize 	= AES_MAX_KEY_SIZE,
+				.ivsize 	= AES_BLOCK_SIZE,
+				.setkey 	= crypto4xx_setkey_aes_cfb,
+				.encrypt 	= crypto4xx_encrypt,
+				.decrypt 	= crypto4xx_decrypt,
+			}
+		}
+	}},
+	/* Crypto AES ECB, CBC, CTR, GCM, CCM, and GMAC modes */
+        { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, .u.cipher = {
+		.cra_name 		= "ecb(aes)",
+		.cra_driver_name 	= "ppc4xx-ecb-aes",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= AES_BLOCK_SIZE,
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_ablkcipher_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 		= {
+			.ablkcipher = {
+				.min_keysize 	= AES_MIN_KEY_SIZE,
+				.max_keysize 	= AES_MAX_KEY_SIZE,
+				.setkey 	= crypto4xx_setkey_aes_ecb,
+				.encrypt 	= crypto4xx_encrypt,
+				.decrypt 	= crypto4xx_decrypt,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, .u.cipher = {
+		.cra_name 		= "rfc3686(ctr(aes))",
+		.cra_driver_name 	= "ppc4xx-ctr-aes",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= CTR_RFC3686_BLOCK_SIZE,
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type		= &crypto_ablkcipher_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 		= {
+			.ablkcipher = {
+				.min_keysize 	= AES_MIN_KEY_SIZE,
+				.max_keysize 	= AES_MAX_KEY_SIZE,
+				.ivsize 	= CTR_RFC3686_BLOCK_SIZE,
+				.setkey 	= crypto4xx_setkey_aes_ctr,
+				.encrypt 	= crypto4xx_encrypt_ctr,
+				.decrypt 	= crypto4xx_decrypt_ctr,
+			}
+		}
+	}},
+
+	/* AEAD Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "gcm(aes)",
+		.cra_driver_name 	= "ppc4xx-gcm-aes",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= AES_BLOCK_SIZE,
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 		= {
+			.aead = {
+				.maxauthsize	= 16,
+				.ivsize 	= 12,
+				.setkey 	= crypto4xx_setkey_aes_gcm,
+				.setauthsize	= crypto4xx_setauthsize_aes,
+				.encrypt 	= crypto4xx_encrypt_aes_gcm,
+				.decrypt 	= crypto4xx_decrypt_aes_gcm,
+				.givencrypt	= crypto4xx_givencrypt_aes_gcm,
+				.givdecrypt	= crypto4xx_givdecrypt_aes_gcm,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "ccm(aes)",
+		.cra_driver_name 	= "ppc4xx-ccm-aes",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= AES_BLOCK_SIZE,
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 		= {
+			.aead = {
+				.ivsize 	= AES_BLOCK_SIZE,
+				.maxauthsize	= 16,
+				.setkey		= crypto4xx_setkey_aes_ccm,
+				.setauthsize	= crypto4xx_setauthsize_aes,
+				.encrypt	= crypto4xx_encrypt_aes_ccm,
+				.decrypt	= crypto4xx_decrypt_aes_ccm,
+				.givencrypt	= crypto4xx_givencrypt_aes_ccm,
+				.givdecrypt	= crypto4xx_givdecrypt_aes_ccm,
+			}
+		}
+	}},
+
+	/* Hash MD5 */
+        { .type = CRYPTO_ALG_TYPE_AHASH, .u.hash = {
+		.init		= crypto4xx_hash_init,
+		.update		= crypto4xx_hash_update,
+		.final 		= crypto4xx_hash_final,
+		.digest		= crypto4xx_hash_digest,
+		.halg.digestsize 	= SA_HASH_ALG_MD5_DIGEST_SIZE,
+		.halg.base 	= {
+			.cra_name 		= "md5",
+			.cra_driver_name 	= "ppc4xx-md5",
+			.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+			.cra_flags 		= CRYPTO_ALG_TYPE_AHASH | CRYPTO_ALG_ASYNC,
+			.cra_blocksize 		= 64,
+			.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+			.cra_alignmask 		= 0,
+			.cra_type 		= &crypto_ahash_type,
+			.cra_init 		= crypto4xx_md5_alg_init,
+			.cra_exit		= crypto4xx_alg_exit,
+			.cra_module 		= THIS_MODULE,
+		}
+	}},
+#endif
+#if 1
+	/* Hash MD5-HMAC */
+        { .type = CRYPTO_ALG_TYPE_AHASH, .u.hash = {
+		.init		= crypto4xx_hash_init,
+		.update		= crypto4xx_hash_update,
+		.final 		= crypto4xx_hash_final,
+		.digest		= crypto4xx_hash_digest,
+		.setkey		= crypto4xx_md5_hmac_setkey,
+		.halg.digestsize	= SA_HASH_ALG_MD5_DIGEST_SIZE,
+		.halg.base = {
+			.cra_name 		= "hmac(md5)",
+			.cra_driver_name 	= "ppc4xx-hmac-md5",
+			.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+			.cra_flags 		= CRYPTO_ALG_TYPE_AHASH | CRYPTO_ALG_ASYNC,
+			.cra_blocksize 		= 64,
+			.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+			.cra_alignmask 		= 0,
+			.cra_type 		= &crypto_ahash_type,
+			.cra_module 		= THIS_MODULE,
+		}
+	}},
+
+	/* Hash SHA1, SHA2 and HMAC */
+        { .type = CRYPTO_ALG_TYPE_AHASH, .u.hash = {
+		.init   	= crypto4xx_hash_init,
+		.update 	= crypto4xx_hash_update,
+		.final  	= crypto4xx_hash_final,
+		.digest 	= crypto4xx_hash_digest,
+		.halg.digestsize	= SHA1_DIGEST_SIZE,
+		.halg.base = {
+			.cra_name 		= "sha1",
+			.cra_driver_name 	= "ppc4xx-sha1",
+			.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+			.cra_flags 		= CRYPTO_ALG_TYPE_AHASH | CRYPTO_ALG_ASYNC,
+			.cra_blocksize 		= SHA1_BLOCK_SIZE,
+			.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+			.cra_alignmask 		= 0,
+			.cra_type   		= &crypto_ahash_type,
+			.cra_init 		= crypto4xx_sha1_alg_init,
+			.cra_exit		= crypto4xx_alg_exit,
+			.cra_module 		= THIS_MODULE,
+		}
+	}},
+#endif
+        { .type = CRYPTO_ALG_TYPE_AHASH, .u.hash = {
+		.init   	= crypto4xx_hash_init,
+		.update 	= crypto4xx_hash_update,
+		.final  	= crypto4xx_hash_final,
+		.digest 	= crypto4xx_hash_digest,
+		.setkey 	= crypto4xx_sha1_hmac_setkey,
+		.halg.digestsize 	= SHA1_DIGEST_SIZE,
+		.halg.base = {
+			.cra_name 		= "hmac(sha1)",
+			.cra_driver_name 	= "ppc4xx-hmac-sha1",
+			.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+			.cra_flags 		= CRYPTO_ALG_TYPE_AHASH | CRYPTO_ALG_ASYNC,
+			.cra_blocksize 		= SHA1_BLOCK_SIZE,
+			.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+			.cra_alignmask 		= 0,
+			.cra_type   		= &crypto_ahash_type,
+			.cra_module 		= THIS_MODULE,
+		}
+	}},
+
+#if 1
+        { .type = CRYPTO_ALG_TYPE_AHASH, .u.hash = {
+		.init		= crypto4xx_hash_init,
+		.update		= crypto4xx_hash_update,
+		.final 		= crypto4xx_hash_final,
+		.digest		= crypto4xx_hash_digest,
+		.halg.digestsize	= SHA224_DIGEST_SIZE,
+		.halg.base = {
+			.cra_name 		= "sha224",
+			.cra_driver_name 	= "ppc4xx-sha224",
+			.cra_priority		= CRYPTO4XX_CRYPTO_PRIORITY,
+			.cra_flags 		= CRYPTO_ALG_TYPE_AHASH | CRYPTO_ALG_ASYNC,
+			.cra_blocksize 		= SHA224_BLOCK_SIZE,
+			.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+			.cra_alignmask 		= 0,
+			.cra_type 		= &crypto_ahash_type,
+			.cra_init 		= crypto4xx_sha2_alg_init,
+			.cra_exit		= crypto4xx_alg_exit,
+			.cra_module 		= THIS_MODULE,
+		}
+	}},
+
+        { .type = CRYPTO_ALG_TYPE_AHASH, .u.hash = {
+		.init   	= crypto4xx_hash_init,
+		.update		= crypto4xx_hash_update,
+		.final 		= crypto4xx_hash_final,
+		.digest		= crypto4xx_hash_digest,
+		.setkey		= crypto4xx_sha2_hmac_setkey,
+		.halg.digestsize 	= SHA224_DIGEST_SIZE,
+		.halg.base = {
+			.cra_name 		= "hmac(sha224)",
+			.cra_driver_name 	= "ppc4xx-hmac-sha224",
+			.cra_priority		= CRYPTO4XX_CRYPTO_PRIORITY,
+			.cra_flags 		= CRYPTO_ALG_TYPE_AHASH | CRYPTO_ALG_ASYNC,
+			.cra_blocksize 		= SHA224_BLOCK_SIZE,
+			.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+			.cra_alignmask 		= 0,
+			.cra_type 		= &crypto_ahash_type,
+			.cra_module 		= THIS_MODULE,
+		}
+	}},
+
+        { .type = CRYPTO_ALG_TYPE_AHASH, .u.hash = {
+		.init		= crypto4xx_hash_init,
+		.update		= crypto4xx_hash_update,
+		.final 		= crypto4xx_hash_final,
+		.digest		= crypto4xx_hash_digest,
+		.halg.digestsize	= SHA256_DIGEST_SIZE,
+		.halg.base = {
+			.cra_name 		= "sha256",
+			.cra_driver_name 	= "ppc4xx-sha256",
+			.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+			.cra_flags 		= CRYPTO_ALG_TYPE_AHASH | CRYPTO_ALG_ASYNC,
+			.cra_blocksize 		= SHA256_BLOCK_SIZE,
+			.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+			.cra_alignmask 		= 0,
+			.cra_type 		= &crypto_ahash_type,
+			.cra_init 		= crypto4xx_sha2_alg_init,
+			.cra_exit		= crypto4xx_alg_exit,
+			.cra_module 		= THIS_MODULE,
+		}
+	}},
 
+        { .type = CRYPTO_ALG_TYPE_AHASH, .u.hash = {
+		.init		= crypto4xx_hash_init,
+		.update		= crypto4xx_hash_update,
+		.final 		= crypto4xx_hash_final,
+		.digest		= crypto4xx_hash_digest,
+		.setkey		= crypto4xx_sha2_hmac_setkey,
+		.halg.digestsize	= SHA256_DIGEST_SIZE,
+		.halg.base = {
+			.cra_name 		= "hmac(sha256)",
+			.cra_driver_name 	= "ppc4xx-hmac-sha256",
+			.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+			.cra_flags 		= CRYPTO_ALG_TYPE_AHASH | CRYPTO_ALG_ASYNC,
+			.cra_blocksize 		= SHA256_BLOCK_SIZE,
+			.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+			.cra_alignmask 		= 0,
+			.cra_type 		= &crypto_ahash_type,
+			.cra_module 		= THIS_MODULE,
+		}
+	}},
+
+        { .type = CRYPTO_ALG_TYPE_AHASH, .u.hash = {
+		.init		= crypto4xx_hash_init,
+		.update		= crypto4xx_hash_update,
+		.final 		= crypto4xx_hash_final,
+		.digest		= crypto4xx_hash_digest,
+		.halg.digestsize	= SHA384_DIGEST_SIZE,
+		.halg.base = {
+			.cra_name 		= "sha384",
+			.cra_driver_name 	= "ppc4xx-sha384",
+			.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+			.cra_flags 		= CRYPTO_ALG_TYPE_AHASH | CRYPTO_ALG_ASYNC,
+			.cra_blocksize 		= SHA384_BLOCK_SIZE,
+			.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+			.cra_alignmask 		= 0,
+			.cra_type 		= &crypto_ahash_type,
+			.cra_init 		= crypto4xx_sha2_alg_init,
+			.cra_exit		= crypto4xx_alg_exit,
+			.cra_module 		= THIS_MODULE,
+		}
+	}},
+
+        { .type = CRYPTO_ALG_TYPE_AHASH, .u.hash = {
+		.init		= crypto4xx_hash_init,
+		.update 	= crypto4xx_hash_update,
+		.final 		= crypto4xx_hash_final,
+		.digest		= crypto4xx_hash_digest,
+		.setkey		= crypto4xx_sha2_hmac_setkey,
+		.halg.digestsize	= SHA384_DIGEST_SIZE,
+		.halg.base = {
+			.cra_name 		= "hmac(sha384)",
+			.cra_driver_name 	= "ppc4xx-hmac-sha384",
+			.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+			.cra_flags 		= CRYPTO_ALG_TYPE_AHASH | CRYPTO_ALG_ASYNC,
+			.cra_blocksize 		= SHA384_BLOCK_SIZE,
+			.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+			.cra_alignmask 		= 0,
+			.cra_type 		= &crypto_ahash_type,
+			.cra_module 		= THIS_MODULE,
+		}
+	}},
+
+        { .type = CRYPTO_ALG_TYPE_AHASH, .u.hash = {
+		.init		= crypto4xx_hash_init,
+		.update		= crypto4xx_hash_update,
+		.final 		= crypto4xx_hash_final,
+		.digest		= crypto4xx_hash_digest,
+		.halg.digestsize 	= SHA512_DIGEST_SIZE,
+		.halg.base = {
+			.cra_name 		= "sha512",
+			.cra_driver_name 	= "ppc4xx-sha512",
+			.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+			.cra_flags 		= CRYPTO_ALG_TYPE_AHASH | CRYPTO_ALG_ASYNC,
+			.cra_blocksize 		= SHA512_BLOCK_SIZE,
+			.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+			.cra_alignmask 		= 0,
+			.cra_type 		= &crypto_ahash_type,
+			.cra_init 		= crypto4xx_sha2_alg_init,
+			.cra_exit		= crypto4xx_alg_exit,
+			.cra_module 		= THIS_MODULE,
+		}
+	}},
+#endif
+#if 1
+        { .type = CRYPTO_ALG_TYPE_AHASH, .u.hash = {
+		.init		= crypto4xx_hash_init,
+		.update		= crypto4xx_hash_update,
+		.final		= crypto4xx_hash_final,
+		.digest 	= crypto4xx_hash_digest,
+		.setkey 	= crypto4xx_sha2_hmac_setkey,
+		.halg.digestsize 	= SHA512_DIGEST_SIZE,
+		.halg.base = {
+			.cra_name 		= "hmac(sha512)",
+			.cra_driver_name 	= "ppc4xx-hmac-sha512",
+			.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+			.cra_flags 		= CRYPTO_ALG_TYPE_AHASH | CRYPTO_ALG_ASYNC,
+			.cra_blocksize 		= SHA512_BLOCK_SIZE,
+			.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+			.cra_alignmask 		= 0,
+			.cra_type 		= &crypto_ahash_type,
+			.cra_module 		= THIS_MODULE,
+		}
+	}},
+	/* Hash XCBC, GHASH, and Kasumi F9 */
+	{ .type = CRYPTO_ALG_TYPE_AHASH, .u.hash = {
+		.init   	= crypto4xx_hash_init,
+		.update 	= crypto4xx_hash_update,
+		.final  	= crypto4xx_hash_final,
+		.digest 	= crypto4xx_hash_digest,
+		.setkey 	= crypto4xx_xcbc_setkey,
+		.halg.digestsize 	= 16,
+		.halg.base = {
+			.cra_name 		= "xcbc(aes)",
+			.cra_driver_name	= "ppc4xx-xcbc-aes",
+			.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+			.cra_flags 		= CRYPTO_ALG_TYPE_AHASH | CRYPTO_ALG_ASYNC,
+			.cra_blocksize 		= AES_BLOCK_SIZE,
+			.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+			.cra_alignmask 		= 0,
+			.cra_type 		= &crypto_ahash_type,
+			.cra_module 		= THIS_MODULE,
+		}
+	}},
+
+	/* Crypto Kasumi and Kasumi F8 */
+        { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, .u.cipher = {
+		.cra_name 		= "kasumi",
+		.cra_driver_name 	= "ppc4xx-kasumi",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
+		.cra_blocksize		= KASUMI_BLOCK_SIZE,
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_ablkcipher_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.ablkcipher = {
+				.min_keysize 	= KASUMI_KEY_SIZE,
+				.max_keysize 	= KASUMI_KEY_SIZE,
+				.ivsize 	= KASUMI_BLOCK_SIZE,
+				.setkey 	= crypto4xx_setkey_kasumi_p,
+				.encrypt	= crypto4xx_encrypt,
+				.decrypt	= crypto4xx_decrypt,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, .u.cipher = {
+		.cra_name 		= "f8(kasumi)",
+		.cra_driver_name 	= "ppc4xx-f8-kasumi",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
+		.cra_blocksize		= KASUMI_BLOCK_SIZE,
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_ablkcipher_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.ablkcipher = {
+				.min_keysize	= KASUMI_KEY_SIZE,
+				.max_keysize	= KASUMI_KEY_SIZE,
+				.ivsize		= KASUMI_BLOCK_SIZE,
+				.setkey		= crypto4xx_setkey_kasumi_f8,
+				.encrypt	= crypto4xx_encrypt_kasumi_f8,
+				.decrypt	= crypto4xx_decrypt_kasumi_f8,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AHASH, .u.hash = {
+		.init   	= crypto4xx_hash_init,
+		.update 	= crypto4xx_hash_update,
+		.final  	= crypto4xx_hash_final,
+		.digest 	= crypto4xx_kasumi_f9_digest,
+		.setkey 	= crypto4xx_kasumi_f9_setkey,
+		.halg.digestsize 	= 8,
+		.halg.base = {
+			.cra_name 		= "f9(kasumi)",
+			.cra_driver_name 	= "ppc4xx-f9-kasumi",
+			.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+			.cra_flags 		= CRYPTO_ALG_TYPE_AHASH | CRYPTO_ALG_ASYNC,
+			.cra_blocksize		= KASUMI_BLOCK_SIZE,
+			.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+			.cra_alignmask		= 0,
+			.cra_type 		= &crypto_ahash_type,
+			.cra_module 		= THIS_MODULE,
+		}
+	}},
+#endif
+#if 1
+	/* Crypto ARC4 - stateless */
+        { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, .u.cipher = {
+		.cra_name 		= "ecb(arc4)",
+		.cra_driver_name 	= "ppc4xx-arc4",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 1,
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_ablkcipher_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.ablkcipher = {
+				.min_keysize 	= 1,
+				.max_keysize 	= 16,
+				.setkey 	= crypto4xx_setkey_arc4,
+				.encrypt	= crypto4xx_arc4_encrypt,
+				.decrypt	= crypto4xx_arc4_decrypt,
+			}
+		}
+	}},
+	/* Crypto ARC4 - statefull */
+        { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, .u.cipher = {
+		.cra_name 		= "cbc(arc4)",
+		.cra_driver_name 	= "ppc4xx-arc4",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_BLKCIPHER | CRYPTO_ALG_ASYNC,
+		.cra_blocksize		= 1,
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type		= &crypto_ablkcipher_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.ablkcipher = {
+				.min_keysize 	= 1,
+				.max_keysize	= 16,
+				.setkey		= crypto4xx_setkey_arc4,
+				.encrypt 	= crypto4xx_arc4_encrypt,
+				.decrypt	= crypto4xx_arc4_decrypt,
+			}
+		}
+	}},
+#endif
+#if 1
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tunnel(esp(authenc(hmac(md5),cbc(aes))))",
+		.cra_driver_name 	= "tunnel-esp-cbc-aes-md5",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 16,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			={
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 16,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tunnel_esp_cbc_aes_md5,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_esp_cbc,
+			}
+		}
+	}},
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tunnel(esp(authenc(hmac(sha1),cbc(aes))))",
+		.cra_driver_name 	= "tunnel-esp-cbc-aes-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 16,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 20,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tunnel_esp_cbc_aes_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_esp_cbc,
+			}
+		}
+	}},
+#endif
+#if 1
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tunnel(esp(authenc(hmac(sha224),cbc(aes))))",
+		.cra_driver_name 	= "tunnel-esp-cbc-aes-sha224",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 16,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 28,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tunnel_esp_cbc_aes_sha224,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_esp_cbc,
+			}
+		}
+	}},
+#endif
+#if 1
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tunnel(esp(authenc(hmac(sha256),cbc(aes))))",
+		.cra_driver_name 	= "tunnel-esp-cbc-aes-sha256",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 16,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 32,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tunnel_esp_cbc_aes_sha256,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_esp_cbc,
+			}
+		}
+	}},
+
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tunnel(esp(authenc(hmac(sha384),cbc(aes))))",
+		.cra_driver_name 	= "tunnel-esp-cbc-aes-sha384",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 16,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 48,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tunnel_esp_cbc_aes_sha384,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_esp_cbc,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tunnel(esp(authenc(hmac(sha512),cbc(aes))))",
+		.cra_driver_name 	= "tunnel-esp-cbc-aes-sha512",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 16,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 64,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tunnel_esp_cbc_aes_sha512,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_esp_cbc,
+			}
+		}
+	}},
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tunnel(esp(authenc(hmac(md5),cbc(des))))",
+		.cra_driver_name 	= "tunnel-esp-cbc-des-md5",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 16,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tunnel_esp_cbc_des_md5,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_esp_cbc,
+			}
+		}
+	}},
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tunnel(esp(authenc(hmac(sha1),cbc(des))))",
+		.cra_driver_name 	= "tunnel-esp-cbc-des-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 20,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tunnel_esp_cbc_des_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_esp_cbc,
+			}
+		}
+	}},
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tunnel(esp(authenc(hmac(sha224),cbc(des))))",
+		.cra_driver_name 	= "tunnel-esp-cbc-des-sha224",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+			.ivsize 		= 8,	/* IV size is 16 bytes */
+			.maxauthsize		= 28,	/* Max auth data size in bytes */
+			.setkey 		= crypto4xx_setkey_tunnel_esp_cbc_des_sha224,
+			.setauthsize		= NULL,
+			.encrypt 		= crypto4xx_encrypt_esp_cbc,
+			.decrypt 		= crypto4xx_decrypt_esp_cbc,
+			.givencrypt		= crypto4xx_givencrypt_esp_cbc,
+			}
+		}
+	}},
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tunnel(esp(authenc(hmac(sha256),cbc(des))))",
+		.cra_driver_name 	= "tunnel-esp-cbc-des-sha256",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 32,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tunnel_esp_cbc_des_sha256,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_esp_cbc,
+			}
+		}
+	}},
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tunnel(esp(authenc(hmac(sha384),cbc(des))))",
+		.cra_driver_name 	= "tunnel-esp-cbc-des-sha384",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 48,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tunnel_esp_cbc_des_sha384,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_esp_cbc,
+			}
+		}
+	}},
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tunnel(esp(authenc(hmac(sha512),cbc(des))))",
+		.cra_driver_name 	= "tunnel-esp-cbc-des-sha512",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 64,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tunnel_esp_cbc_des_sha512,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_esp_cbc,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tunnel(esp(authenc(hmac(md5),cbc(des3_ede))))",
+		.cra_driver_name 	= "tunnel-esp-cbc-3des-md5",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 16,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tunnel_esp_cbc_3des_md5,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_esp_cbc,
+			}
+		}
+	}},
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tunnel(esp(authenc(hmac(md5),cbc(des3_ede))))",
+		.cra_driver_name 	= "tunnel-esp-cbc-3des-md5",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 16,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tunnel_esp_cbc_3des_md5,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_esp_cbc,
+			}
+		}
+	}},
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tunnel(esp(authenc(hmac(sha1),cbc(des3_ede))))",
+		.cra_driver_name 	= "tunnel-esp-cbc-3des-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+		.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 20,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tunnel_esp_cbc_3des_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_esp_cbc,
+			}
+		}
+	}},
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tunnel(esp(authenc(hmac(sha224),cbc(des3_ede))))",
+		.cra_driver_name 	= "tunnel-esp-cbc-3des-sha224",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 28,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tunnel_esp_cbc_3des_sha224,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_esp_cbc,
+			}
+		}
+	}},
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tunnel(esp(authenc(hmac(sha256),cbc(des3_ede))))",
+		.cra_driver_name 	= "tunnel-esp-cbc-3des-sha256",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 32,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tunnel_esp_cbc_3des_sha256,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_esp_cbc,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tunnel(esp(authenc(hmac(sha384),cbc(des3_ede))))",
+		.cra_driver_name 	= "tunnel-esp-cbc-3des-sha384",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 48,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tunnel_esp_cbc_3des_sha384,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_esp_cbc,
+			}
+		}
+	}},
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tunnel(esp(authenc(hmac(sha512),cbc(des3_ede))))",
+		.cra_driver_name 	= "tunnel-esp-cbc-3des-sha512",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 8 bytes */
+				.maxauthsize		= 64,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tunnel_esp_cbc_3des_sha512,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_esp_cbc,
+			}
+		}
+	}},
+	
+	/** IPSec transport combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "transport(esp(authenc(hmac(md5),cbc(aes))))",
+		.cra_driver_name 	= "transport-esp-cbc-aes-md5",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 16,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 16,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_transport_esp_cbc_aes_md5,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_transport_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_transport_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_transport_esp_cbc,
+			}
+		}
+	}},
+
+
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "transport(esp(authenc(hmac(sha1),cbc(aes))))",
+		.cra_driver_name 	= "transport-esp-cbc-aes-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 16,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 20,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_transport_esp_cbc_aes_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_transport_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_transport_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_transport_esp_cbc,
+			}
+		}
+	}},
+
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "transport(esp(authenc(hmac(sha224),cbc(aes))))",
+		.cra_driver_name 	= "transport-esp-cbc-aes-sha224",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 16,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 28,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_transport_esp_cbc_aes_sha224,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_transport_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_transport_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_transport_esp_cbc,
+			}
+		}
+	}},
+
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "transport(esp(authenc(hmac(sha256),cbc(aes))))",
+		.cra_driver_name 	= "transport-esp-cbc-aes-sha224",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 16,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 32,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_transport_esp_cbc_aes_sha256,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_transport_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_transport_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_transport_esp_cbc,
+			}
+		}
+	}},
+
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "transport(esp(authenc(hmac(sha384),cbc(aes))))",
+		.cra_driver_name 	= "transport-esp-cbc-aes-sha384",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 16,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit 		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 48,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_transport_esp_cbc_aes_sha384,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_transport_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_transport_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_transport_esp_cbc,
+			}
+		}
+	}},
+
+
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "transport(esp(authenc(hmac(sha512),cbc(aes))))",
+		.cra_driver_name 	= "transport-esp-cbc-aes-sha512",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 16,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit 		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 64,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_transport_esp_cbc_aes_sha512,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_transport_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_transport_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_transport_esp_cbc,
+			}
+		}
+	}},
+
+	/* IPSec transport combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "transport(esp(authenc(hmac(md5),cbc(des))))",
+		.cra_driver_name 	= "transport-esp-cbc-des-md5",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit 		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 16,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_transport_esp_cbc_des_md5,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_transport_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_transport_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_transport_esp_cbc,
+			}
+		}
+	}},
+
+
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "transport(esp(authenc(hmac(sha1),cbc(des))))",
+		.cra_driver_name 	= "transport-esp-cbc-des-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 	= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit 		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 20,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_transport_esp_cbc_des_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_transport_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_transport_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_transport_esp_cbc,
+			}
+		}
+	}},
+
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "transport(esp(authenc(hmac(sha224),cbc(des))))",
+		.cra_driver_name 	= "transport-esp-cbc-des-sha224",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit 		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 28,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_transport_esp_cbc_des_sha224,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_transport_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_transport_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_transport_esp_cbc,
+			}
+		}
+	}},
+
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "transport(esp(authenc(hmac(sha256),cbc(des))))",
+		.cra_driver_name 	= "transport-esp-cbc-des-sha256",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit 		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 32,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_transport_esp_cbc_des_sha256,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_transport_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_transport_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_transport_esp_cbc,
+			}
+		}
+	}},
+
+
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "transport(esp(authenc(hmac(sha384),cbc(des))))",
+		.cra_driver_name 	= "transport-esp-cbc-des-sha384",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit 		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 48,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_transport_esp_cbc_des_sha384,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_transport_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_transport_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_transport_esp_cbc,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "transport(esp(authenc(hmac(sha512),cbc(des))))",
+		.cra_driver_name 	= "transport-esp-cbc-des-sha512",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit 		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 64,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_transport_esp_cbc_des_sha512,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_transport_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_transport_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_transport_esp_cbc,
+			}
+		}
+	}},
+
+	/* IPSec transport combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "transport(esp(authenc(hmac(md5),cbc(des3_ede))))",
+		.cra_driver_name 	= "transport-esp-cbc-3des-md5",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit 		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 16,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_transport_esp_cbc_3des_md5,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_transport_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_transport_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_transport_esp_cbc,
+			}
+		}
+	}},
+
+
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "transport(esp(authenc(hmac(sha1),cbc(des3_ede))))",
+		.cra_driver_name 	= "transport-esp-cbc-3des-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit 		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 20,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_transport_esp_cbc_3des_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_transport_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_transport_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_transport_esp_cbc,
+			}
+		}
+	}},
+
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "transport(esp(authenc(hmac(sha224),cbc(des3_ede))))",
+		.cra_driver_name 	= "transport-esp-cbc-3des-sha224",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit 		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 28,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_transport_esp_cbc_3des_sha224,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_transport_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_transport_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_transport_esp_cbc,
+			}
+		}
+	}},
+#endif
+#if 1
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "transport(esp(authenc(hmac(sha256),cbc(des3_ede))))",
+		.cra_driver_name 	= "transport-esp-cbc-3des-sha256",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 32,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_transport_esp_cbc_3des_sha256,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_transport_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_transport_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_transport_esp_cbc,
+			}
+		}
+	}},
+
+	/* IPSec combined hash and crypto Algorithms */
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "transport(esp(authenc(hmac(sha384),cbc(des3_ede))))",
+		.cra_driver_name 	= "transport-esp-cbc-3des-sha384",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 48,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_transport_esp_cbc_3des_sha384,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_transport_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_transport_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_transport_esp_cbc,
+			}
+		}
+	}},
+
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "transport(esp(authenc(hmac(sha512),cbc(des3_ede))))",
+		.cra_driver_name 	= "transport-esp-cbc-3des-sha512",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 8,
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 64,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_transport_esp_cbc_3des_sha512,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_transport_esp_cbc,
+				.decrypt 		= crypto4xx_decrypt_transport_esp_cbc,
+				.givencrypt		= crypto4xx_givencrypt_transport_esp_cbc,
+			}
+		}
+	}},
+	
+	{ .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "transport(esp(rfc4106(gcm(aes))))",
+		.cra_driver_name 	= "transport-esp-rfc4106-gcm-aes",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 16,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,	/* Hardware requires 16 bytes aligned */
+		.cra_type 		= &crypto_aead_type,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+				.aead = {
+			.ivsize 		= 8,	/* IV size for crypto */
+			.maxauthsize		= 12,	/* Max auth data size in bytes */
+			.setkey 		= crypto4xx_setkey_transport_esp_rfc4106_gcm,
+			.setauthsize		= crypto4xx_setauthsize_aes,
+			.encrypt 		= crypto4xx_encrypt_transport_esp_cbc,
+			.decrypt 		= crypto4xx_decrypt_transport_esp_cbc,
+			.givencrypt		= crypto4xx_givencrypt_transport_esp_cbc,
+			}
+		}
+	}},
+
+	{ .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "rfc4106(gcm(aes))",
+		.cra_driver_name 	= "transport-esp-rfc4104-gcm-aes",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY_IPSEC-100,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 	= 16,
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 	= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_exit 		= crypto4xx_alg_exit,
+		.cra_u 		= {.aead = {
+		.ivsize 		= 8,	/* IV size is 16 bytes */
+		.setkey 		= crypto4xx_setkey_transport_esp_rfc4106_gcm,
+		.setauthsize		= crypto4xx_setauthsize_aes,
+		.encrypt 		= crypto4xx_encrypt_transport_esp_cbc,
+		.decrypt 		= crypto4xx_decrypt_transport_esp_cbc,
+		.givencrypt		= crypto4xx_givencrypt_transport_esp_cbc,
+		}
+	}}},
+	
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "macsec(gcm)",
+		.cra_driver_name 	= "macsec-ppc4xx",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_macsec_gcm,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_macsec,
+				.decrypt 		= crypto4xx_decrypt_macsec,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+#endif
+#if 1
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "dtls(aes-sha1)",
+		.cra_driver_name 	= "dtls-ppc4xx",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_dtls_aes_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_dtls,
+				.decrypt 		= crypto4xx_decrypt_dtls,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+#endif
+#if 1
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "dtls(des-sha1)",
+		.cra_driver_name 	= "ppc4xx-dtls-des-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 		= {
+		 	.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_dtls_des_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_dtls,
+				.decrypt 		= crypto4xx_decrypt_dtls,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+	 	}
+	}},
+#endif
+#if 1
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "dtls(des3-sha1)",
+		.cra_driver_name 	= "ppc4xx-dtls-des3-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+		 	.aead	= {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_dtls_des3_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_dtls,
+				.decrypt 		= crypto4xx_decrypt_dtls,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+	 	}
+	}},
+
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "dtls(NULL-md5)",
+		.cra_driver_name 	= "ppc4xx-dtls-null-md5",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u			= {
+		 	.aead = {
+				.ivsize 		= 0,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_dtls_null_md5,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_dtls,
+				.decrypt 		= crypto4xx_decrypt_dtls,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			 }
+	 	}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "dtls(NULL-sha1)",
+		.cra_driver_name 	= "ppc4xx-dtls-null-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 		= {
+		 	.aead = {
+			.ivsize 		= 0,	/* IV size is 16 bytes */
+			.maxauthsize		= 128,	/* Max auth data size in bytes */
+			.setkey 		= crypto4xx_setkey_dtls_null_sha1,
+			.setauthsize		= NULL,
+			.encrypt 		= crypto4xx_encrypt_dtls,
+			.decrypt 		= crypto4xx_decrypt_dtls,
+			.givencrypt		= NULL,
+			.givdecrypt		= NULL,
+	 		}
+	 	}
+	}},
+
+#endif
+#if 1
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "ssl(aes-sha1)",
+		.cra_driver_name 	= "ppc4xx-ssl-aes-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 64 bits  ... 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0xF,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 		= {
+		 	.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_ssl_aes_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_ssl_aes,
+				.decrypt 		= crypto4xx_decrypt_ssl_aes,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "ssl(des-sha1)",
+		.cra_driver_name 	= "ppc4xx-ssl-des-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+			.ivsize 		= 16,	/* IV size is 16 bytes */
+			.maxauthsize		= 128,	/* Max auth data size in bytes */
+			.setkey 		= crypto4xx_setkey_ssl_des_sha1,
+			.setauthsize		= NULL,
+			.encrypt 		= crypto4xx_encrypt_ssl_des,
+			.decrypt 		= crypto4xx_decrypt_ssl_des,
+			.givencrypt		= NULL,
+			.givdecrypt		= NULL,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "ssl(des3-sha1)",
+		.cra_driver_name 	= "ppc4xx-ssl-des3-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_ssl_des3_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_ssl_des,
+				.decrypt 		= crypto4xx_decrypt_ssl_des,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "ssl(arc4-sha1)",
+		.cra_driver_name 	= "ppc4xx-ssl-arc4-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_ssl_arc4_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_ssl_arc4,
+				.decrypt 		= crypto4xx_decrypt_ssl_arc4,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "ssl(arc4-md5)",
+		.cra_driver_name 	= "ppc4xx-ssl-arc4-md5",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_ssl_arc4_md5,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_ssl_arc4,
+				.decrypt 		= crypto4xx_decrypt_ssl_arc4,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+#endif
+#if 1
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "ssl(NULL-md5)",
+		.cra_driver_name 	= "ppc4xx-ssl-null-md5",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 0,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_ssl_null_md5,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_ssl_null,
+				.decrypt 		= crypto4xx_decrypt_ssl_null,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "ssl(NULL-sha1)",
+		.cra_driver_name 	= "ppc4xx-ssl-null-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 0,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_ssl_null_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_ssl_null,
+				.decrypt 		= crypto4xx_decrypt_ssl_null,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+#endif
+#if 1
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tls(aes-sha1)",
+		.cra_driver_name 	= "ppc4xx-tls-aes-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tls_aes_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_ssl_aes,
+				.decrypt 		= crypto4xx_decrypt_ssl_aes,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tls(des-sha1)",
+		.cra_driver_name 	= "ppc4xx-tls-des-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tls_des_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_ssl_des,
+				.decrypt 		= crypto4xx_decrypt_ssl_des,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tls(des3-sha1)",
+		.cra_driver_name 	= "ppc4xx-tls-des3-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tls_des3_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_ssl_des,
+				.decrypt 		= crypto4xx_decrypt_ssl_des,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tls(arc4-sha1)",
+		.cra_driver_name 	= "ppc4xx-tls-arc4-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tls_arc4_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_ssl_arc4,
+				.decrypt 		= crypto4xx_decrypt_ssl_arc4,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tls(arc4-md5)",
+		.cra_driver_name 	= "ppc4xx-tls-arc4-md5",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tls_arc4_md5,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_ssl_arc4,
+				.decrypt 		= crypto4xx_decrypt_ssl_arc4,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tls(NULL-md5)",
+		.cra_driver_name 	= "ppc4xx-tls-null-md5",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 0,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tls_null_md5,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_ssl_null,
+				.decrypt 		= crypto4xx_decrypt_ssl_null,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tls(NULL-sha1)",
+		.cra_driver_name 	= "ppc4xx-tls-null-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 0,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tls_null_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_ssl_null,
+				.decrypt 		= crypto4xx_decrypt_ssl_null,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tls1_1(aes-sha1)",
+		.cra_driver_name 	= "ppc4xx-tls1.1-aes-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tls1_1_aes_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_dtls,
+				.decrypt 		= crypto4xx_decrypt_dtls,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tls1_1(des-sha1)",
+		.cra_driver_name 	= "ppc4xx-tls1.1-des-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tls1_1_des_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_dtls,
+				.decrypt 		= crypto4xx_decrypt_dtls,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tls1_1(des3-sha1)",
+		.cra_driver_name 	= "ppc4xx-tls1.1-des3-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 8,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tls1_1_des3_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_dtls,
+				.decrypt 		= crypto4xx_decrypt_dtls,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tls1_1(arc4-sha1)",
+		.cra_driver_name 	= "ppc4xx-tls1.1-arc4-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tls1_1_arc4_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_ssl_arc4,
+				.decrypt 		= crypto4xx_decrypt_ssl_arc4,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tls1_1(arc4-md5)",
+		.cra_driver_name 	= "ppc4xx-tls1.1-arc4-md5",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 16,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tls1_1_arc4_md5,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_ssl_arc4,
+				.decrypt 		= crypto4xx_decrypt_ssl_arc4,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tls1_1(NULL-md5)",
+		.cra_driver_name 	= "ppc4xx-tls1.1-null-md5",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 0,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tls1_1_null_md5,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_dtls,
+				.decrypt 		= crypto4xx_decrypt_dtls,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+
+        { .type = CRYPTO_ALG_TYPE_AEAD, .u.cipher = {
+		.cra_name 		= "tls1_1(NULL-sha1)",
+		.cra_driver_name 	= "ppc4xx-tls1.1-null-sha1",
+		.cra_priority 		= CRYPTO4XX_CRYPTO_PRIORITY,
+		.cra_flags 		= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC,
+		.cra_blocksize 		= 64,	/* 128-bits block */
+		.cra_ctxsize 		= sizeof(struct crypto4xx_ctx),
+		.cra_alignmask 		= 0,
+		.cra_type 		= &crypto_aead_type,
+		.cra_init		= crypto4xx_alg_init,
+		.cra_exit		= crypto4xx_alg_exit,
+		.cra_module 		= THIS_MODULE,
+		.cra_u 			= {
+			.aead = {
+				.ivsize 		= 0,	/* IV size is 16 bytes */
+				.maxauthsize		= 128,	/* Max auth data size in bytes */
+				.setkey 		= crypto4xx_setkey_tls1_1_null_sha1,
+				.setauthsize		= NULL,
+				.encrypt 		= crypto4xx_encrypt_dtls,
+				.decrypt 		= crypto4xx_decrypt_dtls,
+				.givencrypt		= NULL,
+				.givdecrypt		= NULL,
+			}
+		}
+	}},
+#endif
+};
+#define CRYPTO4XX_CONSOLE_DRIVER_NAME	"crypto4xx"
 /**
  * Module Initialization Routine
  */
@@ -1156,6 +3929,9 @@ static int __init crypto4xx_probe(struct of_device *ofdev,
 	struct resource res;
 	struct device *dev = &ofdev->dev;
 	struct crypto4xx_core_device *core_dev;
+	unsigned int pvr;
+	unsigned short min;
+	int revb_ver = 1;	/* RevB of crypto core */
 
 	rc = of_address_to_resource(ofdev->node, 0, &res);
 	if (rc)
@@ -1172,6 +3948,7 @@ static int __init crypto4xx_probe(struct of_device *ofdev,
 		       mfdcri(SDR0, PPC405EX_SDR0_SRST) | PPC405EX_CE_RESET);
 		mtdcri(SDR0, PPC405EX_SDR0_SRST,
 		       mfdcri(SDR0, PPC405EX_SDR0_SRST) & ~PPC405EX_CE_RESET);
+		revb_ver = 0;
 	} else if (of_find_compatible_node(NULL, NULL,
 			"amcc,ppc460sx-crypto")) {
 		mtdcri(SDR0, PPC460SX_SDR0_SRST,
@@ -1193,8 +3970,23 @@ static int __init crypto4xx_probe(struct of_device *ofdev,
 	if (!core_dev->dev)
 		goto err_alloc_dev;
 
+	/* Older version of 460EX/GT does not support H/W based security intr coalescing */
+	pvr = mfspr(SPRN_PVR);
+	printk("Reading pvr value = %x\n", pvr);
+	if ((pvr & 0xfffffff0) == 0x130218A0) {
+		min = PVR_MIN(pvr);
+		if (min < 4) {
+			printk(KERN_INFO "RevA 460EX/GT ... h/w bug in security intr coal\n");
+			revb_ver = 0;
+		} else {
+			printk(KERN_INFO "RevB h/w security interrupt coalescing supported ...\n");
+		}
+	}
+
+	core_dev->revb_ver = revb_ver;
 	core_dev->dev->core_dev = core_dev;
 	core_dev->device = dev;
+	core_dev->irq_cnt = 0ll;
 	spin_lock_init(&core_dev->lock);
 	INIT_LIST_HEAD(&core_dev->dev->alg_list);
 	rc = crypto4xx_build_pdr(core_dev->dev);
@@ -1209,6 +4001,25 @@ static int __init crypto4xx_probe(struct of_device *ofdev,
 	if (rc)
 		goto err_build_sdr;
 
+	proc_crypto4xx = proc_mkdir("driver/crypto4xx", NULL);
+	if(proc_crypto4xx == NULL) {
+		printk(KERN_ERR
+				"%s: Error creating proc entry\n",__FUNCTION__);
+		return -ENOMEM;
+	}
+ 
+	entry = create_proc_read_entry("crypto4xx",
+				       0,
+				       proc_crypto4xx,
+				       crypto4xx_device_read_procmem,
+				       core_dev);
+	if(entry == NULL) {
+		printk(KERN_CRIT
+				"%s: crypto4xx: create_proc_read_entry failed!\n",
+		__FUNCTION__);
+		return -ENOMEM;
+	}
+
 	/* Init tasklet for bottom half processing */
 	tasklet_init(&core_dev->tasklet, crypto4xx_bh_tasklet_cb,
 		     (unsigned long) dev);
@@ -1216,7 +4027,7 @@ static int __init crypto4xx_probe(struct of_device *ofdev,
 	/* Register for Crypto isr, Crypto Engine IRQ */
 	core_dev->irq = irq_of_parse_and_map(ofdev->node, 0);
 	rc = request_irq(core_dev->irq, crypto4xx_ce_interrupt_handler, 0,
-			 core_dev->dev->name, dev);
+			 "CRYPTO", dev);
 	if (rc)
 		goto err_request_irq;
 
@@ -1269,8 +4080,12 @@ static int __exit crypto4xx_remove(struct of_device *ofdev)
 	/* Un-register with Linux CryptoAPI */
 	crypto4xx_unregister_alg(core_dev->dev);
 	/* Free all allocated memory */
-	crypto4xx_stop_all(core_dev);
+	remove_proc_entry("crypto4xx", entry) ;
+	entry = NULL;
+	remove_proc_entry("driver/crypto4xx", proc_crypto4xx);
+	proc_crypto4xx = NULL;
 
+	crypto4xx_stop_all(core_dev);
 	return 0;
 }