pasdk/common/evmc66x_gpio_dbg.c

   1 /*
   2  * Copyright (c) 2010-2017, Texas Instruments Incorporated
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * *  Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  * *  Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * *  Neither the name of Texas Instruments Incorporated nor the names of
  17  *    its contributors may be used to endorse or promote products derived
  18  *    from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  27  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  28  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  29  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  30  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  */
  33
  34 /**
  35  *
  36  * \file   evmc66x_gpio.c
  37  *
  38  * \brief  This file contains the lower level functions to access GPIO
  39  *
  40  *****************************************************************************/
  41
  42 /************************
  43  * Include Files
  44  ************************/
  45
  46 #include "evmc66x_gpio_dbg.h"
  47 //#include "platform_internal.h"
  48
  49 //#if (PLATFORM_GPIO_IN)
  50
  51 /**
  52  * \brief  This function performs different control operations on GPIO
  53  *
  54  * \param   gpioPortNumber [IN]     GPIO port number
  55  * \param   pinNum         [IN]     GPIO pin number
  56  * \param   ctrlCmd        [IN]     Command to indicate action to perform
  57  * \n                               Use below macros as input for 'ctrlCmd'
  58  * \n        GPIO_CTRL_SET_DIR       - Command to set GPIO pin direction
  59  * \n        GPIO_CTRL_SET_OUTPUT    - Command to set GPIO pin output
  60  * \n        GPIO_CTRL_CLEAR_OUTPUT  - Command to clear GPIO pin output
  61  * \n        GPIO_CTRL_READ_INPUT    - Command to read GPIO pin input
  62  * \n        GPIO_CTRL_SET_RE_INTR   - Command to set rising edge interrupt
  63  * \n        GPIO_CTRL_CLEAR_RE_INTR - Command to clear rising edge interrupt
  64  * \n        GPIO_CTRL_SET_FE_INTR   - Command to set falling edge interrupt
  65  * \n        GPIO_CTRL_CLEAR_FE_INTR - Command to clear falling edge interrupt
  66  *
  67  * \param   ctrlData       [IN/OUT] Data to be manipulated by the command
  68  *
  69  * \return
  70  * \n      GPIO_RET_OK          - Requested operation is successful
  71  * \n      INVALID_GPIO_PORT    - Invalid GPIO port number
  72  * \n      INVALID_GPIO_NUMBER  - Invalid GPIO pin number
  73  *
  74  */
  75 static GPIO_RET GPIO_ctrl(uint8_t gpioPortNumber, uint8_t pinNum,
  76                           uint8_t ctrlCmd, void *ctrlData)
  77 {
  78         GPIO_RET       retVal;
  79     uint8_t        bankIndex;
  80     uint8_t        bitPos;
  81     CSL_GpioHandle hGpio;
  82     GpioDirection  direction;
  83
  84     retVal = GPIO_RET_OK;
  85
  86     if(pinNum < GPIO_MAX_NUMBER)
  87     {
  88                 hGpio = GPIOGetRegBaseAddr(gpioPortNumber);
  89                 if(hGpio != NULL)
  90                 {
  91                         bankIndex = pinNum / GPIO_PINS_PER_BANK;
  92                         bitPos    = pinNum % GPIO_PINS_PER_BANK;
  93
  94                         switch(ctrlCmd)
  95                         {
  96                                 /* Command to set GPIO pin direction */
  97                 case GPIO_CTRL_SET_DIR:
  98                          direction = *((GpioDirection*)ctrlData);
  99                                          if     (direction == GPIO_IN)
 100                                          {
 101                                                 hGpio->BANK_REGISTERS[bankIndex].DIR |= 1 << bitPos;
 102                                          }
 103                                          else
 104                                          {
 105                                                 hGpio->BANK_REGISTERS[bankIndex].DIR &= ~(1 << bitPos);
 106                                          }
 107                          break;
 108
 109                                 /* Command to set GPIO pin output */
 110                 case GPIO_CTRL_SET_OUTPUT:
 111                          hGpio->BANK_REGISTERS[bankIndex].SET_DATA = 1 << bitPos;
 112                          break;
 113
 114                                 /* Command to clear GPIO pin output */
 115                 case GPIO_CTRL_CLEAR_OUTPUT:
 116                          hGpio->BANK_REGISTERS[bankIndex].CLR_DATA = 1 << bitPos;
 117                          break;
 118
 119                                 /* Command to read GPIO pin input */
 120                 case GPIO_CTRL_READ_INPUT:
 121                          *(uint8_t*)ctrlData =
 122                                CSL_FEXTR (hGpio->BANK_REGISTERS[bankIndex].IN_DATA,
 123                                           bitPos, bitPos);
 124                          break;
 125
 126                                 /* Command to set rising edge interrupt */
 127                 case GPIO_CTRL_SET_RE_INTR:
 128                          CSL_FINSR (hGpio->BANK_REGISTERS[bankIndex].SET_RIS_TRIG,
 129                                     bitPos, bitPos, 1);
 130                          break;
 131
 132                                 /* Command to clear rising edge interrupt */
 133                 case GPIO_CTRL_CLEAR_RE_INTR:
 134                          hGpio->BANK_REGISTERS[bankIndex].CLR_RIS_TRIG |= 1 << pinNum;
 135                          break;
 136
 137                                 /* Command to set falling edge interrupt */
 138                 case GPIO_CTRL_SET_FE_INTR:
 139                          CSL_FINSR (hGpio->BANK_REGISTERS[bankIndex].SET_FAL_TRIG,
 140                                     bitPos, bitPos, 1);
 141                          break;
 142
 143                                 /* Command to clear falling edge interrupt */
 144                 case GPIO_CTRL_CLEAR_FE_INTR:
 145                          hGpio->BANK_REGISTERS[bankIndex].CLR_FAL_TRIG |=  1 << pinNum;
 146                          break;
 147
 148                 default:
 149                          retVal = GPIO_RET_FAIL;
 150                          break;
 151                         }
 152                 }
 153                 else
 154                 {
 155                         retVal = INVALID_GPIO_PORT;
 156                 }
 157         }
 158         else
 159         {
 160                 retVal = INVALID_GPIO_NUMBER;
 161         }
 162
 163         return (retVal);
 164
 165 } //gpio_ctrl
 166
 167 /**
 168  * \brief  Returns base address of given GPIO port number.
 169  *
 170  * \param   gpioPortNumber [IN]    GPIO port number
 171  *
 172  * \return CSL_GpioHandle\n
 173  *
 174  */
 175 CSL_GpioHandle GPIOGetRegBaseAddr(uint8_t gpioPortNumber)
 176 {
 177         CSL_GpioHandle addr;
 178
 179         switch(gpioPortNumber)
 180         {
 181                 case GPIO_PORT_0:
 182                         addr = (CSL_GpioHandle)CSL_GPIO_0_REGS;
 183                         break;
 184
 185                 case GPIO_PORT_1:
 186                         addr = (CSL_GpioHandle)CSL_GPIO_1_REGS;
 187                         break;
 188
 189                 default :
 190                         addr = NULL;
 191                         break;
 192         }
 193
 194         return (addr);
 195
 196 }  //gpioGetRegBaseAddr
 197
 198 /**
 199  * \brief  Initializes the GPIO peripheral
 200  *
 201  * \param   gpioPortNumber [IN]    GPIO port number
 202  *
 203  * \return
 204  * \n      GPIO_RET_OK          - Requested operation is successful
 205  * \n      INVALID_GPIO_PORT    - Invalid GPIO port number
 206  *
 207  */
 208 GPIO_RET GPIOInit(uint8_t gpioPortNumber)
 209 {
 210         GPIO_RET    retVal;
 211     uint8_t     bankNum;
 212     uint8_t     pinNum;
 213
 214         retVal = GPIO_RET_OK;
 215
 216     if (gpioPortNumber <= GPIO_PORT_1)
 217     {
 218                 /* Disable the GPIO global interrupts */
 219                 /*for (bankNum = 0; bankNum < GPIO_MAX_BANKS; bankNum++)
 220                 {
 221                         gpioDisableGlobalInterrupt(gpioPortNumber, bankNum);
 222                 }*/
 223
 224             /* Clear all falling edge trigger and rising edge trigger */
 225            /* for (pinNum = 0; pinNum < GPIO_MAX_NUMBER; pinNum++)
 226             {
 227             gpioClearFallingEdgeInterrupt(gpioPortNumber, pinNum);
 228             gpioClearRisingEdgeInterrupt(gpioPortNumber, pinNum);
 229         }*/
 230         }
 231         else
 232         {
 233                 retVal = INVALID_GPIO_PORT;
 234         }
 235
 236         return (retVal);
 237
 238 } //gpioInit
 239
 240 /**
 241  * \brief  This function configures the specified GPIO's direction
 242  *
 243  * \param   gpioPortNumber [IN]    GPIO port number
 244  * \param   pinNum         [IN]    GPIO pin number
 245  * \param   direction      [IN]    GPIO pin direction
 246  *
 247  * \return
 248  * \n      GPIO_RET_OK          - Requested operation is successful
 249  * \n      INVALID_GPIO_PORT    - Invalid GPIO port number
 250  * \n      INVALID_GPIO_NUMBER  - Invalid GPIO pin number
 251  *
 252  */
 253 GPIO_RET GPIOSetDirection(uint8_t gpioPortNumber, uint8_t pinNum,
 254                           GpioDirection direction)
 255 {
 256         GPIO_RET    retVal;
 257
 258     retVal = GPIO_ctrl(gpioPortNumber, pinNum, GPIO_CTRL_SET_DIR, &direction);
 259
 260         return (retVal);
 261
 262 } //gpioSetDirection
 263
 264 /**
 265  * \brief  This function sets the specified GPIO's pin state to 1
 266  *
 267  * \param   gpioPortNumber [IN]    GPIO port number
 268  * \param   pinNum         [IN]    GPIO pin number
 269  *
 270  * \return
 271  * \n      GPIO_RET_OK          - Requested operation is successful
 272  * \n      INVALID_GPIO_PORT    - Invalid GPIO port number
 273  * \n      INVALID_GPIO_NUMBER  - Invalid GPIO pin number
 274  *
 275  */
 276 GPIO_RET GPIOSetOutput(uint8_t gpioPortNumber, uint8_t pinNum)
 277 {
 278         GPIO_RET retVal;
 279
 280     retVal = GPIO_ctrl(gpioPortNumber, pinNum, GPIO_CTRL_SET_OUTPUT, NULL);
 281
 282         return (retVal);
 283
 284 } //gpioSetOutput
 285
 286 /**
 287  * \brief  This function Clears the specified GPIO's pin state to 0
 288  *
 289  * \param   gpioPortNumber [IN]    GPIO port number
 290  * \param   pinNum         [IN]    GPIO pin number
 291  *
 292  * \return
 293  * \n      GPIO_RET_OK          - Requested operation is successful
 294  * \n      INVALID_GPIO_PORT    - Invalid GPIO port number
 295  * \n      INVALID_GPIO_NUMBER  - Invalid GPIO pin number
 296  *
 297  */
 298 GPIO_RET GPIOClearOutput(uint8_t gpioPortNumber, uint8_t pinNum)
 299 {
 300         GPIO_RET retVal;
 301
 302     retVal = GPIO_ctrl(gpioPortNumber, pinNum, GPIO_CTRL_CLEAR_OUTPUT, NULL);
 303
 304         return (retVal);
 305
 306 } //gpioClearOutput
 307
 308 /**
 309  * \brief  This function gets the specified GPIO's pin state
 310  *
 311  * The specified GPIO should be configured as input
 312  *
 313  * \param   gpioPortNumber [IN]    GPIO port number
 314  * \param   pinNum         [IN]    GPIO pin number
 315  *
 316  * \return
 317  * \n      uint32_t - Input state of GPIO if success
 318  * \n                           - else GPIO status
 319  */
 320 uint32_t GPIOReadInput(uint8_t gpioPortNumber, uint8_t pinNum)
 321 {
 322     uint8_t  inData = 0;
 323     uint32_t retVal;
 324
 325     retVal = GPIO_ctrl(gpioPortNumber, pinNum, GPIO_CTRL_READ_INPUT, &inData);
 326         if(GPIO_RET_OK == retVal)
 327         {
 328                 if( ( inData & GPIO_HIGH ) == GPIO_HIGH )
 329                 {
 330                         retVal = GPIO_HIGH;
 331                 }
 332                 else
 333                 {
 334                         retVal = GPIO_LOW;
 335                 }
 336         }
 337
 338         return(retVal);
 339
 340 } //gpioReadInput
 341
 342 /**
 343  * \brief  This function Enables GPIO interrupts to CPU
 344  *
 345  * \param   gpioPortNumber [IN]    GPIO port number
 346  * \param   bankNum        [IN]    GPIO bank number
 347  *
 348  * \return
 349  * \n      GPIO_RET_OK          - Requested operation is successful
 350  * \n      INVALID_GPIO_PORT    - Invalid GPIO port number
 351  * \n      INVALID_GPIO_NUMBER  - Invalid GPIO bank number
 352  */
 353 /*GPIO_RET gpioEnableGlobalInterrupt(uint8_t gpioPortNumber, uint8_t bankNum)
 354 {
 355         GPIO_RET       retVal;
 356         CSL_GpioHandle hGpio;
 357
 358         retVal = GPIO_RET_OK;
 359
 360         if(bankNum <= GPIO_MAX_BANKS)
 361         {
 362                 hGpio = gpioGetRegBaseAddr(gpioPortNumber);
 363                 if(hGpio != NULL)
 364                 {
 365                         CSL_GPIO_bankInterruptEnable(hGpio, bankNum);
 366                 }
 367                 else
 368                 {
 369                         retVal = INVALID_GPIO_PORT;
 370                 }
 371         }
 372         else
 373         {
 374                 retVal = INVALID_GPIO_NUMBER;
 375         }
 376
 377         return (retVal);
 378
 379 } *///gpioEnableGlobalInterrupt
 380
 381 /**
 382  * \brief  This function Disables GPIO interrupts to CPU
 383  *
 384  * \param   gpioPortNumber [IN]    GPIO port number
 385  * \param   bankNum        [IN]    GPIO bank number
 386  *
 387  * \return
 388  * \n      GPIO_RET_OK          - Requested operation is successful
 389  * \n      INVALID_GPIO_PORT    - Invalid GPIO port number
 390  * \n      INVALID_GPIO_NUMBER  - Invalid GPIO bank number
 391  */
 392 /*GPIO_RET gpioDisableGlobalInterrupt(uint8_t gpioPortNumber, uint8_t bankNum)
 393 {
 394         GPIO_RET       retVal;
 395         CSL_GpioHandle hGpio;
 396
 397         retVal = GPIO_RET_OK;
 398
 399         if(bankNum <= GPIO_MAX_BANKS)
 400         {
 401                 hGpio = gpioGetRegBaseAddr(gpioPortNumber);
 402                 if(hGpio != NULL)
 403                 {
 404                         CSL_GPIO_bankInterruptDisable(hGpio, bankNum);
 405                 }
 406                 else
 407                 {
 408                         retVal = INVALID_GPIO_PORT;
 409                 }
 410         }
 411         else
 412         {
 413                 retVal = INVALID_GPIO_NUMBER;
 414         }
 415
 416         return (retVal);
 417
 418 } *///gpioDisableGlobalInterrupt
 419
 420 /**
 421  * \brief  This function sets specified GPIO's rising edge interrupt
 422  *
 423  * \param   gpioPortNumber [IN]    GPIO port number
 424  * \param   pinNum         [IN]    GPIO pin number
 425  *
 426  * \return
 427  * \n      GPIO_RET_OK          - Requested operation is successful
 428  * \n      INVALID_GPIO_PORT    - Invalid GPIO port number
 429  * \n      INVALID_GPIO_NUMBER  - Invalid GPIO pin number
 430  */
 431 /*GPIO_RET gpioSetRisingEdgeInterrupt(uint8_t gpioPortNumber, uint8_t pinNum)
 432 {
 433         GPIO_RET retVal;
 434
 435     retVal = gpio_ctrl(gpioPortNumber, pinNum, GPIO_CTRL_SET_RE_INTR, NULL);
 436
 437         return (retVal);
 438
 439 } *///gpioSetRisingEdgeInterrupt
 440
 441 /**
 442  * \brief  This function clears specified GPIO's rising edge interrupt
 443  *
 444  * \param   gpioPortNumber [IN]    GPIO port number
 445  * \param   pinNum         [IN]    GPIO pin number
 446  *
 447  * \return
 448  * \n      GPIO_RET_OK          - Requested operation is successful
 449  * \n      INVALID_GPIO_PORT    - Invalid GPIO port number
 450  * \n      INVALID_GPIO_NUMBER  - Invalid GPIO pin number
 451  */
 452 /*GPIO_RET gpioClearRisingEdgeInterrupt(uint8_t gpioPortNumber, uint8_t pinNum)
 453 {
 454         GPIO_RET retVal;
 455
 456     retVal = gpio_ctrl(gpioPortNumber, pinNum, GPIO_CTRL_CLEAR_RE_INTR, NULL);
 457
 458         return (retVal);
 459
 460 } *///gpioClearRisingEdgeInterrupt
 461
 462 /**
 463  * \brief  This function sets specified GPIO's falling edge interrupt
 464  *
 465  * \param   gpioPortNumber [IN]    GPIO port number
 466  * \param   pinNum         [IN]    GPIO pin number
 467  *
 468  * \return
 469  * \n      GPIO_RET_OK          - Requested operation is successful
 470  * \n      INVALID_GPIO_PORT    - Invalid GPIO port number
 471  * \n      INVALID_GPIO_NUMBER  - Invalid GPIO pin number
 472  */
 473 /*GPIO_RET gpioSetFallingEdgeInterrupt(uint8_t gpioPortNumber, uint8_t pinNum)
 474 {
 475         GPIO_RET retVal;
 476
 477     retVal = gpio_ctrl(gpioPortNumber, pinNum, GPIO_CTRL_SET_FE_INTR, NULL);
 478
 479         return (retVal);
 480
 481 }*/ //gpioSetFallingEdgeInterrupt
 482
 483 /**
 484  * \brief  This function clears specified GPIO's falling edge interrupt
 485  *
 486  * \param   gpioPortNumber [IN]    GPIO port number
 487  * \param   pinNum         [IN]    GPIO pin number
 488  *
 489  * \return
 490  * \n      GPIO_RET_OK          - Requested operation is successful
 491  * \n      INVALID_GPIO_PORT    - Invalid GPIO port number
 492  * \n      INVALID_GPIO_NUMBER  - Invalid GPIO pin number
 493  */
 494 /*GPIO_RET gpioClearFallingEdgeInterrupt(uint8_t gpioPortNumber, uint8_t pinNum)
 495 {
 496         GPIO_RET retVal;
 497
 498     retVal = gpio_ctrl(gpioPortNumber, pinNum, GPIO_CTRL_CLEAR_FE_INTR, NULL);
 499
 500         return (retVal);
 501 }*/
 502
 503 //#endif /* #if PLATFORM_GPIO_IN */
 504
 505 /* Nothing past this point */