31935736acdfc798fa3b33644d1b9e939ff371da
[linux-3.10.git] / drivers / crypto / tegra-se.c
1 /*
2  * Cryptographic API.
3  * drivers/crypto/tegra-se.c
4  *
5  * Support for Tegra Security Engine hardware crypto algorithms.
6  *
7  * Copyright (c) 2011-2013, NVIDIA Corporation. All Rights Reserved.
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  * This program is distributed in the hope that it will be useful, but WITHOUT
15  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
17  * more details.
18  *
19  * You should have received a copy of the GNU General Public License along
20  * with this program; if not, write to the Free Software Foundation, Inc.,
21  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
22  */
23
24 #include <linux/module.h>
25 #include <linux/init.h>
26 #include <linux/errno.h>
27 #include <linux/kernel.h>
28 #include <linux/clk.h>
29 #include <linux/platform_device.h>
30 #include <linux/scatterlist.h>
31 #include <linux/dma-mapping.h>
32 #include <linux/io.h>
33 #include <linux/mutex.h>
34 #include <linux/interrupt.h>
35 #include <linux/types.h>
36 #include <linux/errno.h>
37 #include <crypto/scatterwalk.h>
38 #include <crypto/algapi.h>
39 #include <crypto/aes.h>
40 #include <crypto/internal/rng.h>
41 #include <crypto/internal/hash.h>
42 #include <crypto/sha.h>
43 #include <linux/pm_runtime.h>
44 #include <mach/hardware.h>
45
46 #include <mach/pm_domains.h>
47
48 #include "tegra-se.h"
49
50 #define DRIVER_NAME     "tegra-se"
51
52 /* Security Engine operation modes */
53 enum tegra_se_aes_op_mode {
54         SE_AES_OP_MODE_CBC,     /* Cipher Block Chaining (CBC) mode */
55         SE_AES_OP_MODE_ECB,     /* Electronic Codebook (ECB) mode */
56         SE_AES_OP_MODE_CTR,     /* Counter (CTR) mode */
57         SE_AES_OP_MODE_OFB,     /* Output feedback (CFB) mode */
58         SE_AES_OP_MODE_RNG_X931,        /* Random number generator (RNG) mode */
59         SE_AES_OP_MODE_RNG_DRBG,        /* Deterministic Random Bit Generator */
60         SE_AES_OP_MODE_CMAC,    /* Cipher-based MAC (CMAC) mode */
61         SE_AES_OP_MODE_SHA1,    /* Secure Hash Algorithm-1 (SHA1) mode */
62         SE_AES_OP_MODE_SHA224,  /* Secure Hash Algorithm-224  (SHA224) mode */
63         SE_AES_OP_MODE_SHA256,  /* Secure Hash Algorithm-256  (SHA256) mode */
64         SE_AES_OP_MODE_SHA384,  /* Secure Hash Algorithm-384  (SHA384) mode */
65         SE_AES_OP_MODE_SHA512   /* Secure Hash Algorithm-512  (SHA512) mode */
66 };
67
68 /* Security Engine key table type */
69 enum tegra_se_key_table_type {
70         SE_KEY_TABLE_TYPE_KEY,  /* Key */
71         SE_KEY_TABLE_TYPE_ORGIV,        /* Original IV */
72         SE_KEY_TABLE_TYPE_UPDTDIV       /* Updated IV */
73 };
74
75 /* Security Engine request context */
76 struct tegra_se_req_context {
77         enum tegra_se_aes_op_mode op_mode; /* Security Engine operation mode */
78         bool encrypt;   /* Operation type */
79 };
80
81 struct tegra_se_chipdata {
82         bool cprng_supported;
83         bool drbg_supported;
84         bool rsa_supported;
85         unsigned long aes_freq;
86         unsigned long rng_freq;
87         unsigned long sha1_freq;
88         unsigned long sha224_freq;
89         unsigned long sha256_freq;
90         unsigned long sha384_freq;
91         unsigned long sha512_freq;
92         unsigned long rsa_freq;
93 };
94
95 struct tegra_se_dev {
96         struct device *dev;
97         void __iomem *io_reg;   /* se device memory/io */
98         void __iomem *pmc_io_reg;       /* pmc device memory/io */
99         int irq;        /* irq allocated */
100         spinlock_t lock;        /* spin lock */
101         struct clk *pclk;       /* Security Engine clock */
102         struct crypto_queue queue; /* Security Engine crypto queue */
103         struct tegra_se_slot *slot_list;        /* pointer to key slots */
104         struct tegra_se_rsa_slot *rsa_slot_list; /* rsa key slot pointer */
105         u64 ctr;
106         u32 *src_ll_buf;        /* pointer to source linked list buffer */
107         dma_addr_t src_ll_buf_adr; /* Source linked list buffer dma address */
108         u32 src_ll_size;        /* Size of source linked list buffer */
109         u32 *dst_ll_buf;        /* pointer to destination linked list buffer */
110         dma_addr_t dst_ll_buf_adr; /* Destination linked list dma address */
111         u32 dst_ll_size;        /* Size of destination linked list buffer */
112         u32 *ctx_save_buf;      /* LP context buffer pointer*/
113         dma_addr_t ctx_save_buf_adr;    /* LP context buffer dma address*/
114         struct completion complete;     /* Tells the task completion */
115         bool work_q_busy;       /* Work queue busy status */
116         struct tegra_se_chipdata *chipdata; /* chip specific data */
117 };
118
119 static struct tegra_se_dev *sg_tegra_se_dev;
120
121 /* Security Engine AES context */
122 struct tegra_se_aes_context {
123         struct tegra_se_dev *se_dev;    /* Security Engine device */
124         struct tegra_se_slot *slot;     /* Security Engine key slot */
125         u32 keylen;     /* key length in bits */
126         u32 op_mode;    /* AES operation mode */
127 };
128
129 /* Security Engine random number generator context */
130 struct tegra_se_rng_context {
131         struct tegra_se_dev *se_dev;    /* Security Engine device */
132         struct tegra_se_slot *slot;     /* Security Engine key slot */
133         u32 *dt_buf;    /* Destination buffer pointer */
134         dma_addr_t dt_buf_adr;  /* Destination buffer dma address */
135         u32 *rng_buf;   /* RNG buffer pointer */
136         dma_addr_t rng_buf_adr; /* RNG buffer dma address */
137         bool use_org_iv;        /* Tells whether original IV is be used
138                                 or not. If it is false updated IV is used*/
139 };
140
141 /* Security Engine SHA context */
142 struct tegra_se_sha_context {
143         struct tegra_se_dev     *se_dev;        /* Security Engine device */
144         u32 op_mode;    /* SHA operation mode */
145 };
146
147 /* Security Engine AES CMAC context */
148 struct tegra_se_aes_cmac_context {
149         struct tegra_se_dev *se_dev;    /* Security Engine device */
150         struct tegra_se_slot *slot;     /* Security Engine key slot */
151         u32 keylen;     /* key length in bits */
152         u8 K1[TEGRA_SE_KEY_128_SIZE];   /* Key1 */
153         u8 K2[TEGRA_SE_KEY_128_SIZE];   /* Key2 */
154         dma_addr_t dma_addr;    /* DMA address of local buffer */
155         u32 buflen;     /* local buffer length */
156         u8      *buffer;        /* local buffer pointer */
157 };
158
159 /* Security Engine key slot */
160 struct tegra_se_slot {
161         struct list_head node;
162         u8 slot_num;    /* Key slot number */
163         bool available; /* Tells whether key slot is free to use */
164 };
165
166 static struct tegra_se_slot ssk_slot = {
167         .slot_num = 15,
168         .available = false,
169 };
170
171 static struct tegra_se_slot srk_slot = {
172         .slot_num = 0,
173         .available = false,
174 };
175
176 /* Security Engine Linked List */
177 struct tegra_se_ll {
178         dma_addr_t addr; /* DMA buffer address */
179         u32 data_len; /* Data length in DMA buffer */
180 };
181
182 static LIST_HEAD(key_slot);
183 static LIST_HEAD(rsa_key_slot);
184 static DEFINE_SPINLOCK(rsa_key_slot_lock);
185
186 #define RSA_MIN_SIZE    64
187 #define RSA_MAX_SIZE    256
188 #define RNG_RESEED_INTERVAL     100
189 #define TEGRA_SE_RSA_CONTEXT_SAVE_KEYSLOT_COUNT 4
190
191 static DEFINE_SPINLOCK(key_slot_lock);
192 static DEFINE_MUTEX(se_hw_lock);
193
194 /* create a work for handling the async transfers */
195 static void tegra_se_work_handler(struct work_struct *work);
196 static DECLARE_WORK(se_work, tegra_se_work_handler);
197 static struct workqueue_struct *se_work_q;
198
199 #define PMC_SCRATCH43_REG_OFFSET 0x22c
200 #define GET_MSB(x)  ((x) >> (8*sizeof(x)-1))
201 static int force_reseed_count;
202 static int drbg_ro_entropy_src_enabled;
203 static void tegra_se_leftshift_onebit(u8 *in_buf, u32 size, u8 *org_msb)
204 {
205         u8 carry;
206         u32 i;
207
208         *org_msb = GET_MSB(in_buf[0]);
209
210         /* left shift one bit */
211         in_buf[0] <<= 1;
212         for (carry = 0, i = 1; i < size; i++) {
213                 carry = GET_MSB(in_buf[i]);
214                 in_buf[i-1] |= carry;
215                 in_buf[i] <<= 1;
216         }
217 }
218
219 extern unsigned long long tegra_chip_uid(void);
220
221 static inline void se_writel(struct tegra_se_dev *se_dev,
222         unsigned int val, unsigned int reg_offset)
223 {
224         writel(val, se_dev->io_reg + reg_offset);
225 }
226
227 static inline unsigned int se_readl(struct tegra_se_dev *se_dev,
228         unsigned int reg_offset)
229 {
230         unsigned int val;
231
232         val = readl(se_dev->io_reg + reg_offset);
233
234         return val;
235 }
236
237 static void tegra_se_free_key_slot(struct tegra_se_slot *slot)
238 {
239         if (slot) {
240                 spin_lock(&key_slot_lock);
241                 slot->available = true;
242                 spin_unlock(&key_slot_lock);
243         }
244 }
245
246 static struct tegra_se_slot *tegra_se_alloc_key_slot(void)
247 {
248         struct tegra_se_slot *slot = NULL;
249         bool found = false;
250
251         spin_lock(&key_slot_lock);
252         list_for_each_entry(slot, &key_slot, node) {
253                 if (slot->available) {
254                         slot->available = false;
255                         found = true;
256                         break;
257                 }
258         }
259         spin_unlock(&key_slot_lock);
260         return found ? slot : NULL;
261 }
262
263 static int tegra_init_key_slot(struct tegra_se_dev *se_dev)
264 {
265         int i;
266
267         se_dev->slot_list = kzalloc(sizeof(struct tegra_se_slot) *
268                                         TEGRA_SE_KEYSLOT_COUNT, GFP_KERNEL);
269         if (se_dev->slot_list == NULL) {
270                 dev_err(se_dev->dev, "slot list memory allocation failed\n");
271                 return -ENOMEM;
272         }
273         spin_lock_init(&key_slot_lock);
274         spin_lock(&key_slot_lock);
275         for (i = 0; i < TEGRA_SE_KEYSLOT_COUNT; i++) {
276                 /*
277                  * Slot 0 and 15 are reserved and will not be added to the
278                  * free slots pool. Slot 0 is used for SRK generation and
279                  * Slot 15 is used for SSK operation
280                  */
281                 if ((i == srk_slot.slot_num) || (i == ssk_slot.slot_num))
282                         continue;
283                 se_dev->slot_list[i].available = true;
284                 se_dev->slot_list[i].slot_num = i;
285                 INIT_LIST_HEAD(&se_dev->slot_list[i].node);
286                 list_add_tail(&se_dev->slot_list[i].node, &key_slot);
287         }
288         spin_unlock(&key_slot_lock);
289
290         return 0;
291 }
292
293 static void tegra_se_key_read_disable(u8 slot_num)
294 {
295         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
296         u32 val;
297
298         val = se_readl(se_dev,
299                         (SE_KEY_TABLE_ACCESS_REG_OFFSET + (slot_num * 4)));
300         val &= ~(1 << SE_KEY_READ_DISABLE_SHIFT);
301         se_writel(se_dev,
302                 val, (SE_KEY_TABLE_ACCESS_REG_OFFSET + (slot_num * 4)));
303 }
304
305 static void tegra_se_key_read_disable_all(void)
306 {
307         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
308         u8 slot_num;
309
310         mutex_lock(&se_hw_lock);
311         pm_runtime_get_sync(se_dev->dev);
312
313         for (slot_num = 0; slot_num < TEGRA_SE_KEYSLOT_COUNT; slot_num++)
314                 tegra_se_key_read_disable(slot_num);
315
316         pm_runtime_put(se_dev->dev);
317         mutex_unlock(&se_hw_lock);
318 }
319
320 static void tegra_se_config_algo(struct tegra_se_dev *se_dev,
321         enum tegra_se_aes_op_mode mode, bool encrypt, u32 key_len)
322 {
323         u32 val = 0;
324
325         switch (mode) {
326         case SE_AES_OP_MODE_CBC:
327         case SE_AES_OP_MODE_CMAC:
328                 if (encrypt) {
329                         val = SE_CONFIG_ENC_ALG(ALG_AES_ENC);
330                         if (key_len == TEGRA_SE_KEY_256_SIZE)
331                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY256);
332                         else if (key_len == TEGRA_SE_KEY_192_SIZE)
333                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY192);
334                         else
335                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY128);
336                         val |= SE_CONFIG_DEC_ALG(ALG_NOP);
337                 } else {
338                         val = SE_CONFIG_DEC_ALG(ALG_AES_DEC);
339                         if (key_len == TEGRA_SE_KEY_256_SIZE)
340                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY256);
341                         else if (key_len == TEGRA_SE_KEY_192_SIZE)
342                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY192);
343                         else
344                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY128);
345                 }
346                 if (mode == SE_AES_OP_MODE_CMAC)
347                         val |= SE_CONFIG_DST(DST_HASHREG);
348                 else
349                         val |= SE_CONFIG_DST(DST_MEMORY);
350                 break;
351         case SE_AES_OP_MODE_RNG_X931:
352         case SE_AES_OP_MODE_RNG_DRBG:
353                 val = SE_CONFIG_ENC_ALG(ALG_RNG) |
354                         SE_CONFIG_ENC_MODE(MODE_KEY128) |
355                                 SE_CONFIG_DST(DST_MEMORY);
356                 break;
357         case SE_AES_OP_MODE_ECB:
358                 if (encrypt) {
359                         val = SE_CONFIG_ENC_ALG(ALG_AES_ENC);
360                         if (key_len == TEGRA_SE_KEY_256_SIZE)
361                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY256);
362                         else if (key_len == TEGRA_SE_KEY_192_SIZE)
363                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY192);
364                         else
365                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY128);
366                 } else {
367                         val = SE_CONFIG_DEC_ALG(ALG_AES_DEC);
368                         if (key_len == TEGRA_SE_KEY_256_SIZE)
369                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY256);
370                         else if (key_len == TEGRA_SE_KEY_192_SIZE)
371                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY192);
372                         else
373                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY128);
374                 }
375                 val |= SE_CONFIG_DST(DST_MEMORY);
376                 break;
377         case SE_AES_OP_MODE_CTR:
378                 if (encrypt) {
379                         val = SE_CONFIG_ENC_ALG(ALG_AES_ENC);
380                         if (key_len == TEGRA_SE_KEY_256_SIZE)
381                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY256);
382                         else if (key_len == TEGRA_SE_KEY_192_SIZE)
383                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY192);
384                         else
385                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY128);
386                 } else {
387                         val = SE_CONFIG_DEC_ALG(ALG_AES_DEC);
388                         if (key_len == TEGRA_SE_KEY_256_SIZE) {
389                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY256);
390                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY256);
391                         } else if (key_len == TEGRA_SE_KEY_192_SIZE) {
392                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY192);
393                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY192);
394                         } else {
395                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY128);
396                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY128);
397                         }
398                 }
399                 val |= SE_CONFIG_DST(DST_MEMORY);
400                 break;
401         case SE_AES_OP_MODE_OFB:
402                 if (encrypt) {
403                         val = SE_CONFIG_ENC_ALG(ALG_AES_ENC);
404                         if (key_len == TEGRA_SE_KEY_256_SIZE)
405                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY256);
406                         else if (key_len == TEGRA_SE_KEY_192_SIZE)
407                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY192);
408                         else
409                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY128);
410                 } else {
411                         val = SE_CONFIG_DEC_ALG(ALG_AES_DEC);
412                         if (key_len == TEGRA_SE_KEY_256_SIZE) {
413                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY256);
414                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY256);
415                         } else if (key_len == TEGRA_SE_KEY_192_SIZE) {
416                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY192);
417                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY192);
418                         } else {
419                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY128);
420                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY128);
421                         }
422                 }
423                 val |= SE_CONFIG_DST(DST_MEMORY);
424                 break;
425         case SE_AES_OP_MODE_SHA1:
426                 val = SE_CONFIG_ENC_ALG(ALG_SHA) |
427                         SE_CONFIG_ENC_MODE(MODE_SHA1) |
428                                 SE_CONFIG_DST(DST_HASHREG);
429                 break;
430         case SE_AES_OP_MODE_SHA224:
431                 val = SE_CONFIG_ENC_ALG(ALG_SHA) |
432                         SE_CONFIG_ENC_MODE(MODE_SHA224) |
433                                 SE_CONFIG_DST(DST_HASHREG);
434                 break;
435         case SE_AES_OP_MODE_SHA256:
436                 val = SE_CONFIG_ENC_ALG(ALG_SHA) |
437                         SE_CONFIG_ENC_MODE(MODE_SHA256) |
438                                 SE_CONFIG_DST(DST_HASHREG);
439                 break;
440         case SE_AES_OP_MODE_SHA384:
441                 val = SE_CONFIG_ENC_ALG(ALG_SHA) |
442                         SE_CONFIG_ENC_MODE(MODE_SHA384) |
443                                 SE_CONFIG_DST(DST_HASHREG);
444                 break;
445         case SE_AES_OP_MODE_SHA512:
446                 val = SE_CONFIG_ENC_ALG(ALG_SHA) |
447                         SE_CONFIG_ENC_MODE(MODE_SHA512) |
448                                 SE_CONFIG_DST(DST_HASHREG);
449                 break;
450         default:
451                 dev_warn(se_dev->dev, "Invalid operation mode\n");
452                 break;
453         }
454
455         se_writel(se_dev, val, SE_CONFIG_REG_OFFSET);
456 }
457
458 static void tegra_se_write_seed(struct tegra_se_dev *se_dev, u32 *pdata)
459 {
460         u32 i;
461
462         for (i = 0; i < SE_CRYPTO_CTR_REG_COUNT; i++)
463                 se_writel(se_dev, pdata[i], SE_CRYPTO_CTR_REG_OFFSET + (i * 4));
464 }
465
466 static void tegra_se_write_key_table(u8 *pdata, u32 data_len,
467         u8 slot_num, enum tegra_se_key_table_type type)
468 {
469         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
470         u32 data_size = SE_KEYTABLE_REG_MAX_DATA;
471         u32 *pdata_buf = (u32 *)pdata;
472         u8 pkt = 0, quad = 0;
473         u32 val = 0, i;
474
475         if (pdata_buf == NULL)
476                 return;
477
478         if ((type == SE_KEY_TABLE_TYPE_KEY) && (slot_num == ssk_slot.slot_num))
479                 return;
480
481         if (type == SE_KEY_TABLE_TYPE_ORGIV)
482                 quad = QUAD_ORG_IV;
483         else if (type == SE_KEY_TABLE_TYPE_UPDTDIV)
484                 quad = QUAD_UPDTD_IV;
485         else
486                 quad = QUAD_KEYS_128;
487
488         /* write data to the key table */
489         do {
490                 for (i = 0; i < data_size; i += 4, data_len -= 4)
491                         se_writel(se_dev, *pdata_buf++,
492                                 SE_KEYTABLE_DATA0_REG_OFFSET + i);
493
494                 pkt = SE_KEYTABLE_SLOT(slot_num) | SE_KEYTABLE_QUAD(quad);
495                 val = SE_KEYTABLE_OP_TYPE(OP_WRITE) |
496                         SE_KEYTABLE_TABLE_SEL(TABLE_KEYIV) |
497                                 SE_KEYTABLE_PKT(pkt);
498
499                 se_writel(se_dev, val, SE_KEYTABLE_REG_OFFSET);
500
501                 data_size = data_len;
502                 quad = QUAD_KEYS_256;
503
504         } while (data_len);
505 }
506
507 static void tegra_se_config_crypto(struct tegra_se_dev *se_dev,
508         enum tegra_se_aes_op_mode mode, bool encrypt, u8 slot_num, bool org_iv)
509 {
510         u32 val = 0;
511         unsigned long freq = 0;
512         int err = 0;
513
514         switch (mode) {
515         case SE_AES_OP_MODE_CMAC:
516         case SE_AES_OP_MODE_CBC:
517                 if (encrypt) {
518                         val = SE_CRYPTO_INPUT_SEL(INPUT_AHB) |
519                                 SE_CRYPTO_VCTRAM_SEL(VCTRAM_AESOUT) |
520                                 SE_CRYPTO_XOR_POS(XOR_TOP) |
521                                 SE_CRYPTO_CORE_SEL(CORE_ENCRYPT);
522                 } else {
523                         val = SE_CRYPTO_INPUT_SEL(INPUT_AHB) |
524                                 SE_CRYPTO_VCTRAM_SEL(VCTRAM_PREVAHB) |
525                                 SE_CRYPTO_XOR_POS(XOR_BOTTOM) |
526                                 SE_CRYPTO_CORE_SEL(CORE_DECRYPT);
527                 }
528                 freq = se_dev->chipdata->aes_freq;
529                 break;
530         case SE_AES_OP_MODE_RNG_X931:
531                 val = SE_CRYPTO_INPUT_SEL(INPUT_AHB) |
532                         SE_CRYPTO_XOR_POS(XOR_BYPASS) |
533                         SE_CRYPTO_CORE_SEL(CORE_ENCRYPT);
534                 freq = se_dev->chipdata->rng_freq;
535                 break;
536         case SE_AES_OP_MODE_RNG_DRBG:
537                 val = SE_CRYPTO_INPUT_SEL(INPUT_RANDOM) |
538                         SE_CRYPTO_XOR_POS(XOR_BYPASS) |
539                         SE_CRYPTO_CORE_SEL(CORE_ENCRYPT);
540                 if ((tegra_get_chipid() == TEGRA_CHIPID_TEGRA11))
541                         val = val | SE_CRYPTO_KEY_INDEX(slot_num);
542                 freq = se_dev->chipdata->rng_freq;
543                 break;
544         case SE_AES_OP_MODE_ECB:
545                 if (encrypt) {
546                         val = SE_CRYPTO_INPUT_SEL(INPUT_AHB) |
547                                 SE_CRYPTO_XOR_POS(XOR_BYPASS) |
548                                 SE_CRYPTO_CORE_SEL(CORE_ENCRYPT);
549                 } else {
550                         val = SE_CRYPTO_INPUT_SEL(INPUT_AHB) |
551                                 SE_CRYPTO_XOR_POS(XOR_BYPASS) |
552                                 SE_CRYPTO_CORE_SEL(CORE_DECRYPT);
553                 }
554                 freq = se_dev->chipdata->aes_freq;
555                 break;
556         case SE_AES_OP_MODE_CTR:
557                 val = SE_CRYPTO_INPUT_SEL(INPUT_LNR_CTR) |
558                         SE_CRYPTO_VCTRAM_SEL(VCTRAM_AHB) |
559                         SE_CRYPTO_XOR_POS(XOR_BOTTOM) |
560                         SE_CRYPTO_CORE_SEL(CORE_ENCRYPT);
561                 freq = se_dev->chipdata->aes_freq;
562                 break;
563         case SE_AES_OP_MODE_OFB:
564                 val = SE_CRYPTO_INPUT_SEL(INPUT_AESOUT) |
565                         SE_CRYPTO_VCTRAM_SEL(VCTRAM_AHB) |
566                         SE_CRYPTO_XOR_POS(XOR_BOTTOM) |
567                         SE_CRYPTO_CORE_SEL(CORE_ENCRYPT);
568                 freq = se_dev->chipdata->aes_freq;
569                 break;
570         default:
571                 dev_warn(se_dev->dev, "Invalid operation mode\n");
572                 break;
573         }
574
575         if (mode == SE_AES_OP_MODE_CTR) {
576                 val |= SE_CRYPTO_HASH(HASH_DISABLE) |
577                         SE_CRYPTO_KEY_INDEX(slot_num) |
578                         SE_CRYPTO_CTR_CNTN(1);
579         } else {
580                 val |= SE_CRYPTO_HASH(HASH_DISABLE) |
581                         SE_CRYPTO_KEY_INDEX(slot_num) |
582                         (org_iv ? SE_CRYPTO_IV_SEL(IV_ORIGINAL) :
583                         SE_CRYPTO_IV_SEL(IV_UPDATED));
584         }
585
586         err = clk_set_rate(se_dev->pclk, freq);
587         if (err) {
588                 dev_err(se_dev->dev, "clock set_rate failed.\n");
589                 return;
590         }
591
592         /* enable hash for CMAC */
593         if (mode == SE_AES_OP_MODE_CMAC)
594                 val |= SE_CRYPTO_HASH(HASH_ENABLE);
595
596         se_writel(se_dev, val, SE_CRYPTO_REG_OFFSET);
597
598         if (mode == SE_AES_OP_MODE_RNG_DRBG) {
599                 if ((tegra_get_chipid() == TEGRA_CHIPID_TEGRA11) &&
600                                                 force_reseed_count <= 0) {
601                         se_writel(se_dev,
602                                 SE_RNG_CONFIG_MODE(DRBG_MODE_FORCE_RESEED)|
603                                 SE_RNG_CONFIG_SRC(DRBG_SRC_LFSR),
604                                 SE_RNG_CONFIG_REG_OFFSET);
605                 force_reseed_count = RNG_RESEED_INTERVAL;
606                 } else {
607                         se_writel(se_dev,
608                                 SE_RNG_CONFIG_MODE(DRBG_MODE_NORMAL)|
609                                 SE_RNG_CONFIG_SRC(DRBG_SRC_LFSR),
610                                 SE_RNG_CONFIG_REG_OFFSET);
611                 }
612                 if ((tegra_get_chipid() == TEGRA_CHIPID_TEGRA11))
613                         --force_reseed_count;
614
615                 se_writel(se_dev, RNG_RESEED_INTERVAL,
616                         SE_RNG_RESEED_INTERVAL_REG_OFFSET);
617         }
618
619         if (mode == SE_AES_OP_MODE_CTR)
620                 se_writel(se_dev, 1, SE_SPARE_0_REG_OFFSET);
621
622         if (mode == SE_AES_OP_MODE_OFB)
623                 se_writel(se_dev, 1, SE_SPARE_0_REG_OFFSET);
624
625 }
626
627 static void tegra_se_config_sha(struct tegra_se_dev *se_dev, u32 count,
628         unsigned long freq)
629 {
630         int i;
631         int err = 0;
632
633         se_writel(se_dev, (count * 8), SE_SHA_MSG_LENGTH_REG_OFFSET);
634         se_writel(se_dev, (count * 8), SE_SHA_MSG_LEFT_REG_OFFSET);
635         for (i = 1; i < 4; i++) {
636                 se_writel(se_dev, 0, SE_SHA_MSG_LENGTH_REG_OFFSET + (4 * i));
637                 se_writel(se_dev, 0, SE_SHA_MSG_LEFT_REG_OFFSET + (4 * i));
638         }
639
640         err = clk_set_rate(se_dev->pclk, freq);
641         if (err) {
642                 dev_err(se_dev->dev, "clock set_rate failed.\n");
643                 return;
644         }
645         se_writel(se_dev, SHA_ENABLE, SE_SHA_CONFIG_REG_OFFSET);
646 }
647
648 static int tegra_se_start_operation(struct tegra_se_dev *se_dev, u32 nbytes,
649         bool context_save)
650 {
651         u32 nblocks = nbytes / TEGRA_SE_AES_BLOCK_SIZE;
652         int ret = 0;
653         u32 val = 0;
654
655         if ((tegra_get_chipid() == TEGRA_CHIPID_TEGRA11) &&
656                                 nblocks > SE_MAX_LAST_BLOCK_SIZE)
657                 return -EINVAL;
658
659         dma_sync_single_for_device(se_dev->dev, se_dev->src_ll_buf_adr,
660                                 nbytes, DMA_TO_DEVICE);
661         dma_sync_single_for_device(se_dev->dev, se_dev->dst_ll_buf_adr,
662                                 nbytes, DMA_TO_DEVICE);
663         /* clear any pending interrupts */
664         val = se_readl(se_dev, SE_INT_STATUS_REG_OFFSET);
665         se_writel(se_dev, val, SE_INT_STATUS_REG_OFFSET);
666         se_writel(se_dev, se_dev->src_ll_buf_adr, SE_IN_LL_ADDR_REG_OFFSET);
667         se_writel(se_dev, se_dev->dst_ll_buf_adr, SE_OUT_LL_ADDR_REG_OFFSET);
668
669         if (nblocks)
670                 se_writel(se_dev, nblocks-1, SE_BLOCK_COUNT_REG_OFFSET);
671
672         /* enable interupts */
673         val = SE_INT_ERROR(INT_ENABLE) | SE_INT_OP_DONE(INT_ENABLE);
674         se_writel(se_dev, val, SE_INT_ENABLE_REG_OFFSET);
675
676         INIT_COMPLETION(se_dev->complete);
677
678         if (context_save)
679                 se_writel(se_dev, SE_OPERATION(OP_CTX_SAVE),
680                         SE_OPERATION_REG_OFFSET);
681         else
682                 se_writel(se_dev, SE_OPERATION(OP_SRART),
683                         SE_OPERATION_REG_OFFSET);
684
685         ret = wait_for_completion_timeout(&se_dev->complete,
686                         msecs_to_jiffies(1000));
687
688         dma_sync_single_for_cpu(se_dev->dev, se_dev->src_ll_buf_adr,
689                                 nbytes, DMA_FROM_DEVICE);
690         dma_sync_single_for_cpu(se_dev->dev, se_dev->dst_ll_buf_adr,
691                                 nbytes, DMA_FROM_DEVICE);
692         if (ret == 0) {
693                 dev_err(se_dev->dev, "operation timed out no interrupt\n");
694                 return -ETIMEDOUT;
695         }
696
697         return 0;
698 }
699
700 static void tegra_se_read_hash_result(struct tegra_se_dev *se_dev,
701         u8 *pdata, u32 nbytes, bool swap32)
702 {
703         u32 *result = (u32 *)pdata;
704         u32 i;
705
706         for (i = 0; i < nbytes/4; i++) {
707                 result[i] = se_readl(se_dev, SE_HASH_RESULT_REG_OFFSET +
708                                 (i * sizeof(u32)));
709                 if (swap32)
710                         result[i] = be32_to_cpu(result[i]);
711         }
712 }
713
714 static int tegra_map_sg(struct device *dev, struct scatterlist *sg,
715                         unsigned int nents, enum dma_data_direction dir,
716                         struct tegra_se_ll *se_ll, u32 total)
717 {
718         u32 total_loop = 0;
719         total_loop = total;
720
721                 while (sg) {
722                         dma_map_sg(dev, sg, 1, dir);
723                         se_ll->addr = sg_dma_address(sg);
724                         se_ll->data_len = min(sg->length, total_loop);
725                         total_loop -= min(sg->length, total_loop);
726                                 sg = scatterwalk_sg_next(sg);
727                         se_ll++;
728                 }
729         return nents;
730 }
731
732 static void tegra_unmap_sg(struct device *dev, struct scatterlist *sg,
733                                 enum dma_data_direction dir, u32 total)
734 {
735         while (sg) {
736                 dma_unmap_sg(dev, sg, 1, dir);
737                         sg = scatterwalk_sg_next(sg);
738         }
739 }
740
741 static int tegra_se_count_sgs(struct scatterlist *sl, u32 nbytes, int *chained)
742 {
743         struct scatterlist *sg = sl;
744         int sg_nents = 0;
745
746         *chained = 0;
747         while (sg) {
748                 sg_nents++;
749                 nbytes -= min(sl->length, nbytes);
750                 if (!sg_is_last(sg) && (sg + 1)->length == 0)
751                         *chained = 1;
752                 sg = scatterwalk_sg_next(sg);
753         }
754
755         return sg_nents;
756 }
757
758 static int tegra_se_alloc_ll_buf(struct tegra_se_dev *se_dev,
759         u32 num_src_sgs, u32 num_dst_sgs)
760 {
761         if (se_dev->src_ll_buf || se_dev->dst_ll_buf) {
762                 dev_err(se_dev->dev, "trying to allocate memory to allocated memory\n");
763                 return -EBUSY;
764         }
765
766         if (num_src_sgs) {
767                 se_dev->src_ll_size =
768                         (sizeof(struct tegra_se_ll) * num_src_sgs) +
769                                 sizeof(u32);
770                 se_dev->src_ll_buf = dma_alloc_coherent(se_dev->dev,
771                                         se_dev->src_ll_size,
772                                         &se_dev->src_ll_buf_adr, GFP_KERNEL);
773                 if (!se_dev->src_ll_buf) {
774                         dev_err(se_dev->dev, "can not allocate src lldma buffer\n");
775                         return -ENOMEM;
776                 }
777         }
778         if (num_dst_sgs) {
779                 se_dev->dst_ll_size =
780                                 (sizeof(struct tegra_se_ll) * num_dst_sgs) +
781                                         sizeof(u32);
782                 se_dev->dst_ll_buf = dma_alloc_coherent(se_dev->dev,
783                                         se_dev->dst_ll_size,
784                                         &se_dev->dst_ll_buf_adr, GFP_KERNEL);
785                 if (!se_dev->dst_ll_buf) {
786                         dev_err(se_dev->dev, "can not allocate dst ll dma buffer\n");
787                         return -ENOMEM;
788                 }
789         }
790
791         return 0;
792 }
793
794 static void tegra_se_free_ll_buf(struct tegra_se_dev *se_dev)
795 {
796         if (se_dev->src_ll_buf) {
797                 dma_free_coherent(se_dev->dev, se_dev->src_ll_size,
798                         se_dev->src_ll_buf, se_dev->src_ll_buf_adr);
799                 se_dev->src_ll_buf = NULL;
800         }
801
802         if (se_dev->dst_ll_buf) {
803                 dma_free_coherent(se_dev->dev, se_dev->dst_ll_size,
804                         se_dev->dst_ll_buf, se_dev->dst_ll_buf_adr);
805                 se_dev->dst_ll_buf = NULL;
806         }
807 }
808
809 static int tegra_se_setup_ablk_req(struct tegra_se_dev *se_dev,
810         struct ablkcipher_request *req)
811 {
812         struct scatterlist *src_sg, *dst_sg;
813         struct tegra_se_ll *src_ll, *dst_ll;
814         u32 total, num_src_sgs, num_dst_sgs;
815         int src_chained, dst_chained;
816         int ret = 0;
817
818         num_src_sgs = tegra_se_count_sgs(req->src, req->nbytes, &src_chained);
819         num_dst_sgs = tegra_se_count_sgs(req->dst, req->nbytes, &dst_chained);
820
821         if ((num_src_sgs > SE_MAX_SRC_SG_COUNT) ||
822                 (num_dst_sgs > SE_MAX_DST_SG_COUNT)) {
823                         dev_err(se_dev->dev, "num of SG buffers are more\n");
824                         return -EINVAL;
825         }
826
827         *se_dev->src_ll_buf = num_src_sgs-1;
828         *se_dev->dst_ll_buf = num_dst_sgs-1;
829
830         src_ll = (struct tegra_se_ll *)(se_dev->src_ll_buf + 1);
831         dst_ll = (struct tegra_se_ll *)(se_dev->dst_ll_buf + 1);
832
833         src_sg = req->src;
834         dst_sg = req->dst;
835         total = req->nbytes;
836
837         if (total) {
838                 tegra_map_sg(se_dev->dev, src_sg, 1, DMA_TO_DEVICE,
839                                         src_ll, total);
840                 tegra_map_sg(se_dev->dev, dst_sg, 1, DMA_FROM_DEVICE,
841                                         dst_ll, total);
842                 WARN_ON(src_sg->length != dst_sg->length);
843         }
844         return ret;
845 }
846
847 static void tegra_se_dequeue_complete_req(struct tegra_se_dev *se_dev,
848         struct ablkcipher_request *req)
849 {
850         struct scatterlist *src_sg, *dst_sg;
851         u32 total;
852
853         if (req) {
854                 src_sg = req->src;
855                 dst_sg = req->dst;
856                 total = req->nbytes;
857                 tegra_unmap_sg(se_dev->dev, dst_sg,  DMA_FROM_DEVICE, total);
858                 tegra_unmap_sg(se_dev->dev, src_sg,  DMA_TO_DEVICE, total);
859         }
860 }
861
862 static void tegra_se_process_new_req(struct crypto_async_request *async_req)
863 {
864         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
865         struct ablkcipher_request *req = ablkcipher_request_cast(async_req);
866         struct tegra_se_req_context *req_ctx = ablkcipher_request_ctx(req);
867         struct tegra_se_aes_context *aes_ctx =
868                         crypto_ablkcipher_ctx(crypto_ablkcipher_reqtfm(req));
869         int ret = 0;
870
871         /* take access to the hw */
872         mutex_lock(&se_hw_lock);
873
874         /* write IV */
875         if (req->info) {
876                 if (req_ctx->op_mode == SE_AES_OP_MODE_CTR) {
877                         tegra_se_write_seed(se_dev, (u32 *)req->info);
878                 } else {
879                         tegra_se_write_key_table(req->info,
880                                 TEGRA_SE_AES_IV_SIZE,
881                                 aes_ctx->slot->slot_num,
882                                 SE_KEY_TABLE_TYPE_ORGIV);
883                 }
884         }
885         tegra_se_setup_ablk_req(se_dev, req);
886         tegra_se_config_algo(se_dev, req_ctx->op_mode, req_ctx->encrypt,
887                 aes_ctx->keylen);
888         tegra_se_config_crypto(se_dev, req_ctx->op_mode, req_ctx->encrypt,
889                         aes_ctx->slot->slot_num, req->info ? true : false);
890         ret = tegra_se_start_operation(se_dev, req->nbytes, false);
891         tegra_se_dequeue_complete_req(se_dev, req);
892
893         mutex_unlock(&se_hw_lock);
894         req->base.complete(&req->base, ret);
895 }
896
897 static irqreturn_t tegra_se_irq(int irq, void *dev)
898 {
899         struct tegra_se_dev *se_dev = dev;
900         u32 val;
901
902         val = se_readl(se_dev, SE_INT_STATUS_REG_OFFSET);
903         se_writel(se_dev, val, SE_INT_STATUS_REG_OFFSET);
904
905         if (val & SE_INT_ERROR(INT_SET))
906                 dev_err(se_dev->dev, "tegra_se_irq::error");
907
908         if (val & SE_INT_OP_DONE(INT_SET))
909                 complete(&se_dev->complete);
910
911         return IRQ_HANDLED;
912 }
913
914 static void tegra_se_work_handler(struct work_struct *work)
915 {
916         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
917         struct crypto_async_request *async_req = NULL;
918         struct crypto_async_request *backlog = NULL;
919
920         pm_runtime_get_sync(se_dev->dev);
921
922         do {
923                 spin_lock_irq(&se_dev->lock);
924                 backlog = crypto_get_backlog(&se_dev->queue);
925                 async_req = crypto_dequeue_request(&se_dev->queue);
926                 if (!async_req)
927                         se_dev->work_q_busy = false;
928
929                 spin_unlock_irq(&se_dev->lock);
930
931                 if (backlog) {
932                         backlog->complete(backlog, -EINPROGRESS);
933                         backlog = NULL;
934                 }
935
936                 if (async_req) {
937                         tegra_se_process_new_req(async_req);
938                         async_req = NULL;
939                 }
940         } while (se_dev->work_q_busy);
941         pm_runtime_put(se_dev->dev);
942 }
943
944 static int tegra_se_aes_queue_req(struct ablkcipher_request *req)
945 {
946
947         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
948         unsigned long flags;
949         bool idle = true;
950         int err = 0;
951         int chained;
952
953         if (!tegra_se_count_sgs(req->src, req->nbytes, &chained))
954                 return -EINVAL;
955
956         spin_lock_irqsave(&se_dev->lock, flags);
957         err = ablkcipher_enqueue_request(&se_dev->queue, req);
958         if (se_dev->work_q_busy)
959                 idle = false;
960         spin_unlock_irqrestore(&se_dev->lock, flags);
961
962         if (idle) {
963                 spin_lock_irq(&se_dev->lock);
964                 se_dev->work_q_busy = true;
965                 spin_unlock_irq(&se_dev->lock);
966                 queue_work(se_work_q, &se_work);
967         }
968
969         return err;
970 }
971
972 static int tegra_se_aes_cbc_encrypt(struct ablkcipher_request *req)
973 {
974         struct tegra_se_req_context *req_ctx = ablkcipher_request_ctx(req);
975
976         req_ctx->encrypt = true;
977         req_ctx->op_mode = SE_AES_OP_MODE_CBC;
978
979         return tegra_se_aes_queue_req(req);
980 }
981
982 static int tegra_se_aes_cbc_decrypt(struct ablkcipher_request *req)
983 {
984         struct tegra_se_req_context *req_ctx = ablkcipher_request_ctx(req);
985
986         req_ctx->encrypt = false;
987         req_ctx->op_mode = SE_AES_OP_MODE_CBC;
988
989         return tegra_se_aes_queue_req(req);
990 }
991
992 static int tegra_se_aes_ecb_encrypt(struct ablkcipher_request *req)
993 {
994         struct tegra_se_req_context *req_ctx = ablkcipher_request_ctx(req);
995
996         req_ctx->encrypt = true;
997         req_ctx->op_mode = SE_AES_OP_MODE_ECB;
998
999         return tegra_se_aes_queue_req(req);
1000 }
1001
1002 static int tegra_se_aes_ecb_decrypt(struct ablkcipher_request *req)
1003 {
1004         struct tegra_se_req_context *req_ctx = ablkcipher_request_ctx(req);
1005
1006         req_ctx->encrypt = false;
1007         req_ctx->op_mode = SE_AES_OP_MODE_ECB;
1008
1009         return tegra_se_aes_queue_req(req);
1010 }
1011
1012 static int tegra_se_aes_ctr_encrypt(struct ablkcipher_request *req)
1013 {
1014         struct tegra_se_req_context *req_ctx = ablkcipher_request_ctx(req);
1015
1016         req_ctx->encrypt = true;
1017         req_ctx->op_mode = SE_AES_OP_MODE_CTR;
1018
1019         return tegra_se_aes_queue_req(req);
1020 }
1021
1022 static int tegra_se_aes_ctr_decrypt(struct ablkcipher_request *req)
1023 {
1024         struct tegra_se_req_context *req_ctx = ablkcipher_request_ctx(req);
1025
1026         req_ctx->encrypt = false;
1027         req_ctx->op_mode = SE_AES_OP_MODE_CTR;
1028
1029         return tegra_se_aes_queue_req(req);
1030 }
1031
1032 static int tegra_se_aes_ofb_encrypt(struct ablkcipher_request *req)
1033 {
1034         struct tegra_se_req_context *req_ctx = ablkcipher_request_ctx(req);
1035
1036         req_ctx->encrypt = true;
1037         req_ctx->op_mode = SE_AES_OP_MODE_OFB;
1038
1039         return tegra_se_aes_queue_req(req);
1040 }
1041
1042 static int tegra_se_aes_ofb_decrypt(struct ablkcipher_request *req)
1043 {
1044         struct tegra_se_req_context *req_ctx = ablkcipher_request_ctx(req);
1045
1046         req_ctx->encrypt = false;
1047         req_ctx->op_mode = SE_AES_OP_MODE_OFB;
1048
1049         return tegra_se_aes_queue_req(req);
1050 }
1051
1052 static int tegra_se_aes_setkey(struct crypto_ablkcipher *tfm,
1053         const u8 *key, u32 keylen)
1054 {
1055         struct tegra_se_aes_context *ctx = crypto_ablkcipher_ctx(tfm);
1056         struct tegra_se_dev *se_dev = NULL;
1057         struct tegra_se_slot *pslot;
1058         u8 *pdata = (u8 *)key;
1059
1060         if (!ctx || !ctx->se_dev) {
1061                 pr_err("invalid context or dev");
1062                 return -EINVAL;
1063         }
1064
1065         se_dev = ctx->se_dev;
1066
1067         if ((keylen != TEGRA_SE_KEY_128_SIZE) &&
1068                 (keylen != TEGRA_SE_KEY_192_SIZE) &&
1069                 (keylen != TEGRA_SE_KEY_256_SIZE)) {
1070                 dev_err(se_dev->dev, "invalid key size");
1071                 return -EINVAL;
1072         }
1073
1074         if (key) {
1075                 if (!ctx->slot || (ctx->slot &&
1076                     ctx->slot->slot_num == ssk_slot.slot_num)) {
1077                         pslot = tegra_se_alloc_key_slot();
1078                         if (!pslot) {
1079                                 dev_err(se_dev->dev, "no free key slot\n");
1080                                 return -ENOMEM;
1081                         }
1082                         ctx->slot = pslot;
1083                 }
1084                 ctx->keylen = keylen;
1085         } else {
1086                 tegra_se_free_key_slot(ctx->slot);
1087                 ctx->slot = &ssk_slot;
1088                 ctx->keylen = AES_KEYSIZE_128;
1089         }
1090
1091         /* take access to the hw */
1092         mutex_lock(&se_hw_lock);
1093         pm_runtime_get_sync(se_dev->dev);
1094
1095         /* load the key */
1096         tegra_se_write_key_table(pdata, keylen, ctx->slot->slot_num,
1097                 SE_KEY_TABLE_TYPE_KEY);
1098
1099         pm_runtime_put(se_dev->dev);
1100         mutex_unlock(&se_hw_lock);
1101
1102         return 0;
1103 }
1104
1105 static int tegra_se_aes_cra_init(struct crypto_tfm *tfm)
1106 {
1107         struct tegra_se_aes_context *ctx = crypto_tfm_ctx(tfm);
1108
1109         ctx->se_dev = sg_tegra_se_dev;
1110         tfm->crt_ablkcipher.reqsize = sizeof(struct tegra_se_req_context);
1111
1112         return 0;
1113 }
1114
1115 static void tegra_se_aes_cra_exit(struct crypto_tfm *tfm)
1116 {
1117         struct tegra_se_aes_context *ctx = crypto_tfm_ctx(tfm);
1118
1119         tegra_se_free_key_slot(ctx->slot);
1120         ctx->slot = NULL;
1121 }
1122
1123 static int tegra_se_rng_init(struct crypto_tfm *tfm)
1124 {
1125         struct tegra_se_rng_context *rng_ctx = crypto_tfm_ctx(tfm);
1126         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
1127
1128         rng_ctx->se_dev = se_dev;
1129         rng_ctx->dt_buf = dma_alloc_coherent(se_dev->dev, TEGRA_SE_RNG_DT_SIZE,
1130                 &rng_ctx->dt_buf_adr, GFP_KERNEL);
1131         if (!rng_ctx->dt_buf) {
1132                 dev_err(se_dev->dev, "can not allocate rng dma buffer");
1133                 return -ENOMEM;
1134         }
1135
1136         rng_ctx->rng_buf = dma_alloc_coherent(rng_ctx->se_dev->dev,
1137                 TEGRA_SE_RNG_DT_SIZE, &rng_ctx->rng_buf_adr, GFP_KERNEL);
1138         if (!rng_ctx->rng_buf) {
1139                 dev_err(se_dev->dev, "can not allocate rng dma buffer");
1140                 dma_free_coherent(rng_ctx->se_dev->dev, TEGRA_SE_RNG_DT_SIZE,
1141                                         rng_ctx->dt_buf, rng_ctx->dt_buf_adr);
1142                 return -ENOMEM;
1143         }
1144
1145         rng_ctx->slot = tegra_se_alloc_key_slot();
1146
1147         if (!rng_ctx->slot) {
1148                 dev_err(rng_ctx->se_dev->dev, "no free slot\n");
1149                 dma_free_coherent(rng_ctx->se_dev->dev, TEGRA_SE_RNG_DT_SIZE,
1150                                         rng_ctx->dt_buf, rng_ctx->dt_buf_adr);
1151                 dma_free_coherent(rng_ctx->se_dev->dev, TEGRA_SE_RNG_DT_SIZE,
1152                                         rng_ctx->rng_buf, rng_ctx->rng_buf_adr);
1153                 return -ENOMEM;
1154         }
1155
1156         return 0;
1157 }
1158
1159 static void tegra_se_rng_exit(struct crypto_tfm *tfm)
1160 {
1161         struct tegra_se_rng_context *rng_ctx = crypto_tfm_ctx(tfm);
1162
1163         if (rng_ctx->dt_buf) {
1164                 dma_free_coherent(rng_ctx->se_dev->dev, TEGRA_SE_RNG_DT_SIZE,
1165                         rng_ctx->dt_buf, rng_ctx->dt_buf_adr);
1166         }
1167
1168         if (rng_ctx->rng_buf) {
1169                 dma_free_coherent(rng_ctx->se_dev->dev, TEGRA_SE_RNG_DT_SIZE,
1170                         rng_ctx->rng_buf, rng_ctx->rng_buf_adr);
1171         }
1172
1173         tegra_se_free_key_slot(rng_ctx->slot);
1174         rng_ctx->slot = NULL;
1175         rng_ctx->se_dev = NULL;
1176 }
1177
1178 static int tegra_se_rng_get_random(struct crypto_rng *tfm, u8 *rdata, u32 dlen)
1179 {
1180         struct tegra_se_rng_context *rng_ctx = crypto_rng_ctx(tfm);
1181         struct tegra_se_dev *se_dev = rng_ctx->se_dev;
1182         struct tegra_se_ll *src_ll, *dst_ll;
1183         unsigned char *dt_buf = (unsigned char *)rng_ctx->dt_buf;
1184         u8 *rdata_addr;
1185         int ret = 0, i, j, num_blocks, data_len = 0;
1186
1187         num_blocks = (dlen / TEGRA_SE_RNG_DT_SIZE);
1188
1189         data_len = (dlen % TEGRA_SE_RNG_DT_SIZE);
1190         if (data_len == 0)
1191                 num_blocks = num_blocks - 1;
1192
1193         /* take access to the hw */
1194         mutex_lock(&se_hw_lock);
1195         pm_runtime_get_sync(se_dev->dev);
1196
1197         *se_dev->src_ll_buf = 0;
1198         *se_dev->dst_ll_buf = 0;
1199         src_ll = (struct tegra_se_ll *)(se_dev->src_ll_buf + 1);
1200         dst_ll = (struct tegra_se_ll *)(se_dev->dst_ll_buf + 1);
1201         src_ll->addr = rng_ctx->dt_buf_adr;
1202         src_ll->data_len = TEGRA_SE_RNG_DT_SIZE;
1203         dst_ll->addr = rng_ctx->rng_buf_adr;
1204         dst_ll->data_len = TEGRA_SE_RNG_DT_SIZE;
1205
1206         dma_sync_single_for_device(se_dev->dev, rng_ctx->dt_buf_adr,
1207                                 TEGRA_SE_RNG_DT_SIZE, DMA_TO_DEVICE);
1208
1209         tegra_se_config_algo(se_dev, SE_AES_OP_MODE_RNG_X931, true,
1210                 TEGRA_SE_KEY_128_SIZE);
1211         tegra_se_config_crypto(se_dev, SE_AES_OP_MODE_RNG_X931, true,
1212                                 rng_ctx->slot->slot_num, rng_ctx->use_org_iv);
1213         for (j = 0; j <= num_blocks; j++) {
1214
1215                 dma_sync_single_for_device(se_dev->dev, rng_ctx->rng_buf_adr,
1216                                 TEGRA_SE_RNG_DT_SIZE, DMA_TO_DEVICE);
1217
1218                 ret = tegra_se_start_operation(se_dev,
1219                                 TEGRA_SE_RNG_DT_SIZE, false);
1220
1221                 dma_sync_single_for_cpu(se_dev->dev, rng_ctx->rng_buf_adr,
1222                                 TEGRA_SE_RNG_DT_SIZE, DMA_FROM_DEVICE);
1223
1224                 if (!ret) {
1225                         rdata_addr = (rdata + (j * TEGRA_SE_RNG_DT_SIZE));
1226
1227                         if (data_len && num_blocks == j) {
1228                                 memcpy(rdata_addr, rng_ctx->rng_buf, data_len);
1229                         } else {
1230                                 memcpy(rdata_addr,
1231                                         rng_ctx->rng_buf, TEGRA_SE_RNG_DT_SIZE);
1232                         }
1233
1234                         /* update DT vector */
1235                         for (i = TEGRA_SE_RNG_DT_SIZE - 1; i >= 0; i--) {
1236                                 dt_buf[i] += 1;
1237                                 if (dt_buf[i] != 0)
1238                                         break;
1239                         }
1240                 } else {
1241                         dlen = 0;
1242                 }
1243                 if (rng_ctx->use_org_iv) {
1244                         rng_ctx->use_org_iv = false;
1245                         tegra_se_config_crypto(se_dev,
1246                                 SE_AES_OP_MODE_RNG_X931, true,
1247                                 rng_ctx->slot->slot_num, rng_ctx->use_org_iv);
1248                 }
1249
1250         }
1251
1252         dma_sync_single_for_cpu(se_dev->dev, rng_ctx->dt_buf_adr,
1253                                 TEGRA_SE_RNG_DT_SIZE, DMA_FROM_DEVICE);
1254
1255         pm_runtime_put(se_dev->dev);
1256         mutex_unlock(&se_hw_lock);
1257
1258         return dlen;
1259 }
1260
1261 static int tegra_se_rng_reset(struct crypto_rng *tfm, u8 *seed, u32 slen)
1262 {
1263         struct tegra_se_rng_context *rng_ctx = crypto_rng_ctx(tfm);
1264         struct tegra_se_dev *se_dev = rng_ctx->se_dev;
1265         u8 *iv = seed;
1266         u8 *key = (u8 *)(seed + TEGRA_SE_RNG_IV_SIZE);
1267         u8 *dt = key + TEGRA_SE_RNG_KEY_SIZE;
1268         struct timespec ts;
1269         u64 nsec, tmp[2];
1270
1271         BUG_ON(!seed);
1272
1273         /* take access to the hw */
1274         mutex_lock(&se_hw_lock);
1275         pm_runtime_get_sync(se_dev->dev);
1276
1277         tegra_se_write_key_table(key, TEGRA_SE_RNG_KEY_SIZE,
1278                 rng_ctx->slot->slot_num, SE_KEY_TABLE_TYPE_KEY);
1279
1280         tegra_se_write_key_table(iv, TEGRA_SE_RNG_IV_SIZE,
1281                 rng_ctx->slot->slot_num, SE_KEY_TABLE_TYPE_ORGIV);
1282
1283         pm_runtime_put(se_dev->dev);
1284         mutex_unlock(&se_hw_lock);
1285
1286         if (slen < TEGRA_SE_RNG_SEED_SIZE) {
1287                 getnstimeofday(&ts);
1288                 nsec = timespec_to_ns(&ts);
1289                 do_div(nsec, 1000);
1290                 nsec ^= se_dev->ctr << 56;
1291                 se_dev->ctr++;
1292                 tmp[0] = nsec;
1293                 tmp[1] = tegra_chip_uid();
1294                 memcpy(rng_ctx->dt_buf, (u8 *)tmp, TEGRA_SE_RNG_DT_SIZE);
1295         } else {
1296                 memcpy(rng_ctx->dt_buf, dt, TEGRA_SE_RNG_DT_SIZE);
1297         }
1298
1299         rng_ctx->use_org_iv = true;
1300
1301         return 0;
1302 }
1303
1304 static int tegra_se_rng_drbg_init(struct crypto_tfm *tfm)
1305 {
1306         struct tegra_se_rng_context *rng_ctx = crypto_tfm_ctx(tfm);
1307         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
1308
1309         rng_ctx->se_dev = se_dev;
1310         rng_ctx->dt_buf = dma_alloc_coherent(se_dev->dev, TEGRA_SE_RNG_DT_SIZE,
1311                 &rng_ctx->dt_buf_adr, GFP_KERNEL);
1312         if (!rng_ctx->dt_buf) {
1313                 dev_err(se_dev->dev, "can not allocate rng dma buffer");
1314                 return -ENOMEM;
1315         }
1316
1317         rng_ctx->rng_buf = dma_alloc_coherent(rng_ctx->se_dev->dev,
1318                 TEGRA_SE_RNG_DT_SIZE, &rng_ctx->rng_buf_adr, GFP_KERNEL);
1319         if (!rng_ctx->rng_buf) {
1320                 dev_err(se_dev->dev, "can not allocate rng dma buffer");
1321                 dma_free_coherent(rng_ctx->se_dev->dev, TEGRA_SE_RNG_DT_SIZE,
1322                                         rng_ctx->dt_buf, rng_ctx->dt_buf_adr);
1323                 return -ENOMEM;
1324         }
1325
1326         /* take access to the hw */
1327         mutex_lock(&se_hw_lock);
1328         pm_runtime_get_sync(se_dev->dev);
1329
1330         if (!drbg_ro_entropy_src_enabled
1331                 && (tegra_get_chipid() != TEGRA_CHIPID_TEGRA3)
1332                 && (tegra_get_chipid() != TEGRA_CHIPID_TEGRA11)) {
1333                 se_writel(se_dev,
1334                         SE_RNG_SRC_CONFIG_RO_ENT_SRC(DRBG_RO_ENT_SRC_ENABLE)
1335                 |SE_RNG_SRC_CONFIG_RO_ENT_SRC_LOCK(DRBG_RO_ENT_SRC_LOCK_ENABLE),
1336                         SE_RNG_SRC_CONFIG_REG_OFFSET);
1337                 drbg_ro_entropy_src_enabled = 1;
1338         }
1339
1340         pm_runtime_put(se_dev->dev);
1341         mutex_unlock(&se_hw_lock);
1342
1343         return 0;
1344 }
1345
1346 static int tegra_se_rng_drbg_get_random(struct crypto_rng *tfm,
1347         u8 *rdata, u32 dlen)
1348 {
1349         struct tegra_se_rng_context *rng_ctx = crypto_rng_ctx(tfm);
1350         struct tegra_se_dev *se_dev = rng_ctx->se_dev;
1351         struct tegra_se_ll *src_ll, *dst_ll;
1352         u8 *rdata_addr;
1353         int ret = 0, j, num_blocks, data_len = 0;
1354
1355         num_blocks = (dlen / TEGRA_SE_RNG_DT_SIZE);
1356
1357         data_len = (dlen % TEGRA_SE_RNG_DT_SIZE);
1358         if (data_len == 0)
1359                 num_blocks = num_blocks - 1;
1360
1361         /* take access to the hw */
1362         mutex_lock(&se_hw_lock);
1363         pm_runtime_get_sync(se_dev->dev);
1364
1365         *se_dev->src_ll_buf = 0;
1366         *se_dev->dst_ll_buf = 0;
1367         src_ll = (struct tegra_se_ll *)(se_dev->src_ll_buf + 1);
1368         dst_ll = (struct tegra_se_ll *)(se_dev->dst_ll_buf + 1);
1369         src_ll->addr = rng_ctx->dt_buf_adr;
1370         src_ll->data_len = TEGRA_SE_RNG_DT_SIZE;
1371         dst_ll->addr = rng_ctx->rng_buf_adr;
1372         dst_ll->data_len = TEGRA_SE_RNG_DT_SIZE;
1373
1374         dma_sync_single_for_device(se_dev->dev, rng_ctx->dt_buf_adr,
1375                                 TEGRA_SE_RNG_DT_SIZE, DMA_TO_DEVICE);
1376
1377         tegra_se_config_algo(se_dev, SE_AES_OP_MODE_RNG_DRBG, true,
1378                 TEGRA_SE_KEY_128_SIZE);
1379         tegra_se_config_crypto(se_dev, SE_AES_OP_MODE_RNG_DRBG, true,
1380                                 0, true);
1381         for (j = 0; j <= num_blocks; j++) {
1382
1383                 dma_sync_single_for_device(se_dev->dev, rng_ctx->rng_buf_adr,
1384                                 TEGRA_SE_RNG_DT_SIZE, DMA_TO_DEVICE);
1385
1386                 ret = tegra_se_start_operation(se_dev,
1387                                 TEGRA_SE_RNG_DT_SIZE, false);
1388
1389                 dma_sync_single_for_cpu(se_dev->dev, rng_ctx->rng_buf_adr,
1390                                 TEGRA_SE_RNG_DT_SIZE, DMA_FROM_DEVICE);
1391                 if (!ret) {
1392                         rdata_addr = (rdata + (j * TEGRA_SE_RNG_DT_SIZE));
1393
1394                         if (data_len && num_blocks == j) {
1395                                 memcpy(rdata_addr, rng_ctx->rng_buf, data_len);
1396                         } else {
1397                                 memcpy(rdata_addr,
1398                                         rng_ctx->rng_buf, TEGRA_SE_RNG_DT_SIZE);
1399                         }
1400                 } else {
1401                         dlen = 0;
1402                 }
1403         }
1404
1405         dma_sync_single_for_cpu(se_dev->dev, rng_ctx->dt_buf_adr,
1406                                 TEGRA_SE_RNG_DT_SIZE, DMA_FROM_DEVICE);
1407
1408         pm_runtime_put(se_dev->dev);
1409         mutex_unlock(&se_hw_lock);
1410
1411         return dlen;
1412 }
1413
1414 static int tegra_se_rng_drbg_reset(struct crypto_rng *tfm, u8 *seed, u32 slen)
1415 {
1416         return 0;
1417 }
1418
1419 static void tegra_se_rng_drbg_exit(struct crypto_tfm *tfm)
1420 {
1421         struct tegra_se_rng_context *rng_ctx = crypto_tfm_ctx(tfm);
1422
1423         if (rng_ctx->dt_buf) {
1424                 dma_free_coherent(rng_ctx->se_dev->dev, TEGRA_SE_RNG_DT_SIZE,
1425                         rng_ctx->dt_buf, rng_ctx->dt_buf_adr);
1426         }
1427
1428         if (rng_ctx->rng_buf) {
1429                 dma_free_coherent(rng_ctx->se_dev->dev, TEGRA_SE_RNG_DT_SIZE,
1430                         rng_ctx->rng_buf, rng_ctx->rng_buf_adr);
1431         }
1432         rng_ctx->se_dev = NULL;
1433 }
1434
1435 int tegra_se_sha_init(struct ahash_request *req)
1436 {
1437         return 0;
1438 }
1439
1440 int tegra_se_sha_update(struct ahash_request *req)
1441 {
1442         return 0;
1443 }
1444
1445 int tegra_se_sha_finup(struct ahash_request *req)
1446 {
1447         return 0;
1448 }
1449
1450 int tegra_se_sha_final(struct ahash_request *req)
1451 {
1452         struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
1453         struct tegra_se_sha_context *sha_ctx = crypto_ahash_ctx(tfm);
1454         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
1455         struct scatterlist *src_sg;
1456         struct tegra_se_ll *src_ll;
1457         u32 total, num_sgs;
1458         unsigned long freq = 0;
1459         int err = 0;
1460         int chained;
1461
1462         if (!req->nbytes)
1463                 return -EINVAL;
1464
1465         if (crypto_ahash_digestsize(tfm) == SHA1_DIGEST_SIZE) {
1466                 sha_ctx->op_mode = SE_AES_OP_MODE_SHA1;
1467                 freq = se_dev->chipdata->sha1_freq;
1468         }
1469
1470         if (crypto_ahash_digestsize(tfm) == SHA224_DIGEST_SIZE) {
1471                 sha_ctx->op_mode = SE_AES_OP_MODE_SHA224;
1472                 freq = se_dev->chipdata->sha224_freq;
1473         }
1474
1475         if (crypto_ahash_digestsize(tfm) == SHA256_DIGEST_SIZE) {
1476                 sha_ctx->op_mode = SE_AES_OP_MODE_SHA256;
1477                 freq = se_dev->chipdata->sha256_freq;
1478         }
1479
1480         if (crypto_ahash_digestsize(tfm) == SHA384_DIGEST_SIZE) {
1481                 sha_ctx->op_mode = SE_AES_OP_MODE_SHA384;
1482                 freq = se_dev->chipdata->sha384_freq;
1483         }
1484
1485         if (crypto_ahash_digestsize(tfm) == SHA512_DIGEST_SIZE) {
1486                 sha_ctx->op_mode = SE_AES_OP_MODE_SHA512;
1487                 freq = se_dev->chipdata->sha512_freq;
1488         }
1489
1490         /* take access to the hw */
1491         mutex_lock(&se_hw_lock);
1492         pm_runtime_get_sync(se_dev->dev);
1493
1494         num_sgs = tegra_se_count_sgs(req->src, req->nbytes, &chained);
1495         if ((num_sgs > SE_MAX_SRC_SG_COUNT)) {
1496                 dev_err(se_dev->dev, "num of SG buffers are more\n");
1497                 pm_runtime_put(se_dev->dev);
1498                 mutex_unlock(&se_hw_lock);
1499                 return -EINVAL;
1500         }
1501
1502         *se_dev->src_ll_buf = num_sgs - 1;
1503         src_ll = (struct tegra_se_ll *)(se_dev->src_ll_buf + 1);
1504         src_sg = req->src;
1505         total = req->nbytes;
1506
1507         if (total)
1508                 tegra_map_sg(se_dev->dev, src_sg, 1, DMA_TO_DEVICE,
1509                                                         src_ll, total);
1510
1511         tegra_se_config_algo(se_dev, sha_ctx->op_mode, false, 0);
1512         tegra_se_config_sha(se_dev, req->nbytes, freq);
1513         err = tegra_se_start_operation(se_dev, 0, false);
1514         if (!err) {
1515                 tegra_se_read_hash_result(se_dev, req->result,
1516                         crypto_ahash_digestsize(tfm), true);
1517                 if ((sha_ctx->op_mode == SE_AES_OP_MODE_SHA384) ||
1518                         (sha_ctx->op_mode == SE_AES_OP_MODE_SHA512)) {
1519                         u32 *result = (u32 *)req->result;
1520                         u32 temp, i;
1521
1522                         for (i = 0; i < crypto_ahash_digestsize(tfm)/4;
1523                                 i += 2) {
1524                                 temp = result[i];
1525                                 result[i] = result[i+1];
1526                                 result[i+1] = temp;
1527                         }
1528                 }
1529         }
1530
1531         src_sg = req->src;
1532         total = req->nbytes;
1533         if (total)
1534                 tegra_unmap_sg(se_dev->dev, src_sg, DMA_TO_DEVICE, total);
1535
1536         pm_runtime_put(se_dev->dev);
1537         mutex_unlock(&se_hw_lock);
1538
1539         return err;
1540 }
1541
1542 static int tegra_se_sha_digest(struct ahash_request *req)
1543 {
1544         return tegra_se_sha_init(req) ?: tegra_se_sha_final(req);
1545 }
1546
1547 int tegra_se_sha_cra_init(struct crypto_tfm *tfm)
1548 {
1549         crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),
1550                                  sizeof(struct tegra_se_sha_context));
1551         return 0;
1552 }
1553
1554 void tegra_se_sha_cra_exit(struct crypto_tfm *tfm)
1555 {
1556         /* do nothing */
1557 }
1558
1559 int tegra_se_aes_cmac_init(struct ahash_request *req)
1560 {
1561
1562         return 0;
1563 }
1564
1565 int tegra_se_aes_cmac_update(struct ahash_request *req)
1566 {
1567         return 0;
1568 }
1569
1570 int tegra_se_aes_cmac_final(struct ahash_request *req)
1571 {
1572         struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
1573         struct tegra_se_aes_cmac_context *cmac_ctx = crypto_ahash_ctx(tfm);
1574         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
1575         struct scatterlist *src_sg;
1576         struct tegra_se_ll *src_ll;
1577         struct sg_mapping_iter miter;
1578         u32 num_sgs, blocks_to_process, last_block_bytes = 0, bytes_to_copy = 0;
1579         u8 piv[TEGRA_SE_AES_IV_SIZE];
1580         int total, ret = 0, i = 0, mapped_sg_count = 0;
1581         bool padding_needed = false;
1582         unsigned long flags;
1583         unsigned int sg_flags = SG_MITER_ATOMIC;
1584         u8 *temp_buffer = NULL;
1585         bool use_orig_iv = true;
1586         int chained;
1587
1588         /* take access to the hw */
1589         mutex_lock(&se_hw_lock);
1590         pm_runtime_get_sync(se_dev->dev);
1591
1592         blocks_to_process = req->nbytes / TEGRA_SE_AES_BLOCK_SIZE;
1593         /* num of bytes less than block size */
1594         if ((req->nbytes % TEGRA_SE_AES_BLOCK_SIZE) || !blocks_to_process) {
1595                 padding_needed = true;
1596                 last_block_bytes = req->nbytes % TEGRA_SE_AES_BLOCK_SIZE;
1597         } else {
1598                 /* decrement num of blocks */
1599                 blocks_to_process--;
1600                 if (blocks_to_process) {
1601                         /* there are blocks to process and find last block
1602                                 bytes */
1603                         last_block_bytes = req->nbytes -
1604                                 (blocks_to_process * TEGRA_SE_AES_BLOCK_SIZE);
1605                 } else {
1606                         /* this is the last block and equal to block size */
1607                         last_block_bytes = req->nbytes;
1608                 }
1609         }
1610
1611         /* first process all blocks except last block */
1612         if (blocks_to_process) {
1613                 num_sgs = tegra_se_count_sgs(req->src, req->nbytes, &chained);
1614                 if (num_sgs > SE_MAX_SRC_SG_COUNT) {
1615                         dev_err(se_dev->dev, "num of SG buffers are more\n");
1616                         goto out;
1617                 }
1618                 *se_dev->src_ll_buf = num_sgs - 1;
1619                 src_ll = (struct tegra_se_ll *)(se_dev->src_ll_buf + 1);
1620                 src_sg = req->src;
1621                 total = blocks_to_process * TEGRA_SE_AES_BLOCK_SIZE;
1622                 while (total > 0) {
1623                         ret = dma_map_sg(se_dev->dev, src_sg, 1, DMA_TO_DEVICE);
1624                         mapped_sg_count++;
1625                         if (!ret) {
1626                                 dev_err(se_dev->dev, "dma_map_sg() error\n");
1627                                 goto out;
1628                         }
1629                         src_ll->addr = sg_dma_address(src_sg);
1630                         if (total > src_sg->length)
1631                                 src_ll->data_len = src_sg->length;
1632                         else
1633                                 src_ll->data_len = total;
1634
1635                         total -= src_sg->length;
1636                         if (total > 0) {
1637                                         src_sg = scatterwalk_sg_next(src_sg);
1638                                 src_ll++;
1639                         }
1640                         WARN_ON(((total != 0) && (!src_sg)));
1641                 }
1642                 tegra_se_config_algo(se_dev, SE_AES_OP_MODE_CMAC, true,
1643                         cmac_ctx->keylen);
1644                 /* write zero IV */
1645                 memset(piv, 0, TEGRA_SE_AES_IV_SIZE);
1646                 tegra_se_write_key_table(piv, TEGRA_SE_AES_IV_SIZE,
1647                                         cmac_ctx->slot->slot_num,
1648                                         SE_KEY_TABLE_TYPE_ORGIV);
1649                 tegra_se_config_crypto(se_dev, SE_AES_OP_MODE_CMAC, true,
1650                                         cmac_ctx->slot->slot_num, true);
1651                 tegra_se_start_operation(se_dev,
1652                         blocks_to_process * TEGRA_SE_AES_BLOCK_SIZE, false);
1653                 src_sg = req->src;
1654                 while (mapped_sg_count--) {
1655                         dma_unmap_sg(se_dev->dev, src_sg, 1, DMA_TO_DEVICE);
1656                                 src_sg = scatterwalk_sg_next(src_sg);
1657                 }
1658                 use_orig_iv = false;
1659         }
1660
1661         /* get the last block bytes from the sg_dma buffer using miter */
1662         src_sg = req->src;
1663         num_sgs = tegra_se_count_sgs(req->src, req->nbytes, &chained);
1664         sg_flags |= SG_MITER_FROM_SG;
1665         sg_miter_start(&miter, req->src, num_sgs, sg_flags);
1666         local_irq_save(flags);
1667         total = 0;
1668         cmac_ctx->buffer = dma_alloc_coherent(se_dev->dev,
1669                                 TEGRA_SE_AES_BLOCK_SIZE,
1670                                 &cmac_ctx->dma_addr, GFP_KERNEL);
1671
1672         if (!cmac_ctx->buffer)
1673                 goto out;
1674
1675         temp_buffer = cmac_ctx->buffer;
1676         while (sg_miter_next(&miter) && total < req->nbytes) {
1677                 unsigned int len;
1678                 len = min(miter.length, req->nbytes - total);
1679                 if ((req->nbytes - (total + len)) <= last_block_bytes) {
1680                         bytes_to_copy =
1681                                 last_block_bytes -
1682                                 (req->nbytes - (total + len));
1683                         memcpy(temp_buffer, miter.addr + (len - bytes_to_copy),
1684                                 bytes_to_copy);
1685                         last_block_bytes -= bytes_to_copy;
1686                         temp_buffer += bytes_to_copy;
1687                 }
1688                 total += len;
1689         }
1690         sg_miter_stop(&miter);
1691         local_irq_restore(flags);
1692
1693         /* process last block */
1694         if (padding_needed) {
1695                 /* pad with 0x80, 0, 0 ... */
1696                 last_block_bytes = req->nbytes % TEGRA_SE_AES_BLOCK_SIZE;
1697                 cmac_ctx->buffer[last_block_bytes] = 0x80;
1698                 for (i = last_block_bytes+1; i < TEGRA_SE_AES_BLOCK_SIZE; i++)
1699                         cmac_ctx->buffer[i] = 0;
1700                 /* XOR with K2 */
1701                 for (i = 0; i < TEGRA_SE_AES_BLOCK_SIZE; i++)
1702                         cmac_ctx->buffer[i] ^= cmac_ctx->K2[i];
1703         } else {
1704                 /* XOR with K1 */
1705                 for (i = 0; i < TEGRA_SE_AES_BLOCK_SIZE; i++)
1706                         cmac_ctx->buffer[i] ^= cmac_ctx->K1[i];
1707         }
1708         *se_dev->src_ll_buf = 0;
1709         src_ll = (struct tegra_se_ll *)(se_dev->src_ll_buf + 1);
1710         src_ll->addr = cmac_ctx->dma_addr;
1711         src_ll->data_len = TEGRA_SE_AES_BLOCK_SIZE;
1712         dma_sync_single_for_device(se_dev->dev, cmac_ctx->dma_addr,
1713                                 TEGRA_SE_AES_BLOCK_SIZE, DMA_TO_DEVICE);
1714
1715         if (use_orig_iv) {
1716                 /* use zero IV, this is when num of bytes is
1717                         less <= block size */
1718                 memset(piv, 0, TEGRA_SE_AES_IV_SIZE);
1719                 tegra_se_write_key_table(piv, TEGRA_SE_AES_IV_SIZE,
1720                                         cmac_ctx->slot->slot_num,
1721                                         SE_KEY_TABLE_TYPE_ORGIV);
1722         }
1723
1724         tegra_se_config_algo(se_dev, SE_AES_OP_MODE_CMAC, true,
1725                                 cmac_ctx->keylen);
1726         tegra_se_config_crypto(se_dev, SE_AES_OP_MODE_CMAC, true,
1727                                 cmac_ctx->slot->slot_num, use_orig_iv);
1728         tegra_se_start_operation(se_dev, TEGRA_SE_AES_BLOCK_SIZE, false);
1729         tegra_se_read_hash_result(se_dev, req->result,
1730                                 TEGRA_SE_AES_CMAC_DIGEST_SIZE, false);
1731
1732 out:
1733
1734         pm_runtime_put(se_dev->dev);
1735         mutex_unlock(&se_hw_lock);
1736
1737         if (cmac_ctx->buffer) {
1738                 dma_sync_single_for_cpu(se_dev->dev, cmac_ctx->dma_addr,
1739                                 TEGRA_SE_AES_BLOCK_SIZE, DMA_FROM_DEVICE);
1740                 dma_free_coherent(se_dev->dev, TEGRA_SE_AES_BLOCK_SIZE,
1741                         cmac_ctx->buffer, cmac_ctx->dma_addr);
1742         }
1743
1744         return 0;
1745 }
1746
1747 int tegra_se_aes_cmac_setkey(struct crypto_ahash *tfm, const u8 *key,
1748                 unsigned int keylen)
1749 {
1750         struct tegra_se_aes_cmac_context *ctx = crypto_ahash_ctx(tfm);
1751         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
1752         struct tegra_se_ll *src_ll, *dst_ll;
1753         struct tegra_se_slot *pslot;
1754         u8 piv[TEGRA_SE_AES_IV_SIZE];
1755         u32 *pbuf;
1756         dma_addr_t pbuf_adr;
1757         int ret = 0;
1758         u8 const rb = 0x87;
1759         u8 msb;
1760
1761         if (!ctx) {
1762                 dev_err(se_dev->dev, "invalid context");
1763                 return -EINVAL;
1764         }
1765
1766         if ((keylen != TEGRA_SE_KEY_128_SIZE) &&
1767                 (keylen != TEGRA_SE_KEY_192_SIZE) &&
1768                 (keylen != TEGRA_SE_KEY_256_SIZE)) {
1769                 dev_err(se_dev->dev, "invalid key size");
1770                 return -EINVAL;
1771         }
1772
1773         if (key) {
1774                 if (!ctx->slot || (ctx->slot &&
1775                     ctx->slot->slot_num == ssk_slot.slot_num)) {
1776                         pslot = tegra_se_alloc_key_slot();
1777                         if (!pslot) {
1778                                 dev_err(se_dev->dev, "no free key slot\n");
1779                                 return -ENOMEM;
1780                         }
1781                         ctx->slot = pslot;
1782                 }
1783                 ctx->keylen = keylen;
1784         } else {
1785                 tegra_se_free_key_slot(ctx->slot);
1786                 ctx->slot = &ssk_slot;
1787                 ctx->keylen = AES_KEYSIZE_128;
1788         }
1789
1790         pbuf = dma_alloc_coherent(se_dev->dev, TEGRA_SE_AES_BLOCK_SIZE,
1791                 &pbuf_adr, GFP_KERNEL);
1792         if (!pbuf) {
1793                 dev_err(se_dev->dev, "can not allocate dma buffer");
1794                 return -ENOMEM;
1795         }
1796         memset(pbuf, 0, TEGRA_SE_AES_BLOCK_SIZE);
1797
1798         /* take access to the hw */
1799         mutex_lock(&se_hw_lock);
1800         pm_runtime_get_sync(se_dev->dev);
1801
1802         *se_dev->src_ll_buf = 0;
1803         *se_dev->dst_ll_buf = 0;
1804         src_ll = (struct tegra_se_ll *)(se_dev->src_ll_buf + 1);
1805         dst_ll = (struct tegra_se_ll *)(se_dev->dst_ll_buf + 1);
1806
1807         src_ll->addr = pbuf_adr;
1808         src_ll->data_len = TEGRA_SE_AES_BLOCK_SIZE;
1809         dst_ll->addr = pbuf_adr;
1810         dst_ll->data_len = TEGRA_SE_AES_BLOCK_SIZE;
1811
1812         /* load the key */
1813         tegra_se_write_key_table((u8 *)key, keylen,
1814                                 ctx->slot->slot_num, SE_KEY_TABLE_TYPE_KEY);
1815
1816         /* write zero IV */
1817         memset(piv, 0, TEGRA_SE_AES_IV_SIZE);
1818
1819         /* load IV */
1820         tegra_se_write_key_table(piv, TEGRA_SE_AES_IV_SIZE,
1821                                 ctx->slot->slot_num, SE_KEY_TABLE_TYPE_ORGIV);
1822
1823         /* config crypto algo */
1824         tegra_se_config_algo(se_dev, SE_AES_OP_MODE_CBC, true, keylen);
1825
1826         tegra_se_config_crypto(se_dev, SE_AES_OP_MODE_CBC, true,
1827                 ctx->slot->slot_num, true);
1828
1829         dma_sync_single_for_device(se_dev->dev, pbuf_adr,
1830                         TEGRA_SE_AES_BLOCK_SIZE, DMA_TO_DEVICE);
1831
1832         ret = tegra_se_start_operation(se_dev, TEGRA_SE_AES_BLOCK_SIZE, false);
1833         if (ret) {
1834                 dev_err(se_dev->dev, "tegra_se_aes_cmac_setkey:: start op failed\n");
1835                 goto out;
1836         }
1837
1838         dma_sync_single_for_cpu(se_dev->dev, pbuf_adr,
1839                         TEGRA_SE_AES_BLOCK_SIZE, DMA_FROM_DEVICE);
1840
1841
1842         /* compute K1 subkey */
1843         memcpy(ctx->K1, pbuf, TEGRA_SE_AES_BLOCK_SIZE);
1844         tegra_se_leftshift_onebit(ctx->K1, TEGRA_SE_AES_BLOCK_SIZE, &msb);
1845         if (msb)
1846                 ctx->K1[TEGRA_SE_AES_BLOCK_SIZE - 1] ^= rb;
1847
1848         /* compute K2 subkey */
1849         memcpy(ctx->K2, ctx->K1, TEGRA_SE_AES_BLOCK_SIZE);
1850         tegra_se_leftshift_onebit(ctx->K2, TEGRA_SE_AES_BLOCK_SIZE, &msb);
1851
1852         if (msb)
1853                 ctx->K2[TEGRA_SE_AES_BLOCK_SIZE - 1] ^= rb;
1854
1855 out:
1856         pm_runtime_put(se_dev->dev);
1857         mutex_unlock(&se_hw_lock);
1858
1859         dma_sync_single_for_cpu(se_dev->dev, pbuf_adr,
1860                         TEGRA_SE_AES_BLOCK_SIZE, DMA_FROM_DEVICE);
1861
1862         if (pbuf) {
1863                 dma_free_coherent(se_dev->dev, TEGRA_SE_AES_BLOCK_SIZE,
1864                         pbuf, pbuf_adr);
1865         }
1866
1867         return 0;
1868 }
1869
1870 int tegra_se_aes_cmac_digest(struct ahash_request *req)
1871 {
1872         return tegra_se_aes_cmac_init(req) ?: tegra_se_aes_cmac_final(req);
1873 }
1874
1875 int tegra_se_aes_cmac_finup(struct ahash_request *req)
1876 {
1877         return 0;
1878 }
1879
1880 int tegra_se_aes_cmac_cra_init(struct crypto_tfm *tfm)
1881 {
1882         crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),
1883                                  sizeof(struct tegra_se_aes_cmac_context));
1884
1885         return 0;
1886 }
1887 void tegra_se_aes_cmac_cra_exit(struct crypto_tfm *tfm)
1888 {
1889         struct tegra_se_aes_cmac_context *ctx = crypto_tfm_ctx(tfm);
1890
1891         tegra_se_free_key_slot(ctx->slot);
1892         ctx->slot = NULL;
1893 }
1894
1895 /* Security Engine rsa key slot */
1896 struct tegra_se_rsa_slot {
1897         struct list_head node;
1898         u8 slot_num;    /* Key slot number */
1899         bool available; /* Tells whether key slot is free to use */
1900 };
1901
1902
1903 /* Security Engine AES RSA context */
1904 struct tegra_se_aes_rsa_context {
1905         struct tegra_se_dev *se_dev;    /* Security Engine device */
1906         struct tegra_se_rsa_slot *slot; /* Security Engine rsa key slot */
1907         u32 keylen;     /* key length in bits */
1908 };
1909
1910 static void tegra_se_rsa_free_key_slot(struct tegra_se_rsa_slot *slot)
1911 {
1912         if (slot) {
1913                 spin_lock(&rsa_key_slot_lock);
1914                 slot->available = true;
1915                 spin_unlock(&rsa_key_slot_lock);
1916         }
1917 }
1918
1919 static struct tegra_se_rsa_slot *tegra_se_alloc_rsa_key_slot(void)
1920 {
1921         struct tegra_se_rsa_slot *slot = NULL;
1922         bool found = false;
1923
1924         spin_lock(&rsa_key_slot_lock);
1925         list_for_each_entry(slot, &key_slot, node) {
1926                 if (slot->available) {
1927                         slot->available = false;
1928                         found = true;
1929                         break;
1930                 }
1931         }
1932         spin_unlock(&rsa_key_slot_lock);
1933         return found ? slot : NULL;
1934 }
1935
1936 static int tegra_init_rsa_key_slot(struct tegra_se_dev *se_dev)
1937 {
1938         int i;
1939
1940         se_dev->rsa_slot_list = kzalloc(sizeof(struct tegra_se_rsa_slot) *
1941                                         TEGRA_SE_RSA_KEYSLOT_COUNT, GFP_KERNEL);
1942         if (se_dev->rsa_slot_list == NULL) {
1943                 dev_err(se_dev->dev, "rsa slot list memory allocation failed\n");
1944                 return -ENOMEM;
1945         }
1946         spin_lock_init(&rsa_key_slot_lock);
1947         spin_lock(&rsa_key_slot_lock);
1948         for (i = 0; i < TEGRA_SE_RSA_KEYSLOT_COUNT; i++) {
1949                 se_dev->rsa_slot_list[i].available = true;
1950                 se_dev->rsa_slot_list[i].slot_num = i;
1951                 INIT_LIST_HEAD(&se_dev->rsa_slot_list[i].node);
1952                 list_add_tail(&se_dev->rsa_slot_list[i].node, &key_slot);
1953         }
1954         spin_unlock(&rsa_key_slot_lock);
1955
1956         return 0;
1957 }
1958
1959 int tegra_se_rsa_init(struct ahash_request *req)
1960 {
1961         return 0;
1962 }
1963
1964 int tegra_se_rsa_update(struct ahash_request *req)
1965 {
1966         return 0;
1967 }
1968
1969 int tegra_se_rsa_final(struct ahash_request *req)
1970 {
1971         return 0;
1972 }
1973
1974 int tegra_se_rsa_setkey(struct crypto_ahash *tfm, const u8 *key,
1975                 unsigned int keylen)
1976 {
1977         struct tegra_se_aes_rsa_context *ctx = crypto_ahash_ctx(tfm);
1978         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
1979         u32 module_key_length = 0;
1980         u32 exponent_key_length = 0;
1981         u32 pkt, val;
1982         u32 key_size_words;
1983         u32 key_word_size = 4;
1984         u32 *pkeydata = (u32 *)key;
1985         s32 i = 0;
1986         struct tegra_se_rsa_slot *pslot;
1987         unsigned long freq = 0;
1988         int err = 0;
1989
1990         if (!ctx || !key)
1991                 return -EINVAL;
1992
1993         /* Allocate rsa key slot */
1994         pslot = tegra_se_alloc_rsa_key_slot();
1995         if (!pslot) {
1996                 dev_err(se_dev->dev, "no free key slot\n");
1997                 return -ENOMEM;
1998         }
1999         ctx->slot = pslot;
2000         ctx->keylen = keylen;
2001
2002         module_key_length = (keylen >> 16);
2003         exponent_key_length = (keylen & (0xFFFF));
2004
2005         if (!(((module_key_length / 64) >= 1) &&
2006                         ((module_key_length / 64) <= 4)))
2007                 return -EINVAL;
2008
2009         freq = se_dev->chipdata->rsa_freq;
2010         err = clk_set_rate(se_dev->pclk, freq);
2011         if (err) {
2012                 dev_err(se_dev->dev, "clock set_rate failed.\n");
2013                 return err;
2014         }
2015
2016         /* take access to the hw */
2017         mutex_lock(&se_hw_lock);
2018         pm_runtime_get_sync(se_dev->dev);
2019
2020         /* Write key length */
2021         se_writel(se_dev, ((module_key_length / 64) - 1),
2022                 SE_RSA_KEY_SIZE_REG_OFFSET);
2023
2024         /* Write exponent size in 32 bytes */
2025         se_writel(se_dev, (exponent_key_length / 4),
2026                 SE_RSA_EXP_SIZE_REG_OFFSET);
2027
2028         if (exponent_key_length) {
2029                 key_size_words = (exponent_key_length / key_word_size);
2030                 /* Write exponent */
2031                 for (i = (key_size_words - 1); i >= 0; i--) {
2032                         se_writel(se_dev, *pkeydata++, SE_RSA_KEYTABLE_DATA);
2033                         pkt = RSA_KEY_INPUT_MODE(RSA_KEY_INPUT_MODE_REG) |
2034                                 RSA_KEY_NUM(ctx->slot->slot_num) |
2035                                 RSA_KEY_TYPE(RSA_KEY_TYPE_EXP) |
2036                                 RSA_KEY_PKT_WORD_ADDR(i);
2037                         val = SE_RSA_KEY_OP(RSA_KEY_WRITE) |
2038                                         SE_RSA_KEYTABLE_PKT(pkt);
2039
2040                         se_writel(se_dev, val, SE_RSA_KEYTABLE_ADDR);
2041                 }
2042         }
2043
2044         if (module_key_length) {
2045                 key_size_words = (module_key_length / key_word_size);
2046                 /* Write moduleus */
2047                 for (i = (key_size_words - 1); i >= 0; i--) {
2048                         se_writel(se_dev, *pkeydata++, SE_RSA_KEYTABLE_DATA);
2049                         pkt = RSA_KEY_INPUT_MODE(RSA_KEY_INPUT_MODE_REG) |
2050                                 RSA_KEY_NUM(ctx->slot->slot_num) |
2051                                 RSA_KEY_TYPE(RSA_KEY_TYPE_MOD) |
2052                                 RSA_KEY_PKT_WORD_ADDR(i);
2053                         val = SE_RSA_KEY_OP(RSA_KEY_WRITE) |
2054                                         SE_RSA_KEYTABLE_PKT(pkt);
2055
2056                         se_writel(se_dev, val, SE_RSA_KEYTABLE_ADDR);
2057                 }
2058         }
2059         pm_runtime_put(se_dev->dev);
2060         mutex_unlock(&se_hw_lock);
2061         return 0;
2062 }
2063
2064 static void tegra_se_read_rsa_result(struct tegra_se_dev *se_dev,
2065         u8 *pdata, unsigned int nbytes)
2066 {
2067         u32 *result = (u32 *)pdata;
2068         u32 i;
2069
2070         for (i = 0; i < nbytes / 4; i++)
2071                 result[i] = se_readl(se_dev, SE_RSA_OUTPUT +
2072                                 (i * sizeof(u32)));
2073 }
2074
2075 int tegra_se_rsa_digest(struct ahash_request *req)
2076 {
2077         struct crypto_ahash *tfm = NULL;
2078         struct tegra_se_aes_rsa_context *rsa_ctx = NULL;
2079         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
2080         struct scatterlist *src_sg;
2081         struct tegra_se_ll *src_ll;
2082         u32 num_sgs;
2083         int total, ret = 0;
2084         u32 val = 0;
2085         int chained;
2086
2087         if (!req)
2088                 return -EINVAL;
2089
2090         tfm = crypto_ahash_reqtfm(req);
2091
2092         if (!tfm)
2093                 return -EINVAL;
2094
2095         rsa_ctx = crypto_ahash_ctx(tfm);
2096
2097         if (!rsa_ctx || !rsa_ctx->slot)
2098                 return -EINVAL;
2099
2100         if (!req->nbytes)
2101                 return -EINVAL;
2102
2103         if ((req->nbytes < TEGRA_SE_RSA512_DIGEST_SIZE) ||
2104                         (req->nbytes > TEGRA_SE_RSA2048_DIGEST_SIZE))
2105                 return -EINVAL;
2106
2107         num_sgs = tegra_se_count_sgs(req->src, req->nbytes, &chained);
2108         if (num_sgs > SE_MAX_SRC_SG_COUNT) {
2109                 dev_err(se_dev->dev, "num of SG buffers are more\n");
2110                 return -EINVAL;
2111         }
2112
2113         *se_dev->src_ll_buf = num_sgs - 1;
2114         src_ll = (struct tegra_se_ll *)(se_dev->src_ll_buf + 1);
2115         src_sg = req->src;
2116         total = req->nbytes;
2117
2118         while (total > 0) {
2119                 ret = dma_map_sg(se_dev->dev, src_sg, 1, DMA_TO_DEVICE);
2120                 if (!ret) {
2121                         dev_err(se_dev->dev, "dma_map_sg() error\n");
2122                         goto out;
2123                 }
2124                 src_ll->addr = sg_dma_address(src_sg);
2125                 src_ll->data_len = src_sg->length;
2126
2127                 total -= src_sg->length;
2128                 if (total > 0) {
2129                                 src_sg = scatterwalk_sg_next(src_sg);
2130                         src_ll++;
2131                 }
2132                 WARN_ON(((total != 0) && (!src_sg)));
2133         }
2134
2135         /* take access to the hw */
2136         mutex_lock(&se_hw_lock);
2137         pm_runtime_get_sync(se_dev->dev);
2138
2139         val = SE_CONFIG_ENC_ALG(ALG_RSA) |
2140                 SE_CONFIG_DEC_ALG(ALG_NOP) |
2141                 SE_CONFIG_DST(DST_RSAREG);
2142         se_writel(se_dev, val, SE_CONFIG_REG_OFFSET);
2143         se_writel(se_dev, RSA_KEY_SLOT(rsa_ctx->slot->slot_num), SE_RSA_CONFIG);
2144         se_writel(se_dev, SE_CRYPTO_INPUT_SEL(INPUT_AHB), SE_CRYPTO_REG_OFFSET);
2145
2146         ret = tegra_se_start_operation(se_dev, 256, false);
2147         if (ret) {
2148                 dev_err(se_dev->dev, "tegra_se_aes_rsa_digest:: start op failed\n");
2149                 pm_runtime_put_sync(se_dev->dev);
2150                 mutex_unlock(&se_hw_lock);
2151                 goto out;
2152         }
2153
2154         tegra_se_read_rsa_result(se_dev, req->result, req->nbytes);
2155
2156         pm_runtime_put_sync(se_dev->dev);
2157         mutex_unlock(&se_hw_lock);
2158
2159 out:
2160         return ret;
2161 }
2162
2163 int tegra_se_rsa_finup(struct ahash_request *req)
2164 {
2165         return 0;
2166 }
2167
2168 int tegra_se_rsa_cra_init(struct crypto_tfm *tfm)
2169 {
2170         return 0;
2171 }
2172
2173 void tegra_se_rsa_cra_exit(struct crypto_tfm *tfm)
2174 {
2175         struct tegra_se_aes_rsa_context *ctx = crypto_tfm_ctx(tfm);
2176
2177         tegra_se_rsa_free_key_slot(ctx->slot);
2178         ctx->slot = NULL;
2179 }
2180
2181 static struct crypto_alg aes_algs[] = {
2182         {
2183                 .cra_name = "cbc(aes)",
2184                 .cra_driver_name = "cbc-aes-tegra",
2185                 .cra_priority = 300,
2186                 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
2187                 .cra_blocksize = TEGRA_SE_AES_BLOCK_SIZE,
2188                 .cra_ctxsize  = sizeof(struct tegra_se_aes_context),
2189                 .cra_alignmask = 0,
2190                 .cra_type = &crypto_ablkcipher_type,
2191                 .cra_module = THIS_MODULE,
2192                 .cra_init = tegra_se_aes_cra_init,
2193                 .cra_exit = tegra_se_aes_cra_exit,
2194                 .cra_u.ablkcipher = {
2195                         .min_keysize = TEGRA_SE_AES_MIN_KEY_SIZE,
2196                         .max_keysize = TEGRA_SE_AES_MAX_KEY_SIZE,
2197                         .ivsize = TEGRA_SE_AES_IV_SIZE,
2198                         .setkey = tegra_se_aes_setkey,
2199                         .encrypt = tegra_se_aes_cbc_encrypt,
2200                         .decrypt = tegra_se_aes_cbc_decrypt,
2201                 }
2202         }, {
2203                 .cra_name = "ecb(aes)",
2204                 .cra_driver_name = "ecb-aes-tegra",
2205                 .cra_priority = 300,
2206                 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
2207                 .cra_blocksize = TEGRA_SE_AES_BLOCK_SIZE,
2208                 .cra_ctxsize  = sizeof(struct tegra_se_aes_context),
2209                 .cra_alignmask = 0,
2210                 .cra_type = &crypto_ablkcipher_type,
2211                 .cra_module = THIS_MODULE,
2212                 .cra_init = tegra_se_aes_cra_init,
2213                 .cra_exit = tegra_se_aes_cra_exit,
2214                 .cra_u.ablkcipher = {
2215                         .min_keysize = TEGRA_SE_AES_MIN_KEY_SIZE,
2216                         .max_keysize = TEGRA_SE_AES_MAX_KEY_SIZE,
2217                         .ivsize = TEGRA_SE_AES_IV_SIZE,
2218                         .setkey = tegra_se_aes_setkey,
2219                         .encrypt = tegra_se_aes_ecb_encrypt,
2220                         .decrypt = tegra_se_aes_ecb_decrypt,
2221                 }
2222         }, {
2223                 .cra_name = "ctr(aes)",
2224                 .cra_driver_name = "ctr-aes-tegra",
2225                 .cra_priority = 300,
2226                 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
2227                 .cra_blocksize = TEGRA_SE_AES_BLOCK_SIZE,
2228                 .cra_ctxsize  = sizeof(struct tegra_se_aes_context),
2229                 .cra_alignmask = 0,
2230                 .cra_type = &crypto_ablkcipher_type,
2231                 .cra_module = THIS_MODULE,
2232                 .cra_init = tegra_se_aes_cra_init,
2233                 .cra_exit = tegra_se_aes_cra_exit,
2234                 .cra_u.ablkcipher = {
2235                         .min_keysize = TEGRA_SE_AES_MIN_KEY_SIZE,
2236                         .max_keysize = TEGRA_SE_AES_MAX_KEY_SIZE,
2237                         .ivsize = TEGRA_SE_AES_IV_SIZE,
2238                         .setkey = tegra_se_aes_setkey,
2239                         .encrypt = tegra_se_aes_ctr_encrypt,
2240                         .decrypt = tegra_se_aes_ctr_decrypt,
2241                         .geniv = "eseqiv",
2242                 }
2243         }, {
2244                 .cra_name = "ofb(aes)",
2245                 .cra_driver_name = "ofb-aes-tegra",
2246                 .cra_priority = 300,
2247                 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
2248                 .cra_blocksize = TEGRA_SE_AES_BLOCK_SIZE,
2249                 .cra_ctxsize  = sizeof(struct tegra_se_aes_context),
2250                 .cra_alignmask = 0,
2251                 .cra_type = &crypto_ablkcipher_type,
2252                 .cra_module = THIS_MODULE,
2253                 .cra_init = tegra_se_aes_cra_init,
2254                 .cra_exit = tegra_se_aes_cra_exit,
2255                 .cra_u.ablkcipher = {
2256                         .min_keysize = TEGRA_SE_AES_MIN_KEY_SIZE,
2257                         .max_keysize = TEGRA_SE_AES_MAX_KEY_SIZE,
2258                         .ivsize = TEGRA_SE_AES_IV_SIZE,
2259                         .setkey = tegra_se_aes_setkey,
2260                         .encrypt = tegra_se_aes_ofb_encrypt,
2261                         .decrypt = tegra_se_aes_ofb_decrypt,
2262                         .geniv = "eseqiv",
2263                 }
2264         }, {
2265                 .cra_name = "ansi_cprng",
2266                 .cra_driver_name = "rng-aes-tegra",
2267                 .cra_priority = 100,
2268                 .cra_flags = CRYPTO_ALG_TYPE_RNG,
2269                 .cra_ctxsize = sizeof(struct tegra_se_rng_context),
2270                 .cra_type = &crypto_rng_type,
2271                 .cra_module = THIS_MODULE,
2272                 .cra_init = tegra_se_rng_init,
2273                 .cra_exit = tegra_se_rng_exit,
2274                 .cra_u = {
2275                         .rng = {
2276                                 .rng_make_random = tegra_se_rng_get_random,
2277                                 .rng_reset = tegra_se_rng_reset,
2278                                 .seedsize = TEGRA_SE_RNG_SEED_SIZE,
2279                         }
2280                 }
2281         }, {
2282                 .cra_name = "rng_drbg",
2283                 .cra_driver_name = "rng_drbg-aes-tegra",
2284                 .cra_priority = 100,
2285                 .cra_flags = CRYPTO_ALG_TYPE_RNG,
2286                 .cra_ctxsize = sizeof(struct tegra_se_rng_context),
2287                 .cra_type = &crypto_rng_type,
2288                 .cra_module = THIS_MODULE,
2289                 .cra_init = tegra_se_rng_drbg_init,
2290                 .cra_exit = tegra_se_rng_drbg_exit,
2291                 .cra_u = {
2292                         .rng = {
2293                                 .rng_make_random = tegra_se_rng_drbg_get_random,
2294                                 .rng_reset = tegra_se_rng_drbg_reset,
2295                                 .seedsize = TEGRA_SE_RNG_SEED_SIZE,
2296                         }
2297                 }
2298         }
2299 };
2300
2301 static struct ahash_alg hash_algs[] = {
2302         {
2303                 .init = tegra_se_aes_cmac_init,
2304                 .update = tegra_se_aes_cmac_update,
2305                 .final = tegra_se_aes_cmac_final,
2306                 .finup = tegra_se_aes_cmac_finup,
2307                 .digest = tegra_se_aes_cmac_digest,
2308                 .setkey = tegra_se_aes_cmac_setkey,
2309                 .halg.digestsize = TEGRA_SE_AES_CMAC_DIGEST_SIZE,
2310                 .halg.base = {
2311                         .cra_name = "cmac(aes)",
2312                         .cra_driver_name = "tegra-se-cmac(aes)",
2313                         .cra_priority = 100,
2314                         .cra_flags = CRYPTO_ALG_TYPE_AHASH,
2315                         .cra_blocksize = TEGRA_SE_AES_BLOCK_SIZE,
2316                         .cra_ctxsize = sizeof(struct tegra_se_aes_cmac_context),
2317                         .cra_alignmask = 0,
2318                         .cra_module     = THIS_MODULE,
2319                         .cra_init       = tegra_se_aes_cmac_cra_init,
2320                         .cra_exit       = tegra_se_aes_cmac_cra_exit,
2321                 }
2322         }, {
2323                 .init = tegra_se_sha_init,
2324                 .update = tegra_se_sha_update,
2325                 .final = tegra_se_sha_final,
2326                 .finup = tegra_se_sha_finup,
2327                 .digest = tegra_se_sha_digest,
2328                 .halg.digestsize = SHA1_DIGEST_SIZE,
2329                 .halg.base = {
2330                         .cra_name = "sha1",
2331                         .cra_driver_name = "tegra-se-sha1",
2332                         .cra_priority = 100,
2333                         .cra_flags = CRYPTO_ALG_TYPE_AHASH,
2334                         .cra_blocksize = SHA1_BLOCK_SIZE,
2335                         .cra_ctxsize = sizeof(struct tegra_se_sha_context),
2336                         .cra_alignmask = 0,
2337                         .cra_module = THIS_MODULE,
2338                         .cra_init = tegra_se_sha_cra_init,
2339                         .cra_exit = tegra_se_sha_cra_exit,
2340                 }
2341         }, {
2342                 .init = tegra_se_sha_init,
2343                 .update = tegra_se_sha_update,
2344                 .final = tegra_se_sha_final,
2345                 .finup = tegra_se_sha_finup,
2346                 .digest = tegra_se_sha_digest,
2347                 .halg.digestsize = SHA224_DIGEST_SIZE,
2348                 .halg.base = {
2349                         .cra_name = "sha224",
2350                         .cra_driver_name = "tegra-se-sha224",
2351                         .cra_priority = 100,
2352                         .cra_flags = CRYPTO_ALG_TYPE_AHASH,
2353                         .cra_blocksize = SHA224_BLOCK_SIZE,
2354                         .cra_ctxsize = sizeof(struct tegra_se_sha_context),
2355                         .cra_alignmask = 0,
2356                         .cra_module = THIS_MODULE,
2357                         .cra_init = tegra_se_sha_cra_init,
2358                         .cra_exit = tegra_se_sha_cra_exit,
2359                 }
2360         }, {
2361                 .init = tegra_se_sha_init,
2362                 .update = tegra_se_sha_update,
2363                 .final = tegra_se_sha_final,
2364                 .finup = tegra_se_sha_finup,
2365                 .digest = tegra_se_sha_digest,
2366                 .halg.digestsize = SHA256_DIGEST_SIZE,
2367                 .halg.base = {
2368                         .cra_name = "sha256",
2369                         .cra_driver_name = "tegra-se-sha256",
2370                         .cra_priority = 100,
2371                         .cra_flags = CRYPTO_ALG_TYPE_AHASH,
2372                         .cra_blocksize = SHA256_BLOCK_SIZE,
2373                         .cra_ctxsize = sizeof(struct tegra_se_sha_context),
2374                         .cra_alignmask = 0,
2375                         .cra_module = THIS_MODULE,
2376                         .cra_init = tegra_se_sha_cra_init,
2377                         .cra_exit = tegra_se_sha_cra_exit,
2378                 }
2379         }, {
2380                 .init = tegra_se_sha_init,
2381                 .update = tegra_se_sha_update,
2382                 .final = tegra_se_sha_final,
2383                 .finup = tegra_se_sha_finup,
2384                 .digest = tegra_se_sha_digest,
2385                 .halg.digestsize = SHA384_DIGEST_SIZE,
2386                 .halg.base = {
2387                         .cra_name = "sha384",
2388                         .cra_driver_name = "tegra-se-sha384",
2389                         .cra_priority = 100,
2390                         .cra_flags = CRYPTO_ALG_TYPE_AHASH,
2391                         .cra_blocksize = SHA384_BLOCK_SIZE,
2392                         .cra_ctxsize = sizeof(struct tegra_se_sha_context),
2393                         .cra_alignmask = 0,
2394                         .cra_module = THIS_MODULE,
2395                         .cra_init = tegra_se_sha_cra_init,
2396                         .cra_exit = tegra_se_sha_cra_exit,
2397                 }
2398         }, {
2399                 .init = tegra_se_sha_init,
2400                 .update = tegra_se_sha_update,
2401                 .final = tegra_se_sha_final,
2402                 .finup = tegra_se_sha_finup,
2403                 .digest = tegra_se_sha_digest,
2404                 .halg.digestsize = SHA512_DIGEST_SIZE,
2405                 .halg.base = {
2406                         .cra_name = "sha512",
2407                         .cra_driver_name = "tegra-se-sha512",
2408                         .cra_priority = 100,
2409                         .cra_flags = CRYPTO_ALG_TYPE_AHASH,
2410                         .cra_blocksize = SHA512_BLOCK_SIZE,
2411                         .cra_ctxsize = sizeof(struct tegra_se_sha_context),
2412                         .cra_alignmask = 0,
2413                         .cra_module = THIS_MODULE,
2414                         .cra_init = tegra_se_sha_cra_init,
2415                         .cra_exit = tegra_se_sha_cra_exit,
2416                 }
2417         }, {
2418                 .init = tegra_se_rsa_init,
2419                 .update = tegra_se_rsa_update,
2420                 .final = tegra_se_rsa_final,
2421                 .finup = tegra_se_rsa_finup,
2422                 .digest = tegra_se_rsa_digest,
2423                 .setkey = tegra_se_rsa_setkey,
2424                 .halg.digestsize = TEGRA_SE_RSA512_DIGEST_SIZE,
2425                 .halg.base = {
2426                         .cra_name = "rsa512",
2427                         .cra_driver_name = "tegra-se-rsa512",
2428                         .cra_priority = 100,
2429                         .cra_flags = CRYPTO_ALG_TYPE_AHASH,
2430                         .cra_blocksize = TEGRA_SE_RSA512_DIGEST_SIZE,
2431                         .cra_ctxsize = sizeof(struct tegra_se_aes_cmac_context),
2432                         .cra_alignmask = 0,
2433                         .cra_module = THIS_MODULE,
2434                         .cra_init = tegra_se_rsa_cra_init,
2435                         .cra_exit = tegra_se_rsa_cra_exit,
2436                 }
2437         }, {
2438                 .init = tegra_se_rsa_init,
2439                 .update = tegra_se_rsa_update,
2440                 .final = tegra_se_rsa_final,
2441                 .finup = tegra_se_rsa_finup,
2442                 .digest = tegra_se_rsa_digest,
2443                 .setkey = tegra_se_rsa_setkey,
2444                 .halg.digestsize = TEGRA_SE_RSA1024_DIGEST_SIZE,
2445                 .halg.base = {
2446                         .cra_name = "rsa1024",
2447                         .cra_driver_name = "tegra-se-rsa1024",
2448                         .cra_priority = 100,
2449                         .cra_flags = CRYPTO_ALG_TYPE_AHASH,
2450                         .cra_blocksize = TEGRA_SE_RSA1024_DIGEST_SIZE,
2451                         .cra_ctxsize = sizeof(struct tegra_se_aes_cmac_context),
2452                         .cra_alignmask = 0,
2453                         .cra_module = THIS_MODULE,
2454                         .cra_init = tegra_se_rsa_cra_init,
2455                         .cra_exit = tegra_se_rsa_cra_exit,
2456                 }
2457         }, {
2458                 .init = tegra_se_rsa_init,
2459                 .update = tegra_se_rsa_update,
2460                 .final = tegra_se_rsa_final,
2461                 .finup = tegra_se_rsa_finup,
2462                 .digest = tegra_se_rsa_digest,
2463                 .setkey = tegra_se_rsa_setkey,
2464                 .halg.digestsize = TEGRA_SE_RSA1536_DIGEST_SIZE,
2465                 .halg.base = {
2466                         .cra_name = "rsa1536",
2467                         .cra_driver_name = "tegra-se-rsa1536",
2468                         .cra_priority = 100,
2469                         .cra_flags = CRYPTO_ALG_TYPE_AHASH,
2470                         .cra_blocksize = TEGRA_SE_RSA1536_DIGEST_SIZE,
2471                         .cra_ctxsize = sizeof(struct tegra_se_aes_cmac_context),
2472                         .cra_alignmask = 0,
2473                         .cra_module = THIS_MODULE,
2474                         .cra_init = tegra_se_rsa_cra_init,
2475                         .cra_exit = tegra_se_rsa_cra_exit,
2476                 }
2477         }, {
2478                 .init = tegra_se_rsa_init,
2479                 .update = tegra_se_rsa_update,
2480                 .final = tegra_se_rsa_final,
2481                 .finup = tegra_se_rsa_finup,
2482                 .digest = tegra_se_rsa_digest,
2483                 .setkey = tegra_se_rsa_setkey,
2484                 .halg.digestsize = TEGRA_SE_RSA2048_DIGEST_SIZE,
2485                 .halg.base = {
2486                         .cra_name = "rsa2048",
2487                         .cra_driver_name = "tegra-se-rsa2048",
2488                         .cra_priority = 100,
2489                         .cra_flags = CRYPTO_ALG_TYPE_AHASH,
2490                         .cra_blocksize = TEGRA_SE_RSA2048_DIGEST_SIZE,
2491                         .cra_ctxsize = sizeof(struct tegra_se_aes_cmac_context),
2492                         .cra_alignmask = 0,
2493                         .cra_module = THIS_MODULE,
2494                         .cra_init = tegra_se_rsa_cra_init,
2495                         .cra_exit = tegra_se_rsa_cra_exit,
2496                 }
2497         }
2498 };
2499
2500 bool isAlgoSupported(struct tegra_se_dev *se_dev, const char *algo)
2501 {
2502         if (!strcmp(algo, "ansi_cprng")) {
2503                 if (se_dev->chipdata->cprng_supported)
2504                         return true;
2505                 else
2506                         return false;
2507         }
2508
2509         if (!strcmp(algo, "drbg")) {
2510                 if (se_dev->chipdata->drbg_supported)
2511                         return true;
2512                 else
2513                         return false;
2514         }
2515
2516         if (!strcmp(algo, "rsa512") || !strcmp(algo, "rsa1024") ||
2517                 !strcmp(algo, "rsa1536") || !strcmp(algo, "rsa2048")) {
2518                 if (se_dev->chipdata->rsa_supported)
2519                         return true;
2520                 else
2521                         return false;
2522         }
2523
2524         return true;
2525 }
2526
2527 static int tegra_se_probe(struct platform_device *pdev)
2528 {
2529         struct tegra_se_dev *se_dev = NULL;
2530         struct resource *res = NULL;
2531         int err = 0, i = 0, j = 0, k = 0;
2532
2533         se_dev = kzalloc(sizeof(struct tegra_se_dev), GFP_KERNEL);
2534         if (!se_dev) {
2535                 dev_err(&pdev->dev, "memory allocation failed\n");
2536                 return -ENOMEM;
2537         }
2538
2539         spin_lock_init(&se_dev->lock);
2540         crypto_init_queue(&se_dev->queue, TEGRA_SE_CRYPTO_QUEUE_LENGTH);
2541         platform_set_drvdata(pdev, se_dev);
2542         se_dev->dev = &pdev->dev;
2543
2544         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2545         if (!res) {
2546                 err = -ENXIO;
2547                 dev_err(se_dev->dev, "platform_get_resource failed\n");
2548                 goto fail;
2549         }
2550
2551         se_dev->io_reg = ioremap(res->start, resource_size(res));
2552         if (!se_dev->io_reg) {
2553                 err = -ENOMEM;
2554                 dev_err(se_dev->dev, "ioremap failed\n");
2555                 goto fail;
2556         }
2557
2558         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
2559         if (!res) {
2560                 err = -ENXIO;
2561                 dev_err(se_dev->dev, "platform_get_resource failed\n");
2562                 goto err_pmc;
2563         }
2564
2565         se_dev->pmc_io_reg = ioremap(res->start, resource_size(res));
2566         if (!se_dev->pmc_io_reg) {
2567                 err = -ENOMEM;
2568                 dev_err(se_dev->dev, "pmc ioremap failed\n");
2569                 goto err_pmc;
2570         }
2571
2572         se_dev->irq = platform_get_irq(pdev, 0);
2573         if (!se_dev->irq) {
2574                 err = -ENODEV;
2575                 dev_err(se_dev->dev, "platform_get_irq failed\n");
2576                 goto err_irq;
2577         }
2578
2579         se_dev->chipdata =
2580                 (struct tegra_se_chipdata *)pdev->id_entry->driver_data;
2581
2582         /* Initialize the clock */
2583         se_dev->pclk = clk_get(se_dev->dev, "se");
2584         if (IS_ERR(se_dev->pclk)) {
2585                 dev_err(se_dev->dev, "clock intialization failed (%d)\n",
2586                         (int)se_dev->pclk);
2587                 err = -ENODEV;
2588                 goto clean;
2589         }
2590
2591         err = clk_set_rate(se_dev->pclk, ULONG_MAX);
2592         if (err) {
2593                 dev_err(se_dev->dev, "clock set_rate failed.\n");
2594                 goto clean;
2595         }
2596
2597         err = tegra_init_key_slot(se_dev);
2598         if (err) {
2599                 dev_err(se_dev->dev, "init_key_slot failed\n");
2600                 goto clean;
2601         }
2602
2603         err = tegra_init_rsa_key_slot(se_dev);
2604         if (err) {
2605                 dev_err(se_dev->dev, "init_rsa_key_slot failed\n");
2606                 goto clean;
2607         }
2608
2609         init_completion(&se_dev->complete);
2610         se_work_q = alloc_workqueue("se_work_q", WQ_HIGHPRI | WQ_UNBOUND, 16);
2611         if (!se_work_q) {
2612                 dev_err(se_dev->dev, "alloc_workqueue failed\n");
2613                 goto clean;
2614         }
2615
2616         sg_tegra_se_dev = se_dev;
2617         tegra_pd_add_device(&tegra_mc_chain_b, se_dev->dev);
2618         pm_runtime_enable(se_dev->dev);
2619         tegra_se_key_read_disable_all();
2620
2621         err = request_irq(se_dev->irq, tegra_se_irq, IRQF_DISABLED,
2622                         DRIVER_NAME, se_dev);
2623         if (err) {
2624                 dev_err(se_dev->dev, "request_irq failed - irq[%d] err[%d]\n",
2625                         se_dev->irq, err);
2626                 goto err_irq;
2627         }
2628
2629         err = tegra_se_alloc_ll_buf(se_dev, SE_MAX_SRC_SG_COUNT,
2630                 SE_MAX_DST_SG_COUNT);
2631         if (err) {
2632                 dev_err(se_dev->dev, "can not allocate ll dma buffer\n");
2633                 goto clean;
2634         }
2635
2636         for (i = 0; i < ARRAY_SIZE(aes_algs); i++) {
2637                 if (isAlgoSupported(se_dev, aes_algs[i].cra_name)) {
2638                         INIT_LIST_HEAD(&aes_algs[i].cra_list);
2639                         err = crypto_register_alg(&aes_algs[i]);
2640                         if (err) {
2641                                 dev_err(se_dev->dev,
2642                                 "crypto_register_alg failed index[%d]\n", i);
2643                                 goto clean;
2644                         }
2645                 }
2646         }
2647
2648         for (j = 0; j < ARRAY_SIZE(hash_algs); j++) {
2649                 if (isAlgoSupported(se_dev, hash_algs[j].halg.base.cra_name)) {
2650                         err = crypto_register_ahash(&hash_algs[j]);
2651                         if (err) {
2652                                 dev_err(se_dev->dev,
2653                                 "crypto_register_sha alg failed index[%d]\n",
2654                                 i);
2655                                 goto clean;
2656                         }
2657                 }
2658         }
2659
2660 #if defined(CONFIG_PM)
2661         if (!se_dev->chipdata->drbg_supported)
2662                 se_dev->ctx_save_buf = dma_alloc_coherent(se_dev->dev,
2663                         SE_CONTEXT_BUFER_SIZE, &se_dev->ctx_save_buf_adr,
2664                         GFP_KERNEL);
2665         else
2666                 se_dev->ctx_save_buf = dma_alloc_coherent(se_dev->dev,
2667                         SE_CONTEXT_DRBG_BUFER_SIZE,
2668                         &se_dev->ctx_save_buf_adr, GFP_KERNEL);
2669
2670         if (!se_dev->ctx_save_buf) {
2671                 dev_err(se_dev->dev, "Context save buffer alloc filed\n");
2672                 goto clean;
2673         }
2674 #endif
2675
2676         dev_info(se_dev->dev, "%s: complete", __func__);
2677         return 0;
2678
2679 clean:
2680         pm_runtime_disable(se_dev->dev);
2681         for (k = 0; k < i; k++)
2682                 crypto_unregister_alg(&aes_algs[k]);
2683
2684         for (k = 0; k < j; k++)
2685                 crypto_unregister_ahash(&hash_algs[j]);
2686
2687         tegra_se_free_ll_buf(se_dev);
2688
2689         if (se_work_q)
2690                 destroy_workqueue(se_work_q);
2691
2692         if (se_dev->pclk)
2693                 clk_put(se_dev->pclk);
2694
2695         free_irq(se_dev->irq, &pdev->dev);
2696
2697 err_irq:
2698         iounmap(se_dev->pmc_io_reg);
2699 err_pmc:
2700         iounmap(se_dev->io_reg);
2701
2702 fail:
2703         platform_set_drvdata(pdev, NULL);
2704         kfree(se_dev);
2705         sg_tegra_se_dev = NULL;
2706
2707         return err;
2708 }
2709
2710 static int tegra_se_remove(struct platform_device *pdev)
2711 {
2712         struct tegra_se_dev *se_dev = platform_get_drvdata(pdev);
2713         int i;
2714
2715         if (!se_dev)
2716                 return -ENODEV;
2717
2718         pm_runtime_disable(se_dev->dev);
2719
2720         cancel_work_sync(&se_work);
2721         if (se_work_q)
2722                 destroy_workqueue(se_work_q);
2723         free_irq(se_dev->irq, &pdev->dev);
2724         for (i = 0; i < ARRAY_SIZE(aes_algs); i++)
2725                 crypto_unregister_alg(&aes_algs[i]);
2726         for (i = 0; i < ARRAY_SIZE(hash_algs); i++)
2727                 crypto_unregister_ahash(&hash_algs[i]);
2728         if (se_dev->pclk)
2729                 clk_put(se_dev->pclk);
2730         tegra_se_free_ll_buf(se_dev);
2731         if (se_dev->ctx_save_buf) {
2732                 if (!se_dev->chipdata->drbg_supported)
2733                         dma_free_coherent(se_dev->dev, SE_CONTEXT_BUFER_SIZE,
2734                                 se_dev->ctx_save_buf, se_dev->ctx_save_buf_adr);
2735                 else
2736                         dma_free_coherent(se_dev->dev,
2737                                 SE_CONTEXT_DRBG_BUFER_SIZE,
2738                                 se_dev->ctx_save_buf, se_dev->ctx_save_buf_adr);
2739                 se_dev->ctx_save_buf = NULL;
2740         }
2741         iounmap(se_dev->io_reg);
2742         iounmap(se_dev->pmc_io_reg);
2743         kfree(se_dev);
2744         sg_tegra_se_dev = NULL;
2745
2746         return 0;
2747 }
2748
2749 #if defined(CONFIG_PM)
2750 static int tegra_se_resume(struct device *dev)
2751 {
2752         return 0;
2753 }
2754
2755 static int tegra_se_generate_rng_key(struct tegra_se_dev *se_dev)
2756 {
2757         int ret = 0;
2758         u32 val = 0;
2759
2760         *se_dev->src_ll_buf = 0;
2761         *se_dev->dst_ll_buf = 0;
2762
2763         /* Configure algorithm */
2764         val = SE_CONFIG_ENC_ALG(ALG_RNG) | SE_CONFIG_ENC_MODE(MODE_KEY128) |
2765                 SE_CONFIG_DST(DST_KEYTAB);
2766         se_writel(se_dev, val, SE_CONFIG_REG_OFFSET);
2767
2768         /* Configure destination key index number */
2769         val = SE_CRYPTO_KEYTABLE_DST_KEY_INDEX(srk_slot.slot_num) |
2770                 SE_CRYPTO_KEYTABLE_DST_WORD_QUAD(KEYS_0_3);
2771         se_writel(se_dev, val, SE_CRYPTO_KEYTABLE_DST_REG_OFFSET);
2772
2773         /* Configure crypto */
2774         val = SE_CRYPTO_INPUT_SEL(INPUT_RANDOM) |
2775                 SE_CRYPTO_XOR_POS(XOR_BYPASS) |
2776                 SE_CRYPTO_CORE_SEL(CORE_ENCRYPT) |
2777                 SE_CRYPTO_HASH(HASH_DISABLE) |
2778                 SE_CRYPTO_KEY_INDEX(ssk_slot.slot_num) |
2779                 SE_CRYPTO_IV_SEL(IV_ORIGINAL);
2780         se_writel(se_dev, val, SE_CRYPTO_REG_OFFSET);
2781
2782         ret = tegra_se_start_operation(se_dev, TEGRA_SE_KEY_128_SIZE, false);
2783
2784         return ret;
2785 }
2786
2787 static int tegra_se_generate_srk(struct tegra_se_dev *se_dev)
2788 {
2789         int ret = 0;
2790         u32 val = 0;
2791
2792         mutex_lock(&se_hw_lock);
2793         pm_runtime_get_sync(se_dev->dev);
2794
2795         ret = tegra_se_generate_rng_key(se_dev);
2796         if (ret) {
2797                 pm_runtime_put(se_dev->dev);
2798                 mutex_unlock(&se_hw_lock);
2799                 return ret;
2800         }
2801
2802         *se_dev->src_ll_buf = 0;
2803         *se_dev->dst_ll_buf = 0;
2804
2805         val = SE_CONFIG_ENC_ALG(ALG_RNG) | SE_CONFIG_ENC_MODE(MODE_KEY128) |
2806                 SE_CONFIG_DEC_ALG(ALG_NOP) | SE_CONFIG_DST(DST_SRK);
2807
2808         se_writel(se_dev, val, SE_CONFIG_REG_OFFSET);
2809
2810         if (!se_dev->chipdata->drbg_supported)
2811                 val = SE_CRYPTO_XOR_POS(XOR_BYPASS) |
2812                                 SE_CRYPTO_CORE_SEL(CORE_ENCRYPT) |
2813                                 SE_CRYPTO_HASH(HASH_DISABLE) |
2814                                 SE_CRYPTO_KEY_INDEX(srk_slot.slot_num) |
2815                                 SE_CRYPTO_IV_SEL(IV_UPDATED);
2816         else
2817                 val = SE_CRYPTO_XOR_POS(XOR_BYPASS) |
2818                                 SE_CRYPTO_CORE_SEL(CORE_ENCRYPT) |
2819                                 SE_CRYPTO_HASH(HASH_DISABLE) |
2820                                 SE_CRYPTO_KEY_INDEX(srk_slot.slot_num) |
2821                                 SE_CRYPTO_IV_SEL(IV_UPDATED)|
2822                                 SE_CRYPTO_INPUT_SEL(INPUT_RANDOM);
2823         se_writel(se_dev, val, SE_CRYPTO_REG_OFFSET);
2824
2825         if (se_dev->chipdata->drbg_supported) {
2826                 se_writel(se_dev, SE_RNG_CONFIG_MODE(DRBG_MODE_FORCE_RESEED)|
2827                         SE_RNG_CONFIG_SRC(DRBG_SRC_ENTROPY),
2828                         SE_RNG_CONFIG_REG_OFFSET);
2829                 se_writel(se_dev, RNG_RESEED_INTERVAL,
2830                         SE_RNG_RESEED_INTERVAL_REG_OFFSET);
2831         }
2832         ret = tegra_se_start_operation(se_dev, TEGRA_SE_KEY_128_SIZE, false);
2833
2834         pm_runtime_put(se_dev->dev);
2835         mutex_unlock(&se_hw_lock);
2836
2837         return ret;
2838 }
2839
2840 static int tegra_se_lp_generate_random_data(struct tegra_se_dev *se_dev)
2841 {
2842         struct tegra_se_ll *src_ll, *dst_ll;
2843         int ret = 0;
2844         u32 val;
2845
2846         mutex_lock(&se_hw_lock);
2847         pm_runtime_get_sync(se_dev->dev);
2848
2849         *se_dev->src_ll_buf = 0;
2850         *se_dev->dst_ll_buf = 0;
2851         src_ll = (struct tegra_se_ll *)(se_dev->src_ll_buf + 1);
2852         dst_ll = (struct tegra_se_ll *)(se_dev->dst_ll_buf + 1);
2853         src_ll->addr = se_dev->ctx_save_buf_adr;
2854         src_ll->data_len = SE_CONTEXT_SAVE_RANDOM_DATA_SIZE;
2855         dst_ll->addr = se_dev->ctx_save_buf_adr;
2856         dst_ll->data_len = SE_CONTEXT_SAVE_RANDOM_DATA_SIZE;
2857
2858         tegra_se_config_algo(se_dev, SE_AES_OP_MODE_RNG_X931, true,
2859                 TEGRA_SE_KEY_128_SIZE);
2860
2861         /* Configure crypto */
2862         val = SE_CRYPTO_INPUT_SEL(INPUT_RANDOM) |
2863                 SE_CRYPTO_XOR_POS(XOR_BYPASS) |
2864                 SE_CRYPTO_CORE_SEL(CORE_ENCRYPT) |
2865                 SE_CRYPTO_HASH(HASH_DISABLE) |
2866                 SE_CRYPTO_KEY_INDEX(srk_slot.slot_num) |
2867                 SE_CRYPTO_IV_SEL(IV_ORIGINAL);
2868
2869         se_writel(se_dev, val, SE_CRYPTO_REG_OFFSET);
2870         if (se_dev->chipdata->drbg_supported)
2871                 se_writel(se_dev, SE_RNG_CONFIG_MODE(DRBG_MODE_FORCE_RESEED)|
2872                         SE_RNG_CONFIG_SRC(DRBG_SRC_ENTROPY),
2873                         SE_RNG_CONFIG_REG_OFFSET);
2874
2875         dma_sync_single_for_device(se_dev->dev, se_dev->ctx_save_buf_adr,
2876                         SE_CONTEXT_SAVE_RANDOM_DATA_SIZE, DMA_TO_DEVICE);
2877
2878         ret = tegra_se_start_operation(se_dev,
2879                         SE_CONTEXT_SAVE_RANDOM_DATA_SIZE, false);
2880
2881         dma_sync_single_for_cpu(se_dev->dev, se_dev->ctx_save_buf_adr,
2882                 SE_CONTEXT_SAVE_RANDOM_DATA_SIZE, DMA_FROM_DEVICE);
2883
2884         pm_runtime_put(se_dev->dev);
2885         mutex_unlock(&se_hw_lock);
2886
2887         return ret;
2888
2889 }
2890
2891 static int tegra_se_lp_encrypt_context_data(struct tegra_se_dev *se_dev,
2892         u32 context_offset, u32 data_size)
2893 {
2894         struct tegra_se_ll *src_ll, *dst_ll;
2895         int ret = 0;
2896
2897         mutex_lock(&se_hw_lock);
2898         pm_runtime_get_sync(se_dev->dev);
2899
2900         *se_dev->src_ll_buf = 0;
2901         *se_dev->dst_ll_buf = 0;
2902         src_ll = (struct tegra_se_ll *)(se_dev->src_ll_buf + 1);
2903         dst_ll = (struct tegra_se_ll *)(se_dev->dst_ll_buf + 1);
2904         src_ll->addr = se_dev->ctx_save_buf_adr + context_offset;
2905         src_ll->data_len = data_size;
2906         dst_ll->addr = se_dev->ctx_save_buf_adr + context_offset;
2907         dst_ll->data_len = data_size;
2908
2909         se_writel(se_dev, SE_CONTEXT_SAVE_SRC(MEM),
2910                 SE_CONTEXT_SAVE_CONFIG_REG_OFFSET);
2911
2912         ret = tegra_se_start_operation(se_dev, data_size, true);
2913
2914         pm_runtime_put(se_dev->dev);
2915
2916         mutex_unlock(&se_hw_lock);
2917
2918         return ret;
2919 }
2920
2921 static int tegra_se_lp_sticky_bits_context_save(struct tegra_se_dev *se_dev)
2922 {
2923         struct tegra_se_ll *dst_ll;
2924         int ret = 0;
2925         u32 val = 0;
2926         int i = 0;
2927
2928         mutex_lock(&se_hw_lock);
2929         pm_runtime_get_sync(se_dev->dev);
2930
2931         *se_dev->src_ll_buf = 0;
2932         *se_dev->dst_ll_buf = 0;
2933         dst_ll = (struct tegra_se_ll *)(se_dev->dst_ll_buf + 1);
2934         dst_ll->addr = (se_dev->ctx_save_buf_adr +
2935                 SE_CONTEXT_SAVE_STICKY_BITS_OFFSET);
2936         dst_ll->data_len = SE_CONTEXT_SAVE_STICKY_BITS_SIZE;
2937
2938         if (!se_dev->chipdata->drbg_supported) {
2939                 se_writel(se_dev, SE_CONTEXT_SAVE_SRC(STICKY_BITS),
2940                         SE_CONTEXT_SAVE_CONFIG_REG_OFFSET);
2941                 ret = tegra_se_start_operation(se_dev,
2942                         SE_CONTEXT_SAVE_STICKY_BITS_SIZE, true);
2943         } else
2944                 for (i = 0; i < 2; i++) {
2945                         val = SE_CONTEXT_SAVE_SRC(STICKY_BITS) |
2946                                 SE_CONTEXT_SAVE_STICKY_WORD_QUAD(i);
2947                         se_writel(se_dev, val,
2948                                 SE_CONTEXT_SAVE_CONFIG_REG_OFFSET);
2949                         ret = tegra_se_start_operation(se_dev,
2950                                 SE_CONTEXT_SAVE_STICKY_BITS_SIZE, true);
2951                         dst_ll->addr += SE_CONTEXT_SAVE_STICKY_BITS_SIZE;
2952                 }
2953
2954         pm_runtime_put(se_dev->dev);
2955         mutex_unlock(&se_hw_lock);
2956
2957         return ret;
2958 }
2959
2960 static int tegra_se_lp_keytable_context_save(struct tegra_se_dev *se_dev)
2961 {
2962         struct tegra_se_ll *dst_ll;
2963         int ret = 0, i, j;
2964         u32 val = 0;
2965
2966         /* take access to the hw */
2967         mutex_lock(&se_hw_lock);
2968         pm_runtime_get_sync(se_dev->dev);
2969
2970         *se_dev->dst_ll_buf = 0;
2971         dst_ll = (struct tegra_se_ll *)(se_dev->dst_ll_buf + 1);
2972         if (!se_dev->chipdata->drbg_supported)
2973                 dst_ll->addr =
2974                         (se_dev->ctx_save_buf_adr +
2975                         SE_CONTEXT_SAVE_KEYS_OFFSET);
2976         else
2977                 dst_ll->addr =
2978                         (se_dev->ctx_save_buf_adr +
2979                         SE11_CONTEXT_SAVE_KEYS_OFFSET);
2980
2981         dst_ll->data_len = TEGRA_SE_KEY_128_SIZE;
2982
2983         for (i = 0; i < TEGRA_SE_KEYSLOT_COUNT; i++) {
2984                 for (j = 0; j < 2; j++) {
2985                         val = SE_CONTEXT_SAVE_SRC(KEYTABLE) |
2986                                 SE_CONTEXT_SAVE_KEY_INDEX(i) |
2987                                 SE_CONTEXT_SAVE_WORD_QUAD(j);
2988                         se_writel(se_dev,
2989                                 val, SE_CONTEXT_SAVE_CONFIG_REG_OFFSET);
2990                         ret = tegra_se_start_operation(se_dev,
2991                                 TEGRA_SE_KEY_128_SIZE, true);
2992                         if (ret)
2993                                 break;
2994                         dst_ll->addr += TEGRA_SE_KEY_128_SIZE;
2995                 }
2996         }
2997
2998         pm_runtime_put(se_dev->dev);
2999         mutex_unlock(&se_hw_lock);
3000
3001         return ret;
3002 }
3003
3004 static int tegra_se_lp_rsakeytable_context_save(struct tegra_se_dev *se_dev)
3005 {
3006         struct tegra_se_ll *dst_ll;
3007         int ret = 0, i, j;
3008         u32 val = 0;
3009
3010         /* take access to the hw */
3011         mutex_lock(&se_hw_lock);
3012         pm_runtime_get_sync(se_dev->dev);
3013
3014         *se_dev->dst_ll_buf = 0;
3015         dst_ll = (struct tegra_se_ll *)(se_dev->dst_ll_buf + 1);
3016         dst_ll->addr =
3017                 (se_dev->ctx_save_buf_adr + SE_CONTEXT_SAVE_RSA_KEYS_OFFSET);
3018         dst_ll->data_len = TEGRA_SE_KEY_128_SIZE;
3019
3020         for (i = 0; i < TEGRA_SE_RSA_CONTEXT_SAVE_KEYSLOT_COUNT; i++) {
3021                 for (j = 0; j < 16; j++) {
3022                         val = SE_CONTEXT_SAVE_SRC(RSA_KEYTABLE) |
3023                                 SE_CONTEXT_SAVE_RSA_KEY_INDEX(i) |
3024                                 SE_CONTEXT_RSA_WORD_QUAD(j);
3025                         se_writel(se_dev,
3026                                 val, SE_CONTEXT_SAVE_CONFIG_REG_OFFSET);
3027                         ret = tegra_se_start_operation(se_dev,
3028                                 TEGRA_SE_KEY_128_SIZE, true);
3029                         if (ret) {
3030                                 dev_err(se_dev->dev, "tegra_se_lp_rsakeytable_context_save error\n");
3031                                 break;
3032                         }
3033                         dst_ll->addr += TEGRA_SE_KEY_128_SIZE;
3034                 }
3035         }
3036
3037         pm_runtime_put(se_dev->dev);
3038         mutex_unlock(&se_hw_lock);
3039
3040         return ret;
3041 }
3042
3043 static int tegra_se_lp_iv_context_save(struct tegra_se_dev *se_dev,
3044         bool org_iv, u32 context_offset)
3045 {
3046         struct tegra_se_ll *dst_ll;
3047         int ret = 0, i;
3048         u32 val = 0;
3049
3050         mutex_lock(&se_hw_lock);
3051         pm_runtime_get_sync(se_dev->dev);
3052
3053         *se_dev->dst_ll_buf = 0;
3054         dst_ll = (struct tegra_se_ll *)(se_dev->dst_ll_buf + 1);
3055         dst_ll->addr = (se_dev->ctx_save_buf_adr + context_offset);
3056         dst_ll->data_len = TEGRA_SE_AES_IV_SIZE;
3057
3058         for (i = 0; i < TEGRA_SE_KEYSLOT_COUNT; i++) {
3059                 val = SE_CONTEXT_SAVE_SRC(KEYTABLE) |
3060                         SE_CONTEXT_SAVE_KEY_INDEX(i) |
3061                         (org_iv ? SE_CONTEXT_SAVE_WORD_QUAD(ORIG_IV) :
3062                         SE_CONTEXT_SAVE_WORD_QUAD(UPD_IV));
3063                 se_writel(se_dev, val, SE_CONTEXT_SAVE_CONFIG_REG_OFFSET);
3064                 ret = tegra_se_start_operation(se_dev,
3065                         TEGRA_SE_AES_IV_SIZE, true);
3066                 if (ret)
3067                         break;
3068                 dst_ll->addr += TEGRA_SE_AES_IV_SIZE;
3069         }
3070
3071         pm_runtime_put(se_dev->dev);
3072         mutex_unlock(&se_hw_lock);
3073
3074         return ret;
3075 }
3076
3077 static int tegra_se_save_SRK(struct tegra_se_dev *se_dev)
3078 {
3079         int ret;
3080         int val;
3081
3082         mutex_lock(&se_hw_lock);
3083         pm_runtime_get_sync(se_dev->dev);
3084
3085         se_writel(se_dev, SE_CONTEXT_SAVE_SRC(SRK),
3086                 SE_CONTEXT_SAVE_CONFIG_REG_OFFSET);
3087         ret = tegra_se_start_operation(se_dev, 0, true);
3088
3089         if (ret < 0) {
3090                 dev_err(se_dev->dev, "\n LP SRK operation failed\n");
3091                 pm_runtime_put(se_dev->dev);
3092                 mutex_unlock(&se_hw_lock);
3093                 return ret;
3094         }
3095
3096         if ((tegra_get_chipid() == TEGRA_CHIPID_TEGRA11) &&
3097                                 se_dev->chipdata->drbg_supported) {
3098                 /* clear any pending interrupts */
3099                 val = se_readl(se_dev, SE_INT_STATUS_REG_OFFSET);
3100                 se_writel(se_dev, val, SE_INT_STATUS_REG_OFFSET);
3101
3102                 /* enable interupts */
3103                 val = SE_INT_ERROR(INT_ENABLE) | SE_INT_OP_DONE(INT_ENABLE);
3104                 se_writel(se_dev, val, SE_INT_ENABLE_REG_OFFSET);
3105
3106                 val = SE_CONFIG_ENC_ALG(ALG_NOP) |
3107                                 SE_CONFIG_DEC_ALG(ALG_NOP);
3108                 se_writel(se_dev, val, SE_CRYPTO_REG_OFFSET);
3109
3110                 INIT_COMPLETION(se_dev->complete);
3111
3112                 se_writel(se_dev, SE_OPERATION(OP_CTX_SAVE),
3113                         SE_OPERATION_REG_OFFSET);
3114                 ret = wait_for_completion_timeout(&se_dev->complete,
3115                                 msecs_to_jiffies(1000));
3116
3117                 if (ret == 0) {
3118                         dev_err(se_dev->dev, "\n LP SRK timed out no interrupt\n");
3119                         pm_runtime_put(se_dev->dev);
3120                         mutex_unlock(&se_hw_lock);
3121                         return -ETIMEDOUT;
3122                 }
3123         }
3124
3125         pm_runtime_put(se_dev->dev);
3126         mutex_unlock(&se_hw_lock);
3127
3128         return 0;
3129 }
3130
3131 static int tegra_se_suspend(struct device *dev)
3132 {
3133         struct platform_device *pdev = to_platform_device(dev);
3134         struct tegra_se_dev *se_dev = platform_get_drvdata(pdev);
3135         int err = 0, i;
3136         unsigned char *dt_buf = NULL;
3137         u8 pdata[SE_CONTEXT_KNOWN_PATTERN_SIZE] = {
3138                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
3139                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
3140
3141         if (!se_dev)
3142                 return -ENODEV;
3143
3144         /* Generate SRK */
3145         err = tegra_se_generate_srk(se_dev);
3146         if (err) {
3147                 dev_err(se_dev->dev, "\n LP SRK genration failed\n");
3148                 goto out;
3149         }
3150
3151         /* Generate random data*/
3152         err = tegra_se_lp_generate_random_data(se_dev);
3153         if (err) {
3154                 dev_err(se_dev->dev, "\n LP random pattern generation failed\n");
3155                 goto out;
3156         }
3157
3158         /* Encrypt random data */
3159         err = tegra_se_lp_encrypt_context_data(se_dev,
3160                 SE_CONTEXT_SAVE_RANDOM_DATA_OFFSET,
3161                 SE_CONTEXT_SAVE_RANDOM_DATA_SIZE);
3162         if (err) {
3163                 dev_err(se_dev->dev, "\n LP random pattern encryption failed\n");
3164                 goto out;
3165         }
3166
3167         /* Sticky bits context save*/
3168         err = tegra_se_lp_sticky_bits_context_save(se_dev);
3169         if (err) {
3170                 dev_err(se_dev->dev, "\n LP sticky bits context save failure\n");
3171                 goto out;
3172         }
3173
3174         /* Key table context save*/
3175         err = tegra_se_lp_keytable_context_save(se_dev);
3176         if (err) {
3177                 dev_err(se_dev->dev, "\n LP key table  save failure\n");
3178                 goto out;
3179         }
3180
3181         /* Original iv context save*/
3182         err = tegra_se_lp_iv_context_save(se_dev,
3183                 true,
3184                 (se_dev->chipdata->drbg_supported ?
3185                         SE11_CONTEXT_ORIGINAL_IV_OFFSET :
3186                         SE_CONTEXT_ORIGINAL_IV_OFFSET));
3187         if (err) {
3188                 dev_err(se_dev->dev, "\n LP original iv save failure\n");
3189                 goto out;
3190         }
3191
3192         /* Updated iv context save*/
3193         err = tegra_se_lp_iv_context_save(se_dev,
3194                 false,
3195                 (se_dev->chipdata->drbg_supported ?
3196                 SE11_CONTEXT_UPDATED_IV_OFFSET :
3197                 SE_CONTEXT_UPDATED_IV_OFFSET));
3198         if (err) {
3199                 dev_err(se_dev->dev, "\n LP updated iv save failure\n");
3200                 goto out;
3201         }
3202
3203         if (se_dev->chipdata->drbg_supported) {
3204                 /* rsa-key slot table context save*/
3205                 err = tegra_se_lp_rsakeytable_context_save(se_dev);
3206                 if (err) {
3207                         dev_err(se_dev->dev, "\n LP RSA key table save failure\n");
3208                         goto out;
3209                 }
3210                 /* Encrypt known pattern */
3211                 dt_buf = (unsigned char *)se_dev->ctx_save_buf;
3212                 dt_buf +=
3213                         SE_CONTEXT_SAVE_RSA_KNOWN_PATTERN_OFFSET;
3214                 for (i = 0; i < SE_CONTEXT_KNOWN_PATTERN_SIZE; i++)
3215                         dt_buf[i] = pdata[i];
3216                 err = tegra_se_lp_encrypt_context_data(se_dev,
3217                         SE_CONTEXT_SAVE_RSA_KNOWN_PATTERN_OFFSET,
3218                         SE_CONTEXT_KNOWN_PATTERN_SIZE);
3219         } else {
3220                 /* Encrypt known pattern */
3221                 dt_buf = (unsigned char *)se_dev->ctx_save_buf;
3222                 dt_buf +=
3223                         SE_CONTEXT_SAVE_KNOWN_PATTERN_OFFSET;
3224                 for (i = 0; i < SE_CONTEXT_KNOWN_PATTERN_SIZE; i++)
3225                         dt_buf[i] = pdata[i];
3226                 err = tegra_se_lp_encrypt_context_data(se_dev,
3227                         SE_CONTEXT_SAVE_KNOWN_PATTERN_OFFSET,
3228                         SE_CONTEXT_KNOWN_PATTERN_SIZE);
3229         }
3230         if (err) {
3231                 dev_err(se_dev->dev, "LP known pattern save failure\n");
3232                 goto out;
3233         }
3234
3235         /* Write lp context buffer address into PMC scratch register */
3236         writel(page_to_phys(vmalloc_to_page(se_dev->ctx_save_buf)),
3237                 se_dev->pmc_io_reg + PMC_SCRATCH43_REG_OFFSET);
3238
3239         /* Saves SRK in secure scratch */
3240         err = tegra_se_save_SRK(se_dev);
3241         if (err < 0) {
3242                 dev_err(se_dev->dev, "LP SRK save failure\n");
3243                 goto out;
3244         }
3245
3246 out:
3247         return err;
3248 }
3249 #endif
3250
3251 #if defined(CONFIG_PM_RUNTIME)
3252 static int tegra_se_runtime_suspend(struct device *dev)
3253 {
3254         /*
3255          * do a dummy read, to avoid scenarios where you have unposted writes
3256          * still on the bus, before disabling clocks
3257          */
3258         se_readl(sg_tegra_se_dev, SE_CONFIG_REG_OFFSET);
3259
3260         clk_disable_unprepare(sg_tegra_se_dev->pclk);
3261         return 0;
3262 }
3263
3264 static int tegra_se_runtime_resume(struct device *dev)
3265 {
3266         clk_prepare_enable(sg_tegra_se_dev->pclk);
3267         return 0;
3268 }
3269
3270 static const struct dev_pm_ops tegra_se_dev_pm_ops = {
3271         .runtime_suspend = tegra_se_runtime_suspend,
3272         .runtime_resume = tegra_se_runtime_resume,
3273 #if defined(CONFIG_PM)
3274         .suspend = tegra_se_suspend,
3275         .resume = tegra_se_resume,
3276 #endif
3277 };
3278 #endif
3279
3280 static struct tegra_se_chipdata tegra_se_chipdata = {
3281         .rsa_supported = false,
3282         .cprng_supported = true,
3283         .drbg_supported = false,
3284         .aes_freq = 300000000,
3285         .rng_freq = 300000000,
3286         .sha1_freq = 300000000,
3287         .sha224_freq = 300000000,
3288         .sha256_freq = 300000000,
3289         .sha384_freq = 300000000,
3290         .sha512_freq = 300000000,
3291 };
3292
3293 static struct tegra_se_chipdata tegra11_se_chipdata = {
3294         .rsa_supported = true,
3295         .cprng_supported = false,
3296         .drbg_supported = true,
3297         .aes_freq = 150000000,
3298         .rng_freq = 150000000,
3299         .sha1_freq = 200000000,
3300         .sha224_freq = 250000000,
3301         .sha256_freq = 250000000,
3302         .sha384_freq = 150000000,
3303         .sha512_freq = 150000000,
3304         .rsa_freq = 350000000,
3305
3306 };
3307
3308 static struct platform_device_id tegra_dev_se_devtype[] = {
3309         {
3310                 .name = "tegra-se",
3311                 .driver_data = (unsigned long)&tegra_se_chipdata,
3312         },
3313         {
3314                         .name = "tegra11-se",
3315                         .driver_data = (unsigned long)&tegra11_se_chipdata,
3316         }
3317 };
3318
3319 static struct platform_driver tegra_se_driver = {
3320         .probe  = tegra_se_probe,
3321         .remove = tegra_se_remove,
3322         .id_table = tegra_dev_se_devtype,
3323         .driver = {
3324                 .name   = "tegra-se",
3325                 .owner  = THIS_MODULE,
3326 #if defined(CONFIG_PM_RUNTIME)
3327                 .pm = &tegra_se_dev_pm_ops,
3328 #endif
3329         },
3330 };
3331
3332 static int __init tegra_se_module_init(void)
3333 {
3334         return  platform_driver_register(&tegra_se_driver);
3335 }
3336
3337 static void __exit tegra_se_module_exit(void)
3338 {
3339         platform_driver_unregister(&tegra_se_driver);
3340 }
3341
3342 module_init(tegra_se_module_init);
3343 module_exit(tegra_se_module_exit);
3344
3345 MODULE_DESCRIPTION("Tegra Crypto algorithm support");
3346 MODULE_AUTHOR("NVIDIA Corporation");
3347 MODULE_LICENSE("GPL");
3348 MODULE_ALIAS("tegra-se");
3349