2 * linux/drivers/s390/crypto/zcrypt_cex2a.c
6 * Copyright (C) 2001, 2006 IBM Corporation
7 * Author(s): Robert Burroughs
8 * Eric Rossman (edrossma@us.ibm.com)
10 * Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
11 * Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>
12 * Ralph Wuerthner <rwuerthn@de.ibm.com>
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2, or (at your option)
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, write to the Free Software
26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29 #include <linux/module.h>
30 #include <linux/slab.h>
31 #include <linux/init.h>
32 #include <linux/err.h>
33 #include <linux/atomic.h>
34 #include <asm/uaccess.h>
37 #include "zcrypt_api.h"
38 #include "zcrypt_error.h"
39 #include "zcrypt_cex2a.h"
41 #define CEX2A_MIN_MOD_SIZE 1 /* 8 bits */
42 #define CEX2A_MAX_MOD_SIZE 256 /* 2048 bits */
43 #define CEX3A_MIN_MOD_SIZE CEX2A_MIN_MOD_SIZE
44 #define CEX3A_MAX_MOD_SIZE 512 /* 4096 bits */
46 #define CEX2A_SPEED_RATING 970
47 #define CEX3A_SPEED_RATING 900 /* Fixme: Needs finetuning */
49 #define CEX2A_MAX_MESSAGE_SIZE 0x390 /* sizeof(struct type50_crb2_msg) */
50 #define CEX2A_MAX_RESPONSE_SIZE 0x110 /* max outputdatalength + type80_hdr */
52 #define CEX3A_MAX_RESPONSE_SIZE 0x210 /* 512 bit modulus
53 * (max outputdatalength) +
55 #define CEX3A_MAX_MESSAGE_SIZE sizeof(struct type50_crb3_msg)
57 #define CEX2A_CLEANUP_TIME (15*HZ)
58 #define CEX3A_CLEANUP_TIME CEX2A_CLEANUP_TIME
60 static struct ap_device_id zcrypt_cex2a_ids
[] = {
61 { AP_DEVICE(AP_DEVICE_TYPE_CEX2A
) },
62 { AP_DEVICE(AP_DEVICE_TYPE_CEX3A
) },
63 { /* end of list */ },
66 MODULE_DEVICE_TABLE(ap
, zcrypt_cex2a_ids
);
67 MODULE_AUTHOR("IBM Corporation");
68 MODULE_DESCRIPTION("CEX2A Cryptographic Coprocessor device driver, "
69 "Copyright 2001, 2006 IBM Corporation");
70 MODULE_LICENSE("GPL");
72 static int zcrypt_cex2a_probe(struct ap_device
*ap_dev
);
73 static void zcrypt_cex2a_remove(struct ap_device
*ap_dev
);
74 static void zcrypt_cex2a_receive(struct ap_device
*, struct ap_message
*,
77 static struct ap_driver zcrypt_cex2a_driver
= {
78 .probe
= zcrypt_cex2a_probe
,
79 .remove
= zcrypt_cex2a_remove
,
80 .ids
= zcrypt_cex2a_ids
,
81 .request_timeout
= CEX2A_CLEANUP_TIME
,
85 * Convert a ICAMEX message to a type50 MEX message.
87 * @zdev: crypto device pointer
88 * @zreq: crypto request pointer
89 * @mex: pointer to user input data
91 * Returns 0 on success or -EFAULT.
93 static int ICAMEX_msg_to_type50MEX_msg(struct zcrypt_device
*zdev
,
94 struct ap_message
*ap_msg
,
95 struct ica_rsa_modexpo
*mex
)
97 unsigned char *mod
, *exp
, *inp
;
100 mod_len
= mex
->inputdatalength
;
102 if (mod_len
<= 128) {
103 struct type50_meb1_msg
*meb1
= ap_msg
->message
;
104 memset(meb1
, 0, sizeof(*meb1
));
105 ap_msg
->length
= sizeof(*meb1
);
106 meb1
->header
.msg_type_code
= TYPE50_TYPE_CODE
;
107 meb1
->header
.msg_len
= sizeof(*meb1
);
108 meb1
->keyblock_type
= TYPE50_MEB1_FMT
;
109 mod
= meb1
->modulus
+ sizeof(meb1
->modulus
) - mod_len
;
110 exp
= meb1
->exponent
+ sizeof(meb1
->exponent
) - mod_len
;
111 inp
= meb1
->message
+ sizeof(meb1
->message
) - mod_len
;
112 } else if (mod_len
<= 256) {
113 struct type50_meb2_msg
*meb2
= ap_msg
->message
;
114 memset(meb2
, 0, sizeof(*meb2
));
115 ap_msg
->length
= sizeof(*meb2
);
116 meb2
->header
.msg_type_code
= TYPE50_TYPE_CODE
;
117 meb2
->header
.msg_len
= sizeof(*meb2
);
118 meb2
->keyblock_type
= TYPE50_MEB2_FMT
;
119 mod
= meb2
->modulus
+ sizeof(meb2
->modulus
) - mod_len
;
120 exp
= meb2
->exponent
+ sizeof(meb2
->exponent
) - mod_len
;
121 inp
= meb2
->message
+ sizeof(meb2
->message
) - mod_len
;
123 /* mod_len > 256 = 4096 bit RSA Key */
124 struct type50_meb3_msg
*meb3
= ap_msg
->message
;
125 memset(meb3
, 0, sizeof(*meb3
));
126 ap_msg
->length
= sizeof(*meb3
);
127 meb3
->header
.msg_type_code
= TYPE50_TYPE_CODE
;
128 meb3
->header
.msg_len
= sizeof(*meb3
);
129 meb3
->keyblock_type
= TYPE50_MEB3_FMT
;
130 mod
= meb3
->modulus
+ sizeof(meb3
->modulus
) - mod_len
;
131 exp
= meb3
->exponent
+ sizeof(meb3
->exponent
) - mod_len
;
132 inp
= meb3
->message
+ sizeof(meb3
->message
) - mod_len
;
135 if (copy_from_user(mod
, mex
->n_modulus
, mod_len
) ||
136 copy_from_user(exp
, mex
->b_key
, mod_len
) ||
137 copy_from_user(inp
, mex
->inputdata
, mod_len
))
143 * Convert a ICACRT message to a type50 CRT message.
145 * @zdev: crypto device pointer
146 * @zreq: crypto request pointer
147 * @crt: pointer to user input data
149 * Returns 0 on success or -EFAULT.
151 static int ICACRT_msg_to_type50CRT_msg(struct zcrypt_device
*zdev
,
152 struct ap_message
*ap_msg
,
153 struct ica_rsa_modexpo_crt
*crt
)
155 int mod_len
, short_len
, long_len
, long_offset
, limit
;
156 unsigned char *p
, *q
, *dp
, *dq
, *u
, *inp
;
158 mod_len
= crt
->inputdatalength
;
159 short_len
= mod_len
/ 2;
160 long_len
= mod_len
/ 2 + 8;
163 * CEX2A cannot handle p, dp, or U > 128 bytes.
164 * If we have one of these, we need to do extra checking.
165 * For CEX3A the limit is 256 bytes.
167 if (zdev
->max_mod_size
== CEX3A_MAX_MOD_SIZE
)
172 if (long_len
> limit
) {
174 * zcrypt_rsa_crt already checked for the leading
175 * zeroes of np_prime, bp_key and u_mult_inc.
177 long_offset
= long_len
- limit
;
183 * Instead of doing extra work for p, dp, U > 64 bytes, we'll just use
184 * the larger message structure.
186 if (long_len
<= 64) {
187 struct type50_crb1_msg
*crb1
= ap_msg
->message
;
188 memset(crb1
, 0, sizeof(*crb1
));
189 ap_msg
->length
= sizeof(*crb1
);
190 crb1
->header
.msg_type_code
= TYPE50_TYPE_CODE
;
191 crb1
->header
.msg_len
= sizeof(*crb1
);
192 crb1
->keyblock_type
= TYPE50_CRB1_FMT
;
193 p
= crb1
->p
+ sizeof(crb1
->p
) - long_len
;
194 q
= crb1
->q
+ sizeof(crb1
->q
) - short_len
;
195 dp
= crb1
->dp
+ sizeof(crb1
->dp
) - long_len
;
196 dq
= crb1
->dq
+ sizeof(crb1
->dq
) - short_len
;
197 u
= crb1
->u
+ sizeof(crb1
->u
) - long_len
;
198 inp
= crb1
->message
+ sizeof(crb1
->message
) - mod_len
;
199 } else if (long_len
<= 128) {
200 struct type50_crb2_msg
*crb2
= ap_msg
->message
;
201 memset(crb2
, 0, sizeof(*crb2
));
202 ap_msg
->length
= sizeof(*crb2
);
203 crb2
->header
.msg_type_code
= TYPE50_TYPE_CODE
;
204 crb2
->header
.msg_len
= sizeof(*crb2
);
205 crb2
->keyblock_type
= TYPE50_CRB2_FMT
;
206 p
= crb2
->p
+ sizeof(crb2
->p
) - long_len
;
207 q
= crb2
->q
+ sizeof(crb2
->q
) - short_len
;
208 dp
= crb2
->dp
+ sizeof(crb2
->dp
) - long_len
;
209 dq
= crb2
->dq
+ sizeof(crb2
->dq
) - short_len
;
210 u
= crb2
->u
+ sizeof(crb2
->u
) - long_len
;
211 inp
= crb2
->message
+ sizeof(crb2
->message
) - mod_len
;
213 /* long_len >= 256 */
214 struct type50_crb3_msg
*crb3
= ap_msg
->message
;
215 memset(crb3
, 0, sizeof(*crb3
));
216 ap_msg
->length
= sizeof(*crb3
);
217 crb3
->header
.msg_type_code
= TYPE50_TYPE_CODE
;
218 crb3
->header
.msg_len
= sizeof(*crb3
);
219 crb3
->keyblock_type
= TYPE50_CRB3_FMT
;
220 p
= crb3
->p
+ sizeof(crb3
->p
) - long_len
;
221 q
= crb3
->q
+ sizeof(crb3
->q
) - short_len
;
222 dp
= crb3
->dp
+ sizeof(crb3
->dp
) - long_len
;
223 dq
= crb3
->dq
+ sizeof(crb3
->dq
) - short_len
;
224 u
= crb3
->u
+ sizeof(crb3
->u
) - long_len
;
225 inp
= crb3
->message
+ sizeof(crb3
->message
) - mod_len
;
228 if (copy_from_user(p
, crt
->np_prime
+ long_offset
, long_len
) ||
229 copy_from_user(q
, crt
->nq_prime
, short_len
) ||
230 copy_from_user(dp
, crt
->bp_key
+ long_offset
, long_len
) ||
231 copy_from_user(dq
, crt
->bq_key
, short_len
) ||
232 copy_from_user(u
, crt
->u_mult_inv
+ long_offset
, long_len
) ||
233 copy_from_user(inp
, crt
->inputdata
, mod_len
))
240 * Copy results from a type 80 reply message back to user space.
242 * @zdev: crypto device pointer
243 * @reply: reply AP message.
244 * @data: pointer to user output data
245 * @length: size of user output data
247 * Returns 0 on success or -EFAULT.
249 static int convert_type80(struct zcrypt_device
*zdev
,
250 struct ap_message
*reply
,
251 char __user
*outputdata
,
252 unsigned int outputdatalength
)
254 struct type80_hdr
*t80h
= reply
->message
;
257 if (t80h
->len
< sizeof(*t80h
) + outputdatalength
) {
258 /* The result is too short, the CEX2A card may not do that.. */
260 return -EAGAIN
; /* repeat the request on a different device. */
262 if (zdev
->user_space_type
== ZCRYPT_CEX2A
)
263 BUG_ON(t80h
->len
> CEX2A_MAX_RESPONSE_SIZE
);
265 BUG_ON(t80h
->len
> CEX3A_MAX_RESPONSE_SIZE
);
266 data
= reply
->message
+ t80h
->len
- outputdatalength
;
267 if (copy_to_user(outputdata
, data
, outputdatalength
))
272 static int convert_response(struct zcrypt_device
*zdev
,
273 struct ap_message
*reply
,
274 char __user
*outputdata
,
275 unsigned int outputdatalength
)
277 /* Response type byte is the second byte in the response. */
278 switch (((unsigned char *) reply
->message
)[1]) {
279 case TYPE82_RSP_CODE
:
280 case TYPE88_RSP_CODE
:
281 return convert_error(zdev
, reply
);
282 case TYPE80_RSP_CODE
:
283 return convert_type80(zdev
, reply
,
284 outputdata
, outputdatalength
);
285 default: /* Unknown response type, this should NEVER EVER happen */
287 return -EAGAIN
; /* repeat the request on a different device. */
292 * This function is called from the AP bus code after a crypto request
293 * "msg" has finished with the reply message "reply".
294 * It is called from tasklet context.
295 * @ap_dev: pointer to the AP device
296 * @msg: pointer to the AP message
297 * @reply: pointer to the AP reply message
299 static void zcrypt_cex2a_receive(struct ap_device
*ap_dev
,
300 struct ap_message
*msg
,
301 struct ap_message
*reply
)
303 static struct error_hdr error_reply
= {
304 .type
= TYPE82_RSP_CODE
,
305 .reply_code
= REP82_ERROR_MACHINE_FAILURE
,
307 struct type80_hdr
*t80h
;
310 /* Copy the reply message to the request message buffer. */
312 memcpy(msg
->message
, &error_reply
, sizeof(error_reply
));
315 t80h
= reply
->message
;
316 if (t80h
->type
== TYPE80_RSP_CODE
) {
317 if (ap_dev
->device_type
== AP_DEVICE_TYPE_CEX2A
)
318 length
= min(CEX2A_MAX_RESPONSE_SIZE
, (int) t80h
->len
);
320 length
= min(CEX3A_MAX_RESPONSE_SIZE
, (int) t80h
->len
);
321 memcpy(msg
->message
, reply
->message
, length
);
323 memcpy(msg
->message
, reply
->message
, sizeof error_reply
);
325 complete((struct completion
*) msg
->private);
328 static atomic_t zcrypt_step
= ATOMIC_INIT(0);
331 * The request distributor calls this function if it picked the CEX2A
332 * device to handle a modexpo request.
333 * @zdev: pointer to zcrypt_device structure that identifies the
334 * CEX2A device to the request distributor
335 * @mex: pointer to the modexpo request buffer
337 static long zcrypt_cex2a_modexpo(struct zcrypt_device
*zdev
,
338 struct ica_rsa_modexpo
*mex
)
340 struct ap_message ap_msg
;
341 struct completion work
;
344 ap_init_message(&ap_msg
);
345 if (zdev
->user_space_type
== ZCRYPT_CEX2A
)
346 ap_msg
.message
= kmalloc(CEX2A_MAX_MESSAGE_SIZE
, GFP_KERNEL
);
348 ap_msg
.message
= kmalloc(CEX3A_MAX_MESSAGE_SIZE
, GFP_KERNEL
);
351 ap_msg
.receive
= zcrypt_cex2a_receive
;
352 ap_msg
.psmid
= (((unsigned long long) current
->pid
) << 32) +
353 atomic_inc_return(&zcrypt_step
);
354 ap_msg
.private = &work
;
355 rc
= ICAMEX_msg_to_type50MEX_msg(zdev
, &ap_msg
, mex
);
358 init_completion(&work
);
359 ap_queue_message(zdev
->ap_dev
, &ap_msg
);
360 rc
= wait_for_completion_interruptible(&work
);
362 rc
= convert_response(zdev
, &ap_msg
, mex
->outputdata
,
363 mex
->outputdatalength
);
365 /* Signal pending. */
366 ap_cancel_message(zdev
->ap_dev
, &ap_msg
);
368 kfree(ap_msg
.message
);
373 * The request distributor calls this function if it picked the CEX2A
374 * device to handle a modexpo_crt request.
375 * @zdev: pointer to zcrypt_device structure that identifies the
376 * CEX2A device to the request distributor
377 * @crt: pointer to the modexpoc_crt request buffer
379 static long zcrypt_cex2a_modexpo_crt(struct zcrypt_device
*zdev
,
380 struct ica_rsa_modexpo_crt
*crt
)
382 struct ap_message ap_msg
;
383 struct completion work
;
386 ap_init_message(&ap_msg
);
387 if (zdev
->user_space_type
== ZCRYPT_CEX2A
)
388 ap_msg
.message
= kmalloc(CEX2A_MAX_MESSAGE_SIZE
, GFP_KERNEL
);
390 ap_msg
.message
= kmalloc(CEX3A_MAX_MESSAGE_SIZE
, GFP_KERNEL
);
393 ap_msg
.receive
= zcrypt_cex2a_receive
;
394 ap_msg
.psmid
= (((unsigned long long) current
->pid
) << 32) +
395 atomic_inc_return(&zcrypt_step
);
396 ap_msg
.private = &work
;
397 rc
= ICACRT_msg_to_type50CRT_msg(zdev
, &ap_msg
, crt
);
400 init_completion(&work
);
401 ap_queue_message(zdev
->ap_dev
, &ap_msg
);
402 rc
= wait_for_completion_interruptible(&work
);
404 rc
= convert_response(zdev
, &ap_msg
, crt
->outputdata
,
405 crt
->outputdatalength
);
407 /* Signal pending. */
408 ap_cancel_message(zdev
->ap_dev
, &ap_msg
);
410 kfree(ap_msg
.message
);
415 * The crypto operations for a CEX2A card.
417 static struct zcrypt_ops zcrypt_cex2a_ops
= {
418 .rsa_modexpo
= zcrypt_cex2a_modexpo
,
419 .rsa_modexpo_crt
= zcrypt_cex2a_modexpo_crt
,
423 * Probe function for CEX2A cards. It always accepts the AP device
424 * since the bus_match already checked the hardware type.
425 * @ap_dev: pointer to the AP device.
427 static int zcrypt_cex2a_probe(struct ap_device
*ap_dev
)
429 struct zcrypt_device
*zdev
= NULL
;
432 switch (ap_dev
->device_type
) {
433 case AP_DEVICE_TYPE_CEX2A
:
434 zdev
= zcrypt_device_alloc(CEX2A_MAX_RESPONSE_SIZE
);
437 zdev
->user_space_type
= ZCRYPT_CEX2A
;
438 zdev
->type_string
= "CEX2A";
439 zdev
->min_mod_size
= CEX2A_MIN_MOD_SIZE
;
440 zdev
->max_mod_size
= CEX2A_MAX_MOD_SIZE
;
442 zdev
->speed_rating
= CEX2A_SPEED_RATING
;
443 zdev
->max_exp_bit_length
= CEX2A_MAX_MOD_SIZE
;
445 case AP_DEVICE_TYPE_CEX3A
:
446 zdev
= zcrypt_device_alloc(CEX3A_MAX_RESPONSE_SIZE
);
449 zdev
->user_space_type
= ZCRYPT_CEX3A
;
450 zdev
->type_string
= "CEX3A";
451 zdev
->min_mod_size
= CEX2A_MIN_MOD_SIZE
;
452 zdev
->max_mod_size
= CEX2A_MAX_MOD_SIZE
;
453 zdev
->max_exp_bit_length
= CEX2A_MAX_MOD_SIZE
;
454 if (ap_4096_commands_available(ap_dev
->qid
)) {
455 zdev
->max_mod_size
= CEX3A_MAX_MOD_SIZE
;
456 zdev
->max_exp_bit_length
= CEX3A_MAX_MOD_SIZE
;
459 zdev
->speed_rating
= CEX3A_SPEED_RATING
;
463 zdev
->ap_dev
= ap_dev
;
464 zdev
->ops
= &zcrypt_cex2a_ops
;
466 ap_dev
->reply
= &zdev
->reply
;
467 ap_dev
->private = zdev
;
468 rc
= zcrypt_device_register(zdev
);
471 ap_dev
->private = NULL
;
472 zcrypt_device_free(zdev
);
478 * This is called to remove the extended CEX2A driver information
479 * if an AP device is removed.
481 static void zcrypt_cex2a_remove(struct ap_device
*ap_dev
)
483 struct zcrypt_device
*zdev
= ap_dev
->private;
485 zcrypt_device_unregister(zdev
);
488 int __init
zcrypt_cex2a_init(void)
490 return ap_driver_register(&zcrypt_cex2a_driver
, THIS_MODULE
, "cex2a");
493 void __exit
zcrypt_cex2a_exit(void)
495 ap_driver_unregister(&zcrypt_cex2a_driver
);
498 module_init(zcrypt_cex2a_init
);
499 module_exit(zcrypt_cex2a_exit
);