diff options
Diffstat (limited to 'include/crypto/pka_4xx.h')
| -rw-r--r-- | include/crypto/pka_4xx.h | 897 |
1 files changed, 897 insertions, 0 deletions
diff --git a/include/crypto/pka_4xx.h b/include/crypto/pka_4xx.h new file mode 100644 index 00000000000..41663fd7d9a --- /dev/null +++ b/include/crypto/pka_4xx.h @@ -0,0 +1,897 @@ +/******************************************************************************* + * + * Copyright (c) 2008 Loc Ho <lho@amcc.com> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * + * Detail Description: + * This file defines ioctl structures for the Linux CryptoAPI interface. It + * provides user space applications accesss into the Linux CryptoAPI + * functionalities. + * + * @file pka4xx.h + * + * This file provides helper to the AMCC SoC PKA hardware. + * + ******************************************************************************* + */ +#ifndef __PKA4XX_H__ +#define __PKA4XX_H__ + +#define PKA4XX_RAM_SIZE (8*1024) +/* Reserve last 72 bytes for used by sequencer firmware and round down + to 8-bytes align */ +#define PKA4XX_RAM_FREE_SIZE (((8*1024)-72)&~0x7) +#define PKA4XX_PROGRAM_SIZE (2*1024) + +/** + * PKA Register and bit Definitions + * + */ + +/* Register PKT_FUNCTION bit definition */ +#define PKA_FUNCTION_MUL 0x00000001 +#define PKA_FUNCTION_ADDSUB 0x00000002 +#define PKA_FUNCTION_RSVD 0x00000004 +#define PKA_FUNCTION_MSONE 0x00000008 +#define PKA_FUNCTION_ADD 0x00000010 +#define PKA_FUNCTION_SUB 0x00000020 +#define PKA_FUNCTION_RSHIFT 0x00000040 +#define PKA_FUNCTION_LSHIFT 0x00000080 +#define PKA_FUNCTION_DIV 0x00000100 +#define PKA_FUNCTION_MOD 0x00000200 +#define PKA_FUNCTION_COMPARE 0x00000400 +#define PKA_FUNCTION_COPY 0x00000800 +#define PKA_FUNCTION_SEQOP_MASK (7 << 12) +#define PKA_FUNCTION_SEQOP_EXPMOD_CRT (1 << 12) +#define PKA_FUNCTION_SEQOP_EXPMOD_ACT4 (2 << 12) +#define PKA_FUNCTION_SEQOP_ECC_ADD (3 << 12) +#define PKA_FUNCTION_SEQOP_EXPMOD_ACT2 (4 << 12) +#define PKA_FUNCTION_SEQOP_ECC_MUL (5 << 12) +#define PKA_FUNCTION_SEQOP_EXPMOD_VAR (6 << 12) +#define PKA_FUNCTION_SEQOP_MODINV (7 << 12) +#define PKA_FUNCTION_RUN (1 << 15) +#define PKA_FUNCTION_STALL (1 << 24) + +/* Register PKA_COMPARE bit definition */ +#define PKA_COMPARE_EQUAL 0x00000001 +#define PKA_COMPARE_LESSTHAN 0x00000002 +#define PKA_COMPARE_GREATHERTHAN 0x00000004 + +/* Register PKA_MSW bit definition */ +#define PKA_MSW_ADDR_MASK 0x000007FF +#define PKA_MSW_RESULT_ZERO (1 << 15) + +/* Register PKA_DIVMSW bit definition */ +#define PKA_DIVMSW_ADDR_MASK 0x000007FF +#define PKA_DIVMSW_RESULT_ZERO (1 << 15) + +/* Register PKA_SEQ_CTRL bit definition */ +#define PKA_SEQ_CTRL_SW_CTRL_TRIGGER_MASK 0x000000FF +#define PKA_SEQ_CTRL_SEQ_STATUS_MASK 0x0000FF00 +#define PKA_SEQ_CTRL_RESET 0x80000000 + +/* PKA Registers definitions */ +#define PKA_APTR_ADDR 0x0000 +#define PKA_BPTR_ADDR 0x0004 +#define PKA_CPTR_ADDR 0x0008 +#define PKA_DPTR_ADDR 0x000C +#define PKA_ALENGTH_ADDR 0x0010 +#define PKA_BLENGTH_ADDR 0x0014 +#define PKA_SHIFT_ADDR 0x0018 +#define PKA_FUNCTION_ADDR 0x001C +#define PKA_COMPARE_ADDR 0x0020 +#define PKA_MSW_ADDR 0x0024 +#define PKA_DIVMSW_ADDR 0x0028 +#define PKA_SEQ_CTRL_ADDR 0x00C8 +#define PKA_RAM_ADDR 0x2000 +#define PKA_PROGRAM_ADDR 0x2000 /* PKA Program area is shared + with PKA_RAM. To access, + put the Sequencer into reset. + See PKA_SEQ_CTRL. */ + +/* # of operation can be queued */ +#define PKA4XX_PENDING_OP_MAX 256 +#define MAX_FREE_DESC_AVAIL_TRY 10 + +typedef void (*pka4xx_cb)(void *ctx, int status); + +/** Structure definitions used for asynchronous PKA operations */ +struct pka4xx_async_pkcp_op { + u32 vecA_cnt; + u32 *vecA; + u32 vecB_cnt; + u32 *vecB; + u32 *vec_addsub_C; + u8 shift_val; +}; + +struct pka4xx_async_expmod_op { + u32 *base; + u32 *exp; + u32 *modulus; + u32 exp_cnt; + u32 base_mod_cnt; +}; + +struct pka4xx_async_expmod_crt_op { + u32 *expP; + u32 *expQ; + u32 exp_len; + u32 *modP; + u32 *modQ; + u32 mod_inverse_len; + u32 *inverseQ; + u32 *input; +}; + +#define async_pkcp async_op.pkcp_op +#define async_expmod async_op.expmod_op +#define async_expmod_crt async_op.expmod_crt_op + +struct pka4xx_op +{ + u8 id; + u32 opcode; /* Encoded as PKA_FUNCTION register */ + pka4xx_cb cb; /* Callback function */ + void *ctx; /* Context for callback function */ + u16 resultC_cnt; /* # of DWORD for result C */ + u16 resultD_cnt; /* # of DWORD for result D */ + u32 *resultC_addr; /* Address for result C */ + u32 *resultD_addr; /* Address for result C */ + u32 ramC_addr; /* PKA RAM Address for result C in DWORD unit */ + u32 ramD_addr; /* PKA RAM Address for result D in DWORD unit */ + u32 ram_addr_start; /* PKA RAM Address start */ + u16 ram_addr_size; /* PKA RAM Address size */ + struct list_head next; + int status; + union { + struct pka4xx_async_expmod_crt_op expmod_crt_op; + struct pka4xx_async_expmod_op expmod_op; + struct pka4xx_async_pkcp_op pkcp_op; + } async_op; +}; + +/** Context for async operations */ +struct pka4xx_ctx +{ + s16 ram_blk2use; + struct { + u8 usable; + s16 sizeDW; + u32 addrDW; + } ram_blk[2]; + u16 op_head; + u16 op_tail; + struct pka4xx_op op[PKA4XX_PENDING_OP_MAX]; + u32 csr_paddr; + u32 pka_ram_paddr; + volatile char *csr; + volatile char *pka_ram; + int irq; + struct list_head completed_event_queue; + + spinlock_t lock; + struct tasklet_struct tasklet; +}; + +struct hal_config; + +/** + * @brief IRQ Handler for PKA Interrupts + * @return Success/Failure + */ +irqreturn_t pka4xx_irq_handler(int irq, void *id); + +/** + * @brief Tasklet for post-processing of result of PKA operstaions + */ +void pka4xx_tasklet_cb (unsigned long data); + +/** + * @brief Process completed events + */ +void pka4xx_process_completed_event (struct pka4xx_op *op); + +/** + * @brief Retrieve the PKA context (OS neutral) + * @return A pointer to PKA context + * @note New layer of the device musts returns a pointer to this variables. + * + * + */ +struct pka4xx_ctx *pka_get_ctx(void); + +/** + * @brief This function MUSTs be called to initialize the HW + * access function. + * @param amcc_hal_cfg HW access configuration. If NULL, + * default will be used. + * @return PPRO_RC_OK or PPRO_RC_FATAL + * @note To load all access functions from HAL with default initial + * map address, pass a NULL as its parameter. + * @n To load all access functions from HAL with default runtime + * map address, initialize an amcc_hal_config_t struct + * with valid HAL signature and set + * amcc_hal_config->flags |= HAL_FLAG_LOADINIT; + * + ******************************************************************************* + */ +int pka4xx_config_set(struct hal_config *cfg); + +/** + * @brief This function MUSTs be called to de-initialize the HW + * access function. + * @return PPRO_RC_OK or PPRO_RC_FATAL + * + * + */ +int pka4xx_config_clear(void); + +/** + * @brief This functions reads from the PKA registers. + * @param reg_addr Device register offset + * @param data_val An DWORD pointer to store the returned value + * @return PPRO_RC_OK or PPRO_RC_FATAL + * + * + */ +int pka4xx_csr_hw_read32(u32 reg_addr, u32 *data_val); + +/** + * @brief This functions writes to the PKA registers. + * @param reg_addr Device register offset + * @param data_val An DWORD value to write + * @return PPRO_RC_OK or PPRO_RC_FATAL + * + * + */ +int pka4xx_csr_hw_write32(u32 reg_addr, u32 data_val); + +/** + * @brief This functions reads from the PKA RAM. + * @param reg_addr ram addr + * @param data_val An DWORD pointer to store the returned value + * @return PPRO_RC_OK or PPRO_RC_FATAL + * + * + */ +int pka4xx_ram_hw_read32(u32 reg_addr, u32 *data_val); + +/** + * @brief This functions writes to the PKA RAM. + * @param reg_addr ram addr + * @param data_val An DWORD value to write + * @return PPRO_RC_OK or PPRO_RC_FATAL + * + * + */ +int pka4xx_ram_hw_write32(u32 reg_addr, u32 data_val); +/** + * @brief Initiaize PKA hardware + * @return PPRO_RC_OK or PPRO_RC_FATAL + * + * + */ +int pka4xx_hw_init(void); + +/** + * @brief De-Initiaize PKA hardware + * @return PPRO_RC_OK or PPRO_RC_FATAL + * + * + */ +int pka4xx_hw_deinit(void); + +/**< PKA input vector max count */ +#define PKA4XX_VECTOR_MAXSIZE 256 + +/** + * @brief Performs large vector multiplication (A * B = C) + * @param cb Callback function of asynchronous operation. If this + * parameter is NULL, then it will block until operation + * completed. As this function is called from interrupt + * context, it should defer complex operation and + * return as soon as possible. When there is pending + * operation, this parameter can not be NULL. + * @param ctx A void context pointer passed in cb function + * @param op_id An integer identifier pointer for asynchronous + * operation. It can be used to cancel pending operation. + * Can be NULL. + * @param multiplicand_len Length of multiplicand in DWORD unit (<= + * PKA4XX_VECTOR_MAXSIZE) + * @param multiplicand Multiplicand vector pointer of the operation - input A + * @param multiplier_len Length of multiplier in DWORD unit (<= + * PKA4XX_VECTOR_MAXSIZE) + * @param multiplier Multiplier vector pointer of the operation - input B + * @param product Result product vector - output C. Length is + * multiplicand_len * multiplier_len in DWORD unit + * @return PPRO_RC_INVALID_PARM - any invalid parameters (< 0) + * PPRO_RC_EBUSY - If cb ia NULL and there is pending operation + * (< 0). Or, hardware buffer is full. + * PPRO_RC_EINPROGRESS - operation is pending (< 0) + * PPRO_RC_OK - operation completed successfully (= 0) + * + * + */ +int pka4xx_mul(pka4xx_cb cb, + void *ctx, + u32 *op_id, + u32 multiplicand_len, + u32 *multiplicand, + u32 multiplier_len, + u32 *multiplier, + u32 *product); + +/** + * @brief Performs vector division (A / B = D and A % B = C) + * @param cb Callback function of asynchronous operation. If this + * parameter is NULL, then it will block until operation + * completed. As this function is called from interrupt + * context, it should defer complex operation and + * return as soon as possible. When there is pending + * operation, this parameter can not be NULL. + * @param ctx A void context pointer passed in cb function + * @param op_id An integer identifier pointer for asynchronous + * operation. It can be used to cancel pending operation. + * Can be NULL. + * @param dividend_len Length of dividend in DWORD unit (<= + * PKA4XX_VECTOR_MAXSIZE) + * @param dividend Dividend vector pointer of the operation - input A + * @param divisor_len Length of divisor in DWORD unit (<= dividend_len <= + * PKA4XX_VECTOR_MAXSIZE) + * @param divisor Divisor vector pointer of the operation - input B - + * where most significant 32 bits != 0 + * @param remainder Result reminder vector pointer of the operation - + * output C. Length is divisor_len + 1 in DWORD unit + * @param quotient Result integer vector pointer of the operation - + * output D. Length is dividend_len - divisor_len + 1 + * in DWORD unit + * @return PPRO_RC_INVALID_PARM - any invalid parameters (< 0) + * PPRO_RC_EBUSY - If cb ia NULL and there is pending operation + * (< 0). Or, hardware buffer is full. + * PPRO_RC_EINPROGRESS - operation is pending (< 0) + * PPRO_RC_OK - operation completed successfully (= 0) + * + * + */ +int pka4xx_div(pka4xx_cb cb, + void *ctx, + u32 *op_id, + u32 dividend_len, + u32 *dividend, + u32 divisor_len, + u32 *divisor, + u32 *remainder, + u32 *quotient); + +/** + * @brief Performs vector modulo (A % B = C) where B != 0 + * @param cb Callback function of asynchronous operation. If this + * parameter is NULL, then it will block until operation + * completed. As this function is called from interrupt + * context, it should defer complex operation and + * return as soon as possible. When there is pending + * operation, this parameter can not be NULL. + * @param ctx A void context pointer passed in cb function + * @param op_id An integer identifier pointer for asynchronous + * operation. It can be used to cancel pending operation. + * Can be NULL. + * @param dividend_len Length of dividend in DWORD unit (<= + * PKA4XX_VECTOR_MAXSIZE) + * @param dividend Dividend vector pointer of the operation - input A + * @param divisor_len Length of divisor in DWORD unit (<= dividend_len <= + * PKA4XX_VECTOR_MAXSIZE) + * @param divisor Divisor vector pointer of the operation - input B + * @param remainder Result reminder vector pointer of the operation - + * output C. Length is divisor_len + 1 in DWORD unit + * @return PPRO_RC_INVALID_PARM - any invalid parameters (< 0) + * PPRO_RC_EBUSY - If cb ia NULL and there is pending operation + * (< 0). Or, hardware buffer is full. + * PPRO_RC_EINPROGRESS - operation is pending (< 0) + * PPRO_RC_OK - operation completed successfully (= 0) + * + * + */ +int pka4xx_mod(pka4xx_cb cb, + void *ctx, + u32 *op_id, + u32 dividend_len, + u32 *dividend, + u32 divisor_len, + u32 *divisor, + u32 *remainder); + +/** + * @brief Performs vector addition (A + B = C) + * @param cb Callback function of asynchronous operation. If this + * parameter is NULL, then it will block until operation + * completed. As this function is called from interrupt + * context, it should defer complex operation and + * return as soon as possible. When there is pending + * operation, this parameter can not be NULL. + * @param ctx A void context pointer passed in cb function + * @param op_id An integer identifier pointer for asynchronous + * operation. It can be used to cancel pending operation. + * Can be NULL. + * @param addendA_len Length of addendA in DWORD unit (<= + * PKA4XX_VECTOR_MAXSIZE) + * @param addendA Addend vector pointer of the operation - input A + * @param addendB_len Length of addendB in DWORD unit (<= + * PKA4XX_VECTOR_MAXSIZE) + * @param addendB Addend vector pointer of the operation - input B + * @param sum Result sum vector pointer of the operation - output C. + * Length is MAX(addendA_len, addendB_len) + 1 in DWORD + * unit + * @return PPRO_RC_INVALID_PARM - any invalid parameters (< 0) + * PPRO_RC_EBUSY - If cb ia NULL and there is pending operation + * (< 0). Or, hardware buffer is full. + * PPRO_RC_EINPROGRESS - operation is pending (< 0) + * PPRO_RC_OK - operation completed successfully (= 0) + * + * + */ +int pka4xx_add(pka4xx_cb cb, + void *ctx, + u32 *op_id, + u32 addendA_len, + u32 *addendA, + u32 addendB_len, + u32 *addendB, + u32 *sum); + +/** + * @brief Performs vector substraction (A - B = C) where A >= B + * @param cb Callback function of asynchronous operation. If this + * parameter is NULL, then it will block until operation + * completed. As this function is called from interrupt + * context, it should defer complex operation and + * return as soon as possible. When there is pending + * operation, this parameter can not be NULL. + * @param ctx A void context pointer passed in cb function + * @param op_id An integer identifier pointer for asynchronous + * operation. It can be used to cancel pending operation. + * Can be NULL. + * @param minuend_len Length of minuend in DWORD unit (<= + * PKA4XX_VECTOR_MAXSIZE) + * @param minuend Minuendnd vector pointer of the operation - input A + * @param subtrahend_len Length of minuend in DWORD unit (<= + * PKA4XX_VECTOR_MAXSIZE) + * @param subtrahend Subtrahend vector pointer of the operation - input B + * @param difference Result difference vector pointer of the operation - + * output C. Length is MAX(minuend_len, subtrahend_len) + * in DWORD unit. + * @return PPRO_RC_INVALID_PARM - any invalid parameters (< 0) + * PPRO_RC_EBUSY - If cb ia NULL and there is pending operation + * (< 0). Or, hardware buffer is full. + * PPRO_RC_EINPROGRESS - operation is pending (< 0) + * PPRO_RC_OK - operation completed successfully (= 0) + * + * + */ +int pka4xx_sub(pka4xx_cb cb, + void *ctx, + u32 *op_id, + u32 minuend_len, + u32 *minuend, + u32 subtrahend_len, + u32 *subtrahend, + u32 *difference); + +/** + * @brief Performs vector addition and then substraction (A + C - B = D) where + * A + C >= B. + * @param cb Callback function of asynchronous operation. If this + * parameter is NULL, then it will block until operation + * completed. As this function is called from interrupt + * context, it should defer complex operation and + * return as soon as possible. When there is pending + * operation, this parameter can not be NULL. + * @param ctx A void context pointer passed in cb function + * @param op_id An integer identifier pointer for asynchronous + * operation. It can be used to cancel pending operation. + * Can be NULL. + * @param input_cnt Length of all inputs in DWORD unit (<= + * PKA4XX_VECTOR_MAXSIZE) + * @param addendA Addend vector pointer of the operation - input A + * @param addendC Addend vector pointer of the operation - input C + * @param subtrahend Subtrahend vector pointer of the operation - input B + * @param result Result vector pointer of the operation - output D. + * Length is input_cnt + 1 in DWORD unit. + * @return PPRO_RC_INVALID_PARM - any invalid parameters (< 0) + * PPRO_RC_EBUSY - If cb ia NULL and there is pending operation + * (< 0). Or, hardware buffer is full. + * PPRO_RC_EINPROGRESS - operation is pending (< 0) + * PPRO_RC_OK - operation completed successfully (= 0) + * + * + */ +int pka4xx_addsub(pka4xx_cb cb, + void *ctx, + u32 *op_id, + u32 input_cnt, + u32 *addendA, + u32 *addendC, + u32 *subtrahend, + u32 *result); + +/** + * @brief Performs vector right shift (A >> X = C) + * @param cb Callback function of asynchronous operation. If this + * parameter is NULL, then it will block until operation + * completed. As this function is called from interrupt + * context, it should defer complex operation and + * return as soon as possible. When there is pending + * operation, this parameter can not be NULL. + * @param ctx A void context pointer passed in cb function + * @param op_id An integer identifier pointer for asynchronous + * operation. It can be used to cancel pending operation. + * Can be NULL. + * @param input_cnt Length of input in DWORD unit (<= + * PKA4XX_VECTOR_MAXSIZE) + * @param input Input vector pointer of the operation - input A + * @param shift Shift value of the operation - input X. 0 <= shift <= 31 + * @param result Result vector pointer of the operation - output C + * @return PPRO_RC_INVALID_PARM - any invalid parameters (< 0) + * PPRO_RC_EBUSY - If cb ia NULL and there is pending operation + * (< 0). Or, hardware buffer is full. + * PPRO_RC_EINPROGRESS - operation is pending (< 0) + * PPRO_RC_OK - operation completed successfully (= 0) + * + * + */ +int pka4xx_rshift(pka4xx_cb cb, + void *ctx, + u32 *op_id, + u32 input_cnt, + u32 *input, + u8 shift, + u32 *result); + +/** + * @brief Performs vector left shift (A << X = C) + * @param cb Callback function of asynchronous operation. If this + * parameter is NULL, then it will block until operation + * completed. As this function is called from interrupt + * context, it should defer complex operation and + * return as soon as possible. When there is pending + * operation, this parameter can not be NULL. + * @param ctx A void context pointer passed in cb function + * @param op_id An integer identifier pointer for asynchronous + * operation. It can be used to cancel pending operation. + * Can be NULL. + * @param input_cnt Length of input in DWORD unit (<= + * PKA4XX_VECTOR_MAXSIZE) + * @param input Input vector pointer of the operation - input A + * @param shift Shift value of the operation - input X. 0 <= shift <= 31 + * @param result Result vector pointer of the operation - output C + * @return PPRO_RC_INVALID_PARM - any invalid parameters (< 0) + * PPRO_RC_EBUSY - If cb ia NULL and there is pending operation + * (< 0). Or, hardware buffer is full. + * PPRO_RC_EINPROGRESS - operation is pending (< 0) + * PPRO_RC_OK - operation completed successfully (= 0) + * + * + */ +int pka4xx_lshift(pka4xx_cb cb, + void *ctx, + u32 *op_id, + u32 input_cnt, + u32 *input, + u8 shift, + u32 *result); + +/** + * @brief Performs vector comparsion (A < B, A == B, or A > B) + * @param cb Callback function of asynchronous operation. If this + * parameter is NULL, then it will block until operation + * completed. As this function is called from interrupt + * context, it should defer complex operation and + * return as soon as possible. When there is pending + * operation, this parameter can not be NULL. + * @param ctx A void context pointer passed in cb function + * @param op_id An integer identifier pointer for asynchronous + * operation. It can be used to cancel pending operation. + * Can be NULL. + * @param input1_cnt Length of input1 in DWORD unit (<= + * PKA4XX_VECTOR_MAXSIZE) + * @param input1 Input vector pointer of the operation - input A + * @param input2_cnt Length of input2 in DWORD unit (<= + * PKA4XX_VECTOR_MAXSIZE) + * @param input2 Input vector pointer of the operation - input B + * @param result Single result pointer to an unsigned char to store + * the result. 0 = A=B; -1 = A<B; 1 = A>B. + * @return PPRO_RC_INVALID_PARM - any invalid parameters (< 0) + * PPRO_RC_EBUSY - If cb ia NULL and there is pending operation + * (< 0). Or, hardware buffer is full. + * PPRO_RC_EINPROGRESS - operation is pending (< 0) + * PPRO_RC_OK - operation completed successfully (= 0) + * + * + */ +int pka4xx_compare(pka4xx_cb cb, + void *ctx, + u32 *op_id, + u32 input1_cnt, + u32 *input1, + u32 input2_cnt, + u32 *input2, + int *result); + +/** + * @brief Performs vector modular exponentiation operation - C^A % B = D where B + * is odd integer and > 2^32 and C < B + * @param cb Callback function of asynchronous operation. If this + * parameter is NULL, then it will block until operation + * completed. As this function is called from interrupt + * context, it should defer complext operation and + * return as soon as possible. When there is pending + * operation, this parameter can not be NULL. + * @param ctx A void context pointer passed in cb function + * @param op_id An integer identifier pointer for asynchronous + * operation. It can be used to cancel pending operation. + * Can be NULL. + * @param odd_pwr_cnt # of pre-calculated 'odd power'. For value of: + * 2 = ExpMod-ACT2 + * 8 = ExpMod-ACT4 + * 1,3,4,5,6,7,9..16 = ExpMod-variable + * 17...MAX = invalid parameter + * @param base_mod_cnt Length of base and modulus in DWORD unit (<= + * PKA4XX_VECTOR_MAXSIZE) + * @param base Base vector pointer of the operation - input C + * @param modulus Modulus vector pointer of the operation - input B + * @param exponent_cnt Length of exponent in DWORD unit (<= + * PKA4XX_VECTOR_MAXSIZE) + * @param exponent Exponent vector pointer of the operation - input A + * @param result Result vector pointer of the operation. Length is + * base_mod_cnt in DWORD unit. + * @return PPRO_RC_INVALID_PARM - any invalid parameters (< 0) + * PPRO_RC_EBUSY - If cb ia NULL and there is pending operation + * (< 0). Or, hardware buffer is full. + * PPRO_RC_EINPROGRESS - operation is pending (< 0) + * PPRO_RC_OK - operation completed successfully (= 0) + * + * @note Use of odd power > 8 is not advisable as the speed advantage for + * each extra odd power decreases rapidly (and even become negative for + * short exponent vector lengths due to the extra pre-processsing + * required). More odd power requires more PKA RAM which will decrease + * queue (setup) of pending operation for asynchronous operation. + * + * + */ +extern int pka4xx_expmod(pka4xx_cb cb, + void *ctx, + u32 *op_id, + u8 odd_pwr_cnt, + u32 base_mod_cnt, + u32 *base, + u32 *modulus, + u32 exponent_cnt, + u32 *exponent, + u32 *result); + +/** + * @brief Performs vector modular exponentiation with CRT operation (RSA-CRT) + * @param cb Callback function of asynchronous operation. If this + * parameter is NULL, then it will block until operation + * completed. As this function is called from interrupt + * context, it should defer complex operation and + * return as soon as possible. When there is pending + * operation, this parameter can not be NULL. + * @param ctx A void context pointer passed in cb function + * @param op_id An integer identifier pointer for asynchronous + * operation. It can be used to cancel pending operation. + * Can be NULL. + * @param odd_pwr_cnt # of pre-calculated 'odd power' (1-16) + * @param exp_len Length of exponent(s) in DWORD unit (<= + * PKA4XX_VECTOR_MAXSIZE) + * @param expP Exponent P vector pointer of the operation - input expP + * @param expQ Exponent Q vector pointer of the operation - input expQ + * @param mod_inverse_len Length of modulus(es), inverse in DWORD unit (<= + * PKA4XX_VECTOR_MAXSIZE) + * @param modP Modulus P vector pointer of the operation - input modP + * @param modQ Modulus Q vector pointer of the operation - input modQ + * @param inverseQ Inverse Q vector pointer of the operation - input + * inverseQ + * @param input Input vector pointer of the operation - input + * 'Input'. Input is 2*mod_inverse_len. + * @param result Result vector of the operation. Result is + * 2*mod_inverse_len. + * @return PPRO_RC_INVALID_PARM - any invalid parameters (< 0) + * PPRO_RC_EBUSY - If cb ia NULL and there is pending operation + * (< 0). Or, hardware buffer is full. + * PPRO_RC_EINPROGRESS - operation is pending (< 0) + * PPRO_RC_OK - operation completed successfully (= 0) + * + * @note CRT Formula Rewritten: + * + * X = (Input % modP)^expP % modP + * Y = (Input % modQ)^expQ % modP + * Z = (((X-Y) % modP) * inverseQ % modP) * modQ + * R = Y + Z + * inverseQ = modQ^-1 % modP + * expP = d^-1 % (modP - 1) + * expQ = d^-1 % (modQ - 1) + * + * where modP and modQ is odd and co-prime (GCD=1), modP > 2^32, + * modQ > 2^32, 0 < expP < modP - 1, 0 < expQ < modQ - 1, + * inverseQ * modP = 1, Input < (modP * modQ), and d is decrypt + * exponent. d can be calculated by d = e^-1 % (p - 1)(q - 1) where + * e is the encrypt exponent chosen such that it is prime and + * GCD(p - 1, q - 1) != e. + * + * + */ +int pka4xx_expmod_crt(pka4xx_cb cb, + void *ctx, + u32 *op_id, + u8 odd_pwr_cnt, + u32 exp_len, + u32 *expP, + u32 *expQ, + u32 mod_inverse_len, + u32 *modP, + u32 *modQ, + u32 *inverseQ, + u32 *input, + u32 *result); + +/** + * @brief Performs vector modular inversion operation - 1/A % B = D where B + * is odd integer and not 1. + * @param cb Callback function of asynchronous operation. If this + * parameter is NULL, then it will block until operation + * completed. As this function is called from interrupt + * context, it should defer complext operation and + * return as soon as possible. When there is pending + * operation, this parameter can not be NULL. + * @param ctx A void context pointer passed in cb function + * @param op_id An integer identifier pointer for asynchronous + * operation. It can be used to cancel pending operation. + * Can be NULL. + * @param inverse_len Length of inverse in DWORD unit (<= + * PKA4XX_VECTOR_MAXSIZE) + * @param inverse Inverse vector pointer of the operation - input A + * @param modulus_len Length of modulus in DWORD unit (<= + * PKA4XX_VECTOR_MAXSIZE) + * @param modulus Modulus vector pointer of the operation - input B + * @param result Result vector pointer of the operation - output B. + * Length is modulus_len in DWORD unit. + * @return PPRO_RC_INVALID_PARM - any invalid parameters (< 0) + * PPRO_RC_EBUSY - If cb ia NULL and there is pending operation + * (< 0). Or, hardware buffer is full. + * PPRO_RC_HWERROR - no inverse [GCD(A,B)=1] or modulus (B) even + * PPRO_RC_EINPROGRESS - operation is pending (< 0) + * PPRO_RC_OK - operation completed successfully (= 0) + * + * + */ +int pka4xx_modinv(pka4xx_cb cb, + void *ctx, + u32 *op_id, + u32 inverse_len, + u32 *inverse, + u32 modulus_len, + u32 *modulus, + u32 *result); + +/** + * @brief Performs vector ECC add operation (Point addition/doubling on elliptic + * curve) - y^2 = x^3 + a * x + b % p + * pntA + pntC = pntD + * where p is prime and > 2^63, a < p, b < p and pntA and pntC on curve + * + * @param cb Callback function of asynchronous operation. If this + * parameter is NULL, then it will block until operation + * completed. As this function is called from interrupt + * context, it should defer complext operation and + * return as soon as possible. When there is pending + * operation, this parameter can not be NULL. + * @param ctx A void context pointer passed in cb function + * @param op_id An integer identifier pointer for asynchronous + * operation. It can be used to cancel pending operation. + * Can be NULL. + * @param input_len Length of points, p, and a in DWORD unit + * (<= 24) + * @param pntAx Point Ax vector pointer of the operation - input pntAx + * @param pntAy Point Ay vector pointer of the operation - input pntAy + * @param p Curve parameter p pointer vector of the operation - + * input p + * @param a Constant a vector pointer of the operation - input a + * @param pntCx Point Cx vector pointer of the operation - input pntCx + * @param pntCy Point Cy vector pointer of the operation - input pntCy + * @param pntDx Result pointer Dx vector pointer of the operation. + * Length is input_len + 2 + (input_len % 2) in + * DWORD unit. + * @param pntDy Result pointer Dy vector pointer of the operation. + * Length is input_len + 2 + (input_len % 2) in + * DWORD unit. + * @return PPRO_RC_INVALID_PARM - any invalid parameters (< 0) + * PPRO_RC_EBUSY - If cb ia NULL and there is pending operation + * (< 0). Or, hardware buffer is full. + * PPRO_RC_HWERROR - result is "point-at-infinity" or p not odd, + * p too short, or etc + * PPRO_RC_EINPROGRESS - operation is pending (< 0) + * PPRO_RC_OK - operation completed successfully (= 0) + * + ******************************************************************************* + */ +int pka4xx_ecc_add(pka4xx_cb cb, + void *ctx, + u32 *op_id, + u32 input_len, + u32 *pntAx, + u32 *pntAy, + u32 *p, + u32 *a, + u32 *pntCx, + u32 *pntCy, + u32 *pntDx, + u32 *pntDy); + +/** + * @brief Performs vector ECC multiply operation (Point multiplicatio on + * elliptic curve) - y^2 = x^3 + a * x + b % p + * k * pntC = pntD + * where p is prime and > 2^63, a < p, b < p and pntA and pntC on curve + * + * @param cb Callback function of asynchronous operation. If this + * parameter is NULL, then it will block until operation + * completed. As this function is called from interrupt + * context, it should defer complext operation and + * return as soon as possible. When there is pending + * operation, this parameter can not be NULL. + * @param ctx A void context pointer passed in cb function + * @param op_id An integer identifier pointer for asynchronous + * operation. It can be used to cancel pending operation. + * Can be NULL. + * @param k_len Length of k constant in DWORD unit (<= 24) + * @param k Constant k vector pointer of the operation - input k + * @param p_len Length of p in DWORD unit (p_len + a_len + b_len <= 24) + * @param p Curve parameter p vector of the operation - input p + * @param a_len Length of a in DWORD unit (p_len + a_len + b_len <= 24) + * @param a Constant a vector of the operation - input a + * @param b_len Length of b in DWORD unit (p_len + a_len + b_len <= 24) + * @param b Constant b vector of the operation - input b + * @param pntCx Point Cx vector pointer of the operation - input pntCx. + * Length is p_len + a_len + b_len in DWORD unit. + * @param pntCy Point Cy vector pointer of the operation - input pntCy. + * Length is p_len + a_len + b_len in DWORD unit. + * @param result Result vector pointer of the operation. Length is + * 2 * (p_len + a_len + 2 + ((p_len+a_len) % 2)) in + * DWORD unit. The first one for pntDx and second for + * pntDy. + * @return PPRO_RC_INVALID_PARM - any invalid parameters (< 0) + * PPRO_RC_EBUSY - If cb ia NULL and there is pending operation + * (< 0). Or, hardware buffer is full. + * PPRO_RC_HWERROR - result is "point-at-infinity" or p not odd, + * p too short, or etc + * PPRO_RC_EINPROGRESS - operation is pending (< 0) + * PPRO_RC_OK - operation completed successfully (= 0) + * + ******************************************************************************* + */ +int pka4xx_ecc_mul(pka4xx_cb cb, + void *ctx, + u32 *op_id, + u32 k_len, + u32 *k, + u32 p_a_pnt_len, + u32 *p, + u32 *a, + u32 *b, + u32 *pntCx, + u32 *pntCy, + u32 *pntDx, + u32 *pntDy); + +#endif |