Circular buffer read cleanup from Build #38 (work on PASDK-53).
[processor-sdk/performance-audio-sr.git] / pasdk / common / evmc66x_gpio_dbg.c
1 /*
2  * Copyright (c) 2010-2015, 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  */
34 /**
35  *
36  * \file   evmc66x_gpio.c
37  *
38  * \brief  This file contains the lower level functions to access GPIO
39  *
40  *****************************************************************************/
42 /************************
43  * Include Files
44  ************************/
46 #include "evmc66x_gpio_dbg.h"
47 //#include "platform_internal.h"
49 //#if (PLATFORM_GPIO_IN)
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;
84     retVal = GPIO_RET_OK;
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;
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;
109                                 /* Command to set GPIO pin output */
110                 case GPIO_CTRL_SET_OUTPUT:
111                          hGpio->BANK_REGISTERS[bankIndex].SET_DATA = 1 << bitPos;
112                          break;
114                                 /* Command to clear GPIO pin output */
115                 case GPIO_CTRL_CLEAR_OUTPUT:
116                          hGpio->BANK_REGISTERS[bankIndex].CLR_DATA = 1 << bitPos;
117                          break;
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;
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;
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;
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;
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;
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         }
163         return (retVal);
165 } //gpio_ctrl
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)
177         CSL_GpioHandle addr;
179         switch(gpioPortNumber)
180         {
181                 case GPIO_PORT_0:
182                         addr = (CSL_GpioHandle)CSL_GPIO_0_REGS;
183                         break;
185                 case GPIO_PORT_1:
186                         addr = (CSL_GpioHandle)CSL_GPIO_1_REGS;
187                         break;
189                 default :
190                         addr = NULL;
191                         break;
192         }
194         return (addr);
196 }  //gpioGetRegBaseAddr
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)
210         GPIO_RET    retVal;
211     uint8_t     bankNum;
212     uint8_t     pinNum;
214         retVal = GPIO_RET_OK;
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                 }*/
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         }
236         return (retVal);
238 } //gpioInit
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)
256         GPIO_RET    retVal;
258     retVal = GPIO_ctrl(gpioPortNumber, pinNum, GPIO_CTRL_SET_DIR, &direction);
260         return (retVal);
262 } //gpioSetDirection
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)
278         GPIO_RET retVal;
280     retVal = GPIO_ctrl(gpioPortNumber, pinNum, GPIO_CTRL_SET_OUTPUT, NULL);
282         return (retVal);
284 } //gpioSetOutput
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)
300         GPIO_RET retVal;
302     retVal = GPIO_ctrl(gpioPortNumber, pinNum, GPIO_CTRL_CLEAR_OUTPUT, NULL);
304         return (retVal);
306 } //gpioClearOutput
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)
322     uint8_t  inData = 0;
323     uint32_t retVal;
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         }
338         return(retVal);
340 } //gpioReadInput
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)
355         GPIO_RET       retVal;
356         CSL_GpioHandle hGpio;
358         retVal = GPIO_RET_OK;
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         }
377         return (retVal);
379 } *///gpioEnableGlobalInterrupt
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)
394         GPIO_RET       retVal;
395         CSL_GpioHandle hGpio;
397         retVal = GPIO_RET_OK;
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         }
416         return (retVal);
418 } *///gpioDisableGlobalInterrupt
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)
433         GPIO_RET retVal;
435     retVal = gpio_ctrl(gpioPortNumber, pinNum, GPIO_CTRL_SET_RE_INTR, NULL);
437         return (retVal);
439 } *///gpioSetRisingEdgeInterrupt
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)
454         GPIO_RET retVal;
456     retVal = gpio_ctrl(gpioPortNumber, pinNum, GPIO_CTRL_CLEAR_RE_INTR, NULL);
458         return (retVal);
460 } *///gpioClearRisingEdgeInterrupt
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)
475         GPIO_RET retVal;
477     retVal = gpio_ctrl(gpioPortNumber, pinNum, GPIO_CTRL_SET_FE_INTR, NULL);
479         return (retVal);
481 }*/ //gpioSetFallingEdgeInterrupt
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)
496         GPIO_RET retVal;
498     retVal = gpio_ctrl(gpioPortNumber, pinNum, GPIO_CTRL_CLEAR_FE_INTR, NULL);
500         return (retVal);
501 }*/
503 //#endif /* #if PLATFORM_GPIO_IN */
505 /* Nothing past this point */