sys/mips/rmi/dev/sec/rmilib.c

   1 /*-
   2  * Copyright (c) 2003-2009 RMI Corporation
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of RMI Corporation, nor the names of its contributors,
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * RMI_BSD
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/param.h>
  36 #include <sys/types.h>
  37 #include <sys/systm.h>
  38 #include <sys/kernel.h>
  39 #include <sys/module.h>
  40 #include <sys/malloc.h>
  41 #include <sys/bus.h>
  42 #include <machine/bus.h>
  43 #include <machine/md_var.h>
  44 #include <machine/cpuregs.h>
  45
  46 #include <vm/vm.h>
  47 #include <vm/pmap.h>
  48
  49 #include <opencrypto/cryptodev.h>
  50
  51 #include <mips/rmi/rmi_mips_exts.h>
  52 #include <mips/rmi/iomap.h>
  53 #include <mips/rmi/pic.h>
  54 #include <mips/rmi/rmi_boot_info.h>
  55 #include <mips/rmi/msgring.h>
  56 #include <mips/rmi/board.h>
  57 #include <mips/rmi/dev/sec/rmilib.h>
  58 #include <mips/rmi/dev/sec/desc.h>
  59
  60
  61 /* static int msgrng_stnid_pk0 = MSGRNG_STNID_PK0; */
  62
  63 /* #define RMI_SEC_DEBUG */
  64
  65 #define SMP_CACHE_BYTES XLR_CACHELINE_SIZE
  66 #define NUM_CHUNKS(size, bits) ( ((size)>>(bits)) + (((size)&((1<<(bits))-1))?1:0) )
  67
  68 static const char nib2hex[] = "0123456789ABCDEF";
  69 symkey_desc_pt g_desc;
  70 struct xlr_sec_command *g_cmd;
  71
  72 #ifdef XLR_SEC_CMD_DEBUG
  73 static void decode_symkey_desc(symkey_desc_pt desc, uint32_t cfg_vector);
  74 #endif
  75
  76 static int xlr_sec_cipher_hash_command(xlr_sec_io_pt op, symkey_desc_pt desc,
  77     uint8_t);
  78 static xlr_sec_error_t xlr_sec_setup_descriptor(xlr_sec_io_pt op,
  79     unsigned int flags, symkey_desc_pt desc, uint32_t * cfg_vector);
  80
  81 static xlr_sec_error_t xlr_sec_setup_packet(xlr_sec_io_pt op,
  82     symkey_desc_pt desc, unsigned int flags, uint64_t * data,
  83     PacketDescriptor_pt pkt_desc, ControlDescriptor_pt ctl_desc,
  84     uint32_t vector, PacketDescriptor_pt next_pkt_desc,
  85     uint8_t multi_frag_flag);
  86 static int xlr_sec_submit_message(symkey_desc_pt desc, uint32_t cfg_vector);
  87 static xlr_sec_error_t xlr_sec_setup_cipher(xlr_sec_io_pt op,
  88     ControlDescriptor_pt ctl_desc, uint32_t * vector);
  89 static xlr_sec_error_t xlr_sec_setup_digest(xlr_sec_io_pt op,
  90     ControlDescriptor_pt ctl_desc, uint32_t * vector);
  91 static xlr_sec_error_t xlr_sec_setup_cksum(xlr_sec_io_pt op,
  92     ControlDescriptor_pt ctl_desc);
  93 static xlr_sec_error_t xlr_sec_control_setup(xlr_sec_io_pt op,
  94     unsigned int flags, uint64_t * control, ControlDescriptor_pt ctl_desc,
  95     xlr_sec_drv_user_t * user, uint32_t vector);
  96 static void xlr_sec_free_desc(symkey_desc_pt desc);
  97
  98 void print_buf(char *desc, void *data, int len);
  99 xlr_sec_error_t xlr_sec_submit_op(symkey_desc_pt desc);
 100 void xlr_sec_msgring_handler(int bucket, int size, int code, int stid,
 101     struct msgrng_msg *msg, void *data);
 102
 103 void
 104 xlr_sec_init(struct xlr_sec_softc *sc)
 105 {
 106         unsigned int i;
 107         xlr_reg_t *mmio;
 108
 109         mmio = sc->mmio = xlr_io_mmio(XLR_IO_SECURITY_OFFSET);
 110         xlr_write_reg(mmio, SEC_DMA_CREDIT, SEC_DMA_CREDIT_CONFIG);
 111         xlr_write_reg(mmio, SEC_CONFIG2, SEC_CFG2_ROUND_ROBIN_ON);
 112
 113         for (i = 0; i < 8; i++)
 114                 xlr_write_reg(mmio,
 115                     SEC_MSG_BUCKET0_SIZE + i,
 116                     xlr_is_xls() ?
 117                     xls_bucket_sizes.bucket[MSGRNG_STNID_SEC + i] :
 118                     bucket_sizes.bucket[MSGRNG_STNID_SEC + i]);
 119
 120         for (i = 0; i < 128; i++)
 121                 xlr_write_reg(mmio,
 122                     SEC_CC_CPU0_0 + i,
 123                     xlr_is_xls() ?
 124                     xls_cc_table_sec.counters[i >> 3][i & 0x07] :
 125                     cc_table_sec.counters[i >> 3][i & 0x07]);
 126
 127         /*
 128          * Register a bucket handler with the phoenix messaging subsystem
 129          * For now, register handler for bucket 0->5 in msg stn 0
 130          */
 131         if (register_msgring_handler(TX_STN_SAE, xlr_sec_msgring_handler, NULL)) {
 132                 panic("Couldn't register msgring handler 0\n");
 133         }
 134         return;
 135 }
 136
 137 int
 138 xlr_sec_setup(struct xlr_sec_session *ses,
 139     struct xlr_sec_command *cmd,
 140     symkey_desc_pt desc)
 141 {
 142         xlr_sec_io_pt op;
 143         int size, ret_val;
 144         int iv_len;
 145
 146         desc->ses = ses;
 147         op = &cmd->op;
 148         if (op == NULL)
 149                 return (-ENOMEM);
 150
 151         desc->ctl_desc.instruction = 0;
 152         memset(&desc->ctl_desc.cipherHashInfo, 0, sizeof(CipherHashInfo_t));
 153         desc->control = 0;
 154         desc->pkt_desc[0].srcLengthIVOffUseIVNext = 0;
 155         desc->pkt_desc[0].dstDataSettings = 0;
 156         desc->pkt_desc[0].authDstNonceLow = 0;
 157         desc->pkt_desc[0].ckSumDstNonceHiCFBMaskLLWMask = 0;
 158         desc->pkt_desc[1].srcLengthIVOffUseIVNext = 0;
 159         desc->pkt_desc[1].dstDataSettings = 0;
 160         desc->pkt_desc[1].authDstNonceLow = 0;
 161         desc->pkt_desc[1].ckSumDstNonceHiCFBMaskLLWMask = 0;
 162         desc->data = 0;
 163         desc->ctl_result = 0;
 164         desc->data_result = 0;
 165
 166         if (op->flags & XLR_SEC_FLAGS_HIGH_PRIORITY)
 167                 if (!xlr_is_xls())
 168                         desc->op_ctl.stn_id++;
 169
 170         desc->user.user_src = (uint8_t *) (unsigned long)op->source_buf;
 171         desc->user.user_dest = (uint8_t *) (unsigned long)op->dest_buf;
 172         desc->user.user_auth = (uint8_t *) (unsigned long)op->auth_dest;
 173
 174         if ((op->cipher_type == XLR_SEC_CIPHER_TYPE_ARC4) &&
 175             (!op->rc4_state && (op->rc4_loadstate || op->rc4_savestate))) {
 176                 printf(" ** Load/Save State and no State **");
 177                 xlr_sec_free_desc(desc);
 178                 return (-EINVAL);
 179         }
 180         desc->user.user_state = (uint8_t *) (unsigned long)op->rc4_state;
 181
 182         switch (op->cipher_type) {
 183         case XLR_SEC_CIPHER_TYPE_NONE:
 184                 iv_len = 0;
 185                 break;
 186         case XLR_SEC_CIPHER_TYPE_DES:
 187         case XLR_SEC_CIPHER_TYPE_3DES:
 188                 iv_len = XLR_SEC_DES_IV_LENGTH;
 189                 break;
 190         case XLR_SEC_CIPHER_TYPE_AES128:
 191         case XLR_SEC_CIPHER_TYPE_AES192:
 192         case XLR_SEC_CIPHER_TYPE_AES256:
 193                 iv_len = XLR_SEC_AES_IV_LENGTH;
 194                 break;
 195         case XLR_SEC_CIPHER_TYPE_ARC4:
 196                 iv_len = XLR_SEC_ARC4_IV_LENGTH;
 197                 break;
 198         case XLR_SEC_CIPHER_TYPE_KASUMI_F8:
 199                 iv_len = XLR_SEC_KASUMI_F8_IV_LENGTH;
 200                 break;
 201
 202         default:
 203                 printf(" ** Undefined Cipher Type **");
 204                 xlr_sec_free_desc(desc);
 205                 return (-EINVAL);
 206         }
 207         size = op->source_buf_size + iv_len;
 208
 209         /*
 210          * make sure that there are enough bytes for aes based stream
 211          * ciphers
 212          */
 213         if (op->cipher_mode == XLR_SEC_CIPHER_MODE_F8 ||
 214             op->cipher_mode == XLR_SEC_CIPHER_MODE_CTR)
 215                 size += XLR_SEC_AES_BLOCK_SIZE - 1;
 216
 217         if (op->cipher_type == XLR_SEC_CIPHER_TYPE_NONE) {
 218                 if (op->source_buf_size != 0) {
 219                         memcpy(desc->user.aligned_src,
 220                             (uint8_t *)(uintptr_t)op->source_buf,
 221                             op->source_buf_size);
 222                 }
 223         } else {
 224                 if (ses->multi_frag_flag) {
 225                         /* copy IV into temporary kernel source buffer */
 226                         memcpy(desc->user.aligned_src, &op->initial_vector[0], iv_len);
 227
 228                         /* copy input data to temporary kernel source buffer */
 229                         memcpy((uint8_t *) (desc->user.aligned_src + iv_len),
 230                             (uint8_t *) (unsigned long)op->source_buf, SEC_MAX_FRAG_LEN);
 231
 232                         desc->next_src_len = op->source_buf_size - SEC_MAX_FRAG_LEN;
 233                         memcpy((uint8_t *) (desc->next_src_buf),
 234                             (uint8_t *) (unsigned long)(op->source_buf + SEC_MAX_FRAG_LEN),
 235                             desc->next_src_len);
 236
 237                         op->source_buf_size = SEC_MAX_FRAG_LEN;
 238                         op->source_buf_size += iv_len;
 239                 } else {
 240                         /* copy IV into temporary kernel source buffer */
 241                         memcpy(desc->user.aligned_src, &op->initial_vector[0], iv_len);
 242
 243                         /* copy input data to temporary kernel source buffer */
 244                         memcpy((uint8_t *) (desc->user.aligned_src + iv_len),
 245                             (uint8_t *) (unsigned long)op->source_buf, op->source_buf_size);
 246                         op->source_buf_size += iv_len;
 247                 }
 248         }
 249
 250         /* Set source to new kernel space */
 251         op->source_buf = (uint64_t) (unsigned long)desc->user.aligned_src;
 252
 253         /*
 254          * Build new dest buffer, for Cipher output only
 255          */
 256         if (op->cipher_type == XLR_SEC_CIPHER_TYPE_NONE) {
 257                 /*
 258                  * Digest Engine *NEEDS* this, otherwise it will write at
 259                  * 0[x]
 260                  */
 261                 op->dest_buf = (uint64_t) (unsigned long)desc->user.aligned_src;
 262         } else {
 263                 /* DEBUG -dpk */
 264                 XLR_SEC_CMD_DIAG("dest_buf_size = %d \n", op->dest_buf_size);
 265                 size = op->dest_buf_size + iv_len;
 266
 267                 /*
 268                  * make sure that there are enough bytes for aes based
 269                  * stream ciphers
 270                  */
 271                 if (op->cipher_mode == XLR_SEC_CIPHER_MODE_F8 ||
 272                     op->cipher_mode == XLR_SEC_CIPHER_MODE_CTR)
 273                         size += XLR_SEC_AES_BLOCK_SIZE - 1;
 274                 op->dest_buf = (uint64_t) (unsigned long)desc->user.aligned_dest;
 275         }
 276
 277         ret_val = xlr_sec_cipher_hash_command(op, desc, ses->multi_frag_flag);
 278         return (ret_val);
 279
 280 }
 281
 282 static int
 283 xlr_sec_cipher_hash_command(xlr_sec_io_pt op, symkey_desc_pt desc,
 284     uint8_t multi_frag_flag)
 285 {
 286         xlr_sec_error_t err;
 287         uint32_t cfg_vector;
 288         unsigned int setup_flags = 0;
 289
 290         err = XLR_SEC_ERR_NONE;
 291         cfg_vector = 0;
 292
 293         if ((op->digest_type == XLR_SEC_DIGEST_TYPE_NONE) &&
 294             (op->cipher_type != XLR_SEC_CIPHER_TYPE_ARC4) &&
 295             (op->cipher_mode != XLR_SEC_CIPHER_MODE_F8) &&
 296             (op->cipher_type != XLR_SEC_CIPHER_TYPE_KASUMI_F8) &&
 297             (op->source_buf_size & 0x7)) {
 298                 printf("Invalid Cipher Block Size, data len=%d\n",
 299                     op->source_buf_size);
 300                 return (-EINVAL);
 301         }
 302         do {
 303
 304                 if ((op->cipher_type == XLR_SEC_CIPHER_TYPE_3DES) &&
 305                     (op->cipher_op == XLR_SEC_CIPHER_OP_DECRYPT))
 306                         setup_flags = XLR_SEC_SETUP_OP_FLIP_3DES_KEY;
 307
 308                 err = xlr_sec_setup_descriptor(op,
 309                     setup_flags,
 310                     desc, &cfg_vector);
 311                 if (err != XLR_SEC_ERR_NONE)
 312                         break;
 313
 314                 err = xlr_sec_setup_packet(op,
 315                     desc,
 316                     op->digest_type != XLR_SEC_DIGEST_TYPE_NONE ?
 317                     XLR_SEC_SETUP_OP_CIPHER_HMAC : 0,
 318                     &desc->data,
 319                     &desc->pkt_desc[0],
 320                     &desc->ctl_desc,
 321                     cfg_vector,
 322                     &desc->pkt_desc[1],
 323                     multi_frag_flag);
 324                 if (err != XLR_SEC_ERR_NONE)
 325                         break;
 326         } while (0);
 327         if (err != XLR_SEC_ERR_NONE) {
 328                 return (EINVAL);
 329         }
 330         err = xlr_sec_submit_message(desc, cfg_vector);
 331         return err;
 332 }
 333
 334 static xlr_sec_error_t
 335 xlr_sec_setup_descriptor(xlr_sec_io_pt op,
 336     unsigned int flags,
 337     symkey_desc_pt desc,
 338     uint32_t * cfg_vector)
 339 {
 340         xlr_sec_error_t err;
 341
 342         XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: ENTER\n");
 343
 344         if ((err = xlr_sec_setup_cipher(op, &desc->ctl_desc, cfg_vector)) != XLR_SEC_ERR_NONE) {
 345                 XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: xlr_sec_setup_cipher done err %d\n",
 346                     (int)err);
 347                 return err;
 348         }
 349         if (op->digest_type != XLR_SEC_DIGEST_TYPE_NONE) {
 350                 if ((err = xlr_sec_setup_digest(op, &desc->ctl_desc, cfg_vector)) != XLR_SEC_ERR_NONE) {
 351                         XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: xlr_sec_setup_digest done err %d\n",
 352                             (int)err);
 353                         return err;
 354                 }
 355         }
 356         if ((err = xlr_sec_setup_cksum(op, &desc->ctl_desc)) != XLR_SEC_ERR_NONE) {
 357                 XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: xlr_sec_setup_cksum done err %d\n",
 358                     (int)err);
 359                 return err;
 360         }
 361         if ((err = xlr_sec_control_setup(op,
 362             flags,
 363             &desc->control,
 364             &desc->ctl_desc,
 365             &desc->user,
 366             *cfg_vector)) != XLR_SEC_ERR_NONE) {
 367                 XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: xlr_sec_control_setup done err %d\n",
 368                     (int)err);
 369                 return err;
 370         }
 371         XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: DONE\n");
 372         return err;
 373 }
 374
 375
 376
 377 static
 378 xlr_sec_error_t
 379 xlr_sec_setup_packet(xlr_sec_io_pt op,
 380     symkey_desc_pt desc,
 381     unsigned int flags,
 382     uint64_t * data,
 383     PacketDescriptor_pt pkt_desc,
 384     ControlDescriptor_pt ctl_desc,
 385     uint32_t vector,
 386     PacketDescriptor_pt next_pkt_desc,
 387     uint8_t multi_frag_flag)
 388 {
 389         uint32_t len, next_len = 0, len_dwords, last_u64_bytes;
 390         uint64_t addr;
 391         uint64_t seg_addr, next_seg_addr = 0;
 392         uint64_t byte_offset, global_offset;
 393         uint32_t cipher_offset_dwords;
 394
 395         XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ENTER  vector = %04x\n", vector);
 396
 397         /* physical address of the source buffer */
 398         addr = (uint64_t) vtophys((void *)(unsigned long)op->source_buf);
 399         /* cache-aligned base of the source buffer */
 400         seg_addr = (addr & ~(SMP_CACHE_BYTES - 1));
 401         /* offset in bytes to the source buffer start from the segment base */
 402         byte_offset = addr - seg_addr;
 403         /* global offset: 0-7 bytes */
 404         global_offset = byte_offset & 0x7;
 405
 406
 407         /*
 408          * op->source_buf_size is expected to be the Nb double words to
 409          * stream in (Including Segment address->CP/IV/Auth/CkSum offsets)
 410          */
 411
 412         /*
 413          * adjusted length of the whole thing, accounting for the added
 414          * head, sans global_offset (per Paul S.)
 415          */
 416
 417         len = op->source_buf_size + byte_offset - global_offset;
 418         if (multi_frag_flag) {
 419                 next_seg_addr = (uint64_t)vtophys((void *)(uintptr_t)desc->next_src_buf);
 420                 next_seg_addr = (next_seg_addr & ~(SMP_CACHE_BYTES - 1));
 421                 next_len = desc->next_src_len;
 422         }
 423         /* length of the whole thing in dwords */
 424         len_dwords = NUM_CHUNKS(len, 3);
 425         /* number of bytes in the last chunk (len % 8) */
 426         last_u64_bytes = len & 0x07;
 427
 428         if (op->cipher_offset & 0x7) {
 429                 printf("** cipher_offset(%d) fails 64-bit word alignment **",
 430                     op->cipher_offset);
 431
 432                 return XLR_SEC_ERR_CIPHER_MODE; /* ! fix ! */
 433         }
 434         /*
 435          * global_offset is only three bits, so work the number of the whole
 436          * 8-byte words into the global offset. both offset and
 437          * cipher_offset are byte counts
 438          */
 439         cipher_offset_dwords = (op->iv_offset + byte_offset) >> 3;
 440
 441         if (op->cipher_mode == XLR_SEC_CIPHER_MODE_F8 ||
 442             op->cipher_mode == XLR_SEC_CIPHER_MODE_CTR) {
 443                 if (multi_frag_flag) {
 444                         int nlhmac = ((op->source_buf_size + global_offset + 7 - op->cipher_offset) >> 3) & 1;
 445
 446                         pkt_desc->srcLengthIVOffUseIVNext =
 447                             FIELD_VALUE(PKT_DSC_HASHBYTES, len & 7) |
 448                             FIELD_VALUE(PKT_DSC_IVOFF, cipher_offset_dwords) |
 449                             FIELD_VALUE(PKT_DSC_PKTLEN, nlhmac + ((len + 7) >> 3)) |
 450                             FIELD_VALUE(PKT_DSC_NLHMAC, nlhmac) |
 451                             FIELD_VALUE(PKT_DSC_BREAK, 0) |
 452                             FIELD_VALUE(PKT_DSC_WAIT, 1) |
 453                             FIELD_VALUE(PKT_DSC_NEXT, 1) |
 454                             FIELD_VALUE(PKT_DSC_SEGADDR, seg_addr >> (PKT_DSC_SEGADDR_LSB)) |
 455                             FIELD_VALUE(PKT_DSC_SEGOFFSET, global_offset);
 456                 } else {
 457                         int nlhmac = ((op->source_buf_size + global_offset + 7 - op->cipher_offset) >> 3) & 1;
 458
 459                         pkt_desc->srcLengthIVOffUseIVNext =
 460                             FIELD_VALUE(PKT_DSC_HASHBYTES, len & 7) |
 461                             FIELD_VALUE(PKT_DSC_IVOFF, cipher_offset_dwords) |
 462                             FIELD_VALUE(PKT_DSC_PKTLEN, nlhmac + ((len + 7) >> 3)) |
 463                             FIELD_VALUE(PKT_DSC_NLHMAC, nlhmac) |
 464                             FIELD_VALUE(PKT_DSC_BREAK, 0) |
 465                             FIELD_VALUE(PKT_DSC_WAIT, 0) |
 466                             FIELD_VALUE(PKT_DSC_SEGADDR, seg_addr >> (PKT_DSC_SEGADDR_LSB)) |
 467                             FIELD_VALUE(PKT_DSC_SEGOFFSET, global_offset);
 468
 469                 }
 470         } else {
 471                 if (multi_frag_flag) {
 472                         pkt_desc->srcLengthIVOffUseIVNext =
 473                             FIELD_VALUE(PKT_DSC_HASHBYTES, len & 7) |
 474                             FIELD_VALUE(PKT_DSC_IVOFF, cipher_offset_dwords) |
 475                             FIELD_VALUE(PKT_DSC_PKTLEN, (len + 7) >> 3) |
 476                             FIELD_VALUE(PKT_DSC_BREAK, 0) |
 477                             FIELD_VALUE(PKT_DSC_WAIT, 0) |
 478                             FIELD_VALUE(PKT_DSC_NEXT, 1) |
 479                             FIELD_VALUE(PKT_DSC_SEGADDR, seg_addr >> (PKT_DSC_SEGADDR_LSB)) |
 480                             FIELD_VALUE(PKT_DSC_SEGOFFSET, global_offset);
 481
 482
 483                         next_pkt_desc->srcLengthIVOffUseIVNext =
 484                             FIELD_VALUE(PKT_DSC_HASHBYTES, (next_len & 7)) |
 485                             FIELD_VALUE(PKT_DSC_IVOFF, 0) |
 486                             FIELD_VALUE(PKT_DSC_PKTLEN, (next_len + 7) >> 3) |
 487                             FIELD_VALUE(PKT_DSC_BREAK, 0) |
 488                             FIELD_VALUE(PKT_DSC_WAIT, 0) |
 489                             FIELD_VALUE(PKT_DSC_NEXT, 0) |
 490                             FIELD_VALUE(PKT_DSC_SEGADDR, next_seg_addr >> (PKT_DSC_SEGADDR_LSB)) |
 491                             FIELD_VALUE(PKT_DSC_SEGOFFSET, 0);
 492
 493
 494                 } else {
 495                         pkt_desc->srcLengthIVOffUseIVNext =
 496                             FIELD_VALUE(PKT_DSC_HASHBYTES, len & 7) |
 497                             FIELD_VALUE(PKT_DSC_IVOFF, cipher_offset_dwords) |
 498                             FIELD_VALUE(PKT_DSC_PKTLEN, (len + 7) >> 3) |
 499                             FIELD_VALUE(PKT_DSC_BREAK, 0) |
 500                             FIELD_VALUE(PKT_DSC_WAIT, 0) |
 501                             FIELD_VALUE(PKT_DSC_SEGADDR, seg_addr >> (PKT_DSC_SEGADDR_LSB)) |
 502                             FIELD_VALUE(PKT_DSC_SEGOFFSET, global_offset);
 503
 504
 505                 }
 506         }
 507
 508         switch (op->pkt_hmac) {
 509         case XLR_SEC_LOADHMACKEY_MODE_OLD:
 510                 CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext,
 511                     PKT_DSC_LOADHMACKEY, PKT_DSC_LOADHMACKEY_OLD);
 512                 if (multi_frag_flag) {
 513                         CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext,
 514                             PKT_DSC_LOADHMACKEY, PKT_DSC_LOADHMACKEY_OLD);
 515
 516                 }
 517                 break;
 518         case XLR_SEC_LOADHMACKEY_MODE_LOAD:
 519                 CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext,
 520                     PKT_DSC_LOADHMACKEY, PKT_DSC_LOADHMACKEY_LOAD);
 521                 if (multi_frag_flag) {
 522                         CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext,
 523                             PKT_DSC_LOADHMACKEY, PKT_DSC_LOADHMACKEY_LOAD);
 524
 525                 }
 526                 break;
 527         default:
 528                 if (vector & (XLR_SEC_VECTOR_HMAC | XLR_SEC_VECTOR_HMAC2 | XLR_SEC_VECTOR_GCM | XLR_SEC_VECTOR_F9)) {
 529                         XLR_SEC_CMD_DIAG("xlr_sec_setup_packet:  ERR_LOADHMACKEY_MODE EXIT\n");
 530                         return XLR_SEC_ERR_LOADHMACKEY_MODE;
 531                 }
 532                 break;
 533         }
 534
 535         switch (op->pkt_hash) {
 536         case XLR_SEC_PADHASH_PADDED:
 537                 CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext,
 538                     PKT_DSC_PADHASH, PKT_DSC_PADHASH_PADDED);
 539                 if (multi_frag_flag) {
 540                         CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext,
 541                             PKT_DSC_PADHASH, PKT_DSC_PADHASH_PADDED);
 542                 }
 543                 break;
 544         case XLR_SEC_PADHASH_PAD:
 545                 CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext,
 546                     PKT_DSC_PADHASH, PKT_DSC_PADHASH_PAD);
 547                 if (multi_frag_flag) {
 548                         CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext,
 549                             PKT_DSC_PADHASH, PKT_DSC_PADHASH_PAD);
 550                 }
 551                 break;
 552         default:
 553                 if (vector & (XLR_SEC_VECTOR_MAC | XLR_SEC_VECTOR_HMAC | XLR_SEC_VECTOR_HMAC2)) {
 554                         XLR_SEC_CMD_DIAG("xlr_sec_setup_packet:  ERR_PADHASH_MODE EXIT\n");
 555                         return XLR_SEC_ERR_PADHASH_MODE;
 556                 }
 557                 break;
 558         }
 559
 560         switch (op->pkt_iv) {
 561         case XLR_SEC_PKT_IV_OLD:
 562                 CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext,
 563                     PKT_DSC_IV, PKT_DSC_IV_OLD);
 564                 if (multi_frag_flag) {
 565                         CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext,
 566                             PKT_DSC_IV, PKT_DSC_IV_OLD);
 567
 568                 }
 569                 break;
 570         case XLR_SEC_PKT_IV_NEW:
 571                 CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext,
 572                     PKT_DSC_IV, PKT_DSC_IV_NEW);
 573                 if (multi_frag_flag) {
 574                         CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext,
 575                             PKT_DSC_IV, PKT_DSC_IV_NEW);
 576
 577                 }
 578                 break;
 579         default:
 580                 if (vector & XLR_SEC_VECTOR_CIPHER) {
 581                         XLR_SEC_CMD_DIAG("xlr_sec_setup_packet:  ERR_PKT_IV_MODE EXIT\n");
 582                         return XLR_SEC_ERR_PKT_IV_MODE;
 583                 }
 584                 break;
 585         }
 586
 587         XLR_SEC_CMD_DIAG("xlr_sec_setup_packet:  src_buf=%llx  phys_src_buf=%llx \n",
 588             (unsigned long long)op->source_buf, (unsigned long long)addr);
 589
 590         XLR_SEC_CMD_DIAG("xlr_sec_setup_packet:  seg_addr=%llx  offset=%lld\n",
 591             (unsigned long long)seg_addr, (unsigned long long)byte_offset);
 592
 593         XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: global src offset: %d, iv_offset=%d\n",
 594             cipher_offset_dwords, op->iv_offset);
 595
 596         XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: src_buf_sz=%d  PKT_LEN=%d\n",
 597             op->source_buf_size, len_dwords);
 598
 599         /*
 600          * same operation with the destination. cipher offset affects this,
 601          * as well
 602          */
 603         if (multi_frag_flag) {
 604                 next_seg_addr = (uint64_t) vtophys((void *)(unsigned long)(desc->next_dest_buf));
 605                 next_seg_addr = (next_seg_addr & ~(SMP_CACHE_BYTES - 1));
 606         }
 607         addr = (uint64_t) vtophys((void *)(unsigned long)op->dest_buf);
 608         seg_addr = (addr & ~(SMP_CACHE_BYTES - 1));
 609         byte_offset = addr - seg_addr;
 610         global_offset = byte_offset & 0x7;
 611
 612         XLR_SEC_CMD_DIAG("xlr_sec_setup_packet:  dest_buf=%llx  phys_dest_buf=%llx \n",
 613             (unsigned long long)op->dest_buf, (unsigned long long)addr);
 614
 615         XLR_SEC_CMD_DIAG("xlr_sec_setup_packet:  seg_addr=%llx  offset=%lld\n",
 616             (unsigned long long)seg_addr, (unsigned long long)byte_offset);
 617
 618         /*
 619          * Dest Address = (Cipher Dest Address) + (Cipher Offset) + (Global
 620          * Dest Data Offset)
 621          *
 622          * Cipher Dest Address - Cache-line  (0xffffffffe0) Cipher Offset -
 623          * Which (64-bit) Word in Cacheline  (0-3) Global Dest Data Offset -
 624          * Number of Bytes in (64-bit) Word before data
 625          *
 626          * It must be set for Digest-only Ops, since the Digest engine will
 627          * write data to this address.
 628          */
 629         cipher_offset_dwords = (op->cipher_offset + byte_offset) >> 3;
 630
 631
 632         pkt_desc->dstDataSettings =
 633         /* SYM_OP, HASHSRC */
 634             FIELD_VALUE(PKT_DSC_CPHROFF, cipher_offset_dwords) |
 635             FIELD_VALUE(PKT_DSC_HASHOFF, (op->digest_offset + byte_offset) >> 3) |
 636             FIELD_VALUE(PKT_DSC_CPHR_DST_ADDR, seg_addr) |
 637             FIELD_VALUE(PKT_DSC_CPHR_DST_DWOFFSET, 0) |
 638             FIELD_VALUE(PKT_DSC_CPHR_DST_OFFSET, global_offset);
 639
 640         if (multi_frag_flag) {
 641                 next_pkt_desc->dstDataSettings =
 642                 /* SYM_OP, HASHSRC */
 643                     FIELD_VALUE(PKT_DSC_CPHROFF, cipher_offset_dwords) |
 644                     FIELD_VALUE(PKT_DSC_HASHOFF, (op->digest_offset + byte_offset) >> 3) |
 645                     FIELD_VALUE(PKT_DSC_CPHR_DST_ADDR, next_seg_addr) |
 646                     FIELD_VALUE(PKT_DSC_CPHR_DST_DWOFFSET, 0) |
 647                     FIELD_VALUE(PKT_DSC_CPHR_DST_OFFSET, global_offset);
 648
 649         }
 650         if (op->cipher_type == XLR_SEC_CIPHER_TYPE_ARC4)
 651                 pkt_desc->dstDataSettings |= FIELD_VALUE(PKT_DSC_ARC4BYTECOUNT, last_u64_bytes);
 652
 653         if (op->cipher_type != XLR_SEC_CIPHER_TYPE_NONE) {
 654                 switch (op->cipher_op) {
 655                 case XLR_SEC_CIPHER_OP_ENCRYPT:
 656                         CLEAR_SET_FIELD(pkt_desc->dstDataSettings,
 657                             PKT_DSC_SYM_OP, PKT_DSC_SYM_OP_ENCRYPT);
 658                         if (multi_frag_flag) {
 659                                 CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings,
 660                                     PKT_DSC_SYM_OP, PKT_DSC_SYM_OP_ENCRYPT);
 661
 662                         }
 663                         break;
 664                 case XLR_SEC_CIPHER_OP_DECRYPT:
 665                         CLEAR_SET_FIELD(pkt_desc->dstDataSettings,
 666                             PKT_DSC_SYM_OP, PKT_DSC_SYM_OP_DECRYPT);
 667                         if (multi_frag_flag) {
 668                                 CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings,
 669                                     PKT_DSC_SYM_OP, PKT_DSC_SYM_OP_DECRYPT);
 670
 671                         }
 672                         break;
 673                 default:
 674                         XLR_SEC_CMD_DIAG("xlr_sec_setup_packet:  ERR_CIPHER_OP EXIT\n");
 675                         return XLR_SEC_ERR_CIPHER_OP;
 676                 }
 677         }
 678         if (flags & XLR_SEC_SETUP_OP_HMAC) {
 679                 switch (op->digest_src) {
 680                 case XLR_SEC_DIGEST_SRC_DMA:
 681                         CLEAR_SET_FIELD(pkt_desc->dstDataSettings,
 682                             PKT_DSC_HASHSRC, PKT_DSC_HASHSRC_DMA);
 683                         if (multi_frag_flag) {
 684                                 CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings,
 685                                     PKT_DSC_HASHSRC, PKT_DSC_HASHSRC_DMA);
 686
 687                         }
 688                         break;
 689                 case XLR_SEC_DIGEST_SRC_CPHR:
 690                         CLEAR_SET_FIELD(pkt_desc->dstDataSettings,
 691                             PKT_DSC_HASHSRC, PKT_DSC_HASHSRC_CIPHER);
 692                         if (multi_frag_flag) {
 693                                 CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings,
 694                                     PKT_DSC_HASHSRC, PKT_DSC_HASHSRC_CIPHER);
 695                         }
 696                         break;
 697                 default:
 698                         XLR_SEC_CMD_DIAG("xlr_sec_setup_packet:  ERR_DIGEST_SRC EXIT\n");
 699                         return XLR_SEC_ERR_DIGEST_SRC;
 700                 }
 701         }
 702         if (op->cksum_type != XLR_SEC_CKSUM_TYPE_NOP) {
 703                 switch (op->cksum_src) {
 704                 case XLR_SEC_CKSUM_SRC_DMA:
 705                         CLEAR_SET_FIELD(pkt_desc->dstDataSettings,
 706                             PKT_DSC_CKSUMSRC, PKT_DSC_CKSUMSRC_DMA);
 707                         if (multi_frag_flag) {
 708                                 CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings,
 709                                     PKT_DSC_CKSUMSRC, PKT_DSC_CKSUMSRC_DMA);
 710                         }
 711                         break;
 712                 case XLR_SEC_CKSUM_SRC_CIPHER:
 713                         CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings,
 714                             PKT_DSC_CKSUMSRC, PKT_DSC_CKSUMSRC_CIPHER);
 715                         if (multi_frag_flag) {
 716                                 CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings,
 717                                     PKT_DSC_CKSUMSRC, PKT_DSC_CKSUMSRC_CIPHER);
 718                         }
 719                         break;
 720                 default:
 721                         XLR_SEC_CMD_DIAG("xlr_sec_setup_packet:  ERR_CKSUM_SRC EXIT\n");
 722                         return XLR_SEC_ERR_CKSUM_SRC;
 723                 }
 724         }
 725         pkt_desc->ckSumDstNonceHiCFBMaskLLWMask =
 726             FIELD_VALUE(PKT_DSC_HASH_BYTE_OFF, (op->digest_offset & 0x7)) |
 727             FIELD_VALUE(PKT_DSC_PKTLEN_BYTES, 0) |
 728         /* NONCE_HI, PKT_DSC_LASTWORD, CFB_MASK, CKSUM_DST_ADDR */
 729             FIELD_VALUE(PKT_DSC_IV_OFF_HI, 0);
 730
 731         if (multi_frag_flag) {
 732                 next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask =
 733                     FIELD_VALUE(PKT_DSC_HASH_BYTE_OFF, (op->digest_offset & 0x7)) |
 734                     FIELD_VALUE(PKT_DSC_PKTLEN_BYTES, 0) |
 735                 /* NONCE_HI, PKT_DSC_LASTWORD, CFB_MASK, CKSUM_DST_ADDR */
 736                     FIELD_VALUE(PKT_DSC_IV_OFF_HI, 0);
 737
 738         }
 739         switch (op->pkt_lastword) {
 740         case XLR_SEC_LASTWORD_128:
 741                 CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
 742                     PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_128);
 743                 if (multi_frag_flag) {
 744                         CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
 745                             PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_128);
 746
 747                 }
 748                 break;
 749         case XLR_SEC_LASTWORD_96MASK:
 750                 CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
 751                     PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_96MASK);
 752                 if (multi_frag_flag) {
 753                         CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
 754                             PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_96MASK);
 755                 }
 756                 break;
 757         case XLR_SEC_LASTWORD_64MASK:
 758                 CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
 759                     PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_64MASK);
 760                 if (multi_frag_flag) {
 761                         CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
 762                             PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_64MASK);
 763                 }
 764                 break;
 765         case XLR_SEC_LASTWORD_32MASK:
 766                 CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
 767                     PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_32MASK);
 768                 if (multi_frag_flag) {
 769                         CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
 770                             PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_32MASK);
 771                 }
 772                 break;
 773         default:
 774                 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet:  ERR_LASTWORD_MODE EXIT\n");
 775                 return XLR_SEC_ERR_LASTWORD_MODE;
 776         }
 777         CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
 778             PKT_DSC_CFB_MASK, op->cfb_mask);
 779         CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
 780             PKT_DSC_NONCE_HI, htonl(op->nonce) >> 24);
 781         CLEAR_SET_FIELD(pkt_desc->authDstNonceLow,
 782             PKT_DSC_NONCE_LOW, htonl(op->nonce) & 0xffffff);
 783
 784         if (multi_frag_flag) {
 785                 CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
 786                     PKT_DSC_CFB_MASK, op->cfb_mask);
 787                 CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
 788                     PKT_DSC_NONCE_HI, htonl(op->nonce) >> 24);
 789                 CLEAR_SET_FIELD(next_pkt_desc->authDstNonceLow,
 790                     PKT_DSC_NONCE_LOW, htonl(op->nonce) & 0xffffff);
 791
 792
 793         }
 794         /* Auth Dest Address must be Cacheline aligned on input */
 795         if (vector & (XLR_SEC_VECTOR_MAC | XLR_SEC_VECTOR_HMAC | XLR_SEC_VECTOR_HMAC2 | XLR_SEC_VECTOR_GCM | XLR_SEC_VECTOR_F9)) {
 796                 pkt_desc->authDstNonceLow |=
 797                 /* NONCE_LOW */
 798                     FIELD_VALUE(PKT_DSC_AUTH_DST_ADDR,
 799                     (uint64_t) vtophys((void *)(unsigned long)op->auth_dest)) |
 800                     FIELD_VALUE(PKT_DSC_CIPH_OFF_HI, 0);
 801
 802
 803                 if (multi_frag_flag) {
 804                         next_pkt_desc->authDstNonceLow |=
 805                         /* NONCE_LOW */
 806                             FIELD_VALUE(PKT_DSC_AUTH_DST_ADDR,
 807                             (uint64_t) vtophys((void *)(unsigned long)desc->next_auth_dest)) |
 808                             FIELD_VALUE(PKT_DSC_CIPH_OFF_HI, 0);
 809
 810
 811                 }
 812         }
 813         /* CkSum Dest Address must be Cacheline aligned on input */
 814         if (op->cksum_type == XLR_SEC_CKSUM_TYPE_IP) {
 815                 CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
 816                     PKT_DSC_CKSUM_DST_ADDR,
 817                     (uint64_t) vtophys((void *)(unsigned long)op->cksum_dest));
 818
 819                 if (multi_frag_flag) {
 820                         CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
 821                             PKT_DSC_CKSUM_DST_ADDR,
 822                             (uint64_t) vtophys((void *)(unsigned long)desc->next_cksum_dest));
 823                 }
 824         }
 825         /*
 826          * XLR_SEC_CMD_DIAG (" xlr_sec_setup_packet():  pkt_desc=%llx
 827          * phys_pkt_desc=%llx \n", (unsigned long long)pkt_desc, (unsigned
 828          * long long)virt_to_phys(pkt_desc)); (unsigned long long)pkt_desc,
 829          * (unsigned long long)vtophys(pkt_desc));
 830          */
 831         XLR_SEC_CMD_DIAG(" xlr_sec_setup_packet():  pkt_desc=%p   phys_pkt_desc=%llx \n",
 832             pkt_desc, (unsigned long long)vtophys(pkt_desc));
 833
 834         CLEAR_SET_FIELD(*data, MSG_CMD_DATA_ADDR, ((uint64_t) vtophys(pkt_desc)));
 835         CLEAR_SET_FIELD(*data, MSG_CMD_DATA_CTL, SEC_EOP);
 836         CLEAR_SET_FIELD(*data, MSG_CMD_DATA_LEN, MSG_CMD_DATA_LEN_LOAD);
 837
 838         XLR_SEC_CMD_DIAG("xlr_sec_setup_packet:  DONE\n");
 839
 840 #ifdef RMI_SEC_DEBUG
 841         {
 842                 printf("data desc\n");
 843                 printf("srcLengthIVOffUseIVNext = 0x%llx\n", pkt_desc->srcLengthIVOffUseIVNext);
 844                 printf("dstDataSettings = 0x%llx\n", pkt_desc->dstDataSettings);
 845                 printf("authDstNonceLow = 0x%llx\n", pkt_desc->authDstNonceLow);
 846                 printf("ckSumDstNonceHiCFBMaskLLWMask = 0x%llx\n", pkt_desc->ckSumDstNonceHiCFBMaskLLWMask);
 847         }
 848
 849         if (multi_frag_flag) {
 850
 851                 printf("next data desc\n");
 852                 printf("srcLengthIVOffUseIVNext = 0x%llx\n", next_pkt_desc->srcLengthIVOffUseIVNext);
 853                 printf("dstDataSettings = 0x%llx\n", next_pkt_desc->dstDataSettings);
 854                 printf("authDstNonceLow = 0x%llx\n", next_pkt_desc->authDstNonceLow);
 855                 printf("ckSumDstNonceHiCFBMaskLLWMask = 0x%llx\n", next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask);
 856         }
 857 #endif
 858
 859 #ifdef SYMBOL
 860         if (op->cipher_type == XLR_SEC_CIPHER_TYPE_ARC4) {
 861                 op->source_buf -= 0;
 862                 op->source_buf_size += 0;
 863                 op->dest_buf -= 0;
 864         }
 865 #endif
 866         return XLR_SEC_ERR_NONE;
 867 }
 868
 869
 870 static int
 871 identify_symkey_ctl_error(uint32_t code, xlr_sec_error_t err)
 872 {
 873         int ret_val = EINVAL;
 874
 875         switch (code) {
 876         case CTL_ERR_NONE:
 877                 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error:  No Error\n");
 878                 ret_val = 0;
 879                 break;
 880         case CTL_ERR_CIPHER_OP:
 881                 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_CIPHER_OP) - Unknown Cipher Op \n");
 882                 break;
 883         case CTL_ERR_MODE:
 884                 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_MODE) - "
 885                     "Unknown or Not Allowed Mode \n");
 886                 break;
 887         case CTL_ERR_CHKSUM_SRC:
 888                 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_CHKSUM_SRC) - Unknown CkSum Src\n");
 889                 break;
 890         case CTL_ERR_CFB_MASK:
 891                 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_CFB_MASK) - Forbidden CFB Mask \n");
 892                 break;
 893         case CTL_ERR_OP:
 894                 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_OP) - Unknown Ctrl Op \n");
 895                 break;
 896         case CTL_ERR_DATA_READ:
 897                 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_DATA_READ) - Data Read Error\n");
 898                 break;
 899         case CTL_ERR_DESC_CTRL:
 900                 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_DESC_CTRL) - "
 901                     "Descriptor Ctrl Field Error  \n");
 902                 break;
 903         case CTL_ERR_UNDEF1:
 904         case CTL_ERR_UNDEF2:
 905         default:
 906                 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error:  UNKNOWN CODE=%d \n", code);
 907                 break;
 908         }
 909         return ret_val;
 910 }
 911
 912 static
 913 int
 914 identify_symkey_data_error(uint32_t code, xlr_sec_error_t err)
 915 {
 916         int ret_val = -EINVAL;
 917
 918         switch (code) {
 919         case DATA_ERR_NONE:
 920                 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error  No Error\n");
 921                 ret_val = 0;
 922                 break;
 923         case DATA_ERR_LEN_CIPHER:
 924                 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Not Enough Data To Cipher\n");
 925                 break;
 926         case DATA_ERR_IV_ADDR:
 927                 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Illegal IV Loacation\n");
 928                 break;
 929         case DATA_ERR_WD_LEN_AES:
 930                 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Illegal Nb Words To AES\n");
 931                 break;
 932         case DATA_ERR_BYTE_COUNT:
 933                 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Illegal Pad And ByteCount Spec\n");
 934                 break;
 935         case DATA_ERR_LEN_CKSUM:
 936                 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Not Enough Data To CkSum\n");
 937                 break;
 938         case DATA_ERR_OP:
 939                 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Unknown Data Op \n");
 940                 break;
 941         case DATA_ERR_READ:
 942                 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Data Read Error \n");
 943                 break;
 944         case DATA_ERR_WRITE:
 945                 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Data Write Error \n");
 946                 break;
 947         case DATA_ERR_UNDEF1:
 948         default:
 949                 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error - UNKNOWN CODE=%d \n", code);
 950                 break;
 951         }
 952         return ret_val;
 953 }
 954
 955
 956 static int
 957 xlr_sec_submit_message(symkey_desc_pt desc, uint32_t cfg_vector)
 958 {
 959         xlr_sec_error_t err;
 960         uint32_t ctl_error, data_error;
 961         int ret_val = 0;
 962
 963         XLR_SEC_CMD_DIAG("xlr_sec_submit_message:  ENTER\n");
 964         err = XLR_SEC_ERR_NONE;
 965         XLR_SEC_CMD_DIAG_SYM_DESC(desc, cfg_vector);
 966
 967         do {
 968                 /* For now, send message and wait for response */
 969                 err = xlr_sec_submit_op(desc);
 970
 971                 XLR_SEC_CMD_DIAG("xlr_sec_submit_message:  err = %d \n", (uint32_t) err);
 972
 973                 if (err != XLR_SEC_ERR_NONE) {
 974                         ret_val = (EINVAL);
 975                         break;
 976                 }
 977                 ctl_error = desc->ctl_result;
 978                 data_error = desc->data_result;
 979
 980                 XLR_SEC_CMD_DIAG("xlr_sec_submit_message: ctl_error = %x   data_error = %x\n",
 981                     ctl_error, data_error);
 982
 983                 if ((ret_val = identify_symkey_ctl_error(ctl_error, err)) == 0)
 984                         ret_val = identify_symkey_data_error(data_error, err);
 985
 986                 XLR_SEC_CMD_DIAG("xlr_sec_submit_message: identify error = %d \n", ret_val);
 987
 988         } while (0);
 989
 990         XLR_SEC_CMD_DIAG("xlr_sec_submit_message:  DONE\n");
 991         return (ret_val);
 992 }
 993
 994
 995 static
 996 xlr_sec_error_t
 997 xlr_sec_setup_cipher(xlr_sec_io_pt op,
 998     ControlDescriptor_pt ctl_desc,
 999     uint32_t * vector)
