Pileus Git - ~andy/linux/blob - drivers/s390/crypto/zcrypt_api.c

   1 /*
   2  *  zcrypt 2.1.0
   3  *
   4  *  Copyright IBM Corp. 2001, 2012
   5  *  Author(s): Robert Burroughs
   6  *             Eric Rossman (edrossma@us.ibm.com)
   7  *             Cornelia Huck <cornelia.huck@de.ibm.com>
   8  *
   9  *  Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
  10  *  Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>
  11  *                                Ralph Wuerthner <rwuerthn@de.ibm.com>
  12  *  MSGTYPE restruct:             Holger Dengler <hd@linux.vnet.ibm.com>
  13  *
  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)
  17  * any later version.
  18  *
  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.
  23  *
  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.
  27  */
  28
  29 #include <linux/module.h>
  30 #include <linux/init.h>
  31 #include <linux/interrupt.h>
  32 #include <linux/miscdevice.h>
  33 #include <linux/fs.h>
  34 #include <linux/proc_fs.h>
  35 #include <linux/seq_file.h>
  36 #include <linux/compat.h>
  37 #include <linux/slab.h>
  38 #include <linux/atomic.h>
  39 #include <asm/uaccess.h>
  40 #include <linux/hw_random.h>
  41 #include <linux/debugfs.h>
  42 #include <asm/debug.h>
  43
  44 #include "zcrypt_debug.h"
  45 #include "zcrypt_api.h"
  46
  47 /*
  48  * Module description.
  49  */
  50 MODULE_AUTHOR("IBM Corporation");
  51 MODULE_DESCRIPTION("Cryptographic Coprocessor interface, " \
  52                    "Copyright IBM Corp. 2001, 2012");
  53 MODULE_LICENSE("GPL");
  54
  55 static DEFINE_SPINLOCK(zcrypt_device_lock);
  56 static LIST_HEAD(zcrypt_device_list);
  57 static int zcrypt_device_count = 0;
  58 static atomic_t zcrypt_open_count = ATOMIC_INIT(0);
  59 static atomic_t zcrypt_rescan_count = ATOMIC_INIT(0);
  60
  61 atomic_t zcrypt_rescan_req = ATOMIC_INIT(0);
  62 EXPORT_SYMBOL(zcrypt_rescan_req);
  63
  64 static int zcrypt_rng_device_add(void);
  65 static void zcrypt_rng_device_remove(void);
  66
  67 static DEFINE_SPINLOCK(zcrypt_ops_list_lock);
  68 static LIST_HEAD(zcrypt_ops_list);
  69
  70 static debug_info_t *zcrypt_dbf_common;
  71 static debug_info_t *zcrypt_dbf_devices;
  72 static struct dentry *debugfs_root;
  73
  74 /*
  75  * Device attributes common for all crypto devices.
  76  */
  77 static ssize_t zcrypt_type_show(struct device *dev,
  78                                 struct device_attribute *attr, char *buf)
  79 {
  80         struct zcrypt_device *zdev = to_ap_dev(dev)->private;
  81         return snprintf(buf, PAGE_SIZE, "%s\n", zdev->type_string);
  82 }
  83
  84 static DEVICE_ATTR(type, 0444, zcrypt_type_show, NULL);
  85
  86 static ssize_t zcrypt_online_show(struct device *dev,
  87                                   struct device_attribute *attr, char *buf)
  88 {
  89         struct zcrypt_device *zdev = to_ap_dev(dev)->private;
  90         return snprintf(buf, PAGE_SIZE, "%d\n", zdev->online);
  91 }
  92
  93 static ssize_t zcrypt_online_store(struct device *dev,
  94                                    struct device_attribute *attr,
  95                                    const char *buf, size_t count)
  96 {
  97         struct zcrypt_device *zdev = to_ap_dev(dev)->private;
  98         int online;
  99
 100         if (sscanf(buf, "%d\n", &online) != 1 || online < 0 || online > 1)
 101                 return -EINVAL;
 102         zdev->online = online;
 103         ZCRYPT_DBF_DEV(DBF_INFO, zdev, "dev%04xo%dman", zdev->ap_dev->qid,
 104                        zdev->online);
 105         if (!online)
 106                 ap_flush_queue(zdev->ap_dev);
 107         return count;
 108 }
 109
 110 static DEVICE_ATTR(online, 0644, zcrypt_online_show, zcrypt_online_store);
 111
 112 static struct attribute * zcrypt_device_attrs[] = {
 113         &dev_attr_type.attr,
 114         &dev_attr_online.attr,
 115         NULL,
 116 };
 117
 118 static struct attribute_group zcrypt_device_attr_group = {
 119         .attrs = zcrypt_device_attrs,
 120 };
 121
 122 /**
 123  * Process a rescan of the transport layer.
 124  *
 125  * Returns 1, if the rescan has been processed, otherwise 0.
 126  */
 127 static inline int zcrypt_process_rescan(void)
 128 {
 129         if (atomic_read(&zcrypt_rescan_req)) {
 130                 atomic_set(&zcrypt_rescan_req, 0);
 131                 atomic_inc(&zcrypt_rescan_count);
 132                 ap_bus_force_rescan();
 133                 ZCRYPT_DBF_COMMON(DBF_INFO, "rescan%07d",
 134                                   atomic_inc_return(&zcrypt_rescan_count));
 135                 return 1;
 136         }
 137         return 0;
 138 }
 139
 140 /**
 141  * __zcrypt_increase_preference(): Increase preference of a crypto device.
 142  * @zdev: Pointer the crypto device
 143  *
 144  * Move the device towards the head of the device list.
 145  * Need to be called while holding the zcrypt device list lock.
 146  * Note: cards with speed_rating of 0 are kept at the end of the list.
 147  */
 148 static void __zcrypt_increase_preference(struct zcrypt_device *zdev)
 149 {
 150         struct zcrypt_device *tmp;
 151         struct list_head *l;
 152
 153         if (zdev->speed_rating == 0)
 154                 return;
 155         for (l = zdev->list.prev; l != &zcrypt_device_list; l = l->prev) {
 156                 tmp = list_entry(l, struct zcrypt_device, list);
 157                 if ((tmp->request_count + 1) * tmp->speed_rating <=
 158                     (zdev->request_count + 1) * zdev->speed_rating &&
 159                     tmp->speed_rating != 0)
 160                         break;
 161         }
 162         if (l == zdev->list.prev)
 163                 return;
 164         /* Move zdev behind l */
 165         list_move(&zdev->list, l);
 166 }
 167
 168 /**
 169  * __zcrypt_decrease_preference(): Decrease preference of a crypto device.
 170  * @zdev: Pointer to a crypto device.
 171  *
 172  * Move the device towards the tail of the device list.
 173  * Need to be called while holding the zcrypt device list lock.
 174  * Note: cards with speed_rating of 0 are kept at the end of the list.
 175  */
 176 static void __zcrypt_decrease_preference(struct zcrypt_device *zdev)
 177 {
 178         struct zcrypt_device *tmp;
 179         struct list_head *l;
 180
 181         if (zdev->speed_rating == 0)
 182                 return;
 183         for (l = zdev->list.next; l != &zcrypt_device_list; l = l->next) {
 184                 tmp = list_entry(l, struct zcrypt_device, list);
 185                 if ((tmp->request_count + 1) * tmp->speed_rating >
 186                     (zdev->request_count + 1) * zdev->speed_rating ||
 187                     tmp->speed_rating == 0)
 188                         break;
 189         }
 190         if (l == zdev->list.next)
 191                 return;
 192         /* Move zdev before l */
 193         list_move_tail(&zdev->list, l);
 194 }
 195
 196 static void zcrypt_device_release(struct kref *kref)
 197 {
 198         struct zcrypt_device *zdev =
 199                 container_of(kref, struct zcrypt_device, refcount);
 200         zcrypt_device_free(zdev);
 201 }
 202
 203 void zcrypt_device_get(struct zcrypt_device *zdev)
 204 {
 205         kref_get(&zdev->refcount);
 206 }
 207 EXPORT_SYMBOL(zcrypt_device_get);
 208
 209 int zcrypt_device_put(struct zcrypt_device *zdev)
 210 {
 211         return kref_put(&zdev->refcount, zcrypt_device_release);
 212 }
 213 EXPORT_SYMBOL(zcrypt_device_put);
 214
 215 struct zcrypt_device *zcrypt_device_alloc(size_t max_response_size)
 216 {
 217         struct zcrypt_device *zdev;
 218
 219         zdev = kzalloc(sizeof(struct zcrypt_device), GFP_KERNEL);
 220         if (!zdev)
 221                 return NULL;
 222         zdev->reply.message = kmalloc(max_response_size, GFP_KERNEL);
 223         if (!zdev->reply.message)
 224                 goto out_free;
 225         zdev->reply.length = max_response_size;
 226         spin_lock_init(&zdev->lock);
 227         INIT_LIST_HEAD(&zdev->list);
 228         zdev->dbf_area = zcrypt_dbf_devices;
 229         return zdev;
 230
 231 out_free:
 232         kfree(zdev);
 233         return NULL;
 234 }
 235 EXPORT_SYMBOL(zcrypt_device_alloc);
 236
 237 void zcrypt_device_free(struct zcrypt_device *zdev)
 238 {
 239         kfree(zdev->reply.message);
 240         kfree(zdev);
 241 }
 242 EXPORT_SYMBOL(zcrypt_device_free);
 243
 244 /**
 245  * zcrypt_device_register() - Register a crypto device.
 246  * @zdev: Pointer to a crypto device
 247  *
 248  * Register a crypto device. Returns 0 if successful.
 249  */
 250 int zcrypt_device_register(struct zcrypt_device *zdev)
 251 {
 252         int rc;
 253
 254         if (!zdev->ops)
 255                 return -ENODEV;
 256         rc = sysfs_create_group(&zdev->ap_dev->device.kobj,
 257                                 &zcrypt_device_attr_group);
 258         if (rc)
 259                 goto out;
 260         get_device(&zdev->ap_dev->device);
 261         kref_init(&zdev->refcount);
 262         spin_lock_bh(&zcrypt_device_lock);
 263         zdev->online = 1;       /* New devices are online by default. */
 264         ZCRYPT_DBF_DEV(DBF_INFO, zdev, "dev%04xo%dreg", zdev->ap_dev->qid,
 265                        zdev->online);
 266         list_add_tail(&zdev->list, &zcrypt_device_list);
 267         __zcrypt_increase_preference(zdev);
 268         zcrypt_device_count++;
 269         spin_unlock_bh(&zcrypt_device_lock);
 270         if (zdev->ops->rng) {
 271                 rc = zcrypt_rng_device_add();
 272                 if (rc)
 273                         goto out_unregister;
 274         }
 275         return 0;
 276
 277 out_unregister:
 278         spin_lock_bh(&zcrypt_device_lock);
 279         zcrypt_device_count--;
 280         list_del_init(&zdev->list);
 281         spin_unlock_bh(&zcrypt_device_lock);
 282         sysfs_remove_group(&zdev->ap_dev->device.kobj,
 283                            &zcrypt_device_attr_group);
 284         put_device(&zdev->ap_dev->device);
 285         zcrypt_device_put(zdev);
 286 out:
 287         return rc;
 288 }
 289 EXPORT_SYMBOL(zcrypt_device_register);
 290
 291 /**
 292  * zcrypt_device_unregister(): Unregister a crypto device.
 293  * @zdev: Pointer to crypto device
 294  *
 295  * Unregister a crypto device.
 296  */
 297 void zcrypt_device_unregister(struct zcrypt_device *zdev)
 298 {
 299         if (zdev->ops->rng)
 300                 zcrypt_rng_device_remove();
 301         spin_lock_bh(&zcrypt_device_lock);
 302         zcrypt_device_count--;
 303         list_del_init(&zdev->list);
 304         spin_unlock_bh(&zcrypt_device_lock);
 305         sysfs_remove_group(&zdev->ap_dev->device.kobj,
 306                            &zcrypt_device_attr_group);
 307         put_device(&zdev->ap_dev->device);
 308         zcrypt_device_put(zdev);
 309 }
 310 EXPORT_SYMBOL(zcrypt_device_unregister);
 311
 312 void zcrypt_msgtype_register(struct zcrypt_ops *zops)
 313 {
 314         if (zops->owner) {
 315                 spin_lock_bh(&zcrypt_ops_list_lock);
 316                 list_add_tail(&zops->list, &zcrypt_ops_list);
 317                 spin_unlock_bh(&zcrypt_ops_list_lock);
 318         }
 319 }
 320 EXPORT_SYMBOL(zcrypt_msgtype_register);
 321
 322 void zcrypt_msgtype_unregister(struct zcrypt_ops *zops)
 323 {
 324         spin_lock_bh(&zcrypt_ops_list_lock);
 325         list_del_init(&zops->list);
 326         spin_unlock_bh(&zcrypt_ops_list_lock);
 327 }
 328 EXPORT_SYMBOL(zcrypt_msgtype_unregister);
 329
 330 static inline
 331 struct zcrypt_ops *__ops_lookup(unsigned char *name, int variant)
 332 {
 333         struct zcrypt_ops *zops;
 334         int found = 0;
 335
 336         spin_lock_bh(&zcrypt_ops_list_lock);
 337         list_for_each_entry(zops, &zcrypt_ops_list, list) {
 338                 if ((zops->variant == variant) &&
 339                     (!strncmp(zops->owner->name, name, MODULE_NAME_LEN))) {
 340                         found = 1;
 341                         break;
 342                 }
 343         }
 344         spin_unlock_bh(&zcrypt_ops_list_lock);
 345
 346         if (!found)
 347                 return NULL;
 348         return zops;
 349 }
 350
 351 struct zcrypt_ops *zcrypt_msgtype_request(unsigned char *name, int variant)
 352 {
 353         struct zcrypt_ops *zops = NULL;
 354
 355         zops = __ops_lookup(name, variant);
 356         if (!zops) {
 357                 request_module(name);
 358                 zops = __ops_lookup(name, variant);
 359         }
 360         if ((!zops) || (!try_module_get(zops->owner)))
 361                 return NULL;
 362         return zops;
 363 }
 364 EXPORT_SYMBOL(zcrypt_msgtype_request);
 365
 366 void zcrypt_msgtype_release(struct zcrypt_ops *zops)
 367 {
 368         if (zops)
 369                 module_put(zops->owner);
 370 }
 371 EXPORT_SYMBOL(zcrypt_msgtype_release);
 372
 373 /**
 374  * zcrypt_read (): Not supported beyond zcrypt 1.3.1.
 375  *
 376  * This function is not supported beyond zcrypt 1.3.1.
 377  */
 378 static ssize_t zcrypt_read(struct file *filp, char __user *buf,
 379                            size_t count, loff_t *f_pos)
 380 {
 381         return -EPERM;
 382 }
 383
 384 /**
 385  * zcrypt_write(): Not allowed.
 386  *
 387  * Write is is not allowed
 388  */
 389 static ssize_t zcrypt_write(struct file *filp, const char __user *buf,
 390                             size_t count, loff_t *f_pos)
 391 {
 392         return -EPERM;
 393 }
 394
 395 /**
 396  * zcrypt_open(): Count number of users.
 397  *
 398  * Device open function to count number of users.
 399  */
 400 static int zcrypt_open(struct inode *inode, struct file *filp)
 401 {
 402         atomic_inc(&zcrypt_open_count);
 403         return nonseekable_open(inode, filp);
 404 }
 405
 406 /**
 407  * zcrypt_release(): Count number of users.
 408  *
 409  * Device close function to count number of users.
 410  */
 411 static int zcrypt_release(struct inode *inode, struct file *filp)
 412 {
 413         atomic_dec(&zcrypt_open_count);
 414         return 0;
 415 }
 416
 417 /*
 418  * zcrypt ioctls.
 419  */
 420 static long zcrypt_rsa_modexpo(struct ica_rsa_modexpo *mex)
 421 {
 422         struct zcrypt_device *zdev;
 423         int rc;
 424
 425         if (mex->outputdatalength < mex->inputdatalength)
 426                 return -EINVAL;
 427         /*
 428          * As long as outputdatalength is big enough, we can set the
 429          * outputdatalength equal to the inputdatalength, since that is the
 430          * number of bytes we will copy in any case
 431          */
 432         mex->outputdatalength = mex->inputdatalength;
 433
 434         spin_lock_bh(&zcrypt_device_lock);
 435         list_for_each_entry(zdev, &zcrypt_device_list, list) {
 436                 if (!zdev->online ||
 437                     !zdev->ops->rsa_modexpo ||
 438                     zdev->min_mod_size > mex->inputdatalength ||
 439                     zdev->max_mod_size < mex->inputdatalength)
 440                         continue;
 441                 zcrypt_device_get(zdev);
 442                 get_device(&zdev->ap_dev->device);
 443                 zdev->request_count++;
 444                 __zcrypt_decrease_preference(zdev);
 445                 if (try_module_get(zdev->ap_dev->drv->driver.owner)) {
 446                         spin_unlock_bh(&zcrypt_device_lock);
 447                         rc = zdev->ops->rsa_modexpo(zdev, mex);
 448                         spin_lock_bh(&zcrypt_device_lock);
 449                         module_put(zdev->ap_dev->drv->driver.owner);
 450                 }
 451                 else
 452                         rc = -EAGAIN;
 453                 zdev->request_count--;
 454                 __zcrypt_increase_preference(zdev);
 455                 put_device(&zdev->ap_dev->device);
 456                 zcrypt_device_put(zdev);
 457                 spin_unlock_bh(&zcrypt_device_lock);
 458                 return rc;
 459         }
 460         spin_unlock_bh(&zcrypt_device_lock);
 461         return -ENODEV;
 462 }
 463
 464 static long zcrypt_rsa_crt(struct ica_rsa_modexpo_crt *crt)
 465 {
 466         struct zcrypt_device *zdev;
 467         unsigned long long z1, z2, z3;
 468         int rc, copied;
 469
 470         if (crt->outputdatalength < crt->inputdatalength ||
 471             (crt->inputdatalength & 1))
 472                 return -EINVAL;
 473         /*
 474          * As long as outputdatalength is big enough, we can set the
 475          * outputdatalength equal to the inputdatalength, since that is the
 476          * number of bytes we will copy in any case
 477          */
 478         crt->outputdatalength = crt->inputdatalength;
 479
 480         copied = 0;
 481  restart:
 482         spin_lock_bh(&zcrypt_device_lock);
 483         list_for_each_entry(zdev, &zcrypt_device_list, list) {
 484                 if (!zdev->online ||
 485                     !zdev->ops->rsa_modexpo_crt ||
 486                     zdev->min_mod_size > crt->inputdatalength ||
 487                     zdev->max_mod_size < crt->inputdatalength)
 488                         continue;
 489                 if (zdev->short_crt && crt->inputdatalength > 240) {
 490                         /*
 491                          * Check inputdata for leading zeros for cards
 492                          * that can't handle np_prime, bp_key, or
 493                          * u_mult_inv > 128 bytes.
 494                          */
 495                         if (copied == 0) {
 496                                 unsigned int len;
 497                                 spin_unlock_bh(&zcrypt_device_lock);
 498                                 /* len is max 256 / 2 - 120 = 8
 499                                  * For bigger device just assume len of leading
 500                                  * 0s is 8 as stated in the requirements for
 501                                  * ica_rsa_modexpo_crt struct in zcrypt.h.
 502                                  */
 503                                 if (crt->inputdatalength <= 256)
 504                                         len = crt->inputdatalength / 2 - 120;
 505                                 else
 506                                         len = 8;
 507                                 if (len > sizeof(z1))
 508                                         return -EFAULT;
 509                                 z1 = z2 = z3 = 0;
 510                                 if (copy_from_user(&z1, crt->np_prime, len) ||
 511                                     copy_from_user(&z2, crt->bp_key, len) ||
 512                                     copy_from_user(&z3, crt->u_mult_inv, len))
 513                                         return -EFAULT;
 514                                 z1 = z2 = z3 = 0;
 515                                 copied = 1;
 516                                 /*
 517                                  * We have to restart device lookup -
 518                                  * the device list may have changed by now.
 519                                  */
 520                                 goto restart;
 521                         }
 522                         if (z1 != 0ULL || z2 != 0ULL || z3 != 0ULL)
 523                                 /* The device can't handle this request. */
 524                                 continue;
 525                 }
 526                 zcrypt_device_get(zdev);
 527                 get_device(&zdev->ap_dev->device);
 528                 zdev->request_count++;
 529                 __zcrypt_decrease_preference(zdev);
 530                 if (try_module_get(zdev->ap_dev->drv->driver.owner)) {
 531                         spin_unlock_bh(&zcrypt_device_lock);
 532                         rc = zdev->ops->rsa_modexpo_crt(zdev, crt);
 533                         spin_lock_bh(&zcrypt_device_lock);
 534                         module_put(zdev->ap_dev->drv->driver.owner);
 535                 }
 536                 else
 537                         rc = -EAGAIN;
 538                 zdev->request_count--;
 539                 __zcrypt_increase_preference(zdev);
 540                 put_device(&zdev->ap_dev->device);
 541                 zcrypt_device_put(zdev);
 542                 spin_unlock_bh(&zcrypt_device_lock);
 543                 return rc;
 544         }
 545         spin_unlock_bh(&zcrypt_device_lock);
 546         return -ENODEV;
 547 }
 548
 549 static long zcrypt_send_cprb(struct ica_xcRB *xcRB)
 550 {
 551         struct zcrypt_device *zdev;
 552         int rc;
 553
 554         spin_lock_bh(&zcrypt_device_lock);
 555         list_for_each_entry(zdev, &zcrypt_device_list, list) {
 556                 if (!zdev->online || !zdev->ops->send_cprb ||
 557                     (xcRB->user_defined != AUTOSELECT &&
 558                         AP_QID_DEVICE(zdev->ap_dev->qid) != xcRB->user_defined)
 559                     )
 560                         continue;
 561                 zcrypt_device_get(zdev);
 562                 get_device(&zdev->ap_dev->device);
 563                 zdev->request_count++;
 564                 __zcrypt_decrease_preference(zdev);
 565                 if (try_module_get(zdev->ap_dev->drv->driver.owner)) {
 566                         spin_unlock_bh(&zcrypt_device_lock);
 567                         rc = zdev->ops->send_cprb(zdev, xcRB);
 568                         spin_lock_bh(&zcrypt_device_lock);
 569                         module_put(zdev->ap_dev->drv->driver.owner);
 570                 }
 571                 else
 572                         rc = -EAGAIN;
 573                 zdev->request_count--;
 574                 __zcrypt_increase_preference(zdev);
 575                 put_device(&zdev->ap_dev->device);
 576                 zcrypt_device_put(zdev);
 577                 spin_unlock_bh(&zcrypt_device_lock);
 578                 return rc;
 579         }
 580         spin_unlock_bh(&zcrypt_device_lock);
 581         return -ENODEV;
 582 }
 583
 584 static long zcrypt_rng(char *buffer)
 585 {
 586         struct zcrypt_device *zdev;
 587         int rc;
 588
 589         spin_lock_bh(&zcrypt_device_lock);
 590         list_for_each_entry(zdev, &zcrypt_device_list, list) {
 591                 if (!zdev->online || !zdev->ops->rng)
 592                         continue;
 593                 zcrypt_device_get(zdev);
 594                 get_device(&zdev->ap_dev->device);
 595                 zdev->request_count++;
 596                 __zcrypt_decrease_preference(zdev);
 597                 if (try_module_get(zdev->ap_dev->drv->driver.owner)) {
 598                         spin_unlock_bh(&zcrypt_device_lock);
 599                         rc = zdev->ops->rng(zdev, buffer);
 600                         spin_lock_bh(&zcrypt_device_lock);
 601                         module_put(zdev->ap_dev->drv->driver.owner);
 602                 } else
 603                         rc = -EAGAIN;
 604                 zdev->request_count--;
 605                 __zcrypt_increase_preference(zdev);
 606                 put_device(&zdev->ap_dev->device);
 607                 zcrypt_device_put(zdev);
 608                 spin_unlock_bh(&zcrypt_device_lock);
 609                 return rc;
 610         }
 611         spin_unlock_bh(&zcrypt_device_lock);
 612         return -ENODEV;
 613 }
 614
 615 static void zcrypt_status_mask(char status[AP_DEVICES])
 616 {
 617         struct zcrypt_device *zdev;
 618
 619         memset(status, 0, sizeof(char) * AP_DEVICES);
 620         spin_lock_bh(&zcrypt_device_lock);
 621         list_for_each_entry(zdev, &zcrypt_device_list, list)
 622                 status[AP_QID_DEVICE(zdev->ap_dev->qid)] =
 623                         zdev->online ? zdev->user_space_type : 0x0d;
 624         spin_unlock_bh(&zcrypt_device_lock);
 625 }
 626
 627 static void zcrypt_qdepth_mask(char qdepth[AP_DEVICES])
 628 {
 629         struct zcrypt_device *zdev;
 630
 631         memset(qdepth, 0, sizeof(char)  * AP_DEVICES);
 632         spin_lock_bh(&zcrypt_device_lock);
 633         list_for_each_entry(zdev, &zcrypt_device_list, list) {
 634                 spin_lock(&zdev->ap_dev->lock);
 635                 qdepth[AP_QID_DEVICE(zdev->ap_dev->qid)] =
 636                         zdev->ap_dev->pendingq_count +
 637                         zdev->ap_dev->requestq_count;
 638                 spin_unlock(&zdev->ap_dev->lock);
 639         }
 640         spin_unlock_bh(&zcrypt_device_lock);
 641 }
 642
 643 static void zcrypt_perdev_reqcnt(int reqcnt[AP_DEVICES])
 644 {
 645         struct zcrypt_device *zdev;
 646
 647         memset(reqcnt, 0, sizeof(int) * AP_DEVICES);
 648         spin_lock_bh(&zcrypt_device_lock);
 649         list_for_each_entry(zdev, &zcrypt_device_list, list) {
 650                 spin_lock(&zdev->ap_dev->lock);
 651                 reqcnt[AP_QID_DEVICE(zdev->ap_dev->qid)] =
 652                         zdev->ap_dev->total_request_count;
 653                 spin_unlock(&zdev->ap_dev->lock);
 654         }
 655         spin_unlock_bh(&zcrypt_device_lock);
 656 }
 657
 658 static int zcrypt_pendingq_count(void)
 659 {
 660         struct zcrypt_device *zdev;
 661         int pendingq_count = 0;
 662
 663         spin_lock_bh(&zcrypt_device_lock);
 664         list_for_each_entry(zdev, &zcrypt_device_list, list) {
 665                 spin_lock(&zdev->ap_dev->lock);
 666                 pendingq_count += zdev->ap_dev->pendingq_count;
 667                 spin_unlock(&zdev->ap_dev->lock);
 668         }
 669         spin_unlock_bh(&zcrypt_device_lock);
 670         return pendingq_count;
 671 }
 672
 673 static int zcrypt_requestq_count(void)
 674 {
 675         struct zcrypt_device *zdev;
 676         int requestq_count = 0;
 677
 678         spin_lock_bh(&zcrypt_device_lock);
 679         list_for_each_entry(zdev, &zcrypt_device_list, list) {
 680                 spin_lock(&zdev->ap_dev->lock);
 681                 requestq_count += zdev->ap_dev->requestq_count;
 682                 spin_unlock(&zdev->ap_dev->lock);
 683         }
 684         spin_unlock_bh(&zcrypt_device_lock);
 685         return requestq_count;
 686 }
 687
 688 static int zcrypt_count_type(int type)
 689 {
 690         struct zcrypt_device *zdev;
 691         int device_count = 0;
 692
 693         spin_lock_bh(&zcrypt_device_lock);
 694         list_for_each_entry(zdev, &zcrypt_device_list, list)
 695                 if (zdev->user_space_type == type)
 696                         device_count++;
 697         spin_unlock_bh(&zcrypt_device_lock);
 698         return device_count;
 699 }
 700
 701 /**
 702  * zcrypt_ica_status(): Old, depracted combi status call.
 703  *
 704  * Old, deprecated combi status call.
 705  */
 706 static long zcrypt_ica_status(struct file *filp, unsigned long arg)
 707 {
 708         struct ica_z90_status *pstat;
 709         int ret;
 710
 711         pstat = kzalloc(sizeof(*pstat), GFP_KERNEL);
 712         if (!pstat)
 713                 return -ENOMEM;
 714         pstat->totalcount = zcrypt_device_count;
 715         pstat->leedslitecount = zcrypt_count_type(ZCRYPT_PCICA);
 716         pstat->leeds2count = zcrypt_count_type(ZCRYPT_PCICC);
 717         pstat->requestqWaitCount = zcrypt_requestq_count();
 718         pstat->pendingqWaitCount = zcrypt_pendingq_count();
 719         pstat->totalOpenCount = atomic_read(&zcrypt_open_count);
 720         pstat->cryptoDomain = ap_domain_index;
 721         zcrypt_status_mask(pstat->status);
 722         zcrypt_qdepth_mask(pstat->qdepth);
 723         ret = 0;
 724         if (copy_to_user((void __user *) arg, pstat, sizeof(*pstat)))
 725                 ret = -EFAULT;
 726         kfree(pstat);
 727         return ret;
 728 }
 729
 730 static long zcrypt_unlocked_ioctl(struct file *filp, unsigned int cmd,
 731                                   unsigned long arg)
 732 {
 733         int rc;
 734
 735         switch (cmd) {
 736         case ICARSAMODEXPO: {
 737                 struct ica_rsa_modexpo __user *umex = (void __user *) arg;
 738                 struct ica_rsa_modexpo mex;
 739                 if (copy_from_user(&mex, umex, sizeof(mex)))
 740                         return -EFAULT;
 741                 do {
 742                         rc = zcrypt_rsa_modexpo(&mex);
 743                 } while (rc == -EAGAIN);
 744                 /* on failure: retry once again after a requested rescan */
 745                 if ((rc == -ENODEV) && (zcrypt_process_rescan()))
 746                         do {
 747                                 rc = zcrypt_rsa_modexpo(&mex);
 748                         } while (rc == -EAGAIN);
 749                 if (rc)
 750                         return rc;
 751                 return put_user(mex.outputdatalength, &umex->outputdatalength);
 752         }
 753         case ICARSACRT: {
 754                 struct ica_rsa_modexpo_crt __user *ucrt = (void __user *) arg;
 755                 struct ica_rsa_modexpo_crt crt;
 756                 if (copy_from_user(&crt, ucrt, sizeof(crt)))
 757                         return -EFAULT;
 758                 do {
 759                         rc = zcrypt_rsa_crt(&crt);
 760                 } while (rc == -EAGAIN);
 761                 /* on failure: retry once again after a requested rescan */
 762                 if ((rc == -ENODEV) && (zcrypt_process_rescan()))
 763                         do {
 764                                 rc = zcrypt_rsa_crt(&crt);
 765                         } while (rc == -EAGAIN);
 766                 if (rc)
 767                         return rc;
 768                 return put_user(crt.outputdatalength, &ucrt->outputdatalength);
 769         }
 770         case ZSECSENDCPRB: {
 771                 struct ica_xcRB __user *uxcRB = (void __user *) arg;
 772                 struct ica_xcRB xcRB;
 773                 if (copy_from_user(&xcRB, uxcRB, sizeof(xcRB)))
 774                         return -EFAULT;
 775                 do {
 776                         rc = zcrypt_send_cprb(&xcRB);
 777                 } while (rc == -EAGAIN);
 778                 /* on failure: retry once again after a requested rescan */
 779                 if ((rc == -ENODEV) && (zcrypt_process_rescan()))
 780                         do {
 781                                 rc = zcrypt_send_cprb(&xcRB);
 782                         } while (rc == -EAGAIN);
 783                 if (copy_to_user(uxcRB, &xcRB, sizeof(xcRB)))
 784                         return -EFAULT;
 785                 return rc;
 786         }
 787         case Z90STAT_STATUS_MASK: {
 788                 char status[AP_DEVICES];
 789                 zcrypt_status_mask(status);
 790                 if (copy_to_user((char __user *) arg, status,
 791                                  sizeof(char) * AP_DEVICES))
 792                         return -EFAULT;
 793                 return 0;
 794         }
 795         case Z90STAT_QDEPTH_MASK: {
 796                 char qdepth[AP_DEVICES];
 797                 zcrypt_qdepth_mask(qdepth);
 798                 if (copy_to_user((char __user *) arg, qdepth,
 799                                  sizeof(char) * AP_DEVICES))
 800                         return -EFAULT;
 801                 return 0;
 802         }
 803         case Z90STAT_PERDEV_REQCNT: {
 804                 int reqcnt[AP_DEVICES];
 805                 zcrypt_perdev_reqcnt(reqcnt);
 806                 if (copy_to_user((int __user *) arg, reqcnt,
 807                                  sizeof(int) * AP_DEVICES))
 808                         return -EFAULT;
 809                 return 0;
 810         }
 811         case Z90STAT_REQUESTQ_COUNT:
 812                 return put_user(zcrypt_requestq_count(), (int __user *) arg);
 813         case Z90STAT_PENDINGQ_COUNT:
 814                 return put_user(zcrypt_pendingq_count(), (int __user *) arg);
 815         case Z90STAT_TOTALOPEN_COUNT:
 816                 return put_user(atomic_read(&zcrypt_open_count),
 817                                 (int __user *) arg);
 818         case Z90STAT_DOMAIN_INDEX:
 819                 return put_user(ap_domain_index, (int __user *) arg);
 820         /*
 821          * Deprecated ioctls. Don't add another device count ioctl,
 822          * you can count them yourself in the user space with the
 823          * output of the Z90STAT_STATUS_MASK ioctl.
 824          */
 825         case ICAZ90STATUS:
 826                 return zcrypt_ica_status(filp, arg);
 827         case Z90STAT_TOTALCOUNT:
 828                 return put_user(zcrypt_device_count, (int __user *) arg);
 829         case Z90STAT_PCICACOUNT:
 830                 return put_user(zcrypt_count_type(ZCRYPT_PCICA),
 831                                 (int __user *) arg);
 832         case Z90STAT_PCICCCOUNT:
 833                 return put_user(zcrypt_count_type(ZCRYPT_PCICC),
 834                                 (int __user *) arg);
 835         case Z90STAT_PCIXCCMCL2COUNT:
 836                 return put_user(zcrypt_count_type(ZCRYPT_PCIXCC_MCL2),
 837                                 (int __user *) arg);
 838         case Z90STAT_PCIXCCMCL3COUNT:
 839                 return put_user(zcrypt_count_type(ZCRYPT_PCIXCC_MCL3),
 840                                 (int __user *) arg);
 841         case Z90STAT_PCIXCCCOUNT:
 842                 return put_user(zcrypt_count_type(ZCRYPT_PCIXCC_MCL2) +
 843                                 zcrypt_count_type(ZCRYPT_PCIXCC_MCL3),
 844                                 (int __user *) arg);
 845         case Z90STAT_CEX2CCOUNT:
 846                 return put_user(zcrypt_count_type(ZCRYPT_CEX2C),
 847                                 (int __user *) arg);
 848         case Z90STAT_CEX2ACOUNT:
 849                 return put_user(zcrypt_count_type(ZCRYPT_CEX2A),
 850                                 (int __user *) arg);
 851         default:
 852                 /* unknown ioctl number */
 853                 return -ENOIOCTLCMD;
 854         }
 855 }
 856
 857 #ifdef CONFIG_COMPAT
 858 /*
 859  * ioctl32 conversion routines
 860  */
 861 struct compat_ica_rsa_modexpo {
 862         compat_uptr_t   inputdata;
 863         unsigned int    inputdatalength;
 864         compat_uptr_t   outputdata;
 865         unsigned int    outputdatalength;
 866         compat_uptr_t   b_key;
 867         compat_uptr_t   n_modulus;
 868 };
 869
 870 static long trans_modexpo32(struct file *filp, unsigned int cmd,
 871                             unsigned long arg)
 872 {
 873         struct compat_ica_rsa_modexpo __user *umex32 = compat_ptr(arg);
 874         struct compat_ica_rsa_modexpo mex32;
 875         struct ica_rsa_modexpo mex64;
 876         long rc;
 877
 878         if (copy_from_user(&mex32, umex32, sizeof(mex32)))
 879                 return -EFAULT;
 880         mex64.inputdata = compat_ptr(mex32.inputdata);
 881         mex64.inputdatalength = mex32.inputdatalength;
 882         mex64.outputdata = compat_ptr(mex32.outputdata);
 883         mex64.outputdatalength = mex32.outputdatalength;
 884         mex64.b_key = compat_ptr(mex32.b_key);
 885         mex64.n_modulus = compat_ptr(mex32.n_modulus);
 886         do {
 887                 rc = zcrypt_rsa_modexpo(&mex64);
 888         } while (rc == -EAGAIN);
 889         /* on failure: retry once again after a requested rescan */
 890         if ((rc == -ENODEV) && (zcrypt_process_rescan()))
 891                 do {
 892                         rc = zcrypt_rsa_modexpo(&mex64);
 893                 } while (rc == -EAGAIN);
 894         if (rc)
 895                 return rc;
 896         return put_user(mex64.outputdatalength,
 897                         &umex32->outputdatalength);
 898 }
 899
 900 struct compat_ica_rsa_modexpo_crt {
 901         compat_uptr_t   inputdata;
 902         unsigned int    inputdatalength;
 903         compat_uptr_t   outputdata;
 904         unsigned int    outputdatalength;
 905         compat_uptr_t   bp_key;
 906         compat_uptr_t   bq_key;
 907         compat_uptr_t   np_prime;
 908         compat_uptr_t   nq_prime;
 909         compat_uptr_t   u_mult_inv;
 910 };
 911
 912 static long trans_modexpo_crt32(struct file *filp, unsigned int cmd,
 913                                 unsigned long arg)
 914 {
 915         struct compat_ica_rsa_modexpo_crt __user *ucrt32 = compat_ptr(arg);
 916         struct compat_ica_rsa_modexpo_crt crt32;
 917         struct ica_rsa_modexpo_crt crt64;
 918         long rc;
 919
 920         if (copy_from_user(&crt32, ucrt32, sizeof(crt32)))
 921                 return -EFAULT;
 922         crt64.inputdata = compat_ptr(crt32.inputdata);
 923         crt64.inputdatalength = crt32.inputdatalength;
 924         crt64.outputdata=  compat_ptr(crt32.outputdata);
 925         crt64.outputdatalength = crt32.outputdatalength;
 926         crt64.bp_key = compat_ptr(crt32.bp_key);
 927         crt64.bq_key = compat_ptr(crt32.bq_key);
 928         crt64.np_prime = compat_ptr(crt32.np_prime);
 929         crt64.nq_prime = compat_ptr(crt32.nq_prime);
 930         crt64.u_mult_inv = compat_ptr(crt32.u_mult_inv);
 931         do {
 932                 rc = zcrypt_rsa_crt(&crt64);
 933         } while (rc == -EAGAIN);
 934         /* on failure: retry once again after a requested rescan */
 935         if ((rc == -ENODEV) && (zcrypt_process_rescan()))
 936                 do {
 937                         rc = zcrypt_rsa_crt(&crt64);
 938                 } while (rc == -EAGAIN);
 939         if (rc)
 940                 return rc;
 941         return put_user(crt64.outputdatalength,
 942                         &ucrt32->outputdatalength);
 943 }
 944
 945 struct compat_ica_xcRB {
 946         unsigned short  agent_ID;
 947         unsigned int    user_defined;
 948         unsigned short  request_ID;
 949         unsigned int    request_control_blk_length;
 950         unsigned char   padding1[16 - sizeof (compat_uptr_t)];
 951         compat_uptr_t   request_control_blk_addr;
 952         unsigned int    request_data_length;
 953         char            padding2[16 - sizeof (compat_uptr_t)];
 954         compat_uptr_t   request_data_address;
 955         unsigned int    reply_control_blk_length;
 956         char            padding3[16 - sizeof (compat_uptr_t)];
 957         compat_uptr_t   reply_control_blk_addr;
 958         unsigned int    reply_data_length;
 959         char            padding4[16 - sizeof (compat_uptr_t)];
 960         compat_uptr_t   reply_data_addr;
 961         unsigned short  priority_window;
 962         unsigned int    status;
 963 } __attribute__((packed));
 964
 965 static long trans_xcRB32(struct file *filp, unsigned int cmd,
 966                          unsigned long arg)
 967 {
 968         struct compat_ica_xcRB __user *uxcRB32 = compat_ptr(arg);
 969         struct compat_ica_xcRB xcRB32;
 970         struct ica_xcRB xcRB64;
 971         long rc;
 972
 973         if (copy_from_user(&xcRB32, uxcRB32, sizeof(xcRB32)))
 974                 return -EFAULT;
 975         xcRB64.agent_ID = xcRB32.agent_ID;
 976         xcRB64.user_defined = xcRB32.user_defined;
 977         xcRB64.request_ID = xcRB32.request_ID;
 978         xcRB64.request_control_blk_length =
 979                 xcRB32.request_control_blk_length;
 980         xcRB64.request_control_blk_addr =
 981                 compat_ptr(xcRB32.request_control_blk_addr);
 982         xcRB64.request_data_length =
 983                 xcRB32.request_data_length;
 984         xcRB64.request_data_address =
 985                 compat_ptr(xcRB32.request_data_address);
 986         xcRB64.reply_control_blk_length =
 987                 xcRB32.reply_control_blk_length;
 988         xcRB64.reply_control_blk_addr =
 989                 compat_ptr(xcRB32.reply_control_blk_addr);
 990         xcRB64.reply_data_length = xcRB32.reply_data_length;
 991         xcRB64.reply_data_addr =
 992                 compat_ptr(xcRB32.reply_data_addr);
 993         xcRB64.priority_window = xcRB32.priority_window;
 994         xcRB64.status = xcRB32.status;
 995         do {
 996                 rc = zcrypt_send_cprb(&xcRB64);
 997         } while (rc == -EAGAIN);
 998         /* on failure: retry once again after a requested rescan */
 999         if ((rc == -ENODEV) && (zcrypt_process_rescan()))
1000                 do {
1001                         rc = zcrypt_send_cprb(&xcRB64);
1002                 } while (rc == -EAGAIN);
1003         xcRB32.reply_control_blk_length = xcRB64.reply_control_blk_length;
1004         xcRB32.reply_data_length = xcRB64.reply_data_length;
1005         xcRB32.status = xcRB64.status;
1006         if (copy_to_user(uxcRB32, &xcRB32, sizeof(xcRB32)))
1007                         return -EFAULT;
1008         return rc;
1009 }
1010
1011 static long zcrypt_compat_ioctl(struct file *filp, unsigned int cmd,
1012                          unsigned long arg)
1013 {
1014         if (cmd == ICARSAMODEXPO)
1015                 return trans_modexpo32(filp, cmd, arg);
1016         if (cmd == ICARSACRT)
1017                 return trans_modexpo_crt32(filp, cmd, arg);
1018         if (cmd == ZSECSENDCPRB)
1019                 return trans_xcRB32(filp, cmd, arg);
1020         return zcrypt_unlocked_ioctl(filp, cmd, arg);
1021 }
1022 #endif
1023
1024 /*
1025  * Misc device file operations.
1026  */
1027 static const struct file_operations zcrypt_fops = {
1028         .owner          = THIS_MODULE,
1029         .read           = zcrypt_read,
1030         .write          = zcrypt_write,
1031         .unlocked_ioctl = zcrypt_unlocked_ioctl,
1032 #ifdef CONFIG_COMPAT
1033         .compat_ioctl   = zcrypt_compat_ioctl,
1034 #endif
1035         .open           = zcrypt_open,
1036         .release        = zcrypt_release,
1037         .llseek         = no_llseek,
1038 };
1039
1040 /*
1041  * Misc device.
1042  */
1043 static struct miscdevice zcrypt_misc_device = {
1044         .minor      = MISC_DYNAMIC_MINOR,
1045         .name       = "z90crypt",
1046         .fops       = &zcrypt_fops,
1047 };
1048
1049 /*
1050  * Deprecated /proc entry support.
1051  */
1052 static struct proc_dir_entry *zcrypt_entry;
1053
1054 static void sprintcl(struct seq_file *m, unsigned char *addr, unsigned int len)
1055 {
1056         int i;
1057
1058         for (i = 0; i < len; i++)
1059                 seq_printf(m, "%01x", (unsigned int) addr[i]);
1060         seq_putc(m, ' ');
1061 }
1062
1063 static void sprintrw(struct seq_file *m, unsigned char *addr, unsigned int len)
1064 {
1065         int inl, c, cx;
1066
1067         seq_printf(m, "    ");
1068         inl = 0;
1069         for (c = 0; c < (len / 16); c++) {
1070                 sprintcl(m, addr+inl, 16);
1071                 inl += 16;
1072         }
1073         cx = len%16;
1074         if (cx) {
1075                 sprintcl(m, addr+inl, cx);
1076                 inl += cx;
1077         }
1078         seq_putc(m, '\n');
1079 }
1080
1081 static void sprinthx(unsigned char *title, struct seq_file *m,
1082                      unsigned char *addr, unsigned int len)
1083 {
1084         int inl, r, rx;
1085
1086         seq_printf(m, "\n%s\n", title);
1087         inl = 0;
1088         for (r = 0; r < (len / 64); r++) {
1089                 sprintrw(m, addr+inl, 64);
1090                 inl += 64;
1091         }
1092         rx = len % 64;
1093         if (rx) {
1094                 sprintrw(m, addr+inl, rx);
1095                 inl += rx;
1096         }
1097         seq_putc(m, '\n');
1098 }
1099
1100 static void sprinthx4(unsigned char *title, struct seq_file *m,
1101                       unsigned int *array, unsigned int len)
1102 {
1103         int r;
1104
1105         seq_printf(m, "\n%s\n", title);
1106         for (r = 0; r < len; r++) {
1107                 if ((r % 8) == 0)
1108                         seq_printf(m, "    ");
1109                 seq_printf(m, "%08X ", array[r]);
1110                 if ((r % 8) == 7)
1111                         seq_putc(m, '\n');
1112         }
1113         seq_putc(m, '\n');
1114 }
1115
1116 static int zcrypt_proc_show(struct seq_file *m, void *v)
1117 {
1118         char workarea[sizeof(int) * AP_DEVICES];
1119
1120         seq_printf(m, "\nzcrypt version: %d.%d.%d\n",
1121                    ZCRYPT_VERSION, ZCRYPT_RELEASE, ZCRYPT_VARIANT);
1122         seq_printf(m, "Cryptographic domain: %d\n", ap_domain_index);
1123         seq_printf(m, "Total device count: %d\n", zcrypt_device_count);
1124         seq_printf(m, "PCICA count: %d\n", zcrypt_count_type(ZCRYPT_PCICA));
1125         seq_printf(m, "PCICC count: %d\n", zcrypt_count_type(ZCRYPT_PCICC));
1126         seq_printf(m, "PCIXCC MCL2 count: %d\n",
1127                    zcrypt_count_type(ZCRYPT_PCIXCC_MCL2));
1128         seq_printf(m, "PCIXCC MCL3 count: %d\n",
1129                    zcrypt_count_type(ZCRYPT_PCIXCC_MCL3));
1130         seq_printf(m, "CEX2C count: %d\n", zcrypt_count_type(ZCRYPT_CEX2C));
1131         seq_printf(m, "CEX2A count: %d\n", zcrypt_count_type(ZCRYPT_CEX2A));
1132         seq_printf(m, "CEX3C count: %d\n", zcrypt_count_type(ZCRYPT_CEX3C));
1133         seq_printf(m, "CEX3A count: %d\n", zcrypt_count_type(ZCRYPT_CEX3A));
1134         seq_printf(m, "requestq count: %d\n", zcrypt_requestq_count());
1135         seq_printf(m, "pendingq count: %d\n", zcrypt_pendingq_count());
1136         seq_printf(m, "Total open handles: %d\n\n",
1137                    atomic_read(&zcrypt_open_count));
1138         zcrypt_status_mask(workarea);
1139         sprinthx("Online devices: 1=PCICA 2=PCICC 3=PCIXCC(MCL2) "
1140                  "4=PCIXCC(MCL3) 5=CEX2C 6=CEX2A 7=CEX3C 8=CEX3A",
1141                  m, workarea, AP_DEVICES);
1142         zcrypt_qdepth_mask(workarea);
1143         sprinthx("Waiting work element counts", m, workarea, AP_DEVICES);
1144         zcrypt_perdev_reqcnt((int *) workarea);
1145         sprinthx4("Per-device successfully completed request counts",
1146                   m, (unsigned int *) workarea, AP_DEVICES);
1147         return 0;
1148 }
1149
1150 static int zcrypt_proc_open(struct inode *inode, struct file *file)
1151 {
1152         return single_open(file, zcrypt_proc_show, NULL);
1153 }
1154
1155 static void zcrypt_disable_card(int index)
1156 {
1157         struct zcrypt_device *zdev;
1158
1159         spin_lock_bh(&zcrypt_device_lock);
1160         list_for_each_entry(zdev, &zcrypt_device_list, list)
1161                 if (AP_QID_DEVICE(zdev->ap_dev->qid) == index) {
1162                         zdev->online = 0;
1163                         ap_flush_queue(zdev->ap_dev);
1164                         break;
1165                 }
1166         spin_unlock_bh(&zcrypt_device_lock);
1167 }
1168
1169 static void zcrypt_enable_card(int index)
1170 {
1171         struct zcrypt_device *zdev;
1172
1173         spin_lock_bh(&zcrypt_device_lock);
1174         list_for_each_entry(zdev, &zcrypt_device_list, list)
1175                 if (AP_QID_DEVICE(zdev->ap_dev->qid) == index) {
1176                         zdev->online = 1;
1177                         break;
1178                 }
1179         spin_unlock_bh(&zcrypt_device_lock);
1180 }
1181
1182 static ssize_t zcrypt_proc_write(struct file *file, const char __user *buffer,
1183                                  size_t count, loff_t *pos)
1184 {
1185         unsigned char *lbuf, *ptr;
1186         size_t local_count;
1187         int j;
1188
1189         if (count <= 0)
1190                 return 0;
1191
1192 #define LBUFSIZE 1200UL
1193         lbuf = kmalloc(LBUFSIZE, GFP_KERNEL);
1194         if (!lbuf)
1195                 return 0;
1196
1197         local_count = min(LBUFSIZE - 1, count);
1198         if (copy_from_user(lbuf, buffer, local_count) != 0) {
1199                 kfree(lbuf);
1200                 return -EFAULT;
1201         }
1202         lbuf[local_count] = '\0';
1203
1204         ptr = strstr(lbuf, "Online devices");
1205         if (!ptr)
1206                 goto out;
1207         ptr = strstr(ptr, "\n");
1208         if (!ptr)
1209                 goto out;
1210         ptr++;
1211
1212         if (strstr(ptr, "Waiting work element counts") == NULL)
1213                 goto out;
1214
1215         for (j = 0; j < 64 && *ptr; ptr++) {
1216                 /*
1217                  * '0' for no device, '1' for PCICA, '2' for PCICC,
1218                  * '3' for PCIXCC_MCL2, '4' for PCIXCC_MCL3,
1219                  * '5' for CEX2C and '6' for CEX2A'
1220                  * '7' for CEX3C and '8' for CEX3A
1221                  */
1222                 if (*ptr >= '0' && *ptr <= '8')
1223                         j++;
1224                 else if (*ptr == 'd' || *ptr == 'D')
1225                         zcrypt_disable_card(j++);
1226                 else if (*ptr == 'e' || *ptr == 'E')
1227                         zcrypt_enable_card(j++);
1228                 else if (*ptr != ' ' && *ptr != '\t')
1229                         break;
1230         }
1231 out:
1232         kfree(lbuf);
1233         return count;
1234 }
1235
1236 static const struct file_operations zcrypt_proc_fops = {
1237         .owner          = THIS_MODULE,
1238         .open           = zcrypt_proc_open,
1239         .read           = seq_read,
1240         .llseek         = seq_lseek,
1241         .release        = single_release,
1242         .write          = zcrypt_proc_write,
1243 };
1244
1245 static int zcrypt_rng_device_count;
1246 static u32 *zcrypt_rng_buffer;
1247 static int zcrypt_rng_buffer_index;
1248 static DEFINE_MUTEX(zcrypt_rng_mutex);
1249
1250 static int zcrypt_rng_data_read(struct hwrng *rng, u32 *data)
1251 {
1252         int rc;
1253
1254         /*
1255          * We don't need locking here because the RNG API guarantees serialized
1256          * read method calls.
1257          */
1258         if (zcrypt_rng_buffer_index == 0) {
1259                 rc = zcrypt_rng((char *) zcrypt_rng_buffer);
1260                 /* on failure: retry once again after a requested rescan */
1261                 if ((rc == -ENODEV) && (zcrypt_process_rescan()))
1262                         rc = zcrypt_rng((char *) zcrypt_rng_buffer);
1263                 if (rc < 0)
1264                         return -EIO;
1265                 zcrypt_rng_buffer_index = rc / sizeof *data;
1266         }
1267         *data = zcrypt_rng_buffer[--zcrypt_rng_buffer_index];
1268         return sizeof *data;
1269 }
1270
1271 static struct hwrng zcrypt_rng_dev = {
1272         .name           = "zcrypt",
1273         .data_read      = zcrypt_rng_data_read,
1274 };
1275
1276 static int zcrypt_rng_device_add(void)
1277 {
1278         int rc = 0;
1279
1280         mutex_lock(&zcrypt_rng_mutex);
1281         if (zcrypt_rng_device_count == 0) {
1282                 zcrypt_rng_buffer = (u32 *) get_zeroed_page(GFP_KERNEL);
1283                 if (!zcrypt_rng_buffer) {
1284                         rc = -ENOMEM;
1285                         goto out;
1286                 }
1287                 zcrypt_rng_buffer_index = 0;
1288                 rc = hwrng_register(&zcrypt_rng_dev);
1289                 if (rc)
1290                         goto out_free;
1291                 zcrypt_rng_device_count = 1;
1292         } else
1293                 zcrypt_rng_device_count++;
1294         mutex_unlock(&zcrypt_rng_mutex);
1295         return 0;
1296
1297 out_free:
1298         free_page((unsigned long) zcrypt_rng_buffer);
1299 out:
1300         mutex_unlock(&zcrypt_rng_mutex);
1301         return rc;
1302 }
1303
1304 static void zcrypt_rng_device_remove(void)
1305 {
1306         mutex_lock(&zcrypt_rng_mutex);
1307         zcrypt_rng_device_count--;
1308         if (zcrypt_rng_device_count == 0) {
1309                 hwrng_unregister(&zcrypt_rng_dev);
1310                 free_page((unsigned long) zcrypt_rng_buffer);
1311         }
1312         mutex_unlock(&zcrypt_rng_mutex);
1313 }
1314
1315 int __init zcrypt_debug_init(void)
1316 {
1317         debugfs_root = debugfs_create_dir("zcrypt", NULL);
1318
1319         zcrypt_dbf_common = debug_register("zcrypt_common", 1, 1, 16);
1320         debug_register_view(zcrypt_dbf_common, &debug_hex_ascii_view);
1321         debug_set_level(zcrypt_dbf_common, DBF_ERR);
1322
1323         zcrypt_dbf_devices = debug_register("zcrypt_devices", 1, 1, 16);
1324         debug_register_view(zcrypt_dbf_devices, &debug_hex_ascii_view);
1325         debug_set_level(zcrypt_dbf_devices, DBF_ERR);
1326
1327         return 0;
1328 }
1329
1330 void zcrypt_debug_exit(void)
1331 {
1332         debugfs_remove(debugfs_root);
1333         if (zcrypt_dbf_common)
1334                 debug_unregister(zcrypt_dbf_common);
1335         if (zcrypt_dbf_devices)
1336                 debug_unregister(zcrypt_dbf_devices);
1337 }
1338
1339 /**
1340  * zcrypt_api_init(): Module initialization.
1341  *
1342  * The module initialization code.
1343  */
1344 int __init zcrypt_api_init(void)
1345 {
1346         int rc;
1347
1348         rc = zcrypt_debug_init();
1349         if (rc)
1350                 goto out;
1351
1352         atomic_set(&zcrypt_rescan_req, 0);
1353
1354         /* Register the request sprayer. */
1355         rc = misc_register(&zcrypt_misc_device);
1356         if (rc < 0)
1357                 goto out;
1358
1359         /* Set up the proc file system */
1360         zcrypt_entry = proc_create("driver/z90crypt", 0644, NULL, &zcrypt_proc_fops);
1361         if (!zcrypt_entry) {
1362                 rc = -ENOMEM;
1363                 goto out_misc;
1364         }
1365
1366         return 0;
1367
1368 out_misc:
1369         misc_deregister(&zcrypt_misc_device);
1370 out:
1371         return rc;
1372 }
1373
1374 /**
1375  * zcrypt_api_exit(): Module termination.
1376  *
1377  * The module termination code.
1378  */
1379 void zcrypt_api_exit(void)
1380 {
1381         remove_proc_entry("driver/z90crypt", NULL);
1382         misc_deregister(&zcrypt_misc_device);
1383         zcrypt_debug_exit();
1384 }
1385
1386 module_init(zcrypt_api_init);
1387 module_exit(zcrypt_api_exit);