Contiki-NG
ecc-driver.c
Go to the documentation of this file.
1 /*
2  * Original file:
3  * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com/
4  * All rights reserved.
5  *
6  * Port to Contiki:
7  * Copyright (c) 2014 Andreas Dröscher <contiki@anticat.ch>
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  * notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  * notice, this list of conditions and the following disclaimer in the
16  * documentation and/or other materials provided with the distribution.
17  *
18  * 3. Neither the name of the copyright holder nor the names of its
19  * contributors may be used to endorse or promote products derived
20  * from this software without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
25  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
26  * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
27  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
28  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
29  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
31  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
32  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
33  * OF THE POSSIBILITY OF SUCH DAMAGE.
34  */
35 /**
36  * \addtogroup cc2538-ecc
37  * @{
38  *
39  * \file
40  * Implementation of the cc2538 ECC driver
41  */
42 #include "dev/ecc-driver.h"
43 #include "reg.h"
44 #include "dev/nvic.h"
45 
46 #define ASSERT(IF) if(!(IF)) { return PKA_STATUS_INVALID_PARAM; }
47 
48 /*---------------------------------------------------------------------------*/
49 uint8_t
50 ecc_mul_start(uint32_t *scalar, ec_point_t *ec_point,
51  ecc_curve_info_t *curve, uint32_t *result_vector,
52  struct process *process)
53 {
54 
55  uint8_t extraBuf;
56  uint32_t offset;
57  int i;
58 
59  /* Check for the arguments. */
60  ASSERT(NULL != scalar);
61  ASSERT(NULL != ec_point);
62  ASSERT(NULL != ec_point->x);
63  ASSERT(NULL != ec_point->y);
64  ASSERT(NULL != curve);
65  ASSERT(curve->size <= PKA_MAX_CURVE_SIZE);
66  ASSERT(NULL != result_vector);
67 
68  offset = 0;
69 
70  /* Make sure no PKA operation is in progress. */
71  if((REG(PKA_FUNCTION) & PKA_FUNCTION_RUN) != 0) {
73  }
74 
75  /* Calculate the extra buffer requirement. */
76  extraBuf = 2 + curve->size % 2;
77 
78  /* Update the A ptr with the offset address of the PKA RAM location
79  * where the scalar will be stored. */
80  REG(PKA_APTR) = offset >> 2;
81 
82  /* Load the scalar in PKA RAM. */
83  for(i = 0; i < curve->size; i++) {
84  REG(PKA_RAM_BASE + offset + 4 * i) = *scalar++;
85  }
86 
87  /* Determine the offset for the next data. */
88  offset += 4 * (i + (curve->size % 2));
89 
90  /* Update the B ptr with the offset address of the PKA RAM location
91  * where the curve parameters will be stored. */
92  REG(PKA_BPTR) = offset >> 2;
93 
94  /* Write curve parameter 'p' as 1st part of vector B immediately
95  * following vector A at PKA RAM */
96  for(i = 0; i < curve->size; i++) {
97  REG(PKA_RAM_BASE + offset + 4 * i) = (uint32_t)curve->prime[i];
98  }
99 
100  /* Determine the offset for the next data. */
101  offset += 4 * (i + extraBuf);
102 
103  /* Copy curve parameter 'a' in PKA RAM. */
104  for(i = 0; i < curve->size; i++) {
105  REG(PKA_RAM_BASE + offset + 4 * i) = (uint32_t)curve->a[i];
106  }
107 
108  /* Determine the offset for the next data. */
109  offset += 4 * (i + extraBuf);
110 
111  /* Copy curve parameter 'b' in PKA RAM. */
112  for(i = 0; i < curve->size; i++) {
113  REG(PKA_RAM_BASE + offset + 4 * i) = (uint32_t)curve->b[i];
114  }
115 
116  /* Determine the offset for the next data. */
117  offset += 4 * (i + extraBuf);
118 
119  /* Update the C ptr with the offset address of the PKA RAM location
120  * where the x, y will be stored. */
121  REG(PKA_CPTR) = offset >> 2;
122 
123  /* Write elliptic curve point.x co-ordinate value. */
124  for(i = 0; i < curve->size; i++) {
125  REG(PKA_RAM_BASE + offset + 4 * i) = ec_point->x[i];
126  }
127 
128  /* Determine the offset for the next data. */
129  offset += 4 * (i + extraBuf);
130 
131  /* Write elliptic curve point.y co-ordinate value. */
132  for(i = 0; i < curve->size; i++) {
133  REG(PKA_RAM_BASE + offset + 4 * i) = ec_point->y[i];
134  }
135 
136  /* Determine the offset for the next data. */
137  offset += 4 * (i + extraBuf);
138 
139  /* Update the result location. */
140  *result_vector = PKA_RAM_BASE + offset;
141 
142  /* Load D ptr with the result location in PKA RAM. */
143  REG(PKA_DPTR) = offset >> 2;
144 
145  /* Load length registers. */
146  REG(PKA_ALENGTH) = curve->size;
147  REG(PKA_BLENGTH) = curve->size;
148 
149  /* set the PKA function to ECC-MULT and start the operation. */
150  REG(PKA_FUNCTION) = 0x0000D000;
151 
152  /* Enable Interrupt */
153  if(process != NULL) {
155  NVIC_ClearPendingIRQ(PKA_IRQn);
156  NVIC_EnableIRQ(PKA_IRQn);
157  }
158 
159  return PKA_STATUS_SUCCESS;
160 }
161 /*---------------------------------------------------------------------------*/
162 uint8_t
163 ecc_mul_get_result(ec_point_t *ec_point,
164  uint32_t result_vector)
165 {
166  int i;
167  uint32_t addr;
168  uint32_t regMSWVal;
169  uint32_t len;
170 
171  /* Check for the arguments. */
172  ASSERT(NULL != ec_point);
173  ASSERT(NULL != ec_point->x);
174  ASSERT(NULL != ec_point->y);
175  ASSERT(result_vector > PKA_RAM_BASE);
176  ASSERT(result_vector < (PKA_RAM_BASE + PKA_RAM_SIZE));
177 
178  /* Verify that the operation is completed. */
179  if((REG(PKA_FUNCTION) & PKA_FUNCTION_RUN) != 0) {
181  }
182 
183  /* Disable Interrupt */
184  NVIC_DisableIRQ(PKA_IRQn);
186 
187  if(REG(PKA_SHIFT) == 0x00000000) {
188  /* Get the MSW register value. */
189  regMSWVal = REG(PKA_MSW);
190 
191  /* Check to make sure that the result vector is not all zeroes. */
192  if(regMSWVal & PKA_MSW_RESULT_IS_ZERO) {
193  return PKA_STATUS_RESULT_0;
194  }
195 
196  /* Get the length of the result */
197  len = ((regMSWVal & PKA_MSW_MSW_ADDRESS_M) + 1)
198  - ((result_vector - PKA_RAM_BASE) >> 2);
199 
200  addr = result_vector;
201 
202  /* copy the x co-ordinate value of the result from vector D into
203  * the \e ec_point. */
204  for(i = 0; i < len; i++) {
205  ec_point->x[i] = REG(addr + 4 * i);
206  }
207 
208  addr += 4 * (i + 2 + len % 2);
209 
210  /* copy the y co-ordinate value of the result from vector D into
211  * the \e ec_point. */
212  for(i = 0; i < len; i++) {
213  ec_point->y[i] = REG(addr + 4 * i);
214  }
215 
216  return PKA_STATUS_SUCCESS;
217  } else {
218  return PKA_STATUS_FAILURE;
219  }
220 }
221 /*---------------------------------------------------------------------------*/
222 uint8_t
223 ecc_mul_gen_pt_start(uint32_t *scalar, ecc_curve_info_t *curve,
224  uint32_t *result_vector, struct process *process)
225 {
226  uint8_t extraBuf;
227  uint32_t offset;
228  int i;
229 
230  /* check for the arguments. */
231  ASSERT(NULL != scalar);
232  ASSERT(NULL != curve);
233  ASSERT(curve->size <= PKA_MAX_CURVE_SIZE);
234  ASSERT(NULL != result_vector);
235 
236  offset = 0;
237 
238  /* Make sure no operation is in progress. */
239  if((REG(PKA_FUNCTION) & PKA_FUNCTION_RUN) != 0) {
241  }
242 
243  /* Calculate the extra buffer requirement. */
244  extraBuf = 2 + curve->size % 2;
245 
246  /* Update the A ptr with the offset address of the PKA RAM location
247  * where the scalar will be stored. */
248  REG(PKA_APTR) = offset >> 2;
249 
250  /* Load the scalar in PKA RAM. */
251  for(i = 0; i < curve->size; i++) {
252  REG(PKA_RAM_BASE + offset + 4 * i) = *scalar++;
253  }
254 
255  /* Determine the offset in PKA RAM for the next data. */
256  offset += 4 * (i + (curve->size % 2));
257 
258  /* Update the B ptr with the offset address of the PKA RAM location
259  * where the curve parameters will be stored. */
260  REG(PKA_BPTR) = offset >> 2;
261 
262  /* Write curve parameter 'p' as 1st part of vector B. */
263  for(i = 0; i < curve->size; i++) {
264  REG(PKA_RAM_BASE + offset + 4 * i) = (uint32_t)curve->prime[i];
265  }
266 
267  /* Determine the offset in PKA RAM for the next data. */
268  offset += 4 * (i + extraBuf);
269 
270  /* Write curve parameter 'a' in PKA RAM. */
271  for(i = 0; i < curve->size; i++) {
272  REG(PKA_RAM_BASE + offset + 4 * i) = (uint32_t)curve->a[i];
273  }
274 
275  /* Determine the offset in PKA RAM for the next data. */
276  offset += 4 * (i + extraBuf);
277 
278  /* write curve parameter 'b' in PKA RAM. */
279  for(i = 0; i < curve->size; i++) {
280  REG(PKA_RAM_BASE + offset + 4 * i) = (uint32_t)curve->b[i];
281  }
282 
283  /* Determine the offset in PKA RAM for the next data. */
284  offset += 4 * (i + extraBuf);
285 
286  /* Update the C ptr with the offset address of the PKA RAM location
287  * where the x, y will be stored. */
288  REG(PKA_CPTR) = offset >> 2;
289 
290  /* Write x co-ordinate value of the Generator point in PKA RAM. */
291  for(i = 0; i < curve->size; i++) {
292  REG(PKA_RAM_BASE + offset + 4 * i) = (uint32_t)curve->x[i];
293  }
294 
295  /* Determine the offset in PKA RAM for the next data. */
296  offset += 4 * (i + extraBuf);
297 
298  /* Write y co-ordinate value of the Generator point in PKA RAM. */
299  for(i = 0; i < curve->size; i++) {
300  REG(PKA_RAM_BASE + offset + 4 * i) = (uint32_t)curve->y[i];
301  }
302 
303  /* Determine the offset in PKA RAM for the next data. */
304  offset += 4 * (i + extraBuf);
305 
306  /* Update the result location. */
307  *result_vector = PKA_RAM_BASE + offset;
308 
309  /* Load D ptr with the result location in PKA RAM. */
310  REG(PKA_DPTR) = offset >> 2;
311 
312  /* Load length registers. */
313  REG(PKA_ALENGTH) = curve->size;
314  REG(PKA_BLENGTH) = curve->size;
315 
316  /* Set the PKA function to ECC-MULT and start the operation. */
317  REG(PKA_FUNCTION) = 0x0000D000;
318 
319  /* Enable Interrupt */
320  if(process != NULL) {
322  NVIC_ClearPendingIRQ(PKA_IRQn);
323  NVIC_EnableIRQ(PKA_IRQn);
324  }
325 
326  return PKA_STATUS_SUCCESS;
327 }
328 /*---------------------------------------------------------------------------*/
329 uint8_t
330 ecc_mul_gen_pt_get_result(ec_point_t *ec_point,
331  uint32_t result_vector)
332 {
333 
334  int i;
335  uint32_t regMSWVal;
336  uint32_t addr;
337  uint32_t len;
338 
339  /* Check for the arguments. */
340  ASSERT(NULL != ec_point);
341  ASSERT(NULL != ec_point->x);
342  ASSERT(NULL != ec_point->y);
343  ASSERT(result_vector > PKA_RAM_BASE);
344  ASSERT(result_vector < (PKA_RAM_BASE + PKA_RAM_SIZE));
345 
346  /* Verify that the operation is completed. */
347  if((REG(PKA_FUNCTION) & PKA_FUNCTION_RUN) != 0) {
349  }
350 
351  /* Disable Interrupt */
352  NVIC_DisableIRQ(PKA_IRQn);
354 
355  if(REG(PKA_SHIFT) == 0x00000000) {
356  /* Get the MSW register value. */
357  regMSWVal = REG(PKA_MSW);
358 
359  /* Check to make sure that the result vector is not all zeroes. */
360  if(regMSWVal & PKA_MSW_RESULT_IS_ZERO) {
361  return PKA_STATUS_RESULT_0;
362  }
363 
364  /* Get the length of the result. */
365  len = ((regMSWVal & PKA_MSW_MSW_ADDRESS_M) + 1)
366  - ((result_vector - PKA_RAM_BASE) >> 2);
367 
368  addr = result_vector;
369 
370  /* Copy the x co-ordinate value of the result from vector D into the
371  * EC point. */
372  for(i = 0; i < len; i++) {
373  ec_point->x[i] = REG(addr + 4 * i);
374  }
375 
376  addr += 4 * (i + 2 + len % 2);
377 
378  /* Copy the y co-ordinate value of the result from vector D into the
379  * EC point. */
380  for(i = 0; i < len; i++) {
381  ec_point->y[i] = REG(addr + 4 * i);
382  }
383 
384  return PKA_STATUS_SUCCESS;
385  } else {
386  return PKA_STATUS_FAILURE;
387  }
388 }
389 /*---------------------------------------------------------------------------*/
390 uint8_t
391 ecc_add_start(ec_point_t *ec_point1, ec_point_t *ec_point2,
392  ecc_curve_info_t *curve, uint32_t *result_vector,
393  struct process *process)
394 {
395 
396  uint8_t extraBuf;
397  uint32_t offset;
398  int i;
399 
400  /* Check for the arguments. */
401  ASSERT(NULL != ec_point1);
402  ASSERT(NULL != ec_point1->x);
403  ASSERT(NULL != ec_point1->y);
404  ASSERT(NULL != ec_point2);
405  ASSERT(NULL != ec_point2->x);
406  ASSERT(NULL != ec_point2->y);
407  ASSERT(NULL != curve);
408  ASSERT(NULL != result_vector);
409 
410  offset = 0;
411 
412  /* Make sure no operation is in progress. */
413  if((REG(PKA_FUNCTION) & PKA_FUNCTION_RUN) != 0) {
415  }
416 
417  /* Calculate the extra buffer requirement. */
418  extraBuf = 2 + curve->size % 2;
419 
420  /* Update the A ptr with the offset address of the PKA RAM location
421  * where the first ecPt will be stored. */
422  REG(PKA_APTR) = offset >> 2;
423 
424  /* Load the x co-ordinate value of the first EC point in PKA RAM. */
425  for(i = 0; i < curve->size; i++) {
426  REG(PKA_RAM_BASE + offset + 4 * i) = ec_point1->x[i];
427  }
428 
429  /* Determine the offset in PKA RAM for the next data. */
430  offset += 4 * (i + extraBuf);
431 
432  /* Load the y co-ordinate value of the first EC point in PKA RAM. */
433  for(i = 0; i < curve->size; i++) {
434  REG(PKA_RAM_BASE + offset + 4 * i) = ec_point1->y[i];
435  }
436 
437  /* Determine the offset in PKA RAM for the next data. */
438  offset += 4 * (i + extraBuf);
439 
440  /* Update the B ptr with the offset address of the PKA RAM location
441  * where the curve parameters will be stored. */
442  REG(PKA_BPTR) = offset >> 2;
443 
444  /* Write curve parameter 'p' as 1st part of vector B */
445  for(i = 0; i < curve->size; i++) {
446  REG(PKA_RAM_BASE + offset + 4 * i) = (uint32_t)curve->prime[i];
447  }
448 
449  /* Determine the offset in PKA RAM for the next data. */
450  offset += 4 * (i + extraBuf);
451 
452  /* Write curve parameter 'a'. */
453  for(i = 0; i < curve->size; i++) {
454  REG(PKA_RAM_BASE + offset + 4 * i) = (uint32_t)curve->a[i];
455  }
456 
457  /* Determine the offset in PKA RAM for the next data. */
458  offset += 4 * (i + extraBuf);
459 
460  /* Update the C ptr with the offset address of the PKA RAM location
461  * where the ecPt2 will be stored. */
462  REG(PKA_CPTR) = offset >> 2;
463 
464  /* Load the x co-ordinate value of the second EC point in PKA RAM. */
465  for(i = 0; i < curve->size; i++) {
466  REG(PKA_RAM_BASE + offset + 4 * i) = ec_point2->x[i];
467  }
468 
469  /* Determine the offset in PKA RAM for the next data. */
470  offset += 4 * (i + extraBuf);
471 
472  /* Load the y co-ordinate value of the second EC point in PKA RAM. */
473  for(i = 0; i < curve->size; i++) {
474  REG(PKA_RAM_BASE + offset + 4 * i) = ec_point2->y[i];
475  }
476 
477  /* Determine the offset in PKA RAM for the next data. */
478  offset += 4 * (i + extraBuf);
479 
480  /* Copy the result vector location. */
481  *result_vector = PKA_RAM_BASE + offset;
482 
483  /* Load D ptr with the result location in PKA RAM. */
484  REG(PKA_DPTR) = offset >> 2;
485 
486  /* Load length registers. */
487  REG(PKA_BLENGTH) = curve->size;
488 
489  /* Set the PKA Function to ECC-ADD and start the operation. */
490  REG(PKA_FUNCTION) = 0x0000B000;
491 
492  /* Enable Interrupt */
493  if(process != NULL) {
495  NVIC_ClearPendingIRQ(PKA_IRQn);
496  NVIC_EnableIRQ(PKA_IRQn);
497  }
498 
499  return PKA_STATUS_SUCCESS;
500 }
501 /*---------------------------------------------------------------------------*/
502 uint8_t
503 ecc_add_get_result(ec_point_t *ec_point, uint32_t result_vector)
504 {
505  uint32_t regMSWVal;
506  uint32_t addr;
507  int i;
508  uint32_t len;
509 
510  /* Check for the arguments. */
511  ASSERT(NULL != ec_point);
512  ASSERT(NULL != ec_point->x);
513  ASSERT(NULL != ec_point->y);
514  ASSERT(result_vector > PKA_RAM_BASE);
515  ASSERT(result_vector < (PKA_RAM_BASE + PKA_RAM_SIZE));
516 
517  if((REG(PKA_FUNCTION) & PKA_FUNCTION_RUN) != 0) {
519  }
520 
521  /* Disable Interrupt */
522  NVIC_DisableIRQ(PKA_IRQn);
524 
525  if(REG(PKA_SHIFT) == 0x00000000) {
526  /* Get the MSW register value. */
527  regMSWVal = REG(PKA_MSW);
528 
529  /* Check to make sure that the result vector is not all zeroes. */
530  if(regMSWVal & PKA_MSW_RESULT_IS_ZERO) {
531  return PKA_STATUS_RESULT_0;
532  }
533 
534  /* Get the length of the result. */
535  len = ((regMSWVal & PKA_MSW_MSW_ADDRESS_M) + 1)
536  - ((result_vector - PKA_RAM_BASE) >> 2);
537 
538  addr = result_vector;
539 
540  /* Copy the x co-ordinate value of result from vector D into the
541  * the output EC Point. */
542  for(i = 0; i < len; i++) {
543  ec_point->x[i] = REG(addr + 4 * i);
544  }
545 
546  addr += 4 * (i + 2 + len % 2);
547 
548  /* Copy the y co-ordinate value of result from vector D into the
549  * the output EC Point. */
550  for(i = 0; i < len; i++) {
551  ec_point->y[i] = REG(addr + 4 * i);
552  }
553 
554  return PKA_STATUS_SUCCESS;
555  } else {
556  return PKA_STATUS_FAILURE;
557  }
558 }
559 /** @} */
#define PKA_STATUS_SUCCESS
Success.
Definition: pka.h:1296
Header file for the ARM Nested Vectored Interrupt Controller.
uint8_t ecc_mul_get_result(ec_point_t *ec_point, uint32_t result_vector)
Gets the result of ECC Multiplication.
Definition: ecc-driver.c:163
static uip_ds6_addr_t * addr
Pointer to a nbr cache entry.
Definition: uip-nd6.c:107
uint8_t ecc_mul_gen_pt_start(uint32_t *scalar, ecc_curve_info_t *curve, uint32_t *result_vector, struct process *process)
Starts the ECC Multiplication with Generator point.
Definition: ecc-driver.c:223
#define PKA_FUNCTION
PKA function This register contains the control bits to start basic PKCP as well as complex sequencer...
Definition: pka.h:273
#define PKA_STATUS_FAILURE
Failure.
Definition: pka.h:1297
Header file with register manipulation macro definitions.
#define PKA_RAM_BASE
PKA Memory Address.
Definition: pka.h:57
uint8_t ecc_add_get_result(ec_point_t *ec_point, uint32_t result_vector)
Gets the result of the ECC Addition.
Definition: ecc-driver.c:503
#define PKA_CPTR
PKA vector C address During execution of basic PKCP operations, this register is double buffered and ...
Definition: pka.h:132
uint8_t ecc_mul_start(uint32_t *scalar, ec_point_t *ec_point, ecc_curve_info_t *curve, uint32_t *result_vector, struct process *process)
Starts ECC Multiplication.
Definition: ecc-driver.c:50
uint8_t ecc_mul_gen_pt_get_result(ec_point_t *ec_point, uint32_t result_vector)
Gets the result of ECC Multiplication with Generator point.
Definition: ecc-driver.c:330
#define PKA_STATUS_RESULT_0
Result is all zeros.
Definition: pka.h:1300
PKA Interrupt.
Definition: cc2538_cm3.h:112
#define PKA_MSW_MSW_ADDRESS_M
Address of the most-significant nonzero 32-bit word of the result vector in PKA RAM.
Definition: pka.h:919
Header file for the cc2538 ECC driver.
#define PKA_ALENGTH
PKA vector A length During execution of basic PKCP operations, this register is double buffered and c...
Definition: pka.h:190
#define PKA_SHIFT
PKA bit shift value For basic PKCP operations, modifying the contents of this register is made imposs...
Definition: pka.h:248
uint8_t ecc_add_start(ec_point_t *ec_point1, ec_point_t *ec_point2, ecc_curve_info_t *curve, uint32_t *result_vector, struct process *process)
Starts the ECC Addition.
Definition: ecc-driver.c:391
#define PKA_STATUS_OPERATION_INPRG
PKA operation is in progress.
Definition: pka.h:1311
#define PKA_BLENGTH
PKA vector B length During execution of basic PKCP operations, this register is double buffered and c...
Definition: pka.h:219
#define PKA_APTR
PKA vector A address During execution of basic PKCP operations, this register is double buffered and ...
Definition: pka.h:74
#define PKA_MAX_CURVE_SIZE
Define for the maximum curve size supported by the PKA module in 32 bit word.
Definition: pka.h:59
#define PKA_FUNCTION_RUN
The host sets this bit to instruct the PKA module to begin processing the basic PKCP or complex seque...
Definition: pka.h:733
#define PKA_MSW
PKA most-significant-word of result vector This register indicates the (word) address in the PKA RAM ...
Definition: pka.h:337
#define PKA_DPTR
PKA vector D address During execution of basic PKCP operations, this register is double buffered and ...
Definition: pka.h:161
void pka_register_process_notification(struct process *p)
Registers a process to be notified of the completion of a PKA operation.
Definition: pka.c:119
#define PKA_RAM_SIZE
PKA Memory Size.
Definition: pka.h:58
#define PKA_MSW_RESULT_IS_ZERO
The result vector is all zeroes, ignore the address returned in bits [10:0].
Definition: pka.h:911
#define PKA_BPTR
PKA vector B address During execution of basic PKCP operations, this register is double buffered and ...
Definition: pka.h:103