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