1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2019 Fuzhou Rockchip Electronics Co., Ltd 4 */ 5 6 #ifndef _ROCKCHIP_CRYPTO_V2_PKA_H_ 7 #define _ROCKCHIP_CRYPTO_V2_PKA_H_ 8 #include <common.h> 9 #include <rockchip/crypto_v2.h> 10 #include <rockchip/crypto_v2_util.h> 11 12 #define CRYPTO_BASE crypto_base 13 14 #define MPA_USE_ALLOC 1 15 16 struct mpa_num { 17 u32 alloc; 18 s32 size; 19 u32 *d; 20 }; 21 22 #define RK_MAX_RSA_NBITS 4096 23 #define RK_MAX_RSA_NCHARS ((RK_MAX_RSA_NBITS) / 8) 24 #define RK_MAX_RSA_BWORDS ((RK_MAX_RSA_NBITS) / 32) 25 26 /* define NpCreateFlag values */ 27 #define RK_PKA_CREATE_NP 1 28 #define RK_PKA_SET_NP 0 29 /* size of buffer for Barrett modulus tag NP, used in PKI algorithms */ 30 #define RK_PKA_BARRETT_IN_WORDS 5 31 /* Barrett modulus tag type - 5 words size array */ 32 typedef u32 RK_PKA_NP_t[RK_PKA_BARRETT_IN_WORDS]; 33 34 #define RK_PKA_MemSetZero(buf, size) \ 35 util_word_memset((void *)buf, 0x00, size) 36 37 #define RK_PKA_FastMemCpy(dst, src, size) \ 38 util_word_memcpy((void *)dst, (void *)src, size) 39 40 #define RK_PKA_ReverseMemcpy(dst, src, size) \ 41 util_reverse_word_memcpy((void *)dst, (void *)src, size) 42 43 #define RES_DISCARD 0x3F 44 45 /* base address - 0x00F10B00 */ 46 #define RK_PKI_ERROR_BASE 0x00F10B00 47 #define RK_PKI_HW_VER_INCORRECT_ERROR (RK_PKI_ERROR_BASE + 0x0UL) 48 #define RK_PKI_HW_DECRYPED_ERROR (RK_PKI_ERROR_BASE + 0x1UL) 49 #define RK_PKI_KEY_SIZE_ERROR (RK_PKI_ERROR_BASE + 0x2UL) 50 51 /* Error definitions for PKA using */ 52 #define RK_PKA_ILLEGAL_PTR_ERROR (RK_PKI_ERROR_BASE + 0x20UL) 53 #define RK_PKA_ENTRIES_COUNT_ERROR (RK_PKI_ERROR_BASE + 0x21UL) 54 #define RK_PKA_REGISTER_SIZES_ERROR (RK_PKI_ERROR_BASE + 0x22UL) 55 #define RK_PKA_SET_MAP_MODE_ERROR (RK_PKI_ERROR_BASE + 0x23UL) 56 57 #define RK_PKA_DIVIDER_IS_NULL_ERROR (RK_PKI_ERROR_BASE + 0x2EUL) 58 #define RK_PKA_MODULUS_IS_NULL_ERROR (RK_PKI_ERROR_BASE + 0x2FUL) 59 #define RK_PKA_DATA_SIZE_ERROR (RK_PKI_ERROR_BASE + 0x30UL) 60 #define RK_PKA_OPERATION_SIZE_ERROR (RK_PKI_ERROR_BASE + 0x31UL) 61 62 #define RK_PKA_MAX_REGS_COUNT 8 63 #define RK_PKA_MAX_PHYS_MEM_REGS_COUNT 32 64 #define RK_PKA_MAX_REGS_MEM_SIZE_BYTES 4096 65 66 /* PKA control values */ 67 #define RK_PKA_PIPE_READY 1 68 #define RK_PKA_OP_DONE 1 69 #define RK_PKA_SW_REST 1 70 71 /* PKA N_NP_T0_T1 register fields positions (low bit position) */ 72 #define RK_PKA_N_NP_T0_T1_REG_N_POS CRYPTO_N_VIRTUAL_ADDR_SHIFT 73 #define RK_PKA_N_NP_T0_T1_REG_NP_POS CRYPTO_NP_VIRTUAL_ADDR_SHIFT 74 #define RK_PKA_N_NP_T0_T1_REG_T0_POS CRYPTO_T0_VIRTUAL_ADDR_SHIFT 75 #define RK_PKA_N_NP_T0_T1_REG_T1_POS CRYPTO_T1_VIRTUAL_ADDR_SHIFT 76 77 /* PKA N_NP_T0_T1 register default (reset) value: N=0, NP=1, T0=30, T1=31 */ 78 #define PKA_N 0UL 79 #define PKA_NP 1UL 80 #define PKA_T0 30UL 81 #define PKA_T1 31UL 82 #define RK_PKA_N_NP_T0_T1_REG_DEFAULT_VAL \ 83 (PKA_N << RK_PKA_N_NP_T0_T1_REG_N_POS | \ 84 PKA_NP << RK_PKA_N_NP_T0_T1_REG_NP_POS | \ 85 PKA_T0 << RK_PKA_N_NP_T0_T1_REG_T0_POS | \ 86 PKA_T1 << RK_PKA_N_NP_T0_T1_REG_T1_POS) 87 88 /* PKA STATUS register fields positions (low bit position) */ 89 #define RK_PKA_STATUS_PIPE_IS_REDY_POS 0 90 #define RK_PKA_STATUS_PKA_BUSY_POS 1 91 #define RK_PKA_STATUS_ALU_OUT_ZERO_POS 2 92 #define RK_PKA_STATUS_ALU_MODOVRFLW_POS 3 93 #define RK_PKA_STATUS_DIV_BY_ZERO_POS 4 94 #define RK_PKA_STATUS_ALU_CARRY_POS 5 95 #define RK_PKA_STATUS_ALU_SIGN_OUT_POS 6 96 #define RK_PKA_STATUS_MODINV_OF_ZERO_POS 7 97 #define RK_PKA_STATUS_PKA_CPU_BUSY_POS 8 98 #define RK_PKA_STATUS_OPCODE_POS 9 99 #define RK_PKA_STATUS_TAG_POS 14 100 101 #define RK_PKA_STATUS_OPCODE_MASK 0x1FUl 102 #define RK_PKA_STATUS_TAG_MASK 0x3FUl 103 104 /* PKA OPCODE register fields positions (low bit position) */ 105 #define RK_PKA_OPCODE_TAG_POS 0 106 #define RK_PKA_OPCODE_RESULT_POS 6 107 #define RK_PKA_OPCODE_R_DISCARD_POS 11 108 #define RK_PKA_OPCODE_OPERAND_2_POS 12 109 #define RK_PKA_OPCODE_OPERAND_2_IMMED_POS 17 110 #define RK_PKA_OPCODE_OPERAND_1_POS 18 111 #define RK_PKA_OPCODE_OPERAND_1_IMMED_POS 23 112 #define RK_PKA_OPCODE_LEN_POS 24 113 #define RK_PKA_OPCODE_OPERATION_ID_POS 27 114 115 /* PKA data registers base address 116 *should be always zero since it's the offset 117 * from the start of the PKA memory and not from the HOST memory 118 */ 119 #define RK_PKA_DATA_REGS_BASE_ADDR (CRYPTO_BASE + CRYPTO_SRAM_BASE) 120 #define RK_PKA_DATA_REGS_MEMORY_OFFSET_ADDR (CRYPTO_BASE + CRYPTO_SRAM_BASE) 121 122 /* Machine Opcodes definitions (according to HW CRS ) */ 123 #define RK_PKA_MIN_OPCODE 0x00 124 125 #define PKA_Add 0x04 126 #define PKA_AddIm 0x04 127 #define PKA_Sub 0x05 128 #define PKA_SubIm 0x05 129 #define PKA_Neg 0x05 130 #define PKA_ModAdd 0x06 131 #define PKA_ModAddIm 0x06 132 #define PKA_ModSub 0x07 133 #define PKA_ModSubIm 0x07 134 #define PKA_ModNeg 0x07 135 #define PKA_AND 0x08 136 #define PKA_Test0 0x08 137 #define PKA_Clr0 0x08 138 #define PKA_Clr 0x08 139 #define PKA_OR 0x09 140 #define PKA_Copy 0x09 141 #define PKA_SetBit0 0x09 142 #define PKA_XOR 0x0A 143 #define PKA_Flip0 0x0A 144 #define PKA_InvertBits 0x0A 145 #define PKA_Compare 0x0A 146 #define PKA_SHR0 0x0C 147 #define PKA_SHR1 0x0D 148 #define PKA_SHL0 0x0E 149 #define PKA_SHL1 0x0F 150 #define PKA_LMul 0x10 151 #define PKA_ModMul 0x11 152 #define PKA_ModMulNR 0x12 153 #define PKA_ModExp 0x13 154 #define PKA_Div 0x14 155 #define PKA_ModInv 0x15 156 #define PKA_ModDiv 0x16 157 #define PKA_HMul 0x17 158 #define PKA_Terminate 0x00 159 160 #define RK_PKA_MAX_OPCODE 0x17 161 162 /*************************************************************/ 163 /* Macros for waiting PKA machine ready states */ 164 /*************************************************************/ 165 166 void rk_pka_ram_ctrl_enable(void); 167 168 void rk_pka_ram_ctrl_disable(void); 169 170 void rk_pka_wait_on_ram_ready(void); 171 172 void rk_pka_wait_on_pipe_ready(void); 173 174 void rk_pka_wait_on_done(void); 175 176 /***************************************************** 177 * Macros for controlling PKA machine and changing * 178 * PKA sizes table and mapping table settings. * 179 *****************************************************/ 180 #define PKA_CLK_ENABLE() 181 182 #define PKA_CLK_DISABLE() 183 184 void rk_pka_set_startmemaddr_reg(u32 start_mem_addr); 185 186 void rk_pka_set_N_NP_T0_T1_reg(u32 N, u32 NP, u32 T0, u32 T1); 187 188 void rk_pka_set_default_N_NP_T0_T1_reg(void); 189 190 void rk_pka_get_status(u32 *status); 191 192 void rk_pka_get_status_alu_outzero(u32 *status); 193 194 void rk_pka_get_status_mod_overfl(u32 *status); 195 196 void rk_pka_get_status_div_byzero(u32 *status); 197 198 void rk_pka_get_status_carry(u32 *status); 199 200 void rk_pka_get_status_alu_signout(u32 *status); 201 202 void rk_pka_get_status_modinv_ofzero(u32 *status); 203 204 void rk_pka_get_status_opcode(u32 *status); 205 206 void rk_pka_get_status_tag(u32 *status); 207 208 /****************************************************************** 209 * Macros for setting and reading sizes from PKA regsSizesTable * 210 ******************************************************************/ 211 void rk_pka_set_regsize(u32 size_bits, u32 entry_num); 212 213 void rk_pka_read_regsize(u32 *size_bits, u32 entry_num); 214 215 /****************************************************************** 216 * Macros for setting and reading addresses of PKA data registers * 217 ******************************************************************/ 218 void rk_pka_set_regaddr(u32 vir_reg, u32 phys_addr); 219 220 void rk_pka_get_regaddr(u32 vir_reg, u32 *phys_addr); 221 222 void rk_pka_read_regaddr(u32 vir_reg, u32 *phys_addr); 223 224 /********************************************** 225 * Macros for setting Full PKI opcode * 226 **********************************************/ 227 u32 rk_pka_make_full_opcode(u32 opcode, u32 len_id, 228 u32 is_a_immed, u32 op_a, 229 u32 is_b_immed, u32 op_b, 230 u32 res_discard, u32 res, 231 u32 tag); 232 233 /****************************************************** 234 * Macros for reading and loading PKA memory data * 235 ******************************************************/ 236 void rk_pka_hw_load_value2pka_mem(u32 addr, u32 val); 237 238 void rk_pka_hw_load_block2pka_mem(u32 addr, u32 *ptr, 239 u32 size_words); 240 241 void rk_pka_hw_reverse_load_block2pka_mem(u32 addr, u32 *ptr, 242 u32 size_words); 243 244 void rk_pka_hw_clear_pka_mem(u32 addr, u32 size_words); 245 246 void rk_pka_hw_read_value_from_pka_mem(u32 addr, u32 *val); 247 248 void rk_pka_hw_read_block_from_pka_mem(u32 addr, u32 *ptr, 249 u32 size_words); 250 251 void rk_pka_hw_reverse_read_block_from_pka_mem(u32 addr, u32 *ptr, 252 u32 size_words); 253 254 u32 rk_pka_exec_operation(u32 opcode, u8 len_id, 255 u8 is_a_immed, s8 op_a, 256 u8 is_b_immed, s8 op_b, 257 u8 res_discard, s8 res, u8 tag); 258 259 /************************************************************************* 260 * Macros for calling PKA operations (names according to operation issue * 261 *************************************************************************/ 262 263 /*--------------------------------------*/ 264 /* 1. ADD - SUBTRACT operations */ 265 /*--------------------------------------*/ 266 /* Add: res = op_a + op_b */ 267 #define RK_PKA_Add(len_id, op_a, op_b, res, tag) \ 268 rk_pka_exec_operation(PKA_Add, (len_id), 0, (op_a),\ 269 0, (op_b), 0, (res), (tag)) 270 271 /* AddIm: res = op_a + op_b_im */ 272 #define RK_PKA_AddIm(len_id, op_a, op_b_im, res, tag) \ 273 rk_pka_exec_operation(PKA_Add, (len_id), 0, (op_a), \ 274 1, (op_b_im), 0, (res), (tag)) 275 276 /* Sub: res = op_a - op_b */ 277 #define RK_PKA_Sub(len_id, op_a, op_b, res, tag) \ 278 rk_pka_exec_operation(PKA_Sub, (len_id), 0, (op_a), \ 279 0, (op_b), 0, (res), (tag)) 280 281 /* SubIm: res = op_a - op_b_im */ 282 #define RK_PKA_SubIm(len_id, op_a, op_b_im, res, tag) \ 283 rk_pka_exec_operation(PKA_Sub, (len_id), 0, (op_a), \ 284 1, (op_b_im), 0, (res), (tag)) 285 286 /* Neg: res = 0 - op_b */ 287 #define RK_PKA_Neg(len_id, op_b, res, tag) \ 288 rk_pka_exec_operation(PKA_Sub, (len_id), 1, 0, \ 289 0, (op_b), 0, (res), (tag)) 290 291 /* ModAdd: res = (op_a + op_b) mod N */ 292 #define RK_PKA_ModAdd(len_id, op_a, op_b, res, tag) \ 293 rk_pka_exec_operation(PKA_ModAdd, (len_id), 0, (op_a), \ 294 0, (op_b), 0, (res), (tag)) 295 296 /* ModAddIm: res = (op_a + op_b_im) mod N */ 297 #define RK_PKA_ModAddIm(len_id, op_a, op_b_im, res, tag) \ 298 rk_pka_exec_operation(PKA_ModAdd, (len_id), 0, (op_a), \ 299 1, (op_b_im), 0, (res), (tag)) 300 301 /* ModSub: res = (op_a - op_b) mod N */ 302 #define RK_PKA_ModSub(len_id, op_a, op_b, res, tag) \ 303 rk_pka_exec_operation(PKA_ModSub, (len_id), 0, (op_a), \ 304 0, (op_b), 0, (res), (tag)) 305 306 /* ModSubIm: res = (op_a - op_b_im) mod N */ 307 #define RK_PKA_ModSubIm(len_id, op_a, op_b_im, res, tag) \ 308 rk_pka_exec_operation(PKA_ModSub, (len_id), 0, (op_a), \ 309 1, (op_b_im), 0, (res), (tag)) 310 311 /* ModNeg: res = (0 - op_b) mod N */ 312 #define RK_PKA_ModNeg(len_id, op_b, res, tag) \ 313 rk_pka_exec_operation(PKA_ModSub, (len_id), 1, 0, \ 314 0, (op_b), 0, (res), (tag)) 315 316 /*--------------------------------------*/ 317 /* 2. Logical operations */ 318 /*--------------------------------------*/ 319 320 /* AND: res = op_a & op_b */ 321 #define RK_PKA_AND(len_id, op_a, op_b, res, tag) \ 322 rk_pka_exec_operation(PKA_AND, (len_id), 0, (op_a), \ 323 0, (op_b), 0, (res), (tag)) 324 325 /* AndIm: res = op_a & op_b */ 326 #define RK_PKA_AndIm(len_id, op_a, op_b, res, tag) \ 327 rk_pka_exec_operation(PKA_AND, (len_id), 0, (op_a), \ 328 1, (op_b), 0, (res), (tag)) 329 330 /* Tst0: op_a & 0x1 - tests the bit 0 of operand A. */ 331 /* If bit0 = 0, then ZeroOfStatus = 1, else 0 */ 332 #define RK_PKA_Tst0(len_id, op_a, tag) \ 333 rk_pka_exec_operation(PKA_AND, (len_id), 0, (op_a), \ 334 1, 0x01, 1, RES_DISCARD, (tag)) 335 336 /* Clr0: res = op_a & (-2) - clears the bit 0 of operand A. */ 337 /* Note: -2 = 0x1E for 5-bit size */ 338 #define RK_PKA_Clr0(len_id, op_a, res, tag) \ 339 rk_pka_exec_operation(PKA_AND, (len_id), 0, (op_a), \ 340 1, 0x1E, 0, (res), (tag)) 341 342 /* Clr: res = op_a & 0 - clears the operand A. */ 343 #define RK_PKA_Clr(len_id, op_a, tag) \ 344 rk_pka_exec_operation(PKA_AND, (len_id), 0, (op_a), \ 345 1, 0x00, 0, (op_a), (tag)) 346 347 /* Clear: for full clearing the actual register op_a, 348 * this macro calls Clr operation twice. 349 */ 350 #define RK_PKA_Clear(len_id, op_a, tag) \ 351 RK_PKA_Clr(len_id, op_a, tag) 352 353 /* OR: res = op_a || op_b */ 354 #define RK_PKA_OR(len_id, op_a, op_b, res, tag) \ 355 rk_pka_exec_operation(PKA_OR, (len_id), 0, (op_a), \ 356 0, (op_b), 0, (res), (tag)) 357 358 /* OrIm: res = op_a || op_b */ 359 #define RK_PKA_OrIm(len_id, op_a, op_b, res, tag) \ 360 rk_pka_exec_operation(PKA_OR, (len_id), 0, (op_a), \ 361 1, (op_b), 0, (res), (tag)) 362 363 /* Copy: OpDest = OpSrc || 0 */ 364 #define RK_PKA_Copy(len_id, op_dest, op_src, tag) \ 365 rk_pka_exec_operation(PKA_OR, (len_id), 0, (op_src), \ 366 1, 0x00, 0, (op_dest), (tag)) 367 368 /* Set0: res = op_a || 1 : set bit0 = 1, other bits are not changed */ 369 #define RK_PKA_Set0(len_id, op_a, res, tag) \ 370 rk_pka_exec_operation(PKA_OR, (len_id), 0, (op_a), \ 371 1, 0x01, 0, (res), (tag)) 372 373 /* Xor: res = op_a ^ op_b */ 374 #define RK_PKA_Xor(len_id, op_a, op_b, res, tag) \ 375 rk_pka_exec_operation(PKA_XOR, (len_id), 0, (op_a), \ 376 0, (op_b), 0, (res), (tag)) 377 378 /* XorIm: res = op_a ^ op_b */ 379 #define RK_PKA_XorIm(len_id, op_a, op_b, res, tag) \ 380 rk_pka_exec_operation(PKA_XOR, (len_id), 0, (op_a), \ 381 1, (op_b), 0, (res), (tag)) 382 383 /* Flip0: res = op_a || 1 - inverts the bit 0 of operand A */ 384 #define RK_PKA_Flip0(len_id, op_a, res, tag) \ 385 rk_pka_exec_operation(PKA_XOR, (len_id), 0, (op_a), \ 386 1, 0x01, 0, (res), (tag)) 387 388 /* Invert: res = op_a ^ 0xFFF.FF : inverts all bits of op_a . */ 389 /* Note: 0xFFFFF = 0x1F for 5 bits size of second operand */ 390 #define RK_PKA_Invert(len_id, op_a, res, tag) \ 391 rk_pka_exec_operation(PKA_XOR, (len_id), 0, (op_a), \ 392 1, 0x1F, 0, (res), (tag)) 393 394 /* Compare: op_a ^ op_b . Rsult of compare in ZeroBitOfStatus: */ 395 /* If op_a == op_b then Z = 1 */ 396 #define RK_PKA_Compare(len_id, op_a, op_b, tag) \ 397 rk_pka_exec_operation(PKA_XOR, (len_id), 0, (op_a), \ 398 0, (op_b), 1, (0), (tag)) 399 400 /* CompareImmediate: op_a ^ op_b . Rsult of compare in ZeroBitOfStatus: */ 401 /* If op_a == op_b then status Z = 1 */ 402 #define RK_PKA_CompareIm(len_id, op_a, op_b, tag) \ 403 rk_pka_exec_operation(PKA_XOR, (len_id), 0, (op_a), \ 404 1, (op_b), 1, (0), (tag)) 405 406 /*----------------------------------------------*/ 407 /* 3. SHIFT operations */ 408 /*----------------------------------------------*/ 409 410 /* SHR0: res = op_a >> (S+1) : 411 * shifts right operand A by S+1 bits, insert 0 to left most bits 412 */ 413 #define RK_PKA_SHR0(len_id, op_a, S, res, tag) \ 414 rk_pka_exec_operation(PKA_SHR0, (len_id), 0, (op_a), \ 415 0, (S), 0, (res), (tag)) 416 417 /* SHR1: res = op_a >> (S+1) : 418 * shifts right operand A by S+1 bits, insert 1 to left most bits 419 */ 420 #define RK_PKA_SHR1(len_id, op_a, S, res, tag) \ 421 rk_pka_exec_operation(PKA_SHR1, (len_id), 0, (op_a), \ 422 0, (S), 0, (res), (tag)) 423 424 /* SHL0: res = op_a << (S+1) : 425 * shifts left operand A by S+1 bits, insert 0 to right most bits 426 */ 427 #define RK_PKA_SHL0(len_id, op_a, S, res, tag) \ 428 rk_pka_exec_operation(PKA_SHL0, (len_id), 0, (op_a), \ 429 0, (S), 0, (res), (tag)) 430 431 /* SHL1: res = op_a << (S+1) : 432 * shifts left operand A by S+1 bits, insert 1 to right most bits 433 */ 434 #define RK_PKA_SHL1(len_id, op_a, S, res, tag) \ 435 rk_pka_exec_operation(PKA_SHL1, (len_id), 0, (op_a), \ 436 0, (S), 0, (res), (tag)) 437 438 /*--------------------------------------------------------------*/ 439 /* 2. Multiplication and other operations */ 440 /* Note: See notes to RK_PKAExecOperation */ 441 /*--------------------------------------------------------------*/ 442 443 /* RMul: res = LowHalfOf(op_a * op_b), where size of operands and result 444 * is equaled to operation size, defined by len_id. Note: for receiving 445 * full result, the len_id must be set according to (sizeA + sizeB) and 446 * leading not significant bits of operands must be zeroed 447 */ 448 #define RK_PKA_LMul(len_id, op_a, op_b, res, tag) \ 449 rk_pka_exec_operation(PKA_LMul, (len_id), 0, (op_a), \ 450 0, (op_b), 0, (res), (tag)) 451 452 /* HMul: res = HighHalfOf(op_a * op_b) + one high word of low half of 453 * (op_a * op_b), where size of operands is equaled to operation size, 454 * defined by len_id. Note: Size of operation result is by one word large, 455 * than operation size 456 */ 457 #define RK_PKA_HMul(len_id, op_a, op_b, res, tag) \ 458 rk_pka_exec_operation(PKA_HMul, (len_id), 0, (op_a), \ 459 0, (op_b), 0, (res), (tag)) 460 461 /* ModMul: res = op_a * op_b mod N - modular multiplication */ 462 #define RK_PKA_ModMul(len_id, op_a, op_b, res, tag) \ 463 rk_pka_exec_operation(PKA_ModMul, (len_id), 0, (op_a), \ 464 0, (op_b), 0, (res), (tag)) 465 466 /* ModMulN: res = op_a * op_b mod N 467 * - modular multiplication (final reduction is omitted) 468 */ 469 #define RK_PKA_ModMulN(len_id, op_a, op_b, res, tag) \ 470 rk_pka_exec_operation(PKA_ModMulNR, (len_id), 0, \ 471 (op_a), 0, (op_b), 0, \ 472 (res), (tag)) 473 474 /* ModExp: res = op_a ** op_b mod N - modular exponentiation */ 475 #define RK_PKA_ModExp(len_id, op_a, op_b, res, tag) \ 476 rk_pka_exec_operation(PKA_ModExp, (len_id), 0, (op_a), \ 477 0, (op_b), 0, (res), (tag)) 478 479 /* Divide: res = op_a / op_b , op_a = op_a mod op_b - division, */ 480 #define RK_PKA_Div(len_id, op_a, op_b, res, tag) \ 481 rk_pka_exec_operation(PKA_Div, (len_id), 0, (op_a), \ 482 0, (op_b), 0, (res), (tag)) 483 484 /* ModInv: Modular inversion: calculates res = 1/op_b mod N */ 485 #define RK_PKA_ModInv(len_id, op_b, res, tag) \ 486 rk_pka_exec_operation(PKA_ModInv, (len_id), 0, 1, \ 487 0, (op_b), 0, (res), (tag)) 488 #define RK_PKA_ModDiv(len_id, op_a, op_b, res, tag) \ 489 rk_pka_exec_operation(PKA_ModDiv, (len_id), 0, (op_a), \ 490 0, (op_b), 0, (res), (tag)) 491 492 /* Terminate - special operation, which allows HOST access */ 493 /* to PKA data memory registers after end of PKA operations */ 494 #define RK_PKA_Terminate(tag) \ 495 rk_pka_exec_operation(PKA_Terminate, 0, 0, 0, 0, \ 496 0, 0, 0, (tag)) 497 498 struct rk_pka_regs_map { 499 u32 reges_num[RK_PKA_MAX_PHYS_MEM_REGS_COUNT]; 500 u32 regs_addr[RK_PKA_MAX_PHYS_MEM_REGS_COUNT]; 501 }; 502 503 u32 rk_pka_set_sizes_tab(u32 regs_sizes_ptr[RK_PKA_MAX_REGS_COUNT], 504 u32 count_of_sizes, 505 u32 max_size_bits, 506 u32 is_default_map); 507 508 #define RK_PKA_DefaultSetRegsSizesTab(max_size_bits) \ 509 rk_pka_set_sizes_tab(0, 0, (max_size_bits), 1) 510 u32 rk_pka_set_map_tab(struct rk_pka_regs_map *regs_map_ptr, u32 *count_of_regs, 511 u32 maxsize_words, u32 N_NP_T0_T1, 512 u32 is_default_map); 513 514 #define RK_PKA_DefaultSetRegsMapTab(maxsize_words, count_of_regs) \ 515 rk_pka_set_map_tab(NULL, (count_of_regs), \ 516 (maxsize_words), 0, 1) 517 518 u32 rk_pka_clear_block_of_regs(u8 first_reg, u8 count_of_regs, u8 len_id); 519 520 u32 rk_pka_init(u32 regs_sizes_ptr[RK_PKA_MAX_REGS_COUNT], 521 u32 count_of_sizes, 522 struct rk_pka_regs_map *regs_map_ptr, 523 u32 count_of_regs, 524 u32 op_size_bits, 525 u32 regsize_words, 526 u32 N_NP_T0_T1, 527 u32 is_default_map); 528 #define RK_PKA_DefaultInitPKA(max_size_bits, regsize_words) \ 529 rk_pka_init(0, 0, 0, 0, (max_size_bits), \ 530 (regsize_words), 0, 1) 531 532 void rk_pka_finish(void); 533 u32 rk_pka_calcNp_and_initmodop(u32 len_id, u32 mod_size_bits, 534 s8 r_t0, s8 r_t1, s8 r_t2); 535 536 u32 rk_pka_div_long_num(u8 len_id, s8 op_a, u32 s, s8 op_b, 537 s8 res, s8 r_t1, s8 r_t2); 538 539 u32 rk_calcNp_and_initmodop(u32 *N_ptr, u32 N_size_bits, 540 u32 *NP_ptr, u8 np_create_flag, 541 s8 r_t0, s8 r_t1, s8 r_t2); 542 543 void rk_pka_copy_data_into_reg(s8 dst_reg, u8 len_id, u32 *src_ptr, 544 u32 size_words); 545 void rk_pka_copy_data_from_reg(u32 *dst_ptr, u32 size_words, 546 s8 src_reg); 547 int test_rk3326_rsa(void); 548 int rk_mpa_alloc(struct mpa_num **mpa, void *data, u32 word_size); 549 void rk_mpa_free(struct mpa_num **mpa); 550 int rk_abs_add(void *a, void *b, void *c); 551 int rk_mod(void *a, void *b, void *c); 552 int rk_exptmod(void *a, void *b, void *c, void *d); 553 int rk_exptmod_np(void *m, void *e, void *n, void *np, void *d); 554 555 #endif 556