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 };
  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                         PDEBUG("Bad block format on PCICC\n");
 365                         return -EINVAL;
 366                 }
 367                 if (service_rc == 8 && service_rs == 65) {
 368                         PDEBUG("Probably an even modulus on PCICC\n");
 369                         return -EINVAL;
 370                 }
 371                 if (service_rc == 8 && service_rs == 770) {
 372                         PDEBUG("Invalid key length on PCICC\n");
 373                         zdev->max_mod_size = PCICC_MAX_MOD_SIZE_OLD;
 374                         return -EAGAIN;
 375                 }
 376                 if (service_rc == 8 && service_rs == 783) {
 377                         PDEBUG("Extended bitlengths not enabled on PCICC\n");
 378                         zdev->max_mod_size = PCICC_MAX_MOD_SIZE_OLD;
 379                         return -EAGAIN;
 380                 }
 381                 PRINTK("Unknown service rc/rs (PCICC): %d/%d\n",
 382                        service_rc, service_rs);
 383                 zdev->online = 0;
 384                 return -EAGAIN; /* repeat the request on a different device. */
 385         }
 386         data = msg->text;
 387         reply_len = le16_to_cpu(msg->length) - 2;
 388         if (reply_len > outputdatalength)
 389                 return -EINVAL;
 390         /**
 391          * For all encipher requests, the length of the ciphertext (reply_len)
 392          * will always equal the modulus length. For MEX decipher requests
 393          * the output needs to get padded. Minimum pad size is 10.
 394          *
 395          * Currently, the cases where padding will be added is for:
 396          * - PCIXCC_MCL2 using a CRT form token (since PKD didn't support
 397          *   ZERO-PAD and CRT is only supported for PKD requests)
 398          * - PCICC, always
 399          */
 400         pad_len = outputdatalength - reply_len;
 401         if (pad_len > 0) {
 402                 if (pad_len < 10)
 403                         return -EINVAL;
 404                 /* 'restore' padding left in the PCICC/PCIXCC card. */
 405                 if (copy_to_user(outputdata, static_pad, pad_len - 1))
 406                         return -EFAULT;
 407                 if (put_user(0, outputdata + pad_len - 1))
 408                         return -EFAULT;
 409         }
 410         /* Copy the crypto response to user space. */
 411         if (copy_to_user(outputdata + pad_len, data, reply_len))
 412                 return -EFAULT;
 413         return 0;
 414 }
 415
 416 static int convert_response(struct zcrypt_device *zdev,
 417                             struct ap_message *reply,
 418                             char __user *outputdata,
 419                             unsigned int outputdatalength)
 420 {
 421         struct type86_reply *msg = reply->message;
 422
 423         /* Response type byte is the second byte in the response. */
 424         switch (msg->hdr.type) {
 425         case TYPE82_RSP_CODE:
 426         case TYPE88_RSP_CODE:
 427                 return convert_error(zdev, reply);
 428         case TYPE86_RSP_CODE:
 429                 if (msg->hdr.reply_code)
 430                         return convert_error(zdev, reply);
 431                 if (msg->cprb.cprb_ver_id == 0x01)
 432                         return convert_type86(zdev, reply,
 433                                               outputdata, outputdatalength);
 434                 /* no break, incorrect cprb version is an unknown response */
 435         default: /* Unknown response type, this should NEVER EVER happen */
 436                 PRINTK("Unrecognized Message Header: %08x%08x\n",
 437                        *(unsigned int *) reply->message,
 438                        *(unsigned int *) (reply->message+4));
 439                 zdev->online = 0;
 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 = reply->message;
 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         else if (t86r->hdr.type == TYPE86_RSP_CODE &&
 467                  t86r->cprb.cprb_ver_id == 0x01) {
 468                 length = sizeof(struct type86_reply) + t86r->length - 2;
 469                 length = min(PCICC_MAX_RESPONSE_SIZE, length);
 470                 memcpy(msg->message, reply->message, length);
 471         } else
 472                 memcpy(msg->message, reply->message, sizeof error_reply);
 473         complete((struct completion *) msg->private);
 474 }
 475
 476 static atomic_t zcrypt_step = ATOMIC_INIT(0);
 477
 478 /**
 479  * The request distributor calls this function if it picked the PCICC
 480  * device to handle a modexpo request.
 481  * @zdev: pointer to zcrypt_device structure that identifies the
 482  *        PCICC device to the request distributor
 483  * @mex: pointer to the modexpo request buffer
 484  */
 485 static long zcrypt_pcicc_modexpo(struct zcrypt_device *zdev,
 486                                  struct ica_rsa_modexpo *mex)
 487 {
 488         struct ap_message ap_msg;
 489         struct completion work;
 490         int rc;
 491
 492         ap_msg.message = (void *) get_zeroed_page(GFP_KERNEL);
 493         if (!ap_msg.message)
 494                 return -ENOMEM;
 495         ap_msg.length = PAGE_SIZE;
 496         ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
 497                                 atomic_inc_return(&zcrypt_step);
 498         ap_msg.private = &work;
 499         rc = ICAMEX_msg_to_type6MEX_msg(zdev, &ap_msg, mex);
 500         if (rc)
 501                 goto out_free;
 502         init_completion(&work);
 503         ap_queue_message(zdev->ap_dev, &ap_msg);
 504         rc = wait_for_completion_interruptible_timeout(
 505                                 &work, PCICC_CLEANUP_TIME);
 506         if (rc > 0)
 507                 rc = convert_response(zdev, &ap_msg, mex->outputdata,
 508                                       mex->outputdatalength);
 509         else {
 510                 /* Signal pending or message timed out. */
 511                 ap_cancel_message(zdev->ap_dev, &ap_msg);
 512                 if (rc == 0)
 513                         /* Message timed out. */
 514                         rc = -ETIME;
 515         }
 516 out_free:
 517         free_page((unsigned long) ap_msg.message);
 518         return rc;
 519 }
 520
 521 /**
 522  * The request distributor calls this function if it picked the PCICC
 523  * device to handle a modexpo_crt request.
 524  * @zdev: pointer to zcrypt_device structure that identifies the
 525  *        PCICC device to the request distributor
 526  * @crt: pointer to the modexpoc_crt request buffer
 527  */
 528 static long zcrypt_pcicc_modexpo_crt(struct zcrypt_device *zdev,
 529                                      struct ica_rsa_modexpo_crt *crt)
 530 {
 531         struct ap_message ap_msg;
 532         struct completion work;
 533         int rc;
 534
 535         ap_msg.message = (void *) get_zeroed_page(GFP_KERNEL);
 536         if (!ap_msg.message)
 537                 return -ENOMEM;
 538         ap_msg.length = PAGE_SIZE;
 539         ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
 540                                 atomic_inc_return(&zcrypt_step);
 541         ap_msg.private = &work;
 542         rc = ICACRT_msg_to_type6CRT_msg(zdev, &ap_msg, crt);
 543         if (rc)
 544                 goto out_free;
 545         init_completion(&work);
 546         ap_queue_message(zdev->ap_dev, &ap_msg);
 547         rc = wait_for_completion_interruptible_timeout(
 548                                 &work, PCICC_CLEANUP_TIME);
 549         if (rc > 0)
 550                 rc = convert_response(zdev, &ap_msg, crt->outputdata,
 551                                       crt->outputdatalength);
 552         else {
 553                 /* Signal pending or message timed out. */
 554                 ap_cancel_message(zdev->ap_dev, &ap_msg);
 555                 if (rc == 0)
 556                         /* Message timed out. */
 557                         rc = -ETIME;
 558         }
 559 out_free:
 560         free_page((unsigned long) ap_msg.message);
 561         return rc;
 562 }
 563
 564 /**
 565  * The crypto operations for a PCICC card.
 566  */
 567 static struct zcrypt_ops zcrypt_pcicc_ops = {
 568         .rsa_modexpo = zcrypt_pcicc_modexpo,
 569         .rsa_modexpo_crt = zcrypt_pcicc_modexpo_crt,
 570 };
 571
 572 /**
 573  * Probe function for PCICC cards. It always accepts the AP device
 574  * since the bus_match already checked the hardware type.
 575  * @ap_dev: pointer to the AP device.
 576  */
 577 static int zcrypt_pcicc_probe(struct ap_device *ap_dev)
 578 {
 579         struct zcrypt_device *zdev;
 580         int rc;
 581
 582         zdev = zcrypt_device_alloc(PCICC_MAX_RESPONSE_SIZE);
 583         if (!zdev)
 584                 return -ENOMEM;
 585         zdev->ap_dev = ap_dev;
 586         zdev->ops = &zcrypt_pcicc_ops;
 587         zdev->online = 1;
 588         zdev->user_space_type = ZCRYPT_PCICC;
 589         zdev->type_string = "PCICC";
 590         zdev->min_mod_size = PCICC_MIN_MOD_SIZE;
 591         zdev->max_mod_size = PCICC_MAX_MOD_SIZE;
 592         zdev->speed_rating = PCICC_SPEED_RATING;
 593         ap_dev->reply = &zdev->reply;
 594         ap_dev->private = zdev;
 595         rc = zcrypt_device_register(zdev);
 596         if (rc)
 597                 goto out_free;
 598         return 0;
 599
 600  out_free:
 601         ap_dev->private = NULL;
 602         zcrypt_device_free(zdev);
 603         return rc;
 604 }
 605
 606 /**
 607  * This is called to remove the extended PCICC driver information
 608  * if an AP device is removed.
 609  */
 610 static void zcrypt_pcicc_remove(struct ap_device *ap_dev)
 611 {
 612         struct zcrypt_device *zdev = ap_dev->private;
 613
 614         zcrypt_device_unregister(zdev);
 615 }
 616
 617 int __init zcrypt_pcicc_init(void)
 618 {
 619         return ap_driver_register(&zcrypt_pcicc_driver, THIS_MODULE, "pcicc");
 620 }
 621
 622 void zcrypt_pcicc_exit(void)
 623 {
 624         ap_driver_unregister(&zcrypt_pcicc_driver);
 625 }
 626
 627 #ifndef CONFIG_ZCRYPT_MONOLITHIC
 628 module_init(zcrypt_pcicc_init);
 629 module_exit(zcrypt_pcicc_exit);
 630 #endif