source: trunk/target/linux/coldfire/patches/024-Add-SEC-1.1-support-for-MCF547x-and-MCF548x.patch @ 31546

Last change on this file since 31546 was 31546, checked in by kaloz, 4 years ago

[coldfire]: switch to 2.6.38

File size: 60.7 KB
  • arch/m68k/coldfire/m547x/mcf548x-devices.c

    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 b static struct resource coldfire_sec_reso 
    5454}; 
    5555 
    5656static struct platform_device coldfire_sec_device = { 
    57         .name                   = "fsl-sec1", 
     57        .name                   = "talitos", 
    5858        .id                     = -1, 
    5959        .num_resources          = ARRAY_SIZE(coldfire_sec_resources), 
    6060        .resource               = coldfire_sec_resources, 
  • arch/m68k/include/asm/cf_io.h

    a b static inline void memcpy_toio(volatile 
    192192#define writel(b, addr) (void)((*(volatile unsigned int *) (addr)) = (b)) 
    193193#endif /* readb */ 
    194194 
     195/* access ports */ 
     196#define setbits32(_addr, _v) out_be32((_addr), in_be32(_addr) |  (_v)) 
     197#define clrbits32(_addr, _v) out_be32((_addr), in_be32(_addr) & ~(_v)) 
     198 
    195199#endif /* _IO_H */ 
  • crypto/testmgr.c

    a b static int test_hash(struct crypto_ahash 
    212212                                   tcrypt_complete, &tresult); 
    213213 
    214214        j = 0; 
     215#if defined(CONFIG_CRYPTO_DEV_CF_TALITOS) 
     216        for (i = 1; i < tcount; i++) { 
     217#else 
    215218        for (i = 0; i < tcount; i++) { 
     219#endif 
    216220                if (template[i].np) 
    217221                        continue; 
    218222 
    static int test_hash(struct crypto_ahash 
    276280                        hexdump(result, crypto_ahash_digestsize(tfm)); 
    277281                        ret = -EINVAL; 
    278282                        goto out; 
    279                 } 
     283                } else 
     284                        printk(KERN_INFO "alg: hash: Test %d succeed for %s\n", 
     285                                j, algo); 
    280286        } 
    281287 
    282288        j = 0; 
    static int test_hash(struct crypto_ahash 
    344350                                hexdump(result, crypto_ahash_digestsize(tfm)); 
    345351                                ret = -EINVAL; 
    346352                                goto out; 
    347                         } 
     353                        } else 
     354                                printk(KERN_INFO "alg: hash: Chunking test %d " 
     355                                       "succeed for %s\n", j, algo); 
    348356                } 
    349357        } 
    350358 
    static int test_skcipher(struct crypto_a 
    788796        else 
    789797                e = "decryption"; 
    790798 
    791         printk(KERN_INFO "%s testing %s %s\n", __func__, algo, e); 
    792799        init_completion(&result.completion); 
    793800 
    794801        req = ablkcipher_request_alloc(tfm, GFP_KERNEL); 
    static int test_skcipher(struct crypto_a 
    963970                                               "%u for %s\n", j, e, k, algo); 
    964971                                        hexdump(q, template[i].tap[k]); 
    965972                                        goto out; 
    966                                 } 
     973                                } else 
     974                                        printk(KERN_INFO "alg: skcipher: Chunk " 
     975                                                "test %d pass on %s for %s\n", 
     976                                                j, e, algo); 
    967977 
    968978                                q += template[i].tap[k]; 
    969979                                for (n = 0; offset_in_page(q + n) && q[n]; n++) 
  • drivers/crypto/Kconfig

    a b config CRYPTO_DEV_TALITOS 
    282282          To compile this driver as a module, choose M here: the module 
    283283          will be called talitos. 
    284284 
     285config CRYPTO_DEV_CF_TALITOS 
     286        tristate "Talitos Freescale Coldfire Security Engine (SEC)" 
     287        select CRYPTO_ALGAPI 
     288        select CRYPTO_AUTHENC 
     289        select HW_RANDOM 
     290        depends on (M547X || M548X) 
     291        help 
     292          Say 'Y' here to use the Freescale Coldfire Security Engine (SEC) 
     293          to offload cryptographic algorithm computation. 
     294 
     295          The Freescale SEC is present on Coldfire MCF547x and MCF548x 
     296          processors. 
     297 
    285298config CRYPTO_DEV_IXP4XX 
    286299        tristate "Driver for IXP4xx crypto hardware acceleration" 
    287300        depends on ARCH_IXP4XX 
  • drivers/crypto/Makefile

    a b n2_crypto-y := n2_core.o n2_asm.o 
    66obj-$(CONFIG_CRYPTO_DEV_HIFN_795X) += hifn_795x.o 
    77obj-$(CONFIG_CRYPTO_DEV_MV_CESA) += mv_cesa.o 
    88obj-$(CONFIG_CRYPTO_DEV_TALITOS) += talitos.o 
     9obj-$(CONFIG_CRYPTO_DEV_CF_TALITOS) += cf_talitos.o 
    910obj-$(CONFIG_CRYPTO_DEV_IXP4XX) += ixp4xx_crypto.o 
    1011obj-$(CONFIG_CRYPTO_DEV_MCFCAU) += mcfcau.o 
    1112obj-$(CONFIG_CRYPTO_DEV_MCFCAU_DES) += mcfcau-des.o 
  • new file drivers/crypto/cf_talitos.c

    - +  
     1/* 
     2 * cf_talitos - Freescale Coldfire Integrated Security Engine 
     3 *              (SEC) device driver 
     4 * 
     5 * Copyright (C) 2011 Freescale Semiconductor, Inc. All Rights Reserved. 
     6 *      Author: Alison Wang <b18965@freescale.com> 
     7 *              based on talitos.c 
     8 * 
     9 * This program is free software; you can redistribute it and/or modify 
     10 * it under the terms of the GNU General Public License as published by 
     11 * the Free Software Foundation; either version 2 of the License, or 
     12 * (at your option) any later version. 
     13 */ 
     14 
     15#include <linux/kernel.h> 
     16#include <linux/module.h> 
     17#include <linux/mod_devicetable.h> 
     18#include <linux/device.h> 
     19#include <linux/interrupt.h> 
     20#include <linux/crypto.h> 
     21#include <linux/hw_random.h> 
     22#include <linux/platform_device.h> 
     23#include <linux/dma-mapping.h> 
     24#include <linux/io.h> 
     25#include <linux/spinlock.h> 
     26#include <linux/rtnetlink.h> 
     27#include <linux/slab.h> 
     28 
     29#include <crypto/algapi.h> 
     30#include <crypto/aes.h> 
     31#include <crypto/des.h> 
     32#include <crypto/sha.h> 
     33#include <crypto/md5.h> 
     34#include <crypto/aead.h> 
     35#include <crypto/authenc.h> 
     36#include <crypto/skcipher.h> 
     37#include <crypto/hash.h> 
     38#include <crypto/internal/hash.h> 
     39#include <crypto/scatterwalk.h> 
     40 
     41#include <asm/m5485sim.h> 
     42#include "cf_talitos.h" 
     43 
     44#define TALITOS_TIMEOUT 100000 
     45#define TALITOS_MAX_DATA_LEN 65535 
     46 
     47#define DESC_TYPE(desc_hdr) (((desc_hdr) >> 4) & 0xf) 
     48#define PRIMARY_EU(desc_hdr) (((desc_hdr) >> 28) & 0xf) 
     49#define SECONDARY_EU(desc_hdr) (((desc_hdr) >> 16) & 0xf) 
     50 
     51#define CF_TALITOS_DEBUG 0 
     52#if CF_TALITOS_DEBUG 
     53#define dprintk(args...) printk(args) 
     54#else 
     55#define dprintk(...) 
     56#endif 
     57 
     58/* descriptor pointer entry */ 
     59struct talitos_ptr { 
     60        u32 len;        /* length */ 
     61        u32 ptr;        /* address */ 
     62}; 
     63 
     64static const struct talitos_ptr zero_entry = { 
     65        .len = 0, 
     66        .ptr = 0 
     67}; 
     68 
     69/* descriptor */ 
     70struct talitos_desc { 
     71        u32 hdr;                        /* header */ 
     72        struct talitos_ptr ptr[7];      /* ptr/len pair array */ 
     73        u32 next_hdr; 
     74}; 
     75 
     76/** 
     77 * talitos_request - descriptor submission request 
     78 * @desc: descriptor pointer (kernel virtual) 
     79 * @dma_desc: descriptor's physical bus address 
     80 * @callback: whom to call when descriptor processing is done 
     81 * @context: caller context (optional) 
     82 */ 
     83struct talitos_request { 
     84        struct talitos_desc *desc; 
     85        dma_addr_t dma_desc; 
     86        void (*callback) (struct device *dev, struct talitos_desc *desc, 
     87                void *context, int error); 
     88        void *context; 
     89}; 
     90 
     91/* per-channel fifo management */ 
     92struct talitos_channel { 
     93        /* request fifo */ 
     94        struct talitos_request *fifo; 
     95 
     96        /* number of requests pending in channel h/w fifo */ 
     97        atomic_t submit_count ____cacheline_aligned; 
     98 
     99        /* request submission (head) lock */ 
     100        spinlock_t head_lock ____cacheline_aligned; 
     101        /* index to next free descriptor request */ 
     102        int head; 
     103 
     104        /* request release (tail) lock */ 
     105        spinlock_t tail_lock ____cacheline_aligned; 
     106        /* index to next in-progress/done descriptor request */ 
     107        int tail; 
     108}; 
     109 
     110struct talitos_private { 
     111        struct device *dev; 
     112        struct platform_device *pdev; 
     113        void __iomem *reg; 
     114        int irq; 
     115 
     116        /* SEC version geometry (from device tree node) */ 
     117        unsigned int num_channels; 
     118        unsigned int chfifo_len; 
     119        unsigned int exec_units; 
     120        unsigned int desc_types; 
     121 
     122        /* SEC Compatibility info */ 
     123        unsigned long features; 
     124 
     125        /* 
     126         * length of the request fifo 
     127         * fifo_len is chfifo_len rounded up to next power of 2 
     128         * so we can use bitwise ops to wrap 
     129         */ 
     130        unsigned int fifo_len; 
     131 
     132        struct talitos_channel *chan; 
     133 
     134        /* next channel to be assigned next incoming descriptor */ 
     135        atomic_t last_chan ____cacheline_aligned; 
     136 
     137        /* request callback tasklet */ 
     138        struct tasklet_struct done_task; 
     139 
     140        /* list of registered algorithms */ 
     141        struct list_head alg_list; 
     142 
     143        /* hwrng device */ 
     144        struct hwrng rng; 
     145}; 
     146 
     147/* .features flag */ 
     148#define TALITOS_FTR_SRC_LINK_TBL_LEN_INCLUDES_EXTENT 0x00000001 
     149#define TALITOS_FTR_HW_AUTH_CHECK 0x00000002 
     150#define TALITOS_FTR_SHA224_HWINIT 0x00000004 
     151 
     152/* 
     153 * map virtual single (contiguous) pointer to h/w descriptor pointer 
     154 */ 
     155static void map_single_talitos_ptr(struct device *dev, 
     156                                   struct talitos_ptr *talitos_ptr, 
     157                                   unsigned short len, void *data, 
     158                                   unsigned char extent, 
     159                                   enum dma_data_direction dir) 
     160{ 
     161        dma_addr_t dma_addr = dma_map_single(dev, data, len, dir); 
     162 
     163        talitos_ptr->len = len; 
     164        talitos_ptr->ptr = dma_addr; 
     165} 
     166 
     167/* 
     168 * unmap bus single (contiguous) h/w descriptor pointer 
     169 */ 
     170static void unmap_single_talitos_ptr(struct device *dev, 
     171                                     struct talitos_ptr *talitos_ptr, 
     172                                     enum dma_data_direction dir) 
     173{ 
     174        dma_unmap_single(dev, talitos_ptr->ptr, talitos_ptr->len, dir); 
     175} 
     176 
     177static int reset_channel(struct device *dev, int ch) 
     178{ 
     179        struct talitos_private *priv = dev_get_drvdata(dev); 
     180        unsigned int timeout = TALITOS_TIMEOUT; 
     181 
     182        setbits32(priv->reg + TALITOS_CCCR(ch), TALITOS_CCCR_RESET); 
     183 
     184        while ((in_be32(priv->reg + TALITOS_CCCR(ch)) & 
     185                TALITOS_CCCR_RESET) && --timeout) 
     186                cpu_relax(); 
     187 
     188        if (timeout == 0) { 
     189                dev_err(dev, "failed to reset channel %d\n", ch); 
     190                return -EIO; 
     191        } 
     192 
     193        /* set 36-bit addressing, done writeback enable and done IRQ enable */ 
     194        setbits32(priv->reg + TALITOS_CCCR(ch), TALITOS_CCCR_NE | 
     195                        TALITOS_CCCR_NT | TALITOS_CCCR_CDWE | 
     196                        TALITOS_CCCR_CDIE); 
     197 
     198        return 0; 
     199} 
     200 
     201static int reset_device(struct device *dev) 
     202{ 
     203        struct talitos_private *priv = dev_get_drvdata(dev); 
     204        unsigned int timeout = TALITOS_TIMEOUT; 
     205 
     206        setbits32(priv->reg + TALITOS_MCR, TALITOS_MCR_SWR); 
     207 
     208        while ((in_be32(priv->reg + TALITOS_MCR) & TALITOS_MCR_SWR) 
     209               && --timeout) 
     210                cpu_relax(); 
     211 
     212        if (timeout == 0) { 
     213                dev_err(dev, "failed to reset device\n"); 
     214                return -EIO; 
     215        } 
     216 
     217        setbits32(priv->reg + TALITOS_DEURCR, TALITOS_DEURCR_RESET); 
     218        setbits32(priv->reg + TALITOS_AFEURCR, TALITOS_AFEURCR_RESET); 
     219        setbits32(priv->reg + TALITOS_AESURCR, TALITOS_AESURCR_RESET); 
     220        setbits32(priv->reg + TALITOS_MDEURCR, TALITOS_MDEURCR_RESET); 
     221        setbits32(priv->reg + TALITOS_RNGRCR, TALITOS_RNGRCR_SR); 
     222        return 0; 
     223} 
     224 
     225/* 
     226 * Reset and initialize the device 
     227 */ 
     228static int init_device(struct device *dev) 
     229{ 
     230        struct talitos_private *priv = dev_get_drvdata(dev); 
     231        int ch, err; 
     232 
     233        /* 
     234         * Master reset 
     235         * errata documentation: warning: certain SEC interrupts 
     236         * are not fully cleared by writing the MCR:SWR bit, 
     237         * set bit twice to completely reset 
     238         */ 
     239        err = reset_device(dev); 
     240        if (err) 
     241                return err; 
     242 
     243        err = reset_device(dev); 
     244        if (err) 
     245                return err; 
     246 
     247        /* reset channels */ 
     248        for (ch = 0; ch < priv->num_channels; ch++) { 
     249                err = reset_channel(dev, ch); 
     250                if (err) 
     251                        return err; 
     252        } 
     253 
     254        /* enable channel done and error interrupts */ 
     255        out_be32(priv->reg + TALITOS_IMR, 0); 
     256        out_be32(priv->reg + TALITOS_IMR_LO, 0); 
     257 
     258        out_be32(priv->reg + TALITOS_ICR, 
     259                        TALITOS_ICR_CHERR | TALITOS_ICR_CHDONE); 
     260        out_be32(priv->reg + TALITOS_ICR_LO, 
     261                        TALITOS_ICR_LO_CHERR | TALITOS_ICR_LO_CHDONE); 
     262 
     263        return 0; 
     264} 
     265 
     266/** 
     267 * talitos_submit - submits a descriptor to the device for processing 
     268 * @dev:        the SEC device to be used 
     269 * @desc:       the descriptor to be processed by the device 
     270 * @callback:   whom to call when processing is complete 
     271 * @context:    a handle for use by caller (optional) 
     272 * 
     273 * desc must contain valid dma-mapped (bus physical) address pointers. 
     274 * callback must check err and feedback in descriptor header 
     275 * for device processing status. 
     276 */ 
     277static int talitos_submit(struct device *dev, struct talitos_desc *desc, 
     278                          void (*callback)(struct device *dev, 
     279                                           struct talitos_desc *desc, 
     280                                           void *context, int error), 
     281                          void *context) 
     282{ 
     283        struct talitos_private *priv = dev_get_drvdata(dev); 
     284        struct talitos_request *request; 
     285        unsigned long flags, ch; 
     286        int head; 
     287 
     288        /* ignore key parity check in triple DES */ 
     289        if (((desc->hdr & DESC_HDR_SEL0_MASK) == DESC_HDR_SEL0_DEU) && 
     290                (desc->hdr & DESC_HDR_MODE0_DEU_3DES)) 
     291                setbits32(priv->reg + TALITOS_DEUIMR, TALITOS_DEUIMR_KPE_MASK); 
     292 
     293        /* select done notification */ 
     294        desc->hdr |= DESC_HDR_DONE; 
     295 
     296        /* emulate SEC's round-robin channel fifo polling scheme */ 
     297        ch = atomic_inc_return(&priv->last_chan) & (priv->num_channels - 1); 
     298 
     299        spin_lock_irqsave(&priv->chan[ch].head_lock, flags); 
     300 
     301        head = priv->chan[ch].head; 
     302        request = &priv->chan[ch].fifo[head]; 
     303 
     304        /* map descriptor and save caller data */ 
     305        request->dma_desc = dma_map_single(dev, desc, sizeof(*desc), 
     306                                DMA_BIDIRECTIONAL); 
     307        request->callback = callback; 
     308        request->context = context; 
     309 
     310        /* increment fifo head */ 
     311        priv->chan[ch].head = (priv->chan[ch].head + 1) & (priv->fifo_len - 1); 
     312 
     313        smp_wmb(); 
     314        request->desc = desc; 
     315 
     316        /* GO! */ 
     317        wmb(); 
     318        out_be32(priv->reg + TALITOS_FF(ch), request->dma_desc); 
     319 
     320        spin_unlock_irqrestore(&priv->chan[ch].head_lock, flags); 
     321 
     322        return -EINPROGRESS; 
     323} 
     324 
     325/* 
     326 * process what was done, notify callback of error if not 
     327 */ 
     328static void flush_channel(struct device *dev, int ch, int error, int reset_ch) 
     329{ 
     330        struct talitos_private *priv = dev_get_drvdata(dev); 
     331        struct talitos_request *request, saved_req; 
     332        unsigned long flags; 
     333        int tail, status; 
     334 
     335        spin_lock_irqsave(&priv->chan[ch].tail_lock, flags); 
     336 
     337        tail = priv->chan[ch].tail; 
     338        while (priv->chan[ch].fifo[tail].desc) { 
     339                request = &priv->chan[ch].fifo[tail]; 
     340 
     341                /* descriptors with their done bits set don't get the error */ 
     342                rmb(); 
     343                if ((request->desc->hdr & DESC_HDR_DONE) == DESC_HDR_DONE) 
     344                        status = 0; 
     345                else 
     346                        if (!error) 
     347                                break; 
     348                        else 
     349                                status = error; 
     350 
     351                dma_unmap_single(dev, request->dma_desc, 
     352                                 sizeof(struct talitos_desc), 
     353                                 DMA_BIDIRECTIONAL); 
     354 
     355                /* copy entries so we can call callback outside lock */ 
     356                saved_req.desc = request->desc; 
     357                saved_req.callback = request->callback; 
     358                saved_req.context = request->context; 
     359 
     360                /* release request entry in fifo */ 
     361                smp_wmb(); 
     362                request->desc = NULL; 
     363 
     364                /* increment fifo tail */ 
     365                priv->chan[ch].tail = (tail + 1) & (priv->fifo_len - 1); 
     366 
     367                spin_unlock_irqrestore(&priv->chan[ch].tail_lock, flags); 
     368 
     369                atomic_dec(&priv->chan[ch].submit_count); 
     370 
     371                saved_req.callback(dev, saved_req.desc, saved_req.context, 
     372                                   status); 
     373                /* channel may resume processing in single desc error case */ 
     374                if (error && !reset_ch && status == error) 
     375                        return; 
     376                spin_lock_irqsave(&priv->chan[ch].tail_lock, flags); 
     377                tail = priv->chan[ch].tail; 
     378        } 
     379 
     380        spin_unlock_irqrestore(&priv->chan[ch].tail_lock, flags); 
     381} 
     382 
     383/* 
     384 * process completed requests for channels that have done status 
     385 */ 
     386static void talitos_done(unsigned long data) 
     387{ 
     388        struct device *dev = (struct device *)data; 
     389        struct talitos_private *priv = dev_get_drvdata(dev); 
     390        int ch; 
     391 
     392        for (ch = 0; ch < priv->num_channels; ch++) 
     393                flush_channel(dev, ch, 0, 0); 
     394 
     395        /* At this point, all completed channels have been processed. 
     396         * Unmask done interrupts for channels completed later on. 
     397         */ 
     398        out_be32(priv->reg + TALITOS_IMR, 0); 
     399        out_be32(priv->reg + TALITOS_IMR_LO, 0); 
     400 
     401        out_be32(priv->reg + TALITOS_ICR, 
     402                        TALITOS_ICR_CHERR | TALITOS_ICR_CHDONE); 
     403        out_be32(priv->reg + TALITOS_ICR_LO, 
     404                        TALITOS_ICR_LO_CHERR | TALITOS_ICR_LO_CHDONE); 
     405} 
     406 
     407/* 
     408 * locate current (offending) descriptor 
     409 */ 
     410static struct talitos_desc *current_desc(struct device *dev, int ch) 
     411{ 
     412        struct talitos_private *priv = dev_get_drvdata(dev); 
     413        int tail = priv->chan[ch].tail; 
     414        dma_addr_t cur_desc; 
     415 
     416        cur_desc = in_be32(priv->reg + TALITOS_CDPR(ch)); 
     417 
     418        while (priv->chan[ch].fifo[tail].dma_desc != cur_desc) { 
     419                tail = (tail + 1) & (priv->fifo_len - 1); 
     420                if (tail == priv->chan[ch].tail) { 
     421                        dev_err(dev, "couldn't locate current descriptor\n"); 
     422                        return NULL; 
     423                } 
     424        } 
     425 
     426        return priv->chan[ch].fifo[tail].desc; 
     427} 
     428 
     429/* 
     430 * user diagnostics; report root cause of error based on execution unit status 
     431 */ 
     432static void report_eu_error(struct device *dev, int ch, 
     433                            struct talitos_desc *desc) 
     434{ 
     435        struct talitos_private *priv = dev_get_drvdata(dev); 
     436        int i; 
     437 
     438        switch (desc->hdr & DESC_HDR_SEL0_MASK) { 
     439        case DESC_HDR_SEL0_AFEU: 
     440                dev_err(dev, "AFEUISR 0x%08x\n", 
     441                        in_be32(priv->reg + TALITOS_AFEUISR)); 
     442                break; 
     443        case DESC_HDR_SEL0_DEU: 
     444                dev_err(dev, "DEUISR 0x%08x\n", 
     445                        in_be32(priv->reg + TALITOS_DEUISR)); 
     446                break; 
     447        case DESC_HDR_SEL0_MDEU: 
     448                dev_err(dev, "MDEUISR 0x%08x\n", 
     449                        in_be32(priv->reg + TALITOS_MDEUISR)); 
     450                break; 
     451        case DESC_HDR_SEL0_RNG: 
     452                dev_err(dev, "RNGISR 0x%08x\n", 
     453                        in_be32(priv->reg + TALITOS_RNGISR)); 
     454                break; 
     455        case DESC_HDR_SEL0_AESU: 
     456                dev_err(dev, "AESUISR 0x%08x\n", 
     457                        in_be32(priv->reg + TALITOS_AESUISR)); 
     458                break; 
     459        } 
     460 
     461        switch (desc->hdr & DESC_HDR_SEL1_MASK) { 
     462        case DESC_HDR_SEL1_MDEU: 
     463                dev_err(dev, "MDEUISR 0x%08x\n", 
     464                        in_be32(priv->reg + TALITOS_MDEUISR)); 
     465                break; 
     466        } 
     467 
     468        for (i = 0; i < 8; i++) 
     469                dev_err(dev, "DESCBUF 0x%08x\n", 
     470                        in_be32(priv->reg + TALITOS_DESCBUF(ch) + 8 * i)); 
     471} 
     472 
     473/* 
     474 * recover from error interrupts 
     475 */ 
     476static void talitos_error(unsigned long data, u32 isr, u32 isr_lo) 
     477{ 
     478        struct device *dev = (struct device *)data; 
     479        struct talitos_private *priv = dev_get_drvdata(dev); 
     480        int ch, error, reset_ch = 0; 
     481        u32 v, v_lo; 
     482 
     483        for (ch = 0; ch < priv->num_channels; ch++) { 
     484                /* skip channels without errors */ 
     485                if (!((isr >> 29) & (1 << (ch * 2)))) 
     486                        continue; 
     487 
     488                error = -EINVAL; 
     489 
     490                v = in_be32(priv->reg + TALITOS_CCPSR(ch)); 
     491                v_lo = in_be32(priv->reg + TALITOS_CCPSR_LO(ch)); 
     492 
     493                if (v_lo & TALITOS_CCPSR_LO_TEA) 
     494                        dev_err(dev, "master data transfer error\n"); 
     495                if (v_lo & TALITOS_CCPSR_LO_PERR) 
     496                        dev_err(dev, "fetch pointer not complete error\n"); 
     497                if (v_lo & TALITOS_CCPSR_LO_DERR) 
     498                        dev_err(dev, "illegal descriptor header error\n"); 
     499                if (v_lo & TALITOS_CCPSR_LO_SERR) 
     500                        dev_err(dev, "static assignment error\n"); 
     501                if (v_lo & TALITOS_CCPSR_LO_EUERR) 
     502                        report_eu_error(dev, ch, current_desc(dev, ch)); 
     503 
     504                flush_channel(dev, ch, error, reset_ch); 
     505 
     506                if (reset_ch) 
     507                        reset_channel(dev, ch); 
     508        } 
     509 
     510        /* purge request queues */ 
     511        for (ch = 0; ch < priv->num_channels; ch++) 
     512                flush_channel(dev, ch, -EIO, 1); 
     513 
     514        /* reset and reinitialize the device */ 
     515        init_device(dev); 
     516} 
     517 
     518static irqreturn_t talitos_interrupt(int irq, void *data) 
     519{ 
     520        struct device *dev = data; 
     521        struct talitos_private *priv = dev_get_drvdata(dev); 
     522        u32 isr, isr_lo; 
     523 
     524        isr = in_be32(priv->reg + TALITOS_ISR); 
     525        isr_lo = in_be32(priv->reg + TALITOS_ISR_LO); 
     526        /* Acknowledge interrupt */ 
     527        out_be32(priv->reg + TALITOS_ICR, isr); 
     528        out_be32(priv->reg + TALITOS_ICR_LO, isr_lo); 
     529 
     530        if (unlikely(isr & ~TALITOS_ISR_CHDONE)) { 
     531                talitos_error((unsigned long)data, isr, isr_lo); 
     532        } else if (likely(isr & TALITOS_ISR_CHDONE)) { 
     533                /* mask further done interrupts. */ 
     534                setbits32(priv->reg + TALITOS_IMR, TALITOS_IMR_DONE); 
     535                /* done_task will unmask done interrupts at exit */ 
     536                tasklet_schedule(&priv->done_task); 
     537        } 
     538 
     539        return (isr || isr_lo) ? IRQ_HANDLED : IRQ_NONE; 
     540} 
     541 
     542 
     543/* 
     544 * crypto alg 
     545 */ 
     546#define TALITOS_CRA_PRIORITY            3000 
     547#define TALITOS_MAX_KEY_SIZE            64 
     548#define TALITOS_MAX_IV_LENGTH           16 
     549#define TALITOS_MAX_OUTPUTDATA_SIZE     64 
     550#define TALITOS_MAX_INPUTDATA_SIZE      64 
     551 
     552#define ARC4_MIN_KEY_SIZE               4 
     553#define ARC4_MAX_KEY_SIZE               16 
     554#define ARC4_BLOCK_SIZE                 64 
     555#define MD5_BLOCK_SIZE                  64 
     556 
     557struct talitos_ctx { 
     558        struct device *dev; 
     559        __be32 desc_hdr_template; 
     560        u8 key[TALITOS_MAX_KEY_SIZE]; 
     561        u8 iv[TALITOS_MAX_IV_LENGTH]; 
     562        unsigned int keylen; 
     563        unsigned int enckeylen; 
     564        unsigned int authkeylen; 
     565        unsigned int authsize; 
     566}; 
     567 
     568#define HASH_MAX_BLOCK_SIZE             SHA512_BLOCK_SIZE 
     569#define TALITOS_MDEU_MAX_CONTEXT_SIZE           \ 
     570        TALITOS_MDEU_CONTEXT_SIZE_MD5_SHA1_SHA256 
     571 
     572struct talitos_ahash_req_ctx { 
     573        u32 hw_context[TALITOS_MDEU_MAX_CONTEXT_SIZE / sizeof(u32)]; 
     574        unsigned int hw_context_size; 
     575        u8 buf[HASH_MAX_BLOCK_SIZE]; 
     576        u8 bufnext[HASH_MAX_BLOCK_SIZE]; 
     577        unsigned int swinit; 
     578        unsigned int first; 
     579        unsigned int last; 
     580        unsigned int to_hash_later; 
     581        u64 nbuf; 
     582        struct scatterlist bufsl[2]; 
     583        struct scatterlist *psrc; 
     584}; 
     585 
     586/* 
     587 * talitos_edesc - s/w-extended descriptor 
     588 * @src_nents: number of segments in input scatterlist 
     589 * @dst_nents: number of segments in output scatterlist 
     590 * @desc: h/w descriptor 
     591 * 
     592 * if decrypting (with authcheck), or either one of src_nents or dst_nents 
     593 * is greater than 1, an integrity check value is concatenated to the end 
     594 * of link_tbl data 
     595 */ 
     596struct talitos_edesc { 
     597        int src_nents; 
     598        int dst_nents; 
     599        int src_is_chained; 
     600        int dst_is_chained; 
     601        struct talitos_desc desc; 
     602        u8 src_buf[TALITOS_MAX_INPUTDATA_SIZE]; 
     603        u8 dst_buf[TALITOS_MAX_OUTPUTDATA_SIZE]; 
     604}; 
     605 
     606static int talitos_map_sg(struct device *dev, struct scatterlist *sg, 
     607                          unsigned int nents, enum dma_data_direction dir, 
     608                          int chained) 
     609{ 
     610        if (unlikely(chained)) 
     611                while (sg) { 
     612                        dma_map_sg(dev, sg, 1, dir); 
     613                        sg = scatterwalk_sg_next(sg); 
     614                } 
     615        else 
     616                dma_map_sg(dev, sg, nents, dir); 
     617        return nents; 
     618} 
     619 
     620static void talitos_unmap_sg_chain(struct device *dev, struct scatterlist *sg, 
     621                                   enum dma_data_direction dir) 
     622{ 
     623        while (sg) { 
     624                dma_unmap_sg(dev, sg, 1, dir); 
     625                sg = scatterwalk_sg_next(sg); 
     626        } 
     627} 
     628 
     629static void talitos_sg_unmap(struct device *dev, 
     630                             struct talitos_edesc *edesc, 
     631                             struct scatterlist *src, 
     632                             struct scatterlist *dst) 
     633{ 
     634        unsigned int src_nents = edesc->src_nents ? : 1; 
     635        unsigned int dst_nents = edesc->dst_nents ? : 1; 
     636 
     637        if (src != dst) { 
     638                if (edesc->src_is_chained) 
     639                        talitos_unmap_sg_chain(dev, src, DMA_TO_DEVICE); 
     640                else 
     641                        dma_unmap_sg(dev, src, src_nents, DMA_TO_DEVICE); 
     642 
     643                if (dst) { 
     644                        if (edesc->dst_is_chained) 
     645                                talitos_unmap_sg_chain(dev, dst, 
     646                                                       DMA_FROM_DEVICE); 
     647                        else 
     648                                dma_unmap_sg(dev, dst, dst_nents, 
     649                                             DMA_FROM_DEVICE); 
     650                } 
     651        } else 
     652                if (edesc->src_is_chained) 
     653                        talitos_unmap_sg_chain(dev, src, DMA_BIDIRECTIONAL); 
     654                else 
     655                        dma_unmap_sg(dev, src, src_nents, DMA_BIDIRECTIONAL); 
     656} 
     657 
     658/* 
     659 * derive number of elements in scatterlist 
     660 */ 
     661static int sg_count(struct scatterlist *sg_list, int nbytes, int *chained) 
     662{ 
     663        struct scatterlist *sg = sg_list; 
     664        int sg_nents = 0; 
     665 
     666        *chained = 0; 
     667        while (nbytes > 0) { 
     668                sg_nents++; 
     669                nbytes -= sg->length; 
     670                if (!sg_is_last(sg) && (sg + 1)->length == 0) 
     671                        *chained = 1; 
     672                sg = scatterwalk_sg_next(sg); 
     673        } 
     674 
     675        return sg_nents; 
     676} 
     677 
     678/** 
     679 * sg_copy_end_to_buffer - Copy end data from SG list to a linear buffer 
     680 * @sgl:                 The SG list 
     681 * @nents:               Number of SG entries 
     682 * @buf:                 Where to copy to 
     683 * @buflen:              The number of bytes to copy 
     684 * @skip:                The number of bytes to skip before copying. 
     685 *                       Note: skip + buflen should equal SG total size. 
     686 * 
     687 * Returns the number of copied bytes. 
     688 * 
     689 **/ 
     690static size_t sg_copy_end_to_buffer(struct scatterlist *sgl, unsigned int nents, 
     691                                    void *buf, size_t buflen, unsigned int skip) 
     692{ 
     693        unsigned int offset = 0; 
     694        unsigned int boffset = 0; 
     695        struct sg_mapping_iter miter; 
     696        unsigned long flags; 
     697        unsigned int sg_flags = SG_MITER_ATOMIC; 
     698        size_t total_buffer = buflen + skip; 
     699 
     700        sg_flags |= SG_MITER_FROM_SG; 
     701 
     702        sg_miter_start(&miter, sgl, nents, sg_flags); 
     703 
     704        local_irq_save(flags); 
     705 
     706        while (sg_miter_next(&miter) && offset < total_buffer) { 
     707                unsigned int len; 
     708                unsigned int ignore; 
     709 
     710                if ((offset + miter.length) > skip) { 
     711                        if (offset < skip) { 
     712                                /* Copy part of this segment */ 
     713                                ignore = skip - offset; 
     714                                len = miter.length - ignore; 
     715                                if (boffset + len > buflen) 
     716                                        len = buflen - boffset; 
     717                                memcpy(buf + boffset, miter.addr + ignore, len); 
     718                        } else { 
     719                                /* Copy all of this segment (up to buflen) */ 
     720                                len = miter.length; 
     721                                if (boffset + len > buflen) 
     722                                        len = buflen - boffset; 
     723                                memcpy(buf + boffset, miter.addr, len); 
     724                        } 
     725                        boffset += len; 
     726                } 
     727                offset += miter.length; 
     728        } 
     729 
     730        sg_miter_stop(&miter); 
     731 
     732        local_irq_restore(flags); 
     733        return boffset; 
     734} 
     735 
     736/* 
     737 * allocate and map the extended descriptor 
     738 */ 
     739static struct talitos_edesc *talitos_edesc_alloc(struct device *dev, 
     740                                                 struct scatterlist *src, 
     741                                                 struct scatterlist *dst, 
     742                                                 int hash_result, 
     743                                                 unsigned int cryptlen, 
     744                                                 unsigned int authsize, 
     745                                                 int icv_stashing, 
     746                                                 u32 cryptoflags) 
     747{ 
     748        struct talitos_edesc *edesc; 
     749        int src_nents, dst_nents, alloc_len; 
     750        int src_chained, dst_chained = 0; 
     751        gfp_t flags = cryptoflags & CRYPTO_TFM_REQ_MAY_SLEEP ? GFP_KERNEL : 
     752                      GFP_ATOMIC; 
     753 
     754        if (cryptlen + authsize > TALITOS_MAX_DATA_LEN) { 
     755                dev_err(dev, "length exceeds h/w max limit\n"); 
     756                return ERR_PTR(-EINVAL); 
     757        } 
     758 
     759        src_nents = sg_count(src, cryptlen + authsize, &src_chained); 
     760        src_nents = (src_nents == 1) ? 0 : src_nents; 
     761 
     762        if (hash_result) { 
     763                dst_nents = 0; 
     764        } else { 
     765                if (dst == src) { 
     766                        dst_nents = src_nents; 
     767                } else { 
     768                        dst_nents = sg_count(dst, cryptlen + authsize, 
     769                                             &dst_chained); 
     770                        dst_nents = (dst_nents == 1) ? 0 : dst_nents; 
     771                } 
     772        } 
     773 
     774        /* 
     775         * allocate space for base edesc plus the link tables, 
     776         * allowing for two separate entries for ICV and generated ICV (+ 2), 
     777         * and the ICV data itself 
     778         */ 
     779        alloc_len = sizeof(struct talitos_edesc); 
     780 
     781        edesc = kmalloc(alloc_len, GFP_KERNEL | flags); 
     782        if (!edesc) { 
     783                dev_err(dev, "could not allocate edescriptor\n"); 
     784                return ERR_PTR(-ENOMEM); 
     785        } 
     786 
     787        edesc->src_nents = src_nents; 
     788        edesc->dst_nents = dst_nents; 
     789        edesc->src_is_chained = src_chained; 
     790        edesc->dst_is_chained = dst_chained; 
     791        return edesc; 
     792} 
     793 
     794static int ablkcipher_setkey(struct crypto_ablkcipher *cipher, 
     795                             const u8 *key, unsigned int keylen) 
     796{ 
     797        struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher); 
     798        struct ablkcipher_alg *alg = crypto_ablkcipher_alg(cipher); 
     799 
     800        if (keylen > TALITOS_MAX_KEY_SIZE) 
     801                goto badkey; 
     802 
     803        if (keylen < alg->min_keysize || keylen > alg->max_keysize) 
     804                goto badkey; 
     805 
     806        memcpy(&ctx->key, key, keylen); 
     807        ctx->keylen = keylen; 
     808 
     809        return 0; 
     810 
     811badkey: 
     812        crypto_ablkcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN); 
     813        return -EINVAL; 
     814} 
     815 
     816static void common_nonsnoop_unmap(struct device *dev, 
     817                                  struct talitos_edesc *edesc, 
     818                                  struct ablkcipher_request *areq) 
     819{ 
     820        unmap_single_talitos_ptr(dev, &edesc->desc.ptr[5], DMA_FROM_DEVICE); 
     821        unmap_single_talitos_ptr(dev, &edesc->desc.ptr[2], DMA_TO_DEVICE); 
     822        unmap_single_talitos_ptr(dev, &edesc->desc.ptr[1], DMA_TO_DEVICE); 
     823 
     824        talitos_sg_unmap(dev, edesc, areq->src, areq->dst); 
     825} 
     826 
     827static void ablkcipher_done(struct device *dev, 
     828                            struct talitos_desc *desc, void *context, 
     829                            int err) 
     830{ 
     831        struct ablkcipher_request *areq = context; 
     832        struct talitos_edesc *edesc; 
     833 
     834        edesc = container_of(desc, struct talitos_edesc, desc); 
     835 
     836        if (edesc->dst_nents != 0) 
     837                sg_copy_from_buffer(areq->dst, edesc->dst_nents, 
     838                        edesc->dst_buf, areq->nbytes); 
     839 
     840        common_nonsnoop_unmap(dev, edesc, areq); 
     841 
     842        kfree(edesc); 
     843 
     844        areq->base.complete(&areq->base, err); 
     845} 
     846 
     847static int common_nonsnoop(struct talitos_edesc *edesc, 
     848                           struct ablkcipher_request *areq, 
     849                           u8 *giv, 
     850                           void (*callback) (struct device *dev, 
     851                                             struct talitos_desc *desc, 
     852                                             void *context, int error)) 
     853{ 
     854        struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(areq); 
     855        struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher); 
     856        struct device *dev = ctx->dev; 
     857        struct talitos_desc *desc = &edesc->desc; 
     858        unsigned int cryptlen = areq->nbytes; 
     859        unsigned int ivsize; 
     860        int sg_count, ret; 
     861 
     862        desc->next_hdr = 0; 
     863 
     864        /* first DWORD empty */ 
     865        desc->ptr[0] = zero_entry; 
     866 
     867        /* cipher iv */ 
     868        ivsize = crypto_ablkcipher_ivsize(cipher); 
     869        map_single_talitos_ptr(dev, &desc->ptr[1], ivsize, giv ?: areq->info, 0, 
     870                               DMA_TO_DEVICE); 
     871 
     872        /* AFEU using a key */ 
     873        if (((desc->hdr & DESC_HDR_SEL0_MASK) == DESC_HDR_SEL0_AFEU) && 
     874                ((desc->hdr & DESC_HDR_MODE0_MASK) == 
     875                 DESC_HDR_MODE0_AFEU_USE_KEY)) 
     876                desc->ptr[1] = zero_entry; 
     877 
     878        /* cipher key */ 
     879        map_single_talitos_ptr(dev, &desc->ptr[2], ctx->keylen, 
     880                               (char *)&ctx->key, 0, DMA_TO_DEVICE); 
     881 
     882        /* AFEU using context */ 
     883        if (((desc->hdr & DESC_HDR_SEL0_MASK) == DESC_HDR_SEL0_AFEU) && 
     884                ((desc->hdr & DESC_HDR_MODE0_MASK) == 
     885                 DESC_HDR_MODE0_AFEU_USE_CONTEXT)) 
     886                desc->ptr[2] = zero_entry; 
     887 
     888        /* 
     889         * cipher in 
     890         */ 
     891        desc->ptr[3].len = cpu_to_be16(cryptlen); 
     892 
     893        sg_count = talitos_map_sg(dev, areq->src, edesc->src_nents ? : 1, 
     894                                  (areq->src == areq->dst) ? DMA_BIDIRECTIONAL 
     895                                                           : DMA_TO_DEVICE, 
     896                                  edesc->src_is_chained); 
     897 
     898        if (sg_count == 1) 
     899                desc->ptr[3].ptr = sg_dma_address(areq->src); 
     900        else { 
     901                sg_copy_to_buffer(areq->src, sg_count, edesc->src_buf, 
     902                                desc->ptr[3].len); 
     903                desc->ptr[3].ptr = (u32)edesc->src_buf; 
     904        } 
     905 
     906        /* cipher out */ 
     907        desc->ptr[4].len = cpu_to_be16(cryptlen); 
     908 
     909        if (areq->src != areq->dst) 
     910                sg_count = talitos_map_sg(dev, areq->dst, 
     911                                          edesc->dst_nents ? : 1, 
     912                                          DMA_FROM_DEVICE, 
     913                                          edesc->dst_is_chained); 
     914 
     915        if (sg_count == 1) 
     916                desc->ptr[4].ptr = sg_dma_address(areq->dst); 
     917        else 
     918                desc->ptr[4].ptr = (u32)edesc->dst_buf; 
     919 
     920        /* iv out */ 
     921        map_single_talitos_ptr(dev, &desc->ptr[5], ivsize, ctx->iv, 0, 
     922                               DMA_FROM_DEVICE); 
     923 
     924        /* last DWORD empty */ 
     925        desc->ptr[6] = zero_entry; 
     926 
     927        ret = talitos_submit(dev, desc, callback, areq); 
     928        if (ret != -EINPROGRESS) { 
     929                common_nonsnoop_unmap(dev, edesc, areq); 
     930                kfree(edesc); 
     931        } 
     932        return ret; 
     933} 
     934 
     935static struct talitos_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request * 
     936                                                    areq) 
     937{ 
     938        struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(areq); 
     939        struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher); 
     940 
     941        return talitos_edesc_alloc(ctx->dev, areq->src, areq->dst, 0, 
     942                                   areq->nbytes, 0, 0, areq->base.flags); 
     943} 
     944 
     945static int ablkcipher_encrypt(struct ablkcipher_request *areq) 
     946{ 
     947        struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(areq); 
     948        struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher); 
     949        struct talitos_edesc *edesc; 
     950 
     951        /* allocate extended descriptor */ 
     952        edesc = ablkcipher_edesc_alloc(areq); 
     953        if (IS_ERR(edesc)) 
     954                return PTR_ERR(edesc); 
     955 
     956        /* set encrypt except AFEU */ 
     957        if ((ctx->desc_hdr_template & DESC_HDR_SEL0_MASK) == DESC_HDR_SEL0_AFEU) 
     958                edesc->desc.hdr = ctx->desc_hdr_template; 
     959        else 
     960                edesc->desc.hdr = ctx->desc_hdr_template | 
     961                        DESC_HDR_MODE0_ENCRYP; 
     962 
     963        return common_nonsnoop(edesc, areq, NULL, ablkcipher_done); 
     964} 
     965 
     966static int ablkcipher_decrypt(struct ablkcipher_request *areq) 
     967{ 
     968        struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(areq); 
     969        struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher); 
     970        struct talitos_edesc *edesc; 
     971 
     972        /* allocate extended descriptor */ 
     973        edesc = ablkcipher_edesc_alloc(areq); 
     974        if (IS_ERR(edesc)) 
     975                return PTR_ERR(edesc); 
     976 
     977        edesc->desc.hdr = ctx->desc_hdr_template | DESC_HDR_DIR_INBOUND; 
     978 
     979        return common_nonsnoop(edesc, areq, NULL, ablkcipher_done); 
     980} 
     981 
     982static void common_nonsnoop_hash_unmap(struct device *dev, 
     983                                       struct talitos_edesc *edesc, 
     984                                       struct ahash_request *areq) 
     985{ 
     986        struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); 
     987 
     988        unmap_single_talitos_ptr(dev, &edesc->desc.ptr[5], DMA_FROM_DEVICE); 
     989 
     990        /* When using hashctx-in, must unmap it. */ 
     991        if (edesc->desc.ptr[1].len) 
     992                unmap_single_talitos_ptr(dev, &edesc->desc.ptr[1], 
     993                                         DMA_TO_DEVICE); 
     994 
     995        if (edesc->desc.ptr[2].len) 
     996                unmap_single_talitos_ptr(dev, &edesc->desc.ptr[2], 
     997                                         DMA_TO_DEVICE); 
     998 
     999        talitos_sg_unmap(dev, edesc, req_ctx->psrc, NULL); 
     1000} 
     1001 
     1002static void ahash_done(struct device *dev, 
     1003                       struct talitos_desc *desc, void *context, 
     1004                       int err) 
     1005{ 
     1006        struct ahash_request *areq = context; 
     1007        struct talitos_edesc *edesc = 
     1008                 container_of(desc, struct talitos_edesc, desc); 
     1009        struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); 
     1010 
     1011        if (!req_ctx->last && req_ctx->to_hash_later) { 
     1012                /* Position any partial block for next update/final/finup */ 
     1013                memcpy(req_ctx->buf, req_ctx->bufnext, req_ctx->to_hash_later); 
     1014                req_ctx->nbuf = req_ctx->to_hash_later; 
     1015        } 
     1016        common_nonsnoop_hash_unmap(dev, edesc, areq); 
     1017 
     1018        kfree(edesc); 
     1019 
     1020        areq->base.complete(&areq->base, err); 
     1021} 
     1022 
     1023static int common_nonsnoop_hash(struct talitos_edesc *edesc, 
     1024                                struct ahash_request *areq, unsigned int length, 
     1025                                void (*callback) (struct device *dev, 
     1026                                                  struct talitos_desc *desc, 
     1027                                                  void *context, int error)) 
     1028{ 
     1029        struct crypto_ahash *tfm = crypto_ahash_reqtfm(areq); 
     1030        struct talitos_ctx *ctx = crypto_ahash_ctx(tfm); 
     1031        struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); 
     1032        struct device *dev = ctx->dev; 
     1033        struct talitos_desc *desc = &edesc->desc; 
     1034        int sg_count, ret; 
     1035 
     1036        desc->next_hdr = 0; 
     1037 
     1038        /* first DWORD empty */ 
     1039        desc->ptr[0] = zero_entry; 
     1040 
     1041        /* hash context in */ 
     1042        if (!req_ctx->first || req_ctx->swinit) { 
     1043                map_single_talitos_ptr(dev, &desc->ptr[1], 
     1044                                       req_ctx->hw_context_size, 
     1045                                       (char *)req_ctx->hw_context, 0, 
     1046                                       DMA_TO_DEVICE); 
     1047                req_ctx->swinit = 0; 
     1048        } else { 
     1049                desc->ptr[1] = zero_entry; 
     1050                /* Indicate next op is not the first. */ 
     1051                req_ctx->first = 0; 
     1052        } 
     1053 
     1054        /* HMAC key */ 
     1055        if (ctx->keylen) 
     1056                map_single_talitos_ptr(dev, &desc->ptr[2], ctx->keylen, 
     1057                                       (char *)&ctx->key, 0, DMA_TO_DEVICE); 
     1058        else 
     1059                desc->ptr[2] = zero_entry; 
     1060 
     1061        /* 
     1062         * data in 
     1063         */ 
     1064        desc->ptr[3].len = length; 
     1065        sg_count = talitos_map_sg(dev, req_ctx->psrc, 
     1066                                  edesc->src_nents ? : 1, 
     1067                                  DMA_TO_DEVICE, 
     1068                                  edesc->src_is_chained); 
     1069 
     1070        if (sg_count == 1) 
     1071                desc->ptr[3].ptr = sg_dma_address(req_ctx->psrc); 
     1072        else { 
     1073                sg_copy_to_buffer(req_ctx->psrc, sg_count, edesc->src_buf, 
     1074                                desc->ptr[3].len); 
     1075                desc->ptr[3].ptr = (u32)edesc->src_buf; 
     1076        } 
     1077 
     1078        /* fifth DWORD empty */ 
     1079        desc->ptr[4] = zero_entry; 
     1080 
     1081        /* hash/HMAC out -or- hash context out */ 
     1082        if (req_ctx->last) 
     1083                map_single_talitos_ptr(dev, &desc->ptr[5], 
     1084                                crypto_ahash_digestsize(tfm), 
     1085                                areq->result, 0, DMA_FROM_DEVICE); 
     1086        else 
     1087                map_single_talitos_ptr(dev, &desc->ptr[5], 
     1088                                req_ctx->hw_context_size, 
     1089                                req_ctx->hw_context, 0, DMA_FROM_DEVICE); 
     1090 
     1091        /* last DWORD empty */ 
     1092        desc->ptr[6] = zero_entry; 
     1093 
     1094        ret = talitos_submit(dev, desc, callback, areq); 
     1095        if (ret != -EINPROGRESS) { 
     1096                common_nonsnoop_hash_unmap(dev, edesc, areq); 
     1097                kfree(edesc); 
     1098        } 
     1099        return ret; 
     1100} 
     1101 
     1102static struct talitos_edesc *ahash_edesc_alloc(struct ahash_request *areq, 
     1103                                               unsigned int nbytes) 
     1104{ 
     1105        struct crypto_ahash *tfm = crypto_ahash_reqtfm(areq); 
     1106        struct talitos_ctx *ctx = crypto_ahash_ctx(tfm); 
     1107        struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); 
     1108 
     1109        return talitos_edesc_alloc(ctx->dev, req_ctx->psrc, NULL, 1, 
     1110                                   nbytes, 0, 0, areq->base.flags); 
     1111} 
     1112 
     1113static int ahash_init(struct ahash_request *areq) 
     1114{ 
     1115        struct crypto_ahash *tfm = crypto_ahash_reqtfm(areq); 
     1116        struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); 
     1117 
     1118        /* Initialize the context */ 
     1119        req_ctx->nbuf = 0; 
     1120        req_ctx->first = 1; /* first indicates h/w must init its context */ 
     1121        req_ctx->swinit = 0; /* assume h/w init of context */ 
     1122        req_ctx->hw_context_size = 
     1123                (crypto_ahash_digestsize(tfm) <= SHA256_DIGEST_SIZE) 
     1124                        ? TALITOS_MDEU_CONTEXT_SIZE_MD5_SHA1_SHA256 
     1125                        : TALITOS_MDEU_CONTEXT_SIZE_SHA384_SHA512; 
     1126 
     1127        return 0; 
     1128} 
     1129 
     1130/* 
     1131 * on h/w without explicit sha224 support, we initialize h/w context 
     1132 * manually with sha224 constants, and tell it to run sha256. 
     1133 */ 
     1134static int ahash_init_sha224_swinit(struct ahash_request *areq) 
     1135{ 
     1136        struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); 
     1137 
     1138        ahash_init(areq); 
     1139        req_ctx->swinit = 1;/* prevent h/w initting context with sha256 values*/ 
     1140 
     1141        req_ctx->hw_context[0] = SHA224_H0; 
     1142        req_ctx->hw_context[1] = SHA224_H1; 
     1143        req_ctx->hw_context[2] = SHA224_H2; 
     1144        req_ctx->hw_context[3] = SHA224_H3; 
     1145        req_ctx->hw_context[4] = SHA224_H4; 
     1146        req_ctx->hw_context[5] = SHA224_H5; 
     1147        req_ctx->hw_context[6] = SHA224_H6; 
     1148        req_ctx->hw_context[7] = SHA224_H7; 
     1149 
     1150        /* init 64-bit count */ 
     1151        req_ctx->hw_context[8] = 0; 
     1152        req_ctx->hw_context[9] = 0; 
     1153 
     1154        return 0; 
     1155} 
     1156 
     1157static int ahash_process_req(struct ahash_request *areq, unsigned int nbytes) 
     1158{ 
     1159        struct crypto_ahash *tfm = crypto_ahash_reqtfm(areq); 
     1160        struct talitos_ctx *ctx = crypto_ahash_ctx(tfm); 
     1161        struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); 
     1162        struct talitos_edesc *edesc; 
     1163        unsigned int blocksize = 
     1164                        crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm)); 
     1165        unsigned int nbytes_to_hash; 
     1166        unsigned int to_hash_later; 
     1167        unsigned int nsg; 
     1168        int chained; 
     1169 
     1170        if (!req_ctx->last && (nbytes + req_ctx->nbuf <= blocksize)) { 
     1171                /* Buffer up to one whole block */ 
     1172                sg_copy_to_buffer(areq->src, 
     1173                                  sg_count(areq->src, nbytes, &chained), 
     1174                                  req_ctx->buf + req_ctx->nbuf, nbytes); 
     1175                req_ctx->nbuf += nbytes; 
     1176                return 0; 
     1177        } 
     1178 
     1179        /* At least (blocksize + 1) bytes are available to hash */ 
     1180        nbytes_to_hash = nbytes + req_ctx->nbuf; 
     1181        to_hash_later = nbytes_to_hash & (blocksize - 1); 
     1182 
     1183        if (req_ctx->last) 
     1184                to_hash_later = 0; 
     1185        else if (to_hash_later) 
     1186                /* There is a partial block. Hash the full block(s) now */ 
     1187                nbytes_to_hash -= to_hash_later; 
     1188        else { 
     1189                /* Keep one block buffered */ 
     1190                nbytes_to_hash -= blocksize; 
     1191                to_hash_later = blocksize; 
     1192        } 
     1193 
     1194        /* Chain in any previously buffered data */ 
     1195        if (req_ctx->nbuf) { 
     1196                nsg = (req_ctx->nbuf < nbytes_to_hash) ? 2 : 1; 
     1197                sg_init_table(req_ctx->bufsl, nsg); 
     1198                sg_set_buf(req_ctx->bufsl, req_ctx->buf, req_ctx->nbuf); 
     1199                if (nsg > 1) 
     1200                        scatterwalk_sg_chain(req_ctx->bufsl, 2, areq->src); 
     1201                req_ctx->psrc = req_ctx->bufsl; 
     1202        } else 
     1203                req_ctx->psrc = areq->src; 
     1204 
     1205        if (to_hash_later) { 
     1206                int nents = sg_count(areq->src, nbytes, &chained); 
     1207                sg_copy_end_to_buffer(areq->src, nents, 
     1208                                      req_ctx->bufnext, 
     1209                                      to_hash_later, 
     1210                                      nbytes - to_hash_later); 
     1211        } 
     1212        req_ctx->to_hash_later = to_hash_later; 
     1213 
     1214        /* Allocate extended descriptor */ 
     1215        edesc = ahash_edesc_alloc(areq, nbytes_to_hash); 
     1216        if (IS_ERR(edesc)) 
     1217                return PTR_ERR(edesc); 
     1218 
     1219        edesc->desc.hdr = ctx->desc_hdr_template; 
     1220 
     1221        /* On last one, request SEC to pad; otherwise continue */ 
     1222        if (req_ctx->last) 
     1223                edesc->desc.hdr |= DESC_HDR_MODE0_MDEU_PAD; 
     1224        else 
     1225                edesc->desc.hdr |= DESC_HDR_MODE0_MDEU_CONT; 
     1226 
     1227        /* request SEC to INIT hash. */ 
     1228        if (req_ctx->first && !req_ctx->swinit) 
     1229                edesc->desc.hdr |= DESC_HDR_MODE0_MDEU_INIT; 
     1230 
     1231        /* When the tfm context has a keylen, it's an HMAC. 
     1232         * A first or last (ie. not middle) descriptor must request HMAC. 
     1233         */ 
     1234        if (ctx->keylen && (req_ctx->first || req_ctx->last)) 
     1235                edesc->desc.hdr |= DESC_HDR_MODE0_MDEU_HMAC; 
     1236 
     1237        return common_nonsnoop_hash(edesc, areq, nbytes_to_hash, 
     1238                                    ahash_done); 
     1239} 
     1240 
     1241static int ahash_update(struct ahash_request *areq) 
     1242{ 
     1243        struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); 
     1244 
     1245        req_ctx->last = 0; 
     1246 
     1247        return ahash_process_req(areq, areq->nbytes); 
     1248} 
     1249 
     1250static int ahash_final(struct ahash_request *areq) 
     1251{ 
     1252        struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); 
     1253 
     1254        req_ctx->last = 1; 
     1255 
     1256        return ahash_process_req(areq, 0); 
     1257} 
     1258 
     1259static int ahash_finup(struct ahash_request *areq) 
     1260{ 
     1261        struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); 
     1262 
     1263        req_ctx->last = 1; 
     1264 
     1265        return ahash_process_req(areq, areq->nbytes); 
     1266} 
     1267 
     1268static int ahash_digest(struct ahash_request *areq) 
     1269{ 
     1270        struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq); 
     1271        struct crypto_ahash *ahash = crypto_ahash_reqtfm(areq); 
     1272 
     1273        ahash->init(areq); 
     1274        req_ctx->last = 1; 
     1275 
     1276        return ahash_process_req(areq, areq->nbytes); 
     1277} 
     1278 
     1279struct talitos_alg_template { 
     1280        u32 type; 
     1281        union { 
     1282                struct crypto_alg crypto; 
     1283                struct ahash_alg hash; 
     1284        } alg; 
     1285        __be32 desc_hdr_template; 
     1286}; 
     1287 
     1288static struct talitos_alg_template driver_algs[] = { 
     1289        /* ABLKCIPHER algorithms. */ 
     1290        {       .type = CRYPTO_ALG_TYPE_ABLKCIPHER, 
     1291                .alg.crypto = { 
     1292                        .cra_name = "ecb(arc4)", 
     1293                        .cra_driver_name = "ecb-arc4-talitos", 
     1294                        .cra_blocksize = ARC4_BLOCK_SIZE, 
     1295                        .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | 
     1296                                        CRYPTO_ALG_ASYNC, 
     1297                        .cra_type = &crypto_ablkcipher_type, 
     1298                        .cra_ablkcipher = { 
     1299                                .setkey = ablkcipher_setkey, 
     1300                                .encrypt = ablkcipher_encrypt, 
     1301                                .decrypt = ablkcipher_decrypt, 
     1302                                .geniv = "eseqiv", 
     1303                                .min_keysize = ARC4_MIN_KEY_SIZE, 
     1304                                .max_keysize = ARC4_MAX_KEY_SIZE, 
     1305                                .ivsize = ARC4_BLOCK_SIZE, 
     1306                        } 
     1307                }, 
     1308                .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_AFEU | 
     1309                                     DESC_HDR_SEL0_AFEU | 
     1310                                     DESC_HDR_MODE0_AFEU_USE_KEY, 
     1311        }, 
     1312        {       .type = CRYPTO_ALG_TYPE_ABLKCIPHER, 
     1313                .alg.crypto = { 
     1314                        .cra_name = "cbc(aes)", 
     1315                        .cra_driver_name = "cbc-aes-talitos", 
     1316                        .cra_blocksize = AES_BLOCK_SIZE, 
     1317                        .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | 
     1318                                        CRYPTO_ALG_ASYNC, 
     1319                        .cra_type = &crypto_ablkcipher_type, 
     1320                        .cra_ablkcipher = { 
     1321                                .setkey = ablkcipher_setkey, 
     1322                                .encrypt = ablkcipher_encrypt, 
     1323                                .decrypt = ablkcipher_decrypt, 
     1324                                .geniv = "eseqiv", 
     1325                                .min_keysize = AES_MIN_KEY_SIZE, 
     1326                                .max_keysize = AES_MAX_KEY_SIZE, 
     1327                                .ivsize = AES_BLOCK_SIZE, 
     1328                        } 
     1329                }, 
     1330                .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | 
     1331                                     DESC_HDR_SEL0_AESU | 
     1332                                     DESC_HDR_MODE0_AESU_CBC, 
     1333        }, 
     1334        {       .type = CRYPTO_ALG_TYPE_ABLKCIPHER, 
     1335                .alg.crypto = { 
     1336                        .cra_name = "cbc(des)", 
     1337                        .cra_driver_name = "cbc-des-talitos", 
     1338                        .cra_blocksize = DES_BLOCK_SIZE, 
     1339                        .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | 
     1340                                        CRYPTO_ALG_ASYNC, 
     1341                        .cra_type = &crypto_ablkcipher_type, 
     1342                        .cra_ablkcipher = { 
     1343                                .setkey = ablkcipher_setkey, 
     1344                                .encrypt = ablkcipher_encrypt, 
     1345                                .decrypt = ablkcipher_decrypt, 
     1346                                .geniv = "eseqiv", 
     1347                                .min_keysize = DES_KEY_SIZE, 
     1348                                .max_keysize = DES_KEY_SIZE, 
     1349                                .ivsize = DES_BLOCK_SIZE, 
     1350                        } 
     1351                }, 
     1352                .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | 
     1353                                        DESC_HDR_SEL0_DEU | 
     1354                                        DESC_HDR_MODE0_DEU_CBC, 
     1355        }, 
     1356        {       .type = CRYPTO_ALG_TYPE_ABLKCIPHER, 
     1357                .alg.crypto = { 
     1358                        .cra_name = "cbc(des3_ede)", 
     1359                        .cra_driver_name = "cbc-3des-talitos", 
     1360                        .cra_blocksize = DES3_EDE_BLOCK_SIZE, 
     1361                        .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | 
     1362                                        CRYPTO_ALG_ASYNC, 
     1363                        .cra_type = &crypto_ablkcipher_type, 
     1364                        .cra_ablkcipher = { 
     1365                                .setkey = ablkcipher_setkey, 
     1366                                .encrypt = ablkcipher_encrypt, 
     1367                                .decrypt = ablkcipher_decrypt, 
     1368                                .geniv = "eseqiv", 
     1369                                .min_keysize = DES3_EDE_KEY_SIZE, 
     1370                                .max_keysize = DES3_EDE_KEY_SIZE, 
     1371                                .ivsize = DES3_EDE_BLOCK_SIZE, 
     1372                        } 
     1373                }, 
     1374                .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | 
     1375                                        DESC_HDR_SEL0_DEU | 
     1376                                        DESC_HDR_MODE0_DEU_CBC | 
     1377                                        DESC_HDR_MODE0_DEU_3DES, 
     1378        }, 
     1379        /* AHASH algorithms. */ 
     1380        {       .type = CRYPTO_ALG_TYPE_AHASH, 
     1381                .alg.hash = { 
     1382                        .init = ahash_init, 
     1383                        .update = ahash_update, 
     1384                        .final = ahash_final, 
     1385                        .finup = ahash_finup, 
     1386                        .digest = ahash_digest, 
     1387                        .halg.digestsize = MD5_DIGEST_SIZE, 
     1388                        .halg.base = { 
     1389                                .cra_name = "md5", 
     1390                                .cra_driver_name = "md5-talitos", 
     1391                                .cra_blocksize = MD5_BLOCK_SIZE, 
     1392                                .cra_flags = CRYPTO_ALG_TYPE_AHASH | 
     1393                                             CRYPTO_ALG_ASYNC, 
     1394                                .cra_type = &crypto_ahash_type 
     1395                        } 
     1396                }, 
     1397                .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | 
     1398                                     DESC_HDR_SEL0_MDEU | 
     1399                                     DESC_HDR_MODE0_MDEU_MD5, 
     1400        }, 
     1401        {       .type = CRYPTO_ALG_TYPE_AHASH, 
     1402                .alg.hash = { 
     1403                        .init = ahash_init, 
     1404                        .update = ahash_update, 
     1405                        .final = ahash_final, 
     1406                        .finup = ahash_finup, 
     1407                        .digest = ahash_digest, 
     1408                        .halg.digestsize = SHA1_DIGEST_SIZE, 
     1409                        .halg.base = { 
     1410                                .cra_name = "sha1", 
     1411                                .cra_driver_name = "sha1-talitos", 
     1412                                .cra_blocksize = SHA1_BLOCK_SIZE, 
     1413                                .cra_flags = CRYPTO_ALG_TYPE_AHASH | 
     1414                                             CRYPTO_ALG_ASYNC, 
     1415                                .cra_type = &crypto_ahash_type 
     1416                        } 
     1417                }, 
     1418                .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | 
     1419                                     DESC_HDR_SEL0_MDEU | 
     1420                                     DESC_HDR_MODE0_MDEU_SHA1, 
     1421        }, 
     1422}; 
     1423 
     1424struct talitos_crypto_alg { 
     1425        struct list_head entry; 
     1426        struct device *dev; 
     1427        struct talitos_alg_template algt; 
     1428}; 
     1429 
     1430static int talitos_cra_init(struct crypto_tfm *tfm) 
     1431{ 
     1432        struct crypto_alg *alg = tfm->__crt_alg; 
     1433        struct talitos_crypto_alg *talitos_alg; 
     1434        struct talitos_ctx *ctx = crypto_tfm_ctx(tfm); 
     1435 
     1436        if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_AHASH) 
     1437                talitos_alg = container_of(__crypto_ahash_alg(alg), 
     1438                                           struct talitos_crypto_alg, 
     1439                                           algt.alg.hash); 
     1440        else 
     1441                talitos_alg = container_of(alg, struct talitos_crypto_alg, 
     1442                                           algt.alg.crypto); 
     1443 
     1444        /* update context with ptr to dev */ 
     1445        ctx->dev = talitos_alg->dev; 
     1446 
     1447        /* copy descriptor header template value */ 
     1448        ctx->desc_hdr_template = talitos_alg->algt.desc_hdr_template; 
     1449 
     1450        return 0; 
     1451} 
     1452 
     1453static int talitos_cra_init_ahash(struct crypto_tfm *tfm) 
     1454{ 
     1455        struct talitos_ctx *ctx = crypto_tfm_ctx(tfm); 
     1456 
     1457        talitos_cra_init(tfm); 
     1458 
     1459        ctx->keylen = 0; 
     1460        crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm), 
     1461                                 sizeof(struct talitos_ahash_req_ctx)); 
     1462 
     1463        return 0; 
     1464} 
     1465 
     1466/* 
     1467 * given the alg's descriptor header template, determine whether descriptor 
     1468 * type and primary/secondary execution units required match the hw 
     1469 * capabilities description provided in the device tree node. 
     1470 */ 
     1471static int hw_supports(struct device *dev, __be32 desc_hdr_template) 
     1472{ 
     1473        struct talitos_private *priv = dev_get_drvdata(dev); 
     1474        int ret; 
     1475 
     1476        ret = (DESC_TYPE(desc_hdr_template) & priv->desc_types) && 
     1477              (PRIMARY_EU(desc_hdr_template) & priv->exec_units); 
     1478 
     1479        if (SECONDARY_EU(desc_hdr_template)) 
     1480                ret = ret && (SECONDARY_EU(desc_hdr_template) 
     1481                                & priv->exec_units); 
     1482 
     1483        return ret; 
     1484} 
     1485 
     1486static int talitos_remove(struct platform_device *pdev) 
     1487{ 
     1488        struct device *dev = &pdev->dev; 
     1489        struct talitos_private *priv = dev_get_drvdata(dev); 
     1490        struct talitos_crypto_alg *t_alg, *n; 
     1491        int i; 
     1492 
     1493        list_for_each_entry_safe(t_alg, n, &priv->alg_list, entry) { 
     1494                switch (t_alg->algt.type) { 
     1495                case CRYPTO_ALG_TYPE_ABLKCIPHER: 
     1496                case CRYPTO_ALG_TYPE_AEAD: 
     1497                        crypto_unregister_alg(&t_alg->algt.alg.crypto); 
     1498                        break; 
     1499                case CRYPTO_ALG_TYPE_AHASH: 
     1500                        crypto_unregister_ahash(&t_alg->algt.alg.hash); 
     1501                        break; 
     1502                } 
     1503                list_del(&t_alg->entry); 
     1504                kfree(t_alg); 
     1505        } 
     1506 
     1507        for (i = 0; i < priv->num_channels; i++) 
     1508                kfree(priv->chan[i].fifo); 
     1509 
     1510        kfree(priv->chan); 
     1511 
     1512        if (priv->irq != 0) 
     1513                free_irq(priv->irq, dev); 
     1514 
     1515        tasklet_kill(&priv->done_task); 
     1516 
     1517        iounmap(priv->reg); 
     1518 
     1519        dev_set_drvdata(dev, NULL); 
     1520 
     1521        kfree(priv); 
     1522 
     1523        return 0; 
     1524} 
     1525 
     1526static struct talitos_crypto_alg *talitos_alg_alloc(struct device *dev, 
     1527                                                    struct talitos_alg_template 
     1528                                                        *template) 
     1529{ 
     1530        struct talitos_private *priv = dev_get_drvdata(dev); 
     1531        struct talitos_crypto_alg *t_alg; 
     1532        struct crypto_alg *alg; 
     1533 
     1534        t_alg = kzalloc(sizeof(struct talitos_crypto_alg), GFP_KERNEL); 
     1535        if (!t_alg) 
     1536                return ERR_PTR(-ENOMEM); 
     1537 
     1538        t_alg->algt = *template; 
     1539 
     1540        switch (t_alg->algt.type) { 
     1541        case CRYPTO_ALG_TYPE_ABLKCIPHER: 
     1542                alg = &t_alg->algt.alg.crypto; 
     1543                alg->cra_init = talitos_cra_init; 
     1544                break; 
     1545        case CRYPTO_ALG_TYPE_AHASH: 
     1546                alg = &t_alg->algt.alg.hash.halg.base; 
     1547                alg->cra_init = talitos_cra_init_ahash; 
     1548                if (!(priv->features & TALITOS_FTR_SHA224_HWINIT) && 
     1549                    !strcmp(alg->cra_name, "sha224")) { 
     1550                        t_alg->algt.alg.hash.init = ahash_init_sha224_swinit; 
     1551                        t_alg->algt.desc_hdr_template = 
     1552                                        DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | 
     1553                                        DESC_HDR_SEL0_MDEU | 
     1554                                        DESC_HDR_MODE0_MDEU_SHA256; 
     1555                } 
     1556                break; 
     1557        default: 
     1558                dev_err(dev, "unknown algorithm type %d\n", t_alg->algt.type); 
     1559                return ERR_PTR(-EINVAL); 
     1560        } 
     1561 
     1562        alg->cra_module = THIS_MODULE; 
     1563        alg->cra_priority = TALITOS_CRA_PRIORITY; 
     1564        alg->cra_alignmask = 0; 
     1565        alg->cra_ctxsize = sizeof(struct talitos_ctx); 
     1566 
     1567        t_alg->dev = dev; 
     1568 
     1569        return t_alg; 
     1570} 
     1571 
     1572static int __devinit talitos_probe(struct platform_device *pdev) 
     1573{ 
     1574        struct device *dev = &pdev->dev; 
     1575        struct talitos_private *priv; 
     1576        int prop; 
     1577        struct resource *r; 
     1578        int i, err; 
     1579 
     1580        priv = kzalloc(sizeof(struct talitos_private), GFP_KERNEL); 
     1581        if (!priv) 
     1582                return -ENOMEM; 
     1583 
     1584        dev_set_drvdata(dev, priv); 
     1585 
     1586        priv->pdev = pdev; 
     1587 
     1588        tasklet_init(&priv->done_task, talitos_done, (unsigned long)dev); 
     1589 
     1590        INIT_LIST_HEAD(&priv->alg_list); 
     1591 
     1592        priv->irq = 64 + ISC_SEC; 
     1593        /* get the irq line */ 
     1594        err = request_irq(priv->irq, talitos_interrupt, IRQF_DISABLED, 
     1595                        dev_driver_string(dev), dev); 
     1596        if (err) { 
     1597                dev_err(dev, "failed to request irq %d\n", priv->irq); 
     1598                goto err_out; 
     1599        } else 
     1600                MCF_ICR(ISC_SEC) = ILP_SEC; 
     1601 
     1602 
     1603        /* get a pointer to the register memory */ 
     1604        r = platform_get_resource(pdev, IORESOURCE_MEM, 0); 
     1605        priv->reg = ioremap(r->start, (r->end - r->start)); 
     1606        if (!priv->reg) 
     1607                dev_err(dev, "failed to ioremap\n"); 
     1608 
     1609        /* get SEC version capabilities from device tree */ 
     1610        prop = in_be32(priv->reg + TALITOS_ID); 
     1611        if (prop & TALITOS_ID_SEC_1_1) { 
     1612                priv->num_channels = TALITOS_NCHANNELS_SEC_1_1; 
     1613                priv->chfifo_len = TALITOS_CHFIFOLEN_SEC_1_1; 
     1614                priv->exec_units = TALITOS_HAS_EUS_SEC_1_1; 
     1615                priv->desc_types = TALITOS_HAS_DESCTYPES_SEC_1_1; 
     1616        } else { 
     1617                dev_err(dev, "failed to id device\n"); 
     1618                goto err_out; 
     1619        } 
     1620 
     1621        priv->chan = kzalloc(sizeof(struct talitos_channel) * 
     1622                             priv->num_channels, GFP_KERNEL); 
     1623        if (!priv->chan) { 
     1624                dev_err(dev, "failed to allocate channel management space\n"); 
     1625                err = -ENOMEM; 
     1626                goto err_out; 
     1627        } 
     1628 
     1629        for (i = 0; i < priv->num_channels; i++) { 
     1630                spin_lock_init(&priv->chan[i].head_lock); 
     1631                spin_lock_init(&priv->chan[i].tail_lock); 
     1632        } 
     1633 
     1634        priv->fifo_len = roundup_pow_of_two(priv->chfifo_len); 
     1635 
     1636        for (i = 0; i < priv->num_channels; i++) { 
     1637                priv->chan[i].fifo = kzalloc(sizeof(struct talitos_request) * 
     1638                                             priv->fifo_len, GFP_KERNEL); 
     1639                if (!priv->chan[i].fifo) { 
     1640                        dev_err(dev, "failed to allocate request fifo %d\n", i); 
     1641                        err = -ENOMEM; 
     1642                        goto err_out; 
     1643                } 
     1644        } 
     1645 
     1646        for (i = 0; i < priv->num_channels; i++) 
     1647                atomic_set(&priv->chan[i].submit_count, 
     1648                        -(priv->chfifo_len - 1)); 
     1649 
     1650        dma_set_mask(dev, DMA_BIT_MASK(36)); 
     1651 
     1652        /* reset and initialize the h/w */ 
     1653        err = init_device(dev); 
     1654        if (err) { 
     1655                dev_err(dev, "failed to initialize device\n"); 
     1656                goto err_out; 
     1657        } 
     1658 
     1659        /* register crypto algorithms the device supports */ 
     1660        for (i = 0; i < ARRAY_SIZE(driver_algs); i++) { 
     1661                if (hw_supports(dev, driver_algs[i].desc_hdr_template)) { 
     1662                        struct talitos_crypto_alg *t_alg; 
     1663                        char *name = NULL; 
     1664 
     1665                        t_alg = talitos_alg_alloc(dev, &driver_algs[i]); 
     1666                        if (IS_ERR(t_alg)) { 
     1667                                err = PTR_ERR(t_alg); 
     1668                                goto err_out; 
     1669                        } 
     1670 
     1671                        switch (t_alg->algt.type) { 
     1672                        case CRYPTO_ALG_TYPE_ABLKCIPHER: 
     1673                        case CRYPTO_ALG_TYPE_AEAD: 
     1674                                err = crypto_register_alg( 
     1675                                                &t_alg->algt.alg.crypto); 
     1676                                name = t_alg->algt.alg.crypto.cra_driver_name; 
     1677                                break; 
     1678                        case CRYPTO_ALG_TYPE_AHASH: 
     1679                                err = crypto_register_ahash( 
     1680                                                &t_alg->algt.alg.hash); 
     1681                                name = 
     1682                                t_alg->algt.alg.hash.halg.base.cra_driver_name; 
     1683                                break; 
     1684                        } 
     1685                        if (err) { 
     1686                                dev_err(dev, "%s alg registration failed\n", 
     1687                                        name); 
     1688                                kfree(t_alg); 
     1689                        } else { 
     1690                                list_add_tail(&t_alg->entry, &priv->alg_list); 
     1691                                dev_info(dev, "%s\n", name); 
     1692                        } 
     1693                } 
     1694        } 
     1695 
     1696        return 0; 
     1697 
     1698err_out: 
     1699        talitos_remove(pdev); 
     1700 
     1701        return err; 
     1702} 
     1703 
     1704static struct platform_driver talitos_driver = { 
     1705        .driver = { 
     1706                .name = "talitos", 
     1707                .owner = THIS_MODULE, 
     1708        }, 
     1709        .probe = talitos_probe, 
     1710        .remove = talitos_remove, 
     1711}; 
     1712 
     1713static int __init talitos_init(void) 
     1714{ 
     1715        return platform_driver_register(&talitos_driver); 
     1716} 
     1717module_init(talitos_init); 
     1718 
     1719static void __exit talitos_exit(void) 
     1720{ 
     1721        platform_driver_unregister(&talitos_driver); 
     1722} 
     1723module_exit(talitos_exit); 
     1724 
     1725MODULE_LICENSE("GPL"); 
     1726MODULE_AUTHOR("Kim Phillips <kim.phillips@freescale.com>"); 
     1727MODULE_DESCRIPTION("Freescale integrated security engine (SEC) driver"); 
  • new file drivers/crypto/cf_talitos.h

    - +  
     1/* 
     2 * Freescale Coldfire SEC (talitos) device dependent data structures 
     3 * 
     4 * Copyright 2011 Freescale Semiconductor, Inc. All Rights Reserved. 
     5 * 
     6 * This program is free software; you can redistribute it and/or modify 
     7 * it under the terms of the GNU General Public License as published by 
     8 * the Free Software Foundation; either version 2 of the License, or 
     9 * (at your option) any later version. 
     10 */ 
     11 
     12/* device ID register values */ 
     13#define TALITOS_ID_SEC_1_1      (0x09000000)  /* MCF547x and MCF548x */ 
     14 
     15/* 
     16 * following num_channels, channel-fifo-depth, exec-unit-mask, and 
     17 * descriptor-types-mask are for forward-compatibility with openfirmware 
     18 * flat device trees 
     19 */ 
     20 
     21/* 
     22 *  num_channels : the number of channels available in each SEC version. 
     23 */ 
     24 
     25/* n.b. this driver requires these values be a power of 2 */ 
     26#define TALITOS_NCHANNELS_SEC_1_1       2 
     27 
     28/* 
     29 *  channel-fifo-depth : The number of descriptor 
     30 *  pointers a channel fetch fifo can hold. 
     31 */ 
     32#define TALITOS_CHFIFOLEN_SEC_1_1       1 
     33 
     34/* the corresponding masks for each SEC version */ 
     35#define TALITOS_HAS_EUS_SEC_1_1         0x7 
     36 
     37/* the corresponding masks for each SEC version */ 
     38#define TALITOS_HAS_DESCTYPES_SEC_1_1   0xf 
     39 
     40/* 
     41 * a TALITOS_xxx_HI address points to the low data bits (32-63) of the register 
     42 */ 
     43/* global register offset addresses */ 
     44/* EU Assaginment controller register is useless*/ 
     45#define TALITOS_EUACR           0x1000 
     46#define TALITOS_EUACR_LO        0x1004 
     47 
     48#define TALITOS_IMR             0x1008          /* interrupt mask register */ 
     49#define TALITOS_IMR_ALL         0xf8000000      /* enable all interrupts mask */ 
     50#define TALITOS_IMR_ERR         0xa8000000      /* mask error interrupts */ 
     51#define TALITOS_IMR_DONE        0x50000000      /* mask done interrupts */ 
     52#define TALITOS_IMR_LO          0x100C          /* interrupt mask register */ 
     53/* mask all channel interrupts mask */ 
     54#define TALITOS_IMR_LO_ALL      0x03333340 
     55#define TALITOS_IMR_LO_ERR      0x02222240      /* mask error interrupts */ 
     56#define TALITOS_IMR_LO_DONE     0x01111100      /* mask done interrupts */ 
     57 
     58#define TALITOS_ISR             0x1010          /* interrupt status register */ 
     59#define TALITOS_ISR_CHERR       0xa8000000      /* errors mask */ 
     60#define TALITOS_ISR_CHDONE      0x50000000      /* channel(s) done mask */ 
     61#define TALITOS_ISR_LO          0x1014          /* interrupt status register */ 
     62 
     63#define TALITOS_ICR             0x1018          /* interrupt clear register */ 
     64#define TALITOS_ICR_CHERR       0xa8000000      /* errors enable */ 
     65#define TALITOS_ICR_CHDONE      0x50000000      /* channel(s) done enable */ 
     66#define TALITOS_ICR_LO          0x101C          /* interrupt clear register */ 
     67#define TALITOS_ICR_LO_CHERR    0x02222240      /* errors enable */ 
     68#define TALITOS_ICR_LO_CHDONE   0x01111100      /* channel(s) done enable */ 
     69 
     70#define TALITOS_ID              0x1020 
     71 
     72/* EU Assaginment status register is useless*/ 
     73#define TALITOS_EUASR           0x1028 
     74#define TALITOS_EUASR_LO        0x102C 
     75 
     76#define TALITOS_MCR             0x1030          /* master control register */ 
     77#define TALITOS_MCR_SWR         0x01000000 
     78 
     79#define TALITOS_MEAR            0x1038 
     80 
     81/* channel register address stride */ 
     82#define TALITOS_CH_STRIDE       0x1000 
     83 
     84/* channel register offset addresses and bits */ 
     85#define TALITOS_CCCR(ch)        (ch * TALITOS_CH_STRIDE + 0x200c) 
     86#define TALITOS_CCCR_RESET   0x1     /* Channel Reset bit */ 
     87#define TALITOS_CCCR_CDWE    0x10    /* Channel done writeback enable bit */ 
     88#define TALITOS_CCCR_NE      0x8     /* Fetch Next Descriptor Enable bit */ 
     89#define TALITOS_CCCR_NT      0x4     /* Notification type bit */ 
     90#define TALITOS_CCCR_CDIE    0x2     /* Channel Done Interrupt Enable bit */ 
     91 
     92/* Crypto-Channel Pointer Status Reg */ 
     93#define TALITOS_CCPSR(ch)       (ch * TALITOS_CH_STRIDE + 0x2010) 
     94#define TALITOS_CCPSR_LO(ch)    (ch * TALITOS_CH_STRIDE + 0x2014) 
     95#define TALITOS_CCPSR_LO_TEA    0x2000  /* Transfer error acknowledge */ 
     96#define TALITOS_CCPSR_LO_PERR   0x1000  /* Pointer not complete error */ 
     97#define TALITOS_CCPSR_LO_DERR   0x400   /* Descriptor error */ 
     98#define TALITOS_CCPSR_LO_SERR   0x200   /* Static assignment error */ 
     99#define TALITOS_CCPSR_LO_EUERR  0x100   /* EU error */ 
     100 
     101/* channel fetch fifo register */ 
     102#define TALITOS_FF(ch)          (ch * TALITOS_CH_STRIDE + 0x204c) 
     103 
     104/* Crypto-Channel Pointer Status Reg */ 
     105#define TALITOS_CDPR(ch)        (ch * TALITOS_CH_STRIDE + 0x2044) 
     106 
     107/* Descriptor Buffer (debug) 0x2080-0x20BF*/ 
     108#define TALITOS_DESCBUF(ch)     (ch * TALITOS_CH_STRIDE + 0x2080) 
     109 
     110/* execution unit register offset addresses and bits */ 
     111#define TALITOS_DEURCR          0xa018  /* DEU reset control register */ 
     112#define TALITOS_DEURCR_RESET    0x01000000  /* DEU reset bit */ 
     113#define TALITOS_DEUSR           0xa028  /* DEU status register */ 
     114#define TALITOS_DEUSR_RESET     0x01000000  /* DEU Reset status bit */ 
     115#define TALITOS_DEUISR          0xa030  /* DEU interrupt status register */ 
     116#define TALITOS_DEUIMR          0xa038  /* DEU interrupt mask register */ 
     117#define TALITOS_DEUIMR_MASK     0xf63f0000  /* DEU interrupt control mask*/ 
     118#define TALITOS_DEUIMR_KPE_MASK 0x00200000  /* DEU interrupt KPE mask*/ 
     119 
     120#define TALITOS_AESURCR         0x12018  /* AESU reset control register */ 
     121#define TALITOS_AESURCR_RESET   0x01000000  /* AESU reset bit */ 
     122#define TALITOS_AESUSR          0x12028  /* AESU status register */ 
     123#define TALITOS_AESUSR_RESET    0x01000000  /* AESU Reset status bit */ 
     124#define TALITOS_AESUISR         0x12030  /* AESU interrupt status register */ 
     125#define TALITOS_AESUIMR         0x12038  /* AESU interrupt mask register */ 
     126#define TALITOS_AESUIMR_MASK    0xf61f0000  /* AESU interrupt control mask*/ 
     127 
     128#define TALITOS_MDEURCR         0xc018  /* MDEU reset control register */ 
     129#define TALITOS_MDEURCR_RESET   0x01000000  /* MDEU reset bit */ 
     130#define TALITOS_MDEUSR          0xc028  /* MDEU status register */ 
     131#define TALITOS_MDEUSR_RESET    0x01000000  /* MDEU Reset status bit */ 
     132#define TALITOS_MDEUISR         0xc030  /* MDEU interrupt status register */ 
     133#define TALITOS_MDEUIMR         0xc038  /* MDEU interrupt mask register */ 
     134#define TALITOS_MDEUIMR_MASK    0xc41f0000  /* MDEU interrupt control mask*/ 
     135 
     136#define TALITOS_AFEURCR         0x8018  /* AFEU reset control register */ 
     137#define TALITOS_AFEURCR_RESET   0x01000000  /* AFEU reset bit */ 
     138#define TALITOS_AFEUSR          0x8028  /* AFEU status register */ 
     139#define TALITOS_AFEUSR_RESET    0x01000000  /* AFEU Reset status bit */ 
     140#define TALITOS_AFEUISR         0x8030  /* AFEU interrupt status register */ 
     141#define TALITOS_AFEUIMR         0x8038  /* AFEU interrupt mask register */ 
     142#define TALITOS_AFEUIMR_MASK    0xf61f0000  /* AFEU interrupt control mask*/ 
     143 
     144#define TALITOS_RNGRCR          0xe018  /* RNG Reset control register */ 
     145#define TALITOS_RNGRCR_SR       0x01000000      /* RNG RNGRCR:Software Reset */ 
     146#define TALITOS_RNGSR           0xe028  /* RNG status register */ 
     147#define TALITOS_RNGSR_RD        0x01000000      /* RNG Reset done */ 
     148#define TALITOS_RNGISR          0xe030  /* RNG Interrupt status register */ 
     149#define TALITOS_RNGIMR          0xe038  /* RNG interrupt mask register */ 
     150#define TALITOS_RNGIMR_MASK     0xc2100000  /* RNG interrupt control mask*/ 
     151 
     152#define TALITOS_MDEU_CONTEXT_SIZE_MD5_SHA1_SHA256       0x28 
     153#define TALITOS_MDEU_CONTEXT_SIZE_SHA384_SHA512         0x48 
     154 
     155/***************************RC4*******************/ 
     156#define ARC4_SEC_MIN_KEY_SIZE   5 
     157#define ARC4_SEC_MAX_KEY_SIZE   16 
     158#define ARC4_SEC_CONTEXT_LEN    259 
     159#define SEC_ALG_AFEU_KEY              0x10200050 
     160#define SEC_ALG_AFEU_CONTEXT          0x10700050 
     161 
     162/* talitos descriptor header (hdr) bits */ 
     163 
     164/* primary execution unit select */ 
     165#define DESC_HDR_SEL0_MASK      0xf0000000 
     166#define DESC_HDR_SEL0_AFEU      0x10000000 
     167#define DESC_HDR_SEL0_DEU       0x20000000 
     168#define DESC_HDR_SEL0_MDEU      0x30000000 
     169#define DESC_HDR_SEL0_RNG       0x40000000 
     170#define DESC_HDR_SEL0_AESU      0x60000000 
     171 
     172/* primary execution unit mode (MODE0) and derivatives */ 
     173#define DESC_HDR_MODE0_MASK             0x0ff00000 
     174#define DESC_HDR_MODE0_ENCRYP           0x00100000 
     175#define DESC_HDR_MODE0_AFEU_USE_KEY     0x00200000 
     176#define DESC_HDR_MODE0_AFEU_USE_CONTEXT 0x00700000 
     177#define DESC_HDR_MODE0_AESU_CBC         0x00200000 
     178#define DESC_HDR_MODE0_AESU_ENC         0x00100000 
     179#define DESC_HDR_MODE0_DEU_CBC          0x00400000 
     180#define DESC_HDR_MODE0_DEU_3DES         0x00200000 
     181#define DESC_HDR_MODE0_DEU_ENC          0x00100000 
     182#define DESC_HDR_MODE0_MDEU_CONT        0x08000000 
     183#define DESC_HDR_MODE0_MDEU_INIT        0x01000000      /* init starting regs */ 
     184#define DESC_HDR_MODE0_MDEU_HMAC        0x00800000 
     185#define DESC_HDR_MODE0_MDEU_PAD         0x00400000      /* PD */ 
     186#define DESC_HDR_MODE0_MDEU_MD5         0x00200000 
     187#define DESC_HDR_MODE0_MDEU_SHA256      0x00100000 
     188#define DESC_HDR_MODE0_MDEU_SHA1        0x00000000      /* SHA-160 */ 
     189#define DESC_HDR_MODE0_MDEU_MD5_HMAC    \ 
     190                (DESC_HDR_MODE0_MDEU_MD5 | DESC_HDR_MODE0_MDEU_HMAC) 
     191#define DESC_HDR_MODE0_MDEU_SHA256_HMAC \ 
     192                (DESC_HDR_MODE0_MDEU_SHA256 | DESC_HDR_MODE0_MDEU_HMAC) 
     193#define DESC_HDR_MODE0_MDEU_SHA1_HMAC   \ 
     194                (DESC_HDR_MODE0_MDEU_SHA1 | DESC_HDR_MODE0_MDEU_HMAC) 
     195 
     196/* secondary execution unit select (SEL1) */ 
     197/* it's MDEU or nothing */ 
     198#define DESC_HDR_SEL1_MASK      0x000f0000 
     199#define DESC_HDR_SEL1_MDEU      0x00030000 
     200 
     201/* secondary execution unit mode (MODE1) and derivatives */ 
     202#define DESC_HDR_MODE1_MDEU_INIT        0x00001000      /* init starting regs */ 
     203#define DESC_HDR_MODE1_MDEU_HMAC        0x00000800 
     204#define DESC_HDR_MODE1_MDEU_PAD         0x00000400      /* PD */ 
     205#define DESC_HDR_MODE1_MDEU_MD5         0x00000200 
     206#define DESC_HDR_MODE1_MDEU_SHA256      0x00000100 
     207#define DESC_HDR_MODE1_MDEU_SHA1        0x00000000      /* SHA-160 */ 
     208#define DESC_HDR_MODE1_MDEU_MD5_HMAC    \ 
     209        (DESC_HDR_MODE1_MDEU_MD5 | DESC_HDR_MODE1_MDEU_HMAC) 
     210#define DESC_HDR_MODE1_MDEU_SHA256_HMAC \ 
     211        (DESC_HDR_MODE1_MDEU_SHA256 | DESC_HDR_MODE1_MDEU_HMAC) 
     212#define DESC_HDR_MODE1_MDEU_SHA1_HMAC   \ 
     213        (DESC_HDR_MODE1_MDEU_SHA1 | DESC_HDR_MODE1_MDEU_HMAC) 
     214 
     215/* direction of overall data flow (DIR) */ 
     216#define DESC_HDR_DIR_OUTBOUND   0x00000000 
     217#define DESC_HDR_DIR_INBOUND    0x00000002 
     218 
     219/* done notification (DN) */ 
     220#define DESC_HDR_DONE           0x00000001 
     221 
     222/* descriptor types */ 
     223#define DESC_HDR_TYPE_AESU_CTR_NONSNOOP         (0 << 4) 
     224#define DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU   (1 << 4) 
     225#define DESC_HDR_TYPE_HMAC_SNOOP_NO_AFEU        (2 << 4) 
     226#define DESC_HDR_TYPE_NONHMAC_SNOOP_NO_AFEU     (3 << 4) 
     227#define DESC_HDR_TYPE_COMMON_NONSNOOP_AFEU      (5 << 4) 
     228 
     229#define TALITOS_HDR_DONE_BITS   0xff000000 
Note: See TracBrowser for help on using the repository browser.