diff options
Diffstat (limited to 'target/linux/coldfire/patches/024-Add-SEC-1.1-support-for-MCF547x-and-MCF548x.patch')
-rw-r--r-- | target/linux/coldfire/patches/024-Add-SEC-1.1-support-for-MCF547x-and-MCF548x.patch | 2093 |
1 files changed, 2093 insertions, 0 deletions
diff --git a/target/linux/coldfire/patches/024-Add-SEC-1.1-support-for-MCF547x-and-MCF548x.patch b/target/linux/coldfire/patches/024-Add-SEC-1.1-support-for-MCF547x-and-MCF548x.patch new file mode 100644 index 0000000000..53cebe184b --- /dev/null +++ b/target/linux/coldfire/patches/024-Add-SEC-1.1-support-for-MCF547x-and-MCF548x.patch @@ -0,0 +1,2093 @@ +From c925421b8c35357427499f3d298777535c2c6cfd Mon Sep 17 00:00:00 2001 +From: Alison Wang <b18965@freescale.com> +Date: Thu, 4 Aug 2011 09:59:45 +0800 +Subject: [PATCH 24/52] Add SEC 1.1 support for MCF547x and MCF548x + +Add SEC 1.1 support for MCF547x and MCF548x. The SEC driver is +in drivers/crypto. + +Signed-off-by: Alison Wang <b18965@freescale.com> +--- + arch/m68k/coldfire/m547x/mcf548x-devices.c | 2 +- + arch/m68k/include/asm/cf_io.h | 4 + + crypto/testmgr.c | 18 +- + drivers/crypto/Kconfig | 13 + + drivers/crypto/Makefile | 1 + + drivers/crypto/cf_talitos.c | 1727 ++++++++++++++++++++++++++++ + drivers/crypto/cf_talitos.h | 229 ++++ + 7 files changed, 1989 insertions(+), 5 deletions(-) + create mode 100644 drivers/crypto/cf_talitos.c + create mode 100644 drivers/crypto/cf_talitos.h + +--- a/arch/m68k/coldfire/m547x/mcf548x-devices.c ++++ b/arch/m68k/coldfire/m547x/mcf548x-devices.c +@@ -54,7 +54,7 @@ static struct resource coldfire_sec_reso + }; + + static struct platform_device coldfire_sec_device = { +- .name = "fsl-sec1", ++ .name = "talitos", + .id = -1, + .num_resources = ARRAY_SIZE(coldfire_sec_resources), + .resource = coldfire_sec_resources, +--- a/arch/m68k/include/asm/cf_io.h ++++ b/arch/m68k/include/asm/cf_io.h +@@ -192,4 +192,8 @@ static inline void memcpy_toio(volatile + #define writel(b, addr) (void)((*(volatile unsigned int *) (addr)) = (b)) + #endif /* readb */ + ++/* access ports */ ++#define setbits32(_addr, _v) out_be32((_addr), in_be32(_addr) | (_v)) ++#define clrbits32(_addr, _v) out_be32((_addr), in_be32(_addr) & ~(_v)) ++ + #endif /* _IO_H */ +--- a/crypto/testmgr.c ++++ b/crypto/testmgr.c +@@ -212,7 +212,11 @@ static int test_hash(struct crypto_ahash + tcrypt_complete, &tresult); + + j = 0; ++#if defined(CONFIG_CRYPTO_DEV_CF_TALITOS) ++ for (i = 1; i < tcount; i++) { ++#else + for (i = 0; i < tcount; i++) { ++#endif + if (template[i].np) + continue; + +@@ -276,7 +280,9 @@ static int test_hash(struct crypto_ahash + hexdump(result, crypto_ahash_digestsize(tfm)); + ret = -EINVAL; + goto out; +- } ++ } else ++ printk(KERN_INFO "alg: hash: Test %d succeed for %s\n", ++ j, algo); + } + + j = 0; +@@ -344,7 +350,9 @@ static int test_hash(struct crypto_ahash + hexdump(result, crypto_ahash_digestsize(tfm)); + ret = -EINVAL; + goto out; +- } ++ } else ++ printk(KERN_INFO "alg: hash: Chunking test %d " ++ "succeed for %s\n", j, algo); + } + } + +@@ -788,7 +796,6 @@ static int test_skcipher(struct crypto_a + else + e = "decryption"; + +- printk(KERN_INFO "%s testing %s %s\n", __func__, algo, e); + init_completion(&result.completion); + + req = ablkcipher_request_alloc(tfm, GFP_KERNEL); +@@ -963,7 +970,10 @@ static int test_skcipher(struct crypto_a + "%u for %s\n", j, e, k, algo); + hexdump(q, template[i].tap[k]); + goto out; +- } ++ } else ++ printk(KERN_INFO "alg: skcipher: Chunk " ++ "test %d pass on %s for %s\n", ++ j, e, algo); + + q += template[i].tap[k]; + for (n = 0; offset_in_page(q + n) && q[n]; n++) +--- a/drivers/crypto/Kconfig ++++ b/drivers/crypto/Kconfig +@@ -282,6 +282,19 @@ config CRYPTO_DEV_TALITOS + To compile this driver as a module, choose M here: the module + will be called talitos. + ++config CRYPTO_DEV_CF_TALITOS ++ tristate "Talitos Freescale Coldfire Security Engine (SEC)" ++ select CRYPTO_ALGAPI ++ select CRYPTO_AUTHENC ++ select HW_RANDOM ++ depends on (M547X || M548X) ++ help ++ Say 'Y' here to use the Freescale Coldfire Security Engine (SEC) ++ to offload cryptographic algorithm computation. ++ ++ The Freescale SEC is present on Coldfire MCF547x and MCF548x ++ processors. ++ + config CRYPTO_DEV_IXP4XX + tristate "Driver for IXP4xx crypto hardware acceleration" + depends on ARCH_IXP4XX +--- a/drivers/crypto/Makefile ++++ b/drivers/crypto/Makefile +@@ -6,6 +6,7 @@ n2_crypto-y := n2_core.o n2_asm.o + obj-$(CONFIG_CRYPTO_DEV_HIFN_795X) += hifn_795x.o + obj-$(CONFIG_CRYPTO_DEV_MV_CESA) += mv_cesa.o + obj-$(CONFIG_CRYPTO_DEV_TALITOS) += talitos.o ++obj-$(CONFIG_CRYPTO_DEV_CF_TALITOS) += cf_talitos.o + obj-$(CONFIG_CRYPTO_DEV_IXP4XX) += ixp4xx_crypto.o + obj-$(CONFIG_CRYPTO_DEV_MCFCAU) += mcfcau.o + obj-$(CONFIG_CRYPTO_DEV_MCFCAU_DES) += mcfcau-des.o +--- /dev/null ++++ b/drivers/crypto/cf_talitos.c +@@ -0,0 +1,1727 @@ ++/* ++ * cf_talitos - Freescale Coldfire Integrated Security Engine ++ * (SEC) device driver ++ * ++ * Copyright (C) 2011 Freescale Semiconductor, Inc. All Rights Reserved. ++ * Author: Alison Wang <b18965@freescale.com> ++ * based on talitos.c ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ */ ++ ++#include <linux/kernel.h> ++#include <linux/module.h> ++#include <linux/mod_devicetable.h> ++#include <linux/device.h> ++#include <linux/interrupt.h> ++#include <linux/crypto.h> ++#include <linux/hw_random.h> ++#include <linux/platform_device.h> ++#include <linux/dma-mapping.h> ++#include <linux/io.h> ++#include <linux/spinlock.h> ++#include <linux/rtnetlink.h> ++#include <linux/slab.h> ++ ++#include <crypto/algapi.h> ++#include <crypto/aes.h> ++#include <crypto/des.h> ++#include <crypto/sha.h> ++#include <crypto/md5.h> ++#include <crypto/aead.h> ++#include <crypto/authenc.h> ++#include <crypto/skcipher.h> ++#include <crypto/hash.h> ++#include <crypto/internal/hash.h> ++#include <crypto/scatterwalk.h> ++ ++#include <asm/m5485sim.h> ++#include "cf_talitos.h" ++ ++#define TALITOS_TIMEOUT 100000 ++#define TALITOS_MAX_DATA_LEN 65535 ++ ++#define DESC_TYPE(desc_hdr) (((desc_hdr) >> 4) & 0xf) ++#define PRIMARY_EU(desc_hdr) (((desc_hdr) >> 28) & 0xf) ++#define SECONDARY_EU(desc_hdr) (((desc_hdr) >> 16) & 0xf) ++ ++#define CF_TALITOS_DEBUG 0 ++#if CF_TALITOS_DEBUG ++#define dprintk(args...) printk(args) ++#else ++#define dprintk(...) ++#endif ++ ++/* descriptor pointer entry */ ++struct talitos_ptr { ++ u32 len; /* length */ ++ u32 ptr; /* address */ ++}; ++ ++static const struct talitos_ptr zero_entry = { ++ .len = 0, ++ .ptr = 0 ++}; ++ ++/* descriptor */ ++struct talitos_desc { ++ u32 hdr; /* header */ ++ struct talitos_ptr ptr[7]; /* ptr/len pair array */ ++ u32 next_hdr; ++}; ++ ++/** ++ * talitos_request - descriptor submission request ++ * @desc: descriptor pointer (kernel virtual) ++ * @dma_desc: descriptor's physical bus address ++ * @callback: whom to call when descriptor processing is done ++ * @context: caller context (optional) ++ */ ++struct talitos_request { ++ struct talitos_desc *desc; ++ dma_addr_t dma_desc; ++ void (*callback) (struct device *dev, struct talitos_desc *desc, ++ void *context, int error); ++ void *context; ++}; ++ ++/* per-channel fifo management */ ++struct talitos_channel { ++ /* request fifo */ ++ struct talitos_request *fifo; ++ ++ /* number of requests pending in channel h/w fifo */ ++ atomic_t submit_count ____cacheline_aligned; ++ ++ /* request submission (head) lock */ ++ spinlock_t head_lock ____cacheline_aligned; ++ /* index to next free descriptor request */ ++ int head; ++ ++ /* request release (tail) lock */ ++ spinlock_t tail_lock ____cacheline_aligned; ++ /* index to next in-progress/done descriptor request */ ++ int tail; ++}; ++ ++struct talitos_private { ++ struct device *dev; ++ struct platform_device *pdev; ++ void __iomem *reg; ++ int irq; ++ ++ /* SEC version geometry (from device tree node) */ ++ unsigned int num_channels; ++ unsigned int chfifo_len; ++ unsigned int exec_units; ++ unsigned int desc_types; ++ ++ /* SEC Compatibility info */ ++ unsigned long features; ++ ++ /* ++ * length of the request fifo ++ * fifo_len is chfifo_len rounded up to next power of 2 ++ * so we can use bitwise ops to wrap ++ */ ++ unsigned int fifo_len; ++ ++ struct talitos_channel *chan; ++ ++ /* next channel to be assigned next incoming descriptor */ ++ atomic_t last_chan ____cacheline_aligned; ++ ++ /* request callback tasklet */ ++ struct tasklet_struct done_task; ++ ++ /* list of registered algorithms */ ++ struct list_head alg_list; ++ ++ /* hwrng device */ ++ struct hwrng rng; ++}; ++ ++/* .features flag */ ++#define TALITOS_FTR_SRC_LINK_TBL_LEN_INCLUDES_EXTENT 0x00000001 ++#define TALITOS_FTR_HW_AUTH_CHECK 0x00000002 ++#define TALITOS_FTR_SHA224_HWINIT 0x00000004 ++ ++/* ++ * map virtual single (contiguous) pointer to h/w descriptor pointer ++ */ ++static void map_single_talitos_ptr(struct device *dev, ++ struct talitos_ptr *talitos_ptr, ++ unsigned short len, void *data, ++ unsigned char extent, ++ enum dma_data_direction dir) ++{ ++ dma_addr_t dma_addr = dma_map_single(dev, data, len, dir); ++ ++ talitos_ptr->len = len; ++ talitos_ptr->ptr = dma_addr; ++} ++ ++/* ++ * unmap bus single (contiguous) h/w descriptor pointer ++ */ ++static void unmap_single_talitos_ptr(struct device *dev, ++ struct talitos_ptr *talitos_ptr, ++ enum dma_data_direction dir) ++{ ++ dma_unmap_single(dev, talitos_ptr->ptr, talitos_ptr->len, dir); ++} ++ ++static int reset_channel(struct device *dev, int ch) ++{ ++ struct talitos_private *priv = dev_get_drvdata(dev); ++ unsigned int timeout = TALITOS_TIMEOUT; ++ ++ setbits32(priv->reg + TALITOS_CCCR(ch), TALITOS_CCCR_RESET); ++ ++ while ((in_be32(priv->reg + TALITOS_CCCR(ch)) & ++ TALITOS_CCCR_RESET) && --timeout) ++ cpu_relax(); ++ ++ if (timeout == 0) { ++ dev_err(dev, "failed to reset channel %d\n", ch); ++ return -EIO; ++ } ++ ++ /* set 36-bit addressing, done writeback enable and done IRQ enable */ ++ setbits32(priv->reg + TALITOS_CCCR(ch), TALITOS_CCCR_NE | ++ TALITOS_CCCR_NT | TALITOS_CCCR_CDWE | ++ TALITOS_CCCR_CDIE); ++ ++ return 0; ++} ++ ++static int reset_device(struct device *dev) ++{ ++ struct talitos_private *priv = dev_get_drvdata(dev); ++ unsigned int timeout = TALITOS_TIMEOUT; ++ ++ setbits32(priv->reg + TALITOS_MCR, TALITOS_MCR_SWR); ++ ++ while ((in_be32(priv->reg + TALITOS_MCR) & TALITOS_MCR_SWR) ++ && --timeout) ++ cpu_relax(); ++ ++ if (timeout == 0) { ++ dev_err(dev, "failed to reset device\n"); ++ return -EIO; ++ } ++ ++ setbits32(priv->reg + TALITOS_DEURCR, TALITOS_DEURCR_RESET); ++ setbits32(priv->reg + TALITOS_AFEURCR, TALITOS_AFEURCR_RESET); ++ setbits32(priv->reg + TALITOS_AESURCR, TALITOS_AESURCR_RESET); ++ setbits32(priv->reg + TALITOS_MDEURCR, TALITOS_MDEURCR_RESET); ++ setbits32(priv->reg + TALITOS_RNGRCR, TALITOS_RNGRCR_SR); ++ return 0; ++} ++ ++/* ++ * Reset and initialize the device ++ */ ++static int init_device(struct device *dev) ++{ ++ struct talitos_private *priv = dev_get_drvdata(dev); ++ int ch, err; ++ ++ /* ++ * Master reset ++ * errata documentation: warning: certain SEC interrupts ++ * are not fully cleared by writing the MCR:SWR bit, ++ * set bit twice to completely reset ++ */ ++ err = reset_device(dev); ++ if (err) ++ return err; ++ ++ err = reset_device(dev); ++ if (err) ++ return err; ++ ++ /* reset channels */ ++ for (ch = 0; ch < priv->num_channels; ch++) { ++ err = reset_channel(dev, ch); ++ if (err) ++ return err; ++ } ++ ++ /* enable channel done and error interrupts */ ++ out_be32(priv->reg + TALITOS_IMR, 0); ++ out_be32(priv->reg + TALITOS_IMR_LO, 0); ++ ++ out_be32(priv->reg + TALITOS_ICR, ++ TALITOS_ICR_CHERR | TALITOS_ICR_CHDONE); ++ out_be32(priv->reg + TALITOS_ICR_LO, ++ TALITOS_ICR_LO_CHERR | TALITOS_ICR_LO_CHDONE); ++ ++ return 0; ++} ++ ++/** ++ * talitos_submit - submits a descriptor to the device for processing ++ * @dev: the SEC device to be used ++ * @desc: the descriptor to be processed by the device ++ * @callback: whom to call when processing is complete ++ * @context: a handle for use by caller (optional) ++ * ++ * desc must contain valid dma-mapped (bus physical) address pointers. ++ * callback must check err and feedback in descriptor header ++ * for device processing status. ++ */ ++static int talitos_submit(struct device *dev, struct talitos_desc *desc, ++ void (*callback)(struct device *dev, ++ struct talitos_desc *desc, ++ void *context, int error), ++ void *context) ++{ ++ struct talitos_private *priv = dev_get_drvdata(dev); ++ struct talitos_request *request; ++ unsigned long flags, ch; ++ int head; ++ ++ /* ignore key parity check in triple DES */ ++ if (((desc->hdr & DESC_HDR_SEL0_MASK) == DESC_HDR_SEL0_DEU) && ++ (desc->hdr & DESC_HDR_MODE0_DEU_3DES)) ++ setbits32(priv->reg + TALITOS_DEUIMR, TALITOS_DEUIMR_KPE_MASK); ++ ++ /* select done notification */ ++ desc->hdr |= DESC_HDR_DONE; ++ ++ /* emulate SEC's round-robin channel fifo polling scheme */ ++ ch = atomic_inc_return(&priv->last_chan) & (priv->num_channels - 1); ++ ++ spin_lock_irqsave(&priv->chan[ch].head_lock, flags); ++ ++ head = priv->chan[ch].head; ++ request = &priv->chan[ch].fifo[head]; ++ ++ /* map descriptor and save caller data */ ++ request->dma_desc = dma_map_single(dev, desc, sizeof(*desc), ++ DMA_BIDIRECTIONAL); ++ request->callback = callback; ++ request->context = context; ++ ++ /* increment fifo head */ ++ priv->chan[ch].head = (priv->chan[ch].head + 1) & (priv->fifo_len - 1); ++ ++ smp_wmb(); ++ request->desc = desc; ++ ++ /* GO! */ ++ wmb(); ++ out_be32(priv->reg + TALITOS_FF(ch), request->dma_desc); ++ ++ spin_unlock_irqrestore(&priv->chan[ch].head_lock, flags); ++ ++ return -EINPROGRESS; ++} ++ ++/* ++ * process what was done, notify callback of error if not ++ */ ++static void flush_channel(struct device *dev, int ch, int error, int reset_ch) ++{ ++ struct talitos_private *priv = dev_get_drvdata(dev); ++ struct talitos_request *request, saved_req; ++ unsigned long flags; ++ int tail, status; ++ ++ spin_lock_irqsave(&priv->chan[ch].tail_lock, flags); ++ ++ tail = priv->chan[ch].tail; ++ while (priv->chan[ch].fifo[tail].desc) { ++ request = &priv->chan[ch].fifo[tail]; ++ ++ /* descriptors with their done bits set don't get the error */ ++ rmb(); ++ if ((request->desc->hdr & DESC_HDR_DONE) == DESC_HDR_DONE) ++ status = 0; ++ else ++ if (!error) ++ break; ++ else ++ status = error; ++ ++ dma_unmap_single(dev, request->dma_desc, ++ sizeof(struct talitos_desc), ++ DMA_BIDIRECTIONAL); ++ ++ /* copy entries so we can call callback outside lock */ ++ saved_req.desc = request->desc; ++ saved_req.callback = request->callback; ++ saved_req.context = request->context; ++ ++ /* release request entry in fifo */ ++ smp_wmb(); ++ request->desc = NULL; ++ ++ /* increment fifo tail */ ++ priv->chan[ch].tail = (tail + 1) & (priv->fifo_len - 1); ++ ++ spin_unlock_irqrestore(&priv->chan[ch].tail_lock, flags); ++ ++ atomic_dec(&priv->chan[ch].submit_count); ++ ++ saved_req.callback(dev, saved_req.desc, saved_req.context, ++ status); ++ /* channel may resume processing in single desc error case */ ++ if (error && !reset_ch && status == error) ++ return; ++ spin_lock_irqsave(&priv->chan[ch].tail_lock, flags); ++ tail = priv->chan[ch].tail; ++ } ++ ++ spin_unlock_irqrestore(&priv->chan[ch].tail_lock, flags); ++} ++ ++/* ++ * process completed requests for channels that have done status ++ */ ++static void talitos_done(unsigned long data) ++{ ++ struct device *dev = (struct device *)data; ++ struct talitos_private *priv = dev_get_drvdata(dev); ++ int ch; ++ ++ for (ch = 0; ch < priv->num_channels; ch++) ++ flush_channel(dev, ch, 0, 0); ++ ++ /* At this point, all completed channels have been processed. ++ * Unmask done interrupts for channels completed later on. ++ */ ++ out_be32(priv->reg + TALITOS_IMR, 0); ++ out_be32(priv->reg + TALITOS_IMR_LO, 0); ++ ++ out_be32(priv->reg + TALITOS_ICR, ++ TALITOS_ICR_CHERR | TALITOS_ICR_CHDONE); ++ out_be32(priv->reg + TALITOS_ICR_LO, ++ TALITOS_ICR_LO_CHERR | TALITOS_ICR_LO_CHDONE); ++} ++ ++/* ++ * locate current (offending) descriptor ++ */ ++static struct talitos_desc *current_desc(struct device *dev, int ch) ++{ ++ struct talitos_private *priv = dev_get_drvdata(dev); ++ int tail = priv->chan[ch].tail; ++ dma_addr_t cur_desc; ++ ++ cur_desc = in_be32(priv->reg + TALITOS_CDPR(ch)); ++ ++ while (priv->chan[ch].fifo[tail].dma_desc != cur_desc) { ++ tail = (tail + 1) & (priv->fifo_len - 1); ++ if (tail == priv->chan[ch].tail) { ++ dev_err(dev, "couldn't locate current descriptor\n"); ++ return NULL; ++ } ++ } ++ ++ return priv->chan[ch].fifo[tail].desc; ++} ++ ++/* ++ * user diagnostics; report root cause of error based on execution unit status ++ */ ++static void report_eu_error(struct device *dev, int ch, ++ struct talitos_desc *desc) ++{ ++ struct talitos_private *priv = dev_get_drvdata(dev); ++ int i; ++ ++ switch (desc->hdr & DESC_HDR_SEL0_MASK) { ++ case DESC_HDR_SEL0_AFEU: ++ dev_err(dev, "AFEUISR 0x%08x\n", ++ in_be32(priv->reg + TALITOS_AFEUISR)); ++ break; ++ case DESC_HDR_SEL0_DEU: ++ dev_err(dev, "DEUISR 0x%08x\n", ++ in_be32(priv->reg + TALITOS_DEUISR)); ++ break; ++ case DESC_HDR_SEL0_MDEU: ++ dev_err(dev, "MDEUISR 0x%08x\n", ++ in_be32(priv->reg + TALITOS_MDEUISR)); ++ break; ++ case DESC_HDR_SEL0_RNG: ++ dev_err(dev, "RNGISR 0x%08x\n", ++ in_be32(priv->reg + TALITOS_RNGISR)); ++ break; ++ case DESC_HDR_SEL0_AESU: ++ dev_err(dev, "AESUISR 0x%08x\n", ++ in_be32(priv->reg + TALITOS_AESUISR)); ++ break; ++ } ++ ++ switch (desc->hdr & DESC_HDR_SEL1_MASK) { ++ case DESC_HDR_SEL1_MDEU: ++ dev_err(dev, "MDEUISR 0x%08x\n", ++ in_be32(priv->reg + TALITOS_MDEUISR)); ++ break; ++ } ++ ++ for (i = 0; i < 8; i++) ++ dev_err(dev, "DESCBUF 0x%08x\n", ++ in_be32(priv->reg + TALITOS_DESCBUF(ch) + 8 * i)); ++} ++ ++/* ++ * recover from error interrupts ++ */ ++static void talitos_error(unsigned long data, u32 isr, u32 isr_lo) ++{ ++ struct device *dev = (struct device *)data; ++ struct talitos_private *priv = dev_get_drvdata(dev); ++ int ch, error, reset_ch = 0; ++ u32 v, v_lo; ++ ++ for (ch = 0; ch < priv->num_channels; ch++) { ++ /* skip channels without errors */ ++ if (!((isr >> 29) & (1 << (ch * 2)))) ++ continue; ++ ++ error = -EINVAL; ++ ++ v = in_be32(priv->reg + TALITOS_CCPSR(ch)); ++ v_lo = in_be32(priv->reg + TALITOS_CCPSR_LO(ch)); ++ ++ if (v_lo & TALITOS_CCPSR_LO_TEA) ++ dev_err(dev, "master data transfer error\n"); ++ if (v_lo & TALITOS_CCPSR_LO_PERR) ++ dev_err(dev, "fetch pointer not complete error\n"); ++ if (v_lo & TALITOS_CCPSR_LO_DERR) ++ dev_err(dev, "illegal descriptor header error\n"); ++ if (v_lo & TALITOS_CCPSR_LO_SERR) ++ dev_err(dev, "static assignment error\n"); ++ if (v_lo & TALITOS_CCPSR_LO_EUERR) ++ report_eu_error(dev, ch, current_desc(dev, ch)); ++ ++ flush_channel(dev, ch, error, reset_ch); ++ ++ if (reset_ch) ++ reset_channel(dev, ch); ++ } ++ ++ /* purge request queues */ ++ for (ch = 0; ch < priv->num_channels; ch++) ++ flush_channel(dev, ch, -EIO, 1); ++ ++ /* reset and reinitialize the device */ ++ init_device(dev); ++} ++ ++static irqreturn_t talitos_interrupt(int irq, void *data) ++{ ++ struct device *dev = data; ++ struct talitos_private *priv = dev_get_drvdata(dev); ++ u32 isr, isr_lo; ++ ++ isr = in_be32(priv->reg + TALITOS_ISR); ++ isr_lo = in_be32(priv->reg + TALITOS_ISR_LO); ++ /* Acknowledge interrupt */ ++ out_be32(priv->reg + TALITOS_ICR, isr); ++ out_be32(priv->reg + TALITOS_ICR_LO, isr_lo); ++ ++ if (unlikely(isr & ~TALITOS_ISR_CHDONE)) { ++ talitos_error((unsigned long)data, isr, isr_lo); ++ } else if (likely(isr & TALITOS_ISR_CHDONE)) { ++ /* mask further done interrupts. */ ++ setbits32(priv->reg + TALITOS_IMR, TALITOS_IMR_DONE); ++ /* done_task will unmask done interrupts at exit */ ++ tasklet_schedule(&priv->done_task); ++ } ++ ++ return (isr || isr_lo) ? IRQ_HANDLED : IRQ_NONE; ++} ++ ++ ++/* ++ * crypto alg ++ */ ++#define TALITOS_CRA_PRIORITY 3000 ++#define TALITOS_MAX_KEY_SIZE 64 ++#define TALITOS_MAX_IV_LENGTH 16 ++#define TALITOS_MAX_OUTPUTDATA_SIZE 64 ++#define TALITOS_MAX_INPUTDATA_SIZE 64 ++ ++#define ARC4_MIN_KEY_SIZE 4 ++#define ARC4_MAX_KEY_SIZE 16 ++#define ARC4_BLOCK_SIZE 64 ++#define MD5_BLOCK_SIZE 64 ++ ++struct talitos_ctx { ++ struct device *dev; ++ __be32 desc_hdr_template; ++ u8 key[TALITOS_MAX_KEY_SIZE]; ++ u8 iv[TALITOS_MAX_IV_LENGTH]; ++ unsigned int keylen; ++ unsigned int enckeylen; ++ unsigned int authkeylen; ++ unsigned int authsize; ++}; ++ ++#define HASH_MAX_BLOCK_SIZE SHA512_BLOCK_SIZE ++#define TALITOS_MDEU_MAX_CONTEXT_SIZE \ ++ TALITOS_MDEU_CONTEXT_SIZE_MD5_SHA1_SHA256 ++ ++struct talitos_ahash_req_ctx { ++ u32 hw_context[TALITOS_MDEU_MAX_CONTEXT_SIZE / sizeof(u32)]; ++ unsigned int hw_context_size; ++ u8 buf[HASH_MAX_BLOCK_SIZE]; ++ u8 bufnext[HASH_MAX_BLOCK_SIZE]; ++ unsigned int swinit; ++ unsigned int first; ++ unsigned int last; ++ unsigned int to_hash_later; ++ u64 nbuf; ++ struct scatterlist bufsl[2]; ++ struct scatterlist *psrc; ++}; ++ ++/* ++ * talitos_edesc - s/w-extended descriptor ++ * @src_nents: number of segments in input scatterlist ++ * @dst_nents: number of segments in output scatterlist ++ * @desc: h/w descriptor ++ * ++ * if decrypting (with authcheck), or either one of src_nents or dst_nents ++ * is greater than 1, an integrity check value is concatenated to the end ++ * of link_tbl data ++ */ ++struct talitos_edesc { ++ int src_nents; ++ int dst_nents; ++ int src_is_chained; ++ int dst_is_chained; ++ struct talitos_desc desc; ++ u8 src_buf[TALITOS_MAX_INPUTDATA_SIZE]; ++ u8 dst_buf[TALITOS_MAX_OUTPUTDATA_SIZE]; ++}; ++ ++static int talitos_map_sg(struct device *dev, struct scatterlist *sg, ++ unsigned int nents, enum dma_data_direction dir, ++ int chained) ++{ ++ if (unlikely(chained)) ++ while (sg) { ++ dma_map_sg(dev, sg, 1, dir); ++ sg = scatterwalk_sg_next(sg); ++ } ++ else ++ dma_map_sg(dev, sg, nents, dir); ++ return nents; ++} ++ ++static void talitos_unmap_sg_chain(struct device *dev, struct scatterlist *sg, ++ enum dma_data_direction dir) ++{ ++ while (sg) { ++ dma_unmap_sg(dev, sg, 1, dir); ++ sg = scatterwalk_sg_next(sg); ++ } ++} ++ ++static void talitos_sg_unmap(struct device *dev, ++ struct talitos_edesc *edesc, ++ struct scatterlist *src, ++ struct scatterlist *dst) ++{ ++ unsigned int src_nents = edesc->src_nents ? : 1; ++ unsigned int dst_nents = edesc->dst_nents ? : 1; ++ ++ if (src != dst) { ++ if (edesc->src_is_chained) ++ talitos_unmap_sg_chain(dev, src, DMA_TO_DEVICE); ++ else ++ dma_unmap_sg(dev, src, src_nents, DMA_TO_DEVICE); ++ ++ if (dst) { ++ if (edesc->dst_is_chained) ++ talitos_unmap_sg_chain(dev, dst, ++ DMA_FROM_DEVICE); ++ else ++ dma_unmap_sg(dev, dst, dst_nents, ++ DMA_FROM_DEVICE); ++ } ++ } else ++ if (edesc->src_is_chained) ++ talitos_unmap_sg_chain(dev, src, DMA_BIDIRECTIONAL); ++ else ++ dma_unmap_sg(dev, src, src_nents, DMA_BIDIRECTIONAL); ++} ++ ++/* ++ * derive number of elements in scatterlist ++ */ ++static int sg_count(struct scatterlist *sg_list, int nbytes, int *chained) ++{ ++ struct scatterlist *sg = sg_list; ++ int sg_nents = 0; ++ ++ *chained = 0; ++ while (nbytes > 0) { ++ sg_nents++; ++ nbytes -= sg->length; ++ if (!sg_is_last(sg) && (sg + 1)->length == 0) ++ *chained = 1; ++ sg = scatterwalk_sg_next(sg); ++ } ++ ++ return sg_nents; ++} ++ ++/** ++ * sg_copy_end_to_buffer - Copy end data from SG list to a linear buffer ++ * @sgl: The SG list ++ * @nents: Number of SG entries ++ * @buf: Where to copy to ++ * @buflen: The number of bytes to copy ++ * @skip: The number of bytes to skip before copying. ++ * Note: skip + buflen should equal SG total size. ++ * ++ * Returns the number of copied bytes. ++ * ++ **/ ++static size_t sg_copy_end_to_buffer(struct scatterlist *sgl, unsigned int nents, ++ void *buf, size_t buflen, unsigned int skip) ++{ ++ unsigned int offset = 0; ++ unsigned int boffset = 0; ++ struct sg_mapping_iter miter; ++ unsigned long flags; ++ unsigned int sg_flags = SG_MITER_ATOMIC; ++ size_t total_buffer = buflen + skip; ++ ++ sg_flags |= SG_MITER_FROM_SG; ++ ++ sg_miter_start(&miter, sgl, nents, sg_flags); ++ ++ local_irq_save(flags); ++ ++ while (sg_miter_next(&miter) && offset < total_buffer) { ++ unsigned int len; ++ unsigned int ignore; ++ ++ if ((offset + miter.length) > skip) { ++ if (offset < skip) { ++ /* Copy part of this segment */ ++ ignore = skip - offset; ++ len = miter.length - ignore; ++ if (boffset + len > buflen) ++ len = buflen - boffset; ++ memcpy(buf + boffset, miter.addr + ignore, len); ++ } else { ++ /* Copy all of this segment (up to buflen) */ ++ len = miter.length; ++ if (boffset + len > buflen) ++ len = buflen - boffset; ++ memcpy(buf + boffset, miter.addr, len); ++ } ++ boffset += len; ++ } ++ offset += miter.length; ++ } ++ ++ sg_miter_stop(&miter); ++ ++ local_irq_restore(flags); ++ return boffset; ++} ++ ++/* ++ * allocate and map the extended descriptor ++ */ ++static struct talitos_edesc *talitos_edesc_alloc(struct device *dev, ++ struct scatterlist *src, ++ struct scatterlist *dst, ++ int hash_result, ++ unsigned int cryptlen, ++ unsigned int authsize, ++ int icv_stashing, ++ u32 cryptoflags) ++{ ++ struct talitos_edesc *edesc; ++ int src_nents, dst_nents, alloc_len; ++ int src_chained, dst_chained = 0; ++ gfp_t flags = cryptoflags & CRYPTO_TFM_REQ_MAY_SLEEP ? GFP_KERNEL : ++ GFP_ATOMIC; ++ ++ if (cryptlen + authsize > TALITOS_MAX_DATA_LEN) { ++ dev_err(dev, "length exceeds h/w max limit\n"); ++ return ERR_PTR(-EINVAL); ++ } ++ ++ src_nents = sg_count(src, cryptlen + authsize, &src_chained); ++ src_nents = (src_nents == 1) ? 0 : src_nents; ++ ++ if (hash_result) { ++ dst_nents = 0; ++ } else { ++ if (dst == src) { ++ dst_nents = src_nents; ++ } else { ++ dst_nents = sg_count(dst, cryptlen + authsize, ++ &dst_chained); ++ dst_nents = (dst_nents == 1) ? 0 : dst_nents; ++ } ++ } ++ ++ /* ++ * allocate space for base edesc plus the link tables, ++ * allowing for two separate entries for ICV and generated ICV (+ 2), ++ * and the ICV data itself ++ */ ++ alloc_len = sizeof(struct talitos_edesc); ++ ++ edesc = kmalloc(alloc_len, GFP_KERNEL | flags); ++ if (!edesc) { ++ dev_err(dev, "could not allocate edescriptor\n"); ++ return ERR_PTR(-ENOMEM); ++ } ++ ++ edesc->src_nents = src_nents; ++ edesc->dst_nents = dst_nents; ++ edesc->src_is_chained = src_chained; ++ edesc->dst_is_chained = dst_chained; ++ return edesc; ++} ++ ++static int ablkcipher_setkey(struct crypto_ablkcipher *cipher, ++ const u8 *key, unsigned int keylen) ++{ ++ struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher); ++ struct ablkcipher_alg *alg = crypto_ablkcipher_alg(cipher); ++ ++ if (keylen > TALITOS_MAX_KEY_SIZE) ++ goto badkey; ++ ++ if (keylen < alg->min_keysize || keylen > alg->max_keysize) ++ goto badkey; ++ ++ memcpy(&ctx->key, key, keylen); ++ ctx->keylen = keylen; ++ ++ return 0; ++ ++badkey: ++ crypto_ablkcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN); ++ return -EINVAL; ++} ++ ++static void common_nonsnoop_unmap(struct device *dev, ++ struct talitos_edesc *edesc, ++ struct ablkcipher_request *areq) ++{ ++ unmap_single_talitos_ptr(dev, &edesc->desc.ptr[5], DMA_FROM_DEVICE); ++ unmap_single_talitos_ptr(dev, &edesc->desc.ptr[2], DMA_TO_DEVICE); ++ unmap_single_talitos_ptr(dev, &edesc->desc.ptr[1], DMA_TO_DEVICE); ++ ++ talitos_sg_unmap(dev, edesc, areq->src, areq->dst); ++} ++ ++static void ablkcipher_done(struct device *dev, ++ struct talitos_desc *desc, void *context, ++ int err) ++{ ++ struct ablkcipher_request *areq = context; ++ struct talitos_edesc *edesc; ++ ++ edesc = container_of(desc, struct talitos_edesc, desc); ++ ++ if (edesc->dst_nents != 0) ++ sg_copy_from_buffer(areq->dst, edesc->dst_nents, ++ edesc->dst_buf, areq->nbytes); ++ ++ common_nonsnoop_unmap(dev, edesc, areq); ++ ++ kfree(edesc); ++ ++ areq->base.complete(&areq->base, err); ++} ++ ++static int common_nonsnoop(struct talitos_edesc *edesc, ++ struct ablkcipher_request *areq, ++ u8 *giv, ++ void (*callback) (struct device *dev, ++ struct talitos_desc *desc, ++ void *context, int error)) ++{ ++ struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(areq); ++ struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher); ++ struct device *dev = ctx->dev; ++ struct talitos_desc *desc = &edesc->desc; ++ unsigned int cryptlen = areq->nbytes; ++ unsigned int ivsize; ++ int sg_count, ret; ++ ++ desc->next_hdr = 0; ++ ++ /* first DWORD empty */ ++ desc->ptr[0] = zero_entry; ++ ++ /* cipher iv */ ++ ivsize = crypto_ablkcipher_ivsize(cipher); ++ map_single_talitos_ptr(dev, &desc->ptr[1], ivsize, giv ?: areq->info, 0, ++ DMA_TO_DEVICE); ++ ++ /* AFEU using a key */ ++ if (((desc->hdr & DESC_HDR_SEL0_MASK) == DESC_HDR_SEL0_AFEU) && ++ ((desc->hdr & DESC_HDR_MODE0_MASK) == ++ DESC_HDR_MODE0_AFEU_USE_KEY)) ++ desc->ptr[1] = zero_entry; ++ ++ /* cipher key */ ++ map_single_talitos_ptr(dev, &desc->ptr[2], ctx->keylen, ++ (char *)&ctx->key, 0, DMA_TO_DEVICE); ++ ++ /* AFEU using context */ ++ if (((desc->hdr & DESC_HDR_SEL0_MASK) == DESC_HDR_SEL0_AFEU) && ++ ((desc->hdr & DESC_HDR_MODE0_MASK) == ++ DESC_HDR_MODE0_AFEU_USE_CONTEXT)) ++ desc->ptr[2] = zero_entry; ++ ++ /* ++ * cipher in ++ */ ++ desc->ptr[3].len = cpu_to_be16(cryptlen); ++ ++ sg_count = talitos_map_sg(dev, areq->src, edesc->src_nents ? : 1, ++ (areq->src == areq->dst) ? DMA_BIDIRECTIONAL ++ : DMA_TO_DEVICE, ++ edesc->src_is_chained); ++ ++ if (sg_count == 1) ++ desc->ptr[3].ptr = sg_dma_address(areq->src); ++ else { ++ sg_copy_to_buffer(areq->src, sg_count, edesc->src_buf, ++ desc->ptr[3].len); ++ desc->ptr[3].ptr = (u32)edesc->src_buf; ++ } ++ ++ /* cipher out */ ++ desc->ptr[4].len = cpu_to_be16(cryptlen); ++ ++ if (areq->src != areq->dst) ++ sg_count = talitos_map_sg(dev, areq->dst, ++ edesc->dst_nents ? : 1, ++ DMA_FROM_DEVICE, ++ edesc->dst_is_chained); ++ ++ if (sg_count == 1) ++ desc->ptr[4].ptr = sg_dma_address(areq->dst); ++ else ++ desc->ptr[4].ptr = (u32)edesc->dst_buf; ++ ++ /* iv out */ ++ map_single_talitos_ptr(dev, &desc->ptr[5], ivsize, ctx->iv, 0, ++ DMA_FROM_DEVICE); ++ ++ /* last DWORD empty */ ++ desc->ptr[6] = zero_entry; ++ ++ ret = talitos_submit(dev, desc, callback, areq); ++ if (ret != -EINPROGRESS) { ++ common_nonsnoop_unmap(dev, edesc, areq); ++ kfree(edesc); ++ } ++ return ret; ++} ++ ++static struct talitos_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request * ++ areq) ++{ ++ struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(areq); ++ struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher); ++ ++ return talitos_edesc_alloc(ctx->dev, areq->src, areq->dst, 0, ++ areq->nbytes, 0, 0, areq->base.flags); ++} ++ ++static int ablkcipher_encrypt(struct ablkcipher_request *areq) ++{ ++ struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(areq); ++ struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher); ++ struct talitos_edesc *edesc; ++ ++ /* allocate extended descriptor */ ++ edesc = ablkcipher_edesc_alloc(areq); ++ if (IS_ERR(edesc)) ++ return PTR_ERR(edesc); ++ ++ /* set encrypt except AFEU */ ++ if ((ctx->desc_hdr_template & DESC_HDR_SEL0_MASK) == DESC_HDR_SEL0_AFEU) ++ edesc->desc.hdr = ctx->desc_hdr_template; ++ else ++ edesc->desc.hdr = ctx->desc_hdr_template | ++ DESC_HDR_MODE0_ENCRYP; ++ ++ return common_nonsnoop(edesc, areq, NULL, ablkcipher_done); ++} ++ ++static int ablkcipher_decrypt(struct ablkcipher_request *areq) ++{ ++ struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(areq); ++ struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher); ++ struct talitos_edesc *edesc; ++ ++ /* allocate extended descriptor */ ++ edesc = ablkcipher_edesc_alloc(areq); ++ if (IS_ERR(edesc)) ++ return PTR_ERR(edesc); ++ ++ edesc->desc.hdr = ctx->desc_hdr_template | DESC_HDR_DIR_INBOUND; ++ ++ return common_nonsnoop(edesc, areq, NULL, ablkcipher_done); ++} ++ ++static void common_nonsnoop_hash_unmap(struct device *dev, ++ struct talitos_edesc *edesc, ++ struct ahash_request *areq) ++{ ++ struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); ++ ++ unmap_single_talitos_ptr(dev, &edesc->desc.ptr[5], DMA_FROM_DEVICE); ++ ++ /* When using hashctx-in, must unmap it. */ ++ if (edesc->desc.ptr[1].len) ++ unmap_single_talitos_ptr(dev, &edesc->desc.ptr[1], ++ DMA_TO_DEVICE); ++ ++ if (edesc->desc.ptr[2].len) ++ unmap_single_talitos_ptr(dev, &edesc->desc.ptr[2], ++ DMA_TO_DEVICE); ++ ++ talitos_sg_unmap(dev, edesc, req_ctx->psrc, NULL); ++} ++ ++static void ahash_done(struct device *dev, ++ struct talitos_desc *desc, void *context, ++ int err) ++{ ++ struct ahash_request *areq = context; ++ struct talitos_edesc *edesc = ++ container_of(desc, struct talitos_edesc, desc); ++ struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); ++ ++ if (!req_ctx->last && req_ctx->to_hash_later) { ++ /* Position any partial block for next update/final/finup */ ++ memcpy(req_ctx->buf, req_ctx->bufnext, req_ctx->to_hash_later); ++ req_ctx->nbuf = req_ctx->to_hash_later; ++ } ++ common_nonsnoop_hash_unmap(dev, edesc, areq); ++ ++ kfree(edesc); ++ ++ areq->base.complete(&areq->base, err); ++} ++ ++static int common_nonsnoop_hash(struct talitos_edesc *edesc, ++ struct ahash_request *areq, unsigned int length, ++ void (*callback) (struct device *dev, ++ struct talitos_desc *desc, ++ void *context, int error)) ++{ ++ struct crypto_ahash *tfm = crypto_ahash_reqtfm(areq); ++ struct talitos_ctx *ctx = crypto_ahash_ctx(tfm); ++ struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); ++ struct device *dev = ctx->dev; ++ struct talitos_desc *desc = &edesc->desc; ++ int sg_count, ret; ++ ++ desc->next_hdr = 0; ++ ++ /* first DWORD empty */ ++ desc->ptr[0] = zero_entry; ++ ++ /* hash context in */ ++ if (!req_ctx->first || req_ctx->swinit) { ++ map_single_talitos_ptr(dev, &desc->ptr[1], ++ req_ctx->hw_context_size, ++ (char *)req_ctx->hw_context, 0, ++ DMA_TO_DEVICE); ++ req_ctx->swinit = 0; ++ } else { ++ desc->ptr[1] = zero_entry; ++ /* Indicate next op is not the first. */ ++ req_ctx->first = 0; ++ } ++ ++ /* HMAC key */ ++ if (ctx->keylen) ++ map_single_talitos_ptr(dev, &desc->ptr[2], ctx->keylen, ++ (char *)&ctx->key, 0, DMA_TO_DEVICE); ++ else ++ desc->ptr[2] = zero_entry; ++ ++ /* ++ * data in ++ */ ++ desc->ptr[3].len = length; ++ sg_count = talitos_map_sg(dev, req_ctx->psrc, ++ edesc->src_nents ? : 1, ++ DMA_TO_DEVICE, ++ edesc->src_is_chained); ++ ++ if (sg_count == 1) ++ desc->ptr[3].ptr = sg_dma_address(req_ctx->psrc); ++ else { ++ sg_copy_to_buffer(req_ctx->psrc, sg_count, edesc->src_buf, ++ desc->ptr[3].len); ++ desc->ptr[3].ptr = (u32)edesc->src_buf; ++ } ++ ++ /* fifth DWORD empty */ ++ desc->ptr[4] = zero_entry; ++ ++ /* hash/HMAC out -or- hash context out */ ++ if (req_ctx->last) ++ map_single_talitos_ptr(dev, &desc->ptr[5], ++ crypto_ahash_digestsize(tfm), ++ areq->result, 0, DMA_FROM_DEVICE); ++ else ++ map_single_talitos_ptr(dev, &desc->ptr[5], ++ req_ctx->hw_context_size, ++ req_ctx->hw_context, 0, DMA_FROM_DEVICE); ++ ++ /* last DWORD empty */ ++ desc->ptr[6] = zero_entry; ++ ++ ret = talitos_submit(dev, desc, callback, areq); ++ if (ret != -EINPROGRESS) { ++ common_nonsnoop_hash_unmap(dev, edesc, areq); ++ kfree(edesc); ++ } ++ return ret; ++} ++ ++static struct talitos_edesc *ahash_edesc_alloc(struct ahash_request *areq, ++ unsigned int nbytes) ++{ ++ struct crypto_ahash *tfm = crypto_ahash_reqtfm(areq); ++ struct talitos_ctx *ctx = crypto_ahash_ctx(tfm); ++ struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); ++ ++ return talitos_edesc_alloc(ctx->dev, req_ctx->psrc, NULL, 1, ++ nbytes, 0, 0, areq->base.flags); ++} ++ ++static int ahash_init(struct ahash_request *areq) ++{ ++ struct crypto_ahash *tfm = crypto_ahash_reqtfm(areq); ++ struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); ++ ++ /* Initialize the context */ ++ req_ctx->nbuf = 0; ++ req_ctx->first = 1; /* first indicates h/w must init its context */ ++ req_ctx->swinit = 0; /* assume h/w init of context */ ++ req_ctx->hw_context_size = ++ (crypto_ahash_digestsize(tfm) <= SHA256_DIGEST_SIZE) ++ ? TALITOS_MDEU_CONTEXT_SIZE_MD5_SHA1_SHA256 ++ : TALITOS_MDEU_CONTEXT_SIZE_SHA384_SHA512; ++ ++ return 0; ++} ++ ++/* ++ * on h/w without explicit sha224 support, we initialize h/w context ++ * manually with sha224 constants, and tell it to run sha256. ++ */ ++static int ahash_init_sha224_swinit(struct ahash_request *areq) ++{ ++ struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); ++ ++ ahash_init(areq); ++ req_ctx->swinit = 1;/* prevent h/w initting context with sha256 values*/ ++ ++ req_ctx->hw_context[0] = SHA224_H0; ++ req_ctx->hw_context[1] = SHA224_H1; ++ req_ctx->hw_context[2] = SHA224_H2; ++ req_ctx->hw_context[3] = SHA224_H3; ++ req_ctx->hw_context[4] = SHA224_H4; ++ req_ctx->hw_context[5] = SHA224_H5; ++ req_ctx->hw_context[6] = SHA224_H6; ++ req_ctx->hw_context[7] = SHA224_H7; ++ ++ /* init 64-bit count */ ++ req_ctx->hw_context[8] = 0; ++ req_ctx->hw_context[9] = 0; ++ ++ return 0; ++} ++ ++static int ahash_process_req(struct ahash_request *areq, unsigned int nbytes) ++{ ++ struct crypto_ahash *tfm = crypto_ahash_reqtfm(areq); ++ struct talitos_ctx *ctx = crypto_ahash_ctx(tfm); ++ struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); ++ struct talitos_edesc *edesc; ++ unsigned int blocksize = ++ crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm)); ++ unsigned int nbytes_to_hash; ++ unsigned int to_hash_later; ++ unsigned int nsg; ++ int chained; ++ ++ if (!req_ctx->last && (nbytes + req_ctx->nbuf <= blocksize)) { ++ /* Buffer up to one whole block */ ++ sg_copy_to_buffer(areq->src, ++ sg_count(areq->src, nbytes, &chained), ++ req_ctx->buf + req_ctx->nbuf, nbytes); ++ req_ctx->nbuf += nbytes; ++ return 0; ++ } ++ ++ /* At least (blocksize + 1) bytes are available to hash */ ++ nbytes_to_hash = nbytes + req_ctx->nbuf; ++ to_hash_later = nbytes_to_hash & (blocksize - 1); ++ ++ if (req_ctx->last) ++ to_hash_later = 0; ++ else if (to_hash_later) ++ /* There is a partial block. Hash the full block(s) now */ ++ nbytes_to_hash -= to_hash_later; ++ else { ++ /* Keep one block buffered */ ++ nbytes_to_hash -= blocksize; ++ to_hash_later = blocksize; ++ } ++ ++ /* Chain in any previously buffered data */ ++ if (req_ctx->nbuf) { ++ nsg = (req_ctx->nbuf < nbytes_to_hash) ? 2 : 1; ++ sg_init_table(req_ctx->bufsl, nsg); ++ sg_set_buf(req_ctx->bufsl, req_ctx->buf, req_ctx->nbuf); ++ if (nsg > 1) ++ scatterwalk_sg_chain(req_ctx->bufsl, 2, areq->src); ++ req_ctx->psrc = req_ctx->bufsl; ++ } else ++ req_ctx->psrc = areq->src; ++ ++ if (to_hash_later) { ++ int nents = sg_count(areq->src, nbytes, &chained); ++ sg_copy_end_to_buffer(areq->src, nents, ++ req_ctx->bufnext, ++ to_hash_later, ++ nbytes - to_hash_later); ++ } ++ req_ctx->to_hash_later = to_hash_later; ++ ++ /* Allocate extended descriptor */ ++ edesc = ahash_edesc_alloc(areq, nbytes_to_hash); ++ if (IS_ERR(edesc)) ++ return PTR_ERR(edesc); ++ ++ edesc->desc.hdr = ctx->desc_hdr_template; ++ ++ /* On last one, request SEC to pad; otherwise continue */ ++ if (req_ctx->last) ++ edesc->desc.hdr |= DESC_HDR_MODE0_MDEU_PAD; ++ else ++ edesc->desc.hdr |= DESC_HDR_MODE0_MDEU_CONT; ++ ++ /* request SEC to INIT hash. */ ++ if (req_ctx->first && !req_ctx->swinit) ++ edesc->desc.hdr |= DESC_HDR_MODE0_MDEU_INIT; ++ ++ /* When the tfm context has a keylen, it's an HMAC. ++ * A first or last (ie. not middle) descriptor must request HMAC. ++ */ ++ if (ctx->keylen && (req_ctx->first || req_ctx->last)) ++ edesc->desc.hdr |= DESC_HDR_MODE0_MDEU_HMAC; ++ ++ return common_nonsnoop_hash(edesc, areq, nbytes_to_hash, ++ ahash_done); ++} ++ ++static int ahash_update(struct ahash_request *areq) ++{ ++ struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); ++ ++ req_ctx->last = 0; ++ ++ return ahash_process_req(areq, areq->nbytes); ++} ++ ++static int ahash_final(struct ahash_request *areq) ++{ ++ struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); ++ ++ req_ctx->last = 1; ++ ++ return ahash_process_req(areq, 0); ++} ++ ++static int ahash_finup(struct ahash_request *areq) ++{ ++ struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); ++ ++ req_ctx->last = 1; ++ ++ return ahash_process_req(areq, areq->nbytes); ++} ++ ++static int ahash_digest(struct ahash_request *areq) ++{ ++ struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); ++ struct crypto_ahash *ahash = crypto_ahash_reqtfm(areq); ++ ++ ahash->init(areq); ++ req_ctx->last = 1; ++ ++ return ahash_process_req(areq, areq->nbytes); ++} ++ ++struct talitos_alg_template { ++ u32 type; ++ union { ++ struct crypto_alg crypto; ++ struct ahash_alg hash; ++ } alg; ++ __be32 desc_hdr_template; ++}; ++ ++static struct talitos_alg_template driver_algs[] = { ++ /* ABLKCIPHER algorithms. */ ++ { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, ++ .alg.crypto = { ++ .cra_name = "ecb(arc4)", ++ .cra_driver_name = "ecb-arc4-talitos", ++ .cra_blocksize = ARC4_BLOCK_SIZE, ++ .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | ++ CRYPTO_ALG_ASYNC, ++ .cra_type = &crypto_ablkcipher_type, ++ .cra_ablkcipher = { ++ .setkey = ablkcipher_setkey, ++ .encrypt = ablkcipher_encrypt, ++ .decrypt = ablkcipher_decrypt, ++ .geniv = "eseqiv", ++ .min_keysize = ARC4_MIN_KEY_SIZE, ++ .max_keysize = ARC4_MAX_KEY_SIZE, ++ .ivsize = ARC4_BLOCK_SIZE, ++ } ++ }, ++ .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_AFEU | ++ DESC_HDR_SEL0_AFEU | ++ DESC_HDR_MODE0_AFEU_USE_KEY, ++ }, ++ { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, ++ .alg.crypto = { ++ .cra_name = "cbc(aes)", ++ .cra_driver_name = "cbc-aes-talitos", ++ .cra_blocksize = AES_BLOCK_SIZE, ++ .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | ++ CRYPTO_ALG_ASYNC, ++ .cra_type = &crypto_ablkcipher_type, ++ .cra_ablkcipher = { ++ .setkey = ablkcipher_setkey, ++ .encrypt = ablkcipher_encrypt, ++ .decrypt = ablkcipher_decrypt, ++ .geniv = "eseqiv", ++ .min_keysize = AES_MIN_KEY_SIZE, ++ .max_keysize = AES_MAX_KEY_SIZE, ++ .ivsize = AES_BLOCK_SIZE, ++ } ++ }, ++ .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | ++ DESC_HDR_SEL0_AESU | ++ DESC_HDR_MODE0_AESU_CBC, ++ }, ++ { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, ++ .alg.crypto = { ++ .cra_name = "cbc(des)", ++ .cra_driver_name = "cbc-des-talitos", ++ .cra_blocksize = DES_BLOCK_SIZE, ++ .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | ++ CRYPTO_ALG_ASYNC, ++ .cra_type = &crypto_ablkcipher_type, ++ .cra_ablkcipher = { ++ .setkey = ablkcipher_setkey, ++ .encrypt = ablkcipher_encrypt, ++ .decrypt = ablkcipher_decrypt, ++ .geniv = "eseqiv", ++ .min_keysize = DES_KEY_SIZE, ++ .max_keysize = DES_KEY_SIZE, ++ .ivsize = DES_BLOCK_SIZE, ++ } ++ }, ++ .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | ++ DESC_HDR_SEL0_DEU | ++ DESC_HDR_MODE0_DEU_CBC, ++ }, ++ { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, ++ .alg.crypto = { ++ .cra_name = "cbc(des3_ede)", ++ .cra_driver_name = "cbc-3des-talitos", ++ .cra_blocksize = DES3_EDE_BLOCK_SIZE, ++ .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | ++ CRYPTO_ALG_ASYNC, ++ .cra_type = &crypto_ablkcipher_type, ++ .cra_ablkcipher = { ++ .setkey = ablkcipher_setkey, ++ .encrypt = ablkcipher_encrypt, ++ .decrypt = ablkcipher_decrypt, ++ .geniv = "eseqiv", ++ .min_keysize = DES3_EDE_KEY_SIZE, ++ .max_keysize = DES3_EDE_KEY_SIZE, ++ .ivsize = DES3_EDE_BLOCK_SIZE, ++ } ++ }, ++ .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | ++ DESC_HDR_SEL0_DEU | ++ DESC_HDR_MODE0_DEU_CBC | ++ DESC_HDR_MODE0_DEU_3DES, ++ }, ++ /* AHASH algorithms. */ ++ { .type = CRYPTO_ALG_TYPE_AHASH, ++ .alg.hash = { ++ .init = ahash_init, ++ .update = ahash_update, ++ .final = ahash_final, ++ .finup = ahash_finup, ++ .digest = ahash_digest, ++ .halg.digestsize = MD5_DIGEST_SIZE, ++ .halg.base = { ++ .cra_name = "md5", ++ .cra_driver_name = "md5-talitos", ++ .cra_blocksize = MD5_BLOCK_SIZE, ++ .cra_flags = CRYPTO_ALG_TYPE_AHASH | ++ CRYPTO_ALG_ASYNC, ++ .cra_type = &crypto_ahash_type ++ } ++ }, ++ .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | ++ DESC_HDR_SEL0_MDEU | ++ DESC_HDR_MODE0_MDEU_MD5, ++ }, ++ { .type = CRYPTO_ALG_TYPE_AHASH, ++ .alg.hash = { ++ .init = ahash_init, ++ .update = ahash_update, ++ .final = ahash_final, ++ .finup = ahash_finup, ++ .digest = ahash_digest, ++ .halg.digestsize = SHA1_DIGEST_SIZE, ++ .halg.base = { ++ .cra_name = "sha1", ++ .cra_driver_name = "sha1-talitos", ++ .cra_blocksize = SHA1_BLOCK_SIZE, ++ .cra_flags = CRYPTO_ALG_TYPE_AHASH | ++ CRYPTO_ALG_ASYNC, ++ .cra_type = &crypto_ahash_type ++ } ++ }, ++ .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | ++ DESC_HDR_SEL0_MDEU | ++ DESC_HDR_MODE0_MDEU_SHA1, ++ }, ++}; ++ ++struct talitos_crypto_alg { ++ struct list_head entry; ++ struct device *dev; ++ struct talitos_alg_template algt; ++}; ++ ++static int talitos_cra_init(struct crypto_tfm *tfm) ++{ ++ struct crypto_alg *alg = tfm->__crt_alg; ++ struct talitos_crypto_alg *talitos_alg; ++ struct talitos_ctx *ctx = crypto_tfm_ctx(tfm); ++ ++ if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_AHASH) ++ talitos_alg = container_of(__crypto_ahash_alg(alg), ++ struct talitos_crypto_alg, ++ algt.alg.hash); ++ else ++ talitos_alg = container_of(alg, struct talitos_crypto_alg, ++ algt.alg.crypto); ++ ++ /* update context with ptr to dev */ ++ ctx->dev = talitos_alg->dev; ++ ++ /* copy descriptor header template value */ ++ ctx->desc_hdr_template = talitos_alg->algt.desc_hdr_template; ++ ++ return 0; ++} ++ ++static int talitos_cra_init_ahash(struct crypto_tfm *tfm) ++{ ++ struct talitos_ctx *ctx = crypto_tfm_ctx(tfm); ++ ++ talitos_cra_init(tfm); ++ ++ ctx->keylen = 0; ++ crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm), ++ sizeof(struct talitos_ahash_req_ctx)); ++ ++ return 0; ++} ++ ++/* ++ * given the alg's descriptor header template, determine whether descriptor ++ * type and primary/secondary execution units required match the hw ++ * capabilities description provided in the device tree node. ++ */ ++static int hw_supports(struct device *dev, __be32 desc_hdr_template) ++{ ++ struct talitos_private *priv = dev_get_drvdata(dev); ++ int ret; ++ ++ ret = (DESC_TYPE(desc_hdr_template) & priv->desc_types) && ++ (PRIMARY_EU(desc_hdr_template) & priv->exec_units); ++ ++ if (SECONDARY_EU(desc_hdr_template)) ++ ret = ret && (SECONDARY_EU(desc_hdr_template) ++ & priv->exec_units); ++ ++ return ret; ++} ++ ++static int talitos_remove(struct platform_device *pdev) ++{ ++ struct device *dev = &pdev->dev; ++ struct talitos_private *priv = dev_get_drvdata(dev); ++ struct talitos_crypto_alg *t_alg, *n; ++ int i; ++ ++ list_for_each_entry_safe(t_alg, n, &priv->alg_list, entry) { ++ switch (t_alg->algt.type) { ++ case CRYPTO_ALG_TYPE_ABLKCIPHER: ++ case CRYPTO_ALG_TYPE_AEAD: ++ crypto_unregister_alg(&t_alg->algt.alg.crypto); ++ break; ++ case CRYPTO_ALG_TYPE_AHASH: ++ crypto_unregister_ahash(&t_alg->algt.alg.hash); ++ break; ++ } ++ list_del(&t_alg->entry); ++ kfree(t_alg); ++ } ++ ++ for (i = 0; i < priv->num_channels; i++) ++ kfree(priv->chan[i].fifo); ++ ++ kfree(priv->chan); ++ ++ if (priv->irq != 0) ++ free_irq(priv->irq, dev); ++ ++ tasklet_kill(&priv->done_task); ++ ++ iounmap(priv->reg); ++ ++ dev_set_drvdata(dev, NULL); ++ ++ kfree(priv); ++ ++ return 0; ++} ++ ++static struct talitos_crypto_alg *talitos_alg_alloc(struct device *dev, ++ struct talitos_alg_template ++ *template) ++{ ++ struct talitos_private *priv = dev_get_drvdata(dev); ++ struct talitos_crypto_alg *t_alg; ++ struct crypto_alg *alg; ++ ++ t_alg = kzalloc(sizeof(struct talitos_crypto_alg), GFP_KERNEL); ++ if (!t_alg) ++ return ERR_PTR(-ENOMEM); ++ ++ t_alg->algt = *template; ++ ++ switch (t_alg->algt.type) { ++ case CRYPTO_ALG_TYPE_ABLKCIPHER: ++ alg = &t_alg->algt.alg.crypto; ++ alg->cra_init = talitos_cra_init; ++ break; ++ case CRYPTO_ALG_TYPE_AHASH: ++ alg = &t_alg->algt.alg.hash.halg.base; ++ alg->cra_init = talitos_cra_init_ahash; ++ if (!(priv->features & TALITOS_FTR_SHA224_HWINIT) && ++ !strcmp(alg->cra_name, "sha224")) { ++ t_alg->algt.alg.hash.init = ahash_init_sha224_swinit; ++ t_alg->algt.desc_hdr_template = ++ DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | ++ DESC_HDR_SEL0_MDEU | ++ DESC_HDR_MODE0_MDEU_SHA256; ++ } ++ break; ++ default: ++ dev_err(dev, "unknown algorithm type %d\n", t_alg->algt.type); ++ return ERR_PTR(-EINVAL); ++ } ++ ++ alg->cra_module = THIS_MODULE; ++ alg->cra_priority = TALITOS_CRA_PRIORITY; ++ alg->cra_alignmask = 0; ++ alg->cra_ctxsize = sizeof(struct talitos_ctx); ++ ++ t_alg->dev = dev; ++ ++ return t_alg; ++} ++ ++static int __devinit talitos_probe(struct platform_device *pdev) ++{ ++ struct device *dev = &pdev->dev; ++ struct talitos_private *priv; ++ int prop; ++ struct resource *r; ++ int i, err; ++ ++ priv = kzalloc(sizeof(struct talitos_private), GFP_KERNEL); ++ if (!priv) ++ return -ENOMEM; ++ ++ dev_set_drvdata(dev, priv); ++ ++ priv->pdev = pdev; ++ ++ tasklet_init(&priv->done_task, talitos_done, (unsigned long)dev); ++ ++ INIT_LIST_HEAD(&priv->alg_list); ++ ++ priv->irq = 64 + ISC_SEC; ++ /* get the irq line */ ++ err = request_irq(priv->irq, talitos_interrupt, IRQF_DISABLED, ++ dev_driver_string(dev), dev); ++ if (err) { ++ dev_err(dev, "failed to request irq %d\n", priv->irq); ++ goto err_out; ++ } else ++ MCF_ICR(ISC_SEC) = ILP_SEC; ++ ++ ++ /* get a pointer to the register memory */ ++ r = platform_get_resource(pdev, IORESOURCE_MEM, 0); ++ priv->reg = ioremap(r->start, (r->end - r->start)); ++ if (!priv->reg) ++ dev_err(dev, "failed to ioremap\n"); ++ ++ /* get SEC version capabilities from device tree */ ++ prop = in_be32(priv->reg + TALITOS_ID); ++ if (prop & TALITOS_ID_SEC_1_1) { ++ priv->num_channels = TALITOS_NCHANNELS_SEC_1_1; ++ priv->chfifo_len = TALITOS_CHFIFOLEN_SEC_1_1; ++ priv->exec_units = TALITOS_HAS_EUS_SEC_1_1; ++ priv->desc_types = TALITOS_HAS_DESCTYPES_SEC_1_1; ++ } else { ++ dev_err(dev, "failed to id device\n"); ++ goto err_out; ++ } ++ ++ priv->chan = kzalloc(sizeof(struct talitos_channel) * ++ priv->num_channels, GFP_KERNEL); ++ if (!priv->chan) { ++ dev_err(dev, "failed to allocate channel management space\n"); ++ err = -ENOMEM; ++ goto err_out; ++ } ++ ++ for (i = 0; i < priv->num_channels; i++) { ++ spin_lock_init(&priv->chan[i].head_lock); ++ spin_lock_init(&priv->chan[i].tail_lock); ++ } ++ ++ priv->fifo_len = roundup_pow_of_two(priv->chfifo_len); ++ ++ for (i = 0; i < priv->num_channels; i++) { ++ priv->chan[i].fifo = kzalloc(sizeof(struct talitos_request) * ++ priv->fifo_len, GFP_KERNEL); ++ if (!priv->chan[i].fifo) { ++ dev_err(dev, "failed to allocate request fifo %d\n", i); ++ err = -ENOMEM; ++ goto err_out; ++ } ++ } ++ ++ for (i = 0; i < priv->num_channels; i++) ++ atomic_set(&priv->chan[i].submit_count, ++ -(priv->chfifo_len - 1)); ++ ++ dma_set_mask(dev, DMA_BIT_MASK(36)); ++ ++ /* reset and initialize the h/w */ ++ err = init_device(dev); ++ if (err) { ++ dev_err(dev, "failed to initialize device\n"); ++ goto err_out; ++ } ++ ++ /* register crypto algorithms the device supports */ ++ for (i = 0; i < ARRAY_SIZE(driver_algs); i++) { ++ if (hw_supports(dev, driver_algs[i].desc_hdr_template)) { ++ struct talitos_crypto_alg *t_alg; ++ char *name = NULL; ++ ++ t_alg = talitos_alg_alloc(dev, &driver_algs[i]); ++ if (IS_ERR(t_alg)) { ++ err = PTR_ERR(t_alg); ++ goto err_out; ++ } ++ ++ switch (t_alg->algt.type) { ++ case CRYPTO_ALG_TYPE_ABLKCIPHER: ++ case CRYPTO_ALG_TYPE_AEAD: ++ err = crypto_register_alg( ++ &t_alg->algt.alg.crypto); ++ name = t_alg->algt.alg.crypto.cra_driver_name; ++ break; ++ case CRYPTO_ALG_TYPE_AHASH: ++ err = crypto_register_ahash( ++ &t_alg->algt.alg.hash); ++ name = ++ t_alg->algt.alg.hash.halg.base.cra_driver_name; ++ break; ++ } ++ if (err) { ++ dev_err(dev, "%s alg registration failed\n", ++ name); ++ kfree(t_alg); ++ } else { ++ list_add_tail(&t_alg->entry, &priv->alg_list); ++ dev_info(dev, "%s\n", name); ++ } ++ } ++ } ++ ++ return 0; ++ ++err_out: ++ talitos_remove(pdev); ++ ++ return err; ++} ++ ++static struct platform_driver talitos_driver = { ++ .driver = { ++ .name = "talitos", ++ .owner = THIS_MODULE, ++ }, ++ .probe = talitos_probe, ++ .remove = talitos_remove, ++}; ++ ++static int __init talitos_init(void) ++{ ++ return platform_driver_register(&talitos_driver); ++} ++module_init(talitos_init); ++ ++static void __exit talitos_exit(void) ++{ ++ platform_driver_unregister(&talitos_driver); ++} ++module_exit(talitos_exit); ++ ++MODULE_LICENSE("GPL"); ++MODULE_AUTHOR("Kim Phillips <kim.phillips@freescale.com>"); ++MODULE_DESCRIPTION("Freescale integrated security engine (SEC) driver"); +--- /dev/null ++++ b/drivers/crypto/cf_talitos.h +@@ -0,0 +1,229 @@ ++/* ++ * Freescale Coldfire SEC (talitos) device dependent data structures ++ * ++ * Copyright 2011 Freescale Semiconductor, Inc. All Rights Reserved. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ */ ++ ++/* device ID register values */ ++#define TALITOS_ID_SEC_1_1 (0x09000000) /* MCF547x and MCF548x */ ++ ++/* ++ * following num_channels, channel-fifo-depth, exec-unit-mask, and ++ * descriptor-types-mask are for forward-compatibility with openfirmware ++ * flat device trees ++ */ ++ ++/* ++ * num_channels : the number of channels available in each SEC version. ++ */ ++ ++/* n.b. this driver requires these values be a power of 2 */ ++#define TALITOS_NCHANNELS_SEC_1_1 2 ++ ++/* ++ * channel-fifo-depth : The number of descriptor ++ * pointers a channel fetch fifo can hold. ++ */ ++#define TALITOS_CHFIFOLEN_SEC_1_1 1 ++ ++/* the corresponding masks for each SEC version */ ++#define TALITOS_HAS_EUS_SEC_1_1 0x7 ++ ++/* the corresponding masks for each SEC version */ ++#define TALITOS_HAS_DESCTYPES_SEC_1_1 0xf ++ ++/* ++ * a TALITOS_xxx_HI address points to the low data bits (32-63) of the register ++ */ ++/* global register offset addresses */ ++/* EU Assaginment controller register is useless*/ ++#define TALITOS_EUACR 0x1000 ++#define TALITOS_EUACR_LO 0x1004 ++ ++#define TALITOS_IMR 0x1008 /* interrupt mask register */ ++#define TALITOS_IMR_ALL 0xf8000000 /* enable all interrupts mask */ ++#define TALITOS_IMR_ERR 0xa8000000 /* mask error interrupts */ ++#define TALITOS_IMR_DONE 0x50000000 /* mask done interrupts */ ++#define TALITOS_IMR_LO 0x100C /* interrupt mask register */ ++/* mask all channel interrupts mask */ ++#define TALITOS_IMR_LO_ALL 0x03333340 ++#define TALITOS_IMR_LO_ERR 0x02222240 /* mask error interrupts */ ++#define TALITOS_IMR_LO_DONE 0x01111100 /* mask done interrupts */ ++ ++#define TALITOS_ISR 0x1010 /* interrupt status register */ ++#define TALITOS_ISR_CHERR 0xa8000000 /* errors mask */ ++#define TALITOS_ISR_CHDONE 0x50000000 /* channel(s) done mask */ ++#define TALITOS_ISR_LO 0x1014 /* interrupt status register */ ++ ++#define TALITOS_ICR 0x1018 /* interrupt clear register */ ++#define TALITOS_ICR_CHERR 0xa8000000 /* errors enable */ ++#define TALITOS_ICR_CHDONE 0x50000000 /* channel(s) done enable */ ++#define TALITOS_ICR_LO 0x101C /* interrupt clear register */ ++#define TALITOS_ICR_LO_CHERR 0x02222240 /* errors enable */ ++#define TALITOS_ICR_LO_CHDONE 0x01111100 /* channel(s) done enable */ ++ ++#define TALITOS_ID 0x1020 ++ ++/* EU Assaginment status register is useless*/ ++#define TALITOS_EUASR 0x1028 ++#define TALITOS_EUASR_LO 0x102C ++ ++#define TALITOS_MCR 0x1030 /* master control register */ ++#define TALITOS_MCR_SWR 0x01000000 ++ ++#define TALITOS_MEAR 0x1038 ++ ++/* channel register address stride */ ++#define TALITOS_CH_STRIDE 0x1000 ++ ++/* channel register offset addresses and bits */ ++#define TALITOS_CCCR(ch) (ch * TALITOS_CH_STRIDE + 0x200c) ++#define TALITOS_CCCR_RESET 0x1 /* Channel Reset bit */ ++#define TALITOS_CCCR_CDWE 0x10 /* Channel done writeback enable bit */ ++#define TALITOS_CCCR_NE 0x8 /* Fetch Next Descriptor Enable bit */ ++#define TALITOS_CCCR_NT 0x4 /* Notification type bit */ ++#define TALITOS_CCCR_CDIE 0x2 /* Channel Done Interrupt Enable bit */ ++ ++/* Crypto-Channel Pointer Status Reg */ ++#define TALITOS_CCPSR(ch) (ch * TALITOS_CH_STRIDE + 0x2010) ++#define TALITOS_CCPSR_LO(ch) (ch * TALITOS_CH_STRIDE + 0x2014) ++#define TALITOS_CCPSR_LO_TEA 0x2000 /* Transfer error acknowledge */ ++#define TALITOS_CCPSR_LO_PERR 0x1000 /* Pointer not complete error */ ++#define TALITOS_CCPSR_LO_DERR 0x400 /* Descriptor error */ ++#define TALITOS_CCPSR_LO_SERR 0x200 /* Static assignment error */ ++#define TALITOS_CCPSR_LO_EUERR 0x100 /* EU error */ ++ ++/* channel fetch fifo register */ ++#define TALITOS_FF(ch) (ch * TALITOS_CH_STRIDE + 0x204c) ++ ++/* Crypto-Channel Pointer Status Reg */ ++#define TALITOS_CDPR(ch) (ch * TALITOS_CH_STRIDE + 0x2044) ++ ++/* Descriptor Buffer (debug) 0x2080-0x20BF*/ ++#define TALITOS_DESCBUF(ch) (ch * TALITOS_CH_STRIDE + 0x2080) ++ ++/* execution unit register offset addresses and bits */ ++#define TALITOS_DEURCR 0xa018 /* DEU reset control register */ ++#define TALITOS_DEURCR_RESET 0x01000000 /* DEU reset bit */ ++#define TALITOS_DEUSR 0xa028 /* DEU status register */ ++#define TALITOS_DEUSR_RESET 0x01000000 /* DEU Reset status bit */ ++#define TALITOS_DEUISR 0xa030 /* DEU interrupt status register */ ++#define TALITOS_DEUIMR 0xa038 /* DEU interrupt mask register */ ++#define TALITOS_DEUIMR_MASK 0xf63f0000 /* DEU interrupt control mask*/ ++#define TALITOS_DEUIMR_KPE_MASK 0x00200000 /* DEU interrupt KPE mask*/ ++ ++#define TALITOS_AESURCR 0x12018 /* AESU reset control register */ ++#define TALITOS_AESURCR_RESET 0x01000000 /* AESU reset bit */ ++#define TALITOS_AESUSR 0x12028 /* AESU status register */ ++#define TALITOS_AESUSR_RESET 0x01000000 /* AESU Reset status bit */ ++#define TALITOS_AESUISR 0x12030 /* AESU interrupt status register */ ++#define TALITOS_AESUIMR 0x12038 /* AESU interrupt mask register */ ++#define TALITOS_AESUIMR_MASK 0xf61f0000 /* AESU interrupt control mask*/ ++ ++#define TALITOS_MDEURCR 0xc018 /* MDEU reset control register */ ++#define TALITOS_MDEURCR_RESET 0x01000000 /* MDEU reset bit */ ++#define TALITOS_MDEUSR 0xc028 /* MDEU status register */ ++#define TALITOS_MDEUSR_RESET 0x01000000 /* MDEU Reset status bit */ ++#define TALITOS_MDEUISR 0xc030 /* MDEU interrupt status register */ ++#define TALITOS_MDEUIMR 0xc038 /* MDEU interrupt mask register */ ++#define TALITOS_MDEUIMR_MASK 0xc41f0000 /* MDEU interrupt control mask*/ ++ ++#define TALITOS_AFEURCR 0x8018 /* AFEU reset control register */ ++#define TALITOS_AFEURCR_RESET 0x01000000 /* AFEU reset bit */ ++#define TALITOS_AFEUSR 0x8028 /* AFEU status register */ ++#define TALITOS_AFEUSR_RESET 0x01000000 /* AFEU Reset status bit */ ++#define TALITOS_AFEUISR 0x8030 /* AFEU interrupt status register */ ++#define TALITOS_AFEUIMR 0x8038 /* AFEU interrupt mask register */ ++#define TALITOS_AFEUIMR_MASK 0xf61f0000 /* AFEU interrupt control mask*/ ++ ++#define TALITOS_RNGRCR 0xe018 /* RNG Reset control register */ ++#define TALITOS_RNGRCR_SR 0x01000000 /* RNG RNGRCR:Software Reset */ ++#define TALITOS_RNGSR 0xe028 /* RNG status register */ ++#define TALITOS_RNGSR_RD 0x01000000 /* RNG Reset done */ ++#define TALITOS_RNGISR 0xe030 /* RNG Interrupt status register */ ++#define TALITOS_RNGIMR 0xe038 /* RNG interrupt mask register */ ++#define TALITOS_RNGIMR_MASK 0xc2100000 /* RNG interrupt control mask*/ ++ ++#define TALITOS_MDEU_CONTEXT_SIZE_MD5_SHA1_SHA256 0x28 ++#define TALITOS_MDEU_CONTEXT_SIZE_SHA384_SHA512 0x48 ++ ++/***************************RC4*******************/ ++#define ARC4_SEC_MIN_KEY_SIZE 5 ++#define ARC4_SEC_MAX_KEY_SIZE 16 ++#define ARC4_SEC_CONTEXT_LEN 259 ++#define SEC_ALG_AFEU_KEY 0x10200050 ++#define SEC_ALG_AFEU_CONTEXT 0x10700050 ++ ++/* talitos descriptor header (hdr) bits */ ++ ++/* primary execution unit select */ ++#define DESC_HDR_SEL0_MASK 0xf0000000 ++#define DESC_HDR_SEL0_AFEU 0x10000000 ++#define DESC_HDR_SEL0_DEU 0x20000000 ++#define DESC_HDR_SEL0_MDEU 0x30000000 ++#define DESC_HDR_SEL0_RNG 0x40000000 ++#define DESC_HDR_SEL0_AESU 0x60000000 ++ ++/* primary execution unit mode (MODE0) and derivatives */ ++#define DESC_HDR_MODE0_MASK 0x0ff00000 ++#define DESC_HDR_MODE0_ENCRYP 0x00100000 ++#define DESC_HDR_MODE0_AFEU_USE_KEY 0x00200000 ++#define DESC_HDR_MODE0_AFEU_USE_CONTEXT 0x00700000 ++#define DESC_HDR_MODE0_AESU_CBC 0x00200000 ++#define DESC_HDR_MODE0_AESU_ENC 0x00100000 ++#define DESC_HDR_MODE0_DEU_CBC 0x00400000 ++#define DESC_HDR_MODE0_DEU_3DES 0x00200000 ++#define DESC_HDR_MODE0_DEU_ENC 0x00100000 ++#define DESC_HDR_MODE0_MDEU_CONT 0x08000000 ++#define DESC_HDR_MODE0_MDEU_INIT 0x01000000 /* init starting regs */ ++#define DESC_HDR_MODE0_MDEU_HMAC 0x00800000 ++#define DESC_HDR_MODE0_MDEU_PAD 0x00400000 /* PD */ ++#define DESC_HDR_MODE0_MDEU_MD5 0x00200000 ++#define DESC_HDR_MODE0_MDEU_SHA256 0x00100000 ++#define DESC_HDR_MODE0_MDEU_SHA1 0x00000000 /* SHA-160 */ ++#define DESC_HDR_MODE0_MDEU_MD5_HMAC \ ++ (DESC_HDR_MODE0_MDEU_MD5 | DESC_HDR_MODE0_MDEU_HMAC) ++#define DESC_HDR_MODE0_MDEU_SHA256_HMAC \ ++ (DESC_HDR_MODE0_MDEU_SHA256 | DESC_HDR_MODE0_MDEU_HMAC) ++#define DESC_HDR_MODE0_MDEU_SHA1_HMAC \ ++ (DESC_HDR_MODE0_MDEU_SHA1 | DESC_HDR_MODE0_MDEU_HMAC) ++ ++/* secondary execution unit select (SEL1) */ ++/* it's MDEU or nothing */ ++#define DESC_HDR_SEL1_MASK 0x000f0000 ++#define DESC_HDR_SEL1_MDEU 0x00030000 ++ ++/* secondary execution unit mode (MODE1) and derivatives */ ++#define DESC_HDR_MODE1_MDEU_INIT 0x00001000 /* init starting regs */ ++#define DESC_HDR_MODE1_MDEU_HMAC 0x00000800 ++#define DESC_HDR_MODE1_MDEU_PAD 0x00000400 /* PD */ ++#define DESC_HDR_MODE1_MDEU_MD5 0x00000200 ++#define DESC_HDR_MODE1_MDEU_SHA256 0x00000100 ++#define DESC_HDR_MODE1_MDEU_SHA1 0x00000000 /* SHA-160 */ ++#define DESC_HDR_MODE1_MDEU_MD5_HMAC \ ++ (DESC_HDR_MODE1_MDEU_MD5 | DESC_HDR_MODE1_MDEU_HMAC) ++#define DESC_HDR_MODE1_MDEU_SHA256_HMAC \ ++ (DESC_HDR_MODE1_MDEU_SHA256 | DESC_HDR_MODE1_MDEU_HMAC) ++#define DESC_HDR_MODE1_MDEU_SHA1_HMAC \ ++ (DESC_HDR_MODE1_MDEU_SHA1 | DESC_HDR_MODE1_MDEU_HMAC) ++ ++/* direction of overall data flow (DIR) */ ++#define DESC_HDR_DIR_OUTBOUND 0x00000000 ++#define DESC_HDR_DIR_INBOUND 0x00000002 ++ ++/* done notification (DN) */ ++#define DESC_HDR_DONE 0x00000001 ++ ++/* descriptor types */ ++#define DESC_HDR_TYPE_AESU_CTR_NONSNOOP (0 << 4) ++#define DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU (1 << 4) ++#define DESC_HDR_TYPE_HMAC_SNOOP_NO_AFEU (2 << 4) ++#define DESC_HDR_TYPE_NONHMAC_SNOOP_NO_AFEU (3 << 4) ++#define DESC_HDR_TYPE_COMMON_NONSNOOP_AFEU (5 << 4) ++ ++#define TALITOS_HDR_DONE_BITS 0xff000000 |