2 * linux/drivers/s390/crypto/zcrypt_api.c
6 * Copyright (C) 2001, 2006 IBM Corporation
7 * Author(s): Robert Burroughs
8 * Eric Rossman (edrossma@us.ibm.com)
9 * Cornelia Huck <cornelia.huck@de.ibm.com>
11 * Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
12 * Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>
13 * Ralph Wuerthner <rwuerthn@de.ibm.com>
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 2, or (at your option)
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, write to the Free Software
27 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
30 #include <linux/module.h>
31 #include <linux/init.h>
32 #include <linux/interrupt.h>
33 #include <linux/miscdevice.h>
35 #include <linux/proc_fs.h>
36 #include <linux/seq_file.h>
37 #include <linux/compat.h>
38 #include <linux/smp_lock.h>
39 #include <asm/atomic.h>
40 #include <asm/uaccess.h>
41 #include <linux/hw_random.h>
43 #include "zcrypt_api.h"
48 MODULE_AUTHOR("IBM Corporation");
49 MODULE_DESCRIPTION("Cryptographic Coprocessor interface, "
50 "Copyright 2001, 2006 IBM Corporation");
51 MODULE_LICENSE("GPL");
53 static DEFINE_SPINLOCK(zcrypt_device_lock);
54 static LIST_HEAD(zcrypt_device_list);
55 static int zcrypt_device_count = 0;
56 static atomic_t zcrypt_open_count = ATOMIC_INIT(0);
58 static int zcrypt_rng_device_add(void);
59 static void zcrypt_rng_device_remove(void);
62 * Device attributes common for all crypto devices.
64 static ssize_t zcrypt_type_show(struct device *dev,
65 struct device_attribute *attr, char *buf)
67 struct zcrypt_device *zdev = to_ap_dev(dev)->private;
68 return snprintf(buf, PAGE_SIZE, "%s\n", zdev->type_string);
71 static DEVICE_ATTR(type, 0444, zcrypt_type_show, NULL);
73 static ssize_t zcrypt_online_show(struct device *dev,
74 struct device_attribute *attr, char *buf)
76 struct zcrypt_device *zdev = to_ap_dev(dev)->private;
77 return snprintf(buf, PAGE_SIZE, "%d\n", zdev->online);
80 static ssize_t zcrypt_online_store(struct device *dev,
81 struct device_attribute *attr,
82 const char *buf, size_t count)
84 struct zcrypt_device *zdev = to_ap_dev(dev)->private;
87 if (sscanf(buf, "%d\n", &online) != 1 || online < 0 || online > 1)
89 zdev->online = online;
91 ap_flush_queue(zdev->ap_dev);
95 static DEVICE_ATTR(online, 0644, zcrypt_online_show, zcrypt_online_store);
97 static struct attribute * zcrypt_device_attrs[] = {
99 &dev_attr_online.attr,
103 static struct attribute_group zcrypt_device_attr_group = {
104 .attrs = zcrypt_device_attrs,
108 * __zcrypt_increase_preference(): Increase preference of a crypto device.
109 * @zdev: Pointer the crypto device
111 * Move the device towards the head of the device list.
112 * Need to be called while holding the zcrypt device list lock.
113 * Note: cards with speed_rating of 0 are kept at the end of the list.
115 static void __zcrypt_increase_preference(struct zcrypt_device *zdev)
117 struct zcrypt_device *tmp;
120 if (zdev->speed_rating == 0)
122 for (l = zdev->list.prev; l != &zcrypt_device_list; l = l->prev) {
123 tmp = list_entry(l, struct zcrypt_device, list);
124 if ((tmp->request_count + 1) * tmp->speed_rating <=
125 (zdev->request_count + 1) * zdev->speed_rating &&
126 tmp->speed_rating != 0)
129 if (l == zdev->list.prev)
131 /* Move zdev behind l */
132 list_move(&zdev->list, l);
136 * __zcrypt_decrease_preference(): Decrease preference of a crypto device.
137 * @zdev: Pointer to a crypto device.
139 * Move the device towards the tail of the device list.
140 * Need to be called while holding the zcrypt device list lock.
141 * Note: cards with speed_rating of 0 are kept at the end of the list.
143 static void __zcrypt_decrease_preference(struct zcrypt_device *zdev)
145 struct zcrypt_device *tmp;
148 if (zdev->speed_rating == 0)
150 for (l = zdev->list.next; l != &zcrypt_device_list; l = l->next) {
151 tmp = list_entry(l, struct zcrypt_device, list);
152 if ((tmp->request_count + 1) * tmp->speed_rating >
153 (zdev->request_count + 1) * zdev->speed_rating ||
154 tmp->speed_rating == 0)
157 if (l == zdev->list.next)
159 /* Move zdev before l */
160 list_move_tail(&zdev->list, l);
163 static void zcrypt_device_release(struct kref *kref)
165 struct zcrypt_device *zdev =
166 container_of(kref, struct zcrypt_device, refcount);
167 zcrypt_device_free(zdev);
170 void zcrypt_device_get(struct zcrypt_device *zdev)
172 kref_get(&zdev->refcount);
174 EXPORT_SYMBOL(zcrypt_device_get);
176 int zcrypt_device_put(struct zcrypt_device *zdev)
178 return kref_put(&zdev->refcount, zcrypt_device_release);
180 EXPORT_SYMBOL(zcrypt_device_put);
182 struct zcrypt_device *zcrypt_device_alloc(size_t max_response_size)
184 struct zcrypt_device *zdev;
186 zdev = kzalloc(sizeof(struct zcrypt_device), GFP_KERNEL);
189 zdev->reply.message = kmalloc(max_response_size, GFP_KERNEL);
190 if (!zdev->reply.message)
192 zdev->reply.length = max_response_size;
193 spin_lock_init(&zdev->lock);
194 INIT_LIST_HEAD(&zdev->list);
201 EXPORT_SYMBOL(zcrypt_device_alloc);
203 void zcrypt_device_free(struct zcrypt_device *zdev)
205 kfree(zdev->reply.message);
208 EXPORT_SYMBOL(zcrypt_device_free);
211 * zcrypt_device_register() - Register a crypto device.
212 * @zdev: Pointer to a crypto device
214 * Register a crypto device. Returns 0 if successful.
216 int zcrypt_device_register(struct zcrypt_device *zdev)
220 rc = sysfs_create_group(&zdev->ap_dev->device.kobj,
221 &zcrypt_device_attr_group);
224 get_device(&zdev->ap_dev->device);
225 kref_init(&zdev->refcount);
226 spin_lock_bh(&zcrypt_device_lock);
227 zdev->online = 1; /* New devices are online by default. */
228 list_add_tail(&zdev->list, &zcrypt_device_list);
229 __zcrypt_increase_preference(zdev);
230 zcrypt_device_count++;
231 spin_unlock_bh(&zcrypt_device_lock);
232 if (zdev->ops->rng) {
233 rc = zcrypt_rng_device_add();
240 spin_lock_bh(&zcrypt_device_lock);
241 zcrypt_device_count--;
242 list_del_init(&zdev->list);
243 spin_unlock_bh(&zcrypt_device_lock);
244 sysfs_remove_group(&zdev->ap_dev->device.kobj,
245 &zcrypt_device_attr_group);
246 put_device(&zdev->ap_dev->device);
247 zcrypt_device_put(zdev);
251 EXPORT_SYMBOL(zcrypt_device_register);
254 * zcrypt_device_unregister(): Unregister a crypto device.
255 * @zdev: Pointer to crypto device
257 * Unregister a crypto device.
259 void zcrypt_device_unregister(struct zcrypt_device *zdev)
262 zcrypt_rng_device_remove();
263 spin_lock_bh(&zcrypt_device_lock);
264 zcrypt_device_count--;
265 list_del_init(&zdev->list);
266 spin_unlock_bh(&zcrypt_device_lock);
267 sysfs_remove_group(&zdev->ap_dev->device.kobj,
268 &zcrypt_device_attr_group);
269 put_device(&zdev->ap_dev->device);
270 zcrypt_device_put(zdev);
272 EXPORT_SYMBOL(zcrypt_device_unregister);
275 * zcrypt_read (): Not supported beyond zcrypt 1.3.1.
277 * This function is not supported beyond zcrypt 1.3.1.
279 static ssize_t zcrypt_read(struct file *filp, char __user *buf,
280 size_t count, loff_t *f_pos)
286 * zcrypt_write(): Not allowed.
288 * Write is is not allowed
290 static ssize_t zcrypt_write(struct file *filp, const char __user *buf,
291 size_t count, loff_t *f_pos)
297 * zcrypt_open(): Count number of users.
299 * Device open function to count number of users.
301 static int zcrypt_open(struct inode *inode, struct file *filp)
303 atomic_inc(&zcrypt_open_count);
308 * zcrypt_release(): Count number of users.
310 * Device close function to count number of users.
312 static int zcrypt_release(struct inode *inode, struct file *filp)
314 atomic_dec(&zcrypt_open_count);
321 static long zcrypt_rsa_modexpo(struct ica_rsa_modexpo *mex)
323 struct zcrypt_device *zdev;
326 if (mex->outputdatalength < mex->inputdatalength)
329 * As long as outputdatalength is big enough, we can set the
330 * outputdatalength equal to the inputdatalength, since that is the
331 * number of bytes we will copy in any case
333 mex->outputdatalength = mex->inputdatalength;
335 spin_lock_bh(&zcrypt_device_lock);
336 list_for_each_entry(zdev, &zcrypt_device_list, list) {
338 !zdev->ops->rsa_modexpo ||
339 zdev->min_mod_size > mex->inputdatalength ||
340 zdev->max_mod_size < mex->inputdatalength)
342 zcrypt_device_get(zdev);
343 get_device(&zdev->ap_dev->device);
344 zdev->request_count++;
345 __zcrypt_decrease_preference(zdev);
346 if (try_module_get(zdev->ap_dev->drv->driver.owner)) {
347 spin_unlock_bh(&zcrypt_device_lock);
348 rc = zdev->ops->rsa_modexpo(zdev, mex);
349 spin_lock_bh(&zcrypt_device_lock);
350 module_put(zdev->ap_dev->drv->driver.owner);
354 zdev->request_count--;
355 __zcrypt_increase_preference(zdev);
356 put_device(&zdev->ap_dev->device);
357 zcrypt_device_put(zdev);
358 spin_unlock_bh(&zcrypt_device_lock);
361 spin_unlock_bh(&zcrypt_device_lock);
365 static long zcrypt_rsa_crt(struct ica_rsa_modexpo_crt *crt)
367 struct zcrypt_device *zdev;
368 unsigned long long z1, z2, z3;
371 if (crt->outputdatalength < crt->inputdatalength ||
372 (crt->inputdatalength & 1))
375 * As long as outputdatalength is big enough, we can set the
376 * outputdatalength equal to the inputdatalength, since that is the
377 * number of bytes we will copy in any case
379 crt->outputdatalength = crt->inputdatalength;
383 spin_lock_bh(&zcrypt_device_lock);
384 list_for_each_entry(zdev, &zcrypt_device_list, list) {
386 !zdev->ops->rsa_modexpo_crt ||
387 zdev->min_mod_size > crt->inputdatalength ||
388 zdev->max_mod_size < crt->inputdatalength)
390 if (zdev->short_crt && crt->inputdatalength > 240) {
392 * Check inputdata for leading zeros for cards
393 * that can't handle np_prime, bp_key, or
394 * u_mult_inv > 128 bytes.
398 spin_unlock_bh(&zcrypt_device_lock);
399 /* len is max 256 / 2 - 120 = 8 */
400 len = crt->inputdatalength / 2 - 120;
401 if (len > sizeof(z1))
404 if (copy_from_user(&z1, crt->np_prime, len) ||
405 copy_from_user(&z2, crt->bp_key, len) ||
406 copy_from_user(&z3, crt->u_mult_inv, len))
410 * We have to restart device lookup -
411 * the device list may have changed by now.
415 if (z1 != 0ULL || z2 != 0ULL || z3 != 0ULL)
416 /* The device can't handle this request. */
419 zcrypt_device_get(zdev);
420 get_device(&zdev->ap_dev->device);
421 zdev->request_count++;
422 __zcrypt_decrease_preference(zdev);
423 if (try_module_get(zdev->ap_dev->drv->driver.owner)) {
424 spin_unlock_bh(&zcrypt_device_lock);
425 rc = zdev->ops->rsa_modexpo_crt(zdev, crt);
426 spin_lock_bh(&zcrypt_device_lock);
427 module_put(zdev->ap_dev->drv->driver.owner);
431 zdev->request_count--;
432 __zcrypt_increase_preference(zdev);
433 put_device(&zdev->ap_dev->device);
434 zcrypt_device_put(zdev);
435 spin_unlock_bh(&zcrypt_device_lock);
438 spin_unlock_bh(&zcrypt_device_lock);
442 static long zcrypt_send_cprb(struct ica_xcRB *xcRB)
444 struct zcrypt_device *zdev;
447 spin_lock_bh(&zcrypt_device_lock);
448 list_for_each_entry(zdev, &zcrypt_device_list, list) {
449 if (!zdev->online || !zdev->ops->send_cprb ||
450 (xcRB->user_defined != AUTOSELECT &&
451 AP_QID_DEVICE(zdev->ap_dev->qid) != xcRB->user_defined)
454 zcrypt_device_get(zdev);
455 get_device(&zdev->ap_dev->device);
456 zdev->request_count++;
457 __zcrypt_decrease_preference(zdev);
458 if (try_module_get(zdev->ap_dev->drv->driver.owner)) {
459 spin_unlock_bh(&zcrypt_device_lock);
460 rc = zdev->ops->send_cprb(zdev, xcRB);
461 spin_lock_bh(&zcrypt_device_lock);
462 module_put(zdev->ap_dev->drv->driver.owner);
466 zdev->request_count--;
467 __zcrypt_increase_preference(zdev);
468 put_device(&zdev->ap_dev->device);
469 zcrypt_device_put(zdev);
470 spin_unlock_bh(&zcrypt_device_lock);
473 spin_unlock_bh(&zcrypt_device_lock);
477 static long zcrypt_rng(char *buffer)
479 struct zcrypt_device *zdev;
482 spin_lock_bh(&zcrypt_device_lock);
483 list_for_each_entry(zdev, &zcrypt_device_list, list) {
484 if (!zdev->online || !zdev->ops->rng)
486 zcrypt_device_get(zdev);
487 get_device(&zdev->ap_dev->device);
488 zdev->request_count++;
489 __zcrypt_decrease_preference(zdev);
490 if (try_module_get(zdev->ap_dev->drv->driver.owner)) {
491 spin_unlock_bh(&zcrypt_device_lock);
492 rc = zdev->ops->rng(zdev, buffer);
493 spin_lock_bh(&zcrypt_device_lock);
494 module_put(zdev->ap_dev->drv->driver.owner);
497 zdev->request_count--;
498 __zcrypt_increase_preference(zdev);
499 put_device(&zdev->ap_dev->device);
500 zcrypt_device_put(zdev);
501 spin_unlock_bh(&zcrypt_device_lock);
504 spin_unlock_bh(&zcrypt_device_lock);
508 static void zcrypt_status_mask(char status[AP_DEVICES])
510 struct zcrypt_device *zdev;
512 memset(status, 0, sizeof(char) * AP_DEVICES);
513 spin_lock_bh(&zcrypt_device_lock);
514 list_for_each_entry(zdev, &zcrypt_device_list, list)
515 status[AP_QID_DEVICE(zdev->ap_dev->qid)] =
516 zdev->online ? zdev->user_space_type : 0x0d;
517 spin_unlock_bh(&zcrypt_device_lock);
520 static void zcrypt_qdepth_mask(char qdepth[AP_DEVICES])
522 struct zcrypt_device *zdev;
524 memset(qdepth, 0, sizeof(char) * AP_DEVICES);
525 spin_lock_bh(&zcrypt_device_lock);
526 list_for_each_entry(zdev, &zcrypt_device_list, list) {
527 spin_lock(&zdev->ap_dev->lock);
528 qdepth[AP_QID_DEVICE(zdev->ap_dev->qid)] =
529 zdev->ap_dev->pendingq_count +
530 zdev->ap_dev->requestq_count;
531 spin_unlock(&zdev->ap_dev->lock);
533 spin_unlock_bh(&zcrypt_device_lock);
536 static void zcrypt_perdev_reqcnt(int reqcnt[AP_DEVICES])
538 struct zcrypt_device *zdev;
540 memset(reqcnt, 0, sizeof(int) * AP_DEVICES);
541 spin_lock_bh(&zcrypt_device_lock);
542 list_for_each_entry(zdev, &zcrypt_device_list, list) {
543 spin_lock(&zdev->ap_dev->lock);
544 reqcnt[AP_QID_DEVICE(zdev->ap_dev->qid)] =
545 zdev->ap_dev->total_request_count;
546 spin_unlock(&zdev->ap_dev->lock);
548 spin_unlock_bh(&zcrypt_device_lock);
551 static int zcrypt_pendingq_count(void)
553 struct zcrypt_device *zdev;
554 int pendingq_count = 0;
556 spin_lock_bh(&zcrypt_device_lock);
557 list_for_each_entry(zdev, &zcrypt_device_list, list) {
558 spin_lock(&zdev->ap_dev->lock);
559 pendingq_count += zdev->ap_dev->pendingq_count;
560 spin_unlock(&zdev->ap_dev->lock);
562 spin_unlock_bh(&zcrypt_device_lock);
563 return pendingq_count;
566 static int zcrypt_requestq_count(void)
568 struct zcrypt_device *zdev;
569 int requestq_count = 0;
571 spin_lock_bh(&zcrypt_device_lock);
572 list_for_each_entry(zdev, &zcrypt_device_list, list) {
573 spin_lock(&zdev->ap_dev->lock);
574 requestq_count += zdev->ap_dev->requestq_count;
575 spin_unlock(&zdev->ap_dev->lock);
577 spin_unlock_bh(&zcrypt_device_lock);
578 return requestq_count;
581 static int zcrypt_count_type(int type)
583 struct zcrypt_device *zdev;
584 int device_count = 0;
586 spin_lock_bh(&zcrypt_device_lock);
587 list_for_each_entry(zdev, &zcrypt_device_list, list)
588 if (zdev->user_space_type == type)
590 spin_unlock_bh(&zcrypt_device_lock);
595 * zcrypt_ica_status(): Old, depracted combi status call.
597 * Old, deprecated combi status call.
599 static long zcrypt_ica_status(struct file *filp, unsigned long arg)
601 struct ica_z90_status *pstat;
604 pstat = kzalloc(sizeof(*pstat), GFP_KERNEL);
607 pstat->totalcount = zcrypt_device_count;
608 pstat->leedslitecount = zcrypt_count_type(ZCRYPT_PCICA);
609 pstat->leeds2count = zcrypt_count_type(ZCRYPT_PCICC);
610 pstat->requestqWaitCount = zcrypt_requestq_count();
611 pstat->pendingqWaitCount = zcrypt_pendingq_count();
612 pstat->totalOpenCount = atomic_read(&zcrypt_open_count);
613 pstat->cryptoDomain = ap_domain_index;
614 zcrypt_status_mask(pstat->status);
615 zcrypt_qdepth_mask(pstat->qdepth);
617 if (copy_to_user((void __user *) arg, pstat, sizeof(*pstat)))
623 static long zcrypt_unlocked_ioctl(struct file *filp, unsigned int cmd,
629 case ICARSAMODEXPO: {
630 struct ica_rsa_modexpo __user *umex = (void __user *) arg;
631 struct ica_rsa_modexpo mex;
632 if (copy_from_user(&mex, umex, sizeof(mex)))
635 rc = zcrypt_rsa_modexpo(&mex);
636 } while (rc == -EAGAIN);
639 return put_user(mex.outputdatalength, &umex->outputdatalength);
642 struct ica_rsa_modexpo_crt __user *ucrt = (void __user *) arg;
643 struct ica_rsa_modexpo_crt crt;
644 if (copy_from_user(&crt, ucrt, sizeof(crt)))
647 rc = zcrypt_rsa_crt(&crt);
648 } while (rc == -EAGAIN);
651 return put_user(crt.outputdatalength, &ucrt->outputdatalength);
654 struct ica_xcRB __user *uxcRB = (void __user *) arg;
655 struct ica_xcRB xcRB;
656 if (copy_from_user(&xcRB, uxcRB, sizeof(xcRB)))
659 rc = zcrypt_send_cprb(&xcRB);
660 } while (rc == -EAGAIN);
661 if (copy_to_user(uxcRB, &xcRB, sizeof(xcRB)))
665 case Z90STAT_STATUS_MASK: {
666 char status[AP_DEVICES];
667 zcrypt_status_mask(status);
668 if (copy_to_user((char __user *) arg, status,
669 sizeof(char) * AP_DEVICES))
673 case Z90STAT_QDEPTH_MASK: {
674 char qdepth[AP_DEVICES];
675 zcrypt_qdepth_mask(qdepth);
676 if (copy_to_user((char __user *) arg, qdepth,
677 sizeof(char) * AP_DEVICES))
681 case Z90STAT_PERDEV_REQCNT: {
682 int reqcnt[AP_DEVICES];
683 zcrypt_perdev_reqcnt(reqcnt);
684 if (copy_to_user((int __user *) arg, reqcnt,
685 sizeof(int) * AP_DEVICES))
689 case Z90STAT_REQUESTQ_COUNT:
690 return put_user(zcrypt_requestq_count(), (int __user *) arg);
691 case Z90STAT_PENDINGQ_COUNT:
692 return put_user(zcrypt_pendingq_count(), (int __user *) arg);
693 case Z90STAT_TOTALOPEN_COUNT:
694 return put_user(atomic_read(&zcrypt_open_count),
696 case Z90STAT_DOMAIN_INDEX:
697 return put_user(ap_domain_index, (int __user *) arg);
699 * Deprecated ioctls. Don't add another device count ioctl,
700 * you can count them yourself in the user space with the
701 * output of the Z90STAT_STATUS_MASK ioctl.
704 return zcrypt_ica_status(filp, arg);
705 case Z90STAT_TOTALCOUNT:
706 return put_user(zcrypt_device_count, (int __user *) arg);
707 case Z90STAT_PCICACOUNT:
708 return put_user(zcrypt_count_type(ZCRYPT_PCICA),
710 case Z90STAT_PCICCCOUNT:
711 return put_user(zcrypt_count_type(ZCRYPT_PCICC),
713 case Z90STAT_PCIXCCMCL2COUNT:
714 return put_user(zcrypt_count_type(ZCRYPT_PCIXCC_MCL2),
716 case Z90STAT_PCIXCCMCL3COUNT:
717 return put_user(zcrypt_count_type(ZCRYPT_PCIXCC_MCL3),
719 case Z90STAT_PCIXCCCOUNT:
720 return put_user(zcrypt_count_type(ZCRYPT_PCIXCC_MCL2) +
721 zcrypt_count_type(ZCRYPT_PCIXCC_MCL3),
723 case Z90STAT_CEX2CCOUNT:
724 return put_user(zcrypt_count_type(ZCRYPT_CEX2C),
726 case Z90STAT_CEX2ACOUNT:
727 return put_user(zcrypt_count_type(ZCRYPT_CEX2A),
730 /* unknown ioctl number */
737 * ioctl32 conversion routines
739 struct compat_ica_rsa_modexpo {
740 compat_uptr_t inputdata;
741 unsigned int inputdatalength;
742 compat_uptr_t outputdata;
743 unsigned int outputdatalength;
745 compat_uptr_t n_modulus;
748 static long trans_modexpo32(struct file *filp, unsigned int cmd,
751 struct compat_ica_rsa_modexpo __user *umex32 = compat_ptr(arg);
752 struct compat_ica_rsa_modexpo mex32;
753 struct ica_rsa_modexpo mex64;
756 if (copy_from_user(&mex32, umex32, sizeof(mex32)))
758 mex64.inputdata = compat_ptr(mex32.inputdata);
759 mex64.inputdatalength = mex32.inputdatalength;
760 mex64.outputdata = compat_ptr(mex32.outputdata);
761 mex64.outputdatalength = mex32.outputdatalength;
762 mex64.b_key = compat_ptr(mex32.b_key);
763 mex64.n_modulus = compat_ptr(mex32.n_modulus);
765 rc = zcrypt_rsa_modexpo(&mex64);
766 } while (rc == -EAGAIN);
768 rc = put_user(mex64.outputdatalength,
769 &umex32->outputdatalength);
773 struct compat_ica_rsa_modexpo_crt {
774 compat_uptr_t inputdata;
775 unsigned int inputdatalength;
776 compat_uptr_t outputdata;
777 unsigned int outputdatalength;
778 compat_uptr_t bp_key;
779 compat_uptr_t bq_key;
780 compat_uptr_t np_prime;
781 compat_uptr_t nq_prime;
782 compat_uptr_t u_mult_inv;
785 static long trans_modexpo_crt32(struct file *filp, unsigned int cmd,
788 struct compat_ica_rsa_modexpo_crt __user *ucrt32 = compat_ptr(arg);
789 struct compat_ica_rsa_modexpo_crt crt32;
790 struct ica_rsa_modexpo_crt crt64;
793 if (copy_from_user(&crt32, ucrt32, sizeof(crt32)))
795 crt64.inputdata = compat_ptr(crt32.inputdata);
796 crt64.inputdatalength = crt32.inputdatalength;
797 crt64.outputdata= compat_ptr(crt32.outputdata);
798 crt64.outputdatalength = crt32.outputdatalength;
799 crt64.bp_key = compat_ptr(crt32.bp_key);
800 crt64.bq_key = compat_ptr(crt32.bq_key);
801 crt64.np_prime = compat_ptr(crt32.np_prime);
802 crt64.nq_prime = compat_ptr(crt32.nq_prime);
803 crt64.u_mult_inv = compat_ptr(crt32.u_mult_inv);
805 rc = zcrypt_rsa_crt(&crt64);
806 } while (rc == -EAGAIN);
808 rc = put_user(crt64.outputdatalength,
809 &ucrt32->outputdatalength);
813 struct compat_ica_xcRB {
814 unsigned short agent_ID;
815 unsigned int user_defined;
816 unsigned short request_ID;
817 unsigned int request_control_blk_length;
818 unsigned char padding1[16 - sizeof (compat_uptr_t)];
819 compat_uptr_t request_control_blk_addr;
820 unsigned int request_data_length;
821 char padding2[16 - sizeof (compat_uptr_t)];
822 compat_uptr_t request_data_address;
823 unsigned int reply_control_blk_length;
824 char padding3[16 - sizeof (compat_uptr_t)];
825 compat_uptr_t reply_control_blk_addr;
826 unsigned int reply_data_length;
827 char padding4[16 - sizeof (compat_uptr_t)];
828 compat_uptr_t reply_data_addr;
829 unsigned short priority_window;
831 } __attribute__((packed));
833 static long trans_xcRB32(struct file *filp, unsigned int cmd,
836 struct compat_ica_xcRB __user *uxcRB32 = compat_ptr(arg);
837 struct compat_ica_xcRB xcRB32;
838 struct ica_xcRB xcRB64;
841 if (copy_from_user(&xcRB32, uxcRB32, sizeof(xcRB32)))
843 xcRB64.agent_ID = xcRB32.agent_ID;
844 xcRB64.user_defined = xcRB32.user_defined;
845 xcRB64.request_ID = xcRB32.request_ID;
846 xcRB64.request_control_blk_length =
847 xcRB32.request_control_blk_length;
848 xcRB64.request_control_blk_addr =
849 compat_ptr(xcRB32.request_control_blk_addr);
850 xcRB64.request_data_length =
851 xcRB32.request_data_length;
852 xcRB64.request_data_address =
853 compat_ptr(xcRB32.request_data_address);
854 xcRB64.reply_control_blk_length =
855 xcRB32.reply_control_blk_length;
856 xcRB64.reply_control_blk_addr =
857 compat_ptr(xcRB32.reply_control_blk_addr);
858 xcRB64.reply_data_length = xcRB32.reply_data_length;
859 xcRB64.reply_data_addr =
860 compat_ptr(xcRB32.reply_data_addr);
861 xcRB64.priority_window = xcRB32.priority_window;
862 xcRB64.status = xcRB32.status;
864 rc = zcrypt_send_cprb(&xcRB64);
865 } while (rc == -EAGAIN);
866 xcRB32.reply_control_blk_length = xcRB64.reply_control_blk_length;
867 xcRB32.reply_data_length = xcRB64.reply_data_length;
868 xcRB32.status = xcRB64.status;
869 if (copy_to_user(uxcRB32, &xcRB32, sizeof(xcRB32)))
874 static long zcrypt_compat_ioctl(struct file *filp, unsigned int cmd,
877 if (cmd == ICARSAMODEXPO)
878 return trans_modexpo32(filp, cmd, arg);
879 if (cmd == ICARSACRT)
880 return trans_modexpo_crt32(filp, cmd, arg);
881 if (cmd == ZSECSENDCPRB)
882 return trans_xcRB32(filp, cmd, arg);
883 return zcrypt_unlocked_ioctl(filp, cmd, arg);
888 * Misc device file operations.
890 static const struct file_operations zcrypt_fops = {
891 .owner = THIS_MODULE,
893 .write = zcrypt_write,
894 .unlocked_ioctl = zcrypt_unlocked_ioctl,
896 .compat_ioctl = zcrypt_compat_ioctl,
899 .release = zcrypt_release
905 static struct miscdevice zcrypt_misc_device = {
906 .minor = MISC_DYNAMIC_MINOR,
908 .fops = &zcrypt_fops,
912 * Deprecated /proc entry support.
914 static struct proc_dir_entry *zcrypt_entry;
916 static void sprintcl(struct seq_file *m, unsigned char *addr, unsigned int len)
920 for (i = 0; i < len; i++)
921 seq_printf(m, "%01x", (unsigned int) addr[i]);
925 static void sprintrw(struct seq_file *m, unsigned char *addr, unsigned int len)
931 for (c = 0; c < (len / 16); c++) {
932 sprintcl(m, addr+inl, 16);
937 sprintcl(m, addr+inl, cx);
943 static void sprinthx(unsigned char *title, struct seq_file *m,
944 unsigned char *addr, unsigned int len)
948 seq_printf(m, "\n%s\n", title);
950 for (r = 0; r < (len / 64); r++) {
951 sprintrw(m, addr+inl, 64);
956 sprintrw(m, addr+inl, rx);
962 static void sprinthx4(unsigned char *title, struct seq_file *m,
963 unsigned int *array, unsigned int len)
967 seq_printf(m, "\n%s\n", title);
968 for (r = 0; r < len; r++) {
971 seq_printf(m, "%08X ", array[r]);
978 static int zcrypt_proc_show(struct seq_file *m, void *v)
980 char workarea[sizeof(int) * AP_DEVICES];
982 seq_printf(m, "\nzcrypt version: %d.%d.%d\n",
983 ZCRYPT_VERSION, ZCRYPT_RELEASE, ZCRYPT_VARIANT);
984 seq_printf(m, "Cryptographic domain: %d\n", ap_domain_index);
985 seq_printf(m, "Total device count: %d\n", zcrypt_device_count);
986 seq_printf(m, "PCICA count: %d\n", zcrypt_count_type(ZCRYPT_PCICA));
987 seq_printf(m, "PCICC count: %d\n", zcrypt_count_type(ZCRYPT_PCICC));
988 seq_printf(m, "PCIXCC MCL2 count: %d\n",
989 zcrypt_count_type(ZCRYPT_PCIXCC_MCL2));
990 seq_printf(m, "PCIXCC MCL3 count: %d\n",
991 zcrypt_count_type(ZCRYPT_PCIXCC_MCL3));
992 seq_printf(m, "CEX2C count: %d\n", zcrypt_count_type(ZCRYPT_CEX2C));
993 seq_printf(m, "CEX2A count: %d\n", zcrypt_count_type(ZCRYPT_CEX2A));
994 seq_printf(m, "CEX3C count: %d\n", zcrypt_count_type(ZCRYPT_CEX3C));
995 seq_printf(m, "CEX3A count: %d\n", zcrypt_count_type(ZCRYPT_CEX3A));
996 seq_printf(m, "requestq count: %d\n", zcrypt_requestq_count());
997 seq_printf(m, "pendingq count: %d\n", zcrypt_pendingq_count());
998 seq_printf(m, "Total open handles: %d\n\n",
999 atomic_read(&zcrypt_open_count));
1000 zcrypt_status_mask(workarea);
1001 sprinthx("Online devices: 1=PCICA 2=PCICC 3=PCIXCC(MCL2) "
1002 "4=PCIXCC(MCL3) 5=CEX2C 6=CEX2A 7=CEX3C 8=CEX3A",
1003 m, workarea, AP_DEVICES);
1004 zcrypt_qdepth_mask(workarea);
1005 sprinthx("Waiting work element counts", m, workarea, AP_DEVICES);
1006 zcrypt_perdev_reqcnt((int *) workarea);
1007 sprinthx4("Per-device successfully completed request counts",
1008 m, (unsigned int *) workarea, AP_DEVICES);
1012 static int zcrypt_proc_open(struct inode *inode, struct file *file)
1014 return single_open(file, zcrypt_proc_show, NULL);
1017 static void zcrypt_disable_card(int index)
1019 struct zcrypt_device *zdev;
1021 spin_lock_bh(&zcrypt_device_lock);
1022 list_for_each_entry(zdev, &zcrypt_device_list, list)
1023 if (AP_QID_DEVICE(zdev->ap_dev->qid) == index) {
1025 ap_flush_queue(zdev->ap_dev);
1028 spin_unlock_bh(&zcrypt_device_lock);
1031 static void zcrypt_enable_card(int index)
1033 struct zcrypt_device *zdev;
1035 spin_lock_bh(&zcrypt_device_lock);
1036 list_for_each_entry(zdev, &zcrypt_device_list, list)
1037 if (AP_QID_DEVICE(zdev->ap_dev->qid) == index) {
1041 spin_unlock_bh(&zcrypt_device_lock);
1044 static ssize_t zcrypt_proc_write(struct file *file, const char __user *buffer,
1045 size_t count, loff_t *pos)
1047 unsigned char *lbuf, *ptr;
1054 #define LBUFSIZE 1200UL
1055 lbuf = kmalloc(LBUFSIZE, GFP_KERNEL);
1059 local_count = min(LBUFSIZE - 1, count);
1060 if (copy_from_user(lbuf, buffer, local_count) != 0) {
1064 lbuf[local_count] = '\0';
1066 ptr = strstr(lbuf, "Online devices");
1069 ptr = strstr(ptr, "\n");
1074 if (strstr(ptr, "Waiting work element counts") == NULL)
1077 for (j = 0; j < 64 && *ptr; ptr++) {
1079 * '0' for no device, '1' for PCICA, '2' for PCICC,
1080 * '3' for PCIXCC_MCL2, '4' for PCIXCC_MCL3,
1081 * '5' for CEX2C and '6' for CEX2A'
1082 * '7' for CEX3C and '8' for CEX3A
1084 if (*ptr >= '0' && *ptr <= '8')
1086 else if (*ptr == 'd' || *ptr == 'D')
1087 zcrypt_disable_card(j++);
1088 else if (*ptr == 'e' || *ptr == 'E')
1089 zcrypt_enable_card(j++);
1090 else if (*ptr != ' ' && *ptr != '\t')
1098 static const struct file_operations zcrypt_proc_fops = {
1099 .owner = THIS_MODULE,
1100 .open = zcrypt_proc_open,
1102 .llseek = seq_lseek,
1103 .release = single_release,
1104 .write = zcrypt_proc_write,
1107 static int zcrypt_rng_device_count;
1108 static u32 *zcrypt_rng_buffer;
1109 static int zcrypt_rng_buffer_index;
1110 static DEFINE_MUTEX(zcrypt_rng_mutex);
1112 static int zcrypt_rng_data_read(struct hwrng *rng, u32 *data)
1117 * We don't need locking here because the RNG API guarantees serialized
1118 * read method calls.
1120 if (zcrypt_rng_buffer_index == 0) {
1121 rc = zcrypt_rng((char *) zcrypt_rng_buffer);
1124 zcrypt_rng_buffer_index = rc / sizeof *data;
1126 *data = zcrypt_rng_buffer[--zcrypt_rng_buffer_index];
1127 return sizeof *data;
1130 static struct hwrng zcrypt_rng_dev = {
1132 .data_read = zcrypt_rng_data_read,
1135 static int zcrypt_rng_device_add(void)
1139 mutex_lock(&zcrypt_rng_mutex);
1140 if (zcrypt_rng_device_count == 0) {
1141 zcrypt_rng_buffer = (u32 *) get_zeroed_page(GFP_KERNEL);
1142 if (!zcrypt_rng_buffer) {
1146 zcrypt_rng_buffer_index = 0;
1147 rc = hwrng_register(&zcrypt_rng_dev);
1150 zcrypt_rng_device_count = 1;
1152 zcrypt_rng_device_count++;
1153 mutex_unlock(&zcrypt_rng_mutex);
1157 free_page((unsigned long) zcrypt_rng_buffer);
1159 mutex_unlock(&zcrypt_rng_mutex);
1163 static void zcrypt_rng_device_remove(void)
1165 mutex_lock(&zcrypt_rng_mutex);
1166 zcrypt_rng_device_count--;
1167 if (zcrypt_rng_device_count == 0) {
1168 hwrng_unregister(&zcrypt_rng_dev);
1169 free_page((unsigned long) zcrypt_rng_buffer);
1171 mutex_unlock(&zcrypt_rng_mutex);
1175 * zcrypt_api_init(): Module initialization.
1177 * The module initialization code.
1179 int __init zcrypt_api_init(void)
1183 /* Register the request sprayer. */
1184 rc = misc_register(&zcrypt_misc_device);
1188 /* Set up the proc file system */
1189 zcrypt_entry = proc_create("driver/z90crypt", 0644, NULL, &zcrypt_proc_fops);
1190 if (!zcrypt_entry) {
1198 misc_deregister(&zcrypt_misc_device);
1204 * zcrypt_api_exit(): Module termination.
1206 * The module termination code.
1208 void zcrypt_api_exit(void)
1210 remove_proc_entry("driver/z90crypt", NULL);
1211 misc_deregister(&zcrypt_misc_device);
1214 #ifndef CONFIG_ZCRYPT_MONOLITHIC
1215 module_init(zcrypt_api_init);
1216 module_exit(zcrypt_api_exit);