crypto: tegra-se: RNG support for less than 16 Bytes
[linux-2.6.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, NVIDIA Corporation.
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
45 #include "tegra-se.h"
46
47 #define DRIVER_NAME     "tegra-se"
48
49 /* Security Engine operation modes */
50 enum tegra_se_aes_op_mode {
51         SE_AES_OP_MODE_CBC,     /* Cipher Block Chaining (CBC) mode */
52         SE_AES_OP_MODE_ECB,     /* Electronic Codebook (ECB) mode */
53         SE_AES_OP_MODE_CTR,     /* Counter (CTR) mode */
54         SE_AES_OP_MODE_OFB,     /* Output feedback (CFB) mode */
55         SE_AES_OP_MODE_RNG_X931,        /* Random number generator (RNG) mode */
56         SE_AES_OP_MODE_CMAC,    /* Cipher-based MAC (CMAC) mode */
57         SE_AES_OP_MODE_SHA1,    /* Secure Hash Algorithm-1 (SHA1) mode */
58         SE_AES_OP_MODE_SHA224,  /* Secure Hash Algorithm-224  (SHA224) mode */
59         SE_AES_OP_MODE_SHA256,  /* Secure Hash Algorithm-256  (SHA256) mode */
60         SE_AES_OP_MODE_SHA384,  /* Secure Hash Algorithm-384  (SHA384) mode */
61         SE_AES_OP_MODE_SHA512   /* Secure Hash Algorithm-512  (SHA512) mode */
62 };
63
64 /* Security Engine key table type */
65 enum tegra_se_key_table_type {
66         SE_KEY_TABLE_TYPE_KEY,  /* Key */
67         SE_KEY_TABLE_TYPE_ORGIV,        /* Original IV */
68         SE_KEY_TABLE_TYPE_UPDTDIV       /* Updated IV */
69 };
70
71 /* Security Engine request context */
72 struct tegra_se_req_context {
73         enum tegra_se_aes_op_mode op_mode; /* Security Engine operation mode */
74         bool encrypt;   /* Operation type */
75 };
76
77 struct tegra_se_dev {
78         struct device *dev;
79         void __iomem *io_reg;   /* se device memory/io */
80         void __iomem *pmc_io_reg;       /* pmc device memory/io */
81         int irq;        /* irq allocated */
82         spinlock_t lock;        /* spin lock */
83         struct clk *pclk;       /* Security Engine clock */
84         struct crypto_queue queue; /* Security Engine crypto queue */
85         struct tegra_se_slot *slot_list;        /* pointer to key slots */
86         u64 ctr;
87         u32 *src_ll_buf;        /* pointer to source linked list buffer */
88         dma_addr_t src_ll_buf_adr; /* Source linked list buffer dma address */
89         u32 src_ll_size;        /* Size of source linked list buffer */
90         u32 *dst_ll_buf;        /* pointer to destination linked list buffer */
91         dma_addr_t dst_ll_buf_adr; /* Destination linked list dma address */
92         u32 dst_ll_size;        /* Size of destination linked list buffer */
93         u32 *ctx_save_buf;      /* LP context buffer pointer*/
94         dma_addr_t ctx_save_buf_adr;    /* LP context buffer dma address*/
95         struct completion complete;     /* Tells the task completion */
96         bool work_q_busy;       /* Work queue busy status */
97 };
98
99 static struct tegra_se_dev *sg_tegra_se_dev;
100
101 /* Security Engine AES context */
102 struct tegra_se_aes_context {
103         struct tegra_se_dev *se_dev;    /* Security Engine device */
104         struct tegra_se_slot *slot;     /* Security Engine key slot */
105         u32 keylen;     /* key length in bits */
106         u32 op_mode;    /* AES operation mode */
107 };
108
109 /* Security Engine random number generator context */
110 struct tegra_se_rng_context {
111         struct tegra_se_dev *se_dev;    /* Security Engine device */
112         struct tegra_se_slot *slot;     /* Security Engine key slot */
113         u32 *dt_buf;    /* Destination buffer pointer */
114         dma_addr_t dt_buf_adr;  /* Destination buffer dma address */
115         u32 *rng_buf;   /* RNG buffer pointer */
116         dma_addr_t rng_buf_adr; /* RNG buffer dma address */
117         bool use_org_iv;        /* Tells whether original IV is be used
118                                 or not. If it is false updated IV is used*/
119 };
120
121 /* Security Engine SHA context */
122 struct tegra_se_sha_context {
123         struct tegra_se_dev     *se_dev;        /* Security Engine device */
124         u32 op_mode;    /* SHA operation mode */
125 };
126
127 /* Security Engine AES CMAC context */
128 struct tegra_se_aes_cmac_context {
129         struct tegra_se_dev *se_dev;    /* Security Engine device */
130         struct tegra_se_slot *slot;     /* Security Engine key slot */
131         u32 keylen;     /* key length in bits */
132         u8 K1[TEGRA_SE_KEY_128_SIZE];   /* Key1 */
133         u8 K2[TEGRA_SE_KEY_128_SIZE];   /* Key2 */
134         dma_addr_t dma_addr;    /* DMA address of local buffer */
135         u32 buflen;     /* local buffer length */
136         u8      *buffer;        /* local buffer pointer */
137 };
138
139 /* Security Engine key slot */
140 struct tegra_se_slot {
141         struct list_head node;
142         u8 slot_num;    /* Key slot number */
143         bool available; /* Tells whether key slot is free to use */
144 };
145
146 static struct tegra_se_slot ssk_slot = {
147         .slot_num = 15,
148         .available = false,
149 };
150
151 static struct tegra_se_slot srk_slot = {
152         .slot_num = 0,
153         .available = false,
154 };
155
156 /* Security Engine Linked List */
157 struct tegra_se_ll {
158         dma_addr_t addr; /* DMA buffer address */
159         u32 data_len; /* Data length in DMA buffer */
160 };
161
162 static LIST_HEAD(key_slot);
163 static DEFINE_SPINLOCK(key_slot_lock);
164 static DEFINE_MUTEX(se_hw_lock);
165
166 /* create a work for handling the async transfers */
167 static void tegra_se_work_handler(struct work_struct *work);
168 static DECLARE_WORK(se_work, tegra_se_work_handler);
169 static struct workqueue_struct *se_work_q;
170
171 #define PMC_SCRATCH43_REG_OFFSET 0x22c
172 #define GET_MSB(x)  ((x) >> (8*sizeof(x)-1))
173 static void tegra_se_leftshift_onebit(u8 *in_buf, u32 size, u8 *org_msb)
174 {
175         u8 carry;
176         u32 i;
177
178         *org_msb = GET_MSB(in_buf[0]);
179
180         /* left shift one bit */
181         in_buf[0] <<= 1;
182         for (carry = 0, i = 1; i < size; i++) {
183                 carry = GET_MSB(in_buf[i]);
184                 in_buf[i-1] |= carry;
185                 in_buf[i] <<= 1;
186         }
187 }
188
189 extern unsigned long long tegra_chip_uid(void);
190
191 static inline void se_writel(struct tegra_se_dev *se_dev,
192         unsigned int val, unsigned int reg_offset)
193 {
194         writel(val, se_dev->io_reg + reg_offset);
195 }
196
197 static inline unsigned int se_readl(struct tegra_se_dev *se_dev,
198         unsigned int reg_offset)
199 {
200         unsigned int val;
201
202         val = readl(se_dev->io_reg + reg_offset);
203
204         return val;
205 }
206
207 static void tegra_se_free_key_slot(struct tegra_se_slot *slot)
208 {
209         if (slot) {
210                 spin_lock(&key_slot_lock);
211                 slot->available = true;
212                 spin_unlock(&key_slot_lock);
213         }
214 }
215
216 static struct tegra_se_slot *tegra_se_alloc_key_slot(void)
217 {
218         struct tegra_se_slot *slot = NULL;
219         bool found = false;
220
221         spin_lock(&key_slot_lock);
222         list_for_each_entry(slot, &key_slot, node) {
223                 if (slot->available) {
224                         slot->available = false;
225                         found = true;
226                         break;
227                 }
228         }
229         spin_unlock(&key_slot_lock);
230         return found ? slot : NULL;
231 }
232
233 static int tegra_init_key_slot(struct tegra_se_dev *se_dev)
234 {
235         int i;
236
237         se_dev->slot_list = kzalloc(sizeof(struct tegra_se_slot) *
238                                         TEGRA_SE_KEYSLOT_COUNT, GFP_KERNEL);
239         if (se_dev->slot_list == NULL) {
240                 dev_err(se_dev->dev, "slot list memory allocation failed\n");
241                 return -ENOMEM;
242         }
243         spin_lock_init(&key_slot_lock);
244         spin_lock(&key_slot_lock);
245         for (i = 0; i < TEGRA_SE_KEYSLOT_COUNT; i++) {
246                 /*
247                  * Slot 0 and 15 are reserved and will not be added to the
248                  * free slots pool. Slot 0 is used for SRK generation and
249                  * Slot 15 is used for SSK operation
250                  */
251                 if ((i == srk_slot.slot_num) || (i == ssk_slot.slot_num))
252                         continue;
253                 se_dev->slot_list[i].available = true;
254                 se_dev->slot_list[i].slot_num = i;
255                 INIT_LIST_HEAD(&se_dev->slot_list[i].node);
256                 list_add_tail(&se_dev->slot_list[i].node, &key_slot);
257         }
258         spin_unlock(&key_slot_lock);
259
260         return 0;
261 }
262
263 static void tegra_se_key_read_disable(u8 slot_num)
264 {
265         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
266         u32 val;
267
268         val = se_readl(se_dev,
269                         (SE_KEY_TABLE_ACCESS_REG_OFFSET + (slot_num * 4)));
270         val &= ~(1 << SE_KEY_READ_DISABLE_SHIFT);
271         se_writel(se_dev,
272                 val, (SE_KEY_TABLE_ACCESS_REG_OFFSET + (slot_num * 4)));
273 }
274
275 static void tegra_se_key_read_disable_all(void)
276 {
277         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
278         u8 slot_num;
279
280         mutex_lock(&se_hw_lock);
281         pm_runtime_get_sync(se_dev->dev);
282
283         for (slot_num = 0; slot_num < TEGRA_SE_KEYSLOT_COUNT; slot_num++)
284                 tegra_se_key_read_disable(slot_num);
285
286         pm_runtime_put(se_dev->dev);
287         mutex_unlock(&se_hw_lock);
288 }
289
290 static void tegra_se_config_algo(struct tegra_se_dev *se_dev,
291         enum tegra_se_aes_op_mode mode, bool encrypt, u32 key_len)
292 {
293         u32 val = 0;
294
295         switch (mode) {
296         case SE_AES_OP_MODE_CBC:
297         case SE_AES_OP_MODE_CMAC:
298                 if (encrypt) {
299                         val = SE_CONFIG_ENC_ALG(ALG_AES_ENC);
300                         if (key_len == TEGRA_SE_KEY_256_SIZE)
301                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY256);
302                         else if (key_len == TEGRA_SE_KEY_192_SIZE)
303                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY192);
304                         else
305                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY128);
306                         val |= SE_CONFIG_DEC_ALG(ALG_NOP);
307                 } else {
308                         val = SE_CONFIG_DEC_ALG(ALG_AES_DEC);
309                         if (key_len == TEGRA_SE_KEY_256_SIZE)
310                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY256);
311                         else if (key_len == TEGRA_SE_KEY_192_SIZE)
312                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY192);
313                         else
314                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY128);
315                 }
316                 if (mode == SE_AES_OP_MODE_CMAC)
317                         val |= SE_CONFIG_DST(DST_HASHREG);
318                 else
319                         val |= SE_CONFIG_DST(DST_MEMORY);
320                 break;
321         case SE_AES_OP_MODE_RNG_X931:
322                 val = SE_CONFIG_ENC_ALG(ALG_RNG) |
323                         SE_CONFIG_ENC_MODE(MODE_KEY128) |
324                                 SE_CONFIG_DST(DST_MEMORY);
325                 break;
326         case SE_AES_OP_MODE_ECB:
327                 if (encrypt) {
328                         val = SE_CONFIG_ENC_ALG(ALG_AES_ENC);
329                         if (key_len == TEGRA_SE_KEY_256_SIZE)
330                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY256);
331                         else if (key_len == TEGRA_SE_KEY_192_SIZE)
332                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY192);
333                         else
334                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY128);
335                 } else {
336                         val = SE_CONFIG_DEC_ALG(ALG_AES_DEC);
337                         if (key_len == TEGRA_SE_KEY_256_SIZE)
338                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY256);
339                         else if (key_len == TEGRA_SE_KEY_192_SIZE)
340                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY192);
341                         else
342                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY128);
343                 }
344                 val |= SE_CONFIG_DST(DST_MEMORY);
345                 break;
346         case SE_AES_OP_MODE_CTR:
347                 if (encrypt) {
348                         val = SE_CONFIG_ENC_ALG(ALG_AES_ENC);
349                         if (key_len == TEGRA_SE_KEY_256_SIZE)
350                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY256);
351                         else if (key_len == TEGRA_SE_KEY_192_SIZE)
352                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY192);
353                         else
354                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY128);
355                 } else {
356                         val = SE_CONFIG_DEC_ALG(ALG_AES_DEC);
357                         if (key_len == TEGRA_SE_KEY_256_SIZE) {
358                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY256);
359                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY256);
360                         } else if (key_len == TEGRA_SE_KEY_192_SIZE) {
361                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY192);
362                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY192);
363                         } else {
364                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY128);
365                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY128);
366                         }
367                 }
368                 val |= SE_CONFIG_DST(DST_MEMORY);
369                 break;
370         case SE_AES_OP_MODE_OFB:
371                 if (encrypt) {
372                         val = SE_CONFIG_ENC_ALG(ALG_AES_ENC);
373                         if (key_len == TEGRA_SE_KEY_256_SIZE)
374                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY256);
375                         else if (key_len == TEGRA_SE_KEY_192_SIZE)
376                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY192);
377                         else
378                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY128);
379                 } else {
380                         val = SE_CONFIG_DEC_ALG(ALG_AES_DEC);
381                         if (key_len == TEGRA_SE_KEY_256_SIZE) {
382                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY256);
383                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY256);
384                         } else if (key_len == TEGRA_SE_KEY_192_SIZE) {
385                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY192);
386                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY192);
387                         } else {
388                                 val |= SE_CONFIG_DEC_MODE(MODE_KEY128);
389                                 val |= SE_CONFIG_ENC_MODE(MODE_KEY128);
390                         }
391                 }
392                 val |= SE_CONFIG_DST(DST_MEMORY);
393                 break;
394         case SE_AES_OP_MODE_SHA1:
395                 val = SE_CONFIG_ENC_ALG(ALG_SHA) |
396                         SE_CONFIG_ENC_MODE(MODE_SHA1) |
397                                 SE_CONFIG_DST(DST_HASHREG);
398                 break;
399         case SE_AES_OP_MODE_SHA224:
400                 val = SE_CONFIG_ENC_ALG(ALG_SHA) |
401                         SE_CONFIG_ENC_MODE(MODE_SHA224) |
402                                 SE_CONFIG_DST(DST_HASHREG);
403                 break;
404         case SE_AES_OP_MODE_SHA256:
405                 val = SE_CONFIG_ENC_ALG(ALG_SHA) |
406                         SE_CONFIG_ENC_MODE(MODE_SHA256) |
407                                 SE_CONFIG_DST(DST_HASHREG);
408                 break;
409         case SE_AES_OP_MODE_SHA384:
410                 val = SE_CONFIG_ENC_ALG(ALG_SHA) |
411                         SE_CONFIG_ENC_MODE(MODE_SHA384) |
412                                 SE_CONFIG_DST(DST_HASHREG);
413                 break;
414         case SE_AES_OP_MODE_SHA512:
415                 val = SE_CONFIG_ENC_ALG(ALG_SHA) |
416                         SE_CONFIG_ENC_MODE(MODE_SHA512) |
417                                 SE_CONFIG_DST(DST_HASHREG);
418                 break;
419         default:
420                 dev_warn(se_dev->dev, "Invalid operation mode\n");
421                 break;
422         }
423
424         se_writel(se_dev, val, SE_CONFIG_REG_OFFSET);
425 }
426
427 static void tegra_se_write_seed(struct tegra_se_dev *se_dev, u32 *pdata)
428 {
429         u32 i;
430
431         for (i = 0; i < SE_CRYPTO_CTR_REG_COUNT; i++)
432                 se_writel(se_dev, pdata[i], SE_CRYPTO_CTR_REG_OFFSET + (i * 4));
433 }
434
435 static void tegra_se_write_key_table(u8 *pdata, u32 data_len,
436         u8 slot_num, enum tegra_se_key_table_type type)
437 {
438         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
439         u32 data_size = SE_KEYTABLE_REG_MAX_DATA;
440         u32 *pdata_buf = (u32 *)pdata;
441         u8 pkt = 0, quad = 0;
442         u32 val = 0, i;
443
444         if ((type == SE_KEY_TABLE_TYPE_KEY) && (slot_num == ssk_slot.slot_num))
445                 return;
446
447         if (type == SE_KEY_TABLE_TYPE_ORGIV)
448                 quad = QUAD_ORG_IV;
449         else if (type == SE_KEY_TABLE_TYPE_UPDTDIV)
450                 quad = QUAD_UPDTD_IV;
451         else
452                 quad = QUAD_KEYS_128;
453
454         /* write data to the key table */
455         do {
456                 for (i = 0; i < data_size; i += 4, data_len -= 4)
457                         se_writel(se_dev, *pdata_buf++,
458                                 SE_KEYTABLE_DATA0_REG_OFFSET + i);
459
460                 pkt = SE_KEYTABLE_SLOT(slot_num) | SE_KEYTABLE_QUAD(quad);
461                 val = SE_KEYTABLE_OP_TYPE(OP_WRITE) |
462                         SE_KEYTABLE_TABLE_SEL(TABLE_KEYIV) |
463                                 SE_KEYTABLE_PKT(pkt);
464
465                 se_writel(se_dev, val, SE_KEYTABLE_REG_OFFSET);
466
467                 data_size = data_len;
468                 quad = QUAD_KEYS_256;
469
470         } while (data_len);
471 }
472
473 static void tegra_se_config_crypto(struct tegra_se_dev *se_dev,
474         enum tegra_se_aes_op_mode mode, bool encrypt, u8 slot_num, bool org_iv)
475 {
476         u32 val = 0;
477
478         switch (mode) {
479         case SE_AES_OP_MODE_CMAC:
480         case SE_AES_OP_MODE_CBC:
481                 if (encrypt) {
482                         val = SE_CRYPTO_INPUT_SEL(INPUT_AHB) |
483                                 SE_CRYPTO_VCTRAM_SEL(VCTRAM_AESOUT) |
484                                 SE_CRYPTO_XOR_POS(XOR_TOP) |
485                                 SE_CRYPTO_CORE_SEL(CORE_ENCRYPT);
486                 } else {
487                         val = SE_CRYPTO_INPUT_SEL(INPUT_AHB) |
488                                 SE_CRYPTO_VCTRAM_SEL(VCTRAM_PREVAHB) |
489                                 SE_CRYPTO_XOR_POS(XOR_BOTTOM) |
490                                 SE_CRYPTO_CORE_SEL(CORE_DECRYPT);
491                 }
492                 break;
493         case SE_AES_OP_MODE_RNG_X931:
494                 val = SE_CRYPTO_INPUT_SEL(INPUT_AHB) |
495                         SE_CRYPTO_XOR_POS(XOR_BYPASS) |
496                         SE_CRYPTO_CORE_SEL(CORE_ENCRYPT);
497                 break;
498         case SE_AES_OP_MODE_ECB:
499                 if (encrypt) {
500                         val = SE_CRYPTO_INPUT_SEL(INPUT_AHB) |
501                                 SE_CRYPTO_XOR_POS(XOR_BYPASS) |
502                                 SE_CRYPTO_CORE_SEL(CORE_ENCRYPT);
503                 } else {
504                         val = SE_CRYPTO_INPUT_SEL(INPUT_AHB) |
505                                 SE_CRYPTO_XOR_POS(XOR_BYPASS) |
506                                 SE_CRYPTO_CORE_SEL(CORE_DECRYPT);
507                 }
508                 break;
509         case SE_AES_OP_MODE_CTR:
510                 val = SE_CRYPTO_INPUT_SEL(INPUT_LNR_CTR) |
511                         SE_CRYPTO_VCTRAM_SEL(VCTRAM_AHB) |
512                         SE_CRYPTO_XOR_POS(XOR_BOTTOM) |
513                         SE_CRYPTO_CORE_SEL(CORE_ENCRYPT);
514                 break;
515         case SE_AES_OP_MODE_OFB:
516                 val = SE_CRYPTO_INPUT_SEL(INPUT_AESOUT) |
517                         SE_CRYPTO_VCTRAM_SEL(VCTRAM_AHB) |
518                         SE_CRYPTO_XOR_POS(XOR_BOTTOM) |
519                         SE_CRYPTO_CORE_SEL(CORE_ENCRYPT);
520                 break;
521         default:
522                 dev_warn(se_dev->dev, "Invalid operation mode\n");
523                 break;
524         }
525
526         if (mode == SE_AES_OP_MODE_CTR) {
527                 val |= SE_CRYPTO_HASH(HASH_DISABLE) |
528                         SE_CRYPTO_KEY_INDEX(slot_num) |
529                         SE_CRYPTO_CTR_CNTN(1);
530         } else {
531                 val |= SE_CRYPTO_HASH(HASH_DISABLE) |
532                         SE_CRYPTO_KEY_INDEX(slot_num) |
533                         (org_iv ? SE_CRYPTO_IV_SEL(IV_ORIGINAL) :
534                         SE_CRYPTO_IV_SEL(IV_UPDATED));
535         }
536
537         /* enable hash for CMAC */
538         if (mode == SE_AES_OP_MODE_CMAC)
539                 val |= SE_CRYPTO_HASH(HASH_ENABLE);
540
541         se_writel(se_dev, val, SE_CRYPTO_REG_OFFSET);
542
543         if (mode == SE_AES_OP_MODE_CTR)
544                 se_writel(se_dev, 1, SE_SPARE_0_REG_OFFSET);
545
546         if (mode == SE_AES_OP_MODE_OFB)
547                 se_writel(se_dev, 1, SE_SPARE_0_REG_OFFSET);
548
549 }
550
551 static void tegra_se_config_sha(struct tegra_se_dev *se_dev, u32 count)
552 {
553         int i;
554
555         se_writel(se_dev, (count * 8), SE_SHA_MSG_LENGTH_REG_OFFSET);
556         se_writel(se_dev, (count * 8), SE_SHA_MSG_LEFT_REG_OFFSET);
557         for (i = 1; i < 4; i++) {
558                 se_writel(se_dev, 0, SE_SHA_MSG_LENGTH_REG_OFFSET + (4 * i));
559                 se_writel(se_dev, 0, SE_SHA_MSG_LEFT_REG_OFFSET + (4 * i));
560         }
561         se_writel(se_dev, SHA_ENABLE, SE_SHA_CONFIG_REG_OFFSET);
562 }
563
564 static int tegra_se_start_operation(struct tegra_se_dev *se_dev, u32 nbytes,
565         bool context_save)
566 {
567         u32 nblocks = nbytes / TEGRA_SE_AES_BLOCK_SIZE;
568         int ret = 0;
569         u32 val = 0;
570
571         /* clear any pending interrupts */
572         val = se_readl(se_dev, SE_INT_STATUS_REG_OFFSET);
573         se_writel(se_dev, val, SE_INT_STATUS_REG_OFFSET);
574         se_writel(se_dev, se_dev->src_ll_buf_adr, SE_IN_LL_ADDR_REG_OFFSET);
575         se_writel(se_dev, se_dev->dst_ll_buf_adr, SE_OUT_LL_ADDR_REG_OFFSET);
576
577         if (nblocks)
578                 se_writel(se_dev, nblocks-1, SE_BLOCK_COUNT_REG_OFFSET);
579
580         /* enable interupts */
581         val = SE_INT_ERROR(INT_ENABLE) | SE_INT_OP_DONE(INT_ENABLE);
582         se_writel(se_dev, val, SE_INT_ENABLE_REG_OFFSET);
583
584         INIT_COMPLETION(se_dev->complete);
585
586         if (context_save)
587                 se_writel(se_dev, SE_OPERATION(OP_CTX_SAVE),
588                         SE_OPERATION_REG_OFFSET);
589         else
590                 se_writel(se_dev, SE_OPERATION(OP_SRART),
591                         SE_OPERATION_REG_OFFSET);
592
593         ret = wait_for_completion_timeout(&se_dev->complete,
594                         msecs_to_jiffies(1000));
595         if (ret == 0) {
596                 dev_err(se_dev->dev, "operation timed out no interrupt\n");
597                 return -ETIMEDOUT;
598         }
599
600         return 0;
601 }
602
603 static void tegra_se_read_hash_result(struct tegra_se_dev *se_dev,
604         u8 *pdata, u32 nbytes, bool swap32)
605 {
606         u32 *result = (u32 *)pdata;
607         u32 i;
608
609         for (i = 0; i < nbytes/4; i++) {
610                 result[i] = se_readl(se_dev, SE_HASH_RESULT_REG_OFFSET +
611                                 (i * sizeof(u32)));
612                 if (swap32)
613                         result[i] = be32_to_cpu(result[i]);
614         }
615 }
616
617 static int tegra_se_count_sgs(struct scatterlist *sl, u32 total_bytes)
618 {
619         int i = 0;
620
621         if (!total_bytes)
622                 return 0;
623
624         do {
625                 total_bytes -= sl[i].length;
626                 i++;
627         } while (total_bytes > 0);
628
629         return i;
630 }
631
632 static int tegra_se_alloc_ll_buf(struct tegra_se_dev *se_dev,
633         u32 num_src_sgs, u32 num_dst_sgs)
634 {
635         if (se_dev->src_ll_buf || se_dev->dst_ll_buf) {
636                 dev_err(se_dev->dev, "trying to allocate memory to allocated memory\n");
637                 return -EBUSY;
638         }
639
640         if (num_src_sgs) {
641                 se_dev->src_ll_size =
642                         (sizeof(struct tegra_se_ll) * num_src_sgs) +
643                                 sizeof(u32);
644                 se_dev->src_ll_buf = dma_alloc_coherent(se_dev->dev,
645                                         se_dev->src_ll_size,
646                                         &se_dev->src_ll_buf_adr, GFP_KERNEL);
647                 if (!se_dev->src_ll_buf) {
648                         dev_err(se_dev->dev, "can not allocate src lldma buffer\n");
649                         return -ENOMEM;
650                 }
651         }
652         if (num_dst_sgs) {
653                 se_dev->dst_ll_size =
654                                 (sizeof(struct tegra_se_ll) * num_dst_sgs) +
655                                         sizeof(u32);
656                 se_dev->dst_ll_buf = dma_alloc_coherent(se_dev->dev,
657                                         se_dev->dst_ll_size,
658                                         &se_dev->dst_ll_buf_adr, GFP_KERNEL);
659                 if (!se_dev->dst_ll_buf) {
660                         dev_err(se_dev->dev, "can not allocate dst ll dma buffer\n");
661                         return -ENOMEM;
662                 }
663         }
664
665         return 0;
666 }
667
668 static void tegra_se_free_ll_buf(struct tegra_se_dev *se_dev)
669 {
670         if (se_dev->src_ll_buf) {
671                 dma_free_coherent(se_dev->dev, se_dev->src_ll_size,
672                         se_dev->src_ll_buf, se_dev->src_ll_buf_adr);
673                 se_dev->src_ll_buf = NULL;
674         }
675
676         if (se_dev->dst_ll_buf) {
677                 dma_free_coherent(se_dev->dev, se_dev->dst_ll_size,
678                         se_dev->dst_ll_buf, se_dev->dst_ll_buf_adr);
679                 se_dev->dst_ll_buf = NULL;
680         }
681 }
682
683 static int tegra_se_setup_ablk_req(struct tegra_se_dev *se_dev,
684         struct ablkcipher_request *req)
685 {
686         struct scatterlist *src_sg, *dst_sg;
687         struct tegra_se_ll *src_ll, *dst_ll;
688         u32 total, num_src_sgs, num_dst_sgs;
689         int ret = 0;
690
691         num_src_sgs = tegra_se_count_sgs(req->src, req->nbytes);
692         num_dst_sgs = tegra_se_count_sgs(req->dst, req->nbytes);
693
694         if ((num_src_sgs > SE_MAX_SRC_SG_COUNT) ||
695                 (num_dst_sgs > SE_MAX_DST_SG_COUNT)) {
696                         dev_err(se_dev->dev, "num of SG buffers are more\n");
697                         return -EINVAL;
698         }
699
700         *se_dev->src_ll_buf = num_src_sgs-1;
701         *se_dev->dst_ll_buf = num_dst_sgs-1;
702
703         src_ll = (struct tegra_se_ll *)(se_dev->src_ll_buf + 1);
704         dst_ll = (struct tegra_se_ll *)(se_dev->dst_ll_buf + 1);
705
706         src_sg = req->src;
707         dst_sg = req->dst;
708         total = req->nbytes;
709
710         while (total) {
711                 ret = dma_map_sg(se_dev->dev, src_sg, 1, DMA_TO_DEVICE);
712                 if (!ret) {
713                         dev_err(se_dev->dev, "dma_map_sg() error\n");
714                         return -EINVAL;
715                 }
716
717                 ret = dma_map_sg(se_dev->dev, dst_sg, 1, DMA_FROM_DEVICE);
718                 if (!ret) {
719                         dev_err(se_dev->dev, "dma_map_sg() error\n");
720                         dma_unmap_sg(se_dev->dev, src_sg, 1, DMA_TO_DEVICE);
721                         return -EINVAL;
722                 }
723
724                 WARN_ON(src_sg->length != dst_sg->length);
725                 src_ll->addr = sg_dma_address(src_sg);
726                 src_ll->data_len = src_sg->length;
727                 dst_ll->addr = sg_dma_address(dst_sg);
728                 dst_ll->data_len = dst_sg->length;
729
730                 total -= src_sg->length;
731                 src_sg = sg_next(src_sg);
732                 dst_sg = sg_next(dst_sg);
733                 dst_ll++;
734                 src_ll++;
735                 WARN_ON(((total != 0) && (!src_sg || !dst_sg)));
736         }
737         return ret;
738 }
739
740 static void tegra_se_dequeue_complete_req(struct tegra_se_dev *se_dev,
741         struct ablkcipher_request *req)
742 {
743         struct scatterlist *src_sg, *dst_sg;
744         u32 total;
745
746         if (req) {
747                 src_sg = req->src;
748                 dst_sg = req->dst;
749                 total = req->nbytes;
750                 while (total) {
751                         dma_unmap_sg(se_dev->dev, dst_sg, 1, DMA_FROM_DEVICE);
752                         dma_unmap_sg(se_dev->dev, src_sg, 1, DMA_TO_DEVICE);
753                         total -= src_sg->length;
754                         src_sg = sg_next(src_sg);
755                         dst_sg = sg_next(dst_sg);
756                 }
757         }
758 }
759
760 static void tegra_se_process_new_req(struct crypto_async_request *async_req)
761 {
762         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
763         struct ablkcipher_request *req = ablkcipher_request_cast(async_req);
764         struct tegra_se_req_context *req_ctx = ablkcipher_request_ctx(req);
765         struct tegra_se_aes_context *aes_ctx =
766                         crypto_ablkcipher_ctx(crypto_ablkcipher_reqtfm(req));
767         int ret = 0;
768
769         /* take access to the hw */
770         mutex_lock(&se_hw_lock);
771
772         /* write IV */
773         if (req->info) {
774                 if (req_ctx->op_mode == SE_AES_OP_MODE_CTR) {
775                         tegra_se_write_seed(se_dev, (u32 *)req->info);
776                 } else {
777                         tegra_se_write_key_table(req->info,
778                                 TEGRA_SE_AES_IV_SIZE,
779                                 aes_ctx->slot->slot_num,
780                                 SE_KEY_TABLE_TYPE_ORGIV);
781                 }
782         }
783         tegra_se_setup_ablk_req(se_dev, req);
784         tegra_se_config_algo(se_dev, req_ctx->op_mode, req_ctx->encrypt,
785                 aes_ctx->keylen);
786         tegra_se_config_crypto(se_dev, req_ctx->op_mode, req_ctx->encrypt,
787                         aes_ctx->slot->slot_num, req->info ? true : false);
788         ret = tegra_se_start_operation(se_dev, req->nbytes, false);
789         tegra_se_dequeue_complete_req(se_dev, req);
790
791         mutex_unlock(&se_hw_lock);
792         req->base.complete(&req->base, ret);
793 }
794
795 static irqreturn_t tegra_se_irq(int irq, void *dev)
796 {
797         struct tegra_se_dev *se_dev = dev;
798         u32 val;
799
800         val = se_readl(se_dev, SE_INT_STATUS_REG_OFFSET);
801         se_writel(se_dev, val, SE_INT_STATUS_REG_OFFSET);
802
803         if (val & SE_INT_ERROR(INT_SET))
804                 dev_err(se_dev->dev, "tegra_se_irq::error");
805
806         if (val & SE_INT_OP_DONE(INT_SET))
807                 complete(&se_dev->complete);
808
809         return IRQ_HANDLED;
810 }
811
812 static void tegra_se_work_handler(struct work_struct *work)
813 {
814         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
815         struct crypto_async_request *async_req = NULL;
816         struct crypto_async_request *backlog = NULL;
817
818         pm_runtime_get_sync(se_dev->dev);
819
820         do {
821                 spin_lock_irq(&se_dev->lock);
822                 backlog = crypto_get_backlog(&se_dev->queue);
823                 async_req = crypto_dequeue_request(&se_dev->queue);
824                 if (!async_req)
825                         se_dev->work_q_busy = false;
826
827                 spin_unlock_irq(&se_dev->lock);
828
829                 if (backlog) {
830                         backlog->complete(backlog, -EINPROGRESS);
831                         backlog = NULL;
832                 }
833
834                 if (async_req) {
835                         tegra_se_process_new_req(async_req);
836                         async_req = NULL;
837                 }
838         } while (se_dev->work_q_busy);
839         pm_runtime_put(se_dev->dev);
840 }
841
842 static int tegra_se_aes_queue_req(struct ablkcipher_request *req)
843 {
844         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
845         unsigned long flags;
846         bool idle = true;
847         int err = 0;
848
849         spin_lock_irqsave(&se_dev->lock, flags);
850         err = ablkcipher_enqueue_request(&se_dev->queue, req);
851         if (se_dev->work_q_busy)
852                 idle = false;
853         spin_unlock_irqrestore(&se_dev->lock, flags);
854
855         if (idle) {
856                 spin_lock_irq(&se_dev->lock);
857                 se_dev->work_q_busy = true;
858                 spin_unlock_irq(&se_dev->lock);
859                 queue_work(se_work_q, &se_work);
860         }
861
862         return err;
863 }
864
865 static int tegra_se_aes_cbc_encrypt(struct ablkcipher_request *req)
866 {
867         struct tegra_se_req_context *req_ctx = ablkcipher_request_ctx(req);
868
869         req_ctx->encrypt = true;
870         req_ctx->op_mode = SE_AES_OP_MODE_CBC;
871
872         return tegra_se_aes_queue_req(req);
873 }
874
875 static int tegra_se_aes_cbc_decrypt(struct ablkcipher_request *req)
876 {
877         struct tegra_se_req_context *req_ctx = ablkcipher_request_ctx(req);
878
879         req_ctx->encrypt = false;
880         req_ctx->op_mode = SE_AES_OP_MODE_CBC;
881
882         return tegra_se_aes_queue_req(req);
883 }
884
885 static int tegra_se_aes_ecb_encrypt(struct ablkcipher_request *req)
886 {
887         struct tegra_se_req_context *req_ctx = ablkcipher_request_ctx(req);
888
889         req_ctx->encrypt = true;
890         req_ctx->op_mode = SE_AES_OP_MODE_ECB;
891
892         return tegra_se_aes_queue_req(req);
893 }
894
895 static int tegra_se_aes_ecb_decrypt(struct ablkcipher_request *req)
896 {
897         struct tegra_se_req_context *req_ctx = ablkcipher_request_ctx(req);
898
899         req_ctx->encrypt = false;
900         req_ctx->op_mode = SE_AES_OP_MODE_ECB;
901
902         return tegra_se_aes_queue_req(req);
903 }
904
905 static int tegra_se_aes_ctr_encrypt(struct ablkcipher_request *req)
906 {
907         struct tegra_se_req_context *req_ctx = ablkcipher_request_ctx(req);
908
909         req_ctx->encrypt = true;
910         req_ctx->op_mode = SE_AES_OP_MODE_CTR;
911
912         return tegra_se_aes_queue_req(req);
913 }
914
915 static int tegra_se_aes_ctr_decrypt(struct ablkcipher_request *req)
916 {
917         struct tegra_se_req_context *req_ctx = ablkcipher_request_ctx(req);
918
919         req_ctx->encrypt = false;
920         req_ctx->op_mode = SE_AES_OP_MODE_CTR;
921
922         return tegra_se_aes_queue_req(req);
923 }
924
925 static int tegra_se_aes_ofb_encrypt(struct ablkcipher_request *req)
926 {
927         struct tegra_se_req_context *req_ctx = ablkcipher_request_ctx(req);
928
929         req_ctx->encrypt = true;
930         req_ctx->op_mode = SE_AES_OP_MODE_OFB;
931
932         return tegra_se_aes_queue_req(req);
933 }
934
935 static int tegra_se_aes_ofb_decrypt(struct ablkcipher_request *req)
936 {
937         struct tegra_se_req_context *req_ctx = ablkcipher_request_ctx(req);
938
939         req_ctx->encrypt = false;
940         req_ctx->op_mode = SE_AES_OP_MODE_OFB;
941
942         return tegra_se_aes_queue_req(req);
943 }
944
945 static int tegra_se_aes_setkey(struct crypto_ablkcipher *tfm,
946         const u8 *key, u32 keylen)
947 {
948         struct tegra_se_aes_context *ctx = crypto_ablkcipher_ctx(tfm);
949         struct tegra_se_dev *se_dev = ctx->se_dev;
950         struct tegra_se_slot *pslot;
951         u8 *pdata = (u8 *)key;
952
953         if (!ctx) {
954                 dev_err(se_dev->dev, "invalid context");
955                 return -EINVAL;
956         }
957
958         if ((keylen != TEGRA_SE_KEY_128_SIZE) &&
959                 (keylen != TEGRA_SE_KEY_192_SIZE) &&
960                 (keylen != TEGRA_SE_KEY_256_SIZE)) {
961                 dev_err(se_dev->dev, "invalid key size");
962                 return -EINVAL;
963         }
964
965         if (key) {
966                 if (!ctx->slot || (ctx->slot &&
967                     ctx->slot->slot_num == ssk_slot.slot_num)) {
968                         pslot = tegra_se_alloc_key_slot();
969                         if (!pslot) {
970                                 dev_err(se_dev->dev, "no free key slot\n");
971                                 return -ENOMEM;
972                         }
973                         ctx->slot = pslot;
974                 }
975                 ctx->keylen = keylen;
976         } else {
977                 tegra_se_free_key_slot(ctx->slot);
978                 ctx->slot = &ssk_slot;
979                 ctx->keylen = AES_KEYSIZE_128;
980         }
981
982         /* take access to the hw */
983         mutex_lock(&se_hw_lock);
984         pm_runtime_get_sync(se_dev->dev);
985
986         /* load the key */
987         tegra_se_write_key_table(pdata, keylen, ctx->slot->slot_num,
988                 SE_KEY_TABLE_TYPE_KEY);
989
990         pm_runtime_put(se_dev->dev);
991         mutex_unlock(&se_hw_lock);
992
993         return 0;
994 }
995
996 static int tegra_se_aes_cra_init(struct crypto_tfm *tfm)
997 {
998         struct tegra_se_aes_context *ctx = crypto_tfm_ctx(tfm);
999
1000         ctx->se_dev = sg_tegra_se_dev;
1001         tfm->crt_ablkcipher.reqsize = sizeof(struct tegra_se_req_context);
1002
1003         return 0;
1004 }
1005
1006 static void tegra_se_aes_cra_exit(struct crypto_tfm *tfm)
1007 {
1008         struct tegra_se_aes_context *ctx = crypto_tfm_ctx(tfm);
1009
1010         tegra_se_free_key_slot(ctx->slot);
1011         ctx->slot = NULL;
1012 }
1013
1014 static int tegra_se_rng_init(struct crypto_tfm *tfm)
1015 {
1016         struct tegra_se_rng_context *rng_ctx = crypto_tfm_ctx(tfm);
1017         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
1018
1019         rng_ctx->se_dev = se_dev;
1020         rng_ctx->dt_buf = dma_alloc_coherent(se_dev->dev, TEGRA_SE_RNG_DT_SIZE,
1021                 &rng_ctx->dt_buf_adr, GFP_KERNEL);
1022         if (!rng_ctx->dt_buf) {
1023                 dev_err(se_dev->dev, "can not allocate rng dma buffer");
1024                 return -ENOMEM;
1025         }
1026
1027         rng_ctx->rng_buf = dma_alloc_coherent(rng_ctx->se_dev->dev,
1028                 TEGRA_SE_RNG_DT_SIZE, &rng_ctx->rng_buf_adr, GFP_KERNEL);
1029         if (!rng_ctx->rng_buf) {
1030                 dev_err(se_dev->dev, "can not allocate rng dma buffer");
1031                 dma_free_coherent(rng_ctx->se_dev->dev, TEGRA_SE_RNG_DT_SIZE,
1032                                         rng_ctx->dt_buf, rng_ctx->dt_buf_adr);
1033                 return -ENOMEM;
1034         }
1035
1036         rng_ctx->slot = tegra_se_alloc_key_slot();
1037
1038         if (!rng_ctx->slot) {
1039                 dev_err(rng_ctx->se_dev->dev, "no free slot\n");
1040                 dma_free_coherent(rng_ctx->se_dev->dev, TEGRA_SE_RNG_DT_SIZE,
1041                                         rng_ctx->dt_buf, rng_ctx->dt_buf_adr);
1042                 dma_free_coherent(rng_ctx->se_dev->dev, TEGRA_SE_RNG_DT_SIZE,
1043                                         rng_ctx->rng_buf, rng_ctx->rng_buf_adr);
1044                 return -ENOMEM;
1045         }
1046
1047         return 0;
1048 }
1049
1050 static void tegra_se_rng_exit(struct crypto_tfm *tfm)
1051 {
1052         struct tegra_se_rng_context *rng_ctx = crypto_tfm_ctx(tfm);
1053
1054         if (rng_ctx->dt_buf) {
1055                 dma_free_coherent(rng_ctx->se_dev->dev, TEGRA_SE_RNG_DT_SIZE,
1056                         rng_ctx->dt_buf, rng_ctx->dt_buf_adr);
1057         }
1058
1059         if (rng_ctx->rng_buf) {
1060                 dma_free_coherent(rng_ctx->se_dev->dev, TEGRA_SE_RNG_DT_SIZE,
1061                         rng_ctx->rng_buf, rng_ctx->rng_buf_adr);
1062         }
1063
1064         tegra_se_free_key_slot(rng_ctx->slot);
1065         rng_ctx->slot = NULL;
1066         rng_ctx->se_dev = NULL;
1067 }
1068
1069 static int tegra_se_rng_get_random(struct crypto_rng *tfm, u8 *rdata, u32 dlen)
1070 {
1071         struct tegra_se_rng_context *rng_ctx = crypto_rng_ctx(tfm);
1072         struct tegra_se_dev *se_dev = rng_ctx->se_dev;
1073         struct tegra_se_ll *src_ll, *dst_ll;
1074         unsigned char *dt_buf = (unsigned char *)rng_ctx->dt_buf;
1075         u8 *rdata_addr;
1076         int ret = 0, i, j, num_blocks, data_len = 0;
1077
1078         num_blocks = (dlen / TEGRA_SE_RNG_DT_SIZE);
1079
1080         data_len = (dlen % TEGRA_SE_RNG_DT_SIZE);
1081         if (data_len == 0)
1082                 num_blocks = num_blocks - 1;
1083
1084         /* take access to the hw */
1085         mutex_lock(&se_hw_lock);
1086         pm_runtime_get_sync(se_dev->dev);
1087
1088         *se_dev->src_ll_buf = 0;
1089         *se_dev->dst_ll_buf = 0;
1090         src_ll = (struct tegra_se_ll *)(se_dev->src_ll_buf + 1);
1091         dst_ll = (struct tegra_se_ll *)(se_dev->dst_ll_buf + 1);
1092         src_ll->addr = rng_ctx->dt_buf_adr;
1093         src_ll->data_len = TEGRA_SE_RNG_DT_SIZE;
1094         dst_ll->addr = rng_ctx->rng_buf_adr;
1095         dst_ll->data_len = TEGRA_SE_RNG_DT_SIZE;
1096
1097         tegra_se_config_algo(se_dev, SE_AES_OP_MODE_RNG_X931, true,
1098                 TEGRA_SE_KEY_128_SIZE);
1099         tegra_se_config_crypto(se_dev, SE_AES_OP_MODE_RNG_X931, true,
1100                                 rng_ctx->slot->slot_num, rng_ctx->use_org_iv);
1101         for (j = 0; j <= num_blocks; j++) {
1102                 ret = tegra_se_start_operation(se_dev,
1103                                 TEGRA_SE_RNG_DT_SIZE, false);
1104
1105                 if (!ret) {
1106                         rdata_addr = (rdata + (j * TEGRA_SE_RNG_DT_SIZE));
1107
1108                         if (data_len && num_blocks == j) {
1109                                 memcpy(rdata_addr, rng_ctx->rng_buf, data_len);
1110                         } else {
1111                                 memcpy(rdata_addr,
1112                                         rng_ctx->rng_buf, TEGRA_SE_RNG_DT_SIZE);
1113                         }
1114
1115                         /* update DT vector */
1116                         for (i = TEGRA_SE_RNG_DT_SIZE - 1; i >= 0; i--) {
1117                                 dt_buf[i] += 1;
1118                                 if (dt_buf[i] != 0)
1119                                         break;
1120                         }
1121                 } else {
1122                         dlen = 0;
1123                 }
1124                 if (rng_ctx->use_org_iv) {
1125                         rng_ctx->use_org_iv = false;
1126                         tegra_se_config_crypto(se_dev,
1127                                 SE_AES_OP_MODE_RNG_X931, true,
1128                                 rng_ctx->slot->slot_num, rng_ctx->use_org_iv);
1129                 }
1130         }
1131
1132         pm_runtime_put(se_dev->dev);
1133         mutex_unlock(&se_hw_lock);
1134
1135         return dlen;
1136 }
1137
1138 static int tegra_se_rng_reset(struct crypto_rng *tfm, u8 *seed, u32 slen)
1139 {
1140         struct tegra_se_rng_context *rng_ctx = crypto_rng_ctx(tfm);
1141         struct tegra_se_dev *se_dev = rng_ctx->se_dev;
1142         u8 *iv = seed;
1143         u8 *key = (u8 *)(seed + TEGRA_SE_RNG_IV_SIZE);
1144         u8 *dt = key + TEGRA_SE_RNG_KEY_SIZE;
1145         struct timespec ts;
1146         u64 nsec, tmp[2];
1147
1148         BUG_ON(!seed);
1149
1150         /* take access to the hw */
1151         mutex_lock(&se_hw_lock);
1152         pm_runtime_get_sync(se_dev->dev);
1153
1154         tegra_se_write_key_table(key, TEGRA_SE_RNG_KEY_SIZE,
1155                 rng_ctx->slot->slot_num, SE_KEY_TABLE_TYPE_KEY);
1156
1157         tegra_se_write_key_table(iv, TEGRA_SE_RNG_IV_SIZE,
1158                 rng_ctx->slot->slot_num, SE_KEY_TABLE_TYPE_ORGIV);
1159
1160         pm_runtime_put(se_dev->dev);
1161         mutex_unlock(&se_hw_lock);
1162
1163         if (slen < TEGRA_SE_RNG_SEED_SIZE) {
1164                 getnstimeofday(&ts);
1165                 nsec = timespec_to_ns(&ts);
1166                 do_div(nsec, 1000);
1167                 nsec ^= se_dev->ctr << 56;
1168                 se_dev->ctr++;
1169                 tmp[0] = nsec;
1170                 tmp[1] = tegra_chip_uid();
1171                 memcpy(rng_ctx->dt_buf, (u8 *)tmp, TEGRA_SE_RNG_DT_SIZE);
1172         } else {
1173                 memcpy(rng_ctx->dt_buf, dt, TEGRA_SE_RNG_DT_SIZE);
1174         }
1175
1176         rng_ctx->use_org_iv = true;
1177
1178         return 0;
1179 }
1180
1181 int tegra_se_sha_init(struct ahash_request *req)
1182 {
1183         return 0;
1184 }
1185
1186 int tegra_se_sha_update(struct ahash_request *req)
1187 {
1188         return 0;
1189 }
1190
1191 int tegra_se_sha_finup(struct ahash_request *req)
1192 {
1193         return 0;
1194 }
1195
1196 int tegra_se_sha_final(struct ahash_request *req)
1197 {
1198         struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
1199         struct tegra_se_sha_context *sha_ctx = crypto_ahash_ctx(tfm);
1200         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
1201         struct scatterlist *src_sg;
1202         struct tegra_se_ll *src_ll;
1203         u32 total, num_sgs;
1204         int err = 0;
1205
1206         if (crypto_ahash_digestsize(tfm) == SHA1_DIGEST_SIZE)
1207                 sha_ctx->op_mode = SE_AES_OP_MODE_SHA1;
1208
1209         if (crypto_ahash_digestsize(tfm) == SHA224_DIGEST_SIZE)
1210                 sha_ctx->op_mode = SE_AES_OP_MODE_SHA224;
1211
1212         if (crypto_ahash_digestsize(tfm) == SHA256_DIGEST_SIZE)
1213                 sha_ctx->op_mode = SE_AES_OP_MODE_SHA256;
1214
1215         if (crypto_ahash_digestsize(tfm) == SHA384_DIGEST_SIZE)
1216                 sha_ctx->op_mode = SE_AES_OP_MODE_SHA384;
1217
1218         if (crypto_ahash_digestsize(tfm) == SHA512_DIGEST_SIZE)
1219                 sha_ctx->op_mode = SE_AES_OP_MODE_SHA512;
1220
1221         /* take access to the hw */
1222         mutex_lock(&se_hw_lock);
1223         pm_runtime_get_sync(se_dev->dev);
1224
1225         num_sgs = tegra_se_count_sgs(req->src, req->nbytes);
1226         if ((num_sgs > SE_MAX_SRC_SG_COUNT)) {
1227                 dev_err(se_dev->dev, "num of SG buffers are more\n");
1228                 pm_runtime_put(se_dev->dev);
1229                 mutex_unlock(&se_hw_lock);
1230                 return -EINVAL;
1231         }
1232         *se_dev->src_ll_buf = num_sgs-1;
1233         src_ll = (struct tegra_se_ll *)(se_dev->src_ll_buf + 1);
1234         src_sg = req->src;
1235         total = req->nbytes;
1236
1237         while (total) {
1238                 err = dma_map_sg(se_dev->dev, src_sg, 1, DMA_TO_DEVICE);
1239                 if (!err) {
1240                         dev_err(se_dev->dev, "dma_map_sg() error\n");
1241                         pm_runtime_put(se_dev->dev);
1242                         mutex_unlock(&se_hw_lock);
1243                         return -EINVAL;
1244                 }
1245                 src_ll->addr = sg_dma_address(src_sg);
1246                 src_ll->data_len = src_sg->length;
1247
1248                 total -= src_sg->length;
1249                 src_sg = sg_next(src_sg);
1250                 src_ll++;
1251         }
1252
1253         tegra_se_config_algo(se_dev, sha_ctx->op_mode, false, 0);
1254         tegra_se_config_sha(se_dev, req->nbytes);
1255         err = tegra_se_start_operation(se_dev, 0, false);
1256         if (!err) {
1257                 tegra_se_read_hash_result(se_dev, req->result,
1258                         crypto_ahash_digestsize(tfm), true);
1259                 if ((sha_ctx->op_mode == SE_AES_OP_MODE_SHA384) ||
1260                         (sha_ctx->op_mode == SE_AES_OP_MODE_SHA512)) {
1261                         u32 *result = (u32 *)req->result;
1262                         u32 temp, i;
1263
1264                         for (i = 0; i < crypto_ahash_digestsize(tfm)/4;
1265                                 i += 2) {
1266                                 temp = result[i];
1267                                 result[i] = result[i+1];
1268                                 result[i+1] = temp;
1269                         }
1270                 }
1271         }
1272
1273         src_sg = req->src;
1274         total = req->nbytes;
1275         while (total) {
1276                 dma_unmap_sg(se_dev->dev, src_sg, 1, DMA_TO_DEVICE);
1277                 total -= src_sg->length;
1278                 src_sg = sg_next(src_sg);
1279         }
1280         pm_runtime_put(se_dev->dev);
1281         mutex_unlock(&se_hw_lock);
1282
1283         return err;
1284 }
1285
1286 static int tegra_se_sha_digest(struct ahash_request *req)
1287 {
1288         return tegra_se_sha_init(req) ?: tegra_se_sha_final(req);
1289 }
1290
1291 int tegra_se_sha_cra_init(struct crypto_tfm *tfm)
1292 {
1293         crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),
1294                                  sizeof(struct tegra_se_sha_context));
1295         return 0;
1296 }
1297
1298 void tegra_se_sha_cra_exit(struct crypto_tfm *tfm)
1299 {
1300         /* do nothing */
1301 }
1302
1303 int tegra_se_aes_cmac_init(struct ahash_request *req)
1304 {
1305
1306         return 0;
1307 }
1308
1309 int tegra_se_aes_cmac_update(struct ahash_request *req)
1310 {
1311         return 0;
1312 }
1313
1314 int tegra_se_aes_cmac_final(struct ahash_request *req)
1315 {
1316         struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
1317         struct tegra_se_aes_cmac_context *cmac_ctx = crypto_ahash_ctx(tfm);
1318         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
1319         struct scatterlist *src_sg;
1320         struct tegra_se_ll *src_ll;
1321         struct sg_mapping_iter miter;
1322         u32 num_sgs, blocks_to_process, last_block_bytes = 0, bytes_to_copy = 0;
1323         u8 piv[TEGRA_SE_AES_IV_SIZE];
1324         int total, ret = 0, i = 0, mapped_sg_count = 0;
1325         bool padding_needed = false;
1326         unsigned long flags;
1327         unsigned int sg_flags = SG_MITER_ATOMIC;
1328         u8 *temp_buffer = NULL;
1329         bool use_orig_iv = true;
1330
1331         /* take access to the hw */
1332         mutex_lock(&se_hw_lock);
1333         pm_runtime_get_sync(se_dev->dev);
1334
1335         blocks_to_process = req->nbytes / TEGRA_SE_AES_BLOCK_SIZE;
1336         /* num of bytes less than block size */
1337         if ((req->nbytes % TEGRA_SE_AES_BLOCK_SIZE) || !blocks_to_process) {
1338                 padding_needed = true;
1339                 last_block_bytes = req->nbytes % TEGRA_SE_AES_BLOCK_SIZE;
1340         } else {
1341                 /* decrement num of blocks */
1342                 blocks_to_process--;
1343                 if (blocks_to_process) {
1344                         /* there are blocks to process and find last block
1345                                 bytes */
1346                         last_block_bytes = req->nbytes -
1347                                 (blocks_to_process * TEGRA_SE_AES_BLOCK_SIZE);
1348                 } else {
1349                         /* this is the last block and equal to block size */
1350                         last_block_bytes = req->nbytes;
1351                 }
1352         }
1353
1354         /* first process all blocks except last block */
1355         if (blocks_to_process) {
1356                 num_sgs = tegra_se_count_sgs(req->src, req->nbytes);
1357                 if (num_sgs > SE_MAX_SRC_SG_COUNT) {
1358                         dev_err(se_dev->dev, "num of SG buffers are more\n");
1359                         goto out;
1360                 }
1361                 *se_dev->src_ll_buf = num_sgs - 1;
1362                 src_ll = (struct tegra_se_ll *)(se_dev->src_ll_buf + 1);
1363                 src_sg = req->src;
1364                 total = blocks_to_process * TEGRA_SE_AES_BLOCK_SIZE;
1365                 while (total > 0) {
1366                         ret = dma_map_sg(se_dev->dev, src_sg, 1, DMA_TO_DEVICE);
1367                         mapped_sg_count++;
1368                         if (!ret) {
1369                                 dev_err(se_dev->dev, "dma_map_sg() error\n");
1370                                 goto out;
1371                         }
1372                         src_ll->addr = sg_dma_address(src_sg);
1373                         if (total > src_sg->length)
1374                                 src_ll->data_len = src_sg->length;
1375                         else
1376                                 src_ll->data_len = total;
1377
1378                         total -= src_sg->length;
1379                         if (total > 0) {
1380                                 src_sg = sg_next(src_sg);
1381                                 src_ll++;
1382                         }
1383                         WARN_ON(((total != 0) && (!src_sg)));
1384                 }
1385                 tegra_se_config_algo(se_dev, SE_AES_OP_MODE_CMAC, true,
1386                         cmac_ctx->keylen);
1387                 /* write zero IV */
1388                 memset(piv, 0, TEGRA_SE_AES_IV_SIZE);
1389                 tegra_se_write_key_table(piv, TEGRA_SE_AES_IV_SIZE,
1390                                         cmac_ctx->slot->slot_num,
1391                                         SE_KEY_TABLE_TYPE_ORGIV);
1392                 tegra_se_config_crypto(se_dev, SE_AES_OP_MODE_CMAC, true,
1393                                         cmac_ctx->slot->slot_num, true);
1394                 tegra_se_start_operation(se_dev,
1395                         blocks_to_process * TEGRA_SE_AES_BLOCK_SIZE, false);
1396                 src_sg = req->src;
1397                 while (mapped_sg_count--) {
1398                         dma_unmap_sg(se_dev->dev, src_sg, 1, DMA_TO_DEVICE);
1399                         src_sg = sg_next(src_sg);
1400                 }
1401                 use_orig_iv = false;
1402         }
1403
1404         /* get the last block bytes from the sg_dma buffer using miter */
1405         src_sg = req->src;
1406         num_sgs = tegra_se_count_sgs(req->src, req->nbytes);
1407         sg_flags |= SG_MITER_FROM_SG;
1408         sg_miter_start(&miter, req->src, num_sgs, sg_flags);
1409         local_irq_save(flags);
1410         total = 0;
1411         cmac_ctx->buffer = dma_alloc_coherent(se_dev->dev,
1412                                 TEGRA_SE_AES_BLOCK_SIZE,
1413                                 &cmac_ctx->dma_addr, GFP_KERNEL);
1414
1415         if (!cmac_ctx->buffer)
1416                 goto out;
1417
1418         temp_buffer = cmac_ctx->buffer;
1419         while (sg_miter_next(&miter) && total < req->nbytes) {
1420                 unsigned int len;
1421                 len = min(miter.length, req->nbytes - total);
1422                 if ((req->nbytes - (total + len)) <= last_block_bytes) {
1423                         bytes_to_copy =
1424                                 last_block_bytes -
1425                                 (req->nbytes - (total + len));
1426                         memcpy(temp_buffer, miter.addr + (len - bytes_to_copy),
1427                                 bytes_to_copy);
1428                         last_block_bytes -= bytes_to_copy;
1429                         temp_buffer += bytes_to_copy;
1430                 }
1431                 total += len;
1432         }
1433         sg_miter_stop(&miter);
1434         local_irq_restore(flags);
1435
1436         /* process last block */
1437         if (padding_needed) {
1438                 /* pad with 0x80, 0, 0 ... */
1439                 last_block_bytes = req->nbytes % TEGRA_SE_AES_BLOCK_SIZE;
1440                 cmac_ctx->buffer[last_block_bytes] = 0x80;
1441                 for (i = last_block_bytes+1; i < TEGRA_SE_AES_BLOCK_SIZE; i++)
1442                         cmac_ctx->buffer[i] = 0;
1443                 /* XOR with K2 */
1444                 for (i = 0; i < TEGRA_SE_AES_BLOCK_SIZE; i++)
1445                         cmac_ctx->buffer[i] ^= cmac_ctx->K2[i];
1446         } else {
1447                 /* XOR with K1 */
1448                 for (i = 0; i < TEGRA_SE_AES_BLOCK_SIZE; i++)
1449                         cmac_ctx->buffer[i] ^= cmac_ctx->K1[i];
1450         }
1451         *se_dev->src_ll_buf = 0;
1452         src_ll = (struct tegra_se_ll *)(se_dev->src_ll_buf + 1);
1453         src_ll->addr = cmac_ctx->dma_addr;
1454         src_ll->data_len = TEGRA_SE_AES_BLOCK_SIZE;
1455
1456         if (use_orig_iv) {
1457                 /* use zero IV, this is when num of bytes is
1458                         less <= block size */
1459                 memset(piv, 0, TEGRA_SE_AES_IV_SIZE);
1460                 tegra_se_write_key_table(piv, TEGRA_SE_AES_IV_SIZE,
1461                                         cmac_ctx->slot->slot_num,
1462                                         SE_KEY_TABLE_TYPE_ORGIV);
1463         }
1464
1465         tegra_se_config_algo(se_dev, SE_AES_OP_MODE_CMAC, true,
1466                                 cmac_ctx->keylen);
1467         tegra_se_config_crypto(se_dev, SE_AES_OP_MODE_CMAC, true,
1468                                 cmac_ctx->slot->slot_num, use_orig_iv);
1469         tegra_se_start_operation(se_dev, TEGRA_SE_AES_BLOCK_SIZE, false);
1470         tegra_se_read_hash_result(se_dev, req->result,
1471                                 TEGRA_SE_AES_CMAC_DIGEST_SIZE, false);
1472
1473 out:
1474         pm_runtime_put(se_dev->dev);
1475         mutex_unlock(&se_hw_lock);
1476
1477         if (cmac_ctx->buffer)
1478                 dma_free_coherent(se_dev->dev, TEGRA_SE_AES_BLOCK_SIZE,
1479                         cmac_ctx->buffer, cmac_ctx->dma_addr);
1480
1481         return 0;
1482 }
1483
1484 int tegra_se_aes_cmac_setkey(struct crypto_ahash *tfm, const u8 *key,
1485                 unsigned int keylen)
1486 {
1487         struct tegra_se_aes_cmac_context *ctx = crypto_ahash_ctx(tfm);
1488         struct tegra_se_dev *se_dev = sg_tegra_se_dev;
1489         struct tegra_se_ll *src_ll, *dst_ll;
1490         struct tegra_se_slot *pslot;
1491         u8 piv[TEGRA_SE_AES_IV_SIZE];
1492         u32 *pbuf;
1493         dma_addr_t pbuf_adr;
1494         int ret = 0;
1495         u8 const rb = 0x87;
1496         u8 msb;
1497
1498         if (!ctx) {
1499                 dev_err(se_dev->dev, "invalid context");
1500                 return -EINVAL;
1501         }
1502
1503         if ((keylen != TEGRA_SE_KEY_128_SIZE) &&
1504                 (keylen != TEGRA_SE_KEY_192_SIZE) &&
1505                 (keylen != TEGRA_SE_KEY_256_SIZE)) {
1506                 dev_err(se_dev->dev, "invalid key size");
1507                 return -EINVAL;
1508         }
1509
1510         if (key) {
1511                 if (!ctx->slot || (ctx->slot &&
1512                     ctx->slot->slot_num == ssk_slot.slot_num)) {
1513                         pslot = tegra_se_alloc_key_slot();
1514                         if (!pslot) {
1515                                 dev_err(se_dev->dev, "no free key slot\n");
1516                                 return -ENOMEM;
1517                         }
1518                         ctx->slot = pslot;
1519                 }
1520                 ctx->keylen = keylen;
1521         } else {
1522                 tegra_se_free_key_slot(ctx->slot);
1523                 ctx->slot = &ssk_slot;
1524                 ctx->keylen = AES_KEYSIZE_128;
1525         }
1526
1527         pbuf = dma_alloc_coherent(se_dev->dev, TEGRA_SE_AES_BLOCK_SIZE,
1528                 &pbuf_adr, GFP_KERNEL);
1529         if (!pbuf) {
1530                 dev_err(se_dev->dev, "can not allocate dma buffer");
1531                 return -ENOMEM;
1532         }
1533         memset(pbuf, 0, TEGRA_SE_AES_BLOCK_SIZE);
1534
1535         /* take access to the hw */
1536         mutex_lock(&se_hw_lock);
1537         pm_runtime_get_sync(se_dev->dev);
1538
1539         *se_dev->src_ll_buf = 0;
1540         *se_dev->dst_ll_buf = 0;
1541         src_ll = (struct tegra_se_ll *)(se_dev->src_ll_buf + 1);
1542         dst_ll = (struct tegra_se_ll *)(se_dev->dst_ll_buf + 1);
1543
1544         src_ll->addr = pbuf_adr;
1545         src_ll->data_len = TEGRA_SE_AES_BLOCK_SIZE;
1546         dst_ll->addr = pbuf_adr;
1547         dst_ll->data_len = TEGRA_SE_AES_BLOCK_SIZE;
1548
1549         /* load the key */
1550         tegra_se_write_key_table((u8 *)key, keylen,
1551                                 ctx->slot->slot_num, SE_KEY_TABLE_TYPE_KEY);
1552
1553         /* write zero IV */
1554         memset(piv, 0, TEGRA_SE_AES_IV_SIZE);
1555
1556         /* load IV */
1557         tegra_se_write_key_table(piv, TEGRA_SE_AES_IV_SIZE,
1558                                 ctx->slot->slot_num, SE_KEY_TABLE_TYPE_ORGIV);
1559
1560         /* config crypto algo */
1561         tegra_se_config_algo(se_dev, SE_AES_OP_MODE_CBC, true, keylen);
1562
1563         tegra_se_config_crypto(se_dev, SE_AES_OP_MODE_CBC, true,
1564                 ctx->slot->slot_num, true);
1565
1566         ret = tegra_se_start_operation(se_dev, TEGRA_SE_AES_BLOCK_SIZE, false);
1567         if (ret) {
1568                 dev_err(se_dev->dev, "tegra_se_aes_cmac_setkey:: start op failed\n");
1569                 goto out;
1570         }
1571
1572         /* compute K1 subkey */
1573         memcpy(ctx->K1, pbuf, TEGRA_SE_AES_BLOCK_SIZE);
1574         tegra_se_leftshift_onebit(ctx->K1, TEGRA_SE_AES_BLOCK_SIZE, &msb);
1575         if (msb)
1576                 ctx->K1[TEGRA_SE_AES_BLOCK_SIZE - 1] ^= rb;
1577
1578         /* compute K2 subkey */
1579         memcpy(ctx->K2, ctx->K1, TEGRA_SE_AES_BLOCK_SIZE);
1580         tegra_se_leftshift_onebit(ctx->K2, TEGRA_SE_AES_BLOCK_SIZE, &msb);
1581
1582         if (msb)
1583                 ctx->K2[TEGRA_SE_AES_BLOCK_SIZE - 1] ^= rb;
1584
1585 out:
1586         pm_runtime_put(se_dev->dev);
1587         mutex_unlock(&se_hw_lock);
1588
1589         if (pbuf) {
1590                 dma_free_coherent(se_dev->dev, TEGRA_SE_AES_BLOCK_SIZE,
1591                         pbuf, pbuf_adr);
1592         }
1593
1594         return 0;
1595 }
1596
1597 int tegra_se_aes_cmac_digest(struct ahash_request *req)
1598 {
1599         return tegra_se_aes_cmac_init(req) ?: tegra_se_aes_cmac_final(req);
1600 }
1601
1602 int tegra_se_aes_cmac_finup(struct ahash_request *req)
1603 {
1604         return 0;
1605 }
1606
1607 int tegra_se_aes_cmac_cra_init(struct crypto_tfm *tfm)
1608 {
1609         crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),
1610                                  sizeof(struct tegra_se_aes_cmac_context));
1611
1612         return 0;
1613 }
1614 void tegra_se_aes_cmac_cra_exit(struct crypto_tfm *tfm)
1615 {
1616         struct tegra_se_aes_cmac_context *ctx = crypto_tfm_ctx(tfm);
1617
1618         tegra_se_free_key_slot(ctx->slot);
1619         ctx->slot = NULL;
1620 }
1621
1622 static struct crypto_alg aes_algs[] = {
1623         {
1624                 .cra_name = "cbc(aes)",
1625                 .cra_driver_name = "cbc-aes-tegra",
1626                 .cra_priority = 300,
1627                 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
1628                 .cra_blocksize = TEGRA_SE_AES_BLOCK_SIZE,
1629                 .cra_ctxsize  = sizeof(struct tegra_se_aes_context),
1630                 .cra_alignmask = 0,
1631                 .cra_type = &crypto_ablkcipher_type,
1632                 .cra_module = THIS_MODULE,
1633                 .cra_init = tegra_se_aes_cra_init,
1634                 .cra_exit = tegra_se_aes_cra_exit,
1635                 .cra_u.ablkcipher = {
1636                         .min_keysize = TEGRA_SE_AES_MIN_KEY_SIZE,
1637                         .max_keysize = TEGRA_SE_AES_MAX_KEY_SIZE,
1638                         .ivsize = TEGRA_SE_AES_IV_SIZE,
1639                         .setkey = tegra_se_aes_setkey,
1640                         .encrypt = tegra_se_aes_cbc_encrypt,
1641                         .decrypt = tegra_se_aes_cbc_decrypt,
1642                 }
1643         }, {
1644                 .cra_name = "ecb(aes)",
1645                 .cra_driver_name = "ecb-aes-tegra",
1646                 .cra_priority = 300,
1647                 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
1648                 .cra_blocksize = TEGRA_SE_AES_BLOCK_SIZE,
1649                 .cra_ctxsize  = sizeof(struct tegra_se_aes_context),
1650                 .cra_alignmask = 0,
1651                 .cra_type = &crypto_ablkcipher_type,
1652                 .cra_module = THIS_MODULE,
1653                 .cra_init = tegra_se_aes_cra_init,
1654                 .cra_exit = tegra_se_aes_cra_exit,
1655                 .cra_u.ablkcipher = {
1656                         .min_keysize = TEGRA_SE_AES_MIN_KEY_SIZE,
1657                         .max_keysize = TEGRA_SE_AES_MAX_KEY_SIZE,
1658                         .ivsize = TEGRA_SE_AES_IV_SIZE,
1659                         .setkey = tegra_se_aes_setkey,
1660                         .encrypt = tegra_se_aes_ecb_encrypt,
1661                         .decrypt = tegra_se_aes_ecb_decrypt,
1662                 }
1663         }, {
1664                 .cra_name = "ctr(aes)",
1665                 .cra_driver_name = "ctr-aes-tegra",
1666                 .cra_priority = 300,
1667                 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
1668                 .cra_blocksize = TEGRA_SE_AES_BLOCK_SIZE,
1669                 .cra_ctxsize  = sizeof(struct tegra_se_aes_context),
1670                 .cra_alignmask = 0,
1671                 .cra_type = &crypto_ablkcipher_type,
1672                 .cra_module = THIS_MODULE,
1673                 .cra_init = tegra_se_aes_cra_init,
1674                 .cra_exit = tegra_se_aes_cra_exit,
1675                 .cra_u.ablkcipher = {
1676                         .min_keysize = TEGRA_SE_AES_MIN_KEY_SIZE,
1677                         .max_keysize = TEGRA_SE_AES_MAX_KEY_SIZE,
1678                         .ivsize = TEGRA_SE_AES_IV_SIZE,
1679                         .setkey = tegra_se_aes_setkey,
1680                         .encrypt = tegra_se_aes_ctr_encrypt,
1681                         .decrypt = tegra_se_aes_ctr_decrypt,
1682                         .geniv = "eseqiv",
1683                 }
1684         }, {
1685                 .cra_name = "ofb(aes)",
1686                 .cra_driver_name = "ofb-aes-tegra",
1687                 .cra_priority = 300,
1688                 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
1689                 .cra_blocksize = TEGRA_SE_AES_BLOCK_SIZE,
1690                 .cra_ctxsize  = sizeof(struct tegra_se_aes_context),
1691                 .cra_alignmask = 0,
1692                 .cra_type = &crypto_ablkcipher_type,
1693                 .cra_module = THIS_MODULE,
1694                 .cra_init = tegra_se_aes_cra_init,
1695                 .cra_exit = tegra_se_aes_cra_exit,
1696                 .cra_u.ablkcipher = {
1697                         .min_keysize = TEGRA_SE_AES_MIN_KEY_SIZE,
1698                         .max_keysize = TEGRA_SE_AES_MAX_KEY_SIZE,
1699                         .ivsize = TEGRA_SE_AES_IV_SIZE,
1700                         .setkey = tegra_se_aes_setkey,
1701                         .encrypt = tegra_se_aes_ofb_encrypt,
1702                         .decrypt = tegra_se_aes_ofb_decrypt,
1703                         .geniv = "eseqiv",
1704                 }
1705         }, {
1706                 .cra_name = "ansi_cprng",
1707                 .cra_driver_name = "rng-aes-tegra",
1708                 .cra_priority = 100,
1709                 .cra_flags = CRYPTO_ALG_TYPE_RNG,
1710                 .cra_ctxsize = sizeof(struct tegra_se_rng_context),
1711                 .cra_type = &crypto_rng_type,
1712                 .cra_module = THIS_MODULE,
1713                 .cra_init = tegra_se_rng_init,
1714                 .cra_exit = tegra_se_rng_exit,
1715                 .cra_u = {
1716                         .rng = {
1717                                 .rng_make_random = tegra_se_rng_get_random,
1718                                 .rng_reset = tegra_se_rng_reset,
1719                                 .seedsize = TEGRA_SE_RNG_SEED_SIZE,
1720                         }
1721                 }
1722         }
1723 };
1724
1725 static struct ahash_alg hash_algs[] = {
1726         {
1727                 .init = tegra_se_aes_cmac_init,
1728                 .update = tegra_se_aes_cmac_update,
1729                 .final = tegra_se_aes_cmac_final,
1730                 .finup = tegra_se_aes_cmac_finup,
1731                 .digest = tegra_se_aes_cmac_digest,
1732                 .setkey = tegra_se_aes_cmac_setkey,
1733                 .halg.digestsize = TEGRA_SE_AES_CMAC_DIGEST_SIZE,
1734                 .halg.base = {
1735                         .cra_name = "cmac(aes)",
1736                         .cra_driver_name = "tegra-se-cmac(aes)",
1737                         .cra_priority = 100,
1738                         .cra_flags = CRYPTO_ALG_TYPE_AHASH,
1739                         .cra_blocksize = TEGRA_SE_AES_BLOCK_SIZE,
1740                         .cra_ctxsize = sizeof(struct tegra_se_aes_cmac_context),
1741                         .cra_alignmask = 0,
1742                         .cra_module     = THIS_MODULE,
1743                         .cra_init       = tegra_se_aes_cmac_cra_init,
1744                         .cra_exit       = tegra_se_aes_cmac_cra_exit,
1745                 }
1746         }, {
1747                 .init = tegra_se_sha_init,
1748                 .update = tegra_se_sha_update,
1749                 .final = tegra_se_sha_final,
1750                 .finup = tegra_se_sha_finup,
1751                 .digest = tegra_se_sha_digest,
1752                 .halg.digestsize = SHA1_DIGEST_SIZE,
1753                 .halg.base = {
1754                         .cra_name = "sha1",
1755                         .cra_driver_name = "tegra-se-sha1",
1756                         .cra_priority = 100,
1757                         .cra_flags = CRYPTO_ALG_TYPE_AHASH,
1758                         .cra_blocksize = SHA1_BLOCK_SIZE,
1759                         .cra_ctxsize = sizeof(struct tegra_se_sha_context),
1760                         .cra_alignmask = 0,
1761                         .cra_module = THIS_MODULE,
1762                         .cra_init = tegra_se_sha_cra_init,
1763                         .cra_exit = tegra_se_sha_cra_exit,
1764                 }
1765         }, {
1766                 .init = tegra_se_sha_init,
1767                 .update = tegra_se_sha_update,
1768                 .final = tegra_se_sha_final,
1769                 .finup = tegra_se_sha_finup,
1770                 .digest = tegra_se_sha_digest,
1771                 .halg.digestsize = SHA224_DIGEST_SIZE,
1772                 .halg.base = {
1773                         .cra_name = "sha224",
1774                         .cra_driver_name = "tegra-se-sha224",
1775                         .cra_priority = 100,
1776                         .cra_flags = CRYPTO_ALG_TYPE_AHASH,
1777                         .cra_blocksize = SHA224_BLOCK_SIZE,
1778                         .cra_ctxsize = sizeof(struct tegra_se_sha_context),
1779                         .cra_alignmask = 0,
1780                         .cra_module = THIS_MODULE,
1781                         .cra_init = tegra_se_sha_cra_init,
1782                         .cra_exit = tegra_se_sha_cra_exit,
1783                 }
1784         }, {
1785                 .init = tegra_se_sha_init,
1786                 .update = tegra_se_sha_update,
1787                 .final = tegra_se_sha_final,
1788                 .finup = tegra_se_sha_finup,
1789                 .digest = tegra_se_sha_digest,
1790                 .halg.digestsize = SHA256_DIGEST_SIZE,
1791                 .halg.base = {
1792                         .cra_name = "sha256",
1793                         .cra_driver_name = "tegra-se-sha256",
1794                         .cra_priority = 100,
1795                         .cra_flags = CRYPTO_ALG_TYPE_AHASH,
1796                         .cra_blocksize = SHA256_BLOCK_SIZE,
1797                         .cra_ctxsize = sizeof(struct tegra_se_sha_context),
1798                         .cra_alignmask = 0,
1799                         .cra_module = THIS_MODULE,
1800                         .cra_init = tegra_se_sha_cra_init,
1801                         .cra_exit = tegra_se_sha_cra_exit,
1802                 }
1803         }, {
1804                 .init = tegra_se_sha_init,
1805                 .update = tegra_se_sha_update,
1806                 .final = tegra_se_sha_final,
1807                 .finup = tegra_se_sha_finup,
1808                 .digest = tegra_se_sha_digest,
1809                 .halg.digestsize = SHA384_DIGEST_SIZE,
1810                 .halg.base = {
1811                         .cra_name = "sha384",
1812                         .cra_driver_name = "tegra-se-sha384",
1813                         .cra_priority = 100,
1814                         .cra_flags = CRYPTO_ALG_TYPE_AHASH,
1815                         .cra_blocksize = SHA384_BLOCK_SIZE,
1816                         .cra_ctxsize = sizeof(struct tegra_se_sha_context),
1817                         .cra_alignmask = 0,
1818                         .cra_module = THIS_MODULE,
1819                         .cra_init = tegra_se_sha_cra_init,
1820                         .cra_exit = tegra_se_sha_cra_exit,
1821                 }
1822         }, {
1823                 .init = tegra_se_sha_init,
1824                 .update = tegra_se_sha_update,
1825                 .final = tegra_se_sha_final,
1826                 .finup = tegra_se_sha_finup,
1827                 .digest = tegra_se_sha_digest,
1828                 .halg.digestsize = SHA512_DIGEST_SIZE,
1829                 .halg.base = {
1830                         .cra_name = "sha512",
1831                         .cra_driver_name = "tegra-se-sha512",
1832                         .cra_priority = 100,
1833                         .cra_flags = CRYPTO_ALG_TYPE_AHASH,
1834                         .cra_blocksize = SHA512_BLOCK_SIZE,
1835                         .cra_ctxsize = sizeof(struct tegra_se_sha_context),
1836                         .cra_alignmask = 0,
1837                         .cra_module = THIS_MODULE,
1838                         .cra_init = tegra_se_sha_cra_init,
1839                         .cra_exit = tegra_se_sha_cra_exit,
1840                 }
1841         }
1842 };
1843
1844 static int tegra_se_probe(struct platform_device *pdev)
1845 {
1846         struct tegra_se_dev *se_dev = NULL;
1847         struct resource *res = NULL;
1848         int err = 0, i = 0, j = 0, k = 0;
1849
1850         se_dev = kzalloc(sizeof(struct tegra_se_dev), GFP_KERNEL);
1851         if (!se_dev) {
1852                 dev_err(&pdev->dev, "memory allocation failed\n");
1853                 return -ENOMEM;
1854         }
1855
1856         spin_lock_init(&se_dev->lock);
1857         crypto_init_queue(&se_dev->queue, TEGRA_SE_CRYPTO_QUEUE_LENGTH);
1858         platform_set_drvdata(pdev, se_dev);
1859         se_dev->dev = &pdev->dev;
1860
1861         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1862         if (!res) {
1863                 err = -ENXIO;
1864                 dev_err(se_dev->dev, "platform_get_resource failed\n");
1865                 goto fail;
1866         }
1867
1868         se_dev->io_reg = ioremap(res->start, resource_size(res));
1869         if (!se_dev->io_reg) {
1870                 err = -ENOMEM;
1871                 dev_err(se_dev->dev, "ioremap failed\n");
1872                 goto fail;
1873         }
1874
1875         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1876         if (!res) {
1877                 err = -ENXIO;
1878                 dev_err(se_dev->dev, "platform_get_resource failed\n");
1879                 goto err_pmc;
1880         }
1881
1882         se_dev->pmc_io_reg = ioremap(res->start, resource_size(res));
1883         if (!se_dev->pmc_io_reg) {
1884                 err = -ENOMEM;
1885                 dev_err(se_dev->dev, "pmc ioremap failed\n");
1886                 goto err_pmc;
1887         }
1888
1889         se_dev->irq = platform_get_irq(pdev, 0);
1890         if (!se_dev->irq) {
1891                 err = -ENODEV;
1892                 dev_err(se_dev->dev, "platform_get_irq failed\n");
1893                 goto err_irq;
1894         }
1895
1896         err = request_irq(se_dev->irq, tegra_se_irq, IRQF_DISABLED,
1897                         DRIVER_NAME, se_dev);
1898         if (err) {
1899                 dev_err(se_dev->dev, "request_irq failed - irq[%d] err[%d]\n",
1900                         se_dev->irq, err);
1901                 goto err_irq;
1902         }
1903
1904         /* Initialize the clock */
1905         se_dev->pclk = clk_get(se_dev->dev, "se");
1906         if (IS_ERR(se_dev->pclk)) {
1907                 dev_err(se_dev->dev, "clock intialization failed (%d)\n",
1908                         (int)se_dev->pclk);
1909                 err = -ENODEV;
1910                 goto clean;
1911         }
1912
1913         err = clk_set_rate(se_dev->pclk, ULONG_MAX);
1914         if (err) {
1915                 dev_err(se_dev->dev, "clock set_rate failed.\n");
1916                 goto clean;
1917         }
1918
1919         err = tegra_init_key_slot(se_dev);
1920         if (err) {
1921                 dev_err(se_dev->dev, "init_key_slot failed\n");
1922                 goto clean;
1923         }
1924
1925         init_completion(&se_dev->complete);
1926         se_work_q = alloc_workqueue("se_work_q", WQ_HIGHPRI | WQ_UNBOUND, 16);
1927         if (!se_work_q) {
1928                 dev_err(se_dev->dev, "alloc_workqueue failed\n");
1929                 goto clean;
1930         }
1931
1932         sg_tegra_se_dev = se_dev;
1933         pm_runtime_enable(se_dev->dev);
1934         tegra_se_key_read_disable_all();
1935
1936         err = tegra_se_alloc_ll_buf(se_dev, SE_MAX_SRC_SG_COUNT,
1937                 SE_MAX_DST_SG_COUNT);
1938         if (err) {
1939                 dev_err(se_dev->dev, "can not allocate ll dma buffer\n");
1940                 goto clean;
1941         }
1942
1943         for (i = 0; i < ARRAY_SIZE(aes_algs); i++) {
1944                 INIT_LIST_HEAD(&aes_algs[i].cra_list);
1945                 err = crypto_register_alg(&aes_algs[i]);
1946                 if (err) {
1947                         dev_err(se_dev->dev,
1948                                 "crypto_register_alg failed index[%d]\n", i);
1949                         goto clean;
1950                 }
1951         }
1952
1953         for (j = 0; j < ARRAY_SIZE(hash_algs); j++) {
1954                 err = crypto_register_ahash(&hash_algs[j]);
1955                 if (err) {
1956                         dev_err(se_dev->dev,
1957                         "crypto_register_sha alg failed index[%d]\n", i);
1958                         goto clean;
1959                 }
1960         }
1961
1962 #if defined(CONFIG_PM)
1963         se_dev->ctx_save_buf = dma_alloc_coherent(se_dev->dev,
1964                 SE_CONTEXT_BUFER_SIZE, &se_dev->ctx_save_buf_adr, GFP_KERNEL);
1965         if (!se_dev->ctx_save_buf) {
1966                 dev_err(se_dev->dev, "Context save buffer alloc filed\n");
1967                 goto clean;
1968         }
1969 #endif
1970
1971         dev_info(se_dev->dev, "%s: complete", __func__);
1972         return 0;
1973
1974 clean:
1975         pm_runtime_disable(se_dev->dev);
1976         for (k = 0; k < i; k++)
1977                 crypto_unregister_alg(&aes_algs[k]);
1978
1979         for (k = 0; k < j; k++)
1980                 crypto_unregister_ahash(&hash_algs[j]);
1981
1982         tegra_se_free_ll_buf(se_dev);
1983
1984         if (se_work_q)
1985                 destroy_workqueue(se_work_q);
1986
1987         if (se_dev->pclk)
1988                 clk_put(se_dev->pclk);
1989
1990         free_irq(se_dev->irq, &pdev->dev);
1991
1992 err_irq:
1993         iounmap(se_dev->pmc_io_reg);
1994 err_pmc:
1995         iounmap(se_dev->io_reg);
1996
1997 fail:
1998         platform_set_drvdata(pdev, NULL);
1999         kfree(se_dev);
2000         sg_tegra_se_dev = NULL;
2001
2002         return err;
2003 }
2004
2005 static int __devexit tegra_se_remove(struct platform_device *pdev)
2006 {
2007         struct tegra_se_dev *se_dev = platform_get_drvdata(pdev);
2008         int i;
2009
2010         if (!se_dev)
2011                 return -ENODEV;
2012
2013         pm_runtime_disable(se_dev->dev);
2014
2015         cancel_work_sync(&se_work);
2016         if (se_work_q)
2017                 destroy_workqueue(se_work_q);
2018         free_irq(se_dev->irq, &pdev->dev);
2019         for (i = 0; i < ARRAY_SIZE(aes_algs); i++)
2020                 crypto_unregister_alg(&aes_algs[i]);
2021         for (i = 0; i < ARRAY_SIZE(hash_algs); i++)
2022                 crypto_unregister_ahash(&hash_algs[i]);
2023         if (se_dev->pclk)
2024                 clk_put(se_dev->pclk);
2025         tegra_se_free_ll_buf(se_dev);
2026         if (se_dev->ctx_save_buf) {
2027                 dma_free_coherent(se_dev->dev, SE_CONTEXT_BUFER_SIZE,
2028                         se_dev->ctx_save_buf, se_dev->ctx_save_buf_adr);
2029                 se_dev->ctx_save_buf = NULL;
2030         }
2031         iounmap(se_dev->io_reg);
2032         iounmap(se_dev->pmc_io_reg);
2033         kfree(se_dev);
2034         sg_tegra_se_dev = NULL;
2035
2036         return 0;
2037 }
2038
2039 #if defined(CONFIG_PM)
2040 static int tegra_se_resume(struct device *dev)
2041 {
2042         return 0;
2043 }
2044
2045 static int tegra_se_generate_rng_key(struct tegra_se_dev *se_dev)
2046 {
2047         int ret = 0;
2048         u32 val = 0;
2049
2050         *se_dev->src_ll_buf = 0;
2051         *se_dev->dst_ll_buf = 0;
2052
2053         /* Configure algorithm */
2054         val = SE_CONFIG_ENC_ALG(ALG_RNG) | SE_CONFIG_ENC_MODE(MODE_KEY128) |
2055                 SE_CONFIG_DST(DST_KEYTAB);
2056         se_writel(se_dev, val, SE_CONFIG_REG_OFFSET);
2057
2058         /* Configure destination key index number */
2059         val = SE_CRYPTO_KEYTABLE_DST_KEY_INDEX(srk_slot.slot_num) |
2060                 SE_CRYPTO_KEYTABLE_DST_WORD_QUAD(KEYS_0_3);
2061         se_writel(se_dev, val, SE_CRYPTO_KEYTABLE_DST_REG_OFFSET);
2062
2063         /* Configure crypto */
2064         val = SE_CRYPTO_INPUT_SEL(INPUT_LFSR) | SE_CRYPTO_XOR_POS(XOR_BYPASS) |
2065                 SE_CRYPTO_CORE_SEL(CORE_ENCRYPT) |
2066                 SE_CRYPTO_HASH(HASH_DISABLE) |
2067                 SE_CRYPTO_KEY_INDEX(ssk_slot.slot_num) |
2068                 SE_CRYPTO_IV_SEL(IV_ORIGINAL);
2069         se_writel(se_dev, val, SE_CRYPTO_REG_OFFSET);
2070
2071         ret = tegra_se_start_operation(se_dev, TEGRA_SE_KEY_128_SIZE, false);
2072
2073         return ret;
2074 }
2075
2076 static int tegra_se_generate_srk(struct tegra_se_dev *se_dev)
2077 {
2078         int ret = 0;
2079         u32 val = 0;
2080
2081         mutex_lock(&se_hw_lock);
2082         pm_runtime_get_sync(se_dev->dev);
2083
2084         ret = tegra_se_generate_rng_key(se_dev);
2085         if (ret) {
2086                 pm_runtime_put(se_dev->dev);
2087                 mutex_unlock(&se_hw_lock);
2088                 return ret;
2089         }
2090
2091         *se_dev->src_ll_buf = 0;
2092         *se_dev->dst_ll_buf = 0;
2093
2094         val = SE_CONFIG_ENC_ALG(ALG_RNG) | SE_CONFIG_ENC_MODE(MODE_KEY128) |
2095                 SE_CONFIG_DEC_ALG(ALG_NOP) | SE_CONFIG_DST(DST_SRK);
2096
2097         se_writel(se_dev, val, SE_CONFIG_REG_OFFSET);
2098
2099         val = SE_CRYPTO_XOR_POS(XOR_BYPASS) |
2100                 SE_CRYPTO_CORE_SEL(CORE_ENCRYPT) |
2101                 SE_CRYPTO_HASH(HASH_DISABLE) |
2102                 SE_CRYPTO_KEY_INDEX(srk_slot.slot_num) |
2103                 SE_CRYPTO_IV_SEL(IV_UPDATED);
2104
2105         se_writel(se_dev, val, SE_CRYPTO_REG_OFFSET);
2106         ret = tegra_se_start_operation(se_dev, TEGRA_SE_KEY_128_SIZE, false);
2107
2108         pm_runtime_put(se_dev->dev);
2109         mutex_unlock(&se_hw_lock);
2110
2111         return ret;
2112 }
2113
2114 static int tegra_se_lp_generate_random_data(struct tegra_se_dev *se_dev)
2115 {
2116         struct tegra_se_ll *src_ll, *dst_ll;
2117         int ret = 0;
2118         u32 val;
2119
2120         mutex_lock(&se_hw_lock);
2121         pm_runtime_get_sync(se_dev->dev);
2122
2123         *se_dev->src_ll_buf = 0;
2124         *se_dev->dst_ll_buf = 0;
2125         src_ll = (struct tegra_se_ll *)(se_dev->src_ll_buf + 1);
2126         dst_ll = (struct tegra_se_ll *)(se_dev->dst_ll_buf + 1);
2127         src_ll->addr = se_dev->ctx_save_buf_adr;
2128         src_ll->data_len = SE_CONTEXT_SAVE_RANDOM_DATA_SIZE;
2129         dst_ll->addr = se_dev->ctx_save_buf_adr;
2130         dst_ll->data_len = SE_CONTEXT_SAVE_RANDOM_DATA_SIZE;
2131
2132         tegra_se_config_algo(se_dev, SE_AES_OP_MODE_RNG_X931, true,
2133                 TEGRA_SE_KEY_128_SIZE);
2134
2135         /* Configure crypto */
2136         val = SE_CRYPTO_INPUT_SEL(INPUT_LFSR) | SE_CRYPTO_XOR_POS(XOR_BYPASS) |
2137                 SE_CRYPTO_CORE_SEL(CORE_ENCRYPT) |
2138                 SE_CRYPTO_HASH(HASH_DISABLE) |
2139                 SE_CRYPTO_KEY_INDEX(srk_slot.slot_num) |
2140                 SE_CRYPTO_IV_SEL(IV_ORIGINAL);
2141
2142         se_writel(se_dev, val, SE_CRYPTO_REG_OFFSET);
2143         ret = tegra_se_start_operation(se_dev,
2144                 SE_CONTEXT_SAVE_RANDOM_DATA_SIZE, false);
2145
2146         pm_runtime_put(se_dev->dev);
2147         mutex_unlock(&se_hw_lock);
2148
2149         return ret;
2150
2151 }
2152
2153 static int tegra_se_lp_encrypt_context_data(struct tegra_se_dev *se_dev,
2154         u32 context_offset, u32 data_size)
2155 {
2156         struct tegra_se_ll *src_ll, *dst_ll;
2157         int ret = 0;
2158
2159         mutex_lock(&se_hw_lock);
2160         pm_runtime_get_sync(se_dev->dev);
2161
2162         *se_dev->src_ll_buf = 0;
2163         *se_dev->dst_ll_buf = 0;
2164         src_ll = (struct tegra_se_ll *)(se_dev->src_ll_buf + 1);
2165         dst_ll = (struct tegra_se_ll *)(se_dev->dst_ll_buf + 1);
2166         src_ll->addr = se_dev->ctx_save_buf_adr + context_offset;
2167         src_ll->data_len = data_size;
2168         dst_ll->addr = se_dev->ctx_save_buf_adr + context_offset;
2169         dst_ll->data_len = data_size;
2170
2171         se_writel(se_dev, SE_CONTEXT_SAVE_SRC(MEM),
2172                 SE_CONTEXT_SAVE_CONFIG_REG_OFFSET);
2173
2174         ret = tegra_se_start_operation(se_dev, data_size, true);
2175
2176         pm_runtime_put(se_dev->dev);
2177
2178         mutex_unlock(&se_hw_lock);
2179
2180         return ret;
2181 }
2182
2183 static int tegra_se_lp_sticky_bits_context_save(struct tegra_se_dev *se_dev)
2184 {
2185         struct tegra_se_ll *dst_ll;
2186         int ret = 0;
2187
2188         mutex_lock(&se_hw_lock);
2189         pm_runtime_get_sync(se_dev->dev);
2190
2191         *se_dev->src_ll_buf = 0;
2192         *se_dev->dst_ll_buf = 0;
2193         dst_ll = (struct tegra_se_ll *)(se_dev->dst_ll_buf + 1);
2194         dst_ll->addr = (se_dev->ctx_save_buf_adr +
2195                 SE_CONTEXT_SAVE_STICKY_BITS_OFFSET);
2196         dst_ll->data_len = SE_CONTEXT_SAVE_STICKY_BITS_SIZE;
2197
2198         se_writel(se_dev, SE_CONTEXT_SAVE_SRC(STICKY_BITS),
2199                 SE_CONTEXT_SAVE_CONFIG_REG_OFFSET);
2200
2201         ret = tegra_se_start_operation(se_dev,
2202                 SE_CONTEXT_SAVE_STICKY_BITS_SIZE, true);
2203
2204         pm_runtime_put(se_dev->dev);
2205         mutex_unlock(&se_hw_lock);
2206
2207         return ret;
2208 }
2209
2210 static int tegra_se_lp_keytable_context_save(struct tegra_se_dev *se_dev)
2211 {
2212         struct tegra_se_ll *dst_ll;
2213         int ret = 0, i, j;
2214         u32 val = 0;
2215
2216         /* take access to the hw */
2217         mutex_lock(&se_hw_lock);
2218         pm_runtime_get_sync(se_dev->dev);
2219
2220         *se_dev->dst_ll_buf = 0;
2221         dst_ll = (struct tegra_se_ll *)(se_dev->dst_ll_buf + 1);
2222         dst_ll->addr = (se_dev->ctx_save_buf_adr + SE_CONTEXT_SAVE_KEYS_OFFSET);
2223         dst_ll->data_len = TEGRA_SE_KEY_128_SIZE;
2224
2225         for (i = 0; i < TEGRA_SE_KEYSLOT_COUNT; i++) {
2226                 for (j = 0; j < 2; j++) {
2227                         val = SE_CONTEXT_SAVE_SRC(KEYTABLE) |
2228                                 SE_CONTEXT_SAVE_KEY_INDEX(i) |
2229                                 SE_CONTEXT_SAVE_WORD_QUAD(j);
2230                         se_writel(se_dev,
2231                                 val, SE_CONTEXT_SAVE_CONFIG_REG_OFFSET);
2232                         ret = tegra_se_start_operation(se_dev,
2233                                 TEGRA_SE_KEY_128_SIZE, true);
2234                         if (ret)
2235                                 break;
2236                         dst_ll->addr += TEGRA_SE_KEY_128_SIZE;
2237                 }
2238         }
2239
2240         pm_runtime_put(se_dev->dev);
2241         mutex_unlock(&se_hw_lock);
2242
2243         return ret;
2244 }
2245
2246 static int tegra_se_lp_iv_context_save(struct tegra_se_dev *se_dev,
2247         bool org_iv, u32 context_offset)
2248 {
2249         struct tegra_se_ll *dst_ll;
2250         int ret = 0, i;
2251         u32 val = 0;
2252
2253         mutex_lock(&se_hw_lock);
2254         pm_runtime_get_sync(se_dev->dev);
2255
2256         *se_dev->dst_ll_buf = 0;
2257         dst_ll = (struct tegra_se_ll *)(se_dev->dst_ll_buf + 1);
2258         dst_ll->addr = (se_dev->ctx_save_buf_adr + context_offset);
2259         dst_ll->data_len = TEGRA_SE_AES_IV_SIZE;
2260
2261         for (i = 0; i < TEGRA_SE_KEYSLOT_COUNT; i++) {
2262                 val = SE_CONTEXT_SAVE_SRC(KEYTABLE) |
2263                         SE_CONTEXT_SAVE_KEY_INDEX(i) |
2264                         (org_iv ? SE_CONTEXT_SAVE_WORD_QUAD(ORIG_IV) :
2265                         SE_CONTEXT_SAVE_WORD_QUAD(UPD_IV));
2266                 se_writel(se_dev, val, SE_CONTEXT_SAVE_CONFIG_REG_OFFSET);
2267                 ret = tegra_se_start_operation(se_dev,
2268                         TEGRA_SE_AES_IV_SIZE, true);
2269                 if (ret)
2270                         break;
2271                 dst_ll->addr += TEGRA_SE_AES_IV_SIZE;
2272         }
2273
2274         pm_runtime_put(se_dev->dev);
2275         mutex_unlock(&se_hw_lock);
2276
2277         return ret;
2278 }
2279
2280 static int tegra_se_save_SRK(struct tegra_se_dev *se_dev)
2281 {
2282         int ret = 0;
2283
2284         mutex_lock(&se_hw_lock);
2285         pm_runtime_get_sync(se_dev->dev);
2286
2287         se_writel(se_dev, SE_CONTEXT_SAVE_SRC(SRK),
2288                 SE_CONTEXT_SAVE_CONFIG_REG_OFFSET);
2289         ret = tegra_se_start_operation(se_dev, 0, true);
2290
2291         pm_runtime_put(se_dev->dev);
2292         mutex_unlock(&se_hw_lock);
2293
2294         return ret;
2295 }
2296
2297 static int tegra_se_suspend(struct device *dev)
2298 {
2299         struct platform_device *pdev = to_platform_device(dev);
2300         struct tegra_se_dev *se_dev = platform_get_drvdata(pdev);
2301         int err = 0, i;
2302         unsigned char *dt_buf = NULL;
2303         u8 pdata[SE_CONTEXT_KNOWN_PATTERN_SIZE] = {
2304                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
2305                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
2306
2307         if (!se_dev)
2308                 return -ENODEV;
2309
2310         /* Generate SRK */
2311         err = tegra_se_generate_srk(se_dev);
2312         if (err) {
2313                 dev_err(se_dev->dev, "\n LP SRK genration failed\n");
2314                 goto out;
2315         }
2316
2317         /* Generate random data*/
2318         err = tegra_se_lp_generate_random_data(se_dev);
2319         if (err) {
2320                 dev_err(se_dev->dev, "\n LP random pattern generation failed\n");
2321                 goto out;
2322         }
2323
2324         /* Encrypt random data */
2325         err = tegra_se_lp_encrypt_context_data(se_dev,
2326                 SE_CONTEXT_SAVE_RANDOM_DATA_OFFSET,
2327                 SE_CONTEXT_SAVE_RANDOM_DATA_SIZE);
2328         if (err) {
2329                 dev_err(se_dev->dev, "\n LP random pattern encryption failed\n");
2330                 goto out;
2331         }
2332
2333         /* Sticky bits context save*/
2334         err = tegra_se_lp_sticky_bits_context_save(se_dev);
2335         if (err) {
2336                 dev_err(se_dev->dev, "\n LP sticky bits context save failure\n");
2337                 goto out;
2338         }
2339
2340         /* Key table context save*/
2341         err = tegra_se_lp_keytable_context_save(se_dev);
2342         if (err) {
2343                 dev_err(se_dev->dev, "\n LP key table  save failure\n");
2344                 goto out;
2345         }
2346
2347         /* Original iv context save*/
2348         err = tegra_se_lp_iv_context_save(se_dev,
2349                 true, SE_CONTEXT_ORIGINAL_IV_OFFSET);
2350         if (err) {
2351                 dev_err(se_dev->dev, "\n LP original iv save failure\n");
2352                 goto out;
2353         }
2354
2355         /* UPdated iv context save*/
2356         err = tegra_se_lp_iv_context_save(se_dev,
2357                 false, SE_CONTEXT_UPDATED_IV_OFFSET);
2358         if (err) {
2359                 dev_err(se_dev->dev, "\n LP updated iv save failure\n");
2360                 goto out;
2361         }
2362
2363         /* Encrypt known pattern */
2364         dt_buf = (unsigned char *)se_dev->ctx_save_buf;
2365         dt_buf += SE_CONTEXT_KNOWN_PATTERN_OFFSET;
2366         for (i = 0; i < SE_CONTEXT_KNOWN_PATTERN_SIZE; i++)
2367                 dt_buf[i] = pdata[i];
2368         err = tegra_se_lp_encrypt_context_data(se_dev,
2369                 SE_CONTEXT_KNOWN_PATTERN_OFFSET, SE_CONTEXT_KNOWN_PATTERN_SIZE);
2370         if (err) {
2371                 dev_err(se_dev->dev, "LP known pattern save failure\n");
2372                 goto out;
2373         }
2374
2375         /* Write lp context buffer address into PMC scratch register */
2376         writel(se_dev->ctx_save_buf_adr,
2377                 se_dev->pmc_io_reg + PMC_SCRATCH43_REG_OFFSET);
2378
2379         /* Saves SRK in secure scratch */
2380         err = tegra_se_save_SRK(se_dev);
2381         if (err) {
2382                 dev_err(se_dev->dev, "LP SRK save failure\n");
2383                 goto out;
2384         }
2385
2386 out:
2387         return err;
2388 }
2389 #endif
2390
2391 #if defined(CONFIG_PM_RUNTIME)
2392 static int tegra_se_runtime_suspend(struct device *dev)
2393 {
2394         /*
2395          * do a dummy read, to avoid scenarios where you have unposted writes
2396          * still on the bus, before disabling clocks
2397          */
2398         se_readl(sg_tegra_se_dev, SE_CONFIG_REG_OFFSET);
2399
2400         clk_disable(sg_tegra_se_dev->pclk);
2401         return 0;
2402 }
2403
2404 static int tegra_se_runtime_resume(struct device *dev)
2405 {
2406         clk_enable(sg_tegra_se_dev->pclk);
2407         return 0;
2408 }
2409
2410 static const struct dev_pm_ops tegra_se_dev_pm_ops = {
2411         .runtime_suspend = tegra_se_runtime_suspend,
2412         .runtime_resume = tegra_se_runtime_resume,
2413 #if defined(CONFIG_PM)
2414         .suspend = tegra_se_suspend,
2415         .resume = tegra_se_resume,
2416 #endif
2417 };
2418 #endif
2419
2420 static struct platform_driver tegra_se_driver = {
2421         .probe  = tegra_se_probe,
2422         .remove = __devexit_p(tegra_se_remove),
2423         .driver = {
2424                 .name   = "tegra-se",
2425                 .owner  = THIS_MODULE,
2426 #if defined(CONFIG_PM_RUNTIME)
2427                 .pm = &tegra_se_dev_pm_ops,
2428 #endif
2429         },
2430 };
2431
2432 static int __init tegra_se_module_init(void)
2433 {
2434         return  platform_driver_register(&tegra_se_driver);
2435 }
2436
2437 static void __exit tegra_se_module_exit(void)
2438 {
2439         platform_driver_unregister(&tegra_se_driver);
2440 }
2441
2442 module_init(tegra_se_module_init);
2443 module_exit(tegra_se_module_exit);
2444
2445 MODULE_DESCRIPTION("Tegra Crypto algorithm support");
2446 MODULE_AUTHOR("NVIDIA Corporation");
2447 MODULE_LICENSE("GPL");
2448 MODULE_ALIAS("tegra-se");
2449