Re: [RFC 9/9] crypto: Add Samsung crypto engine driver

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Hi,

Any update on this?

Thank you,
Kyungmin Park

On Sat, Jun 12, 2010 at 4:49 AM, Maurus Cuelenaere
<mcuelenaere@xxxxxxxxx> wrote:
> This patch adds support for the Samsung crypto engine driver available in the
> S3C64XX and S5PC100 SoCs. Currently this supports AES and (T)DES with ECB and
> CBC block ciphers (also CTR for AES). Support for (HMAC)-SHA1 acceleration is
> also available in this engine, but isn't used in the driver yet.
>
> Support for DMA has been added in the code but is currently disabled due to
> issues with data transfers.
>
> Signed-off-by: Maurus Cuelenaere <mcuelenaere@xxxxxxxxx>
> ---
>  drivers/crypto/Kconfig   |   11 +
>  drivers/crypto/Makefile  |    1 +
>  drivers/crypto/s3c-sss.c | 1320 ++++++++++++++++++++++++++++++++++++++++++++++
>  3 files changed, 1332 insertions(+), 0 deletions(-)
>  create mode 100644 drivers/crypto/s3c-sss.c
>
> diff --git a/drivers/crypto/Kconfig b/drivers/crypto/Kconfig
> index b08403d..597a151 100644
> --- a/drivers/crypto/Kconfig
> +++ b/drivers/crypto/Kconfig
> @@ -222,4 +222,15 @@ config CRYPTO_DEV_PPC4XX
>        help
>          This option allows you to have support for AMCC crypto acceleration.
>
> +config CRYPTO_DEV_SSS
> +       tristate "Samsung Security Sub-Systems"
> +       depends on SAMSUNG_DEV_SSS
> +       select CRYPTO_ALGAPI
> +       select CRYPTO_BLKCIPHER
> +       select CRYPTO_DES
> +       select CRYPTO_HASH
> +       help
> +           This driver utilizes the cryptographic engine in Samsung S3C64XX
> +           and S5PC100 SoCs.
> +
>  endif # CRYPTO_HW
> diff --git a/drivers/crypto/Makefile b/drivers/crypto/Makefile
> index 6ffcb3f..ef14b4d 100644
> --- a/drivers/crypto/Makefile
> +++ b/drivers/crypto/Makefile
> @@ -6,3 +6,4 @@ obj-$(CONFIG_CRYPTO_DEV_MV_CESA) += mv_cesa.o
>  obj-$(CONFIG_CRYPTO_DEV_TALITOS) += talitos.o
>  obj-$(CONFIG_CRYPTO_DEV_IXP4XX) += ixp4xx_crypto.o
>  obj-$(CONFIG_CRYPTO_DEV_PPC4XX) += amcc/
> +obj-$(CONFIG_CRYPTO_DEV_SSS) += s3c-sss.o
> diff --git a/drivers/crypto/s3c-sss.c b/drivers/crypto/s3c-sss.c
> new file mode 100644
> index 0000000..9fd5288
> --- /dev/null
> +++ b/drivers/crypto/s3c-sss.c
> @@ -0,0 +1,1320 @@
> +/*
> + * linux/drivers/crypto/s3c-sss.c
> + *
> + * Copyright (C) 2010 Maurus Cuelenaere
> + *
> + * Support for S3C64XX Security Sub-Systems
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 as
> + * published by the Free Software Foundation.
> + *
> + */
> +
> +/*#define DEBUG*/
> +
> +#include <linux/clk.h>
> +#include <linux/crypto.h>
> +#include <linux/dma-mapping.h>
> +#include <linux/interrupt.h>
> +#include <linux/io.h>
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/platform_device.h>
> +#include <linux/spinlock.h>
> +#include <linux/timer.h>
> +
> +#include <crypto/internal/hash.h>
> +#include <crypto/algapi.h>
> +#include <crypto/aes.h>
> +#include <crypto/ctr.h>
> +#include <crypto/des.h>
> +#include <crypto/sha.h>
> +#include <crypto/scatterwalk.h>
> +
> +#include <mach/dma.h>
> +
> +#include <plat/regs-sss.h>
> +
> +#define SSS_CRA_PRIORITY       300
> +#define SSS_MAX_KEY_SIZE       AES_MAX_KEY_SIZE
> +#define SSS_FIFO_SIZE          0x40U
> +#define SSS_TIMEOUT            (3*HZ)
> +
> +/**
> + * struct s3c_sss - driver state.
> + * @dev: pointer to the device struct
> + * @clock: clock associated with peripheral
> + * @irq: irq associated with peripheral
> + * @regs: pointer to mapped registers
> + * @regs_phys: pointer to physical address of registers
> + * @regs_res: pointer to struct resource representing registers
> + * @cur_req: pointer to pending request (NULL indicates no current request)
> + * @dma_client: struct used for passing to DMA core
> + * @lock: lock used for synchronizing queue accesses
> + * @tasklet: tasklet doing the main work
> + * @timer: timer used for timing out faulty requests
> + * @queue: queue containing requests
> + */
> +struct s3c_sss {
> +       struct device                   *dev;
> +
> +       struct clk                      *clock;
> +       int                             irq;
> +       void __iomem                    *regs;
> +       void __iomem                    *regs_phys;
> +       struct resource                 *regs_res;
> +
> +       struct ablkcipher_request       *cur_req;
> +       struct s3c2410_dma_client       dma_client;
> +       spinlock_t                      lock;
> +       struct tasklet_struct           tasklet;
> +       struct timer_list               timer;
> +       struct crypto_queue             queue;
> +};
> +
> +/**
> + * struct sss_context - cipher/hash key state
> + * @key: storage for the key
> + * @key_len: length of the key
> + * @dev: pointer to struct containing the driver state
> + */
> +struct sss_context {
> +       u8                              key[SSS_MAX_KEY_SIZE];
> +       unsigned int                    key_len;
> +
> +       struct s3c_sss                  *dev;
> +};
> +
> +/**
> + * struct sss_fifo_channel - FIFO handling state
> + *
> + * @cur_sg: scatterlist used in current transfer
> + * @offset: offset within current scatterlist
> + * @dir: FIFO direction
> + * @sg: pointer to scatter-gather lists
> + * @sg_count: amount of scatter-gather lists
> + * @req_size: size of current request
> + * @bytes_done: amount of data transferred
> + * @dev: pointer to struct containing the driver state
> + */
> +struct sss_fifo_channel {
> +       /* DMA */
> +       struct scatterlist              *cur_sg;
> +       int                             offset;
> +       int                             sg_count;
> +
> +       /* generic */
> +       enum {
> +               FIFO_RX,
> +               FIFO_TX
> +       }                               dir;
> +       struct scatterlist              *sg;
> +       size_t                          req_size;
> +       size_t                          bytes_done;
> +       struct s3c_sss                  *dev;
> +};
> +
> +/**
> + * struct sss_req_context - driver-specific data associated with a request
> + * @algorithm: algorithm used in request
> + * @blk_cipher: block cipher used in request
> + * @direction: whether to encrypt or decrypt
> + * @rx: RX FIFO channel, see struct sss_fifo_channel
> + * @tx: TX FIFO channel, see struct sss_fifo_channel
> + * @setup_done: whether hardware has been set up
> + * @err: indicates any occured error during request
> + */
> +struct sss_req_context {
> +       enum sss_algorithm {
> +               ALGO_AES,
> +               ALGO_DES,
> +               ALGO_TDES,
> +               ALGO_SHA1,
> +               ALGO_HMAC_SHA1,
> +       }                               algorithm;
> +       enum sss_block_cipher {
> +               CIPH_ECB,
> +               CIPH_CBC,
> +               CIPH_CTR,
> +       }                               blk_cipher;
> +       enum sss_direction {
> +               ENCRYPT,
> +               DECRYPT,
> +       }                               direction;
> +
> +       struct sss_fifo_channel         rx;
> +       struct sss_fifo_channel         tx;
> +       bool                            setup_done;
> +       int                             err;
> +};
> +
> +/**
> + * struct sss_crypto_wrapper - simple wrapper for easy access to the driver data
> + * @alg: wrapped crypto algorithm
> + * @dev: pointer to the driver state
> + */
> +struct sss_crypto_wrapper {
> +       struct crypto_alg                alg;
> +       struct s3c_sss                  *dev;
> +};
> +
> +/*** Helper functions ***/
> +
> +#define fifo_to_req_ctx(fifo, dir) container_of((fifo), \
> +                                               struct sss_req_context, dir)
> +
> +static inline struct sss_req_context *sss_to_req_ctx(struct s3c_sss *sss)
> +{
> +       struct ablkcipher_request *req = sss->cur_req;
> +       return req ? ablkcipher_request_ctx(req) : NULL;
> +}
> +
> +static inline unsigned int fifo_to_dma_channel(struct sss_fifo_channel *chan)
> +{
> +       return chan->dir == FIFO_TX ? DMACH_SECURITY_TX : DMACH_SECURITY_RX;
> +}
> +
> +static inline bool sss_dma_enabled(void)
> +{
> +       /* DMA is disabled till someone figures out why it's not transmitting
> +          all data to the crypto engine. */
> +       return false;
> +}
> +
> +static int count_sgs(struct scatterlist *sg)
> +{
> +       int i;
> +
> +       for (i = 0; sg; i++)
> +               sg = sg_next(sg);
> +
> +       return i;
> +}
> +
> +static inline void orrl(u32 val, void __iomem *reg)
> +{
> +       writel(readl(reg) | val, reg);
> +}
> +
> +#ifdef DEBUG
> +static void sss_dump_regs(struct s3c_sss *sss)
> +{
> +       dev_dbg(sss->dev, "DnI_CFG: %x\n", readl(sss->regs + DnI_CFG));
> +
> +       dev_dbg(sss->dev, "FRx_Ctrl: %x\n", readl(sss->regs + FRx_Ctrl));
> +       dev_dbg(sss->dev, "FRx_MLen: %x\n", readl(sss->regs + FRx_MLen));
> +       dev_dbg(sss->dev, "FRx_BlkSz: %x\n", readl(sss->regs + FRx_BlkSz));
> +       dev_dbg(sss->dev, "FRx_Addr: %x\n", readl(sss->regs + FRx_Addr));
> +       dev_dbg(sss->dev, "FRx_MLenCnt: %x\n", readl(sss->regs + FRx_MLenCnt));
> +
> +       dev_dbg(sss->dev, "FTx_Ctrl: %x\n", readl(sss->regs + FTx_Ctrl));
> +       dev_dbg(sss->dev, "FTx_MLen: %x\n", readl(sss->regs + FTx_MLen));
> +       dev_dbg(sss->dev, "FTx_BlkSz: %x\n", readl(sss->regs + FTx_BlkSz));
> +       dev_dbg(sss->dev, "FTx_Addr: %x\n", readl(sss->regs + FTx_Addr));
> +       dev_dbg(sss->dev, "FTx_MLenCnt: %x\n", readl(sss->regs + FTx_MLenCnt));
> +
> +       dev_dbg(sss->dev, "AES_CTRL: %x\n", readl(sss->regs + AES_CTRL));
> +       dev_dbg(sss->dev, "TDES_CTRL: %x\n", readl(sss->regs + TDES_CTRL));
> +       dev_dbg(sss->dev, "HASH_CTRL: %x\n", readl(sss->regs + HASH_CTRL));
> +       dev_dbg(sss->dev, "HASH_STATUS: %x\n", readl(sss->regs + HASH_STATUS));
> +}
> +#else
> +#define sss_dump_regs(...)
> +#endif
> +
> +#ifdef DEBUG
> +static void sss_dump_channel(struct sss_fifo_channel *chan)
> +{
> +       struct s3c_sss *sss = chan->dev;
> +       bool tx = (chan->dir == FIFO_TX);
> +       u32 val;
> +
> +       val = readl(sss->regs + (tx ? FTx_Ctrl : FRx_Ctrl));
> +
> +       dev_dbg(sss->dev, "FIFO_%cX: %c%c%c%c%c\n", tx ? 'T' : 'R',
> +               val & FXx_Ctrl_Full ? 'F' : ' ',
> +               val & FXx_Ctrl_Empty ? 'E' : ' ',
> +               val & FXx_Ctrl_Done ? 'D' : ' ',
> +               val & FXx_Ctrl_Running ? 'R' : ' ',
> +               val & FXx_Ctrl_Start ? 'S' : ' ');
> +
> +       if (sss_dma_enabled()) {
> +               dev_dbg(sss->dev, "      cur_sg: %p\n", chan->cur_sg);
> +               dev_dbg(sss->dev, "      offset: %d\n", chan->offset);
> +               dev_dbg(sss->dev, "    sg_count: %d\n", chan->sg_count);
> +       }
> +
> +       dev_dbg(sss->dev, "    req_size: %d\n", chan->req_size);
> +       dev_dbg(sss->dev, "  bytes_done: %d\n", chan->bytes_done);
> +       dev_dbg(sss->dev, "     mlencnt: %d\n",
> +               readl(sss->regs + (tx ? FTx_MLenCnt : FRx_MLenCnt)) * 4);
> +       dev_dbg(sss->dev, "    wd2write: %d\n", (val >> tx ? 8 : 16) & 0xFF);
> +       dev_dbg(sss->dev, "     wd2read: %d\n", (val >> tx ? 16 : 8) & 0xFF);
> +}
> +#else
> +#define sss_dump_channel(...)
> +#endif
> +
> +static void sss_reset_fifo(struct s3c_sss *sss, int reg)
> +{
> +       int timeout = 1000;
> +       u32 val;
> +
> +       writel(FXx_Ctrl_Reset, sss->regs + reg);
> +
> +       while (timeout-- > 0) {
> +               val = readl(sss->regs + reg);
> +               if (!(val & FXx_Ctrl_Reset))
> +                       break;
> +       }
> +
> +       if (timeout <= 0)
> +               dev_warn(sss->dev, "Failed to reset FIFO_%cX!\n",
> +                        reg == FRx_Ctrl ? 'R' : 'T');
> +}
> +
> +static void sss_reset_hw(struct s3c_sss *sss)
> +{
> +       u32 val = 0;
> +
> +       if (sss_dma_enabled())
> +               val |= (DnI_CFG_RxDmaEnb | DnI_CFG_TxDmaEnb |
> +                       DnI_CFG_RxTrgLevel(16) | DnI_CFG_TxTrgLevel(16));
> +
> +       writel(val, sss->regs + DnI_CFG);
> +
> +       /* Reset FIFOs */
> +       sss_reset_fifo(sss, FRx_Ctrl);
> +       sss_reset_fifo(sss, FTx_Ctrl);
> +
> +       /* Ensure all subsystems are disabled */
> +       writel(0, sss->regs + AES_CTRL);
> +       writel(0, sss->regs + TDES_CTRL);
> +       writel(0, sss->regs + HASH_CTRL);
> +}
> +
> +#ifdef DEBUG
> +static void check_priv_mismatch(struct s3c_sss *sss, const char* name, int reg)
> +{
> +       u32 val = readl(sss->regs + reg);
> +
> +       if (val & RdPrivMismatch)
> +               dev_warn(sss->dev, "%s read privilege mismatch! (0x%x)\n", name,
> +                        val);
> +
> +       if (val & WrPrivMismatch)
> +               dev_warn(sss->dev, "%s write privilege mismatch! (0x%x)\n",
> +                        name, val);
> +}
> +#else
> +#define check_priv_mismatch(...)
> +#endif
> +
> +static irqreturn_t sss_irq(int irq, void *priv)
> +{
> +       struct s3c_sss *sss = priv;
> +       u32 cfg = readl(sss->regs + DnI_CFG);
> +
> +       check_priv_mismatch(sss, "CONFIG", DnI_CFG);
> +
> +       if (cfg & DnI_CFG_FRx_Intr_Status) {
> +               dev_dbg(sss->dev, "%s: FIFO_RX IRQ\n", __func__);
> +               check_priv_mismatch(sss, "FIFO RX", FRx_Ctrl);
> +
> +               if (sss->cur_req && !sss_dma_enabled()) {
> +                       struct sss_fifo_channel *ch = &sss_to_req_ctx(sss)->rx;
> +                       if (ch->req_size) {
> +                               dev_dbg(sss->dev, "Increasing consumption with "
> +                                                 "%d bytes\n", ch->req_size);
> +                               ch->bytes_done += ch->req_size;
> +                               ch->req_size = 0;
> +                               tasklet_schedule(&sss->tasklet);
> +                       }
> +               }
> +       }
> +
> +       if (cfg & DnI_CFG_FTx_Intr_Status) {
> +               dev_dbg(sss->dev, "%s: FIFO_TX IRQ\n", __func__);
> +               check_priv_mismatch(sss, "FIFO TX", FTx_Ctrl);
> +
> +               if (sss->cur_req && !sss_dma_enabled())
> +                       tasklet_schedule(&sss->tasklet);
> +       }
> +
> +       if (cfg & DnI_CFG_SHA_Intr_Status)
> +               dev_dbg(sss->dev, "%s: HASH IRQ\n", __func__);
> +
> +       if (cfg & DnI_CFG_DES_Intr_Status) {
> +               dev_dbg(sss->dev, "%s: TDES IRQ\n", __func__);
> +               check_priv_mismatch(sss, "TDES", TDES_CTRL);
> +       }
> +
> +       if (cfg & DnI_CFG_AES_Intr_Status) {
> +               dev_dbg(sss->dev, "%s: AES IRQ\n", __func__);
> +               check_priv_mismatch(sss, "AES", AES_CTRL);
> +       }
> +
> +       return IRQ_HANDLED;
> +}
> +
> +static void sss_dma_cb(struct s3c2410_dma_chan *chan, void *pw, int size,
> +                      enum s3c2410_dma_buffresult res)
> +{
> +       struct sss_fifo_channel *fifo_chan = pw;
> +       struct s3c_sss *sss = fifo_chan->dev;
> +       struct sss_req_context *req_ctx;
> +
> +       dev_dbg(sss->dev, "%s: FIFO_%cX\n", __func__,
> +               fifo_chan->dir == FIFO_RX ? 'R' : 'T');
> +
> +       if (fifo_chan->dir == FIFO_RX)
> +               req_ctx = fifo_to_req_ctx(fifo_chan, rx);
> +       else
> +               req_ctx = fifo_to_req_ctx(fifo_chan, tx);
> +
> +       switch (res) {
> +       case S3C2410_RES_OK:
> +               fifo_chan->bytes_done += fifo_chan->req_size;
> +               fifo_chan->offset += fifo_chan->req_size;
> +               fifo_chan->req_size = 0;
> +               break;
> +       case S3C2410_RES_ERR:
> +       case S3C2410_RES_ABORT:
> +       default:
> +               dev_err(sss->dev, "Error occured during DMA transfer!\n");
> +               if (!req_ctx->err)
> +                       req_ctx->err = -EIO;
> +       }
> +
> +       tasklet_schedule(&sss->tasklet);
> +}
> +
> +static int sss_setup_dma(struct s3c_sss *sss, unsigned int channel)
> +{
> +       enum s3c2410_dmasrc source;
> +       unsigned long reg;
> +       int ret;
> +
> +       ret = s3c2410_dma_request(channel, &sss->dma_client, sss);
> +       if (ret < 0)
> +               return ret;
> +
> +       if (channel == DMACH_SECURITY_RX) {
> +               reg = (unsigned long)(sss->regs_phys + SDMA_FRx_Buf);
> +               source = S3C2410_DMASRC_MEM;
> +       } else { /* DMACH_SECURITY_TX */
> +               reg = (unsigned long)(sss->regs_phys + SDMA_FTx_Buf);
> +               source = S3C2410_DMASRC_HW;
> +       }
> +
> +       s3c2410_dma_config(channel, 4);
> +       s3c2410_dma_devconfig(channel, source, reg);
> +       s3c2410_dma_set_buffdone_fn(channel, sss_dma_cb);
> +
> +       return 0;
> +}
> +
> +static void sss_setup_hw(struct s3c_sss *sss)
> +{
> +       struct ablkcipher_request *req = sss->cur_req;
> +       struct sss_context *ctx = crypto_tfm_ctx(req->base.tfm);
> +       struct sss_req_context *req_ctx = ablkcipher_request_ctx(req);
> +       u32 val, cfg, fifo_rx, fifo_tx;
> +
> +       dev_dbg(sss->dev, "%s: setting up hw\n", __func__);
> +
> +       sss_reset_hw(sss);
> +
> +       cfg = readl(sss->regs + DnI_CFG);
> +       cfg |= (DnI_CFG_FTx_Intr_En | DnI_CFG_FRx_Intr_En);
> +
> +       fifo_rx = (FXx_Ctrl_Host_Rd_En | FXx_Ctrl_Host_Wr_En |
> +                  FRx_Ctrl_Sync_Tx);
> +       fifo_tx = (FXx_Ctrl_Host_Rd_En | FXx_Ctrl_Host_Wr_En);
> +
> +       switch (req_ctx->algorithm) {
> +       case ALGO_AES:
> +               cfg |= DnI_CFG_AES_Intr_En;
> +               fifo_rx |= FXx_Ctrl_Module_AES;
> +               fifo_tx |= FXx_Ctrl_Module_AES;
> +
> +               switch (req_ctx->blk_cipher) {
> +               case CIPH_ECB:
> +                       val = AES_CTRL_OpMode_ECB;
> +                       break;
> +               case CIPH_CBC:
> +                       val = AES_CTRL_OpMode_CBC;
> +                       memcpy(sss->regs + AES_IV, req->info, 16);
> +                       break;
> +               case CIPH_CTR:
> +                       val = AES_CTRL_OpMode_CTR;
> +                       memcpy(sss->regs + AES_CTR, req->info, 16); /* ??? */
> +                       break;
> +               }
> +
> +               if (req_ctx->direction == DECRYPT &&
> +                   req_ctx->blk_cipher != CIPH_CTR)
> +                       val |= AES_CTRL_OpDirection_Dec;
> +
> +               switch (ctx->key_len) {
> +               case AES_KEYSIZE_128:
> +                       val |= AES_CTRL_KeyMode_128bits;
> +                       break;
> +               case AES_KEYSIZE_192:
> +                       val |= AES_CTRL_KeyMode_192bits;
> +                       break;
> +               case AES_KEYSIZE_256:
> +                       val |= AES_CTRL_KeyMode_256bits;
> +                       break;
> +               }
> +               memcpy(sss->regs + AES_KEY, ctx->key, ctx->key_len);
> +
> +               writel(val, sss->regs + AES_CTRL);
> +
> +               writel(AES_BLOCK_SIZE / 4, sss->regs + FRx_BlkSz);
> +               writel(AES_BLOCK_SIZE / 4, sss->regs + FTx_BlkSz);
> +               writel(sss->regs_phys + AES_DIN, sss->regs + FRx_Addr);
> +               writel(sss->regs_phys + AES_DOUT, sss->regs + FTx_Addr);
> +
> +               break;
> +       case ALGO_DES:
> +       case ALGO_TDES:
> +               cfg |= DnI_CFG_DES_Intr_En;
> +               fifo_rx |= FXx_Ctrl_Module_DES;
> +               fifo_tx |= FXx_Ctrl_Module_DES;
> +
> +               switch (req_ctx->blk_cipher) {
> +               case CIPH_ECB:
> +                       val = TDES_CTRL_Mode_ECB;
> +                       break;
> +               case CIPH_CBC:
> +                       val = TDES_CTRL_Mode_CBC;
> +                       memcpy(sss->regs + TDES_IV, req->info, 16);
> +                       break;
> +               case CIPH_CTR:
> +                       /* NOP */
> +                       break;
> +               }
> +
> +               if (req_ctx->direction == DECRYPT)
> +                       val |= TDES_CTRL_OpDirection_Dec;
> +
> +               if (req_ctx->algorithm == ALGO_TDES)
> +                       val |= TDES_CTRL_Mode_Tdes;
> +
> +               val |= TDES_CTRL_IntMode;
> +
> +               memcpy(sss->regs + TDES_KEY, ctx->key, ctx->key_len);
> +
> +               writel(val, sss->regs + TDES_CTRL);
> +
> +               writel(DES_BLOCK_SIZE / 4, sss->regs + FRx_BlkSz);
> +               writel(DES_BLOCK_SIZE / 4, sss->regs + FTx_BlkSz);
> +               writel(sss->regs_phys + TDES_INPUT, sss->regs + FRx_Addr);
> +               writel(sss->regs_phys + TDES_OUTPUT, sss->regs + FTx_Addr);
> +
> +               break;
> +       case ALGO_SHA1:
> +       case ALGO_HMAC_SHA1:
> +               cfg |= DnI_CFG_SHA_Intr_En;
> +               fifo_rx |= FXx_Ctrl_Module_SHA;
> +               fifo_tx |= FXx_Ctrl_Module_SHA;
> +
> +               /*TODO*/
> +
> +               break;
> +       }
> +
> +       writel(cfg, sss->regs + DnI_CFG);
> +       writel(fifo_rx, sss->regs + FRx_Ctrl);
> +       writel(fifo_tx, sss->regs + FTx_Ctrl);
> +}
> +
> +static void sss_setup_hw_mlen(struct sss_fifo_channel *chan, size_t len)
> +{
> +       struct s3c_sss *sss = chan->dev;
> +
> +       if (chan->dir == FIFO_RX) {
> +               writel(len / 4, sss->regs + FRx_MLen);
> +               orrl(FXx_Ctrl_Start, sss->regs + FRx_Ctrl);
> +       } else {
> +               writel(len / 4, sss->regs + FTx_MLen);
> +               orrl(FXx_Ctrl_Start, sss->regs + FTx_Ctrl);
> +       }
> +}
> +
> +static int sss_setup_dma_channel(struct sss_fifo_channel *chan)
> +{
> +       struct s3c_sss *sss = chan->dev;
> +       unsigned int channel = fifo_to_dma_channel(chan);
> +       int ret;
> +
> +       if (chan->offset >= sg_dma_len(chan->cur_sg)) {
> +               chan->cur_sg = sg_next(chan->cur_sg);
> +               chan->offset = 0;
> +       }
> +
> +       chan->req_size = min(sg_dma_len(chan->cur_sg) - chan->offset,
> +                            SSS_FIFO_SIZE);
> +
> +       sss_setup_hw_mlen(chan, chan->req_size);
> +
> +       dev_dbg(sss->dev, "Enqueue'ing for FIFO_%cX: %x (%d)\n",
> +               channel == DMACH_SECURITY_TX ? 'T' : 'R',
> +               sg_dma_address(chan->cur_sg) + chan->offset, chan->req_size);
> +
> +       ret = s3c2410_dma_enqueue(channel, chan,
> +                                 sg_dma_address(chan->cur_sg) + chan->offset,
> +                                 chan->req_size);
> +       if (ret)
> +               return ret;
> +
> +       return s3c2410_dma_ctrl(fifo_to_dma_channel(chan), S3C2410_DMAOP_START);
> +}
> +
> +static void sss_setup_fifo(struct sss_fifo_channel *chan)
> +{
> +       struct s3c_sss *sss = chan->dev;
> +       struct ablkcipher_request *req = sss->cur_req;
> +       enum dma_data_direction dir;
> +       unsigned int sg_flags;
> +
> +       if (chan->dir == FIFO_RX) {
> +               sg_flags = SG_MITER_FROM_SG;
> +               chan->sg = req->src;
> +               dir = DMA_TO_DEVICE;
> +       } else {
> +               sg_flags = SG_MITER_TO_SG;
> +               chan->sg = req->dst;
> +               dir = DMA_FROM_DEVICE;
> +       }
> +
> +       if (sss_dma_enabled()) {
> +               int sg_count = count_sgs(chan->sg);
> +               chan->sg_count = dma_map_sg(sss->dev, chan->sg, sg_count, dir);
> +               chan->cur_sg = chan->sg;
> +
> +               s3c2410_dma_ctrl(fifo_to_dma_channel(chan),
> +                                S3C2410_DMAOP_FLUSH);
> +       }
> +}
> +
> +static int sss_handle_fifo(struct sss_fifo_channel *chan)
> +{
> +       struct s3c_sss *sss = chan->dev;
> +       struct ablkcipher_request *req = sss->cur_req;
> +       void __iomem *fifo;
> +
> +       if (chan->req_size)
> +               /* FIFO is still transferring data */
> +               return -EINPROGRESS;
> +
> +       if (sss_dma_enabled())
> +               return sss_setup_dma_channel(chan);
> +
> +       /* PIO */
> +       if (chan->dir == FIFO_RX)
> +               fifo = sss->regs + FRx_Buf;
> +       else
> +               fifo = sss->regs + FTx_Buf;
> +
> +       chan->req_size = min(req->nbytes - chan->bytes_done, SSS_FIFO_SIZE);
> +
> +       sss_setup_hw_mlen(chan, chan->req_size);
> +
> +       dev_dbg(sss->dev, "Transferring %d bytes to FIFO_%s\n", chan->req_size,
> +               chan->dir == FIFO_TX ? "TX" : "RX");
> +
> +       scatterwalk_map_and_copy(fifo, chan->sg, chan->bytes_done,
> +                                chan->req_size, (chan->dir == FIFO_TX));
> +
> +       if (chan->dir == FIFO_TX) {
> +               chan->bytes_done += chan->req_size;
> +               chan->req_size = 0;
> +       }
> +
> +       return 0;
> +}
> +
> +static void sss_cleanup_fifo(struct sss_fifo_channel *chan)
> +{
> +       struct s3c_sss *sss = chan->dev;
> +       enum dma_data_direction dir;
> +
> +       if (sss_dma_enabled()) {
> +               if (chan->dir == FIFO_RX)
> +                       dir = DMA_TO_DEVICE;
> +               else
> +                       dir = DMA_FROM_DEVICE;
> +
> +               dma_unmap_sg(sss->dev, chan->sg, chan->sg_count, dir);
> +
> +               s3c2410_dma_ctrl(fifo_to_dma_channel(chan), S3C2410_DMAOP_STOP);
> +       }
> +}
> +
> +static void sss_timer_callback(unsigned long priv)
> +{
> +       struct s3c_sss *sss = (struct s3c_sss *)priv;
> +       struct sss_req_context *req_ctx = sss_to_req_ctx(sss);
> +
> +       dev_err(sss->dev, "Request timed out!\n");
> +       req_ctx->err = -ETIMEDOUT;
> +
> +       tasklet_schedule(&sss->tasklet);
> +}
> +
> +static void sss_tasklet_callback(unsigned long priv)
> +{
> +       struct s3c_sss *sss = (struct s3c_sss *)priv;
> +       struct sss_req_context *req_ctx;
> +       struct ablkcipher_request *req;
> +       unsigned long flags;
> +
> +       if (!sss->cur_req) {
> +               spin_lock_irqsave(&sss->lock, flags);
> +               sss->cur_req = ablkcipher_dequeue_request(&sss->queue);
> +               spin_unlock_irqrestore(&sss->lock, flags);
> +
> +               if (!sss->cur_req) {
> +                       dev_warn(sss->dev, "Tasklet was called without any "
> +                                          "pending request!\n");
> +                       return;
> +               }
> +       }
> +
> +       /*TODO: backlog*/
> +
> +       req = sss->cur_req;
> +       req_ctx = ablkcipher_request_ctx(req);
> +
> +       dev_dbg(sss->dev, "Current request: %p (%d)\n", req, req->nbytes);
> +
> +       if (!req_ctx->setup_done) {
> +               clk_enable(sss->clock);
> +
> +               sss_setup_hw(sss);
> +               sss_setup_fifo(&req_ctx->rx);
> +               sss_setup_fifo(&req_ctx->tx);
> +
> +               req_ctx->setup_done = true;
> +       }
> +
> +       /* Ensure timeout handler is killed */
> +       if (timer_pending(&sss->timer))
> +               del_timer(&sss->timer);
> +
> +       if (!req_ctx->err && (req_ctx->rx.bytes_done < req->nbytes ||
> +                             req_ctx->tx.bytes_done < req->nbytes)) {
> +               int ret;
> +
> +               if (req_ctx->tx.bytes_done < req_ctx->rx.bytes_done)
> +                       /* Keep TX in sync with RX */
> +                       ret = sss_handle_fifo(&req_ctx->tx);
> +               else
> +                       /* Transmit some more data to RX */
> +                       ret = sss_handle_fifo(&req_ctx->rx);
> +
> +               sss_dump_channel(&req_ctx->tx);
> +               sss_dump_channel(&req_ctx->rx);
> +
> +               if (ret && ret != -EINPROGRESS) {
> +                       req_ctx->err = ret;
> +                       goto cleanup;
> +               }
> +
> +               mod_timer(&sss->timer, jiffies + SSS_TIMEOUT);
> +               return;
> +       }
> +
> +cleanup:
> +       sss_cleanup_fifo(&req_ctx->rx);
> +       sss_cleanup_fifo(&req_ctx->tx);
> +
> +       clk_disable(sss->clock);
> +
> +       /* Inform client of completion */
> +       req->base.complete(&req->base, req_ctx->err);
> +
> +       spin_lock_irqsave(&sss->lock, flags);
> +       sss->cur_req = NULL;
> +       /* Check whether there's still work to do */
> +       if (sss->queue.qlen || crypto_get_backlog(&sss->queue))
> +               tasklet_schedule(&sss->tasklet);
> +       spin_unlock_irqrestore(&sss->lock, flags);
> +}
> +
> +/*** SW handling ***/
> +
> +static int sss_crypto_generic(struct ablkcipher_request *req,
> +                             enum sss_algorithm alg,
> +                             enum sss_block_cipher blk_ciph,
> +                             enum sss_direction dir)
> +{
> +       struct sss_context *ctx = crypto_tfm_ctx(req->base.tfm);
> +       struct sss_req_context *req_ctx = ablkcipher_request_ctx(req);
> +       struct s3c_sss *sss = ctx->dev;
> +       unsigned long flags;
> +       int ret;
> +
> +       /* Fill the request */
> +       *req_ctx = (struct sss_req_context){
> +               .algorithm      = alg,
> +               .blk_cipher     = blk_ciph,
> +               .direction      = dir,
> +               .rx             = {
> +                               .dev = sss,
> +                               .dir = FIFO_RX,
> +               },
> +               .tx             = {
> +                               .dev = sss,
> +                               .dir = FIFO_TX,
> +               },
> +       };
> +
> +       /* Enqueue the request */
> +       spin_lock_irqsave(&sss->lock, flags);
> +       ret = ablkcipher_enqueue_request(&sss->queue, req);
> +       if (ret == -EINPROGRESS && !sss->cur_req)
> +               tasklet_schedule(&sss->tasklet);
> +       spin_unlock_irqrestore(&sss->lock, flags);
> +
> +       if (ret != -EINPROGRESS)
> +               dev_err(sss->dev, "Couldn't enqueue request!\n");
> +
> +       return ret;
> +}
> +
> +static int sss_aes_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
> +                         unsigned int len)
> +{
> +       struct crypto_tfm *tfm  = crypto_ablkcipher_tfm(cipher);
> +       struct sss_context *ctx = crypto_tfm_ctx(tfm);
> +
> +       switch (len) {
> +       case AES_KEYSIZE_128:
> +       case AES_KEYSIZE_192:
> +       case AES_KEYSIZE_256:
> +               break;
> +       default:
> +               crypto_ablkcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
> +               return -EINVAL;
> +       }
> +
> +       memcpy(ctx->key, key, len);
> +       ctx->key_len = len;
> +
> +       return 0;
> +}
> +
> +static int sss_des_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
> +                         unsigned int len)
> +{
> +       struct crypto_tfm *tfm  = crypto_ablkcipher_tfm(cipher);
> +       struct sss_context *ctx = crypto_tfm_ctx(tfm);
> +
> +       if (len > SSS_MAX_KEY_SIZE) {
> +               crypto_ablkcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
> +               return -EINVAL;
> +       }
> +
> +       /* RFC2451: weak key checks SHOULD be performed */
> +       if (len == DES_KEY_SIZE) {
> +               u32 tmp[DES_EXPKEY_WORDS];
> +               int ret = des_ekey(tmp, key);
> +
> +               if (unlikely(ret == 0) &&
> +                   (crypto_tfm_get_flags(tfm) & CRYPTO_TFM_REQ_WEAK_KEY)) {
> +                       crypto_tfm_set_flags(tfm, CRYPTO_TFM_RES_WEAK_KEY);
> +                       return -EINVAL;
> +               }
> +       }
> +
> +       memcpy(ctx->key, key, len);
> +       ctx->key_len = len;
> +
> +       return 0;
> +}
> +
> +static int sss_cra_init(struct crypto_tfm *tfm)
> +{
> +       struct sss_crypto_wrapper *wrapper = container_of(tfm->__crt_alg,
> +                                               struct sss_crypto_wrapper, alg);
> +       struct s3c_sss *sss = wrapper->dev;
> +       struct sss_context *ctx = crypto_tfm_ctx(tfm);
> +
> +       ctx->dev = sss;
> +       tfm->crt_ablkcipher.reqsize = sizeof(struct sss_req_context);
> +
> +       return 0;
> +}
> +
> +static int sss_aes_cbc_encrypt(struct ablkcipher_request *req)
> +{
> +       return sss_crypto_generic(req, ALGO_AES, CIPH_CBC, ENCRYPT);
> +}
> +
> +static int sss_aes_cbc_decrypt(struct ablkcipher_request *req)
> +{
> +       return sss_crypto_generic(req, ALGO_AES, CIPH_CBC, DECRYPT);
> +}
> +
> +static int sss_aes_ecb_encrypt(struct ablkcipher_request *req)
> +{
> +       return sss_crypto_generic(req, ALGO_AES, CIPH_ECB, ENCRYPT);
> +}
> +
> +static int sss_aes_ecb_decrypt(struct ablkcipher_request *req)
> +{
> +       return sss_crypto_generic(req, ALGO_AES, CIPH_ECB, DECRYPT);
> +}
> +
> +static int sss_aes_ctr_encrypt(struct ablkcipher_request *req)
> +{
> +       return sss_crypto_generic(req, ALGO_AES, CIPH_CTR, ENCRYPT);
> +}
> +
> +static int sss_aes_ctr_decrypt(struct ablkcipher_request *req)
> +{
> +       return sss_crypto_generic(req, ALGO_AES, CIPH_CTR, DECRYPT);
> +}
> +
> +static int sss_des_ecb_encrypt(struct ablkcipher_request *req)
> +{
> +       return sss_crypto_generic(req, ALGO_DES, CIPH_ECB, ENCRYPT);
> +}
> +
> +static int sss_des_ecb_decrypt(struct ablkcipher_request *req)
> +{
> +       return sss_crypto_generic(req, ALGO_DES, CIPH_ECB, DECRYPT);
> +}
> +
> +static int sss_des_cbc_encrypt(struct ablkcipher_request *req)
> +{
> +       return sss_crypto_generic(req, ALGO_DES, CIPH_CBC, ENCRYPT);
> +}
> +
> +static int sss_des_cbc_decrypt(struct ablkcipher_request *req)
> +{
> +       return sss_crypto_generic(req, ALGO_DES, CIPH_CBC, DECRYPT);
> +}
> +
> +static int sss_tdes_ecb_encrypt(struct ablkcipher_request *req)
> +{
> +       return sss_crypto_generic(req, ALGO_TDES, CIPH_ECB, ENCRYPT);
> +}
> +
> +static int sss_tdes_ecb_decrypt(struct ablkcipher_request *req)
> +{
> +       return sss_crypto_generic(req, ALGO_TDES, CIPH_ECB, DECRYPT);
> +}
> +
> +static int sss_tdes_cbc_encrypt(struct ablkcipher_request *req)
> +{
> +       return sss_crypto_generic(req, ALGO_TDES, CIPH_CBC, ENCRYPT);
> +}
> +
> +static int sss_tdes_cbc_decrypt(struct ablkcipher_request *req)
> +{
> +       return sss_crypto_generic(req, ALGO_TDES, CIPH_CBC, DECRYPT);
> +}
> +
> +static struct sss_algo_template {
> +       char                            *alg_name;
> +       char                            *blk_ciph_name;
> +       int                              blk_size;
> +       struct ablkcipher_alg            ablkcipher;
> +
> +       struct sss_crypto_wrapper       *alg;
> +} sss_crypto_algos[] = {
> +       /* AES ECB/CBC/CTR */
> +       {
> +               .alg_name = "aes",
> +               .blk_ciph_name = "ecb",
> +               .blk_size = AES_BLOCK_SIZE,
> +               .ablkcipher = {
> +                       .min_keysize    =       AES_MIN_KEY_SIZE,
> +                       .max_keysize    =       AES_MAX_KEY_SIZE,
> +                       .setkey         =       sss_aes_setkey,
> +                       .encrypt        =       sss_aes_ecb_encrypt,
> +                       .decrypt        =       sss_aes_ecb_decrypt,
> +               },
> +       },
> +       {
> +               .alg_name = "aes",
> +               .blk_ciph_name = "cbc",
> +               .blk_size = AES_BLOCK_SIZE,
> +               .ablkcipher = {
> +                       .ivsize         =       AES_BLOCK_SIZE,
> +                       .min_keysize    =       AES_MIN_KEY_SIZE,
> +                       .max_keysize    =       AES_MAX_KEY_SIZE,
> +                       .setkey         =       sss_aes_setkey,
> +                       .encrypt        =       sss_aes_cbc_encrypt,
> +                       .decrypt        =       sss_aes_cbc_decrypt,
> +               },
> +       },
> +       {
> +               .alg_name = "aes",
> +               .blk_ciph_name = "ctr",
> +               .blk_size = AES_BLOCK_SIZE,
> +               .ablkcipher = {
> +                       .ivsize         =       CTR_RFC3686_IV_SIZE,
> +                       .min_keysize    =       AES_MIN_KEY_SIZE,
> +                       .max_keysize    =       AES_MAX_KEY_SIZE,
> +                       .setkey         =       sss_aes_setkey,
> +                       .encrypt        =       sss_aes_ctr_encrypt,
> +                       .decrypt        =       sss_aes_ctr_decrypt,
> +               },
> +       },
> +       /* DES CBC/ECB */
> +       {
> +               .alg_name = "des",
> +               .blk_ciph_name = "cbc",
> +               .blk_size = DES_BLOCK_SIZE,
> +               .ablkcipher = {
> +                       .ivsize         =       DES_BLOCK_SIZE,
> +                       .min_keysize    =       DES_KEY_SIZE,
> +                       .max_keysize    =       DES_KEY_SIZE,
> +                       .setkey         =       sss_des_setkey,
> +                       .encrypt        =       sss_des_cbc_encrypt,
> +                       .decrypt        =       sss_des_cbc_decrypt,
> +               },
> +       },
> +       {
> +               .alg_name = "des",
> +               .blk_ciph_name = "ecb",
> +               .blk_size = DES_BLOCK_SIZE,
> +               .ablkcipher = {
> +                       .min_keysize    =       DES_KEY_SIZE,
> +                       .max_keysize    =       DES_KEY_SIZE,
> +                       .setkey         =       sss_des_setkey,
> +                       .encrypt        =       sss_des_ecb_encrypt,
> +                       .decrypt        =       sss_des_ecb_decrypt,
> +               },
> +       },
> +       /* TDES CBC/ECB */
> +       {
> +               .alg_name = "des3_ede",
> +               .blk_ciph_name = "cbc",
> +               .blk_size = DES3_EDE_BLOCK_SIZE,
> +               .ablkcipher = {
> +                       .ivsize         =       DES3_EDE_BLOCK_SIZE,
> +                       .min_keysize    =       DES3_EDE_KEY_SIZE,
> +                       .max_keysize    =       DES3_EDE_KEY_SIZE,
> +                       .setkey         =       sss_des_setkey,
> +                       .encrypt        =       sss_tdes_cbc_encrypt,
> +                       .decrypt        =       sss_tdes_cbc_decrypt,
> +               },
> +       },
> +       {
> +               .alg_name = "des3_ede",
> +               .blk_ciph_name = "ecb",
> +               .blk_size = DES3_EDE_BLOCK_SIZE,
> +               .ablkcipher = {
> +                       .min_keysize    =       DES3_EDE_KEY_SIZE,
> +                       .max_keysize    =       DES3_EDE_KEY_SIZE,
> +                       .setkey         =       sss_des_setkey,
> +                       .encrypt        =       sss_tdes_ecb_encrypt,
> +                       .decrypt        =       sss_tdes_ecb_decrypt,
> +               },
> +       },
> +};
> +
> +static int sss_init_template(struct platform_device *pdev,
> +                            struct sss_algo_template *templ)
> +{
> +       struct s3c_sss *sss = platform_get_drvdata(pdev);
> +       struct sss_crypto_wrapper *alg;
> +
> +       alg = kzalloc(sizeof(struct sss_crypto_wrapper), GFP_KERNEL);
> +       if (!alg)
> +               return -ENOMEM;
> +
> +       alg->dev = sss;
> +       alg->alg = (struct crypto_alg){
> +                       .cra_ablkcipher = templ->ablkcipher,
> +                       .cra_blocksize  = templ->blk_size,
> +                       .cra_ctxsize    = sizeof(struct sss_context),
> +                       .cra_flags      = CRYPTO_ALG_TYPE_ABLKCIPHER |
> +                                         CRYPTO_ALG_ASYNC,
> +                       .cra_init       = sss_cra_init,
> +                       .cra_module     = THIS_MODULE,
> +                       .cra_priority   = SSS_CRA_PRIORITY,
> +                       .cra_type       = &crypto_ablkcipher_type,
> +       };
> +
> +       snprintf(alg->alg.cra_name, CRYPTO_MAX_ALG_NAME, "%s(%s)",
> +                templ->blk_ciph_name, templ->alg_name);
> +       snprintf(alg->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s-%s-%s",
> +                pdev->name, templ->alg_name, templ->blk_ciph_name);
> +
> +       /* Save pointer for removal */
> +       templ->alg = alg;
> +
> +       dev_info(sss->dev, "crypto acceleration for %s", alg->alg.cra_name);
> +
> +       return 0;
> +}
> +
> +static struct ahash_alg sss_hash_algos[] = {
> +#if 0
> +       {
> +               .init           =       sss_sha_init,
> +               .update         =       sss_sha_update,
> +               .final          =       sss_sha1_final,
> +               .digest         =       sss_sha1_digest,
> +               .halg           =       {
> +                       .digestsize             =       SHA1_DIGEST_SIZE,
> +                       .statesize              =       sizeof(struct sha1_state),
> +                       .base                   =       {
> +                               .cra_name               =       "sha1",
> +                               .cra_driver_name        =       "s3c-sss-sha1",
> +                               .cra_priority           =       SSS_CRA_PRIORITY,
> +                               .cra_flags              =       CRYPTO_ALG_TYPE_AHASH |
> +                                                               CRYPTO_ALG_ASYNC,
> +                               .cra_blocksize          =       SHA1_BLOCK_SIZE,
> +                               .cra_ctxsize            =       sizeof(struct sss_context),
> +                               .cra_type               =       &crypto_ahash_type,
> +                               .cra_module             =       THIS_MODULE,
> +                               .cra_init               =       sss_cra_init,
> +                       }
> +               },
> +       },
> +       {
> +               .init           =       sss_sha_init,
> +               .update         =       sss_sha_update,
> +               .final          =       sss_sha1_final,
> +               .digest         =       sss_sha1_digest,
> +               .setkey         =       sss_sha1_setkey,
> +               .halg           =       {
> +                       .digestsize             =       SHA1_DIGEST_SIZE,
> +                       .statesize              =       sizeof(struct sha1_state),
> +                       .base                   =       {
> +                               .cra_name               =       "hmac(sha1)",
> +                               .cra_driver_name        =       "s3c-sss-hmac-sha1",
> +                               .cra_priority           =       SSS_CRA_PRIORITY,
> +                               .cra_flags              =       CRYPTO_ALG_TYPE_AHASH |
> +                                                               CRYPTO_ALG_ASYNC,
> +                               .cra_blocksize          =       SHA1_BLOCK_SIZE,
> +                               .cra_ctxsize            =       sizeof(struct sss_context),
> +                               .cra_type               =       &crypto_ahash_type,
> +                               .cra_module             =       THIS_MODULE,
> +                               .cra_init               =       sss_cra_init,
> +                       }
> +               },
> +       },
> +#endif
> +};
> +
> +static void sss_unregister_algos(void)
> +{
> +       struct sss_crypto_wrapper *alg;
> +       int i;
> +
> +       for (i = 0; i < ARRAY_SIZE(sss_crypto_algos); i++) {
> +               alg = sss_crypto_algos[i].alg;
> +
> +               if (alg) {
> +                       crypto_unregister_alg(&alg->alg);
> +                       kfree(alg);
> +
> +                       sss_crypto_algos[i].alg = NULL;
> +               }
> +       }
> +
> +       /* Unregistering algorithms that weren't registered in the first place
> +          doesn't do any harm, so just do it for all. */
> +       for (i = 0; i < ARRAY_SIZE(sss_hash_algos); i++)
> +               crypto_unregister_ahash(&sss_hash_algos[i]);
> +}
> +
> +static int sss_register_algos(struct platform_device *pdev)
> +{
> +       int i, ret;
> +
> +       for (i = 0; i < ARRAY_SIZE(sss_crypto_algos); i++) {
> +               ret = sss_init_template(pdev, &sss_crypto_algos[i]);
> +               if (ret)
> +                       goto exit;
> +
> +               ret = crypto_register_alg(&sss_crypto_algos[i].alg->alg);
> +               if (ret)
> +                       goto exit;
> +       }
> +
> +       for (i = 0; i < ARRAY_SIZE(sss_hash_algos); i++) {
> +               ret = crypto_register_ahash(&sss_hash_algos[i]);
> +               if (ret)
> +                       goto exit;
> +       }
> +
> +       return 0;
> +
> +exit:
> +       sss_unregister_algos();
> +       return ret;
> +}
> +
> +static int __devinit sss_probe(struct platform_device *pdev)
> +{
> +       struct device *dev = &pdev->dev;
> +       struct resource *res;
> +       struct s3c_sss *sss;
> +       int ret;
> +
> +       sss = kzalloc(sizeof(struct s3c_sss), GFP_KERNEL);
> +       if (!sss) {
> +               dev_err(dev, "cannot allocate memory\n");
> +               return -ENOMEM;
> +       }
> +
> +       spin_lock_init(&sss->lock);
> +       crypto_init_queue(&sss->queue, 50);
> +       tasklet_init(&sss->tasklet, sss_tasklet_callback, (unsigned long) sss);
> +       setup_timer(&sss->timer, sss_timer_callback, (unsigned long) sss);
> +
> +       sss->dev = dev;
> +       sss->dma_client.name = (char *) pdev->name;
> +       platform_set_drvdata(pdev, sss);
> +
> +       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> +       if (!res) {
> +               dev_err(dev, "cannot find register resource\n");
> +               ret = -EINVAL;
> +               goto exit_dev;
> +       }
> +
> +       sss->regs_res = request_mem_region(res->start, resource_size(res),
> +                                          dev_name(dev));
> +       if (!sss->regs_res) {
> +               dev_err(dev, "cannot request register resource\n");
> +               ret = -ENOENT;
> +               goto exit_dev;
> +       }
> +
> +       sss->regs_phys = (void __iomem *) res->start;
> +
> +       sss->regs = ioremap(res->start, resource_size(res));
> +       if (!sss->regs) {
> +               dev_err(dev, "cannot map registers\n");
> +               ret = -ENXIO;
> +               goto exit_resource;
> +       }
> +
> +       ret = platform_get_irq(pdev, 0);
> +       if (ret < 0 || ret == NO_IRQ) {
> +               dev_err(dev, "cannot find IRQ\n");
> +               goto exit_regs_remap;
> +       }
> +
> +       sss->irq = ret;
> +
> +       ret = request_irq(sss->irq, sss_irq, 0, dev_name(dev), sss);
> +       if (ret < 0) {
> +               dev_err(dev, "cannot claim IRQ\n");
> +               goto exit_regs_remap;
> +       }
> +
> +       sss->clock = clk_get(dev, "secur");
> +       if (!sss->clock) {
> +               dev_err(dev, "cannot find clock\n");
> +               ret = -ENXIO;
> +               goto exit_irq;
> +       }
> +
> +       WARN_ON(clk_set_rate(sss->clock, 66*1000000)); /*REMOVEME*/
> +
> +       if (sss_dma_enabled()) {
> +               ret = sss_setup_dma(sss, DMACH_SECURITY_RX);
> +               if (ret < 0) {
> +                       dev_err(dev, "cannot setup SECURITY_RX DMA channel\n");
> +                       goto exit_clock;
> +               }
> +
> +               ret = sss_setup_dma(sss, DMACH_SECURITY_TX);
> +               if (ret < 0) {
> +                       dev_err(dev, "cannot setup SECURITY_TX DMA channel\n");
> +                       goto exit_dma_rx;
> +               }
> +       }
> +
> +       ret = sss_register_algos(pdev);
> +       if (ret) {
> +               dev_err(dev, "cannot register algos\n");
> +               goto exit_dma_tx;
> +       }
> +
> +       return 0;
> +
> +exit_dma_tx:
> +       if (sss_dma_enabled())
> +               s3c2410_dma_free(DMACH_SECURITY_TX, &sss->dma_client);
> +exit_dma_rx:
> +       if (sss_dma_enabled())
> +               s3c2410_dma_free(DMACH_SECURITY_RX, &sss->dma_client);
> +exit_clock:
> +       clk_put(sss->clock);
> +exit_irq:
> +       free_irq(sss->irq, sss);
> +exit_regs_remap:
> +       iounmap(sss->regs);
> +exit_resource:
> +       release_resource(sss->regs_res);
> +       kfree(sss->regs_res);
> +exit_dev:
> +       tasklet_kill(&sss->tasklet);
> +       kfree(sss);
> +
> +       return ret;
> +}
> +
> +static int __devexit sss_remove(struct platform_device *pdev)
> +{
> +       struct s3c_sss *sss = platform_get_drvdata(pdev);
> +
> +       if (timer_pending(&sss->timer))
> +               del_timer(&sss->timer);
> +
> +       if (sss_dma_enabled()) {
> +               s3c2410_dma_free(DMACH_SECURITY_TX, &sss->dma_client);
> +               s3c2410_dma_free(DMACH_SECURITY_RX, &sss->dma_client);
> +       }
> +
> +       sss_unregister_algos();
> +       clk_put(sss->clock);
> +       free_irq(sss->irq, sss);
> +       iounmap(sss->regs);
> +       release_resource(sss->regs_res);
> +       kfree(sss->regs_res);
> +       tasklet_kill(&sss->tasklet);
> +       kfree(sss);
> +
> +       return 0;
> +}
> +
> +static struct platform_driver sss_crypto = {
> +       .driver         = {
> +               .name   = "s3c-sss",
> +               .owner  = THIS_MODULE,
> +       },
> +       .probe          = sss_probe,
> +       .remove         = __devexit_p(sss_remove),
> +};
> +
> +static int __init sss_crypto_init(void)
> +{
> +       return platform_driver_register(&sss_crypto);
> +}
> +module_init(sss_crypto_init);
> +
> +static void __exit sss_crypto_exit(void)
> +{
> +       platform_driver_unregister(&sss_crypto);
> +}
> +module_exit(sss_crypto_exit);
> +
> +MODULE_AUTHOR("Maurus Cuelenaere <mcuelenaere@xxxxxxxxx>");
> +MODULE_DESCRIPTION("Support for Samsung's Security Sub-Systems");
> +MODULE_LICENSE("GPL");
> +MODULE_ALIAS("platform:sss_crypto");
> --
> 1.7.1
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-samsung-soc" in
> the body of a message to majordomo@xxxxxxxxxxxxxxx
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>
--
To unsubscribe from this list: send the line "unsubscribe linux-crypto" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html


[Index of Archives]     [Kernel]     [Gnu Classpath]     [Gnu Crypto]     [DM Crypt]     [Netfilter]     [Bugtraq]

  Powered by Linux