1000 {
1001         uint32_t aes_flag = 0;
1002         uint32_t cipher_vector = 0;
1003
1004         XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher:  ENTER  vector = %04x\n", *vector);
1005
1006         switch (op->cipher_type) {
1007         case XLR_SEC_CIPHER_TYPE_NONE:
1008                 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_BYPASS);
1009                 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher:  CIPHER_TYPE_NONE EXIT\n");
1010                 return XLR_SEC_ERR_NONE;
1011         case XLR_SEC_CIPHER_TYPE_DES:
1012                 cipher_vector |= XLR_SEC_VECTOR_CIPHER_DES;
1013                 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_DES);
1014                 break;
1015         case XLR_SEC_CIPHER_TYPE_3DES:
1016                 cipher_vector |= XLR_SEC_VECTOR_CIPHER_3DES;
1017                 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_3DES);
1018                 break;
1019         case XLR_SEC_CIPHER_TYPE_AES128:
1020                 aes_flag = 1;
1021                 cipher_vector |= XLR_SEC_VECTOR_CIPHER_AES128;
1022                 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_AES128);
1023                 break;
1024         case XLR_SEC_CIPHER_TYPE_AES192:
1025                 aes_flag = 1;
1026                 cipher_vector |= XLR_SEC_VECTOR_CIPHER_AES192;
1027                 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_AES192);
1028                 break;
1029         case XLR_SEC_CIPHER_TYPE_AES256:
1030                 aes_flag = 1;
1031                 cipher_vector |= XLR_SEC_VECTOR_CIPHER_AES256;
1032                 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_AES256);
1033                 break;
1034         case XLR_SEC_CIPHER_TYPE_ARC4:
1035                 cipher_vector |= XLR_SEC_VECTOR_CIPHER_ARC4;
1036                 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_ARC4);
1037                 SET_FIELD(ctl_desc->instruction, CTL_DSC_ARC4_KEYLEN,
1038                     op->rc4_key_len);
1039                 SET_FIELD(ctl_desc->instruction, CTL_DSC_ARC4_LOADSTATE,
1040                     op->rc4_loadstate);
1041                 SET_FIELD(ctl_desc->instruction, CTL_DSC_ARC4_SAVESTATE,
1042                     op->rc4_savestate);
1043                 if (op->rc4_loadstate || op->rc4_savestate)
1044                         cipher_vector |= XLR_SEC_VECTOR_STATE;
1045                 break;
1046         case XLR_SEC_CIPHER_TYPE_KASUMI_F8:
1047                 aes_flag = 1;
1048                 cipher_vector |= XLR_SEC_VECTOR_CIPHER_KASUMI_F8;
1049                 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_KASUMI_F8);
1050                 break;
1051         default:
1052                 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher:  ERR_CIPHER_TYPE EXIT\n");
1053                 return XLR_SEC_ERR_CIPHER_TYPE;
1054         }
1055
1056         switch (op->cipher_mode) {
1057         case XLR_SEC_CIPHER_MODE_ECB:
1058                 if (aes_flag == 1)
1059                         cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC_OFB;
1060                 else
1061                         cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC;
1062                 SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_ECB);
1063                 break;
1064         case XLR_SEC_CIPHER_MODE_CBC:
1065                 if (aes_flag == 1)
1066                         cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC_OFB;
1067                 else
1068                         cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC;
1069                 SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_CBC);
1070                 break;
1071         case XLR_SEC_CIPHER_MODE_OFB:
1072                 if (aes_flag == 0) {
1073                         XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher:  ERR_CIPHER_MODE EXIT\n");
1074                         return XLR_SEC_ERR_CIPHER_MODE;
1075                 }
1076                 cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC_OFB;
1077                 SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_OFB);
1078                 break;
1079         case XLR_SEC_CIPHER_MODE_CTR:
1080                 if (aes_flag == 0) {
1081                         XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher:  ERR_CIPHER_MODE EXIT\n");
1082                         return XLR_SEC_ERR_CIPHER_MODE;
1083                 }
1084                 cipher_vector |= XLR_SEC_VECTOR_MODE_CTR_CFB;
1085                 SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_CTR);
1086                 break;
1087         case XLR_SEC_CIPHER_MODE_CFB:
1088                 if (aes_flag == 0) {
1089                         XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher:  ERR_CIPHER_MODE EXIT\n");
1090                         return XLR_SEC_ERR_CIPHER_MODE;
1091                 }
1092                 cipher_vector |= XLR_SEC_VECTOR_MODE_CTR_CFB;
1093                 SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_CFB);
1094                 break;
1095         case XLR_SEC_CIPHER_MODE_F8:
1096                 if (aes_flag == 0) {
1097                         XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher:  ERR_CIPHER_MODE EXIT\n");
1098                         return XLR_SEC_ERR_CIPHER_MODE;
1099                 }
1100                 cipher_vector |= XLR_SEC_VECTOR_MODE_F8;
1101                 SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_F8);
1102                 break;
1103         default:
1104                 if (!(cipher_vector & (XLR_SEC_VECTOR_CIPHER_ARC4 | XLR_SEC_VECTOR_CIPHER_KASUMI_F8))) {
1105                         XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher:  ERR_CIPHER_MODE EXIT\n");
1106                         return XLR_SEC_ERR_CIPHER_MODE;
1107                 }
1108         }
1109
1110         switch (op->cipher_init) {
1111         case XLR_SEC_CIPHER_INIT_OK:
1112                 SET_FIELD(ctl_desc->instruction,
1113                     CTL_DSC_ICPHR, CTL_DSC_ICPHR_OKY);
1114                 break;
1115
1116         case XLR_SEC_CIPHER_INIT_NK:
1117                 SET_FIELD(ctl_desc->instruction,
1118                     CTL_DSC_ICPHR, CTL_DSC_ICPHR_NKY);
1119                 break;
1120         default:
1121                 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher:  ERR_CIPHER_INIT EXIT\n");
1122                 return XLR_SEC_ERR_CIPHER_INIT;
1123         }
1124
1125         *vector |= cipher_vector;
1126
1127         XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher:  EXIT  vector = %04x\n", *vector);
1128
1129         return XLR_SEC_ERR_NONE;
1130 }
1131
1132 static
1133 xlr_sec_error_t
1134 xlr_sec_setup_digest(xlr_sec_io_pt op,
1135     ControlDescriptor_pt ctl_desc,
1136     uint32_t * vector)
1137 {
1138         uint32_t hash_flag = 0;
1139         uint32_t hmac_flag = 0;
1140         uint32_t digest_vector = 0;
1141
1142         XLR_SEC_CMD_DIAG("xlr_sec_setup_digest:  ENTER  vector = %04x\n", *vector);
1143
1144         switch (op->digest_type) {
1145         case XLR_SEC_DIGEST_TYPE_MD5:
1146                 digest_vector |= XLR_SEC_VECTOR_MAC;
1147                 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_MD5);
1148                 break;
1149         case XLR_SEC_DIGEST_TYPE_SHA1:
1150                 digest_vector |= XLR_SEC_VECTOR_MAC;
1151                 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA1);
1152                 break;
1153         case XLR_SEC_DIGEST_TYPE_SHA256:
1154                 digest_vector |= XLR_SEC_VECTOR_MAC;
1155                 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA256);
1156                 break;
1157         case XLR_SEC_DIGEST_TYPE_SHA384:
1158                 digest_vector |= XLR_SEC_VECTOR_MAC;
1159                 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_SHA384 >> 2);
1160                 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA384);
1161                 break;
1162         case XLR_SEC_DIGEST_TYPE_SHA512:
1163                 digest_vector |= XLR_SEC_VECTOR_MAC;
1164                 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_SHA512 >> 2);
1165                 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA512);
1166                 break;
1167         case XLR_SEC_DIGEST_TYPE_GCM:
1168                 hash_flag = 1;
1169                 digest_vector |= XLR_SEC_VECTOR_GCM;
1170                 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_GCM >> 2);
1171                 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_GCM);
1172                 break;
1173         case XLR_SEC_DIGEST_TYPE_KASUMI_F9:
1174                 hash_flag = 1;
1175                 digest_vector |= XLR_SEC_VECTOR_F9;
1176                 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_KASUMI_F9 >> 2);
1177                 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_KASUMI_F9);
1178                 break;
1179         case XLR_SEC_DIGEST_TYPE_HMAC_MD5:
1180                 hmac_flag = 1;
1181                 digest_vector |= XLR_SEC_VECTOR_HMAC;
1182                 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_MD5);
1183                 break;
1184         case XLR_SEC_DIGEST_TYPE_HMAC_SHA1:
1185                 hmac_flag = 1;
1186                 digest_vector |= XLR_SEC_VECTOR_HMAC;
1187                 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA1);
1188                 break;
1189         case XLR_SEC_DIGEST_TYPE_HMAC_SHA256:
1190                 hmac_flag = 1;
1191                 digest_vector |= XLR_SEC_VECTOR_HMAC;
1192                 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA256);
1193                 break;
1194         case XLR_SEC_DIGEST_TYPE_HMAC_SHA384:
1195                 hmac_flag = 1;
1196                 digest_vector |= XLR_SEC_VECTOR_HMAC2;
1197                 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_SHA384 >> 2);
1198                 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA384);
1199                 break;
1200         case XLR_SEC_DIGEST_TYPE_HMAC_SHA512:
1201                 hmac_flag = 1;
1202                 digest_vector |= XLR_SEC_VECTOR_HMAC2;
1203                 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_SHA512 >> 2);
1204                 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA512);
1205                 break;
1206         default:
1207                 return XLR_SEC_ERR_DIGEST_TYPE;
1208         }
1209
1210         if (hmac_flag == 1) {
1211                 SET_FIELD(ctl_desc->instruction, CTL_DSC_HMAC, CTL_DSC_HMAC_ON);
1212
1213         }
1214         if (hmac_flag || hash_flag) {
1215                 switch (op->digest_init) {
1216                 case XLR_SEC_DIGEST_INIT_OLDKEY:
1217                         SET_FIELD(ctl_desc->instruction, CTL_DSC_IHASH, CTL_DSC_IHASH_OLD);
1218                         break;
1219                 case XLR_SEC_DIGEST_INIT_NEWKEY:
1220                         SET_FIELD(ctl_desc->instruction, CTL_DSC_IHASH, CTL_DSC_IHASH_NEW);
1221                         break;
1222                 default:
1223                         return XLR_SEC_ERR_DIGEST_INIT;
1224                 }
1225         }                       /* hmac_flag */
1226         *vector |= digest_vector;
1227
1228         XLR_SEC_CMD_DIAG("xlr_sec_setup_digest: EXIT  vector = %04x\n", *vector);
1229         return XLR_SEC_ERR_NONE;
1230 }
1231
1232 static
1233 xlr_sec_error_t
1234 xlr_sec_setup_cksum(xlr_sec_io_pt op,
1235     ControlDescriptor_pt ctl_desc)
1236 {
1237         switch (op->cksum_type) {
1238                 case XLR_SEC_CKSUM_TYPE_NOP:
1239                 SET_FIELD(ctl_desc->instruction, CTL_DSC_CKSUM, CTL_DSC_CKSUM_NOP);
1240                 return XLR_SEC_ERR_NONE;
1241         case XLR_SEC_CKSUM_TYPE_IP:
1242                 SET_FIELD(ctl_desc->instruction, CTL_DSC_CKSUM, CTL_DSC_CKSUM_IP);
1243                 break;
1244         default:
1245                 return XLR_SEC_ERR_CKSUM_TYPE;
1246         }
1247
1248         return XLR_SEC_ERR_NONE;
1249 }
1250
1251
1252 static
1253 xlr_sec_error_t
1254 xlr_sec_control_setup(xlr_sec_io_pt op,
1255     unsigned int flags,
1256     uint64_t * control,
1257     ControlDescriptor_pt ctl_desc,
1258     xlr_sec_drv_user_t * user,
1259     uint32_t vector)
1260 {
1261         uint64_t *hmac_key = NULL;
1262         uint64_t *cipher_key = NULL;
1263         uint64_t *cipher_state = NULL;
1264         uint32_t ctl_size = 0;
1265         uint64_t ctl_addr = 0;
1266         uint32_t cipher_keylen = 0;
1267         uint32_t hmac_keylen = 0;
1268         uint32_t ctl_len;
1269
1270 #ifdef SYM_DEBUG
1271         XLR_SEC_CMD_DIAG(" ENTER  vector = %04x\n", vector);
1272 #endif
1273
1274         switch (vector) {
1275         case XLR_SEC_VECTOR_MAC:
1276                 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR_MAC \n");
1277                 ctl_size = sizeof(HMAC_t);
1278                 break;
1279         case XLR_SEC_VECTOR_HMAC:
1280                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_HMAC  \n");
1281                 hmac_key = &ctl_desc->cipherHashInfo.infoHMAC.hmacKey0;
1282                 hmac_keylen = sizeof(HMAC_t);
1283                 ctl_size = sizeof(HMAC_t);
1284                 break;
1285         case XLR_SEC_VECTOR_CIPHER_ARC4:
1286                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4\n");
1287                 cipher_key = &ctl_desc->cipherHashInfo.infoARC4.cipherKey0;
1288                 cipher_keylen = op->rc4_key_len;
1289                 ctl_size = sizeof(ARC4_t);
1290                 break;
1291         case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC:
1292                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__HMAC\n");
1293                 cipher_key = &ctl_desc->cipherHashInfo.infoARC4HMAC.cipherKey0;
1294                 hmac_key = &ctl_desc->cipherHashInfo.infoARC4HMAC.hmacKey0;
1295                 cipher_keylen = op->rc4_key_len;
1296                 hmac_keylen = sizeof(HMAC_t);
1297                 ctl_size = sizeof(ARC4HMAC_t);
1298                 break;
1299         case XLR_SEC_VECTOR_CIPHER_ARC4__STATE:
1300                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__STATE\n");
1301                 cipher_key = &ctl_desc->cipherHashInfo.infoARC4State.cipherKey0;
1302                 cipher_state =
1303                     &ctl_desc->cipherHashInfo.infoARC4State.Arc4SboxData0;
1304                 cipher_keylen = op->rc4_key_len;
1305                 ctl_size = sizeof(ARC4State_t);
1306                 break;
1307         case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC__STATE:
1308                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__HMAC__STATE\n");
1309                 cipher_key = &ctl_desc->cipherHashInfo.infoARC4StateHMAC.cipherKey0;
1310                 cipher_state =
1311                     &ctl_desc->cipherHashInfo.infoARC4StateHMAC.Arc4SboxData0;
1312                 hmac_key = &ctl_desc->cipherHashInfo.infoARC4StateHMAC.hmacKey0;
1313                 cipher_keylen = op->rc4_key_len;
1314                 hmac_keylen = sizeof(HMAC_t);
1315                 ctl_size = sizeof(ARC4StateHMAC_t);
1316                 break;
1317         case XLR_SEC_VECTOR_CIPHER_KASUMI_F8:
1318                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8\n");
1319                 cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8.cipherKey0;
1320                 cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH;
1321                 ctl_size = sizeof(KASUMIF8_t);
1322                 break;
1323         case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC:
1324                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC\n");
1325                 cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8HMAC.cipherKey0;
1326                 cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH;
1327                 hmac_key = &ctl_desc->cipherHashInfo.infoKASUMIF8HMAC.hmacKey0;
1328                 hmac_keylen = sizeof(HMAC_t);
1329                 ctl_size = sizeof(KASUMIF8HMAC_t);
1330                 break;
1331         case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC2:
1332                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC2\n");
1333                 cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8HMAC2.cipherKey0;
1334                 cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH;
1335                 hmac_key = &ctl_desc->cipherHashInfo.infoKASUMIF8HMAC2.hmacKey0;
1336                 hmac_keylen = sizeof(HMAC2_t);
1337                 ctl_size = sizeof(KASUMIF8HMAC2_t);
1338                 break;
1339         case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__GCM:
1340                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__GCM\n");
1341                 cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8GCM.cipherKey0;
1342                 cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH;
1343                 hmac_key = &ctl_desc->cipherHashInfo.infoKASUMIF8GCM.GCMH0;
1344                 hmac_keylen = sizeof(GCM_t);
1345                 ctl_size = sizeof(KASUMIF8GCM_t);
1346                 break;
1347         case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__F9:
1348                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__F9\n");
1349                 cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8F9.cipherKey0;
1350                 cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH;
1351                 hmac_key = &ctl_desc->cipherHashInfo.infoKASUMIF8F9.authKey0;
1352                 hmac_keylen = sizeof(F9_t);
1353                 ctl_size = sizeof(KASUMIF8F9_t);
1354                 break;
1355         case XLR_SEC_VECTOR__CIPHER_DES__HMAC__MODE_ECB_CBC:
1356                 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_DES__HMAC__MODE_ECB_CBC  \n");
1357                 cipher_key = &ctl_desc->cipherHashInfo.infoDESHMAC.cipherKey0;
1358                 hmac_key = &ctl_desc->cipherHashInfo.infoDESHMAC.hmacKey0;
1359                 hmac_keylen = sizeof(HMAC_t);
1360                 cipher_keylen = XLR_SEC_DES_KEY_LENGTH;
1361                 ctl_size = sizeof(DESHMAC_t);
1362                 break;
1363         case XLR_SEC_VECTOR__CIPHER_DES__MODE_ECB_CBC:
1364                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_DES__MODE_ECB_CBC  \n");
1365                 cipher_key = &ctl_desc->cipherHashInfo.infoDES.cipherKey0;
1366                 cipher_keylen = XLR_SEC_DES_KEY_LENGTH;
1367                 ctl_size = sizeof(DES_t);
1368                 break;
1369         case XLR_SEC_VECTOR__CIPHER_3DES__HMAC__MODE_ECB_CBC:
1370                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__HMAC__MODE_ECB_CBC  \n");
1371                 cipher_key = &ctl_desc->cipherHashInfo.info3DESHMAC.cipherKey0;
1372                 hmac_key = &ctl_desc->cipherHashInfo.info3DESHMAC.hmacKey0;
1373                 cipher_keylen = XLR_SEC_3DES_KEY_LENGTH;
1374                 hmac_keylen = sizeof(HMAC_t);
1375                 ctl_size = sizeof(DES3HMAC_t);
1376                 break;
1377         case XLR_SEC_VECTOR__CIPHER_3DES__MODE_ECB_CBC:
1378                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__MODE_ECB_CBC  \n");
1379                 cipher_key = &ctl_desc->cipherHashInfo.info3DES.cipherKey0;
1380                 cipher_keylen = XLR_SEC_3DES_KEY_LENGTH;
1381                 ctl_size = sizeof(DES3_t);
1382                 break;
1383         case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_CTR_CFB:
1384                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_CTR_CFB  \n");
1385                 cipher_key = &ctl_desc->cipherHashInfo.infoAES128HMAC.cipherKey0;
1386                 hmac_key = &ctl_desc->cipherHashInfo.infoAES128HMAC.hmacKey0;
1387                 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
1388                 hmac_keylen = sizeof(HMAC_t);
1389                 ctl_size = sizeof(AES128HMAC_t);
1390                 break;
1391         case XLR_SEC_VECTOR__CIPHER_AES128__MODE_CTR_CFB:
1392                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__MODE_CTR_CFB  \n");
1393                 cipher_key = &ctl_desc->cipherHashInfo.infoAES128.cipherKey0;
1394                 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
1395                 ctl_size = sizeof(AES128_t);
1396                 break;
1397         case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_ECB_CBC_OFB:
1398                 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_ECB_CBC_OFB  \n");
1399                 cipher_key = &ctl_desc->cipherHashInfo.infoAES128HMAC.cipherKey0;
1400                 hmac_key = &ctl_desc->cipherHashInfo.infoAES128HMAC.hmacKey0;
1401                 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
1402                 hmac_keylen = sizeof(HMAC_t);
1403                 ctl_size = sizeof(AES128HMAC_t);
1404                 break;
1405         case XLR_SEC_VECTOR__CIPHER_AES128__MODE_ECB_CBC_OFB:
1406                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__MODE_ECB_CBC_OFB  \n");
1407                 cipher_key = &ctl_desc->cipherHashInfo.infoAES128.cipherKey0;
1408                 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
1409                 ctl_size = sizeof(AES128_t);
1410                 break;
1411         case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_F8:
1412                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_F8  \n");
1413                 cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8HMAC.cipherKey0;
1414                 hmac_key = &ctl_desc->cipherHashInfo.infoAES128F8HMAC.hmacKey0;
1415                 cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH;
1416                 hmac_keylen = sizeof(HMAC_t);
1417                 ctl_size = sizeof(AES128F8HMAC_t);
1418                 break;
1419         case XLR_SEC_VECTOR__CIPHER_AES128__MODE_F8:
1420                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__MODE_F8  \n");
1421                 cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8.cipherKey0;
1422                 cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH;
1423                 ctl_size = sizeof(AES128F8_t);
1424                 break;
1425         case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_CTR_CFB:
1426                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_CTR_CFB  \n");
1427                 cipher_key = &ctl_desc->cipherHashInfo.infoAES192HMAC.cipherKey0;
1428                 hmac_key = &ctl_desc->cipherHashInfo.infoAES192HMAC.hmacKey0;
1429                 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
1430                 hmac_keylen = sizeof(HMAC_t);
1431                 ctl_size = sizeof(AES192HMAC_t);
1432                 break;
1433         case XLR_SEC_VECTOR__CIPHER_AES192__MODE_CTR_CFB:
1434                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__MODE_CTR_CFB  \n");
1435                 cipher_key = &ctl_desc->cipherHashInfo.infoAES192.cipherKey0;
1436                 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
1437                 ctl_size = sizeof(AES192_t);
1438                 break;
1439         case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_ECB_CBC_OFB:
1440                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_ECB_CBC_OFB  \n");
1441                 cipher_key = &ctl_desc->cipherHashInfo.infoAES192HMAC.cipherKey0;
1442                 hmac_key = &ctl_desc->cipherHashInfo.infoAES192HMAC.hmacKey0;
1443                 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
1444                 hmac_keylen = sizeof(HMAC_t);
1445                 ctl_size = sizeof(AES192HMAC_t);
1446                 break;
1447         case XLR_SEC_VECTOR__CIPHER_AES192__MODE_ECB_CBC_OFB:
1448                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__MODE_ECB_CBC_OFB  \n");
1449                 cipher_key = &ctl_desc->cipherHashInfo.infoAES192.cipherKey0;
1450                 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
1451                 ctl_size = sizeof(AES192_t);
1452                 break;
1453         case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_F8:
1454                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_F8  \n");
1455                 cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8HMAC.cipherKey0;
1456                 hmac_key = &ctl_desc->cipherHashInfo.infoAES192F8HMAC.hmacKey0;
1457                 cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH;
1458                 hmac_keylen = sizeof(HMAC_t);
1459                 ctl_size = sizeof(AES192F8HMAC_t);
1460                 break;
1461         case XLR_SEC_VECTOR__CIPHER_AES192__MODE_F8:
1462                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__MODE_F8  \n");
1463                 cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8.cipherKey0;
1464                 cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH;
1465                 ctl_size = sizeof(AES192F8_t);
1466                 break;
1467
1468         case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_CTR_CFB:
1469                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_CTR_CFB  \n");
1470                 cipher_key = &ctl_desc->cipherHashInfo.infoAES256HMAC.cipherKey0;
1471                 hmac_key = &ctl_desc->cipherHashInfo.infoAES256HMAC.hmacKey0;
1472                 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
1473                 hmac_keylen = sizeof(HMAC_t);
1474                 ctl_size = sizeof(AES256HMAC_t);
1475                 break;
1476         case XLR_SEC_VECTOR__CIPHER_AES256__MODE_CTR_CFB:
1477                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__MODE_CTR_CFB  \n");
1478                 cipher_key = &ctl_desc->cipherHashInfo.infoAES256.cipherKey0;
1479                 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
1480                 ctl_size = sizeof(AES256_t);
1481                 break;
1482         case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_ECB_CBC_OFB:
1483                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_ECB_CBC_OFB  \n");
1484                 cipher_key = &ctl_desc->cipherHashInfo.infoAES256HMAC.cipherKey0;
1485                 hmac_key = &ctl_desc->cipherHashInfo.infoAES256HMAC.hmacKey0;
1486                 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
1487                 hmac_keylen = sizeof(HMAC_t);
1488                 ctl_size = sizeof(AES256HMAC_t);
1489                 break;
1490         case XLR_SEC_VECTOR__CIPHER_AES256__MODE_ECB_CBC_OFB:
1491                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__MODE_ECB_CBC_OFB  \n");
1492                 cipher_key = &ctl_desc->cipherHashInfo.infoAES256.cipherKey0;
1493                 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
1494                 ctl_size = sizeof(AES256_t);
1495                 break;
1496         case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_F8:
1497                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_F8  \n");
1498                 cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8HMAC.cipherKey0;
1499                 hmac_key = &ctl_desc->cipherHashInfo.infoAES256F8HMAC.hmacKey0;
1500                 cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH;
1501                 hmac_keylen = sizeof(HMAC_t);
1502                 ctl_size = sizeof(AES256F8HMAC_t);
1503                 break;
1504         case XLR_SEC_VECTOR__CIPHER_AES256__MODE_F8:
1505                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__MODE_F8  \n");
1506                 cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8.cipherKey0;
1507                 cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH;
1508                 ctl_size = sizeof(AES256F8_t);
1509                 break;
1510         case XLR_SEC_VECTOR_HMAC2:
1511                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_HMAC2  \n");
1512                 hmac_key = &ctl_desc->cipherHashInfo.infoHMAC2.hmacKey0;
1513                 hmac_keylen = sizeof(HMAC2_t);
1514                 ctl_size = sizeof(HMAC2_t);
1515                 break;
1516         case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2:
1517                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2\n");
1518                 cipher_key = &ctl_desc->cipherHashInfo.infoARC4HMAC2.cipherKey0;
1519                 hmac_key = &ctl_desc->cipherHashInfo.infoARC4HMAC2.hmacKey0;
1520                 cipher_keylen = op->rc4_key_len;
1521                 hmac_keylen = sizeof(HMAC2_t);
1522                 ctl_size = sizeof(ARC4HMAC2_t);
1523                 break;
1524         case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2__STATE:
1525                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2__STATE\n");
1526                 cipher_key = &ctl_desc->cipherHashInfo.infoARC4StateHMAC2.cipherKey0;
1527                 cipher_state =
1528                     &ctl_desc->cipherHashInfo.infoARC4StateHMAC2.Arc4SboxData0;
1529                 hmac_key = &ctl_desc->cipherHashInfo.infoARC4StateHMAC2.hmacKey0;
1530                 cipher_keylen = op->rc4_key_len;
1531                 hmac_keylen = sizeof(HMAC2_t);
1532                 ctl_size = sizeof(ARC4StateHMAC2_t);
1533                 break;
1534         case XLR_SEC_VECTOR__CIPHER_DES__HMAC2__MODE_ECB_CBC:
1535                 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_DES__HMAC2__MODE_ECB_CBC  \n");
1536                 cipher_key = &ctl_desc->cipherHashInfo.infoDESHMAC2.cipherKey0;
1537                 hmac_key = &ctl_desc->cipherHashInfo.infoDESHMAC2.hmacKey0;
1538                 hmac_keylen = sizeof(HMAC2_t);
1539                 cipher_keylen = XLR_SEC_DES_KEY_LENGTH;
1540                 ctl_size = sizeof(DESHMAC2_t);
1541                 break;
1542         case XLR_SEC_VECTOR__CIPHER_3DES__HMAC2__MODE_ECB_CBC:
1543                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__HMAC2__MODE_ECB_CBC  \n");
1544                 cipher_key = &ctl_desc->cipherHashInfo.info3DESHMAC2.cipherKey0;
1545                 hmac_key = &ctl_desc->cipherHashInfo.info3DESHMAC2.hmacKey0;
1546                 cipher_keylen = XLR_SEC_3DES_KEY_LENGTH;
1547                 hmac_keylen = sizeof(HMAC2_t);
1548                 ctl_size = sizeof(DES3HMAC2_t);
1549                 break;
1550         case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_CTR_CFB:
1551                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_CTR_CFB  \n");
1552                 cipher_key = &ctl_desc->cipherHashInfo.infoAES128HMAC2.cipherKey0;
1553                 hmac_key = &ctl_desc->cipherHashInfo.infoAES128HMAC2.hmacKey0;
1554                 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
1555                 hmac_keylen = sizeof(HMAC2_t);
1556                 ctl_size = sizeof(AES128HMAC2_t);
1557                 break;
1558         case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_ECB_CBC_OFB:
1559                 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_ECB_CBC_OFB  \n");
1560                 cipher_key = &ctl_desc->cipherHashInfo.infoAES128HMAC2.cipherKey0;
1561                 hmac_key = &ctl_desc->cipherHashInfo.infoAES128HMAC2.hmacKey0;
1562                 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
1563                 hmac_keylen = sizeof(HMAC2_t);
1564                 ctl_size = sizeof(AES128HMAC2_t);
1565                 break;
1566         case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_F8:
1567                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_F8  \n");
1568                 cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8HMAC2.cipherKey0;
1569                 hmac_key = &ctl_desc->cipherHashInfo.infoAES128F8HMAC2.hmacKey0;
1570                 cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH;
1571                 hmac_keylen = sizeof(HMAC2_t);
1572                 ctl_size = sizeof(AES128F8HMAC2_t);
1573                 break;
1574         case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_CTR_CFB:
1575                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_CTR_CFB  \n");
1576                 cipher_key = &ctl_desc->cipherHashInfo.infoAES192HMAC2.cipherKey0;
1577                 hmac_key = &ctl_desc->cipherHashInfo.infoAES192HMAC2.hmacKey0;
1578                 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
1579                 hmac_keylen = sizeof(HMAC2_t);
1580                 ctl_size = sizeof(AES192HMAC2_t);
1581                 break;
1582         case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_ECB_CBC_OFB:
1583                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_ECB_CBC_OFB  \n");
1584                 cipher_key = &ctl_desc->cipherHashInfo.infoAES192HMAC2.cipherKey0;
1585                 hmac_key = &ctl_desc->cipherHashInfo.infoAES192HMAC2.hmacKey0;
1586                 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
1587                 hmac_keylen = sizeof(HMAC2_t);
1588                 ctl_size = sizeof(AES192HMAC2_t);
1589                 break;
1590         case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_F8:
1591                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_F8  \n");
1592                 cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8HMAC2.cipherKey0;
1593                 hmac_key = &ctl_desc->cipherHashInfo.infoAES192F8HMAC2.hmacKey0;
1594                 cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH;
1595                 hmac_keylen = sizeof(HMAC2_t);
1596                 ctl_size = sizeof(AES192F8HMAC2_t);
1597                 break;
1598         case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_CTR_CFB:
1599                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_CTR_CFB  \n");
1600                 cipher_key = &ctl_desc->cipherHashInfo.infoAES256HMAC2.cipherKey0;
1601                 hmac_key = &ctl_desc->cipherHashInfo.infoAES256HMAC2.hmacKey0;
1602                 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
1603                 hmac_keylen = sizeof(HMAC2_t);
1604                 ctl_size = sizeof(AES256HMAC2_t);
1605                 break;
1606         case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_ECB_CBC_OFB:
1607                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_ECB_CBC_OFB  \n");
1608                 cipher_key = &ctl_desc->cipherHashInfo.infoAES256HMAC2.cipherKey0;
1609                 hmac_key = &ctl_desc->cipherHashInfo.infoAES256HMAC2.hmacKey0;
1610                 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
1611                 hmac_keylen = sizeof(HMAC2_t);
1612                 ctl_size = sizeof(AES256HMAC2_t);
1613                 break;
1614         case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_F8:
1615                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_F8  \n");
1616                 cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8HMAC2.cipherKey0;
1617                 hmac_key = &ctl_desc->cipherHashInfo.infoAES256F8HMAC2.hmacKey0;
1618                 cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH;
1619                 hmac_keylen = sizeof(HMAC2_t);
1620                 ctl_size = sizeof(AES256F8HMAC2_t);
1621                 break;
1622         case XLR_SEC_VECTOR_GCM:
1623                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_GCM  \n");
1624                 hmac_key = &ctl_desc->cipherHashInfo.infoGCM.GCMH0;
1625                 hmac_keylen = sizeof(GCM_t);
1626                 ctl_size = sizeof(GCM_t);
1627                 break;
1628         case XLR_SEC_VECTOR_CIPHER_ARC4__GCM:
1629                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__GCM\n");
1630                 cipher_key = &ctl_desc->cipherHashInfo.infoARC4GCM.cipherKey0;
1631                 hmac_key = &ctl_desc->cipherHashInfo.infoARC4GCM.GCMH0;
1632                 cipher_keylen = op->rc4_key_len;
1633                 hmac_keylen = sizeof(GCM_t);
1634                 ctl_size = sizeof(ARC4GCM_t);
1635                 break;
1636         case XLR_SEC_VECTOR_CIPHER_ARC4__GCM__STATE:
1637                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__GCM__STATE\n");
1638                 cipher_key = &ctl_desc->cipherHashInfo.infoARC4StateGCM.cipherKey0;
1639                 cipher_state =
1640                     &ctl_desc->cipherHashInfo.infoARC4StateGCM.Arc4SboxData0;
1641                 hmac_key = &ctl_desc->cipherHashInfo.infoARC4StateGCM.GCMH0;
1642                 cipher_keylen = op->rc4_key_len;
1643                 hmac_keylen = sizeof(GCM_t);
1644                 ctl_size = sizeof(ARC4StateGCM_t);
1645                 break;
1646         case XLR_SEC_VECTOR__CIPHER_DES__GCM__MODE_ECB_CBC:
1647                 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_DES__GCM__MODE_ECB_CBC  \n");
1648                 cipher_key = &ctl_desc->cipherHashInfo.infoDESGCM.cipherKey0;
1649                 hmac_key = &ctl_desc->cipherHashInfo.infoDESGCM.GCMH0;
1650                 hmac_keylen = sizeof(GCM_t);
1651                 cipher_keylen = XLR_SEC_DES_KEY_LENGTH;
1652                 ctl_size = sizeof(DESGCM_t);
1653                 break;
1654         case XLR_SEC_VECTOR__CIPHER_3DES__GCM__MODE_ECB_CBC:
1655                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__GCM__MODE_ECB_CBC  \n");
1656                 cipher_key = &ctl_desc->cipherHashInfo.info3DESGCM.cipherKey0;
1657                 hmac_key = &ctl_desc->cipherHashInfo.info3DESGCM.GCMH0;
1658                 cipher_keylen = XLR_SEC_3DES_KEY_LENGTH;
1659                 hmac_keylen = sizeof(GCM_t);
1660                 ctl_size = sizeof(DES3GCM_t);
1661                 break;
1662         case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_CTR_CFB:
1663                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_CTR_CFB  \n");
1664                 cipher_key = &ctl_desc->cipherHashInfo.infoAES128GCM.cipherKey0;
1665                 hmac_key = &ctl_desc->cipherHashInfo.infoAES128GCM.GCMH0;
1666                 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
1667                 hmac_keylen = sizeof(GCM_t);
1668                 ctl_size = sizeof(AES128GCM_t);
1669                 break;
1670         case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_ECB_CBC_OFB:
1671                 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_ECB_CBC_OFB  \n");
1672                 cipher_key = &ctl_desc->cipherHashInfo.infoAES128GCM.cipherKey0;
1673                 hmac_key = &ctl_desc->cipherHashInfo.infoAES128GCM.GCMH0;
1674                 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
1675                 hmac_keylen = sizeof(GCM_t);
1676                 ctl_size = sizeof(AES128GCM_t);
1677                 break;
1678         case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_F8:
1679                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_F8  \n");
1680                 cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8GCM.cipherKey0;
1681                 hmac_key = &ctl_desc->cipherHashInfo.infoAES128F8GCM.GCMH0;
1682                 cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH;
1683                 hmac_keylen = sizeof(GCM_t);
1684                 ctl_size = sizeof(AES128F8GCM_t);
1685                 break;
1686         case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_CTR_CFB:
1687                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_CTR_CFB  \n");
1688                 cipher_key = &ctl_desc->cipherHashInfo.infoAES192GCM.cipherKey0;
1689                 hmac_key = &ctl_desc->cipherHashInfo.infoAES192GCM.GCMH0;
1690                 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
1691                 hmac_keylen = sizeof(GCM_t);
1692                 ctl_size = sizeof(AES192GCM_t);
1693                 break;
1694         case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_ECB_CBC_OFB:
1695                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_ECB_CBC_OFB  \n");
1696                 cipher_key = &ctl_desc->cipherHashInfo.infoAES192GCM.cipherKey0;
1697                 hmac_key = &ctl_desc->cipherHashInfo.infoAES192GCM.GCMH0;
1698                 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
1699                 hmac_keylen = sizeof(GCM_t);
1700                 ctl_size = sizeof(AES192GCM_t);
1701                 break;
1702         case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_F8:
1703                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_F8  \n");
1704                 cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8GCM.cipherKey0;
1705                 hmac_key = &ctl_desc->cipherHashInfo.infoAES192F8GCM.GCMH0;
1706                 cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH;
1707                 hmac_keylen = sizeof(GCM_t);
1708                 ctl_size = sizeof(AES192F8GCM_t);
1709                 break;
1710         case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_CTR_CFB:
1711                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_CTR_CFB  \n");
1712                 cipher_key = &ctl_desc->cipherHashInfo.infoAES256GCM.cipherKey0;
1713                 hmac_key = &ctl_desc->cipherHashInfo.infoAES256GCM.GCMH0;
1714                 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
1715                 hmac_keylen = sizeof(GCM_t);
1716                 ctl_size = sizeof(AES256GCM_t);
1717                 break;
1718         case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_ECB_CBC_OFB:
1719                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_ECB_CBC_OFB  \n");
1720                 cipher_key = &ctl_desc->cipherHashInfo.infoAES256GCM.cipherKey0;
1721                 hmac_key = &ctl_desc->cipherHashInfo.infoAES256GCM.GCMH0;
1722                 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
1723                 hmac_keylen = sizeof(GCM_t);
1724                 ctl_size = sizeof(AES256GCM_t);
1725                 break;
1726         case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_F8:
1727                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_F8  \n");
1728                 cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8GCM.cipherKey0;
1729                 hmac_key = &ctl_desc->cipherHashInfo.infoAES256F8GCM.GCMH0;
1730                 cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH;
1731                 hmac_keylen = sizeof(GCM_t);
1732                 ctl_size = sizeof(AES256F8GCM_t);
1733                 break;
1734         case XLR_SEC_VECTOR_F9:
1735                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_F9  \n");
1736                 hmac_key = &ctl_desc->cipherHashInfo.infoF9.authKey0;
1737                 hmac_keylen = sizeof(F9_t);
1738                 ctl_size = sizeof(F9_t);
1739                 break;
1740         case XLR_SEC_VECTOR_CIPHER_ARC4__F9:
1741                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__F9\n");
1742                 cipher_key = &ctl_desc->cipherHashInfo.infoARC4F9.cipherKey0;
1743                 hmac_key = &ctl_desc->cipherHashInfo.infoARC4F9.authKey0;
1744                 cipher_keylen = op->rc4_key_len;
1745                 hmac_keylen = sizeof(F9_t);
1746                 ctl_size = sizeof(ARC4F9_t);
1747                 break;
1748         case XLR_SEC_VECTOR_CIPHER_ARC4__F9__STATE:
1749                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__F9__STATE\n");
1750                 cipher_key = &ctl_desc->cipherHashInfo.infoARC4StateF9.cipherKey0;
1751                 cipher_state =
1752                     &ctl_desc->cipherHashInfo.infoARC4StateF9.Arc4SboxData0;
1753                 hmac_key = &ctl_desc->cipherHashInfo.infoARC4StateF9.authKey0;
1754                 cipher_keylen = op->rc4_key_len;
1755                 hmac_keylen = sizeof(F9_t);
1756                 ctl_size = sizeof(ARC4StateF9_t);
1757                 break;
1758         case XLR_SEC_VECTOR__CIPHER_DES__F9__MODE_ECB_CBC:
1759                 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_DES__F9__MODE_ECB_CBC  \n");
1760                 cipher_key = &ctl_desc->cipherHashInfo.infoDESF9.cipherKey0;
1761                 hmac_key = &ctl_desc->cipherHashInfo.infoDESF9.authKey0;
1762                 hmac_keylen = sizeof(F9_t);
1763                 cipher_keylen = XLR_SEC_DES_KEY_LENGTH;
1764                 ctl_size = sizeof(DESF9_t);
1765                 break;
1766         case XLR_SEC_VECTOR__CIPHER_3DES__F9__MODE_ECB_CBC:
1767                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__F9__MODE_ECB_CBC  \n");
1768                 cipher_key = &ctl_desc->cipherHashInfo.info3DESF9.cipherKey0;
1769                 hmac_key = &ctl_desc->cipherHashInfo.info3DESF9.authKey0;
1770                 cipher_keylen = XLR_SEC_3DES_KEY_LENGTH;
1771                 hmac_keylen = sizeof(F9_t);
1772                 ctl_size = sizeof(DES3F9_t);
1773                 break;
1774         case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_CTR_CFB:
1775                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_CTR_CFB  \n");
1776                 cipher_key = &ctl_desc->cipherHashInfo.infoAES128F9.cipherKey0;
1777                 hmac_key = &ctl_desc->cipherHashInfo.infoAES128F9.authKey0;
1778                 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
1779                 hmac_keylen = sizeof(F9_t);
1780                 ctl_size = sizeof(AES128F9_t);
1781                 break;
1782         case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_ECB_CBC_OFB:
1783                 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_ECB_CBC_OFB  \n");
1784                 cipher_key = &ctl_desc->cipherHashInfo.infoAES128F9.cipherKey0;
1785                 hmac_key = &ctl_desc->cipherHashInfo.infoAES128F9.authKey0;
1786                 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
1787                 hmac_keylen = sizeof(F9_t);
1788                 ctl_size = sizeof(AES128F9_t);
1789                 break;
1790         case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_F8:
1791                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_F8  \n");
1792                 cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8F9.cipherKey0;
1793                 hmac_key = &ctl_desc->cipherHashInfo.infoAES128F8F9.authKey0;
1794                 cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH;
1795                 hmac_keylen = sizeof(F9_t);
1796                 ctl_size = sizeof(AES128F8F9_t);
1797                 break;
1798         case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_CTR_CFB:
1799                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_CTR_CFB  \n");
1800                 cipher_key = &ctl_desc->cipherHashInfo.infoAES192F9.cipherKey0;
1801                 hmac_key = &ctl_desc->cipherHashInfo.infoAES192F9.authKey0;
1802                 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
1803                 hmac_keylen = sizeof(F9_t);
1804                 ctl_size = sizeof(AES192F9_t);
1805                 break;
1806         case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_ECB_CBC_OFB:
1807                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_ECB_CBC_OFB  \n");
1808                 cipher_key = &ctl_desc->cipherHashInfo.infoAES192F9.cipherKey0;
1809                 hmac_key = &ctl_desc->cipherHashInfo.infoAES192F9.authKey0;
1810                 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
1811                 hmac_keylen = sizeof(F9_t);
1812                 ctl_size = sizeof(AES192F9_t);
1813                 break;
1814         case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_F8:
1815                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_F8  \n");
1816                 cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8F9.cipherKey0;
1817                 hmac_key = &ctl_desc->cipherHashInfo.infoAES192F8F9.authKey0;
1818                 cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH;
1819                 hmac_keylen = sizeof(F9_t);
1820                 ctl_size = sizeof(AES192F8F9_t);
1821                 break;
1822         case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_CTR_CFB:
1823                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_CTR_CFB  \n");
1824                 cipher_key = &ctl_desc->cipherHashInfo.infoAES256F9.cipherKey0;
1825                 hmac_key = &ctl_desc->cipherHashInfo.infoAES256F9.authKey0;
1826                 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
1827                 hmac_keylen = sizeof(F9_t);
1828                 ctl_size = sizeof(AES256F9_t);
1829                 break;
1830         case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_ECB_CBC_OFB:
1831                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_ECB_CBC_OFB  \n");
1832                 cipher_key = &ctl_desc->cipherHashInfo.infoAES256F9.cipherKey0;
1833                 hmac_key = &ctl_desc->cipherHashInfo.infoAES256F9.authKey0;
1834                 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
1835                 hmac_keylen = sizeof(F9_t);
1836                 ctl_size = sizeof(AES256F9_t);
1837                 break;
1838         case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_F8:
1839                 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_F8  \n");
1840                 cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8F9.cipherKey0;
1841                 hmac_key = &ctl_desc->cipherHashInfo.infoAES256F8F9.authKey0;
1842                 cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH;
1843                 hmac_keylen = sizeof(F9_t);
1844                 ctl_size = sizeof(AES256F8F9_t);
1845                 break;
1846
1847         default:
1848                 XLR_SEC_CMD_DIAG("default  \n");
1849                 return XLR_SEC_ERR_CONTROL_VECTOR;
1850         }
1851
1852         if ((cipher_key != NULL) && !(flags & XLR_SEC_SETUP_OP_PRESERVE_CIPHER_KEY))
1853                 memcpy(cipher_key, &op->crypt_key[0], cipher_keylen);
1854
1855         if ((hmac_key != NULL) && !(flags & XLR_SEC_SETUP_OP_PRESERVE_HMAC_KEY))
1856                 memcpy(hmac_key, &op->mac_key[0], hmac_keylen);
1857         if (cipher_state) {
1858                 if (op->rc4_loadstate)
1859                         memcpy(cipher_state, (void *)(unsigned long)op->rc4_state,
1860                             XLR_SEC_MAX_RC4_STATE_SIZE);
1861                 if (op->rc4_savestate)
1862                         user->aligned_state = (char *)cipher_state;
1863         }
1864         if (flags & XLR_SEC_SETUP_OP_FLIP_3DES_KEY) {
1865                 uint64_t temp;
1866
1867                 temp = ctl_desc->cipherHashInfo.info3DES.cipherKey0;
1868                 ctl_desc->cipherHashInfo.info3DES.cipherKey0 =
1869                     ctl_desc->cipherHashInfo.info3DES.cipherKey2;
1870                 ctl_desc->cipherHashInfo.info3DES.cipherKey2 = temp;
1871         }
1872         /*
1873          * Control length is the number of control cachelines to be read so
1874          * user needs to round up the control length to closest integer
1875          * multiple of 32 bytes.
1876          */
1877         ctl_size += sizeof(ctl_desc->instruction);
1878         ctl_len = NUM_CHUNKS(ctl_size, 5);
1879         XLR_SEC_CMD_DIAG("ctl_size in bytes: %u, in cachelines: %u\n", ctl_size, ctl_len);
1880         CLEAR_SET_FIELD(*control, MSG_CMD_CTL_LEN, ctl_len);
1881
1882         ctl_addr = (uint64_t) vtophys(ctl_desc);
1883         CLEAR_SET_FIELD(*control, MSG_CMD_CTL_ADDR, ctl_addr);
1884
1885         XLR_SEC_CMD_DIAG(" xlr_sec_control_setup():  ctl_desc=%p   ctl_addr=%llx \n",
1886             ctl_desc, (unsigned long long)ctl_addr);
1887
1888         CLEAR_SET_FIELD(*control, MSG_CMD_CTL_CTL, SEC_SOP);
1889
1890         return XLR_SEC_ERR_NONE;
1891 }
1892
1893 xlr_sec_error_t
1894 xlr_sec_submit_op(symkey_desc_pt desc)
1895 {
1896         struct msgrng_msg send_msg;
1897
1898         int rsp_dest_id, cpu, hard_cpu, hard_thread;
1899         int code, retries;
1900         unsigned long msgrng_flags = 0;
1901
1902         /* threads (0-3) are orthogonal to buckets 0-3 */
1903         cpu = xlr_cpu_id();
1904
1905         hard_cpu = cpu >> 2;
1906         hard_thread = cpu & 0x3;/* thread id */
1907         rsp_dest_id = (hard_cpu << 3) + hard_thread;
1908
1909         desc->op_ctl.cpu = hard_cpu;
1910         desc->op_ctl.flags = 0; /* called from kernel thread */
1911
1912         XLR_SEC_CMD_DIAG("[%s]:%d:  cpu=0x%x  hard_cpu=0x%x  hard_thrd=0x%x  id=0x%x \n",
1913             __FUNCTION__, __LINE__, cpu, hard_cpu, hard_thread, rsp_dest_id);
1914
1915         /*
1916          * Set DestId in Message Control Word. This tells the Security
1917          * Engine which bucket to send the reply to for this CPU
1918          */
1919         CLEAR_SET_FIELD(desc->control, MSG_CMD_CTL_ID, rsp_dest_id);
1920         CLEAR_SET_FIELD(desc->data, MSG_CMD_CTL_ID, rsp_dest_id);
1921
1922         CLEAR_SET_FIELD(desc->control, MSG_CTL_OP_TYPE, MSG0_CTL_OP_ENGINE_SYMKEY);
1923         CLEAR_SET_FIELD(desc->data, MSG_CTL_OP_TYPE, MSG1_CTL_OP_SYMKEY_PIPE0);
1924
1925         send_msg.msg0 = desc->control | (1ULL << 53);
1926         send_msg.msg1 = desc->data | (1ULL << 53) | (1ULL << 52);
1927         send_msg.msg2 = send_msg.msg3 = 0;
1928
1929         desc->op_ctl.flags = 1;
1930         //in_interrupt();       /* ipsec softirq ? */
1931
1932         XLR_SEC_CMD_DIAG("[%s]: IN_IRQ=%d  msg0=0x%llx  msg1=0x%llx \n",
1933             __FUNCTION__, desc->op_ctl.flags, send_msg.msg0, send_msg.msg1);
1934
1935         retries = 100;
1936         while (retries--) {
1937                 msgrng_flags = msgrng_access_enable();
1938                 code = message_send(SEC_MSGRING_WORDSIZE, MSGRNG_CODE_SEC,
1939                     desc->op_ctl.stn_id, &send_msg);
1940                 msgrng_restore(msgrng_flags);
1941                 if (code == 0)
1942                         break;
1943         }
1944         return (XLR_SEC_ERR_NONE);
1945 }
1946
1947 symkey_desc_pt
1948 xlr_sec_allocate_desc(void *session_ptr)
1949 {
1950         uint64_t addr;
1951         symkey_desc_pt aligned, new;
1952
1953         new = (symkey_desc_pt) malloc(sizeof(symkey_desc_t),
1954             M_DEVBUF, M_NOWAIT | M_ZERO);
1955
1956         if (new == NULL)
1957                 return (NULL);
1958
1959         new->ses = session_ptr;
1960
1961         new->user.kern_src = new->user.aligned_src =
1962             (uint8_t *) contigmalloc(256 * 1024 + 1024,
1963             M_DEVBUF, M_NOWAIT | M_ZERO,
1964             0, 0xffffffff, XLR_CACHELINE_SIZE, 0);
1965
1966         if (new->user.kern_src == NULL) {
1967                 printf("ERROR - malloc failed for user.kern_src\n");
1968                 return NULL;
1969         }
1970         new->user.aligned_dest = new->user.kern_dest =
1971             (uint8_t *) contigmalloc(257 * 1024,
1972             M_DEVBUF, M_NOWAIT | M_ZERO,
1973             0, 0xffffffff, XLR_CACHELINE_SIZE, 0);
1974
1975         if (new->user.aligned_dest == NULL) {
1976                 printf("ERROR - malloc failed for user.aligned_dest\n");
1977                 return NULL;
1978         }
1979         new->next_src_buf = (uint8_t *) contigmalloc(256 * 1024 + 1024,
1980             M_DEVBUF, M_NOWAIT | M_ZERO,
1981             0, 0xffffffff, XLR_CACHELINE_SIZE, 0);
1982
1983         if (new->next_src_buf == NULL) {
1984                 printf("ERROR - malloc failed for next_src_buf\n");
1985                 return NULL;
1986         }
1987         new->next_dest_buf =
1988             (uint8_t *) contigmalloc(257 * 1024,
1989             M_DEVBUF, M_NOWAIT | M_ZERO,
1990             0, 0xffffffff, XLR_CACHELINE_SIZE, 0);
1991
1992         if (new->next_dest_buf == NULL) {
1993                 printf("ERROR - malloc failed for next_dest_buf\n");
1994                 return NULL;
1995         }
1996         new->user.kern_auth = new->user.user_auth = NULL;
1997         new->user.aligned_auth = new->user.user_auth = NULL;
1998
1999         /* find cacheline alignment */
2000         aligned = new;
2001         addr = (uint64_t) vtophys(new);
2002
2003         /* save for free */
2004         aligned->alloc = new;
2005
2006         /* setup common control info */
2007         aligned->op_ctl.phys_self = addr;
2008         aligned->op_ctl.stn_id = MSGRNG_STNID_SEC0;
2009         aligned->op_ctl.vaddr = (uintptr_t)aligned;
2010
2011         return (aligned);
2012 }
2013
2014
2015 static void
2016 xlr_sec_free_desc(symkey_desc_pt desc)
2017 {
2018         if ((desc == NULL) || (desc->alloc == NULL)) {
2019                 printf("%s:  NULL descriptor \n", __FUNCTION__);
2020                 return;
2021         }
2022         contigfree(desc, sizeof(symkey_desc_t), M_DEVBUF);
2023         return;
2024 }
2025
2026 void
2027 print_buf(char *desc, void *data, int len)
2028 {
2029         uint8_t *dp;
2030         int i;
2031
2032         DPRINT("%s: ", desc);   /* newline done in for-loop */
2033         dp = data;
2034         for (i = 0; i < len; i++, dp++) {
2035                 if ((i % 16) == 0)
2036                         DPRINT("\n");
2037                 DPRINT(" %c%c",
2038                     nib2hex[(((*dp) & 0xf0) >> 4)],
2039                     nib2hex[((*dp) & 0x0f)]);
2040         }
2041         DPRINT("\n");
2042 }
2043
2044
2045 #ifdef XLR_SEC_CMD_DEBUG
2046 static void
2047 decode_symkey_desc(symkey_desc_pt desc, uint32_t cfg_vector)
2048 {
2049
2050         unsigned long long word;
2051
2052         /* uint8_t   *info; */
2053         /* int i; */
2054
2055         DPRINT("MSG - CTL: \n");
2056         DPRINT("\t CTRL      = %lld \n",
2057             GET_FIELD(desc->control, MSG_CMD_CTL_CTL));
2058         DPRINT("\t CTRL LEN  = %lld \n",
2059             GET_FIELD(desc->control, MSG_CMD_CTL_LEN));
2060         DPRINT("\t CTRL ADDR = %llx \n\n",
2061             GET_FIELD(desc->control, MSG_CMD_CTL_ADDR));
2062
2063         DPRINT("MSG - DATA: \n");
2064         DPRINT("\t CTRL      = %lld \n",
2065             GET_FIELD(desc->data, MSG_CMD_DATA_CTL));
2066         DPRINT("\t DATA LEN  = %lld \n",
2067             GET_FIELD(desc->data, MSG_CMD_DATA_LEN));
2068         DPRINT("\t DATA ADDR = %llx \n\n",
2069             GET_FIELD(desc->data, MSG_CMD_DATA_ADDR));
2070
2071         DPRINT("CONTROL DESCRIPTOR: \n");
2072         word = desc->ctl_desc.instruction;
2073         DPRINT("\tINSTRUCTION:   %llx\n", word);
2074         DPRINT("\t\tOVERRIDE CIPH = %lld \n", GET_FIELD(word, CTL_DSC_OVERRIDECIPHER));
2075         DPRINT("\t\tARC4 WAIT     = %lld \n", GET_FIELD(word, CTL_DSC_ARC4_WAIT4SAVE));
2076         DPRINT("\t\tARC4 SAVE     = %lld \n", GET_FIELD(word, CTL_DSC_ARC4_SAVESTATE));
2077         DPRINT("\t\tARC4 LOAD     = %lld \n", GET_FIELD(word, CTL_DSC_ARC4_LOADSTATE));
2078         DPRINT("\t\tARC4 KEYLEN   = %lld \n", GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2079         DPRINT("\t\tCIPHER        = %lld \n", GET_FIELD(word, CTL_DSC_CPHR));
2080         DPRINT("\t\tCIPHER MODE   = %lld \n", GET_FIELD(word, CTL_DSC_MODE));
2081         DPRINT("\t\tINIT CIPHER   = %lld \n", GET_FIELD(word, CTL_DSC_ICPHR));
2082         DPRINT("\t\tHMAC          = %lld \n", GET_FIELD(word, CTL_DSC_HMAC));
2083         DPRINT("\t\tHASH ALG      = %lld \n", GET_FIELD(word, CTL_DSC_HASH) | (GET_FIELD(word, CTL_DSC_HASHHI) << 2));
2084         DPRINT("\t\tINIT HASH     = %lld \n", GET_FIELD(word, CTL_DSC_IHASH));
2085         DPRINT("\t\tCHKSUM        = %lld \n", GET_FIELD(word, CTL_DSC_CKSUM));
2086         DPRINT("\tCIPHER HASH INFO: \n");
2087 #if 0
2088         info = (uint8_t *) & desc->ctl_desc->cipherHashInfo;
2089         for (i = 0; i < sizeof(CipherHashInfo_t); i++, info++) {
2090                 DPRINT(" %02x", *info);
2091                 if (i && (i % 16) == 0)
2092                         DPRINT("\n");
2093         }
2094         DPRINT("\n\n");
2095 #endif
2096
2097         switch (cfg_vector) {
2098         case XLR_SEC_VECTOR_CIPHER_ARC4:
2099                 DPRINT("VECTOR:  XLR_SEC_VECTOR_CIPHER_ARC4 \n");
2100                 print_buf("ARC4 Key",
2101                     &desc->ctl_desc.cipherHashInfo.infoARC4.cipherKey0,
2102                     GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2103                 break;
2104         case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC:
2105                 DPRINT("VECTOR:  XLR_SEC_VECTOR_CIPHER_ARC4__HMAC \n");
2106                 print_buf("ARC4 Key",
2107                     &desc->ctl_desc.cipherHashInfo.infoARC4HMAC.cipherKey0,
2108                     GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2109                 print_buf("HMAC Key",
2110                     &desc->ctl_desc.cipherHashInfo.infoARC4HMAC.hmacKey0,
2111                     sizeof(HMAC_t));
2112                 break;
2113         case XLR_SEC_VECTOR_CIPHER_ARC4__STATE:
2114                 DPRINT("VECTOR:  XLR_SEC_VECTOR_CIPHER_ARC4__STATE \n");
2115                 print_buf("ARC4 Key",
2116                     &desc->ctl_desc.cipherHashInfo.infoARC4State.cipherKey0,
2117                     GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2118                 break;
2119         case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC__STATE:
2120                 DPRINT("VECTOR:  XLR_SEC_VECTOR_CIPHER_ARC4__HMAC__STATE \n");
2121                 print_buf("ARC4 Key",
2122                     &desc->ctl_desc.cipherHashInfo.infoARC4StateHMAC.cipherKey0,
2123                     GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2124                 print_buf("HMAC Key",
2125                     &desc->ctl_desc.cipherHashInfo.infoARC4StateHMAC.hmacKey0,
2126                     sizeof(HMAC_t));
2127                 break;
2128         case XLR_SEC_VECTOR_CIPHER_KASUMI_F8:
2129                 DPRINT("VECTOR:  XLR_SEC_VECTOR_CIPHER_KASUMI_F8 \n");
2130                 print_buf("KASUMI_F8 Key",
2131                     &desc->ctl_desc.cipherHashInfo.infoKASUMIF8.cipherKey0,
2132                     XLR_SEC_KASUMI_F8_KEY_LENGTH);
2133                 break;
2134         case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC:
2135                 DPRINT("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC\n");
2136                 print_buf("KASUMI_F8 Key",
2137                     &desc->ctl_desc.cipherHashInfo.infoKASUMIF8HMAC.cipherKey0,
2138                     XLR_SEC_KASUMI_F8_KEY_LENGTH);
2139                 print_buf("HMAC Key",
2140                     &desc->ctl_desc.cipherHashInfo.infoKASUMIF8HMAC.hmacKey0,
2141                     sizeof(HMAC_t));
2142                 break;
2143         case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC2:
2144                 DPRINT("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC2\n");
2145                 print_buf("KASUMI_F8 Key",
2146                     &desc->ctl_desc.cipherHashInfo.infoKASUMIF8HMAC2.cipherKey0,
2147                     XLR_SEC_KASUMI_F8_KEY_LENGTH);
2148                 print_buf("HMAC2 Key",
2149                     &desc->ctl_desc.cipherHashInfo.infoKASUMIF8HMAC2.hmacKey0,
2150                     sizeof(HMAC2_t));
2151                 break;
2152         case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__GCM:
2153                 DPRINT("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__GCM\n");
2154                 print_buf("KASUMI_F8 Key",
2155                     &desc->ctl_desc.cipherHashInfo.infoKASUMIF8GCM.cipherKey0,
2156                     XLR_SEC_KASUMI_F8_KEY_LENGTH);
2157                 print_buf("GCM Key",
2158                     &desc->ctl_desc.cipherHashInfo.infoKASUMIF8GCM.GCMH0,
2159                     sizeof(GCM_t));
2160                 break;
2161         case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__F9:
2162                 DPRINT("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__F9\n");
2163                 print_buf("KASUMI_F8 Key",
2164                     &desc->ctl_desc.cipherHashInfo.infoKASUMIF8F9.cipherKey0,
2165                     XLR_SEC_KASUMI_F8_KEY_LENGTH);
2166                 print_buf("F9 Key",
2167                     &desc->ctl_desc.cipherHashInfo.infoKASUMIF8F9.authKey0,
2168                     sizeof(F9_t));
2169                 break;
2170         case XLR_SEC_VECTOR_MAC:
2171                 DPRINT("VECTOR:  XLR_SEC_VECTOR_MAC \n");
2172                 DPRINT("MAC-ONLY - No Info\n");
2173                 break;
2174         case XLR_SEC_VECTOR_HMAC:
2175                 DPRINT("VECTOR:  XLR_SEC_VECTOR_HMAC \n");
2176                 print_buf("HMAC Key",
2177                     &desc->ctl_desc.cipherHashInfo.infoHMAC.hmacKey0,
2178                     sizeof(HMAC_t));
2179                 break;
2180         case XLR_SEC_VECTOR__CIPHER_DES__HMAC__MODE_ECB_CBC:
2181                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_DES__HMAC__MODE_ECB_CBC \n");
2182                 print_buf("CIPHER Key",
2183                     &desc->ctl_desc.cipherHashInfo.infoDESHMAC.cipherKey0,
2184                     XLR_SEC_DES_KEY_LENGTH);
2185                 print_buf("HMAC Key",
2186                     &desc->ctl_desc.cipherHashInfo.infoDESHMAC.hmacKey0,
2187                     sizeof(HMAC_t));
2188                 break;
2189         case XLR_SEC_VECTOR__CIPHER_DES__MODE_ECB_CBC:
2190                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_DES__MODE_ECB_CBC \n");
2191                 print_buf("CIPHER Key",
2192                     &desc->ctl_desc.cipherHashInfo.infoDES.cipherKey0,
2193                     XLR_SEC_DES_KEY_LENGTH);
2194                 break;
2195         case XLR_SEC_VECTOR__CIPHER_3DES__HMAC__MODE_ECB_CBC:
2196                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_3DES__HMAC__MODE_ECB_CBC \n");
2197                 print_buf("CIPHER Key",
2198                     &desc->ctl_desc.cipherHashInfo.info3DESHMAC.cipherKey0,
2199                     XLR_SEC_3DES_KEY_LENGTH);
2200                 print_buf("HMAC Key",
2201                     &desc->ctl_desc.cipherHashInfo.info3DESHMAC.hmacKey0,
2202                     sizeof(HMAC_t));
2203                 break;
2204         case XLR_SEC_VECTOR__CIPHER_3DES__MODE_ECB_CBC:
2205                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_3DES__MODE_ECB_CBC \n");
2206                 print_buf("CIPHER Key",
2207                     &desc->ctl_desc.cipherHashInfo.info3DES.cipherKey0,
2208                     XLR_SEC_3DES_KEY_LENGTH);
2209                 break;
2210         case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_CTR_CFB:
2211                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_CTR_CFB \n");
2212                 print_buf("CIPHER Key",
2213                     &desc->ctl_desc.cipherHashInfo.infoAES128HMAC.cipherKey0,
2214                     XLR_SEC_AES128_KEY_LENGTH);
2215                 print_buf("HMAC Key",
2216                     &desc->ctl_desc.cipherHashInfo.infoAES128HMAC.hmacKey0,
2217                     sizeof(HMAC_t));
2218                 break;
2219         case XLR_SEC_VECTOR__CIPHER_AES128__MODE_CTR_CFB:
2220                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES128__MODE_CTR_CFB \n");
2221                 print_buf("CIPHER Key",
2222                     &desc->ctl_desc.cipherHashInfo.infoAES128.cipherKey0,
2223                     XLR_SEC_AES128_KEY_LENGTH);
2224                 break;
2225         case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_ECB_CBC_OFB:
2226                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_ECB_CBC_OFB\n");
2227                 print_buf("CIPHER Key",
2228                     &desc->ctl_desc.cipherHashInfo.infoAES128HMAC.cipherKey0,
2229                     XLR_SEC_AES128_KEY_LENGTH);
2230                 print_buf("HMAC Key",
2231                     &desc->ctl_desc.cipherHashInfo.infoAES128HMAC.hmacKey0,
2232                     sizeof(HMAC_t));
2233                 break;
2234         case XLR_SEC_VECTOR__CIPHER_AES128__MODE_ECB_CBC_OFB:
2235                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES128__MODE_ECB_CBC_OFB \n");
2236                 print_buf("CIPHER Key",
2237                     &desc->ctl_desc.cipherHashInfo.infoAES128.cipherKey0,
2238                     XLR_SEC_AES128_KEY_LENGTH);
2239                 break;
2240         case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_CTR_CFB:
2241                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_CTR_CFB \n");
2242                 print_buf("CIPHER Key",
2243                     &desc->ctl_desc.cipherHashInfo.infoAES192HMAC.cipherKey0,
2244                     XLR_SEC_AES192_KEY_LENGTH);
2245                 print_buf("HMAC Key",
2246                     &desc->ctl_desc.cipherHashInfo.infoAES192HMAC.hmacKey0,
2247                     sizeof(HMAC_t));
2248                 break;
2249         case XLR_SEC_VECTOR__CIPHER_AES192__MODE_CTR_CFB:
2250                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES192__MODE_CTR_CFB \n");
2251                 print_buf("CIPHER Key",
2252                     &desc->ctl_desc.cipherHashInfo.infoAES192.cipherKey0,
2253                     XLR_SEC_AES192_KEY_LENGTH);
2254                 break;
2255         case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_ECB_CBC_OFB:
2256                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_ECB_CBC_OFB\n");
2257                 print_buf("CIPHER Key",
2258                     &desc->ctl_desc.cipherHashInfo.infoAES192HMAC.cipherKey0,
2259                     XLR_SEC_AES192_KEY_LENGTH);
2260                 print_buf("HMAC Key",
2261                     &desc->ctl_desc.cipherHashInfo.infoAES192HMAC.hmacKey0,
2262                     sizeof(HMAC_t));
2263                 break;
2264         case XLR_SEC_VECTOR__CIPHER_AES192__MODE_ECB_CBC_OFB:
2265                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES192__MODE_ECB_CBC_OFB \n");
2266                 print_buf("CIPHER Key",
2267                     &desc->ctl_desc.cipherHashInfo.infoAES192.cipherKey0,
2268                     XLR_SEC_AES192_KEY_LENGTH);
2269                 break;
2270
2271         case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_CTR_CFB:
2272                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_CTR_CFB \n");
2273                 print_buf("CIPHER Key",
2274                     &desc->ctl_desc.cipherHashInfo.infoAES256HMAC.cipherKey0,
2275                     XLR_SEC_AES256_KEY_LENGTH);
2276                 print_buf("HMAC Key",
2277                     &desc->ctl_desc.cipherHashInfo.infoAES256HMAC.hmacKey0,
2278                     sizeof(HMAC_t));
2279                 break;
2280         case XLR_SEC_VECTOR__CIPHER_AES256__MODE_CTR_CFB:
2281                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES256__MODE_CTR_CFB \n");
2282                 print_buf("CIPHER Key",
2283                     &desc->ctl_desc.cipherHashInfo.infoAES256.cipherKey0,
2284                     XLR_SEC_AES256_KEY_LENGTH);
2285                 break;
2286         case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_ECB_CBC_OFB:
2287                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_ECB_CBC_OFB \n");
2288                 print_buf("CIPHER Key",
2289                     &desc->ctl_desc.cipherHashInfo.infoAES256HMAC.cipherKey0,
2290                     XLR_SEC_AES256_KEY_LENGTH);
2291                 print_buf("HMAC Key",
2292                     &desc->ctl_desc.cipherHashInfo.infoAES256HMAC.hmacKey0,
2293                     sizeof(HMAC_t));
2294                 break;
2295         case XLR_SEC_VECTOR__CIPHER_AES256__MODE_ECB_CBC_OFB:
2296                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES256__MODE_ECB_CBC_OFB \n");
2297                 print_buf("CIPHER Key",
2298                     &desc->ctl_desc.cipherHashInfo.infoAES256.cipherKey0,
2299                     XLR_SEC_AES256_KEY_LENGTH);
2300                 break;
2301         case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2:
2302                 DPRINT("VECTOR:  XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2 \n");
2303                 print_buf("ARC4 Key",
2304                     &desc->ctl_desc.cipherHashInfo.infoARC4HMAC2.cipherKey0,
2305                     GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2306                 print_buf("HMAC2 Key",
2307                     &desc->ctl_desc.cipherHashInfo.infoARC4HMAC2.hmacKey0,
2308                     sizeof(HMAC2_t));
2309                 break;
2310         case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2__STATE:
2311                 DPRINT("VECTOR:  XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2__STATE \n");
2312                 print_buf("ARC4 Key",
2313                     &desc->ctl_desc.cipherHashInfo.infoARC4StateHMAC2.cipherKey0,
2314                     GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2315                 print_buf("HMAC2 Key",
2316                     &desc->ctl_desc.cipherHashInfo.infoARC4StateHMAC2.hmacKey0,
2317                     sizeof(HMAC2_t));
2318                 break;
2319         case XLR_SEC_VECTOR_HMAC2:
2320                 DPRINT("VECTOR:  XLR_SEC_VECTOR_HMAC2 \n");
2321                 print_buf("HMAC2 Key",
2322                     &desc->ctl_desc.cipherHashInfo.infoHMAC2.hmacKey0,
2323                     sizeof(HMAC2_t));
2324                 break;
2325         case XLR_SEC_VECTOR__CIPHER_DES__HMAC2__MODE_ECB_CBC:
2326                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_DES__HMAC2__MODE_ECB_CBC \n");
2327                 print_buf("CIPHER Key",
2328                     &desc->ctl_desc.cipherHashInfo.infoDESHMAC2.cipherKey0,
2329                     XLR_SEC_DES_KEY_LENGTH);
2330                 print_buf("HMAC2 Key",
2331                     &desc->ctl_desc.cipherHashInfo.infoDESHMAC2.hmacKey0,
2332                     sizeof(HMAC2_t));
2333                 break;
2334         case XLR_SEC_VECTOR__CIPHER_3DES__HMAC2__MODE_ECB_CBC:
2335                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_3DES__HMAC2__MODE_ECB_CBC \n");
2336                 print_buf("CIPHER Key",
2337                     &desc->ctl_desc.cipherHashInfo.info3DESHMAC2.cipherKey0,
2338                     XLR_SEC_3DES_KEY_LENGTH);
2339                 print_buf("HMAC2 Key",
2340                     &desc->ctl_desc.cipherHashInfo.info3DESHMAC2.hmacKey0,
2341                     sizeof(HMAC2_t));
2342                 break;
2343         case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_CTR_CFB:
2344                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_CTR_CFB \n");
2345                 print_buf("CIPHER Key",
2346                     &desc->ctl_desc.cipherHashInfo.infoAES128HMAC2.cipherKey0,
2347                     XLR_SEC_AES128_KEY_LENGTH);
2348                 print_buf("HMAC2 Key",
2349                     &desc->ctl_desc.cipherHashInfo.infoAES128HMAC2.hmacKey0,
2350                     sizeof(HMAC2_t));
2351                 break;
2352         case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_ECB_CBC_OFB:
2353                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_ECB_CBC_OFB\n");
2354                 print_buf("CIPHER Key",
2355                     &desc->ctl_desc.cipherHashInfo.infoAES128HMAC2.cipherKey0,
2356                     XLR_SEC_AES128_KEY_LENGTH);
2357                 print_buf("HMAC2 Key",
2358                     &desc->ctl_desc.cipherHashInfo.infoAES128HMAC2.hmacKey0,
2359                     sizeof(HMAC2_t));
2360                 break;
2361         case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_CTR_CFB:
2362                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_CTR_CFB \n");
2363                 print_buf("CIPHER Key",
2364                     &desc->ctl_desc.cipherHashInfo.infoAES192HMAC2.cipherKey0,
2365                     XLR_SEC_AES192_KEY_LENGTH);
2366                 print_buf("HMAC2 Key",
2367                     &desc->ctl_desc.cipherHashInfo.infoAES192HMAC2.hmacKey0,
2368                     sizeof(HMAC2_t));
2369                 break;
2370         case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_ECB_CBC_OFB:
2371                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_ECB_CBC_OFB\n");
2372                 print_buf("CIPHER Key",
2373                     &desc->ctl_desc.cipherHashInfo.infoAES192HMAC2.cipherKey0,
2374                     XLR_SEC_AES192_KEY_LENGTH);
2375                 print_buf("HMAC2 Key",
2376                     &desc->ctl_desc.cipherHashInfo.infoAES192HMAC2.hmacKey0,
2377                     sizeof(HMAC2_t));
2378                 break;
2379         case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_CTR_CFB:
2380                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_CTR_CFB \n");
2381                 print_buf("CIPHER Key",
2382                     &desc->ctl_desc.cipherHashInfo.infoAES256HMAC2.cipherKey0,
2383                     XLR_SEC_AES256_KEY_LENGTH);
2384                 print_buf("HMAC2 Key",
2385                     &desc->ctl_desc.cipherHashInfo.infoAES256HMAC2.hmacKey0,
2386                     sizeof(HMAC2_t));
2387                 break;
2388
2389         case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_ECB_CBC_OFB:
2390                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_ECB_CBC_OFB \n");
2391                 print_buf("CIPHER Key",
2392                     &desc->ctl_desc.cipherHashInfo.infoAES256HMAC2.cipherKey0,
2393                     XLR_SEC_AES256_KEY_LENGTH);
2394                 print_buf("HMAC2 Key",
2395                     &desc->ctl_desc.cipherHashInfo.infoAES256HMAC2.hmacKey0,
2396                     sizeof(HMAC2_t));
2397                 break;
2398         case XLR_SEC_VECTOR_CIPHER_ARC4__GCM:
2399                 DPRINT("VECTOR:  XLR_SEC_VECTOR_CIPHER_ARC4__GCM \n");
2400                 print_buf("ARC4 Key",
2401                     &desc->ctl_desc.cipherHashInfo.infoARC4GCM.cipherKey0,
2402                     GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2403                 print_buf("GCM Key",
2404                     &desc->ctl_desc.cipherHashInfo.infoARC4GCM.GCMH0,
2405                     sizeof(GCM_t));
2406                 break;
2407         case XLR_SEC_VECTOR_CIPHER_ARC4__GCM__STATE:
2408                 DPRINT("VECTOR:  XLR_SEC_VECTOR_CIPHER_ARC4__GCM__STATE \n");
2409                 print_buf("ARC4 Key",
2410                     &desc->ctl_desc.cipherHashInfo.infoARC4StateGCM.cipherKey0,
2411                     GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2412                 print_buf("GCM Key",
2413                     &desc->ctl_desc.cipherHashInfo.infoARC4StateGCM.GCMH0,
2414                     sizeof(GCM_t));
2415                 break;
2416         case XLR_SEC_VECTOR_GCM:
2417                 DPRINT("VECTOR:  XLR_SEC_VECTOR_GCM \n");
2418                 print_buf("GCM Key",
2419                     &desc->ctl_desc.cipherHashInfo.infoGCM.GCMH0,
2420                     sizeof(GCM_t));
2421                 break;
2422         case XLR_SEC_VECTOR__CIPHER_DES__GCM__MODE_ECB_CBC:
2423                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_DES__GCM__MODE_ECB_CBC \n");
2424                 print_buf("CIPHER Key",
2425                     &desc->ctl_desc.cipherHashInfo.infoDESGCM.cipherKey0,
2426                     XLR_SEC_DES_KEY_LENGTH);
2427                 print_buf("GCM Key",
2428                     &desc->ctl_desc.cipherHashInfo.infoDESGCM.GCMH0,
2429                     sizeof(GCM_t));
2430                 break;
2431         case XLR_SEC_VECTOR__CIPHER_3DES__GCM__MODE_ECB_CBC:
2432                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_3DES__GCM__MODE_ECB_CBC \n");
2433                 print_buf("CIPHER Key",
2434                     &desc->ctl_desc.cipherHashInfo.info3DESGCM.cipherKey0,
2435                     XLR_SEC_3DES_KEY_LENGTH);
2436                 print_buf("GCM Key",
2437                     &desc->ctl_desc.cipherHashInfo.info3DESGCM.GCMH0,
2438                     sizeof(GCM_t));
2439                 break;
2440         case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_CTR_CFB:
2441                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_CTR_CFB \n");
2442                 print_buf("CIPHER Key",
2443                     &desc->ctl_desc.cipherHashInfo.infoAES128GCM.cipherKey0,
2444                     XLR_SEC_AES128_KEY_LENGTH);
2445                 print_buf("GCM Key",
2446                     &desc->ctl_desc.cipherHashInfo.infoAES128GCM.GCMH0,
2447                     XLR_SEC_AES128_KEY_LENGTH);
2448                 break;
2449         case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_ECB_CBC_OFB:
2450                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_ECB_CBC_OFB\n");
2451                 print_buf("CIPHER Key",
2452                     &desc->ctl_desc.cipherHashInfo.infoAES128GCM.cipherKey0,
2453                     XLR_SEC_AES128_KEY_LENGTH);
2454                 print_buf("GCM Key",
2455                     &desc->ctl_desc.cipherHashInfo.infoAES128GCM.GCMH0,
2456                     XLR_SEC_AES128_KEY_LENGTH);
2457                 break;
2458         case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_CTR_CFB:
2459                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_CTR_CFB \n");
2460                 print_buf("CIPHER Key",
2461                     &desc->ctl_desc.cipherHashInfo.infoAES192GCM.cipherKey0,
2462                     XLR_SEC_AES192_KEY_LENGTH);
2463                 print_buf("GCM Key",
2464                     &desc->ctl_desc.cipherHashInfo.infoAES192GCM.GCMH0,
2465                     XLR_SEC_AES192_KEY_LENGTH);
2466                 break;
2467         case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_ECB_CBC_OFB:
2468                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_ECB_CBC_OFB\n");
2469                 print_buf("CIPHER Key",
2470                     &desc->ctl_desc.cipherHashInfo.infoAES192GCM.cipherKey0,
2471                     XLR_SEC_AES192_KEY_LENGTH);
2472                 print_buf("GCM Key",
2473                     &desc->ctl_desc.cipherHashInfo.infoAES192GCM.GCMH0,
2474                     XLR_SEC_AES192_KEY_LENGTH);
2475                 break;
2476         case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_CTR_CFB:
2477                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_CTR_CFB \n");
2478                 print_buf("CIPHER Key",
2479                     &desc->ctl_desc.cipherHashInfo.infoAES256GCM.cipherKey0,
2480                     XLR_SEC_AES256_KEY_LENGTH);
2481                 print_buf("GCM Key",
2482                     &desc->ctl_desc.cipherHashInfo.infoAES256GCM.GCMH0,
2483                     XLR_SEC_AES256_KEY_LENGTH);
2484                 break;
2485         case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_ECB_CBC_OFB:
2486                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_ECB_CBC_OFB \n");
2487                 print_buf("CIPHER Key",
2488                     &desc->ctl_desc.cipherHashInfo.infoAES256GCM.cipherKey0,
2489                     XLR_SEC_AES256_KEY_LENGTH);
2490                 print_buf("GCM Key",
2491                     &desc->ctl_desc.cipherHashInfo.infoAES256GCM.GCMH0,
2492                     XLR_SEC_AES256_KEY_LENGTH);
2493                 break;
2494         case XLR_SEC_VECTOR_CIPHER_ARC4__F9:
2495                 DPRINT("VECTOR:  XLR_SEC_VECTOR_CIPHER_ARC4__F9 \n");
2496                 print_buf("ARC4 Key",
2497                     &desc->ctl_desc.cipherHashInfo.infoARC4F9.cipherKey0,
2498                     GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2499                 print_buf("F9 Key",
2500                     &desc->ctl_desc.cipherHashInfo.infoARC4F9.authKey0,
2501                     sizeof(F9_t));
2502                 break;
2503         case XLR_SEC_VECTOR_CIPHER_ARC4__F9__STATE:
2504                 DPRINT("VECTOR:  XLR_SEC_VECTOR_CIPHER_ARC4__F9__STATE \n");
2505                 print_buf("ARC4 Key",
2506                     &desc->ctl_desc.cipherHashInfo.infoARC4StateF9.cipherKey0,
2507                     GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2508                 print_buf("F9 Key",
2509                     &desc->ctl_desc.cipherHashInfo.infoARC4StateF9.authKey0,
2510                     sizeof(F9_t));
2511                 break;
2512         case XLR_SEC_VECTOR_F9:
2513                 DPRINT("VECTOR:  XLR_SEC_VECTOR_F9 \n");
2514                 print_buf("F9 Key",
2515                     &desc->ctl_desc.cipherHashInfo.infoF9.authKey0,
2516                     sizeof(F9_t));
2517                 break;
2518         case XLR_SEC_VECTOR__CIPHER_DES__F9__MODE_ECB_CBC:
2519                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_DES__F9__MODE_ECB_CBC \n");
2520                 print_buf("CIPHER Key",
2521                     &desc->ctl_desc.cipherHashInfo.infoDESF9.cipherKey0,
2522                     XLR_SEC_DES_KEY_LENGTH);
2523                 print_buf("F9 Key",
2524                     &desc->ctl_desc.cipherHashInfo.infoDESF9.authKey0,
2525                     sizeof(F9_t));
2526                 break;
2527         case XLR_SEC_VECTOR__CIPHER_3DES__F9__MODE_ECB_CBC:
2528                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_3DES__F9__MODE_ECB_CBC \n");
2529                 print_buf("CIPHER Key",
2530                     &desc->ctl_desc.cipherHashInfo.info3DESF9.cipherKey0,
2531                     XLR_SEC_3DES_KEY_LENGTH);
2532                 print_buf("F9 Key",
2533                     &desc->ctl_desc.cipherHashInfo.info3DESF9.authKey0,
2534                     sizeof(F9_t));
2535                 break;
2536         case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_CTR_CFB:
2537                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_CTR_CFB \n");
2538                 print_buf("CIPHER Key",
2539                     &desc->ctl_desc.cipherHashInfo.infoAES128F9.cipherKey0,
2540                     XLR_SEC_AES128_KEY_LENGTH);
2541                 print_buf("F9 Key",
2542                     &desc->ctl_desc.cipherHashInfo.infoAES128F9.authKey0,
2543                     sizeof(F9_t));
2544                 break;
2545         case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_ECB_CBC_OFB:
2546                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_ECB_CBC_OFB\n");
2547                 print_buf("CIPHER Key",
2548                     &desc->ctl_desc.cipherHashInfo.infoAES128F9.cipherKey0,
2549                     XLR_SEC_AES128_KEY_LENGTH);
2550                 print_buf("F9 Key",
2551                     &desc->ctl_desc.cipherHashInfo.infoAES128F9.authKey0,
2552                     sizeof(F9_t));
2553                 break;
2554         case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_CTR_CFB:
2555                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_CTR_CFB \n");
2556                 print_buf("CIPHER Key",
2557                     &desc->ctl_desc.cipherHashInfo.infoAES192F9.cipherKey0,
2558                     XLR_SEC_AES192_KEY_LENGTH);
2559                 print_buf("F9 Key",
2560                     &desc->ctl_desc.cipherHashInfo.infoAES192F9.authKey0,
2561                     sizeof(F9_t));
2562                 break;
2563         case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_ECB_CBC_OFB:
2564                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_ECB_CBC_OFB\n");
2565                 print_buf("CIPHER Key",
2566                     &desc->ctl_desc.cipherHashInfo.infoAES192F9.cipherKey0,
2567                     XLR_SEC_AES192_KEY_LENGTH);
2568                 print_buf("F9 Key",
2569                     &desc->ctl_desc.cipherHashInfo.infoAES192F9.authKey0,
2570                     sizeof(F9_t));
2571                 break;
2572         case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_CTR_CFB:
2573                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_CTR_CFB \n");
2574                 print_buf("CIPHER Key",
2575                     &desc->ctl_desc.cipherHashInfo.infoAES256F9.cipherKey0,
2576                     XLR_SEC_AES256_KEY_LENGTH);
2577                 print_buf("F9 Key",
2578                     &desc->ctl_desc.cipherHashInfo.infoAES256F9.authKey0,
2579                     sizeof(F9_t));
2580                 break;
2581         case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_ECB_CBC_OFB:
2582                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_ECB_CBC_OFB \n");
2583                 print_buf("CIPHER Key",
2584                     &desc->ctl_desc.cipherHashInfo.infoAES256F9.cipherKey0,
2585                     XLR_SEC_AES256_KEY_LENGTH);
2586                 print_buf("F9 Key",
2587                     &desc->ctl_desc.cipherHashInfo.infoAES256F9.authKey0,
2588                     sizeof(F9_t));
2589                 break;
2590         case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_F8:
2591                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_F8 \n");
2592                 print_buf("CIPHER Key",
2593                     &desc->ctl_desc.cipherHashInfo.infoAES128F8HMAC.cipherKey0,
2594                     XLR_SEC_AES128F8_KEY_LENGTH);
2595                 print_buf("HMAC Key",
2596                     &desc->ctl_desc.cipherHashInfo.infoAES128F8HMAC.hmacKey0,
2597                     sizeof(HMAC_t));
2598                 break;
2599         case XLR_SEC_VECTOR__CIPHER_AES128__MODE_F8:
2600                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES128__MODE_F8 \n");
2601                 print_buf("CIPHER Key",
2602                     &desc->ctl_desc.cipherHashInfo.infoAES128F8.cipherKey0,
2603                     XLR_SEC_AES128F8_KEY_LENGTH);
2604                 break;
2605         case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_F8:
2606                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_F8 \n");
2607                 print_buf("CIPHER Key",
2608                     &desc->ctl_desc.cipherHashInfo.infoAES192F8HMAC.cipherKey0,
2609                     XLR_SEC_AES192F8_KEY_LENGTH);
2610                 print_buf("HMAC Key",
2611                     &desc->ctl_desc.cipherHashInfo.infoAES192F8HMAC.hmacKey0,
2612                     sizeof(HMAC_t));
2613                 break;
2614         case XLR_SEC_VECTOR__CIPHER_AES192__MODE_F8:
2615                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES192__MODE_F8 \n");
2616                 print_buf("CIPHER Key",
2617                     &desc->ctl_desc.cipherHashInfo.infoAES192F8.cipherKey0,
2618                     XLR_SEC_AES192F8_KEY_LENGTH);
2619                 break;
2620         case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_F8:
2621                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_F8 \n");
2622                 print_buf("CIPHER Key",
2623                     &desc->ctl_desc.cipherHashInfo.infoAES256F8HMAC.cipherKey0,
2624                     XLR_SEC_AES256F8_KEY_LENGTH);
2625                 print_buf("HMAC Key",
2626                     &desc->ctl_desc.cipherHashInfo.infoAES256HMAC.hmacKey0,
2627                     sizeof(HMAC_t));
2628                 break;
2629         case XLR_SEC_VECTOR__CIPHER_AES256__MODE_F8:
2630                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES256__MODE_F8 \n");
2631                 print_buf("CIPHER Key",
2632                     &desc->ctl_desc.cipherHashInfo.infoAES256F8.cipherKey0,
2633                     XLR_SEC_AES256F8_KEY_LENGTH);
2634                 break;
2635         case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_F8:
2636                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_F8 \n");
2637                 print_buf("CIPHER Key",
2638                     &desc->ctl_desc.cipherHashInfo.infoAES128F8HMAC2.cipherKey0,
2639                     XLR_SEC_AES128F8_KEY_LENGTH);
2640                 print_buf("HMAC2 Key",
2641                     &desc->ctl_desc.cipherHashInfo.infoAES128F8HMAC2.hmacKey0,
2642                     sizeof(HMAC2_t));
2643                 break;
2644         case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_F8:
2645                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_F8 \n");
2646                 print_buf("CIPHER Key",
2647                     &desc->ctl_desc.cipherHashInfo.infoAES192F8HMAC2.cipherKey0,
2648                     XLR_SEC_AES192F8_KEY_LENGTH);
2649                 print_buf("HMAC2 Key",
2650                     &desc->ctl_desc.cipherHashInfo.infoAES192F8HMAC2.hmacKey0,
2651                     sizeof(HMAC2_t));
2652                 break;
2653         case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_F8:
2654                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_F8 \n");
2655                 print_buf("CIPHER Key",
2656                     &desc->ctl_desc.cipherHashInfo.infoAES256F8HMAC2.cipherKey0,
2657                     XLR_SEC_AES256F8_KEY_LENGTH);
2658                 print_buf("HMAC2 Key",
2659                     &desc->ctl_desc.cipherHashInfo.infoAES256F8HMAC2.hmacKey0,
2660                     sizeof(HMAC2_t));
2661                 break;
2662         case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_F8:
2663                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_F8 \n");
2664                 print_buf("CIPHER Key",
2665                     &desc->ctl_desc.cipherHashInfo.infoAES128F8GCM.cipherKey0,
2666                     XLR_SEC_AES128F8_KEY_LENGTH);
2667                 print_buf("GCM Key",
2668                     &desc->ctl_desc.cipherHashInfo.infoAES128GCM.GCMH0,
2669                     XLR_SEC_AES128_KEY_LENGTH);
2670                 break;
2671         case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_F8:
2672                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_F8 \n");
2673                 print_buf("CIPHER Key",
2674                     &desc->ctl_desc.cipherHashInfo.infoAES192F8GCM.cipherKey0,
2675                     XLR_SEC_AES192_KEY_LENGTH);
2676                 print_buf("GCM Key",
2677                     &desc->ctl_desc.cipherHashInfo.infoAES192F8GCM.GCMH0,
2678                     XLR_SEC_AES192_KEY_LENGTH);
2679                 break;
2680         case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_F8:
2681                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_F8 \n");
2682                 print_buf("CIPHER Key",
2683                     &desc->ctl_desc.cipherHashInfo.infoAES256F8GCM.cipherKey0,
2684                     XLR_SEC_AES256F8_KEY_LENGTH);
2685                 print_buf("GCM Key",
2686                     &desc->ctl_desc.cipherHashInfo.infoAES256F8GCM.GCMH0,
2687                     XLR_SEC_AES256_KEY_LENGTH);
2688                 break;
2689         case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_F8:
2690                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_F8 \n");
2691                 print_buf("CIPHER Key",
2692                     &desc->ctl_desc.cipherHashInfo.infoAES128F8F9.cipherKey0,
2693                     XLR_SEC_AES128F8_KEY_LENGTH);
2694                 print_buf("F9 Key",
2695                     &desc->ctl_desc.cipherHashInfo.infoAES128F8F9.authKey0,
2696                     sizeof(F9_t));
2697                 break;
2698         case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_F8:
2699                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_F8 \n");
2700                 print_buf("CIPHER Key",
2701                     &desc->ctl_desc.cipherHashInfo.infoAES192F8F9.cipherKey0,
2702                     XLR_SEC_AES192F8_KEY_LENGTH);
2703                 print_buf("F9 Key",
2704                     &desc->ctl_desc.cipherHashInfo.infoAES192F8F9.authKey0,
2705                     sizeof(F9_t));
2706                 break;
2707         case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_F8:
2708                 DPRINT("VECTOR:  XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_F8 \n");
2709                 print_buf("CIPHER Key",
2710                     &desc->ctl_desc.cipherHashInfo.infoAES256F8F9.cipherKey0,
2711                     XLR_SEC_AES256F8_KEY_LENGTH);
2712                 print_buf("F9 Key",
2713                     &desc->ctl_desc.cipherHashInfo.infoAES256F8F9.authKey0,
2714                     sizeof(F9_t));
2715                 break;
2716
2717         default:
2718                 DPRINT("VECTOR:  ???? \n");
2719                 DPRINT(">>>  WHAT THE HECK !!!  <<< \n");
2720                 break;
2721         }
2722         DPRINT("PACKET DESCRIPTOR: \n");
2723         word = 0; //desc->pkt_desc.srcLengthIVOffUseIVNext;
2724         DPRINT("\tSrcLengthIVOffsetIVNext:   %llx\n", word);
2725         DPRINT("\t\tLoad HMAC         = %lld \n",
2726             GET_FIELD(word, PKT_DSC_LOADHMACKEY));
2727         DPRINT("\t\tPad Hash          = %lld \n",
2728             GET_FIELD(word, PKT_DSC_PADHASH));
2729         DPRINT("\t\tHash Byte Count   = %lld \n",
2730             GET_FIELD(word, PKT_DSC_HASHBYTES));
2731         DPRINT("\t\tNext              = %lld \n",
2732             GET_FIELD(word, PKT_DSC_NEXT));
2733         DPRINT("\t\tUse IV            = %lld \n",
2734             GET_FIELD(word, PKT_DSC_IV));
2735         DPRINT("\t\tIV Offset         = %lld \n",
2736             GET_FIELD(word, PKT_DSC_IVOFF));
2737         DPRINT("\t\tPacket Length     = %lld \n",
2738             GET_FIELD(word, PKT_DSC_PKTLEN));
2739         DPRINT("\t\tNLHMAC            = %lld \n", GET_FIELD(word, PKT_DSC_NLHMAC));
2740         DPRINT("\t\tBreak             = %lld \n", GET_FIELD(word, PKT_DSC_BREAK));
2741         DPRINT("\t\tWait              = %lld \n", GET_FIELD(word, PKT_DSC_WAIT));
2742         DPRINT("\t\tSegment Src Addr  = %llx \n",
2743             (GET_FIELD(word, PKT_DSC_SEGADDR) << 5) & 0xffffffffffULL);
2744         DPRINT("\t\tSRTCP             = %lld \n", GET_FIELD(word, PKT_DSC_SRTCP));
2745         DPRINT("\t\tGlobal Src Offset = %lld \n",
2746             GET_FIELD(word, PKT_DSC_SEGOFFSET));
2747
2748         word = 0; //desc->pkt_desc.dstDataSettings;
2749         DPRINT("\tdstDataSettings:  %llx \n", word);
2750         DPRINT("\t\tArc4 Byte Count   = %lld \n", GET_FIELD(word,
2751             PKT_DSC_ARC4BYTECOUNT));
2752         DPRINT("\t\tSym Operation     = %lld \n", GET_FIELD(word, PKT_DSC_SYM_OP));
2753         DPRINT("\t\tCipher Offset     = %lld \n", GET_FIELD(word, PKT_DSC_CPHROFF));
2754         DPRINT("\t\tHash Offset       = %lld \n", GET_FIELD(word, PKT_DSC_HASHOFF));
2755         DPRINT("\t\tHash Source       = %lld \n", GET_FIELD(word, PKT_DSC_HASHSRC));
2756         DPRINT("\t\tChecksum Offset   = %lld \n", GET_FIELD(word,
2757             PKT_DSC_CKSUMOFF));
2758         DPRINT("\t\tChecksum Source   = %lld \n", GET_FIELD(word,
2759             PKT_DSC_CKSUMSRC));
2760         DPRINT("\t\tCipher Dest Addr  = %llx \n", GET_FIELD(word,
2761             PKT_DSC_CPHR_DST_ADDR));
2762         DPRINT("\t\tCipher Dest Dword = %lld \n", GET_FIELD(word,
2763             PKT_DSC_CPHR_DST_DWOFFSET));
2764         DPRINT("\t\tCipher Dest Offset= %lld \n", GET_FIELD(word,
2765             PKT_DSC_CPHR_DST_OFFSET));
2766         word = 0; //desc->pkt_desc.authDstNonceLow;
2767         DPRINT("\tauthDstNonceLow:  %llx \n", word);
2768         DPRINT("\t\tNonce Low 24      = %lld \n", GET_FIELD(word,
2769             PKT_DSC_NONCE_LOW));
2770         DPRINT("\t\tauthDst           = %llx \n", GET_FIELD(word,
2771             PKT_DSC_AUTH_DST_ADDR));
2772         DPRINT("\t\tCipher Offset High= %lld \n", GET_FIELD(word,
2773             PKT_DSC_CIPH_OFF_HI));
2774         word = 0; //desc->pkt_desc.ckSumDstNonceHiCFBMaskLLWMask;
2775         DPRINT("\tckSumDstNonceHiCFBMaskLLWMask:  %llx \n", word);
2776         DPRINT("\t\tHash Byte off     = %lld \n", GET_FIELD(word, PKT_DSC_HASH_BYTE_OFF));
2777         DPRINT("\t\tPacket Len bytes  = %lld \n", GET_FIELD(word, PKT_DSC_PKTLEN_BYTES));
2778         DPRINT("\t\tLast Long Word Mask = %lld \n", GET_FIELD(word,
2779             PKT_DSC_LASTWORD));
2780         DPRINT("\t\tCipher Dst Address  = %llx \n", GET_FIELD(word,
2781             PKT_DSC_CPHR_DST_ADDR));
2782         DPRINT("\t\tGlobal Dst Offset  = %lld \n", GET_FIELD(word,
2783             PKT_DSC_CPHR_DST_OFFSET));
2784
2785         DPRINT("CFG_VECTOR = %04x\n", cfg_vector);
2786         DPRINT("\n\n");
2787 }
2788
2789 #endif
2790
2791
2792
2793 /* This function is called from an interrupt handler */
2794 void
2795 xlr_sec_msgring_handler(int bucket, int size, int code, int stid,
2796     struct msgrng_msg *msg, void *data)
2797 {
2798         uint64_t error;
2799         uint64_t addr, sec_eng, sec_pipe;
2800         xlr_sec_io_pt op = NULL;
2801         symkey_desc_pt desc = NULL;
2802         struct xlr_sec_session *ses = NULL;
2803         struct xlr_sec_command *cmd = NULL;
2804         uint32_t flags;
2805
2806         if (code != MSGRNG_CODE_SEC) {
2807                 panic("xlr_sec_msgring_handler: bad code = %d,"
2808                     " expected code = %d\n",
2809                     code, MSGRNG_CODE_SEC);
2810         }
2811         if ((stid < MSGRNG_STNID_SEC0) || (stid > MSGRNG_STNID_PK0)) {
2812                 panic("xlr_sec_msgring_handler: bad stn id = %d, expect %d - %d\n",
2813                     stid, MSGRNG_STNID_SEC0, MSGRNG_STNID_PK0);
2814         }
2815         /*
2816          * The Submit() operation encodes the engine and pipe in these two
2817          * separate fields.  This allows use to verify the result type with
2818          * the submitted operation type.
2819          */
2820         sec_eng = GET_FIELD(msg->msg0, MSG_CTL_OP_TYPE);
2821         sec_pipe = GET_FIELD(msg->msg1, MSG_CTL_OP_TYPE);
2822
2823         error = msg->msg0 >> 40 & 0x1ff;
2824         if (error)
2825                 printf("ctrl error = 0x%llx\n", error);
2826         error = msg->msg1 >> 40 & 0x1ff;
2827         if (error)
2828                 printf("data error = 0x%llx\n", error);
2829
2830
2831         XLR_SEC_CMD_DIAG("[%s]:  eng=%lld  pipe=%lld\n",
2832             __FUNCTION__, sec_eng, sec_pipe);
2833
2834         /* Symmetric Key Operation ? */
2835         if (sec_eng == MSG0_CTL_OP_ENGINE_SYMKEY) {
2836
2837                 /*
2838                  * The data descriptor address allows us to associate the
2839                  * response with the submitted operation. Address is 40-bit
2840                  * cacheline aligned address. We need to zero bit 0-4 since
2841                  * they are used for the engine and pipe Id.
2842                  */
2843                 addr = GET_FIELD(msg->msg1, MSG_RSLT_DATA_DSC_ADDR);
2844                 addr = addr & ~((1 << 5) - 1);
2845                 if (!addr) {
2846                         panic("[%s:STNID_SEC]:  NULL symkey addr!\n", __FUNCTION__);
2847                 }
2848
2849                 /*
2850                  * The adddress points to the data descriptor. The operation
2851                  * descriptor is defined with the 32-byte cacheline size in
2852                  * mind.  It allows the code to use this address to
2853                  * reference the symkey descriptor.   (ref:  xlr_sec_desc.h)
2854                  */
2855                 addr = addr - sizeof(OperationDescriptor_t);
2856                 flags = xlr_enable_kx();
2857                 desc = (symkey_desc_pt)(uintptr_t)xlr_paddr_ld(addr +
2858                     offsetof(OperationDescriptor_t, vaddr));
2859                 xlr_restore_kx(flags);
2860
2861                 if (!desc) {
2862                         printf("\nerror : not getting desc back correctly \n");
2863                         panic("[%s:STNID_SEC]:  NULL symkey data descriptor!\n", __FUNCTION__);
2864                 }
2865                 ses = (struct xlr_sec_session *)desc->ses;
2866                 if (!ses) {
2867                         printf("\n error : not getting ses back correctly \n");
2868                         panic("[%s:STNID_SEC]:  NULL symkey data descriptor!\n", __FUNCTION__);
2869                 }
2870                 cmd = &ses->cmd;
2871                 if (!cmd) {
2872                         printf("\n error : not getting cmd back correctly \n");
2873                         panic("[%s:STNID_SEC]:  NULL symkey data descriptor!\n", __FUNCTION__);
2874                 }
2875                 op = &cmd->op;
2876                 if (!op) {
2877                         printf("\n error : not getting op back correctly \n");
2878                         panic("[%s:STNID_SEC]:  NULL symkey data descriptor!\n", __FUNCTION__);
2879                 }
2880                 XLR_SEC_CMD_DIAG("[%s:STNID_SEC]:  addr=0x%llx  desc=%p  alloc=%p \n",
2881                     __FUNCTION__, addr, desc, desc->alloc);
2882
2883                 XLR_SEC_CMD_DIAG("[%s:STNID_SEC]:  op_ctl=%p  phys_self=%llx  stn_id=%d \n",
2884                     __FUNCTION__, &desc->op_ctl, desc->op_ctl.phys_self,
2885                     desc->op_ctl.stn_id);
2886
2887                 if (addr != desc->op_ctl.phys_self) {
2888                         XLR_SEC_CMD_DIAG("[%s:STNID_SEC]:  Control Descriptor fails Self-Verify !\n",
2889                             __FUNCTION__);
2890                         printf("[%s:STNID_SEC]:  Control Descriptor fails Self-Verify !\n",
2891                             __FUNCTION__);
2892                         printf("[%s:STNID_SEC]:  addr=0x%llx  desc=%p  alloc=%p \n",
2893                             __FUNCTION__, (unsigned long long)addr, desc, desc->alloc);
2894                         printf("[%s:STNID_SEC]:  op_ctl=%p  phys_self=%llx  stn_id=%d \n",
2895                             __FUNCTION__, &desc->op_ctl, (unsigned long long)desc->op_ctl.phys_self,
2896                             desc->op_ctl.stn_id);
2897
2898                 }
2899                 if (desc->op_ctl.stn_id != MSGRNG_STNID_SEC0 &&
2900                     desc->op_ctl.stn_id != MSGRNG_STNID_SEC1) {
2901                         XLR_SEC_CMD_DIAG("[%s:STNID_SEC]:  Operation Type Mismatch !\n",
2902                             __FUNCTION__);
2903                         printf("[%s:STNID_SEC]:  Operation Type Mismatch !\n",
2904                             __FUNCTION__);
2905                         printf("[%s:STNID_SEC]:  addr=0x%llx  desc=%p  alloc=%p \n",
2906                             __FUNCTION__, (unsigned long long)addr, desc, desc->alloc);
2907                         printf("[%s:STNID_SEC]:  op_ctl=%p  phys_self=%llx  stn_id=%d \n",
2908                             __FUNCTION__, &desc->op_ctl, (unsigned long long)desc->op_ctl.phys_self,
2909                             desc->op_ctl.stn_id);
2910                 }
2911                 desc->ctl_result = GET_FIELD(msg->msg0, MSG_RSLT_CTL_INST_ERR);
2912                 desc->data_result = GET_FIELD(msg->msg1, MSG_RSLT_DATA_INST_ERR);
2913
2914                 XLR_SEC_CMD_DIAG("[%s:STNID_SEC]:  cpu=%d  ctl_result=0x%llx  data_result=%llx\n",
2915                     __FUNCTION__, desc->op_ctl.cpu,
2916                     desc->ctl_result, desc->data_result);
2917
2918         }
2919 #if 0
2920         else if (sec_eng == MSG0_CTL_OP_ENGINE_PUBKEY) {
2921                 pubkey_desc_pt desc;
2922
2923                 if (sec_pipe != MSG1_CTL_OP_PUBKEY_PIPE0) {
2924                         /* response to uc load */
2925                         /*
2926                          * XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: ecc cpu=%d
2927                          * ctl_result=0x%llx  data_result=%llx\n",
2928                          * __FUNCTION__, desc->op_ctl.cpu, desc->ctl_result,
2929                          * desc->data_result);
2930                          */
2931                         return;
2932                 }
2933                 /*
2934                  * The data descriptor address allows us to associate the
2935                  * response with the submitted operation. Address is 40-bit
2936                  * cacheline aligned address. We need to zero bit 0-4 since
2937                  * they are used for the engine and pipe Id.
2938                  */
2939                 addr = GET_FIELD(msg->msg0, PUBKEY_RSLT_CTL_SRCADDR);
2940                 addr = addr & ~((1 << 5) - 1);
2941                 if (!addr) {
2942                         panic("[%s:STNID_SEC]:  NULL pubkey ctrl desc!\n", __FUNCTION__);
2943                 }
2944                 /*
2945                  * The adddress points to the data descriptor. The operation
2946                  * descriptor is defined with the 32-byte cacheline size in
2947                  * mind.  It allows the code to use this address to
2948                  * reference the symkey descriptor.   (ref:  xlr_sec_desc.h)
2949                  */
2950                 addr = addr - sizeof(OperationDescriptor_t);
2951
2952                 /* Get pointer to pubkey Descriptor */
2953                 desc = (pubkey_desc_pt) (unsigned long)addr;
2954                 if (!desc) {
2955                         panic("[%s:STNID_SEC]:  NULL pubkey data descriptor!\n", __FUNCTION__);
2956                 }
2957                 XLR_SEC_CMD_DIAG("[%s:STNID_PK0]:  addr=0x%llx  desc=%p  alloc=%p \n",
2958                     __FUNCTION__, addr, desc, desc->alloc);
2959
2960                 XLR_SEC_CMD_DIAG("[%s:STNID_PK0]:  op_ctl=%p  phys_self=%llx  stn_id=%d \n",
2961                     __FUNCTION__, &desc->op_ctl, desc->op_ctl.phys_self,
2962                     desc->op_ctl.stn_id);
2963
2964                 if (addr != desc->op_ctl.phys_self) {
2965                         XLR_SEC_CMD_DIAG("[%s:STNID_PK0]:  Control Descriptor fails Self-Verify !\n",
2966                             __FUNCTION__);
2967                 }
2968                 if (desc->op_ctl.stn_id != msgrng_stnid_pk0) {
2969                         XLR_SEC_CMD_DIAG("[%s:STNID_PK0]:  Operation Type Mismatch ! \n",
2970                             __FUNCTION__);
2971                 }
2972                 desc->ctl_result = GET_FIELD(msg->msg0, PUBKEY_RSLT_CTL_ERROR);
2973                 desc->data_result = GET_FIELD(msg->msg1, PUBKEY_RSLT_DATA_ERROR);
2974
2975                 XLR_SEC_CMD_DIAG("[%s:STNID_PK0]:  ctl_result=0x%llx  data_result=%llx\n",
2976                     __FUNCTION__, desc->ctl_result, desc->data_result);
2977
2978         }
2979 #endif
2980         else {
2981                 printf("[%s]: HANDLER  bad id = %d\n", __FUNCTION__, stid);
2982         }
2983 #ifdef RMI_SEC_DEBUG
2984         if (ses->multi_frag_flag) {
2985                 int i;
2986                 char *ptr;
2987
2988                 printf("\n RETURNED DATA:  \n");
2989
2990                 ptr = (char *)(unsigned long)(desc->user.aligned_dest + cmd->op.cipher_offset);
2991                 for (i = 0; i < SEC_MAX_FRAG_LEN; i++) {
2992                         printf("%c  ", (char)*ptr++);
2993                         if ((i % 10) == 0)
2994                                 printf("\n");
2995                 }
2996
2997                 printf("second desc\n");
2998                 ptr = (char *)(unsigned long)(desc->next_dest_buf);
2999                 for (i = 0; i < desc->next_src_len; i++) {
3000                         printf("%c  ", (char)*ptr++);
3001                         if ((i % 10) == 0)
3002                                 printf("\n");
3003                 }
3004         }
3005 #endif
3006
3007         /* Copy cipher-data to User-space */
3008         if (op->cipher_type != XLR_SEC_CIPHER_TYPE_NONE) {
3009                 size = op->dest_buf_size;
3010
3011                 /* DEBUG -dpk */
3012                 XLR_SEC_CMD_DIAG("cipher: to_addr=%p  from_addr=%p  size=%d \n",
3013                     desc->user.user_dest, desc->user.aligned_dest, size);
3014
3015                 if (ses->multi_frag_flag) {
3016                         crypto_copyback(cmd->crp->crp_flags, cmd->crp->crp_buf, 0,
3017                             SEC_MAX_FRAG_LEN, (caddr_t)(long)desc->user.aligned_dest + op->cipher_offset);
3018                         crypto_copyback(cmd->crp->crp_flags, cmd->crp->crp_buf + SEC_MAX_FRAG_LEN, 0,
3019                             desc->next_src_len, (caddr_t)(long)desc->next_dest_buf);
3020                         crypto_done(cmd->crp);
3021                 } else {
3022                         crypto_copyback(cmd->crp->crp_flags, cmd->crp->crp_buf, 0,
3023                             cmd->op.dest_buf_size, (caddr_t)(long)desc->user.aligned_dest + op->cipher_offset);
3024                         crypto_done(cmd->crp);
3025                 }
3026
3027         }
3028
3029         /* Copy digest to User-space */
3030         if (op->digest_type != XLR_SEC_DIGEST_TYPE_NONE) {
3031                 int offset = 0;
3032
3033                 switch (op->digest_type) {
3034                 case XLR_SEC_DIGEST_TYPE_MD5:
3035                         size = XLR_SEC_MD5_LENGTH;
3036                         break;
3037                 case XLR_SEC_DIGEST_TYPE_SHA1:
3038                         size = XLR_SEC_SHA1_LENGTH;
3039                         break;
3040                 case XLR_SEC_DIGEST_TYPE_SHA256:
3041                         size = XLR_SEC_SHA256_LENGTH;
3042                         break;
3043                 case XLR_SEC_DIGEST_TYPE_SHA384:
3044                         size = XLR_SEC_SHA384_LENGTH;
3045                         break;
3046                 case XLR_SEC_DIGEST_TYPE_SHA512:
3047                         size = XLR_SEC_SHA512_LENGTH;
3048                         break;
3049                 case XLR_SEC_DIGEST_TYPE_GCM:
3050                         size = XLR_SEC_GCM_LENGTH;
3051                         break;
3052                 case XLR_SEC_DIGEST_TYPE_KASUMI_F9:
3053                         offset = 4;
3054                         size = XLR_SEC_KASUMI_F9_RESULT_LENGTH;
3055                         break;
3056                 default:
3057                         size = 0;
3058                 }
3059
3060                 XLR_SEC_CMD_DIAG("digest:  to_addr=%p  from_addr=%p  size=%d \n",
3061                     desc->user.user_auth, desc->user.aligned_auth, size);
3062                 memcpy(desc->user.user_auth, desc->user.aligned_auth + offset, size);
3063                 op->auth_dest = (uint64_t) (unsigned long)desc->user.user_auth;
3064         }
3065         if (op->cipher_type == XLR_SEC_CIPHER_TYPE_ARC4 &&
3066             op->rc4_savestate) {
3067                 size = XLR_SEC_MAX_RC4_STATE_SIZE;
3068
3069                 XLR_SEC_CMD_DIAG("state:  to_addr=%p  from_addr=%p  size=%d \n",
3070                     desc->user.user_state, desc->user.aligned_state, size);
3071                 op->rc4_state = (uint64_t) (unsigned long)desc->user.user_state;
3072         }
3073         return;
3074 }