60 #define ASSERT(IF) if(!(IF)) { return PKA_STATUS_INVALID_PARAM; } 65 const uint8_t number_size,
66 const uint32_t *modulus,
67 const uint8_t modulus_size,
68 uint32_t *result_vector,
69 struct process *process)
77 ASSERT(NULL != number);
78 ASSERT(NULL != modulus);
79 ASSERT(NULL != result_vector);
87 extraBuf = 2 + modulus_size % 2;
96 for(i = 0; i < number_size; i++) {
101 offset += 4 * (i + number_size % 2);
108 for(i = 0; i < modulus_size; i++) {
113 offset += 4 * (i + extraBuf);
131 if(process != NULL) {
142 const uint8_t buffer_size,
143 const uint32_t result_vector)
151 ASSERT(NULL != buffer);
178 if(buffer_size < len) {
182 for(i = 0; i < len; i++) {
183 buffer[i] = REG(result_vector + 4 * i);
191 const uint32_t *number2,
193 struct process *process)
200 ASSERT(NULL != number1);
201 ASSERT(NULL != number2);
215 for(i = 0; i < size; i++) {
220 offset += 4 * (i + size % 2);
227 for(i = 0; i < size; i++) {
239 if(process != NULL) {
287 const uint8_t number_size,
288 const uint32_t *modulus,
289 const uint8_t modulus_size,
290 uint32_t *result_vector,
291 struct process *process)
298 ASSERT(NULL != number);
299 ASSERT(NULL != modulus);
300 ASSERT(NULL != result_vector);
314 for(i = 0; i < number_size; i++) {
319 offset += 4 * (i + number_size % 2);
326 for(i = 0; i < modulus_size; i++) {
331 offset += 4 * (i + modulus_size % 2);
347 if(process != NULL) {
358 const uint8_t buffer_size,
359 const uint32_t result_vector)
367 ASSERT(NULL != buffer);
394 if(buffer_size < len) {
399 for(i = 0; i < len; i++) {
400 buffer[i] = REG(result_vector + 4 * i);
408 const uint8_t multiplicand_size,
409 const uint32_t *multiplier,
410 const uint8_t multiplier_size,
411 uint32_t *result_vector,
412 struct process *process)
419 ASSERT(NULL != multiplicand);
420 ASSERT(NULL != multiplier);
421 ASSERT(NULL != result_vector);
435 for(i = 0; i < multiplicand_size; i++) {
441 offset += 4 * (i + (multiplicand_size % 2));
448 for(i = 0; i < multiplier_size; i++) {
454 offset += 4 * (i + (multiplier_size % 2));
470 if(process != NULL) {
481 uint32_t *buffer_size,
482 const uint32_t result_vector)
490 ASSERT(NULL != buffer);
491 ASSERT(NULL != buffer_size);
518 if(*buffer_size < len) {
526 for(i = 0; i < *buffer_size; i++) {
527 buffer[i] = REG(result_vector + 4 * i);
535 const uint8_t number1_size,
536 const uint32_t *number2,
537 const uint8_t number2_size,
538 uint32_t *result_vector,
539 struct process *process)
546 ASSERT(NULL != number1);
547 ASSERT(NULL != number2);
548 ASSERT(NULL != result_vector);
562 for(i = 0; i < number1_size; i++) {
567 offset += 4 * (i + (number1_size % 2));
574 for(i = 0; i < number2_size; i++) {
579 offset += 4 * (i + (number2_size % 2));
595 if(process != NULL) {
606 uint32_t *buffer_size,
607 const uint32_t result_vector)
615 ASSERT(NULL != buffer);
616 ASSERT(NULL != buffer_size);
643 if(*buffer_size < len) {
651 for(i = 0; i < *buffer_size; i++) {
652 buffer[i] = REG(result_vector + 4 * i);
661 const uint8_t number1_size,
662 const uint32_t *number2,
663 const uint8_t number2_size,
664 uint32_t *result_vector,
665 struct process *process)
672 ASSERT(NULL != number1);
673 ASSERT(NULL != number2);
674 ASSERT(NULL != result_vector);
688 for(i = 0; i < number1_size; i++) {
693 offset += 4 * (i + (number1_size % 2));
700 for(i = 0; i < number2_size; i++) {
705 offset += 4 * (i + (number2_size % 2));
721 if(process != NULL) {
732 uint32_t *buffer_size,
733 const uint32_t result_vector)
741 ASSERT(NULL != buffer);
742 ASSERT(NULL != buffer_size);
769 if(*buffer_size < len) {
777 for(i = 0; i < *buffer_size; i++) {
778 buffer[i] = REG(result_vector + 4 * i);
786 const uint8_t number_size,
787 const uint32_t *modulus,
788 const uint8_t modulus_size,
789 const uint32_t *base,
790 const uint8_t base_size,
791 uint32_t *result_vector,
792 struct process *process)
798 ASSERT(NULL != number);
799 ASSERT(NULL != modulus);
800 ASSERT(NULL != base);
801 ASSERT(NULL != result_vector);
802 ASSERT(modulus != base);
816 for(i = 0; i < number_size; i++) {
821 offset += 4 * (i + number_size % 2);
827 for(i = 0; i < modulus_size; i++) {
832 offset += 4 * (i + modulus_size % 2 + 2);
839 for(i = 0; i < base_size; i++) {
865 if(process != NULL) {
876 const uint8_t buffer_size,
877 const uint32_t result_vector)
885 ASSERT(NULL != buffer);
911 if(buffer_size < len) {
916 for(i = 0; i < len; i++) {
917 buffer[i] = REG(result_vector + 4 * i);
925 const uint8_t dividend_size,
926 const uint32_t *divisor,
927 const uint8_t divisor_size,
928 uint32_t *result_vector,
929 struct process *process)
937 if(dividend_size > divisor_size) {
938 spacing = dividend_size;
940 spacing = divisor_size;
942 spacing += 2 + spacing % 2;
945 ASSERT(NULL != dividend);
946 ASSERT(NULL != divisor);
947 ASSERT(NULL != result_vector);
960 for(i = 0; i < dividend_size; i++) {
966 offset += 4 * spacing;
973 for(i = 0; i < divisor_size; i++) {
979 offset += 4 * spacing;
985 offset += 4 * spacing;
1001 if(process != NULL) {
1012 uint32_t *buffer_size,
1013 const uint32_t result_vector)
1021 ASSERT(NULL != buffer);
1022 ASSERT(NULL != buffer_size);
1049 if(*buffer_size < len) {
1057 for(i = 0; i < *buffer_size; i++) {
1058 buffer[i] = REG(result_vector + 4 * i);
#define PKA_FUNCTION_COMPARE
Perform compare operation.
uint8_t bignum_cmp_get_result(void)
Gets the result of the comparison operation of two big numbers.
#define PKA_DIVMSW_RESULT_IS_ZERO
The result vector is all zeroes, ignore the address returned in bits [10:0].
#define PKA_STATUS_SUCCESS
Success.
Header file for the ARM Nested Vectored Interrupt Controller.
#define PKA_STATUS_BUF_UNDERFLOW
Buffer underflow.
#define PKA_FUNCTION_DIVIDE
Perform divide operation.
#define PKA_FUNCTION_SUBTRACT
Perform subtract operation.
#define PKA_STATUS_A_LT_B
Big number compare return status if the first big num is less than the second.
#define PKA_FUNCTION
PKA function This register contains the control bits to start basic PKCP as well as complex sequencer...
uint8_t bignum_subtract_get_result(uint32_t *buffer, uint32_t *buffer_size, const uint32_t result_vector)
Gets the result of big number subtract.
#define PKA_STATUS_FAILURE
Failure.
uint8_t bignum_mod_get_result(uint32_t *buffer, const uint8_t buffer_size, const uint32_t result_vector)
Gets the result of the big number modulus operation.
#define PKA_DIVMSW
PKA most-significant-word of divide remainder This register indicates the (32-bit word) address in th...
uint8_t bignum_exp_mod_start(const uint32_t *number, const uint8_t number_size, const uint32_t *modulus, const uint8_t modulus_size, const uint32_t *base, const uint8_t base_size, uint32_t *result_vector, struct process *process)
Starts the big number moduluar Exponentiation operation.
#define PKA_COMPARE
PKA compare result This register provides the result of a basic PKCP compare operation.
uint8_t bignum_inv_mod_get_result(uint32_t *buffer, const uint8_t buffer_size, const uint32_t result_vector)
Gets the result of the big number inverse modulo operation.
Header file with register manipulation macro definitions.
uint8_t bignum_mod_start(const uint32_t *number, const uint8_t number_size, const uint32_t *modulus, const uint8_t modulus_size, uint32_t *result_vector, struct process *process)
Starts the big number modulus operation.
uint8_t bignum_divide_get_result(uint32_t *buffer, uint32_t *buffer_size, const uint32_t result_vector)
Gets the results of the big number Divide.
#define PKA_STATUS_A_GR_B
Big number compare return status if the first big num is greater than the second. ...
#define PKA_RAM_BASE
PKA Memory Address.
#define PKA_DIVMSW_MSW_ADDRESS_M
Address of the most significant nonzero 32-bit word of the remainder result vector in PKA RAM...
#define PKA_FUNCTION_ADD
Perform add operation.
#define PKA_CPTR
PKA vector C address During execution of basic PKCP operations, this register is double buffered and ...
__STATIC_INLINE void NVIC_DisableIRQ(IRQn_Type IRQn)
Disable External Interrupt.
uint8_t bignum_mul_start(const uint32_t *multiplicand, const uint8_t multiplicand_size, const uint32_t *multiplier, const uint8_t multiplier_size, uint32_t *result_vector, struct process *process)
Starts the big number multiplication.
#define PKA_FUNCTION_MODULO
Perform modulo operation.
#define PKA_STATUS_RESULT_0
Result is all zeros.
uint8_t bignum_add_start(const uint32_t *number1, const uint8_t number1_size, const uint32_t *number2, const uint8_t number2_size, uint32_t *result_vector, struct process *process)
Starts the addition of two big number.
__STATIC_INLINE void NVIC_EnableIRQ(IRQn_Type IRQn)
Enable External Interrupt.
#define PKA_MSW_MSW_ADDRESS_M
Address of the most-significant nonzero 32-bit word of the result vector in PKA RAM.
#define PKA_ALENGTH
PKA vector A length During execution of basic PKCP operations, this register is double buffered and c...
#define PKA_FUNCTION_MULTIPLY
Perform multiply operation.
__STATIC_INLINE void NVIC_ClearPendingIRQ(IRQn_Type IRQn)
Clear Pending Interrupt.
#define PKA_COMPARE_A_LESS_THAN_B
Vector_A is less than Vector_B.
#define PKA_STATUS_OPERATION_INPRG
PKA operation is in progress.
#define PKA_BLENGTH
PKA vector B length During execution of basic PKCP operations, this register is double buffered and c...
uint8_t bignum_add_get_result(uint32_t *buffer, uint32_t *buffer_size, const uint32_t result_vector)
Gets the result of the addition operation on two big number.
uint8_t bignum_cmp_start(const uint32_t *number1, const uint32_t *number2, const uint8_t size, struct process *process)
Starts the comparison of two big numbers.
#define PKA_APTR
PKA vector A address During execution of basic PKCP operations, this register is double buffered and ...
#define PKA_COMPARE_A_GREATER_THAN_B
Vector_A is greater than Vector_B.
#define PKA_COMPARE_A_EQUALS_B
Vector_A is equal to Vector_B.
uint8_t bignum_divide_start(const uint32_t *dividend, const uint8_t dividend_size, const uint32_t *divisor, const uint8_t divisor_size, uint32_t *result_vector, struct process *process)
Starts the big number Divide.
#define PKA_FUNCTION_RUN
The host sets this bit to instruct the PKA module to begin processing the basic PKCP or complex seque...
#define PKA_MSW
PKA most-significant-word of result vector This register indicates the (word) address in the PKA RAM ...
#define PKA_DPTR
PKA vector D address During execution of basic PKCP operations, this register is double buffered and ...
void pka_register_process_notification(struct process *p)
Registers a process to be notified of the completion of a PKA operation.
uint8_t bignum_inv_mod_start(const uint32_t *number, const uint8_t number_size, const uint32_t *modulus, const uint8_t modulus_size, uint32_t *result_vector, struct process *process)
Starts the big number inverse modulo operation.
#define PKA_RAM_SIZE
PKA Memory Size.
uint8_t bignum_subtract_start(const uint32_t *number1, const uint8_t number1_size, const uint32_t *number2, const uint8_t number2_size, uint32_t *result_vector, struct process *process)
Starts the substract of two big number.
uint8_t bignum_exp_mod_get_result(uint32_t *buffer, const uint8_t buffer_size, const uint32_t result_vector)
Gets the result of the big number modulus operation result.
#define PKA_MSW_RESULT_IS_ZERO
The result vector is all zeroes, ignore the address returned in bits [10:0].
uint8_t bignum_mul_get_result(uint32_t *buffer, uint32_t *buffer_size, const uint32_t result_vector)
Gets the results of the big number multiplication.
#define PKA_BPTR
PKA vector B address During execution of basic PKCP operations, this register is double buffered and ...
Header file for the cc2538 BigNum driver.