kernel/drivers/s390/crypto/zcrypt_pcicc.c

   1 /*
   2  *  zcrypt 2.1.0
   3  *
   4  *  Copyright IBM Corp. 2001, 2006
   5  *  Author(s): Robert Burroughs
   6  *             Eric Rossman (edrossma@us.ibm.com)
   7  *
   8  *  Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
   9  *  Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>
  10  *                                Ralph Wuerthner <rwuerthn@de.ibm.com>
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2, or (at your option)
  15  * any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25  */
  26
  27 #define KMSG_COMPONENT "zcrypt"
  28 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  29
  30 #include <linux/module.h>
  31 #include <linux/init.h>
  32 #include <linux/gfp.h>
  33 #include <linux/err.h>
  34 #include <linux/atomic.h>
  35 #include <asm/uaccess.h>
  36
  37 #include "ap_bus.h"
  38 #include "zcrypt_api.h"
  39 #include "zcrypt_error.h"
  40 #include "zcrypt_pcicc.h"
  41 #include "zcrypt_cca_key.h"
  42
  43 #define PCICC_MIN_MOD_SIZE       64     /*  512 bits */
  44 #define PCICC_MAX_MOD_SIZE_OLD  128     /* 1024 bits */
  45 #define PCICC_MAX_MOD_SIZE      256     /* 2048 bits */
  46
  47 /*
  48  * PCICC cards need a speed rating of 0. This keeps them at the end of
  49  * the zcrypt device list (see zcrypt_api.c). PCICC cards are only
  50  * used if no other cards are present because they are slow and can only
  51  * cope with PKCS12 padded requests. The logic is queer. PKCS11 padded
  52  * requests are rejected. The modexpo function encrypts PKCS12 padded data
  53  * and decrypts any non-PKCS12 padded data (except PKCS11) in the assumption
  54  * that it's encrypted PKCS12 data. The modexpo_crt function always decrypts
  55  * the data in the assumption that its PKCS12 encrypted data.
  56  */
  57 #define PCICC_SPEED_RATING      0
  58
  59 #define PCICC_MAX_MESSAGE_SIZE 0x710    /* max size type6 v1 crt message */
  60 #define PCICC_MAX_RESPONSE_SIZE 0x710   /* max size type86 v1 reply      */
  61
  62 #define PCICC_CLEANUP_TIME      (15*HZ)
  63
  64 static struct ap_device_id zcrypt_pcicc_ids[] = {
  65         { AP_DEVICE(AP_DEVICE_TYPE_PCICC) },
  66         { /* end of list */ },
  67 };
  68
  69 MODULE_DEVICE_TABLE(ap, zcrypt_pcicc_ids);
  70 MODULE_AUTHOR("IBM Corporation");
  71 MODULE_DESCRIPTION("PCICC Cryptographic Coprocessor device driver, "
  72                    "Copyright IBM Corp. 2001, 2006");
  73 MODULE_LICENSE("GPL");
  74
  75 static int zcrypt_pcicc_probe(struct ap_device *ap_dev);
  76 static void zcrypt_pcicc_remove(struct ap_device *ap_dev);
  77 static void zcrypt_pcicc_receive(struct ap_device *, struct ap_message *,
  78                                  struct ap_message *);
  79
  80 static struct ap_driver zcrypt_pcicc_driver = {
  81         .probe = zcrypt_pcicc_probe,
  82         .remove = zcrypt_pcicc_remove,
  83         .ids = zcrypt_pcicc_ids,
  84         .request_timeout = PCICC_CLEANUP_TIME,
  85 };
  86
  87 /**
  88  * The following is used to initialize the CPRB passed to the PCICC card
  89  * in a type6 message. The 3 fields that must be filled in at execution
  90  * time are  req_parml, rpl_parml and usage_domain. Note that all three
  91  * fields are *little*-endian. Actually, everything about this interface
  92  * is ascii/little-endian, since the device has 'Intel inside'.
  93  *
  94  * The CPRB is followed immediately by the parm block.
  95  * The parm block contains:
  96  * - function code ('PD' 0x5044 or 'PK' 0x504B)
  97  * - rule block (0x0A00 'PKCS-1.2' or 0x0A00 'ZERO-PAD')
  98  * - VUD block
  99  */
 100 static struct CPRB static_cprb = {
 101         .cprb_len       = __constant_cpu_to_le16(0x0070),
 102         .cprb_ver_id    =  0x41,
 103         .func_id        = {0x54,0x32},
 104         .checkpoint_flag=  0x01,
 105         .svr_namel      = __constant_cpu_to_le16(0x0008),
 106         .svr_name       = {'I','C','S','F',' ',' ',' ',' '}
 107 };
 108
 109 /**
 110  * Check the message for PKCS11 padding.
 111  */
 112 static inline int is_PKCS11_padded(unsigned char *buffer, int length)
 113 {
 114         int i;
 115         if ((buffer[0] != 0x00) || (buffer[1] != 0x01))
 116                 return 0;
 117         for (i = 2; i < length; i++)
 118                 if (buffer[i] != 0xFF)
 119                         break;
 120         if (i < 10 || i == length)
 121                 return 0;
 122         if (buffer[i] != 0x00)
 123                 return 0;
 124         return 1;
 125 }
 126
 127 /**
 128  * Check the message for PKCS12 padding.
 129  */
 130 static inline int is_PKCS12_padded(unsigned char *buffer, int length)
 131 {
 132         int i;
 133         if ((buffer[0] != 0x00) || (buffer[1] != 0x02))
 134                 return 0;
 135         for (i = 2; i < length; i++)
 136                 if (buffer[i] == 0x00)
 137                         break;
 138         if ((i < 10) || (i == length))
 139                 return 0;
 140         if (buffer[i] != 0x00)
 141                 return 0;
 142         return 1;
 143 }
 144
 145 /**
 146  * Convert a ICAMEX message to a type6 MEX message.
 147  *
 148  * @zdev: crypto device pointer
 149  * @zreq: crypto request pointer
 150  * @mex: pointer to user input data
 151  *
 152  * Returns 0 on success or -EFAULT.
 153  */
 154 static int ICAMEX_msg_to_type6MEX_msg(struct zcrypt_device *zdev,
 155                                       struct ap_message *ap_msg,
 156                                       struct ica_rsa_modexpo *mex)
 157 {
 158         static struct type6_hdr static_type6_hdr = {
 159                 .type           =  0x06,
 160                 .offset1        =  0x00000058,
 161                 .agent_id       = {0x01,0x00,0x43,0x43,0x41,0x2D,0x41,0x50,
 162                                    0x50,0x4C,0x20,0x20,0x20,0x01,0x01,0x01},
 163                 .function_code  = {'P','K'},
 164         };
 165         static struct function_and_rules_block static_pke_function_and_rules ={
 166                 .function_code  = {'P','K'},
 167                 .ulen           = __constant_cpu_to_le16(10),
 168                 .only_rule      = {'P','K','C','S','-','1','.','2'}
 169         };
 170         struct {
 171                 struct type6_hdr hdr;
 172                 struct CPRB cprb;
 173                 struct function_and_rules_block fr;
 174                 unsigned short length;
 175                 char text[0];
 176         } __attribute__((packed)) *msg = ap_msg->message;
 177         int vud_len, pad_len, size;
 178
 179         /* VUD.ciphertext */
 180         if (copy_from_user(msg->text, mex->inputdata, mex->inputdatalength))
 181                 return -EFAULT;
 182
 183         if (is_PKCS11_padded(msg->text, mex->inputdatalength))
 184                 return -EINVAL;
 185
 186         /* static message header and f&r */
 187         msg->hdr = static_type6_hdr;
 188         msg->fr = static_pke_function_and_rules;
 189
 190         if (is_PKCS12_padded(msg->text, mex->inputdatalength)) {
 191                 /* strip the padding and adjust the data length */
 192                 pad_len = strnlen(msg->text + 2, mex->inputdatalength - 2) + 3;
 193                 if (pad_len <= 9 || pad_len >= mex->inputdatalength)
 194                         return -ENODEV;
 195                 vud_len = mex->inputdatalength - pad_len;
 196                 memmove(msg->text, msg->text + pad_len, vud_len);
 197                 msg->length = cpu_to_le16(vud_len + 2);
 198
 199                 /* Set up key after the variable length text. */
 200                 size = zcrypt_type6_mex_key_en(mex, msg->text + vud_len, 0);
 201                 if (size < 0)
 202                         return size;
 203                 size += sizeof(*msg) + vud_len; /* total size of msg */
 204         } else {
 205                 vud_len = mex->inputdatalength;
 206                 msg->length = cpu_to_le16(2 + vud_len);
 207
 208                 msg->hdr.function_code[1] = 'D';
 209                 msg->fr.function_code[1] = 'D';
 210
 211                 /* Set up key after the variable length text. */
 212                 size = zcrypt_type6_mex_key_de(mex, msg->text + vud_len, 0);
 213                 if (size < 0)
 214                         return size;
 215                 size += sizeof(*msg) + vud_len; /* total size of msg */
 216         }
 217
 218         /* message header, cprb and f&r */
 219         msg->hdr.ToCardLen1 = (size - sizeof(msg->hdr) + 3) & -4;
 220         msg->hdr.FromCardLen1 = PCICC_MAX_RESPONSE_SIZE - sizeof(msg->hdr);
 221
 222         msg->cprb = static_cprb;
 223         msg->cprb.usage_domain[0]= AP_QID_QUEUE(zdev->ap_dev->qid);
 224         msg->cprb.req_parml = cpu_to_le16(size - sizeof(msg->hdr) -
 225                                            sizeof(msg->cprb));
 226         msg->cprb.rpl_parml = cpu_to_le16(msg->hdr.FromCardLen1);
 227
 228         ap_msg->length = (size + 3) & -4;
 229         return 0;
 230 }
 231
 232 /**
 233  * Convert a ICACRT message to a type6 CRT message.
 234  *
 235  * @zdev: crypto device pointer
 236  * @zreq: crypto request pointer
 237  * @crt: pointer to user input data
 238  *
 239  * Returns 0 on success or -EFAULT.
 240  */
 241 static int ICACRT_msg_to_type6CRT_msg(struct zcrypt_device *zdev,
 242                                       struct ap_message *ap_msg,
 243                                       struct ica_rsa_modexpo_crt *crt)
 244 {
 245         static struct type6_hdr static_type6_hdr = {
 246                 .type           =  0x06,
 247                 .offset1        =  0x00000058,
 248                 .agent_id       = {0x01,0x00,0x43,0x43,0x41,0x2D,0x41,0x50,
 249                                    0x50,0x4C,0x20,0x20,0x20,0x01,0x01,0x01},
 250                 .function_code  = {'P','D'},
 251         };
 252         static struct function_and_rules_block static_pkd_function_and_rules ={
 253                 .function_code  = {'P','D'},
 254                 .ulen           = __constant_cpu_to_le16(10),
 255                 .only_rule      = {'P','K','C','S','-','1','.','2'}
 256         };
 257         struct {
 258                 struct type6_hdr hdr;
 259                 struct CPRB cprb;
 260                 struct function_and_rules_block fr;
 261                 unsigned short length;
 262                 char text[0];
 263         } __attribute__((packed)) *msg = ap_msg->message;
 264         int size;
 265
 266         /* VUD.ciphertext */
 267         msg->length = cpu_to_le16(2 + crt->inputdatalength);
 268         if (copy_from_user(msg->text, crt->inputdata, crt->inputdatalength))
 269                 return -EFAULT;
 270
 271         if (is_PKCS11_padded(msg->text, crt->inputdatalength))
 272                 return -EINVAL;
 273
 274         /* Set up key after the variable length text. */
 275         size = zcrypt_type6_crt_key(crt, msg->text + crt->inputdatalength, 0);
 276         if (size < 0)
 277                 return size;
 278         size += sizeof(*msg) + crt->inputdatalength;    /* total size of msg */
 279
 280         /* message header, cprb and f&r */
 281         msg->hdr = static_type6_hdr;
 282         msg->hdr.ToCardLen1 = (size -  sizeof(msg->hdr) + 3) & -4;
 283         msg->hdr.FromCardLen1 = PCICC_MAX_RESPONSE_SIZE - sizeof(msg->hdr);
 284
 285         msg->cprb = static_cprb;
 286         msg->cprb.usage_domain[0] = AP_QID_QUEUE(zdev->ap_dev->qid);
 287         msg->cprb.req_parml = msg->cprb.rpl_parml =
 288                 cpu_to_le16(size - sizeof(msg->hdr) - sizeof(msg->cprb));
 289
 290         msg->fr = static_pkd_function_and_rules;
 291
 292         ap_msg->length = (size + 3) & -4;
 293         return 0;
 294 }
 295
 296 /**
 297  * Copy results from a type 86 reply message back to user space.
 298  *
 299  * @zdev: crypto device pointer
 300  * @reply: reply AP message.
 301  * @data: pointer to user output data
 302  * @length: size of user output data
 303  *
 304  * Returns 0 on success or -EINVAL, -EFAULT, -EAGAIN in case of an error.
 305  */
 306 struct type86_reply {
 307         struct type86_hdr hdr;
 308         struct type86_fmt2_ext fmt2;
 309         struct CPRB cprb;
 310         unsigned char pad[4];   /* 4 byte function code/rules block ? */
 311         unsigned short length;
 312         char text[0];
 313 } __attribute__((packed));
 314
 315 static int convert_type86(struct zcrypt_device *zdev,
 316                           struct ap_message *reply,
 317                           char __user *outputdata,
 318                           unsigned int outputdatalength)
 319 {
 320         static unsigned char static_pad[] = {
 321                 0x00,0x02,
 322                 0x1B,0x7B,0x5D,0xB5,0x75,0x01,0x3D,0xFD,
 323                 0x8D,0xD1,0xC7,0x03,0x2D,0x09,0x23,0x57,
 324                 0x89,0x49,0xB9,0x3F,0xBB,0x99,0x41,0x5B,
 325                 0x75,0x21,0x7B,0x9D,0x3B,0x6B,0x51,0x39,
 326                 0xBB,0x0D,0x35,0xB9,0x89,0x0F,0x93,0xA5,
 327                 0x0B,0x47,0xF1,0xD3,0xBB,0xCB,0xF1,0x9D,
 328                 0x23,0x73,0x71,0xFF,0xF3,0xF5,0x45,0xFB,
 329                 0x61,0x29,0x23,0xFD,0xF1,0x29,0x3F,0x7F,
 330                 0x17,0xB7,0x1B,0xA9,0x19,0xBD,0x57,0xA9,
 331                 0xD7,0x95,0xA3,0xCB,0xED,0x1D,0xDB,0x45,
 332                 0x7D,0x11,0xD1,0x51,0x1B,0xED,0x71,0xE9,
 333                 0xB1,0xD1,0xAB,0xAB,0x21,0x2B,0x1B,0x9F,
 334                 0x3B,0x9F,0xF7,0xF7,0xBD,0x63,0xEB,0xAD,
 335                 0xDF,0xB3,0x6F,0x5B,0xDB,0x8D,0xA9,0x5D,
 336                 0xE3,0x7D,0x77,0x49,0x47,0xF5,0xA7,0xFD,
 337                 0xAB,0x2F,0x27,0x35,0x77,0xD3,0x49,0xC9,
 338                 0x09,0xEB,0xB1,0xF9,0xBF,0x4B,0xCB,0x2B,
 339                 0xEB,0xEB,0x05,0xFF,0x7D,0xC7,0x91,0x8B,
 340                 0x09,0x83,0xB9,0xB9,0x69,0x33,0x39,0x6B,
 341                 0x79,0x75,0x19,0xBF,0xBB,0x07,0x1D,0xBD,
 342                 0x29,0xBF,0x39,0x95,0x93,0x1D,0x35,0xC7,
 343                 0xC9,0x4D,0xE5,0x97,0x0B,0x43,0x9B,0xF1,
 344                 0x16,0x93,0x03,0x1F,0xA5,0xFB,0xDB,0xF3,
 345                 0x27,0x4F,0x27,0x61,0x05,0x1F,0xB9,0x23,
 346                 0x2F,0xC3,0x81,0xA9,0x23,0x71,0x55,0x55,
 347                 0xEB,0xED,0x41,0xE5,0xF3,0x11,0xF1,0x43,
 348                 0x69,0x03,0xBD,0x0B,0x37,0x0F,0x51,0x8F,
 349                 0x0B,0xB5,0x89,0x5B,0x67,0xA9,0xD9,0x4F,
 350                 0x01,0xF9,0x21,0x77,0x37,0x73,0x79,0xC5,
 351                 0x7F,0x51,0xC1,0xCF,0x97,0xA1,0x75,0xAD,
 352                 0x35,0x9D,0xD3,0xD3,0xA7,0x9D,0x5D,0x41,
 353                 0x6F,0x65,0x1B,0xCF,0xA9,0x87,0x91,0x09
 354         };
 355         struct type86_reply *msg = reply->message;
 356         unsigned short service_rc, service_rs;
 357         unsigned int reply_len, pad_len;
 358         char *data;
 359
 360         service_rc = le16_to_cpu(msg->cprb.ccp_rtcode);
 361         if (unlikely(service_rc != 0)) {
 362                 service_rs = le16_to_cpu(msg->cprb.ccp_rscode);
 363                 if (service_rc == 8 && service_rs == 66)
 364                         return -EINVAL;
 365                 if (service_rc == 8 && service_rs == 65)
 366                         return -EINVAL;
 367                 if (service_rc == 8 && service_rs == 770) {
 368                         zdev->max_mod_size = PCICC_MAX_MOD_SIZE_OLD;
 369                         return -EAGAIN;
 370                 }
 371                 if (service_rc == 8 && service_rs == 783) {
 372                         zdev->max_mod_size = PCICC_MAX_MOD_SIZE_OLD;
 373                         return -EAGAIN;
 374                 }
 375                 if (service_rc == 8 && service_rs == 72)
 376                         return -EINVAL;
 377                 zdev->online = 0;
 378                 pr_err("Cryptographic device %x failed and was set offline\n",
 379                        zdev->ap_dev->qid);
 380                 ZCRYPT_DBF_DEV(DBF_ERR, zdev, "dev%04xo%drc%d",
 381                                zdev->ap_dev->qid, zdev->online,
 382                                msg->hdr.reply_code);
 383                 return -EAGAIN; /* repeat the request on a different device. */
 384         }
 385         data = msg->text;
 386         reply_len = le16_to_cpu(msg->length) - 2;
 387         if (reply_len > outputdatalength)
 388                 return -EINVAL;
 389         /*
 390          * For all encipher requests, the length of the ciphertext (reply_len)
 391          * will always equal the modulus length. For MEX decipher requests
 392          * the output needs to get padded. Minimum pad size is 10.
 393          *
 394          * Currently, the cases where padding will be added is for:
 395          * - PCIXCC_MCL2 using a CRT form token (since PKD didn't support
 396          *   ZERO-PAD and CRT is only supported for PKD requests)
 397          * - PCICC, always
 398          */
 399         pad_len = outputdatalength - reply_len;
 400         if (pad_len > 0) {
 401                 if (pad_len < 10)
 402                         return -EINVAL;
 403                 /* 'restore' padding left in the PCICC/PCIXCC card. */
 404                 if (copy_to_user(outputdata, static_pad, pad_len - 1))
 405                         return -EFAULT;
 406                 if (put_user(0, outputdata + pad_len - 1))
 407                         return -EFAULT;
 408         }
 409         /* Copy the crypto response to user space. */
 410         if (copy_to_user(outputdata + pad_len, data, reply_len))
 411                 return -EFAULT;
 412         return 0;
 413 }
 414
 415 static int convert_response(struct zcrypt_device *zdev,
 416                             struct ap_message *reply,
 417                             char __user *outputdata,
 418                             unsigned int outputdatalength)
 419 {
 420         struct type86_reply *msg = reply->message;
 421
 422         /* Response type byte is the second byte in the response. */
 423         switch (msg->hdr.type) {
 424         case TYPE82_RSP_CODE:
 425         case TYPE88_RSP_CODE:
 426                 return convert_error(zdev, reply);
 427         case TYPE86_RSP_CODE:
 428                 if (msg->hdr.reply_code)
 429                         return convert_error(zdev, reply);
 430                 if (msg->cprb.cprb_ver_id == 0x01)
 431                         return convert_type86(zdev, reply,
 432                                               outputdata, outputdatalength);
 433                 /* no break, incorrect cprb version is an unknown response */
 434         default: /* Unknown response type, this should NEVER EVER happen */
 435                 zdev->online = 0;
 436                 pr_err("Cryptographic device %x failed and was set offline\n",
 437                        zdev->ap_dev->qid);
 438                 ZCRYPT_DBF_DEV(DBF_ERR, zdev, "dev%04xo%dfail",
 439                                zdev->ap_dev->qid, zdev->online);
 440                 return -EAGAIN; /* repeat the request on a different device. */
 441         }
 442 }
 443
 444 /**
 445  * This function is called from the AP bus code after a crypto request
 446  * "msg" has finished with the reply message "reply".
 447  * It is called from tasklet context.
 448  * @ap_dev: pointer to the AP device
 449  * @msg: pointer to the AP message
 450  * @reply: pointer to the AP reply message
 451  */
 452 static void zcrypt_pcicc_receive(struct ap_device *ap_dev,
 453                                  struct ap_message *msg,
 454                                  struct ap_message *reply)
 455 {
 456         static struct error_hdr error_reply = {
 457                 .type = TYPE82_RSP_CODE,
 458                 .reply_code = REP82_ERROR_MACHINE_FAILURE,
 459         };
 460         struct type86_reply *t86r;
 461         int length;
 462
 463         /* Copy the reply message to the request message buffer. */
 464         if (IS_ERR(reply)) {
 465                 memcpy(msg->message, &error_reply, sizeof(error_reply));
 466                 goto out;
 467         }
 468         t86r = reply->message;
 469         if (t86r->hdr.type == TYPE86_RSP_CODE &&
 470                  t86r->cprb.cprb_ver_id == 0x01) {
 471                 length = sizeof(struct type86_reply) + t86r->length - 2;
 472                 length = min(PCICC_MAX_RESPONSE_SIZE, length);
 473                 memcpy(msg->message, reply->message, length);
 474         } else
 475                 memcpy(msg->message, reply->message, sizeof error_reply);
 476 out:
 477         complete((struct completion *) msg->private);
 478 }
 479
 480 static atomic_t zcrypt_step = ATOMIC_INIT(0);
 481
 482 /**
 483  * The request distributor calls this function if it picked the PCICC
 484  * device to handle a modexpo request.
 485  * @zdev: pointer to zcrypt_device structure that identifies the
 486  *        PCICC device to the request distributor
 487  * @mex: pointer to the modexpo request buffer
 488  */
 489 static long zcrypt_pcicc_modexpo(struct zcrypt_device *zdev,
 490                                  struct ica_rsa_modexpo *mex)
 491 {
 492         struct ap_message ap_msg;
 493         struct completion work;
 494         int rc;
 495
 496         ap_init_message(&ap_msg);
 497         ap_msg.message = (void *) get_zeroed_page(GFP_KERNEL);
 498         if (!ap_msg.message)
 499                 return -ENOMEM;
 500         ap_msg.receive = zcrypt_pcicc_receive;
 501         ap_msg.length = PAGE_SIZE;
 502         ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
 503                                 atomic_inc_return(&zcrypt_step);
 504         ap_msg.private = &work;
 505         rc = ICAMEX_msg_to_type6MEX_msg(zdev, &ap_msg, mex);
 506         if (rc)
 507                 goto out_free;
 508         init_completion(&work);
 509         ap_queue_message(zdev->ap_dev, &ap_msg);
 510         rc = wait_for_completion_interruptible(&work);
 511         if (rc == 0)
 512                 rc = convert_response(zdev, &ap_msg, mex->outputdata,
 513                                       mex->outputdatalength);
 514         else
 515                 /* Signal pending. */
 516                 ap_cancel_message(zdev->ap_dev, &ap_msg);
 517 out_free:
 518         free_page((unsigned long) ap_msg.message);
 519         return rc;
 520 }
 521
 522 /**
 523  * The request distributor calls this function if it picked the PCICC
 524  * device to handle a modexpo_crt request.
 525  * @zdev: pointer to zcrypt_device structure that identifies the
 526  *        PCICC device to the request distributor
 527  * @crt: pointer to the modexpoc_crt request buffer
 528  */
 529 static long zcrypt_pcicc_modexpo_crt(struct zcrypt_device *zdev,
 530                                      struct ica_rsa_modexpo_crt *crt)
 531 {
 532         struct ap_message ap_msg;
 533         struct completion work;
 534         int rc;
 535
 536         ap_init_message(&ap_msg);
 537         ap_msg.message = (void *) get_zeroed_page(GFP_KERNEL);
 538         if (!ap_msg.message)
 539                 return -ENOMEM;
 540         ap_msg.receive = zcrypt_pcicc_receive;
 541         ap_msg.length = PAGE_SIZE;
 542         ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
 543                                 atomic_inc_return(&zcrypt_step);
 544         ap_msg.private = &work;
 545         rc = ICACRT_msg_to_type6CRT_msg(zdev, &ap_msg, crt);
 546         if (rc)
 547                 goto out_free;
 548         init_completion(&work);
 549         ap_queue_message(zdev->ap_dev, &ap_msg);
 550         rc = wait_for_completion_interruptible(&work);
 551         if (rc == 0)
 552                 rc = convert_response(zdev, &ap_msg, crt->outputdata,
 553                                       crt->outputdatalength);
 554         else
 555                 /* Signal pending. */
 556                 ap_cancel_message(zdev->ap_dev, &ap_msg);
 557 out_free:
 558         free_page((unsigned long) ap_msg.message);
 559         return rc;
 560 }
 561
 562 /**
 563  * The crypto operations for a PCICC card.
 564  */
 565 static struct zcrypt_ops zcrypt_pcicc_ops = {
 566         .rsa_modexpo = zcrypt_pcicc_modexpo,
 567         .rsa_modexpo_crt = zcrypt_pcicc_modexpo_crt,
 568 };
 569
 570 /**
 571  * Probe function for PCICC cards. It always accepts the AP device
 572  * since the bus_match already checked the hardware type.
 573  * @ap_dev: pointer to the AP device.
 574  */
 575 static int zcrypt_pcicc_probe(struct ap_device *ap_dev)
 576 {
 577         struct zcrypt_device *zdev;
 578         int rc;
 579
 580         zdev = zcrypt_device_alloc(PCICC_MAX_RESPONSE_SIZE);
 581         if (!zdev)
 582                 return -ENOMEM;
 583         zdev->ap_dev = ap_dev;
 584         zdev->ops = &zcrypt_pcicc_ops;
 585         zdev->online = 1;
 586         zdev->user_space_type = ZCRYPT_PCICC;
 587         zdev->type_string = "PCICC";
 588         zdev->min_mod_size = PCICC_MIN_MOD_SIZE;
 589         zdev->max_mod_size = PCICC_MAX_MOD_SIZE;
 590         zdev->speed_rating = PCICC_SPEED_RATING;
 591         zdev->max_exp_bit_length = PCICC_MAX_MOD_SIZE;
 592         ap_dev->reply = &zdev->reply;
 593         ap_dev->private = zdev;
 594         rc = zcrypt_device_register(zdev);
 595         if (rc)
 596                 goto out_free;
 597         return 0;
 598
 599  out_free:
 600         ap_dev->private = NULL;
 601         zcrypt_device_free(zdev);
 602         return rc;
 603 }
 604
 605 /**
 606  * This is called to remove the extended PCICC driver information
 607  * if an AP device is removed.
 608  */
 609 static void zcrypt_pcicc_remove(struct ap_device *ap_dev)
 610 {
 611         struct zcrypt_device *zdev = ap_dev->private;
 612
 613         zcrypt_device_unregister(zdev);
 614 }
 615
 616 int __init zcrypt_pcicc_init(void)
 617 {
 618         return ap_driver_register(&zcrypt_pcicc_driver, THIS_MODULE, "pcicc");
 619 }
 620
 621 void zcrypt_pcicc_exit(void)
 622 {
 623         ap_driver_unregister(&zcrypt_pcicc_driver);
 624 }
 625
 626 module_init(zcrypt_pcicc_init);
 627 module_exit(zcrypt_pcicc_exit);