2 * Copyright (c) 2003-2009 RMI Corporation
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of RMI Corporation, nor the names of its contributors,
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 #include <sys/cdefs.h>
33 __FBSDID("$FreeBSD$");
35 #include <sys/param.h>
36 #include <sys/types.h>
37 #include <sys/systm.h>
38 #include <sys/kernel.h>
39 #include <sys/module.h>
40 #include <sys/malloc.h>
42 #include <machine/bus.h>
43 #include <machine/md_var.h>
44 #include <machine/cpuregs.h>
49 #include <opencrypto/cryptodev.h>
51 #include <mips/rmi/rmi_mips_exts.h>
52 #include <mips/rmi/iomap.h>
53 #include <mips/rmi/pic.h>
54 #include <mips/rmi/rmi_boot_info.h>
55 #include <mips/rmi/msgring.h>
56 #include <mips/rmi/board.h>
57 #include <mips/rmi/dev/sec/rmilib.h>
58 #include <mips/rmi/dev/sec/desc.h>
61 /* static int msgrng_stnid_pk0 = MSGRNG_STNID_PK0; */
63 /* #define RMI_SEC_DEBUG */
65 #define SMP_CACHE_BYTES XLR_CACHELINE_SIZE
66 #define NUM_CHUNKS(size, bits) ( ((size)>>(bits)) + (((size)&((1<<(bits))-1))?1:0) )
68 static const char nib2hex[] = "0123456789ABCDEF";
69 symkey_desc_pt g_desc;
70 struct xlr_sec_command *g_cmd;
72 #ifdef XLR_SEC_CMD_DEBUG
73 static void decode_symkey_desc(symkey_desc_pt desc, uint32_t cfg_vector);
76 static int xlr_sec_cipher_hash_command(xlr_sec_io_pt op, symkey_desc_pt desc,
78 static xlr_sec_error_t xlr_sec_setup_descriptor(xlr_sec_io_pt op,
79 unsigned int flags, symkey_desc_pt desc, uint32_t * cfg_vector);
81 static xlr_sec_error_t xlr_sec_setup_packet(xlr_sec_io_pt op,
82 symkey_desc_pt desc, unsigned int flags, uint64_t * data,
83 PacketDescriptor_pt pkt_desc, ControlDescriptor_pt ctl_desc,
84 uint32_t vector, PacketDescriptor_pt next_pkt_desc,
85 uint8_t multi_frag_flag);
86 static int xlr_sec_submit_message(symkey_desc_pt desc, uint32_t cfg_vector);
87 static xlr_sec_error_t xlr_sec_setup_cipher(xlr_sec_io_pt op,
88 ControlDescriptor_pt ctl_desc, uint32_t * vector);
89 static xlr_sec_error_t xlr_sec_setup_digest(xlr_sec_io_pt op,
90 ControlDescriptor_pt ctl_desc, uint32_t * vector);
91 static xlr_sec_error_t xlr_sec_setup_cksum(xlr_sec_io_pt op,
92 ControlDescriptor_pt ctl_desc);
93 static xlr_sec_error_t xlr_sec_control_setup(xlr_sec_io_pt op,
94 unsigned int flags, uint64_t * control, ControlDescriptor_pt ctl_desc,
95 xlr_sec_drv_user_t * user, uint32_t vector);
96 static void xlr_sec_free_desc(symkey_desc_pt desc);
98 void print_buf(char *desc, void *data, int len);
99 xlr_sec_error_t xlr_sec_submit_op(symkey_desc_pt desc);
100 void xlr_sec_msgring_handler(int bucket, int size, int code, int stid,
101 struct msgrng_msg *msg, void *data);
104 xlr_sec_init(struct xlr_sec_softc *sc)
109 mmio = sc->mmio = xlr_io_mmio(XLR_IO_SECURITY_OFFSET);
110 xlr_write_reg(mmio, SEC_DMA_CREDIT, SEC_DMA_CREDIT_CONFIG);
111 xlr_write_reg(mmio, SEC_CONFIG2, SEC_CFG2_ROUND_ROBIN_ON);
113 for (i = 0; i < 8; i++)
115 SEC_MSG_BUCKET0_SIZE + i,
117 xls_bucket_sizes.bucket[MSGRNG_STNID_SEC + i] :
118 bucket_sizes.bucket[MSGRNG_STNID_SEC + i]);
120 for (i = 0; i < 128; i++)
124 xls_cc_table_sec.counters[i >> 3][i & 0x07] :
125 cc_table_sec.counters[i >> 3][i & 0x07]);
128 * Register a bucket handler with the phoenix messaging subsystem
129 * For now, register handler for bucket 0->5 in msg stn 0
131 if (register_msgring_handler(TX_STN_SAE, xlr_sec_msgring_handler, NULL)) {
132 panic("Couldn't register msgring handler 0\n");
138 xlr_sec_setup(struct xlr_sec_session *ses,
139 struct xlr_sec_command *cmd,
151 desc->ctl_desc.instruction = 0;
152 memset(&desc->ctl_desc.cipherHashInfo, 0, sizeof(CipherHashInfo_t));
154 desc->pkt_desc[0].srcLengthIVOffUseIVNext = 0;
155 desc->pkt_desc[0].dstDataSettings = 0;
156 desc->pkt_desc[0].authDstNonceLow = 0;
157 desc->pkt_desc[0].ckSumDstNonceHiCFBMaskLLWMask = 0;
158 desc->pkt_desc[1].srcLengthIVOffUseIVNext = 0;
159 desc->pkt_desc[1].dstDataSettings = 0;
160 desc->pkt_desc[1].authDstNonceLow = 0;
161 desc->pkt_desc[1].ckSumDstNonceHiCFBMaskLLWMask = 0;
163 desc->ctl_result = 0;
164 desc->data_result = 0;
166 if (op->flags & XLR_SEC_FLAGS_HIGH_PRIORITY)
168 desc->op_ctl.stn_id++;
170 desc->user.user_src = (uint8_t *) (unsigned long)op->source_buf;
171 desc->user.user_dest = (uint8_t *) (unsigned long)op->dest_buf;
172 desc->user.user_auth = (uint8_t *) (unsigned long)op->auth_dest;
174 if ((op->cipher_type == XLR_SEC_CIPHER_TYPE_ARC4) &&
175 (!op->rc4_state && (op->rc4_loadstate || op->rc4_savestate))) {
176 printf(" ** Load/Save State and no State **");
177 xlr_sec_free_desc(desc);
180 desc->user.user_state = (uint8_t *) (unsigned long)op->rc4_state;
182 switch (op->cipher_type) {
183 case XLR_SEC_CIPHER_TYPE_NONE:
186 case XLR_SEC_CIPHER_TYPE_DES:
187 case XLR_SEC_CIPHER_TYPE_3DES:
188 iv_len = XLR_SEC_DES_IV_LENGTH;
190 case XLR_SEC_CIPHER_TYPE_AES128:
191 case XLR_SEC_CIPHER_TYPE_AES192:
192 case XLR_SEC_CIPHER_TYPE_AES256:
193 iv_len = XLR_SEC_AES_IV_LENGTH;
195 case XLR_SEC_CIPHER_TYPE_ARC4:
196 iv_len = XLR_SEC_ARC4_IV_LENGTH;
198 case XLR_SEC_CIPHER_TYPE_KASUMI_F8:
199 iv_len = XLR_SEC_KASUMI_F8_IV_LENGTH;
203 printf(" ** Undefined Cipher Type **");
204 xlr_sec_free_desc(desc);
207 size = op->source_buf_size + iv_len;
210 * make sure that there are enough bytes for aes based stream
213 if (op->cipher_mode == XLR_SEC_CIPHER_MODE_F8 ||
214 op->cipher_mode == XLR_SEC_CIPHER_MODE_CTR)
215 size += XLR_SEC_AES_BLOCK_SIZE - 1;
217 if (op->cipher_type == XLR_SEC_CIPHER_TYPE_NONE) {
218 if (op->source_buf_size != 0) {
219 memcpy(desc->user.aligned_src,
220 (uint8_t *)(uintptr_t)op->source_buf,
221 op->source_buf_size);
224 if (ses->multi_frag_flag) {
225 /* copy IV into temporary kernel source buffer */
226 memcpy(desc->user.aligned_src, &op->initial_vector[0], iv_len);
228 /* copy input data to temporary kernel source buffer */
229 memcpy((uint8_t *) (desc->user.aligned_src + iv_len),
230 (uint8_t *) (unsigned long)op->source_buf, SEC_MAX_FRAG_LEN);
232 desc->next_src_len = op->source_buf_size - SEC_MAX_FRAG_LEN;
233 memcpy((uint8_t *) (desc->next_src_buf),
234 (uint8_t *) (unsigned long)(op->source_buf + SEC_MAX_FRAG_LEN),
237 op->source_buf_size = SEC_MAX_FRAG_LEN;
238 op->source_buf_size += iv_len;
240 /* copy IV into temporary kernel source buffer */
241 memcpy(desc->user.aligned_src, &op->initial_vector[0], iv_len);
243 /* copy input data to temporary kernel source buffer */
244 memcpy((uint8_t *) (desc->user.aligned_src + iv_len),
245 (uint8_t *) (unsigned long)op->source_buf, op->source_buf_size);
246 op->source_buf_size += iv_len;
250 /* Set source to new kernel space */
251 op->source_buf = (uint64_t) (unsigned long)desc->user.aligned_src;
254 * Build new dest buffer, for Cipher output only
256 if (op->cipher_type == XLR_SEC_CIPHER_TYPE_NONE) {
258 * Digest Engine *NEEDS* this, otherwise it will write at
261 op->dest_buf = (uint64_t) (unsigned long)desc->user.aligned_src;
264 XLR_SEC_CMD_DIAG("dest_buf_size = %d \n", op->dest_buf_size);
265 size = op->dest_buf_size + iv_len;
268 * make sure that there are enough bytes for aes based
271 if (op->cipher_mode == XLR_SEC_CIPHER_MODE_F8 ||
272 op->cipher_mode == XLR_SEC_CIPHER_MODE_CTR)
273 size += XLR_SEC_AES_BLOCK_SIZE - 1;
274 op->dest_buf = (uint64_t) (unsigned long)desc->user.aligned_dest;
277 ret_val = xlr_sec_cipher_hash_command(op, desc, ses->multi_frag_flag);
283 xlr_sec_cipher_hash_command(xlr_sec_io_pt op, symkey_desc_pt desc,
284 uint8_t multi_frag_flag)
288 unsigned int setup_flags = 0;
290 err = XLR_SEC_ERR_NONE;
293 if ((op->digest_type == XLR_SEC_DIGEST_TYPE_NONE) &&
294 (op->cipher_type != XLR_SEC_CIPHER_TYPE_ARC4) &&
295 (op->cipher_mode != XLR_SEC_CIPHER_MODE_F8) &&
296 (op->cipher_type != XLR_SEC_CIPHER_TYPE_KASUMI_F8) &&
297 (op->source_buf_size & 0x7)) {
298 printf("Invalid Cipher Block Size, data len=%d\n",
299 op->source_buf_size);
304 if ((op->cipher_type == XLR_SEC_CIPHER_TYPE_3DES) &&
305 (op->cipher_op == XLR_SEC_CIPHER_OP_DECRYPT))
306 setup_flags = XLR_SEC_SETUP_OP_FLIP_3DES_KEY;
308 err = xlr_sec_setup_descriptor(op,
311 if (err != XLR_SEC_ERR_NONE)
314 err = xlr_sec_setup_packet(op,
316 op->digest_type != XLR_SEC_DIGEST_TYPE_NONE ?
317 XLR_SEC_SETUP_OP_CIPHER_HMAC : 0,
324 if (err != XLR_SEC_ERR_NONE)
327 if (err != XLR_SEC_ERR_NONE) {
330 err = xlr_sec_submit_message(desc, cfg_vector);
334 static xlr_sec_error_t
335 xlr_sec_setup_descriptor(xlr_sec_io_pt op,
338 uint32_t * cfg_vector)
342 XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: ENTER\n");
344 if ((err = xlr_sec_setup_cipher(op, &desc->ctl_desc, cfg_vector)) != XLR_SEC_ERR_NONE) {
345 XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: xlr_sec_setup_cipher done err %d\n",
349 if (op->digest_type != XLR_SEC_DIGEST_TYPE_NONE) {
350 if ((err = xlr_sec_setup_digest(op, &desc->ctl_desc, cfg_vector)) != XLR_SEC_ERR_NONE) {
351 XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: xlr_sec_setup_digest done err %d\n",
356 if ((err = xlr_sec_setup_cksum(op, &desc->ctl_desc)) != XLR_SEC_ERR_NONE) {
357 XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: xlr_sec_setup_cksum done err %d\n",
361 if ((err = xlr_sec_control_setup(op,
366 *cfg_vector)) != XLR_SEC_ERR_NONE) {
367 XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: xlr_sec_control_setup done err %d\n",
371 XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: DONE\n");
379 xlr_sec_setup_packet(xlr_sec_io_pt op,
383 PacketDescriptor_pt pkt_desc,
384 ControlDescriptor_pt ctl_desc,
386 PacketDescriptor_pt next_pkt_desc,
387 uint8_t multi_frag_flag)
389 uint32_t len, next_len = 0, len_dwords, last_u64_bytes;
391 uint64_t seg_addr, next_seg_addr = 0;
392 uint64_t byte_offset, global_offset;
393 uint32_t cipher_offset_dwords;
395 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ENTER vector = %04x\n", vector);
397 /* physical address of the source buffer */
398 addr = (uint64_t) vtophys((void *)(unsigned long)op->source_buf);
399 /* cache-aligned base of the source buffer */
400 seg_addr = (addr & ~(SMP_CACHE_BYTES - 1));
401 /* offset in bytes to the source buffer start from the segment base */
402 byte_offset = addr - seg_addr;
403 /* global offset: 0-7 bytes */
404 global_offset = byte_offset & 0x7;
408 * op->source_buf_size is expected to be the Nb double words to
409 * stream in (Including Segment address->CP/IV/Auth/CkSum offsets)
413 * adjusted length of the whole thing, accounting for the added
414 * head, sans global_offset (per Paul S.)
417 len = op->source_buf_size + byte_offset - global_offset;
418 if (multi_frag_flag) {
419 next_seg_addr = (uint64_t)vtophys((void *)(uintptr_t)desc->next_src_buf);
420 next_seg_addr = (next_seg_addr & ~(SMP_CACHE_BYTES - 1));
421 next_len = desc->next_src_len;
423 /* length of the whole thing in dwords */
424 len_dwords = NUM_CHUNKS(len, 3);
425 /* number of bytes in the last chunk (len % 8) */
426 last_u64_bytes = len & 0x07;
428 if (op->cipher_offset & 0x7) {
429 printf("** cipher_offset(%d) fails 64-bit word alignment **",
432 return XLR_SEC_ERR_CIPHER_MODE; /* ! fix ! */
435 * global_offset is only three bits, so work the number of the whole
436 * 8-byte words into the global offset. both offset and
437 * cipher_offset are byte counts
439 cipher_offset_dwords = (op->iv_offset + byte_offset) >> 3;
441 if (op->cipher_mode == XLR_SEC_CIPHER_MODE_F8 ||
442 op->cipher_mode == XLR_SEC_CIPHER_MODE_CTR) {
443 if (multi_frag_flag) {
444 int nlhmac = ((op->source_buf_size + global_offset + 7 - op->cipher_offset) >> 3) & 1;
446 pkt_desc->srcLengthIVOffUseIVNext =
447 FIELD_VALUE(PKT_DSC_HASHBYTES, len & 7) |
448 FIELD_VALUE(PKT_DSC_IVOFF, cipher_offset_dwords) |
449 FIELD_VALUE(PKT_DSC_PKTLEN, nlhmac + ((len + 7) >> 3)) |
450 FIELD_VALUE(PKT_DSC_NLHMAC, nlhmac) |
451 FIELD_VALUE(PKT_DSC_BREAK, 0) |
452 FIELD_VALUE(PKT_DSC_WAIT, 1) |
453 FIELD_VALUE(PKT_DSC_NEXT, 1) |
454 FIELD_VALUE(PKT_DSC_SEGADDR, seg_addr >> (PKT_DSC_SEGADDR_LSB)) |
455 FIELD_VALUE(PKT_DSC_SEGOFFSET, global_offset);
457 int nlhmac = ((op->source_buf_size + global_offset + 7 - op->cipher_offset) >> 3) & 1;
459 pkt_desc->srcLengthIVOffUseIVNext =
460 FIELD_VALUE(PKT_DSC_HASHBYTES, len & 7) |
461 FIELD_VALUE(PKT_DSC_IVOFF, cipher_offset_dwords) |
462 FIELD_VALUE(PKT_DSC_PKTLEN, nlhmac + ((len + 7) >> 3)) |
463 FIELD_VALUE(PKT_DSC_NLHMAC, nlhmac) |
464 FIELD_VALUE(PKT_DSC_BREAK, 0) |
465 FIELD_VALUE(PKT_DSC_WAIT, 0) |
466 FIELD_VALUE(PKT_DSC_SEGADDR, seg_addr >> (PKT_DSC_SEGADDR_LSB)) |
467 FIELD_VALUE(PKT_DSC_SEGOFFSET, global_offset);
471 if (multi_frag_flag) {
472 pkt_desc->srcLengthIVOffUseIVNext =
473 FIELD_VALUE(PKT_DSC_HASHBYTES, len & 7) |
474 FIELD_VALUE(PKT_DSC_IVOFF, cipher_offset_dwords) |
475 FIELD_VALUE(PKT_DSC_PKTLEN, (len + 7) >> 3) |
476 FIELD_VALUE(PKT_DSC_BREAK, 0) |
477 FIELD_VALUE(PKT_DSC_WAIT, 0) |
478 FIELD_VALUE(PKT_DSC_NEXT, 1) |
479 FIELD_VALUE(PKT_DSC_SEGADDR, seg_addr >> (PKT_DSC_SEGADDR_LSB)) |
480 FIELD_VALUE(PKT_DSC_SEGOFFSET, global_offset);
483 next_pkt_desc->srcLengthIVOffUseIVNext =
484 FIELD_VALUE(PKT_DSC_HASHBYTES, (next_len & 7)) |
485 FIELD_VALUE(PKT_DSC_IVOFF, 0) |
486 FIELD_VALUE(PKT_DSC_PKTLEN, (next_len + 7) >> 3) |
487 FIELD_VALUE(PKT_DSC_BREAK, 0) |
488 FIELD_VALUE(PKT_DSC_WAIT, 0) |
489 FIELD_VALUE(PKT_DSC_NEXT, 0) |
490 FIELD_VALUE(PKT_DSC_SEGADDR, next_seg_addr >> (PKT_DSC_SEGADDR_LSB)) |
491 FIELD_VALUE(PKT_DSC_SEGOFFSET, 0);
495 pkt_desc->srcLengthIVOffUseIVNext =
496 FIELD_VALUE(PKT_DSC_HASHBYTES, len & 7) |
497 FIELD_VALUE(PKT_DSC_IVOFF, cipher_offset_dwords) |
498 FIELD_VALUE(PKT_DSC_PKTLEN, (len + 7) >> 3) |
499 FIELD_VALUE(PKT_DSC_BREAK, 0) |
500 FIELD_VALUE(PKT_DSC_WAIT, 0) |
501 FIELD_VALUE(PKT_DSC_SEGADDR, seg_addr >> (PKT_DSC_SEGADDR_LSB)) |
502 FIELD_VALUE(PKT_DSC_SEGOFFSET, global_offset);
508 switch (op->pkt_hmac) {
509 case XLR_SEC_LOADHMACKEY_MODE_OLD:
510 CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext,
511 PKT_DSC_LOADHMACKEY, PKT_DSC_LOADHMACKEY_OLD);
512 if (multi_frag_flag) {
513 CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext,
514 PKT_DSC_LOADHMACKEY, PKT_DSC_LOADHMACKEY_OLD);
518 case XLR_SEC_LOADHMACKEY_MODE_LOAD:
519 CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext,
520 PKT_DSC_LOADHMACKEY, PKT_DSC_LOADHMACKEY_LOAD);
521 if (multi_frag_flag) {
522 CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext,
523 PKT_DSC_LOADHMACKEY, PKT_DSC_LOADHMACKEY_LOAD);
528 if (vector & (XLR_SEC_VECTOR_HMAC | XLR_SEC_VECTOR_HMAC2 | XLR_SEC_VECTOR_GCM | XLR_SEC_VECTOR_F9)) {
529 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_LOADHMACKEY_MODE EXIT\n");
530 return XLR_SEC_ERR_LOADHMACKEY_MODE;
535 switch (op->pkt_hash) {
536 case XLR_SEC_PADHASH_PADDED:
537 CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext,
538 PKT_DSC_PADHASH, PKT_DSC_PADHASH_PADDED);
539 if (multi_frag_flag) {
540 CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext,
541 PKT_DSC_PADHASH, PKT_DSC_PADHASH_PADDED);
544 case XLR_SEC_PADHASH_PAD:
545 CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext,
546 PKT_DSC_PADHASH, PKT_DSC_PADHASH_PAD);
547 if (multi_frag_flag) {
548 CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext,
549 PKT_DSC_PADHASH, PKT_DSC_PADHASH_PAD);
553 if (vector & (XLR_SEC_VECTOR_MAC | XLR_SEC_VECTOR_HMAC | XLR_SEC_VECTOR_HMAC2)) {
554 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_PADHASH_MODE EXIT\n");
555 return XLR_SEC_ERR_PADHASH_MODE;
560 switch (op->pkt_iv) {
561 case XLR_SEC_PKT_IV_OLD:
562 CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext,
563 PKT_DSC_IV, PKT_DSC_IV_OLD);
564 if (multi_frag_flag) {
565 CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext,
566 PKT_DSC_IV, PKT_DSC_IV_OLD);
570 case XLR_SEC_PKT_IV_NEW:
571 CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext,
572 PKT_DSC_IV, PKT_DSC_IV_NEW);
573 if (multi_frag_flag) {
574 CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext,
575 PKT_DSC_IV, PKT_DSC_IV_NEW);
580 if (vector & XLR_SEC_VECTOR_CIPHER) {
581 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_PKT_IV_MODE EXIT\n");
582 return XLR_SEC_ERR_PKT_IV_MODE;
587 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: src_buf=%llx phys_src_buf=%llx \n",
588 (unsigned long long)op->source_buf, (unsigned long long)addr);
590 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: seg_addr=%llx offset=%lld\n",
591 (unsigned long long)seg_addr, (unsigned long long)byte_offset);
593 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: global src offset: %d, iv_offset=%d\n",
594 cipher_offset_dwords, op->iv_offset);
596 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: src_buf_sz=%d PKT_LEN=%d\n",
597 op->source_buf_size, len_dwords);
600 * same operation with the destination. cipher offset affects this,
603 if (multi_frag_flag) {
604 next_seg_addr = (uint64_t) vtophys((void *)(unsigned long)(desc->next_dest_buf));
605 next_seg_addr = (next_seg_addr & ~(SMP_CACHE_BYTES - 1));
607 addr = (uint64_t) vtophys((void *)(unsigned long)op->dest_buf);
608 seg_addr = (addr & ~(SMP_CACHE_BYTES - 1));
609 byte_offset = addr - seg_addr;
610 global_offset = byte_offset & 0x7;
612 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: dest_buf=%llx phys_dest_buf=%llx \n",
613 (unsigned long long)op->dest_buf, (unsigned long long)addr);
615 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: seg_addr=%llx offset=%lld\n",
616 (unsigned long long)seg_addr, (unsigned long long)byte_offset);
619 * Dest Address = (Cipher Dest Address) + (Cipher Offset) + (Global
622 * Cipher Dest Address - Cache-line (0xffffffffe0) Cipher Offset -
623 * Which (64-bit) Word in Cacheline (0-3) Global Dest Data Offset -
624 * Number of Bytes in (64-bit) Word before data
626 * It must be set for Digest-only Ops, since the Digest engine will
627 * write data to this address.
629 cipher_offset_dwords = (op->cipher_offset + byte_offset) >> 3;
632 pkt_desc->dstDataSettings =
633 /* SYM_OP, HASHSRC */
634 FIELD_VALUE(PKT_DSC_CPHROFF, cipher_offset_dwords) |
635 FIELD_VALUE(PKT_DSC_HASHOFF, (op->digest_offset + byte_offset) >> 3) |
636 FIELD_VALUE(PKT_DSC_CPHR_DST_ADDR, seg_addr) |
637 FIELD_VALUE(PKT_DSC_CPHR_DST_DWOFFSET, 0) |
638 FIELD_VALUE(PKT_DSC_CPHR_DST_OFFSET, global_offset);
640 if (multi_frag_flag) {
641 next_pkt_desc->dstDataSettings =
642 /* SYM_OP, HASHSRC */
643 FIELD_VALUE(PKT_DSC_CPHROFF, cipher_offset_dwords) |
644 FIELD_VALUE(PKT_DSC_HASHOFF, (op->digest_offset + byte_offset) >> 3) |
645 FIELD_VALUE(PKT_DSC_CPHR_DST_ADDR, next_seg_addr) |
646 FIELD_VALUE(PKT_DSC_CPHR_DST_DWOFFSET, 0) |
647 FIELD_VALUE(PKT_DSC_CPHR_DST_OFFSET, global_offset);
650 if (op->cipher_type == XLR_SEC_CIPHER_TYPE_ARC4)
651 pkt_desc->dstDataSettings |= FIELD_VALUE(PKT_DSC_ARC4BYTECOUNT, last_u64_bytes);
653 if (op->cipher_type != XLR_SEC_CIPHER_TYPE_NONE) {
654 switch (op->cipher_op) {
655 case XLR_SEC_CIPHER_OP_ENCRYPT:
656 CLEAR_SET_FIELD(pkt_desc->dstDataSettings,
657 PKT_DSC_SYM_OP, PKT_DSC_SYM_OP_ENCRYPT);
658 if (multi_frag_flag) {
659 CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings,
660 PKT_DSC_SYM_OP, PKT_DSC_SYM_OP_ENCRYPT);
664 case XLR_SEC_CIPHER_OP_DECRYPT:
665 CLEAR_SET_FIELD(pkt_desc->dstDataSettings,
666 PKT_DSC_SYM_OP, PKT_DSC_SYM_OP_DECRYPT);
667 if (multi_frag_flag) {
668 CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings,
669 PKT_DSC_SYM_OP, PKT_DSC_SYM_OP_DECRYPT);
674 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_CIPHER_OP EXIT\n");
675 return XLR_SEC_ERR_CIPHER_OP;
678 if (flags & XLR_SEC_SETUP_OP_HMAC) {
679 switch (op->digest_src) {
680 case XLR_SEC_DIGEST_SRC_DMA:
681 CLEAR_SET_FIELD(pkt_desc->dstDataSettings,
682 PKT_DSC_HASHSRC, PKT_DSC_HASHSRC_DMA);
683 if (multi_frag_flag) {
684 CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings,
685 PKT_DSC_HASHSRC, PKT_DSC_HASHSRC_DMA);
689 case XLR_SEC_DIGEST_SRC_CPHR:
690 CLEAR_SET_FIELD(pkt_desc->dstDataSettings,
691 PKT_DSC_HASHSRC, PKT_DSC_HASHSRC_CIPHER);
692 if (multi_frag_flag) {
693 CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings,
694 PKT_DSC_HASHSRC, PKT_DSC_HASHSRC_CIPHER);
698 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_DIGEST_SRC EXIT\n");
699 return XLR_SEC_ERR_DIGEST_SRC;
702 if (op->cksum_type != XLR_SEC_CKSUM_TYPE_NOP) {
703 switch (op->cksum_src) {
704 case XLR_SEC_CKSUM_SRC_DMA:
705 CLEAR_SET_FIELD(pkt_desc->dstDataSettings,
706 PKT_DSC_CKSUMSRC, PKT_DSC_CKSUMSRC_DMA);
707 if (multi_frag_flag) {
708 CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings,
709 PKT_DSC_CKSUMSRC, PKT_DSC_CKSUMSRC_DMA);
712 case XLR_SEC_CKSUM_SRC_CIPHER:
713 CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings,
714 PKT_DSC_CKSUMSRC, PKT_DSC_CKSUMSRC_CIPHER);
715 if (multi_frag_flag) {
716 CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings,
717 PKT_DSC_CKSUMSRC, PKT_DSC_CKSUMSRC_CIPHER);
721 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_CKSUM_SRC EXIT\n");
722 return XLR_SEC_ERR_CKSUM_SRC;
725 pkt_desc->ckSumDstNonceHiCFBMaskLLWMask =
726 FIELD_VALUE(PKT_DSC_HASH_BYTE_OFF, (op->digest_offset & 0x7)) |
727 FIELD_VALUE(PKT_DSC_PKTLEN_BYTES, 0) |
728 /* NONCE_HI, PKT_DSC_LASTWORD, CFB_MASK, CKSUM_DST_ADDR */
729 FIELD_VALUE(PKT_DSC_IV_OFF_HI, 0);
731 if (multi_frag_flag) {
732 next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask =
733 FIELD_VALUE(PKT_DSC_HASH_BYTE_OFF, (op->digest_offset & 0x7)) |
734 FIELD_VALUE(PKT_DSC_PKTLEN_BYTES, 0) |
735 /* NONCE_HI, PKT_DSC_LASTWORD, CFB_MASK, CKSUM_DST_ADDR */
736 FIELD_VALUE(PKT_DSC_IV_OFF_HI, 0);
739 switch (op->pkt_lastword) {
740 case XLR_SEC_LASTWORD_128:
741 CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
742 PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_128);
743 if (multi_frag_flag) {
744 CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
745 PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_128);
749 case XLR_SEC_LASTWORD_96MASK:
750 CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
751 PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_96MASK);
752 if (multi_frag_flag) {
753 CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
754 PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_96MASK);
757 case XLR_SEC_LASTWORD_64MASK:
758 CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
759 PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_64MASK);
760 if (multi_frag_flag) {
761 CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
762 PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_64MASK);
765 case XLR_SEC_LASTWORD_32MASK:
766 CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
767 PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_32MASK);
768 if (multi_frag_flag) {
769 CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
770 PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_32MASK);
774 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_LASTWORD_MODE EXIT\n");
775 return XLR_SEC_ERR_LASTWORD_MODE;
777 CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
778 PKT_DSC_CFB_MASK, op->cfb_mask);
779 CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
780 PKT_DSC_NONCE_HI, htonl(op->nonce) >> 24);
781 CLEAR_SET_FIELD(pkt_desc->authDstNonceLow,
782 PKT_DSC_NONCE_LOW, htonl(op->nonce) & 0xffffff);
784 if (multi_frag_flag) {
785 CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
786 PKT_DSC_CFB_MASK, op->cfb_mask);
787 CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
788 PKT_DSC_NONCE_HI, htonl(op->nonce) >> 24);
789 CLEAR_SET_FIELD(next_pkt_desc->authDstNonceLow,
790 PKT_DSC_NONCE_LOW, htonl(op->nonce) & 0xffffff);
794 /* Auth Dest Address must be Cacheline aligned on input */
795 if (vector & (XLR_SEC_VECTOR_MAC | XLR_SEC_VECTOR_HMAC | XLR_SEC_VECTOR_HMAC2 | XLR_SEC_VECTOR_GCM | XLR_SEC_VECTOR_F9)) {
796 pkt_desc->authDstNonceLow |=
798 FIELD_VALUE(PKT_DSC_AUTH_DST_ADDR,
799 (uint64_t) vtophys((void *)(unsigned long)op->auth_dest)) |
800 FIELD_VALUE(PKT_DSC_CIPH_OFF_HI, 0);
803 if (multi_frag_flag) {
804 next_pkt_desc->authDstNonceLow |=
806 FIELD_VALUE(PKT_DSC_AUTH_DST_ADDR,
807 (uint64_t) vtophys((void *)(unsigned long)desc->next_auth_dest)) |
808 FIELD_VALUE(PKT_DSC_CIPH_OFF_HI, 0);
813 /* CkSum Dest Address must be Cacheline aligned on input */
814 if (op->cksum_type == XLR_SEC_CKSUM_TYPE_IP) {
815 CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
816 PKT_DSC_CKSUM_DST_ADDR,
817 (uint64_t) vtophys((void *)(unsigned long)op->cksum_dest));
819 if (multi_frag_flag) {
820 CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
821 PKT_DSC_CKSUM_DST_ADDR,
822 (uint64_t) vtophys((void *)(unsigned long)desc->next_cksum_dest));
826 * XLR_SEC_CMD_DIAG (" xlr_sec_setup_packet(): pkt_desc=%llx
827 * phys_pkt_desc=%llx \n", (unsigned long long)pkt_desc, (unsigned
828 * long long)virt_to_phys(pkt_desc)); (unsigned long long)pkt_desc,
829 * (unsigned long long)vtophys(pkt_desc));
831 XLR_SEC_CMD_DIAG(" xlr_sec_setup_packet(): pkt_desc=%p phys_pkt_desc=%llx \n",
832 pkt_desc, (unsigned long long)vtophys(pkt_desc));
834 CLEAR_SET_FIELD(*data, MSG_CMD_DATA_ADDR, ((uint64_t) vtophys(pkt_desc)));
835 CLEAR_SET_FIELD(*data, MSG_CMD_DATA_CTL, SEC_EOP);
836 CLEAR_SET_FIELD(*data, MSG_CMD_DATA_LEN, MSG_CMD_DATA_LEN_LOAD);
838 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: DONE\n");
842 printf("data desc\n");
843 printf("srcLengthIVOffUseIVNext = 0x%llx\n", pkt_desc->srcLengthIVOffUseIVNext);
844 printf("dstDataSettings = 0x%llx\n", pkt_desc->dstDataSettings);
845 printf("authDstNonceLow = 0x%llx\n", pkt_desc->authDstNonceLow);
846 printf("ckSumDstNonceHiCFBMaskLLWMask = 0x%llx\n", pkt_desc->ckSumDstNonceHiCFBMaskLLWMask);
849 if (multi_frag_flag) {
851 printf("next data desc\n");
852 printf("srcLengthIVOffUseIVNext = 0x%llx\n", next_pkt_desc->srcLengthIVOffUseIVNext);
853 printf("dstDataSettings = 0x%llx\n", next_pkt_desc->dstDataSettings);
854 printf("authDstNonceLow = 0x%llx\n", next_pkt_desc->authDstNonceLow);
855 printf("ckSumDstNonceHiCFBMaskLLWMask = 0x%llx\n", next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask);
860 if (op->cipher_type == XLR_SEC_CIPHER_TYPE_ARC4) {
862 op->source_buf_size += 0;
866 return XLR_SEC_ERR_NONE;
871 identify_symkey_ctl_error(uint32_t code, xlr_sec_error_t err)
873 int ret_val = EINVAL;
877 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error: No Error\n");
880 case CTL_ERR_CIPHER_OP:
881 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_CIPHER_OP) - Unknown Cipher Op \n");
884 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_MODE) - "
885 "Unknown or Not Allowed Mode \n");
887 case CTL_ERR_CHKSUM_SRC:
888 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_CHKSUM_SRC) - Unknown CkSum Src\n");
890 case CTL_ERR_CFB_MASK:
891 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_CFB_MASK) - Forbidden CFB Mask \n");
894 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_OP) - Unknown Ctrl Op \n");
896 case CTL_ERR_DATA_READ:
897 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_DATA_READ) - Data Read Error\n");
899 case CTL_ERR_DESC_CTRL:
900 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_DESC_CTRL) - "
901 "Descriptor Ctrl Field Error \n");
906 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error: UNKNOWN CODE=%d \n", code);
914 identify_symkey_data_error(uint32_t code, xlr_sec_error_t err)
916 int ret_val = -EINVAL;
920 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error No Error\n");
923 case DATA_ERR_LEN_CIPHER:
924 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Not Enough Data To Cipher\n");
926 case DATA_ERR_IV_ADDR:
927 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Illegal IV Loacation\n");
929 case DATA_ERR_WD_LEN_AES:
930 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Illegal Nb Words To AES\n");
932 case DATA_ERR_BYTE_COUNT:
933 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Illegal Pad And ByteCount Spec\n");
935 case DATA_ERR_LEN_CKSUM:
936 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Not Enough Data To CkSum\n");
939 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Unknown Data Op \n");
942 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Data Read Error \n");
945 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Data Write Error \n");
947 case DATA_ERR_UNDEF1:
949 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error - UNKNOWN CODE=%d \n", code);
957 xlr_sec_submit_message(symkey_desc_pt desc, uint32_t cfg_vector)
960 uint32_t ctl_error, data_error;
963 XLR_SEC_CMD_DIAG("xlr_sec_submit_message: ENTER\n");
964 err = XLR_SEC_ERR_NONE;
965 XLR_SEC_CMD_DIAG_SYM_DESC(desc, cfg_vector);
968 /* For now, send message and wait for response */
969 err = xlr_sec_submit_op(desc);
971 XLR_SEC_CMD_DIAG("xlr_sec_submit_message: err = %d \n", (uint32_t) err);
973 if (err != XLR_SEC_ERR_NONE) {
977 ctl_error = desc->ctl_result;
978 data_error = desc->data_result;
980 XLR_SEC_CMD_DIAG("xlr_sec_submit_message: ctl_error = %x data_error = %x\n",
981 ctl_error, data_error);
983 if ((ret_val = identify_symkey_ctl_error(ctl_error, err)) == 0)
984 ret_val = identify_symkey_data_error(data_error, err);
986 XLR_SEC_CMD_DIAG("xlr_sec_submit_message: identify error = %d \n", ret_val);
990 XLR_SEC_CMD_DIAG("xlr_sec_submit_message: DONE\n");
997 xlr_sec_setup_cipher(xlr_sec_io_pt op,
998 ControlDescriptor_pt ctl_desc,
1001 uint32_t aes_flag = 0;
1002 uint32_t cipher_vector = 0;
1004 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ENTER vector = %04x\n", *vector);
1006 switch (op->cipher_type) {
1007 case XLR_SEC_CIPHER_TYPE_NONE:
1008 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_BYPASS);
1009 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: CIPHER_TYPE_NONE EXIT\n");
1010 return XLR_SEC_ERR_NONE;
1011 case XLR_SEC_CIPHER_TYPE_DES:
1012 cipher_vector |= XLR_SEC_VECTOR_CIPHER_DES;
1013 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_DES);
1015 case XLR_SEC_CIPHER_TYPE_3DES:
1016 cipher_vector |= XLR_SEC_VECTOR_CIPHER_3DES;
1017 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_3DES);
1019 case XLR_SEC_CIPHER_TYPE_AES128:
1021 cipher_vector |= XLR_SEC_VECTOR_CIPHER_AES128;
1022 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_AES128);
1024 case XLR_SEC_CIPHER_TYPE_AES192:
1026 cipher_vector |= XLR_SEC_VECTOR_CIPHER_AES192;
1027 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_AES192);
1029 case XLR_SEC_CIPHER_TYPE_AES256:
1031 cipher_vector |= XLR_SEC_VECTOR_CIPHER_AES256;
1032 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_AES256);
1034 case XLR_SEC_CIPHER_TYPE_ARC4:
1035 cipher_vector |= XLR_SEC_VECTOR_CIPHER_ARC4;
1036 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_ARC4);
1037 SET_FIELD(ctl_desc->instruction, CTL_DSC_ARC4_KEYLEN,
1039 SET_FIELD(ctl_desc->instruction, CTL_DSC_ARC4_LOADSTATE,
1041 SET_FIELD(ctl_desc->instruction, CTL_DSC_ARC4_SAVESTATE,
1043 if (op->rc4_loadstate || op->rc4_savestate)
1044 cipher_vector |= XLR_SEC_VECTOR_STATE;
1046 case XLR_SEC_CIPHER_TYPE_KASUMI_F8:
1048 cipher_vector |= XLR_SEC_VECTOR_CIPHER_KASUMI_F8;
1049 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_KASUMI_F8);
1052 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_TYPE EXIT\n");
1053 return XLR_SEC_ERR_CIPHER_TYPE;
1056 switch (op->cipher_mode) {
1057 case XLR_SEC_CIPHER_MODE_ECB:
1059 cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC_OFB;
1061 cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC;
1062 SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_ECB);
1064 case XLR_SEC_CIPHER_MODE_CBC:
1066 cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC_OFB;
1068 cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC;
1069 SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_CBC);
1071 case XLR_SEC_CIPHER_MODE_OFB:
1072 if (aes_flag == 0) {
1073 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_MODE EXIT\n");
1074 return XLR_SEC_ERR_CIPHER_MODE;
1076 cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC_OFB;
1077 SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_OFB);
1079 case XLR_SEC_CIPHER_MODE_CTR:
1080 if (aes_flag == 0) {
1081 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_MODE EXIT\n");
1082 return XLR_SEC_ERR_CIPHER_MODE;
1084 cipher_vector |= XLR_SEC_VECTOR_MODE_CTR_CFB;
1085 SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_CTR);
1087 case XLR_SEC_CIPHER_MODE_CFB:
1088 if (aes_flag == 0) {
1089 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_MODE EXIT\n");
1090 return XLR_SEC_ERR_CIPHER_MODE;
1092 cipher_vector |= XLR_SEC_VECTOR_MODE_CTR_CFB;
1093 SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_CFB);
1095 case XLR_SEC_CIPHER_MODE_F8:
1096 if (aes_flag == 0) {
1097 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_MODE EXIT\n");
1098 return XLR_SEC_ERR_CIPHER_MODE;
1100 cipher_vector |= XLR_SEC_VECTOR_MODE_F8;
1101 SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_F8);
1104 if (!(cipher_vector & (XLR_SEC_VECTOR_CIPHER_ARC4 | XLR_SEC_VECTOR_CIPHER_KASUMI_F8))) {
1105 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_MODE EXIT\n");
1106 return XLR_SEC_ERR_CIPHER_MODE;
1110 switch (op->cipher_init) {
1111 case XLR_SEC_CIPHER_INIT_OK:
1112 SET_FIELD(ctl_desc->instruction,
1113 CTL_DSC_ICPHR, CTL_DSC_ICPHR_OKY);
1116 case XLR_SEC_CIPHER_INIT_NK:
1117 SET_FIELD(ctl_desc->instruction,
1118 CTL_DSC_ICPHR, CTL_DSC_ICPHR_NKY);
1121 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_INIT EXIT\n");
1122 return XLR_SEC_ERR_CIPHER_INIT;
1125 *vector |= cipher_vector;
1127 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: EXIT vector = %04x\n", *vector);
1129 return XLR_SEC_ERR_NONE;
1134 xlr_sec_setup_digest(xlr_sec_io_pt op,
1135 ControlDescriptor_pt ctl_desc,
1138 uint32_t hash_flag = 0;
1139 uint32_t hmac_flag = 0;
1140 uint32_t digest_vector = 0;
1142 XLR_SEC_CMD_DIAG("xlr_sec_setup_digest: ENTER vector = %04x\n", *vector);
1144 switch (op->digest_type) {
1145 case XLR_SEC_DIGEST_TYPE_MD5:
1146 digest_vector |= XLR_SEC_VECTOR_MAC;
1147 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_MD5);
1149 case XLR_SEC_DIGEST_TYPE_SHA1:
1150 digest_vector |= XLR_SEC_VECTOR_MAC;
1151 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA1);
1153 case XLR_SEC_DIGEST_TYPE_SHA256:
1154 digest_vector |= XLR_SEC_VECTOR_MAC;
1155 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA256);
1157 case XLR_SEC_DIGEST_TYPE_SHA384:
1158 digest_vector |= XLR_SEC_VECTOR_MAC;
1159 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_SHA384 >> 2);
1160 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA384);
1162 case XLR_SEC_DIGEST_TYPE_SHA512:
1163 digest_vector |= XLR_SEC_VECTOR_MAC;
1164 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_SHA512 >> 2);
1165 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA512);
1167 case XLR_SEC_DIGEST_TYPE_GCM:
1169 digest_vector |= XLR_SEC_VECTOR_GCM;
1170 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_GCM >> 2);
1171 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_GCM);
1173 case XLR_SEC_DIGEST_TYPE_KASUMI_F9:
1175 digest_vector |= XLR_SEC_VECTOR_F9;
1176 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_KASUMI_F9 >> 2);
1177 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_KASUMI_F9);
1179 case XLR_SEC_DIGEST_TYPE_HMAC_MD5:
1181 digest_vector |= XLR_SEC_VECTOR_HMAC;
1182 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_MD5);
1184 case XLR_SEC_DIGEST_TYPE_HMAC_SHA1:
1186 digest_vector |= XLR_SEC_VECTOR_HMAC;
1187 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA1);
1189 case XLR_SEC_DIGEST_TYPE_HMAC_SHA256:
1191 digest_vector |= XLR_SEC_VECTOR_HMAC;
1192 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA256);
1194 case XLR_SEC_DIGEST_TYPE_HMAC_SHA384:
1196 digest_vector |= XLR_SEC_VECTOR_HMAC2;
1197 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_SHA384 >> 2);
1198 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA384);
1200 case XLR_SEC_DIGEST_TYPE_HMAC_SHA512:
1202 digest_vector |= XLR_SEC_VECTOR_HMAC2;
1203 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_SHA512 >> 2);
1204 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA512);
1207 return XLR_SEC_ERR_DIGEST_TYPE;
1210 if (hmac_flag == 1) {
1211 SET_FIELD(ctl_desc->instruction, CTL_DSC_HMAC, CTL_DSC_HMAC_ON);
1214 if (hmac_flag || hash_flag) {
1215 switch (op->digest_init) {
1216 case XLR_SEC_DIGEST_INIT_OLDKEY:
1217 SET_FIELD(ctl_desc->instruction, CTL_DSC_IHASH, CTL_DSC_IHASH_OLD);
1219 case XLR_SEC_DIGEST_INIT_NEWKEY:
1220 SET_FIELD(ctl_desc->instruction, CTL_DSC_IHASH, CTL_DSC_IHASH_NEW);
1223 return XLR_SEC_ERR_DIGEST_INIT;
1226 *vector |= digest_vector;
1228 XLR_SEC_CMD_DIAG("xlr_sec_setup_digest: EXIT vector = %04x\n", *vector);
1229 return XLR_SEC_ERR_NONE;
1234 xlr_sec_setup_cksum(xlr_sec_io_pt op,
1235 ControlDescriptor_pt ctl_desc)
1237 switch (op->cksum_type) {
1238 case XLR_SEC_CKSUM_TYPE_NOP:
1239 SET_FIELD(ctl_desc->instruction, CTL_DSC_CKSUM, CTL_DSC_CKSUM_NOP);
1240 return XLR_SEC_ERR_NONE;
1241 case XLR_SEC_CKSUM_TYPE_IP:
1242 SET_FIELD(ctl_desc->instruction, CTL_DSC_CKSUM, CTL_DSC_CKSUM_IP);
1245 return XLR_SEC_ERR_CKSUM_TYPE;
1248 return XLR_SEC_ERR_NONE;
1254 xlr_sec_control_setup(xlr_sec_io_pt op,
1257 ControlDescriptor_pt ctl_desc,
1258 xlr_sec_drv_user_t * user,
1261 uint64_t *hmac_key = NULL;
1262 uint64_t *cipher_key = NULL;
1263 uint64_t *cipher_state = NULL;
1264 uint32_t ctl_size = 0;
1265 uint64_t ctl_addr = 0;
1266 uint32_t cipher_keylen = 0;
1267 uint32_t hmac_keylen = 0;
1271 XLR_SEC_CMD_DIAG(" ENTER vector = %04x\n", vector);
1275 case XLR_SEC_VECTOR_MAC:
1276 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR_MAC \n");
1277 ctl_size = sizeof(HMAC_t);
1279 case XLR_SEC_VECTOR_HMAC:
1280 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_HMAC \n");
1281 hmac_key = &ctl_desc->cipherHashInfo.infoHMAC.hmacKey0;
1282 hmac_keylen = sizeof(HMAC_t);
1283 ctl_size = sizeof(HMAC_t);
1285 case XLR_SEC_VECTOR_CIPHER_ARC4:
1286 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4\n");
1287 cipher_key = &ctl_desc->cipherHashInfo.infoARC4.cipherKey0;
1288 cipher_keylen = op->rc4_key_len;
1289 ctl_size = sizeof(ARC4_t);
1291 case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC:
1292 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__HMAC\n");
1293 cipher_key = &ctl_desc->cipherHashInfo.infoARC4HMAC.cipherKey0;
1294 hmac_key = &ctl_desc->cipherHashInfo.infoARC4HMAC.hmacKey0;
1295 cipher_keylen = op->rc4_key_len;
1296 hmac_keylen = sizeof(HMAC_t);
1297 ctl_size = sizeof(ARC4HMAC_t);
1299 case XLR_SEC_VECTOR_CIPHER_ARC4__STATE:
1300 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__STATE\n");
1301 cipher_key = &ctl_desc->cipherHashInfo.infoARC4State.cipherKey0;
1303 &ctl_desc->cipherHashInfo.infoARC4State.Arc4SboxData0;
1304 cipher_keylen = op->rc4_key_len;
1305 ctl_size = sizeof(ARC4State_t);
1307 case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC__STATE:
1308 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__HMAC__STATE\n");
1309 cipher_key = &ctl_desc->cipherHashInfo.infoARC4StateHMAC.cipherKey0;
1311 &ctl_desc->cipherHashInfo.infoARC4StateHMAC.Arc4SboxData0;
1312 hmac_key = &ctl_desc->cipherHashInfo.infoARC4StateHMAC.hmacKey0;
1313 cipher_keylen = op->rc4_key_len;
1314 hmac_keylen = sizeof(HMAC_t);
1315 ctl_size = sizeof(ARC4StateHMAC_t);
1317 case XLR_SEC_VECTOR_CIPHER_KASUMI_F8:
1318 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8\n");
1319 cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8.cipherKey0;
1320 cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH;
1321 ctl_size = sizeof(KASUMIF8_t);
1323 case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC:
1324 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC\n");
1325 cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8HMAC.cipherKey0;
1326 cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH;
1327 hmac_key = &ctl_desc->cipherHashInfo.infoKASUMIF8HMAC.hmacKey0;
1328 hmac_keylen = sizeof(HMAC_t);
1329 ctl_size = sizeof(KASUMIF8HMAC_t);
1331 case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC2:
1332 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC2\n");
1333 cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8HMAC2.cipherKey0;
1334 cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH;
1335 hmac_key = &ctl_desc->cipherHashInfo.infoKASUMIF8HMAC2.hmacKey0;
1336 hmac_keylen = sizeof(HMAC2_t);
1337 ctl_size = sizeof(KASUMIF8HMAC2_t);
1339 case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__GCM:
1340 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__GCM\n");
1341 cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8GCM.cipherKey0;
1342 cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH;
1343 hmac_key = &ctl_desc->cipherHashInfo.infoKASUMIF8GCM.GCMH0;
1344 hmac_keylen = sizeof(GCM_t);
1345 ctl_size = sizeof(KASUMIF8GCM_t);
1347 case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__F9:
1348 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__F9\n");
1349 cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8F9.cipherKey0;
1350 cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH;
1351 hmac_key = &ctl_desc->cipherHashInfo.infoKASUMIF8F9.authKey0;
1352 hmac_keylen = sizeof(F9_t);
1353 ctl_size = sizeof(KASUMIF8F9_t);
1355 case XLR_SEC_VECTOR__CIPHER_DES__HMAC__MODE_ECB_CBC:
1356 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_DES__HMAC__MODE_ECB_CBC \n");
1357 cipher_key = &ctl_desc->cipherHashInfo.infoDESHMAC.cipherKey0;
1358 hmac_key = &ctl_desc->cipherHashInfo.infoDESHMAC.hmacKey0;
1359 hmac_keylen = sizeof(HMAC_t);
1360 cipher_keylen = XLR_SEC_DES_KEY_LENGTH;
1361 ctl_size = sizeof(DESHMAC_t);
1363 case XLR_SEC_VECTOR__CIPHER_DES__MODE_ECB_CBC:
1364 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_DES__MODE_ECB_CBC \n");
1365 cipher_key = &ctl_desc->cipherHashInfo.infoDES.cipherKey0;
1366 cipher_keylen = XLR_SEC_DES_KEY_LENGTH;
1367 ctl_size = sizeof(DES_t);
1369 case XLR_SEC_VECTOR__CIPHER_3DES__HMAC__MODE_ECB_CBC:
1370 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__HMAC__MODE_ECB_CBC \n");
1371 cipher_key = &ctl_desc->cipherHashInfo.info3DESHMAC.cipherKey0;
1372 hmac_key = &ctl_desc->cipherHashInfo.info3DESHMAC.hmacKey0;
1373 cipher_keylen = XLR_SEC_3DES_KEY_LENGTH;
1374 hmac_keylen = sizeof(HMAC_t);
1375 ctl_size = sizeof(DES3HMAC_t);
1377 case XLR_SEC_VECTOR__CIPHER_3DES__MODE_ECB_CBC:
1378 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__MODE_ECB_CBC \n");
1379 cipher_key = &ctl_desc->cipherHashInfo.info3DES.cipherKey0;
1380 cipher_keylen = XLR_SEC_3DES_KEY_LENGTH;
1381 ctl_size = sizeof(DES3_t);
1383 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_CTR_CFB:
1384 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_CTR_CFB \n");
1385 cipher_key = &ctl_desc->cipherHashInfo.infoAES128HMAC.cipherKey0;
1386 hmac_key = &ctl_desc->cipherHashInfo.infoAES128HMAC.hmacKey0;
1387 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
1388 hmac_keylen = sizeof(HMAC_t);
1389 ctl_size = sizeof(AES128HMAC_t);
1391 case XLR_SEC_VECTOR__CIPHER_AES128__MODE_CTR_CFB:
1392 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__MODE_CTR_CFB \n");
1393 cipher_key = &ctl_desc->cipherHashInfo.infoAES128.cipherKey0;
1394 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
1395 ctl_size = sizeof(AES128_t);
1397 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_ECB_CBC_OFB:
1398 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_ECB_CBC_OFB \n");
1399 cipher_key = &ctl_desc->cipherHashInfo.infoAES128HMAC.cipherKey0;
1400 hmac_key = &ctl_desc->cipherHashInfo.infoAES128HMAC.hmacKey0;
1401 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
1402 hmac_keylen = sizeof(HMAC_t);
1403 ctl_size = sizeof(AES128HMAC_t);
1405 case XLR_SEC_VECTOR__CIPHER_AES128__MODE_ECB_CBC_OFB:
1406 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__MODE_ECB_CBC_OFB \n");
1407 cipher_key = &ctl_desc->cipherHashInfo.infoAES128.cipherKey0;
1408 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
1409 ctl_size = sizeof(AES128_t);
1411 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_F8:
1412 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_F8 \n");
1413 cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8HMAC.cipherKey0;
1414 hmac_key = &ctl_desc->cipherHashInfo.infoAES128F8HMAC.hmacKey0;
1415 cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH;
1416 hmac_keylen = sizeof(HMAC_t);
1417 ctl_size = sizeof(AES128F8HMAC_t);
1419 case XLR_SEC_VECTOR__CIPHER_AES128__MODE_F8:
1420 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__MODE_F8 \n");
1421 cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8.cipherKey0;
1422 cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH;
1423 ctl_size = sizeof(AES128F8_t);
1425 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_CTR_CFB:
1426 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_CTR_CFB \n");
1427 cipher_key = &ctl_desc->cipherHashInfo.infoAES192HMAC.cipherKey0;
1428 hmac_key = &ctl_desc->cipherHashInfo.infoAES192HMAC.hmacKey0;
1429 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
1430 hmac_keylen = sizeof(HMAC_t);
1431 ctl_size = sizeof(AES192HMAC_t);
1433 case XLR_SEC_VECTOR__CIPHER_AES192__MODE_CTR_CFB:
1434 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__MODE_CTR_CFB \n");
1435 cipher_key = &ctl_desc->cipherHashInfo.infoAES192.cipherKey0;
1436 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
1437 ctl_size = sizeof(AES192_t);
1439 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_ECB_CBC_OFB:
1440 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_ECB_CBC_OFB \n");
1441 cipher_key = &ctl_desc->cipherHashInfo.infoAES192HMAC.cipherKey0;
1442 hmac_key = &ctl_desc->cipherHashInfo.infoAES192HMAC.hmacKey0;
1443 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
1444 hmac_keylen = sizeof(HMAC_t);
1445 ctl_size = sizeof(AES192HMAC_t);
1447 case XLR_SEC_VECTOR__CIPHER_AES192__MODE_ECB_CBC_OFB:
1448 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__MODE_ECB_CBC_OFB \n");
1449 cipher_key = &ctl_desc->cipherHashInfo.infoAES192.cipherKey0;
1450 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
1451 ctl_size = sizeof(AES192_t);
1453 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_F8:
1454 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_F8 \n");
1455 cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8HMAC.cipherKey0;
1456 hmac_key = &ctl_desc->cipherHashInfo.infoAES192F8HMAC.hmacKey0;
1457 cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH;
1458 hmac_keylen = sizeof(HMAC_t);
1459 ctl_size = sizeof(AES192F8HMAC_t);
1461 case XLR_SEC_VECTOR__CIPHER_AES192__MODE_F8:
1462 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__MODE_F8 \n");
1463 cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8.cipherKey0;
1464 cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH;
1465 ctl_size = sizeof(AES192F8_t);
1468 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_CTR_CFB:
1469 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_CTR_CFB \n");
1470 cipher_key = &ctl_desc->cipherHashInfo.infoAES256HMAC.cipherKey0;
1471 hmac_key = &ctl_desc->cipherHashInfo.infoAES256HMAC.hmacKey0;
1472 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
1473 hmac_keylen = sizeof(HMAC_t);
1474 ctl_size = sizeof(AES256HMAC_t);
1476 case XLR_SEC_VECTOR__CIPHER_AES256__MODE_CTR_CFB:
1477 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__MODE_CTR_CFB \n");
1478 cipher_key = &ctl_desc->cipherHashInfo.infoAES256.cipherKey0;
1479 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
1480 ctl_size = sizeof(AES256_t);
1482 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_ECB_CBC_OFB:
1483 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_ECB_CBC_OFB \n");
1484 cipher_key = &ctl_desc->cipherHashInfo.infoAES256HMAC.cipherKey0;
1485 hmac_key = &ctl_desc->cipherHashInfo.infoAES256HMAC.hmacKey0;
1486 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
1487 hmac_keylen = sizeof(HMAC_t);
1488 ctl_size = sizeof(AES256HMAC_t);
1490 case XLR_SEC_VECTOR__CIPHER_AES256__MODE_ECB_CBC_OFB:
1491 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__MODE_ECB_CBC_OFB \n");
1492 cipher_key = &ctl_desc->cipherHashInfo.infoAES256.cipherKey0;
1493 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
1494 ctl_size = sizeof(AES256_t);
1496 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_F8:
1497 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_F8 \n");
1498 cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8HMAC.cipherKey0;
1499 hmac_key = &ctl_desc->cipherHashInfo.infoAES256F8HMAC.hmacKey0;
1500 cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH;
1501 hmac_keylen = sizeof(HMAC_t);
1502 ctl_size = sizeof(AES256F8HMAC_t);
1504 case XLR_SEC_VECTOR__CIPHER_AES256__MODE_F8:
1505 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__MODE_F8 \n");
1506 cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8.cipherKey0;
1507 cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH;
1508 ctl_size = sizeof(AES256F8_t);
1510 case XLR_SEC_VECTOR_HMAC2:
1511 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_HMAC2 \n");
1512 hmac_key = &ctl_desc->cipherHashInfo.infoHMAC2.hmacKey0;
1513 hmac_keylen = sizeof(HMAC2_t);
1514 ctl_size = sizeof(HMAC2_t);
1516 case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2:
1517 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2\n");
1518 cipher_key = &ctl_desc->cipherHashInfo.infoARC4HMAC2.cipherKey0;
1519 hmac_key = &ctl_desc->cipherHashInfo.infoARC4HMAC2.hmacKey0;
1520 cipher_keylen = op->rc4_key_len;
1521 hmac_keylen = sizeof(HMAC2_t);
1522 ctl_size = sizeof(ARC4HMAC2_t);
1524 case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2__STATE:
1525 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2__STATE\n");
1526 cipher_key = &ctl_desc->cipherHashInfo.infoARC4StateHMAC2.cipherKey0;
1528 &ctl_desc->cipherHashInfo.infoARC4StateHMAC2.Arc4SboxData0;
1529 hmac_key = &ctl_desc->cipherHashInfo.infoARC4StateHMAC2.hmacKey0;
1530 cipher_keylen = op->rc4_key_len;
1531 hmac_keylen = sizeof(HMAC2_t);
1532 ctl_size = sizeof(ARC4StateHMAC2_t);
1534 case XLR_SEC_VECTOR__CIPHER_DES__HMAC2__MODE_ECB_CBC:
1535 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_DES__HMAC2__MODE_ECB_CBC \n");
1536 cipher_key = &ctl_desc->cipherHashInfo.infoDESHMAC2.cipherKey0;
1537 hmac_key = &ctl_desc->cipherHashInfo.infoDESHMAC2.hmacKey0;
1538 hmac_keylen = sizeof(HMAC2_t);
1539 cipher_keylen = XLR_SEC_DES_KEY_LENGTH;
1540 ctl_size = sizeof(DESHMAC2_t);
1542 case XLR_SEC_VECTOR__CIPHER_3DES__HMAC2__MODE_ECB_CBC:
1543 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__HMAC2__MODE_ECB_CBC \n");
1544 cipher_key = &ctl_desc->cipherHashInfo.info3DESHMAC2.cipherKey0;
1545 hmac_key = &ctl_desc->cipherHashInfo.info3DESHMAC2.hmacKey0;
1546 cipher_keylen = XLR_SEC_3DES_KEY_LENGTH;
1547 hmac_keylen = sizeof(HMAC2_t);
1548 ctl_size = sizeof(DES3HMAC2_t);
1550 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_CTR_CFB:
1551 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_CTR_CFB \n");
1552 cipher_key = &ctl_desc->cipherHashInfo.infoAES128HMAC2.cipherKey0;
1553 hmac_key = &ctl_desc->cipherHashInfo.infoAES128HMAC2.hmacKey0;
1554 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
1555 hmac_keylen = sizeof(HMAC2_t);
1556 ctl_size = sizeof(AES128HMAC2_t);
1558 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_ECB_CBC_OFB:
1559 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_ECB_CBC_OFB \n");
1560 cipher_key = &ctl_desc->cipherHashInfo.infoAES128HMAC2.cipherKey0;
1561 hmac_key = &ctl_desc->cipherHashInfo.infoAES128HMAC2.hmacKey0;
1562 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
1563 hmac_keylen = sizeof(HMAC2_t);
1564 ctl_size = sizeof(AES128HMAC2_t);
1566 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_F8:
1567 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_F8 \n");
1568 cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8HMAC2.cipherKey0;
1569 hmac_key = &ctl_desc->cipherHashInfo.infoAES128F8HMAC2.hmacKey0;
1570 cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH;
1571 hmac_keylen = sizeof(HMAC2_t);
1572 ctl_size = sizeof(AES128F8HMAC2_t);
1574 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_CTR_CFB:
1575 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_CTR_CFB \n");
1576 cipher_key = &ctl_desc->cipherHashInfo.infoAES192HMAC2.cipherKey0;
1577 hmac_key = &ctl_desc->cipherHashInfo.infoAES192HMAC2.hmacKey0;
1578 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
1579 hmac_keylen = sizeof(HMAC2_t);
1580 ctl_size = sizeof(AES192HMAC2_t);
1582 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_ECB_CBC_OFB:
1583 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_ECB_CBC_OFB \n");
1584 cipher_key = &ctl_desc->cipherHashInfo.infoAES192HMAC2.cipherKey0;
1585 hmac_key = &ctl_desc->cipherHashInfo.infoAES192HMAC2.hmacKey0;
1586 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
1587 hmac_keylen = sizeof(HMAC2_t);
1588 ctl_size = sizeof(AES192HMAC2_t);
1590 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_F8:
1591 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_F8 \n");
1592 cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8HMAC2.cipherKey0;
1593 hmac_key = &ctl_desc->cipherHashInfo.infoAES192F8HMAC2.hmacKey0;
1594 cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH;
1595 hmac_keylen = sizeof(HMAC2_t);
1596 ctl_size = sizeof(AES192F8HMAC2_t);
1598 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_CTR_CFB:
1599 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_CTR_CFB \n");
1600 cipher_key = &ctl_desc->cipherHashInfo.infoAES256HMAC2.cipherKey0;
1601 hmac_key = &ctl_desc->cipherHashInfo.infoAES256HMAC2.hmacKey0;
1602 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
1603 hmac_keylen = sizeof(HMAC2_t);
1604 ctl_size = sizeof(AES256HMAC2_t);
1606 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_ECB_CBC_OFB:
1607 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_ECB_CBC_OFB \n");
1608 cipher_key = &ctl_desc->cipherHashInfo.infoAES256HMAC2.cipherKey0;
1609 hmac_key = &ctl_desc->cipherHashInfo.infoAES256HMAC2.hmacKey0;
1610 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
1611 hmac_keylen = sizeof(HMAC2_t);
1612 ctl_size = sizeof(AES256HMAC2_t);
1614 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_F8:
1615 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_F8 \n");
1616 cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8HMAC2.cipherKey0;
1617 hmac_key = &ctl_desc->cipherHashInfo.infoAES256F8HMAC2.hmacKey0;
1618 cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH;
1619 hmac_keylen = sizeof(HMAC2_t);
1620 ctl_size = sizeof(AES256F8HMAC2_t);
1622 case XLR_SEC_VECTOR_GCM:
1623 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_GCM \n");
1624 hmac_key = &ctl_desc->cipherHashInfo.infoGCM.GCMH0;
1625 hmac_keylen = sizeof(GCM_t);
1626 ctl_size = sizeof(GCM_t);
1628 case XLR_SEC_VECTOR_CIPHER_ARC4__GCM:
1629 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__GCM\n");
1630 cipher_key = &ctl_desc->cipherHashInfo.infoARC4GCM.cipherKey0;
1631 hmac_key = &ctl_desc->cipherHashInfo.infoARC4GCM.GCMH0;
1632 cipher_keylen = op->rc4_key_len;
1633 hmac_keylen = sizeof(GCM_t);
1634 ctl_size = sizeof(ARC4GCM_t);
1636 case XLR_SEC_VECTOR_CIPHER_ARC4__GCM__STATE:
1637 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__GCM__STATE\n");
1638 cipher_key = &ctl_desc->cipherHashInfo.infoARC4StateGCM.cipherKey0;
1640 &ctl_desc->cipherHashInfo.infoARC4StateGCM.Arc4SboxData0;
1641 hmac_key = &ctl_desc->cipherHashInfo.infoARC4StateGCM.GCMH0;
1642 cipher_keylen = op->rc4_key_len;
1643 hmac_keylen = sizeof(GCM_t);
1644 ctl_size = sizeof(ARC4StateGCM_t);
1646 case XLR_SEC_VECTOR__CIPHER_DES__GCM__MODE_ECB_CBC:
1647 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_DES__GCM__MODE_ECB_CBC \n");
1648 cipher_key = &ctl_desc->cipherHashInfo.infoDESGCM.cipherKey0;
1649 hmac_key = &ctl_desc->cipherHashInfo.infoDESGCM.GCMH0;
1650 hmac_keylen = sizeof(GCM_t);
1651 cipher_keylen = XLR_SEC_DES_KEY_LENGTH;
1652 ctl_size = sizeof(DESGCM_t);
1654 case XLR_SEC_VECTOR__CIPHER_3DES__GCM__MODE_ECB_CBC:
1655 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__GCM__MODE_ECB_CBC \n");
1656 cipher_key = &ctl_desc->cipherHashInfo.info3DESGCM.cipherKey0;
1657 hmac_key = &ctl_desc->cipherHashInfo.info3DESGCM.GCMH0;
1658 cipher_keylen = XLR_SEC_3DES_KEY_LENGTH;
1659 hmac_keylen = sizeof(GCM_t);
1660 ctl_size = sizeof(DES3GCM_t);
1662 case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_CTR_CFB:
1663 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_CTR_CFB \n");
1664 cipher_key = &ctl_desc->cipherHashInfo.infoAES128GCM.cipherKey0;
1665 hmac_key = &ctl_desc->cipherHashInfo.infoAES128GCM.GCMH0;
1666 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
1667 hmac_keylen = sizeof(GCM_t);
1668 ctl_size = sizeof(AES128GCM_t);
1670 case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_ECB_CBC_OFB:
1671 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_ECB_CBC_OFB \n");
1672 cipher_key = &ctl_desc->cipherHashInfo.infoAES128GCM.cipherKey0;
1673 hmac_key = &ctl_desc->cipherHashInfo.infoAES128GCM.GCMH0;
1674 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
1675 hmac_keylen = sizeof(GCM_t);
1676 ctl_size = sizeof(AES128GCM_t);
1678 case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_F8:
1679 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_F8 \n");
1680 cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8GCM.cipherKey0;
1681 hmac_key = &ctl_desc->cipherHashInfo.infoAES128F8GCM.GCMH0;
1682 cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH;
1683 hmac_keylen = sizeof(GCM_t);
1684 ctl_size = sizeof(AES128F8GCM_t);
1686 case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_CTR_CFB:
1687 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_CTR_CFB \n");
1688 cipher_key = &ctl_desc->cipherHashInfo.infoAES192GCM.cipherKey0;
1689 hmac_key = &ctl_desc->cipherHashInfo.infoAES192GCM.GCMH0;
1690 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
1691 hmac_keylen = sizeof(GCM_t);
1692 ctl_size = sizeof(AES192GCM_t);
1694 case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_ECB_CBC_OFB:
1695 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_ECB_CBC_OFB \n");
1696 cipher_key = &ctl_desc->cipherHashInfo.infoAES192GCM.cipherKey0;
1697 hmac_key = &ctl_desc->cipherHashInfo.infoAES192GCM.GCMH0;
1698 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
1699 hmac_keylen = sizeof(GCM_t);
1700 ctl_size = sizeof(AES192GCM_t);
1702 case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_F8:
1703 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_F8 \n");
1704 cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8GCM.cipherKey0;
1705 hmac_key = &ctl_desc->cipherHashInfo.infoAES192F8GCM.GCMH0;
1706 cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH;
1707 hmac_keylen = sizeof(GCM_t);
1708 ctl_size = sizeof(AES192F8GCM_t);
1710 case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_CTR_CFB:
1711 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_CTR_CFB \n");
1712 cipher_key = &ctl_desc->cipherHashInfo.infoAES256GCM.cipherKey0;
1713 hmac_key = &ctl_desc->cipherHashInfo.infoAES256GCM.GCMH0;
1714 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
1715 hmac_keylen = sizeof(GCM_t);
1716 ctl_size = sizeof(AES256GCM_t);
1718 case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_ECB_CBC_OFB:
1719 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_ECB_CBC_OFB \n");
1720 cipher_key = &ctl_desc->cipherHashInfo.infoAES256GCM.cipherKey0;
1721 hmac_key = &ctl_desc->cipherHashInfo.infoAES256GCM.GCMH0;
1722 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
1723 hmac_keylen = sizeof(GCM_t);
1724 ctl_size = sizeof(AES256GCM_t);
1726 case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_F8:
1727 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_F8 \n");
1728 cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8GCM.cipherKey0;
1729 hmac_key = &ctl_desc->cipherHashInfo.infoAES256F8GCM.GCMH0;
1730 cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH;
1731 hmac_keylen = sizeof(GCM_t);
1732 ctl_size = sizeof(AES256F8GCM_t);
1734 case XLR_SEC_VECTOR_F9:
1735 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_F9 \n");
1736 hmac_key = &ctl_desc->cipherHashInfo.infoF9.authKey0;
1737 hmac_keylen = sizeof(F9_t);
1738 ctl_size = sizeof(F9_t);
1740 case XLR_SEC_VECTOR_CIPHER_ARC4__F9:
1741 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__F9\n");
1742 cipher_key = &ctl_desc->cipherHashInfo.infoARC4F9.cipherKey0;
1743 hmac_key = &ctl_desc->cipherHashInfo.infoARC4F9.authKey0;
1744 cipher_keylen = op->rc4_key_len;
1745 hmac_keylen = sizeof(F9_t);
1746 ctl_size = sizeof(ARC4F9_t);
1748 case XLR_SEC_VECTOR_CIPHER_ARC4__F9__STATE:
1749 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__F9__STATE\n");
1750 cipher_key = &ctl_desc->cipherHashInfo.infoARC4StateF9.cipherKey0;
1752 &ctl_desc->cipherHashInfo.infoARC4StateF9.Arc4SboxData0;
1753 hmac_key = &ctl_desc->cipherHashInfo.infoARC4StateF9.authKey0;
1754 cipher_keylen = op->rc4_key_len;
1755 hmac_keylen = sizeof(F9_t);
1756 ctl_size = sizeof(ARC4StateF9_t);
1758 case XLR_SEC_VECTOR__CIPHER_DES__F9__MODE_ECB_CBC:
1759 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_DES__F9__MODE_ECB_CBC \n");
1760 cipher_key = &ctl_desc->cipherHashInfo.infoDESF9.cipherKey0;
1761 hmac_key = &ctl_desc->cipherHashInfo.infoDESF9.authKey0;
1762 hmac_keylen = sizeof(F9_t);
1763 cipher_keylen = XLR_SEC_DES_KEY_LENGTH;
1764 ctl_size = sizeof(DESF9_t);
1766 case XLR_SEC_VECTOR__CIPHER_3DES__F9__MODE_ECB_CBC:
1767 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__F9__MODE_ECB_CBC \n");
1768 cipher_key = &ctl_desc->cipherHashInfo.info3DESF9.cipherKey0;
1769 hmac_key = &ctl_desc->cipherHashInfo.info3DESF9.authKey0;
1770 cipher_keylen = XLR_SEC_3DES_KEY_LENGTH;
1771 hmac_keylen = sizeof(F9_t);
1772 ctl_size = sizeof(DES3F9_t);
1774 case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_CTR_CFB:
1775 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_CTR_CFB \n");
1776 cipher_key = &ctl_desc->cipherHashInfo.infoAES128F9.cipherKey0;
1777 hmac_key = &ctl_desc->cipherHashInfo.infoAES128F9.authKey0;
1778 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
1779 hmac_keylen = sizeof(F9_t);
1780 ctl_size = sizeof(AES128F9_t);
1782 case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_ECB_CBC_OFB:
1783 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_ECB_CBC_OFB \n");
1784 cipher_key = &ctl_desc->cipherHashInfo.infoAES128F9.cipherKey0;
1785 hmac_key = &ctl_desc->cipherHashInfo.infoAES128F9.authKey0;
1786 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
1787 hmac_keylen = sizeof(F9_t);
1788 ctl_size = sizeof(AES128F9_t);
1790 case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_F8:
1791 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_F8 \n");
1792 cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8F9.cipherKey0;
1793 hmac_key = &ctl_desc->cipherHashInfo.infoAES128F8F9.authKey0;
1794 cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH;
1795 hmac_keylen = sizeof(F9_t);
1796 ctl_size = sizeof(AES128F8F9_t);
1798 case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_CTR_CFB:
1799 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_CTR_CFB \n");
1800 cipher_key = &ctl_desc->cipherHashInfo.infoAES192F9.cipherKey0;
1801 hmac_key = &ctl_desc->cipherHashInfo.infoAES192F9.authKey0;
1802 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
1803 hmac_keylen = sizeof(F9_t);
1804 ctl_size = sizeof(AES192F9_t);
1806 case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_ECB_CBC_OFB:
1807 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_ECB_CBC_OFB \n");
1808 cipher_key = &ctl_desc->cipherHashInfo.infoAES192F9.cipherKey0;
1809 hmac_key = &ctl_desc->cipherHashInfo.infoAES192F9.authKey0;
1810 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
1811 hmac_keylen = sizeof(F9_t);
1812 ctl_size = sizeof(AES192F9_t);
1814 case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_F8:
1815 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_F8 \n");
1816 cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8F9.cipherKey0;
1817 hmac_key = &ctl_desc->cipherHashInfo.infoAES192F8F9.authKey0;
1818 cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH;
1819 hmac_keylen = sizeof(F9_t);
1820 ctl_size = sizeof(AES192F8F9_t);
1822 case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_CTR_CFB:
1823 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_CTR_CFB \n");
1824 cipher_key = &ctl_desc->cipherHashInfo.infoAES256F9.cipherKey0;
1825 hmac_key = &ctl_desc->cipherHashInfo.infoAES256F9.authKey0;
1826 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
1827 hmac_keylen = sizeof(F9_t);
1828 ctl_size = sizeof(AES256F9_t);
1830 case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_ECB_CBC_OFB:
1831 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_ECB_CBC_OFB \n");
1832 cipher_key = &ctl_desc->cipherHashInfo.infoAES256F9.cipherKey0;
1833 hmac_key = &ctl_desc->cipherHashInfo.infoAES256F9.authKey0;
1834 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
1835 hmac_keylen = sizeof(F9_t);
1836 ctl_size = sizeof(AES256F9_t);
1838 case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_F8:
1839 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_F8 \n");
1840 cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8F9.cipherKey0;
1841 hmac_key = &ctl_desc->cipherHashInfo.infoAES256F8F9.authKey0;
1842 cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH;
1843 hmac_keylen = sizeof(F9_t);
1844 ctl_size = sizeof(AES256F8F9_t);
1848 XLR_SEC_CMD_DIAG("default \n");
1849 return XLR_SEC_ERR_CONTROL_VECTOR;
1852 if ((cipher_key != NULL) && !(flags & XLR_SEC_SETUP_OP_PRESERVE_CIPHER_KEY))
1853 memcpy(cipher_key, &op->crypt_key[0], cipher_keylen);
1855 if ((hmac_key != NULL) && !(flags & XLR_SEC_SETUP_OP_PRESERVE_HMAC_KEY))
1856 memcpy(hmac_key, &op->mac_key[0], hmac_keylen);
1858 if (op->rc4_loadstate)
1859 memcpy(cipher_state, (void *)(unsigned long)op->rc4_state,
1860 XLR_SEC_MAX_RC4_STATE_SIZE);
1861 if (op->rc4_savestate)
1862 user->aligned_state = (char *)cipher_state;
1864 if (flags & XLR_SEC_SETUP_OP_FLIP_3DES_KEY) {
1867 temp = ctl_desc->cipherHashInfo.info3DES.cipherKey0;
1868 ctl_desc->cipherHashInfo.info3DES.cipherKey0 =
1869 ctl_desc->cipherHashInfo.info3DES.cipherKey2;
1870 ctl_desc->cipherHashInfo.info3DES.cipherKey2 = temp;
1873 * Control length is the number of control cachelines to be read so
1874 * user needs to round up the control length to closest integer
1875 * multiple of 32 bytes.
1877 ctl_size += sizeof(ctl_desc->instruction);
1878 ctl_len = NUM_CHUNKS(ctl_size, 5);
1879 XLR_SEC_CMD_DIAG("ctl_size in bytes: %u, in cachelines: %u\n", ctl_size, ctl_len);
1880 CLEAR_SET_FIELD(*control, MSG_CMD_CTL_LEN, ctl_len);
1882 ctl_addr = (uint64_t) vtophys(ctl_desc);
1883 CLEAR_SET_FIELD(*control, MSG_CMD_CTL_ADDR, ctl_addr);
1885 XLR_SEC_CMD_DIAG(" xlr_sec_control_setup(): ctl_desc=%p ctl_addr=%llx \n",
1886 ctl_desc, (unsigned long long)ctl_addr);
1888 CLEAR_SET_FIELD(*control, MSG_CMD_CTL_CTL, SEC_SOP);
1890 return XLR_SEC_ERR_NONE;
1894 xlr_sec_submit_op(symkey_desc_pt desc)
1896 struct msgrng_msg send_msg;
1898 int rsp_dest_id, cpu, hard_cpu, hard_thread;
1900 unsigned long msgrng_flags = 0;
1902 /* threads (0-3) are orthogonal to buckets 0-3 */
1905 hard_cpu = cpu >> 2;
1906 hard_thread = cpu & 0x3;/* thread id */
1907 rsp_dest_id = (hard_cpu << 3) + hard_thread;
1909 desc->op_ctl.cpu = hard_cpu;
1910 desc->op_ctl.flags = 0; /* called from kernel thread */
1912 XLR_SEC_CMD_DIAG("[%s]:%d: cpu=0x%x hard_cpu=0x%x hard_thrd=0x%x id=0x%x \n",
1913 __FUNCTION__, __LINE__, cpu, hard_cpu, hard_thread, rsp_dest_id);
1916 * Set DestId in Message Control Word. This tells the Security
1917 * Engine which bucket to send the reply to for this CPU
1919 CLEAR_SET_FIELD(desc->control, MSG_CMD_CTL_ID, rsp_dest_id);
1920 CLEAR_SET_FIELD(desc->data, MSG_CMD_CTL_ID, rsp_dest_id);
1922 CLEAR_SET_FIELD(desc->control, MSG_CTL_OP_TYPE, MSG0_CTL_OP_ENGINE_SYMKEY);
1923 CLEAR_SET_FIELD(desc->data, MSG_CTL_OP_TYPE, MSG1_CTL_OP_SYMKEY_PIPE0);
1925 send_msg.msg0 = desc->control | (1ULL << 53);
1926 send_msg.msg1 = desc->data | (1ULL << 53) | (1ULL << 52);
1927 send_msg.msg2 = send_msg.msg3 = 0;
1929 desc->op_ctl.flags = 1;
1930 //in_interrupt(); /* ipsec softirq ? */
1932 XLR_SEC_CMD_DIAG("[%s]: IN_IRQ=%d msg0=0x%llx msg1=0x%llx \n",
1933 __FUNCTION__, desc->op_ctl.flags, send_msg.msg0, send_msg.msg1);
1937 msgrng_flags = msgrng_access_enable();
1938 code = message_send(SEC_MSGRING_WORDSIZE, MSGRNG_CODE_SEC,
1939 desc->op_ctl.stn_id, &send_msg);
1940 msgrng_restore(msgrng_flags);
1944 return (XLR_SEC_ERR_NONE);
1948 xlr_sec_allocate_desc(void *session_ptr)
1951 symkey_desc_pt aligned, new;
1953 new = (symkey_desc_pt) malloc(sizeof(symkey_desc_t),
1954 M_DEVBUF, M_NOWAIT | M_ZERO);
1959 new->ses = session_ptr;
1961 new->user.kern_src = new->user.aligned_src =
1962 (uint8_t *) contigmalloc(256 * 1024 + 1024,
1963 M_DEVBUF, M_NOWAIT | M_ZERO,
1964 0, 0xffffffff, XLR_CACHELINE_SIZE, 0);
1966 if (new->user.kern_src == NULL) {
1967 printf("ERROR - malloc failed for user.kern_src\n");
1970 new->user.aligned_dest = new->user.kern_dest =
1971 (uint8_t *) contigmalloc(257 * 1024,
1972 M_DEVBUF, M_NOWAIT | M_ZERO,
1973 0, 0xffffffff, XLR_CACHELINE_SIZE, 0);
1975 if (new->user.aligned_dest == NULL) {
1976 printf("ERROR - malloc failed for user.aligned_dest\n");
1979 new->next_src_buf = (uint8_t *) contigmalloc(256 * 1024 + 1024,
1980 M_DEVBUF, M_NOWAIT | M_ZERO,
1981 0, 0xffffffff, XLR_CACHELINE_SIZE, 0);
1983 if (new->next_src_buf == NULL) {
1984 printf("ERROR - malloc failed for next_src_buf\n");
1987 new->next_dest_buf =
1988 (uint8_t *) contigmalloc(257 * 1024,
1989 M_DEVBUF, M_NOWAIT | M_ZERO,
1990 0, 0xffffffff, XLR_CACHELINE_SIZE, 0);
1992 if (new->next_dest_buf == NULL) {
1993 printf("ERROR - malloc failed for next_dest_buf\n");
1996 new->user.kern_auth = new->user.user_auth = NULL;
1997 new->user.aligned_auth = new->user.user_auth = NULL;
1999 /* find cacheline alignment */
2001 addr = (uint64_t) vtophys(new);
2004 aligned->alloc = new;
2006 /* setup common control info */
2007 aligned->op_ctl.phys_self = addr;
2008 aligned->op_ctl.stn_id = MSGRNG_STNID_SEC0;
2009 aligned->op_ctl.vaddr = (uintptr_t)aligned;
2016 xlr_sec_free_desc(symkey_desc_pt desc)
2018 if ((desc == NULL) || (desc->alloc == NULL)) {
2019 printf("%s: NULL descriptor \n", __FUNCTION__);
2022 contigfree(desc, sizeof(symkey_desc_t), M_DEVBUF);
2027 print_buf(char *desc, void *data, int len)
2032 DPRINT("%s: ", desc); /* newline done in for-loop */
2034 for (i = 0; i < len; i++, dp++) {
2038 nib2hex[(((*dp) & 0xf0) >> 4)],
2039 nib2hex[((*dp) & 0x0f)]);
2045 #ifdef XLR_SEC_CMD_DEBUG
2047 decode_symkey_desc(symkey_desc_pt desc, uint32_t cfg_vector)
2050 unsigned long long word;
2052 /* uint8_t *info; */
2055 DPRINT("MSG - CTL: \n");
2056 DPRINT("\t CTRL = %lld \n",
2057 GET_FIELD(desc->control, MSG_CMD_CTL_CTL));
2058 DPRINT("\t CTRL LEN = %lld \n",
2059 GET_FIELD(desc->control, MSG_CMD_CTL_LEN));
2060 DPRINT("\t CTRL ADDR = %llx \n\n",
2061 GET_FIELD(desc->control, MSG_CMD_CTL_ADDR));
2063 DPRINT("MSG - DATA: \n");
2064 DPRINT("\t CTRL = %lld \n",
2065 GET_FIELD(desc->data, MSG_CMD_DATA_CTL));
2066 DPRINT("\t DATA LEN = %lld \n",
2067 GET_FIELD(desc->data, MSG_CMD_DATA_LEN));
2068 DPRINT("\t DATA ADDR = %llx \n\n",
2069 GET_FIELD(desc->data, MSG_CMD_DATA_ADDR));
2071 DPRINT("CONTROL DESCRIPTOR: \n");
2072 word = desc->ctl_desc.instruction;
2073 DPRINT("\tINSTRUCTION: %llx\n", word);
2074 DPRINT("\t\tOVERRIDE CIPH = %lld \n", GET_FIELD(word, CTL_DSC_OVERRIDECIPHER));
2075 DPRINT("\t\tARC4 WAIT = %lld \n", GET_FIELD(word, CTL_DSC_ARC4_WAIT4SAVE));
2076 DPRINT("\t\tARC4 SAVE = %lld \n", GET_FIELD(word, CTL_DSC_ARC4_SAVESTATE));
2077 DPRINT("\t\tARC4 LOAD = %lld \n", GET_FIELD(word, CTL_DSC_ARC4_LOADSTATE));
2078 DPRINT("\t\tARC4 KEYLEN = %lld \n", GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2079 DPRINT("\t\tCIPHER = %lld \n", GET_FIELD(word, CTL_DSC_CPHR));
2080 DPRINT("\t\tCIPHER MODE = %lld \n", GET_FIELD(word, CTL_DSC_MODE));
2081 DPRINT("\t\tINIT CIPHER = %lld \n", GET_FIELD(word, CTL_DSC_ICPHR));
2082 DPRINT("\t\tHMAC = %lld \n", GET_FIELD(word, CTL_DSC_HMAC));
2083 DPRINT("\t\tHASH ALG = %lld \n", GET_FIELD(word, CTL_DSC_HASH) | (GET_FIELD(word, CTL_DSC_HASHHI) << 2));
2084 DPRINT("\t\tINIT HASH = %lld \n", GET_FIELD(word, CTL_DSC_IHASH));
2085 DPRINT("\t\tCHKSUM = %lld \n", GET_FIELD(word, CTL_DSC_CKSUM));
2086 DPRINT("\tCIPHER HASH INFO: \n");
2088 info = (uint8_t *) & desc->ctl_desc->cipherHashInfo;
2089 for (i = 0; i < sizeof(CipherHashInfo_t); i++, info++) {
2090 DPRINT(" %02x", *info);
2091 if (i && (i % 16) == 0)
2097 switch (cfg_vector) {
2098 case XLR_SEC_VECTOR_CIPHER_ARC4:
2099 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4 \n");
2100 print_buf("ARC4 Key",
2101 &desc->ctl_desc.cipherHashInfo.infoARC4.cipherKey0,
2102 GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2104 case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC:
2105 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__HMAC \n");
2106 print_buf("ARC4 Key",
2107 &desc->ctl_desc.cipherHashInfo.infoARC4HMAC.cipherKey0,
2108 GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2109 print_buf("HMAC Key",
2110 &desc->ctl_desc.cipherHashInfo.infoARC4HMAC.hmacKey0,
2113 case XLR_SEC_VECTOR_CIPHER_ARC4__STATE:
2114 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__STATE \n");
2115 print_buf("ARC4 Key",
2116 &desc->ctl_desc.cipherHashInfo.infoARC4State.cipherKey0,
2117 GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2119 case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC__STATE:
2120 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__HMAC__STATE \n");
2121 print_buf("ARC4 Key",
2122 &desc->ctl_desc.cipherHashInfo.infoARC4StateHMAC.cipherKey0,
2123 GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2124 print_buf("HMAC Key",
2125 &desc->ctl_desc.cipherHashInfo.infoARC4StateHMAC.hmacKey0,
2128 case XLR_SEC_VECTOR_CIPHER_KASUMI_F8:
2129 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_KASUMI_F8 \n");
2130 print_buf("KASUMI_F8 Key",
2131 &desc->ctl_desc.cipherHashInfo.infoKASUMIF8.cipherKey0,
2132 XLR_SEC_KASUMI_F8_KEY_LENGTH);
2134 case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC:
2135 DPRINT("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC\n");
2136 print_buf("KASUMI_F8 Key",
2137 &desc->ctl_desc.cipherHashInfo.infoKASUMIF8HMAC.cipherKey0,
2138 XLR_SEC_KASUMI_F8_KEY_LENGTH);
2139 print_buf("HMAC Key",
2140 &desc->ctl_desc.cipherHashInfo.infoKASUMIF8HMAC.hmacKey0,
2143 case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC2:
2144 DPRINT("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC2\n");
2145 print_buf("KASUMI_F8 Key",
2146 &desc->ctl_desc.cipherHashInfo.infoKASUMIF8HMAC2.cipherKey0,
2147 XLR_SEC_KASUMI_F8_KEY_LENGTH);
2148 print_buf("HMAC2 Key",
2149 &desc->ctl_desc.cipherHashInfo.infoKASUMIF8HMAC2.hmacKey0,
2152 case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__GCM:
2153 DPRINT("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__GCM\n");
2154 print_buf("KASUMI_F8 Key",
2155 &desc->ctl_desc.cipherHashInfo.infoKASUMIF8GCM.cipherKey0,
2156 XLR_SEC_KASUMI_F8_KEY_LENGTH);
2157 print_buf("GCM Key",
2158 &desc->ctl_desc.cipherHashInfo.infoKASUMIF8GCM.GCMH0,
2161 case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__F9:
2162 DPRINT("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__F9\n");
2163 print_buf("KASUMI_F8 Key",
2164 &desc->ctl_desc.cipherHashInfo.infoKASUMIF8F9.cipherKey0,
2165 XLR_SEC_KASUMI_F8_KEY_LENGTH);
2167 &desc->ctl_desc.cipherHashInfo.infoKASUMIF8F9.authKey0,
2170 case XLR_SEC_VECTOR_MAC:
2171 DPRINT("VECTOR: XLR_SEC_VECTOR_MAC \n");
2172 DPRINT("MAC-ONLY - No Info\n");
2174 case XLR_SEC_VECTOR_HMAC:
2175 DPRINT("VECTOR: XLR_SEC_VECTOR_HMAC \n");
2176 print_buf("HMAC Key",
2177 &desc->ctl_desc.cipherHashInfo.infoHMAC.hmacKey0,
2180 case XLR_SEC_VECTOR__CIPHER_DES__HMAC__MODE_ECB_CBC:
2181 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_DES__HMAC__MODE_ECB_CBC \n");
2182 print_buf("CIPHER Key",
2183 &desc->ctl_desc.cipherHashInfo.infoDESHMAC.cipherKey0,
2184 XLR_SEC_DES_KEY_LENGTH);
2185 print_buf("HMAC Key",
2186 &desc->ctl_desc.cipherHashInfo.infoDESHMAC.hmacKey0,
2189 case XLR_SEC_VECTOR__CIPHER_DES__MODE_ECB_CBC:
2190 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_DES__MODE_ECB_CBC \n");
2191 print_buf("CIPHER Key",
2192 &desc->ctl_desc.cipherHashInfo.infoDES.cipherKey0,
2193 XLR_SEC_DES_KEY_LENGTH);
2195 case XLR_SEC_VECTOR__CIPHER_3DES__HMAC__MODE_ECB_CBC:
2196 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_3DES__HMAC__MODE_ECB_CBC \n");
2197 print_buf("CIPHER Key",
2198 &desc->ctl_desc.cipherHashInfo.info3DESHMAC.cipherKey0,
2199 XLR_SEC_3DES_KEY_LENGTH);
2200 print_buf("HMAC Key",
2201 &desc->ctl_desc.cipherHashInfo.info3DESHMAC.hmacKey0,
2204 case XLR_SEC_VECTOR__CIPHER_3DES__MODE_ECB_CBC:
2205 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_3DES__MODE_ECB_CBC \n");
2206 print_buf("CIPHER Key",
2207 &desc->ctl_desc.cipherHashInfo.info3DES.cipherKey0,
2208 XLR_SEC_3DES_KEY_LENGTH);
2210 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_CTR_CFB:
2211 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_CTR_CFB \n");
2212 print_buf("CIPHER Key",
2213 &desc->ctl_desc.cipherHashInfo.infoAES128HMAC.cipherKey0,
2214 XLR_SEC_AES128_KEY_LENGTH);
2215 print_buf("HMAC Key",
2216 &desc->ctl_desc.cipherHashInfo.infoAES128HMAC.hmacKey0,
2219 case XLR_SEC_VECTOR__CIPHER_AES128__MODE_CTR_CFB:
2220 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__MODE_CTR_CFB \n");
2221 print_buf("CIPHER Key",
2222 &desc->ctl_desc.cipherHashInfo.infoAES128.cipherKey0,
2223 XLR_SEC_AES128_KEY_LENGTH);
2225 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_ECB_CBC_OFB:
2226 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_ECB_CBC_OFB\n");
2227 print_buf("CIPHER Key",
2228 &desc->ctl_desc.cipherHashInfo.infoAES128HMAC.cipherKey0,
2229 XLR_SEC_AES128_KEY_LENGTH);
2230 print_buf("HMAC Key",
2231 &desc->ctl_desc.cipherHashInfo.infoAES128HMAC.hmacKey0,
2234 case XLR_SEC_VECTOR__CIPHER_AES128__MODE_ECB_CBC_OFB:
2235 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__MODE_ECB_CBC_OFB \n");
2236 print_buf("CIPHER Key",
2237 &desc->ctl_desc.cipherHashInfo.infoAES128.cipherKey0,
2238 XLR_SEC_AES128_KEY_LENGTH);
2240 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_CTR_CFB:
2241 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_CTR_CFB \n");
2242 print_buf("CIPHER Key",
2243 &desc->ctl_desc.cipherHashInfo.infoAES192HMAC.cipherKey0,
2244 XLR_SEC_AES192_KEY_LENGTH);
2245 print_buf("HMAC Key",
2246 &desc->ctl_desc.cipherHashInfo.infoAES192HMAC.hmacKey0,
2249 case XLR_SEC_VECTOR__CIPHER_AES192__MODE_CTR_CFB:
2250 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__MODE_CTR_CFB \n");
2251 print_buf("CIPHER Key",
2252 &desc->ctl_desc.cipherHashInfo.infoAES192.cipherKey0,
2253 XLR_SEC_AES192_KEY_LENGTH);
2255 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_ECB_CBC_OFB:
2256 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_ECB_CBC_OFB\n");
2257 print_buf("CIPHER Key",
2258 &desc->ctl_desc.cipherHashInfo.infoAES192HMAC.cipherKey0,
2259 XLR_SEC_AES192_KEY_LENGTH);
2260 print_buf("HMAC Key",
2261 &desc->ctl_desc.cipherHashInfo.infoAES192HMAC.hmacKey0,
2264 case XLR_SEC_VECTOR__CIPHER_AES192__MODE_ECB_CBC_OFB:
2265 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__MODE_ECB_CBC_OFB \n");
2266 print_buf("CIPHER Key",
2267 &desc->ctl_desc.cipherHashInfo.infoAES192.cipherKey0,
2268 XLR_SEC_AES192_KEY_LENGTH);
2271 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_CTR_CFB:
2272 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_CTR_CFB \n");
2273 print_buf("CIPHER Key",
2274 &desc->ctl_desc.cipherHashInfo.infoAES256HMAC.cipherKey0,
2275 XLR_SEC_AES256_KEY_LENGTH);
2276 print_buf("HMAC Key",
2277 &desc->ctl_desc.cipherHashInfo.infoAES256HMAC.hmacKey0,
2280 case XLR_SEC_VECTOR__CIPHER_AES256__MODE_CTR_CFB:
2281 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__MODE_CTR_CFB \n");
2282 print_buf("CIPHER Key",
2283 &desc->ctl_desc.cipherHashInfo.infoAES256.cipherKey0,
2284 XLR_SEC_AES256_KEY_LENGTH);
2286 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_ECB_CBC_OFB:
2287 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_ECB_CBC_OFB \n");
2288 print_buf("CIPHER Key",
2289 &desc->ctl_desc.cipherHashInfo.infoAES256HMAC.cipherKey0,
2290 XLR_SEC_AES256_KEY_LENGTH);
2291 print_buf("HMAC Key",
2292 &desc->ctl_desc.cipherHashInfo.infoAES256HMAC.hmacKey0,
2295 case XLR_SEC_VECTOR__CIPHER_AES256__MODE_ECB_CBC_OFB:
2296 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__MODE_ECB_CBC_OFB \n");
2297 print_buf("CIPHER Key",
2298 &desc->ctl_desc.cipherHashInfo.infoAES256.cipherKey0,
2299 XLR_SEC_AES256_KEY_LENGTH);
2301 case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2:
2302 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2 \n");
2303 print_buf("ARC4 Key",
2304 &desc->ctl_desc.cipherHashInfo.infoARC4HMAC2.cipherKey0,
2305 GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2306 print_buf("HMAC2 Key",
2307 &desc->ctl_desc.cipherHashInfo.infoARC4HMAC2.hmacKey0,
2310 case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2__STATE:
2311 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2__STATE \n");
2312 print_buf("ARC4 Key",
2313 &desc->ctl_desc.cipherHashInfo.infoARC4StateHMAC2.cipherKey0,
2314 GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2315 print_buf("HMAC2 Key",
2316 &desc->ctl_desc.cipherHashInfo.infoARC4StateHMAC2.hmacKey0,
2319 case XLR_SEC_VECTOR_HMAC2:
2320 DPRINT("VECTOR: XLR_SEC_VECTOR_HMAC2 \n");
2321 print_buf("HMAC2 Key",
2322 &desc->ctl_desc.cipherHashInfo.infoHMAC2.hmacKey0,
2325 case XLR_SEC_VECTOR__CIPHER_DES__HMAC2__MODE_ECB_CBC:
2326 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_DES__HMAC2__MODE_ECB_CBC \n");
2327 print_buf("CIPHER Key",
2328 &desc->ctl_desc.cipherHashInfo.infoDESHMAC2.cipherKey0,
2329 XLR_SEC_DES_KEY_LENGTH);
2330 print_buf("HMAC2 Key",
2331 &desc->ctl_desc.cipherHashInfo.infoDESHMAC2.hmacKey0,
2334 case XLR_SEC_VECTOR__CIPHER_3DES__HMAC2__MODE_ECB_CBC:
2335 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_3DES__HMAC2__MODE_ECB_CBC \n");
2336 print_buf("CIPHER Key",
2337 &desc->ctl_desc.cipherHashInfo.info3DESHMAC2.cipherKey0,
2338 XLR_SEC_3DES_KEY_LENGTH);
2339 print_buf("HMAC2 Key",
2340 &desc->ctl_desc.cipherHashInfo.info3DESHMAC2.hmacKey0,
2343 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_CTR_CFB:
2344 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_CTR_CFB \n");
2345 print_buf("CIPHER Key",
2346 &desc->ctl_desc.cipherHashInfo.infoAES128HMAC2.cipherKey0,
2347 XLR_SEC_AES128_KEY_LENGTH);
2348 print_buf("HMAC2 Key",
2349 &desc->ctl_desc.cipherHashInfo.infoAES128HMAC2.hmacKey0,
2352 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_ECB_CBC_OFB:
2353 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_ECB_CBC_OFB\n");
2354 print_buf("CIPHER Key",
2355 &desc->ctl_desc.cipherHashInfo.infoAES128HMAC2.cipherKey0,
2356 XLR_SEC_AES128_KEY_LENGTH);
2357 print_buf("HMAC2 Key",
2358 &desc->ctl_desc.cipherHashInfo.infoAES128HMAC2.hmacKey0,
2361 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_CTR_CFB:
2362 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_CTR_CFB \n");
2363 print_buf("CIPHER Key",
2364 &desc->ctl_desc.cipherHashInfo.infoAES192HMAC2.cipherKey0,
2365 XLR_SEC_AES192_KEY_LENGTH);
2366 print_buf("HMAC2 Key",
2367 &desc->ctl_desc.cipherHashInfo.infoAES192HMAC2.hmacKey0,
2370 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_ECB_CBC_OFB:
2371 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_ECB_CBC_OFB\n");
2372 print_buf("CIPHER Key",
2373 &desc->ctl_desc.cipherHashInfo.infoAES192HMAC2.cipherKey0,
2374 XLR_SEC_AES192_KEY_LENGTH);
2375 print_buf("HMAC2 Key",
2376 &desc->ctl_desc.cipherHashInfo.infoAES192HMAC2.hmacKey0,
2379 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_CTR_CFB:
2380 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_CTR_CFB \n");
2381 print_buf("CIPHER Key",
2382 &desc->ctl_desc.cipherHashInfo.infoAES256HMAC2.cipherKey0,
2383 XLR_SEC_AES256_KEY_LENGTH);
2384 print_buf("HMAC2 Key",
2385 &desc->ctl_desc.cipherHashInfo.infoAES256HMAC2.hmacKey0,
2389 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_ECB_CBC_OFB:
2390 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_ECB_CBC_OFB \n");
2391 print_buf("CIPHER Key",
2392 &desc->ctl_desc.cipherHashInfo.infoAES256HMAC2.cipherKey0,
2393 XLR_SEC_AES256_KEY_LENGTH);
2394 print_buf("HMAC2 Key",
2395 &desc->ctl_desc.cipherHashInfo.infoAES256HMAC2.hmacKey0,
2398 case XLR_SEC_VECTOR_CIPHER_ARC4__GCM:
2399 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__GCM \n");
2400 print_buf("ARC4 Key",
2401 &desc->ctl_desc.cipherHashInfo.infoARC4GCM.cipherKey0,
2402 GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2403 print_buf("GCM Key",
2404 &desc->ctl_desc.cipherHashInfo.infoARC4GCM.GCMH0,
2407 case XLR_SEC_VECTOR_CIPHER_ARC4__GCM__STATE:
2408 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__GCM__STATE \n");
2409 print_buf("ARC4 Key",
2410 &desc->ctl_desc.cipherHashInfo.infoARC4StateGCM.cipherKey0,
2411 GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2412 print_buf("GCM Key",
2413 &desc->ctl_desc.cipherHashInfo.infoARC4StateGCM.GCMH0,
2416 case XLR_SEC_VECTOR_GCM:
2417 DPRINT("VECTOR: XLR_SEC_VECTOR_GCM \n");
2418 print_buf("GCM Key",
2419 &desc->ctl_desc.cipherHashInfo.infoGCM.GCMH0,
2422 case XLR_SEC_VECTOR__CIPHER_DES__GCM__MODE_ECB_CBC:
2423 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_DES__GCM__MODE_ECB_CBC \n");
2424 print_buf("CIPHER Key",
2425 &desc->ctl_desc.cipherHashInfo.infoDESGCM.cipherKey0,
2426 XLR_SEC_DES_KEY_LENGTH);
2427 print_buf("GCM Key",
2428 &desc->ctl_desc.cipherHashInfo.infoDESGCM.GCMH0,
2431 case XLR_SEC_VECTOR__CIPHER_3DES__GCM__MODE_ECB_CBC:
2432 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_3DES__GCM__MODE_ECB_CBC \n");
2433 print_buf("CIPHER Key",
2434 &desc->ctl_desc.cipherHashInfo.info3DESGCM.cipherKey0,
2435 XLR_SEC_3DES_KEY_LENGTH);
2436 print_buf("GCM Key",
2437 &desc->ctl_desc.cipherHashInfo.info3DESGCM.GCMH0,
2440 case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_CTR_CFB:
2441 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_CTR_CFB \n");
2442 print_buf("CIPHER Key",
2443 &desc->ctl_desc.cipherHashInfo.infoAES128GCM.cipherKey0,
2444 XLR_SEC_AES128_KEY_LENGTH);
2445 print_buf("GCM Key",
2446 &desc->ctl_desc.cipherHashInfo.infoAES128GCM.GCMH0,
2447 XLR_SEC_AES128_KEY_LENGTH);
2449 case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_ECB_CBC_OFB:
2450 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_ECB_CBC_OFB\n");
2451 print_buf("CIPHER Key",
2452 &desc->ctl_desc.cipherHashInfo.infoAES128GCM.cipherKey0,
2453 XLR_SEC_AES128_KEY_LENGTH);
2454 print_buf("GCM Key",
2455 &desc->ctl_desc.cipherHashInfo.infoAES128GCM.GCMH0,
2456 XLR_SEC_AES128_KEY_LENGTH);
2458 case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_CTR_CFB:
2459 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_CTR_CFB \n");
2460 print_buf("CIPHER Key",
2461 &desc->ctl_desc.cipherHashInfo.infoAES192GCM.cipherKey0,
2462 XLR_SEC_AES192_KEY_LENGTH);
2463 print_buf("GCM Key",
2464 &desc->ctl_desc.cipherHashInfo.infoAES192GCM.GCMH0,
2465 XLR_SEC_AES192_KEY_LENGTH);
2467 case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_ECB_CBC_OFB:
2468 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_ECB_CBC_OFB\n");
2469 print_buf("CIPHER Key",
2470 &desc->ctl_desc.cipherHashInfo.infoAES192GCM.cipherKey0,
2471 XLR_SEC_AES192_KEY_LENGTH);
2472 print_buf("GCM Key",
2473 &desc->ctl_desc.cipherHashInfo.infoAES192GCM.GCMH0,
2474 XLR_SEC_AES192_KEY_LENGTH);
2476 case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_CTR_CFB:
2477 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_CTR_CFB \n");
2478 print_buf("CIPHER Key",
2479 &desc->ctl_desc.cipherHashInfo.infoAES256GCM.cipherKey0,
2480 XLR_SEC_AES256_KEY_LENGTH);
2481 print_buf("GCM Key",
2482 &desc->ctl_desc.cipherHashInfo.infoAES256GCM.GCMH0,
2483 XLR_SEC_AES256_KEY_LENGTH);
2485 case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_ECB_CBC_OFB:
2486 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_ECB_CBC_OFB \n");
2487 print_buf("CIPHER Key",
2488 &desc->ctl_desc.cipherHashInfo.infoAES256GCM.cipherKey0,
2489 XLR_SEC_AES256_KEY_LENGTH);
2490 print_buf("GCM Key",
2491 &desc->ctl_desc.cipherHashInfo.infoAES256GCM.GCMH0,
2492 XLR_SEC_AES256_KEY_LENGTH);
2494 case XLR_SEC_VECTOR_CIPHER_ARC4__F9:
2495 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__F9 \n");
2496 print_buf("ARC4 Key",
2497 &desc->ctl_desc.cipherHashInfo.infoARC4F9.cipherKey0,
2498 GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2500 &desc->ctl_desc.cipherHashInfo.infoARC4F9.authKey0,
2503 case XLR_SEC_VECTOR_CIPHER_ARC4__F9__STATE:
2504 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__F9__STATE \n");
2505 print_buf("ARC4 Key",
2506 &desc->ctl_desc.cipherHashInfo.infoARC4StateF9.cipherKey0,
2507 GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
2509 &desc->ctl_desc.cipherHashInfo.infoARC4StateF9.authKey0,
2512 case XLR_SEC_VECTOR_F9:
2513 DPRINT("VECTOR: XLR_SEC_VECTOR_F9 \n");
2515 &desc->ctl_desc.cipherHashInfo.infoF9.authKey0,
2518 case XLR_SEC_VECTOR__CIPHER_DES__F9__MODE_ECB_CBC:
2519 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_DES__F9__MODE_ECB_CBC \n");
2520 print_buf("CIPHER Key",
2521 &desc->ctl_desc.cipherHashInfo.infoDESF9.cipherKey0,
2522 XLR_SEC_DES_KEY_LENGTH);
2524 &desc->ctl_desc.cipherHashInfo.infoDESF9.authKey0,
2527 case XLR_SEC_VECTOR__CIPHER_3DES__F9__MODE_ECB_CBC:
2528 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_3DES__F9__MODE_ECB_CBC \n");
2529 print_buf("CIPHER Key",
2530 &desc->ctl_desc.cipherHashInfo.info3DESF9.cipherKey0,
2531 XLR_SEC_3DES_KEY_LENGTH);
2533 &desc->ctl_desc.cipherHashInfo.info3DESF9.authKey0,
2536 case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_CTR_CFB:
2537 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_CTR_CFB \n");
2538 print_buf("CIPHER Key",
2539 &desc->ctl_desc.cipherHashInfo.infoAES128F9.cipherKey0,
2540 XLR_SEC_AES128_KEY_LENGTH);
2542 &desc->ctl_desc.cipherHashInfo.infoAES128F9.authKey0,
2545 case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_ECB_CBC_OFB:
2546 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_ECB_CBC_OFB\n");
2547 print_buf("CIPHER Key",
2548 &desc->ctl_desc.cipherHashInfo.infoAES128F9.cipherKey0,
2549 XLR_SEC_AES128_KEY_LENGTH);
2551 &desc->ctl_desc.cipherHashInfo.infoAES128F9.authKey0,
2554 case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_CTR_CFB:
2555 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_CTR_CFB \n");
2556 print_buf("CIPHER Key",
2557 &desc->ctl_desc.cipherHashInfo.infoAES192F9.cipherKey0,
2558 XLR_SEC_AES192_KEY_LENGTH);
2560 &desc->ctl_desc.cipherHashInfo.infoAES192F9.authKey0,
2563 case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_ECB_CBC_OFB:
2564 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_ECB_CBC_OFB\n");
2565 print_buf("CIPHER Key",
2566 &desc->ctl_desc.cipherHashInfo.infoAES192F9.cipherKey0,
2567 XLR_SEC_AES192_KEY_LENGTH);
2569 &desc->ctl_desc.cipherHashInfo.infoAES192F9.authKey0,
2572 case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_CTR_CFB:
2573 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_CTR_CFB \n");
2574 print_buf("CIPHER Key",
2575 &desc->ctl_desc.cipherHashInfo.infoAES256F9.cipherKey0,
2576 XLR_SEC_AES256_KEY_LENGTH);
2578 &desc->ctl_desc.cipherHashInfo.infoAES256F9.authKey0,
2581 case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_ECB_CBC_OFB:
2582 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_ECB_CBC_OFB \n");
2583 print_buf("CIPHER Key",
2584 &desc->ctl_desc.cipherHashInfo.infoAES256F9.cipherKey0,
2585 XLR_SEC_AES256_KEY_LENGTH);
2587 &desc->ctl_desc.cipherHashInfo.infoAES256F9.authKey0,
2590 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_F8:
2591 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_F8 \n");
2592 print_buf("CIPHER Key",
2593 &desc->ctl_desc.cipherHashInfo.infoAES128F8HMAC.cipherKey0,
2594 XLR_SEC_AES128F8_KEY_LENGTH);
2595 print_buf("HMAC Key",
2596 &desc->ctl_desc.cipherHashInfo.infoAES128F8HMAC.hmacKey0,
2599 case XLR_SEC_VECTOR__CIPHER_AES128__MODE_F8:
2600 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__MODE_F8 \n");
2601 print_buf("CIPHER Key",
2602 &desc->ctl_desc.cipherHashInfo.infoAES128F8.cipherKey0,
2603 XLR_SEC_AES128F8_KEY_LENGTH);
2605 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_F8:
2606 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_F8 \n");
2607 print_buf("CIPHER Key",
2608 &desc->ctl_desc.cipherHashInfo.infoAES192F8HMAC.cipherKey0,
2609 XLR_SEC_AES192F8_KEY_LENGTH);
2610 print_buf("HMAC Key",
2611 &desc->ctl_desc.cipherHashInfo.infoAES192F8HMAC.hmacKey0,
2614 case XLR_SEC_VECTOR__CIPHER_AES192__MODE_F8:
2615 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__MODE_F8 \n");
2616 print_buf("CIPHER Key",
2617 &desc->ctl_desc.cipherHashInfo.infoAES192F8.cipherKey0,
2618 XLR_SEC_AES192F8_KEY_LENGTH);
2620 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_F8:
2621 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_F8 \n");
2622 print_buf("CIPHER Key",
2623 &desc->ctl_desc.cipherHashInfo.infoAES256F8HMAC.cipherKey0,
2624 XLR_SEC_AES256F8_KEY_LENGTH);
2625 print_buf("HMAC Key",
2626 &desc->ctl_desc.cipherHashInfo.infoAES256HMAC.hmacKey0,
2629 case XLR_SEC_VECTOR__CIPHER_AES256__MODE_F8:
2630 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__MODE_F8 \n");
2631 print_buf("CIPHER Key",
2632 &desc->ctl_desc.cipherHashInfo.infoAES256F8.cipherKey0,
2633 XLR_SEC_AES256F8_KEY_LENGTH);
2635 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_F8:
2636 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_F8 \n");
2637 print_buf("CIPHER Key",
2638 &desc->ctl_desc.cipherHashInfo.infoAES128F8HMAC2.cipherKey0,
2639 XLR_SEC_AES128F8_KEY_LENGTH);
2640 print_buf("HMAC2 Key",
2641 &desc->ctl_desc.cipherHashInfo.infoAES128F8HMAC2.hmacKey0,
2644 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_F8:
2645 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_F8 \n");
2646 print_buf("CIPHER Key",
2647 &desc->ctl_desc.cipherHashInfo.infoAES192F8HMAC2.cipherKey0,
2648 XLR_SEC_AES192F8_KEY_LENGTH);
2649 print_buf("HMAC2 Key",
2650 &desc->ctl_desc.cipherHashInfo.infoAES192F8HMAC2.hmacKey0,
2653 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_F8:
2654 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_F8 \n");
2655 print_buf("CIPHER Key",
2656 &desc->ctl_desc.cipherHashInfo.infoAES256F8HMAC2.cipherKey0,
2657 XLR_SEC_AES256F8_KEY_LENGTH);
2658 print_buf("HMAC2 Key",
2659 &desc->ctl_desc.cipherHashInfo.infoAES256F8HMAC2.hmacKey0,
2662 case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_F8:
2663 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_F8 \n");
2664 print_buf("CIPHER Key",
2665 &desc->ctl_desc.cipherHashInfo.infoAES128F8GCM.cipherKey0,
2666 XLR_SEC_AES128F8_KEY_LENGTH);
2667 print_buf("GCM Key",
2668 &desc->ctl_desc.cipherHashInfo.infoAES128GCM.GCMH0,
2669 XLR_SEC_AES128_KEY_LENGTH);
2671 case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_F8:
2672 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_F8 \n");
2673 print_buf("CIPHER Key",
2674 &desc->ctl_desc.cipherHashInfo.infoAES192F8GCM.cipherKey0,
2675 XLR_SEC_AES192_KEY_LENGTH);
2676 print_buf("GCM Key",
2677 &desc->ctl_desc.cipherHashInfo.infoAES192F8GCM.GCMH0,
2678 XLR_SEC_AES192_KEY_LENGTH);
2680 case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_F8:
2681 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_F8 \n");
2682 print_buf("CIPHER Key",
2683 &desc->ctl_desc.cipherHashInfo.infoAES256F8GCM.cipherKey0,
2684 XLR_SEC_AES256F8_KEY_LENGTH);
2685 print_buf("GCM Key",
2686 &desc->ctl_desc.cipherHashInfo.infoAES256F8GCM.GCMH0,
2687 XLR_SEC_AES256_KEY_LENGTH);
2689 case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_F8:
2690 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_F8 \n");
2691 print_buf("CIPHER Key",
2692 &desc->ctl_desc.cipherHashInfo.infoAES128F8F9.cipherKey0,
2693 XLR_SEC_AES128F8_KEY_LENGTH);
2695 &desc->ctl_desc.cipherHashInfo.infoAES128F8F9.authKey0,
2698 case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_F8:
2699 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_F8 \n");
2700 print_buf("CIPHER Key",
2701 &desc->ctl_desc.cipherHashInfo.infoAES192F8F9.cipherKey0,
2702 XLR_SEC_AES192F8_KEY_LENGTH);
2704 &desc->ctl_desc.cipherHashInfo.infoAES192F8F9.authKey0,
2707 case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_F8:
2708 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_F8 \n");
2709 print_buf("CIPHER Key",
2710 &desc->ctl_desc.cipherHashInfo.infoAES256F8F9.cipherKey0,
2711 XLR_SEC_AES256F8_KEY_LENGTH);
2713 &desc->ctl_desc.cipherHashInfo.infoAES256F8F9.authKey0,
2718 DPRINT("VECTOR: ???? \n");
2719 DPRINT(">>> WHAT THE HECK !!! <<< \n");
2722 DPRINT("PACKET DESCRIPTOR: \n");
2723 word = 0; //desc->pkt_desc.srcLengthIVOffUseIVNext;
2724 DPRINT("\tSrcLengthIVOffsetIVNext: %llx\n", word);
2725 DPRINT("\t\tLoad HMAC = %lld \n",
2726 GET_FIELD(word, PKT_DSC_LOADHMACKEY));
2727 DPRINT("\t\tPad Hash = %lld \n",
2728 GET_FIELD(word, PKT_DSC_PADHASH));
2729 DPRINT("\t\tHash Byte Count = %lld \n",
2730 GET_FIELD(word, PKT_DSC_HASHBYTES));
2731 DPRINT("\t\tNext = %lld \n",
2732 GET_FIELD(word, PKT_DSC_NEXT));
2733 DPRINT("\t\tUse IV = %lld \n",
2734 GET_FIELD(word, PKT_DSC_IV));
2735 DPRINT("\t\tIV Offset = %lld \n",
2736 GET_FIELD(word, PKT_DSC_IVOFF));
2737 DPRINT("\t\tPacket Length = %lld \n",
2738 GET_FIELD(word, PKT_DSC_PKTLEN));
2739 DPRINT("\t\tNLHMAC = %lld \n", GET_FIELD(word, PKT_DSC_NLHMAC));
2740 DPRINT("\t\tBreak = %lld \n", GET_FIELD(word, PKT_DSC_BREAK));
2741 DPRINT("\t\tWait = %lld \n", GET_FIELD(word, PKT_DSC_WAIT));
2742 DPRINT("\t\tSegment Src Addr = %llx \n",
2743 (GET_FIELD(word, PKT_DSC_SEGADDR) << 5) & 0xffffffffffULL);
2744 DPRINT("\t\tSRTCP = %lld \n", GET_FIELD(word, PKT_DSC_SRTCP));
2745 DPRINT("\t\tGlobal Src Offset = %lld \n",
2746 GET_FIELD(word, PKT_DSC_SEGOFFSET));
2748 word = 0; //desc->pkt_desc.dstDataSettings;
2749 DPRINT("\tdstDataSettings: %llx \n", word);
2750 DPRINT("\t\tArc4 Byte Count = %lld \n", GET_FIELD(word,
2751 PKT_DSC_ARC4BYTECOUNT));
2752 DPRINT("\t\tSym Operation = %lld \n", GET_FIELD(word, PKT_DSC_SYM_OP));
2753 DPRINT("\t\tCipher Offset = %lld \n", GET_FIELD(word, PKT_DSC_CPHROFF));
2754 DPRINT("\t\tHash Offset = %lld \n", GET_FIELD(word, PKT_DSC_HASHOFF));
2755 DPRINT("\t\tHash Source = %lld \n", GET_FIELD(word, PKT_DSC_HASHSRC));
2756 DPRINT("\t\tChecksum Offset = %lld \n", GET_FIELD(word,
2758 DPRINT("\t\tChecksum Source = %lld \n", GET_FIELD(word,
2760 DPRINT("\t\tCipher Dest Addr = %llx \n", GET_FIELD(word,
2761 PKT_DSC_CPHR_DST_ADDR));
2762 DPRINT("\t\tCipher Dest Dword = %lld \n", GET_FIELD(word,
2763 PKT_DSC_CPHR_DST_DWOFFSET));
2764 DPRINT("\t\tCipher Dest Offset= %lld \n", GET_FIELD(word,
2765 PKT_DSC_CPHR_DST_OFFSET));
2766 word = 0; //desc->pkt_desc.authDstNonceLow;
2767 DPRINT("\tauthDstNonceLow: %llx \n", word);
2768 DPRINT("\t\tNonce Low 24 = %lld \n", GET_FIELD(word,
2769 PKT_DSC_NONCE_LOW));
2770 DPRINT("\t\tauthDst = %llx \n", GET_FIELD(word,
2771 PKT_DSC_AUTH_DST_ADDR));
2772 DPRINT("\t\tCipher Offset High= %lld \n", GET_FIELD(word,
2773 PKT_DSC_CIPH_OFF_HI));
2774 word = 0; //desc->pkt_desc.ckSumDstNonceHiCFBMaskLLWMask;
2775 DPRINT("\tckSumDstNonceHiCFBMaskLLWMask: %llx \n", word);
2776 DPRINT("\t\tHash Byte off = %lld \n", GET_FIELD(word, PKT_DSC_HASH_BYTE_OFF));
2777 DPRINT("\t\tPacket Len bytes = %lld \n", GET_FIELD(word, PKT_DSC_PKTLEN_BYTES));
2778 DPRINT("\t\tLast Long Word Mask = %lld \n", GET_FIELD(word,
2780 DPRINT("\t\tCipher Dst Address = %llx \n", GET_FIELD(word,
2781 PKT_DSC_CPHR_DST_ADDR));
2782 DPRINT("\t\tGlobal Dst Offset = %lld \n", GET_FIELD(word,
2783 PKT_DSC_CPHR_DST_OFFSET));
2785 DPRINT("CFG_VECTOR = %04x\n", cfg_vector);
2793 /* This function is called from an interrupt handler */
2795 xlr_sec_msgring_handler(int bucket, int size, int code, int stid,
2796 struct msgrng_msg *msg, void *data)
2799 uint64_t addr, sec_eng, sec_pipe;
2800 xlr_sec_io_pt op = NULL;
2801 symkey_desc_pt desc = NULL;
2802 struct xlr_sec_session *ses = NULL;
2803 struct xlr_sec_command *cmd = NULL;
2806 if (code != MSGRNG_CODE_SEC) {
2807 panic("xlr_sec_msgring_handler: bad code = %d,"
2808 " expected code = %d\n",
2809 code, MSGRNG_CODE_SEC);
2811 if ((stid < MSGRNG_STNID_SEC0) || (stid > MSGRNG_STNID_PK0)) {
2812 panic("xlr_sec_msgring_handler: bad stn id = %d, expect %d - %d\n",
2813 stid, MSGRNG_STNID_SEC0, MSGRNG_STNID_PK0);
2816 * The Submit() operation encodes the engine and pipe in these two
2817 * separate fields. This allows use to verify the result type with
2818 * the submitted operation type.
2820 sec_eng = GET_FIELD(msg->msg0, MSG_CTL_OP_TYPE);
2821 sec_pipe = GET_FIELD(msg->msg1, MSG_CTL_OP_TYPE);
2823 error = msg->msg0 >> 40 & 0x1ff;
2825 printf("ctrl error = 0x%llx\n", error);
2826 error = msg->msg1 >> 40 & 0x1ff;
2828 printf("data error = 0x%llx\n", error);
2831 XLR_SEC_CMD_DIAG("[%s]: eng=%lld pipe=%lld\n",
2832 __FUNCTION__, sec_eng, sec_pipe);
2834 /* Symmetric Key Operation ? */
2835 if (sec_eng == MSG0_CTL_OP_ENGINE_SYMKEY) {
2838 * The data descriptor address allows us to associate the
2839 * response with the submitted operation. Address is 40-bit
2840 * cacheline aligned address. We need to zero bit 0-4 since
2841 * they are used for the engine and pipe Id.
2843 addr = GET_FIELD(msg->msg1, MSG_RSLT_DATA_DSC_ADDR);
2844 addr = addr & ~((1 << 5) - 1);
2846 panic("[%s:STNID_SEC]: NULL symkey addr!\n", __FUNCTION__);
2850 * The adddress points to the data descriptor. The operation
2851 * descriptor is defined with the 32-byte cacheline size in
2852 * mind. It allows the code to use this address to
2853 * reference the symkey descriptor. (ref: xlr_sec_desc.h)
2855 addr = addr - sizeof(OperationDescriptor_t);
2856 flags = xlr_enable_kx();
2857 desc = (symkey_desc_pt)(uintptr_t)xlr_paddr_ld(addr +
2858 offsetof(OperationDescriptor_t, vaddr));
2859 xlr_restore_kx(flags);
2862 printf("\nerror : not getting desc back correctly \n");
2863 panic("[%s:STNID_SEC]: NULL symkey data descriptor!\n", __FUNCTION__);
2865 ses = (struct xlr_sec_session *)desc->ses;
2867 printf("\n error : not getting ses back correctly \n");
2868 panic("[%s:STNID_SEC]: NULL symkey data descriptor!\n", __FUNCTION__);
2872 printf("\n error : not getting cmd back correctly \n");
2873 panic("[%s:STNID_SEC]: NULL symkey data descriptor!\n", __FUNCTION__);
2877 printf("\n error : not getting op back correctly \n");
2878 panic("[%s:STNID_SEC]: NULL symkey data descriptor!\n", __FUNCTION__);
2880 XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: addr=0x%llx desc=%p alloc=%p \n",
2881 __FUNCTION__, addr, desc, desc->alloc);
2883 XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: op_ctl=%p phys_self=%llx stn_id=%d \n",
2884 __FUNCTION__, &desc->op_ctl, desc->op_ctl.phys_self,
2885 desc->op_ctl.stn_id);
2887 if (addr != desc->op_ctl.phys_self) {
2888 XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: Control Descriptor fails Self-Verify !\n",
2890 printf("[%s:STNID_SEC]: Control Descriptor fails Self-Verify !\n",
2892 printf("[%s:STNID_SEC]: addr=0x%llx desc=%p alloc=%p \n",
2893 __FUNCTION__, (unsigned long long)addr, desc, desc->alloc);
2894 printf("[%s:STNID_SEC]: op_ctl=%p phys_self=%llx stn_id=%d \n",
2895 __FUNCTION__, &desc->op_ctl, (unsigned long long)desc->op_ctl.phys_self,
2896 desc->op_ctl.stn_id);
2899 if (desc->op_ctl.stn_id != MSGRNG_STNID_SEC0 &&
2900 desc->op_ctl.stn_id != MSGRNG_STNID_SEC1) {
2901 XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: Operation Type Mismatch !\n",
2903 printf("[%s:STNID_SEC]: Operation Type Mismatch !\n",
2905 printf("[%s:STNID_SEC]: addr=0x%llx desc=%p alloc=%p \n",
2906 __FUNCTION__, (unsigned long long)addr, desc, desc->alloc);
2907 printf("[%s:STNID_SEC]: op_ctl=%p phys_self=%llx stn_id=%d \n",
2908 __FUNCTION__, &desc->op_ctl, (unsigned long long)desc->op_ctl.phys_self,
2909 desc->op_ctl.stn_id);
2911 desc->ctl_result = GET_FIELD(msg->msg0, MSG_RSLT_CTL_INST_ERR);
2912 desc->data_result = GET_FIELD(msg->msg1, MSG_RSLT_DATA_INST_ERR);
2914 XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: cpu=%d ctl_result=0x%llx data_result=%llx\n",
2915 __FUNCTION__, desc->op_ctl.cpu,
2916 desc->ctl_result, desc->data_result);
2920 else if (sec_eng == MSG0_CTL_OP_ENGINE_PUBKEY) {
2921 pubkey_desc_pt desc;
2923 if (sec_pipe != MSG1_CTL_OP_PUBKEY_PIPE0) {
2924 /* response to uc load */
2926 * XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: ecc cpu=%d
2927 * ctl_result=0x%llx data_result=%llx\n",
2928 * __FUNCTION__, desc->op_ctl.cpu, desc->ctl_result,
2929 * desc->data_result);
2934 * The data descriptor address allows us to associate the
2935 * response with the submitted operation. Address is 40-bit
2936 * cacheline aligned address. We need to zero bit 0-4 since
2937 * they are used for the engine and pipe Id.
2939 addr = GET_FIELD(msg->msg0, PUBKEY_RSLT_CTL_SRCADDR);
2940 addr = addr & ~((1 << 5) - 1);
2942 panic("[%s:STNID_SEC]: NULL pubkey ctrl desc!\n", __FUNCTION__);
2945 * The adddress points to the data descriptor. The operation
2946 * descriptor is defined with the 32-byte cacheline size in
2947 * mind. It allows the code to use this address to
2948 * reference the symkey descriptor. (ref: xlr_sec_desc.h)
2950 addr = addr - sizeof(OperationDescriptor_t);
2952 /* Get pointer to pubkey Descriptor */
2953 desc = (pubkey_desc_pt) (unsigned long)addr;
2955 panic("[%s:STNID_SEC]: NULL pubkey data descriptor!\n", __FUNCTION__);
2957 XLR_SEC_CMD_DIAG("[%s:STNID_PK0]: addr=0x%llx desc=%p alloc=%p \n",
2958 __FUNCTION__, addr, desc, desc->alloc);
2960 XLR_SEC_CMD_DIAG("[%s:STNID_PK0]: op_ctl=%p phys_self=%llx stn_id=%d \n",
2961 __FUNCTION__, &desc->op_ctl, desc->op_ctl.phys_self,
2962 desc->op_ctl.stn_id);
2964 if (addr != desc->op_ctl.phys_self) {
2965 XLR_SEC_CMD_DIAG("[%s:STNID_PK0]: Control Descriptor fails Self-Verify !\n",
2968 if (desc->op_ctl.stn_id != msgrng_stnid_pk0) {
2969 XLR_SEC_CMD_DIAG("[%s:STNID_PK0]: Operation Type Mismatch ! \n",
2972 desc->ctl_result = GET_FIELD(msg->msg0, PUBKEY_RSLT_CTL_ERROR);
2973 desc->data_result = GET_FIELD(msg->msg1, PUBKEY_RSLT_DATA_ERROR);
2975 XLR_SEC_CMD_DIAG("[%s:STNID_PK0]: ctl_result=0x%llx data_result=%llx\n",
2976 __FUNCTION__, desc->ctl_result, desc->data_result);
2981 printf("[%s]: HANDLER bad id = %d\n", __FUNCTION__, stid);
2983 #ifdef RMI_SEC_DEBUG
2984 if (ses->multi_frag_flag) {
2988 printf("\n RETURNED DATA: \n");
2990 ptr = (char *)(unsigned long)(desc->user.aligned_dest + cmd->op.cipher_offset);
2991 for (i = 0; i < SEC_MAX_FRAG_LEN; i++) {
2992 printf("%c ", (char)*ptr++);
2997 printf("second desc\n");
2998 ptr = (char *)(unsigned long)(desc->next_dest_buf);
2999 for (i = 0; i < desc->next_src_len; i++) {
3000 printf("%c ", (char)*ptr++);
3007 /* Copy cipher-data to User-space */
3008 if (op->cipher_type != XLR_SEC_CIPHER_TYPE_NONE) {
3009 size = op->dest_buf_size;
3012 XLR_SEC_CMD_DIAG("cipher: to_addr=%p from_addr=%p size=%d \n",
3013 desc->user.user_dest, desc->user.aligned_dest, size);
3015 if (ses->multi_frag_flag) {
3016 crypto_copyback(cmd->crp->crp_flags, cmd->crp->crp_buf, 0,
3017 SEC_MAX_FRAG_LEN, (caddr_t)(long)desc->user.aligned_dest + op->cipher_offset);
3018 crypto_copyback(cmd->crp->crp_flags, cmd->crp->crp_buf + SEC_MAX_FRAG_LEN, 0,
3019 desc->next_src_len, (caddr_t)(long)desc->next_dest_buf);
3020 crypto_done(cmd->crp);
3022 crypto_copyback(cmd->crp->crp_flags, cmd->crp->crp_buf, 0,
3023 cmd->op.dest_buf_size, (caddr_t)(long)desc->user.aligned_dest + op->cipher_offset);
3024 crypto_done(cmd->crp);
3029 /* Copy digest to User-space */
3030 if (op->digest_type != XLR_SEC_DIGEST_TYPE_NONE) {
3033 switch (op->digest_type) {
3034 case XLR_SEC_DIGEST_TYPE_MD5:
3035 size = XLR_SEC_MD5_LENGTH;
3037 case XLR_SEC_DIGEST_TYPE_SHA1:
3038 size = XLR_SEC_SHA1_LENGTH;
3040 case XLR_SEC_DIGEST_TYPE_SHA256:
3041 size = XLR_SEC_SHA256_LENGTH;
3043 case XLR_SEC_DIGEST_TYPE_SHA384:
3044 size = XLR_SEC_SHA384_LENGTH;
3046 case XLR_SEC_DIGEST_TYPE_SHA512:
3047 size = XLR_SEC_SHA512_LENGTH;
3049 case XLR_SEC_DIGEST_TYPE_GCM:
3050 size = XLR_SEC_GCM_LENGTH;
3052 case XLR_SEC_DIGEST_TYPE_KASUMI_F9:
3054 size = XLR_SEC_KASUMI_F9_RESULT_LENGTH;
3060 XLR_SEC_CMD_DIAG("digest: to_addr=%p from_addr=%p size=%d \n",
3061 desc->user.user_auth, desc->user.aligned_auth, size);
3062 memcpy(desc->user.user_auth, desc->user.aligned_auth + offset, size);
3063 op->auth_dest = (uint64_t) (unsigned long)desc->user.user_auth;
3065 if (op->cipher_type == XLR_SEC_CIPHER_TYPE_ARC4 &&
3066 op->rc4_savestate) {
3067 size = XLR_SEC_MAX_RC4_STATE_SIZE;
3069 XLR_SEC_CMD_DIAG("state: to_addr=%p from_addr=%p size=%d \n",
3070 desc->user.user_state, desc->user.aligned_state, size);
3071 op->rc4_state = (uint64_t) (unsigned long)desc->user.user_state;