git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/MSP430X_MSP430FR5969_LaunchPad_IAR_CCS/driverlib/MSP430FR5xx_6xx/aes256.c

   1 /* --COPYRIGHT--,BSD\r
   2  * Copyright (c) 2014, Texas Instruments Incorporated\r
   3  * All rights reserved.\r
   4  *\r
   5  * Redistribution and use in source and binary forms, with or without\r
   6  * modification, are permitted provided that the following conditions\r
   7  * are met:\r
   8  *\r
   9  * *  Redistributions of source code must retain the above copyright\r
  10  *    notice, this list of conditions and the following disclaimer.\r
  11  *\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
  15  *\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
  19  *\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
  31  * --/COPYRIGHT--*/\r
  32 //*****************************************************************************\r
  33 //\r
  34 // aes256.c - Driver for the aes256 Module.\r
  35 //\r
  36 //*****************************************************************************\r
  37 \r
  38 //*****************************************************************************\r
  39 //\r
  40 //! \addtogroup aes256_api aes256\r
  41 //! @{\r
  42 //\r
  43 //*****************************************************************************\r
  44 \r
  45 #include "inc/hw_regaccess.h"\r
  46 #include "inc/hw_memmap.h"\r
  47 \r
  48 #ifdef __MSP430_HAS_AES256__\r
  49 #include "aes256.h"\r
  50 \r
  51 #include <assert.h>\r
  52 \r
  53 uint8_t AES256_setCipherKey(uint16_t baseAddress,\r
  54                             const uint8_t * cipherKey,\r
  55                             uint16_t keyLength)\r
  56 {\r
  57     uint8_t i;\r
  58     uint16_t sCipherKey;\r
  59 \r
  60     HWREG16(baseAddress + OFS_AESACTL0) &= (~(AESKL_1 + AESKL_2));\r
  61 \r
  62     switch(keyLength)\r
  63     {\r
  64     case AES256_KEYLENGTH_128BIT:\r
  65         HWREG16(baseAddress + OFS_AESACTL0) |= AESKL__128;\r
  66         break;\r
  67 \r
  68     case AES256_KEYLENGTH_192BIT:\r
  69         HWREG16(baseAddress + OFS_AESACTL0) |= AESKL__192;\r
  70         break;\r
  71 \r
  72     case AES256_KEYLENGTH_256BIT:\r
  73         HWREG16(baseAddress + OFS_AESACTL0) |= AESKL__256;\r
  74         break;\r
  75 \r
  76     default:\r
  77         return(STATUS_FAIL);\r
  78     }\r
  79 \r
  80     keyLength = keyLength / 8;\r
  81 \r
  82     for(i = 0; i < keyLength; i = i + 2)\r
  83     {\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
  87     }\r
  88 \r
  89     // Wait until key is written\r
  90     while(0x00 == (HWREG16(baseAddress + OFS_AESASTAT) & AESKEYWR))\r
  91     {\r
  92         ;\r
  93     }\r
  94     return(STATUS_SUCCESS);\r
  95 }\r
  96 \r
  97 void AES256_encryptData(uint16_t baseAddress,\r
  98                         const uint8_t * data,\r
  99                         uint8_t * encryptedData)\r
 100 {\r
 101     uint8_t i;\r
 102     uint16_t tempData = 0;\r
 103     uint16_t tempVariable = 0;\r
 104 \r
 105     // Set module to encrypt mode\r
 106     HWREG16(baseAddress + OFS_AESACTL0) &= ~AESOP_3;\r
 107 \r
 108     // Write data to encrypt to module\r
 109     for(i = 0; i < 16; i = i + 2)\r
 110     {\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
 114     }\r
 115 \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
 119 \r
 120     // Wait unit finished ~167 MCLK\r
 121     while(AESBUSY == (HWREG16(baseAddress + OFS_AESASTAT) & AESBUSY))\r
 122     {\r
 123         ;\r
 124     }\r
 125 \r
 126     // Write encrypted data back to variable\r
 127     for(i = 0; i < 16; i = i + 2)\r
 128     {\r
 129         tempData = HWREG16(baseAddress + OFS_AESADOUT);\r
 130         *(encryptedData + i) = (uint8_t)tempData;\r
 131         *(encryptedData + i + 1) = (uint8_t)(tempData >> 8);\r
 132     }\r
 133 }\r
 134 \r
 135 void AES256_decryptData(uint16_t baseAddress,\r
 136                         const uint8_t * data,\r
 137                         uint8_t * decryptedData)\r
 138 {\r
 139     uint8_t i;\r
 140     uint16_t tempData = 0;\r
 141     uint16_t tempVariable = 0;\r
 142 \r
 143     // Set module to decrypt mode\r
 144     HWREG16(baseAddress + OFS_AESACTL0) |= (AESOP_3);\r
 145 \r
 146     // Write data to decrypt to module\r
 147     for(i = 0; i < 16; i = i + 2)\r
 148     {\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
 152     }\r
 153 \r
 154     // Key that is already written shall be used\r
 155     // Now decryption starts\r
 156     HWREG16(baseAddress + OFS_AESASTAT) |= AESKEYWR;\r
 157 \r
 158     // Wait unit finished ~167 MCLK\r
 159     while(AESBUSY == (HWREG16(baseAddress + OFS_AESASTAT) & AESBUSY))\r
 160     {\r
 161         ;\r
 162     }\r
 163 \r
 164     // Write encrypted data back to variable\r
 165     for(i = 0; i < 16; i = i + 2)\r
 166     {\r
 167         tempData = HWREG16(baseAddress + OFS_AESADOUT);\r
 168         *(decryptedData + i) = (uint8_t)tempData;\r
 169         *(decryptedData + i + 1) = (uint8_t)(tempData >> 8);\r
 170     }\r
 171 }\r
 172 \r
 173 uint8_t AES256_setDecipherKey(uint16_t baseAddress,\r
 174                               const uint8_t * cipherKey,\r
 175                               uint16_t keyLength)\r
 176 {\r
 177     uint8_t i;\r
 178     uint16_t tempVariable = 0;\r
 179 \r
 180     // Set module to decrypt mode\r
 181     HWREG16(baseAddress + OFS_AESACTL0) &= ~(AESOP0);\r
 182     HWREG16(baseAddress + OFS_AESACTL0) |= AESOP1;\r
 183 \r
 184     switch(keyLength)\r
 185     {\r
 186     case AES256_KEYLENGTH_128BIT:\r
 187         HWREG16(baseAddress + OFS_AESACTL0) |= AESKL__128;\r
 188         break;\r
 189 \r
 190     case AES256_KEYLENGTH_192BIT:\r
 191         HWREG16(baseAddress + OFS_AESACTL0) |= AESKL__192;\r
 192         break;\r
 193 \r
 194     case AES256_KEYLENGTH_256BIT:\r
 195         HWREG16(baseAddress + OFS_AESACTL0) |= AESKL__256;\r
 196         break;\r
 197 \r
 198     default:\r
 199         return(STATUS_FAIL);\r
 200     }\r
 201 \r
 202     keyLength = keyLength / 8;\r
 203 \r
 204     // Write cipher key to key register\r
 205     for(i = 0; i < keyLength; i = i + 2)\r
 206     {\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
 210     }\r
 211 \r
 212     // Wait until key is processed ~52 MCLK\r
 213     while((HWREG16(baseAddress + OFS_AESASTAT) & AESBUSY) == AESBUSY)\r
 214     {\r
 215         ;\r
 216     }\r
 217 \r
 218     return(STATUS_SUCCESS);\r
 219 }\r
 220 \r
 221 void AES256_clearInterrupt(uint16_t baseAddress)\r
 222 {\r
 223     HWREG16(baseAddress + OFS_AESACTL0) &= ~AESRDYIFG;\r
 224 }\r
 225 \r
 226 uint32_t AES256_getInterruptStatus(uint16_t baseAddress)\r
 227 {\r
 228     return ((HWREG16(baseAddress + OFS_AESACTL0) & AESRDYIFG) << 0x04);\r
 229 }\r
 230 \r
 231 void AES256_enableInterrupt(uint16_t baseAddress)\r
 232 {\r
 233     HWREG16(baseAddress + OFS_AESACTL0) |= AESRDYIE;\r
 234 }\r
 235 \r
 236 void AES256_disableInterrupt(uint16_t baseAddress)\r
 237 {\r
 238     HWREG16(baseAddress + OFS_AESACTL0) &= ~AESRDYIE;\r
 239 }\r
 240 \r
 241 void AES256_reset(uint16_t baseAddress)\r
 242 {\r
 243     HWREG16(baseAddress + OFS_AESACTL0) |= AESSWRST;\r
 244 }\r
 245 \r
 246 void AES256_startEncryptData(uint16_t baseAddress,\r
 247                              const uint8_t * data)\r
 248 {\r
 249     uint8_t i;\r
 250     uint16_t tempVariable = 0;\r
 251 \r
 252     // Set module to encrypt mode\r
 253     HWREG16(baseAddress + OFS_AESACTL0) &= ~AESOP_3;\r
 254 \r
 255     // Write data to encrypt to module\r
 256     for(i = 0; i < 16; i = i + 2)\r
 257     {\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
 261     }\r
 262 \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
 266 }\r
 267 \r
 268 void AES256_startDecryptData(uint16_t baseAddress,\r
 269                              const uint8_t * data)\r
 270 {\r
 271     uint8_t i;\r
 272     uint16_t tempVariable = 0;\r
 273 \r
 274     // Set module to decrypt mode\r
 275     HWREG16(baseAddress + OFS_AESACTL0) |= (AESOP_3);\r
 276 \r
 277     // Write data to decrypt to module\r
 278     for(i = 0; i < 16; i = i + 2)\r
 279     {\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
 283     }\r
 284 \r
 285     // Key that is already written shall be used\r
 286     // Now decryption starts\r
 287     HWREG16(baseAddress + OFS_AESASTAT) |= AESKEYWR;\r
 288 }\r
 289 \r
 290 uint8_t AES256_startSetDecipherKey(uint16_t baseAddress,\r
 291                                    const uint8_t * cipherKey,\r
 292                                    uint16_t keyLength)\r
 293 {\r
 294     uint8_t i;\r
 295     uint16_t tempVariable = 0;\r
 296 \r
 297     HWREG16(baseAddress + OFS_AESACTL0) &= ~(AESOP0);\r
 298     HWREG16(baseAddress + OFS_AESACTL0) |= AESOP1;\r
 299 \r
 300     switch(keyLength)\r
 301     {\r
 302     case AES256_KEYLENGTH_128BIT:\r
 303         HWREG16(baseAddress + OFS_AESACTL0) |= AESKL__128;\r
 304         break;\r
 305 \r
 306     case AES256_KEYLENGTH_192BIT:\r
 307         HWREG16(baseAddress + OFS_AESACTL0) |= AESKL__192;\r
 308         break;\r
 309 \r
 310     case AES256_KEYLENGTH_256BIT:\r
 311         HWREG16(baseAddress + OFS_AESACTL0) |= AESKL__256;\r
 312         break;\r
 313 \r
 314     default:\r
 315         return(STATUS_FAIL);\r
 316     }\r
 317 \r
 318     keyLength = keyLength / 8;\r
 319 \r
 320     // Write cipher key to key register\r
 321     for(i = 0; i < keyLength; i = i + 2)\r
 322     {\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
 326     }\r
 327 \r
 328     return(STATUS_SUCCESS);\r
 329 }\r
 330 \r
 331 uint8_t AES256_getDataOut(uint16_t baseAddress,\r
 332                           uint8_t *outputData)\r
 333 {\r
 334     uint8_t i;\r
 335     uint16_t tempData = 0;\r
 336 \r
 337     // If module is busy, exit and return failure\r
 338     if(AESBUSY == (HWREG16(baseAddress + OFS_AESASTAT) & AESBUSY))\r
 339     {\r
 340         return(STATUS_FAIL);\r
 341     }\r
 342 \r
 343     // Write encrypted data back to variable\r
 344     for(i = 0; i < 16; i = i + 2)\r
 345     {\r
 346         tempData = HWREG16(baseAddress + OFS_AESADOUT);\r
 347         *(outputData + i) = (uint8_t)tempData;\r
 348         *(outputData + i + 1) = (uint8_t)(tempData >> 8);\r
 349     }\r
 350 \r
 351     return(STATUS_SUCCESS);\r
 352 }\r
 353 \r
 354 uint16_t AES256_isBusy(uint16_t baseAddress)\r
 355 {\r
 356     return (HWREG16(baseAddress + OFS_AESASTAT) & AESBUSY);\r
 357 }\r
 358 \r
 359 void AES256_clearErrorFlag(uint16_t baseAddress)\r
 360 {\r
 361     HWREG16(baseAddress + OFS_AESACTL0) &= ~AESERRFG;\r
 362 }\r
 363 \r
 364 uint32_t AES256_getErrorFlagStatus(uint16_t baseAddress)\r
 365 {\r
 366     return (HWREG16(baseAddress + OFS_AESACTL0) & AESERRFG);\r
 367 }\r
 368 \r
 369 #endif\r
 370 //*****************************************************************************\r
 371 //\r
 372 //! Close the doxygen group for aes256_api\r
 373 //! @}\r
 374 //\r
 375 //*****************************************************************************\r