2 * Copyright (c) 2014, Texas Instruments Incorporated
\r
3 * All rights reserved.
\r
5 * Redistribution and use in source and binary forms, with or without
\r
6 * modification, are permitted provided that the following conditions
\r
9 * * Redistributions of source code must retain the above copyright
\r
10 * notice, this list of conditions and the following disclaimer.
\r
12 * * Redistributions in binary form must reproduce the above copyright
\r
13 * notice, this list of conditions and the following disclaimer in the
\r
14 * documentation and/or other materials provided with the distribution.
\r
16 * * Neither the name of Texas Instruments Incorporated nor the names of
\r
17 * its contributors may be used to endorse or promote products derived
\r
18 * from this software without specific prior written permission.
\r
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
\r
21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
\r
22 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
\r
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
\r
24 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
\r
25 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
\r
26 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
\r
27 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
\r
28 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
\r
29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
\r
30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\r
32 //*****************************************************************************
\r
34 // aes256.c - Driver for the aes256 Module.
\r
36 //*****************************************************************************
\r
38 //*****************************************************************************
\r
40 //! \addtogroup aes256_api aes256
\r
43 //*****************************************************************************
\r
45 #include "inc/hw_regaccess.h"
\r
46 #include "inc/hw_memmap.h"
\r
48 #ifdef __MSP430_HAS_AES256__
\r
53 uint8_t AES256_setCipherKey(uint16_t baseAddress,
\r
54 const uint8_t * cipherKey,
\r
58 uint16_t sCipherKey;
\r
60 HWREG16(baseAddress + OFS_AESACTL0) &= (~(AESKL_1 + AESKL_2));
\r
64 case AES256_KEYLENGTH_128BIT:
\r
65 HWREG16(baseAddress + OFS_AESACTL0) |= AESKL__128;
\r
68 case AES256_KEYLENGTH_192BIT:
\r
69 HWREG16(baseAddress + OFS_AESACTL0) |= AESKL__192;
\r
72 case AES256_KEYLENGTH_256BIT:
\r
73 HWREG16(baseAddress + OFS_AESACTL0) |= AESKL__256;
\r
77 return(STATUS_FAIL);
\r
80 keyLength = keyLength / 8;
\r
82 for(i = 0; i < keyLength; i = i + 2)
\r
84 sCipherKey = (uint16_t)(cipherKey[i]);
\r
85 sCipherKey = sCipherKey | ((uint16_t)(cipherKey[i + 1]) << 8);
\r
86 HWREG16(baseAddress + OFS_AESAKEY) = sCipherKey;
\r
89 // Wait until key is written
\r
90 while(0x00 == (HWREG16(baseAddress + OFS_AESASTAT) & AESKEYWR))
\r
94 return(STATUS_SUCCESS);
\r
97 void AES256_encryptData(uint16_t baseAddress,
\r
98 const uint8_t * data,
\r
99 uint8_t * encryptedData)
\r
102 uint16_t tempData = 0;
\r
103 uint16_t tempVariable = 0;
\r
105 // Set module to encrypt mode
\r
106 HWREG16(baseAddress + OFS_AESACTL0) &= ~AESOP_3;
\r
108 // Write data to encrypt to module
\r
109 for(i = 0; i < 16; i = i + 2)
\r
111 tempVariable = (uint16_t)(data[i]);
\r
112 tempVariable = tempVariable | ((uint16_t)(data[i + 1]) << 8);
\r
113 HWREG16(baseAddress + OFS_AESADIN) = tempVariable;
\r
116 // Key that is already written shall be used
\r
117 // Encryption is initialized by setting AESKEYWR to 1
\r
118 HWREG16(baseAddress + OFS_AESASTAT) |= AESKEYWR;
\r
120 // Wait unit finished ~167 MCLK
\r
121 while(AESBUSY == (HWREG16(baseAddress + OFS_AESASTAT) & AESBUSY))
\r
126 // Write encrypted data back to variable
\r
127 for(i = 0; i < 16; i = i + 2)
\r
129 tempData = HWREG16(baseAddress + OFS_AESADOUT);
\r
130 *(encryptedData + i) = (uint8_t)tempData;
\r
131 *(encryptedData + i + 1) = (uint8_t)(tempData >> 8);
\r
135 void AES256_decryptData(uint16_t baseAddress,
\r
136 const uint8_t * data,
\r
137 uint8_t * decryptedData)
\r
140 uint16_t tempData = 0;
\r
141 uint16_t tempVariable = 0;
\r
143 // Set module to decrypt mode
\r
144 HWREG16(baseAddress + OFS_AESACTL0) |= (AESOP_3);
\r
146 // Write data to decrypt to module
\r
147 for(i = 0; i < 16; i = i + 2)
\r
149 tempVariable = (uint16_t)(data[i + 1] << 8);
\r
150 tempVariable = tempVariable | ((uint16_t)(data[i]));
\r
151 HWREG16(baseAddress + OFS_AESADIN) = tempVariable;
\r
154 // Key that is already written shall be used
\r
155 // Now decryption starts
\r
156 HWREG16(baseAddress + OFS_AESASTAT) |= AESKEYWR;
\r
158 // Wait unit finished ~167 MCLK
\r
159 while(AESBUSY == (HWREG16(baseAddress + OFS_AESASTAT) & AESBUSY))
\r
164 // Write encrypted data back to variable
\r
165 for(i = 0; i < 16; i = i + 2)
\r
167 tempData = HWREG16(baseAddress + OFS_AESADOUT);
\r
168 *(decryptedData + i) = (uint8_t)tempData;
\r
169 *(decryptedData + i + 1) = (uint8_t)(tempData >> 8);
\r
173 uint8_t AES256_setDecipherKey(uint16_t baseAddress,
\r
174 const uint8_t * cipherKey,
\r
175 uint16_t keyLength)
\r
178 uint16_t tempVariable = 0;
\r
180 // Set module to decrypt mode
\r
181 HWREG16(baseAddress + OFS_AESACTL0) &= ~(AESOP0);
\r
182 HWREG16(baseAddress + OFS_AESACTL0) |= AESOP1;
\r
186 case AES256_KEYLENGTH_128BIT:
\r
187 HWREG16(baseAddress + OFS_AESACTL0) |= AESKL__128;
\r
190 case AES256_KEYLENGTH_192BIT:
\r
191 HWREG16(baseAddress + OFS_AESACTL0) |= AESKL__192;
\r
194 case AES256_KEYLENGTH_256BIT:
\r
195 HWREG16(baseAddress + OFS_AESACTL0) |= AESKL__256;
\r
199 return(STATUS_FAIL);
\r
202 keyLength = keyLength / 8;
\r
204 // Write cipher key to key register
\r
205 for(i = 0; i < keyLength; i = i + 2)
\r
207 tempVariable = (uint16_t)(cipherKey[i]);
\r
208 tempVariable = tempVariable | ((uint16_t)(cipherKey[i + 1]) << 8);
\r
209 HWREG16(baseAddress + OFS_AESAKEY) = tempVariable;
\r
212 // Wait until key is processed ~52 MCLK
\r
213 while((HWREG16(baseAddress + OFS_AESASTAT) & AESBUSY) == AESBUSY)
\r
218 return(STATUS_SUCCESS);
\r
221 void AES256_clearInterrupt(uint16_t baseAddress)
\r
223 HWREG16(baseAddress + OFS_AESACTL0) &= ~AESRDYIFG;
\r
226 uint32_t AES256_getInterruptStatus(uint16_t baseAddress)
\r
228 return ((HWREG16(baseAddress + OFS_AESACTL0) & AESRDYIFG) << 0x04);
\r
231 void AES256_enableInterrupt(uint16_t baseAddress)
\r
233 HWREG16(baseAddress + OFS_AESACTL0) |= AESRDYIE;
\r
236 void AES256_disableInterrupt(uint16_t baseAddress)
\r
238 HWREG16(baseAddress + OFS_AESACTL0) &= ~AESRDYIE;
\r
241 void AES256_reset(uint16_t baseAddress)
\r
243 HWREG16(baseAddress + OFS_AESACTL0) |= AESSWRST;
\r
246 void AES256_startEncryptData(uint16_t baseAddress,
\r
247 const uint8_t * data)
\r
250 uint16_t tempVariable = 0;
\r
252 // Set module to encrypt mode
\r
253 HWREG16(baseAddress + OFS_AESACTL0) &= ~AESOP_3;
\r
255 // Write data to encrypt to module
\r
256 for(i = 0; i < 16; i = i + 2)
\r
258 tempVariable = (uint16_t)(data[i]);
\r
259 tempVariable = tempVariable | ((uint16_t)(data[i + 1 ]) << 8);
\r
260 HWREG16(baseAddress + OFS_AESADIN) = tempVariable;
\r
263 // Key that is already written shall be used
\r
264 // Encryption is initialized by setting AESKEYWR to 1
\r
265 HWREG16(baseAddress + OFS_AESASTAT) |= AESKEYWR;
\r
268 void AES256_startDecryptData(uint16_t baseAddress,
\r
269 const uint8_t * data)
\r
272 uint16_t tempVariable = 0;
\r
274 // Set module to decrypt mode
\r
275 HWREG16(baseAddress + OFS_AESACTL0) |= (AESOP_3);
\r
277 // Write data to decrypt to module
\r
278 for(i = 0; i < 16; i = i + 2)
\r
280 tempVariable = (uint16_t)(data[i + 1] << 8);
\r
281 tempVariable = tempVariable | ((uint16_t)(data[i]));
\r
282 HWREG16(baseAddress + OFS_AESADIN) = tempVariable;
\r
285 // Key that is already written shall be used
\r
286 // Now decryption starts
\r
287 HWREG16(baseAddress + OFS_AESASTAT) |= AESKEYWR;
\r
290 uint8_t AES256_startSetDecipherKey(uint16_t baseAddress,
\r
291 const uint8_t * cipherKey,
\r
292 uint16_t keyLength)
\r
295 uint16_t tempVariable = 0;
\r
297 HWREG16(baseAddress + OFS_AESACTL0) &= ~(AESOP0);
\r
298 HWREG16(baseAddress + OFS_AESACTL0) |= AESOP1;
\r
302 case AES256_KEYLENGTH_128BIT:
\r
303 HWREG16(baseAddress + OFS_AESACTL0) |= AESKL__128;
\r
306 case AES256_KEYLENGTH_192BIT:
\r
307 HWREG16(baseAddress + OFS_AESACTL0) |= AESKL__192;
\r
310 case AES256_KEYLENGTH_256BIT:
\r
311 HWREG16(baseAddress + OFS_AESACTL0) |= AESKL__256;
\r
315 return(STATUS_FAIL);
\r
318 keyLength = keyLength / 8;
\r
320 // Write cipher key to key register
\r
321 for(i = 0; i < keyLength; i = i + 2)
\r
323 tempVariable = (uint16_t)(cipherKey[i]);
\r
324 tempVariable = tempVariable | ((uint16_t)(cipherKey[i + 1]) << 8);
\r
325 HWREG16(baseAddress + OFS_AESAKEY) = tempVariable;
\r
328 return(STATUS_SUCCESS);
\r
331 uint8_t AES256_getDataOut(uint16_t baseAddress,
\r
332 uint8_t *outputData)
\r
335 uint16_t tempData = 0;
\r
337 // If module is busy, exit and return failure
\r
338 if(AESBUSY == (HWREG16(baseAddress + OFS_AESASTAT) & AESBUSY))
\r
340 return(STATUS_FAIL);
\r
343 // Write encrypted data back to variable
\r
344 for(i = 0; i < 16; i = i + 2)
\r
346 tempData = HWREG16(baseAddress + OFS_AESADOUT);
\r
347 *(outputData + i) = (uint8_t)tempData;
\r
348 *(outputData + i + 1) = (uint8_t)(tempData >> 8);
\r
351 return(STATUS_SUCCESS);
\r
354 uint16_t AES256_isBusy(uint16_t baseAddress)
\r
356 return (HWREG16(baseAddress + OFS_AESASTAT) & AESBUSY);
\r
359 void AES256_clearErrorFlag(uint16_t baseAddress)
\r
361 HWREG16(baseAddress + OFS_AESACTL0) &= ~AESERRFG;
\r
364 uint32_t AES256_getErrorFlagStatus(uint16_t baseAddress)
\r
366 return (HWREG16(baseAddress + OFS_AESACTL0) & AESERRFG);
\r
370 //*****************************************************************************
\r
372 //! Close the doxygen group for aes256_api
\r
375 //*****************************************************************************
\r