1 /* 2 * AMD Cryptographic Coprocessor (CCP) driver 3 * 4 * Copyright (C) 2013,2016 Advanced Micro Devices, Inc. 5 * 6 * Author: Tom Lendacky <thomas.lendacky@amd.com> 7 * Author: Gary R Hook <gary.hook@amd.com> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 as 11 * published by the Free Software Foundation. 12 */ 13 14 #ifndef __CPP_H__ 15 #define __CPP_H__ 16 17 #include <linux/scatterlist.h> 18 #include <linux/workqueue.h> 19 #include <linux/list.h> 20 #include <crypto/aes.h> 21 #include <crypto/sha.h> 22 23 24 struct ccp_device; 25 struct ccp_cmd; 26 27 #if defined(CONFIG_CRYPTO_DEV_CCP_DD) || \ 28 defined(CONFIG_CRYPTO_DEV_CCP_DD_MODULE) 29 30 /** 31 * ccp_present - check if a CCP device is present 32 * 33 * Returns zero if a CCP device is present, -ENODEV otherwise. 34 */ 35 int ccp_present(void); 36 37 #define CCP_VSIZE 16 38 #define CCP_VMASK ((unsigned int)((1 << CCP_VSIZE) - 1)) 39 #define CCP_VERSION(v, r) ((unsigned int)((v << CCP_VSIZE) \ 40 | (r & CCP_VMASK))) 41 42 /** 43 * ccp_version - get the version of the CCP 44 * 45 * Returns a positive version number, or zero if no CCP 46 */ 47 unsigned int ccp_version(void); 48 49 /** 50 * ccp_enqueue_cmd - queue an operation for processing by the CCP 51 * 52 * @cmd: ccp_cmd struct to be processed 53 * 54 * Refer to the ccp_cmd struct below for required fields. 55 * 56 * Queue a cmd to be processed by the CCP. If queueing the cmd 57 * would exceed the defined length of the cmd queue the cmd will 58 * only be queued if the CCP_CMD_MAY_BACKLOG flag is set and will 59 * result in a return code of -EBUSY. 60 * 61 * The callback routine specified in the ccp_cmd struct will be 62 * called to notify the caller of completion (if the cmd was not 63 * backlogged) or advancement out of the backlog. If the cmd has 64 * advanced out of the backlog the "err" value of the callback 65 * will be -EINPROGRESS. Any other "err" value during callback is 66 * the result of the operation. 67 * 68 * The cmd has been successfully queued if: 69 * the return code is -EINPROGRESS or 70 * the return code is -EBUSY and CCP_CMD_MAY_BACKLOG flag is set 71 */ 72 int ccp_enqueue_cmd(struct ccp_cmd *cmd); 73 74 #else /* CONFIG_CRYPTO_DEV_CCP_DD is not enabled */ 75 76 static inline int ccp_present(void) 77 { 78 return -ENODEV; 79 } 80 81 static inline unsigned int ccp_version(void) 82 { 83 return 0; 84 } 85 86 static inline int ccp_enqueue_cmd(struct ccp_cmd *cmd) 87 { 88 return -ENODEV; 89 } 90 91 #endif /* CONFIG_CRYPTO_DEV_CCP_DD */ 92 93 94 /***** AES engine *****/ 95 /** 96 * ccp_aes_type - AES key size 97 * 98 * @CCP_AES_TYPE_128: 128-bit key 99 * @CCP_AES_TYPE_192: 192-bit key 100 * @CCP_AES_TYPE_256: 256-bit key 101 */ 102 enum ccp_aes_type { 103 CCP_AES_TYPE_128 = 0, 104 CCP_AES_TYPE_192, 105 CCP_AES_TYPE_256, 106 CCP_AES_TYPE__LAST, 107 }; 108 109 /** 110 * ccp_aes_mode - AES operation mode 111 * 112 * @CCP_AES_MODE_ECB: ECB mode 113 * @CCP_AES_MODE_CBC: CBC mode 114 * @CCP_AES_MODE_OFB: OFB mode 115 * @CCP_AES_MODE_CFB: CFB mode 116 * @CCP_AES_MODE_CTR: CTR mode 117 * @CCP_AES_MODE_CMAC: CMAC mode 118 */ 119 enum ccp_aes_mode { 120 CCP_AES_MODE_ECB = 0, 121 CCP_AES_MODE_CBC, 122 CCP_AES_MODE_OFB, 123 CCP_AES_MODE_CFB, 124 CCP_AES_MODE_CTR, 125 CCP_AES_MODE_CMAC, 126 CCP_AES_MODE__LAST, 127 }; 128 129 /** 130 * ccp_aes_mode - AES operation mode 131 * 132 * @CCP_AES_ACTION_DECRYPT: AES decrypt operation 133 * @CCP_AES_ACTION_ENCRYPT: AES encrypt operation 134 */ 135 enum ccp_aes_action { 136 CCP_AES_ACTION_DECRYPT = 0, 137 CCP_AES_ACTION_ENCRYPT, 138 CCP_AES_ACTION__LAST, 139 }; 140 141 /** 142 * struct ccp_aes_engine - CCP AES operation 143 * @type: AES operation key size 144 * @mode: AES operation mode 145 * @action: AES operation (decrypt/encrypt) 146 * @key: key to be used for this AES operation 147 * @key_len: length in bytes of key 148 * @iv: IV to be used for this AES operation 149 * @iv_len: length in bytes of iv 150 * @src: data to be used for this operation 151 * @dst: data produced by this operation 152 * @src_len: length in bytes of data used for this operation 153 * @cmac_final: indicates final operation when running in CMAC mode 154 * @cmac_key: K1/K2 key used in final CMAC operation 155 * @cmac_key_len: length in bytes of cmac_key 156 * 157 * Variables required to be set when calling ccp_enqueue_cmd(): 158 * - type, mode, action, key, key_len, src, dst, src_len 159 * - iv, iv_len for any mode other than ECB 160 * - cmac_final for CMAC mode 161 * - cmac_key, cmac_key_len for CMAC mode if cmac_final is non-zero 162 * 163 * The iv variable is used as both input and output. On completion of the 164 * AES operation the new IV overwrites the old IV. 165 */ 166 struct ccp_aes_engine { 167 enum ccp_aes_type type; 168 enum ccp_aes_mode mode; 169 enum ccp_aes_action action; 170 171 struct scatterlist *key; 172 u32 key_len; /* In bytes */ 173 174 struct scatterlist *iv; 175 u32 iv_len; /* In bytes */ 176 177 struct scatterlist *src, *dst; 178 u64 src_len; /* In bytes */ 179 180 u32 cmac_final; /* Indicates final cmac cmd */ 181 struct scatterlist *cmac_key; /* K1/K2 cmac key required for 182 * final cmac cmd */ 183 u32 cmac_key_len; /* In bytes */ 184 }; 185 186 /***** XTS-AES engine *****/ 187 /** 188 * ccp_xts_aes_unit_size - XTS unit size 189 * 190 * @CCP_XTS_AES_UNIT_SIZE_16: Unit size of 16 bytes 191 * @CCP_XTS_AES_UNIT_SIZE_512: Unit size of 512 bytes 192 * @CCP_XTS_AES_UNIT_SIZE_1024: Unit size of 1024 bytes 193 * @CCP_XTS_AES_UNIT_SIZE_2048: Unit size of 2048 bytes 194 * @CCP_XTS_AES_UNIT_SIZE_4096: Unit size of 4096 bytes 195 */ 196 enum ccp_xts_aes_unit_size { 197 CCP_XTS_AES_UNIT_SIZE_16 = 0, 198 CCP_XTS_AES_UNIT_SIZE_512, 199 CCP_XTS_AES_UNIT_SIZE_1024, 200 CCP_XTS_AES_UNIT_SIZE_2048, 201 CCP_XTS_AES_UNIT_SIZE_4096, 202 CCP_XTS_AES_UNIT_SIZE__LAST, 203 }; 204 205 /** 206 * struct ccp_xts_aes_engine - CCP XTS AES operation 207 * @action: AES operation (decrypt/encrypt) 208 * @unit_size: unit size of the XTS operation 209 * @key: key to be used for this XTS AES operation 210 * @key_len: length in bytes of key 211 * @iv: IV to be used for this XTS AES operation 212 * @iv_len: length in bytes of iv 213 * @src: data to be used for this operation 214 * @dst: data produced by this operation 215 * @src_len: length in bytes of data used for this operation 216 * @final: indicates final XTS operation 217 * 218 * Variables required to be set when calling ccp_enqueue_cmd(): 219 * - action, unit_size, key, key_len, iv, iv_len, src, dst, src_len, final 220 * 221 * The iv variable is used as both input and output. On completion of the 222 * AES operation the new IV overwrites the old IV. 223 */ 224 struct ccp_xts_aes_engine { 225 enum ccp_aes_action action; 226 enum ccp_xts_aes_unit_size unit_size; 227 228 struct scatterlist *key; 229 u32 key_len; /* In bytes */ 230 231 struct scatterlist *iv; 232 u32 iv_len; /* In bytes */ 233 234 struct scatterlist *src, *dst; 235 u64 src_len; /* In bytes */ 236 237 u32 final; 238 }; 239 240 /***** SHA engine *****/ 241 #define CCP_SHA_BLOCKSIZE SHA256_BLOCK_SIZE 242 #define CCP_SHA_CTXSIZE SHA256_DIGEST_SIZE 243 244 /** 245 * ccp_sha_type - type of SHA operation 246 * 247 * @CCP_SHA_TYPE_1: SHA-1 operation 248 * @CCP_SHA_TYPE_224: SHA-224 operation 249 * @CCP_SHA_TYPE_256: SHA-256 operation 250 */ 251 enum ccp_sha_type { 252 CCP_SHA_TYPE_1 = 1, 253 CCP_SHA_TYPE_224, 254 CCP_SHA_TYPE_256, 255 CCP_SHA_TYPE__LAST, 256 }; 257 258 /** 259 * struct ccp_sha_engine - CCP SHA operation 260 * @type: Type of SHA operation 261 * @ctx: current hash value 262 * @ctx_len: length in bytes of hash value 263 * @src: data to be used for this operation 264 * @src_len: length in bytes of data used for this operation 265 * @opad: data to be used for final HMAC operation 266 * @opad_len: length in bytes of data used for final HMAC operation 267 * @first: indicates first SHA operation 268 * @final: indicates final SHA operation 269 * @msg_bits: total length of the message in bits used in final SHA operation 270 * 271 * Variables required to be set when calling ccp_enqueue_cmd(): 272 * - type, ctx, ctx_len, src, src_len, final 273 * - msg_bits if final is non-zero 274 * 275 * The ctx variable is used as both input and output. On completion of the 276 * SHA operation the new hash value overwrites the old hash value. 277 */ 278 struct ccp_sha_engine { 279 enum ccp_sha_type type; 280 281 struct scatterlist *ctx; 282 u32 ctx_len; /* In bytes */ 283 284 struct scatterlist *src; 285 u64 src_len; /* In bytes */ 286 287 struct scatterlist *opad; 288 u32 opad_len; /* In bytes */ 289 290 u32 first; /* Indicates first sha cmd */ 291 u32 final; /* Indicates final sha cmd */ 292 u64 msg_bits; /* Message length in bits required for 293 * final sha cmd */ 294 }; 295 296 /***** RSA engine *****/ 297 /** 298 * struct ccp_rsa_engine - CCP RSA operation 299 * @key_size: length in bits of RSA key 300 * @exp: RSA exponent 301 * @exp_len: length in bytes of exponent 302 * @mod: RSA modulus 303 * @mod_len: length in bytes of modulus 304 * @src: data to be used for this operation 305 * @dst: data produced by this operation 306 * @src_len: length in bytes of data used for this operation 307 * 308 * Variables required to be set when calling ccp_enqueue_cmd(): 309 * - key_size, exp, exp_len, mod, mod_len, src, dst, src_len 310 */ 311 struct ccp_rsa_engine { 312 u32 key_size; /* In bits */ 313 314 struct scatterlist *exp; 315 u32 exp_len; /* In bytes */ 316 317 struct scatterlist *mod; 318 u32 mod_len; /* In bytes */ 319 320 struct scatterlist *src, *dst; 321 u32 src_len; /* In bytes */ 322 }; 323 324 /***** Passthru engine *****/ 325 /** 326 * ccp_passthru_bitwise - type of bitwise passthru operation 327 * 328 * @CCP_PASSTHRU_BITWISE_NOOP: no bitwise operation performed 329 * @CCP_PASSTHRU_BITWISE_AND: perform bitwise AND of src with mask 330 * @CCP_PASSTHRU_BITWISE_OR: perform bitwise OR of src with mask 331 * @CCP_PASSTHRU_BITWISE_XOR: perform bitwise XOR of src with mask 332 * @CCP_PASSTHRU_BITWISE_MASK: overwrite with mask 333 */ 334 enum ccp_passthru_bitwise { 335 CCP_PASSTHRU_BITWISE_NOOP = 0, 336 CCP_PASSTHRU_BITWISE_AND, 337 CCP_PASSTHRU_BITWISE_OR, 338 CCP_PASSTHRU_BITWISE_XOR, 339 CCP_PASSTHRU_BITWISE_MASK, 340 CCP_PASSTHRU_BITWISE__LAST, 341 }; 342 343 /** 344 * ccp_passthru_byteswap - type of byteswap passthru operation 345 * 346 * @CCP_PASSTHRU_BYTESWAP_NOOP: no byte swapping performed 347 * @CCP_PASSTHRU_BYTESWAP_32BIT: swap bytes within 32-bit words 348 * @CCP_PASSTHRU_BYTESWAP_256BIT: swap bytes within 256-bit words 349 */ 350 enum ccp_passthru_byteswap { 351 CCP_PASSTHRU_BYTESWAP_NOOP = 0, 352 CCP_PASSTHRU_BYTESWAP_32BIT, 353 CCP_PASSTHRU_BYTESWAP_256BIT, 354 CCP_PASSTHRU_BYTESWAP__LAST, 355 }; 356 357 /** 358 * struct ccp_passthru_engine - CCP pass-through operation 359 * @bit_mod: bitwise operation to perform 360 * @byte_swap: byteswap operation to perform 361 * @mask: mask to be applied to data 362 * @mask_len: length in bytes of mask 363 * @src: data to be used for this operation 364 * @dst: data produced by this operation 365 * @src_len: length in bytes of data used for this operation 366 * @final: indicate final pass-through operation 367 * 368 * Variables required to be set when calling ccp_enqueue_cmd(): 369 * - bit_mod, byte_swap, src, dst, src_len 370 * - mask, mask_len if bit_mod is not CCP_PASSTHRU_BITWISE_NOOP 371 */ 372 struct ccp_passthru_engine { 373 enum ccp_passthru_bitwise bit_mod; 374 enum ccp_passthru_byteswap byte_swap; 375 376 struct scatterlist *mask; 377 u32 mask_len; /* In bytes */ 378 379 struct scatterlist *src, *dst; 380 u64 src_len; /* In bytes */ 381 382 u32 final; 383 }; 384 385 /** 386 * struct ccp_passthru_nomap_engine - CCP pass-through operation 387 * without performing DMA mapping 388 * @bit_mod: bitwise operation to perform 389 * @byte_swap: byteswap operation to perform 390 * @mask: mask to be applied to data 391 * @mask_len: length in bytes of mask 392 * @src: data to be used for this operation 393 * @dst: data produced by this operation 394 * @src_len: length in bytes of data used for this operation 395 * @final: indicate final pass-through operation 396 * 397 * Variables required to be set when calling ccp_enqueue_cmd(): 398 * - bit_mod, byte_swap, src, dst, src_len 399 * - mask, mask_len if bit_mod is not CCP_PASSTHRU_BITWISE_NOOP 400 */ 401 struct ccp_passthru_nomap_engine { 402 enum ccp_passthru_bitwise bit_mod; 403 enum ccp_passthru_byteswap byte_swap; 404 405 dma_addr_t mask; 406 u32 mask_len; /* In bytes */ 407 408 dma_addr_t src_dma, dst_dma; 409 u64 src_len; /* In bytes */ 410 411 u32 final; 412 }; 413 414 /***** ECC engine *****/ 415 #define CCP_ECC_MODULUS_BYTES 48 /* 384-bits */ 416 #define CCP_ECC_MAX_OPERANDS 6 417 #define CCP_ECC_MAX_OUTPUTS 3 418 419 /** 420 * ccp_ecc_function - type of ECC function 421 * 422 * @CCP_ECC_FUNCTION_MMUL_384BIT: 384-bit modular multiplication 423 * @CCP_ECC_FUNCTION_MADD_384BIT: 384-bit modular addition 424 * @CCP_ECC_FUNCTION_MINV_384BIT: 384-bit multiplicative inverse 425 * @CCP_ECC_FUNCTION_PADD_384BIT: 384-bit point addition 426 * @CCP_ECC_FUNCTION_PMUL_384BIT: 384-bit point multiplication 427 * @CCP_ECC_FUNCTION_PDBL_384BIT: 384-bit point doubling 428 */ 429 enum ccp_ecc_function { 430 CCP_ECC_FUNCTION_MMUL_384BIT = 0, 431 CCP_ECC_FUNCTION_MADD_384BIT, 432 CCP_ECC_FUNCTION_MINV_384BIT, 433 CCP_ECC_FUNCTION_PADD_384BIT, 434 CCP_ECC_FUNCTION_PMUL_384BIT, 435 CCP_ECC_FUNCTION_PDBL_384BIT, 436 }; 437 438 /** 439 * struct ccp_ecc_modular_math - CCP ECC modular math parameters 440 * @operand_1: first operand for the modular math operation 441 * @operand_1_len: length of the first operand 442 * @operand_2: second operand for the modular math operation 443 * (not used for CCP_ECC_FUNCTION_MINV_384BIT) 444 * @operand_2_len: length of the second operand 445 * (not used for CCP_ECC_FUNCTION_MINV_384BIT) 446 * @result: result of the modular math operation 447 * @result_len: length of the supplied result buffer 448 */ 449 struct ccp_ecc_modular_math { 450 struct scatterlist *operand_1; 451 unsigned int operand_1_len; /* In bytes */ 452 453 struct scatterlist *operand_2; 454 unsigned int operand_2_len; /* In bytes */ 455 456 struct scatterlist *result; 457 unsigned int result_len; /* In bytes */ 458 }; 459 460 /** 461 * struct ccp_ecc_point - CCP ECC point definition 462 * @x: the x coordinate of the ECC point 463 * @x_len: the length of the x coordinate 464 * @y: the y coordinate of the ECC point 465 * @y_len: the length of the y coordinate 466 */ 467 struct ccp_ecc_point { 468 struct scatterlist *x; 469 unsigned int x_len; /* In bytes */ 470 471 struct scatterlist *y; 472 unsigned int y_len; /* In bytes */ 473 }; 474 475 /** 476 * struct ccp_ecc_point_math - CCP ECC point math parameters 477 * @point_1: the first point of the ECC point math operation 478 * @point_2: the second point of the ECC point math operation 479 * (only used for CCP_ECC_FUNCTION_PADD_384BIT) 480 * @domain_a: the a parameter of the ECC curve 481 * @domain_a_len: the length of the a parameter 482 * @scalar: the scalar parameter for the point match operation 483 * (only used for CCP_ECC_FUNCTION_PMUL_384BIT) 484 * @scalar_len: the length of the scalar parameter 485 * (only used for CCP_ECC_FUNCTION_PMUL_384BIT) 486 * @result: the point resulting from the point math operation 487 */ 488 struct ccp_ecc_point_math { 489 struct ccp_ecc_point point_1; 490 struct ccp_ecc_point point_2; 491 492 struct scatterlist *domain_a; 493 unsigned int domain_a_len; /* In bytes */ 494 495 struct scatterlist *scalar; 496 unsigned int scalar_len; /* In bytes */ 497 498 struct ccp_ecc_point result; 499 }; 500 501 /** 502 * struct ccp_ecc_engine - CCP ECC operation 503 * @function: ECC function to perform 504 * @mod: ECC modulus 505 * @mod_len: length in bytes of modulus 506 * @mm: module math parameters 507 * @pm: point math parameters 508 * @ecc_result: result of the ECC operation 509 * 510 * Variables required to be set when calling ccp_enqueue_cmd(): 511 * - function, mod, mod_len 512 * - operand, operand_len, operand_count, output, output_len, output_count 513 * - ecc_result 514 */ 515 struct ccp_ecc_engine { 516 enum ccp_ecc_function function; 517 518 struct scatterlist *mod; 519 u32 mod_len; /* In bytes */ 520 521 union { 522 struct ccp_ecc_modular_math mm; 523 struct ccp_ecc_point_math pm; 524 } u; 525 526 u16 ecc_result; 527 }; 528 529 530 /** 531 * ccp_engine - CCP operation identifiers 532 * 533 * @CCP_ENGINE_AES: AES operation 534 * @CCP_ENGINE_XTS_AES: 128-bit XTS AES operation 535 * @CCP_ENGINE_RSVD1: unused 536 * @CCP_ENGINE_SHA: SHA operation 537 * @CCP_ENGINE_RSA: RSA operation 538 * @CCP_ENGINE_PASSTHRU: pass-through operation 539 * @CCP_ENGINE_ZLIB_DECOMPRESS: unused 540 * @CCP_ENGINE_ECC: ECC operation 541 */ 542 enum ccp_engine { 543 CCP_ENGINE_AES = 0, 544 CCP_ENGINE_XTS_AES_128, 545 CCP_ENGINE_RSVD1, 546 CCP_ENGINE_SHA, 547 CCP_ENGINE_RSA, 548 CCP_ENGINE_PASSTHRU, 549 CCP_ENGINE_ZLIB_DECOMPRESS, 550 CCP_ENGINE_ECC, 551 CCP_ENGINE__LAST, 552 }; 553 554 /* Flag values for flags member of ccp_cmd */ 555 #define CCP_CMD_MAY_BACKLOG 0x00000001 556 #define CCP_CMD_PASSTHRU_NO_DMA_MAP 0x00000002 557 558 /** 559 * struct ccp_cmd - CPP operation request 560 * @entry: list element (ccp driver use only) 561 * @work: work element used for callbacks (ccp driver use only) 562 * @ccp: CCP device to be run on (ccp driver use only) 563 * @ret: operation return code (ccp driver use only) 564 * @flags: cmd processing flags 565 * @engine: CCP operation to perform 566 * @engine_error: CCP engine return code 567 * @u: engine specific structures, refer to specific engine struct below 568 * @callback: operation completion callback function 569 * @data: parameter value to be supplied to the callback function 570 * 571 * Variables required to be set when calling ccp_enqueue_cmd(): 572 * - engine, callback 573 * - See the operation structures below for what is required for each 574 * operation. 575 */ 576 struct ccp_cmd { 577 /* The list_head, work_struct, ccp and ret variables are for use 578 * by the CCP driver only. 579 */ 580 struct list_head entry; 581 struct work_struct work; 582 struct ccp_device *ccp; 583 int ret; 584 585 u32 flags; 586 587 enum ccp_engine engine; 588 u32 engine_error; 589 590 union { 591 struct ccp_aes_engine aes; 592 struct ccp_xts_aes_engine xts; 593 struct ccp_sha_engine sha; 594 struct ccp_rsa_engine rsa; 595 struct ccp_passthru_engine passthru; 596 struct ccp_passthru_nomap_engine passthru_nomap; 597 struct ccp_ecc_engine ecc; 598 } u; 599 600 /* Completion callback support */ 601 void (*callback)(void *data, int err); 602 void *data; 603 }; 604 605 #endif 606