Skip to content

Commit d53641b

Browse files
ccli8cmonr
ccli8
authored and
cmonr
committed
Remove mbedtls prefix for internal functions in ECP alter.
1 parent 8c18a90 commit d53641b

File tree

1 file changed

+67
-67
lines changed

1 file changed

+67
-67
lines changed

‎features/mbedtls/targets/TARGET_NUVOTON/TARGET_M480/ecp/ecp_internal_alt.c

Lines changed: 67 additions & 67 deletions
Original file line numberDiff line numberDiff line change
@@ -88,7 +88,7 @@
8888
* \return 0 if not normalized,
8989
* 1 if normalized
9090
*/
91-
#define MBEDTLS_INTERNAL_MPI_IS_NORM(N, P) \
91+
#define INTERNAL_MPI_IS_NORM(N, P) \
9292
((mbedtls_mpi_cmp_int(&N, 0) >= 0) && (mbedtls_mpi_cmp_mpi(&N, &P) < 0))
9393

9494

@@ -100,9 +100,9 @@
100100
* \param N2 Output MPI which holds normalized N1 if N1 is not normalized yet
101101
* \param P Prime modulus
102102
*/
103-
#define MBEDTLS_INTERNAL_MPI_NORM(R, N1, N2, P) \
103+
#define INTERNAL_MPI_NORM(R, N1, N2, P) \
104104
do { \
105-
if (MBEDTLS_INTERNAL_MPI_IS_NORM(N1, P)) { \
105+
if (INTERNAL_MPI_IS_NORM(N1, P)) { \
106106
*R = &N1; \
107107
} else { \
108108
MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&N2, &N1, &P)); \
@@ -139,13 +139,13 @@
139139
* n is kept with unused modifier.
140140
*
141141
*/
142-
int mbedtls_internal_run_eccop(const mbedtls_ecp_group *grp,
143-
mbedtls_ecp_point *R,
144-
const mbedtls_mpi *m,
145-
const mbedtls_ecp_point *P,
146-
MBED_UNUSED const mbedtls_mpi *n,
147-
const mbedtls_ecp_point *Q,
148-
uint32_t eccop);
142+
int internal_run_eccop(const mbedtls_ecp_group *grp,
143+
mbedtls_ecp_point *R,
144+
const mbedtls_mpi *m,
145+
const mbedtls_ecp_point *P,
146+
MBED_UNUSED const mbedtls_mpi *n,
147+
const mbedtls_ecp_point *Q,
148+
uint32_t eccop);
149149

150150
/**
151151
* \brief Configure MODOP operation and wait for its completion
@@ -165,7 +165,7 @@ int mbedtls_internal_run_eccop(const mbedtls_ecp_group *grp,
165165
*
166166
* \note o1/o2 must be normalized (within [0, p - 1]). r would be normalized.
167167
*/
168-
int mbedtls_internal_run_modop(mbedtls_mpi *r,
168+
int internal_run_modop(mbedtls_mpi *r,
169169
const mbedtls_mpi *o1,
170170
const mbedtls_mpi *o2,
171171
const mbedtls_mpi *p,
@@ -183,7 +183,7 @@ int mbedtls_internal_run_modop(mbedtls_mpi *r,
183183
*
184184
* \note Destination MPI is always non-negative.
185185
*/
186-
static int mbedtls_internal_mpi_read_eccreg( mbedtls_mpi *X, const volatile uint32_t *eccreg, size_t eccreg_num );
186+
static int internal_mpi_read_eccreg( mbedtls_mpi *X, const volatile uint32_t *eccreg, size_t eccreg_num );
187187

188188
/**
189189
* \brief Export X into ECC registers, little endian
@@ -197,7 +197,7 @@ static int mbedtls_internal_mpi_read_eccreg( mbedtls_mpi *X, const volatile uint
197197
* \note Source MPI cannot be negative.
198198
* \note Fills the remaining MSB ECC registers with zeros if X doesn't cover all.
199199
*/
200-
static int mbedtls_internal_mpi_write_eccreg( const mbedtls_mpi *X, volatile uint32_t *eccreg, size_t eccreg_num );
200+
static int internal_mpi_write_eccreg( const mbedtls_mpi *X, volatile uint32_t *eccreg, size_t eccreg_num );
201201

202202
unsigned char mbedtls_internal_ecp_grp_capable( const mbedtls_ecp_group *grp )
203203
{
@@ -289,7 +289,7 @@ int mbedtls_internal_ecp_add_mixed( const mbedtls_ecp_group *grp,
289289
}
290290

291291
/* Run ECC point addition: R = P + Q */
292-
MBEDTLS_MPI_CHK(mbedtls_internal_run_eccop(grp, R, NULL, &P_, NULL, &Q_, ECCOP_POINT_ADD));
292+
MBEDTLS_MPI_CHK(internal_run_eccop(grp, R, NULL, &P_, NULL, &Q_, ECCOP_POINT_ADD));
293293

294294
cleanup:
295295

@@ -327,7 +327,7 @@ int mbedtls_internal_ecp_double_jac( const mbedtls_ecp_group *grp,
327327
MBEDTLS_MPI_CHK(mbedtls_internal_ecp_normalize_jac(grp, &P_));
328328

329329
/* Run ECC point doubling: R = 2*P */
330-
MBEDTLS_MPI_CHK(mbedtls_internal_run_eccop(grp, R, NULL, &P_, NULL, NULL, ECCOP_POINT_DOUBLE));
330+
MBEDTLS_MPI_CHK(internal_run_eccop(grp, R, NULL, &P_, NULL, NULL, ECCOP_POINT_DOUBLE));
331331

332332
cleanup:
333333

@@ -369,7 +369,7 @@ int mbedtls_internal_ecp_mul_jac(mbedtls_ecp_group *grp,
369369
MBEDTLS_MPI_CHK(mbedtls_internal_ecp_normalize_jac(grp, &P_));
370370

371371
/* Run ECC point multiplication: R = m*P */
372-
MBEDTLS_MPI_CHK(mbedtls_internal_run_eccop(grp, R, m, &P_, NULL, NULL, ECCOP_POINT_MUL));
372+
MBEDTLS_MPI_CHK(internal_run_eccop(grp, R, m, &P_, NULL, NULL, ECCOP_POINT_MUL));
373373

374374
cleanup:
375375

@@ -426,28 +426,28 @@ int mbedtls_internal_ecp_normalize_jac( const mbedtls_ecp_group *grp,
426426
mbedtls_mpi_init(&Zi);
427427
mbedtls_mpi_init(&ZZi);
428428

429-
/* Use MBEDTLS_INTERNAL_MPI_NORM(Np, N1, N_, P) to get normalized MPI
429+
/* Use INTERNAL_MPI_NORM(Np, N1, N_, P) to get normalized MPI
430430
*
431431
* N_: Holds normalized MPI if the passed-in MPI N1 is not
432432
* Np: Pointer to normalized MPI, which could be N1 or N_
433433
*/
434434

435435
/* Zi = 1 / Z */
436436
mbedtls_mpi_lset(&Zi, 1);
437-
MBEDTLS_INTERNAL_MPI_NORM(&Np, pt->Z, N, grp->P);
438-
MBEDTLS_MPI_CHK(mbedtls_internal_run_modop(&Zi, &Zi, Np, &grp->P, grp->pbits, MODOP_DIV));
437+
INTERNAL_MPI_NORM(&Np, pt->Z, N, grp->P);
438+
MBEDTLS_MPI_CHK(internal_run_modop(&Zi, &Zi, Np, &grp->P, grp->pbits, MODOP_DIV));
439439

440440
/* ZZi = 1 / Z^2 = Zi * Zi */
441-
MBEDTLS_MPI_CHK(mbedtls_internal_run_modop(&ZZi, &Zi, &Zi, &grp->P, grp->pbits, MODOP_MUL));
441+
MBEDTLS_MPI_CHK(internal_run_modop(&ZZi, &Zi, &Zi, &grp->P, grp->pbits, MODOP_MUL));
442442

443443
/* X = X / Z^2 = X * ZZi */
444-
MBEDTLS_INTERNAL_MPI_NORM(&Np, pt->X, N, grp->P);
445-
MBEDTLS_MPI_CHK(mbedtls_internal_run_modop(&pt->X, Np, &ZZi, &grp->P, grp->pbits, MODOP_MUL));
444+
INTERNAL_MPI_NORM(&Np, pt->X, N, grp->P);
445+
MBEDTLS_MPI_CHK(internal_run_modop(&pt->X, Np, &ZZi, &grp->P, grp->pbits, MODOP_MUL));
446446

447447
/* Y = Y / Z^3 = Y * ZZi * Zi */
448-
MBEDTLS_INTERNAL_MPI_NORM(&Np, pt->Y, N, grp->P);
449-
MBEDTLS_MPI_CHK(mbedtls_internal_run_modop(&pt->Y, Np, &ZZi, &grp->P, grp->pbits, MODOP_MUL));
450-
MBEDTLS_MPI_CHK(mbedtls_internal_run_modop(&pt->Y, &pt->Y, &Zi, &grp->P, grp->pbits, MODOP_MUL));
448+
INTERNAL_MPI_NORM(&Np, pt->Y, N, grp->P);
449+
MBEDTLS_MPI_CHK(internal_run_modop(&pt->Y, Np, &ZZi, &grp->P, grp->pbits, MODOP_MUL));
450+
MBEDTLS_MPI_CHK(internal_run_modop(&pt->Y, &pt->Y, &Zi, &grp->P, grp->pbits, MODOP_MUL));
451451

452452
/* Z = 1 */
453453
MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&pt->Z, 1));
@@ -497,7 +497,7 @@ int mbedtls_internal_ecp_normalize_jac_many(const mbedtls_ecp_group *grp,
497497
}
498498
#endif
499499

500-
int mbedtls_internal_run_eccop(const mbedtls_ecp_group *grp,
500+
int internal_run_eccop(const mbedtls_ecp_group *grp,
501501
mbedtls_ecp_point *R,
502502
const mbedtls_mpi *m,
503503
const mbedtls_ecp_point *P,
@@ -528,7 +528,7 @@ int mbedtls_internal_run_eccop(const mbedtls_ecp_group *grp,
528528

529529
mbedtls_mpi_init(&N_);
530530

531-
/* Use MBEDTLS_INTERNAL_MPI_NORM(Np, N1, N_, P) to get normalized MPI
531+
/* Use INTERNAL_MPI_NORM(Np, N1, N_, P) to get normalized MPI
532532
*
533533
* N_: Holds normalized MPI if the passed-in MPI N1 is not
534534
* Np: Pointer to normalized MPI, which could be N1 or N_
@@ -566,7 +566,7 @@ int mbedtls_internal_run_eccop(const mbedtls_ecp_group *grp,
566566
/* NOTE: If grp->N (order) is a prime, we could detect R = 0 for all m*P cases
567567
* by just checking if m is a multiple of grp->N. Otherwise, sigh. */
568568
/* TODO: Find an approach to detecting R = 0 for all m*P cases */
569-
MBEDTLS_INTERNAL_MPI_NORM(&Np, *m, N_, grp->N);
569+
INTERNAL_MPI_NORM(&Np, *m, N_, grp->N);
570570
if (mbedtls_mpi_cmp_int(Np, 0) == 0) {
571571
MBEDTLS_MPI_CHK(mbedtls_ecp_set_zero(R));
572572
goto cleanup;
@@ -594,7 +594,7 @@ int mbedtls_internal_run_eccop(const mbedtls_ecp_group *grp,
594594
}
595595

596596
/* R = P + Q = P + (-P) = 0 */
597-
MBEDTLS_MPI_CHK(mbedtls_internal_run_modop(&N_, &P->Y, &Q->Y, &grp->P, grp->pbits, MODOP_ADD));
597+
MBEDTLS_MPI_CHK(internal_run_modop(&N_, &P->Y, &Q->Y, &grp->P, grp->pbits, MODOP_ADD));
598598
if (mbedtls_mpi_cmp_int(&N_, 0) == 0) {
599599
MBEDTLS_MPI_CHK(mbedtls_ecp_set_zero(R));
600600
goto cleanup;
@@ -613,7 +613,7 @@ int mbedtls_internal_run_eccop(const mbedtls_ecp_group *grp,
613613
}
614614

615615
/* R = 2*P = P + P = P + (-P) = 0 */
616-
MBEDTLS_MPI_CHK(mbedtls_internal_run_modop(&N_, &P->Y, &P->Y, &grp->P, grp->pbits, MODOP_ADD));
616+
MBEDTLS_MPI_CHK(internal_run_modop(&N_, &P->Y, &P->Y, &grp->P, grp->pbits, MODOP_ADD));
617617
if (mbedtls_mpi_cmp_int(&N_, 0) == 0) {
618618
MBEDTLS_MPI_CHK(mbedtls_ecp_set_zero(R));
619619
goto cleanup;
@@ -627,39 +627,39 @@ int mbedtls_internal_run_eccop(const mbedtls_ecp_group *grp,
627627
/* Special case for A = -3 */
628628
if (grp->A.p == NULL) {
629629
MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&N_, -3));
630-
MBEDTLS_INTERNAL_MPI_NORM(&Np, N_, N_, grp->P);
630+
INTERNAL_MPI_NORM(&Np, N_, N_, grp->P);
631631
} else {
632-
MBEDTLS_INTERNAL_MPI_NORM(&Np, grp->A, N_, grp->P);
632+
INTERNAL_MPI_NORM(&Np, grp->A, N_, grp->P);
633633
}
634-
MBEDTLS_MPI_CHK(mbedtls_internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_A, NU_ECC_BIGNUM_MAXWORD));
635-
MBEDTLS_INTERNAL_MPI_NORM(&Np, grp->B, N_, grp->P);
636-
MBEDTLS_MPI_CHK(mbedtls_internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_B, NU_ECC_BIGNUM_MAXWORD));
634+
MBEDTLS_MPI_CHK(internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_A, NU_ECC_BIGNUM_MAXWORD));
635+
INTERNAL_MPI_NORM(&Np, grp->B, N_, grp->P);
636+
MBEDTLS_MPI_CHK(internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_B, NU_ECC_BIGNUM_MAXWORD));
637637

638638
/* Configure ECC prime modulus */
639-
MBEDTLS_MPI_CHK(mbedtls_internal_mpi_write_eccreg(&grp->P, (uint32_t *) CRPT->ECC_N, NU_ECC_BIGNUM_MAXWORD));
639+
MBEDTLS_MPI_CHK(internal_mpi_write_eccreg(&grp->P, (uint32_t *) CRPT->ECC_N, NU_ECC_BIGNUM_MAXWORD));
640640

641641
/* Configure ECC scalar for point multiplication
642642
*
643643
* Normalize m to within [1, order - 1] which ECCOP_POINT_MUL supports
644644
* Special cases R = 0 should have been detected out above.
645645
*/
646646
if (eccop == ECCOP_POINT_MUL) {
647-
MBEDTLS_INTERNAL_MPI_NORM(&Np, *m, N_, grp->N);
648-
MBEDTLS_MPI_CHK(mbedtls_internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_K, NU_ECC_BIGNUM_MAXWORD));
647+
INTERNAL_MPI_NORM(&Np, *m, N_, grp->N);
648+
MBEDTLS_MPI_CHK(internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_K, NU_ECC_BIGNUM_MAXWORD));
649649
}
650650

651651
/* Configure ECC point (X1, Y1) */
652-
MBEDTLS_INTERNAL_MPI_NORM(&Np, P->X, N_, grp->P);
653-
MBEDTLS_MPI_CHK(mbedtls_internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_X1, NU_ECC_BIGNUM_MAXWORD));
654-
MBEDTLS_INTERNAL_MPI_NORM(&Np, P->Y, N_, grp->P);
655-
MBEDTLS_MPI_CHK(mbedtls_internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_Y1, NU_ECC_BIGNUM_MAXWORD));
652+
INTERNAL_MPI_NORM(&Np, P->X, N_, grp->P);
653+
MBEDTLS_MPI_CHK(internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_X1, NU_ECC_BIGNUM_MAXWORD));
654+
INTERNAL_MPI_NORM(&Np, P->Y, N_, grp->P);
655+
MBEDTLS_MPI_CHK(internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_Y1, NU_ECC_BIGNUM_MAXWORD));
656656

657657
/* Configure ECC points (X2, Y2) */
658658
if (eccop == ECCOP_POINT_ADD) {
659-
MBEDTLS_INTERNAL_MPI_NORM(&Np, Q->X, N_, grp->P);
660-
MBEDTLS_MPI_CHK(mbedtls_internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_X2, NU_ECC_BIGNUM_MAXWORD));
661-
MBEDTLS_INTERNAL_MPI_NORM(&Np, Q->Y, N_, grp->P);
662-
MBEDTLS_MPI_CHK(mbedtls_internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_Y2, NU_ECC_BIGNUM_MAXWORD));
659+
INTERNAL_MPI_NORM(&Np, Q->X, N_, grp->P);
660+
MBEDTLS_MPI_CHK(internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_X2, NU_ECC_BIGNUM_MAXWORD));
661+
INTERNAL_MPI_NORM(&Np, Q->Y, N_, grp->P);
662+
MBEDTLS_MPI_CHK(internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_Y2, NU_ECC_BIGNUM_MAXWORD));
663663
}
664664

