drivers/s390/crypto/z90hardware.c

   1 /*
   2  *  linux/drivers/s390/crypto/z90hardware.c
   3  *
   4  *  z90crypt 1.3.2
   5  *
   6  *  Copyright (C)  2001, 2004 IBM Corporation
   7  *  Author(s): Robert Burroughs (burrough@us.ibm.com)
   8  *             Eric Rossman (edrossma@us.ibm.com)
   9  *
  10  *  Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2, or (at your option)
  15  * any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25  */
  26
  27 #include <asm/uaccess.h>
  28 #include <linux/compiler.h>
  29 #include <linux/delay.h>
  30 #include <linux/init.h>
  31 #include <linux/module.h>
  32 #include "z90crypt.h"
  33 #include "z90common.h"
  34
  35 #define VERSION_Z90HARDWARE_C "$Revision: 1.33 $"
  36
  37 char z90hardware_version[] __initdata =
  38         "z90hardware.o (" VERSION_Z90HARDWARE_C "/"
  39                           VERSION_Z90COMMON_H "/" VERSION_Z90CRYPT_H ")";
  40
  41 struct cca_token_hdr {
  42         unsigned char  token_identifier;
  43         unsigned char  version;
  44         unsigned short token_length;
  45         unsigned char  reserved[4];
  46 };
  47
  48 #define CCA_TKN_HDR_ID_EXT 0x1E
  49
  50 struct cca_private_ext_ME_sec {
  51         unsigned char  section_identifier;
  52         unsigned char  version;
  53         unsigned short section_length;
  54         unsigned char  private_key_hash[20];
  55         unsigned char  reserved1[4];
  56         unsigned char  key_format;
  57         unsigned char  reserved2;
  58         unsigned char  key_name_hash[20];
  59         unsigned char  key_use_flags[4];
  60         unsigned char  reserved3[6];
  61         unsigned char  reserved4[24];
  62         unsigned char  confounder[24];
  63         unsigned char  exponent[128];
  64         unsigned char  modulus[128];
  65 };
  66
  67 #define CCA_PVT_USAGE_ALL 0x80
  68
  69 struct cca_public_sec {
  70         unsigned char  section_identifier;
  71         unsigned char  version;
  72         unsigned short section_length;
  73         unsigned char  reserved[2];
  74         unsigned short exponent_len;
  75         unsigned short modulus_bit_len;
  76         unsigned short modulus_byte_len;
  77         unsigned char  exponent[3];
  78 };
  79
  80 struct cca_private_ext_ME {
  81         struct cca_token_hdr          pvtMEHdr;
  82         struct cca_private_ext_ME_sec pvtMESec;
  83         struct cca_public_sec         pubMESec;
  84 };
  85
  86 struct cca_public_key {
  87         struct cca_token_hdr  pubHdr;
  88         struct cca_public_sec pubSec;
  89 };
  90
  91 struct cca_pvt_ext_CRT_sec {
  92         unsigned char  section_identifier;
  93         unsigned char  version;
  94         unsigned short section_length;
  95         unsigned char  private_key_hash[20];
  96         unsigned char  reserved1[4];
  97         unsigned char  key_format;
  98         unsigned char  reserved2;
  99         unsigned char  key_name_hash[20];
 100         unsigned char  key_use_flags[4];
 101         unsigned short p_len;
 102         unsigned short q_len;
 103         unsigned short dp_len;
 104         unsigned short dq_len;
 105         unsigned short u_len;
 106         unsigned short mod_len;
 107         unsigned char  reserved3[4];
 108         unsigned short pad_len;
 109         unsigned char  reserved4[52];
 110         unsigned char  confounder[8];
 111 };
 112
 113 #define CCA_PVT_EXT_CRT_SEC_ID_PVT 0x08
 114 #define CCA_PVT_EXT_CRT_SEC_FMT_CL 0x40
 115
 116 struct cca_private_ext_CRT {
 117         struct cca_token_hdr       pvtCrtHdr;
 118         struct cca_pvt_ext_CRT_sec pvtCrtSec;
 119         struct cca_public_sec      pubCrtSec;
 120 };
 121
 122 struct ap_status_word {
 123         unsigned char q_stat_flags;
 124         unsigned char response_code;
 125         unsigned char reserved[2];
 126 };
 127
 128 #define AP_Q_STATUS_EMPTY               0x80
 129 #define AP_Q_STATUS_REPLIES_WAITING     0x40
 130 #define AP_Q_STATUS_ARRAY_FULL          0x20
 131
 132 #define AP_RESPONSE_NORMAL              0x00
 133 #define AP_RESPONSE_Q_NOT_AVAIL         0x01
 134 #define AP_RESPONSE_RESET_IN_PROGRESS   0x02
 135 #define AP_RESPONSE_DECONFIGURED        0x03
 136 #define AP_RESPONSE_CHECKSTOPPED        0x04
 137 #define AP_RESPONSE_BUSY                0x05
 138 #define AP_RESPONSE_Q_FULL              0x10
 139 #define AP_RESPONSE_NO_PENDING_REPLY    0x10
 140 #define AP_RESPONSE_INDEX_TOO_BIG       0x11
 141 #define AP_RESPONSE_NO_FIRST_PART       0x13
 142 #define AP_RESPONSE_MESSAGE_TOO_BIG     0x15
 143
 144 #define AP_MAX_CDX_BITL         4
 145 #define AP_RQID_RESERVED_BITL   4
 146 #define SKIP_BITL               (AP_MAX_CDX_BITL + AP_RQID_RESERVED_BITL)
 147
 148 struct type4_hdr {
 149         unsigned char  reserved1;
 150         unsigned char  msg_type_code;
 151         unsigned short msg_len;
 152         unsigned char  request_code;
 153         unsigned char  msg_fmt;
 154         unsigned short reserved2;
 155 };
 156
 157 #define TYPE4_TYPE_CODE 0x04
 158 #define TYPE4_REQU_CODE 0x40
 159
 160 #define TYPE4_SME_LEN 0x0188
 161 #define TYPE4_LME_LEN 0x0308
 162 #define TYPE4_SCR_LEN 0x01E0
 163 #define TYPE4_LCR_LEN 0x03A0
 164
 165 #define TYPE4_SME_FMT 0x00
 166 #define TYPE4_LME_FMT 0x10
 167 #define TYPE4_SCR_FMT 0x40
 168 #define TYPE4_LCR_FMT 0x50
 169
 170 struct type4_sme {
 171         struct type4_hdr header;
 172         unsigned char    message[128];
 173         unsigned char    exponent[128];
 174         unsigned char    modulus[128];
 175 };
 176
 177 struct type4_lme {
 178         struct type4_hdr header;
 179         unsigned char    message[256];
 180         unsigned char    exponent[256];
 181         unsigned char    modulus[256];
 182 };
 183
 184 struct type4_scr {
 185         struct type4_hdr header;
 186         unsigned char    message[128];
 187         unsigned char    dp[72];
 188         unsigned char    dq[64];
 189         unsigned char    p[72];
 190         unsigned char    q[64];
 191         unsigned char    u[72];
 192 };
 193
 194 struct type4_lcr {
 195         struct type4_hdr header;
 196         unsigned char    message[256];
 197         unsigned char    dp[136];
 198         unsigned char    dq[128];
 199         unsigned char    p[136];
 200         unsigned char    q[128];
 201         unsigned char    u[136];
 202 };
 203
 204 union type4_msg {
 205         struct type4_sme sme;
 206         struct type4_lme lme;
 207         struct type4_scr scr;
 208         struct type4_lcr lcr;
 209 };
 210
 211 struct type84_hdr {
 212         unsigned char  reserved1;
 213         unsigned char  code;
 214         unsigned short len;
 215         unsigned char  reserved2[4];
 216 };
 217
 218 #define TYPE84_RSP_CODE 0x84
 219
 220 struct type6_hdr {
 221         unsigned char reserved1;
 222         unsigned char type;
 223         unsigned char reserved2[2];
 224         unsigned char right[4];
 225         unsigned char reserved3[2];
 226         unsigned char reserved4[2];
 227         unsigned char apfs[4];
 228         unsigned int  offset1;
 229         unsigned int  offset2;
 230         unsigned int  offset3;
 231         unsigned int  offset4;
 232         unsigned char agent_id[16];
 233         unsigned char rqid[2];
 234         unsigned char reserved5[2];
 235         unsigned char function_code[2];
 236         unsigned char reserved6[2];
 237         unsigned int  ToCardLen1;
 238         unsigned int  ToCardLen2;
 239         unsigned int  ToCardLen3;
 240         unsigned int  ToCardLen4;
 241         unsigned int  FromCardLen1;
 242         unsigned int  FromCardLen2;
 243         unsigned int  FromCardLen3;
 244         unsigned int  FromCardLen4;
 245 };
 246
 247 struct CPRB {
 248         unsigned char cprb_len[2];
 249         unsigned char cprb_ver_id;
 250         unsigned char pad_000;
 251         unsigned char srpi_rtcode[4];
 252         unsigned char srpi_verb;
 253         unsigned char flags;
 254         unsigned char func_id[2];
 255         unsigned char checkpoint_flag;
 256         unsigned char resv2;
 257         unsigned char req_parml[2];
 258         unsigned char req_parmp[4];
 259         unsigned char req_datal[4];
 260         unsigned char req_datap[4];
 261         unsigned char rpl_parml[2];
 262         unsigned char pad_001[2];
 263         unsigned char rpl_parmp[4];
 264         unsigned char rpl_datal[4];
 265         unsigned char rpl_datap[4];
 266         unsigned char ccp_rscode[2];
 267         unsigned char ccp_rtcode[2];
 268         unsigned char repd_parml[2];
 269         unsigned char mac_data_len[2];
 270         unsigned char repd_datal[4];
 271         unsigned char req_pc[2];
 272         unsigned char res_origin[8];
 273         unsigned char mac_value[8];
 274         unsigned char logon_id[8];
 275         unsigned char usage_domain[2];
 276         unsigned char resv3[18];
 277         unsigned char svr_namel[2];
 278         unsigned char svr_name[8];
 279 };
 280
 281 struct type6_msg {
 282         struct type6_hdr header;
 283         struct CPRB      CPRB;
 284 };
 285
 286 union request_msg {
 287         union  type4_msg t4msg;
 288         struct type6_msg t6msg;
 289 };
 290
 291 struct request_msg_ext {
 292         int               q_nr;
 293         unsigned char     *psmid;
 294         union request_msg reqMsg;
 295 };
 296
 297 struct type82_hdr {
 298         unsigned char reserved1;
 299         unsigned char type;
 300         unsigned char reserved2[2];
 301         unsigned char reply_code;
 302         unsigned char reserved3[3];
 303 };
 304
 305 #define TYPE82_RSP_CODE 0x82
 306
 307 #define REPLY_ERROR_MACHINE_FAILURE  0x10
 308 #define REPLY_ERROR_PREEMPT_FAILURE  0x12
 309 #define REPLY_ERROR_CHECKPT_FAILURE  0x14
 310 #define REPLY_ERROR_MESSAGE_TYPE     0x20
 311 #define REPLY_ERROR_INVALID_COMM_CD  0x21
 312 #define REPLY_ERROR_INVALID_MSG_LEN  0x23
 313 #define REPLY_ERROR_RESERVD_FIELD    0x24
 314 #define REPLY_ERROR_FORMAT_FIELD     0x29
 315 #define REPLY_ERROR_INVALID_COMMAND  0x30
 316 #define REPLY_ERROR_MALFORMED_MSG    0x40
 317 #define REPLY_ERROR_RESERVED_FIELDO  0x50
 318 #define REPLY_ERROR_WORD_ALIGNMENT   0x60
 319 #define REPLY_ERROR_MESSAGE_LENGTH   0x80
 320 #define REPLY_ERROR_OPERAND_INVALID  0x82
 321 #define REPLY_ERROR_OPERAND_SIZE     0x84
 322 #define REPLY_ERROR_EVEN_MOD_IN_OPND 0x85
 323 #define REPLY_ERROR_RESERVED_FIELD   0x88
 324 #define REPLY_ERROR_TRANSPORT_FAIL   0x90
 325 #define REPLY_ERROR_PACKET_TRUNCATED 0xA0
 326 #define REPLY_ERROR_ZERO_BUFFER_LEN  0xB0
 327
 328 struct type86_hdr {
 329         unsigned char reserved1;
 330         unsigned char type;
 331         unsigned char format;
 332         unsigned char reserved2;
 333         unsigned char reply_code;
 334         unsigned char reserved3[3];
 335 };
 336
 337 #define TYPE86_RSP_CODE 0x86
 338 #define TYPE86_FMT2     0x02
 339
 340 struct type86_fmt2_msg {
 341         struct type86_hdr hdr;
 342         unsigned char     reserved[4];
 343         unsigned char     apfs[4];
 344         unsigned int      count1;
 345         unsigned int      offset1;
 346         unsigned int      count2;
 347         unsigned int      offset2;
 348         unsigned int      count3;
 349         unsigned int      offset3;
 350         unsigned int      count4;
 351         unsigned int      offset4;
 352 };
 353
 354 static struct type6_hdr static_type6_hdr = {
 355         0x00,
 356         0x06,
 357         {0x00,0x00},
 358         {0x00,0x00,0x00,0x00},
 359         {0x00,0x00},
 360         {0x00,0x00},
 361         {0x00,0x00,0x00,0x00},
 362         0x00000058,
 363         0x00000000,
 364         0x00000000,
 365         0x00000000,
 366         {0x01,0x00,0x43,0x43,0x41,0x2D,0x41,0x50,
 367          0x50,0x4C,0x20,0x20,0x20,0x01,0x01,0x01},
 368         {0x00,0x00},
 369         {0x00,0x00},
 370         {0x50,0x44},
 371         {0x00,0x00},
 372         0x00000000,
 373         0x00000000,
 374         0x00000000,
 375         0x00000000,
 376         0x00000000,
 377         0x00000000,
 378         0x00000000,
 379         0x00000000
 380 };
 381
 382 static struct type6_hdr static_type6_hdrX = {
 383         0x00,
 384         0x06,
 385         {0x00,0x00},
 386         {0x00,0x00,0x00,0x00},
 387         {0x00,0x00},
 388         {0x00,0x00},
 389         {0x00,0x00,0x00,0x00},
 390         0x00000058,
 391         0x00000000,
 392         0x00000000,
 393         0x00000000,
 394         {0x43,0x41,0x00,0x00,0x00,0x00,0x00,0x00,
 395          0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
 396         {0x00,0x00},
 397         {0x00,0x00},
 398         {0x50,0x44},
 399         {0x00,0x00},
 400         0x00000000,
 401         0x00000000,
 402         0x00000000,
 403         0x00000000,
 404         0x00000000,
 405         0x00000000,
 406         0x00000000,
 407         0x00000000
 408 };
 409
 410 static struct CPRB static_cprb = {
 411         {0x70,0x00},
 412         0x41,
 413         0x00,
 414         {0x00,0x00,0x00,0x00},
 415         0x00,
 416         0x00,
 417         {0x54,0x32},
 418         0x01,
 419         0x00,
 420         {0x00,0x00},
 421         {0x00,0x00,0x00,0x00},
 422         {0x00,0x00,0x00,0x00},
 423         {0x00,0x00,0x00,0x00},
 424         {0x00,0x00},
 425         {0x00,0x00},
 426         {0x00,0x00,0x00,0x00},
 427         {0x00,0x00,0x00,0x00},
 428         {0x00,0x00,0x00,0x00},
 429         {0x00,0x00},
 430         {0x00,0x00},
 431         {0x00,0x00},
 432         {0x00,0x00},
 433         {0x00,0x00,0x00,0x00},
 434         {0x00,0x00},
 435         {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
 436         {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
 437         {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
 438         {0x00,0x00},
 439         {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 440          0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 441          0x00,0x00},
 442         {0x08,0x00},
 443         {0x49,0x43,0x53,0x46,0x20,0x20,0x20,0x20}
 444 };
 445
 446 struct function_and_rules_block {
 447         unsigned char function_code[2];
 448         unsigned char ulen[2];
 449         unsigned char only_rule[8];
 450 };
 451
 452 static struct function_and_rules_block static_pkd_function_and_rules = {
 453         {0x50,0x44},
 454         {0x0A,0x00},
 455         {'P','K','C','S','-','1','.','2'}
 456 };
 457
 458 static struct function_and_rules_block static_pke_function_and_rules = {
 459         {0x50,0x4B},
 460         {0x0A,0x00},
 461         {'P','K','C','S','-','1','.','2'}
 462 };
 463
 464 struct T6_keyBlock_hdr {
 465         unsigned char blen[2];
 466         unsigned char ulen[2];
 467         unsigned char flags[2];
 468 };
 469
 470 static struct T6_keyBlock_hdr static_T6_keyBlock_hdr = {
 471         {0x89,0x01},
 472         {0x87,0x01},
 473         {0x00}
 474 };
 475
 476 static struct CPRBX static_cprbx = {
 477         0x00DC,
 478         0x02,
 479         {0x00,0x00,0x00},
 480         {0x54,0x32},
 481         {0x00,0x00,0x00,0x00},
 482         0x00000000,
 483         0x00000000,
 484         0x00000000,
 485         0x00000000,
 486         0x00000000,
 487         0x00000000,
 488         0x00000000,
 489         {0x00,0x00,0x00,0x00},
 490         0x00000000,
 491         {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 492          0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
 493         {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 494          0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
 495         {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 496          0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
 497         {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 498          0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
 499         {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 500          0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
 501         {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 502          0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
 503         0x0000,
 504         0x0000,
 505         0x00000000,
 506         {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
 507         {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
 508         0x00,
 509         0x00,
 510         0x0000,
 511         {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
 512         {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 513          0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 514          0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}
 515 };
 516
 517 static struct function_and_rules_block static_pkd_function_and_rulesX_MCL2 = {
 518         {0x50,0x44},
 519         {0x00,0x0A},
 520         {'P','K','C','S','-','1','.','2'}
 521 };
 522
 523 static struct function_and_rules_block static_pke_function_and_rulesX_MCL2 = {
 524         {0x50,0x4B},
 525         {0x00,0x0A},
 526         {'Z','E','R','O','-','P','A','D'}
 527 };
 528
 529 static struct function_and_rules_block static_pkd_function_and_rulesX = {
 530         {0x50,0x44},
 531         {0x00,0x0A},
 532         {'Z','E','R','O','-','P','A','D'}
 533 };
 534
 535 static struct function_and_rules_block static_pke_function_and_rulesX = {
 536         {0x50,0x4B},
 537         {0x00,0x0A},
 538         {'M','R','P',' ',' ',' ',' ',' '}
 539 };
 540
 541 struct T6_keyBlock_hdrX {
 542         unsigned short blen;
 543         unsigned short ulen;
 544         unsigned char flags[2];
 545 };
 546
 547 static unsigned char static_pad[256] = {
 548 0x1B,0x7B,0x5D,0xB5,0x75,0x01,0x3D,0xFD,0x8D,0xD1,0xC7,0x03,0x2D,0x09,0x23,0x57,
 549 0x89,0x49,0xB9,0x3F,0xBB,0x99,0x41,0x5B,0x75,0x21,0x7B,0x9D,0x3B,0x6B,0x51,0x39,
 550 0xBB,0x0D,0x35,0xB9,0x89,0x0F,0x93,0xA5,0x0B,0x47,0xF1,0xD3,0xBB,0xCB,0xF1,0x9D,
 551 0x23,0x73,0x71,0xFF,0xF3,0xF5,0x45,0xFB,0x61,0x29,0x23,0xFD,0xF1,0x29,0x3F,0x7F,
 552 0x17,0xB7,0x1B,0xA9,0x19,0xBD,0x57,0xA9,0xD7,0x95,0xA3,0xCB,0xED,0x1D,0xDB,0x45,
 553 0x7D,0x11,0xD1,0x51,0x1B,0xED,0x71,0xE9,0xB1,0xD1,0xAB,0xAB,0x21,0x2B,0x1B,0x9F,
 554 0x3B,0x9F,0xF7,0xF7,0xBD,0x63,0xEB,0xAD,0xDF,0xB3,0x6F,0x5B,0xDB,0x8D,0xA9,0x5D,
 555 0xE3,0x7D,0x77,0x49,0x47,0xF5,0xA7,0xFD,0xAB,0x2F,0x27,0x35,0x77,0xD3,0x49,0xC9,
 556 0x09,0xEB,0xB1,0xF9,0xBF,0x4B,0xCB,0x2B,0xEB,0xEB,0x05,0xFF,0x7D,0xC7,0x91,0x8B,
 557 0x09,0x83,0xB9,0xB9,0x69,0x33,0x39,0x6B,0x79,0x75,0x19,0xBF,0xBB,0x07,0x1D,0xBD,
 558 0x29,0xBF,0x39,0x95,0x93,0x1D,0x35,0xC7,0xC9,0x4D,0xE5,0x97,0x0B,0x43,0x9B,0xF1,
 559 0x16,0x93,0x03,0x1F,0xA5,0xFB,0xDB,0xF3,0x27,0x4F,0x27,0x61,0x05,0x1F,0xB9,0x23,
 560 0x2F,0xC3,0x81,0xA9,0x23,0x71,0x55,0x55,0xEB,0xED,0x41,0xE5,0xF3,0x11,0xF1,0x43,
 561 0x69,0x03,0xBD,0x0B,0x37,0x0F,0x51,0x8F,0x0B,0xB5,0x89,0x5B,0x67,0xA9,0xD9,0x4F,
 562 0x01,0xF9,0x21,0x77,0x37,0x73,0x79,0xC5,0x7F,0x51,0xC1,0xCF,0x97,0xA1,0x75,0xAD,
 563 0x35,0x9D,0xD3,0xD3,0xA7,0x9D,0x5D,0x41,0x6F,0x65,0x1B,0xCF,0xA9,0x87,0x91,0x09
 564 };
 565
 566 static struct cca_private_ext_ME static_pvt_me_key = {
 567         {
 568                 0x1E,
 569                 0x00,
 570                 0x0183,
 571                 {0x00,0x00,0x00,0x00}
 572         },
 573
 574         {
 575                 0x02,
 576                 0x00,
 577                 0x016C,
 578                 {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 579                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 580                  0x00,0x00,0x00,0x00},
 581                 {0x00,0x00,0x00,0x00},
 582                 0x00,
 583                 0x00,
 584                 {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 585                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 586                  0x00,0x00,0x00,0x00},
 587                 {0x80,0x00,0x00,0x00},
 588                 {0x00,0x00,0x00,0x00,0x00,0x00},
 589                 {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 590                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 591                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
 592                 {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 593                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 594                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
 595                 {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 596                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 597                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 598                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 599                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 600                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 601                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 602                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 603                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 604                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 605                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 606                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 607                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 608                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 609                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 610                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
 611                 {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 612                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 613                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 614                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 615                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 616                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 617                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 618                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 619                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 620                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 621                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 622                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 623                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 624                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 625                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 626                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}
 627         },
 628
 629         {
 630                 0x04,
 631                 0x00,
 632                 0x000F,
 633                 {0x00,0x00},
 634                 0x0003,
 635                 0x0000,
 636                 0x0000,
 637                 {0x01,0x00,0x01}
 638         }
 639 };
 640
 641 static struct cca_public_key static_public_key = {
 642         {
 643                 0x1E,
 644                 0x00,
 645                 0x0000,
 646                 {0x00,0x00,0x00,0x00}
 647         },
 648
 649         {
 650                 0x04,
 651                 0x00,
 652                 0x0000,
 653                 {0x00,0x00},
 654                 0x0000,
 655                 0x0000,
 656                 0x0000,
 657                 {0x01,0x00,0x01}
 658         }
 659 };
 660
 661 #define FIXED_TYPE6_ME_LEN 0x0000025F
 662
 663 #define FIXED_TYPE6_ME_EN_LEN 0x000000F0
 664
 665 #define FIXED_TYPE6_ME_LENX 0x000002CB
 666
 667 #define FIXED_TYPE6_ME_EN_LENX 0x0000015C
 668
 669 static struct cca_public_sec static_cca_pub_sec = {
 670         0x04,
 671         0x00,
 672         0x000f,
 673         {0x00,0x00},
 674         0x0003,
 675         0x0000,
 676         0x0000,
 677         {0x01,0x00,0x01}
 678 };
 679
 680 #define FIXED_TYPE6_CR_LEN 0x00000177
 681
 682 #define FIXED_TYPE6_CR_LENX 0x000001E3
 683
 684 #define MAX_RESPONSE_SIZE 0x00000710
 685
 686 #define MAX_RESPONSEX_SIZE 0x0000077C
 687
 688 #define RESPONSE_CPRB_SIZE  0x000006B8
 689 #define RESPONSE_CPRBX_SIZE 0x00000724
 690
 691 #define CALLER_HEADER 12
 692
 693 static unsigned char static_PKE_function_code[2] = {0x50, 0x4B};
 694
 695 static inline int
 696 testq(int q_nr, int *q_depth, int *dev_type, struct ap_status_word *stat)
 697 {
 698         int ccode;
 699
 700         asm volatile
 701 #ifdef __s390x__
 702         ("      llgfr   0,%4            \n"
 703          "      slgr    1,1             \n"
 704          "      lgr     2,1             \n"
 705          "0:    .long   0xb2af0000      \n"
 706          "1:    ipm     %0              \n"
 707          "      srl     %0,28           \n"
 708          "      iihh    %0,0            \n"
 709          "      iihl    %0,0            \n"
 710          "      lgr     %1,1            \n"
 711          "      lgr     %3,2            \n"
 712          "      srl     %3,24           \n"
 713          "      sll     2,24            \n"
 714          "      srl     2,24            \n"
 715          "      lgr     %2,2            \n"
 716          "2:                            \n"
 717          ".section .fixup,\"ax\"        \n"
 718          "3:                            \n"
 719          "      lhi     %0,%h5          \n"
 720          "      jg      2b              \n"
 721          ".previous                     \n"
 722          ".section __ex_table,\"a\"     \n"
 723          "      .align  8               \n"
 724          "      .quad   0b,3b           \n"
 725          "      .quad   1b,3b           \n"
 726          ".previous"
 727          :"=d" (ccode),"=d" (*stat),"=d" (*q_depth), "=d" (*dev_type)
 728          :"d" (q_nr), "K" (DEV_TSQ_EXCEPTION)
 729          :"cc","0","1","2","memory");
 730 #else
 731         ("      lr      0,%4            \n"
 732          "      slr     1,1             \n"
 733          "      lr      2,1             \n"
 734          "0:    .long   0xb2af0000      \n"
 735          "1:    ipm     %0              \n"
 736          "      srl     %0,28           \n"
 737          "      lr      %1,1            \n"
 738          "      lr      %3,2            \n"
 739          "      srl     %3,24           \n"
 740          "      sll     2,24            \n"
 741          "      srl     2,24            \n"
 742          "      lr      %2,2            \n"
 743          "2:                            \n"
 744          ".section .fixup,\"ax\"        \n"
 745          "3:                            \n"
 746          "      lhi     %0,%h5          \n"
 747          "      bras    1,4f            \n"
 748          "      .long   2b              \n"
 749          "4:                            \n"
 750          "      l       1,0(1)          \n"
 751          "      br      1               \n"
 752          ".previous                     \n"
 753          ".section __ex_table,\"a\"     \n"
 754          "      .align  4               \n"
 755          "      .long   0b,3b           \n"
 756          "      .long   1b,3b           \n"
 757          ".previous"
 758          :"=d" (ccode),"=d" (*stat),"=d" (*q_depth), "=d" (*dev_type)
 759          :"d" (q_nr), "K" (DEV_TSQ_EXCEPTION)
 760          :"cc","0","1","2","memory");
 761 #endif
 762         return ccode;
 763 }
 764
 765 static inline int
 766 resetq(int q_nr, struct ap_status_word *stat_p)
 767 {
 768         int ccode;
 769
 770         asm volatile
 771 #ifdef __s390x__
 772         ("      llgfr   0,%2            \n"
 773          "      lghi    1,1             \n"
 774          "      sll     1,24            \n"
 775          "      or      0,1             \n"
 776          "      slgr    1,1             \n"
 777          "      lgr     2,1             \n"
 778          "0:    .long   0xb2af0000      \n"
 779          "1:    ipm     %0              \n"
 780          "      srl     %0,28           \n"
 781          "      iihh    %0,0            \n"
 782          "      iihl    %0,0            \n"
 783          "      lgr     %1,1            \n"
 784          "2:                            \n"
 785          ".section .fixup,\"ax\"        \n"
 786          "3:                            \n"
 787          "      lhi     %0,%h3          \n"
 788          "      jg      2b              \n"
 789          ".previous                     \n"
 790          ".section __ex_table,\"a\"     \n"
 791          "      .align  8               \n"
 792          "      .quad   0b,3b           \n"
 793          "      .quad   1b,3b           \n"
 794          ".previous"
 795          :"=d" (ccode),"=d" (*stat_p)
 796          :"d" (q_nr), "K" (DEV_RSQ_EXCEPTION)
 797          :"cc","0","1","2","memory");
 798 #else
 799         ("      lr      0,%2            \n"
 800          "      lhi     1,1             \n"
 801          "      sll     1,24            \n"
 802          "      or      0,1             \n"
 803          "      slr     1,1             \n"
 804          "      lr      2,1             \n"
 805          "0:    .long   0xb2af0000      \n"
 806          "1:    ipm     %0              \n"
 807          "      srl     %0,28           \n"
 808          "      lr      %1,1            \n"
 809          "2:                            \n"
 810          ".section .fixup,\"ax\"        \n"
 811          "3:                            \n"
 812          "      lhi     %0,%h3          \n"
 813          "      bras    1,4f            \n"
 814          "      .long   2b              \n"
 815          "4:                            \n"
 816          "      l       1,0(1)          \n"
 817          "      br      1               \n"
 818          ".previous                     \n"
 819          ".section __ex_table,\"a\"     \n"
 820          "      .align  4               \n"
 821          "      .long   0b,3b           \n"
 822          "      .long   1b,3b           \n"
 823          ".previous"
 824          :"=d" (ccode),"=d" (*stat_p)
 825          :"d" (q_nr), "K" (DEV_RSQ_EXCEPTION)
 826          :"cc","0","1","2","memory");
 827 #endif
 828         return ccode;
 829 }
 830
 831 static inline int
 832 sen(int msg_len, unsigned char *msg_ext, struct ap_status_word *stat)
 833 {
 834         int ccode;
 835
 836         asm volatile
 837 #ifdef __s390x__
 838         ("      lgr     6,%3            \n"
 839          "      llgfr   7,%2            \n"
 840          "      llgt    0,0(6)          \n"
 841          "      lghi    1,64            \n"
 842          "      sll     1,24            \n"
 843          "      or      0,1             \n"
 844          "      la      6,4(6)          \n"
 845          "      llgt    2,0(6)          \n"
 846          "      llgt    3,4(6)          \n"
 847          "      la      6,8(6)          \n"
 848          "      slr     1,1             \n"
 849          "0:    .long   0xb2ad0026      \n"
 850          "1:    brc     2,0b            \n"
 851          "      ipm     %0              \n"
 852          "      srl     %0,28           \n"
 853          "      iihh    %0,0            \n"
 854          "      iihl    %0,0            \n"
 855          "      lgr     %1,1            \n"
 856          "2:                            \n"
 857          ".section .fixup,\"ax\"        \n"
 858          "3:                            \n"
 859          "      lhi     %0,%h4          \n"
 860          "      jg      2b              \n"
 861          ".previous                     \n"
 862          ".section __ex_table,\"a\"     \n"
 863          "      .align  8               \n"
 864          "      .quad   0b,3b           \n"
 865          "      .quad   1b,3b           \n"
 866          ".previous"
 867          :"=d" (ccode),"=d" (*stat)
 868          :"d" (msg_len),"a" (msg_ext), "K" (DEV_SEN_EXCEPTION)
 869          :"cc","0","1","2","3","6","7","memory");
 870 #else
 871         ("      lr      6,%3            \n"
 872          "      lr      7,%2            \n"
 873          "      l       0,0(6)          \n"
 874          "      lhi     1,64            \n"
 875          "      sll     1,24            \n"
 876          "      or      0,1             \n"
 877          "      la      6,4(6)          \n"
 878          "      l       2,0(6)          \n"
 879          "      l       3,4(6)          \n"
 880          "      la      6,8(6)          \n"
 881          "      slr     1,1             \n"
 882          "0:    .long   0xb2ad0026      \n"
 883          "1:    brc     2,0b            \n"
 884          "      ipm     %0              \n"
 885          "      srl     %0,28           \n"
 886          "      lr      %1,1            \n"
 887          "2:                            \n"
 888          ".section .fixup,\"ax\"        \n"
 889          "3:                            \n"
 890          "      lhi     %0,%h4          \n"
 891          "      bras    1,4f            \n"
 892          "      .long   2b              \n"
 893          "4:                            \n"
 894          "      l       1,0(1)          \n"
 895          "      br      1               \n"
 896          ".previous                     \n"
 897          ".section __ex_table,\"a\"     \n"
 898          "      .align  4               \n"
 899          "      .long   0b,3b           \n"
 900          "      .long   1b,3b           \n"
 901          ".previous"
 902          :"=d" (ccode),"=d" (*stat)
 903          :"d" (msg_len),"a" (msg_ext), "K" (DEV_SEN_EXCEPTION)
 904          :"cc","0","1","2","3","6","7","memory");
 905 #endif
 906         return ccode;
 907 }
 908
 909 static inline int
 910 rec(int q_nr, int buff_l, unsigned char *rsp, unsigned char *id,
 911     struct ap_status_word *st)
 912 {
 913         int ccode;
 914
 915         asm volatile
 916 #ifdef __s390x__
 917         ("      llgfr   0,%2            \n"
 918          "      lgr     3,%4            \n"
 919          "      lgr     6,%3            \n"
 920          "      llgfr   7,%5            \n"
 921          "      lghi    1,128           \n"
 922          "      sll     1,24            \n"
 923          "      or      0,1             \n"
 924          "      slgr    1,1             \n"
 925          "      lgr     2,1             \n"
 926          "      lgr     4,1             \n"
 927          "      lgr     5,1             \n"
 928          "0:    .long   0xb2ae0046      \n"
 929          "1:    brc     2,0b            \n"
 930          "      brc     4,0b            \n"
 931          "      ipm     %0              \n"
 932          "      srl     %0,28           \n"
 933          "      iihh    %0,0            \n"
 934          "      iihl    %0,0            \n"
 935          "      lgr     %1,1            \n"
 936          "      st      4,0(3)          \n"
 937          "      st      5,4(3)          \n"
 938          "2:                            \n"
 939          ".section .fixup,\"ax\"        \n"
 940          "3:                            \n"
 941          "      lhi   %0,%h6            \n"
 942          "      jg    2b                \n"
 943          ".previous                     \n"
 944          ".section __ex_table,\"a\"     \n"
 945          "   .align     8               \n"
 946          "   .quad      0b,3b           \n"
 947          "   .quad      1b,3b           \n"
 948          ".previous"
 949          :"=d"(ccode),"=d"(*st)
 950          :"d" (q_nr), "d" (rsp), "d" (id), "d" (buff_l), "K" (DEV_REC_EXCEPTION)
 951          :"cc","0","1","2","3","4","5","6","7","memory");
 952 #else
 953         ("      lr      0,%2            \n"
 954          "      lr      3,%4            \n"
 955          "      lr      6,%3            \n"
 956          "      lr      7,%5            \n"
 957          "      lhi     1,128           \n"
 958          "      sll     1,24            \n"
 959          "      or      0,1             \n"
 960          "      slr     1,1             \n"
 961          "      lr      2,1             \n"
 962          "      lr      4,1             \n"
 963          "      lr      5,1             \n"
 964          "0:    .long   0xb2ae0046      \n"
 965          "1:    brc     2,0b            \n"
 966          "      brc     4,0b            \n"
 967          "      ipm     %0              \n"
 968          "      srl     %0,28           \n"
 969          "      lr      %1,1            \n"
 970          "      st      4,0(3)          \n"
 971          "      st      5,4(3)          \n"
 972          "2:                            \n"
 973          ".section .fixup,\"ax\"        \n"
 974          "3:                            \n"
 975          "      lhi   %0,%h6            \n"
 976          "      bras  1,4f              \n"
 977          "      .long 2b                \n"
 978          "4:                            \n"
 979          "      l     1,0(1)            \n"
 980          "      br    1                 \n"
 981          ".previous                     \n"
 982          ".section __ex_table,\"a\"     \n"
 983          "   .align     4               \n"
 984          "   .long      0b,3b           \n"
 985          "   .long      1b,3b           \n"
 986          ".previous"
 987          :"=d"(ccode),"=d"(*st)
 988          :"d" (q_nr), "d" (rsp), "d" (id), "d" (buff_l), "K" (DEV_REC_EXCEPTION)
 989          :"cc","0","1","2","3","4","5","6","7","memory");
 990 #endif
 991         return ccode;
 992 }
 993
 994 static inline void
 995 itoLe2(int *i_p, unsigned char *lechars)
 996 {
 997         *lechars       = *((unsigned char *) i_p + sizeof(int) - 1);
 998         *(lechars + 1) = *((unsigned char *) i_p + sizeof(int) - 2);
 999 }
1000
1001 static inline void
1002 le2toI(unsigned char *lechars, int *i_p)
1003 {
1004         unsigned char *ic_p;
1005         *i_p = 0;
1006         ic_p = (unsigned char *) i_p;
1007         *(ic_p + 2) = *(lechars + 1);
1008         *(ic_p + 3) = *(lechars);
1009 }
1010
1011 static inline int
1012 is_empty(unsigned char *ptr, int len)
1013 {
1014         return !memcmp(ptr, (unsigned char *) &static_pvt_me_key+60, len);
1015 }
1016
1017 enum hdstat
1018 query_online(int deviceNr, int cdx, int resetNr, int *q_depth, int *dev_type)
1019 {
1020         int q_nr, i, t_depth, t_dev_type;
1021         enum devstat ccode;
1022         struct ap_status_word stat_word;
1023         enum hdstat stat;
1024         int break_out;
1025
1026         q_nr = (deviceNr << SKIP_BITL) + cdx;
1027         stat = HD_BUSY;
1028         ccode = testq(q_nr, &t_depth, &t_dev_type, &stat_word);
1029         PDEBUG("ccode %d response_code %02X\n", ccode, stat_word.response_code);
1030         break_out = 0;
1031         for (i = 0; i < resetNr; i++) {
1032                 if (ccode > 3) {
1033                         PRINTKC("Exception testing device %d\n", i);
1034                         return HD_TSQ_EXCEPTION;
1035                 }
1036                 switch (ccode) {
1037                 case 0:
1038                         PDEBUG("t_dev_type %d\n", t_dev_type);
1039                         break_out = 1;
1040                         stat = HD_ONLINE;
1041                         *q_depth = t_depth + 1;
1042                         switch (t_dev_type) {
1043                         case OTHER_HW:
1044                                 stat = HD_NOT_THERE;
1045                                 *dev_type = NILDEV;
1046                                 break;
1047                         case PCICA_HW:
1048                                 *dev_type = PCICA;
1049                                 break;
1050                         case PCICC_HW:
1051                                 *dev_type = PCICC;
1052                                 break;
1053                         case PCIXCC_HW:
1054                                 *dev_type = PCIXCC_UNK;
1055                                 break;
1056                         case CEX2C_HW:
1057                                 *dev_type = CEX2C;
1058                                 break;
1059                         default:
1060                                 *dev_type = NILDEV;
1061                                 break;
1062                         }
1063                         PDEBUG("available device %d: Q depth = %d, dev "
1064                                "type = %d, stat = %02X%02X%02X%02X\n",
1065                                deviceNr, *q_depth, *dev_type,
1066                                stat_word.q_stat_flags,
1067                                stat_word.response_code,
1068                                stat_word.reserved[0],
1069                                stat_word.reserved[1]);
1070                         break;
1071                 case 3:
1072                         switch (stat_word.response_code) {
1073                         case AP_RESPONSE_NORMAL:
1074                                 stat = HD_ONLINE;
1075                                 break_out = 1;
1076                                 *q_depth = t_depth + 1;
1077                                 *dev_type = t_dev_type;
1078                                 PDEBUG("cc3, available device "
1079                                        "%d: Q depth = %d, dev "
1080                                        "type = %d, stat = "
1081                                        "%02X%02X%02X%02X\n",
1082                                        deviceNr, *q_depth,
1083                                        *dev_type,
1084                                        stat_word.q_stat_flags,
1085                                        stat_word.response_code,
1086                                        stat_word.reserved[0],
1087                                        stat_word.reserved[1]);
1088                                 break;
1089                         case AP_RESPONSE_Q_NOT_AVAIL:
1090                                 stat = HD_NOT_THERE;
1091                                 break_out = 1;
1092                                 break;
1093                         case AP_RESPONSE_RESET_IN_PROGRESS:
1094                                 PDEBUG("device %d in reset\n",
1095                                        deviceNr);
1096                                 break;
1097                         case AP_RESPONSE_DECONFIGURED:
1098                                 stat = HD_DECONFIGURED;
1099                                 break_out = 1;
1100                                 break;
1101                         case AP_RESPONSE_CHECKSTOPPED:
1102                                 stat = HD_CHECKSTOPPED;
1103                                 break_out = 1;
1104                                 break;
1105                         case AP_RESPONSE_BUSY:
1106                                 PDEBUG("device %d busy\n",
1107                                        deviceNr);
1108                                 break;
1109                         default:
1110                                 break;
1111                         }
1112                         break;
1113                 default:
1114                         stat = HD_NOT_THERE;
1115                         break_out = 1;
1116                         break;
1117                 }
1118                 if (break_out)
1119                         break;
1120
1121                 udelay(5);
1122
1123                 ccode = testq(q_nr, &t_depth, &t_dev_type, &stat_word);
1124         }
1125         return stat;
1126 }
1127
1128 enum devstat
1129 reset_device(int deviceNr, int cdx, int resetNr)
1130 {
1131         int q_nr, ccode = 0, dummy_qdepth, dummy_devType, i;
1132         struct ap_status_word stat_word;
1133         enum devstat stat;
1134         int break_out;
1135
1136         q_nr = (deviceNr << SKIP_BITL) + cdx;
1137         stat = DEV_GONE;
1138         ccode = resetq(q_nr, &stat_word);
1139         if (ccode > 3)
1140                 return DEV_RSQ_EXCEPTION;
1141
1142         break_out = 0;
1143         for (i = 0; i < resetNr; i++) {
1144                 switch (ccode) {
1145                 case 0:
1146                         stat = DEV_ONLINE;
1147                         if (stat_word.q_stat_flags & AP_Q_STATUS_EMPTY)
1148                                 break_out = 1;
1149                         break;
1150                 case 3:
1151                         switch (stat_word.response_code) {
1152                         case AP_RESPONSE_NORMAL:
1153                                 stat = DEV_ONLINE;
1154                                 if (stat_word.q_stat_flags & AP_Q_STATUS_EMPTY)
1155                                         break_out = 1;
1156                                 break;
1157                         case AP_RESPONSE_Q_NOT_AVAIL:
1158                         case AP_RESPONSE_DECONFIGURED:
1159                         case AP_RESPONSE_CHECKSTOPPED:
1160                                 stat = DEV_GONE;
1161                                 break_out = 1;
1162                                 break;
1163                         case AP_RESPONSE_RESET_IN_PROGRESS:
1164                         case AP_RESPONSE_BUSY:
1165                         default:
1166                                 break;
1167                         }
1168                         break;
1169                 default:
1170                         stat = DEV_GONE;
1171                         break_out = 1;
1172                         break;
1173                 }
1174                 if (break_out == 1)
1175                         break;
1176                 udelay(5);
1177
1178                 ccode = testq(q_nr, &dummy_qdepth, &dummy_devType, &stat_word);
1179                 if (ccode > 3) {
1180                         stat = DEV_TSQ_EXCEPTION;
1181                         break;
1182                 }
1183         }
1184         PDEBUG("Number of testq's needed for reset: %d\n", i);
1185
1186         if (i >= resetNr) {
1187           stat = DEV_GONE;
1188         }
1189
1190         return stat;
1191 }
1192
1193 #ifdef DEBUG_HYDRA_MSGS
1194 static inline void
1195 print_buffer(unsigned char *buffer, int bufflen)
1196 {
1197         int i;
1198         for (i = 0; i < bufflen; i += 16) {
1199                 PRINTK("%04X: %02X%02X%02X%02X %02X%02X%02X%02X "
1200                        "%02X%02X%02X%02X %02X%02X%02X%02X\n", i,
1201                        buffer[i+0], buffer[i+1], buffer[i+2], buffer[i+3],
1202                        buffer[i+4], buffer[i+5], buffer[i+6], buffer[i+7],
1203                        buffer[i+8], buffer[i+9], buffer[i+10], buffer[i+11],
1204                        buffer[i+12], buffer[i+13], buffer[i+14], buffer[i+15]);
1205         }
1206 }
1207 #endif
1208
1209 enum devstat
1210 send_to_AP(int dev_nr, int cdx, int msg_len, unsigned char *msg_ext)
1211 {
1212         struct ap_status_word stat_word;
1213         enum devstat stat;
1214         int ccode;
1215
1216         ((struct request_msg_ext *) msg_ext)->q_nr =
1217                 (dev_nr << SKIP_BITL) + cdx;
1218         PDEBUG("msg_len passed to sen: %d\n", msg_len);
1219         PDEBUG("q number passed to sen: %02x%02x%02x%02x\n",
1220                msg_ext[0], msg_ext[1], msg_ext[2], msg_ext[3]);
1221         stat = DEV_GONE;
1222
1223 #ifdef DEBUG_HYDRA_MSGS
1224         PRINTK("Request header: %02X%02X%02X%02X %02X%02X%02X%02X "
1225                "%02X%02X%02X%02X\n",
1226                msg_ext[0], msg_ext[1], msg_ext[2], msg_ext[3],
1227                msg_ext[4], msg_ext[5], msg_ext[6], msg_ext[7],
1228                msg_ext[8], msg_ext[9], msg_ext[10], msg_ext[11]);
1229         print_buffer(msg_ext+CALLER_HEADER, msg_len);
1230 #endif
1231
1232         ccode = sen(msg_len, msg_ext, &stat_word);
1233         if (ccode > 3)
1234                 return DEV_SEN_EXCEPTION;
1235
1236         PDEBUG("nq cc: %u, st: %02x%02x%02x%02x\n",
1237                ccode, stat_word.q_stat_flags, stat_word.response_code,
1238                stat_word.reserved[0], stat_word.reserved[1]);
1239         switch (ccode) {
1240         case 0:
1241                 stat = DEV_ONLINE;
1242                 break;
1243         case 1:
1244                 stat = DEV_GONE;
1245                 break;
1246         case 3:
1247                 switch (stat_word.response_code) {
1248                 case AP_RESPONSE_NORMAL:
1249                         stat = DEV_ONLINE;
1250                         break;
1251                 case AP_RESPONSE_Q_FULL:
1252                         stat = DEV_QUEUE_FULL;
1253                         break;
1254                 default:
1255                         stat = DEV_GONE;
1256                         break;
1257                 }
1258                 break;
1259         default:
1260                 stat = DEV_GONE;
1261                 break;
1262         }
1263
1264         return stat;
1265 }
1266
1267 enum devstat
1268 receive_from_AP(int dev_nr, int cdx, int resplen, unsigned char *resp,
1269                 unsigned char *psmid)
1270 {
1271         int ccode;
1272         struct ap_status_word stat_word;
1273         enum devstat stat;
1274
1275         memset(resp, 0x00, 8);
1276
1277         ccode = rec((dev_nr << SKIP_BITL) + cdx, resplen, resp, psmid,
1278                     &stat_word);
1279         if (ccode > 3)
1280                 return DEV_REC_EXCEPTION;
1281
1282         PDEBUG("dq cc: %u, st: %02x%02x%02x%02x\n",
1283                ccode, stat_word.q_stat_flags, stat_word.response_code,
1284                stat_word.reserved[0], stat_word.reserved[1]);
1285
1286         stat = DEV_GONE;
1287         switch (ccode) {
1288         case 0:
1289                 stat = DEV_ONLINE;
1290 #ifdef DEBUG_HYDRA_MSGS
1291                 print_buffer(resp, resplen);
1292 #endif
1293                 break;
1294         case 3:
1295                 switch (stat_word.response_code) {
1296                 case AP_RESPONSE_NORMAL:
1297                         stat = DEV_ONLINE;
1298                         break;
1299                 case AP_RESPONSE_NO_PENDING_REPLY:
1300                         if (stat_word.q_stat_flags & AP_Q_STATUS_EMPTY)
1301                                 stat = DEV_EMPTY;
1302                         else
1303                                 stat = DEV_NO_WORK;
1304                         break;
1305                 case AP_RESPONSE_INDEX_TOO_BIG:
1306                 case AP_RESPONSE_NO_FIRST_PART:
1307                 case AP_RESPONSE_MESSAGE_TOO_BIG:
1308                         stat = DEV_BAD_MESSAGE;
1309                         break;
1310                 default:
1311                         break;
1312                 }
1313                 break;
1314         default:
1315                 break;
1316         }
1317
1318         return stat;
1319 }
1320
1321 static inline int
1322 pad_msg(unsigned char *buffer, int  totalLength, int msgLength)
1323 {
1324         int pad_len;
1325
1326         for (pad_len = 0; pad_len < (totalLength - msgLength); pad_len++)
1327                 if (buffer[pad_len] != 0x00)
1328                         break;
1329         pad_len -= 3;
1330         if (pad_len < 8)
1331                 return SEN_PAD_ERROR;
1332
1333         buffer[0] = 0x00;
1334         buffer[1] = 0x02;
1335
1336         memcpy(buffer+2, static_pad, pad_len);
1337
1338         buffer[pad_len + 2] = 0x00;
1339
1340         return 0;
1341 }
1342
1343 static inline int
1344 is_common_public_key(unsigned char *key, int len)
1345 {
1346         int i;
1347
1348         for (i = 0; i < len; i++)
1349                 if (key[i])
1350                         break;
1351         key += i;
1352         len -= i;
1353         if (((len == 1) && (key[0] == 3)) ||
1354             ((len == 3) && (key[0] == 1) && (key[1] == 0) && (key[2] == 1)))
1355                 return 1;
1356
1357         return 0;
1358 }
1359
1360 static int
1361 ICAMEX_msg_to_type4MEX_msg(struct ica_rsa_modexpo *icaMex_p, int *z90cMsg_l_p,
1362                            union type4_msg *z90cMsg_p)
1363 {
1364         int mod_len, msg_size, mod_tgt_len, exp_tgt_len, inp_tgt_len;
1365         unsigned char *mod_tgt, *exp_tgt, *inp_tgt;
1366         union type4_msg *tmp_type4_msg;
1367
1368         mod_len = icaMex_p->inputdatalength;
1369
1370         msg_size = ((mod_len <= 128) ? TYPE4_SME_LEN : TYPE4_LME_LEN) +
1371                     CALLER_HEADER;
1372
1373         memset(z90cMsg_p, 0, msg_size);
1374
1375         tmp_type4_msg = (union type4_msg *)
1376                 ((unsigned char *) z90cMsg_p + CALLER_HEADER);
1377
1378         tmp_type4_msg->sme.header.msg_type_code = TYPE4_TYPE_CODE;
1379         tmp_type4_msg->sme.header.request_code = TYPE4_REQU_CODE;
1380
1381         if (mod_len <= 128) {
1382                 tmp_type4_msg->sme.header.msg_fmt = TYPE4_SME_FMT;
1383                 tmp_type4_msg->sme.header.msg_len = TYPE4_SME_LEN;
1384                 mod_tgt = tmp_type4_msg->sme.modulus;
1385                 mod_tgt_len = sizeof(tmp_type4_msg->sme.modulus);
1386                 exp_tgt = tmp_type4_msg->sme.exponent;
1387                 exp_tgt_len = sizeof(tmp_type4_msg->sme.exponent);
1388                 inp_tgt = tmp_type4_msg->sme.message;
1389                 inp_tgt_len = sizeof(tmp_type4_msg->sme.message);
1390         } else {
1391                 tmp_type4_msg->lme.header.msg_fmt = TYPE4_LME_FMT;
1392                 tmp_type4_msg->lme.header.msg_len = TYPE4_LME_LEN;
1393                 mod_tgt = tmp_type4_msg->lme.modulus;
1394                 mod_tgt_len = sizeof(tmp_type4_msg->lme.modulus);
1395                 exp_tgt = tmp_type4_msg->lme.exponent;
1396                 exp_tgt_len = sizeof(tmp_type4_msg->lme.exponent);
1397                 inp_tgt = tmp_type4_msg->lme.message;
1398                 inp_tgt_len = sizeof(tmp_type4_msg->lme.message);
1399         }
1400
1401         mod_tgt += (mod_tgt_len - mod_len);
1402         if (copy_from_user(mod_tgt, icaMex_p->n_modulus, mod_len))
1403                 return SEN_RELEASED;
1404         if (is_empty(mod_tgt, mod_len))
1405                 return SEN_USER_ERROR;
1406         exp_tgt += (exp_tgt_len - mod_len);
1407         if (copy_from_user(exp_tgt, icaMex_p->b_key, mod_len))
1408                 return SEN_RELEASED;
1409         if (is_empty(exp_tgt, mod_len))
1410                 return SEN_USER_ERROR;
1411         inp_tgt += (inp_tgt_len - mod_len);
1412         if (copy_from_user(inp_tgt, icaMex_p->inputdata, mod_len))
1413                 return SEN_RELEASED;
1414         if (is_empty(inp_tgt, mod_len))
1415                 return SEN_USER_ERROR;
1416
1417         *z90cMsg_l_p = msg_size - CALLER_HEADER;
1418
1419         return 0;
1420 }
1421
1422 static int
1423 ICACRT_msg_to_type4CRT_msg(struct ica_rsa_modexpo_crt *icaMsg_p,
1424                            int *z90cMsg_l_p, union type4_msg *z90cMsg_p)
1425 {
1426         int mod_len, short_len, long_len, tmp_size, p_tgt_len, q_tgt_len,
1427             dp_tgt_len, dq_tgt_len, u_tgt_len, inp_tgt_len;
1428         unsigned char *p_tgt, *q_tgt, *dp_tgt, *dq_tgt, *u_tgt, *inp_tgt;
1429         union type4_msg *tmp_type4_msg;
1430
1431         mod_len = icaMsg_p->inputdatalength;
1432         short_len = mod_len / 2;
1433         long_len = mod_len / 2 + 8;
1434
1435         tmp_size = ((mod_len <= 128) ? TYPE4_SCR_LEN : TYPE4_LCR_LEN) +
1436                     CALLER_HEADER;
1437
1438         memset(z90cMsg_p, 0, tmp_size);
1439
1440         tmp_type4_msg = (union type4_msg *)
1441                 ((unsigned char *) z90cMsg_p + CALLER_HEADER);
1442
1443         tmp_type4_msg->scr.header.msg_type_code = TYPE4_TYPE_CODE;
1444         tmp_type4_msg->scr.header.request_code = TYPE4_REQU_CODE;
1445         if (mod_len <= 128) {
1446                 tmp_type4_msg->scr.header.msg_fmt = TYPE4_SCR_FMT;
1447                 tmp_type4_msg->scr.header.msg_len = TYPE4_SCR_LEN;
1448                 p_tgt = tmp_type4_msg->scr.p;
1449                 p_tgt_len = sizeof(tmp_type4_msg->scr.p);
1450                 q_tgt = tmp_type4_msg->scr.q;
1451                 q_tgt_len = sizeof(tmp_type4_msg->scr.q);
1452                 dp_tgt = tmp_type4_msg->scr.dp;
1453                 dp_tgt_len = sizeof(tmp_type4_msg->scr.dp);
1454                 dq_tgt = tmp_type4_msg->scr.dq;
1455                 dq_tgt_len = sizeof(tmp_type4_msg->scr.dq);
1456                 u_tgt = tmp_type4_msg->scr.u;
1457                 u_tgt_len = sizeof(tmp_type4_msg->scr.u);
1458                 inp_tgt = tmp_type4_msg->scr.message;
1459                 inp_tgt_len = sizeof(tmp_type4_msg->scr.message);
1460         } else {
1461                 tmp_type4_msg->lcr.header.msg_fmt = TYPE4_LCR_FMT;
1462                 tmp_type4_msg->lcr.header.msg_len = TYPE4_LCR_LEN;
1463                 p_tgt = tmp_type4_msg->lcr.p;
1464                 p_tgt_len = sizeof(tmp_type4_msg->lcr.p);
1465                 q_tgt = tmp_type4_msg->lcr.q;
1466                 q_tgt_len = sizeof(tmp_type4_msg->lcr.q);
1467                 dp_tgt = tmp_type4_msg->lcr.dp;
1468                 dp_tgt_len = sizeof(tmp_type4_msg->lcr.dp);
1469                 dq_tgt = tmp_type4_msg->lcr.dq;
1470                 dq_tgt_len = sizeof(tmp_type4_msg->lcr.dq);
1471                 u_tgt = tmp_type4_msg->lcr.u;
1472                 u_tgt_len = sizeof(tmp_type4_msg->lcr.u);
1473                 inp_tgt = tmp_type4_msg->lcr.message;
1474                 inp_tgt_len = sizeof(tmp_type4_msg->lcr.message);
1475         }
1476
1477         p_tgt += (p_tgt_len - long_len);
1478         if (copy_from_user(p_tgt, icaMsg_p->np_prime, long_len))
1479                 return SEN_RELEASED;
1480         if (is_empty(p_tgt, long_len))
1481                 return SEN_USER_ERROR;
1482         q_tgt += (q_tgt_len - short_len);
1483         if (copy_from_user(q_tgt, icaMsg_p->nq_prime, short_len))
1484                 return SEN_RELEASED;
1485         if (is_empty(q_tgt, short_len))
1486                 return SEN_USER_ERROR;
1487         dp_tgt += (dp_tgt_len - long_len);
1488         if (copy_from_user(dp_tgt, icaMsg_p->bp_key, long_len))
1489                 return SEN_RELEASED;
1490         if (is_empty(dp_tgt, long_len))
1491                 return SEN_USER_ERROR;
1492         dq_tgt += (dq_tgt_len - short_len);
1493         if (copy_from_user(dq_tgt, icaMsg_p->bq_key, short_len))
1494                 return SEN_RELEASED;
1495         if (is_empty(dq_tgt, short_len))
1496                 return SEN_USER_ERROR;
1497         u_tgt += (u_tgt_len - long_len);
1498         if (copy_from_user(u_tgt, icaMsg_p->u_mult_inv, long_len))
1499                 return SEN_RELEASED;
1500         if (is_empty(u_tgt, long_len))
1501                 return SEN_USER_ERROR;
1502         inp_tgt += (inp_tgt_len - mod_len);
1503         if (copy_from_user(inp_tgt, icaMsg_p->inputdata, mod_len))
1504                 return SEN_RELEASED;
1505         if (is_empty(inp_tgt, mod_len))
1506                 return SEN_USER_ERROR;
1507
1508         *z90cMsg_l_p = tmp_size - CALLER_HEADER;
1509
1510         return 0;
1511 }
1512
1513 static int
1514 ICAMEX_msg_to_type6MEX_de_msg(struct ica_rsa_modexpo *icaMsg_p, int cdx,
1515                               int *z90cMsg_l_p, struct type6_msg *z90cMsg_p)
1516 {
1517         int mod_len, vud_len, tmp_size, total_CPRB_len, parmBlock_l;
1518         unsigned char *temp;
1519         struct type6_hdr *tp6Hdr_p;
1520         struct CPRB *cprb_p;
1521         struct cca_private_ext_ME *key_p;
1522         static int deprecated_msg_count = 0;
1523
1524         mod_len = icaMsg_p->inputdatalength;
1525         tmp_size = FIXED_TYPE6_ME_LEN + mod_len;
1526         total_CPRB_len = tmp_size - sizeof(struct type6_hdr);
1527         parmBlock_l = total_CPRB_len - sizeof(struct CPRB);
1528         tmp_size = 4*((tmp_size + 3)/4) + CALLER_HEADER;
1529
1530         memset(z90cMsg_p, 0, tmp_size);
1531
1532         temp = (unsigned char *)z90cMsg_p + CALLER_HEADER;
1533         memcpy(temp, &static_type6_hdr, sizeof(struct type6_hdr));
1534         tp6Hdr_p = (struct type6_hdr *)temp;
1535         tp6Hdr_p->ToCardLen1 = 4*((total_CPRB_len+3)/4);
1536         tp6Hdr_p->FromCardLen1 = RESPONSE_CPRB_SIZE;
1537
1538         temp += sizeof(struct type6_hdr);
1539         memcpy(temp, &static_cprb, sizeof(struct CPRB));
1540         cprb_p = (struct CPRB *) temp;
1541         cprb_p->usage_domain[0]= (unsigned char)cdx;
1542         itoLe2(&parmBlock_l, cprb_p->req_parml);
1543         itoLe2((int *)&(tp6Hdr_p->FromCardLen1), cprb_p->rpl_parml);
1544
1545         temp += sizeof(struct CPRB);
1546         memcpy(temp, &static_pkd_function_and_rules,
1547                sizeof(struct function_and_rules_block));
1548
1549         temp += sizeof(struct function_and_rules_block);
1550         vud_len = 2 + icaMsg_p->inputdatalength;
1551         itoLe2(&vud_len, temp);
1552
1553         temp += 2;
1554         if (copy_from_user(temp, icaMsg_p->inputdata, mod_len))
1555                 return SEN_RELEASED;
1556         if (is_empty(temp, mod_len))
1557                 return SEN_USER_ERROR;
1558
1559         temp += mod_len;
1560         memcpy(temp, &static_T6_keyBlock_hdr, sizeof(struct T6_keyBlock_hdr));
1561
1562         temp += sizeof(struct T6_keyBlock_hdr);
1563         memcpy(temp, &static_pvt_me_key, sizeof(struct cca_private_ext_ME));
1564         key_p = (struct cca_private_ext_ME *)temp;
1565         temp = key_p->pvtMESec.exponent + sizeof(key_p->pvtMESec.exponent)
1566                - mod_len;
1567         if (copy_from_user(temp, icaMsg_p->b_key, mod_len))
1568                 return SEN_RELEASED;
1569         if (is_empty(temp, mod_len))
1570                 return SEN_USER_ERROR;
1571
1572         if (is_common_public_key(temp, mod_len)) {
1573                 if (deprecated_msg_count < 20) {
1574                         PRINTK("Common public key used for modex decrypt\n");
1575                         deprecated_msg_count++;
1576                         if (deprecated_msg_count == 20)
1577                                 PRINTK("No longer issuing messages about common"
1578                                        " public key for modex decrypt.\n");
1579                 }
1580                 return SEN_NOT_AVAIL;
1581         }
1582
1583         temp = key_p->pvtMESec.modulus + sizeof(key_p->pvtMESec.modulus)
1584                - mod_len;
1585         if (copy_from_user(temp, icaMsg_p->n_modulus, mod_len))
1586                 return SEN_RELEASED;
1587         if (is_empty(temp, mod_len))
1588                 return SEN_USER_ERROR;
1589
1590         key_p->pubMESec.modulus_bit_len = 8 * mod_len;
1591
1592         *z90cMsg_l_p = tmp_size - CALLER_HEADER;
1593
1594         return 0;
1595 }
1596
1597 static int
1598 ICAMEX_msg_to_type6MEX_en_msg(struct ica_rsa_modexpo *icaMsg_p, int cdx,
1599                               int *z90cMsg_l_p, struct type6_msg *z90cMsg_p)
1600 {
1601         int mod_len, vud_len, exp_len, key_len;
1602         int pad_len, tmp_size, total_CPRB_len, parmBlock_l, i;
1603         unsigned char *temp_exp, *exp_p, *temp;
1604         struct type6_hdr *tp6Hdr_p;
1605         struct CPRB *cprb_p;
1606         struct cca_public_key *key_p;
1607         struct T6_keyBlock_hdr *keyb_p;
1608
1609         temp_exp = kmalloc(256, GFP_KERNEL);
1610         if (!temp_exp)
1611                 return EGETBUFF;
1612         mod_len = icaMsg_p->inputdatalength;
1613         if (copy_from_user(temp_exp, icaMsg_p->b_key, mod_len)) {
1614                 kfree(temp_exp);
1615                 return SEN_RELEASED;
1616         }
1617         if (is_empty(temp_exp, mod_len)) {
1618                 kfree(temp_exp);
1619                 return SEN_USER_ERROR;
1620         }
1621
1622         exp_p = temp_exp;
1623         for (i = 0; i < mod_len; i++)
1624                 if (exp_p[i])
1625                         break;
1626         if (i >= mod_len) {
1627                 kfree(temp_exp);
1628                 return SEN_USER_ERROR;
1629         }
1630
1631         exp_len = mod_len - i;
1632         exp_p += i;
1633
1634         PDEBUG("exp_len after computation: %08x\n", exp_len);
1635         tmp_size = FIXED_TYPE6_ME_EN_LEN + 2 * mod_len + exp_len;
1636         total_CPRB_len = tmp_size - sizeof(struct type6_hdr);
1637         parmBlock_l = total_CPRB_len - sizeof(struct CPRB);
1638         tmp_size = 4*((tmp_size + 3)/4) + CALLER_HEADER;
1639
1640         vud_len = 2 + mod_len;
1641         memset(z90cMsg_p, 0, tmp_size);
1642
1643         temp = (unsigned char *)z90cMsg_p + CALLER_HEADER;
1644         memcpy(temp, &static_type6_hdr, sizeof(struct type6_hdr));
1645         tp6Hdr_p = (struct type6_hdr *)temp;
1646         tp6Hdr_p->ToCardLen1 = 4*((total_CPRB_len+3)/4);
1647         tp6Hdr_p->FromCardLen1 = RESPONSE_CPRB_SIZE;
1648         memcpy(tp6Hdr_p->function_code, static_PKE_function_code,
1649                sizeof(static_PKE_function_code));
1650         temp += sizeof(struct type6_hdr);
1651         memcpy(temp, &static_cprb, sizeof(struct CPRB));
1652         cprb_p = (struct CPRB *) temp;
1653         cprb_p->usage_domain[0]= (unsigned char)cdx;
1654         itoLe2((int *)&(tp6Hdr_p->FromCardLen1), cprb_p->rpl_parml);
1655         temp += sizeof(struct CPRB);
1656         memcpy(temp, &static_pke_function_and_rules,
1657                  sizeof(struct function_and_rules_block));
1658         temp += sizeof(struct function_and_rules_block);
1659         temp += 2;
1660         if (copy_from_user(temp, icaMsg_p->inputdata, mod_len)) {
1661                 kfree(temp_exp);
1662                 return SEN_RELEASED;
1663         }
1664         if (is_empty(temp, mod_len)) {
1665                 kfree(temp_exp);
1666                 return SEN_USER_ERROR;
1667         }
1668         if ((temp[0] != 0x00) || (temp[1] != 0x02)) {
1669                 kfree(temp_exp);
1670                 return SEN_NOT_AVAIL;
1671         }
1672         for (i = 2; i < mod_len; i++)
1673                 if (temp[i] == 0x00)
1674                         break;
1675         if ((i < 9) || (i > (mod_len - 2))) {
1676                 kfree(temp_exp);
1677                 return SEN_NOT_AVAIL;
1678         }
1679         pad_len = i + 1;
1680         vud_len = mod_len - pad_len;
1681         memmove(temp, temp+pad_len, vud_len);
1682         temp -= 2;
1683         vud_len += 2;
1684         itoLe2(&vud_len, temp);
1685         temp += (vud_len);
1686         keyb_p = (struct T6_keyBlock_hdr *)temp;
1687         temp += sizeof(struct T6_keyBlock_hdr);
1688         memcpy(temp, &static_public_key, sizeof(static_public_key));
1689         key_p = (struct cca_public_key *)temp;
1690         temp = key_p->pubSec.exponent;
1691         memcpy(temp, exp_p, exp_len);
1692         kfree(temp_exp);
1693         temp += exp_len;
1694         if (copy_from_user(temp, icaMsg_p->n_modulus, mod_len))
1695                 return SEN_RELEASED;
1696         if (is_empty(temp, mod_len))
1697                 return SEN_USER_ERROR;
1698         key_p->pubSec.modulus_bit_len = 8 * mod_len;
1699         key_p->pubSec.modulus_byte_len = mod_len;
1700         key_p->pubSec.exponent_len = exp_len;
1701         key_p->pubSec.section_length = CALLER_HEADER + mod_len + exp_len;
1702         key_len = key_p->pubSec.section_length + sizeof(struct cca_token_hdr);
1703         key_p->pubHdr.token_length = key_len;
1704         key_len += 4;
1705         itoLe2(&key_len, keyb_p->ulen);
1706         key_len += 2;
1707         itoLe2(&key_len, keyb_p->blen);
1708         parmBlock_l -= pad_len;
1709         itoLe2(&parmBlock_l, cprb_p->req_parml);
1710         *z90cMsg_l_p = tmp_size - CALLER_HEADER;
1711
1712         return 0;
1713 }
1714
1715 static int
1716 ICACRT_msg_to_type6CRT_msg(struct ica_rsa_modexpo_crt *icaMsg_p, int cdx,
1717                            int *z90cMsg_l_p, struct type6_msg *z90cMsg_p)
1718 {
1719         int mod_len, vud_len, tmp_size, total_CPRB_len, parmBlock_l, short_len;
1720         int long_len, pad_len, keyPartsLen, tmp_l;
1721         unsigned char *tgt_p, *temp;
1722         struct type6_hdr *tp6Hdr_p;
1723         struct CPRB *cprb_p;
1724         struct cca_token_hdr *keyHdr_p;
1725         struct cca_pvt_ext_CRT_sec *pvtSec_p;
1726         struct cca_public_sec *pubSec_p;
1727
1728         mod_len = icaMsg_p->inputdatalength;
1729         short_len = mod_len / 2;
1730         long_len = 8 + short_len;
1731         keyPartsLen = 3 * long_len + 2 * short_len;
1732         pad_len = (8 - (keyPartsLen % 8)) % 8;
1733         keyPartsLen += pad_len + mod_len;
1734         tmp_size = FIXED_TYPE6_CR_LEN + keyPartsLen + mod_len;
1735         total_CPRB_len = tmp_size -  sizeof(struct type6_hdr);
1736         parmBlock_l = total_CPRB_len - sizeof(struct CPRB);
1737         vud_len = 2 + mod_len;
1738         tmp_size = 4*((tmp_size + 3)/4) + CALLER_HEADER;
1739
1740         memset(z90cMsg_p, 0, tmp_size);
1741         tgt_p = (unsigned char *)z90cMsg_p + CALLER_HEADER;
1742         memcpy(tgt_p, &static_type6_hdr, sizeof(struct type6_hdr));
1743         tp6Hdr_p = (struct type6_hdr *)tgt_p;
1744         tp6Hdr_p->ToCardLen1 = 4*((total_CPRB_len+3)/4);
1745         tp6Hdr_p->FromCardLen1 = RESPONSE_CPRB_SIZE;
1746         tgt_p += sizeof(struct type6_hdr);
1747         cprb_p = (struct CPRB *) tgt_p;
1748         memcpy(tgt_p, &static_cprb, sizeof(struct CPRB));
1749         cprb_p->usage_domain[0]= *((unsigned char *)(&(cdx))+3);
1750         itoLe2(&parmBlock_l, cprb_p->req_parml);
1751         memcpy(cprb_p->rpl_parml, cprb_p->req_parml,
1752                sizeof(cprb_p->req_parml));
1753         tgt_p += sizeof(struct CPRB);
1754         memcpy(tgt_p, &static_pkd_function_and_rules,
1755                sizeof(struct function_and_rules_block));
1756         tgt_p += sizeof(struct function_and_rules_block);
1757         itoLe2(&vud_len, tgt_p);
1758         tgt_p += 2;
1759         if (copy_from_user(tgt_p, icaMsg_p->inputdata, mod_len))
1760                 return SEN_RELEASED;
1761         if (is_empty(tgt_p, mod_len))
1762                 return SEN_USER_ERROR;
1763         tgt_p += mod_len;
1764         tmp_l = sizeof(struct T6_keyBlock_hdr) + sizeof(struct cca_token_hdr) +
1765                 sizeof(struct cca_pvt_ext_CRT_sec) + 0x0F + keyPartsLen;
1766         itoLe2(&tmp_l, tgt_p);
1767         temp = tgt_p + 2;
1768         tmp_l -= 2;
1769         itoLe2(&tmp_l, temp);
1770         tgt_p += sizeof(struct T6_keyBlock_hdr);
1771         keyHdr_p = (struct cca_token_hdr *)tgt_p;
1772         keyHdr_p->token_identifier = CCA_TKN_HDR_ID_EXT;
1773         tmp_l -= 4;
1774         keyHdr_p->token_length = tmp_l;
1775         tgt_p += sizeof(struct cca_token_hdr);
1776         pvtSec_p = (struct cca_pvt_ext_CRT_sec *)tgt_p;
1777         pvtSec_p->section_identifier = CCA_PVT_EXT_CRT_SEC_ID_PVT;
1778         pvtSec_p->section_length =
1779                 sizeof(struct cca_pvt_ext_CRT_sec) + keyPartsLen;
1780         pvtSec_p->key_format = CCA_PVT_EXT_CRT_SEC_FMT_CL;
1781         pvtSec_p->key_use_flags[0] = CCA_PVT_USAGE_ALL;
1782         pvtSec_p->p_len = long_len;
1783         pvtSec_p->q_len = short_len;
1784         pvtSec_p->dp_len = long_len;
1785         pvtSec_p->dq_len = short_len;
1786         pvtSec_p->u_len = long_len;
1787         pvtSec_p->mod_len = mod_len;
1788         pvtSec_p->pad_len = pad_len;
1789         tgt_p += sizeof(struct cca_pvt_ext_CRT_sec);
1790         if (copy_from_user(tgt_p, icaMsg_p->np_prime, long_len))
1791                 return SEN_RELEASED;
1792         if (is_empty(tgt_p, long_len))
1793                 return SEN_USER_ERROR;
1794         tgt_p += long_len;
1795         if (copy_from_user(tgt_p, icaMsg_p->nq_prime, short_len))
1796                 return SEN_RELEASED;
1797         if (is_empty(tgt_p, short_len))
1798                 return SEN_USER_ERROR;
1799         tgt_p += short_len;
1800         if (copy_from_user(tgt_p, icaMsg_p->bp_key, long_len))
1801                 return SEN_RELEASED;
1802         if (is_empty(tgt_p, long_len))
1803                 return SEN_USER_ERROR;
1804         tgt_p += long_len;
1805         if (copy_from_user(tgt_p, icaMsg_p->bq_key, short_len))
1806                 return SEN_RELEASED;
1807         if (is_empty(tgt_p, short_len))
1808                 return SEN_USER_ERROR;
1809         tgt_p += short_len;
1810         if (copy_from_user(tgt_p, icaMsg_p->u_mult_inv, long_len))
1811                 return SEN_RELEASED;
1812         if (is_empty(tgt_p, long_len))
1813                 return SEN_USER_ERROR;
1814         tgt_p += long_len;
1815         tgt_p += pad_len;
1816         memset(tgt_p, 0xFF, mod_len);
1817         tgt_p += mod_len;
1818         memcpy(tgt_p, &static_cca_pub_sec, sizeof(struct cca_public_sec));
1819         pubSec_p = (struct cca_public_sec *) tgt_p;
1820         pubSec_p->modulus_bit_len = 8 * mod_len;
1821         *z90cMsg_l_p = tmp_size - CALLER_HEADER;
1822
1823         return 0;
1824 }
1825
1826 static int
1827 ICAMEX_msg_to_type6MEX_msgX(struct ica_rsa_modexpo *icaMsg_p, int cdx,
1828                             int *z90cMsg_l_p, struct type6_msg *z90cMsg_p,
1829                             int dev_type)
1830 {
1831         int mod_len, exp_len, vud_len, tmp_size, total_CPRB_len, parmBlock_l;
1832         int key_len, i;
1833         unsigned char *temp_exp, *tgt_p, *temp, *exp_p;
1834         struct type6_hdr *tp6Hdr_p;
1835         struct CPRBX *cprbx_p;
1836         struct cca_public_key *key_p;
1837         struct T6_keyBlock_hdrX *keyb_p;
1838
1839         temp_exp = kmalloc(256, GFP_KERNEL);
1840         if (!temp_exp)
1841                 return EGETBUFF;
1842         mod_len = icaMsg_p->inputdatalength;
1843         if (copy_from_user(temp_exp, icaMsg_p->b_key, mod_len)) {
1844                 kfree(temp_exp);
1845                 return SEN_RELEASED;
1846         }
1847         if (is_empty(temp_exp, mod_len)) {
1848                 kfree(temp_exp);
1849                 return SEN_USER_ERROR;
1850         }
1851         exp_p = temp_exp;
1852         for (i = 0; i < mod_len; i++)
1853                 if (exp_p[i])
1854                         break;
1855         if (i >= mod_len) {
1856                 kfree(temp_exp);
1857                 return SEN_USER_ERROR;
1858         }
1859         exp_len = mod_len - i;
1860         exp_p += i;
1861         PDEBUG("exp_len after computation: %08x\n", exp_len);
1862         tmp_size = FIXED_TYPE6_ME_EN_LENX + 2 * mod_len + exp_len;
1863         total_CPRB_len = tmp_size - sizeof(struct type6_hdr);
1864         parmBlock_l = total_CPRB_len - sizeof(struct CPRBX);
1865         tmp_size = tmp_size + CALLER_HEADER;
1866         vud_len = 2 + mod_len;
1867         memset(z90cMsg_p, 0, tmp_size);
1868         tgt_p = (unsigned char *)z90cMsg_p + CALLER_HEADER;
1869         memcpy(tgt_p, &static_type6_hdrX, sizeof(struct type6_hdr));
1870         tp6Hdr_p = (struct type6_hdr *)tgt_p;
1871         tp6Hdr_p->ToCardLen1 = total_CPRB_len;
1872         tp6Hdr_p->FromCardLen1 = RESPONSE_CPRBX_SIZE;
1873         memcpy(tp6Hdr_p->function_code, static_PKE_function_code,
1874                sizeof(static_PKE_function_code));
1875         tgt_p += sizeof(struct type6_hdr);
1876         memcpy(tgt_p, &static_cprbx, sizeof(struct CPRBX));
1877         cprbx_p = (struct CPRBX *) tgt_p;
1878         cprbx_p->domain = (unsigned short)cdx;
1879         cprbx_p->rpl_msgbl = RESPONSE_CPRBX_SIZE;
1880         tgt_p += sizeof(struct CPRBX);
1881         if (dev_type == PCIXCC_MCL2)
1882                 memcpy(tgt_p, &static_pke_function_and_rulesX_MCL2,
1883                        sizeof(struct function_and_rules_block));
1884         else
1885                 memcpy(tgt_p, &static_pke_function_and_rulesX,
1886                        sizeof(struct function_and_rules_block));
1887         tgt_p += sizeof(struct function_and_rules_block);
1888
1889         tgt_p += 2;
1890         if (copy_from_user(tgt_p, icaMsg_p->inputdata, mod_len)) {
1891                 kfree(temp_exp);
1892                 return SEN_RELEASED;
1893         }
1894         if (is_empty(tgt_p, mod_len)) {
1895                 kfree(temp_exp);
1896                 return SEN_USER_ERROR;
1897         }
1898         tgt_p -= 2;
1899         *((short *)tgt_p) = (short) vud_len;
1900         tgt_p += vud_len;
1901         keyb_p = (struct T6_keyBlock_hdrX *)tgt_p;
1902         tgt_p += sizeof(struct T6_keyBlock_hdrX);
1903         memcpy(tgt_p, &static_public_key, sizeof(static_public_key));
1904         key_p = (struct cca_public_key *)tgt_p;
1905         temp = key_p->pubSec.exponent;
1906         memcpy(temp, exp_p, exp_len);
1907         kfree(temp_exp);
1908         temp += exp_len;
1909         if (copy_from_user(temp, icaMsg_p->n_modulus, mod_len))
1910                 return SEN_RELEASED;
1911         if (is_empty(temp, mod_len))
1912                 return SEN_USER_ERROR;
1913         key_p->pubSec.modulus_bit_len = 8 * mod_len;
1914         key_p->pubSec.modulus_byte_len = mod_len;
1915         key_p->pubSec.exponent_len = exp_len;
1916         key_p->pubSec.section_length = CALLER_HEADER + mod_len + exp_len;
1917         key_len = key_p->pubSec.section_length + sizeof(struct cca_token_hdr);
1918         key_p->pubHdr.token_length = key_len;
1919         key_len += 4;
1920         keyb_p->ulen = (unsigned short)key_len;
1921         key_len += 2;
1922         keyb_p->blen = (unsigned short)key_len;
1923         cprbx_p->req_parml = parmBlock_l;
1924         *z90cMsg_l_p = tmp_size - CALLER_HEADER;
1925
1926         return 0;
1927 }
1928
1929 static int
1930 ICACRT_msg_to_type6CRT_msgX(struct ica_rsa_modexpo_crt *icaMsg_p, int cdx,
1931                             int *z90cMsg_l_p, struct type6_msg *z90cMsg_p,
1932                             int dev_type)
1933 {
1934         int mod_len, vud_len, tmp_size, total_CPRB_len, parmBlock_l, short_len;
1935         int long_len, pad_len, keyPartsLen, tmp_l;
1936         unsigned char *tgt_p, *temp;
1937         struct type6_hdr *tp6Hdr_p;
1938         struct CPRBX *cprbx_p;
1939         struct cca_token_hdr *keyHdr_p;
1940         struct cca_pvt_ext_CRT_sec *pvtSec_p;
1941         struct cca_public_sec *pubSec_p;
1942
1943         mod_len = icaMsg_p->inputdatalength;
1944         short_len = mod_len / 2;
1945         long_len = 8 + short_len;
1946         keyPartsLen = 3 * long_len + 2 * short_len;
1947         pad_len = (8 - (keyPartsLen % 8)) % 8;
1948         keyPartsLen += pad_len + mod_len;
1949         tmp_size = FIXED_TYPE6_CR_LENX + keyPartsLen + mod_len;
1950         total_CPRB_len = tmp_size -  sizeof(struct type6_hdr);
1951         parmBlock_l = total_CPRB_len - sizeof(struct CPRBX);
1952         vud_len = 2 + mod_len;
1953         tmp_size = tmp_size + CALLER_HEADER;
1954         memset(z90cMsg_p, 0, tmp_size);
1955         tgt_p = (unsigned char *)z90cMsg_p + CALLER_HEADER;
1956         memcpy(tgt_p, &static_type6_hdrX, sizeof(struct type6_hdr));
1957         tp6Hdr_p = (struct type6_hdr *)tgt_p;
1958         tp6Hdr_p->ToCardLen1 = total_CPRB_len;
1959         tp6Hdr_p->FromCardLen1 = RESPONSE_CPRBX_SIZE;
1960         tgt_p += sizeof(struct type6_hdr);
1961         cprbx_p = (struct CPRBX *) tgt_p;
1962         memcpy(tgt_p, &static_cprbx, sizeof(struct CPRBX));
1963         cprbx_p->domain = (unsigned short)cdx;
1964         cprbx_p->req_parml = parmBlock_l;
1965         cprbx_p->rpl_msgbl = parmBlock_l;
1966         tgt_p += sizeof(struct CPRBX);
1967         if (dev_type == PCIXCC_MCL2)
1968                 memcpy(tgt_p, &static_pkd_function_and_rulesX_MCL2,
1969                        sizeof(struct function_and_rules_block));
1970         else
1971                 memcpy(tgt_p, &static_pkd_function_and_rulesX,
1972                        sizeof(struct function_and_rules_block));
1973         tgt_p += sizeof(struct function_and_rules_block);
1974         *((short *)tgt_p) = (short) vud_len;
1975         tgt_p += 2;
1976         if (copy_from_user(tgt_p, icaMsg_p->inputdata, mod_len))
1977                 return SEN_RELEASED;
1978         if (is_empty(tgt_p, mod_len))
1979                 return SEN_USER_ERROR;
1980         tgt_p += mod_len;
1981         tmp_l = sizeof(struct T6_keyBlock_hdr) + sizeof(struct cca_token_hdr) +
1982                 sizeof(struct cca_pvt_ext_CRT_sec) + 0x0F + keyPartsLen;
1983         *((short *)tgt_p) = (short) tmp_l;
1984         temp = tgt_p + 2;
1985         tmp_l -= 2;
1986         *((short *)temp) = (short) tmp_l;
1987         tgt_p += sizeof(struct T6_keyBlock_hdr);
1988         keyHdr_p = (struct cca_token_hdr *)tgt_p;
1989         keyHdr_p->token_identifier = CCA_TKN_HDR_ID_EXT;
1990         tmp_l -= 4;
1991         keyHdr_p->token_length = tmp_l;
1992         tgt_p += sizeof(struct cca_token_hdr);
1993         pvtSec_p = (struct cca_pvt_ext_CRT_sec *)tgt_p;
1994         pvtSec_p->section_identifier = CCA_PVT_EXT_CRT_SEC_ID_PVT;
1995         pvtSec_p->section_length =
1996                 sizeof(struct cca_pvt_ext_CRT_sec) + keyPartsLen;
1997         pvtSec_p->key_format = CCA_PVT_EXT_CRT_SEC_FMT_CL;
1998         pvtSec_p->key_use_flags[0] = CCA_PVT_USAGE_ALL;
1999         pvtSec_p->p_len = long_len;
2000         pvtSec_p->q_len = short_len;
2001         pvtSec_p->dp_len = long_len;
2002         pvtSec_p->dq_len = short_len;
2003         pvtSec_p->u_len = long_len;
2004         pvtSec_p->mod_len = mod_len;
2005         pvtSec_p->pad_len = pad_len;
2006         tgt_p += sizeof(struct cca_pvt_ext_CRT_sec);
2007         if (copy_from_user(tgt_p, icaMsg_p->np_prime, long_len))
2008                 return SEN_RELEASED;
2009         if (is_empty(tgt_p, long_len))
2010                 return SEN_USER_ERROR;
2011         tgt_p += long_len;
2012         if (copy_from_user(tgt_p, icaMsg_p->nq_prime, short_len))
2013                 return SEN_RELEASED;
2014         if (is_empty(tgt_p, short_len))
2015                 return SEN_USER_ERROR;
2016         tgt_p += short_len;
2017         if (copy_from_user(tgt_p, icaMsg_p->bp_key, long_len))
2018                 return SEN_RELEASED;
2019         if (is_empty(tgt_p, long_len))
2020                 return SEN_USER_ERROR;
2021         tgt_p += long_len;
2022         if (copy_from_user(tgt_p, icaMsg_p->bq_key, short_len))
2023                 return SEN_RELEASED;
2024         if (is_empty(tgt_p, short_len))
2025                 return SEN_USER_ERROR;
2026         tgt_p += short_len;
2027         if (copy_from_user(tgt_p, icaMsg_p->u_mult_inv, long_len))
2028                 return SEN_RELEASED;
2029         if (is_empty(tgt_p, long_len))
2030                 return SEN_USER_ERROR;
2031         tgt_p += long_len;
2032         tgt_p += pad_len;
2033         memset(tgt_p, 0xFF, mod_len);
2034         tgt_p += mod_len;
2035         memcpy(tgt_p, &static_cca_pub_sec, sizeof(struct cca_public_sec));
2036         pubSec_p = (struct cca_public_sec *) tgt_p;
2037         pubSec_p->modulus_bit_len = 8 * mod_len;
2038         *z90cMsg_l_p = tmp_size - CALLER_HEADER;
2039
2040         return 0;
2041 }
2042
2043 int
2044 convert_request(unsigned char *buffer, int func, unsigned short function,
2045                 int cdx, int dev_type, int *msg_l_p, unsigned char *msg_p)
2046 {
2047         if (dev_type == PCICA) {
2048                 if (func == ICARSACRT)
2049                         return ICACRT_msg_to_type4CRT_msg(
2050                                 (struct ica_rsa_modexpo_crt *) buffer,
2051                                 msg_l_p, (union type4_msg *) msg_p);
2052                 else
2053                         return ICAMEX_msg_to_type4MEX_msg(
2054                                 (struct ica_rsa_modexpo *) buffer,
2055                                 msg_l_p, (union type4_msg *) msg_p);
2056         }
2057         if (dev_type == PCICC) {
2058                 if (func == ICARSACRT)
2059                         return ICACRT_msg_to_type6CRT_msg(
2060                                 (struct ica_rsa_modexpo_crt *) buffer,
2061                                 cdx, msg_l_p, (struct type6_msg *)msg_p);
2062                 if (function == PCI_FUNC_KEY_ENCRYPT)
2063                         return ICAMEX_msg_to_type6MEX_en_msg(
2064                                 (struct ica_rsa_modexpo *) buffer,
2065                                 cdx, msg_l_p, (struct type6_msg *) msg_p);
2066                 else
2067                         return ICAMEX_msg_to_type6MEX_de_msg(
2068                                 (struct ica_rsa_modexpo *) buffer,
2069                                 cdx, msg_l_p, (struct type6_msg *) msg_p);
2070         }
2071         if ((dev_type == PCIXCC_MCL2) ||
2072             (dev_type == PCIXCC_MCL3) ||
2073             (dev_type == CEX2C)) {
2074                 if (func == ICARSACRT)
2075                         return ICACRT_msg_to_type6CRT_msgX(
2076                                 (struct ica_rsa_modexpo_crt *) buffer,
2077                                 cdx, msg_l_p, (struct type6_msg *) msg_p,
2078                                 dev_type);
2079                 else
2080                         return ICAMEX_msg_to_type6MEX_msgX(
2081                                 (struct ica_rsa_modexpo *) buffer,
2082                                 cdx, msg_l_p, (struct type6_msg *) msg_p,
2083                                 dev_type);
2084         }
2085
2086         return 0;
2087 }
2088
2089 int ext_bitlens_msg_count = 0;
2090 static inline void
2091 unset_ext_bitlens(void)
2092 {
2093         if (!ext_bitlens_msg_count) {
2094                 PRINTK("Unable to use coprocessors for extended bitlengths. "
2095                        "Using PCICAs (if present) for extended bitlengths. "
2096                        "This is not an error.\n");
2097                 ext_bitlens_msg_count++;
2098         }
2099         ext_bitlens = 0;
2100 }
2101
2102 int
2103 convert_response(unsigned char *response, unsigned char *buffer,
2104                  int *respbufflen_p, unsigned char *resp_buff)
2105 {
2106         struct ica_rsa_modexpo *icaMsg_p = (struct ica_rsa_modexpo *) buffer;
2107         struct type82_hdr *t82h_p = (struct type82_hdr *) response;
2108         struct type84_hdr *t84h_p = (struct type84_hdr *) response;
2109         struct type86_fmt2_msg *t86m_p =  (struct type86_fmt2_msg *) response;
2110         int reply_code, service_rc, service_rs, src_l;
2111         unsigned char *src_p, *tgt_p;
2112         struct CPRB *cprb_p;
2113         struct CPRBX *cprbx_p;
2114
2115         src_p = 0;
2116         reply_code = 0;
2117         service_rc = 0;
2118         service_rs = 0;
2119         src_l = 0;
2120         switch (t82h_p->type) {
2121         case TYPE82_RSP_CODE:
2122                 reply_code = t82h_p->reply_code;
2123                 src_p = (unsigned char *)t82h_p;
2124                 PRINTK("Hardware error: Type 82 Message Header: "
2125                        "%02x%02x%02x%02x%02x%02x%02x%02x\n",
2126                        src_p[0], src_p[1], src_p[2], src_p[3],
2127                        src_p[4], src_p[5], src_p[6], src_p[7]);
2128                 break;
2129         case TYPE84_RSP_CODE:
2130                 src_l = icaMsg_p->outputdatalength;
2131                 src_p = response + (int)t84h_p->len - src_l;
2132                 break;
2133         case TYPE86_RSP_CODE:
2134                 reply_code = t86m_p->hdr.reply_code;
2135                 if (reply_code != 0)
2136                         break;
2137                 cprb_p = (struct CPRB *)
2138                         (response + sizeof(struct type86_fmt2_msg));
2139                 cprbx_p = (struct CPRBX *) cprb_p;
2140                 if (cprb_p->cprb_ver_id != 0x02) {
2141                         le2toI(cprb_p->ccp_rtcode, &service_rc);
2142                         if (service_rc != 0) {
2143                                 le2toI(cprb_p->ccp_rscode, &service_rs);
2144                                 if ((service_rc == 8) && (service_rs == 66))
2145                                         PDEBUG("Bad block format on PCICC\n");
2146                                 else if ((service_rc == 8) && (service_rs == 770)) {
2147                                         PDEBUG("Invalid key length on PCICC\n");
2148                                         unset_ext_bitlens();
2149                                         return REC_USE_PCICA;
2150                                 }
2151                                 else if ((service_rc == 8) && (service_rs == 783)) {
2152                                         PDEBUG("Extended bitlengths not enabled"
2153                                                "on PCICC\n");
2154                                         unset_ext_bitlens();
2155                                         return REC_USE_PCICA;
2156                                 }
2157                                 else
2158                                         PRINTK("service rc/rs: %d/%d\n",
2159                                                service_rc, service_rs);
2160                                 return REC_OPERAND_INV;
2161                         }
2162                         src_p = (unsigned char *)cprb_p + sizeof(struct CPRB);
2163                         src_p += 4;
2164                         le2toI(src_p, &src_l);
2165                         src_l -= 2;
2166                         src_p += 2;
2167                 } else {
2168                         service_rc = (int)cprbx_p->ccp_rtcode;
2169                         if (service_rc != 0) {
2170                                 service_rs = (int) cprbx_p->ccp_rscode;
2171                                 if ((service_rc == 8) && (service_rs == 66))
2172                                         PDEBUG("Bad block format on PCXICC\n");
2173                                 else if ((service_rc == 8) && (service_rs == 770)) {
2174                                         PDEBUG("Invalid key length on PCIXCC\n");
2175                                         unset_ext_bitlens();
2176                                         return REC_USE_PCICA;
2177                                 }
2178                                 else if ((service_rc == 8) && (service_rs == 783)) {
2179                                         PDEBUG("Extended bitlengths not enabled"
2180                                                "on PCIXCC\n");
2181                                         unset_ext_bitlens();
2182                                         return REC_USE_PCICA;
2183                                 }
2184                                 else
2185                                         PRINTK("service rc/rs: %d/%d\n",
2186                                                service_rc, service_rs);
2187                                 return REC_OPERAND_INV;
2188                         }
2189                         src_p = (unsigned char *)
2190                                 cprbx_p + sizeof(struct CPRBX);
2191                         src_p += 4;
2192                         src_l = (int)(*((short *) src_p));
2193                         src_l -= 2;
2194                         src_p += 2;
2195                 }
2196                 break;
2197         default:
2198                 return REC_BAD_MESSAGE;
2199         }
2200
2201         if (reply_code)
2202                 switch (reply_code) {
2203                 case REPLY_ERROR_OPERAND_INVALID:
2204                         return REC_OPERAND_INV;
2205                 case REPLY_ERROR_OPERAND_SIZE:
2206                         return REC_OPERAND_SIZE;
2207                 case REPLY_ERROR_EVEN_MOD_IN_OPND:
2208                         return REC_EVEN_MOD;
2209                 case REPLY_ERROR_MESSAGE_TYPE:
2210                         return WRONG_DEVICE_TYPE;
2211                 case REPLY_ERROR_TRANSPORT_FAIL:
2212                         PRINTKW("Transport failed (APFS = %02X%02X%02X%02X)\n",
2213                                 t86m_p->apfs[0], t86m_p->apfs[1],
2214                                 t86m_p->apfs[2], t86m_p->apfs[3]);
2215                         return REC_HARDWAR_ERR;
2216                 default:
2217                         PRINTKW("reply code = %d\n", reply_code);
2218                         return REC_HARDWAR_ERR;
2219                 }
2220
2221         if (service_rc != 0)
2222                 return REC_OPERAND_INV;
2223
2224         if ((src_l > icaMsg_p->outputdatalength) ||
2225             (src_l > RESPBUFFSIZE) ||
2226             (src_l <= 0))
2227                 return REC_OPERAND_SIZE;
2228
2229         PDEBUG("Length returned = %d\n", src_l);
2230         tgt_p = resp_buff + icaMsg_p->outputdatalength - src_l;
2231         memcpy(tgt_p, src_p, src_l);
2232         if ((t82h_p->type == TYPE86_RSP_CODE) && (resp_buff < tgt_p)) {
2233                 memset(resp_buff, 0, icaMsg_p->outputdatalength - src_l);
2234                 if (pad_msg(resp_buff, icaMsg_p->outputdatalength, src_l))
2235                         return REC_INVALID_PAD;
2236         }
2237         *respbufflen_p = icaMsg_p->outputdatalength;
2238         if (*respbufflen_p == 0)
2239                 PRINTK("Zero *respbufflen_p\n");
2240
2241         return 0;
2242 }
2243