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