665665
crypto_ecc_prestart();
@@ -670,8 +670,8 @@ int mbedtls_internal_run_eccop(const mbedtls_ecp_group *grp,
670670
MBEDTLS_MPI_CHK(ecc_done ? 0 : -1);
671671

672672
/* (X1, Y1) hold the normalized result. */
673-
MBEDTLS_MPI_CHK(mbedtls_internal_mpi_read_eccreg(&R->X, (uint32_t *) CRPT->ECC_X1, NU_ECC_BIGNUM_MAXWORD));
674-
MBEDTLS_MPI_CHK(mbedtls_internal_mpi_read_eccreg(&R->Y, (uint32_t *) CRPT->ECC_Y1, NU_ECC_BIGNUM_MAXWORD));
673+
MBEDTLS_MPI_CHK(internal_mpi_read_eccreg(&R->X, (uint32_t *) CRPT->ECC_X1, NU_ECC_BIGNUM_MAXWORD));
674+
MBEDTLS_MPI_CHK(internal_mpi_read_eccreg(&R->Y, (uint32_t *) CRPT->ECC_Y1, NU_ECC_BIGNUM_MAXWORD));
675675
MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&R->Z, 1));
676676

677677
cleanup:
@@ -681,12 +681,12 @@ int mbedtls_internal_run_eccop(const mbedtls_ecp_group *grp,
681681
return ret;
682682
}
683683

