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)
176 {
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)
209 {
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)
255 {
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)
277 {
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)
299 {
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)
321 {
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)
354 {
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)
393 {
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)
432 {
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)
453 {
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)
474 {
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)
495 {
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 */