1198157Srrs/*- 2198157Srrs * Copyright (c) 2003-2009 RMI Corporation 3198157Srrs * All rights reserved. 4198157Srrs * 5198157Srrs * Redistribution and use in source and binary forms, with or without 6198157Srrs * modification, are permitted provided that the following conditions 7198157Srrs * are met: 8198157Srrs * 1. Redistributions of source code must retain the above copyright 9198157Srrs * notice, this list of conditions and the following disclaimer. 10198157Srrs * 2. Redistributions in binary form must reproduce the above copyright 11198157Srrs * notice, this list of conditions and the following disclaimer in the 12198157Srrs * documentation and/or other materials provided with the distribution. 13198157Srrs * 3. Neither the name of RMI Corporation, nor the names of its contributors, 14198157Srrs * may be used to endorse or promote products derived from this software 15198157Srrs * without specific prior written permission. 16198157Srrs * 17198157Srrs * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18198157Srrs * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19198157Srrs * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20198157Srrs * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21198157Srrs * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22198157Srrs * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23198157Srrs * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24198157Srrs * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25198157Srrs * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26198157Srrs * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27198157Srrs * SUCH DAMAGE. 28198157Srrs * 29202066Simp * RMI_BSD 30202066Simp */ 31198157Srrs 32198157Srrs#include <sys/cdefs.h> 33202066Simp__FBSDID("$FreeBSD$"); 34198157Srrs 35198157Srrs#include <sys/param.h> 36198157Srrs#include <sys/types.h> 37198157Srrs#include <sys/systm.h> 38198157Srrs#include <sys/kernel.h> 39198157Srrs#include <sys/module.h> 40198157Srrs#include <sys/malloc.h> 41198157Srrs#include <sys/bus.h> 42198157Srrs#include <machine/bus.h> 43198157Srrs#include <machine/md_var.h> 44198157Srrs#include <machine/cpuregs.h> 45198157Srrs 46198157Srrs#include <vm/vm.h> 47198157Srrs#include <vm/pmap.h> 48198157Srrs 49198157Srrs#include <opencrypto/cryptodev.h> 50198157Srrs 51212763Sjchandra#include <mips/rmi/rmi_mips_exts.h> 52212763Sjchandra#include <mips/rmi/iomap.h> 53212763Sjchandra#include <mips/rmi/pic.h> 54212763Sjchandra#include <mips/rmi/rmi_boot_info.h> 55212763Sjchandra#include <mips/rmi/msgring.h> 56212763Sjchandra#include <mips/rmi/board.h> 57202066Simp#include <mips/rmi/dev/sec/rmilib.h> 58202066Simp#include <mips/rmi/dev/sec/desc.h> 59198157Srrs 60198157Srrs 61212763Sjchandra/* static int msgrng_stnid_pk0 = MSGRNG_STNID_PK0; */ 62198627Srrs 63212763Sjchandra/* #define RMI_SEC_DEBUG */ 64198157Srrs 65198157Srrs#define SMP_CACHE_BYTES XLR_CACHELINE_SIZE 66198157Srrs#define NUM_CHUNKS(size, bits) ( ((size)>>(bits)) + (((size)&((1<<(bits))-1))?1:0) ) 67198157Srrs 68198157Srrsstatic const char nib2hex[] = "0123456789ABCDEF"; 69198627Srrssymkey_desc_pt g_desc; 70198627Srrsstruct xlr_sec_command *g_cmd; 71198157Srrs 72198157Srrs#ifdef XLR_SEC_CMD_DEBUG 73212763Sjchandrastatic void decode_symkey_desc(symkey_desc_pt desc, uint32_t cfg_vector); 74198157Srrs#endif 75198157Srrs 76212763Sjchandrastatic int xlr_sec_cipher_hash_command(xlr_sec_io_pt op, symkey_desc_pt desc, 77212763Sjchandra uint8_t); 78212763Sjchandrastatic xlr_sec_error_t xlr_sec_setup_descriptor(xlr_sec_io_pt op, 79212763Sjchandra unsigned int flags, symkey_desc_pt desc, uint32_t * cfg_vector); 80198157Srrs 81212763Sjchandrastatic xlr_sec_error_t xlr_sec_setup_packet(xlr_sec_io_pt op, 82212763Sjchandra symkey_desc_pt desc, unsigned int flags, uint64_t * data, 83212763Sjchandra PacketDescriptor_pt pkt_desc, ControlDescriptor_pt ctl_desc, 84212763Sjchandra uint32_t vector, PacketDescriptor_pt next_pkt_desc, 85198627Srrs uint8_t multi_frag_flag); 86212763Sjchandrastatic int xlr_sec_submit_message(symkey_desc_pt desc, uint32_t cfg_vector); 87212763Sjchandrastatic xlr_sec_error_t xlr_sec_setup_cipher(xlr_sec_io_pt op, 88212763Sjchandra ControlDescriptor_pt ctl_desc, uint32_t * vector); 89212763Sjchandrastatic xlr_sec_error_t xlr_sec_setup_digest(xlr_sec_io_pt op, 90212763Sjchandra ControlDescriptor_pt ctl_desc, uint32_t * vector); 91212763Sjchandrastatic xlr_sec_error_t xlr_sec_setup_cksum(xlr_sec_io_pt op, 92198627Srrs ControlDescriptor_pt ctl_desc); 93212763Sjchandrastatic xlr_sec_error_t xlr_sec_control_setup(xlr_sec_io_pt op, 94212763Sjchandra unsigned int flags, uint64_t * control, ControlDescriptor_pt ctl_desc, 95212763Sjchandra xlr_sec_drv_user_t * user, uint32_t vector); 96212763Sjchandrastatic void xlr_sec_free_desc(symkey_desc_pt desc); 97198157Srrs 98212763Sjchandravoid print_buf(char *desc, void *data, int len); 99212763Sjchandraxlr_sec_error_t xlr_sec_submit_op(symkey_desc_pt desc); 100212763Sjchandravoid xlr_sec_msgring_handler(int bucket, int size, int code, int stid, 101198627Srrs struct msgrng_msg *msg, void *data); 102198157Srrs 103198627Srrsvoid 104198627Srrsxlr_sec_init(struct xlr_sec_softc *sc) 105198157Srrs{ 106198627Srrs unsigned int i; 107198627Srrs xlr_reg_t *mmio; 108198157Srrs 109198627Srrs mmio = sc->mmio = xlr_io_mmio(XLR_IO_SECURITY_OFFSET); 110198627Srrs xlr_write_reg(mmio, SEC_DMA_CREDIT, SEC_DMA_CREDIT_CONFIG); 111198627Srrs xlr_write_reg(mmio, SEC_CONFIG2, SEC_CFG2_ROUND_ROBIN_ON); 112198157Srrs 113198627Srrs for (i = 0; i < 8; i++) 114198627Srrs xlr_write_reg(mmio, 115198627Srrs SEC_MSG_BUCKET0_SIZE + i, 116198627Srrs xlr_is_xls() ? 117198627Srrs xls_bucket_sizes.bucket[MSGRNG_STNID_SEC + i] : 118198627Srrs bucket_sizes.bucket[MSGRNG_STNID_SEC + i]); 119198157Srrs 120198627Srrs for (i = 0; i < 128; i++) 121198627Srrs xlr_write_reg(mmio, 122198627Srrs SEC_CC_CPU0_0 + i, 123198627Srrs xlr_is_xls() ? 124198627Srrs xls_cc_table_sec.counters[i >> 3][i & 0x07] : 125198627Srrs cc_table_sec.counters[i >> 3][i & 0x07]); 126198157Srrs 127198627Srrs /* 128198627Srrs * Register a bucket handler with the phoenix messaging subsystem 129198627Srrs * For now, register handler for bucket 0->5 in msg stn 0 130198627Srrs */ 131198627Srrs if (register_msgring_handler(TX_STN_SAE, xlr_sec_msgring_handler, NULL)) { 132198627Srrs panic("Couldn't register msgring handler 0\n"); 133198627Srrs } 134198627Srrs return; 135198157Srrs} 136198157Srrs 137198627Srrsint 138198627Srrsxlr_sec_setup(struct xlr_sec_session *ses, 139198627Srrs struct xlr_sec_command *cmd, 140212763Sjchandra symkey_desc_pt desc) 141198157Srrs{ 142198627Srrs xlr_sec_io_pt op; 143198627Srrs int size, ret_val; 144198627Srrs int iv_len; 145198157Srrs 146198627Srrs desc->ses = ses; 147198627Srrs op = &cmd->op; 148198627Srrs if (op == NULL) 149198627Srrs return (-ENOMEM); 150198157Srrs 151198627Srrs desc->ctl_desc.instruction = 0; 152198627Srrs memset(&desc->ctl_desc.cipherHashInfo, 0, sizeof(CipherHashInfo_t)); 153198627Srrs desc->control = 0; 154198627Srrs desc->pkt_desc[0].srcLengthIVOffUseIVNext = 0; 155198627Srrs desc->pkt_desc[0].dstDataSettings = 0; 156198627Srrs desc->pkt_desc[0].authDstNonceLow = 0; 157198627Srrs desc->pkt_desc[0].ckSumDstNonceHiCFBMaskLLWMask = 0; 158198627Srrs desc->pkt_desc[1].srcLengthIVOffUseIVNext = 0; 159198627Srrs desc->pkt_desc[1].dstDataSettings = 0; 160198627Srrs desc->pkt_desc[1].authDstNonceLow = 0; 161198627Srrs desc->pkt_desc[1].ckSumDstNonceHiCFBMaskLLWMask = 0; 162198627Srrs desc->data = 0; 163198627Srrs desc->ctl_result = 0; 164198627Srrs desc->data_result = 0; 165198157Srrs 166198627Srrs if (op->flags & XLR_SEC_FLAGS_HIGH_PRIORITY) 167198627Srrs if (!xlr_is_xls()) 168198627Srrs desc->op_ctl.stn_id++; 169198157Srrs 170198627Srrs desc->user.user_src = (uint8_t *) (unsigned long)op->source_buf; 171198627Srrs desc->user.user_dest = (uint8_t *) (unsigned long)op->dest_buf; 172198627Srrs desc->user.user_auth = (uint8_t *) (unsigned long)op->auth_dest; 173198157Srrs 174198627Srrs if ((op->cipher_type == XLR_SEC_CIPHER_TYPE_ARC4) && 175198627Srrs (!op->rc4_state && (op->rc4_loadstate || op->rc4_savestate))) { 176198627Srrs printf(" ** Load/Save State and no State **"); 177198627Srrs xlr_sec_free_desc(desc); 178198627Srrs return (-EINVAL); 179198627Srrs } 180198627Srrs desc->user.user_state = (uint8_t *) (unsigned long)op->rc4_state; 181198157Srrs 182198627Srrs switch (op->cipher_type) { 183198627Srrs case XLR_SEC_CIPHER_TYPE_NONE: 184198627Srrs iv_len = 0; 185198627Srrs break; 186198627Srrs case XLR_SEC_CIPHER_TYPE_DES: 187198627Srrs case XLR_SEC_CIPHER_TYPE_3DES: 188198627Srrs iv_len = XLR_SEC_DES_IV_LENGTH; 189198627Srrs break; 190198627Srrs case XLR_SEC_CIPHER_TYPE_AES128: 191198627Srrs case XLR_SEC_CIPHER_TYPE_AES192: 192198627Srrs case XLR_SEC_CIPHER_TYPE_AES256: 193198627Srrs iv_len = XLR_SEC_AES_IV_LENGTH; 194198627Srrs break; 195198627Srrs case XLR_SEC_CIPHER_TYPE_ARC4: 196198627Srrs iv_len = XLR_SEC_ARC4_IV_LENGTH; 197198627Srrs break; 198198627Srrs case XLR_SEC_CIPHER_TYPE_KASUMI_F8: 199198627Srrs iv_len = XLR_SEC_KASUMI_F8_IV_LENGTH; 200198627Srrs break; 201198157Srrs 202198627Srrs default: 203198627Srrs printf(" ** Undefined Cipher Type **"); 204198627Srrs xlr_sec_free_desc(desc); 205198627Srrs return (-EINVAL); 206198627Srrs } 207198627Srrs size = op->source_buf_size + iv_len; 208198157Srrs 209198627Srrs /* 210198627Srrs * make sure that there are enough bytes for aes based stream 211198627Srrs * ciphers 212198627Srrs */ 213198627Srrs if (op->cipher_mode == XLR_SEC_CIPHER_MODE_F8 || 214198627Srrs op->cipher_mode == XLR_SEC_CIPHER_MODE_CTR) 215198627Srrs size += XLR_SEC_AES_BLOCK_SIZE - 1; 216198157Srrs 217198627Srrs if (op->cipher_type == XLR_SEC_CIPHER_TYPE_NONE) { 218198627Srrs if (op->source_buf_size != 0) { 219212763Sjchandra memcpy(desc->user.aligned_src, 220212763Sjchandra (uint8_t *)(uintptr_t)op->source_buf, 221198627Srrs op->source_buf_size); 222198627Srrs } 223198627Srrs } else { 224198627Srrs if (ses->multi_frag_flag) { 225198627Srrs /* copy IV into temporary kernel source buffer */ 226198627Srrs memcpy(desc->user.aligned_src, &op->initial_vector[0], iv_len); 227198157Srrs 228198627Srrs /* copy input data to temporary kernel source buffer */ 229198627Srrs memcpy((uint8_t *) (desc->user.aligned_src + iv_len), 230198627Srrs (uint8_t *) (unsigned long)op->source_buf, SEC_MAX_FRAG_LEN); 231198157Srrs 232198627Srrs desc->next_src_len = op->source_buf_size - SEC_MAX_FRAG_LEN; 233198627Srrs memcpy((uint8_t *) (desc->next_src_buf), 234198627Srrs (uint8_t *) (unsigned long)(op->source_buf + SEC_MAX_FRAG_LEN), 235198627Srrs desc->next_src_len); 236198157Srrs 237198627Srrs op->source_buf_size = SEC_MAX_FRAG_LEN; 238198627Srrs op->source_buf_size += iv_len; 239198627Srrs } else { 240198627Srrs /* copy IV into temporary kernel source buffer */ 241198627Srrs memcpy(desc->user.aligned_src, &op->initial_vector[0], iv_len); 242198157Srrs 243198627Srrs /* copy input data to temporary kernel source buffer */ 244198627Srrs memcpy((uint8_t *) (desc->user.aligned_src + iv_len), 245198627Srrs (uint8_t *) (unsigned long)op->source_buf, op->source_buf_size); 246198627Srrs op->source_buf_size += iv_len; 247198627Srrs } 248198627Srrs } 249198157Srrs 250198627Srrs /* Set source to new kernel space */ 251198627Srrs op->source_buf = (uint64_t) (unsigned long)desc->user.aligned_src; 252198157Srrs 253198627Srrs /* 254198627Srrs * Build new dest buffer, for Cipher output only 255198627Srrs */ 256198627Srrs if (op->cipher_type == XLR_SEC_CIPHER_TYPE_NONE) { 257198627Srrs /* 258198627Srrs * Digest Engine *NEEDS* this, otherwise it will write at 259198627Srrs * 0[x] 260198627Srrs */ 261198627Srrs op->dest_buf = (uint64_t) (unsigned long)desc->user.aligned_src; 262198627Srrs } else { 263198627Srrs /* DEBUG -dpk */ 264198627Srrs XLR_SEC_CMD_DIAG("dest_buf_size = %d \n", op->dest_buf_size); 265198627Srrs size = op->dest_buf_size + iv_len; 266198157Srrs 267198627Srrs /* 268198627Srrs * make sure that there are enough bytes for aes based 269198627Srrs * stream ciphers 270198627Srrs */ 271198627Srrs if (op->cipher_mode == XLR_SEC_CIPHER_MODE_F8 || 272198627Srrs op->cipher_mode == XLR_SEC_CIPHER_MODE_CTR) 273198627Srrs size += XLR_SEC_AES_BLOCK_SIZE - 1; 274198627Srrs op->dest_buf = (uint64_t) (unsigned long)desc->user.aligned_dest; 275198627Srrs } 276198157Srrs 277198627Srrs ret_val = xlr_sec_cipher_hash_command(op, desc, ses->multi_frag_flag); 278198627Srrs return (ret_val); 279198157Srrs 280198157Srrs} 281198157Srrs 282198157Srrsstatic int 283198627Srrsxlr_sec_cipher_hash_command(xlr_sec_io_pt op, symkey_desc_pt desc, 284198627Srrs uint8_t multi_frag_flag) 285198157Srrs{ 286198627Srrs xlr_sec_error_t err; 287198627Srrs uint32_t cfg_vector; 288198627Srrs unsigned int setup_flags = 0; 289198157Srrs 290198627Srrs err = XLR_SEC_ERR_NONE; 291198627Srrs cfg_vector = 0; 292198157Srrs 293198627Srrs if ((op->digest_type == XLR_SEC_DIGEST_TYPE_NONE) && 294198627Srrs (op->cipher_type != XLR_SEC_CIPHER_TYPE_ARC4) && 295198627Srrs (op->cipher_mode != XLR_SEC_CIPHER_MODE_F8) && 296198627Srrs (op->cipher_type != XLR_SEC_CIPHER_TYPE_KASUMI_F8) && 297198627Srrs (op->source_buf_size & 0x7)) { 298198627Srrs printf("Invalid Cipher Block Size, data len=%d\n", 299198627Srrs op->source_buf_size); 300198627Srrs return (-EINVAL); 301198627Srrs } 302198627Srrs do { 303198157Srrs 304198627Srrs if ((op->cipher_type == XLR_SEC_CIPHER_TYPE_3DES) && 305198627Srrs (op->cipher_op == XLR_SEC_CIPHER_OP_DECRYPT)) 306198627Srrs setup_flags = XLR_SEC_SETUP_OP_FLIP_3DES_KEY; 307198157Srrs 308198627Srrs err = xlr_sec_setup_descriptor(op, 309198627Srrs setup_flags, 310198627Srrs desc, &cfg_vector); 311198627Srrs if (err != XLR_SEC_ERR_NONE) 312198627Srrs break; 313198157Srrs 314198627Srrs err = xlr_sec_setup_packet(op, 315198627Srrs desc, 316198627Srrs op->digest_type != XLR_SEC_DIGEST_TYPE_NONE ? 317198627Srrs XLR_SEC_SETUP_OP_CIPHER_HMAC : 0, 318198627Srrs &desc->data, 319198627Srrs &desc->pkt_desc[0], 320198627Srrs &desc->ctl_desc, 321198627Srrs cfg_vector, 322198627Srrs &desc->pkt_desc[1], 323198627Srrs multi_frag_flag); 324198627Srrs if (err != XLR_SEC_ERR_NONE) 325198627Srrs break; 326198627Srrs } while (0); 327198627Srrs if (err != XLR_SEC_ERR_NONE) { 328198627Srrs return (EINVAL); 329198627Srrs } 330198627Srrs err = xlr_sec_submit_message(desc, cfg_vector); 331198627Srrs return err; 332198157Srrs} 333198157Srrs 334198157Srrsstatic xlr_sec_error_t 335198627Srrsxlr_sec_setup_descriptor(xlr_sec_io_pt op, 336198627Srrs unsigned int flags, 337198627Srrs symkey_desc_pt desc, 338198627Srrs uint32_t * cfg_vector) 339198157Srrs{ 340198627Srrs xlr_sec_error_t err; 341198157Srrs 342198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: ENTER\n"); 343198157Srrs 344198627Srrs if ((err = xlr_sec_setup_cipher(op, &desc->ctl_desc, cfg_vector)) != XLR_SEC_ERR_NONE) { 345198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: xlr_sec_setup_cipher done err %d\n", 346198627Srrs (int)err); 347198627Srrs return err; 348198627Srrs } 349198627Srrs if (op->digest_type != XLR_SEC_DIGEST_TYPE_NONE) { 350198627Srrs if ((err = xlr_sec_setup_digest(op, &desc->ctl_desc, cfg_vector)) != XLR_SEC_ERR_NONE) { 351198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: xlr_sec_setup_digest done err %d\n", 352198627Srrs (int)err); 353198627Srrs return err; 354198627Srrs } 355198627Srrs } 356198627Srrs if ((err = xlr_sec_setup_cksum(op, &desc->ctl_desc)) != XLR_SEC_ERR_NONE) { 357198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: xlr_sec_setup_cksum done err %d\n", 358198627Srrs (int)err); 359198627Srrs return err; 360198627Srrs } 361198627Srrs if ((err = xlr_sec_control_setup(op, 362198627Srrs flags, 363198627Srrs &desc->control, 364198627Srrs &desc->ctl_desc, 365198627Srrs &desc->user, 366198627Srrs *cfg_vector)) != XLR_SEC_ERR_NONE) { 367198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: xlr_sec_control_setup done err %d\n", 368198627Srrs (int)err); 369198627Srrs return err; 370198627Srrs } 371198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: DONE\n"); 372198627Srrs return err; 373198157Srrs} 374198157Srrs 375198157Srrs 376198157Srrs 377198157Srrsstatic 378198627Srrsxlr_sec_error_t 379198627Srrsxlr_sec_setup_packet(xlr_sec_io_pt op, 380198627Srrs symkey_desc_pt desc, 381198627Srrs unsigned int flags, 382198627Srrs uint64_t * data, 383198627Srrs PacketDescriptor_pt pkt_desc, 384198627Srrs ControlDescriptor_pt ctl_desc, 385198627Srrs uint32_t vector, 386198627Srrs PacketDescriptor_pt next_pkt_desc, 387198627Srrs uint8_t multi_frag_flag) 388198157Srrs{ 389198627Srrs uint32_t len, next_len = 0, len_dwords, last_u64_bytes; 390198627Srrs uint64_t addr; 391198627Srrs uint64_t seg_addr, next_seg_addr = 0; 392198627Srrs uint64_t byte_offset, global_offset; 393198627Srrs uint32_t cipher_offset_dwords; 394198157Srrs 395198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ENTER vector = %04x\n", vector); 396198157Srrs 397198627Srrs /* physical address of the source buffer */ 398198627Srrs addr = (uint64_t) vtophys((void *)(unsigned long)op->source_buf); 399198627Srrs /* cache-aligned base of the source buffer */ 400198627Srrs seg_addr = (addr & ~(SMP_CACHE_BYTES - 1)); 401198627Srrs /* offset in bytes to the source buffer start from the segment base */ 402198627Srrs byte_offset = addr - seg_addr; 403198627Srrs /* global offset: 0-7 bytes */ 404198627Srrs global_offset = byte_offset & 0x7; 405198157Srrs 406198157Srrs 407198627Srrs /* 408198627Srrs * op->source_buf_size is expected to be the Nb double words to 409198627Srrs * stream in (Including Segment address->CP/IV/Auth/CkSum offsets) 410198627Srrs */ 411198157Srrs 412198627Srrs /* 413198627Srrs * adjusted length of the whole thing, accounting for the added 414198627Srrs * head, sans global_offset (per Paul S.) 415198627Srrs */ 416198157Srrs 417198627Srrs len = op->source_buf_size + byte_offset - global_offset; 418198627Srrs if (multi_frag_flag) { 419212763Sjchandra next_seg_addr = (uint64_t)vtophys((void *)(uintptr_t)desc->next_src_buf); 420198627Srrs next_seg_addr = (next_seg_addr & ~(SMP_CACHE_BYTES - 1)); 421198627Srrs next_len = desc->next_src_len; 422198627Srrs } 423198627Srrs /* length of the whole thing in dwords */ 424198627Srrs len_dwords = NUM_CHUNKS(len, 3); 425198627Srrs /* number of bytes in the last chunk (len % 8) */ 426198627Srrs last_u64_bytes = len & 0x07; 427198157Srrs 428198627Srrs if (op->cipher_offset & 0x7) { 429198627Srrs printf("** cipher_offset(%d) fails 64-bit word alignment **", 430198627Srrs op->cipher_offset); 431198157Srrs 432198627Srrs return XLR_SEC_ERR_CIPHER_MODE; /* ! fix ! */ 433198627Srrs } 434198627Srrs /* 435198627Srrs * global_offset is only three bits, so work the number of the whole 436198627Srrs * 8-byte words into the global offset. both offset and 437198627Srrs * cipher_offset are byte counts 438198627Srrs */ 439198627Srrs cipher_offset_dwords = (op->iv_offset + byte_offset) >> 3; 440198157Srrs 441198627Srrs if (op->cipher_mode == XLR_SEC_CIPHER_MODE_F8 || 442198627Srrs op->cipher_mode == XLR_SEC_CIPHER_MODE_CTR) { 443198627Srrs if (multi_frag_flag) { 444198627Srrs int nlhmac = ((op->source_buf_size + global_offset + 7 - op->cipher_offset) >> 3) & 1; 445198157Srrs 446198627Srrs pkt_desc->srcLengthIVOffUseIVNext = 447198627Srrs FIELD_VALUE(PKT_DSC_HASHBYTES, len & 7) | 448198627Srrs FIELD_VALUE(PKT_DSC_IVOFF, cipher_offset_dwords) | 449198627Srrs FIELD_VALUE(PKT_DSC_PKTLEN, nlhmac + ((len + 7) >> 3)) | 450198627Srrs FIELD_VALUE(PKT_DSC_NLHMAC, nlhmac) | 451198627Srrs FIELD_VALUE(PKT_DSC_BREAK, 0) | 452198627Srrs FIELD_VALUE(PKT_DSC_WAIT, 1) | 453198627Srrs FIELD_VALUE(PKT_DSC_NEXT, 1) | 454198627Srrs FIELD_VALUE(PKT_DSC_SEGADDR, seg_addr >> (PKT_DSC_SEGADDR_LSB)) | 455198627Srrs FIELD_VALUE(PKT_DSC_SEGOFFSET, global_offset); 456198627Srrs } else { 457198627Srrs int nlhmac = ((op->source_buf_size + global_offset + 7 - op->cipher_offset) >> 3) & 1; 458198157Srrs 459198627Srrs pkt_desc->srcLengthIVOffUseIVNext = 460198627Srrs FIELD_VALUE(PKT_DSC_HASHBYTES, len & 7) | 461198627Srrs FIELD_VALUE(PKT_DSC_IVOFF, cipher_offset_dwords) | 462198627Srrs FIELD_VALUE(PKT_DSC_PKTLEN, nlhmac + ((len + 7) >> 3)) | 463198627Srrs FIELD_VALUE(PKT_DSC_NLHMAC, nlhmac) | 464198627Srrs FIELD_VALUE(PKT_DSC_BREAK, 0) | 465198627Srrs FIELD_VALUE(PKT_DSC_WAIT, 0) | 466198627Srrs FIELD_VALUE(PKT_DSC_SEGADDR, seg_addr >> (PKT_DSC_SEGADDR_LSB)) | 467198627Srrs FIELD_VALUE(PKT_DSC_SEGOFFSET, global_offset); 468198157Srrs 469198627Srrs } 470198627Srrs } else { 471198627Srrs if (multi_frag_flag) { 472198627Srrs pkt_desc->srcLengthIVOffUseIVNext = 473198627Srrs FIELD_VALUE(PKT_DSC_HASHBYTES, len & 7) | 474198627Srrs FIELD_VALUE(PKT_DSC_IVOFF, cipher_offset_dwords) | 475198627Srrs FIELD_VALUE(PKT_DSC_PKTLEN, (len + 7) >> 3) | 476198627Srrs FIELD_VALUE(PKT_DSC_BREAK, 0) | 477198627Srrs FIELD_VALUE(PKT_DSC_WAIT, 0) | 478198627Srrs FIELD_VALUE(PKT_DSC_NEXT, 1) | 479198627Srrs FIELD_VALUE(PKT_DSC_SEGADDR, seg_addr >> (PKT_DSC_SEGADDR_LSB)) | 480198627Srrs FIELD_VALUE(PKT_DSC_SEGOFFSET, global_offset); 481198157Srrs 482198157Srrs 483198627Srrs next_pkt_desc->srcLengthIVOffUseIVNext = 484198627Srrs FIELD_VALUE(PKT_DSC_HASHBYTES, (next_len & 7)) | 485198627Srrs FIELD_VALUE(PKT_DSC_IVOFF, 0) | 486198627Srrs FIELD_VALUE(PKT_DSC_PKTLEN, (next_len + 7) >> 3) | 487198627Srrs FIELD_VALUE(PKT_DSC_BREAK, 0) | 488198627Srrs FIELD_VALUE(PKT_DSC_WAIT, 0) | 489198627Srrs FIELD_VALUE(PKT_DSC_NEXT, 0) | 490198627Srrs FIELD_VALUE(PKT_DSC_SEGADDR, next_seg_addr >> (PKT_DSC_SEGADDR_LSB)) | 491198627Srrs FIELD_VALUE(PKT_DSC_SEGOFFSET, 0); 492198157Srrs 493198157Srrs 494198627Srrs } else { 495198627Srrs pkt_desc->srcLengthIVOffUseIVNext = 496198627Srrs FIELD_VALUE(PKT_DSC_HASHBYTES, len & 7) | 497198627Srrs FIELD_VALUE(PKT_DSC_IVOFF, cipher_offset_dwords) | 498198627Srrs FIELD_VALUE(PKT_DSC_PKTLEN, (len + 7) >> 3) | 499198627Srrs FIELD_VALUE(PKT_DSC_BREAK, 0) | 500198627Srrs FIELD_VALUE(PKT_DSC_WAIT, 0) | 501198627Srrs FIELD_VALUE(PKT_DSC_SEGADDR, seg_addr >> (PKT_DSC_SEGADDR_LSB)) | 502198627Srrs FIELD_VALUE(PKT_DSC_SEGOFFSET, global_offset); 503198157Srrs 504198157Srrs 505198627Srrs } 506198627Srrs } 507198157Srrs 508198627Srrs switch (op->pkt_hmac) { 509198627Srrs case XLR_SEC_LOADHMACKEY_MODE_OLD: 510198627Srrs CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext, 511198627Srrs PKT_DSC_LOADHMACKEY, PKT_DSC_LOADHMACKEY_OLD); 512198627Srrs if (multi_frag_flag) { 513198627Srrs CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext, 514198627Srrs PKT_DSC_LOADHMACKEY, PKT_DSC_LOADHMACKEY_OLD); 515198157Srrs 516198627Srrs } 517198627Srrs break; 518198627Srrs case XLR_SEC_LOADHMACKEY_MODE_LOAD: 519198627Srrs CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext, 520198627Srrs PKT_DSC_LOADHMACKEY, PKT_DSC_LOADHMACKEY_LOAD); 521198627Srrs if (multi_frag_flag) { 522198627Srrs CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext, 523198627Srrs PKT_DSC_LOADHMACKEY, PKT_DSC_LOADHMACKEY_LOAD); 524198157Srrs 525198627Srrs } 526198627Srrs break; 527198627Srrs default: 528198627Srrs if (vector & (XLR_SEC_VECTOR_HMAC | XLR_SEC_VECTOR_HMAC2 | XLR_SEC_VECTOR_GCM | XLR_SEC_VECTOR_F9)) { 529198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_LOADHMACKEY_MODE EXIT\n"); 530198627Srrs return XLR_SEC_ERR_LOADHMACKEY_MODE; 531198627Srrs } 532198627Srrs break; 533198627Srrs } 534198157Srrs 535198627Srrs switch (op->pkt_hash) { 536198627Srrs case XLR_SEC_PADHASH_PADDED: 537198627Srrs CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext, 538198627Srrs PKT_DSC_PADHASH, PKT_DSC_PADHASH_PADDED); 539198627Srrs if (multi_frag_flag) { 540198627Srrs CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext, 541198627Srrs PKT_DSC_PADHASH, PKT_DSC_PADHASH_PADDED); 542198627Srrs } 543198627Srrs break; 544198627Srrs case XLR_SEC_PADHASH_PAD: 545198627Srrs CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext, 546198627Srrs PKT_DSC_PADHASH, PKT_DSC_PADHASH_PAD); 547198627Srrs if (multi_frag_flag) { 548198627Srrs CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext, 549198627Srrs PKT_DSC_PADHASH, PKT_DSC_PADHASH_PAD); 550198627Srrs } 551198627Srrs break; 552198627Srrs default: 553198627Srrs if (vector & (XLR_SEC_VECTOR_MAC | XLR_SEC_VECTOR_HMAC | XLR_SEC_VECTOR_HMAC2)) { 554198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_PADHASH_MODE EXIT\n"); 555198627Srrs return XLR_SEC_ERR_PADHASH_MODE; 556198627Srrs } 557198627Srrs break; 558198627Srrs } 559198157Srrs 560198627Srrs switch (op->pkt_iv) { 561198627Srrs case XLR_SEC_PKT_IV_OLD: 562198627Srrs CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext, 563198627Srrs PKT_DSC_IV, PKT_DSC_IV_OLD); 564198627Srrs if (multi_frag_flag) { 565198627Srrs CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext, 566198627Srrs PKT_DSC_IV, PKT_DSC_IV_OLD); 567198157Srrs 568198627Srrs } 569198627Srrs break; 570198627Srrs case XLR_SEC_PKT_IV_NEW: 571198627Srrs CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext, 572198627Srrs PKT_DSC_IV, PKT_DSC_IV_NEW); 573198627Srrs if (multi_frag_flag) { 574198627Srrs CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext, 575198627Srrs PKT_DSC_IV, PKT_DSC_IV_NEW); 576198157Srrs 577198627Srrs } 578198627Srrs break; 579198627Srrs default: 580198627Srrs if (vector & XLR_SEC_VECTOR_CIPHER) { 581198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_PKT_IV_MODE EXIT\n"); 582198627Srrs return XLR_SEC_ERR_PKT_IV_MODE; 583198627Srrs } 584198627Srrs break; 585198627Srrs } 586198157Srrs 587198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: src_buf=%llx phys_src_buf=%llx \n", 588198627Srrs (unsigned long long)op->source_buf, (unsigned long long)addr); 589198157Srrs 590198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: seg_addr=%llx offset=%lld\n", 591198627Srrs (unsigned long long)seg_addr, (unsigned long long)byte_offset); 592198157Srrs 593198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: global src offset: %d, iv_offset=%d\n", 594198627Srrs cipher_offset_dwords, op->iv_offset); 595198157Srrs 596198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: src_buf_sz=%d PKT_LEN=%d\n", 597198627Srrs op->source_buf_size, len_dwords); 598198157Srrs 599198627Srrs /* 600198627Srrs * same operation with the destination. cipher offset affects this, 601198627Srrs * as well 602198627Srrs */ 603198627Srrs if (multi_frag_flag) { 604198627Srrs next_seg_addr = (uint64_t) vtophys((void *)(unsigned long)(desc->next_dest_buf)); 605198627Srrs next_seg_addr = (next_seg_addr & ~(SMP_CACHE_BYTES - 1)); 606198627Srrs } 607198627Srrs addr = (uint64_t) vtophys((void *)(unsigned long)op->dest_buf); 608198627Srrs seg_addr = (addr & ~(SMP_CACHE_BYTES - 1)); 609198627Srrs byte_offset = addr - seg_addr; 610198627Srrs global_offset = byte_offset & 0x7; 611198157Srrs 612198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: dest_buf=%llx phys_dest_buf=%llx \n", 613198627Srrs (unsigned long long)op->dest_buf, (unsigned long long)addr); 614198157Srrs 615198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: seg_addr=%llx offset=%lld\n", 616198627Srrs (unsigned long long)seg_addr, (unsigned long long)byte_offset); 617198157Srrs 618198627Srrs /* 619198627Srrs * Dest Address = (Cipher Dest Address) + (Cipher Offset) + (Global 620198627Srrs * Dest Data Offset) 621198627Srrs * 622198627Srrs * Cipher Dest Address - Cache-line (0xffffffffe0) Cipher Offset - 623198627Srrs * Which (64-bit) Word in Cacheline (0-3) Global Dest Data Offset - 624198627Srrs * Number of Bytes in (64-bit) Word before data 625198627Srrs * 626198627Srrs * It must be set for Digest-only Ops, since the Digest engine will 627198627Srrs * write data to this address. 628198627Srrs */ 629198627Srrs cipher_offset_dwords = (op->cipher_offset + byte_offset) >> 3; 630198157Srrs 631198157Srrs 632198627Srrs pkt_desc->dstDataSettings = 633198627Srrs /* SYM_OP, HASHSRC */ 634198627Srrs FIELD_VALUE(PKT_DSC_CPHROFF, cipher_offset_dwords) | 635198627Srrs FIELD_VALUE(PKT_DSC_HASHOFF, (op->digest_offset + byte_offset) >> 3) | 636198627Srrs FIELD_VALUE(PKT_DSC_CPHR_DST_ADDR, seg_addr) | 637198627Srrs FIELD_VALUE(PKT_DSC_CPHR_DST_DWOFFSET, 0) | 638198627Srrs FIELD_VALUE(PKT_DSC_CPHR_DST_OFFSET, global_offset); 639198157Srrs 640198627Srrs if (multi_frag_flag) { 641198627Srrs next_pkt_desc->dstDataSettings = 642198627Srrs /* SYM_OP, HASHSRC */ 643198627Srrs FIELD_VALUE(PKT_DSC_CPHROFF, cipher_offset_dwords) | 644198627Srrs FIELD_VALUE(PKT_DSC_HASHOFF, (op->digest_offset + byte_offset) >> 3) | 645198627Srrs FIELD_VALUE(PKT_DSC_CPHR_DST_ADDR, next_seg_addr) | 646198627Srrs FIELD_VALUE(PKT_DSC_CPHR_DST_DWOFFSET, 0) | 647198627Srrs FIELD_VALUE(PKT_DSC_CPHR_DST_OFFSET, global_offset); 648198157Srrs 649198627Srrs } 650198627Srrs if (op->cipher_type == XLR_SEC_CIPHER_TYPE_ARC4) 651198627Srrs pkt_desc->dstDataSettings |= FIELD_VALUE(PKT_DSC_ARC4BYTECOUNT, last_u64_bytes); 652198157Srrs 653198627Srrs if (op->cipher_type != XLR_SEC_CIPHER_TYPE_NONE) { 654198627Srrs switch (op->cipher_op) { 655198627Srrs case XLR_SEC_CIPHER_OP_ENCRYPT: 656198627Srrs CLEAR_SET_FIELD(pkt_desc->dstDataSettings, 657198627Srrs PKT_DSC_SYM_OP, PKT_DSC_SYM_OP_ENCRYPT); 658198627Srrs if (multi_frag_flag) { 659198627Srrs CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings, 660198627Srrs PKT_DSC_SYM_OP, PKT_DSC_SYM_OP_ENCRYPT); 661198157Srrs 662198627Srrs } 663198627Srrs break; 664198627Srrs case XLR_SEC_CIPHER_OP_DECRYPT: 665198627Srrs CLEAR_SET_FIELD(pkt_desc->dstDataSettings, 666198627Srrs PKT_DSC_SYM_OP, PKT_DSC_SYM_OP_DECRYPT); 667198627Srrs if (multi_frag_flag) { 668198627Srrs CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings, 669198627Srrs PKT_DSC_SYM_OP, PKT_DSC_SYM_OP_DECRYPT); 670198157Srrs 671198627Srrs } 672198627Srrs break; 673198627Srrs default: 674198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_CIPHER_OP EXIT\n"); 675198627Srrs return XLR_SEC_ERR_CIPHER_OP; 676198627Srrs } 677198627Srrs } 678198627Srrs if (flags & XLR_SEC_SETUP_OP_HMAC) { 679198627Srrs switch (op->digest_src) { 680198627Srrs case XLR_SEC_DIGEST_SRC_DMA: 681198627Srrs CLEAR_SET_FIELD(pkt_desc->dstDataSettings, 682198627Srrs PKT_DSC_HASHSRC, PKT_DSC_HASHSRC_DMA); 683198627Srrs if (multi_frag_flag) { 684198627Srrs CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings, 685198627Srrs PKT_DSC_HASHSRC, PKT_DSC_HASHSRC_DMA); 686198157Srrs 687198627Srrs } 688198627Srrs break; 689198627Srrs case XLR_SEC_DIGEST_SRC_CPHR: 690198627Srrs CLEAR_SET_FIELD(pkt_desc->dstDataSettings, 691198627Srrs PKT_DSC_HASHSRC, PKT_DSC_HASHSRC_CIPHER); 692198627Srrs if (multi_frag_flag) { 693198627Srrs CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings, 694198627Srrs PKT_DSC_HASHSRC, PKT_DSC_HASHSRC_CIPHER); 695198627Srrs } 696198627Srrs break; 697198627Srrs default: 698198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_DIGEST_SRC EXIT\n"); 699198627Srrs return XLR_SEC_ERR_DIGEST_SRC; 700198627Srrs } 701198627Srrs } 702198627Srrs if (op->cksum_type != XLR_SEC_CKSUM_TYPE_NOP) { 703198627Srrs switch (op->cksum_src) { 704198627Srrs case XLR_SEC_CKSUM_SRC_DMA: 705198627Srrs CLEAR_SET_FIELD(pkt_desc->dstDataSettings, 706198627Srrs PKT_DSC_CKSUMSRC, PKT_DSC_CKSUMSRC_DMA); 707198627Srrs if (multi_frag_flag) { 708198627Srrs CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings, 709198627Srrs PKT_DSC_CKSUMSRC, PKT_DSC_CKSUMSRC_DMA); 710198627Srrs } 711198627Srrs break; 712198627Srrs case XLR_SEC_CKSUM_SRC_CIPHER: 713198627Srrs CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings, 714198627Srrs PKT_DSC_CKSUMSRC, PKT_DSC_CKSUMSRC_CIPHER); 715198627Srrs if (multi_frag_flag) { 716198627Srrs CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings, 717198627Srrs PKT_DSC_CKSUMSRC, PKT_DSC_CKSUMSRC_CIPHER); 718198627Srrs } 719198627Srrs break; 720198627Srrs default: 721198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_CKSUM_SRC EXIT\n"); 722198627Srrs return XLR_SEC_ERR_CKSUM_SRC; 723198627Srrs } 724198627Srrs } 725198627Srrs pkt_desc->ckSumDstNonceHiCFBMaskLLWMask = 726198627Srrs FIELD_VALUE(PKT_DSC_HASH_BYTE_OFF, (op->digest_offset & 0x7)) | 727198627Srrs FIELD_VALUE(PKT_DSC_PKTLEN_BYTES, 0) | 728198627Srrs /* NONCE_HI, PKT_DSC_LASTWORD, CFB_MASK, CKSUM_DST_ADDR */ 729198627Srrs FIELD_VALUE(PKT_DSC_IV_OFF_HI, 0); 730198157Srrs 731198627Srrs if (multi_frag_flag) { 732198627Srrs next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask = 733198627Srrs FIELD_VALUE(PKT_DSC_HASH_BYTE_OFF, (op->digest_offset & 0x7)) | 734198627Srrs FIELD_VALUE(PKT_DSC_PKTLEN_BYTES, 0) | 735198627Srrs /* NONCE_HI, PKT_DSC_LASTWORD, CFB_MASK, CKSUM_DST_ADDR */ 736198627Srrs FIELD_VALUE(PKT_DSC_IV_OFF_HI, 0); 737198157Srrs 738198627Srrs } 739198627Srrs switch (op->pkt_lastword) { 740198627Srrs case XLR_SEC_LASTWORD_128: 741198627Srrs CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 742198627Srrs PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_128); 743198627Srrs if (multi_frag_flag) { 744198627Srrs CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 745198627Srrs PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_128); 746198157Srrs 747198627Srrs } 748198627Srrs break; 749198627Srrs case XLR_SEC_LASTWORD_96MASK: 750198627Srrs CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 751198627Srrs PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_96MASK); 752198627Srrs if (multi_frag_flag) { 753198627Srrs CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 754198627Srrs PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_96MASK); 755198627Srrs } 756198627Srrs break; 757198627Srrs case XLR_SEC_LASTWORD_64MASK: 758198627Srrs CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 759198627Srrs PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_64MASK); 760198627Srrs if (multi_frag_flag) { 761198627Srrs CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 762198627Srrs PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_64MASK); 763198627Srrs } 764198627Srrs break; 765198627Srrs case XLR_SEC_LASTWORD_32MASK: 766198627Srrs CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 767198627Srrs PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_32MASK); 768198627Srrs if (multi_frag_flag) { 769198627Srrs CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 770198627Srrs PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_32MASK); 771198627Srrs } 772198627Srrs break; 773198627Srrs default: 774198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_LASTWORD_MODE EXIT\n"); 775198627Srrs return XLR_SEC_ERR_LASTWORD_MODE; 776198627Srrs } 777198627Srrs CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 778198627Srrs PKT_DSC_CFB_MASK, op->cfb_mask); 779198627Srrs CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 780198627Srrs PKT_DSC_NONCE_HI, htonl(op->nonce) >> 24); 781198627Srrs CLEAR_SET_FIELD(pkt_desc->authDstNonceLow, 782198627Srrs PKT_DSC_NONCE_LOW, htonl(op->nonce) & 0xffffff); 783198157Srrs 784198627Srrs if (multi_frag_flag) { 785198627Srrs CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 786198627Srrs PKT_DSC_CFB_MASK, op->cfb_mask); 787198627Srrs CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 788198627Srrs PKT_DSC_NONCE_HI, htonl(op->nonce) >> 24); 789198627Srrs CLEAR_SET_FIELD(next_pkt_desc->authDstNonceLow, 790198627Srrs PKT_DSC_NONCE_LOW, htonl(op->nonce) & 0xffffff); 791198157Srrs 792198157Srrs 793198627Srrs } 794198627Srrs /* Auth Dest Address must be Cacheline aligned on input */ 795198627Srrs if (vector & (XLR_SEC_VECTOR_MAC | XLR_SEC_VECTOR_HMAC | XLR_SEC_VECTOR_HMAC2 | XLR_SEC_VECTOR_GCM | XLR_SEC_VECTOR_F9)) { 796198627Srrs pkt_desc->authDstNonceLow |= 797198627Srrs /* NONCE_LOW */ 798198627Srrs FIELD_VALUE(PKT_DSC_AUTH_DST_ADDR, 799198627Srrs (uint64_t) vtophys((void *)(unsigned long)op->auth_dest)) | 800198627Srrs FIELD_VALUE(PKT_DSC_CIPH_OFF_HI, 0); 801198157Srrs 802198157Srrs 803198627Srrs if (multi_frag_flag) { 804198627Srrs next_pkt_desc->authDstNonceLow |= 805198627Srrs /* NONCE_LOW */ 806198627Srrs FIELD_VALUE(PKT_DSC_AUTH_DST_ADDR, 807198627Srrs (uint64_t) vtophys((void *)(unsigned long)desc->next_auth_dest)) | 808198627Srrs FIELD_VALUE(PKT_DSC_CIPH_OFF_HI, 0); 809198157Srrs 810198157Srrs 811198627Srrs } 812198627Srrs } 813198627Srrs /* CkSum Dest Address must be Cacheline aligned on input */ 814198627Srrs if (op->cksum_type == XLR_SEC_CKSUM_TYPE_IP) { 815198627Srrs CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 816198627Srrs PKT_DSC_CKSUM_DST_ADDR, 817198627Srrs (uint64_t) vtophys((void *)(unsigned long)op->cksum_dest)); 818198157Srrs 819198627Srrs if (multi_frag_flag) { 820198627Srrs CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 821198627Srrs PKT_DSC_CKSUM_DST_ADDR, 822198627Srrs (uint64_t) vtophys((void *)(unsigned long)desc->next_cksum_dest)); 823198627Srrs } 824198627Srrs } 825198627Srrs /* 826198627Srrs * XLR_SEC_CMD_DIAG (" xlr_sec_setup_packet(): pkt_desc=%llx 827198627Srrs * phys_pkt_desc=%llx \n", (unsigned long long)pkt_desc, (unsigned 828198627Srrs * long long)virt_to_phys(pkt_desc)); (unsigned long long)pkt_desc, 829198627Srrs * (unsigned long long)vtophys(pkt_desc)); 830198627Srrs */ 831198627Srrs XLR_SEC_CMD_DIAG(" xlr_sec_setup_packet(): pkt_desc=%p phys_pkt_desc=%llx \n", 832198627Srrs pkt_desc, (unsigned long long)vtophys(pkt_desc)); 833198157Srrs 834198627Srrs CLEAR_SET_FIELD(*data, MSG_CMD_DATA_ADDR, ((uint64_t) vtophys(pkt_desc))); 835198627Srrs CLEAR_SET_FIELD(*data, MSG_CMD_DATA_CTL, SEC_EOP); 836198627Srrs CLEAR_SET_FIELD(*data, MSG_CMD_DATA_LEN, MSG_CMD_DATA_LEN_LOAD); 837198157Srrs 838198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: DONE\n"); 839198157Srrs 840198157Srrs#ifdef RMI_SEC_DEBUG 841198627Srrs { 842198627Srrs printf("data desc\n"); 843198627Srrs printf("srcLengthIVOffUseIVNext = 0x%llx\n", pkt_desc->srcLengthIVOffUseIVNext); 844198627Srrs printf("dstDataSettings = 0x%llx\n", pkt_desc->dstDataSettings); 845198627Srrs printf("authDstNonceLow = 0x%llx\n", pkt_desc->authDstNonceLow); 846198627Srrs printf("ckSumDstNonceHiCFBMaskLLWMask = 0x%llx\n", pkt_desc->ckSumDstNonceHiCFBMaskLLWMask); 847198627Srrs } 848198157Srrs 849198627Srrs if (multi_frag_flag) { 850198157Srrs 851198627Srrs printf("next data desc\n"); 852198627Srrs printf("srcLengthIVOffUseIVNext = 0x%llx\n", next_pkt_desc->srcLengthIVOffUseIVNext); 853198627Srrs printf("dstDataSettings = 0x%llx\n", next_pkt_desc->dstDataSettings); 854198627Srrs printf("authDstNonceLow = 0x%llx\n", next_pkt_desc->authDstNonceLow); 855198627Srrs printf("ckSumDstNonceHiCFBMaskLLWMask = 0x%llx\n", next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask); 856198627Srrs } 857198157Srrs#endif 858198157Srrs 859198157Srrs#ifdef SYMBOL 860198627Srrs if (op->cipher_type == XLR_SEC_CIPHER_TYPE_ARC4) { 861198627Srrs op->source_buf -= 0; 862198627Srrs op->source_buf_size += 0; 863198627Srrs op->dest_buf -= 0; 864198627Srrs } 865198157Srrs#endif 866198627Srrs return XLR_SEC_ERR_NONE; 867198157Srrs} 868198157Srrs 869198157Srrs 870198627Srrsstatic int 871198627Srrsidentify_symkey_ctl_error(uint32_t code, xlr_sec_error_t err) 872198157Srrs{ 873198627Srrs int ret_val = EINVAL; 874198157Srrs 875198627Srrs switch (code) { 876198627Srrs case CTL_ERR_NONE: 877198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error: No Error\n"); 878198627Srrs ret_val = 0; 879198627Srrs break; 880198627Srrs case CTL_ERR_CIPHER_OP: 881198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_CIPHER_OP) - Unknown Cipher Op \n"); 882198627Srrs break; 883198627Srrs case CTL_ERR_MODE: 884198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_MODE) - " 885198627Srrs "Unknown or Not Allowed Mode \n"); 886198627Srrs break; 887198627Srrs case CTL_ERR_CHKSUM_SRC: 888198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_CHKSUM_SRC) - Unknown CkSum Src\n"); 889198627Srrs break; 890198627Srrs case CTL_ERR_CFB_MASK: 891198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_CFB_MASK) - Forbidden CFB Mask \n"); 892198627Srrs break; 893198627Srrs case CTL_ERR_OP: 894198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_OP) - Unknown Ctrl Op \n"); 895198627Srrs break; 896198627Srrs case CTL_ERR_DATA_READ: 897198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_DATA_READ) - Data Read Error\n"); 898198627Srrs break; 899198627Srrs case CTL_ERR_DESC_CTRL: 900198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_DESC_CTRL) - " 901198627Srrs "Descriptor Ctrl Field Error \n"); 902198627Srrs break; 903198627Srrs case CTL_ERR_UNDEF1: 904198627Srrs case CTL_ERR_UNDEF2: 905198627Srrs default: 906198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error: UNKNOWN CODE=%d \n", code); 907198627Srrs break; 908198627Srrs } 909198627Srrs return ret_val; 910198157Srrs} 911198157Srrs 912198157Srrsstatic 913198627Srrsint 914198627Srrsidentify_symkey_data_error(uint32_t code, xlr_sec_error_t err) 915198157Srrs{ 916198627Srrs int ret_val = -EINVAL; 917198157Srrs 918198627Srrs switch (code) { 919198627Srrs case DATA_ERR_NONE: 920198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error No Error\n"); 921198627Srrs ret_val = 0; 922198627Srrs break; 923198627Srrs case DATA_ERR_LEN_CIPHER: 924198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Not Enough Data To Cipher\n"); 925198627Srrs break; 926198627Srrs case DATA_ERR_IV_ADDR: 927198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Illegal IV Loacation\n"); 928198627Srrs break; 929198627Srrs case DATA_ERR_WD_LEN_AES: 930198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Illegal Nb Words To AES\n"); 931198627Srrs break; 932198627Srrs case DATA_ERR_BYTE_COUNT: 933198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Illegal Pad And ByteCount Spec\n"); 934198627Srrs break; 935198627Srrs case DATA_ERR_LEN_CKSUM: 936198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Not Enough Data To CkSum\n"); 937198627Srrs break; 938198627Srrs case DATA_ERR_OP: 939198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Unknown Data Op \n"); 940198627Srrs break; 941198627Srrs case DATA_ERR_READ: 942198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Data Read Error \n"); 943198627Srrs break; 944198627Srrs case DATA_ERR_WRITE: 945198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Data Write Error \n"); 946198627Srrs break; 947198627Srrs case DATA_ERR_UNDEF1: 948198627Srrs default: 949198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error - UNKNOWN CODE=%d \n", code); 950198627Srrs break; 951198627Srrs } 952198627Srrs return ret_val; 953198157Srrs} 954198157Srrs 955198157Srrs 956198157Srrsstatic int 957198157Srrsxlr_sec_submit_message(symkey_desc_pt desc, uint32_t cfg_vector) 958198157Srrs{ 959198627Srrs xlr_sec_error_t err; 960198627Srrs uint32_t ctl_error, data_error; 961198627Srrs int ret_val = 0; 962198157Srrs 963198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_submit_message: ENTER\n"); 964198627Srrs err = XLR_SEC_ERR_NONE; 965198627Srrs XLR_SEC_CMD_DIAG_SYM_DESC(desc, cfg_vector); 966198157Srrs 967198627Srrs do { 968198627Srrs /* For now, send message and wait for response */ 969198627Srrs err = xlr_sec_submit_op(desc); 970198157Srrs 971198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_submit_message: err = %d \n", (uint32_t) err); 972198157Srrs 973198627Srrs if (err != XLR_SEC_ERR_NONE) { 974198627Srrs ret_val = (EINVAL); 975198627Srrs break; 976198627Srrs } 977198627Srrs ctl_error = desc->ctl_result; 978198627Srrs data_error = desc->data_result; 979198157Srrs 980198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_submit_message: ctl_error = %x data_error = %x\n", 981198627Srrs ctl_error, data_error); 982198157Srrs 983198627Srrs if ((ret_val = identify_symkey_ctl_error(ctl_error, err)) == 0) 984198627Srrs ret_val = identify_symkey_data_error(data_error, err); 985198157Srrs 986198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_submit_message: identify error = %d \n", ret_val); 987198157Srrs 988198627Srrs } while (0); 989198627Srrs 990198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_submit_message: DONE\n"); 991198627Srrs return (ret_val); 992198157Srrs} 993198157Srrs 994198157Srrs 995198157Srrsstatic 996198627Srrsxlr_sec_error_t 997198627Srrsxlr_sec_setup_cipher(xlr_sec_io_pt op, 998198627Srrs ControlDescriptor_pt ctl_desc, 999198627Srrs uint32_t * vector) 1000198157Srrs{ 1001198627Srrs uint32_t aes_flag = 0; 1002198627Srrs uint32_t cipher_vector = 0; 1003198157Srrs 1004198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ENTER vector = %04x\n", *vector); 1005198157Srrs 1006198627Srrs switch (op->cipher_type) { 1007198627Srrs case XLR_SEC_CIPHER_TYPE_NONE: 1008198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_BYPASS); 1009198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: CIPHER_TYPE_NONE EXIT\n"); 1010198627Srrs return XLR_SEC_ERR_NONE; 1011198627Srrs case XLR_SEC_CIPHER_TYPE_DES: 1012198627Srrs cipher_vector |= XLR_SEC_VECTOR_CIPHER_DES; 1013198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_DES); 1014198627Srrs break; 1015198627Srrs case XLR_SEC_CIPHER_TYPE_3DES: 1016198627Srrs cipher_vector |= XLR_SEC_VECTOR_CIPHER_3DES; 1017198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_3DES); 1018198627Srrs break; 1019198627Srrs case XLR_SEC_CIPHER_TYPE_AES128: 1020198627Srrs aes_flag = 1; 1021198627Srrs cipher_vector |= XLR_SEC_VECTOR_CIPHER_AES128; 1022198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_AES128); 1023198627Srrs break; 1024198627Srrs case XLR_SEC_CIPHER_TYPE_AES192: 1025198627Srrs aes_flag = 1; 1026198627Srrs cipher_vector |= XLR_SEC_VECTOR_CIPHER_AES192; 1027198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_AES192); 1028198627Srrs break; 1029198627Srrs case XLR_SEC_CIPHER_TYPE_AES256: 1030198627Srrs aes_flag = 1; 1031198627Srrs cipher_vector |= XLR_SEC_VECTOR_CIPHER_AES256; 1032198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_AES256); 1033198627Srrs break; 1034198627Srrs case XLR_SEC_CIPHER_TYPE_ARC4: 1035198627Srrs cipher_vector |= XLR_SEC_VECTOR_CIPHER_ARC4; 1036198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_ARC4); 1037198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_ARC4_KEYLEN, 1038198627Srrs op->rc4_key_len); 1039198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_ARC4_LOADSTATE, 1040198627Srrs op->rc4_loadstate); 1041198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_ARC4_SAVESTATE, 1042198627Srrs op->rc4_savestate); 1043198627Srrs if (op->rc4_loadstate || op->rc4_savestate) 1044198627Srrs cipher_vector |= XLR_SEC_VECTOR_STATE; 1045198627Srrs break; 1046198627Srrs case XLR_SEC_CIPHER_TYPE_KASUMI_F8: 1047198627Srrs aes_flag = 1; 1048198627Srrs cipher_vector |= XLR_SEC_VECTOR_CIPHER_KASUMI_F8; 1049198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_KASUMI_F8); 1050198627Srrs break; 1051198627Srrs default: 1052198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_TYPE EXIT\n"); 1053198627Srrs return XLR_SEC_ERR_CIPHER_TYPE; 1054198627Srrs } 1055198157Srrs 1056198627Srrs switch (op->cipher_mode) { 1057198627Srrs case XLR_SEC_CIPHER_MODE_ECB: 1058198627Srrs if (aes_flag == 1) 1059198627Srrs cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC_OFB; 1060198627Srrs else 1061198627Srrs cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC; 1062198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_ECB); 1063198627Srrs break; 1064198627Srrs case XLR_SEC_CIPHER_MODE_CBC: 1065198627Srrs if (aes_flag == 1) 1066198627Srrs cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC_OFB; 1067198627Srrs else 1068198627Srrs cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC; 1069198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_CBC); 1070198627Srrs break; 1071198627Srrs case XLR_SEC_CIPHER_MODE_OFB: 1072198627Srrs if (aes_flag == 0) { 1073198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_MODE EXIT\n"); 1074198627Srrs return XLR_SEC_ERR_CIPHER_MODE; 1075198627Srrs } 1076198627Srrs cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC_OFB; 1077198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_OFB); 1078198627Srrs break; 1079198627Srrs case XLR_SEC_CIPHER_MODE_CTR: 1080198627Srrs if (aes_flag == 0) { 1081198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_MODE EXIT\n"); 1082198627Srrs return XLR_SEC_ERR_CIPHER_MODE; 1083198627Srrs } 1084198627Srrs cipher_vector |= XLR_SEC_VECTOR_MODE_CTR_CFB; 1085198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_CTR); 1086198627Srrs break; 1087198627Srrs case XLR_SEC_CIPHER_MODE_CFB: 1088198627Srrs if (aes_flag == 0) { 1089198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_MODE EXIT\n"); 1090198627Srrs return XLR_SEC_ERR_CIPHER_MODE; 1091198627Srrs } 1092198627Srrs cipher_vector |= XLR_SEC_VECTOR_MODE_CTR_CFB; 1093198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_CFB); 1094198627Srrs break; 1095198627Srrs case XLR_SEC_CIPHER_MODE_F8: 1096198627Srrs if (aes_flag == 0) { 1097198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_MODE EXIT\n"); 1098198627Srrs return XLR_SEC_ERR_CIPHER_MODE; 1099198627Srrs } 1100198627Srrs cipher_vector |= XLR_SEC_VECTOR_MODE_F8; 1101198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_F8); 1102198627Srrs break; 1103198627Srrs default: 1104198627Srrs if (!(cipher_vector & (XLR_SEC_VECTOR_CIPHER_ARC4 | XLR_SEC_VECTOR_CIPHER_KASUMI_F8))) { 1105198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_MODE EXIT\n"); 1106198627Srrs return XLR_SEC_ERR_CIPHER_MODE; 1107198627Srrs } 1108198157Srrs } 1109198157Srrs 1110198627Srrs switch (op->cipher_init) { 1111198627Srrs case XLR_SEC_CIPHER_INIT_OK: 1112198627Srrs SET_FIELD(ctl_desc->instruction, 1113198627Srrs CTL_DSC_ICPHR, CTL_DSC_ICPHR_OKY); 1114198627Srrs break; 1115198157Srrs 1116198627Srrs case XLR_SEC_CIPHER_INIT_NK: 1117198627Srrs SET_FIELD(ctl_desc->instruction, 1118198627Srrs CTL_DSC_ICPHR, CTL_DSC_ICPHR_NKY); 1119198627Srrs break; 1120198627Srrs default: 1121198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_INIT EXIT\n"); 1122198627Srrs return XLR_SEC_ERR_CIPHER_INIT; 1123198627Srrs } 1124198157Srrs 1125198627Srrs *vector |= cipher_vector; 1126198157Srrs 1127198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: EXIT vector = %04x\n", *vector); 1128198157Srrs 1129198627Srrs return XLR_SEC_ERR_NONE; 1130198157Srrs} 1131198157Srrs 1132198157Srrsstatic 1133198627Srrsxlr_sec_error_t 1134198627Srrsxlr_sec_setup_digest(xlr_sec_io_pt op, 1135198627Srrs ControlDescriptor_pt ctl_desc, 1136198627Srrs uint32_t * vector) 1137198157Srrs{ 1138198627Srrs uint32_t hash_flag = 0; 1139198627Srrs uint32_t hmac_flag = 0; 1140198627Srrs uint32_t digest_vector = 0; 1141198157Srrs 1142198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_digest: ENTER vector = %04x\n", *vector); 1143198157Srrs 1144198627Srrs switch (op->digest_type) { 1145198627Srrs case XLR_SEC_DIGEST_TYPE_MD5: 1146198627Srrs digest_vector |= XLR_SEC_VECTOR_MAC; 1147198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_MD5); 1148198627Srrs break; 1149198627Srrs case XLR_SEC_DIGEST_TYPE_SHA1: 1150198627Srrs digest_vector |= XLR_SEC_VECTOR_MAC; 1151198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA1); 1152198627Srrs break; 1153198627Srrs case XLR_SEC_DIGEST_TYPE_SHA256: 1154198627Srrs digest_vector |= XLR_SEC_VECTOR_MAC; 1155198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA256); 1156198627Srrs break; 1157198627Srrs case XLR_SEC_DIGEST_TYPE_SHA384: 1158198627Srrs digest_vector |= XLR_SEC_VECTOR_MAC; 1159198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_SHA384 >> 2); 1160198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA384); 1161198627Srrs break; 1162198627Srrs case XLR_SEC_DIGEST_TYPE_SHA512: 1163198627Srrs digest_vector |= XLR_SEC_VECTOR_MAC; 1164198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_SHA512 >> 2); 1165198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA512); 1166198627Srrs break; 1167198627Srrs case XLR_SEC_DIGEST_TYPE_GCM: 1168198627Srrs hash_flag = 1; 1169198627Srrs digest_vector |= XLR_SEC_VECTOR_GCM; 1170198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_GCM >> 2); 1171198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_GCM); 1172198627Srrs break; 1173198627Srrs case XLR_SEC_DIGEST_TYPE_KASUMI_F9: 1174198627Srrs hash_flag = 1; 1175198627Srrs digest_vector |= XLR_SEC_VECTOR_F9; 1176198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_KASUMI_F9 >> 2); 1177198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_KASUMI_F9); 1178198627Srrs break; 1179198627Srrs case XLR_SEC_DIGEST_TYPE_HMAC_MD5: 1180198627Srrs hmac_flag = 1; 1181198627Srrs digest_vector |= XLR_SEC_VECTOR_HMAC; 1182198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_MD5); 1183198627Srrs break; 1184198627Srrs case XLR_SEC_DIGEST_TYPE_HMAC_SHA1: 1185198627Srrs hmac_flag = 1; 1186198627Srrs digest_vector |= XLR_SEC_VECTOR_HMAC; 1187198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA1); 1188198627Srrs break; 1189198627Srrs case XLR_SEC_DIGEST_TYPE_HMAC_SHA256: 1190198627Srrs hmac_flag = 1; 1191198627Srrs digest_vector |= XLR_SEC_VECTOR_HMAC; 1192198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA256); 1193198627Srrs break; 1194198627Srrs case XLR_SEC_DIGEST_TYPE_HMAC_SHA384: 1195198627Srrs hmac_flag = 1; 1196198627Srrs digest_vector |= XLR_SEC_VECTOR_HMAC2; 1197198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_SHA384 >> 2); 1198198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA384); 1199198627Srrs break; 1200198627Srrs case XLR_SEC_DIGEST_TYPE_HMAC_SHA512: 1201198627Srrs hmac_flag = 1; 1202198627Srrs digest_vector |= XLR_SEC_VECTOR_HMAC2; 1203198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_SHA512 >> 2); 1204198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA512); 1205198627Srrs break; 1206198627Srrs default: 1207198627Srrs return XLR_SEC_ERR_DIGEST_TYPE; 1208198627Srrs } 1209198157Srrs 1210198627Srrs if (hmac_flag == 1) { 1211198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_HMAC, CTL_DSC_HMAC_ON); 1212198157Srrs 1213198627Srrs } 1214198627Srrs if (hmac_flag || hash_flag) { 1215198627Srrs switch (op->digest_init) { 1216198627Srrs case XLR_SEC_DIGEST_INIT_OLDKEY: 1217198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_IHASH, CTL_DSC_IHASH_OLD); 1218198627Srrs break; 1219198627Srrs case XLR_SEC_DIGEST_INIT_NEWKEY: 1220198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_IHASH, CTL_DSC_IHASH_NEW); 1221198627Srrs break; 1222198627Srrs default: 1223198627Srrs return XLR_SEC_ERR_DIGEST_INIT; 1224198627Srrs } 1225198627Srrs } /* hmac_flag */ 1226198627Srrs *vector |= digest_vector; 1227198157Srrs 1228198627Srrs XLR_SEC_CMD_DIAG("xlr_sec_setup_digest: EXIT vector = %04x\n", *vector); 1229198627Srrs return XLR_SEC_ERR_NONE; 1230198157Srrs} 1231198157Srrs 1232198157Srrsstatic 1233198627Srrsxlr_sec_error_t 1234198627Srrsxlr_sec_setup_cksum(xlr_sec_io_pt op, 1235198627Srrs ControlDescriptor_pt ctl_desc) 1236198157Srrs{ 1237198627Srrs switch (op->cksum_type) { 1238198627Srrs case XLR_SEC_CKSUM_TYPE_NOP: 1239198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_CKSUM, CTL_DSC_CKSUM_NOP); 1240198627Srrs return XLR_SEC_ERR_NONE; 1241198627Srrs case XLR_SEC_CKSUM_TYPE_IP: 1242198627Srrs SET_FIELD(ctl_desc->instruction, CTL_DSC_CKSUM, CTL_DSC_CKSUM_IP); 1243198627Srrs break; 1244198627Srrs default: 1245198627Srrs return XLR_SEC_ERR_CKSUM_TYPE; 1246198627Srrs } 1247198157Srrs 1248198627Srrs return XLR_SEC_ERR_NONE; 1249198157Srrs} 1250198157Srrs 1251198157Srrs 1252198157Srrsstatic 1253198627Srrsxlr_sec_error_t 1254198627Srrsxlr_sec_control_setup(xlr_sec_io_pt op, 1255198627Srrs unsigned int flags, 1256198627Srrs uint64_t * control, 1257198627Srrs ControlDescriptor_pt ctl_desc, 1258198627Srrs xlr_sec_drv_user_t * user, 1259198627Srrs uint32_t vector) 1260198157Srrs{ 1261198627Srrs uint64_t *hmac_key = NULL; 1262198627Srrs uint64_t *cipher_key = NULL; 1263198627Srrs uint64_t *cipher_state = NULL; 1264198627Srrs uint32_t ctl_size = 0; 1265198627Srrs uint64_t ctl_addr = 0; 1266198627Srrs uint32_t cipher_keylen = 0; 1267198627Srrs uint32_t hmac_keylen = 0; 1268198627Srrs uint32_t ctl_len; 1269198157Srrs 1270198157Srrs#ifdef SYM_DEBUG 1271198627Srrs XLR_SEC_CMD_DIAG(" ENTER vector = %04x\n", vector); 1272198157Srrs#endif 1273198157Srrs 1274198627Srrs switch (vector) { 1275198627Srrs case XLR_SEC_VECTOR_MAC: 1276198627Srrs XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR_MAC \n"); 1277198627Srrs ctl_size = sizeof(HMAC_t); 1278198627Srrs break; 1279198627Srrs case XLR_SEC_VECTOR_HMAC: 1280198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_HMAC \n"); 1281198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoHMAC.hmacKey0; 1282198627Srrs hmac_keylen = sizeof(HMAC_t); 1283198627Srrs ctl_size = sizeof(HMAC_t); 1284198627Srrs break; 1285198627Srrs case XLR_SEC_VECTOR_CIPHER_ARC4: 1286198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4\n"); 1287198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoARC4.cipherKey0; 1288198627Srrs cipher_keylen = op->rc4_key_len; 1289198627Srrs ctl_size = sizeof(ARC4_t); 1290198627Srrs break; 1291198627Srrs case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC: 1292198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__HMAC\n"); 1293198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoARC4HMAC.cipherKey0; 1294198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoARC4HMAC.hmacKey0; 1295198627Srrs cipher_keylen = op->rc4_key_len; 1296198627Srrs hmac_keylen = sizeof(HMAC_t); 1297198627Srrs ctl_size = sizeof(ARC4HMAC_t); 1298198627Srrs break; 1299198627Srrs case XLR_SEC_VECTOR_CIPHER_ARC4__STATE: 1300198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__STATE\n"); 1301198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoARC4State.cipherKey0; 1302198627Srrs cipher_state = 1303198627Srrs &ctl_desc->cipherHashInfo.infoARC4State.Arc4SboxData0; 1304198627Srrs cipher_keylen = op->rc4_key_len; 1305198627Srrs ctl_size = sizeof(ARC4State_t); 1306198627Srrs break; 1307198627Srrs case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC__STATE: 1308198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__HMAC__STATE\n"); 1309198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoARC4StateHMAC.cipherKey0; 1310198627Srrs cipher_state = 1311198627Srrs &ctl_desc->cipherHashInfo.infoARC4StateHMAC.Arc4SboxData0; 1312198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoARC4StateHMAC.hmacKey0; 1313198627Srrs cipher_keylen = op->rc4_key_len; 1314198627Srrs hmac_keylen = sizeof(HMAC_t); 1315198627Srrs ctl_size = sizeof(ARC4StateHMAC_t); 1316198627Srrs break; 1317198627Srrs case XLR_SEC_VECTOR_CIPHER_KASUMI_F8: 1318198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8\n"); 1319198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8.cipherKey0; 1320198627Srrs cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH; 1321198627Srrs ctl_size = sizeof(KASUMIF8_t); 1322198627Srrs break; 1323198627Srrs case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC: 1324198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC\n"); 1325198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8HMAC.cipherKey0; 1326198627Srrs cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH; 1327198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoKASUMIF8HMAC.hmacKey0; 1328198627Srrs hmac_keylen = sizeof(HMAC_t); 1329198627Srrs ctl_size = sizeof(KASUMIF8HMAC_t); 1330198627Srrs break; 1331198627Srrs case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC2: 1332198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC2\n"); 1333198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8HMAC2.cipherKey0; 1334198627Srrs cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH; 1335198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoKASUMIF8HMAC2.hmacKey0; 1336198627Srrs hmac_keylen = sizeof(HMAC2_t); 1337198627Srrs ctl_size = sizeof(KASUMIF8HMAC2_t); 1338198627Srrs break; 1339198627Srrs case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__GCM: 1340198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__GCM\n"); 1341198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8GCM.cipherKey0; 1342198627Srrs cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH; 1343198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoKASUMIF8GCM.GCMH0; 1344198627Srrs hmac_keylen = sizeof(GCM_t); 1345198627Srrs ctl_size = sizeof(KASUMIF8GCM_t); 1346198627Srrs break; 1347198627Srrs case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__F9: 1348198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__F9\n"); 1349198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8F9.cipherKey0; 1350198627Srrs cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH; 1351198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoKASUMIF8F9.authKey0; 1352198627Srrs hmac_keylen = sizeof(F9_t); 1353198627Srrs ctl_size = sizeof(KASUMIF8F9_t); 1354198627Srrs break; 1355198627Srrs case XLR_SEC_VECTOR__CIPHER_DES__HMAC__MODE_ECB_CBC: 1356198627Srrs XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_DES__HMAC__MODE_ECB_CBC \n"); 1357198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoDESHMAC.cipherKey0; 1358198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoDESHMAC.hmacKey0; 1359198627Srrs hmac_keylen = sizeof(HMAC_t); 1360198627Srrs cipher_keylen = XLR_SEC_DES_KEY_LENGTH; 1361198627Srrs ctl_size = sizeof(DESHMAC_t); 1362198627Srrs break; 1363198627Srrs case XLR_SEC_VECTOR__CIPHER_DES__MODE_ECB_CBC: 1364198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_DES__MODE_ECB_CBC \n"); 1365198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoDES.cipherKey0; 1366198627Srrs cipher_keylen = XLR_SEC_DES_KEY_LENGTH; 1367198627Srrs ctl_size = sizeof(DES_t); 1368198627Srrs break; 1369198627Srrs case XLR_SEC_VECTOR__CIPHER_3DES__HMAC__MODE_ECB_CBC: 1370198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__HMAC__MODE_ECB_CBC \n"); 1371198627Srrs cipher_key = &ctl_desc->cipherHashInfo.info3DESHMAC.cipherKey0; 1372198627Srrs hmac_key = &ctl_desc->cipherHashInfo.info3DESHMAC.hmacKey0; 1373198627Srrs cipher_keylen = XLR_SEC_3DES_KEY_LENGTH; 1374198627Srrs hmac_keylen = sizeof(HMAC_t); 1375198627Srrs ctl_size = sizeof(DES3HMAC_t); 1376198627Srrs break; 1377198627Srrs case XLR_SEC_VECTOR__CIPHER_3DES__MODE_ECB_CBC: 1378198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__MODE_ECB_CBC \n"); 1379198627Srrs cipher_key = &ctl_desc->cipherHashInfo.info3DES.cipherKey0; 1380198627Srrs cipher_keylen = XLR_SEC_3DES_KEY_LENGTH; 1381198627Srrs ctl_size = sizeof(DES3_t); 1382198627Srrs break; 1383198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_CTR_CFB: 1384198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_CTR_CFB \n"); 1385198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES128HMAC.cipherKey0; 1386198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES128HMAC.hmacKey0; 1387198627Srrs cipher_keylen = XLR_SEC_AES128_KEY_LENGTH; 1388198627Srrs hmac_keylen = sizeof(HMAC_t); 1389198627Srrs ctl_size = sizeof(AES128HMAC_t); 1390198627Srrs break; 1391198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__MODE_CTR_CFB: 1392198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__MODE_CTR_CFB \n"); 1393198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES128.cipherKey0; 1394198627Srrs cipher_keylen = XLR_SEC_AES128_KEY_LENGTH; 1395198627Srrs ctl_size = sizeof(AES128_t); 1396198627Srrs break; 1397198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_ECB_CBC_OFB: 1398198627Srrs XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_ECB_CBC_OFB \n"); 1399198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES128HMAC.cipherKey0; 1400198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES128HMAC.hmacKey0; 1401198627Srrs cipher_keylen = XLR_SEC_AES128_KEY_LENGTH; 1402198627Srrs hmac_keylen = sizeof(HMAC_t); 1403198627Srrs ctl_size = sizeof(AES128HMAC_t); 1404198627Srrs break; 1405198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__MODE_ECB_CBC_OFB: 1406198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__MODE_ECB_CBC_OFB \n"); 1407198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES128.cipherKey0; 1408198627Srrs cipher_keylen = XLR_SEC_AES128_KEY_LENGTH; 1409198627Srrs ctl_size = sizeof(AES128_t); 1410198627Srrs break; 1411198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_F8: 1412198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_F8 \n"); 1413198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8HMAC.cipherKey0; 1414198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES128F8HMAC.hmacKey0; 1415198627Srrs cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH; 1416198627Srrs hmac_keylen = sizeof(HMAC_t); 1417198627Srrs ctl_size = sizeof(AES128F8HMAC_t); 1418198627Srrs break; 1419198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__MODE_F8: 1420198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__MODE_F8 \n"); 1421198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8.cipherKey0; 1422198627Srrs cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH; 1423198627Srrs ctl_size = sizeof(AES128F8_t); 1424198627Srrs break; 1425198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_CTR_CFB: 1426198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_CTR_CFB \n"); 1427198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES192HMAC.cipherKey0; 1428198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES192HMAC.hmacKey0; 1429198627Srrs cipher_keylen = XLR_SEC_AES192_KEY_LENGTH; 1430198627Srrs hmac_keylen = sizeof(HMAC_t); 1431198627Srrs ctl_size = sizeof(AES192HMAC_t); 1432198627Srrs break; 1433198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__MODE_CTR_CFB: 1434198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__MODE_CTR_CFB \n"); 1435198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES192.cipherKey0; 1436198627Srrs cipher_keylen = XLR_SEC_AES192_KEY_LENGTH; 1437198627Srrs ctl_size = sizeof(AES192_t); 1438198627Srrs break; 1439198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_ECB_CBC_OFB: 1440198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_ECB_CBC_OFB \n"); 1441198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES192HMAC.cipherKey0; 1442198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES192HMAC.hmacKey0; 1443198627Srrs cipher_keylen = XLR_SEC_AES192_KEY_LENGTH; 1444198627Srrs hmac_keylen = sizeof(HMAC_t); 1445198627Srrs ctl_size = sizeof(AES192HMAC_t); 1446198627Srrs break; 1447198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__MODE_ECB_CBC_OFB: 1448198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__MODE_ECB_CBC_OFB \n"); 1449198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES192.cipherKey0; 1450198627Srrs cipher_keylen = XLR_SEC_AES192_KEY_LENGTH; 1451198627Srrs ctl_size = sizeof(AES192_t); 1452198627Srrs break; 1453198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_F8: 1454198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_F8 \n"); 1455198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8HMAC.cipherKey0; 1456198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES192F8HMAC.hmacKey0; 1457198627Srrs cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH; 1458198627Srrs hmac_keylen = sizeof(HMAC_t); 1459198627Srrs ctl_size = sizeof(AES192F8HMAC_t); 1460198627Srrs break; 1461198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__MODE_F8: 1462198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__MODE_F8 \n"); 1463198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8.cipherKey0; 1464198627Srrs cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH; 1465198627Srrs ctl_size = sizeof(AES192F8_t); 1466198627Srrs break; 1467198157Srrs 1468198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_CTR_CFB: 1469198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_CTR_CFB \n"); 1470198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES256HMAC.cipherKey0; 1471198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES256HMAC.hmacKey0; 1472198627Srrs cipher_keylen = XLR_SEC_AES256_KEY_LENGTH; 1473198627Srrs hmac_keylen = sizeof(HMAC_t); 1474198627Srrs ctl_size = sizeof(AES256HMAC_t); 1475198627Srrs break; 1476198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__MODE_CTR_CFB: 1477198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__MODE_CTR_CFB \n"); 1478198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES256.cipherKey0; 1479198627Srrs cipher_keylen = XLR_SEC_AES256_KEY_LENGTH; 1480198627Srrs ctl_size = sizeof(AES256_t); 1481198627Srrs break; 1482198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_ECB_CBC_OFB: 1483198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_ECB_CBC_OFB \n"); 1484198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES256HMAC.cipherKey0; 1485198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES256HMAC.hmacKey0; 1486198627Srrs cipher_keylen = XLR_SEC_AES256_KEY_LENGTH; 1487198627Srrs hmac_keylen = sizeof(HMAC_t); 1488198627Srrs ctl_size = sizeof(AES256HMAC_t); 1489198627Srrs break; 1490198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__MODE_ECB_CBC_OFB: 1491198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__MODE_ECB_CBC_OFB \n"); 1492198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES256.cipherKey0; 1493198627Srrs cipher_keylen = XLR_SEC_AES256_KEY_LENGTH; 1494198627Srrs ctl_size = sizeof(AES256_t); 1495198627Srrs break; 1496198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_F8: 1497198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_F8 \n"); 1498198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8HMAC.cipherKey0; 1499198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES256F8HMAC.hmacKey0; 1500198627Srrs cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH; 1501198627Srrs hmac_keylen = sizeof(HMAC_t); 1502198627Srrs ctl_size = sizeof(AES256F8HMAC_t); 1503198627Srrs break; 1504198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__MODE_F8: 1505198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__MODE_F8 \n"); 1506198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8.cipherKey0; 1507198627Srrs cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH; 1508198627Srrs ctl_size = sizeof(AES256F8_t); 1509198627Srrs break; 1510198627Srrs case XLR_SEC_VECTOR_HMAC2: 1511198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_HMAC2 \n"); 1512198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoHMAC2.hmacKey0; 1513198627Srrs hmac_keylen = sizeof(HMAC2_t); 1514198627Srrs ctl_size = sizeof(HMAC2_t); 1515198627Srrs break; 1516198627Srrs case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2: 1517198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2\n"); 1518198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoARC4HMAC2.cipherKey0; 1519198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoARC4HMAC2.hmacKey0; 1520198627Srrs cipher_keylen = op->rc4_key_len; 1521198627Srrs hmac_keylen = sizeof(HMAC2_t); 1522198627Srrs ctl_size = sizeof(ARC4HMAC2_t); 1523198627Srrs break; 1524198627Srrs case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2__STATE: 1525198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2__STATE\n"); 1526198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoARC4StateHMAC2.cipherKey0; 1527198627Srrs cipher_state = 1528198627Srrs &ctl_desc->cipherHashInfo.infoARC4StateHMAC2.Arc4SboxData0; 1529198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoARC4StateHMAC2.hmacKey0; 1530198627Srrs cipher_keylen = op->rc4_key_len; 1531198627Srrs hmac_keylen = sizeof(HMAC2_t); 1532198627Srrs ctl_size = sizeof(ARC4StateHMAC2_t); 1533198627Srrs break; 1534198627Srrs case XLR_SEC_VECTOR__CIPHER_DES__HMAC2__MODE_ECB_CBC: 1535198627Srrs XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_DES__HMAC2__MODE_ECB_CBC \n"); 1536198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoDESHMAC2.cipherKey0; 1537198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoDESHMAC2.hmacKey0; 1538198627Srrs hmac_keylen = sizeof(HMAC2_t); 1539198627Srrs cipher_keylen = XLR_SEC_DES_KEY_LENGTH; 1540198627Srrs ctl_size = sizeof(DESHMAC2_t); 1541198627Srrs break; 1542198627Srrs case XLR_SEC_VECTOR__CIPHER_3DES__HMAC2__MODE_ECB_CBC: 1543198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__HMAC2__MODE_ECB_CBC \n"); 1544198627Srrs cipher_key = &ctl_desc->cipherHashInfo.info3DESHMAC2.cipherKey0; 1545198627Srrs hmac_key = &ctl_desc->cipherHashInfo.info3DESHMAC2.hmacKey0; 1546198627Srrs cipher_keylen = XLR_SEC_3DES_KEY_LENGTH; 1547198627Srrs hmac_keylen = sizeof(HMAC2_t); 1548198627Srrs ctl_size = sizeof(DES3HMAC2_t); 1549198627Srrs break; 1550198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_CTR_CFB: 1551198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_CTR_CFB \n"); 1552198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES128HMAC2.cipherKey0; 1553198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES128HMAC2.hmacKey0; 1554198627Srrs cipher_keylen = XLR_SEC_AES128_KEY_LENGTH; 1555198627Srrs hmac_keylen = sizeof(HMAC2_t); 1556198627Srrs ctl_size = sizeof(AES128HMAC2_t); 1557198627Srrs break; 1558198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_ECB_CBC_OFB: 1559198627Srrs XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_ECB_CBC_OFB \n"); 1560198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES128HMAC2.cipherKey0; 1561198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES128HMAC2.hmacKey0; 1562198627Srrs cipher_keylen = XLR_SEC_AES128_KEY_LENGTH; 1563198627Srrs hmac_keylen = sizeof(HMAC2_t); 1564198627Srrs ctl_size = sizeof(AES128HMAC2_t); 1565198627Srrs break; 1566198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_F8: 1567198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_F8 \n"); 1568198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8HMAC2.cipherKey0; 1569198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES128F8HMAC2.hmacKey0; 1570198627Srrs cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH; 1571198627Srrs hmac_keylen = sizeof(HMAC2_t); 1572198627Srrs ctl_size = sizeof(AES128F8HMAC2_t); 1573198627Srrs break; 1574198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_CTR_CFB: 1575198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_CTR_CFB \n"); 1576198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES192HMAC2.cipherKey0; 1577198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES192HMAC2.hmacKey0; 1578198627Srrs cipher_keylen = XLR_SEC_AES192_KEY_LENGTH; 1579198627Srrs hmac_keylen = sizeof(HMAC2_t); 1580198627Srrs ctl_size = sizeof(AES192HMAC2_t); 1581198627Srrs break; 1582198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_ECB_CBC_OFB: 1583198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_ECB_CBC_OFB \n"); 1584198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES192HMAC2.cipherKey0; 1585198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES192HMAC2.hmacKey0; 1586198627Srrs cipher_keylen = XLR_SEC_AES192_KEY_LENGTH; 1587198627Srrs hmac_keylen = sizeof(HMAC2_t); 1588198627Srrs ctl_size = sizeof(AES192HMAC2_t); 1589198627Srrs break; 1590198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_F8: 1591198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_F8 \n"); 1592198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8HMAC2.cipherKey0; 1593198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES192F8HMAC2.hmacKey0; 1594198627Srrs cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH; 1595198627Srrs hmac_keylen = sizeof(HMAC2_t); 1596198627Srrs ctl_size = sizeof(AES192F8HMAC2_t); 1597198627Srrs break; 1598198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_CTR_CFB: 1599198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_CTR_CFB \n"); 1600198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES256HMAC2.cipherKey0; 1601198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES256HMAC2.hmacKey0; 1602198627Srrs cipher_keylen = XLR_SEC_AES256_KEY_LENGTH; 1603198627Srrs hmac_keylen = sizeof(HMAC2_t); 1604198627Srrs ctl_size = sizeof(AES256HMAC2_t); 1605198627Srrs break; 1606198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_ECB_CBC_OFB: 1607198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_ECB_CBC_OFB \n"); 1608198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES256HMAC2.cipherKey0; 1609198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES256HMAC2.hmacKey0; 1610198627Srrs cipher_keylen = XLR_SEC_AES256_KEY_LENGTH; 1611198627Srrs hmac_keylen = sizeof(HMAC2_t); 1612198627Srrs ctl_size = sizeof(AES256HMAC2_t); 1613198627Srrs break; 1614198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_F8: 1615198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_F8 \n"); 1616198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8HMAC2.cipherKey0; 1617198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES256F8HMAC2.hmacKey0; 1618198627Srrs cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH; 1619198627Srrs hmac_keylen = sizeof(HMAC2_t); 1620198627Srrs ctl_size = sizeof(AES256F8HMAC2_t); 1621198627Srrs break; 1622198627Srrs case XLR_SEC_VECTOR_GCM: 1623198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_GCM \n"); 1624198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoGCM.GCMH0; 1625198627Srrs hmac_keylen = sizeof(GCM_t); 1626198627Srrs ctl_size = sizeof(GCM_t); 1627198627Srrs break; 1628198627Srrs case XLR_SEC_VECTOR_CIPHER_ARC4__GCM: 1629198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__GCM\n"); 1630198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoARC4GCM.cipherKey0; 1631198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoARC4GCM.GCMH0; 1632198627Srrs cipher_keylen = op->rc4_key_len; 1633198627Srrs hmac_keylen = sizeof(GCM_t); 1634198627Srrs ctl_size = sizeof(ARC4GCM_t); 1635198627Srrs break; 1636198627Srrs case XLR_SEC_VECTOR_CIPHER_ARC4__GCM__STATE: 1637198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__GCM__STATE\n"); 1638198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoARC4StateGCM.cipherKey0; 1639198627Srrs cipher_state = 1640198627Srrs &ctl_desc->cipherHashInfo.infoARC4StateGCM.Arc4SboxData0; 1641198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoARC4StateGCM.GCMH0; 1642198627Srrs cipher_keylen = op->rc4_key_len; 1643198627Srrs hmac_keylen = sizeof(GCM_t); 1644198627Srrs ctl_size = sizeof(ARC4StateGCM_t); 1645198627Srrs break; 1646198627Srrs case XLR_SEC_VECTOR__CIPHER_DES__GCM__MODE_ECB_CBC: 1647198627Srrs XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_DES__GCM__MODE_ECB_CBC \n"); 1648198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoDESGCM.cipherKey0; 1649198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoDESGCM.GCMH0; 1650198627Srrs hmac_keylen = sizeof(GCM_t); 1651198627Srrs cipher_keylen = XLR_SEC_DES_KEY_LENGTH; 1652198627Srrs ctl_size = sizeof(DESGCM_t); 1653198627Srrs break; 1654198627Srrs case XLR_SEC_VECTOR__CIPHER_3DES__GCM__MODE_ECB_CBC: 1655198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__GCM__MODE_ECB_CBC \n"); 1656198627Srrs cipher_key = &ctl_desc->cipherHashInfo.info3DESGCM.cipherKey0; 1657198627Srrs hmac_key = &ctl_desc->cipherHashInfo.info3DESGCM.GCMH0; 1658198627Srrs cipher_keylen = XLR_SEC_3DES_KEY_LENGTH; 1659198627Srrs hmac_keylen = sizeof(GCM_t); 1660198627Srrs ctl_size = sizeof(DES3GCM_t); 1661198627Srrs break; 1662198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_CTR_CFB: 1663198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_CTR_CFB \n"); 1664198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES128GCM.cipherKey0; 1665198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES128GCM.GCMH0; 1666198627Srrs cipher_keylen = XLR_SEC_AES128_KEY_LENGTH; 1667198627Srrs hmac_keylen = sizeof(GCM_t); 1668198627Srrs ctl_size = sizeof(AES128GCM_t); 1669198627Srrs break; 1670198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_ECB_CBC_OFB: 1671198627Srrs XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_ECB_CBC_OFB \n"); 1672198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES128GCM.cipherKey0; 1673198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES128GCM.GCMH0; 1674198627Srrs cipher_keylen = XLR_SEC_AES128_KEY_LENGTH; 1675198627Srrs hmac_keylen = sizeof(GCM_t); 1676198627Srrs ctl_size = sizeof(AES128GCM_t); 1677198627Srrs break; 1678198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_F8: 1679198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_F8 \n"); 1680198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8GCM.cipherKey0; 1681198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES128F8GCM.GCMH0; 1682198627Srrs cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH; 1683198627Srrs hmac_keylen = sizeof(GCM_t); 1684198627Srrs ctl_size = sizeof(AES128F8GCM_t); 1685198627Srrs break; 1686198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_CTR_CFB: 1687198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_CTR_CFB \n"); 1688198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES192GCM.cipherKey0; 1689198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES192GCM.GCMH0; 1690198627Srrs cipher_keylen = XLR_SEC_AES192_KEY_LENGTH; 1691198627Srrs hmac_keylen = sizeof(GCM_t); 1692198627Srrs ctl_size = sizeof(AES192GCM_t); 1693198627Srrs break; 1694198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_ECB_CBC_OFB: 1695198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_ECB_CBC_OFB \n"); 1696198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES192GCM.cipherKey0; 1697198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES192GCM.GCMH0; 1698198627Srrs cipher_keylen = XLR_SEC_AES192_KEY_LENGTH; 1699198627Srrs hmac_keylen = sizeof(GCM_t); 1700198627Srrs ctl_size = sizeof(AES192GCM_t); 1701198627Srrs break; 1702198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_F8: 1703198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_F8 \n"); 1704198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8GCM.cipherKey0; 1705198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES192F8GCM.GCMH0; 1706198627Srrs cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH; 1707198627Srrs hmac_keylen = sizeof(GCM_t); 1708198627Srrs ctl_size = sizeof(AES192F8GCM_t); 1709198627Srrs break; 1710198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_CTR_CFB: 1711198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_CTR_CFB \n"); 1712198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES256GCM.cipherKey0; 1713198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES256GCM.GCMH0; 1714198627Srrs cipher_keylen = XLR_SEC_AES256_KEY_LENGTH; 1715198627Srrs hmac_keylen = sizeof(GCM_t); 1716198627Srrs ctl_size = sizeof(AES256GCM_t); 1717198627Srrs break; 1718198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_ECB_CBC_OFB: 1719198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_ECB_CBC_OFB \n"); 1720198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES256GCM.cipherKey0; 1721198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES256GCM.GCMH0; 1722198627Srrs cipher_keylen = XLR_SEC_AES256_KEY_LENGTH; 1723198627Srrs hmac_keylen = sizeof(GCM_t); 1724198627Srrs ctl_size = sizeof(AES256GCM_t); 1725198627Srrs break; 1726198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_F8: 1727198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_F8 \n"); 1728198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8GCM.cipherKey0; 1729198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES256F8GCM.GCMH0; 1730198627Srrs cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH; 1731198627Srrs hmac_keylen = sizeof(GCM_t); 1732198627Srrs ctl_size = sizeof(AES256F8GCM_t); 1733198627Srrs break; 1734198627Srrs case XLR_SEC_VECTOR_F9: 1735198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_F9 \n"); 1736198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoF9.authKey0; 1737198627Srrs hmac_keylen = sizeof(F9_t); 1738198627Srrs ctl_size = sizeof(F9_t); 1739198627Srrs break; 1740198627Srrs case XLR_SEC_VECTOR_CIPHER_ARC4__F9: 1741198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__F9\n"); 1742198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoARC4F9.cipherKey0; 1743198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoARC4F9.authKey0; 1744198627Srrs cipher_keylen = op->rc4_key_len; 1745198627Srrs hmac_keylen = sizeof(F9_t); 1746198627Srrs ctl_size = sizeof(ARC4F9_t); 1747198627Srrs break; 1748198627Srrs case XLR_SEC_VECTOR_CIPHER_ARC4__F9__STATE: 1749198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__F9__STATE\n"); 1750198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoARC4StateF9.cipherKey0; 1751198627Srrs cipher_state = 1752198627Srrs &ctl_desc->cipherHashInfo.infoARC4StateF9.Arc4SboxData0; 1753198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoARC4StateF9.authKey0; 1754198627Srrs cipher_keylen = op->rc4_key_len; 1755198627Srrs hmac_keylen = sizeof(F9_t); 1756198627Srrs ctl_size = sizeof(ARC4StateF9_t); 1757198627Srrs break; 1758198627Srrs case XLR_SEC_VECTOR__CIPHER_DES__F9__MODE_ECB_CBC: 1759198627Srrs XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_DES__F9__MODE_ECB_CBC \n"); 1760198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoDESF9.cipherKey0; 1761198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoDESF9.authKey0; 1762198627Srrs hmac_keylen = sizeof(F9_t); 1763198627Srrs cipher_keylen = XLR_SEC_DES_KEY_LENGTH; 1764198627Srrs ctl_size = sizeof(DESF9_t); 1765198627Srrs break; 1766198627Srrs case XLR_SEC_VECTOR__CIPHER_3DES__F9__MODE_ECB_CBC: 1767198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__F9__MODE_ECB_CBC \n"); 1768198627Srrs cipher_key = &ctl_desc->cipherHashInfo.info3DESF9.cipherKey0; 1769198627Srrs hmac_key = &ctl_desc->cipherHashInfo.info3DESF9.authKey0; 1770198627Srrs cipher_keylen = XLR_SEC_3DES_KEY_LENGTH; 1771198627Srrs hmac_keylen = sizeof(F9_t); 1772198627Srrs ctl_size = sizeof(DES3F9_t); 1773198627Srrs break; 1774198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_CTR_CFB: 1775198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_CTR_CFB \n"); 1776198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES128F9.cipherKey0; 1777198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES128F9.authKey0; 1778198627Srrs cipher_keylen = XLR_SEC_AES128_KEY_LENGTH; 1779198627Srrs hmac_keylen = sizeof(F9_t); 1780198627Srrs ctl_size = sizeof(AES128F9_t); 1781198627Srrs break; 1782198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_ECB_CBC_OFB: 1783198627Srrs XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_ECB_CBC_OFB \n"); 1784198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES128F9.cipherKey0; 1785198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES128F9.authKey0; 1786198627Srrs cipher_keylen = XLR_SEC_AES128_KEY_LENGTH; 1787198627Srrs hmac_keylen = sizeof(F9_t); 1788198627Srrs ctl_size = sizeof(AES128F9_t); 1789198627Srrs break; 1790198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_F8: 1791198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_F8 \n"); 1792198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8F9.cipherKey0; 1793198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES128F8F9.authKey0; 1794198627Srrs cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH; 1795198627Srrs hmac_keylen = sizeof(F9_t); 1796198627Srrs ctl_size = sizeof(AES128F8F9_t); 1797198627Srrs break; 1798198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_CTR_CFB: 1799198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_CTR_CFB \n"); 1800198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES192F9.cipherKey0; 1801198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES192F9.authKey0; 1802198627Srrs cipher_keylen = XLR_SEC_AES192_KEY_LENGTH; 1803198627Srrs hmac_keylen = sizeof(F9_t); 1804198627Srrs ctl_size = sizeof(AES192F9_t); 1805198627Srrs break; 1806198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_ECB_CBC_OFB: 1807198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_ECB_CBC_OFB \n"); 1808198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES192F9.cipherKey0; 1809198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES192F9.authKey0; 1810198627Srrs cipher_keylen = XLR_SEC_AES192_KEY_LENGTH; 1811198627Srrs hmac_keylen = sizeof(F9_t); 1812198627Srrs ctl_size = sizeof(AES192F9_t); 1813198627Srrs break; 1814198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_F8: 1815198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_F8 \n"); 1816198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8F9.cipherKey0; 1817198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES192F8F9.authKey0; 1818198627Srrs cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH; 1819198627Srrs hmac_keylen = sizeof(F9_t); 1820198627Srrs ctl_size = sizeof(AES192F8F9_t); 1821198627Srrs break; 1822198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_CTR_CFB: 1823198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_CTR_CFB \n"); 1824198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES256F9.cipherKey0; 1825198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES256F9.authKey0; 1826198627Srrs cipher_keylen = XLR_SEC_AES256_KEY_LENGTH; 1827198627Srrs hmac_keylen = sizeof(F9_t); 1828198627Srrs ctl_size = sizeof(AES256F9_t); 1829198627Srrs break; 1830198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_ECB_CBC_OFB: 1831198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_ECB_CBC_OFB \n"); 1832198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES256F9.cipherKey0; 1833198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES256F9.authKey0; 1834198627Srrs cipher_keylen = XLR_SEC_AES256_KEY_LENGTH; 1835198627Srrs hmac_keylen = sizeof(F9_t); 1836198627Srrs ctl_size = sizeof(AES256F9_t); 1837198627Srrs break; 1838198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_F8: 1839198627Srrs XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_F8 \n"); 1840198627Srrs cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8F9.cipherKey0; 1841198627Srrs hmac_key = &ctl_desc->cipherHashInfo.infoAES256F8F9.authKey0; 1842198627Srrs cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH; 1843198627Srrs hmac_keylen = sizeof(F9_t); 1844198627Srrs ctl_size = sizeof(AES256F8F9_t); 1845198627Srrs break; 1846198157Srrs 1847198627Srrs default: 1848198627Srrs XLR_SEC_CMD_DIAG("default \n"); 1849198627Srrs return XLR_SEC_ERR_CONTROL_VECTOR; 1850198627Srrs } 1851198157Srrs 1852198627Srrs if ((cipher_key != NULL) && !(flags & XLR_SEC_SETUP_OP_PRESERVE_CIPHER_KEY)) 1853198627Srrs memcpy(cipher_key, &op->crypt_key[0], cipher_keylen); 1854198157Srrs 1855198627Srrs if ((hmac_key != NULL) && !(flags & XLR_SEC_SETUP_OP_PRESERVE_HMAC_KEY)) 1856198627Srrs memcpy(hmac_key, &op->mac_key[0], hmac_keylen); 1857198627Srrs if (cipher_state) { 1858198627Srrs if (op->rc4_loadstate) 1859198627Srrs memcpy(cipher_state, (void *)(unsigned long)op->rc4_state, 1860198157Srrs XLR_SEC_MAX_RC4_STATE_SIZE); 1861198627Srrs if (op->rc4_savestate) 1862198627Srrs user->aligned_state = (char *)cipher_state; 1863198627Srrs } 1864198627Srrs if (flags & XLR_SEC_SETUP_OP_FLIP_3DES_KEY) { 1865198627Srrs uint64_t temp; 1866198157Srrs 1867198627Srrs temp = ctl_desc->cipherHashInfo.info3DES.cipherKey0; 1868198627Srrs ctl_desc->cipherHashInfo.info3DES.cipherKey0 = 1869198627Srrs ctl_desc->cipherHashInfo.info3DES.cipherKey2; 1870198627Srrs ctl_desc->cipherHashInfo.info3DES.cipherKey2 = temp; 1871198627Srrs } 1872198627Srrs /* 1873198627Srrs * Control length is the number of control cachelines to be read so 1874198627Srrs * user needs to round up the control length to closest integer 1875198627Srrs * multiple of 32 bytes. 1876198627Srrs */ 1877198627Srrs ctl_size += sizeof(ctl_desc->instruction); 1878198627Srrs ctl_len = NUM_CHUNKS(ctl_size, 5); 1879198627Srrs XLR_SEC_CMD_DIAG("ctl_size in bytes: %u, in cachelines: %u\n", ctl_size, ctl_len); 1880198627Srrs CLEAR_SET_FIELD(*control, MSG_CMD_CTL_LEN, ctl_len); 1881198157Srrs 1882198627Srrs ctl_addr = (uint64_t) vtophys(ctl_desc); 1883198627Srrs CLEAR_SET_FIELD(*control, MSG_CMD_CTL_ADDR, ctl_addr); 1884198157Srrs 1885198627Srrs XLR_SEC_CMD_DIAG(" xlr_sec_control_setup(): ctl_desc=%p ctl_addr=%llx \n", 1886198627Srrs ctl_desc, (unsigned long long)ctl_addr); 1887198157Srrs 1888198627Srrs CLEAR_SET_FIELD(*control, MSG_CMD_CTL_CTL, SEC_SOP); 1889198157Srrs 1890198627Srrs return XLR_SEC_ERR_NONE; 1891198157Srrs} 1892198157Srrs 1893198157Srrsxlr_sec_error_t 1894198157Srrsxlr_sec_submit_op(symkey_desc_pt desc) 1895198157Srrs{ 1896198627Srrs struct msgrng_msg send_msg; 1897198157Srrs 1898198627Srrs int rsp_dest_id, cpu, hard_cpu, hard_thread; 1899198627Srrs int code, retries; 1900198627Srrs unsigned long msgrng_flags = 0; 1901198157Srrs 1902198627Srrs /* threads (0-3) are orthogonal to buckets 0-3 */ 1903198627Srrs cpu = xlr_cpu_id(); 1904198157Srrs 1905198627Srrs hard_cpu = cpu >> 2; 1906198627Srrs hard_thread = cpu & 0x3;/* thread id */ 1907198627Srrs rsp_dest_id = (hard_cpu << 3) + hard_thread; 1908198157Srrs 1909198627Srrs desc->op_ctl.cpu = hard_cpu; 1910198627Srrs desc->op_ctl.flags = 0; /* called from kernel thread */ 1911198157Srrs 1912198627Srrs XLR_SEC_CMD_DIAG("[%s]:%d: cpu=0x%x hard_cpu=0x%x hard_thrd=0x%x id=0x%x \n", 1913198627Srrs __FUNCTION__, __LINE__, cpu, hard_cpu, hard_thread, rsp_dest_id); 1914198157Srrs 1915198627Srrs /* 1916198627Srrs * Set DestId in Message Control Word. This tells the Security 1917198627Srrs * Engine which bucket to send the reply to for this CPU 1918198627Srrs */ 1919198627Srrs CLEAR_SET_FIELD(desc->control, MSG_CMD_CTL_ID, rsp_dest_id); 1920198627Srrs CLEAR_SET_FIELD(desc->data, MSG_CMD_CTL_ID, rsp_dest_id); 1921198157Srrs 1922198627Srrs CLEAR_SET_FIELD(desc->control, MSG_CTL_OP_TYPE, MSG0_CTL_OP_ENGINE_SYMKEY); 1923198627Srrs CLEAR_SET_FIELD(desc->data, MSG_CTL_OP_TYPE, MSG1_CTL_OP_SYMKEY_PIPE0); 1924198157Srrs 1925198627Srrs send_msg.msg0 = desc->control | (1ULL << 53); 1926198627Srrs send_msg.msg1 = desc->data | (1ULL << 53) | (1ULL << 52); 1927198627Srrs send_msg.msg2 = send_msg.msg3 = 0; 1928198157Srrs 1929198627Srrs desc->op_ctl.flags = 1; 1930198627Srrs //in_interrupt(); /* ipsec softirq ? */ 1931198157Srrs 1932198627Srrs XLR_SEC_CMD_DIAG("[%s]: IN_IRQ=%d msg0=0x%llx msg1=0x%llx \n", 1933198627Srrs __FUNCTION__, desc->op_ctl.flags, send_msg.msg0, send_msg.msg1); 1934198157Srrs 1935198627Srrs retries = 100; 1936198627Srrs while (retries--) { 1937212763Sjchandra msgrng_flags = msgrng_access_enable(); 1938212763Sjchandra code = message_send(SEC_MSGRING_WORDSIZE, MSGRNG_CODE_SEC, 1939212763Sjchandra desc->op_ctl.stn_id, &send_msg); 1940212763Sjchandra msgrng_restore(msgrng_flags); 1941198627Srrs if (code == 0) 1942198627Srrs break; 1943198627Srrs } 1944198627Srrs return (XLR_SEC_ERR_NONE); 1945198157Srrs} 1946198157Srrs 1947198627Srrssymkey_desc_pt 1948198627Srrsxlr_sec_allocate_desc(void *session_ptr) 1949198157Srrs{ 1950198627Srrs uint64_t addr; 1951198627Srrs symkey_desc_pt aligned, new; 1952198157Srrs 1953198627Srrs new = (symkey_desc_pt) malloc(sizeof(symkey_desc_t), 1954198627Srrs M_DEVBUF, M_NOWAIT | M_ZERO); 1955198157Srrs 1956198627Srrs if (new == NULL) 1957198627Srrs return (NULL); 1958198157Srrs 1959198627Srrs new->ses = session_ptr; 1960198157Srrs 1961198627Srrs new->user.kern_src = new->user.aligned_src = 1962198627Srrs (uint8_t *) contigmalloc(256 * 1024 + 1024, 1963198627Srrs M_DEVBUF, M_NOWAIT | M_ZERO, 1964198627Srrs 0, 0xffffffff, XLR_CACHELINE_SIZE, 0); 1965198157Srrs 1966198627Srrs if (new->user.kern_src == NULL) { 1967198627Srrs printf("ERROR - malloc failed for user.kern_src\n"); 1968198627Srrs return NULL; 1969198627Srrs } 1970198627Srrs new->user.aligned_dest = new->user.kern_dest = 1971198627Srrs (uint8_t *) contigmalloc(257 * 1024, 1972198627Srrs M_DEVBUF, M_NOWAIT | M_ZERO, 1973198627Srrs 0, 0xffffffff, XLR_CACHELINE_SIZE, 0); 1974198157Srrs 1975198627Srrs if (new->user.aligned_dest == NULL) { 1976198627Srrs printf("ERROR - malloc failed for user.aligned_dest\n"); 1977198627Srrs return NULL; 1978198627Srrs } 1979198627Srrs new->next_src_buf = (uint8_t *) contigmalloc(256 * 1024 + 1024, 1980198627Srrs M_DEVBUF, M_NOWAIT | M_ZERO, 1981198627Srrs 0, 0xffffffff, XLR_CACHELINE_SIZE, 0); 1982198157Srrs 1983198627Srrs if (new->next_src_buf == NULL) { 1984198627Srrs printf("ERROR - malloc failed for next_src_buf\n"); 1985198627Srrs return NULL; 1986198627Srrs } 1987198627Srrs new->next_dest_buf = 1988198627Srrs (uint8_t *) contigmalloc(257 * 1024, 1989198627Srrs M_DEVBUF, M_NOWAIT | M_ZERO, 1990198627Srrs 0, 0xffffffff, XLR_CACHELINE_SIZE, 0); 1991198157Srrs 1992198627Srrs if (new->next_dest_buf == NULL) { 1993198627Srrs printf("ERROR - malloc failed for next_dest_buf\n"); 1994198627Srrs return NULL; 1995198627Srrs } 1996198627Srrs new->user.kern_auth = new->user.user_auth = NULL; 1997198627Srrs new->user.aligned_auth = new->user.user_auth = NULL; 1998198157Srrs 1999198627Srrs /* find cacheline alignment */ 2000198627Srrs aligned = new; 2001198627Srrs addr = (uint64_t) vtophys(new); 2002198157Srrs 2003198627Srrs /* save for free */ 2004198627Srrs aligned->alloc = new; 2005198157Srrs 2006198627Srrs /* setup common control info */ 2007198627Srrs aligned->op_ctl.phys_self = addr; 2008198627Srrs aligned->op_ctl.stn_id = MSGRNG_STNID_SEC0; 2009212763Sjchandra aligned->op_ctl.vaddr = (uintptr_t)aligned; 2010198157Srrs 2011198627Srrs return (aligned); 2012198157Srrs} 2013198157Srrs 2014198157Srrs 2015198627Srrsstatic void 2016198627Srrsxlr_sec_free_desc(symkey_desc_pt desc) 2017198157Srrs{ 2018198627Srrs if ((desc == NULL) || (desc->alloc == NULL)) { 2019198627Srrs printf("%s: NULL descriptor \n", __FUNCTION__); 2020198627Srrs return; 2021198627Srrs } 2022198627Srrs contigfree(desc, sizeof(symkey_desc_t), M_DEVBUF); 2023198627Srrs return; 2024198157Srrs} 2025198157Srrs 2026198627Srrsvoid 2027198627Srrsprint_buf(char *desc, void *data, int len) 2028198157Srrs{ 2029198627Srrs uint8_t *dp; 2030198627Srrs int i; 2031198157Srrs 2032198627Srrs DPRINT("%s: ", desc); /* newline done in for-loop */ 2033198627Srrs dp = data; 2034198627Srrs for (i = 0; i < len; i++, dp++) { 2035198627Srrs if ((i % 16) == 0) 2036198627Srrs DPRINT("\n"); 2037198627Srrs DPRINT(" %c%c", 2038198627Srrs nib2hex[(((*dp) & 0xf0) >> 4)], 2039198627Srrs nib2hex[((*dp) & 0x0f)]); 2040198627Srrs } 2041198627Srrs DPRINT("\n"); 2042198157Srrs} 2043198157Srrs 2044198157Srrs 2045198157Srrs#ifdef XLR_SEC_CMD_DEBUG 2046198157Srrsstatic void 2047198627Srrsdecode_symkey_desc(symkey_desc_pt desc, uint32_t cfg_vector) 2048198157Srrs{ 2049198157Srrs 2050198627Srrs unsigned long long word; 2051198157Srrs 2052198627Srrs /* uint8_t *info; */ 2053198627Srrs /* int i; */ 2054198157Srrs 2055198627Srrs DPRINT("MSG - CTL: \n"); 2056198627Srrs DPRINT("\t CTRL = %lld \n", 2057198627Srrs GET_FIELD(desc->control, MSG_CMD_CTL_CTL)); 2058198627Srrs DPRINT("\t CTRL LEN = %lld \n", 2059198627Srrs GET_FIELD(desc->control, MSG_CMD_CTL_LEN)); 2060198627Srrs DPRINT("\t CTRL ADDR = %llx \n\n", 2061198627Srrs GET_FIELD(desc->control, MSG_CMD_CTL_ADDR)); 2062198157Srrs 2063198627Srrs DPRINT("MSG - DATA: \n"); 2064198627Srrs DPRINT("\t CTRL = %lld \n", 2065198627Srrs GET_FIELD(desc->data, MSG_CMD_DATA_CTL)); 2066198627Srrs DPRINT("\t DATA LEN = %lld \n", 2067198627Srrs GET_FIELD(desc->data, MSG_CMD_DATA_LEN)); 2068198627Srrs DPRINT("\t DATA ADDR = %llx \n\n", 2069198627Srrs GET_FIELD(desc->data, MSG_CMD_DATA_ADDR)); 2070198627Srrs 2071198627Srrs DPRINT("CONTROL DESCRIPTOR: \n"); 2072198627Srrs word = desc->ctl_desc.instruction; 2073198627Srrs DPRINT("\tINSTRUCTION: %llx\n", word); 2074198627Srrs DPRINT("\t\tOVERRIDE CIPH = %lld \n", GET_FIELD(word, CTL_DSC_OVERRIDECIPHER)); 2075198627Srrs DPRINT("\t\tARC4 WAIT = %lld \n", GET_FIELD(word, CTL_DSC_ARC4_WAIT4SAVE)); 2076198627Srrs DPRINT("\t\tARC4 SAVE = %lld \n", GET_FIELD(word, CTL_DSC_ARC4_SAVESTATE)); 2077198627Srrs DPRINT("\t\tARC4 LOAD = %lld \n", GET_FIELD(word, CTL_DSC_ARC4_LOADSTATE)); 2078198627Srrs DPRINT("\t\tARC4 KEYLEN = %lld \n", GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2079198627Srrs DPRINT("\t\tCIPHER = %lld \n", GET_FIELD(word, CTL_DSC_CPHR)); 2080198627Srrs DPRINT("\t\tCIPHER MODE = %lld \n", GET_FIELD(word, CTL_DSC_MODE)); 2081198627Srrs DPRINT("\t\tINIT CIPHER = %lld \n", GET_FIELD(word, CTL_DSC_ICPHR)); 2082198627Srrs DPRINT("\t\tHMAC = %lld \n", GET_FIELD(word, CTL_DSC_HMAC)); 2083198627Srrs DPRINT("\t\tHASH ALG = %lld \n", GET_FIELD(word, CTL_DSC_HASH) | (GET_FIELD(word, CTL_DSC_HASHHI) << 2)); 2084198627Srrs DPRINT("\t\tINIT HASH = %lld \n", GET_FIELD(word, CTL_DSC_IHASH)); 2085198627Srrs DPRINT("\t\tCHKSUM = %lld \n", GET_FIELD(word, CTL_DSC_CKSUM)); 2086198627Srrs DPRINT("\tCIPHER HASH INFO: \n"); 2087198157Srrs#if 0 2088198627Srrs info = (uint8_t *) & desc->ctl_desc->cipherHashInfo; 2089198627Srrs for (i = 0; i < sizeof(CipherHashInfo_t); i++, info++) { 2090198627Srrs DPRINT(" %02x", *info); 2091198627Srrs if (i && (i % 16) == 0) 2092198627Srrs DPRINT("\n"); 2093198627Srrs } 2094198627Srrs DPRINT("\n\n"); 2095198157Srrs#endif 2096198157Srrs 2097198627Srrs switch (cfg_vector) { 2098198627Srrs case XLR_SEC_VECTOR_CIPHER_ARC4: 2099198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4 \n"); 2100198627Srrs print_buf("ARC4 Key", 2101198627Srrs &desc->ctl_desc.cipherHashInfo.infoARC4.cipherKey0, 2102198627Srrs GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2103198627Srrs break; 2104198627Srrs case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC: 2105198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__HMAC \n"); 2106198627Srrs print_buf("ARC4 Key", 2107198627Srrs &desc->ctl_desc.cipherHashInfo.infoARC4HMAC.cipherKey0, 2108198627Srrs GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2109198627Srrs print_buf("HMAC Key", 2110198627Srrs &desc->ctl_desc.cipherHashInfo.infoARC4HMAC.hmacKey0, 2111198627Srrs sizeof(HMAC_t)); 2112198627Srrs break; 2113198627Srrs case XLR_SEC_VECTOR_CIPHER_ARC4__STATE: 2114198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__STATE \n"); 2115198627Srrs print_buf("ARC4 Key", 2116198627Srrs &desc->ctl_desc.cipherHashInfo.infoARC4State.cipherKey0, 2117198627Srrs GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2118198627Srrs break; 2119198627Srrs case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC__STATE: 2120198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__HMAC__STATE \n"); 2121198627Srrs print_buf("ARC4 Key", 2122198627Srrs &desc->ctl_desc.cipherHashInfo.infoARC4StateHMAC.cipherKey0, 2123198627Srrs GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2124198627Srrs print_buf("HMAC Key", 2125198627Srrs &desc->ctl_desc.cipherHashInfo.infoARC4StateHMAC.hmacKey0, 2126198627Srrs sizeof(HMAC_t)); 2127198627Srrs break; 2128198627Srrs case XLR_SEC_VECTOR_CIPHER_KASUMI_F8: 2129198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_KASUMI_F8 \n"); 2130198627Srrs print_buf("KASUMI_F8 Key", 2131198627Srrs &desc->ctl_desc.cipherHashInfo.infoKASUMIF8.cipherKey0, 2132198627Srrs XLR_SEC_KASUMI_F8_KEY_LENGTH); 2133198627Srrs break; 2134198627Srrs case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC: 2135198627Srrs DPRINT("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC\n"); 2136198627Srrs print_buf("KASUMI_F8 Key", 2137198627Srrs &desc->ctl_desc.cipherHashInfo.infoKASUMIF8HMAC.cipherKey0, 2138198627Srrs XLR_SEC_KASUMI_F8_KEY_LENGTH); 2139198627Srrs print_buf("HMAC Key", 2140198627Srrs &desc->ctl_desc.cipherHashInfo.infoKASUMIF8HMAC.hmacKey0, 2141198627Srrs sizeof(HMAC_t)); 2142198627Srrs break; 2143198627Srrs case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC2: 2144198627Srrs DPRINT("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC2\n"); 2145198627Srrs print_buf("KASUMI_F8 Key", 2146198627Srrs &desc->ctl_desc.cipherHashInfo.infoKASUMIF8HMAC2.cipherKey0, 2147198627Srrs XLR_SEC_KASUMI_F8_KEY_LENGTH); 2148198627Srrs print_buf("HMAC2 Key", 2149198627Srrs &desc->ctl_desc.cipherHashInfo.infoKASUMIF8HMAC2.hmacKey0, 2150198627Srrs sizeof(HMAC2_t)); 2151198627Srrs break; 2152198627Srrs case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__GCM: 2153198627Srrs DPRINT("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__GCM\n"); 2154198627Srrs print_buf("KASUMI_F8 Key", 2155198627Srrs &desc->ctl_desc.cipherHashInfo.infoKASUMIF8GCM.cipherKey0, 2156198627Srrs XLR_SEC_KASUMI_F8_KEY_LENGTH); 2157198627Srrs print_buf("GCM Key", 2158198627Srrs &desc->ctl_desc.cipherHashInfo.infoKASUMIF8GCM.GCMH0, 2159198627Srrs sizeof(GCM_t)); 2160198627Srrs break; 2161198627Srrs case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__F9: 2162198627Srrs DPRINT("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__F9\n"); 2163198627Srrs print_buf("KASUMI_F8 Key", 2164198627Srrs &desc->ctl_desc.cipherHashInfo.infoKASUMIF8F9.cipherKey0, 2165198627Srrs XLR_SEC_KASUMI_F8_KEY_LENGTH); 2166198627Srrs print_buf("F9 Key", 2167198627Srrs &desc->ctl_desc.cipherHashInfo.infoKASUMIF8F9.authKey0, 2168198627Srrs sizeof(F9_t)); 2169198627Srrs break; 2170198627Srrs case XLR_SEC_VECTOR_MAC: 2171198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR_MAC \n"); 2172198627Srrs DPRINT("MAC-ONLY - No Info\n"); 2173198627Srrs break; 2174198627Srrs case XLR_SEC_VECTOR_HMAC: 2175198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR_HMAC \n"); 2176198627Srrs print_buf("HMAC Key", 2177198627Srrs &desc->ctl_desc.cipherHashInfo.infoHMAC.hmacKey0, 2178198627Srrs sizeof(HMAC_t)); 2179198627Srrs break; 2180198627Srrs case XLR_SEC_VECTOR__CIPHER_DES__HMAC__MODE_ECB_CBC: 2181198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_DES__HMAC__MODE_ECB_CBC \n"); 2182198627Srrs print_buf("CIPHER Key", 2183198627Srrs &desc->ctl_desc.cipherHashInfo.infoDESHMAC.cipherKey0, 2184198627Srrs XLR_SEC_DES_KEY_LENGTH); 2185198627Srrs print_buf("HMAC Key", 2186198627Srrs &desc->ctl_desc.cipherHashInfo.infoDESHMAC.hmacKey0, 2187198627Srrs sizeof(HMAC_t)); 2188198627Srrs break; 2189198627Srrs case XLR_SEC_VECTOR__CIPHER_DES__MODE_ECB_CBC: 2190198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_DES__MODE_ECB_CBC \n"); 2191198627Srrs print_buf("CIPHER Key", 2192198627Srrs &desc->ctl_desc.cipherHashInfo.infoDES.cipherKey0, 2193198627Srrs XLR_SEC_DES_KEY_LENGTH); 2194198627Srrs break; 2195198627Srrs case XLR_SEC_VECTOR__CIPHER_3DES__HMAC__MODE_ECB_CBC: 2196198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_3DES__HMAC__MODE_ECB_CBC \n"); 2197198627Srrs print_buf("CIPHER Key", 2198198627Srrs &desc->ctl_desc.cipherHashInfo.info3DESHMAC.cipherKey0, 2199198627Srrs XLR_SEC_3DES_KEY_LENGTH); 2200198627Srrs print_buf("HMAC Key", 2201198627Srrs &desc->ctl_desc.cipherHashInfo.info3DESHMAC.hmacKey0, 2202198627Srrs sizeof(HMAC_t)); 2203198627Srrs break; 2204198627Srrs case XLR_SEC_VECTOR__CIPHER_3DES__MODE_ECB_CBC: 2205198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_3DES__MODE_ECB_CBC \n"); 2206198627Srrs print_buf("CIPHER Key", 2207198627Srrs &desc->ctl_desc.cipherHashInfo.info3DES.cipherKey0, 2208198627Srrs XLR_SEC_3DES_KEY_LENGTH); 2209198627Srrs break; 2210198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_CTR_CFB: 2211198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_CTR_CFB \n"); 2212198627Srrs print_buf("CIPHER Key", 2213198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128HMAC.cipherKey0, 2214198627Srrs XLR_SEC_AES128_KEY_LENGTH); 2215198627Srrs print_buf("HMAC Key", 2216198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128HMAC.hmacKey0, 2217198627Srrs sizeof(HMAC_t)); 2218198627Srrs break; 2219198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__MODE_CTR_CFB: 2220198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__MODE_CTR_CFB \n"); 2221198627Srrs print_buf("CIPHER Key", 2222198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128.cipherKey0, 2223198627Srrs XLR_SEC_AES128_KEY_LENGTH); 2224198627Srrs break; 2225198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_ECB_CBC_OFB: 2226198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_ECB_CBC_OFB\n"); 2227198627Srrs print_buf("CIPHER Key", 2228198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128HMAC.cipherKey0, 2229198627Srrs XLR_SEC_AES128_KEY_LENGTH); 2230198627Srrs print_buf("HMAC Key", 2231198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128HMAC.hmacKey0, 2232198627Srrs sizeof(HMAC_t)); 2233198627Srrs break; 2234198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__MODE_ECB_CBC_OFB: 2235198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__MODE_ECB_CBC_OFB \n"); 2236198627Srrs print_buf("CIPHER Key", 2237198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128.cipherKey0, 2238198627Srrs XLR_SEC_AES128_KEY_LENGTH); 2239198627Srrs break; 2240198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_CTR_CFB: 2241198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_CTR_CFB \n"); 2242198627Srrs print_buf("CIPHER Key", 2243198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192HMAC.cipherKey0, 2244198627Srrs XLR_SEC_AES192_KEY_LENGTH); 2245198627Srrs print_buf("HMAC Key", 2246198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192HMAC.hmacKey0, 2247198627Srrs sizeof(HMAC_t)); 2248198627Srrs break; 2249198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__MODE_CTR_CFB: 2250198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__MODE_CTR_CFB \n"); 2251198627Srrs print_buf("CIPHER Key", 2252198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192.cipherKey0, 2253198627Srrs XLR_SEC_AES192_KEY_LENGTH); 2254198627Srrs break; 2255198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_ECB_CBC_OFB: 2256198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_ECB_CBC_OFB\n"); 2257198627Srrs print_buf("CIPHER Key", 2258198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192HMAC.cipherKey0, 2259198627Srrs XLR_SEC_AES192_KEY_LENGTH); 2260198627Srrs print_buf("HMAC Key", 2261198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192HMAC.hmacKey0, 2262198627Srrs sizeof(HMAC_t)); 2263198627Srrs break; 2264198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__MODE_ECB_CBC_OFB: 2265198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__MODE_ECB_CBC_OFB \n"); 2266198627Srrs print_buf("CIPHER Key", 2267198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192.cipherKey0, 2268198627Srrs XLR_SEC_AES192_KEY_LENGTH); 2269198627Srrs break; 2270198157Srrs 2271198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_CTR_CFB: 2272198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_CTR_CFB \n"); 2273198627Srrs print_buf("CIPHER Key", 2274198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256HMAC.cipherKey0, 2275198627Srrs XLR_SEC_AES256_KEY_LENGTH); 2276198627Srrs print_buf("HMAC Key", 2277198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256HMAC.hmacKey0, 2278198627Srrs sizeof(HMAC_t)); 2279198627Srrs break; 2280198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__MODE_CTR_CFB: 2281198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__MODE_CTR_CFB \n"); 2282198627Srrs print_buf("CIPHER Key", 2283198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256.cipherKey0, 2284198627Srrs XLR_SEC_AES256_KEY_LENGTH); 2285198627Srrs break; 2286198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_ECB_CBC_OFB: 2287198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_ECB_CBC_OFB \n"); 2288198627Srrs print_buf("CIPHER Key", 2289198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256HMAC.cipherKey0, 2290198627Srrs XLR_SEC_AES256_KEY_LENGTH); 2291198627Srrs print_buf("HMAC Key", 2292198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256HMAC.hmacKey0, 2293198627Srrs sizeof(HMAC_t)); 2294198627Srrs break; 2295198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__MODE_ECB_CBC_OFB: 2296198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__MODE_ECB_CBC_OFB \n"); 2297198627Srrs print_buf("CIPHER Key", 2298198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256.cipherKey0, 2299198627Srrs XLR_SEC_AES256_KEY_LENGTH); 2300198627Srrs break; 2301198627Srrs case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2: 2302198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2 \n"); 2303198627Srrs print_buf("ARC4 Key", 2304198627Srrs &desc->ctl_desc.cipherHashInfo.infoARC4HMAC2.cipherKey0, 2305198627Srrs GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2306198627Srrs print_buf("HMAC2 Key", 2307198627Srrs &desc->ctl_desc.cipherHashInfo.infoARC4HMAC2.hmacKey0, 2308198627Srrs sizeof(HMAC2_t)); 2309198627Srrs break; 2310198627Srrs case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2__STATE: 2311198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2__STATE \n"); 2312198627Srrs print_buf("ARC4 Key", 2313198627Srrs &desc->ctl_desc.cipherHashInfo.infoARC4StateHMAC2.cipherKey0, 2314198627Srrs GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2315198627Srrs print_buf("HMAC2 Key", 2316198627Srrs &desc->ctl_desc.cipherHashInfo.infoARC4StateHMAC2.hmacKey0, 2317198627Srrs sizeof(HMAC2_t)); 2318198627Srrs break; 2319198627Srrs case XLR_SEC_VECTOR_HMAC2: 2320198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR_HMAC2 \n"); 2321198627Srrs print_buf("HMAC2 Key", 2322198627Srrs &desc->ctl_desc.cipherHashInfo.infoHMAC2.hmacKey0, 2323198627Srrs sizeof(HMAC2_t)); 2324198627Srrs break; 2325198627Srrs case XLR_SEC_VECTOR__CIPHER_DES__HMAC2__MODE_ECB_CBC: 2326198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_DES__HMAC2__MODE_ECB_CBC \n"); 2327198627Srrs print_buf("CIPHER Key", 2328198627Srrs &desc->ctl_desc.cipherHashInfo.infoDESHMAC2.cipherKey0, 2329198627Srrs XLR_SEC_DES_KEY_LENGTH); 2330198627Srrs print_buf("HMAC2 Key", 2331198627Srrs &desc->ctl_desc.cipherHashInfo.infoDESHMAC2.hmacKey0, 2332198627Srrs sizeof(HMAC2_t)); 2333198627Srrs break; 2334198627Srrs case XLR_SEC_VECTOR__CIPHER_3DES__HMAC2__MODE_ECB_CBC: 2335198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_3DES__HMAC2__MODE_ECB_CBC \n"); 2336198627Srrs print_buf("CIPHER Key", 2337198627Srrs &desc->ctl_desc.cipherHashInfo.info3DESHMAC2.cipherKey0, 2338198627Srrs XLR_SEC_3DES_KEY_LENGTH); 2339198627Srrs print_buf("HMAC2 Key", 2340198627Srrs &desc->ctl_desc.cipherHashInfo.info3DESHMAC2.hmacKey0, 2341198627Srrs sizeof(HMAC2_t)); 2342198627Srrs break; 2343198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_CTR_CFB: 2344198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_CTR_CFB \n"); 2345198627Srrs print_buf("CIPHER Key", 2346198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128HMAC2.cipherKey0, 2347198627Srrs XLR_SEC_AES128_KEY_LENGTH); 2348198627Srrs print_buf("HMAC2 Key", 2349198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128HMAC2.hmacKey0, 2350198627Srrs sizeof(HMAC2_t)); 2351198627Srrs break; 2352198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_ECB_CBC_OFB: 2353198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_ECB_CBC_OFB\n"); 2354198627Srrs print_buf("CIPHER Key", 2355198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128HMAC2.cipherKey0, 2356198627Srrs XLR_SEC_AES128_KEY_LENGTH); 2357198627Srrs print_buf("HMAC2 Key", 2358198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128HMAC2.hmacKey0, 2359198627Srrs sizeof(HMAC2_t)); 2360198627Srrs break; 2361198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_CTR_CFB: 2362198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_CTR_CFB \n"); 2363198627Srrs print_buf("CIPHER Key", 2364198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192HMAC2.cipherKey0, 2365198627Srrs XLR_SEC_AES192_KEY_LENGTH); 2366198627Srrs print_buf("HMAC2 Key", 2367198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192HMAC2.hmacKey0, 2368198627Srrs sizeof(HMAC2_t)); 2369198627Srrs break; 2370198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_ECB_CBC_OFB: 2371198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_ECB_CBC_OFB\n"); 2372198627Srrs print_buf("CIPHER Key", 2373198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192HMAC2.cipherKey0, 2374198627Srrs XLR_SEC_AES192_KEY_LENGTH); 2375198627Srrs print_buf("HMAC2 Key", 2376198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192HMAC2.hmacKey0, 2377198627Srrs sizeof(HMAC2_t)); 2378198627Srrs break; 2379198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_CTR_CFB: 2380198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_CTR_CFB \n"); 2381198627Srrs print_buf("CIPHER Key", 2382198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256HMAC2.cipherKey0, 2383198627Srrs XLR_SEC_AES256_KEY_LENGTH); 2384198627Srrs print_buf("HMAC2 Key", 2385198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256HMAC2.hmacKey0, 2386198627Srrs sizeof(HMAC2_t)); 2387198627Srrs break; 2388198157Srrs 2389198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_ECB_CBC_OFB: 2390198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_ECB_CBC_OFB \n"); 2391198627Srrs print_buf("CIPHER Key", 2392198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256HMAC2.cipherKey0, 2393198627Srrs XLR_SEC_AES256_KEY_LENGTH); 2394198627Srrs print_buf("HMAC2 Key", 2395198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256HMAC2.hmacKey0, 2396198627Srrs sizeof(HMAC2_t)); 2397198627Srrs break; 2398198627Srrs case XLR_SEC_VECTOR_CIPHER_ARC4__GCM: 2399198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__GCM \n"); 2400198627Srrs print_buf("ARC4 Key", 2401198627Srrs &desc->ctl_desc.cipherHashInfo.infoARC4GCM.cipherKey0, 2402198627Srrs GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2403198627Srrs print_buf("GCM Key", 2404198627Srrs &desc->ctl_desc.cipherHashInfo.infoARC4GCM.GCMH0, 2405198627Srrs sizeof(GCM_t)); 2406198627Srrs break; 2407198627Srrs case XLR_SEC_VECTOR_CIPHER_ARC4__GCM__STATE: 2408198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__GCM__STATE \n"); 2409198627Srrs print_buf("ARC4 Key", 2410198627Srrs &desc->ctl_desc.cipherHashInfo.infoARC4StateGCM.cipherKey0, 2411198627Srrs GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2412198627Srrs print_buf("GCM Key", 2413198627Srrs &desc->ctl_desc.cipherHashInfo.infoARC4StateGCM.GCMH0, 2414198627Srrs sizeof(GCM_t)); 2415198627Srrs break; 2416198627Srrs case XLR_SEC_VECTOR_GCM: 2417198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR_GCM \n"); 2418198627Srrs print_buf("GCM Key", 2419198627Srrs &desc->ctl_desc.cipherHashInfo.infoGCM.GCMH0, 2420198627Srrs sizeof(GCM_t)); 2421198627Srrs break; 2422198627Srrs case XLR_SEC_VECTOR__CIPHER_DES__GCM__MODE_ECB_CBC: 2423198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_DES__GCM__MODE_ECB_CBC \n"); 2424198627Srrs print_buf("CIPHER Key", 2425198627Srrs &desc->ctl_desc.cipherHashInfo.infoDESGCM.cipherKey0, 2426198627Srrs XLR_SEC_DES_KEY_LENGTH); 2427198627Srrs print_buf("GCM Key", 2428198627Srrs &desc->ctl_desc.cipherHashInfo.infoDESGCM.GCMH0, 2429198627Srrs sizeof(GCM_t)); 2430198627Srrs break; 2431198627Srrs case XLR_SEC_VECTOR__CIPHER_3DES__GCM__MODE_ECB_CBC: 2432198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_3DES__GCM__MODE_ECB_CBC \n"); 2433198627Srrs print_buf("CIPHER Key", 2434198627Srrs &desc->ctl_desc.cipherHashInfo.info3DESGCM.cipherKey0, 2435198627Srrs XLR_SEC_3DES_KEY_LENGTH); 2436198627Srrs print_buf("GCM Key", 2437198627Srrs &desc->ctl_desc.cipherHashInfo.info3DESGCM.GCMH0, 2438198627Srrs sizeof(GCM_t)); 2439198627Srrs break; 2440198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_CTR_CFB: 2441198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_CTR_CFB \n"); 2442198627Srrs print_buf("CIPHER Key", 2443198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128GCM.cipherKey0, 2444198627Srrs XLR_SEC_AES128_KEY_LENGTH); 2445198627Srrs print_buf("GCM Key", 2446198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128GCM.GCMH0, 2447198627Srrs XLR_SEC_AES128_KEY_LENGTH); 2448198627Srrs break; 2449198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_ECB_CBC_OFB: 2450198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_ECB_CBC_OFB\n"); 2451198627Srrs print_buf("CIPHER Key", 2452198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128GCM.cipherKey0, 2453198627Srrs XLR_SEC_AES128_KEY_LENGTH); 2454198627Srrs print_buf("GCM Key", 2455198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128GCM.GCMH0, 2456198627Srrs XLR_SEC_AES128_KEY_LENGTH); 2457198627Srrs break; 2458198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_CTR_CFB: 2459198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_CTR_CFB \n"); 2460198627Srrs print_buf("CIPHER Key", 2461198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192GCM.cipherKey0, 2462198627Srrs XLR_SEC_AES192_KEY_LENGTH); 2463198627Srrs print_buf("GCM Key", 2464198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192GCM.GCMH0, 2465198627Srrs XLR_SEC_AES192_KEY_LENGTH); 2466198627Srrs break; 2467198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_ECB_CBC_OFB: 2468198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_ECB_CBC_OFB\n"); 2469198627Srrs print_buf("CIPHER Key", 2470198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192GCM.cipherKey0, 2471198627Srrs XLR_SEC_AES192_KEY_LENGTH); 2472198627Srrs print_buf("GCM Key", 2473198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192GCM.GCMH0, 2474198627Srrs XLR_SEC_AES192_KEY_LENGTH); 2475198627Srrs break; 2476198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_CTR_CFB: 2477198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_CTR_CFB \n"); 2478198627Srrs print_buf("CIPHER Key", 2479198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256GCM.cipherKey0, 2480198627Srrs XLR_SEC_AES256_KEY_LENGTH); 2481198627Srrs print_buf("GCM Key", 2482198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256GCM.GCMH0, 2483198627Srrs XLR_SEC_AES256_KEY_LENGTH); 2484198627Srrs break; 2485198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_ECB_CBC_OFB: 2486198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_ECB_CBC_OFB \n"); 2487198627Srrs print_buf("CIPHER Key", 2488198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256GCM.cipherKey0, 2489198627Srrs XLR_SEC_AES256_KEY_LENGTH); 2490198627Srrs print_buf("GCM Key", 2491198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256GCM.GCMH0, 2492198627Srrs XLR_SEC_AES256_KEY_LENGTH); 2493198627Srrs break; 2494198627Srrs case XLR_SEC_VECTOR_CIPHER_ARC4__F9: 2495198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__F9 \n"); 2496198627Srrs print_buf("ARC4 Key", 2497198627Srrs &desc->ctl_desc.cipherHashInfo.infoARC4F9.cipherKey0, 2498198627Srrs GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2499198627Srrs print_buf("F9 Key", 2500198627Srrs &desc->ctl_desc.cipherHashInfo.infoARC4F9.authKey0, 2501198627Srrs sizeof(F9_t)); 2502198627Srrs break; 2503198627Srrs case XLR_SEC_VECTOR_CIPHER_ARC4__F9__STATE: 2504198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__F9__STATE \n"); 2505198627Srrs print_buf("ARC4 Key", 2506198627Srrs &desc->ctl_desc.cipherHashInfo.infoARC4StateF9.cipherKey0, 2507198627Srrs GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2508198627Srrs print_buf("F9 Key", 2509198627Srrs &desc->ctl_desc.cipherHashInfo.infoARC4StateF9.authKey0, 2510198627Srrs sizeof(F9_t)); 2511198627Srrs break; 2512198627Srrs case XLR_SEC_VECTOR_F9: 2513198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR_F9 \n"); 2514198627Srrs print_buf("F9 Key", 2515198627Srrs &desc->ctl_desc.cipherHashInfo.infoF9.authKey0, 2516198627Srrs sizeof(F9_t)); 2517198627Srrs break; 2518198627Srrs case XLR_SEC_VECTOR__CIPHER_DES__F9__MODE_ECB_CBC: 2519198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_DES__F9__MODE_ECB_CBC \n"); 2520198627Srrs print_buf("CIPHER Key", 2521198627Srrs &desc->ctl_desc.cipherHashInfo.infoDESF9.cipherKey0, 2522198627Srrs XLR_SEC_DES_KEY_LENGTH); 2523198627Srrs print_buf("F9 Key", 2524198627Srrs &desc->ctl_desc.cipherHashInfo.infoDESF9.authKey0, 2525198627Srrs sizeof(F9_t)); 2526198627Srrs break; 2527198627Srrs case XLR_SEC_VECTOR__CIPHER_3DES__F9__MODE_ECB_CBC: 2528198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_3DES__F9__MODE_ECB_CBC \n"); 2529198627Srrs print_buf("CIPHER Key", 2530198627Srrs &desc->ctl_desc.cipherHashInfo.info3DESF9.cipherKey0, 2531198627Srrs XLR_SEC_3DES_KEY_LENGTH); 2532198627Srrs print_buf("F9 Key", 2533198627Srrs &desc->ctl_desc.cipherHashInfo.info3DESF9.authKey0, 2534198627Srrs sizeof(F9_t)); 2535198627Srrs break; 2536198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_CTR_CFB: 2537198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_CTR_CFB \n"); 2538198627Srrs print_buf("CIPHER Key", 2539198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128F9.cipherKey0, 2540198627Srrs XLR_SEC_AES128_KEY_LENGTH); 2541198627Srrs print_buf("F9 Key", 2542198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128F9.authKey0, 2543198627Srrs sizeof(F9_t)); 2544198627Srrs break; 2545198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_ECB_CBC_OFB: 2546198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_ECB_CBC_OFB\n"); 2547198627Srrs print_buf("CIPHER Key", 2548198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128F9.cipherKey0, 2549198627Srrs XLR_SEC_AES128_KEY_LENGTH); 2550198627Srrs print_buf("F9 Key", 2551198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128F9.authKey0, 2552198627Srrs sizeof(F9_t)); 2553198627Srrs break; 2554198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_CTR_CFB: 2555198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_CTR_CFB \n"); 2556198627Srrs print_buf("CIPHER Key", 2557198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192F9.cipherKey0, 2558198627Srrs XLR_SEC_AES192_KEY_LENGTH); 2559198627Srrs print_buf("F9 Key", 2560198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192F9.authKey0, 2561198627Srrs sizeof(F9_t)); 2562198627Srrs break; 2563198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_ECB_CBC_OFB: 2564198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_ECB_CBC_OFB\n"); 2565198627Srrs print_buf("CIPHER Key", 2566198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192F9.cipherKey0, 2567198627Srrs XLR_SEC_AES192_KEY_LENGTH); 2568198627Srrs print_buf("F9 Key", 2569198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192F9.authKey0, 2570198627Srrs sizeof(F9_t)); 2571198627Srrs break; 2572198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_CTR_CFB: 2573198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_CTR_CFB \n"); 2574198627Srrs print_buf("CIPHER Key", 2575198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256F9.cipherKey0, 2576198627Srrs XLR_SEC_AES256_KEY_LENGTH); 2577198627Srrs print_buf("F9 Key", 2578198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256F9.authKey0, 2579198627Srrs sizeof(F9_t)); 2580198627Srrs break; 2581198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_ECB_CBC_OFB: 2582198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_ECB_CBC_OFB \n"); 2583198627Srrs print_buf("CIPHER Key", 2584198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256F9.cipherKey0, 2585198627Srrs XLR_SEC_AES256_KEY_LENGTH); 2586198627Srrs print_buf("F9 Key", 2587198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256F9.authKey0, 2588198627Srrs sizeof(F9_t)); 2589198627Srrs break; 2590198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_F8: 2591198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_F8 \n"); 2592198627Srrs print_buf("CIPHER Key", 2593198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128F8HMAC.cipherKey0, 2594198627Srrs XLR_SEC_AES128F8_KEY_LENGTH); 2595198627Srrs print_buf("HMAC Key", 2596198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128F8HMAC.hmacKey0, 2597198627Srrs sizeof(HMAC_t)); 2598198627Srrs break; 2599198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__MODE_F8: 2600198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__MODE_F8 \n"); 2601198627Srrs print_buf("CIPHER Key", 2602198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128F8.cipherKey0, 2603198627Srrs XLR_SEC_AES128F8_KEY_LENGTH); 2604198627Srrs break; 2605198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_F8: 2606198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_F8 \n"); 2607198627Srrs print_buf("CIPHER Key", 2608198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192F8HMAC.cipherKey0, 2609198627Srrs XLR_SEC_AES192F8_KEY_LENGTH); 2610198627Srrs print_buf("HMAC Key", 2611198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192F8HMAC.hmacKey0, 2612198627Srrs sizeof(HMAC_t)); 2613198627Srrs break; 2614198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__MODE_F8: 2615198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__MODE_F8 \n"); 2616198627Srrs print_buf("CIPHER Key", 2617198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192F8.cipherKey0, 2618198627Srrs XLR_SEC_AES192F8_KEY_LENGTH); 2619198627Srrs break; 2620198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_F8: 2621198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_F8 \n"); 2622198627Srrs print_buf("CIPHER Key", 2623198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256F8HMAC.cipherKey0, 2624198627Srrs XLR_SEC_AES256F8_KEY_LENGTH); 2625198627Srrs print_buf("HMAC Key", 2626198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256HMAC.hmacKey0, 2627198627Srrs sizeof(HMAC_t)); 2628198627Srrs break; 2629198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__MODE_F8: 2630198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__MODE_F8 \n"); 2631198627Srrs print_buf("CIPHER Key", 2632198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256F8.cipherKey0, 2633198627Srrs XLR_SEC_AES256F8_KEY_LENGTH); 2634198627Srrs break; 2635198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_F8: 2636198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_F8 \n"); 2637198627Srrs print_buf("CIPHER Key", 2638198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128F8HMAC2.cipherKey0, 2639198627Srrs XLR_SEC_AES128F8_KEY_LENGTH); 2640198627Srrs print_buf("HMAC2 Key", 2641198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128F8HMAC2.hmacKey0, 2642198627Srrs sizeof(HMAC2_t)); 2643198627Srrs break; 2644198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_F8: 2645198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_F8 \n"); 2646198627Srrs print_buf("CIPHER Key", 2647198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192F8HMAC2.cipherKey0, 2648198627Srrs XLR_SEC_AES192F8_KEY_LENGTH); 2649198627Srrs print_buf("HMAC2 Key", 2650198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192F8HMAC2.hmacKey0, 2651198627Srrs sizeof(HMAC2_t)); 2652198627Srrs break; 2653198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_F8: 2654198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_F8 \n"); 2655198627Srrs print_buf("CIPHER Key", 2656198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256F8HMAC2.cipherKey0, 2657198627Srrs XLR_SEC_AES256F8_KEY_LENGTH); 2658198627Srrs print_buf("HMAC2 Key", 2659198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256F8HMAC2.hmacKey0, 2660198627Srrs sizeof(HMAC2_t)); 2661198627Srrs break; 2662198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_F8: 2663198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_F8 \n"); 2664198627Srrs print_buf("CIPHER Key", 2665198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128F8GCM.cipherKey0, 2666198627Srrs XLR_SEC_AES128F8_KEY_LENGTH); 2667198627Srrs print_buf("GCM Key", 2668198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128GCM.GCMH0, 2669198627Srrs XLR_SEC_AES128_KEY_LENGTH); 2670198627Srrs break; 2671198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_F8: 2672198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_F8 \n"); 2673198627Srrs print_buf("CIPHER Key", 2674198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192F8GCM.cipherKey0, 2675198627Srrs XLR_SEC_AES192_KEY_LENGTH); 2676198627Srrs print_buf("GCM Key", 2677198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192F8GCM.GCMH0, 2678198627Srrs XLR_SEC_AES192_KEY_LENGTH); 2679198627Srrs break; 2680198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_F8: 2681198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_F8 \n"); 2682198627Srrs print_buf("CIPHER Key", 2683198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256F8GCM.cipherKey0, 2684198627Srrs XLR_SEC_AES256F8_KEY_LENGTH); 2685198627Srrs print_buf("GCM Key", 2686198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256F8GCM.GCMH0, 2687198627Srrs XLR_SEC_AES256_KEY_LENGTH); 2688198627Srrs break; 2689198627Srrs case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_F8: 2690198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_F8 \n"); 2691198627Srrs print_buf("CIPHER Key", 2692198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128F8F9.cipherKey0, 2693198627Srrs XLR_SEC_AES128F8_KEY_LENGTH); 2694198627Srrs print_buf("F9 Key", 2695198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES128F8F9.authKey0, 2696198627Srrs sizeof(F9_t)); 2697198627Srrs break; 2698198627Srrs case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_F8: 2699198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_F8 \n"); 2700198627Srrs print_buf("CIPHER Key", 2701198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192F8F9.cipherKey0, 2702198627Srrs XLR_SEC_AES192F8_KEY_LENGTH); 2703198627Srrs print_buf("F9 Key", 2704198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES192F8F9.authKey0, 2705198627Srrs sizeof(F9_t)); 2706198627Srrs break; 2707198627Srrs case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_F8: 2708198627Srrs DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_F8 \n"); 2709198627Srrs print_buf("CIPHER Key", 2710198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256F8F9.cipherKey0, 2711198627Srrs XLR_SEC_AES256F8_KEY_LENGTH); 2712198627Srrs print_buf("F9 Key", 2713198627Srrs &desc->ctl_desc.cipherHashInfo.infoAES256F8F9.authKey0, 2714198627Srrs sizeof(F9_t)); 2715198627Srrs break; 2716198157Srrs 2717198627Srrs default: 2718198627Srrs DPRINT("VECTOR: ???? \n"); 2719198627Srrs DPRINT(">>> WHAT THE HECK !!! <<< \n"); 2720198627Srrs break; 2721198627Srrs } 2722198627Srrs DPRINT("PACKET DESCRIPTOR: \n"); 2723212763Sjchandra word = 0; //desc->pkt_desc.srcLengthIVOffUseIVNext; 2724198627Srrs DPRINT("\tSrcLengthIVOffsetIVNext: %llx\n", word); 2725198627Srrs DPRINT("\t\tLoad HMAC = %lld \n", 2726198627Srrs GET_FIELD(word, PKT_DSC_LOADHMACKEY)); 2727198627Srrs DPRINT("\t\tPad Hash = %lld \n", 2728198627Srrs GET_FIELD(word, PKT_DSC_PADHASH)); 2729198627Srrs DPRINT("\t\tHash Byte Count = %lld \n", 2730198627Srrs GET_FIELD(word, PKT_DSC_HASHBYTES)); 2731198627Srrs DPRINT("\t\tNext = %lld \n", 2732198627Srrs GET_FIELD(word, PKT_DSC_NEXT)); 2733198627Srrs DPRINT("\t\tUse IV = %lld \n", 2734198627Srrs GET_FIELD(word, PKT_DSC_IV)); 2735198627Srrs DPRINT("\t\tIV Offset = %lld \n", 2736198627Srrs GET_FIELD(word, PKT_DSC_IVOFF)); 2737198627Srrs DPRINT("\t\tPacket Length = %lld \n", 2738198627Srrs GET_FIELD(word, PKT_DSC_PKTLEN)); 2739198627Srrs DPRINT("\t\tNLHMAC = %lld \n", GET_FIELD(word, PKT_DSC_NLHMAC)); 2740198627Srrs DPRINT("\t\tBreak = %lld \n", GET_FIELD(word, PKT_DSC_BREAK)); 2741198627Srrs DPRINT("\t\tWait = %lld \n", GET_FIELD(word, PKT_DSC_WAIT)); 2742198627Srrs DPRINT("\t\tSegment Src Addr = %llx \n", 2743198627Srrs (GET_FIELD(word, PKT_DSC_SEGADDR) << 5) & 0xffffffffffULL); 2744198627Srrs DPRINT("\t\tSRTCP = %lld \n", GET_FIELD(word, PKT_DSC_SRTCP)); 2745198627Srrs DPRINT("\t\tGlobal Src Offset = %lld \n", 2746198627Srrs GET_FIELD(word, PKT_DSC_SEGOFFSET)); 2747198157Srrs 2748212763Sjchandra word = 0; //desc->pkt_desc.dstDataSettings; 2749198627Srrs DPRINT("\tdstDataSettings: %llx \n", word); 2750198627Srrs DPRINT("\t\tArc4 Byte Count = %lld \n", GET_FIELD(word, 2751198627Srrs PKT_DSC_ARC4BYTECOUNT)); 2752198627Srrs DPRINT("\t\tSym Operation = %lld \n", GET_FIELD(word, PKT_DSC_SYM_OP)); 2753198627Srrs DPRINT("\t\tCipher Offset = %lld \n", GET_FIELD(word, PKT_DSC_CPHROFF)); 2754198627Srrs DPRINT("\t\tHash Offset = %lld \n", GET_FIELD(word, PKT_DSC_HASHOFF)); 2755198627Srrs DPRINT("\t\tHash Source = %lld \n", GET_FIELD(word, PKT_DSC_HASHSRC)); 2756198627Srrs DPRINT("\t\tChecksum Offset = %lld \n", GET_FIELD(word, 2757198627Srrs PKT_DSC_CKSUMOFF)); 2758198627Srrs DPRINT("\t\tChecksum Source = %lld \n", GET_FIELD(word, 2759198627Srrs PKT_DSC_CKSUMSRC)); 2760198627Srrs DPRINT("\t\tCipher Dest Addr = %llx \n", GET_FIELD(word, 2761198627Srrs PKT_DSC_CPHR_DST_ADDR)); 2762198627Srrs DPRINT("\t\tCipher Dest Dword = %lld \n", GET_FIELD(word, 2763198627Srrs PKT_DSC_CPHR_DST_DWOFFSET)); 2764198627Srrs DPRINT("\t\tCipher Dest Offset= %lld \n", GET_FIELD(word, 2765198627Srrs PKT_DSC_CPHR_DST_OFFSET)); 2766212763Sjchandra word = 0; //desc->pkt_desc.authDstNonceLow; 2767198627Srrs DPRINT("\tauthDstNonceLow: %llx \n", word); 2768198627Srrs DPRINT("\t\tNonce Low 24 = %lld \n", GET_FIELD(word, 2769198627Srrs PKT_DSC_NONCE_LOW)); 2770198627Srrs DPRINT("\t\tauthDst = %llx \n", GET_FIELD(word, 2771198627Srrs PKT_DSC_AUTH_DST_ADDR)); 2772198627Srrs DPRINT("\t\tCipher Offset High= %lld \n", GET_FIELD(word, 2773198627Srrs PKT_DSC_CIPH_OFF_HI)); 2774212763Sjchandra word = 0; //desc->pkt_desc.ckSumDstNonceHiCFBMaskLLWMask; 2775198627Srrs DPRINT("\tckSumDstNonceHiCFBMaskLLWMask: %llx \n", word); 2776198627Srrs DPRINT("\t\tHash Byte off = %lld \n", GET_FIELD(word, PKT_DSC_HASH_BYTE_OFF)); 2777198627Srrs DPRINT("\t\tPacket Len bytes = %lld \n", GET_FIELD(word, PKT_DSC_PKTLEN_BYTES)); 2778198627Srrs DPRINT("\t\tLast Long Word Mask = %lld \n", GET_FIELD(word, 2779198627Srrs PKT_DSC_LASTWORD)); 2780198627Srrs DPRINT("\t\tCipher Dst Address = %llx \n", GET_FIELD(word, 2781198627Srrs PKT_DSC_CPHR_DST_ADDR)); 2782198627Srrs DPRINT("\t\tGlobal Dst Offset = %lld \n", GET_FIELD(word, 2783198627Srrs PKT_DSC_CPHR_DST_OFFSET)); 2784198627Srrs 2785198627Srrs DPRINT("CFG_VECTOR = %04x\n", cfg_vector); 2786198627Srrs DPRINT("\n\n"); 2787198157Srrs} 2788198627Srrs 2789198157Srrs#endif 2790198157Srrs 2791198157Srrs 2792198157Srrs 2793198157Srrs/* This function is called from an interrupt handler */ 2794198627Srrsvoid 2795198627Srrsxlr_sec_msgring_handler(int bucket, int size, int code, int stid, 2796198627Srrs struct msgrng_msg *msg, void *data) 2797198157Srrs{ 2798198627Srrs uint64_t error; 2799198627Srrs uint64_t addr, sec_eng, sec_pipe; 2800198627Srrs xlr_sec_io_pt op = NULL; 2801198627Srrs symkey_desc_pt desc = NULL; 2802198627Srrs struct xlr_sec_session *ses = NULL; 2803198627Srrs struct xlr_sec_command *cmd = NULL; 2804212763Sjchandra uint32_t flags; 2805198157Srrs 2806198627Srrs if (code != MSGRNG_CODE_SEC) { 2807198627Srrs panic("xlr_sec_msgring_handler: bad code = %d," 2808198627Srrs " expected code = %d\n", 2809198627Srrs code, MSGRNG_CODE_SEC); 2810198627Srrs } 2811198627Srrs if ((stid < MSGRNG_STNID_SEC0) || (stid > MSGRNG_STNID_PK0)) { 2812198627Srrs panic("xlr_sec_msgring_handler: bad stn id = %d, expect %d - %d\n", 2813198627Srrs stid, MSGRNG_STNID_SEC0, MSGRNG_STNID_PK0); 2814198627Srrs } 2815198627Srrs /* 2816198627Srrs * The Submit() operation encodes the engine and pipe in these two 2817198627Srrs * separate fields. This allows use to verify the result type with 2818198627Srrs * the submitted operation type. 2819198627Srrs */ 2820198627Srrs sec_eng = GET_FIELD(msg->msg0, MSG_CTL_OP_TYPE); 2821198627Srrs sec_pipe = GET_FIELD(msg->msg1, MSG_CTL_OP_TYPE); 2822198157Srrs 2823198627Srrs error = msg->msg0 >> 40 & 0x1ff; 2824198627Srrs if (error) 2825198627Srrs printf("ctrl error = 0x%llx\n", error); 2826198627Srrs error = msg->msg1 >> 40 & 0x1ff; 2827198627Srrs if (error) 2828198627Srrs printf("data error = 0x%llx\n", error); 2829198157Srrs 2830198157Srrs 2831198627Srrs XLR_SEC_CMD_DIAG("[%s]: eng=%lld pipe=%lld\n", 2832198627Srrs __FUNCTION__, sec_eng, sec_pipe); 2833198157Srrs 2834198627Srrs /* Symmetric Key Operation ? */ 2835198627Srrs if (sec_eng == MSG0_CTL_OP_ENGINE_SYMKEY) { 2836198157Srrs 2837198627Srrs /* 2838198627Srrs * The data descriptor address allows us to associate the 2839198627Srrs * response with the submitted operation. Address is 40-bit 2840198627Srrs * cacheline aligned address. We need to zero bit 0-4 since 2841198627Srrs * they are used for the engine and pipe Id. 2842198627Srrs */ 2843198627Srrs addr = GET_FIELD(msg->msg1, MSG_RSLT_DATA_DSC_ADDR); 2844198627Srrs addr = addr & ~((1 << 5) - 1); 2845198627Srrs if (!addr) { 2846198627Srrs panic("[%s:STNID_SEC]: NULL symkey addr!\n", __FUNCTION__); 2847212763Sjchandra } 2848198157Srrs 2849198627Srrs /* 2850198627Srrs * The adddress points to the data descriptor. The operation 2851198627Srrs * descriptor is defined with the 32-byte cacheline size in 2852198627Srrs * mind. It allows the code to use this address to 2853198627Srrs * reference the symkey descriptor. (ref: xlr_sec_desc.h) 2854198627Srrs */ 2855198627Srrs addr = addr - sizeof(OperationDescriptor_t); 2856212763Sjchandra flags = xlr_enable_kx(); 2857212763Sjchandra desc = (symkey_desc_pt)(uintptr_t)xlr_paddr_ld(addr + 2858212763Sjchandra offsetof(OperationDescriptor_t, vaddr)); 2859212763Sjchandra xlr_restore_kx(flags); 2860198157Srrs 2861198627Srrs if (!desc) { 2862198627Srrs printf("\nerror : not getting desc back correctly \n"); 2863198627Srrs panic("[%s:STNID_SEC]: NULL symkey data descriptor!\n", __FUNCTION__); 2864198627Srrs } 2865198627Srrs ses = (struct xlr_sec_session *)desc->ses; 2866198627Srrs if (!ses) { 2867198627Srrs printf("\n error : not getting ses back correctly \n"); 2868198627Srrs panic("[%s:STNID_SEC]: NULL symkey data descriptor!\n", __FUNCTION__); 2869198627Srrs } 2870198627Srrs cmd = &ses->cmd; 2871198627Srrs if (!cmd) { 2872198627Srrs printf("\n error : not getting cmd back correctly \n"); 2873198627Srrs panic("[%s:STNID_SEC]: NULL symkey data descriptor!\n", __FUNCTION__); 2874198627Srrs } 2875198627Srrs op = &cmd->op; 2876198627Srrs if (!op) { 2877198627Srrs printf("\n error : not getting op back correctly \n"); 2878198627Srrs panic("[%s:STNID_SEC]: NULL symkey data descriptor!\n", __FUNCTION__); 2879198627Srrs } 2880198627Srrs XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: addr=0x%llx desc=%p alloc=%p \n", 2881198627Srrs __FUNCTION__, addr, desc, desc->alloc); 2882198157Srrs 2883198627Srrs XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: op_ctl=%p phys_self=%llx stn_id=%d \n", 2884198627Srrs __FUNCTION__, &desc->op_ctl, desc->op_ctl.phys_self, 2885198627Srrs desc->op_ctl.stn_id); 2886198157Srrs 2887198627Srrs if (addr != desc->op_ctl.phys_self) { 2888198627Srrs XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: Control Descriptor fails Self-Verify !\n", 2889198627Srrs __FUNCTION__); 2890198627Srrs printf("[%s:STNID_SEC]: Control Descriptor fails Self-Verify !\n", 2891198627Srrs __FUNCTION__); 2892198627Srrs printf("[%s:STNID_SEC]: addr=0x%llx desc=%p alloc=%p \n", 2893198627Srrs __FUNCTION__, (unsigned long long)addr, desc, desc->alloc); 2894198627Srrs printf("[%s:STNID_SEC]: op_ctl=%p phys_self=%llx stn_id=%d \n", 2895198627Srrs __FUNCTION__, &desc->op_ctl, (unsigned long long)desc->op_ctl.phys_self, 2896198627Srrs desc->op_ctl.stn_id); 2897198157Srrs 2898198627Srrs } 2899198627Srrs if (desc->op_ctl.stn_id != MSGRNG_STNID_SEC0 && 2900198627Srrs desc->op_ctl.stn_id != MSGRNG_STNID_SEC1) { 2901198627Srrs XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: Operation Type Mismatch !\n", 2902198627Srrs __FUNCTION__); 2903198627Srrs printf("[%s:STNID_SEC]: Operation Type Mismatch !\n", 2904198627Srrs __FUNCTION__); 2905198627Srrs printf("[%s:STNID_SEC]: addr=0x%llx desc=%p alloc=%p \n", 2906198627Srrs __FUNCTION__, (unsigned long long)addr, desc, desc->alloc); 2907198627Srrs printf("[%s:STNID_SEC]: op_ctl=%p phys_self=%llx stn_id=%d \n", 2908198627Srrs __FUNCTION__, &desc->op_ctl, (unsigned long long)desc->op_ctl.phys_self, 2909198627Srrs desc->op_ctl.stn_id); 2910198627Srrs } 2911198627Srrs desc->ctl_result = GET_FIELD(msg->msg0, MSG_RSLT_CTL_INST_ERR); 2912198627Srrs desc->data_result = GET_FIELD(msg->msg1, MSG_RSLT_DATA_INST_ERR); 2913198157Srrs 2914198627Srrs XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: cpu=%d ctl_result=0x%llx data_result=%llx\n", 2915198627Srrs __FUNCTION__, desc->op_ctl.cpu, 2916198627Srrs desc->ctl_result, desc->data_result); 2917198157Srrs 2918198627Srrs } 2919198157Srrs#if 0 2920198627Srrs else if (sec_eng == MSG0_CTL_OP_ENGINE_PUBKEY) { 2921198627Srrs pubkey_desc_pt desc; 2922198157Srrs 2923198627Srrs if (sec_pipe != MSG1_CTL_OP_PUBKEY_PIPE0) { 2924198627Srrs /* response to uc load */ 2925198627Srrs /* 2926198627Srrs * XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: ecc cpu=%d 2927198627Srrs * ctl_result=0x%llx data_result=%llx\n", 2928198627Srrs * __FUNCTION__, desc->op_ctl.cpu, desc->ctl_result, 2929198627Srrs * desc->data_result); 2930198627Srrs */ 2931198627Srrs return; 2932198627Srrs } 2933198627Srrs /* 2934198627Srrs * The data descriptor address allows us to associate the 2935198627Srrs * response with the submitted operation. Address is 40-bit 2936198627Srrs * cacheline aligned address. We need to zero bit 0-4 since 2937198627Srrs * they are used for the engine and pipe Id. 2938198627Srrs */ 2939198627Srrs addr = GET_FIELD(msg->msg0, PUBKEY_RSLT_CTL_SRCADDR); 2940198627Srrs addr = addr & ~((1 << 5) - 1); 2941198627Srrs if (!addr) { 2942198627Srrs panic("[%s:STNID_SEC]: NULL pubkey ctrl desc!\n", __FUNCTION__); 2943198627Srrs } 2944198627Srrs /* 2945198627Srrs * The adddress points to the data descriptor. The operation 2946198627Srrs * descriptor is defined with the 32-byte cacheline size in 2947198627Srrs * mind. It allows the code to use this address to 2948198627Srrs * reference the symkey descriptor. (ref: xlr_sec_desc.h) 2949198627Srrs */ 2950198627Srrs addr = addr - sizeof(OperationDescriptor_t); 2951198157Srrs 2952198627Srrs /* Get pointer to pubkey Descriptor */ 2953198627Srrs desc = (pubkey_desc_pt) (unsigned long)addr; 2954198627Srrs if (!desc) { 2955198627Srrs panic("[%s:STNID_SEC]: NULL pubkey data descriptor!\n", __FUNCTION__); 2956198627Srrs } 2957198627Srrs XLR_SEC_CMD_DIAG("[%s:STNID_PK0]: addr=0x%llx desc=%p alloc=%p \n", 2958198627Srrs __FUNCTION__, addr, desc, desc->alloc); 2959198157Srrs 2960198627Srrs XLR_SEC_CMD_DIAG("[%s:STNID_PK0]: op_ctl=%p phys_self=%llx stn_id=%d \n", 2961198627Srrs __FUNCTION__, &desc->op_ctl, desc->op_ctl.phys_self, 2962198627Srrs desc->op_ctl.stn_id); 2963198157Srrs 2964198627Srrs if (addr != desc->op_ctl.phys_self) { 2965198627Srrs XLR_SEC_CMD_DIAG("[%s:STNID_PK0]: Control Descriptor fails Self-Verify !\n", 2966198627Srrs __FUNCTION__); 2967198627Srrs } 2968198627Srrs if (desc->op_ctl.stn_id != msgrng_stnid_pk0) { 2969198627Srrs XLR_SEC_CMD_DIAG("[%s:STNID_PK0]: Operation Type Mismatch ! \n", 2970198627Srrs __FUNCTION__); 2971198627Srrs } 2972198627Srrs desc->ctl_result = GET_FIELD(msg->msg0, PUBKEY_RSLT_CTL_ERROR); 2973198627Srrs desc->data_result = GET_FIELD(msg->msg1, PUBKEY_RSLT_DATA_ERROR); 2974198157Srrs 2975198627Srrs XLR_SEC_CMD_DIAG("[%s:STNID_PK0]: ctl_result=0x%llx data_result=%llx\n", 2976198627Srrs __FUNCTION__, desc->ctl_result, desc->data_result); 2977198157Srrs 2978198627Srrs } 2979198157Srrs#endif 2980198627Srrs else { 2981198627Srrs printf("[%s]: HANDLER bad id = %d\n", __FUNCTION__, stid); 2982198627Srrs } 2983198157Srrs#ifdef RMI_SEC_DEBUG 2984198627Srrs if (ses->multi_frag_flag) { 2985198627Srrs int i; 2986198627Srrs char *ptr; 2987198157Srrs 2988198627Srrs printf("\n RETURNED DATA: \n"); 2989198157Srrs 2990198627Srrs ptr = (char *)(unsigned long)(desc->user.aligned_dest + cmd->op.cipher_offset); 2991198627Srrs for (i = 0; i < SEC_MAX_FRAG_LEN; i++) { 2992198627Srrs printf("%c ", (char)*ptr++); 2993198627Srrs if ((i % 10) == 0) 2994198627Srrs printf("\n"); 2995198627Srrs } 2996198627Srrs 2997198627Srrs printf("second desc\n"); 2998198627Srrs ptr = (char *)(unsigned long)(desc->next_dest_buf); 2999198627Srrs for (i = 0; i < desc->next_src_len; i++) { 3000198627Srrs printf("%c ", (char)*ptr++); 3001198627Srrs if ((i % 10) == 0) 3002198627Srrs printf("\n"); 3003198627Srrs } 3004198627Srrs } 3005198157Srrs#endif 3006198157Srrs 3007198627Srrs /* Copy cipher-data to User-space */ 3008198627Srrs if (op->cipher_type != XLR_SEC_CIPHER_TYPE_NONE) { 3009198627Srrs size = op->dest_buf_size; 3010198157Srrs 3011198627Srrs /* DEBUG -dpk */ 3012198627Srrs XLR_SEC_CMD_DIAG("cipher: to_addr=%p from_addr=%p size=%d \n", 3013198627Srrs desc->user.user_dest, desc->user.aligned_dest, size); 3014198157Srrs 3015198627Srrs if (ses->multi_frag_flag) { 3016198627Srrs crypto_copyback(cmd->crp->crp_flags, cmd->crp->crp_buf, 0, 3017198627Srrs SEC_MAX_FRAG_LEN, (caddr_t)(long)desc->user.aligned_dest + op->cipher_offset); 3018198627Srrs crypto_copyback(cmd->crp->crp_flags, cmd->crp->crp_buf + SEC_MAX_FRAG_LEN, 0, 3019198627Srrs desc->next_src_len, (caddr_t)(long)desc->next_dest_buf); 3020198627Srrs crypto_done(cmd->crp); 3021198627Srrs } else { 3022198627Srrs crypto_copyback(cmd->crp->crp_flags, cmd->crp->crp_buf, 0, 3023198627Srrs cmd->op.dest_buf_size, (caddr_t)(long)desc->user.aligned_dest + op->cipher_offset); 3024198627Srrs crypto_done(cmd->crp); 3025198627Srrs } 3026198157Srrs 3027212763Sjchandra } 3028198157Srrs 3029198627Srrs /* Copy digest to User-space */ 3030198627Srrs if (op->digest_type != XLR_SEC_DIGEST_TYPE_NONE) { 3031198627Srrs int offset = 0; 3032198157Srrs 3033198627Srrs switch (op->digest_type) { 3034198627Srrs case XLR_SEC_DIGEST_TYPE_MD5: 3035198627Srrs size = XLR_SEC_MD5_LENGTH; 3036198627Srrs break; 3037198627Srrs case XLR_SEC_DIGEST_TYPE_SHA1: 3038198627Srrs size = XLR_SEC_SHA1_LENGTH; 3039198627Srrs break; 3040198627Srrs case XLR_SEC_DIGEST_TYPE_SHA256: 3041198627Srrs size = XLR_SEC_SHA256_LENGTH; 3042198627Srrs break; 3043198627Srrs case XLR_SEC_DIGEST_TYPE_SHA384: 3044198627Srrs size = XLR_SEC_SHA384_LENGTH; 3045198627Srrs break; 3046198627Srrs case XLR_SEC_DIGEST_TYPE_SHA512: 3047198627Srrs size = XLR_SEC_SHA512_LENGTH; 3048198627Srrs break; 3049198627Srrs case XLR_SEC_DIGEST_TYPE_GCM: 3050198627Srrs size = XLR_SEC_GCM_LENGTH; 3051198627Srrs break; 3052198627Srrs case XLR_SEC_DIGEST_TYPE_KASUMI_F9: 3053198627Srrs offset = 4; 3054198627Srrs size = XLR_SEC_KASUMI_F9_RESULT_LENGTH; 3055198627Srrs break; 3056198627Srrs default: 3057198627Srrs size = 0; 3058198627Srrs } 3059198157Srrs 3060198627Srrs XLR_SEC_CMD_DIAG("digest: to_addr=%p from_addr=%p size=%d \n", 3061198627Srrs desc->user.user_auth, desc->user.aligned_auth, size); 3062198627Srrs memcpy(desc->user.user_auth, desc->user.aligned_auth + offset, size); 3063198627Srrs op->auth_dest = (uint64_t) (unsigned long)desc->user.user_auth; 3064198627Srrs } 3065198627Srrs if (op->cipher_type == XLR_SEC_CIPHER_TYPE_ARC4 && 3066198627Srrs op->rc4_savestate) { 3067198627Srrs size = XLR_SEC_MAX_RC4_STATE_SIZE; 3068198157Srrs 3069198627Srrs XLR_SEC_CMD_DIAG("state: to_addr=%p from_addr=%p size=%d \n", 3070198627Srrs desc->user.user_state, desc->user.aligned_state, size); 3071198627Srrs op->rc4_state = (uint64_t) (unsigned long)desc->user.user_state; 3072198627Srrs } 3073198627Srrs return; 3074198157Srrs} 3075