684-
int mbedtls_internal_run_modop(mbedtls_mpi *r,
685-
const mbedtls_mpi *o1,
686-
const mbedtls_mpi *o2,
687-
const mbedtls_mpi *p,
688-
uint32_t pbits,
689-
uint32_t modop)
684+
int internal_run_modop(mbedtls_mpi *r,
685+
const mbedtls_mpi *o1,
686+
const mbedtls_mpi *o2,
687+
const mbedtls_mpi *p,
688+
uint32_t pbits,
689+
uint32_t modop)
690690
{
691691
if (r == NULL ||
692692
o1 == NULL ||
@@ -732,7 +732,7 @@ int mbedtls_internal_run_modop(mbedtls_mpi *r,
732732

733733
mbedtls_mpi_init(&N_);
734734

735-
/* Use MBEDTLS_INTERNAL_MPI_NORM(Np, N1, N_, P) to get normalized MPI
735+
/* Use INTERNAL_MPI_NORM(Np, N1, N_, P) to get normalized MPI
736736
*
737737
* N_: Holds normalized MPI if the passed-in MPI N1 is not
738738
* Np: Pointer to normalized MPI, which could be N1 or N_
@@ -741,20 +741,20 @@ int mbedtls_internal_run_modop(mbedtls_mpi *r,
741741
if (modop == MODOP_MUL ||
742742
modop == MODOP_ADD ||
743743
modop == MODOP_SUB) {
744-
MBEDTLS_INTERNAL_MPI_NORM(&Np, *o1, N_, *p);
745-
MBEDTLS_MPI_CHK(mbedtls_internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_X1, NU_ECC_BIGNUM_MAXWORD));
746-
MBEDTLS_INTERNAL_MPI_NORM(&Np, *o2, N_, *p);
747-
MBEDTLS_MPI_CHK(mbedtls_internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_Y1, NU_ECC_BIGNUM_MAXWORD));
744+
INTERNAL_MPI_NORM(&Np, *o1, N_, *p);
745+
MBEDTLS_MPI_CHK(internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_X1, NU_ECC_BIGNUM_MAXWORD));
746+
INTERNAL_MPI_NORM(&Np, *o2, N_, *p);
747+
MBEDTLS_MPI_CHK(internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_Y1, NU_ECC_BIGNUM_MAXWORD));
748748
} else if (modop == MODOP_DIV) {
749-
MBEDTLS_INTERNAL_MPI_NORM(&Np, *o2, N_, *p);
750-
MBEDTLS_MPI_CHK(mbedtls_internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_X1, NU_ECC_BIGNUM_MAXWORD));
751-
MBEDTLS_INTERNAL_MPI_NORM(&Np, *o1, N_, *p);
752-
MBEDTLS_MPI_CHK(mbedtls_internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_Y1, NU_ECC_BIGNUM_MAXWORD));
749+
INTERNAL_MPI_NORM(&Np, *o2, N_, *p);
750+
MBEDTLS_MPI_CHK(internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_X1, NU_ECC_BIGNUM_MAXWORD));
751+
INTERNAL_MPI_NORM(&Np, *o1, N_, *p);
752+
MBEDTLS_MPI_CHK(internal_mpi_write_eccreg(Np, (uint32_t *) CRPT->ECC_Y1, NU_ECC_BIGNUM_MAXWORD));
753753
} else {
754754
MBEDTLS_MPI_CHK(MBEDTLS_ERR_ECP_BAD_INPUT_DATA);
755755
}
756756

757-
MBEDTLS_MPI_CHK(mbedtls_internal_mpi_write_eccreg(p, (uint32_t *) CRPT->ECC_N, NU_ECC_BIGNUM_MAXWORD));
757+
MBEDTLS_MPI_CHK(internal_mpi_write_eccreg(p, (uint32_t *) CRPT->ECC_N, NU_ECC_BIGNUM_MAXWORD));
758758

759759
crypto_ecc_prestart();
760760
CRPT->ECC_CTL = (pbits << CRPT_ECC_CTL_CURVEM_Pos) | (ECCOP_MODULE | modop) | CRPT_ECC_CTL_FSEL_Msk | CRPT_ECC_CTL_START_Msk;
@@ -764,7 +764,7 @@ int mbedtls_internal_run_modop(mbedtls_mpi *r,
764764
MBEDTLS_MPI_CHK(ecc_done ? 0 : -1);
765765

766766
/* X1 holds the result. */
767-
MBEDTLS_MPI_CHK(mbedtls_internal_mpi_read_eccreg(r, (uint32_t *) CRPT->ECC_X1, NU_ECC_BIGNUM_MAXWORD));
767+
MBEDTLS_MPI_CHK(internal_mpi_read_eccreg(r, (uint32_t *) CRPT->ECC_X1, NU_ECC_BIGNUM_MAXWORD));
768768

769769
cleanup:
770770

@@ -775,7 +775,7 @@ int mbedtls_internal_run_modop(mbedtls_mpi *r,
775775

776776
#endif // ECP_SHORTWEIERSTRASS
777777

778-
static int mbedtls_internal_mpi_read_eccreg(mbedtls_mpi *x, const volatile uint32_t *eccreg, size_t eccreg_num)
778+
static int internal_mpi_read_eccreg(mbedtls_mpi *x, const volatile uint32_t *eccreg, size_t eccreg_num)
779779
{
780780
if (x == NULL) {
781781
return MBEDTLS_ERR_MPI_BAD_INPUT_DATA;
@@ -802,7 +802,7 @@ static int mbedtls_internal_mpi_read_eccreg(mbedtls_mpi *x, const volatile uint3
802802
return ret;
803803
}
804804

805-
static int mbedtls_internal_mpi_write_eccreg( const mbedtls_mpi *x, volatile uint32_t *eccreg, size_t eccreg_num )
805+
static int internal_mpi_write_eccreg( const mbedtls_mpi *x, volatile uint32_t *eccreg, size_t eccreg_num )
806806
{
807807
if (x == NULL) {
808808
return MBEDTLS_ERR_MPI_BAD_INPUT_DATA;

0 commit comments

Comments
 (0)