drivers/s390/crypto/zcrypt_pcicc.c

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