drivers/s390/crypto/zcrypt_msgtype6.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  *
   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  *  MSGTYPE restruct:             Holger Dengler <hd@linux.vnet.ibm.com>
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2, or (at your option)
  16  * any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  26  */
  27
  28 #define KMSG_COMPONENT "zcrypt"
  29 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  30
  31 #include <linux/module.h>
  32 #include <linux/init.h>
  33 #include <linux/err.h>
  34 #include <linux/delay.h>
  35 #include <linux/slab.h>
  36 #include <linux/atomic.h>
  37 #include <linux/uaccess.h>
  38
  39 #include "ap_bus.h"
  40 #include "zcrypt_api.h"
  41 #include "zcrypt_error.h"
  42 #include "zcrypt_msgtype6.h"
  43 #include "zcrypt_cca_key.h"
  44
  45 #define PCIXCC_MIN_MOD_SIZE_OLD  64     /*  512 bits    */
  46 #define PCIXCC_MAX_ICA_RESPONSE_SIZE 0x77c /* max size type86 v2 reply      */
  47
  48 #define CEIL4(x) ((((x)+3)/4)*4)
  49
  50 struct response_type {
  51         struct completion work;
  52         int type;
  53 };
  54 #define PCIXCC_RESPONSE_TYPE_ICA  0
  55 #define PCIXCC_RESPONSE_TYPE_XCRB 1
  56 #define PCIXCC_RESPONSE_TYPE_EP11 2
  57
  58 MODULE_AUTHOR("IBM Corporation");
  59 MODULE_DESCRIPTION("Cryptographic Coprocessor (message type 6), " \
  60                    "Copyright IBM Corp. 2001, 2012");
  61 MODULE_LICENSE("GPL");
  62
  63 /**
  64  * CPRB
  65  *        Note that all shorts, ints and longs are little-endian.
  66  *        All pointer fields are 32-bits long, and mean nothing
  67  *
  68  *        A request CPRB is followed by a request_parameter_block.
  69  *
  70  *        The request (or reply) parameter block is organized thus:
  71  *          function code
  72  *          VUD block
  73  *          key block
  74  */
  75 struct CPRB {
  76         unsigned short cprb_len;        /* CPRB length                   */
  77         unsigned char cprb_ver_id;      /* CPRB version id.              */
  78         unsigned char pad_000;          /* Alignment pad byte.           */
  79         unsigned char srpi_rtcode[4];   /* SRPI return code LELONG       */
  80         unsigned char srpi_verb;        /* SRPI verb type                */
  81         unsigned char flags;            /* flags                         */
  82         unsigned char func_id[2];       /* function id                   */
  83         unsigned char checkpoint_flag;  /*                               */
  84         unsigned char resv2;            /* reserved                      */
  85         unsigned short req_parml;       /* request parameter buffer      */
  86                                         /* length 16-bit little endian   */
  87         unsigned char req_parmp[4];     /* request parameter buffer      *
  88                                          * pointer (means nothing: the   *
  89                                          * parameter buffer follows      *
  90                                          * the CPRB).                    */
  91         unsigned char req_datal[4];     /* request data buffer           */
  92                                         /* length         ULELONG        */
  93         unsigned char req_datap[4];     /* request data buffer           */
  94                                         /* pointer                       */
  95         unsigned short rpl_parml;       /* reply  parameter buffer       */
  96                                         /* length 16-bit little endian   */
  97         unsigned char pad_001[2];       /* Alignment pad bytes. ULESHORT */
  98         unsigned char rpl_parmp[4];     /* reply parameter buffer        *
  99                                          * pointer (means nothing: the   *
 100                                          * parameter buffer follows      *
 101                                          * the CPRB).                    */
 102         unsigned char rpl_datal[4];     /* reply data buffer len ULELONG */
 103         unsigned char rpl_datap[4];     /* reply data buffer             */
 104                                         /* pointer                       */
 105         unsigned short ccp_rscode;      /* server reason code   ULESHORT */
 106         unsigned short ccp_rtcode;      /* server return code   ULESHORT */
 107         unsigned char repd_parml[2];    /* replied parameter len ULESHORT*/
 108         unsigned char mac_data_len[2];  /* Mac Data Length      ULESHORT */
 109         unsigned char repd_datal[4];    /* replied data length  ULELONG  */
 110         unsigned char req_pc[2];        /* PC identifier                 */
 111         unsigned char res_origin[8];    /* resource origin               */
 112         unsigned char mac_value[8];     /* Mac Value                     */
 113         unsigned char logon_id[8];      /* Logon Identifier              */
 114         unsigned char usage_domain[2];  /* cdx                           */
 115         unsigned char resv3[18];        /* reserved for requestor        */
 116         unsigned short svr_namel;       /* server name length  ULESHORT  */
 117         unsigned char svr_name[8];      /* server name                   */
 118 } __packed;
 119
 120 struct function_and_rules_block {
 121         unsigned char function_code[2];
 122         unsigned short ulen;
 123         unsigned char only_rule[8];
 124 } __packed;
 125
 126 /**
 127  * The following is used to initialize the CPRBX passed to the PCIXCC/CEX2C
 128  * card in a type6 message. The 3 fields that must be filled in at execution
 129  * time are  req_parml, rpl_parml and usage_domain.
 130  * Everything about this interface is ascii/big-endian, since the
 131  * device does *not* have 'Intel inside'.
 132  *
 133  * The CPRBX is followed immediately by the parm block.
 134  * The parm block contains:
 135  * - function code ('PD' 0x5044 or 'PK' 0x504B)
 136  * - rule block (one of:)
 137  *   + 0x000A 'PKCS-1.2' (MCL2 'PD')
 138  *   + 0x000A 'ZERO-PAD' (MCL2 'PK')
 139  *   + 0x000A 'ZERO-PAD' (MCL3 'PD' or CEX2C 'PD')
 140  *   + 0x000A 'MRP     ' (MCL3 'PK' or CEX2C 'PK')
 141  * - VUD block
 142  */
 143 static const struct CPRBX static_cprbx = {
 144         .cprb_len       =  0x00DC,
 145         .cprb_ver_id    =  0x02,
 146         .func_id        = {0x54, 0x32},
 147 };
 148
 149 int speed_idx_cca(int req_type)
 150 {
 151         switch (req_type) {
 152         case 0x4142:
 153         case 0x4149:
 154         case 0x414D:
 155         case 0x4341:
 156         case 0x4344:
 157         case 0x4354:
 158         case 0x4358:
 159         case 0x444B:
 160         case 0x4558:
 161         case 0x4643:
 162         case 0x4651:
 163         case 0x4C47:
 164         case 0x4C4B:
 165         case 0x4C51:
 166         case 0x4F48:
 167         case 0x504F:
 168         case 0x5053:
 169         case 0x5058:
 170         case 0x5343:
 171         case 0x5344:
 172         case 0x5345:
 173         case 0x5350:
 174                 return LOW;
 175         case 0x414B:
 176         case 0x4345:
 177         case 0x4349:
 178         case 0x434D:
 179         case 0x4847:
 180         case 0x4849:
 181         case 0x484D:
 182         case 0x4850:
 183         case 0x4851:
 184         case 0x4954:
 185         case 0x4958:
 186         case 0x4B43:
 187         case 0x4B44:
 188         case 0x4B45:
 189         case 0x4B47:
 190         case 0x4B48:
 191         case 0x4B49:
 192         case 0x4B4E:
 193         case 0x4B50:
 194         case 0x4B52:
 195         case 0x4B54:
 196         case 0x4B58:
 197         case 0x4D50:
 198         case 0x4D53:
 199         case 0x4D56:
 200         case 0x4D58:
 201         case 0x5044:
 202         case 0x5045:
 203         case 0x5046:
 204         case 0x5047:
 205         case 0x5049:
 206         case 0x504B:
 207         case 0x504D:
 208         case 0x5254:
 209         case 0x5347:
 210         case 0x5349:
 211         case 0x534B:
 212         case 0x534D:
 213         case 0x5356:
 214         case 0x5358:
 215         case 0x5443:
 216         case 0x544B:
 217         case 0x5647:
 218                 return HIGH;
 219         default:
 220                 return MEDIUM;
 221         }
 222 }
 223
 224 int speed_idx_ep11(int req_type)
 225 {
 226         switch (req_type) {
 227         case  1:
 228         case  2:
 229         case 36:
 230         case 37:
 231         case 38:
 232         case 39:
 233         case 40:
 234                 return LOW;
 235         case 17:
 236         case 18:
 237         case 19:
 238         case 20:
 239         case 21:
 240         case 22:
 241         case 26:
 242         case 30:
 243         case 31:
 244         case 32:
 245         case 33:
 246         case 34:
 247         case 35:
 248                 return HIGH;
 249         default:
 250                 return MEDIUM;
 251         }
 252 }
 253
 254
 255 /**
 256  * Convert a ICAMEX message to a type6 MEX message.
 257  *
 258  * @zq: crypto device pointer
 259  * @ap_msg: pointer to AP message
 260  * @mex: pointer to user input data
 261  *
 262  * Returns 0 on success or -EFAULT.
 263  */
 264 static int ICAMEX_msg_to_type6MEX_msgX(struct zcrypt_queue *zq,
 265                                        struct ap_message *ap_msg,
 266                                        struct ica_rsa_modexpo *mex)
 267 {
 268         static struct type6_hdr static_type6_hdrX = {
 269                 .type           =  0x06,
 270                 .offset1        =  0x00000058,
 271                 .agent_id       = {'C', 'A',},
 272                 .function_code  = {'P', 'K'},
 273         };
 274         static struct function_and_rules_block static_pke_fnr = {
 275                 .function_code  = {'P', 'K'},
 276                 .ulen           = 10,
 277                 .only_rule      = {'M', 'R', 'P', ' ', ' ', ' ', ' ', ' '}
 278         };
 279         struct {
 280                 struct type6_hdr hdr;
 281                 struct CPRBX cprbx;
 282                 struct function_and_rules_block fr;
 283                 unsigned short length;
 284                 char text[0];
 285         } __packed * msg = ap_msg->message;
 286         int size;
 287
 288         /* VUD.ciphertext */
 289         msg->length = mex->inputdatalength + 2;
 290         if (copy_from_user(msg->text, mex->inputdata, mex->inputdatalength))
 291                 return -EFAULT;
 292
 293         /* Set up key which is located after the variable length text. */
 294         size = zcrypt_type6_mex_key_en(mex, msg->text+mex->inputdatalength);
 295         if (size < 0)
 296                 return size;
 297         size += sizeof(*msg) + mex->inputdatalength;
 298
 299         /* message header, cprbx and f&r */
 300         msg->hdr = static_type6_hdrX;
 301         msg->hdr.ToCardLen1 = size - sizeof(msg->hdr);
 302         msg->hdr.FromCardLen1 = PCIXCC_MAX_ICA_RESPONSE_SIZE - sizeof(msg->hdr);
 303
 304         msg->cprbx = static_cprbx;
 305         msg->cprbx.domain = AP_QID_QUEUE(zq->queue->qid);
 306         msg->cprbx.rpl_msgbl = msg->hdr.FromCardLen1;
 307
 308         msg->fr = static_pke_fnr;
 309
 310         msg->cprbx.req_parml = size - sizeof(msg->hdr) - sizeof(msg->cprbx);
 311
 312         ap_msg->length = size;
 313         return 0;
 314 }
 315
 316 /**
 317  * Convert a ICACRT message to a type6 CRT message.
 318  *
 319  * @zq: crypto device pointer
 320  * @ap_msg: pointer to AP message
 321  * @crt: pointer to user input data
 322  *
 323  * Returns 0 on success or -EFAULT.
 324  */
 325 static int ICACRT_msg_to_type6CRT_msgX(struct zcrypt_queue *zq,
 326                                        struct ap_message *ap_msg,
 327                                        struct ica_rsa_modexpo_crt *crt)
 328 {
 329         static struct type6_hdr static_type6_hdrX = {
 330                 .type           =  0x06,
 331                 .offset1        =  0x00000058,
 332                 .agent_id       = {'C', 'A',},
 333                 .function_code  = {'P', 'D'},
 334         };
 335         static struct function_and_rules_block static_pkd_fnr = {
 336                 .function_code  = {'P', 'D'},
 337                 .ulen           = 10,
 338                 .only_rule      = {'Z', 'E', 'R', 'O', '-', 'P', 'A', 'D'}
 339         };
 340
 341         struct {
 342                 struct type6_hdr hdr;
 343                 struct CPRBX cprbx;
 344                 struct function_and_rules_block fr;
 345                 unsigned short length;
 346                 char text[0];
 347         } __packed * msg = ap_msg->message;
 348         int size;
 349
 350         /* VUD.ciphertext */
 351         msg->length = crt->inputdatalength + 2;
 352         if (copy_from_user(msg->text, crt->inputdata, crt->inputdatalength))
 353                 return -EFAULT;
 354
 355         /* Set up key which is located after the variable length text. */
 356         size = zcrypt_type6_crt_key(crt, msg->text + crt->inputdatalength);
 357         if (size < 0)
 358                 return size;
 359         size += sizeof(*msg) + crt->inputdatalength;    /* total size of msg */
 360
 361         /* message header, cprbx and f&r */
 362         msg->hdr = static_type6_hdrX;
 363         msg->hdr.ToCardLen1 = size -  sizeof(msg->hdr);
 364         msg->hdr.FromCardLen1 = PCIXCC_MAX_ICA_RESPONSE_SIZE - sizeof(msg->hdr);
 365
 366         msg->cprbx = static_cprbx;
 367         msg->cprbx.domain = AP_QID_QUEUE(zq->queue->qid);
 368         msg->cprbx.req_parml = msg->cprbx.rpl_msgbl =
 369                 size - sizeof(msg->hdr) - sizeof(msg->cprbx);
 370
 371         msg->fr = static_pkd_fnr;
 372
 373         ap_msg->length = size;
 374         return 0;
 375 }
 376
 377 /**
 378  * Convert a XCRB message to a type6 CPRB message.
 379  *
 380  * @zq: crypto device pointer
 381  * @ap_msg: pointer to AP message
 382  * @xcRB: pointer to user input data
 383  *
 384  * Returns 0 on success or -EFAULT, -EINVAL.
 385  */
 386 struct type86_fmt2_msg {
 387         struct type86_hdr hdr;
 388         struct type86_fmt2_ext fmt2;
 389 } __packed;
 390
 391 static int XCRB_msg_to_type6CPRB_msgX(struct ap_message *ap_msg,
 392                                       struct ica_xcRB *xcRB,
 393                                       unsigned int *fcode,
 394                                       unsigned short **dom)
 395 {
 396         static struct type6_hdr static_type6_hdrX = {
 397                 .type           =  0x06,
 398                 .offset1        =  0x00000058,
 399         };
 400         struct {
 401                 struct type6_hdr hdr;
 402                 struct CPRBX cprbx;
 403         } __packed * msg = ap_msg->message;
 404
 405         int rcblen = CEIL4(xcRB->request_control_blk_length);
 406         int replylen, req_sumlen, resp_sumlen;
 407         char *req_data = ap_msg->message + sizeof(struct type6_hdr) + rcblen;
 408         char *function_code;
 409
 410         if (CEIL4(xcRB->request_control_blk_length) <
 411                         xcRB->request_control_blk_length)
 412                 return -EINVAL; /* overflow after alignment*/
 413
 414         /* length checks */
 415         ap_msg->length = sizeof(struct type6_hdr) +
 416                 CEIL4(xcRB->request_control_blk_length) +
 417                 xcRB->request_data_length;
 418         if (ap_msg->length > MSGTYPE06_MAX_MSG_SIZE)
 419                 return -EINVAL;
 420
 421         /* Overflow check
 422            sum must be greater (or equal) than the largest operand */
 423         req_sumlen = CEIL4(xcRB->request_control_blk_length) +
 424                         xcRB->request_data_length;
 425         if ((CEIL4(xcRB->request_control_blk_length) <=
 426                                                 xcRB->request_data_length) ?
 427                 (req_sumlen < xcRB->request_data_length) :
 428                 (req_sumlen < CEIL4(xcRB->request_control_blk_length))) {
 429                 return -EINVAL;
 430         }
 431
 432         if (CEIL4(xcRB->reply_control_blk_length) <
 433                         xcRB->reply_control_blk_length)
 434                 return -EINVAL; /* overflow after alignment*/
 435
 436         replylen = sizeof(struct type86_fmt2_msg) +
 437                 CEIL4(xcRB->reply_control_blk_length) +
 438                 xcRB->reply_data_length;
 439         if (replylen > MSGTYPE06_MAX_MSG_SIZE)
 440                 return -EINVAL;
 441
 442         /* Overflow check
 443            sum must be greater (or equal) than the largest operand */
 444         resp_sumlen = CEIL4(xcRB->reply_control_blk_length) +
 445                         xcRB->reply_data_length;
 446         if ((CEIL4(xcRB->reply_control_blk_length) <= xcRB->reply_data_length) ?
 447                 (resp_sumlen < xcRB->reply_data_length) :
 448                 (resp_sumlen < CEIL4(xcRB->reply_control_blk_length))) {
 449                 return -EINVAL;
 450         }
 451
 452         /* prepare type6 header */
 453         msg->hdr = static_type6_hdrX;
 454         memcpy(msg->hdr.agent_id , &(xcRB->agent_ID), sizeof(xcRB->agent_ID));
 455         msg->hdr.ToCardLen1 = xcRB->request_control_blk_length;
 456         if (xcRB->request_data_length) {
 457                 msg->hdr.offset2 = msg->hdr.offset1 + rcblen;
 458                 msg->hdr.ToCardLen2 = xcRB->request_data_length;
 459         }
 460         msg->hdr.FromCardLen1 = xcRB->reply_control_blk_length;
 461         msg->hdr.FromCardLen2 = xcRB->reply_data_length;
 462
 463         /* prepare CPRB */
 464         if (copy_from_user(&(msg->cprbx), xcRB->request_control_blk_addr,
 465                     xcRB->request_control_blk_length))
 466                 return -EFAULT;
 467         if (msg->cprbx.cprb_len + sizeof(msg->hdr.function_code) >
 468             xcRB->request_control_blk_length)
 469                 return -EINVAL;
 470         function_code = ((unsigned char *)&msg->cprbx) + msg->cprbx.cprb_len;
 471         memcpy(msg->hdr.function_code, function_code,
 472                sizeof(msg->hdr.function_code));
 473
 474         *fcode = (msg->hdr.function_code[0] << 8) | msg->hdr.function_code[1];
 475         *dom = (unsigned short *)&msg->cprbx.domain;
 476
 477         if (memcmp(function_code, "US", 2) == 0)
 478                 ap_msg->special = 1;
 479         else
 480                 ap_msg->special = 0;
 481
 482         /* copy data block */
 483         if (xcRB->request_data_length &&
 484             copy_from_user(req_data, xcRB->request_data_address,
 485                 xcRB->request_data_length))
 486                 return -EFAULT;
 487
 488         return 0;
 489 }
 490
 491 static int xcrb_msg_to_type6_ep11cprb_msgx(struct ap_message *ap_msg,
 492                                        struct ep11_urb *xcRB,
 493                                        unsigned int *fcode)
 494 {
 495         unsigned int lfmt;
 496         static struct type6_hdr static_type6_ep11_hdr = {
 497                 .type           =  0x06,
 498                 .rqid           = {0x00, 0x01},
 499                 .function_code  = {0x00, 0x00},
 500                 .agent_id[0]    =  0x58,        /* {'X'} */
 501                 .agent_id[1]    =  0x43,        /* {'C'} */
 502                 .offset1        =  0x00000058,
 503         };
 504
 505         struct {
 506                 struct type6_hdr hdr;
 507                 struct ep11_cprb cprbx;
 508                 unsigned char   pld_tag;        /* fixed value 0x30 */
 509                 unsigned char   pld_lenfmt;     /* payload length format */
 510         } __packed * msg = ap_msg->message;
 511
 512         struct pld_hdr {
 513                 unsigned char   func_tag;       /* fixed value 0x4 */
 514                 unsigned char   func_len;       /* fixed value 0x4 */
 515                 unsigned int    func_val;       /* function ID     */
 516                 unsigned char   dom_tag;        /* fixed value 0x4 */
 517                 unsigned char   dom_len;        /* fixed value 0x4 */
 518                 unsigned int    dom_val;        /* domain id       */
 519         } __packed * payload_hdr = NULL;
 520
 521         if (CEIL4(xcRB->req_len) < xcRB->req_len)
 522                 return -EINVAL; /* overflow after alignment*/
 523
 524         /* length checks */
 525         ap_msg->length = sizeof(struct type6_hdr) + xcRB->req_len;
 526         if (CEIL4(xcRB->req_len) > MSGTYPE06_MAX_MSG_SIZE -
 527                                    (sizeof(struct type6_hdr)))
 528                 return -EINVAL;
 529
 530         if (CEIL4(xcRB->resp_len) < xcRB->resp_len)
 531                 return -EINVAL; /* overflow after alignment*/
 532
 533         if (CEIL4(xcRB->resp_len) > MSGTYPE06_MAX_MSG_SIZE -
 534                                     (sizeof(struct type86_fmt2_msg)))
 535                 return -EINVAL;
 536
 537         /* prepare type6 header */
 538         msg->hdr = static_type6_ep11_hdr;
 539         msg->hdr.ToCardLen1   = xcRB->req_len;
 540         msg->hdr.FromCardLen1 = xcRB->resp_len;
 541
 542         /* Import CPRB data from the ioctl input parameter */
 543         if (copy_from_user(&(msg->cprbx.cprb_len),
 544                            (char __force __user *)xcRB->req, xcRB->req_len)) {
 545                 return -EFAULT;
 546         }
 547
 548         if ((msg->pld_lenfmt & 0x80) == 0x80) { /*ext.len.fmt 2 or 3*/
 549                 switch (msg->pld_lenfmt & 0x03) {
 550                 case 1:
 551                         lfmt = 2;
 552                         break;
 553                 case 2:
 554                         lfmt = 3;
 555                         break;
 556                 default:
 557                         return -EINVAL;
 558                 }
 559         } else {
 560                 lfmt = 1; /* length format #1 */
 561         }
 562         payload_hdr = (struct pld_hdr *)((&(msg->pld_lenfmt))+lfmt);
 563         *fcode = payload_hdr->func_val & 0xFFFF;
 564
 565         return 0;
 566 }
 567
 568 /**
 569  * Copy results from a type 86 ICA reply message back to user space.
 570  *
 571  * @zq: crypto device pointer
 572  * @reply: reply AP message.
 573  * @data: pointer to user output data
 574  * @length: size of user output data
 575  *
 576  * Returns 0 on success or -EINVAL, -EFAULT, -EAGAIN in case of an error.
 577  */
 578 struct type86x_reply {
 579         struct type86_hdr hdr;
 580         struct type86_fmt2_ext fmt2;
 581         struct CPRBX cprbx;
 582         unsigned char pad[4];   /* 4 byte function code/rules block ? */
 583         unsigned short length;
 584         char text[0];
 585 } __packed;
 586
 587 struct type86_ep11_reply {
 588         struct type86_hdr hdr;
 589         struct type86_fmt2_ext fmt2;
 590         struct ep11_cprb cprbx;
 591 } __packed;
 592
 593 static int convert_type86_ica(struct zcrypt_queue *zq,
 594                           struct ap_message *reply,
 595                           char __user *outputdata,
 596                           unsigned int outputdatalength)
 597 {
 598         static unsigned char static_pad[] = {
 599                 0x00, 0x02,
 600                 0x1B, 0x7B, 0x5D, 0xB5, 0x75, 0x01, 0x3D, 0xFD,
 601                 0x8D, 0xD1, 0xC7, 0x03, 0x2D, 0x09, 0x23, 0x57,
 602                 0x89, 0x49, 0xB9, 0x3F, 0xBB, 0x99, 0x41, 0x5B,
 603                 0x75, 0x21, 0x7B, 0x9D, 0x3B, 0x6B, 0x51, 0x39,
 604                 0xBB, 0x0D, 0x35, 0xB9, 0x89, 0x0F, 0x93, 0xA5,
 605                 0x0B, 0x47, 0xF1, 0xD3, 0xBB, 0xCB, 0xF1, 0x9D,
 606                 0x23, 0x73, 0x71, 0xFF, 0xF3, 0xF5, 0x45, 0xFB,
 607                 0x61, 0x29, 0x23, 0xFD, 0xF1, 0x29, 0x3F, 0x7F,
 608                 0x17, 0xB7, 0x1B, 0xA9, 0x19, 0xBD, 0x57, 0xA9,
 609                 0xD7, 0x95, 0xA3, 0xCB, 0xED, 0x1D, 0xDB, 0x45,
 610                 0x7D, 0x11, 0xD1, 0x51, 0x1B, 0xED, 0x71, 0xE9,
 611                 0xB1, 0xD1, 0xAB, 0xAB, 0x21, 0x2B, 0x1B, 0x9F,
 612                 0x3B, 0x9F, 0xF7, 0xF7, 0xBD, 0x63, 0xEB, 0xAD,
 613                 0xDF, 0xB3, 0x6F, 0x5B, 0xDB, 0x8D, 0xA9, 0x5D,
 614                 0xE3, 0x7D, 0x77, 0x49, 0x47, 0xF5, 0xA7, 0xFD,
 615                 0xAB, 0x2F, 0x27, 0x35, 0x77, 0xD3, 0x49, 0xC9,
 616                 0x09, 0xEB, 0xB1, 0xF9, 0xBF, 0x4B, 0xCB, 0x2B,
 617                 0xEB, 0xEB, 0x05, 0xFF, 0x7D, 0xC7, 0x91, 0x8B,
 618                 0x09, 0x83, 0xB9, 0xB9, 0x69, 0x33, 0x39, 0x6B,
 619                 0x79, 0x75, 0x19, 0xBF, 0xBB, 0x07, 0x1D, 0xBD,
 620                 0x29, 0xBF, 0x39, 0x95, 0x93, 0x1D, 0x35, 0xC7,
 621                 0xC9, 0x4D, 0xE5, 0x97, 0x0B, 0x43, 0x9B, 0xF1,
 622                 0x16, 0x93, 0x03, 0x1F, 0xA5, 0xFB, 0xDB, 0xF3,
 623                 0x27, 0x4F, 0x27, 0x61, 0x05, 0x1F, 0xB9, 0x23,
 624                 0x2F, 0xC3, 0x81, 0xA9, 0x23, 0x71, 0x55, 0x55,
 625                 0xEB, 0xED, 0x41, 0xE5, 0xF3, 0x11, 0xF1, 0x43,
 626                 0x69, 0x03, 0xBD, 0x0B, 0x37, 0x0F, 0x51, 0x8F,
 627                 0x0B, 0xB5, 0x89, 0x5B, 0x67, 0xA9, 0xD9, 0x4F,
 628                 0x01, 0xF9, 0x21, 0x77, 0x37, 0x73, 0x79, 0xC5,
 629                 0x7F, 0x51, 0xC1, 0xCF, 0x97, 0xA1, 0x75, 0xAD,
 630                 0x35, 0x9D, 0xD3, 0xD3, 0xA7, 0x9D, 0x5D, 0x41,
 631                 0x6F, 0x65, 0x1B, 0xCF, 0xA9, 0x87, 0x91, 0x09
 632         };
 633         struct type86x_reply *msg = reply->message;
 634         unsigned short service_rc, service_rs;
 635         unsigned int reply_len, pad_len;
 636         char *data;
 637
 638         service_rc = msg->cprbx.ccp_rtcode;
 639         if (unlikely(service_rc != 0)) {
 640                 service_rs = msg->cprbx.ccp_rscode;
 641                 if ((service_rc == 8 && service_rs == 66) ||
 642                     (service_rc == 8 && service_rs == 65) ||
 643                     (service_rc == 8 && service_rs == 72) ||
 644                     (service_rc == 8 && service_rs == 770) ||
 645                     (service_rc == 12 && service_rs == 769)) {
 646                         ZCRYPT_DBF(DBF_DEBUG,
 647                                    "device=%02x.%04x rc/rs=%d/%d => rc=EINVAL\n",
 648                                    AP_QID_CARD(zq->queue->qid),
 649                                    AP_QID_QUEUE(zq->queue->qid),
 650                                    (int) service_rc, (int) service_rs);
 651                         return -EINVAL;
 652                 }
 653                 if (service_rc == 8 && service_rs == 783) {
 654                         zq->zcard->min_mod_size =
 655                                 PCIXCC_MIN_MOD_SIZE_OLD;
 656                         ZCRYPT_DBF(DBF_DEBUG,
 657                                    "device=%02x.%04x rc/rs=%d/%d => rc=EAGAIN\n",
 658                                    AP_QID_CARD(zq->queue->qid),
 659                                    AP_QID_QUEUE(zq->queue->qid),
 660                                    (int) service_rc, (int) service_rs);
 661                         return -EAGAIN;
 662                 }
 663                 zq->online = 0;
 664                 pr_err("Cryptographic device %02x.%04x failed and was set offline\n",
 665                        AP_QID_CARD(zq->queue->qid),
 666                        AP_QID_QUEUE(zq->queue->qid));
 667                 ZCRYPT_DBF(DBF_ERR,
 668                            "device=%02x.%04x rc/rs=%d/%d => online=0 rc=EAGAIN\n",
 669                            AP_QID_CARD(zq->queue->qid),
 670                            AP_QID_QUEUE(zq->queue->qid),
 671                            (int) service_rc, (int) service_rs);
 672                 return -EAGAIN; /* repeat the request on a different device. */
 673         }
 674         data = msg->text;
 675         reply_len = msg->length - 2;
 676         if (reply_len > outputdatalength)
 677                 return -EINVAL;
 678         /*
 679          * For all encipher requests, the length of the ciphertext (reply_len)
 680          * will always equal the modulus length. For MEX decipher requests
 681          * the output needs to get padded. Minimum pad size is 10.
 682          *
 683          * Currently, the cases where padding will be added is for:
 684          * - PCIXCC_MCL2 using a CRT form token (since PKD didn't support
 685          *   ZERO-PAD and CRT is only supported for PKD requests)
 686          * - PCICC, always
 687          */
 688         pad_len = outputdatalength - reply_len;
 689         if (pad_len > 0) {
 690                 if (pad_len < 10)
 691                         return -EINVAL;
 692                 /* 'restore' padding left in the PCICC/PCIXCC card. */
 693                 if (copy_to_user(outputdata, static_pad, pad_len - 1))
 694                         return -EFAULT;
 695                 if (put_user(0, outputdata + pad_len - 1))
 696                         return -EFAULT;
 697         }
 698         /* Copy the crypto response to user space. */
 699         if (copy_to_user(outputdata + pad_len, data, reply_len))
 700                 return -EFAULT;
 701         return 0;
 702 }
 703
 704 /**
 705  * Copy results from a type 86 XCRB reply message back to user space.
 706  *
 707  * @zq: crypto device pointer
 708  * @reply: reply AP message.
 709  * @xcRB: pointer to XCRB
 710  *
 711  * Returns 0 on success or -EINVAL, -EFAULT, -EAGAIN in case of an error.
 712  */
 713 static int convert_type86_xcrb(struct zcrypt_queue *zq,
 714                                struct ap_message *reply,
 715                                struct ica_xcRB *xcRB)
 716 {
 717         struct type86_fmt2_msg *msg = reply->message;
 718         char *data = reply->message;
 719
 720         /* Copy CPRB to user */
 721         if (copy_to_user(xcRB->reply_control_blk_addr,
 722                 data + msg->fmt2.offset1, msg->fmt2.count1))
 723                 return -EFAULT;
 724         xcRB->reply_control_blk_length = msg->fmt2.count1;
 725
 726         /* Copy data buffer to user */
 727         if (msg->fmt2.count2)
 728                 if (copy_to_user(xcRB->reply_data_addr,
 729                         data + msg->fmt2.offset2, msg->fmt2.count2))
 730                         return -EFAULT;
 731         xcRB->reply_data_length = msg->fmt2.count2;
 732         return 0;
 733 }
 734
 735 /**
 736  * Copy results from a type 86 EP11 XCRB reply message back to user space.
 737  *
 738  * @zq: crypto device pointer
 739  * @reply: reply AP message.
 740  * @xcRB: pointer to EP11 user request block
 741  *
 742  * Returns 0 on success or -EINVAL, -EFAULT, -EAGAIN in case of an error.
 743  */
 744 static int convert_type86_ep11_xcrb(struct zcrypt_queue *zq,
 745                                     struct ap_message *reply,
 746                                     struct ep11_urb *xcRB)
 747 {
 748         struct type86_fmt2_msg *msg = reply->message;
 749         char *data = reply->message;
 750
 751         if (xcRB->resp_len < msg->fmt2.count1)
 752                 return -EINVAL;
 753
 754         /* Copy response CPRB to user */
 755         if (copy_to_user((char __force __user *)xcRB->resp,
 756                          data + msg->fmt2.offset1, msg->fmt2.count1))
 757                 return -EFAULT;
 758         xcRB->resp_len = msg->fmt2.count1;
 759         return 0;
 760 }
 761
 762 static int convert_type86_rng(struct zcrypt_queue *zq,
 763                           struct ap_message *reply,
 764                           char *buffer)
 765 {
 766         struct {
 767                 struct type86_hdr hdr;
 768                 struct type86_fmt2_ext fmt2;
 769                 struct CPRBX cprbx;
 770         } __packed * msg = reply->message;
 771         char *data = reply->message;
 772
 773         if (msg->cprbx.ccp_rtcode != 0 || msg->cprbx.ccp_rscode != 0)
 774                 return -EINVAL;
 775         memcpy(buffer, data + msg->fmt2.offset2, msg->fmt2.count2);
 776         return msg->fmt2.count2;
 777 }
 778
 779 static int convert_response_ica(struct zcrypt_queue *zq,
 780                             struct ap_message *reply,
 781                             char __user *outputdata,
 782                             unsigned int outputdatalength)
 783 {
 784         struct type86x_reply *msg = reply->message;
 785
 786         switch (msg->hdr.type) {
 787         case TYPE82_RSP_CODE:
 788         case TYPE88_RSP_CODE:
 789                 return convert_error(zq, reply);
 790         case TYPE86_RSP_CODE:
 791                 if (msg->cprbx.ccp_rtcode &&
 792                    (msg->cprbx.ccp_rscode == 0x14f) &&
 793                    (outputdatalength > 256)) {
 794                         if (zq->zcard->max_exp_bit_length <= 17) {
 795                                 zq->zcard->max_exp_bit_length = 17;
 796                                 return -EAGAIN;
 797                         } else
 798                                 return -EINVAL;
 799                 }
 800                 if (msg->hdr.reply_code)
 801                         return convert_error(zq, reply);
 802                 if (msg->cprbx.cprb_ver_id == 0x02)
 803                         return convert_type86_ica(zq, reply,
 804                                                   outputdata, outputdatalength);
 805                 /* Fall through, no break, incorrect cprb version is an unknown
 806                  * response */
 807         default: /* Unknown response type, this should NEVER EVER happen */
 808                 zq->online = 0;
 809                 pr_err("Cryptographic device %02x.%04x failed and was set offline\n",
 810                        AP_QID_CARD(zq->queue->qid),
 811                        AP_QID_QUEUE(zq->queue->qid));
 812                 ZCRYPT_DBF(DBF_ERR,
 813                            "device=%02x.%04x rtype=0x%02x => online=0 rc=EAGAIN\n",
 814                            AP_QID_CARD(zq->queue->qid),
 815                            AP_QID_QUEUE(zq->queue->qid),
 816                            (int) msg->hdr.type);
 817                 return -EAGAIN; /* repeat the request on a different device. */
 818         }
 819 }
 820
 821 static int convert_response_xcrb(struct zcrypt_queue *zq,
 822                             struct ap_message *reply,
 823                             struct ica_xcRB *xcRB)
 824 {
 825         struct type86x_reply *msg = reply->message;
 826
 827         switch (msg->hdr.type) {
 828         case TYPE82_RSP_CODE:
 829         case TYPE88_RSP_CODE:
 830                 xcRB->status = 0x0008044DL; /* HDD_InvalidParm */
 831                 return convert_error(zq, reply);
 832         case TYPE86_RSP_CODE:
 833                 if (msg->hdr.reply_code) {
 834                         memcpy(&(xcRB->status), msg->fmt2.apfs, sizeof(u32));
 835                         return convert_error(zq, reply);
 836                 }
 837                 if (msg->cprbx.cprb_ver_id == 0x02)
 838                         return convert_type86_xcrb(zq, reply, xcRB);
 839                 /* Fall through, no break, incorrect cprb version is an unknown
 840                  * response */
 841         default: /* Unknown response type, this should NEVER EVER happen */
 842                 xcRB->status = 0x0008044DL; /* HDD_InvalidParm */
 843                 zq->online = 0;
 844                 pr_err("Cryptographic device %02x.%04x failed and was set offline\n",
 845                        AP_QID_CARD(zq->queue->qid),
 846                        AP_QID_QUEUE(zq->queue->qid));
 847                 ZCRYPT_DBF(DBF_ERR,
 848                            "device=%02x.%04x rtype=0x%02x => online=0 rc=EAGAIN\n",
 849                            AP_QID_CARD(zq->queue->qid),
 850                            AP_QID_QUEUE(zq->queue->qid),
 851                            (int) msg->hdr.type);
 852                 return -EAGAIN; /* repeat the request on a different device. */
 853         }
 854 }
 855
 856 static int convert_response_ep11_xcrb(struct zcrypt_queue *zq,
 857         struct ap_message *reply, struct ep11_urb *xcRB)
 858 {
 859         struct type86_ep11_reply *msg = reply->message;
 860
 861         switch (msg->hdr.type) {
 862         case TYPE82_RSP_CODE:
 863         case TYPE87_RSP_CODE:
 864                 return convert_error(zq, reply);
 865         case TYPE86_RSP_CODE:
 866                 if (msg->hdr.reply_code)
 867                         return convert_error(zq, reply);
 868                 if (msg->cprbx.cprb_ver_id == 0x04)
 869                         return convert_type86_ep11_xcrb(zq, reply, xcRB);
 870         /* Fall through, no break, incorrect cprb version is an unknown resp.*/
 871         default: /* Unknown response type, this should NEVER EVER happen */
 872                 zq->online = 0;
 873                 pr_err("Cryptographic device %02x.%04x failed and was set offline\n",
 874                        AP_QID_CARD(zq->queue->qid),
 875                        AP_QID_QUEUE(zq->queue->qid));
 876                 ZCRYPT_DBF(DBF_ERR,
 877                            "device=%02x.%04x rtype=0x%02x => online=0 rc=EAGAIN\n",
 878                            AP_QID_CARD(zq->queue->qid),
 879                            AP_QID_QUEUE(zq->queue->qid),
 880                            (int) msg->hdr.type);
 881                 return -EAGAIN; /* repeat the request on a different device. */
 882         }
 883 }
 884
 885 static int convert_response_rng(struct zcrypt_queue *zq,
 886                                  struct ap_message *reply,
 887                                  char *data)
 888 {
 889         struct type86x_reply *msg = reply->message;
 890
 891         switch (msg->hdr.type) {
 892         case TYPE82_RSP_CODE:
 893         case TYPE88_RSP_CODE:
 894                 return -EINVAL;
 895         case TYPE86_RSP_CODE:
 896                 if (msg->hdr.reply_code)
 897                         return -EINVAL;
 898                 if (msg->cprbx.cprb_ver_id == 0x02)
 899                         return convert_type86_rng(zq, reply, data);
 900                 /* Fall through, no break, incorrect cprb version is an unknown
 901                  * response */
 902         default: /* Unknown response type, this should NEVER EVER happen */
 903                 zq->online = 0;
 904                 pr_err("Cryptographic device %02x.%04x failed and was set offline\n",
 905                        AP_QID_CARD(zq->queue->qid),
 906                        AP_QID_QUEUE(zq->queue->qid));
 907                 ZCRYPT_DBF(DBF_ERR,
 908                            "device=%02x.%04x rtype=0x%02x => online=0 rc=EAGAIN\n",
 909                            AP_QID_CARD(zq->queue->qid),
 910                            AP_QID_QUEUE(zq->queue->qid),
 911                            (int) msg->hdr.type);
 912                 return -EAGAIN; /* repeat the request on a different device. */
 913         }
 914 }
 915
 916 /**
 917  * This function is called from the AP bus code after a crypto request
 918  * "msg" has finished with the reply message "reply".
 919  * It is called from tasklet context.
 920  * @aq: pointer to the AP queue
 921  * @msg: pointer to the AP message
 922  * @reply: pointer to the AP reply message
 923  */
 924 static void zcrypt_msgtype6_receive(struct ap_queue *aq,
 925                                   struct ap_message *msg,
 926                                   struct ap_message *reply)
 927 {
 928         static struct error_hdr error_reply = {
 929                 .type = TYPE82_RSP_CODE,
 930                 .reply_code = REP82_ERROR_MACHINE_FAILURE,
 931         };
 932         struct response_type *resp_type =
 933                 (struct response_type *) msg->private;
 934         struct type86x_reply *t86r;
 935         int length;
 936
 937         /* Copy the reply message to the request message buffer. */
 938         if (!reply)
 939                 goto out;       /* ap_msg->rc indicates the error */
 940         t86r = reply->message;
 941         if (t86r->hdr.type == TYPE86_RSP_CODE &&
 942                  t86r->cprbx.cprb_ver_id == 0x02) {
 943                 switch (resp_type->type) {
 944                 case PCIXCC_RESPONSE_TYPE_ICA:
 945                         length = sizeof(struct type86x_reply)
 946                                 + t86r->length - 2;
 947                         length = min(PCIXCC_MAX_ICA_RESPONSE_SIZE, length);
 948                         memcpy(msg->message, reply->message, length);
 949                         break;
 950                 case PCIXCC_RESPONSE_TYPE_XCRB:
 951                         length = t86r->fmt2.offset2 + t86r->fmt2.count2;
 952                         length = min(MSGTYPE06_MAX_MSG_SIZE, length);
 953                         memcpy(msg->message, reply->message, length);
 954                         break;
 955                 default:
 956                         memcpy(msg->message, &error_reply,
 957                                sizeof(error_reply));
 958                 }
 959         } else
 960                 memcpy(msg->message, reply->message, sizeof(error_reply));
 961 out:
 962         complete(&(resp_type->work));
 963 }
 964
 965 /**
 966  * This function is called from the AP bus code after a crypto request
 967  * "msg" has finished with the reply message "reply".
 968  * It is called from tasklet context.
 969  * @aq: pointer to the AP queue
 970  * @msg: pointer to the AP message
 971  * @reply: pointer to the AP reply message
 972  */
 973 static void zcrypt_msgtype6_receive_ep11(struct ap_queue *aq,
 974                                          struct ap_message *msg,
 975                                          struct ap_message *reply)
 976 {
 977         static struct error_hdr error_reply = {
 978                 .type = TYPE82_RSP_CODE,
 979                 .reply_code = REP82_ERROR_MACHINE_FAILURE,
 980         };
 981         struct response_type *resp_type =
 982                 (struct response_type *)msg->private;
 983         struct type86_ep11_reply *t86r;
 984         int length;
 985
 986         /* Copy the reply message to the request message buffer. */
 987         if (!reply)
 988                 goto out;       /* ap_msg->rc indicates the error */
 989         t86r = reply->message;
 990         if (t86r->hdr.type == TYPE86_RSP_CODE &&
 991             t86r->cprbx.cprb_ver_id == 0x04) {
 992                 switch (resp_type->type) {
 993                 case PCIXCC_RESPONSE_TYPE_EP11:
 994                         length = t86r->fmt2.offset1 + t86r->fmt2.count1;
 995                         length = min(MSGTYPE06_MAX_MSG_SIZE, length);
 996                         memcpy(msg->message, reply->message, length);
 997                         break;
 998                 default:
 999                         memcpy(msg->message, &error_reply, sizeof(error_reply));
1000                 }
1001         } else {
1002                 memcpy(msg->message, reply->message, sizeof(error_reply));
1003           }
1004 out:
1005         complete(&(resp_type->work));
1006 }
1007
1008 static atomic_t zcrypt_step = ATOMIC_INIT(0);
1009
1010 /**
1011  * The request distributor calls this function if it picked the PCIXCC/CEX2C
1012  * device to handle a modexpo request.
1013  * @zq: pointer to zcrypt_queue structure that identifies the
1014  *        PCIXCC/CEX2C device to the request distributor
1015  * @mex: pointer to the modexpo request buffer
1016  */
1017 static long zcrypt_msgtype6_modexpo(struct zcrypt_queue *zq,
1018                                   struct ica_rsa_modexpo *mex)
1019 {
1020         struct ap_message ap_msg;
1021         struct response_type resp_type = {
1022                 .type = PCIXCC_RESPONSE_TYPE_ICA,
1023         };
1024         int rc;
1025
1026         ap_init_message(&ap_msg);
1027         ap_msg.message = (void *) get_zeroed_page(GFP_KERNEL);
1028         if (!ap_msg.message)
1029                 return -ENOMEM;
1030         ap_msg.receive = zcrypt_msgtype6_receive;
1031         ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
1032                                 atomic_inc_return(&zcrypt_step);
1033         ap_msg.private = &resp_type;
1034         rc = ICAMEX_msg_to_type6MEX_msgX(zq, &ap_msg, mex);
1035         if (rc)
1036                 goto out_free;
1037         init_completion(&resp_type.work);
1038         ap_queue_message(zq->queue, &ap_msg);
1039         rc = wait_for_completion_interruptible(&resp_type.work);
1040         if (rc == 0) {
1041                 rc = ap_msg.rc;
1042                 if (rc == 0)
1043                         rc = convert_response_ica(zq, &ap_msg,
1044                                                   mex->outputdata,
1045                                                   mex->outputdatalength);
1046         } else
1047                 /* Signal pending. */
1048                 ap_cancel_message(zq->queue, &ap_msg);
1049 out_free:
1050         free_page((unsigned long) ap_msg.message);
1051         return rc;
1052 }
1053
1054 /**
1055  * The request distributor calls this function if it picked the PCIXCC/CEX2C
1056  * device to handle a modexpo_crt request.
1057  * @zq: pointer to zcrypt_queue structure that identifies the
1058  *        PCIXCC/CEX2C device to the request distributor
1059  * @crt: pointer to the modexpoc_crt request buffer
1060  */
1061 static long zcrypt_msgtype6_modexpo_crt(struct zcrypt_queue *zq,
1062                                       struct ica_rsa_modexpo_crt *crt)
1063 {
1064         struct ap_message ap_msg;
1065         struct response_type resp_type = {
1066                 .type = PCIXCC_RESPONSE_TYPE_ICA,
1067         };
1068         int rc;
1069
1070         ap_init_message(&ap_msg);
1071         ap_msg.message = (void *) get_zeroed_page(GFP_KERNEL);
1072         if (!ap_msg.message)
1073                 return -ENOMEM;
1074         ap_msg.receive = zcrypt_msgtype6_receive;
1075         ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
1076                                 atomic_inc_return(&zcrypt_step);
1077         ap_msg.private = &resp_type;
1078         rc = ICACRT_msg_to_type6CRT_msgX(zq, &ap_msg, crt);
1079         if (rc)
1080                 goto out_free;
1081         init_completion(&resp_type.work);
1082         ap_queue_message(zq->queue, &ap_msg);
1083         rc = wait_for_completion_interruptible(&resp_type.work);
1084         if (rc == 0) {
1085                 rc = ap_msg.rc;
1086                 if (rc == 0)
1087                         rc = convert_response_ica(zq, &ap_msg,
1088                                                   crt->outputdata,
1089                                                   crt->outputdatalength);
1090         } else {
1091                 /* Signal pending. */
1092                 ap_cancel_message(zq->queue, &ap_msg);
1093         }
1094 out_free:
1095         free_page((unsigned long) ap_msg.message);
1096         return rc;
1097 }
1098
1099 unsigned int get_cprb_fc(struct ica_xcRB *xcRB,
1100                                 struct ap_message *ap_msg,
1101                                 unsigned int *func_code, unsigned short **dom)
1102 {
1103         struct response_type resp_type = {
1104                 .type = PCIXCC_RESPONSE_TYPE_XCRB,
1105         };
1106         int rc;
1107
1108         ap_init_message(ap_msg);
1109         ap_msg->message = kmalloc(MSGTYPE06_MAX_MSG_SIZE, GFP_KERNEL);
1110         if (!ap_msg->message)
1111                 return -ENOMEM;
1112         ap_msg->receive = zcrypt_msgtype6_receive;
1113         ap_msg->psmid = (((unsigned long long) current->pid) << 32) +
1114                                 atomic_inc_return(&zcrypt_step);
1115         ap_msg->private = kmalloc(sizeof(resp_type), GFP_KERNEL);
1116         if (!ap_msg->private) {
1117                 kzfree(ap_msg->message);
1118                 return -ENOMEM;
1119         }
1120         memcpy(ap_msg->private, &resp_type, sizeof(resp_type));
1121         rc = XCRB_msg_to_type6CPRB_msgX(ap_msg, xcRB, func_code, dom);
1122         if (rc) {
1123                 kzfree(ap_msg->message);
1124                 kzfree(ap_msg->private);
1125         }
1126         return rc;
1127 }
1128
1129 /**
1130  * The request distributor calls this function if it picked the PCIXCC/CEX2C
1131  * device to handle a send_cprb request.
1132  * @zq: pointer to zcrypt_queue structure that identifies the
1133  *        PCIXCC/CEX2C device to the request distributor
1134  * @xcRB: pointer to the send_cprb request buffer
1135  */
1136 static long zcrypt_msgtype6_send_cprb(struct zcrypt_queue *zq,
1137                                     struct ica_xcRB *xcRB,
1138                                     struct ap_message *ap_msg)
1139 {
1140         int rc;
1141         struct response_type *rtype = (struct response_type *)(ap_msg->private);
1142
1143         init_completion(&rtype->work);
1144         ap_queue_message(zq->queue, ap_msg);
1145         rc = wait_for_completion_interruptible(&rtype->work);
1146         if (rc == 0) {
1147                 rc = ap_msg->rc;
1148                 if (rc == 0)
1149                         rc = convert_response_xcrb(zq, ap_msg, xcRB);
1150         } else
1151                 /* Signal pending. */
1152                 ap_cancel_message(zq->queue, ap_msg);
1153
1154         kzfree(ap_msg->message);
1155         kzfree(ap_msg->private);
1156         return rc;
1157 }
1158
1159 unsigned int get_ep11cprb_fc(struct ep11_urb *xcrb,
1160                                     struct ap_message *ap_msg,
1161                                     unsigned int *func_code)
1162 {
1163         struct response_type resp_type = {
1164                 .type = PCIXCC_RESPONSE_TYPE_EP11,
1165         };
1166         int rc;
1167
1168         ap_init_message(ap_msg);
1169         ap_msg->message = kmalloc(MSGTYPE06_MAX_MSG_SIZE, GFP_KERNEL);
1170         if (!ap_msg->message)
1171                 return -ENOMEM;
1172         ap_msg->receive = zcrypt_msgtype6_receive_ep11;
1173         ap_msg->psmid = (((unsigned long long) current->pid) << 32) +
1174                                 atomic_inc_return(&zcrypt_step);
1175         ap_msg->private = kmalloc(sizeof(resp_type), GFP_KERNEL);
1176         if (!ap_msg->private) {
1177                 kzfree(ap_msg->message);
1178                 return -ENOMEM;
1179         }
1180         memcpy(ap_msg->private, &resp_type, sizeof(resp_type));
1181         rc = xcrb_msg_to_type6_ep11cprb_msgx(ap_msg, xcrb, func_code);
1182         if (rc) {
1183                 kzfree(ap_msg->message);
1184                 kzfree(ap_msg->private);
1185         }
1186         return rc;
1187 }
1188
1189 /**
1190  * The request distributor calls this function if it picked the CEX4P
1191  * device to handle a send_ep11_cprb request.
1192  * @zq: pointer to zcrypt_queue structure that identifies the
1193  *        CEX4P device to the request distributor
1194  * @xcRB: pointer to the ep11 user request block
1195  */
1196 static long zcrypt_msgtype6_send_ep11_cprb(struct zcrypt_queue *zq,
1197                                            struct ep11_urb *xcrb,
1198                                            struct ap_message *ap_msg)
1199 {
1200         int rc;
1201         unsigned int lfmt;
1202         struct response_type *rtype = (struct response_type *)(ap_msg->private);
1203         struct {
1204                 struct type6_hdr hdr;
1205                 struct ep11_cprb cprbx;
1206                 unsigned char   pld_tag;        /* fixed value 0x30 */
1207                 unsigned char   pld_lenfmt;     /* payload length format */
1208         } __packed * msg = ap_msg->message;
1209         struct pld_hdr {
1210                 unsigned char   func_tag;       /* fixed value 0x4 */
1211                 unsigned char   func_len;       /* fixed value 0x4 */
1212                 unsigned int    func_val;       /* function ID     */
1213                 unsigned char   dom_tag;        /* fixed value 0x4 */
1214                 unsigned char   dom_len;        /* fixed value 0x4 */
1215                 unsigned int    dom_val;        /* domain id       */
1216         } __packed * payload_hdr = NULL;
1217
1218
1219         /**
1220          * The target domain field within the cprb body/payload block will be
1221          * replaced by the usage domain for non-management commands only.
1222          * Therefore we check the first bit of the 'flags' parameter for
1223          * management command indication.
1224          *   0 - non management command
1225          *   1 - management command
1226          */
1227         if (!((msg->cprbx.flags & 0x80) == 0x80)) {
1228                 msg->cprbx.target_id = (unsigned int)
1229                                         AP_QID_QUEUE(zq->queue->qid);
1230
1231                 if ((msg->pld_lenfmt & 0x80) == 0x80) { /*ext.len.fmt 2 or 3*/
1232                         switch (msg->pld_lenfmt & 0x03) {
1233                         case 1:
1234                                 lfmt = 2;
1235                                 break;
1236                         case 2:
1237                                 lfmt = 3;
1238                                 break;
1239                         default:
1240                                 return -EINVAL;
1241                         }
1242                 } else {
1243                         lfmt = 1; /* length format #1 */
1244                 }
1245                 payload_hdr = (struct pld_hdr *)((&(msg->pld_lenfmt))+lfmt);
1246                 payload_hdr->dom_val = (unsigned int)
1247                                         AP_QID_QUEUE(zq->queue->qid);
1248         }
1249
1250         init_completion(&rtype->work);
1251         ap_queue_message(zq->queue, ap_msg);
1252         rc = wait_for_completion_interruptible(&rtype->work);
1253         if (rc == 0) {
1254                 rc = ap_msg->rc;
1255                 if (rc == 0)
1256                         rc = convert_response_ep11_xcrb(zq, ap_msg, xcrb);
1257         } else
1258                 /* Signal pending. */
1259                 ap_cancel_message(zq->queue, ap_msg);
1260
1261         kzfree(ap_msg->message);
1262         kzfree(ap_msg->private);
1263         return rc;
1264 }
1265
1266 unsigned int get_rng_fc(struct ap_message *ap_msg, int *func_code,
1267                                                    unsigned int *domain)
1268 {
1269         struct response_type resp_type = {
1270                 .type = PCIXCC_RESPONSE_TYPE_XCRB,
1271         };
1272
1273         ap_init_message(ap_msg);
1274         ap_msg->message = kmalloc(MSGTYPE06_MAX_MSG_SIZE, GFP_KERNEL);
1275         if (!ap_msg->message)
1276                 return -ENOMEM;
1277         ap_msg->receive = zcrypt_msgtype6_receive;
1278         ap_msg->psmid = (((unsigned long long) current->pid) << 32) +
1279                                 atomic_inc_return(&zcrypt_step);
1280         ap_msg->private = kmalloc(sizeof(resp_type), GFP_KERNEL);
1281         if (!ap_msg->private) {
1282                 kzfree(ap_msg->message);
1283                 return -ENOMEM;
1284         }
1285         memcpy(ap_msg->private, &resp_type, sizeof(resp_type));
1286
1287         rng_type6CPRB_msgX(ap_msg, ZCRYPT_RNG_BUFFER_SIZE, domain);
1288
1289         *func_code = HWRNG;
1290         return 0;
1291 }
1292
1293 /**
1294  * The request distributor calls this function if it picked the PCIXCC/CEX2C
1295  * device to generate random data.
1296  * @zq: pointer to zcrypt_queue structure that identifies the
1297  *        PCIXCC/CEX2C device to the request distributor
1298  * @buffer: pointer to a memory page to return random data
1299  */
1300 static long zcrypt_msgtype6_rng(struct zcrypt_queue *zq,
1301                                 char *buffer, struct ap_message *ap_msg)
1302 {
1303         struct {
1304                 struct type6_hdr hdr;
1305                 struct CPRBX cprbx;
1306                 char function_code[2];
1307                 short int rule_length;
1308                 char rule[8];
1309                 short int verb_length;
1310                 short int key_length;
1311         } __packed * msg = ap_msg->message;
1312         struct response_type *rtype = (struct response_type *)(ap_msg->private);
1313         int rc;
1314
1315         msg->cprbx.domain = AP_QID_QUEUE(zq->queue->qid);
1316
1317         init_completion(&rtype->work);
1318         ap_queue_message(zq->queue, ap_msg);
1319         rc = wait_for_completion_interruptible(&rtype->work);
1320         if (rc == 0) {
1321                 rc = ap_msg->rc;
1322                 if (rc == 0)
1323                         rc = convert_response_rng(zq, ap_msg, buffer);
1324         } else
1325                 /* Signal pending. */
1326                 ap_cancel_message(zq->queue, ap_msg);
1327
1328         kzfree(ap_msg->message);
1329         kzfree(ap_msg->private);
1330         return rc;
1331 }
1332
1333 /**
1334  * The crypto operations for a PCIXCC/CEX2C card.
1335  */
1336 static struct zcrypt_ops zcrypt_msgtype6_norng_ops = {
1337         .owner = THIS_MODULE,
1338         .name = MSGTYPE06_NAME,
1339         .variant = MSGTYPE06_VARIANT_NORNG,
1340         .rsa_modexpo = zcrypt_msgtype6_modexpo,
1341         .rsa_modexpo_crt = zcrypt_msgtype6_modexpo_crt,
1342         .send_cprb = zcrypt_msgtype6_send_cprb,
1343 };
1344
1345 static struct zcrypt_ops zcrypt_msgtype6_ops = {
1346         .owner = THIS_MODULE,
1347         .name = MSGTYPE06_NAME,
1348         .variant = MSGTYPE06_VARIANT_DEFAULT,
1349         .rsa_modexpo = zcrypt_msgtype6_modexpo,
1350         .rsa_modexpo_crt = zcrypt_msgtype6_modexpo_crt,
1351         .send_cprb = zcrypt_msgtype6_send_cprb,
1352         .rng = zcrypt_msgtype6_rng,
1353 };
1354
1355 static struct zcrypt_ops zcrypt_msgtype6_ep11_ops = {
1356         .owner = THIS_MODULE,
1357         .name = MSGTYPE06_NAME,
1358         .variant = MSGTYPE06_VARIANT_EP11,
1359         .rsa_modexpo = NULL,
1360         .rsa_modexpo_crt = NULL,
1361         .send_ep11_cprb = zcrypt_msgtype6_send_ep11_cprb,
1362 };
1363
1364 void __init zcrypt_msgtype6_init(void)
1365 {
1366         zcrypt_msgtype_register(&zcrypt_msgtype6_norng_ops);
1367         zcrypt_msgtype_register(&zcrypt_msgtype6_ops);
1368         zcrypt_msgtype_register(&zcrypt_msgtype6_ep11_ops);
1369 }
1370
1371 void __exit zcrypt_msgtype6_exit(void)
1372 {
1373         zcrypt_msgtype_unregister(&zcrypt_msgtype6_norng_ops);
1374         zcrypt_msgtype_unregister(&zcrypt_msgtype6_ops);
1375         zcrypt_msgtype_unregister(&zcrypt_msgtype6_ep11_ops);
1376 }