blob: 29b9469f83789eb42ee8c5d47ca7901d85fb70af [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Cryptographic API.
3 *
4 * Support for VIA PadLock hardware crypto engine.
5 *
6 * Copyright (c) 2004 Michal Ludvig <michal@logix.cz>
7 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 */
9
Herbert Xu28ce7282006-08-21 21:38:42 +100010#include <crypto/algapi.h>
Sebastian Siewior89e126542007-10-17 23:18:57 +080011#include <crypto/aes.h>
Herbert Xu21493082011-01-07 14:52:00 +110012#include <crypto/padlock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/module.h>
14#include <linux/init.h>
15#include <linux/types.h>
16#include <linux/errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/interrupt.h>
Herbert Xu6789b2d2005-07-06 13:52:27 -070018#include <linux/kernel.h>
Herbert Xu420a4b22008-08-31 15:58:45 +100019#include <linux/percpu.h>
20#include <linux/smp.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090021#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <asm/byteorder.h>
Chuck Ebberta76c1c22009-06-18 19:24:10 +080023#include <asm/processor.h>
Suresh Siddhae4914012008-08-13 22:02:26 +100024#include <asm/i387.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025
Chuck Ebbert8d8409f2009-06-18 19:31:09 +080026/*
27 * Number of data blocks actually fetched for each xcrypt insn.
28 * Processors with prefetch errata will fetch extra blocks.
29 */
Chuck Ebberta76c1c22009-06-18 19:24:10 +080030static unsigned int ecb_fetch_blocks = 2;
Chuck Ebbert8d8409f2009-06-18 19:31:09 +080031#define MAX_ECB_FETCH_BLOCKS (8)
Chuck Ebberta76c1c22009-06-18 19:24:10 +080032#define ecb_fetch_bytes (ecb_fetch_blocks * AES_BLOCK_SIZE)
Chuck Ebbert8d8409f2009-06-18 19:31:09 +080033
34static unsigned int cbc_fetch_blocks = 1;
35#define MAX_CBC_FETCH_BLOCKS (4)
Chuck Ebberta76c1c22009-06-18 19:24:10 +080036#define cbc_fetch_bytes (cbc_fetch_blocks * AES_BLOCK_SIZE)
37
Michal Ludvigccc17c32006-07-15 10:23:49 +100038/* Control word. */
39struct cword {
40 unsigned int __attribute__ ((__packed__))
41 rounds:4,
42 algo:3,
43 keygen:1,
44 interm:1,
45 encdec:1,
46 ksize:2;
47} __attribute__ ((__aligned__(PADLOCK_ALIGNMENT)));
48
Michal Ludvigcc086322006-07-15 11:08:50 +100049/* Whenever making any changes to the following
50 * structure *make sure* you keep E, d_data
Sebastian Siewior7dc748e2008-04-01 21:24:50 +080051 * and cword aligned on 16 Bytes boundaries and
52 * the Hardware can access 16 * 16 bytes of E and d_data
53 * (only the first 15 * 16 bytes matter but the HW reads
54 * more).
55 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070056struct aes_ctx {
Sebastian Siewior7dc748e2008-04-01 21:24:50 +080057 u32 E[AES_MAX_KEYLENGTH_U32]
58 __attribute__ ((__aligned__(PADLOCK_ALIGNMENT)));
59 u32 d_data[AES_MAX_KEYLENGTH_U32]
60 __attribute__ ((__aligned__(PADLOCK_ALIGNMENT)));
Herbert Xu6789b2d2005-07-06 13:52:27 -070061 struct {
62 struct cword encrypt;
63 struct cword decrypt;
64 } cword;
Herbert Xu82062c72006-05-16 22:20:34 +100065 u32 *D;
Linus Torvalds1da177e2005-04-16 15:20:36 -070066};
67
Tejun Heo390dfd92009-10-29 22:34:14 +090068static DEFINE_PER_CPU(struct cword *, paes_last_cword);
Herbert Xu420a4b22008-08-31 15:58:45 +100069
Linus Torvalds1da177e2005-04-16 15:20:36 -070070/* Tells whether the ACE is capable to generate
71 the extended key for a given key_len. */
72static inline int
73aes_hw_extkey_available(uint8_t key_len)
74{
75 /* TODO: We should check the actual CPU model/stepping
76 as it's possible that the capability will be
77 added in the next CPU revisions. */
78 if (key_len == 16)
79 return 1;
80 return 0;
81}
82
Herbert Xu28ce7282006-08-21 21:38:42 +100083static inline struct aes_ctx *aes_ctx_common(void *ctx)
Herbert Xu6789b2d2005-07-06 13:52:27 -070084{
Herbert Xu28ce7282006-08-21 21:38:42 +100085 unsigned long addr = (unsigned long)ctx;
Herbert Xuf10b7892006-01-25 22:34:01 +110086 unsigned long align = PADLOCK_ALIGNMENT;
87
88 if (align <= crypto_tfm_ctx_alignment())
89 align = 1;
Herbert Xu6c2bb982006-05-16 22:09:29 +100090 return (struct aes_ctx *)ALIGN(addr, align);
Herbert Xu6789b2d2005-07-06 13:52:27 -070091}
92
Herbert Xu28ce7282006-08-21 21:38:42 +100093static inline struct aes_ctx *aes_ctx(struct crypto_tfm *tfm)
94{
95 return aes_ctx_common(crypto_tfm_ctx(tfm));
96}
97
98static inline struct aes_ctx *blk_aes_ctx(struct crypto_blkcipher *tfm)
99{
100 return aes_ctx_common(crypto_blkcipher_ctx(tfm));
101}
102
Herbert Xu6c2bb982006-05-16 22:09:29 +1000103static int aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
Herbert Xu560c06a2006-08-13 14:16:39 +1000104 unsigned int key_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105{
Herbert Xu6c2bb982006-05-16 22:09:29 +1000106 struct aes_ctx *ctx = aes_ctx(tfm);
Herbert Xu06ace7a2005-10-30 21:25:15 +1100107 const __le32 *key = (const __le32 *)in_key;
Herbert Xu560c06a2006-08-13 14:16:39 +1000108 u32 *flags = &tfm->crt_flags;
Sebastian Siewior7dc748e2008-04-01 21:24:50 +0800109 struct crypto_aes_ctx gen_aes;
Herbert Xu420a4b22008-08-31 15:58:45 +1000110 int cpu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111
Herbert Xu560c06a2006-08-13 14:16:39 +1000112 if (key_len % 8) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
114 return -EINVAL;
115 }
116
Herbert Xu6789b2d2005-07-06 13:52:27 -0700117 /*
118 * If the hardware is capable of generating the extended key
119 * itself we must supply the plain key for both encryption
120 * and decryption.
121 */
Herbert Xu82062c72006-05-16 22:20:34 +1000122 ctx->D = ctx->E;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123
Sebastian Siewior7dc748e2008-04-01 21:24:50 +0800124 ctx->E[0] = le32_to_cpu(key[0]);
125 ctx->E[1] = le32_to_cpu(key[1]);
126 ctx->E[2] = le32_to_cpu(key[2]);
127 ctx->E[3] = le32_to_cpu(key[3]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128
Herbert Xu6789b2d2005-07-06 13:52:27 -0700129 /* Prepare control words. */
130 memset(&ctx->cword, 0, sizeof(ctx->cword));
131
132 ctx->cword.decrypt.encdec = 1;
133 ctx->cword.encrypt.rounds = 10 + (key_len - 16) / 4;
134 ctx->cword.decrypt.rounds = ctx->cword.encrypt.rounds;
135 ctx->cword.encrypt.ksize = (key_len - 16) / 8;
136 ctx->cword.decrypt.ksize = ctx->cword.encrypt.ksize;
137
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 /* Don't generate extended keys if the hardware can do it. */
139 if (aes_hw_extkey_available(key_len))
Herbert Xu420a4b22008-08-31 15:58:45 +1000140 goto ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141
Herbert Xu6789b2d2005-07-06 13:52:27 -0700142 ctx->D = ctx->d_data;
143 ctx->cword.encrypt.keygen = 1;
144 ctx->cword.decrypt.keygen = 1;
145
Sebastian Siewior7dc748e2008-04-01 21:24:50 +0800146 if (crypto_aes_expand_key(&gen_aes, in_key, key_len)) {
147 *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
148 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 }
150
Sebastian Siewior7dc748e2008-04-01 21:24:50 +0800151 memcpy(ctx->E, gen_aes.key_enc, AES_MAX_KEYLENGTH);
152 memcpy(ctx->D, gen_aes.key_dec, AES_MAX_KEYLENGTH);
Herbert Xu420a4b22008-08-31 15:58:45 +1000153
154ok:
155 for_each_online_cpu(cpu)
Tejun Heo390dfd92009-10-29 22:34:14 +0900156 if (&ctx->cword.encrypt == per_cpu(paes_last_cword, cpu) ||
157 &ctx->cword.decrypt == per_cpu(paes_last_cword, cpu))
158 per_cpu(paes_last_cword, cpu) = NULL;
Herbert Xu420a4b22008-08-31 15:58:45 +1000159
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 return 0;
161}
162
163/* ====== Encryption/decryption routines ====== */
164
Herbert Xu28e8c3a2005-07-06 13:52:43 -0700165/* These are the real call to PadLock. */
Herbert Xu420a4b22008-08-31 15:58:45 +1000166static inline void padlock_reset_key(struct cword *cword)
Herbert Xu866cd902007-12-27 00:04:44 +1100167{
Herbert Xu420a4b22008-08-31 15:58:45 +1000168 int cpu = raw_smp_processor_id();
169
Tejun Heo390dfd92009-10-29 22:34:14 +0900170 if (cword != per_cpu(paes_last_cword, cpu))
Sebastian Andrzej Siewiord1c8b0a2009-04-21 14:14:37 +0800171#ifndef CONFIG_X86_64
Herbert Xu420a4b22008-08-31 15:58:45 +1000172 asm volatile ("pushfl; popfl");
Sebastian Andrzej Siewiord1c8b0a2009-04-21 14:14:37 +0800173#else
174 asm volatile ("pushfq; popfq");
175#endif
Herbert Xu420a4b22008-08-31 15:58:45 +1000176}
177
178static inline void padlock_store_cword(struct cword *cword)
179{
Tejun Heo390dfd92009-10-29 22:34:14 +0900180 per_cpu(paes_last_cword, raw_smp_processor_id()) = cword;
Herbert Xu866cd902007-12-27 00:04:44 +1100181}
182
Suresh Siddhae4914012008-08-13 22:02:26 +1000183/*
184 * While the padlock instructions don't use FP/SSE registers, they
185 * generate a spurious DNA fault when cr0.ts is '1'. These instructions
186 * should be used only inside the irq_ts_save/restore() context
187 */
188
Chuck Ebbert8d8409f2009-06-18 19:31:09 +0800189static inline void rep_xcrypt_ecb(const u8 *input, u8 *output, void *key,
Chuck Ebberta76c1c22009-06-18 19:24:10 +0800190 struct cword *control_word, int count)
Herbert Xud4a7dd82007-12-28 11:05:46 +1100191{
192 asm volatile (".byte 0xf3,0x0f,0xa7,0xc8" /* rep xcryptecb */
193 : "+S"(input), "+D"(output)
Chuck Ebberta76c1c22009-06-18 19:24:10 +0800194 : "d"(control_word), "b"(key), "c"(count));
Herbert Xud4a7dd82007-12-28 11:05:46 +1100195}
196
Chuck Ebbert8d8409f2009-06-18 19:31:09 +0800197static inline u8 *rep_xcrypt_cbc(const u8 *input, u8 *output, void *key,
198 u8 *iv, struct cword *control_word, int count)
199{
200 asm volatile (".byte 0xf3,0x0f,0xa7,0xd0" /* rep xcryptcbc */
201 : "+S" (input), "+D" (output), "+a" (iv)
202 : "d" (control_word), "b" (key), "c" (count));
203 return iv;
204}
205
206static void ecb_crypt_copy(const u8 *in, u8 *out, u32 *key,
Chuck Ebberta76c1c22009-06-18 19:24:10 +0800207 struct cword *cword, int count)
Herbert Xud4a7dd82007-12-28 11:05:46 +1100208{
Chuck Ebberta76c1c22009-06-18 19:24:10 +0800209 /*
210 * Padlock prefetches extra data so we must provide mapped input buffers.
211 * Assume there are at least 16 bytes of stack already in use.
212 */
Chuck Ebbert8d8409f2009-06-18 19:31:09 +0800213 u8 buf[AES_BLOCK_SIZE * (MAX_ECB_FETCH_BLOCKS - 1) + PADLOCK_ALIGNMENT - 1];
Herbert Xu490fe3f2008-01-11 08:09:35 +1100214 u8 *tmp = PTR_ALIGN(&buf[0], PADLOCK_ALIGNMENT);
Herbert Xud4a7dd82007-12-28 11:05:46 +1100215
Chuck Ebberta76c1c22009-06-18 19:24:10 +0800216 memcpy(tmp, in, count * AES_BLOCK_SIZE);
Chuck Ebbert8d8409f2009-06-18 19:31:09 +0800217 rep_xcrypt_ecb(tmp, out, key, cword, count);
Herbert Xud4a7dd82007-12-28 11:05:46 +1100218}
219
Chuck Ebbert8d8409f2009-06-18 19:31:09 +0800220static u8 *cbc_crypt_copy(const u8 *in, u8 *out, u32 *key,
221 u8 *iv, struct cword *cword, int count)
222{
223 /*
224 * Padlock prefetches extra data so we must provide mapped input buffers.
225 * Assume there are at least 16 bytes of stack already in use.
226 */
227 u8 buf[AES_BLOCK_SIZE * (MAX_CBC_FETCH_BLOCKS - 1) + PADLOCK_ALIGNMENT - 1];
228 u8 *tmp = PTR_ALIGN(&buf[0], PADLOCK_ALIGNMENT);
229
230 memcpy(tmp, in, count * AES_BLOCK_SIZE);
231 return rep_xcrypt_cbc(tmp, out, key, iv, cword, count);
232}
233
234static inline void ecb_crypt(const u8 *in, u8 *out, u32 *key,
Chuck Ebberta76c1c22009-06-18 19:24:10 +0800235 struct cword *cword, int count)
Herbert Xud4a7dd82007-12-28 11:05:46 +1100236{
Chuck Ebberta76c1c22009-06-18 19:24:10 +0800237 /* Padlock in ECB mode fetches at least ecb_fetch_bytes of data.
238 * We could avoid some copying here but it's probably not worth it.
239 */
Chuck Ebberte8edb3c2009-11-03 10:32:03 -0500240 if (unlikely(((unsigned long)in & ~PAGE_MASK) + ecb_fetch_bytes > PAGE_SIZE)) {
Chuck Ebbert8d8409f2009-06-18 19:31:09 +0800241 ecb_crypt_copy(in, out, key, cword, count);
Herbert Xud4a7dd82007-12-28 11:05:46 +1100242 return;
243 }
244
Chuck Ebbert8d8409f2009-06-18 19:31:09 +0800245 rep_xcrypt_ecb(in, out, key, cword, count);
246}
247
248static inline u8 *cbc_crypt(const u8 *in, u8 *out, u32 *key,
249 u8 *iv, struct cword *cword, int count)
250{
251 /* Padlock in CBC mode fetches at least cbc_fetch_bytes of data. */
Chuck Ebberte8edb3c2009-11-03 10:32:03 -0500252 if (unlikely(((unsigned long)in & ~PAGE_MASK) + cbc_fetch_bytes > PAGE_SIZE))
Chuck Ebbert8d8409f2009-06-18 19:31:09 +0800253 return cbc_crypt_copy(in, out, key, iv, cword, count);
254
255 return rep_xcrypt_cbc(in, out, key, iv, cword, count);
Herbert Xud4a7dd82007-12-28 11:05:46 +1100256}
257
Herbert Xu6789b2d2005-07-06 13:52:27 -0700258static inline void padlock_xcrypt_ecb(const u8 *input, u8 *output, void *key,
259 void *control_word, u32 count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260{
Chuck Ebberta76c1c22009-06-18 19:24:10 +0800261 u32 initial = count & (ecb_fetch_blocks - 1);
262
263 if (count < ecb_fetch_blocks) {
Chuck Ebbert8d8409f2009-06-18 19:31:09 +0800264 ecb_crypt(input, output, key, control_word, count);
Herbert Xud4a7dd82007-12-28 11:05:46 +1100265 return;
266 }
267
Chuck Ebberta76c1c22009-06-18 19:24:10 +0800268 if (initial)
269 asm volatile (".byte 0xf3,0x0f,0xa7,0xc8" /* rep xcryptecb */
270 : "+S"(input), "+D"(output)
271 : "d"(control_word), "b"(key), "c"(initial));
272
273 asm volatile (".byte 0xf3,0x0f,0xa7,0xc8" /* rep xcryptecb */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 : "+S"(input), "+D"(output)
Chuck Ebberta76c1c22009-06-18 19:24:10 +0800275 : "d"(control_word), "b"(key), "c"(count - initial));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276}
277
Herbert Xu476df252005-07-06 13:54:09 -0700278static inline u8 *padlock_xcrypt_cbc(const u8 *input, u8 *output, void *key,
279 u8 *iv, void *control_word, u32 count)
Herbert Xu28e8c3a2005-07-06 13:52:43 -0700280{
Chuck Ebbert8d8409f2009-06-18 19:31:09 +0800281 u32 initial = count & (cbc_fetch_blocks - 1);
282
283 if (count < cbc_fetch_blocks)
284 return cbc_crypt(input, output, key, iv, control_word, count);
285
286 if (initial)
287 asm volatile (".byte 0xf3,0x0f,0xa7,0xd0" /* rep xcryptcbc */
288 : "+S" (input), "+D" (output), "+a" (iv)
Herbert Xuc054a072010-11-04 14:38:39 -0400289 : "d" (control_word), "b" (key), "c" (initial));
Chuck Ebbert8d8409f2009-06-18 19:31:09 +0800290
291 asm volatile (".byte 0xf3,0x0f,0xa7,0xd0" /* rep xcryptcbc */
Herbert Xu28e8c3a2005-07-06 13:52:43 -0700292 : "+S" (input), "+D" (output), "+a" (iv)
Chuck Ebbert8d8409f2009-06-18 19:31:09 +0800293 : "d" (control_word), "b" (key), "c" (count-initial));
Herbert Xu476df252005-07-06 13:54:09 -0700294 return iv;
Herbert Xu28e8c3a2005-07-06 13:52:43 -0700295}
296
Herbert Xu6c2bb982006-05-16 22:09:29 +1000297static void aes_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298{
Herbert Xu6c2bb982006-05-16 22:09:29 +1000299 struct aes_ctx *ctx = aes_ctx(tfm);
Suresh Siddhae4914012008-08-13 22:02:26 +1000300 int ts_state;
Suresh Siddhae4914012008-08-13 22:02:26 +1000301
Herbert Xu420a4b22008-08-31 15:58:45 +1000302 padlock_reset_key(&ctx->cword.encrypt);
Suresh Siddhae4914012008-08-13 22:02:26 +1000303 ts_state = irq_ts_save();
Chuck Ebbert8d8409f2009-06-18 19:31:09 +0800304 ecb_crypt(in, out, ctx->E, &ctx->cword.encrypt, 1);
Suresh Siddhae4914012008-08-13 22:02:26 +1000305 irq_ts_restore(ts_state);
Herbert Xu420a4b22008-08-31 15:58:45 +1000306 padlock_store_cword(&ctx->cword.encrypt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307}
308
Herbert Xu6c2bb982006-05-16 22:09:29 +1000309static void aes_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310{
Herbert Xu6c2bb982006-05-16 22:09:29 +1000311 struct aes_ctx *ctx = aes_ctx(tfm);
Suresh Siddhae4914012008-08-13 22:02:26 +1000312 int ts_state;
Suresh Siddhae4914012008-08-13 22:02:26 +1000313
Herbert Xu420a4b22008-08-31 15:58:45 +1000314 padlock_reset_key(&ctx->cword.encrypt);
Suresh Siddhae4914012008-08-13 22:02:26 +1000315 ts_state = irq_ts_save();
Chuck Ebbert8d8409f2009-06-18 19:31:09 +0800316 ecb_crypt(in, out, ctx->D, &ctx->cword.decrypt, 1);
Suresh Siddhae4914012008-08-13 22:02:26 +1000317 irq_ts_restore(ts_state);
Herbert Xu420a4b22008-08-31 15:58:45 +1000318 padlock_store_cword(&ctx->cword.encrypt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319}
320
321static struct crypto_alg aes_alg = {
322 .cra_name = "aes",
Herbert Xuc8a19c92005-11-05 18:06:26 +1100323 .cra_driver_name = "aes-padlock",
Michal Ludvigccc17c32006-07-15 10:23:49 +1000324 .cra_priority = PADLOCK_CRA_PRIORITY,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 .cra_flags = CRYPTO_ALG_TYPE_CIPHER,
326 .cra_blocksize = AES_BLOCK_SIZE,
Herbert Xufbdae9f2005-07-06 13:53:29 -0700327 .cra_ctxsize = sizeof(struct aes_ctx),
Herbert Xu6789b2d2005-07-06 13:52:27 -0700328 .cra_alignmask = PADLOCK_ALIGNMENT - 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 .cra_module = THIS_MODULE,
330 .cra_list = LIST_HEAD_INIT(aes_alg.cra_list),
331 .cra_u = {
332 .cipher = {
333 .cia_min_keysize = AES_MIN_KEY_SIZE,
334 .cia_max_keysize = AES_MAX_KEY_SIZE,
335 .cia_setkey = aes_set_key,
336 .cia_encrypt = aes_encrypt,
Herbert Xu28e8c3a2005-07-06 13:52:43 -0700337 .cia_decrypt = aes_decrypt,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 }
339 }
340};
341
Herbert Xu28ce7282006-08-21 21:38:42 +1000342static int ecb_aes_encrypt(struct blkcipher_desc *desc,
343 struct scatterlist *dst, struct scatterlist *src,
344 unsigned int nbytes)
345{
346 struct aes_ctx *ctx = blk_aes_ctx(desc->tfm);
347 struct blkcipher_walk walk;
348 int err;
Suresh Siddhae4914012008-08-13 22:02:26 +1000349 int ts_state;
Herbert Xu28ce7282006-08-21 21:38:42 +1000350
Herbert Xu420a4b22008-08-31 15:58:45 +1000351 padlock_reset_key(&ctx->cword.encrypt);
Herbert Xu866cd902007-12-27 00:04:44 +1100352
Herbert Xu28ce7282006-08-21 21:38:42 +1000353 blkcipher_walk_init(&walk, dst, src, nbytes);
354 err = blkcipher_walk_virt(desc, &walk);
355
Suresh Siddhae4914012008-08-13 22:02:26 +1000356 ts_state = irq_ts_save();
Herbert Xu28ce7282006-08-21 21:38:42 +1000357 while ((nbytes = walk.nbytes)) {
358 padlock_xcrypt_ecb(walk.src.virt.addr, walk.dst.virt.addr,
359 ctx->E, &ctx->cword.encrypt,
360 nbytes / AES_BLOCK_SIZE);
361 nbytes &= AES_BLOCK_SIZE - 1;
362 err = blkcipher_walk_done(desc, &walk, nbytes);
363 }
Suresh Siddhae4914012008-08-13 22:02:26 +1000364 irq_ts_restore(ts_state);
Herbert Xu28ce7282006-08-21 21:38:42 +1000365
Herbert Xu420a4b22008-08-31 15:58:45 +1000366 padlock_store_cword(&ctx->cword.encrypt);
367
Herbert Xu28ce7282006-08-21 21:38:42 +1000368 return err;
369}
370
371static int ecb_aes_decrypt(struct blkcipher_desc *desc,
372 struct scatterlist *dst, struct scatterlist *src,
373 unsigned int nbytes)
374{
375 struct aes_ctx *ctx = blk_aes_ctx(desc->tfm);
376 struct blkcipher_walk walk;
377 int err;
Suresh Siddhae4914012008-08-13 22:02:26 +1000378 int ts_state;
Herbert Xu28ce7282006-08-21 21:38:42 +1000379
Herbert Xu420a4b22008-08-31 15:58:45 +1000380 padlock_reset_key(&ctx->cword.decrypt);
Herbert Xu866cd902007-12-27 00:04:44 +1100381
Herbert Xu28ce7282006-08-21 21:38:42 +1000382 blkcipher_walk_init(&walk, dst, src, nbytes);
383 err = blkcipher_walk_virt(desc, &walk);
384
Suresh Siddhae4914012008-08-13 22:02:26 +1000385 ts_state = irq_ts_save();
Herbert Xu28ce7282006-08-21 21:38:42 +1000386 while ((nbytes = walk.nbytes)) {
387 padlock_xcrypt_ecb(walk.src.virt.addr, walk.dst.virt.addr,
388 ctx->D, &ctx->cword.decrypt,
389 nbytes / AES_BLOCK_SIZE);
390 nbytes &= AES_BLOCK_SIZE - 1;
391 err = blkcipher_walk_done(desc, &walk, nbytes);
392 }
Suresh Siddhae4914012008-08-13 22:02:26 +1000393 irq_ts_restore(ts_state);
Herbert Xu420a4b22008-08-31 15:58:45 +1000394
395 padlock_store_cword(&ctx->cword.encrypt);
396
Herbert Xu28ce7282006-08-21 21:38:42 +1000397 return err;
398}
399
400static struct crypto_alg ecb_aes_alg = {
401 .cra_name = "ecb(aes)",
402 .cra_driver_name = "ecb-aes-padlock",
403 .cra_priority = PADLOCK_COMPOSITE_PRIORITY,
404 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
405 .cra_blocksize = AES_BLOCK_SIZE,
406 .cra_ctxsize = sizeof(struct aes_ctx),
407 .cra_alignmask = PADLOCK_ALIGNMENT - 1,
408 .cra_type = &crypto_blkcipher_type,
409 .cra_module = THIS_MODULE,
410 .cra_list = LIST_HEAD_INIT(ecb_aes_alg.cra_list),
411 .cra_u = {
412 .blkcipher = {
413 .min_keysize = AES_MIN_KEY_SIZE,
414 .max_keysize = AES_MAX_KEY_SIZE,
415 .setkey = aes_set_key,
416 .encrypt = ecb_aes_encrypt,
417 .decrypt = ecb_aes_decrypt,
418 }
419 }
420};
421
422static int cbc_aes_encrypt(struct blkcipher_desc *desc,
423 struct scatterlist *dst, struct scatterlist *src,
424 unsigned int nbytes)
425{
426 struct aes_ctx *ctx = blk_aes_ctx(desc->tfm);
427 struct blkcipher_walk walk;
428 int err;
Suresh Siddhae4914012008-08-13 22:02:26 +1000429 int ts_state;
Herbert Xu28ce7282006-08-21 21:38:42 +1000430
Herbert Xu420a4b22008-08-31 15:58:45 +1000431 padlock_reset_key(&ctx->cword.encrypt);
Herbert Xu866cd902007-12-27 00:04:44 +1100432
Herbert Xu28ce7282006-08-21 21:38:42 +1000433 blkcipher_walk_init(&walk, dst, src, nbytes);
434 err = blkcipher_walk_virt(desc, &walk);
435
Suresh Siddhae4914012008-08-13 22:02:26 +1000436 ts_state = irq_ts_save();
Herbert Xu28ce7282006-08-21 21:38:42 +1000437 while ((nbytes = walk.nbytes)) {
438 u8 *iv = padlock_xcrypt_cbc(walk.src.virt.addr,
439 walk.dst.virt.addr, ctx->E,
440 walk.iv, &ctx->cword.encrypt,
441 nbytes / AES_BLOCK_SIZE);
442 memcpy(walk.iv, iv, AES_BLOCK_SIZE);
443 nbytes &= AES_BLOCK_SIZE - 1;
444 err = blkcipher_walk_done(desc, &walk, nbytes);
445 }
Suresh Siddhae4914012008-08-13 22:02:26 +1000446 irq_ts_restore(ts_state);
Herbert Xu28ce7282006-08-21 21:38:42 +1000447
Herbert Xu420a4b22008-08-31 15:58:45 +1000448 padlock_store_cword(&ctx->cword.decrypt);
449
Herbert Xu28ce7282006-08-21 21:38:42 +1000450 return err;
451}
452
453static int cbc_aes_decrypt(struct blkcipher_desc *desc,
454 struct scatterlist *dst, struct scatterlist *src,
455 unsigned int nbytes)
456{
457 struct aes_ctx *ctx = blk_aes_ctx(desc->tfm);
458 struct blkcipher_walk walk;
459 int err;
Suresh Siddhae4914012008-08-13 22:02:26 +1000460 int ts_state;
Herbert Xu28ce7282006-08-21 21:38:42 +1000461
Herbert Xu420a4b22008-08-31 15:58:45 +1000462 padlock_reset_key(&ctx->cword.encrypt);
Herbert Xu866cd902007-12-27 00:04:44 +1100463
Herbert Xu28ce7282006-08-21 21:38:42 +1000464 blkcipher_walk_init(&walk, dst, src, nbytes);
465 err = blkcipher_walk_virt(desc, &walk);
466
Suresh Siddhae4914012008-08-13 22:02:26 +1000467 ts_state = irq_ts_save();
Herbert Xu28ce7282006-08-21 21:38:42 +1000468 while ((nbytes = walk.nbytes)) {
469 padlock_xcrypt_cbc(walk.src.virt.addr, walk.dst.virt.addr,
470 ctx->D, walk.iv, &ctx->cword.decrypt,
471 nbytes / AES_BLOCK_SIZE);
472 nbytes &= AES_BLOCK_SIZE - 1;
473 err = blkcipher_walk_done(desc, &walk, nbytes);
474 }
475
Suresh Siddhae4914012008-08-13 22:02:26 +1000476 irq_ts_restore(ts_state);
Herbert Xu420a4b22008-08-31 15:58:45 +1000477
478 padlock_store_cword(&ctx->cword.encrypt);
479
Herbert Xu28ce7282006-08-21 21:38:42 +1000480 return err;
481}
482
483static struct crypto_alg cbc_aes_alg = {
484 .cra_name = "cbc(aes)",
485 .cra_driver_name = "cbc-aes-padlock",
486 .cra_priority = PADLOCK_COMPOSITE_PRIORITY,
487 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
488 .cra_blocksize = AES_BLOCK_SIZE,
489 .cra_ctxsize = sizeof(struct aes_ctx),
490 .cra_alignmask = PADLOCK_ALIGNMENT - 1,
491 .cra_type = &crypto_blkcipher_type,
492 .cra_module = THIS_MODULE,
493 .cra_list = LIST_HEAD_INIT(cbc_aes_alg.cra_list),
494 .cra_u = {
495 .blkcipher = {
496 .min_keysize = AES_MIN_KEY_SIZE,
497 .max_keysize = AES_MAX_KEY_SIZE,
498 .ivsize = AES_BLOCK_SIZE,
499 .setkey = aes_set_key,
500 .encrypt = cbc_aes_encrypt,
501 .decrypt = cbc_aes_decrypt,
502 }
503 }
504};
505
Michal Ludvig1191f0a2006-08-06 22:46:20 +1000506static int __init padlock_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507{
Michal Ludvig1191f0a2006-08-06 22:46:20 +1000508 int ret;
Chuck Ebberta76c1c22009-06-18 19:24:10 +0800509 struct cpuinfo_x86 *c = &cpu_data(0);
Michal Ludvig1191f0a2006-08-06 22:46:20 +1000510
Jonathan Niederc39cc372011-08-03 14:07:11 +0800511 if (!cpu_has_xcrypt)
Michal Ludvig1191f0a2006-08-06 22:46:20 +1000512 return -ENODEV;
Michal Ludvig1191f0a2006-08-06 22:46:20 +1000513
514 if (!cpu_has_xcrypt_enabled) {
Jeremy Katzb43e7262008-07-03 19:03:31 +0800515 printk(KERN_NOTICE PFX "VIA PadLock detected, but not enabled. Hmm, strange...\n");
Michal Ludvig1191f0a2006-08-06 22:46:20 +1000516 return -ENODEV;
517 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518
Herbert Xu28ce7282006-08-21 21:38:42 +1000519 if ((ret = crypto_register_alg(&aes_alg)))
520 goto aes_err;
521
522 if ((ret = crypto_register_alg(&ecb_aes_alg)))
523 goto ecb_aes_err;
524
525 if ((ret = crypto_register_alg(&cbc_aes_alg)))
526 goto cbc_aes_err;
Michal Ludvig1191f0a2006-08-06 22:46:20 +1000527
528 printk(KERN_NOTICE PFX "Using VIA PadLock ACE for AES algorithm.\n");
529
Chuck Ebberta76c1c22009-06-18 19:24:10 +0800530 if (c->x86 == 6 && c->x86_model == 15 && c->x86_mask == 2) {
Chuck Ebbert8d8409f2009-06-18 19:31:09 +0800531 ecb_fetch_blocks = MAX_ECB_FETCH_BLOCKS;
532 cbc_fetch_blocks = MAX_CBC_FETCH_BLOCKS;
Chuck Ebberta76c1c22009-06-18 19:24:10 +0800533 printk(KERN_NOTICE PFX "VIA Nano stepping 2 detected: enabling workaround.\n");
534 }
535
Herbert Xu28ce7282006-08-21 21:38:42 +1000536out:
Michal Ludvig1191f0a2006-08-06 22:46:20 +1000537 return ret;
Herbert Xu28ce7282006-08-21 21:38:42 +1000538
539cbc_aes_err:
540 crypto_unregister_alg(&ecb_aes_alg);
541ecb_aes_err:
542 crypto_unregister_alg(&aes_alg);
543aes_err:
544 printk(KERN_ERR PFX "VIA PadLock AES initialization failed.\n");
545 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546}
547
Michal Ludvig1191f0a2006-08-06 22:46:20 +1000548static void __exit padlock_fini(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549{
Herbert Xu28ce7282006-08-21 21:38:42 +1000550 crypto_unregister_alg(&cbc_aes_alg);
551 crypto_unregister_alg(&ecb_aes_alg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 crypto_unregister_alg(&aes_alg);
553}
Michal Ludvig1191f0a2006-08-06 22:46:20 +1000554
555module_init(padlock_init);
556module_exit(padlock_fini);
557
558MODULE_DESCRIPTION("VIA PadLock AES algorithm support");
559MODULE_LICENSE("GPL");
560MODULE_AUTHOR("Michal Ludvig");
561
Herbert Xuacd246b2009-04-21 13:55:20 +0800562MODULE_ALIAS("aes");