git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M4_SimpleLink_CC3220SF_CCS/ti/devices/cc32xx/driverlib/rom.h

   1 /*
   2  * -------------------------------------------
   3  *    CC3220 SDK - v0.10.00.00
   4  * -------------------------------------------
   5  *
   6  *  Copyright (C) 2015 Texas Instruments Incorporated - http://www.ti.com/
   7  *
   8  *  Redistribution and use in source and binary forms, with or without
   9  *  modification, are permitted provided that the following conditions
  10  *  are met:
  11  *
  12  *    Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  *    Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the
  18  *    distribution.
  19  *
  20  *    Neither the name of Texas Instruments Incorporated nor the names of
  21  *    its contributors may be used to endorse or promote products derived
  22  *    from this software without specific prior written permission.
  23  *
  24  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  25  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  26  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  27  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  28  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  29  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  30  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  31  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  32  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  33  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  34  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35  *
  36  */
  37 //*****************************************************************************
  38 //
  39 // rom.h - Macros to facilitate calling functions in the ROM.
  40 //
  41 //
  42 //*****************************************************************************
  43 //
  44 // THIS IS AN AUTO-GENERATED FILE.  DO NOT EDIT BY HAND.
  45 //
  46 //*****************************************************************************
  47
  48 #ifndef __ROM_H__
  49 #define __ROM_H__
  50
  51 //*****************************************************************************
  52 //
  53 // For backward compatibility with older Driverlib versions
  54 //
  55 //*****************************************************************************
  56 #ifdef TARGET_IS_CC3200
  57 #define USE_CC3200_ROM_DRV_API
  58 #endif
  59
  60 //*****************************************************************************
  61 //
  62 // Pointers to the main API tables.
  63 //
  64 //*****************************************************************************
  65 #define ROM_APITABLE            ((unsigned long *)0x0000040C)
  66 #define ROM_VERSION             (ROM_APITABLE[0])
  67 #define ROM_UARTTABLE           ((unsigned long *)(ROM_APITABLE[1]))
  68 #define ROM_TIMERTABLE          ((unsigned long *)(ROM_APITABLE[2]))
  69 #define ROM_WATCHDOGTABLE       ((unsigned long *)(ROM_APITABLE[3]))
  70 #define ROM_INTERRUPTTABLE      ((unsigned long *)(ROM_APITABLE[4]))
  71 #define ROM_UDMATABLE           ((unsigned long *)(ROM_APITABLE[5]))
  72 #define ROM_PRCMTABLE           ((unsigned long *)(ROM_APITABLE[6]))
  73 #define ROM_I2CTABLE            ((unsigned long *)(ROM_APITABLE[7]))
  74 #define ROM_SPITABLE            ((unsigned long *)(ROM_APITABLE[8]))
  75 #define ROM_CAMERATABLE         ((unsigned long *)(ROM_APITABLE[9]))
  76 #define ROM_FLASHTABLE          ((unsigned long *)(ROM_APITABLE[10]))
  77 #define ROM_PINTABLE            ((unsigned long *)(ROM_APITABLE[11]))
  78 #define ROM_SYSTICKTABLE        ((unsigned long *)(ROM_APITABLE[12]))
  79 #define ROM_UTILSTABLE          ((unsigned long *)(ROM_APITABLE[13]))
  80 #define ROM_I2STABLE            ((unsigned long *)(ROM_APITABLE[14]))
  81 #define ROM_HWSPINLOCKTABLE     ((unsigned long *)(ROM_APITABLE[15]))
  82 #define ROM_GPIOTABLE           ((unsigned long *)(ROM_APITABLE[16]))
  83 #define ROM_AESTABLE            ((unsigned long *)(ROM_APITABLE[17]))
  84 #define ROM_DESTABLE            ((unsigned long *)(ROM_APITABLE[18]))
  85 #define ROM_SHAMD5TABLE         ((unsigned long *)(ROM_APITABLE[19]))
  86 #define ROM_CRCTABLE            ((unsigned long *)(ROM_APITABLE[20]))
  87 #define ROM_SDHOSTTABLE         ((unsigned long *)(ROM_APITABLE[21]))
  88 #define ROM_ADCTABLE            ((unsigned long *)(ROM_APITABLE[22]))
  89 #define ROM_CPUTABLE            ((unsigned long *)(ROM_APITABLE[23]))
  90
  91 //*****************************************************************************
  92 //
  93 // Macros for calling ROM functions in the Interrupt API.
  94 //
  95 //*****************************************************************************
  96 #if defined(USE_CC3200_ROM_DRV_API) || \
  97     defined(USE_CC3220_ROM_DRV_API)
  98 #define ROM_IntEnable                                                         \
  99         ((void (*)(unsigned long ulInterrupt))ROM_INTERRUPTTABLE[0])
 100 #endif
 101 #if defined(USE_CC3200_ROM_DRV_API) || \
 102     defined(USE_CC3220_ROM_DRV_API)
 103 #define ROM_IntMasterEnable                                                   \
 104         ((tBoolean (*)(void))ROM_INTERRUPTTABLE[1])
 105 #endif
 106 #if defined(USE_CC3200_ROM_DRV_API) || \
 107     defined(USE_CC3220_ROM_DRV_API)
 108 #define ROM_IntMasterDisable                                                  \
 109         ((tBoolean (*)(void))ROM_INTERRUPTTABLE[2])
 110 #endif
 111 #if defined(USE_CC3200_ROM_DRV_API) || \
 112     defined(USE_CC3220_ROM_DRV_API)
 113 #define ROM_IntDisable                                                        \
 114         ((void (*)(unsigned long ulInterrupt))ROM_INTERRUPTTABLE[3])
 115 #endif
 116 #if defined(USE_CC3200_ROM_DRV_API) || \
 117     defined(USE_CC3220_ROM_DRV_API)
 118 #define ROM_IntPriorityGroupingSet                                            \
 119         ((void (*)(unsigned long ulBits))ROM_INTERRUPTTABLE[4])
 120 #endif
 121 #if defined(USE_CC3200_ROM_DRV_API) || \
 122     defined(USE_CC3220_ROM_DRV_API)
 123 #define ROM_IntPriorityGroupingGet                                            \
 124         ((unsigned long (*)(void))ROM_INTERRUPTTABLE[5])
 125 #endif
 126 #if defined(USE_CC3200_ROM_DRV_API) || \
 127     defined(USE_CC3220_ROM_DRV_API)
 128 #define ROM_IntPrioritySet                                                    \
 129         ((void (*)(unsigned long ulInterrupt,                                 \
 130                    unsigned char ucPriority))ROM_INTERRUPTTABLE[6])
 131 #endif
 132 #if defined(USE_CC3200_ROM_DRV_API) || \
 133     defined(USE_CC3220_ROM_DRV_API)
 134 #define ROM_IntPriorityGet                                                    \
 135         ((long (*)(unsigned long ulInterrupt))ROM_INTERRUPTTABLE[7])
 136 #endif
 137 #if defined(USE_CC3200_ROM_DRV_API) || \
 138     defined(USE_CC3220_ROM_DRV_API)
 139 #define ROM_IntPendSet                                                        \
 140         ((void (*)(unsigned long ulInterrupt))ROM_INTERRUPTTABLE[8])
 141 #endif
 142 #if defined(USE_CC3200_ROM_DRV_API) || \
 143     defined(USE_CC3220_ROM_DRV_API)
 144 #define ROM_IntPendClear                                                      \
 145         ((void (*)(unsigned long ulInterrupt))ROM_INTERRUPTTABLE[9])
 146 #endif
 147 #if defined(USE_CC3200_ROM_DRV_API) || \
 148     defined(USE_CC3220_ROM_DRV_API)
 149 #define ROM_IntPriorityMaskSet                                                \
 150         ((void (*)(unsigned long ulPriorityMask))ROM_INTERRUPTTABLE[10])
 151 #endif
 152 #if defined(USE_CC3200_ROM_DRV_API) || \
 153     defined(USE_CC3220_ROM_DRV_API)
 154 #define ROM_IntPriorityMaskGet                                                \
 155         ((unsigned long (*)(void))ROM_INTERRUPTTABLE[11])
 156 #endif
 157 #if defined(USE_CC3200_ROM_DRV_API) || \
 158     defined(USE_CC3220_ROM_DRV_API)
 159 #define ROM_IntRegister                                                       \
 160         ((void (*)(unsigned long ulInterrupt,                                 \
 161                    void (*pfnHandler)(void)))ROM_INTERRUPTTABLE[12])
 162 #endif
 163 #if defined(USE_CC3200_ROM_DRV_API) || \
 164     defined(USE_CC3220_ROM_DRV_API)
 165 #define ROM_IntUnregister                                                     \
 166         ((void (*)(unsigned long ulInterrupt))ROM_INTERRUPTTABLE[13])
 167 #endif
 168 #if defined(USE_CC3200_ROM_DRV_API) || \
 169     defined(USE_CC3220_ROM_DRV_API)
 170 #define ROM_IntVTableBaseSet                                                  \
 171         ((void (*)(unsigned long ulVtableBase))ROM_INTERRUPTTABLE[14])
 172 #endif
 173
 174 //*****************************************************************************
 175 //
 176 // Macros for calling ROM functions in the Timer API.
 177 //
 178 //*****************************************************************************
 179 #if defined(USE_CC3200_ROM_DRV_API) || \
 180     defined(USE_CC3220_ROM_DRV_API)
 181 #define ROM_TimerEnable                                                       \
 182         ((void (*)(unsigned long ulBase,                                      \
 183                    unsigned long ulTimer))ROM_TIMERTABLE[0])
 184 #endif
 185 #if defined(USE_CC3200_ROM_DRV_API) || \
 186     defined(USE_CC3220_ROM_DRV_API)
 187 #define ROM_TimerDisable                                                      \
 188         ((void (*)(unsigned long ulBase,                                      \
 189                    unsigned long ulTimer))ROM_TIMERTABLE[1])
 190 #endif
 191 #if defined(USE_CC3200_ROM_DRV_API) || \
 192     defined(USE_CC3220_ROM_DRV_API)
 193 #define ROM_TimerConfigure                                                    \
 194         ((void (*)(unsigned long ulBase,                                      \
 195                    unsigned long ulConfig))ROM_TIMERTABLE[2])
 196 #endif
 197 #if defined(USE_CC3200_ROM_DRV_API) || \
 198     defined(USE_CC3220_ROM_DRV_API)
 199 #define ROM_TimerControlLevel                                                 \
 200         ((void (*)(unsigned long ulBase,                                      \
 201                    unsigned long ulTimer,                                     \
 202                    tBoolean bInvert))ROM_TIMERTABLE[3])
 203 #endif
 204 #if defined(USE_CC3200_ROM_DRV_API) || \
 205     defined(USE_CC3220_ROM_DRV_API)
 206 #define ROM_TimerControlEvent                                                 \
 207         ((void (*)(unsigned long ulBase,                                      \
 208                    unsigned long ulTimer,                                     \
 209                    unsigned long ulEvent))ROM_TIMERTABLE[4])
 210 #endif
 211 #if defined(USE_CC3200_ROM_DRV_API) || \
 212     defined(USE_CC3220_ROM_DRV_API)
 213 #define ROM_TimerControlStall                                                 \
 214         ((void (*)(unsigned long ulBase,                                      \
 215                    unsigned long ulTimer,                                     \
 216                    tBoolean bStall))ROM_TIMERTABLE[5])
 217 #endif
 218 #if defined(USE_CC3200_ROM_DRV_API) || \
 219     defined(USE_CC3220_ROM_DRV_API)
 220 #define ROM_TimerPrescaleSet                                                  \
 221         ((void (*)(unsigned long ulBase,                                      \
 222                    unsigned long ulTimer,                                     \
 223                    unsigned long ulValue))ROM_TIMERTABLE[6])
 224 #endif
 225 #if defined(USE_CC3200_ROM_DRV_API) || \
 226     defined(USE_CC3220_ROM_DRV_API)
 227 #define ROM_TimerPrescaleGet                                                  \
 228         ((unsigned long (*)(unsigned long ulBase,                             \
 229                             unsigned long ulTimer))ROM_TIMERTABLE[7])
 230 #endif
 231 #if defined(USE_CC3200_ROM_DRV_API) || \
 232     defined(USE_CC3220_ROM_DRV_API)
 233 #define ROM_TimerPrescaleMatchSet                                             \
 234         ((void (*)(unsigned long ulBase,                                      \
 235                    unsigned long ulTimer,                                     \
 236                    unsigned long ulValue))ROM_TIMERTABLE[8])
 237 #endif
 238 #if defined(USE_CC3200_ROM_DRV_API) || \
 239     defined(USE_CC3220_ROM_DRV_API)
 240 #define ROM_TimerPrescaleMatchGet                                             \
 241         ((unsigned long (*)(unsigned long ulBase,                             \
 242                             unsigned long ulTimer))ROM_TIMERTABLE[9])
 243 #endif
 244 #if defined(USE_CC3200_ROM_DRV_API) || \
 245     defined(USE_CC3220_ROM_DRV_API)
 246 #define ROM_TimerLoadSet                                                      \
 247         ((void (*)(unsigned long ulBase,                                      \
 248                    unsigned long ulTimer,                                     \
 249                    unsigned long ulValue))ROM_TIMERTABLE[10])
 250 #endif
 251 #if defined(USE_CC3200_ROM_DRV_API) || \
 252     defined(USE_CC3220_ROM_DRV_API)
 253 #define ROM_TimerLoadGet                                                      \
 254         ((unsigned long (*)(unsigned long ulBase,                             \
 255                             unsigned long ulTimer))ROM_TIMERTABLE[11])
 256 #endif
 257 #if defined(USE_CC3200_ROM_DRV_API) || \
 258     defined(USE_CC3220_ROM_DRV_API)
 259 #define ROM_TimerValueGet                                                     \
 260         ((unsigned long (*)(unsigned long ulBase,                             \
 261                             unsigned long ulTimer))ROM_TIMERTABLE[12])
 262 #endif
 263 #if defined(USE_CC3200_ROM_DRV_API) || \
 264     defined(USE_CC3220_ROM_DRV_API)
 265 #define ROM_TimerMatchSet                                                     \
 266         ((void (*)(unsigned long ulBase,                                      \
 267                    unsigned long ulTimer,                                     \
 268                    unsigned long ulValue))ROM_TIMERTABLE[13])
 269 #endif
 270 #if defined(USE_CC3200_ROM_DRV_API) || \
 271     defined(USE_CC3220_ROM_DRV_API)
 272 #define ROM_TimerMatchGet                                                     \
 273         ((unsigned long (*)(unsigned long ulBase,                             \
 274                             unsigned long ulTimer))ROM_TIMERTABLE[14])
 275 #endif
 276 #if defined(USE_CC3200_ROM_DRV_API) || \
 277     defined(USE_CC3220_ROM_DRV_API)
 278 #define ROM_TimerIntRegister                                                  \
 279         ((void (*)(unsigned long ulBase,                                      \
 280                    unsigned long ulTimer,                                     \
 281                    void (*pfnHandler)(void)))ROM_TIMERTABLE[15])
 282 #endif
 283 #if defined(USE_CC3200_ROM_DRV_API) || \
 284     defined(USE_CC3220_ROM_DRV_API)
 285 #define ROM_TimerIntUnregister                                                \
 286         ((void (*)(unsigned long ulBase,                                      \
 287                    unsigned long ulTimer))ROM_TIMERTABLE[16])
 288 #endif
 289 #if defined(USE_CC3200_ROM_DRV_API) || \
 290     defined(USE_CC3220_ROM_DRV_API)
 291 #define ROM_TimerIntEnable                                                    \
 292         ((void (*)(unsigned long ulBase,                                      \
 293                    unsigned long ulIntFlags))ROM_TIMERTABLE[17])
 294 #endif
 295 #if defined(USE_CC3200_ROM_DRV_API) || \
 296     defined(USE_CC3220_ROM_DRV_API)
 297 #define ROM_TimerIntDisable                                                   \
 298         ((void (*)(unsigned long ulBase,                                      \
 299                    unsigned long ulIntFlags))ROM_TIMERTABLE[18])
 300 #endif
 301 #if defined(USE_CC3200_ROM_DRV_API) || \
 302     defined(USE_CC3220_ROM_DRV_API)
 303 #define ROM_TimerIntStatus                                                    \
 304         ((unsigned long (*)(unsigned long ulBase,                             \
 305                             tBoolean bMasked))ROM_TIMERTABLE[19])
 306 #endif
 307 #if defined(USE_CC3200_ROM_DRV_API) || \
 308     defined(USE_CC3220_ROM_DRV_API)
 309 #define ROM_TimerIntClear                                                     \
 310         ((void (*)(unsigned long ulBase,                                      \
 311                    unsigned long ulIntFlags))ROM_TIMERTABLE[20])
 312 #endif
 313 #if defined(USE_CC3220_ROM_DRV_API)
 314 #define ROM_TimerValueSet                                                     \
 315         ((void (*)(unsigned long ulBase,                                      \
 316                    unsigned long ulTimer,                                     \
 317                    unsigned long ulValue))ROM_TIMERTABLE[22])
 318 #endif
 319 #if defined(USE_CC3220_ROM_DRV_API)
 320 #define ROM_TimerDMAEventSet                                                  \
 321         ((void (*)(unsigned long ulBase,                                      \
 322                    unsigned long ulDMAEvent))ROM_TIMERTABLE[23])
 323 #endif
 324 #if defined(USE_CC3220_ROM_DRV_API)
 325 #define ROM_TimerDMAEventGet                                                  \
 326         ((unsigned long (*)(unsigned long ulBase))ROM_TIMERTABLE[24])
 327 #endif
 328
 329 //*****************************************************************************
 330 //
 331 // Macros for calling ROM functions in the UART API.
 332 //
 333 //*****************************************************************************
 334 #if defined(USE_CC3200_ROM_DRV_API) || \
 335     defined(USE_CC3220_ROM_DRV_API)
 336 #define ROM_UARTParityModeSet                                                 \
 337         ((void (*)(unsigned long ulBase,                                      \
 338                    unsigned long ulParity))ROM_UARTTABLE[0])
 339 #endif
 340 #if defined(USE_CC3200_ROM_DRV_API) || \
 341     defined(USE_CC3220_ROM_DRV_API)
 342 #define ROM_UARTParityModeGet                                                 \
 343         ((unsigned long (*)(unsigned long ulBase))ROM_UARTTABLE[1])
 344 #endif
 345 #if defined(USE_CC3200_ROM_DRV_API) || \
 346     defined(USE_CC3220_ROM_DRV_API)
 347 #define ROM_UARTFIFOLevelSet                                                  \
 348         ((void (*)(unsigned long ulBase,                                      \
 349                    unsigned long ulTxLevel,                                   \
 350                    unsigned long ulRxLevel))ROM_UARTTABLE[2])
 351 #endif
 352 #if defined(USE_CC3200_ROM_DRV_API) || \
 353     defined(USE_CC3220_ROM_DRV_API)
 354 #define ROM_UARTFIFOLevelGet                                                  \
 355         ((void (*)(unsigned long ulBase,                                      \
 356                    unsigned long *pulTxLevel,                                 \
 357                    unsigned long *pulRxLevel))ROM_UARTTABLE[3])
 358 #endif
 359 #if defined(USE_CC3200_ROM_DRV_API) || \
 360     defined(USE_CC3220_ROM_DRV_API)
 361 #define ROM_UARTConfigSetExpClk                                               \
 362         ((void (*)(unsigned long ulBase,                                      \
 363                    unsigned long ulUARTClk,                                   \
 364                    unsigned long ulBaud,                                      \
 365                    unsigned long ulConfig))ROM_UARTTABLE[4])
 366 #endif
 367 #if defined(USE_CC3200_ROM_DRV_API) || \
 368     defined(USE_CC3220_ROM_DRV_API)
 369 #define ROM_UARTConfigGetExpClk                                               \
 370         ((void (*)(unsigned long ulBase,                                      \
 371                    unsigned long ulUARTClk,                                   \
 372                    unsigned long *pulBaud,                                    \
 373                    unsigned long *pulConfig))ROM_UARTTABLE[5])
 374 #endif
 375 #if defined(USE_CC3200_ROM_DRV_API) || \
 376     defined(USE_CC3220_ROM_DRV_API)
 377 #define ROM_UARTEnable                                                        \
 378         ((void (*)(unsigned long ulBase))ROM_UARTTABLE[6])
 379 #endif
 380 #if defined(USE_CC3200_ROM_DRV_API) || \
 381     defined(USE_CC3220_ROM_DRV_API)
 382 #define ROM_UARTDisable                                                       \
 383         ((void (*)(unsigned long ulBase))ROM_UARTTABLE[7])
 384 #endif
 385 #if defined(USE_CC3200_ROM_DRV_API) || \
 386     defined(USE_CC3220_ROM_DRV_API)
 387 #define ROM_UARTFIFOEnable                                                    \
 388         ((void (*)(unsigned long ulBase))ROM_UARTTABLE[8])
 389 #endif
 390 #if defined(USE_CC3200_ROM_DRV_API) || \
 391     defined(USE_CC3220_ROM_DRV_API)
 392 #define ROM_UARTFIFODisable                                                   \
 393         ((void (*)(unsigned long ulBase))ROM_UARTTABLE[9])
 394 #endif
 395 #if defined(USE_CC3200_ROM_DRV_API) || \
 396     defined(USE_CC3220_ROM_DRV_API)
 397 #define ROM_UARTCharsAvail                                                    \
 398         ((tBoolean (*)(unsigned long ulBase))ROM_UARTTABLE[10])
 399 #endif
 400 #if defined(USE_CC3200_ROM_DRV_API) || \
 401     defined(USE_CC3220_ROM_DRV_API)
 402 #define ROM_UARTSpaceAvail                                                    \
 403         ((tBoolean (*)(unsigned long ulBase))ROM_UARTTABLE[11])
 404 #endif
 405 #if defined(USE_CC3200_ROM_DRV_API) || \
 406     defined(USE_CC3220_ROM_DRV_API)
 407 #define ROM_UARTCharGetNonBlocking                                            \
 408         ((long (*)(unsigned long ulBase))ROM_UARTTABLE[12])
 409 #endif
 410 #if defined(USE_CC3200_ROM_DRV_API) || \
 411     defined(USE_CC3220_ROM_DRV_API)
 412 #define ROM_UARTCharGet                                                       \
 413         ((long (*)(unsigned long ulBase))ROM_UARTTABLE[13])
 414 #endif
 415 #if defined(USE_CC3200_ROM_DRV_API) || \
 416     defined(USE_CC3220_ROM_DRV_API)
 417 #define ROM_UARTCharPutNonBlocking                                            \
 418         ((tBoolean (*)(unsigned long ulBase,                                  \
 419                        unsigned char ucData))ROM_UARTTABLE[14])
 420 #endif
 421 #if defined(USE_CC3200_ROM_DRV_API) || \
 422     defined(USE_CC3220_ROM_DRV_API)
 423 #define ROM_UARTCharPut                                                       \
 424         ((void (*)(unsigned long ulBase,                                      \
 425                    unsigned char ucData))ROM_UARTTABLE[15])
 426 #endif
 427 #if defined(USE_CC3200_ROM_DRV_API) || \
 428     defined(USE_CC3220_ROM_DRV_API)
 429 #define ROM_UARTBreakCtl                                                      \
 430         ((void (*)(unsigned long ulBase,                                      \
 431                    tBoolean bBreakState))ROM_UARTTABLE[16])
 432 #endif
 433 #if defined(USE_CC3200_ROM_DRV_API) || \
 434     defined(USE_CC3220_ROM_DRV_API)
 435 #define ROM_UARTBusy                                                          \
 436         ((tBoolean (*)(unsigned long ulBase))ROM_UARTTABLE[17])
 437 #endif
 438 #if defined(USE_CC3200_ROM_DRV_API) || \
 439     defined(USE_CC3220_ROM_DRV_API)
 440 #define ROM_UARTIntRegister                                                   \
 441         ((void (*)(unsigned long ulBase,                                      \
 442                    void(*pfnHandler)(void)))ROM_UARTTABLE[18])
 443 #endif
 444 #if defined(USE_CC3200_ROM_DRV_API) || \
 445     defined(USE_CC3220_ROM_DRV_API)
 446 #define ROM_UARTIntUnregister                                                 \
 447         ((void (*)(unsigned long ulBase))ROM_UARTTABLE[19])
 448 #endif
 449 #if defined(USE_CC3200_ROM_DRV_API) || \
 450     defined(USE_CC3220_ROM_DRV_API)
 451 #define ROM_UARTIntEnable                                                     \
 452         ((void (*)(unsigned long ulBase,                                      \
 453                    unsigned long ulIntFlags))ROM_UARTTABLE[20])
 454 #endif
 455 #if defined(USE_CC3200_ROM_DRV_API) || \
 456     defined(USE_CC3220_ROM_DRV_API)
 457 #define ROM_UARTIntDisable                                                    \
 458         ((void (*)(unsigned long ulBase,                                      \
 459                    unsigned long ulIntFlags))ROM_UARTTABLE[21])
 460 #endif
 461 #if defined(USE_CC3200_ROM_DRV_API) || \
 462     defined(USE_CC3220_ROM_DRV_API)
 463 #define ROM_UARTIntStatus                                                     \
 464         ((unsigned long (*)(unsigned long ulBase,                             \
 465                             tBoolean bMasked))ROM_UARTTABLE[22])
 466 #endif
 467 #if defined(USE_CC3200_ROM_DRV_API) || \
 468     defined(USE_CC3220_ROM_DRV_API)
 469 #define ROM_UARTIntClear                                                      \
 470         ((void (*)(unsigned long ulBase,                                      \
 471                    unsigned long ulIntFlags))ROM_UARTTABLE[23])
 472 #endif
 473 #if defined(USE_CC3200_ROM_DRV_API) || \
 474     defined(USE_CC3220_ROM_DRV_API)
 475 #define ROM_UARTDMAEnable                                                     \
 476         ((void (*)(unsigned long ulBase,                                      \
 477                    unsigned long ulDMAFlags))ROM_UARTTABLE[24])
 478 #endif
 479 #if defined(USE_CC3200_ROM_DRV_API) || \
 480     defined(USE_CC3220_ROM_DRV_API)
 481 #define ROM_UARTDMADisable                                                    \
 482         ((void (*)(unsigned long ulBase,                                      \
 483                    unsigned long ulDMAFlags))ROM_UARTTABLE[25])
 484 #endif
 485 #if defined(USE_CC3200_ROM_DRV_API) || \
 486     defined(USE_CC3220_ROM_DRV_API)
 487 #define ROM_UARTRxErrorGet                                                    \
 488         ((unsigned long (*)(unsigned long ulBase))ROM_UARTTABLE[26])
 489 #endif
 490 #if defined(USE_CC3200_ROM_DRV_API) || \
 491     defined(USE_CC3220_ROM_DRV_API)
 492 #define ROM_UARTRxErrorClear                                                  \
 493         ((void (*)(unsigned long ulBase))ROM_UARTTABLE[27])
 494 #endif
 495 #if defined(USE_CC3200_ROM_DRV_API) || \
 496     defined(USE_CC3220_ROM_DRV_API)
 497 #define ROM_UARTModemControlSet                                               \
 498         ((void (*)(unsigned long ulBase,                                      \
 499                    unsigned long ulControl))ROM_UARTTABLE[28])
 500 #endif
 501 #if defined(USE_CC3200_ROM_DRV_API) || \
 502     defined(USE_CC3220_ROM_DRV_API)
 503 #define ROM_UARTModemControlClear                                             \
 504         ((void (*)(unsigned long ulBase,                                      \
 505                    unsigned long ulControl))ROM_UARTTABLE[29])
 506 #endif
 507 #if defined(USE_CC3200_ROM_DRV_API) || \
 508     defined(USE_CC3220_ROM_DRV_API)
 509 #define ROM_UARTModemControlGet                                               \
 510         ((unsigned long (*)(unsigned long ulBase))ROM_UARTTABLE[30])
 511 #endif
 512 #if defined(USE_CC3200_ROM_DRV_API) || \
 513     defined(USE_CC3220_ROM_DRV_API)
 514 #define ROM_UARTModemStatusGet                                                \
 515         ((unsigned long (*)(unsigned long ulBase))ROM_UARTTABLE[31])
 516 #endif
 517 #if defined(USE_CC3200_ROM_DRV_API) || \
 518     defined(USE_CC3220_ROM_DRV_API)
 519 #define ROM_UARTFlowControlSet                                                \
 520         ((void (*)(unsigned long ulBase,                                      \
 521                    unsigned long ulMode))ROM_UARTTABLE[32])
 522 #endif
 523 #if defined(USE_CC3200_ROM_DRV_API) || \
 524     defined(USE_CC3220_ROM_DRV_API)
 525 #define ROM_UARTFlowControlGet                                                \
 526         ((unsigned long (*)(unsigned long ulBase))ROM_UARTTABLE[33])
 527 #endif
 528 #if defined(USE_CC3200_ROM_DRV_API) || \
 529     defined(USE_CC3220_ROM_DRV_API)
 530 #define ROM_UARTTxIntModeSet                                                  \
 531         ((void (*)(unsigned long ulBase,                                      \
 532                    unsigned long ulMode))ROM_UARTTABLE[34])
 533 #endif
 534 #if defined(USE_CC3200_ROM_DRV_API) || \
 535     defined(USE_CC3220_ROM_DRV_API)
 536 #define ROM_UARTTxIntModeGet                                                  \
 537         ((unsigned long (*)(unsigned long ulBase))ROM_UARTTABLE[35])
 538 #endif
 539
 540 //*****************************************************************************
 541 //
 542 // Macros for calling ROM functions in the uDMA API.
 543 //
 544 //*****************************************************************************
 545 #if defined(USE_CC3200_ROM_DRV_API) || \
 546     defined(USE_CC3220_ROM_DRV_API)
 547 #define ROM_uDMAChannelTransferSet                                            \
 548         ((void (*)(unsigned long ulChannelStructIndex,                        \
 549                    unsigned long ulMode,                                      \
 550                    void *pvSrcAddr,                                           \
 551                    void *pvDstAddr,                                           \
 552                    unsigned long ulTransferSize))ROM_UDMATABLE[0])
 553 #endif
 554 #if defined(USE_CC3200_ROM_DRV_API) || \
 555     defined(USE_CC3220_ROM_DRV_API)
 556 #define ROM_uDMAEnable                                                        \
 557         ((void (*)(void))ROM_UDMATABLE[1])
 558 #endif
 559 #if defined(USE_CC3200_ROM_DRV_API) || \
 560     defined(USE_CC3220_ROM_DRV_API)
 561 #define ROM_uDMADisable                                                       \
 562         ((void (*)(void))ROM_UDMATABLE[2])
 563 #endif
 564 #if defined(USE_CC3200_ROM_DRV_API) || \
 565     defined(USE_CC3220_ROM_DRV_API)
 566 #define ROM_uDMAErrorStatusGet                                                \
 567         ((unsigned long (*)(void))ROM_UDMATABLE[3])
 568 #endif
 569 #if defined(USE_CC3200_ROM_DRV_API) || \
 570     defined(USE_CC3220_ROM_DRV_API)
 571 #define ROM_uDMAErrorStatusClear                                              \
 572         ((void (*)(void))ROM_UDMATABLE[4])
 573 #endif
 574 #if defined(USE_CC3200_ROM_DRV_API) || \
 575     defined(USE_CC3220_ROM_DRV_API)
 576 #define ROM_uDMAChannelEnable                                                 \
 577         ((void (*)(unsigned long ulChannelNum))ROM_UDMATABLE[5])
 578 #endif
 579 #if defined(USE_CC3200_ROM_DRV_API) || \
 580     defined(USE_CC3220_ROM_DRV_API)
 581 #define ROM_uDMAChannelDisable                                                \
 582         ((void (*)(unsigned long ulChannelNum))ROM_UDMATABLE[6])
 583 #endif
 584 #if defined(USE_CC3200_ROM_DRV_API) || \
 585     defined(USE_CC3220_ROM_DRV_API)
 586 #define ROM_uDMAChannelIsEnabled                                              \
 587         ((tBoolean (*)(unsigned long ulChannelNum))ROM_UDMATABLE[7])
 588 #endif
 589 #if defined(USE_CC3200_ROM_DRV_API) || \
 590     defined(USE_CC3220_ROM_DRV_API)
 591 #define ROM_uDMAControlBaseSet                                                \
 592         ((void (*)(void *pControlTable))ROM_UDMATABLE[8])
 593 #endif
 594 #if defined(USE_CC3200_ROM_DRV_API) || \
 595     defined(USE_CC3220_ROM_DRV_API)
 596 #define ROM_uDMAControlBaseGet                                                \
 597         ((void * (*)(void))ROM_UDMATABLE[9])
 598 #endif
 599 #if defined(USE_CC3200_ROM_DRV_API) || \
 600     defined(USE_CC3220_ROM_DRV_API)
 601 #define ROM_uDMAChannelRequest                                                \
 602         ((void (*)(unsigned long ulChannelNum))ROM_UDMATABLE[10])
 603 #endif
 604 #if defined(USE_CC3200_ROM_DRV_API) || \
 605     defined(USE_CC3220_ROM_DRV_API)
 606 #define ROM_uDMAChannelAttributeEnable                                        \
 607         ((void (*)(unsigned long ulChannelNum,                                \
 608                    unsigned long ulAttr))ROM_UDMATABLE[11])
 609 #endif
 610 #if defined(USE_CC3200_ROM_DRV_API) || \
 611     defined(USE_CC3220_ROM_DRV_API)
 612 #define ROM_uDMAChannelAttributeDisable                                       \
 613         ((void (*)(unsigned long ulChannelNum,                                \
 614                    unsigned long ulAttr))ROM_UDMATABLE[12])
 615 #endif
 616 #if defined(USE_CC3200_ROM_DRV_API) || \
 617     defined(USE_CC3220_ROM_DRV_API)
 618 #define ROM_uDMAChannelAttributeGet                                           \
 619         ((unsigned long (*)(unsigned long ulChannelNum))ROM_UDMATABLE[13])
 620 #endif
 621 #if defined(USE_CC3200_ROM_DRV_API) || \
 622     defined(USE_CC3220_ROM_DRV_API)
 623 #define ROM_uDMAChannelControlSet                                             \
 624         ((void (*)(unsigned long ulChannelStructIndex,                        \
 625                    unsigned long ulControl))ROM_UDMATABLE[14])
 626 #endif
 627 #if defined(USE_CC3200_ROM_DRV_API) || \
 628     defined(USE_CC3220_ROM_DRV_API)
 629 #define ROM_uDMAChannelSizeGet                                                \
 630         ((unsigned long (*)(unsigned long ulChannelStructIndex))ROM_UDMATABLE[15])
 631 #endif
 632 #if defined(USE_CC3200_ROM_DRV_API) || \
 633     defined(USE_CC3220_ROM_DRV_API)
 634 #define ROM_uDMAChannelModeGet                                                \
 635         ((unsigned long (*)(unsigned long ulChannelStructIndex))ROM_UDMATABLE[16])
 636 #endif
 637 #if defined(USE_CC3200_ROM_DRV_API) || \
 638     defined(USE_CC3220_ROM_DRV_API)
 639 #define ROM_uDMAIntStatus                                                     \
 640         ((unsigned long (*)(void))ROM_UDMATABLE[17])
 641 #endif
 642 #if defined(USE_CC3200_ROM_DRV_API) || \
 643     defined(USE_CC3220_ROM_DRV_API)
 644 #define ROM_uDMAIntClear                                                      \
 645         ((void (*)(unsigned long ulChanMask))ROM_UDMATABLE[18])
 646 #endif
 647 #if defined(USE_CC3200_ROM_DRV_API) || \
 648     defined(USE_CC3220_ROM_DRV_API)
 649 #define ROM_uDMAControlAlternateBaseGet                                       \
 650         ((void * (*)(void))ROM_UDMATABLE[19])
 651 #endif
 652 #if defined(USE_CC3200_ROM_DRV_API) || \
 653     defined(USE_CC3220_ROM_DRV_API)
 654 #define ROM_uDMAChannelScatterGatherSet                                       \
 655         ((void (*)(unsigned long ulChannelNum,                                \
 656                    unsigned ulTaskCount,                                      \
 657                    void *pvTaskList,                                          \
 658                    unsigned long ulIsPeriphSG))ROM_UDMATABLE[20])
 659 #endif
 660 #if defined(USE_CC3200_ROM_DRV_API) || \
 661     defined(USE_CC3220_ROM_DRV_API)
 662 #define ROM_uDMAChannelAssign                                                 \
 663         ((void (*)(unsigned long ulMapping))ROM_UDMATABLE[21])
 664 #endif
 665 #if defined(USE_CC3200_ROM_DRV_API) || \
 666     defined(USE_CC3220_ROM_DRV_API)
 667 #define ROM_uDMAIntRegister                                                   \
 668         ((void (*)(unsigned long ulIntChannel,                                \
 669                    void (*pfnHandler)(void)))ROM_UDMATABLE[22])
 670 #endif
 671 #if defined(USE_CC3200_ROM_DRV_API) || \
 672     defined(USE_CC3220_ROM_DRV_API)
 673 #define ROM_uDMAIntUnregister                                                 \
 674         ((void (*)(unsigned long ulIntChannel))ROM_UDMATABLE[23])
 675 #endif
 676
 677 //*****************************************************************************
 678 //
 679 // Macros for calling ROM functions in the Watchdog API.
 680 //
 681 //*****************************************************************************
 682 #if defined(USE_CC3200_ROM_DRV_API) || \
 683     defined(USE_CC3220_ROM_DRV_API)
 684 #define ROM_WatchdogIntClear                                                  \
 685         ((void (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[0])
 686 #endif
 687 #if defined(USE_CC3200_ROM_DRV_API) || \
 688     defined(USE_CC3220_ROM_DRV_API)
 689 #define ROM_WatchdogRunning                                                   \
 690         ((tBoolean (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[1])
 691 #endif
 692 #if defined(USE_CC3200_ROM_DRV_API) || \
 693     defined(USE_CC3220_ROM_DRV_API)
 694 #define ROM_WatchdogEnable                                                    \
 695         ((void (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[2])
 696 #endif
 697 #if defined(USE_CC3200_ROM_DRV_API) || \
 698     defined(USE_CC3220_ROM_DRV_API)
 699 #define ROM_WatchdogLock                                                      \
 700         ((void (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[3])
 701 #endif
 702 #if defined(USE_CC3200_ROM_DRV_API) || \
 703     defined(USE_CC3220_ROM_DRV_API)
 704 #define ROM_WatchdogUnlock                                                    \
 705         ((void (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[4])
 706 #endif
 707 #if defined(USE_CC3200_ROM_DRV_API) || \
 708     defined(USE_CC3220_ROM_DRV_API)
 709 #define ROM_WatchdogLockState                                                 \
 710         ((tBoolean (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[5])
 711 #endif
 712 #if defined(USE_CC3200_ROM_DRV_API) || \
 713     defined(USE_CC3220_ROM_DRV_API)
 714 #define ROM_WatchdogReloadSet                                                 \
 715         ((void (*)(unsigned long ulBase,                                      \
 716                    unsigned long ulLoadVal))ROM_WATCHDOGTABLE[6])
 717 #endif
 718 #if defined(USE_CC3200_ROM_DRV_API) || \
 719     defined(USE_CC3220_ROM_DRV_API)
 720 #define ROM_WatchdogReloadGet                                                 \
 721         ((unsigned long (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[7])
 722 #endif
 723 #if defined(USE_CC3200_ROM_DRV_API) || \
 724     defined(USE_CC3220_ROM_DRV_API)
 725 #define ROM_WatchdogValueGet                                                  \
 726         ((unsigned long (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[8])
 727 #endif
 728 #if defined(USE_CC3200_ROM_DRV_API) || \
 729     defined(USE_CC3220_ROM_DRV_API)
 730 #define ROM_WatchdogIntStatus                                                 \
 731         ((unsigned long (*)(unsigned long ulBase,                             \
 732                             tBoolean bMasked))ROM_WATCHDOGTABLE[10])
 733 #endif
 734 #if defined(USE_CC3200_ROM_DRV_API) || \
 735     defined(USE_CC3220_ROM_DRV_API)
 736 #define ROM_WatchdogStallEnable                                               \
 737         ((void (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[11])
 738 #endif
 739 #if defined(USE_CC3200_ROM_DRV_API) || \
 740     defined(USE_CC3220_ROM_DRV_API)
 741 #define ROM_WatchdogStallDisable                                              \
 742         ((void (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[12])
 743 #endif
 744 #if defined(USE_CC3200_ROM_DRV_API) || \
 745     defined(USE_CC3220_ROM_DRV_API)
 746 #define ROM_WatchdogIntRegister                                               \
 747         ((void (*)(unsigned long ulBase,                                      \
 748                    void(*pfnHandler)(void)))ROM_WATCHDOGTABLE[13])
 749 #endif
 750 #if defined(USE_CC3200_ROM_DRV_API) || \
 751     defined(USE_CC3220_ROM_DRV_API)
 752 #define ROM_WatchdogIntUnregister                                             \
 753         ((void (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[14])
 754 #endif
 755
 756 //*****************************************************************************
 757 //
 758 // Macros for calling ROM functions in the I2C API.
 759 //
 760 //*****************************************************************************
 761 #if defined(USE_CC3200_ROM_DRV_API) || \
 762     defined(USE_CC3220_ROM_DRV_API)
 763 #define ROM_I2CIntRegister                                                    \
 764         ((void (*)(uint32_t ui32Base,                                         \
 765                    void(pfnHandler)(void)))ROM_I2CTABLE[0])
 766 #endif
 767 #if defined(USE_CC3200_ROM_DRV_API) || \
 768     defined(USE_CC3220_ROM_DRV_API)
 769 #define ROM_I2CIntUnregister                                                  \
 770         ((void (*)(uint32_t ui32Base))ROM_I2CTABLE[1])
 771 #endif
 772 #if defined(USE_CC3200_ROM_DRV_API) || \
 773     defined(USE_CC3220_ROM_DRV_API)
 774 #define ROM_I2CTxFIFOConfigSet                                                \
 775         ((void (*)(uint32_t ui32Base,                                         \
 776                    uint32_t ui32Config))ROM_I2CTABLE[2])
 777 #endif
 778 #if defined(USE_CC3200_ROM_DRV_API) || \
 779     defined(USE_CC3220_ROM_DRV_API)
 780 #define ROM_I2CTxFIFOFlush                                                    \
 781         ((void (*)(uint32_t ui32Base))ROM_I2CTABLE[3])
 782 #endif
 783 #if defined(USE_CC3200_ROM_DRV_API) || \
 784     defined(USE_CC3220_ROM_DRV_API)
 785 #define ROM_I2CRxFIFOConfigSet                                                \
 786         ((void (*)(uint32_t ui32Base,                                         \
 787                    uint32_t ui32Config))ROM_I2CTABLE[4])
 788 #endif
 789 #if defined(USE_CC3200_ROM_DRV_API) || \
 790     defined(USE_CC3220_ROM_DRV_API)
 791 #define ROM_I2CRxFIFOFlush                                                    \
 792         ((void (*)(uint32_t ui32Base))ROM_I2CTABLE[5])
 793 #endif
 794 #if defined(USE_CC3200_ROM_DRV_API) || \
 795     defined(USE_CC3220_ROM_DRV_API)
 796 #define ROM_I2CFIFOStatus                                                     \
 797         ((uint32_t (*)(uint32_t ui32Base))ROM_I2CTABLE[6])
 798 #endif
 799 #if defined(USE_CC3200_ROM_DRV_API) || \
 800     defined(USE_CC3220_ROM_DRV_API)
 801 #define ROM_I2CFIFODataPut                                                    \
 802         ((void (*)(uint32_t ui32Base,                                         \
 803                    uint8_t ui8Data))ROM_I2CTABLE[7])
 804 #endif
 805 #if defined(USE_CC3200_ROM_DRV_API) || \
 806     defined(USE_CC3220_ROM_DRV_API)
 807 #define ROM_I2CFIFODataPutNonBlocking                                         \
 808         ((uint32_t (*)(uint32_t ui32Base,                                     \
 809                        uint8_t ui8Data))ROM_I2CTABLE[8])
 810 #endif
 811 #if defined(USE_CC3200_ROM_DRV_API) || \
 812     defined(USE_CC3220_ROM_DRV_API)
 813 #define ROM_I2CFIFODataGet                                                    \
 814         ((uint32_t (*)(uint32_t ui32Base))ROM_I2CTABLE[9])
 815 #endif
 816 #if defined(USE_CC3200_ROM_DRV_API) || \
 817     defined(USE_CC3220_ROM_DRV_API)
 818 #define ROM_I2CFIFODataGetNonBlocking                                         \
 819         ((uint32_t (*)(uint32_t ui32Base,                                     \
 820                        uint8_t *pui8Data))ROM_I2CTABLE[10])
 821 #endif
 822 #if defined(USE_CC3200_ROM_DRV_API) || \
 823     defined(USE_CC3220_ROM_DRV_API)
 824 #define ROM_I2CMasterBurstLengthSet                                           \
 825         ((void (*)(uint32_t ui32Base,                                         \
 826                    uint8_t ui8Length))ROM_I2CTABLE[11])
 827 #endif
 828 #if defined(USE_CC3200_ROM_DRV_API) || \
 829     defined(USE_CC3220_ROM_DRV_API)
 830 #define ROM_I2CMasterBurstCountGet                                            \
 831         ((uint32_t (*)(uint32_t ui32Base))ROM_I2CTABLE[12])
 832 #endif
 833 #if defined(USE_CC3200_ROM_DRV_API) || \
 834     defined(USE_CC3220_ROM_DRV_API)
 835 #define ROM_I2CMasterGlitchFilterConfigSet                                    \
 836         ((void (*)(uint32_t ui32Base,                                         \
 837                    uint32_t ui32Config))ROM_I2CTABLE[13])
 838 #endif
 839 #if defined(USE_CC3200_ROM_DRV_API) || \
 840     defined(USE_CC3220_ROM_DRV_API)
 841 #define ROM_I2CSlaveFIFOEnable                                                \
 842         ((void (*)(uint32_t ui32Base,                                         \
 843                    uint32_t ui32Config))ROM_I2CTABLE[14])
 844 #endif
 845 #if defined(USE_CC3200_ROM_DRV_API) || \
 846     defined(USE_CC3220_ROM_DRV_API)
 847 #define ROM_I2CSlaveFIFODisable                                               \
 848         ((void (*)(uint32_t ui32Base))ROM_I2CTABLE[15])
 849 #endif
 850 #if defined(USE_CC3200_ROM_DRV_API) || \
 851     defined(USE_CC3220_ROM_DRV_API)
 852 #define ROM_I2CMasterBusBusy                                                  \
 853         ((bool (*)(uint32_t ui32Base))ROM_I2CTABLE[16])
 854 #endif
 855 #if defined(USE_CC3200_ROM_DRV_API) || \
 856     defined(USE_CC3220_ROM_DRV_API)
 857 #define ROM_I2CMasterBusy                                                     \
 858         ((bool (*)(uint32_t ui32Base))ROM_I2CTABLE[17])
 859 #endif
 860 #if defined(USE_CC3200_ROM_DRV_API) || \
 861     defined(USE_CC3220_ROM_DRV_API)
 862 #define ROM_I2CMasterControl                                                  \
 863         ((void (*)(uint32_t ui32Base,                                         \
 864                    uint32_t ui32Cmd))ROM_I2CTABLE[18])
 865 #endif
 866 #if defined(USE_CC3200_ROM_DRV_API) || \
 867     defined(USE_CC3220_ROM_DRV_API)
 868 #define ROM_I2CMasterDataGet                                                  \
 869         ((uint32_t (*)(uint32_t ui32Base))ROM_I2CTABLE[19])
 870 #endif
 871 #if defined(USE_CC3200_ROM_DRV_API) || \
 872     defined(USE_CC3220_ROM_DRV_API)
 873 #define ROM_I2CMasterDataPut                                                  \
 874         ((void (*)(uint32_t ui32Base,                                         \
 875                    uint8_t ui8Data))ROM_I2CTABLE[20])
 876 #endif
 877 #if defined(USE_CC3200_ROM_DRV_API) || \
 878     defined(USE_CC3220_ROM_DRV_API)
 879 #define ROM_I2CMasterDisable                                                  \
 880         ((void (*)(uint32_t ui32Base))ROM_I2CTABLE[21])
 881 #endif
 882 #if defined(USE_CC3200_ROM_DRV_API) || \
 883     defined(USE_CC3220_ROM_DRV_API)
 884 #define ROM_I2CMasterEnable                                                   \
 885         ((void (*)(uint32_t ui32Base))ROM_I2CTABLE[22])
 886 #endif
 887 #if defined(USE_CC3200_ROM_DRV_API) || \
 888     defined(USE_CC3220_ROM_DRV_API)
 889 #define ROM_I2CMasterErr                                                      \
 890         ((uint32_t (*)(uint32_t ui32Base))ROM_I2CTABLE[23])
 891 #endif
 892 #if defined(USE_CC3200_ROM_DRV_API) || \
 893     defined(USE_CC3220_ROM_DRV_API)
 894 #define ROM_I2CMasterIntClear                                                 \
 895         ((void (*)(uint32_t ui32Base))ROM_I2CTABLE[24])
 896 #endif
 897 #if defined(USE_CC3200_ROM_DRV_API) || \
 898     defined(USE_CC3220_ROM_DRV_API)
 899 #define ROM_I2CMasterIntDisable                                               \
 900         ((void (*)(uint32_t ui32Base))ROM_I2CTABLE[25])
 901 #endif
 902 #if defined(USE_CC3200_ROM_DRV_API) || \
 903     defined(USE_CC3220_ROM_DRV_API)
 904 #define ROM_I2CMasterIntEnable                                                \
 905         ((void (*)(uint32_t ui32Base))ROM_I2CTABLE[26])
 906 #endif
 907 #if defined(USE_CC3200_ROM_DRV_API) || \
 908     defined(USE_CC3220_ROM_DRV_API)
 909 #define ROM_I2CMasterIntStatus                                                \
 910         ((bool (*)(uint32_t ui32Base,                                         \
 911                    bool bMasked))ROM_I2CTABLE[27])
 912 #endif
 913 #if defined(USE_CC3200_ROM_DRV_API) || \
 914     defined(USE_CC3220_ROM_DRV_API)
 915 #define ROM_I2CMasterIntEnableEx                                              \
 916         ((void (*)(uint32_t ui32Base,                                         \
 917                    uint32_t ui32IntFlags))ROM_I2CTABLE[28])
 918 #endif
 919 #if defined(USE_CC3200_ROM_DRV_API) || \
 920     defined(USE_CC3220_ROM_DRV_API)
 921 #define ROM_I2CMasterIntDisableEx                                             \
 922         ((void (*)(uint32_t ui32Base,                                         \
 923                    uint32_t ui32IntFlags))ROM_I2CTABLE[29])
 924 #endif
 925 #if defined(USE_CC3200_ROM_DRV_API) || \
 926     defined(USE_CC3220_ROM_DRV_API)
 927 #define ROM_I2CMasterIntStatusEx                                              \
 928         ((uint32_t (*)(uint32_t ui32Base,                                     \
 929                        bool bMasked))ROM_I2CTABLE[30])
 930 #endif
 931 #if defined(USE_CC3200_ROM_DRV_API) || \
 932     defined(USE_CC3220_ROM_DRV_API)
 933 #define ROM_I2CMasterIntClearEx                                               \
 934         ((void (*)(uint32_t ui32Base,                                         \
 935                    uint32_t ui32IntFlags))ROM_I2CTABLE[31])
 936 #endif
 937 #if defined(USE_CC3200_ROM_DRV_API) || \
 938     defined(USE_CC3220_ROM_DRV_API)
 939 #define ROM_I2CMasterTimeoutSet                                               \
 940         ((void (*)(uint32_t ui32Base,                                         \
 941                    uint32_t ui32Value))ROM_I2CTABLE[32])
 942 #endif
 943 #if defined(USE_CC3200_ROM_DRV_API) || \
 944     defined(USE_CC3220_ROM_DRV_API)
 945 #define ROM_I2CSlaveACKOverride                                               \
 946         ((void (*)(uint32_t ui32Base,                                         \
 947                    bool bEnable))ROM_I2CTABLE[33])
 948 #endif
 949 #if defined(USE_CC3200_ROM_DRV_API) || \
 950     defined(USE_CC3220_ROM_DRV_API)
 951 #define ROM_I2CSlaveACKValueSet                                               \
 952         ((void (*)(uint32_t ui32Base,                                         \
 953                    bool bACK))ROM_I2CTABLE[34])
 954 #endif
 955 #if defined(USE_CC3200_ROM_DRV_API) || \
 956     defined(USE_CC3220_ROM_DRV_API)
 957 #define ROM_I2CMasterLineStateGet                                             \
 958         ((uint32_t (*)(uint32_t ui32Base))ROM_I2CTABLE[35])
 959 #endif
 960 #if defined(USE_CC3200_ROM_DRV_API) || \
 961     defined(USE_CC3220_ROM_DRV_API)
 962 #define ROM_I2CMasterSlaveAddrSet                                             \
 963         ((void (*)(uint32_t ui32Base,                                         \
 964                    uint8_t ui8SlaveAddr,                                      \
 965                    bool bReceive))ROM_I2CTABLE[36])
 966 #endif
 967 #if defined(USE_CC3200_ROM_DRV_API) || \
 968     defined(USE_CC3220_ROM_DRV_API)
 969 #define ROM_I2CSlaveDataGet                                                   \
 970         ((uint32_t (*)(uint32_t ui32Base))ROM_I2CTABLE[37])
 971 #endif
 972 #if defined(USE_CC3200_ROM_DRV_API) || \
 973     defined(USE_CC3220_ROM_DRV_API)
 974 #define ROM_I2CSlaveDataPut                                                   \
 975         ((void (*)(uint32_t ui32Base,                                         \
 976                    uint8_t ui8Data))ROM_I2CTABLE[38])
 977 #endif
 978 #if defined(USE_CC3200_ROM_DRV_API) || \
 979     defined(USE_CC3220_ROM_DRV_API)
 980 #define ROM_I2CSlaveDisable                                                   \
 981         ((void (*)(uint32_t ui32Base))ROM_I2CTABLE[39])
 982 #endif
 983 #if defined(USE_CC3200_ROM_DRV_API) || \
 984     defined(USE_CC3220_ROM_DRV_API)
 985 #define ROM_I2CSlaveEnable                                                    \
 986         ((void (*)(uint32_t ui32Base))ROM_I2CTABLE[40])
 987 #endif
 988 #if defined(USE_CC3200_ROM_DRV_API) || \
 989     defined(USE_CC3220_ROM_DRV_API)
 990 #define ROM_I2CSlaveInit                                                      \
 991         ((void (*)(uint32_t ui32Base,                                         \
 992                    uint8_t ui8SlaveAddr))ROM_I2CTABLE[41])
 993 #endif
 994 #if defined(USE_CC3200_ROM_DRV_API) || \
 995     defined(USE_CC3220_ROM_DRV_API)
 996 #define ROM_I2CSlaveAddressSet                                                \
 997         ((void (*)(uint32_t ui32Base,                                         \
 998                    uint8_t ui8AddrNum,                                        \
 999                    uint8_t ui8SlaveAddr))ROM_I2CTABLE[42])
1000 #endif
1001 #if defined(USE_CC3200_ROM_DRV_API) || \
1002     defined(USE_CC3220_ROM_DRV_API)
1003 #define ROM_I2CSlaveIntClear                                                  \
1004         ((void (*)(uint32_t ui32Base))ROM_I2CTABLE[43])
1005 #endif
1006 #if defined(USE_CC3200_ROM_DRV_API) || \
1007     defined(USE_CC3220_ROM_DRV_API)
1008 #define ROM_I2CSlaveIntDisable                                                \
1009         ((void (*)(uint32_t ui32Base))ROM_I2CTABLE[44])
1010 #endif
1011 #if defined(USE_CC3200_ROM_DRV_API) || \
1012     defined(USE_CC3220_ROM_DRV_API)
1013 #define ROM_I2CSlaveIntEnable                                                 \
1014         ((void (*)(uint32_t ui32Base))ROM_I2CTABLE[45])
1015 #endif
1016 #if defined(USE_CC3200_ROM_DRV_API) || \
1017     defined(USE_CC3220_ROM_DRV_API)
1018 #define ROM_I2CSlaveIntClearEx                                                \
1019         ((void (*)(uint32_t ui32Base,                                         \
1020                    uint32_t ui32IntFlags))ROM_I2CTABLE[46])
1021 #endif
1022 #if defined(USE_CC3200_ROM_DRV_API) || \
1023     defined(USE_CC3220_ROM_DRV_API)
1024 #define ROM_I2CSlaveIntDisableEx                                              \
1025         ((void (*)(uint32_t ui32Base,                                         \
1026                    uint32_t ui32IntFlags))ROM_I2CTABLE[47])
1027 #endif
1028 #if defined(USE_CC3200_ROM_DRV_API) || \
1029     defined(USE_CC3220_ROM_DRV_API)
1030 #define ROM_I2CSlaveIntEnableEx                                               \
1031         ((void (*)(uint32_t ui32Base,                                         \
1032                    uint32_t ui32IntFlags))ROM_I2CTABLE[48])
1033 #endif
1034 #if defined(USE_CC3200_ROM_DRV_API) || \
1035     defined(USE_CC3220_ROM_DRV_API)
1036 #define ROM_I2CSlaveIntStatus                                                 \
1037         ((bool (*)(uint32_t ui32Base,                                         \
1038                    bool bMasked))ROM_I2CTABLE[49])
1039 #endif
1040 #if defined(USE_CC3200_ROM_DRV_API) || \
1041     defined(USE_CC3220_ROM_DRV_API)
1042 #define ROM_I2CSlaveIntStatusEx                                               \
1043         ((uint32_t (*)(uint32_t ui32Base,                                     \
1044                        bool bMasked))ROM_I2CTABLE[50])
1045 #endif
1046 #if defined(USE_CC3200_ROM_DRV_API) || \
1047     defined(USE_CC3220_ROM_DRV_API)
1048 #define ROM_I2CSlaveStatus                                                    \
1049         ((uint32_t (*)(uint32_t ui32Base))ROM_I2CTABLE[51])
1050 #endif
1051 #if defined(USE_CC3200_ROM_DRV_API) || \
1052     defined(USE_CC3220_ROM_DRV_API)
1053 #define ROM_I2CMasterInitExpClk                                               \
1054         ((void (*)(uint32_t ui32Base,                                         \
1055                    uint32_t ui32I2CClk,                                       \
1056                    bool bFast))ROM_I2CTABLE[52])
1057 #endif
1058
1059 //*****************************************************************************
1060 //
1061 // Macros for calling ROM functions in the SPI API.
1062 //
1063 //*****************************************************************************
1064 #if defined(USE_CC3200_ROM_DRV_API) || \
1065     defined(USE_CC3220_ROM_DRV_API)
1066 #define ROM_SPIEnable                                                         \
1067         ((void (*)(unsigned long ulBase))ROM_SPITABLE[0])
1068 #endif
1069 #if defined(USE_CC3200_ROM_DRV_API) || \
1070     defined(USE_CC3220_ROM_DRV_API)
1071 #define ROM_SPIDisable                                                        \
1072         ((void (*)(unsigned long ulBase))ROM_SPITABLE[1])
1073 #endif
1074 #if defined(USE_CC3200_ROM_DRV_API) || \
1075     defined(USE_CC3220_ROM_DRV_API)
1076 #define ROM_SPIReset                                                          \
1077         ((void (*)(unsigned long ulBase))ROM_SPITABLE[2])
1078 #endif
1079 #if defined(USE_CC3200_ROM_DRV_API) || \
1080     defined(USE_CC3220_ROM_DRV_API)
1081 #define ROM_SPIConfigSetExpClk                                                \
1082         ((void (*)(unsigned long ulBase,                                      \
1083                   unsigned long ulSPIClk,                                     \
1084                    unsigned long ulBitRate,                                   \
1085                    unsigned long ulMode,                                      \
1086                    unsigned long ulSubMode,                                   \
1087                    unsigned long ulConfig))ROM_SPITABLE[3])
1088 #endif
1089 #if defined(USE_CC3200_ROM_DRV_API) || \
1090     defined(USE_CC3220_ROM_DRV_API)
1091 #define ROM_SPIDataGetNonBlocking                                             \
1092         ((long (*)(unsigned long ulBase,                                      \
1093                    unsigned long * pulData))ROM_SPITABLE[4])
1094 #endif
1095 #if defined(USE_CC3200_ROM_DRV_API) || \
1096     defined(USE_CC3220_ROM_DRV_API)
1097 #define ROM_SPIDataGet                                                        \
1098         ((void (*)(unsigned long ulBase,                                      \
1099                    unsigned long *pulData))ROM_SPITABLE[5])
1100 #endif
1101 #if defined(USE_CC3200_ROM_DRV_API) || \
1102     defined(USE_CC3220_ROM_DRV_API)
1103 #define ROM_SPIDataPutNonBlocking                                             \
1104         ((long (*)(unsigned long ulBase,                                      \
1105                    unsigned long ulData))ROM_SPITABLE[6])
1106 #endif
1107 #if defined(USE_CC3200_ROM_DRV_API) || \
1108     defined(USE_CC3220_ROM_DRV_API)
1109 #define ROM_SPIDataPut                                                        \
1110         ((void (*)(unsigned long ulBase,                                      \
1111                    unsigned long ulData))ROM_SPITABLE[7])
1112 #endif
1113 #if defined(USE_CC3200_ROM_DRV_API) || \
1114     defined(USE_CC3220_ROM_DRV_API)
1115 #define ROM_SPIFIFOEnable                                                     \
1116         ((void (*)(unsigned long ulBase,                                      \
1117                    unsigned long ulFlags))ROM_SPITABLE[8])
1118 #endif
1119 #if defined(USE_CC3200_ROM_DRV_API) || \
1120     defined(USE_CC3220_ROM_DRV_API)
1121 #define ROM_SPIFIFODisable                                                    \
1122         ((void (*)(unsigned long ulBase,                                      \
1123                    unsigned long ulFlags))ROM_SPITABLE[9])
1124 #endif
1125 #if defined(USE_CC3200_ROM_DRV_API) || \
1126     defined(USE_CC3220_ROM_DRV_API)
1127 #define ROM_SPIFIFOLevelSet                                                   \
1128         ((void (*)(unsigned long ulBase,                                      \
1129                    unsigned long ulTxLevel,                                   \
1130                    unsigned long ulRxLevel))ROM_SPITABLE[10])
1131 #endif
1132 #if defined(USE_CC3200_ROM_DRV_API) || \
1133     defined(USE_CC3220_ROM_DRV_API)
1134 #define ROM_SPIFIFOLevelGet                                                   \
1135         ((void (*)(unsigned long ulBase,                                      \
1136                    unsigned long *pulTxLevel,                                 \
1137                    unsigned long *pulRxLevel))ROM_SPITABLE[11])
1138 #endif
1139 #if defined(USE_CC3200_ROM_DRV_API) || \
1140     defined(USE_CC3220_ROM_DRV_API)
1141 #define ROM_SPIWordCountSet                                                   \
1142         ((void (*)(unsigned long ulBase,                                      \
1143                    unsigned long ulWordCount))ROM_SPITABLE[12])
1144 #endif
1145 #if defined(USE_CC3200_ROM_DRV_API) || \
1146     defined(USE_CC3220_ROM_DRV_API)
1147 #define ROM_SPIIntRegister                                                    \
1148         ((void (*)(unsigned long ulBase,                                      \
1149                    void(*pfnHandler)(void)))ROM_SPITABLE[13])
1150 #endif
1151 #if defined(USE_CC3200_ROM_DRV_API) || \
1152     defined(USE_CC3220_ROM_DRV_API)
1153 #define ROM_SPIIntUnregister                                                  \
1154         ((void (*)(unsigned long ulBase))ROM_SPITABLE[14])
1155 #endif
1156 #if defined(USE_CC3200_ROM_DRV_API) || \
1157     defined(USE_CC3220_ROM_DRV_API)
1158 #define ROM_SPIIntEnable                                                      \
1159         ((void (*)(unsigned long ulBase,                                      \
1160                    unsigned long ulIntFlags))ROM_SPITABLE[15])
1161 #endif
1162 #if defined(USE_CC3200_ROM_DRV_API) || \
1163     defined(USE_CC3220_ROM_DRV_API)
1164 #define ROM_SPIIntDisable                                                     \
1165         ((void (*)(unsigned long ulBase,                                      \
1166                    unsigned long ulIntFlags))ROM_SPITABLE[16])
1167 #endif
1168 #if defined(USE_CC3200_ROM_DRV_API) || \
1169     defined(USE_CC3220_ROM_DRV_API)
1170 #define ROM_SPIIntStatus                                                      \
1171         ((unsigned long (*)(unsigned long ulBase,                             \
1172                             tBoolean bMasked))ROM_SPITABLE[17])
1173 #endif
1174 #if defined(USE_CC3200_ROM_DRV_API) || \
1175     defined(USE_CC3220_ROM_DRV_API)
1176 #define ROM_SPIIntClear                                                       \
1177         ((void (*)(unsigned long ulBase,                                      \
1178                    unsigned long ulIntFlags))ROM_SPITABLE[18])
1179 #endif
1180 #if defined(USE_CC3200_ROM_DRV_API) || \
1181     defined(USE_CC3220_ROM_DRV_API)
1182 #define ROM_SPIDmaEnable                                                      \
1183         ((void (*)(unsigned long ulBase,                                      \
1184                    unsigned long ulFlags))ROM_SPITABLE[19])
1185 #endif
1186 #if defined(USE_CC3200_ROM_DRV_API) || \
1187     defined(USE_CC3220_ROM_DRV_API)
1188 #define ROM_SPIDmaDisable                                                     \
1189         ((void (*)(unsigned long ulBase,                                      \
1190                    unsigned long ulFlags))ROM_SPITABLE[20])
1191 #endif
1192 #if defined(USE_CC3200_ROM_DRV_API) || \
1193     defined(USE_CC3220_ROM_DRV_API)
1194 #define ROM_SPICSEnable                                                       \
1195         ((void (*)(unsigned long ulBase))ROM_SPITABLE[21])
1196 #endif
1197 #if defined(USE_CC3200_ROM_DRV_API) || \
1198     defined(USE_CC3220_ROM_DRV_API)
1199 #define ROM_SPICSDisable                                                      \
1200         ((void (*)(unsigned long ulBase))ROM_SPITABLE[22])
1201 #endif
1202 #if defined(USE_CC3200_ROM_DRV_API) || \
1203     defined(USE_CC3220_ROM_DRV_API)
1204 #define ROM_SPITransfer                                                       \
1205         ((long (*)(unsigned long ulBase,                                      \
1206                    unsigned char *ucDout,                                     \
1207                    unsigned char *ucDin,                                      \
1208                    unsigned long ulSize,                                      \
1209                    unsigned long ulFlags))ROM_SPITABLE[23])
1210 #endif
1211
1212 //*****************************************************************************
1213 //
1214 // Macros for calling ROM functions in the CAM API.
1215 //
1216 //*****************************************************************************
1217 #if defined(USE_CC3200_ROM_DRV_API) || \
1218     defined(USE_CC3220_ROM_DRV_API)
1219 #define ROM_CameraReset                                                       \
1220         ((void (*)(unsigned long ulBase))ROM_CAMERATABLE[0])
1221 #endif
1222 #if defined(USE_CC3200_ROM_DRV_API) || \
1223     defined(USE_CC3220_ROM_DRV_API)
1224 #define ROM_CameraParamsConfig                                                \
1225         ((void (*)(unsigned long ulBase,                                      \
1226                    unsigned long ulHSPol,                                     \
1227                    unsigned long ulVSPol,                                     \
1228                    unsigned long ulFlags))ROM_CAMERATABLE[1])
1229 #endif
1230 #if defined(USE_CC3200_ROM_DRV_API) || \
1231     defined(USE_CC3220_ROM_DRV_API)
1232 #define ROM_CameraXClkConfig                                                  \
1233         ((void (*)(unsigned long ulBase,                                      \
1234                    unsigned long ulCamClkIn,                                  \
1235                    unsigned long ulXClk))ROM_CAMERATABLE[2])
1236 #endif
1237 #if defined(USE_CC3200_ROM_DRV_API) || \
1238     defined(USE_CC3220_ROM_DRV_API)
1239 #define ROM_CameraXClkSet                                                     \
1240         ((void (*)(unsigned long ulBase,                                      \
1241                    unsigned char bXClkFlags))ROM_CAMERATABLE[3])
1242 #endif
1243 #if defined(USE_CC3200_ROM_DRV_API) || \
1244     defined(USE_CC3220_ROM_DRV_API)
1245 #define ROM_CameraDMAEnable                                                   \
1246         ((void (*)(unsigned long ulBase))ROM_CAMERATABLE[4])
1247 #endif
1248 #if defined(USE_CC3200_ROM_DRV_API) || \
1249     defined(USE_CC3220_ROM_DRV_API)
1250 #define ROM_CameraDMADisable                                                  \
1251         ((void (*)(unsigned long ulBase))ROM_CAMERATABLE[5])
1252 #endif
1253 #if defined(USE_CC3200_ROM_DRV_API) || \
1254     defined(USE_CC3220_ROM_DRV_API)
1255 #define ROM_CameraThresholdSet                                                \
1256         ((void (*)(unsigned long ulBase,                                      \
1257                    unsigned long ulThreshold))ROM_CAMERATABLE[6])
1258 #endif
1259 #if defined(USE_CC3200_ROM_DRV_API) || \
1260     defined(USE_CC3220_ROM_DRV_API)
1261 #define ROM_CameraIntRegister                                                 \
1262         ((void (*)(unsigned long ulBase,                                      \
1263                    void (*pfnHandler)(void)))ROM_CAMERATABLE[7])
1264 #endif
1265 #if defined(USE_CC3200_ROM_DRV_API) || \
1266     defined(USE_CC3220_ROM_DRV_API)
1267 #define ROM_CameraIntUnregister                                               \
1268         ((void (*)(unsigned long ulBase))ROM_CAMERATABLE[8])
1269 #endif
1270 #if defined(USE_CC3200_ROM_DRV_API) || \
1271     defined(USE_CC3220_ROM_DRV_API)
1272 #define ROM_CameraIntEnable                                                   \
1273         ((void (*)(unsigned long ulBase,                                      \
1274                    unsigned long ulIntFlags))ROM_CAMERATABLE[9])
1275 #endif
1276 #if defined(USE_CC3200_ROM_DRV_API) || \
1277     defined(USE_CC3220_ROM_DRV_API)
1278 #define ROM_CameraIntDisable                                                  \
1279         ((void (*)(unsigned long ulBase,                                      \
1280                    unsigned long ulIntFlags))ROM_CAMERATABLE[10])
1281 #endif
1282 #if defined(USE_CC3200_ROM_DRV_API) || \
1283     defined(USE_CC3220_ROM_DRV_API)
1284 #define ROM_CameraIntStatus                                                   \
1285         ((unsigned long (*)(unsigned long ulBase))ROM_CAMERATABLE[11])
1286 #endif
1287 #if defined(USE_CC3200_ROM_DRV_API) || \
1288     defined(USE_CC3220_ROM_DRV_API)
1289 #define ROM_CameraIntClear                                                    \
1290         ((void (*)(unsigned long ulBase,                                      \
1291                    unsigned long ulIntFlags))ROM_CAMERATABLE[12])
1292 #endif
1293 #if defined(USE_CC3200_ROM_DRV_API) || \
1294     defined(USE_CC3220_ROM_DRV_API)
1295 #define ROM_CameraCaptureStop                                                 \
1296         ((void (*)(unsigned long ulBase,                                      \
1297                    tBoolean bImmediate))ROM_CAMERATABLE[13])
1298 #endif
1299 #if defined(USE_CC3200_ROM_DRV_API) || \
1300     defined(USE_CC3220_ROM_DRV_API)
1301 #define ROM_CameraCaptureStart                                                \
1302         ((void (*)(unsigned long ulBase))ROM_CAMERATABLE[14])
1303 #endif
1304 #if defined(USE_CC3200_ROM_DRV_API) || \
1305     defined(USE_CC3220_ROM_DRV_API)
1306 #define ROM_CameraBufferRead                                                  \
1307         ((void (*)(unsigned long ulBase,                                      \
1308                   unsigned long *pBuffer,                                     \
1309                    unsigned char ucSize))ROM_CAMERATABLE[15])
1310 #endif
1311
1312 //*****************************************************************************
1313 //
1314 // Macros for calling ROM functions in the FLASH API.
1315 //
1316 //*****************************************************************************
1317 #if defined(USE_CC3200_ROM_DRV_API) || \
1318     defined(USE_CC3220_ROM_DRV_API)
1319 #define ROM_FlashDisable                                                      \
1320         ((void (*)(void))ROM_FLASHTABLE[0])
1321 #endif
1322 #if defined(USE_CC3200_ROM_DRV_API) || \
1323     defined(USE_CC3220_ROM_DRV_API)
1324 #define ROM_FlashErase                                                        \
1325         ((long (*)(unsigned long ulAddress))ROM_FLASHTABLE[1])
1326 #endif
1327 #if defined(USE_CC3200_ROM_DRV_API) || \
1328     defined(USE_CC3220_ROM_DRV_API)
1329 #define ROM_FlashMassErase                                                    \
1330         ((long (*)(void))ROM_FLASHTABLE[2])
1331 #endif
1332 #if defined(USE_CC3200_ROM_DRV_API) || \
1333     defined(USE_CC3220_ROM_DRV_API)
1334 #define ROM_FlashMassEraseNonBlocking                                         \
1335         ((void (*)(void))ROM_FLASHTABLE[3])
1336 #endif
1337 #if defined(USE_CC3200_ROM_DRV_API) || \
1338     defined(USE_CC3220_ROM_DRV_API)
1339 #define ROM_FlashEraseNonBlocking                                             \
1340         ((void (*)(unsigned long ulAddress))ROM_FLASHTABLE[4])
1341 #endif
1342 #if defined(USE_CC3200_ROM_DRV_API) || \
1343     defined(USE_CC3220_ROM_DRV_API)
1344 #define ROM_FlashProgram                                                      \
1345         ((long (*)(unsigned long *pulData,                                    \
1346                    unsigned long ulAddress,                                   \
1347                    unsigned long ulCount))ROM_FLASHTABLE[5])
1348 #endif
1349 #if defined(USE_CC3200_ROM_DRV_API) || \
1350     defined(USE_CC3220_ROM_DRV_API)
1351 #define ROM_FlashProgramNonBlocking                                           \
1352         ((long (*)(unsigned long *pulData,                                    \
1353                    unsigned long ulAddress,                                   \
1354                    unsigned long ulCount))ROM_FLASHTABLE[6])
1355 #endif
1356 #if defined(USE_CC3200_ROM_DRV_API) || \
1357     defined(USE_CC3220_ROM_DRV_API)
1358 #define ROM_FlashIntRegister                                                  \
1359         ((void (*)(void (*pfnHandler)(void)))ROM_FLASHTABLE[7])
1360 #endif
1361 #if defined(USE_CC3200_ROM_DRV_API) || \
1362     defined(USE_CC3220_ROM_DRV_API)
1363 #define ROM_FlashIntUnregister                                                \
1364         ((void (*)(void))ROM_FLASHTABLE[8])
1365 #endif
1366 #if defined(USE_CC3200_ROM_DRV_API) || \
1367     defined(USE_CC3220_ROM_DRV_API)
1368 #define ROM_FlashIntEnable                                                    \
1369         ((void (*)(unsigned long ulIntFlags))ROM_FLASHTABLE[9])
1370 #endif
1371 #if defined(USE_CC3200_ROM_DRV_API) || \
1372     defined(USE_CC3220_ROM_DRV_API)
1373 #define ROM_FlashIntDisable                                                   \
1374         ((void (*)(unsigned long ulIntFlags))ROM_FLASHTABLE[10])
1375 #endif
1376 #if defined(USE_CC3200_ROM_DRV_API) || \
1377     defined(USE_CC3220_ROM_DRV_API)
1378 #define ROM_FlashIntStatus                                                    \
1379         ((unsigned long (*)(tBoolean bMasked))ROM_FLASHTABLE[11])
1380 #endif
1381 #if defined(USE_CC3200_ROM_DRV_API) || \
1382     defined(USE_CC3220_ROM_DRV_API)
1383 #define ROM_FlashIntClear                                                     \
1384         ((void (*)(unsigned long ulIntFlags))ROM_FLASHTABLE[12])
1385 #endif
1386 #if defined(USE_CC3200_ROM_DRV_API) || \
1387     defined(USE_CC3220_ROM_DRV_API)
1388 #define ROM_FlashProtectGet                                                   \
1389         ((tFlashProtection (*)(unsigned long ulAddress))ROM_FLASHTABLE[13])
1390 #endif
1391
1392 //*****************************************************************************
1393 //
1394 // Macros for calling ROM functions in the Pin API.
1395 //
1396 //*****************************************************************************
1397 #if defined(USE_CC3200_ROM_DRV_API) || \
1398     defined(USE_CC3220_ROM_DRV_API)
1399 #define ROM_PinModeSet                                                        \
1400         ((void (*)(unsigned long ulPin,                                       \
1401                    unsigned long ulPinMode))ROM_PINTABLE[0])
1402 #endif
1403 #if defined(USE_CC3200_ROM_DRV_API) || \
1404     defined(USE_CC3220_ROM_DRV_API)
1405 #define ROM_PinDirModeSet                                                     \
1406         ((void (*)(unsigned long ulPin,                                       \
1407                    unsigned long ulPinIO))ROM_PINTABLE[1])
1408 #endif
1409 #if defined(USE_CC3200_ROM_DRV_API) || \
1410     defined(USE_CC3220_ROM_DRV_API)
1411 #define ROM_PinDirModeGet                                                     \
1412         ((unsigned long (*)(unsigned long ulPin))ROM_PINTABLE[2])
1413 #endif
1414 #if defined(USE_CC3200_ROM_DRV_API) || \
1415     defined(USE_CC3220_ROM_DRV_API)
1416 #define ROM_PinModeGet                                                        \
1417         ((unsigned long (*)(unsigned long ulPin))ROM_PINTABLE[3])
1418 #endif
1419 #if defined(USE_CC3200_ROM_DRV_API) || \
1420     defined(USE_CC3220_ROM_DRV_API)
1421 #define ROM_PinConfigGet                                                      \
1422         ((void (*)(unsigned long ulPin,                                       \
1423                   unsigned long  *pulPinStrength,                             \
1424                    unsigned long *pulPinType))ROM_PINTABLE[4])
1425 #endif
1426 #if defined(USE_CC3200_ROM_DRV_API) || \
1427     defined(USE_CC3220_ROM_DRV_API)
1428 #define ROM_PinConfigSet                                                      \
1429         ((void (*)(unsigned long ulPin,                                       \
1430                   unsigned long  ulPinStrength,                               \
1431                    unsigned long ulPinType))ROM_PINTABLE[5])
1432 #endif
1433 #if defined(USE_CC3200_ROM_DRV_API) || \
1434     defined(USE_CC3220_ROM_DRV_API)
1435 #define ROM_PinTypeUART                                                       \
1436         ((void (*)(unsigned long ulPin,                                       \
1437                   unsigned long ulPinMode))ROM_PINTABLE[6])
1438 #endif
1439 #if defined(USE_CC3200_ROM_DRV_API) || \
1440     defined(USE_CC3220_ROM_DRV_API)
1441 #define ROM_PinTypeI2C                                                        \
1442         ((void (*)(unsigned long ulPin,                                       \
1443                   unsigned long ulPinMode))ROM_PINTABLE[7])
1444 #endif
1445 #if defined(USE_CC3200_ROM_DRV_API) || \
1446     defined(USE_CC3220_ROM_DRV_API)
1447 #define ROM_PinTypeSPI                                                        \
1448         ((void (*)(unsigned long ulPin,                                       \
1449                   unsigned long ulPinMode))ROM_PINTABLE[8])
1450 #endif
1451 #if defined(USE_CC3200_ROM_DRV_API) || \
1452     defined(USE_CC3220_ROM_DRV_API)
1453 #define ROM_PinTypeI2S                                                        \
1454         ((void (*)(unsigned long ulPin,                                       \
1455                   unsigned long ulPinMode))ROM_PINTABLE[9])
1456 #endif
1457 #if defined(USE_CC3200_ROM_DRV_API) || \
1458     defined(USE_CC3220_ROM_DRV_API)
1459 #define ROM_PinTypeTimer                                                      \
1460         ((void (*)(unsigned long ulPin,                                       \
1461                   unsigned long ulPinMode))ROM_PINTABLE[10])
1462 #endif
1463 #if defined(USE_CC3200_ROM_DRV_API) || \
1464     defined(USE_CC3220_ROM_DRV_API)
1465 #define ROM_PinTypeCamera                                                     \
1466         ((void (*)(unsigned long ulPin,                                       \
1467                   unsigned long ulPinMode))ROM_PINTABLE[11])
1468 #endif
1469 #if defined(USE_CC3200_ROM_DRV_API) || \
1470     defined(USE_CC3220_ROM_DRV_API)
1471 #define ROM_PinTypeGPIO                                                       \
1472         ((void (*)(unsigned long ulPin,                                       \
1473                   unsigned long ulPinMode,                                    \
1474                    tBoolean bOpenDrain))ROM_PINTABLE[12])
1475 #endif
1476 #if defined(USE_CC3200_ROM_DRV_API) || \
1477     defined(USE_CC3220_ROM_DRV_API)
1478 #define ROM_PinTypeADC                                                        \
1479         ((void (*)(unsigned long ulPin,                                       \
1480                   unsigned long ulPinMode))ROM_PINTABLE[13])
1481 #endif
1482 #if defined(USE_CC3200_ROM_DRV_API) || \
1483     defined(USE_CC3220_ROM_DRV_API)
1484 #define ROM_PinTypeSDHost                                                     \
1485         ((void (*)(unsigned long ulPin,                                       \
1486                   unsigned long ulPinMode))ROM_PINTABLE[14])
1487 #endif
1488 #if defined(USE_CC3220_ROM_DRV_API)
1489 #define ROM_PinHysteresisSet                                                  \
1490         ((void (*)(unsigned long ulHysteresis))ROM_PINTABLE[15])
1491 #endif
1492 #if defined(USE_CC3220_ROM_DRV_API)
1493 #define ROM_PinLockLevelSet                                                   \
1494         ((void (*)(unsigned long ulPin,                                       \
1495                    unsigned char ucLevel))ROM_PINTABLE[16])
1496 #endif
1497 #if defined(USE_CC3220_ROM_DRV_API)
1498 #define ROM_PinLock                                                           \
1499         ((void (*)(unsigned long ulOutEnable))ROM_PINTABLE[17])
1500 #endif
1501 #if defined(USE_CC3220_ROM_DRV_API)
1502 #define ROM_PinUnlock                                                         \
1503         ((void (*)(void))ROM_PINTABLE[18])
1504 #endif
1505
1506 //*****************************************************************************
1507 //
1508 // Macros for calling ROM functions in the SYSTICK API.
1509 //
1510 //*****************************************************************************
1511 #if defined(USE_CC3200_ROM_DRV_API) || \
1512     defined(USE_CC3220_ROM_DRV_API)
1513 #define ROM_SysTickEnable                                                     \
1514         ((void (*)(void))ROM_SYSTICKTABLE[0])
1515 #endif
1516 #if defined(USE_CC3200_ROM_DRV_API) || \
1517     defined(USE_CC3220_ROM_DRV_API)
1518 #define ROM_SysTickDisable                                                    \
1519         ((void (*)(void))ROM_SYSTICKTABLE[1])
1520 #endif
1521 #if defined(USE_CC3200_ROM_DRV_API) || \
1522     defined(USE_CC3220_ROM_DRV_API)
1523 #define ROM_SysTickIntRegister                                                \
1524         ((void (*)(void (*pfnHandler)(void)))ROM_SYSTICKTABLE[2])
1525 #endif
1526 #if defined(USE_CC3200_ROM_DRV_API) || \
1527     defined(USE_CC3220_ROM_DRV_API)
1528 #define ROM_SysTickIntUnregister                                              \
1529         ((void (*)(void))ROM_SYSTICKTABLE[3])
1530 #endif
1531 #if defined(USE_CC3200_ROM_DRV_API) || \
1532     defined(USE_CC3220_ROM_DRV_API)
1533 #define ROM_SysTickIntEnable                                                  \
1534         ((void (*)(void))ROM_SYSTICKTABLE[4])
1535 #endif
1536 #if defined(USE_CC3200_ROM_DRV_API) || \
1537     defined(USE_CC3220_ROM_DRV_API)
1538 #define ROM_SysTickIntDisable                                                 \
1539         ((void (*)(void))ROM_SYSTICKTABLE[5])
1540 #endif
1541 #if defined(USE_CC3200_ROM_DRV_API) || \
1542     defined(USE_CC3220_ROM_DRV_API)
1543 #define ROM_SysTickPeriodSet                                                  \
1544         ((void (*)(unsigned long ulPeriod))ROM_SYSTICKTABLE[6])
1545 #endif
1546 #if defined(USE_CC3200_ROM_DRV_API) || \
1547     defined(USE_CC3220_ROM_DRV_API)
1548 #define ROM_SysTickPeriodGet                                                  \
1549         ((unsigned long (*)(void))ROM_SYSTICKTABLE[7])
1550 #endif
1551 #if defined(USE_CC3200_ROM_DRV_API) || \
1552     defined(USE_CC3220_ROM_DRV_API)
1553 #define ROM_SysTickValueGet                                                   \
1554         ((unsigned long (*)(void))ROM_SYSTICKTABLE[8])
1555 #endif
1556
1557 //*****************************************************************************
1558 //
1559 // Macros for calling ROM functions in the UTILS API.
1560 //
1561 //*****************************************************************************
1562 #if defined(USE_CC3200_ROM_DRV_API) || \
1563     defined(USE_CC3220_ROM_DRV_API)
1564 #define ROM_UtilsDelay                                                        \
1565         ((void (*)(unsigned long ulCount))ROM_UTILSTABLE[0])
1566 #endif
1567
1568 //*****************************************************************************
1569 //
1570 // Macros for calling ROM functions in the I2S API.
1571 //
1572 //*****************************************************************************
1573 #if defined(USE_CC3200_ROM_DRV_API) || \
1574     defined(USE_CC3220_ROM_DRV_API)
1575 #define ROM_I2SEnable                                                         \
1576         ((void (*)(unsigned long ulBase,                                      \
1577                    unsigned long ulMode))ROM_I2STABLE[0])
1578 #endif
1579 #if defined(USE_CC3200_ROM_DRV_API) || \
1580     defined(USE_CC3220_ROM_DRV_API)
1581 #define ROM_I2SDisable                                                        \
1582         ((void (*)(unsigned long ulBase))ROM_I2STABLE[1])
1583 #endif
1584 #if defined(USE_CC3200_ROM_DRV_API) || \
1585     defined(USE_CC3220_ROM_DRV_API)
1586 #define ROM_I2SDataPut                                                        \
1587         ((void (*)(unsigned long ulBase,                                      \
1588                    unsigned long ulDataLine,                                  \
1589                    unsigned long ulData))ROM_I2STABLE[2])
1590 #endif
1591 #if defined(USE_CC3200_ROM_DRV_API) || \
1592     defined(USE_CC3220_ROM_DRV_API)
1593 #define ROM_I2SDataPutNonBlocking                                             \
1594         ((long (*)(unsigned long ulBase,                                      \
1595                    unsigned long ulDataLine,                                  \
1596                    unsigned long ulData))ROM_I2STABLE[3])
1597 #endif
1598 #if defined(USE_CC3200_ROM_DRV_API) || \
1599     defined(USE_CC3220_ROM_DRV_API)
1600 #define ROM_I2SDataGet                                                        \
1601         ((void (*)(unsigned long ulBase,                                      \
1602                    unsigned long ulDataLine,                                  \
1603                    unsigned long *pulData))ROM_I2STABLE[4])
1604 #endif
1605 #if defined(USE_CC3200_ROM_DRV_API) || \
1606     defined(USE_CC3220_ROM_DRV_API)
1607 #define ROM_I2SDataGetNonBlocking                                             \
1608         ((long (*)(unsigned long ulBase,                                      \
1609                    unsigned long ulDataLine,                                  \
1610                    unsigned long *pulData))ROM_I2STABLE[5])
1611 #endif
1612 #if defined(USE_CC3200_ROM_DRV_API) || \
1613     defined(USE_CC3220_ROM_DRV_API)
1614 #define ROM_I2SConfigSetExpClk                                                \
1615         ((void (*)(unsigned long ulBase,                                      \
1616                    unsigned long ulI2SClk,                                    \
1617                    unsigned long ulBitClk,                                    \
1618                    unsigned long ulConfig))ROM_I2STABLE[6])
1619 #endif
1620 #if defined(USE_CC3200_ROM_DRV_API) || \
1621     defined(USE_CC3220_ROM_DRV_API)
1622 #define ROM_I2STxFIFOEnable                                                   \
1623         ((void (*)(unsigned long ulBase,                                      \
1624                    unsigned long ulTxLevel,                                   \
1625                    unsigned long ulWordsPerTransfer))ROM_I2STABLE[7])
1626 #endif
1627 #if defined(USE_CC3200_ROM_DRV_API) || \
1628     defined(USE_CC3220_ROM_DRV_API)
1629 #define ROM_I2STxFIFODisable                                                  \
1630         ((void (*)(unsigned long ulBase))ROM_I2STABLE[8])
1631 #endif
1632 #if defined(USE_CC3200_ROM_DRV_API) || \
1633     defined(USE_CC3220_ROM_DRV_API)
1634 #define ROM_I2SRxFIFOEnable                                                   \
1635         ((void (*)(unsigned long ulBase,                                      \
1636                    unsigned long ulRxLevel,                                   \
1637                    unsigned long ulWordsPerTransfer))ROM_I2STABLE[9])
1638 #endif
1639 #if defined(USE_CC3200_ROM_DRV_API) || \
1640     defined(USE_CC3220_ROM_DRV_API)
1641 #define ROM_I2SRxFIFODisable                                                  \
1642         ((void (*)(unsigned long ulBase))ROM_I2STABLE[10])
1643 #endif
1644 #if defined(USE_CC3200_ROM_DRV_API) || \
1645     defined(USE_CC3220_ROM_DRV_API)
1646 #define ROM_I2STxFIFOStatusGet                                                \
1647         ((unsigned long (*)(unsigned long ulBase))ROM_I2STABLE[11])
1648 #endif
1649 #if defined(USE_CC3200_ROM_DRV_API) || \
1650     defined(USE_CC3220_ROM_DRV_API)
1651 #define ROM_I2SRxFIFOStatusGet                                                \
1652         ((unsigned long (*)(unsigned long ulBase))ROM_I2STABLE[12])
1653 #endif
1654 #if defined(USE_CC3200_ROM_DRV_API) || \
1655     defined(USE_CC3220_ROM_DRV_API)
1656 #define ROM_I2SSerializerConfig                                               \
1657         ((void (*)(unsigned long ulBase,                                      \
1658                    unsigned long ulDataLine,                                  \
1659                    unsigned long ulSerMode,                                   \
1660                    unsigned long ulInActState))ROM_I2STABLE[13])
1661 #endif
1662 #if defined(USE_CC3200_ROM_DRV_API) || \
1663     defined(USE_CC3220_ROM_DRV_API)
1664 #define ROM_I2SIntEnable                                                      \
1665         ((void (*)(unsigned long ulBase,                                      \
1666                    unsigned long ulIntFlags))ROM_I2STABLE[14])
1667 #endif
1668 #if defined(USE_CC3200_ROM_DRV_API) || \
1669     defined(USE_CC3220_ROM_DRV_API)
1670 #define ROM_I2SIntDisable                                                     \
1671         ((void (*)(unsigned long ulBase,                                      \
1672                    unsigned long ulIntFlags))ROM_I2STABLE[15])
1673 #endif
1674 #if defined(USE_CC3200_ROM_DRV_API) || \
1675     defined(USE_CC3220_ROM_DRV_API)
1676 #define ROM_I2SIntStatus                                                      \
1677         ((unsigned long (*)(unsigned long ulBase))ROM_I2STABLE[16])
1678 #endif
1679 #if defined(USE_CC3200_ROM_DRV_API) || \
1680     defined(USE_CC3220_ROM_DRV_API)
1681 #define ROM_I2SIntClear                                                       \
1682         ((void (*)(unsigned long ulBase,                                      \
1683                    unsigned long ulIntFlags))ROM_I2STABLE[17])
1684 #endif
1685 #if defined(USE_CC3200_ROM_DRV_API) || \
1686     defined(USE_CC3220_ROM_DRV_API)
1687 #define ROM_I2SIntRegister                                                    \
1688         ((void (*)(unsigned long ulBase,                                      \
1689                    void (*pfnHandler)(void)))ROM_I2STABLE[18])
1690 #endif
1691 #if defined(USE_CC3200_ROM_DRV_API) || \
1692     defined(USE_CC3220_ROM_DRV_API)
1693 #define ROM_I2SIntUnregister                                                  \
1694         ((void (*)(unsigned long ulBase))ROM_I2STABLE[19])
1695 #endif
1696 #if defined(USE_CC3220_ROM_DRV_API)
1697 #define ROM_I2STxActiveSlotSet                                                \
1698         ((void (*)(unsigned long ulBase,                                      \
1699                    unsigned long ulActSlot))ROM_I2STABLE[20])
1700 #endif
1701 #if defined(USE_CC3220_ROM_DRV_API)
1702 #define ROM_I2SRxActiveSlotSet                                                \
1703         ((void (*)(unsigned long ulBase,                                      \
1704                    unsigned long ulActSlot))ROM_I2STABLE[21])
1705 #endif
1706
1707 //*****************************************************************************
1708 //
1709 // Macros for calling ROM functions in the GPIO API.
1710 //
1711 //*****************************************************************************
1712 #if defined(USE_CC3200_ROM_DRV_API) || \
1713     defined(USE_CC3220_ROM_DRV_API)
1714 #define ROM_GPIODirModeSet                                                    \
1715         ((void (*)(unsigned long ulPort,                                      \
1716                    unsigned char ucPins,                                      \
1717                    unsigned long ulPinIO))ROM_GPIOTABLE[0])
1718 #endif
1719 #if defined(USE_CC3200_ROM_DRV_API) || \
1720     defined(USE_CC3220_ROM_DRV_API)
1721 #define ROM_GPIODirModeGet                                                    \
1722         ((unsigned long (*)(unsigned long ulPort,                             \
1723                             unsigned char ucPin))ROM_GPIOTABLE[1])
1724 #endif
1725 #if defined(USE_CC3200_ROM_DRV_API) || \
1726     defined(USE_CC3220_ROM_DRV_API)
1727 #define ROM_GPIOIntTypeSet                                                    \
1728         ((void (*)(unsigned long ulPort,                                      \
1729                    unsigned char ucPins,                                      \
1730                    unsigned long ulIntType))ROM_GPIOTABLE[2])
1731 #endif
1732 #if defined(USE_CC3200_ROM_DRV_API) || \
1733     defined(USE_CC3220_ROM_DRV_API)
1734 #define ROM_GPIODMATriggerEnable                                              \
1735         ((void (*)(unsigned long ulPort))ROM_GPIOTABLE[3])
1736 #endif
1737 #if defined(USE_CC3200_ROM_DRV_API) || \
1738     defined(USE_CC3220_ROM_DRV_API)
1739 #define ROM_GPIODMATriggerDisable                                             \
1740         ((void (*)(unsigned long ulPort))ROM_GPIOTABLE[4])
1741 #endif
1742 #if defined(USE_CC3200_ROM_DRV_API) || \
1743     defined(USE_CC3220_ROM_DRV_API)
1744 #define ROM_GPIOIntTypeGet                                                    \
1745         ((unsigned long (*)(unsigned long ulPort,                             \
1746                             unsigned char ucPin))ROM_GPIOTABLE[5])
1747 #endif
1748 #if defined(USE_CC3200_ROM_DRV_API) || \
1749     defined(USE_CC3220_ROM_DRV_API)
1750 #define ROM_GPIOIntEnable                                                     \
1751         ((void (*)(unsigned long ulPort,                                      \
1752                    unsigned long ulIntFlags))ROM_GPIOTABLE[6])
1753 #endif
1754 #if defined(USE_CC3200_ROM_DRV_API) || \
1755     defined(USE_CC3220_ROM_DRV_API)
1756 #define ROM_GPIOIntDisable                                                    \
1757         ((void (*)(unsigned long ulPort,                                      \
1758                    unsigned long ulIntFlags))ROM_GPIOTABLE[7])
1759 #endif
1760 #if defined(USE_CC3200_ROM_DRV_API) || \
1761     defined(USE_CC3220_ROM_DRV_API)
1762 #define ROM_GPIOIntStatus                                                     \
1763         ((long (*)(unsigned long ulPort,                                      \
1764                    tBoolean bMasked))ROM_GPIOTABLE[8])
1765 #endif
1766 #if defined(USE_CC3200_ROM_DRV_API) || \
1767     defined(USE_CC3220_ROM_DRV_API)
1768 #define ROM_GPIOIntClear                                                      \
1769         ((void (*)(unsigned long ulPort,                                      \
1770                    unsigned long ulIntFlags))ROM_GPIOTABLE[9])
1771 #endif
1772 #if defined(USE_CC3200_ROM_DRV_API) || \
1773     defined(USE_CC3220_ROM_DRV_API)
1774 #define ROM_GPIOIntRegister                                                   \
1775         ((void (*)(unsigned long ulPort,                                      \
1776                    void (*pfnIntHandler)(void)))ROM_GPIOTABLE[10])
1777 #endif
1778 #if defined(USE_CC3200_ROM_DRV_API) || \
1779     defined(USE_CC3220_ROM_DRV_API)
1780 #define ROM_GPIOIntUnregister                                                 \
1781         ((void (*)(unsigned long ulPort))ROM_GPIOTABLE[11])
1782 #endif
1783 #if defined(USE_CC3200_ROM_DRV_API) || \
1784     defined(USE_CC3220_ROM_DRV_API)
1785 #define ROM_GPIOPinRead                                                       \
1786         ((long (*)(unsigned long ulPort,                                      \
1787                    unsigned char ucPins))ROM_GPIOTABLE[12])
1788 #endif
1789 #if defined(USE_CC3200_ROM_DRV_API) || \
1790     defined(USE_CC3220_ROM_DRV_API)
1791 #define ROM_GPIOPinWrite                                                      \
1792         ((void (*)(unsigned long ulPort,                                      \
1793                    unsigned char ucPins,                                      \
1794                    unsigned char ucVal))ROM_GPIOTABLE[13])
1795 #endif
1796
1797 //*****************************************************************************
1798 //
1799 // Macros for calling ROM functions in the AES API.
1800 //
1801 //*****************************************************************************
1802 #if defined(USE_CC3200_ROM_DRV_API) || \
1803     defined(USE_CC3220_ROM_DRV_API)
1804 #define ROM_AESConfigSet                                                      \
1805         ((void (*)(uint32_t ui32Base,                                         \
1806                    uint32_t ui32Config))ROM_AESTABLE[0])
1807 #endif
1808 #if defined(USE_CC3200_ROM_DRV_API) || \
1809     defined(USE_CC3220_ROM_DRV_API)
1810 #define ROM_AESKey1Set                                                        \
1811         ((void (*)(uint32_t ui32Base,                                         \
1812                    uint8_t *pui8Key,                                          \
1813                    uint32_t ui32Keysize))ROM_AESTABLE[1])
1814 #endif
1815 #if defined(USE_CC3200_ROM_DRV_API) || \
1816     defined(USE_CC3220_ROM_DRV_API)
1817 #define ROM_AESKey2Set                                                        \
1818         ((void (*)(uint32_t ui32Base,                                         \
1819                    uint8_t *pui8Key,                                          \
1820                    uint32_t ui32Keysize))ROM_AESTABLE[2])
1821 #endif
1822 #if defined(USE_CC3200_ROM_DRV_API) || \
1823     defined(USE_CC3220_ROM_DRV_API)
1824 #define ROM_AESKey3Set                                                        \
1825         ((void (*)(uint32_t ui32Base,                                         \
1826                    uint8_t *pui8Key))ROM_AESTABLE[3])
1827 #endif
1828 #if defined(USE_CC3200_ROM_DRV_API) || \
1829     defined(USE_CC3220_ROM_DRV_API)
1830 #define ROM_AESIVSet                                                          \
1831         ((void (*)(uint32_t ui32Base,                                         \
1832                    uint8_t *pui8IVdata))ROM_AESTABLE[4])
1833 #endif
1834 #if defined(USE_CC3200_ROM_DRV_API) || \
1835     defined(USE_CC3220_ROM_DRV_API)
1836 #define ROM_AESTagRead                                                        \
1837         ((void (*)(uint32_t ui32Base,                                         \
1838                    uint8_t *pui8TagData))ROM_AESTABLE[5])
1839 #endif
1840 #if defined(USE_CC3200_ROM_DRV_API) || \
1841     defined(USE_CC3220_ROM_DRV_API)
1842 #define ROM_AESDataLengthSet                                                  \
1843         ((void (*)(uint32_t ui32Base,                                         \
1844                    uint64_t ui64Length))ROM_AESTABLE[6])
1845 #endif
1846 #if defined(USE_CC3200_ROM_DRV_API) || \
1847     defined(USE_CC3220_ROM_DRV_API)
1848 #define ROM_AESAuthDataLengthSet                                              \
1849         ((void (*)(uint32_t ui32Base,                                         \
1850                    uint32_t ui32Length))ROM_AESTABLE[7])
1851 #endif
1852 #if defined(USE_CC3200_ROM_DRV_API) || \
1853     defined(USE_CC3220_ROM_DRV_API)
1854 #define ROM_AESDataReadNonBlocking                                            \
1855         ((bool (*)(uint32_t ui32Base,                                         \
1856                    uint8_t *pui8Dest,                                         \
1857                    uint8_t ui8Length))ROM_AESTABLE[8])
1858 #endif
1859 #if defined(USE_CC3200_ROM_DRV_API) || \
1860     defined(USE_CC3220_ROM_DRV_API)
1861 #define ROM_AESDataRead                                                       \
1862         ((void (*)(uint32_t ui32Base,                                         \
1863                    uint8_t *pui8Dest,                                         \
1864                    uint8_t ui8Length))ROM_AESTABLE[9])
1865 #endif
1866 #if defined(USE_CC3200_ROM_DRV_API) || \
1867     defined(USE_CC3220_ROM_DRV_API)
1868 #define ROM_AESDataWriteNonBlocking                                           \
1869         ((bool (*)(uint32_t ui32Base,                                         \
1870                    uint8_t *pui8Src,                                          \
1871                    uint8_t ui8Length))ROM_AESTABLE[10])
1872 #endif
1873 #if defined(USE_CC3200_ROM_DRV_API) || \
1874     defined(USE_CC3220_ROM_DRV_API)
1875 #define ROM_AESDataWrite                                                      \
1876         ((void (*)(uint32_t ui32Base,                                         \
1877                    uint8_t *pui8Src,                                          \
1878                    uint8_t ui8Length))ROM_AESTABLE[11])
1879 #endif
1880 #if defined(USE_CC3200_ROM_DRV_API) || \
1881     defined(USE_CC3220_ROM_DRV_API)
1882 #define ROM_AESDataProcess                                                    \
1883         ((bool (*)(uint32_t ui32Base,                                         \
1884                    uint8_t *pui8Src,                                          \
1885                    uint8_t *pui8Dest,                                         \
1886                    uint32_t ui32Length))ROM_AESTABLE[12])
1887 #endif
1888 #if defined(USE_CC3200_ROM_DRV_API) || \
1889     defined(USE_CC3220_ROM_DRV_API)
1890 #define ROM_AESDataMAC                                                        \
1891         ((bool (*)(uint32_t ui32Base,                                         \
1892                    uint8_t *pui8Src,                                          \
1893                    uint32_t ui32Length,                                       \
1894                    uint8_t *pui8Tag))ROM_AESTABLE[13])
1895 #endif
1896 #if defined(USE_CC3200_ROM_DRV_API) || \
1897     defined(USE_CC3220_ROM_DRV_API)
1898 #define ROM_AESDataProcessAE                                                  \
1899         ((bool (*)(uint32_t ui32Base,                                         \
1900                    uint8_t *pui8Src,                                          \
1901                    uint8_t *pui8Dest,                                         \
1902                    uint32_t ui32Length,                                       \
1903                    uint8_t *pui8AuthSrc,                                      \
1904                    uint32_t ui32AuthLength,                                   \
1905                    uint8_t *pui8Tag))ROM_AESTABLE[14])
1906 #endif
1907 #if defined(USE_CC3200_ROM_DRV_API) || \
1908     defined(USE_CC3220_ROM_DRV_API)
1909 #define ROM_AESIntStatus                                                      \
1910         ((uint32_t (*)(uint32_t ui32Base,                                     \
1911                        bool bMasked))ROM_AESTABLE[15])
1912 #endif
1913 #if defined(USE_CC3200_ROM_DRV_API) || \
1914     defined(USE_CC3220_ROM_DRV_API)
1915 #define ROM_AESIntEnable                                                      \
1916         ((void (*)(uint32_t ui32Base,                                         \
1917                    uint32_t ui32IntFlags))ROM_AESTABLE[16])
1918 #endif
1919 #if defined(USE_CC3200_ROM_DRV_API) || \
1920     defined(USE_CC3220_ROM_DRV_API)
1921 #define ROM_AESIntDisable                                                     \
1922         ((void (*)(uint32_t ui32Base,                                         \
1923                    uint32_t ui32IntFlags))ROM_AESTABLE[17])
1924 #endif
1925 #if defined(USE_CC3200_ROM_DRV_API) || \
1926     defined(USE_CC3220_ROM_DRV_API)
1927 #define ROM_AESIntClear                                                       \
1928         ((void (*)(uint32_t ui32Base,                                         \
1929                    uint32_t ui32IntFlags))ROM_AESTABLE[18])
1930 #endif
1931 #if defined(USE_CC3200_ROM_DRV_API) || \
1932     defined(USE_CC3220_ROM_DRV_API)
1933 #define ROM_AESIntRegister                                                    \
1934         ((void (*)(uint32_t ui32Base,                                         \
1935                    void(*pfnHandler)(void)))ROM_AESTABLE[19])
1936 #endif
1937 #if defined(USE_CC3200_ROM_DRV_API) || \
1938     defined(USE_CC3220_ROM_DRV_API)
1939 #define ROM_AESIntUnregister                                                  \
1940         ((void (*)(uint32_t ui32Base))ROM_AESTABLE[20])
1941 #endif
1942 #if defined(USE_CC3200_ROM_DRV_API) || \
1943     defined(USE_CC3220_ROM_DRV_API)
1944 #define ROM_AESDMAEnable                                                      \
1945         ((void (*)(uint32_t ui32Base,                                         \
1946                    uint32_t ui32Flags))ROM_AESTABLE[21])
1947 #endif
1948 #if defined(USE_CC3200_ROM_DRV_API) || \
1949     defined(USE_CC3220_ROM_DRV_API)
1950 #define ROM_AESDMADisable                                                     \
1951         ((void (*)(uint32_t ui32Base,                                         \
1952                    uint32_t ui32Flags))ROM_AESTABLE[22])
1953 #endif
1954 #if defined(USE_CC3220_ROM_DRV_API)
1955 #define ROM_AESIVGet                                                          \
1956         ((void (*)(uint32_t ui32Base,                                         \
1957                    uint8_t *pui8IVdata))ROM_AESTABLE[23])
1958 #endif
1959
1960 //*****************************************************************************
1961 //
1962 // Macros for calling ROM functions in the DES API.
1963 //
1964 //*****************************************************************************
1965 #if defined(USE_CC3200_ROM_DRV_API) || \
1966     defined(USE_CC3220_ROM_DRV_API)
1967 #define ROM_DESConfigSet                                                      \
1968         ((void (*)(uint32_t ui32Base,                                         \
1969                    uint32_t ui32Config))ROM_DESTABLE[0])
1970 #endif
1971 #if defined(USE_CC3200_ROM_DRV_API) || \
1972     defined(USE_CC3220_ROM_DRV_API)
1973 #define ROM_DESDataRead                                                       \
1974         ((void (*)(uint32_t ui32Base,                                         \
1975                    uint8_t *pui8Dest,                                         \
1976                    uint8_t ui8Length))ROM_DESTABLE[1])
1977 #endif
1978 #if defined(USE_CC3200_ROM_DRV_API) || \
1979     defined(USE_CC3220_ROM_DRV_API)
1980 #define ROM_DESDataReadNonBlocking                                            \
1981         ((bool (*)(uint32_t ui32Base,                                         \
1982                    uint8_t *pui8Dest,                                         \
1983                    uint8_t ui8Length))ROM_DESTABLE[2])
1984 #endif
1985 #if defined(USE_CC3200_ROM_DRV_API) || \
1986     defined(USE_CC3220_ROM_DRV_API)
1987 #define ROM_DESDataProcess                                                    \
1988         ((bool (*)(uint32_t ui32Base,                                         \
1989                    uint8_t *pui8Src,                                          \
1990                    uint8_t *pui8Dest,                                         \
1991                    uint32_t ui32Length))ROM_DESTABLE[3])
1992 #endif
1993 #if defined(USE_CC3200_ROM_DRV_API) || \
1994     defined(USE_CC3220_ROM_DRV_API)
1995 #define ROM_DESDataWrite                                                      \
1996         ((void (*)(uint32_t ui32Base,                                         \
1997                    uint8_t *pui8Src,                                          \
1998                    uint8_t ui8Length))ROM_DESTABLE[4])
1999 #endif
2000 #if defined(USE_CC3200_ROM_DRV_API) || \
2001     defined(USE_CC3220_ROM_DRV_API)
2002 #define ROM_DESDataWriteNonBlocking                                           \
2003         ((bool (*)(uint32_t ui32Base,                                         \
2004                    uint8_t *pui8Src,                                          \
2005                    uint8_t ui8Length))ROM_DESTABLE[5])
2006 #endif
2007 #if defined(USE_CC3200_ROM_DRV_API) || \
2008     defined(USE_CC3220_ROM_DRV_API)
2009 #define ROM_DESDMADisable                                                     \
2010         ((void (*)(uint32_t ui32Base,                                         \
2011                    uint32_t ui32Flags))ROM_DESTABLE[6])
2012 #endif
2013 #if defined(USE_CC3200_ROM_DRV_API) || \
2014     defined(USE_CC3220_ROM_DRV_API)
2015 #define ROM_DESDMAEnable                                                      \
2016         ((void (*)(uint32_t ui32Base,                                         \
2017                    uint32_t ui32Flags))ROM_DESTABLE[7])
2018 #endif
2019 #if defined(USE_CC3200_ROM_DRV_API) || \
2020     defined(USE_CC3220_ROM_DRV_API)
2021 #define ROM_DESIntClear                                                       \
2022         ((void (*)(uint32_t ui32Base,                                         \
2023                    uint32_t ui32IntFlags))ROM_DESTABLE[8])
2024 #endif
2025 #if defined(USE_CC3200_ROM_DRV_API) || \
2026     defined(USE_CC3220_ROM_DRV_API)
2027 #define ROM_DESIntDisable                                                     \
2028         ((void (*)(uint32_t ui32Base,                                         \
2029                    uint32_t ui32IntFlags))ROM_DESTABLE[9])
2030 #endif
2031 #if defined(USE_CC3200_ROM_DRV_API) || \
2032     defined(USE_CC3220_ROM_DRV_API)
2033 #define ROM_DESIntEnable                                                      \
2034         ((void (*)(uint32_t ui32Base,                                         \
2035                    uint32_t ui32IntFlags))ROM_DESTABLE[10])
2036 #endif
2037 #if defined(USE_CC3200_ROM_DRV_API) || \
2038     defined(USE_CC3220_ROM_DRV_API)
2039 #define ROM_DESIntRegister                                                    \
2040         ((void (*)(uint32_t ui32Base,                                         \
2041                    void(*pfnHandler)(void)))ROM_DESTABLE[11])
2042 #endif
2043 #if defined(USE_CC3200_ROM_DRV_API) || \
2044     defined(USE_CC3220_ROM_DRV_API)
2045 #define ROM_DESIntStatus                                                      \
2046         ((uint32_t (*)(uint32_t ui32Base,                                     \
2047                        bool bMasked))ROM_DESTABLE[12])
2048 #endif
2049 #if defined(USE_CC3200_ROM_DRV_API) || \
2050     defined(USE_CC3220_ROM_DRV_API)
2051 #define ROM_DESIntUnregister                                                  \
2052         ((void (*)(uint32_t ui32Base))ROM_DESTABLE[13])
2053 #endif
2054 #if defined(USE_CC3200_ROM_DRV_API) || \
2055     defined(USE_CC3220_ROM_DRV_API)
2056 #define ROM_DESIVSet                                                          \
2057         ((bool (*)(uint32_t ui32Base,                                         \
2058                    uint8_t *pui8IVdata))ROM_DESTABLE[14])
2059 #endif
2060 #if defined(USE_CC3200_ROM_DRV_API) || \
2061     defined(USE_CC3220_ROM_DRV_API)
2062 #define ROM_DESKeySet                                                         \
2063         ((void (*)(uint32_t ui32Base,                                         \
2064                    uint8_t *pui8Key))ROM_DESTABLE[15])
2065 #endif
2066 #if defined(USE_CC3200_ROM_DRV_API) || \
2067     defined(USE_CC3220_ROM_DRV_API)
2068 #define ROM_DESDataLengthSet                                                  \
2069         ((void (*)(uint32_t ui32Base,                                         \
2070                    uint32_t ui32Length))ROM_DESTABLE[16])
2071 #endif
2072
2073 //*****************************************************************************
2074 //
2075 // Macros for calling ROM functions in the SHAMD5 API.
2076 //
2077 //*****************************************************************************
2078 #if defined(USE_CC3200_ROM_DRV_API) || \
2079     defined(USE_CC3220_ROM_DRV_API)
2080 #define ROM_SHAMD5ConfigSet                                                   \
2081         ((void (*)(uint32_t ui32Base,                                         \
2082                    uint32_t ui32Mode))ROM_SHAMD5TABLE[0])
2083 #endif
2084 #if defined(USE_CC3200_ROM_DRV_API) || \
2085     defined(USE_CC3220_ROM_DRV_API)
2086 #define ROM_SHAMD5DataProcess                                                 \
2087         ((bool (*)(uint32_t ui32Base,                                         \
2088                    uint8_t *pui8DataSrc,                                      \
2089                    uint32_t ui32DataLength,                                   \
2090                    uint8_t *pui8HashResult))ROM_SHAMD5TABLE[1])
2091 #endif
2092 #if defined(USE_CC3200_ROM_DRV_API) || \
2093     defined(USE_CC3220_ROM_DRV_API)
2094 #define ROM_SHAMD5DataWrite                                                   \
2095         ((void (*)(uint32_t ui32Base,                                         \
2096                    uint8_t *pui8Src))ROM_SHAMD5TABLE[2])
2097 #endif
2098 #if defined(USE_CC3200_ROM_DRV_API) || \
2099     defined(USE_CC3220_ROM_DRV_API)
2100 #define ROM_SHAMD5DataWriteNonBlocking                                        \
2101         ((bool (*)(uint32_t ui32Base,                                         \
2102                    uint8_t *pui8Src))ROM_SHAMD5TABLE[3])
2103 #endif
2104 #if defined(USE_CC3200_ROM_DRV_API) || \
2105     defined(USE_CC3220_ROM_DRV_API)
2106 #define ROM_SHAMD5DMADisable                                                  \
2107         ((void (*)(uint32_t ui32Base))ROM_SHAMD5TABLE[4])
2108 #endif
2109 #if defined(USE_CC3200_ROM_DRV_API) || \
2110     defined(USE_CC3220_ROM_DRV_API)
2111 #define ROM_SHAMD5DMAEnable                                                   \
2112         ((void (*)(uint32_t ui32Base))ROM_SHAMD5TABLE[5])
2113 #endif
2114 #if defined(USE_CC3200_ROM_DRV_API) || \
2115     defined(USE_CC3220_ROM_DRV_API)
2116 #define ROM_SHAMD5DataLengthSet                                               \
2117         ((void (*)(uint32_t ui32Base,                                         \
2118                    uint32_t ui32Length))ROM_SHAMD5TABLE[6])
2119 #endif
2120 #if defined(USE_CC3200_ROM_DRV_API) || \
2121     defined(USE_CC3220_ROM_DRV_API)
2122 #define ROM_SHAMD5HMACKeySet                                                  \
2123         ((void (*)(uint32_t ui32Base,                                         \
2124                    uint8_t *pui8Src))ROM_SHAMD5TABLE[7])
2125 #endif
2126 #if defined(USE_CC3200_ROM_DRV_API) || \
2127     defined(USE_CC3220_ROM_DRV_API)
2128 #define ROM_SHAMD5HMACPPKeyGenerate                                           \
2129         ((void (*)(uint32_t ui32Base,                                         \
2130                    uint8_t *pui8Key,                                          \
2131                    uint8_t *pui8PPKey))ROM_SHAMD5TABLE[8])
2132 #endif
2133 #if defined(USE_CC3200_ROM_DRV_API) || \
2134     defined(USE_CC3220_ROM_DRV_API)
2135 #define ROM_SHAMD5HMACPPKeySet                                                \
2136         ((void (*)(uint32_t ui32Base,                                         \
2137                    uint8_t *pui8Src))ROM_SHAMD5TABLE[9])
2138 #endif
2139 #if defined(USE_CC3200_ROM_DRV_API) || \
2140     defined(USE_CC3220_ROM_DRV_API)
2141 #define ROM_SHAMD5HMACProcess                                                 \
2142         ((bool (*)(uint32_t ui32Base,                                         \
2143                    uint8_t *pui8DataSrc,                                      \
2144                    uint32_t ui32DataLength,                                   \
2145                    uint8_t *pui8HashResult))ROM_SHAMD5TABLE[10])
2146 #endif
2147 #if defined(USE_CC3200_ROM_DRV_API) || \
2148     defined(USE_CC3220_ROM_DRV_API)
2149 #define ROM_SHAMD5IntClear                                                    \
2150         ((void (*)(uint32_t ui32Base,                                         \
2151                    uint32_t ui32IntFlags))ROM_SHAMD5TABLE[11])
2152 #endif
2153 #if defined(USE_CC3200_ROM_DRV_API) || \
2154     defined(USE_CC3220_ROM_DRV_API)
2155 #define ROM_SHAMD5IntDisable                                                  \
2156         ((void (*)(uint32_t ui32Base,                                         \
2157                    uint32_t ui32IntFlags))ROM_SHAMD5TABLE[12])
2158 #endif
2159 #if defined(USE_CC3200_ROM_DRV_API) || \
2160     defined(USE_CC3220_ROM_DRV_API)
2161 #define ROM_SHAMD5IntEnable                                                   \
2162         ((void (*)(uint32_t ui32Base,                                         \
2163                    uint32_t ui32IntFlags))ROM_SHAMD5TABLE[13])
2164 #endif
2165 #if defined(USE_CC3200_ROM_DRV_API) || \
2166     defined(USE_CC3220_ROM_DRV_API)
2167 #define ROM_SHAMD5IntRegister                                                 \
2168         ((void (*)(uint32_t ui32Base,                                         \
2169                    void(*pfnHandler)(void)))ROM_SHAMD5TABLE[14])
2170 #endif
2171 #if defined(USE_CC3200_ROM_DRV_API) || \
2172     defined(USE_CC3220_ROM_DRV_API)
2173 #define ROM_SHAMD5IntStatus                                                   \
2174         ((uint32_t (*)(uint32_t ui32Base,                                     \
2175                        bool bMasked))ROM_SHAMD5TABLE[15])
2176 #endif
2177 #if defined(USE_CC3200_ROM_DRV_API) || \
2178     defined(USE_CC3220_ROM_DRV_API)
2179 #define ROM_SHAMD5IntUnregister                                               \
2180         ((void (*)(uint32_t ui32Base))ROM_SHAMD5TABLE[16])
2181 #endif
2182 #if defined(USE_CC3200_ROM_DRV_API) || \
2183     defined(USE_CC3220_ROM_DRV_API)
2184 #define ROM_SHAMD5ResultRead                                                  \
2185         ((void (*)(uint32_t ui32Base,                                         \
2186                    uint8_t *pui8Dest))ROM_SHAMD5TABLE[17])
2187 #endif
2188
2189 //*****************************************************************************
2190 //
2191 // Macros for calling ROM functions in the CRC API.
2192 //
2193 //*****************************************************************************
2194 #if defined(USE_CC3200_ROM_DRV_API) || \
2195     defined(USE_CC3220_ROM_DRV_API)
2196 #define ROM_CRCConfigSet                                                      \
2197         ((void (*)(uint32_t ui32Base,                                         \
2198                    uint32_t ui32CRCConfig))ROM_CRCTABLE[0])
2199 #endif
2200 #if defined(USE_CC3200_ROM_DRV_API) || \
2201     defined(USE_CC3220_ROM_DRV_API)
2202 #define ROM_CRCDataProcess                                                    \
2203         ((uint32_t (*)(uint32_t ui32Base,                                     \
2204                        void *puiDataIn,                                       \
2205                        uint32_t ui32DataLength,                               \
2206                        uint32_t ui32Config))ROM_CRCTABLE[1])
2207 #endif
2208 #if defined(USE_CC3200_ROM_DRV_API) || \
2209     defined(USE_CC3220_ROM_DRV_API)
2210 #define ROM_CRCDataWrite                                                      \
2211         ((void (*)(uint32_t ui32Base,                                         \
2212                    uint32_t ui32Data))ROM_CRCTABLE[2])
2213 #endif
2214 #if defined(USE_CC3200_ROM_DRV_API) || \
2215     defined(USE_CC3220_ROM_DRV_API)
2216 #define ROM_CRCResultRead                                                     \
2217         ((uint32_t (*)(uint32_t ui32Base))ROM_CRCTABLE[3])
2218 #endif
2219 #if defined(USE_CC3200_ROM_DRV_API) || \
2220     defined(USE_CC3220_ROM_DRV_API)
2221 #define ROM_CRCSeedSet                                                        \
2222         ((void (*)(uint32_t ui32Base,                                         \
2223                    uint32_t ui32Seed))ROM_CRCTABLE[4])
2224 #endif
2225
2226 //*****************************************************************************
2227 //
2228 // Macros for calling ROM functions in the SDHOST API.
2229 //
2230 //*****************************************************************************
2231 #if defined(USE_CC3200_ROM_DRV_API) || \
2232     defined(USE_CC3220_ROM_DRV_API)
2233 #define ROM_SDHostCmdReset                                                    \
2234         ((void (*)(unsigned long ulBase))ROM_SDHOSTTABLE[0])
2235 #endif
2236 #if defined(USE_CC3200_ROM_DRV_API) || \
2237     defined(USE_CC3220_ROM_DRV_API)
2238 #define ROM_SDHostInit                                                        \
2239         ((void (*)(unsigned long ulBase))ROM_SDHOSTTABLE[1])
2240 #endif
2241 #if defined(USE_CC3200_ROM_DRV_API) || \
2242     defined(USE_CC3220_ROM_DRV_API)
2243 #define ROM_SDHostCmdSend                                                     \
2244         ((long (*)(unsigned long ulBase,                                      \
2245                   unsigned long ulCmd,                                        \
2246                    unsigned ulArg))ROM_SDHOSTTABLE[2])
2247 #endif
2248 #if defined(USE_CC3200_ROM_DRV_API) || \
2249     defined(USE_CC3220_ROM_DRV_API)
2250 #define ROM_SDHostIntRegister                                                 \
2251         ((void (*)(unsigned long ulBase,                                      \
2252                    void (*pfnHandler)(void)))ROM_SDHOSTTABLE[3])
2253 #endif
2254 #if defined(USE_CC3200_ROM_DRV_API) || \
2255     defined(USE_CC3220_ROM_DRV_API)
2256 #define ROM_SDHostIntUnregister                                               \
2257         ((void (*)(unsigned long ulBase))ROM_SDHOSTTABLE[4])
2258 #endif
2259 #if defined(USE_CC3200_ROM_DRV_API) || \
2260     defined(USE_CC3220_ROM_DRV_API)
2261 #define ROM_SDHostIntEnable                                                   \
2262         ((void (*)(unsigned long ulBase,                                      \
2263                   unsigned long ulIntFlags))ROM_SDHOSTTABLE[5])
2264 #endif
2265 #if defined(USE_CC3200_ROM_DRV_API) || \
2266     defined(USE_CC3220_ROM_DRV_API)
2267 #define ROM_SDHostIntDisable                                                  \
2268         ((void (*)(unsigned long ulBase,                                      \
2269                   unsigned long ulIntFlags))ROM_SDHOSTTABLE[6])
2270 #endif
2271 #if defined(USE_CC3200_ROM_DRV_API) || \
2272     defined(USE_CC3220_ROM_DRV_API)
2273 #define ROM_SDHostIntStatus                                                   \
2274         ((unsigned long (*)(unsigned long ulBase))ROM_SDHOSTTABLE[7])
2275 #endif
2276 #if defined(USE_CC3200_ROM_DRV_API) || \
2277     defined(USE_CC3220_ROM_DRV_API)
2278 #define ROM_SDHostIntClear                                                    \
2279         ((void (*)(unsigned long ulBase,                                      \
2280                   unsigned long ulIntFlags))ROM_SDHOSTTABLE[8])
2281 #endif
2282 #if defined(USE_CC3200_ROM_DRV_API) || \
2283     defined(USE_CC3220_ROM_DRV_API)
2284 #define ROM_SDHostRespGet                                                     \
2285         ((void (*)(unsigned long ulBase,                                      \
2286                    unsigned long ulRespnse[4]))ROM_SDHOSTTABLE[10])
2287 #endif
2288 #if defined(USE_CC3200_ROM_DRV_API) || \
2289     defined(USE_CC3220_ROM_DRV_API)
2290 #define ROM_SDHostBlockSizeSet                                                \
2291         ((void (*)(unsigned long ulBase,                                      \
2292                    unsigned short ulBlkSize))ROM_SDHOSTTABLE[11])
2293 #endif
2294 #if defined(USE_CC3200_ROM_DRV_API) || \
2295     defined(USE_CC3220_ROM_DRV_API)
2296 #define ROM_SDHostBlockCountSet                                               \
2297         ((void (*)(unsigned long ulBase,                                      \
2298                    unsigned short ulBlkCount))ROM_SDHOSTTABLE[12])
2299 #endif
2300 #if defined(USE_CC3200_ROM_DRV_API) || \
2301     defined(USE_CC3220_ROM_DRV_API)
2302 #define ROM_SDHostDataNonBlockingWrite                                        \
2303         ((tBoolean (*)(unsigned long ulBase,                                  \
2304                        unsigned long ulData))ROM_SDHOSTTABLE[13])
2305 #endif
2306 #if defined(USE_CC3200_ROM_DRV_API) || \
2307     defined(USE_CC3220_ROM_DRV_API)
2308 #define ROM_SDHostDataNonBlockingRead                                         \
2309         ((tBoolean (*)(unsigned long ulBase,                                  \
2310                        unsigned long *pulData))ROM_SDHOSTTABLE[14])
2311 #endif
2312 #if defined(USE_CC3200_ROM_DRV_API) || \
2313     defined(USE_CC3220_ROM_DRV_API)
2314 #define ROM_SDHostDataWrite                                                   \
2315         ((void (*)(unsigned long ulBase,                                      \
2316                    unsigned long ulData))ROM_SDHOSTTABLE[15])
2317 #endif
2318 #if defined(USE_CC3200_ROM_DRV_API) || \
2319     defined(USE_CC3220_ROM_DRV_API)
2320 #define ROM_SDHostDataRead                                                    \
2321         ((void (*)(unsigned long ulBase,                                      \
2322                    unsigned long *ulData))ROM_SDHOSTTABLE[16])
2323 #endif
2324 #if defined(USE_CC3200_ROM_DRV_API) || \
2325     defined(USE_CC3220_ROM_DRV_API)
2326 #define ROM_SDHostSetExpClk                                                   \
2327         ((void (*)(unsigned long ulBase,                                      \
2328                    unsigned long ulSDHostClk,                                 \
2329                    unsigned long ulCardClk))ROM_SDHOSTTABLE[17])
2330 #endif
2331 #if defined(USE_CC3220_ROM_DRV_API)
2332 #define ROM_SDHostCardErrorMaskSet                                            \
2333         ((void (*)(unsigned long ulBase,                                      \
2334                    unsigned long ulErrMask))ROM_SDHOSTTABLE[18])
2335 #endif
2336 #if defined(USE_CC3220_ROM_DRV_API)
2337 #define ROM_SDHostCardErrorMaskGet                                            \
2338         ((unsigned long (*)(unsigned long ulBase))ROM_SDHOSTTABLE[19])
2339 #endif
2340
2341 //*****************************************************************************
2342 //
2343 // Macros for calling ROM functions in the PRCM API.
2344 //
2345 //*****************************************************************************
2346 #if defined(USE_CC3200_ROM_DRV_API) || \
2347     defined(USE_CC3220_ROM_DRV_API)
2348 #define ROM_PRCMMCUReset                                                      \
2349         ((void (*)(tBoolean bIncludeSubsystem))ROM_PRCMTABLE[1])
2350 #endif
2351 #if defined(USE_CC3200_ROM_DRV_API) || \
2352     defined(USE_CC3220_ROM_DRV_API)
2353 #define ROM_PRCMSysResetCauseGet                                              \
2354         ((unsigned long (*)(void))ROM_PRCMTABLE[2])
2355 #endif
2356 #if defined(USE_CC3200_ROM_DRV_API) || \
2357     defined(USE_CC3220_ROM_DRV_API)
2358 #define ROM_PRCMPeripheralClkEnable                                           \
2359         ((void (*)(unsigned long ulPeripheral,                                \
2360                    unsigned long ulClkFlags))ROM_PRCMTABLE[3])
2361 #endif
2362 #if defined(USE_CC3200_ROM_DRV_API) || \
2363     defined(USE_CC3220_ROM_DRV_API)
2364 #define ROM_PRCMPeripheralClkDisable                                          \
2365         ((void (*)(unsigned long ulPeripheral,                                \
2366                    unsigned long ulClkFlags))ROM_PRCMTABLE[4])
2367 #endif
2368 #if defined(USE_CC3200_ROM_DRV_API) || \
2369     defined(USE_CC3220_ROM_DRV_API)
2370 #define ROM_PRCMPeripheralReset                                               \
2371         ((void (*)(unsigned long ulPeripheral))ROM_PRCMTABLE[5])
2372 #endif
2373 #if defined(USE_CC3200_ROM_DRV_API) || \
2374     defined(USE_CC3220_ROM_DRV_API)
2375 #define ROM_PRCMPeripheralStatusGet                                           \
2376         ((tBoolean (*)(unsigned long ulPeripheral))ROM_PRCMTABLE[6])
2377 #endif
2378 #if defined(USE_CC3200_ROM_DRV_API) || \
2379     defined(USE_CC3220_ROM_DRV_API)
2380 #define ROM_PRCMI2SClockFreqSet                                               \
2381         ((void (*)(unsigned long ulI2CClkFreq))ROM_PRCMTABLE[7])
2382 #endif
2383 #if defined(USE_CC3200_ROM_DRV_API) || \
2384     defined(USE_CC3220_ROM_DRV_API)
2385 #define ROM_PRCMPeripheralClockGet                                            \
2386         ((unsigned long (*)(unsigned long ulPeripheral))ROM_PRCMTABLE[8])
2387 #endif
2388 #if defined(USE_CC3200_ROM_DRV_API) || \
2389     defined(USE_CC3220_ROM_DRV_API)
2390 #define ROM_PRCMSleepEnter                                                    \
2391         ((void (*)(void))ROM_PRCMTABLE[9])
2392 #endif
2393 #if defined(USE_CC3200_ROM_DRV_API) || \
2394     defined(USE_CC3220_ROM_DRV_API)
2395 #define ROM_PRCMSRAMRetentionEnable                                           \
2396         ((void (*)(unsigned long ulSramColSel,                                \
2397                    unsigned long ulFlags))ROM_PRCMTABLE[11])
2398 #endif
2399 #if defined(USE_CC3200_ROM_DRV_API) || \
2400     defined(USE_CC3220_ROM_DRV_API)
2401 #define ROM_PRCMSRAMRetentionDisable                                          \
2402         ((void (*)(unsigned long ulSramColSel,                                \
2403                    unsigned long ulFlags))ROM_PRCMTABLE[12])
2404 #endif
2405 #if defined(USE_CC3200_ROM_DRV_API) || \
2406     defined(USE_CC3220_ROM_DRV_API)
2407 #define ROM_PRCMLPDSEnter                                                     \
2408         ((void (*)(void))ROM_PRCMTABLE[13])
2409 #endif
2410 #if defined(USE_CC3200_ROM_DRV_API) || \
2411     defined(USE_CC3220_ROM_DRV_API)
2412 #define ROM_PRCMLPDSIntervalSet                                               \
2413         ((void (*)(unsigned long ulTicks))ROM_PRCMTABLE[14])
2414 #endif
2415 #if defined(USE_CC3200_ROM_DRV_API) || \
2416     defined(USE_CC3220_ROM_DRV_API)
2417 #define ROM_PRCMLPDSWakeupSourceEnable                                        \
2418         ((void (*)(unsigned long ulLpdsWakeupSrc))ROM_PRCMTABLE[15])
2419 #endif
2420 #if defined(USE_CC3200_ROM_DRV_API) || \
2421     defined(USE_CC3220_ROM_DRV_API)
2422 #define ROM_PRCMLPDSWakeupCauseGet                                            \
2423         ((unsigned long (*)(void))ROM_PRCMTABLE[16])
2424 #endif
2425 #if defined(USE_CC3200_ROM_DRV_API) || \
2426     defined(USE_CC3220_ROM_DRV_API)
2427 #define ROM_PRCMLPDSWakeUpGPIOSelect                                          \
2428         ((void (*)(unsigned long ulGPIOPin,                                   \
2429                    unsigned long ulType))ROM_PRCMTABLE[17])
2430 #endif
2431 #if defined(USE_CC3200_ROM_DRV_API) || \
2432     defined(USE_CC3220_ROM_DRV_API)
2433 #define ROM_PRCMLPDSWakeupSourceDisable                                       \
2434         ((void (*)(unsigned long ulLpdsWakeupSrc))ROM_PRCMTABLE[18])
2435 #endif
2436 #if defined(USE_CC3200_ROM_DRV_API) || \
2437     defined(USE_CC3220_ROM_DRV_API)
2438 #define ROM_PRCMHibernateEnter                                                \
2439         ((void (*)(void))ROM_PRCMTABLE[19])
2440 #endif
2441 #if defined(USE_CC3200_ROM_DRV_API) || \
2442     defined(USE_CC3220_ROM_DRV_API)
2443 #define ROM_PRCMHibernateWakeupSourceEnable                                   \
2444         ((void (*)(unsigned long ulHIBWakupSrc))ROM_PRCMTABLE[20])
2445 #endif
2446 #if defined(USE_CC3200_ROM_DRV_API) || \
2447     defined(USE_CC3220_ROM_DRV_API)
2448 #define ROM_PRCMHibernateWakeupCauseGet                                       \
2449         ((unsigned long (*)(void))ROM_PRCMTABLE[21])
2450 #endif
2451 #if defined(USE_CC3200_ROM_DRV_API) || \
2452     defined(USE_CC3220_ROM_DRV_API)
2453 #define ROM_PRCMHibernateWakeUpGPIOSelect                                     \
2454         ((void (*)(unsigned long ulMultiGPIOBitMap,                           \
2455                    unsigned long ulType))ROM_PRCMTABLE[22])
2456 #endif
2457 #if defined(USE_CC3200_ROM_DRV_API) || \
2458     defined(USE_CC3220_ROM_DRV_API)
2459 #define ROM_PRCMHibernateWakeupSourceDisable                                  \
2460         ((void (*)(unsigned long ulHIBWakupSrc))ROM_PRCMTABLE[23])
2461 #endif
2462 #if defined(USE_CC3200_ROM_DRV_API) || \
2463     defined(USE_CC3220_ROM_DRV_API)
2464 #define ROM_PRCMHibernateIntervalSet                                          \
2465         ((void (*)(unsigned long long ullTicks))ROM_PRCMTABLE[24])
2466 #endif
2467 #if defined(USE_CC3200_ROM_DRV_API) || \
2468     defined(USE_CC3220_ROM_DRV_API)
2469 #define ROM_PRCMSlowClkCtrGet                                                 \
2470         ((unsigned long long (*)(void))ROM_PRCMTABLE[25])
2471 #endif
2472 #if defined(USE_CC3200_ROM_DRV_API) || \
2473     defined(USE_CC3220_ROM_DRV_API)
2474 #define ROM_PRCMSlowClkCtrMatchSet                                            \
2475         ((void (*)(unsigned long long ullTicks))ROM_PRCMTABLE[26])
2476 #endif
2477 #if defined(USE_CC3200_ROM_DRV_API) || \
2478     defined(USE_CC3220_ROM_DRV_API)
2479 #define ROM_PRCMSlowClkCtrMatchGet                                            \
2480         ((unsigned long long (*)(void))ROM_PRCMTABLE[27])
2481 #endif
2482 #if defined(USE_CC3200_ROM_DRV_API) || \
2483     defined(USE_CC3220_ROM_DRV_API)
2484 #define ROM_PRCMOCRRegisterWrite                                              \
2485         ((void (*)(unsigned char ucIndex,                                     \
2486                    unsigned long ulRegValue))ROM_PRCMTABLE[28])
2487 #endif
2488 #if defined(USE_CC3200_ROM_DRV_API) || \
2489     defined(USE_CC3220_ROM_DRV_API)
2490 #define ROM_PRCMOCRRegisterRead                                               \
2491         ((unsigned long (*)(unsigned char ucIndex))ROM_PRCMTABLE[29])
2492 #endif
2493 #if defined(USE_CC3200_ROM_DRV_API) || \
2494     defined(USE_CC3220_ROM_DRV_API)
2495 #define ROM_PRCMIntRegister                                                   \
2496         ((void (*)(void (*pfnHandler)(void)))ROM_PRCMTABLE[30])
2497 #endif
2498 #if defined(USE_CC3200_ROM_DRV_API) || \
2499     defined(USE_CC3220_ROM_DRV_API)
2500 #define ROM_PRCMIntUnregister                                                 \
2501         ((void (*)(void))ROM_PRCMTABLE[31])
2502 #endif
2503 #if defined(USE_CC3200_ROM_DRV_API) || \
2504     defined(USE_CC3220_ROM_DRV_API)
2505 #define ROM_PRCMIntEnable                                                     \
2506         ((void (*)(unsigned long ulIntFlags))ROM_PRCMTABLE[32])
2507 #endif
2508 #if defined(USE_CC3200_ROM_DRV_API) || \
2509     defined(USE_CC3220_ROM_DRV_API)
2510 #define ROM_PRCMIntDisable                                                    \
2511         ((void (*)(unsigned long ulIntFlags))ROM_PRCMTABLE[33])
2512 #endif
2513 #if defined(USE_CC3200_ROM_DRV_API) || \
2514     defined(USE_CC3220_ROM_DRV_API)
2515 #define ROM_PRCMIntStatus                                                     \
2516         ((unsigned long (*)(void))ROM_PRCMTABLE[34])
2517 #endif
2518 #if defined(USE_CC3200_ROM_DRV_API) || \
2519     defined(USE_CC3220_ROM_DRV_API)
2520 #define ROM_PRCMRTCInUseSet                                                   \
2521         ((void (*)(void))ROM_PRCMTABLE[35])
2522 #endif
2523 #if defined(USE_CC3200_ROM_DRV_API) || \
2524     defined(USE_CC3220_ROM_DRV_API)
2525 #define ROM_PRCMRTCInUseGet                                                   \
2526         ((tBoolean (*)(void))ROM_PRCMTABLE[36])
2527 #endif
2528 #if defined(USE_CC3200_ROM_DRV_API) || \
2529     defined(USE_CC3220_ROM_DRV_API)
2530 #define ROM_PRCMRTCSet                                                        \
2531         ((void (*)(unsigned long ulSecs,                                      \
2532                    unsigned short usMsec))ROM_PRCMTABLE[37])
2533 #endif
2534 #if defined(USE_CC3200_ROM_DRV_API) || \
2535     defined(USE_CC3220_ROM_DRV_API)
2536 #define ROM_PRCMRTCGet                                                        \
2537         ((void (*)(unsigned long *ulSecs,                                     \
2538                    unsigned short *usMsec))ROM_PRCMTABLE[38])
2539 #endif
2540 #if defined(USE_CC3200_ROM_DRV_API) || \
2541     defined(USE_CC3220_ROM_DRV_API)
2542 #define ROM_PRCMRTCMatchSet                                                   \
2543         ((void (*)(unsigned long ulSecs,                                      \
2544                    unsigned short usMsec))ROM_PRCMTABLE[39])
2545 #endif
2546 #if defined(USE_CC3200_ROM_DRV_API) || \
2547     defined(USE_CC3220_ROM_DRV_API)
2548 #define ROM_PRCMRTCMatchGet                                                   \
2549         ((void (*)(unsigned long *ulSecs,                                     \
2550                    unsigned short *usMsec))ROM_PRCMTABLE[40])
2551 #endif
2552 #if defined(USE_CC3200_ROM_DRV_API) || \
2553     defined(USE_CC3220_ROM_DRV_API)
2554 #define ROM_PRCMLPDSRestoreInfoSet                                            \
2555         ((void (*)(unsigned long ulRestoreSP,                                 \
2556                    unsigned long ulRestorePC))ROM_PRCMTABLE[41])
2557 #endif
2558 #if defined(USE_CC3220_ROM_DRV_API)
2559 #define ROM_PRCMSlowClkCtrFastGet                                             \
2560         ((unsigned long long (*)(void))ROM_PRCMTABLE[42])
2561 #endif
2562 #if defined(USE_CC3220_ROM_DRV_API)
2563 #define ROM_PRCMCC3200MCUInit                                                 \
2564         ((void (*)(void))ROM_PRCMTABLE[43])
2565 #endif
2566 #if defined(USE_CC3220_ROM_DRV_API)
2567 #define ROM_PRCMHIBRegRead                                                    \
2568         ((unsigned long (*)(unsigned long ulRegAddr))ROM_PRCMTABLE[44])
2569 #endif
2570 #if defined(USE_CC3220_ROM_DRV_API)
2571 #define ROM_PRCMHIBRegWrite                                                   \
2572         ((void (*)(unsigned long ulRegAddr,                                   \
2573                    unsigned long ulValue))ROM_PRCMTABLE[45])
2574 #endif
2575 #if defined(USE_CC3220_ROM_DRV_API)
2576 #define ROM_PRCMCameraFreqSet                                                 \
2577         ((unsigned long (*)(unsigned char ulDivider,                          \
2578                             unsigned char ulWidth))ROM_PRCMTABLE[46])
2579 #endif
2580 #if defined(USE_CC3220_ROM_DRV_API)
2581 #define ROM_PRCMIORetentionEnable                                             \
2582         ((void (*)(unsigned long ulIORetGrpFlags))ROM_PRCMTABLE[47])
2583 #endif
2584 #if defined(USE_CC3220_ROM_DRV_API)
2585 #define ROM_PRCMIORetentionDisable                                            \
2586         ((void (*)(unsigned long ulIORetGrpFlags))ROM_PRCMTABLE[48])
2587 #endif
2588 #if defined(USE_CC3220_ROM_DRV_API)
2589 #define ROM_PRCMDeviceTypeGet                                                 \
2590         ((unsigned long (*)(void))ROM_PRCMTABLE[49])
2591 #endif
2592 #if defined(USE_CC3220_ROM_DRV_API)
2593 #define ROM_PRCMLPDSEnterKeepDebugIf                                          \
2594         ((void (*)(void))ROM_PRCMTABLE[50])
2595 #endif
2596 #if defined(USE_CC3220_ROM_DRV_API)
2597 #define ROM_PRCMHibernateCycleTrigger                                         \
2598         ((void (*)(void))ROM_PRCMTABLE[51])
2599 #endif
2600
2601 //*****************************************************************************
2602 //
2603 // Macros for calling ROM functions in the HWSPINLOCK API.
2604 //
2605 //*****************************************************************************
2606 #if defined(USE_CC3200_ROM_DRV_API) || \
2607     defined(USE_CC3220_ROM_DRV_API)
2608 #define ROM_HwSpinLockAcquire                                                 \
2609         ((void (*)(uint32_t ui32LockID))ROM_HWSPINLOCKTABLE[0])
2610 #endif
2611 #if defined(USE_CC3200_ROM_DRV_API) || \
2612     defined(USE_CC3220_ROM_DRV_API)
2613 #define ROM_HwSpinLockTryAcquire                                              \
2614         ((int32_t (*)(uint32_t ui32LockID,                                    \
2615                       uint32_t ui32Retry))ROM_HWSPINLOCKTABLE[1])
2616 #endif
2617 #if defined(USE_CC3200_ROM_DRV_API) || \
2618     defined(USE_CC3220_ROM_DRV_API)
2619 #define ROM_HwSpinLockRelease                                                 \
2620         ((void (*)(uint32_t ui32LockID))ROM_HWSPINLOCKTABLE[2])
2621 #endif
2622 #if defined(USE_CC3200_ROM_DRV_API) || \
2623     defined(USE_CC3220_ROM_DRV_API)
2624 #define ROM_HwSpinLockTest                                                    \
2625         ((uint32_t (*)(uint32_t ui32LockID,                                   \
2626                        bool bCurrentStatus))ROM_HWSPINLOCKTABLE[3])
2627 #endif
2628
2629 //*****************************************************************************
2630 //
2631 // Macros for calling ROM functions in the ADC API.
2632 //
2633 //*****************************************************************************
2634 #if defined(USE_CC3200_ROM_DRV_API) || \
2635     defined(USE_CC3220_ROM_DRV_API)
2636 #define ROM_ADCEnable                                                         \
2637         ((void (*)(unsigned long ulBase))ROM_ADCTABLE[0])
2638 #endif
2639 #if defined(USE_CC3200_ROM_DRV_API) || \
2640     defined(USE_CC3220_ROM_DRV_API)
2641 #define ROM_ADCDisable                                                        \
2642         ((void (*)(unsigned long ulBase))ROM_ADCTABLE[1])
2643 #endif
2644 #if defined(USE_CC3200_ROM_DRV_API) || \
2645     defined(USE_CC3220_ROM_DRV_API)
2646 #define ROM_ADCChannelEnable                                                  \
2647         ((void (*)(unsigned long ulBase,                                      \
2648                   unsigned long ulChannel))ROM_ADCTABLE[2])
2649 #endif
2650 #if defined(USE_CC3200_ROM_DRV_API) || \
2651     defined(USE_CC3220_ROM_DRV_API)
2652 #define ROM_ADCChannelDisable                                                 \
2653         ((void (*)(unsigned long ulBase,                                      \
2654                   unsigned long ulChannel))ROM_ADCTABLE[3])
2655 #endif
2656 #if defined(USE_CC3200_ROM_DRV_API) || \
2657     defined(USE_CC3220_ROM_DRV_API)
2658 #define ROM_ADCIntRegister                                                    \
2659         ((void (*)(unsigned long ulBase,                                      \
2660                    unsigned long ulChannel,                                   \
2661                    void (*pfnHandler)(void)))ROM_ADCTABLE[4])
2662 #endif
2663 #if defined(USE_CC3200_ROM_DRV_API) || \
2664     defined(USE_CC3220_ROM_DRV_API)
2665 #define ROM_ADCIntUnregister                                                  \
2666         ((void (*)(unsigned long ulBase,                                      \
2667                    unsigned long ulChannel))ROM_ADCTABLE[5])
2668 #endif
2669 #if defined(USE_CC3200_ROM_DRV_API) || \
2670     defined(USE_CC3220_ROM_DRV_API)
2671 #define ROM_ADCIntEnable                                                      \
2672         ((void (*)(unsigned long ulBase,                                      \
2673                    unsigned long ulChannel,                                   \
2674                    unsigned long ulIntFlags))ROM_ADCTABLE[6])
2675 #endif
2676 #if defined(USE_CC3200_ROM_DRV_API) || \
2677     defined(USE_CC3220_ROM_DRV_API)
2678 #define ROM_ADCIntDisable                                                     \
2679         ((void (*)(unsigned long ulBase,                                      \
2680                    unsigned long ulChannel,                                   \
2681                    unsigned long ulIntFlags))ROM_ADCTABLE[7])
2682 #endif
2683 #if defined(USE_CC3200_ROM_DRV_API) || \
2684     defined(USE_CC3220_ROM_DRV_API)
2685 #define ROM_ADCIntStatus                                                      \
2686         ((unsigned long (*)(unsigned long ulBase,                             \
2687                            unsigned long ulChannel))ROM_ADCTABLE[8])
2688 #endif
2689 #if defined(USE_CC3200_ROM_DRV_API) || \
2690     defined(USE_CC3220_ROM_DRV_API)
2691 #define ROM_ADCIntClear                                                       \
2692         ((void (*)(unsigned long ulBase,                                      \
2693                    unsigned long ulChannel,                                   \
2694                    unsigned long ulIntFlags))ROM_ADCTABLE[9])
2695 #endif
2696 #if defined(USE_CC3200_ROM_DRV_API) || \
2697     defined(USE_CC3220_ROM_DRV_API)
2698 #define ROM_ADCDMAEnable                                                      \
2699         ((void (*)(unsigned long ulBase,                                      \
2700                    unsigned long ulChannel))ROM_ADCTABLE[10])
2701 #endif
2702 #if defined(USE_CC3200_ROM_DRV_API) || \
2703     defined(USE_CC3220_ROM_DRV_API)
2704 #define ROM_ADCDMADisable                                                     \
2705         ((void (*)(unsigned long ulBase,                                      \
2706                    unsigned long ulChannel))ROM_ADCTABLE[11])
2707 #endif
2708 #if defined(USE_CC3200_ROM_DRV_API) || \
2709     defined(USE_CC3220_ROM_DRV_API)
2710 #define ROM_ADCTimerConfig                                                    \
2711         ((void (*)(unsigned long ulBase,                                      \
2712                    unsigned long ulValue))ROM_ADCTABLE[14])
2713 #endif
2714 #if defined(USE_CC3200_ROM_DRV_API) || \
2715     defined(USE_CC3220_ROM_DRV_API)
2716 #define ROM_ADCTimerEnable                                                    \
2717         ((void (*)(unsigned long ulBase))ROM_ADCTABLE[15])
2718 #endif
2719 #if defined(USE_CC3200_ROM_DRV_API) || \
2720     defined(USE_CC3220_ROM_DRV_API)
2721 #define ROM_ADCTimerDisable                                                   \
2722         ((void (*)(unsigned long ulBase))ROM_ADCTABLE[16])
2723 #endif
2724 #if defined(USE_CC3200_ROM_DRV_API) || \
2725     defined(USE_CC3220_ROM_DRV_API)
2726 #define ROM_ADCTimerReset                                                     \
2727         ((void (*)(unsigned long ulBase))ROM_ADCTABLE[17])
2728 #endif
2729 #if defined(USE_CC3200_ROM_DRV_API) || \
2730     defined(USE_CC3220_ROM_DRV_API)
2731 #define ROM_ADCTimerValueGet                                                  \
2732         ((unsigned long (*)(unsigned long ulBase))ROM_ADCTABLE[18])
2733 #endif
2734 #if defined(USE_CC3200_ROM_DRV_API) || \
2735     defined(USE_CC3220_ROM_DRV_API)
2736 #define ROM_ADCFIFOLvlGet                                                     \
2737         ((unsigned char (*)(unsigned long ulBase,                             \
2738                             unsigned long ulChannel))ROM_ADCTABLE[19])
2739 #endif
2740 #if defined(USE_CC3200_ROM_DRV_API) || \
2741     defined(USE_CC3220_ROM_DRV_API)
2742 #define ROM_ADCFIFORead                                                       \
2743         ((unsigned long (*)(unsigned long ulBase,                             \
2744                             unsigned long ulChannel))ROM_ADCTABLE[20])
2745 #endif
2746
2747 //*****************************************************************************
2748 //
2749 // Macros for calling ROM functions in the CPU API.
2750 //
2751 //*****************************************************************************
2752 #if defined(USE_CC3200_ROM_DRV_API) || \
2753     defined(USE_CC3220_ROM_DRV_API)
2754 #define ROM_CPUcpsid                                                          \
2755         ((unsigned long (*)(void))ROM_CPUTABLE[0])
2756 #endif
2757 #if defined(USE_CC3200_ROM_DRV_API) || \
2758     defined(USE_CC3220_ROM_DRV_API)
2759 #define ROM_CPUcpsie                                                          \
2760         ((unsigned long (*)(void))ROM_CPUTABLE[1])
2761 #endif
2762 #if defined(USE_CC3200_ROM_DRV_API) || \
2763     defined(USE_CC3220_ROM_DRV_API)
2764 #define ROM_CPUprimask                                                        \
2765         ((unsigned long (*)(void))ROM_CPUTABLE[2])
2766 #endif
2767 #if defined(USE_CC3200_ROM_DRV_API) || \
2768     defined(USE_CC3220_ROM_DRV_API)
2769 #define ROM_CPUwfi                                                            \
2770         ((void (*)(void))ROM_CPUTABLE[3])
2771 #endif
2772 #if defined(USE_CC3200_ROM_DRV_API) || \
2773     defined(USE_CC3220_ROM_DRV_API)
2774 #define ROM_CPUbasepriGet                                                     \
2775         ((unsigned long (*)(void))ROM_CPUTABLE[4])
2776 #endif
2777 #if defined(USE_CC3200_ROM_DRV_API) || \
2778     defined(USE_CC3220_ROM_DRV_API)
2779 #define ROM_CPUbasepriSet                                                     \
2780         ((void (*)(unsigned long ulNewBasepri))ROM_CPUTABLE[5])
2781 #endif
2782
2783 //*****************************************************************************
2784 //
2785 // Macros for calling ROM functions Directly.
2786 //
2787 //*****************************************************************************
2788 #define ROM_UtilsDelayDirect                                                  \
2789         ((void (*)(unsigned long ulCount))ROM_UTILSTABLE[0])
2790
2791 #define ROM_PRCMLPDSEnterDirect                                               \
2792         ((void (*)(void))ROM_PRCMTABLE[13])
2793
2794 #define ROM_PRCMLPDSEnterKeepDebugIfDirect                                    \
2795         ((void (*)(void))ROM_PRCMTABLE[50])
2796
2797 #endif // __ROM_H__