1 //<MStar Software>
2 //******************************************************************************
3 // MStar Software
4 // Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved.
5 // All software, firmware and related documentation herein ("MStar Software") are
6 // intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by
7 // law, including, but not limited to, copyright law and international treaties.
8 // Any use, modification, reproduction, retransmission, or republication of all
9 // or part of MStar Software is expressly prohibited, unless prior written
10 // permission has been granted by MStar.
11 //
12 // By accessing, browsing and/or using MStar Software, you acknowledge that you
13 // have read, understood, and agree, to be bound by below terms ("Terms") and to
14 // comply with all applicable laws and regulations:
15 //
16 // 1. MStar shall retain any and all right, ownership and interest to MStar
17 // Software and any modification/derivatives thereof.
18 // No right, ownership, or interest to MStar Software and any
19 // modification/derivatives thereof is transferred to you under Terms.
20 //
21 // 2. You understand that MStar Software might include, incorporate or be
22 // supplied together with third party`s software and the use of MStar
23 // Software may require additional licenses from third parties.
24 // Therefore, you hereby agree it is your sole responsibility to separately
25 // obtain any and all third party right and license necessary for your use of
26 // such third party`s software.
27 //
28 // 3. MStar Software and any modification/derivatives thereof shall be deemed as
29 // MStar`s confidential information and you agree to keep MStar`s
30 // confidential information in strictest confidence and not disclose to any
31 // third party.
32 //
33 // 4. MStar Software is provided on an "AS IS" basis without warranties of any
34 // kind. Any warranties are hereby expressly disclaimed by MStar, including
35 // without limitation, any warranties of merchantability, non-infringement of
36 // intellectual property rights, fitness for a particular purpose, error free
37 // and in conformity with any international standard. You agree to waive any
38 // claim against MStar for any loss, damage, cost or expense that you may
39 // incur related to your use of MStar Software.
40 // In no event shall MStar be liable for any direct, indirect, incidental or
41 // consequential damages, including without limitation, lost of profit or
42 // revenues, lost or damage of data, and unauthorized system use.
43 // You agree that this Section 4 shall still apply without being affected
44 // even if MStar Software has been modified by MStar in accordance with your
45 // request or instruction for your use, except otherwise agreed by both
46 // parties in writing.
47 //
48 // 5. If requested, MStar may from time to time provide technical supports or
49 // services in relation with MStar Software to you for your use of
50 // MStar Software in conjunction with your or your customer`s product
51 // ("Services").
52 // You understand and agree that, except otherwise agreed by both parties in
53 // writing, Services are provided on an "AS IS" basis and the warranty
54 // disclaimer set forth in Section 4 above shall apply.
55 //
56 // 6. Nothing contained herein shall be construed as by implication, estoppels
57 // or otherwise:
58 // (a) conferring any license or right to use MStar name, trademark, service
59 // mark, symbol or any other identification;
60 // (b) obligating MStar or any of its affiliates to furnish any person,
61 // including without limitation, you and your customers, any assistance
62 // of any kind whatsoever, or any information; or
63 // (c) conferring any license or right under any intellectual property right.
64 //
65 // 7. These terms shall be governed by and construed in accordance with the laws
66 // of Taiwan, R.O.C., excluding its conflict of law rules.
67 // Any and all dispute arising out hereof or related hereto shall be finally
68 // settled by arbitration referred to the Chinese Arbitration Association,
69 // Taipei in accordance with the ROC Arbitration Law and the Arbitration
70 // Rules of the Association by three (3) arbitrators appointed in accordance
71 // with the said Rules.
72 // The place of arbitration shall be in Taipei, Taiwan and the language shall
73 // be English.
74 // The arbitration award shall be final and binding to both parties.
75 //
76 //******************************************************************************
77 //<MStar Software>
78 ////////////////////////////////////////////////////////////////////////////////
79 //
80 // Copyright (c) 2008-2009 MStar Semiconductor, Inc.
81 // All rights reserved.
82 //
83 // Unless otherwise stipulated in writing, any and all information contained
84 // herein regardless in any format shall remain the sole proprietary of
85 // MStar Semiconductor Inc. and be kept in strict confidence
86 // (!��MStar Confidential Information!�L) by the recipient.
87 // Any unauthorized act including without limitation unauthorized disclosure,
88 // copying, use, reproduction, sale, distribution, modification, disassembling,
89 // reverse engineering and compiling of the contents of MStar Confidential
90 // Information is unlawful and strictly prohibited. MStar hereby reserves the
91 // rights to any and all damages, losses, costs and expenses resulting therefrom.
92 //
93 ////////////////////////////////////////////////////////////////////////////////
94
95 #ifndef __DRVGPIO_C__
96 #define __DRVGPIO_C__
97
98 //-------------------------------------------------------------------------------------------------
99 // Include Files
100 //-------------------------------------------------------------------------------------------------
101 #include "MsCommon.h"
102 #include "MsVersion.h"
103 #include "MsTypes.h"
104 #include "drvGPIO.h"
105 #include "halGPIO.h"
106 #include "drvMMIO.h"
107 #include "ULog.h"
108
109 #if !defined(MSOS_TYPE_LINUX_KERNEL)
110 #include <stdio.h>
111 #include <string.h>
112 #else
113 #include <linux/string.h>
114 #include <linux/slab.h>
115 #endif
116
117 #if defined(MSOS_TYPE_LINUX)
118 #include <sys/ioctl.h>
119 #include <unistd.h>
120 #include <fcntl.h>
121 #endif
122
123
124 //-------------------------------------------------------------------------------------------------
125 // Local Compiler Options
126 //-------------------------------------------------------------------------------------------------
127 #ifdef CONFIG_MSTAR_UTPA2K_GPIO_ENABLE
128 #define GPIO_UTOPIA20 (1)
129 #else
130 #define GPIO_UTOPIA20 (0)
131 #endif
132
133
134 //-------------------------------------------------------------------------------------------------
135 // Local Defines
136 //-------------------------------------------------------------------------------------------------
137 #define TAG_GPIO "GPIO"
138
139 #define GPIO_DBG_FUNC() if (_geDbfLevel >= E_GPIO_DBGLV_ALL) \
140 {MS_DEBUG_MSG(ULOGD(TAG_GPIO, "\t==== %s ====\n", __FUNCTION__);)}
141 #define GPIO_DBG_INFO(x, args...) if (_geDbfLevel >= E_GPIO_DBGLV_INFO ) \
142 {MS_DEBUG_MSG(ULOGI(TAG_GPIO, x, ##args);)}
143 #define GPIO_DBG_ERR(x, args...) if (_geDbfLevel >= E_GPIO_DBGLV_ERR_ONLY) \
144 {MS_DEBUG_MSG(ULOGE(TAG_GPIO, x, ##args);)}
145
146 //-------------------------------------------------------------------------------------------------
147 // Local Structures
148 //-------------------------------------------------------------------------------------------------
149
150 //-------------------------------------------------------------------------------------------------
151 // Global Variables
152 //-------------------------------------------------------------------------------------------------
153
154
155 //-------------------------------------------------------------------------------------------------
156 // Local Variables
157 //-------------------------------------------------------------------------------------------------
158 static const struct gpio_operations *gpio_op;
159 extern const struct gpio_operations __gpio;
160
161 static MS_BOOL _gbInitGPIO = FALSE;
162 static GPIO_Info _gsInfo;
163 static GPIO_DbgLv _geDbfLevel = E_GPIO_DBGLV_ERR_ONLY;
164 static MSIF_Version _drv_gpio_version = {
165 .DDI = { GPIO_DRV_VERSION },
166 };
167
168 static GPIO_Attribute _GPIO_Attri = E_GPIO_ATTRI_USER_DRV;
169
170 #if defined(MSOS_TYPE_LINUX)
171 struct GPIO_Reg
172 {
173 MS_U32 u32Reg;
174 MS_U8 u8Enable;
175 MS_U8 u8BitMsk;
176 } __attribute__ ((packed));
177
178 typedef struct GPIO_Reg GPIO_Reg_t;
179
180 #define GPIO_IOC_MAGIC 'g'
181 #define MDRV_GPIO_INIT _IO(GPIO_IOC_MAGIC, 0)
182 #define MDRV_GPIO_SET _IOW(GPIO_IOC_MAGIC, 1, MS_U8)
183 #define MDRV_GPIO_OEN _IOW(GPIO_IOC_MAGIC, 2, MS_U8)
184 #define MDRV_GPIO_ODN _IOW(GPIO_IOC_MAGIC, 3, MS_U8)
185 #define MDRV_GPIO_READ _IOWR(GPIO_IOC_MAGIC, 4, MS_U8)
186 #define MDRV_GPIO_PULL_HIGH _IOW(GPIO_IOC_MAGIC, 5, MS_U8)
187 #define MDRV_GPIO_PULL_LOW _IOW(GPIO_IOC_MAGIC, 6, MS_U8)
188 #define MDRV_GPIO_INOUT _IOWR(GPIO_IOC_MAGIC, 7, MS_U8)
189 #define MDRV_GPIO_WREGB _IOW(GPIO_IOC_MAGIC, 8, GPIO_Reg_t)
190 #define KERN_GPIO_OEN _IOW(GPIO_IOC_MAGIC, 9, MS_U8)
191 #define KERN_GPIO_PULL_HIGH _IOW(GPIO_IOC_MAGIC, 10, MS_U8)
192 #define KERN_GPIO_PULL_LOW _IOW(GPIO_IOC_MAGIC, 11, MS_U8)
193 #define GPIO_FW_NAME "/dev/gpio"
194 #endif
195
196 //-------------------------------------------------------------------------------------------------
197 // Debug Functions
198 //-------------------------------------------------------------------------------------------------
199
200
201 //------------------------------------------------------------------------------
202 // Local Functions
203 //------------------------------------------------------------------------------
204 #if (GPIO_UTOPIA20)
205 MS_BOOL bU20GpioOpened = FALSE;
206 void* pInstantGpio;
207 void* pAttributeGpio;
208 #include "drvGPIO_private.h"
209 #include "utopia.h"
_MDrv_GPIO_CheckUtopia20Open(void ** pInstance,MS_U32 u32ModuleVersion,void * pAttribute)210 MS_BOOL _MDrv_GPIO_CheckUtopia20Open(void** pInstance, MS_U32 u32ModuleVersion, void* pAttribute)
211 {
212 if (FALSE == bU20GpioOpened)
213 {
214 if(UtopiaOpen(MODULE_GPIO|KERNEL_MODE, pInstance, u32ModuleVersion, pAttribute) != UTOPIA_STATUS_SUCCESS)
215 {
216 GPIO_DBG_ERR("Open GPIO fail\n");
217 return FALSE;
218 }
219 bU20GpioOpened= TRUE;
220 }
221 return TRUE;
222 }
223 #endif
224
_GPIO_Is_Init(void)225 static MS_BOOL _GPIO_Is_Init(void)
226 {
227 GPIO_DBG_FUNC();
228 if (!_gbInitGPIO)
229 GPIO_DBG_ERR("Call MDrv_GPIO_Init first!\n");
230 return _gbInitGPIO;
231 }
232
MDrv_GPIO_SetIOMapBase(void)233 MS_BOOL MDrv_GPIO_SetIOMapBase(void)
234 {
235 MS_VIRT u32MMIOBaseAdr;
236 MS_PHY u32NonPMBankSize;
237
238 GPIO_DBG_FUNC();
239
240 if( !MDrv_MMIO_GetBASE(&u32MMIOBaseAdr, &u32NonPMBankSize, MS_MODULE_GPIO))
241 {
242 GPIO_DBG_ERR("Get IOMap failure\n");
243 MS_ASSERT(0);
244 return FALSE;
245 }
246 HAL_GPIO_SetIOMapBase(u32MMIOBaseAdr);
247
248 if( !MDrv_MMIO_GetBASE(&u32MMIOBaseAdr, &u32NonPMBankSize, MS_MODULE_PM))
249 {
250 GPIO_DBG_ERR("Get IOMap failure\n");
251 MS_ASSERT(0);
252 return FALSE;
253 }
254 HAL_GPIO_SetIOMapBase_PM(u32MMIOBaseAdr);
255
256 return TRUE;
257 }
258
259
260 //------------------------------------------------------------------------------
261 // Global Functions
262 //------------------------------------------------------------------------------
MDrv_GPIO_GetLibVer(const MSIF_Version ** ppVersion)263 GPIO_Result MDrv_GPIO_GetLibVer(const MSIF_Version **ppVersion)
264 {
265 GPIO_DBG_FUNC();
266
267 if(!ppVersion)
268 return E_GPIO_FAIL;
269
270 *ppVersion = &_drv_gpio_version;
271 return E_GPIO_OK;
272 }
273
MDrv_GPIO_SetDbgLevel(GPIO_DbgLv eLevel)274 GPIO_Result MDrv_GPIO_SetDbgLevel(GPIO_DbgLv eLevel)
275 {
276 GPIO_DBG_INFO("%s level: %u\n", __FUNCTION__, eLevel);
277
278 _geDbfLevel = eLevel;
279 return E_GPIO_OK;
280 }
281
MDrv_GPIO_GetInfo(void)282 const GPIO_Info* MDrv_GPIO_GetInfo(void)
283 {
284 GPIO_DBG_FUNC();
285
286 if(!_GPIO_Is_Init())
287 return (GPIO_Info *)0;
288 _gsInfo.u32GPIONum = END_GPIO_NUM;
289 _gsInfo.u32IOMap = 0;
290 _gsInfo.u32IOMap_PM = 0;
291
292 return (&_gsInfo);
293 }
294
MDrv_GPIO_GetStatus_U2K(GPIO_Status * pStatus)295 void MDrv_GPIO_GetStatus_U2K(GPIO_Status *pStatus)
296 {
297 GPIO_DBG_FUNC();
298
299 if(!_GPIO_Is_Init())
300 return;
301
302 pStatus->bInit = _gbInitGPIO;
303 pStatus->u8DbgLevel = _geDbfLevel;
304 }
305
MDrv_GPIO_GetStatus(GPIO_Status * pStatus)306 void MDrv_GPIO_GetStatus(GPIO_Status *pStatus)
307 {
308 #if (GPIO_UTOPIA20)
309 PGPIO_GET_STS_PARAM pGpioGetStsParam = NULL;
310 if (FALSE == _MDrv_GPIO_CheckUtopia20Open(&pInstantGpio, 0, pAttributeGpio))
311 printf("GPIO Get Status Open Fail \n");
312 pGpioGetStsParam = (PGPIO_GET_STS_PARAM)malloc(sizeof(GPIO_GET_STS_PARAM));
313 pGpioGetStsParam->pSts=pStatus;
314 UtopiaIoctl(pInstantGpio, MDrv_CMD_GPIO_GetStauts,(MS_U32*)pGpioGetStsParam);
315 free(pGpioGetStsParam);
316 #else
317 MDrv_GPIO_GetStatus_U2K(pStatus);
318 #endif
319 }
320
mdrv_gpio_init_U2K(void)321 void mdrv_gpio_init_U2K(void)
322 {
323 GPIO_DBG_FUNC();
324 if(_GPIO_Attri == E_GPIO_ATTRI_USER_DRV)
325 {
326 if (_gbInitGPIO == true)
327 return;
328 _gbInitGPIO = TRUE;
329 gpio_op = &__gpio;
330 MDrv_GPIO_SetIOMapBase();
331 HAL_GPIO_Interrupt_Init();
332 }
333 else if(_GPIO_Attri == E_GPIO_ATTRI_KERNEL_DRV)
334 {
335 #if defined(MSOS_TYPE_LINUX)
336 int fd = -1;
337 fd = open(GPIO_FW_NAME, O_RDWR|O_EXCL);
338 if (fd == -1)
339 {
340 perror("");
341 }
342 else
343 {
344 if(-1 == ioctl(fd, MDRV_GPIO_INIT))
345 {
346 perror("");
347 close(fd);
348 }
349 }
350 close(fd);
351 #endif
352 }
353 }
354
mdrv_gpio_init(void)355 void mdrv_gpio_init(void)
356 {
357 #if (GPIO_UTOPIA20)
358 printf("mdrv_gpio_init \n");
359 if (FALSE == _MDrv_GPIO_CheckUtopia20Open(&pInstantGpio, 0, pAttributeGpio))
360 printf("GPIO Init Open Fail \n");
361 UtopiaIoctl(pInstantGpio, MDrv_CMD_GPIO_Init,(MS_U32*)NULL);
362 #else
363 mdrv_gpio_init_U2K();
364 #endif
365 }
366
367
mdrv_gpio_set_high_U2K(MS_GPIO_NUM gpio)368 void mdrv_gpio_set_high_U2K(MS_GPIO_NUM gpio)
369 {
370 GPIO_DBG_FUNC();
371 if(_GPIO_Attri == E_GPIO_ATTRI_USER_DRV)
372 {
373 MS_ASSERT(gpio_op);
374 if (gpio_op)
375 {
376 gpio_op->set_high(gpio);
377 }
378 }
379 else if(_GPIO_Attri == E_GPIO_ATTRI_KERNEL_DRV)
380 {
381 #if defined(MSOS_TYPE_LINUX)
382 int fd = -1;
383 fd = open(GPIO_FW_NAME, O_RDWR|O_EXCL);
384 if (fd == -1)
385 {
386 perror("");
387 }
388 else
389 {
390 if(-1 ==ioctl(fd, MDRV_GPIO_PULL_HIGH, &gpio))
391 {
392 perror("");
393 close(fd);
394 }
395 }
396 close(fd);
397 #endif
398 }
399
400 }
401
mdrv_gpio_set_high(MS_GPIO_NUM gpio)402 void mdrv_gpio_set_high(MS_GPIO_NUM gpio)
403 {
404 #if (GPIO_UTOPIA20)
405 PGPIO_SET_HIGH_PARAM pGpioSetHighParam = NULL;
406 if (FALSE == _MDrv_GPIO_CheckUtopia20Open(&pInstantGpio, 0, pAttributeGpio))
407 printf("GPIO Set High Open Fail \n");
408 pGpioSetHighParam = (PGPIO_SET_HIGH_PARAM)malloc(sizeof(GPIO_SET_HIGH_PARAM));
409 pGpioSetHighParam->gpio_num = gpio;
410 UtopiaIoctl(pInstantGpio, MDrv_CMD_GPIO_Set_High,(MS_U32*)pGpioSetHighParam);
411 free(pGpioSetHighParam);
412 #else
413 mdrv_gpio_set_high_U2K(gpio);
414 #endif
415 }
416
mdrv_gpio_set_low_U2K(MS_GPIO_NUM gpio)417 void mdrv_gpio_set_low_U2K(MS_GPIO_NUM gpio)
418 {
419 GPIO_DBG_FUNC();
420 if(_GPIO_Attri == E_GPIO_ATTRI_USER_DRV)
421 {
422 MS_ASSERT(gpio_op);
423 if (gpio_op)
424 {
425 gpio_op->set_low(gpio);
426 }
427 }
428 else if(_GPIO_Attri == E_GPIO_ATTRI_KERNEL_DRV)
429 {
430 #if defined(MSOS_TYPE_LINUX)
431 int fd = -1;
432 fd = open(GPIO_FW_NAME, O_RDWR|O_EXCL);
433 if (fd == -1)
434 {
435 perror("");
436 }
437 else
438 {
439 if(-1 ==ioctl(fd, MDRV_GPIO_PULL_LOW, &gpio))
440 {
441 perror("");
442 close(fd);
443 }
444 }
445 close(fd);
446 #endif
447 }
448 }
449
mdrv_gpio_set_low(MS_GPIO_NUM gpio)450 void mdrv_gpio_set_low(MS_GPIO_NUM gpio)
451 {
452 #if (GPIO_UTOPIA20)
453 PGPIO_SET_LOW_PARAM pGpioSetLowParam = NULL;
454 if (FALSE == _MDrv_GPIO_CheckUtopia20Open(&pInstantGpio, 0, pAttributeGpio))
455 printf("GPIO Set Low Open Fail \n");
456 pGpioSetLowParam = (PGPIO_SET_LOW_PARAM)malloc(sizeof(GPIO_SET_LOW_PARAM));
457 pGpioSetLowParam->gpio_num = gpio;
458 UtopiaIoctl(pInstantGpio, MDrv_CMD_GPIO_Set_Low,(MS_U32*)pGpioSetLowParam);
459 free(pGpioSetLowParam);
460 #else
461 mdrv_gpio_set_low_U2K(gpio);
462 #endif
463 }
464
mdrv_gpio_set_input_U2K(MS_GPIO_NUM gpio)465 void mdrv_gpio_set_input_U2K(MS_GPIO_NUM gpio)
466 {
467 GPIO_DBG_FUNC();
468
469 MS_ASSERT(gpio_op);
470 if(_GPIO_Attri == E_GPIO_ATTRI_USER_DRV)
471 {
472 if (gpio_op)
473 {
474 gpio_op->set_input(gpio);
475 }
476 }
477 else if(_GPIO_Attri == E_GPIO_ATTRI_KERNEL_DRV)
478 {
479 #if defined(MSOS_TYPE_LINUX)
480 int fd = -1;
481 fd = open(GPIO_FW_NAME, O_RDWR|O_EXCL);
482 if (fd == -1)
483 {
484 perror("");
485 }
486 else
487 {
488 if(-1 ==ioctl(fd, MDRV_GPIO_ODN, &gpio))
489 {
490 perror("");
491 close(fd);
492 }
493 }
494 close(fd);
495 #endif
496 }
497 }
498
mdrv_gpio_set_input(MS_GPIO_NUM gpio)499 void mdrv_gpio_set_input(MS_GPIO_NUM gpio)
500 {
501 #if (GPIO_UTOPIA20)
502 PGPIO_SET_INPUT_PARAM pGpioSetInputParam = NULL;
503 if (FALSE == _MDrv_GPIO_CheckUtopia20Open(&pInstantGpio, 0, pAttributeGpio))
504 printf("GPIO Set Low Open Fail \n");
505 pGpioSetInputParam = (PGPIO_SET_INPUT_PARAM)malloc(sizeof(GPIO_SET_INPUT_PARAM));
506 pGpioSetInputParam->gpio_num = gpio;
507 UtopiaIoctl(pInstantGpio, MDrv_CMD_GPIO_Set_Input,(MS_U32*)pGpioSetInputParam);
508 free(pGpioSetInputParam);
509 #else
510 mdrv_gpio_set_input_U2K(gpio);
511 #endif
512 }
513
514 #if 0
515 void mdrv_gpio_set_output(MS_GPIO_NUM gpio)
516 {
517 MS_ASSERT(gpio_op);
518 if (gpio_op)
519 {
520 gpio_op->set_output(gpio);
521 }
522 }
523 #endif
mdrv_gpio_get_inout_U2K(MS_GPIO_NUM gpio)524 int mdrv_gpio_get_inout_U2K(MS_GPIO_NUM gpio)
525 {
526 GPIO_DBG_FUNC();
527 if(_GPIO_Attri == E_GPIO_ATTRI_USER_DRV)
528 {
529 MS_ASSERT(gpio_op);
530 if (gpio_op)
531 {
532 return gpio_op->get_inout(gpio);
533 }
534 else
535 return 0;
536 }
537 else if(_GPIO_Attri == E_GPIO_ATTRI_KERNEL_DRV)
538 {
539 #if defined(MSOS_TYPE_LINUX)
540 int fd = -1;
541 fd = open(GPIO_FW_NAME, O_RDWR|O_EXCL);
542 int Ret;
543 if (fd == -1)
544 {
545 perror("");
546 return 0;
547 }
548 else
549 {
550 Ret=ioctl(fd, MDRV_GPIO_INOUT, &gpio);
551 if(-1 ==Ret)
552 {
553 perror("");
554 close(fd);
555 return 0;
556 }
557 }
558 close(fd);
559 return Ret;
560 #endif
561 }
562 return 0;
563 }
564
565
mdrv_gpio_get_inout(MS_GPIO_NUM gpio)566 int mdrv_gpio_get_inout(MS_GPIO_NUM gpio)
567 {
568 #if (GPIO_UTOPIA20)
569 int u32InOutVal;
570 PGPIO_GET_INOUT_PARAM pGpioGetInOutParam = NULL;
571 if (FALSE == _MDrv_GPIO_CheckUtopia20Open(&pInstantGpio, 0, pAttributeGpio))
572 return 0;
573 pGpioGetInOutParam = (PGPIO_GET_INOUT_PARAM)malloc(sizeof(GPIO_GET_INOUT_PARAM));
574 pGpioGetInOutParam->gpio_num=gpio;
575 pGpioGetInOutParam->u32InOut=0;
576 UtopiaIoctl(pInstantGpio, MDrv_CMD_GPIO_Get_Inout,(MS_U32*)pGpioGetInOutParam);
577 u32InOutVal = pGpioGetInOutParam->u32InOut;
578 free(pGpioGetInOutParam);
579 return (int)u32InOutVal;
580 #else
581 return mdrv_gpio_get_inout_U2K(gpio);
582 #endif
583 }
584
585
586
mdrv_gpio_get_level_U2K(MS_GPIO_NUM gpio)587 int mdrv_gpio_get_level_U2K(MS_GPIO_NUM gpio)
588 {
589 GPIO_DBG_FUNC();
590 if(_GPIO_Attri == E_GPIO_ATTRI_USER_DRV)
591 {
592 MS_ASSERT(gpio_op);
593 if (gpio_op)
594 {
595 return gpio_op->get_level(gpio);
596 }
597 else
598 return 0;
599 }
600 else if(_GPIO_Attri == E_GPIO_ATTRI_KERNEL_DRV)
601 {
602 #if defined(MSOS_TYPE_LINUX)
603 int fd = -1;
604 fd = open(GPIO_FW_NAME, O_RDWR|O_EXCL);
605 int Ret;
606 if (fd == -1)
607 {
608 perror("");
609 return 0;
610 }
611 else
612 {
613 Ret=ioctl(fd, MDRV_GPIO_READ, &gpio);
614 if(-1 ==Ret)
615 {
616 perror("");
617 close(fd);
618 return 0;
619 }
620 }
621 close(fd);
622 return Ret;
623 #endif
624 }
625 return 0;
626 }
627
mdrv_gpio_get_level(MS_GPIO_NUM gpio)628 int mdrv_gpio_get_level(MS_GPIO_NUM gpio)
629 {
630 #if (GPIO_UTOPIA20)
631 int u32Level;
632 PGPIO_GET_LEVEL_PARAM pGpioGetLevelParam = NULL;
633 if (FALSE == _MDrv_GPIO_CheckUtopia20Open(&pInstantGpio, 0, pAttributeGpio))
634 return 0;
635 pGpioGetLevelParam = (PGPIO_GET_LEVEL_PARAM)malloc(sizeof(GPIO_GET_LEVEL_PARAM));
636 pGpioGetLevelParam->gpio_num=gpio;
637 pGpioGetLevelParam->u32Level=0;
638 UtopiaIoctl(pInstantGpio, MDrv_CMD_GPIO_Get_Level,(MS_U32*)pGpioGetLevelParam);
639 u32Level = pGpioGetLevelParam->u32Level;
640 free(pGpioGetLevelParam);
641 return (int)u32Level;
642 #else
643 return mdrv_gpio_get_level_U2K(gpio);
644 #endif
645 }
646
mdrv_gpio_attach_interrupt_U2K(MS_GPIO_NUM gpio_num,GPIO_Edge gpio_edge_type,GPIO_Callback pCallback)647 GPIO_Result mdrv_gpio_attach_interrupt_U2K(MS_GPIO_NUM gpio_num,GPIO_Edge gpio_edge_type,GPIO_Callback pCallback)
648 {
649 GPIO_Result ret_val;
650
651 GPIO_DBG_FUNC();
652 if(_GPIO_Is_Init())
653 {
654 ret_val = HAL_GPIO_Attach_Interrupt(gpio_num,gpio_edge_type,pCallback);
655 }
656 else
657 {
658 ret_val = E_GPIO_FAIL;
659 }
660
661 return ret_val;
662 }
663
mdrv_gpio_attach_interrupt(MS_GPIO_NUM gpio_num,GPIO_Edge gpio_edge_type,GPIO_Callback pCallback)664 GPIO_Result mdrv_gpio_attach_interrupt(MS_GPIO_NUM gpio_num,GPIO_Edge gpio_edge_type,GPIO_Callback pCallback)
665 {
666 #if (GPIO_UTOPIA20)
667 GPIO_Result u32Ret;
668 PGPIO_ATTACH_INTERRUPT_PARAM pGpioAttIntParam = NULL;
669 if (FALSE == _MDrv_GPIO_CheckUtopia20Open(&pInstantGpio, 0, pAttributeGpio))
670 return 0;
671 pGpioAttIntParam = (PGPIO_ATTACH_INTERRUPT_PARAM)malloc(sizeof(GPIO_ATTACH_INTERRUPT_PARAM));
672 pGpioAttIntParam->GPIO_Callback=pCallback;
673 pGpioAttIntParam->gpio_edge_type=gpio_edge_type;
674 pGpioAttIntParam->gpio_num=gpio_num;
675 u32Ret=UtopiaIoctl(pInstantGpio, MDrv_CMD_GPIO_Attach_Interrupt,(MS_U32*)pGpioAttIntParam);
676 free(pGpioAttIntParam);
677 return (GPIO_Result)u32Ret;
678 #else
679 return mdrv_gpio_attach_interrupt_U2K(gpio_num,gpio_edge_type,pCallback);
680 #endif
681 }
682
mdrv_gpio_detach_interrupt_U2K(MS_GPIO_NUM gpio_num)683 GPIO_Result mdrv_gpio_detach_interrupt_U2K(MS_GPIO_NUM gpio_num)
684 {
685 GPIO_Result ret_val;
686
687 GPIO_DBG_FUNC();
688 if(_GPIO_Is_Init())
689 {
690 ret_val = HAL_GPIO_Datach_Interrupt(gpio_num);
691 }
692 else
693 {
694 ret_val = E_GPIO_FAIL;
695 }
696 return ret_val;
697 }
698
mdrv_gpio_detach_interrupt(MS_GPIO_NUM gpio_num)699 GPIO_Result mdrv_gpio_detach_interrupt(MS_GPIO_NUM gpio_num)
700 {
701 #if (GPIO_UTOPIA20)
702 GPIO_Result u32Ret;
703 PGPIO_DETACH_INTERRUPT_PARAM pGpioDetachIntParam = NULL;
704 if (FALSE == _MDrv_GPIO_CheckUtopia20Open(&pInstantGpio, 0, pAttributeGpio))
705 return 0;
706 pGpioDetachIntParam = (PGPIO_DETACH_INTERRUPT_PARAM)malloc(sizeof(GPIO_DETACH_INTERRUPT_PARAM));
707 pGpioDetachIntParam->gpio_num=gpio_num;
708 u32Ret=UtopiaIoctl(pInstantGpio, MDrv_CMD_GPIO_Detach_Interrupt,(MS_U32*)pGpioDetachIntParam);
709 free(pGpioDetachIntParam);
710 return (GPIO_Result)u32Ret;
711 #else
712 return mdrv_gpio_detach_interrupt_U2K(gpio_num);
713 #endif
714 }
715
mdrv_gpio_enable_interrupt_U2K(MS_GPIO_NUM gpio)716 GPIO_Result mdrv_gpio_enable_interrupt_U2K(MS_GPIO_NUM gpio)
717 {
718 GPIO_Result ret_val;
719
720 GPIO_DBG_FUNC();
721 if(_GPIO_Is_Init())
722 {
723 ret_val = HAL_GPIO_Enable_Interrupt(gpio);
724 }
725 else
726 {
727 ret_val = E_GPIO_FAIL;
728 }
729
730 return ret_val;
731 }
732
mdrv_gpio_enable_interrupt(MS_GPIO_NUM gpio_num)733 GPIO_Result mdrv_gpio_enable_interrupt(MS_GPIO_NUM gpio_num)
734 {
735 #if (GPIO_UTOPIA20)
736 GPIO_Result u32Ret;
737 PGPIO_ENABLE_INTERRUPT_PARAM pGpioEnableIntParam = NULL;
738 if (FALSE == _MDrv_GPIO_CheckUtopia20Open(&pInstantGpio, 0, pAttributeGpio))
739 return 0;
740 pGpioEnableIntParam = (PGPIO_ENABLE_INTERRUPT_PARAM)malloc(sizeof(GPIO_ENABLE_INTERRUPT_PARAM));
741 pGpioEnableIntParam->gpio_num=gpio_num;
742 u32Ret=UtopiaIoctl(pInstantGpio, MDrv_CMD_GPIO_En_Interrupt,(MS_U32*)pGpioEnableIntParam);
743 free(pGpioEnableIntParam);
744 return (GPIO_Result)u32Ret;
745 #else
746 return mdrv_gpio_enable_interrupt_U2K(gpio_num);
747 #endif
748 }
749
mdrv_gpio_disable_interrupt_U2K(MS_GPIO_NUM gpio)750 GPIO_Result mdrv_gpio_disable_interrupt_U2K(MS_GPIO_NUM gpio)
751 {
752 GPIO_Result ret_val;
753
754 GPIO_DBG_FUNC();
755 if(_GPIO_Is_Init())
756 {
757 ret_val = HAL_GPIO_Disable_Interrupt(gpio);
758 }
759 else
760 {
761 ret_val = E_GPIO_FAIL;
762 }
763
764 return ret_val;
765 }
766
mdrv_gpio_disable_interrupt(MS_GPIO_NUM gpio_num)767 GPIO_Result mdrv_gpio_disable_interrupt(MS_GPIO_NUM gpio_num)
768 {
769 #if (GPIO_UTOPIA20)
770 GPIO_Result u32Ret;
771 PGPIO_DISABLE_INTERRUPT_PARAM pGpioDisableIntParam = NULL;
772 if (FALSE == _MDrv_GPIO_CheckUtopia20Open(&pInstantGpio, 0, pAttributeGpio))
773 return 0;
774 pGpioDisableIntParam = (PGPIO_DISABLE_INTERRUPT_PARAM)malloc(sizeof(GPIO_DISABLE_INTERRUPT_PARAM));
775 pGpioDisableIntParam ->gpio_num=gpio_num;
776 u32Ret=UtopiaIoctl(pInstantGpio, MDrv_CMD_GPIO_Dis_Interrupt,(MS_U32*)pGpioDisableIntParam);
777 free(pGpioDisableIntParam);
778 return (GPIO_Result)u32Ret;
779 #else
780 return mdrv_gpio_disable_interrupt_U2K(gpio_num);
781 #endif
782 }
783
mdrv_gpio_disable_interrupt_all_U2K(void)784 void mdrv_gpio_disable_interrupt_all_U2K(void)
785 {
786 GPIO_DBG_FUNC();
787 if(_GPIO_Is_Init())
788 {
789 HAL_GPIO_Disable_Interrupt_all();
790 }
791 }
792
mdrv_gpio_disable_interrupt_all(void)793 void mdrv_gpio_disable_interrupt_all(void)
794 {
795 #if (GPIO_UTOPIA20)
796 if (FALSE == _MDrv_GPIO_CheckUtopia20Open(&pInstantGpio, 0, pAttributeGpio))
797 printf("gpio_disable Open Fail");
798 UtopiaIoctl(pInstantGpio, MDrv_CMD_GPIO_Dis_Interrupt_All,(MS_U32*)NULL);
799 #else
800 mdrv_gpio_disable_interrupt_all_U2K();
801 #endif
802 }
803
mdrv_gpio_enable_interrupt_all_U2K(void)804 void mdrv_gpio_enable_interrupt_all_U2K(void)
805 {
806 GPIO_DBG_FUNC();
807 if(_GPIO_Is_Init())
808 {
809 HAL_GPIO_Enable_Interrupt_all();
810 }
811 }
812
mdrv_gpio_enable_interrupt_all(void)813 void mdrv_gpio_enable_interrupt_all(void)
814 {
815 #if (GPIO_UTOPIA20)
816 if (FALSE == _MDrv_GPIO_CheckUtopia20Open(&pInstantGpio, 0, pAttributeGpio))
817 printf("gpio_disable Open Fail");
818 UtopiaIoctl(pInstantGpio, MDrv_CMD_GPIO_En_Interrupt_All,(MS_U32*)NULL);
819 #else
820 mdrv_gpio_enable_interrupt_all_U2K();
821 #endif
822 }
823
mdrv_gpio_interrupt_action_U2K(void)824 void mdrv_gpio_interrupt_action_U2K(void)
825 {
826 GPIO_DBG_FUNC();
827 if(_GPIO_Is_Init())
828 {
829 HAL_GPIO_Interrupt_Action();
830 }
831 }
832
mdrv_gpio_interrupt_action(void)833 void mdrv_gpio_interrupt_action(void)
834 {
835 #if (GPIO_UTOPIA20)
836 if (FALSE == _MDrv_GPIO_CheckUtopia20Open(&pInstantGpio, 0, pAttributeGpio))
837 printf("gpio_disable Open Fail");
838 UtopiaIoctl(pInstantGpio, MDrv_CMD_GPIO_Interrupt_Action,(MS_U32*)NULL);
839 #else
840 mdrv_gpio_interrupt_action_U2K();
841 #endif
842 }
843
MDrv_GPIO_SetPowerState(EN_POWER_MODE u16PowerState)844 MS_U16 MDrv_GPIO_SetPowerState(EN_POWER_MODE u16PowerState)
845 {
846 static EN_POWER_MODE _prev_u16PowerState = E_POWER_MECHANICAL;
847 MS_U16 u16Return = FALSE;
848
849 if (u16PowerState == E_POWER_SUSPEND)
850 {
851 _gbInitGPIO = FALSE;
852 _prev_u16PowerState = u16PowerState;
853 return 2; // suspend OK
854 }
855 else if (u16PowerState == E_POWER_RESUME)
856 {
857 if (_prev_u16PowerState == E_POWER_SUSPEND)
858 {
859 mdrv_gpio_init();
860 _prev_u16PowerState = u16PowerState;
861 u16Return = 1; // resume OK
862 }
863 else
864 {
865 ULOGE(TAG_GPIO, "[%s,%5d]It is not suspended yet. We shouldn't resume\n",__FUNCTION__,__LINE__);
866 u16Return = 3; // suspend failed
867 }
868 }
869 else
870 {
871 ULOGE(TAG_GPIO, "[%s,%5d]Do Nothing: %d\n",__FUNCTION__,__LINE__,u16PowerState);
872 u16Return = FALSE;
873 }
874
875 return u16Return;
876 }
877
MDrv_GPIO_Attribute(GPIO_Attribute GpioAttri)878 MS_BOOL MDrv_GPIO_Attribute(GPIO_Attribute GpioAttri)
879 {
880 switch (GpioAttri)
881 {
882 case E_GPIO_ATTRI_USER_DRV:
883 _GPIO_Attri = E_GPIO_ATTRI_USER_DRV;
884 break;
885 case E_GPIO_ATTRI_KERNEL_DRV:
886 _GPIO_Attri = E_GPIO_ATTRI_KERNEL_DRV;
887 break;
888 case E_GPIO_ATTRI_UNKNOWN:
889
890 default:
891 return FALSE;
892
893 break;
894 }
895 return TRUE;
896 }
897
898
899 #endif //__DRVGPIO_C__
900
901