drivers/mtk_wcn_combo/common/platform/rockchip/wmt_plat_rockchip.c

   1 /* Copyright Statement:
   2  *
   3  * This software/firmware and related documentation ("MediaTek Software") are
   4  * protected under relevant copyright laws. The information contained herein
   5  * is confidential and proprietary to MediaTek Inc. and/or its licensors.
   6  * Without the prior written permission of MediaTek inc. and/or its licensors,
   7  * any reproduction, modification, use or disclosure of MediaTek Software,
   8  * and information contained herein, in whole or in part, shall be strictly prohibited.
   9  *
  10  * MediaTek Inc. (C) 2010. All rights reserved.
  11  *
  12  * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  13  * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  14  * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER ON
  15  * AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  18  * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  19  * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  20  * SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH
  21  * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES
  22  * THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES
  23  * CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK
  24  * SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
  25  * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
  26  * CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  27  * AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  28  * OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO
  29  * MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
  30  *
  31  * The following software/firmware and/or related documentation ("MediaTek Software")
  32  * have been modified by MediaTek Inc. All revisions are subject to any receiver's
  33  * applicable license agreements with MediaTek Inc.
  34  */
  35
  36
  37 /*! \file
  38     \brief  Declaration of library functions
  39
  40     Any definitions in this file will be shared among GLUE Layer and internal Driver Stack.
  41 */
  42
  43 /*******************************************************************************
  44 * Copyright (c) 2009 MediaTek Inc.
  45 *
  46 * All rights reserved. Copying, compilation, modification, distribution
  47 * or any other use whatsoever of this material is strictly prohibited
  48 * except in accordance with a Software License Agreement with
  49 * MediaTek Inc.
  50 ********************************************************************************
  51 */
  52
  53 /*******************************************************************************
  54 * LEGAL DISCLAIMER
  55 *
  56 * BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND
  57 * AGREES THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK
  58 * SOFTWARE") RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE
  59 * PROVIDED TO BUYER ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY
  60 * DISCLAIMS ANY AND ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT
  61 * LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  62 * PARTICULAR PURPOSE OR NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE
  63 * ANY WARRANTY WHATSOEVER WITH RESPECT TO THE SOFTWARE OF ANY THIRD PARTY
  64 * WHICH MAY BE USED BY, INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK
  65 * SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY
  66 * WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE
  67 * FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S SPECIFICATION OR TO
  68 * CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  69 *
  70 * BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  71 * LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL
  72 * BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT
  73 * ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY
  74 * BUYER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
  75 *
  76 * THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  77 * WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT
  78 * OF LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING
  79 * THEREOF AND RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN
  80 * FRANCISCO, CA, UNDER THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE
  81 * (ICC).
  82 ********************************************************************************
  83 */
  84
  85
  86 /*******************************************************************************
  87 *                         C O M P I L E R   F L A G S
  88 ********************************************************************************
  89 */
  90
  91 /*******************************************************************************
  92 *                                 M A C R O S
  93 ********************************************************************************
  94 */
  95 #include <asm/mach-types.h>
  96 #include <linux/delay.h>
  97 #include <mach/gpio.h>
  98 #include <mach/io.h>
  99 #include <linux/platform_device.h>
 100
 101 #if CONFIG_HAS_WAKELOCK
 102 #include <linux/wakelock.h>
 103 #define CFG_WMT_WAKELOCK_SUPPORT 1
 104 #endif
 105
 106
 107 #ifdef DFT_TAG
 108 #undef DFT_TAG
 109 #endif
 110 #define DFT_TAG         "[WMT-PLAT]"
 111
 112
 113 /*******************************************************************************
 114 *                    E X T E R N A L   R E F E R E N C E S
 115 ********************************************************************************
 116 */
 117
 118 /*header files*/
 119 #include <linux/interrupt.h>
 120 #include <linux/irq.h>
 121 #include <linux/spinlock.h>
 122
 123 /* MTK_WCN_COMBO header files */
 124 #include "wmt_plat.h"
 125 #include "wmt_exp.h"
 126 #include "mtk_wcn_cmb_hw.h"
 127
 128 /*******************************************************************************
 129 *                              C O N S T A N T S
 130 ********************************************************************************
 131 */
 132
 133
 134 #define GPIO_MT6620_PMUEN               XXX
 135 #define GPIO_MT6620_SYSRST              XXX
 136 #define GPIO_MT6620_LDO_EN     XXX
 137 #define INT_6620              XXX
 138
 139 /*******************************************************************************
 140 *                             D A T A   T Y P E S
 141 ********************************************************************************
 142 */
 143
 144 /*******************************************************************************
 145 *                  F U N C T I O N   D E C L A R A T I O N S
 146 ********************************************************************************
 147 */
 148
 149 static VOID wmt_plat_func_ctrl (UINT32 type, UINT32 on);
 150 static VOID wmt_plat_bgf_eirq_cb (VOID);
 151
 152 static INT32 wmt_plat_ldo_ctrl (ENUM_PIN_STATE state);
 153 static INT32 wmt_plat_pmu_ctrl (ENUM_PIN_STATE state);
 154 static INT32 wmt_plat_rtc_ctrl (ENUM_PIN_STATE state);
 155 static INT32 wmt_plat_rst_ctrl (ENUM_PIN_STATE state);
 156 static INT32 wmt_plat_bgf_eint_ctrl (ENUM_PIN_STATE state);
 157 static INT32 wmt_plat_wifi_eint_ctrl (ENUM_PIN_STATE state);
 158 static INT32 wmt_plat_all_eint_ctrl (ENUM_PIN_STATE state);
 159 static INT32 wmt_plat_uart_ctrl (ENUM_PIN_STATE state);
 160 static INT32 wmt_plat_pcm_ctrl (ENUM_PIN_STATE state);
 161 static INT32 wmt_plat_i2s_ctrl (ENUM_PIN_STATE state);
 162 static INT32 wmt_plat_sdio_pin_ctrl (ENUM_PIN_STATE state);
 163 static INT32 wmt_plat_gps_sync_ctrl (ENUM_PIN_STATE state);
 164 static INT32 wmt_plat_gps_lna_ctrl (ENUM_PIN_STATE state);
 165
 166 static INT32 wmt_plat_dump_pin_conf (VOID);
 167
 168
 169
 170 /*******************************************************************************
 171 *                            P U B L I C   D A T A
 172 ********************************************************************************
 173 */
 174 UINT32 gWmtDbgLvl = WMT_LOG_INFO;
 175
 176 unsigned int g_balance_flag;
 177 spinlock_t g_balance_lock;
 178 unsigned int g_bgf_irq = 69;//INT_6620;//bgf eint number
 179 /*******************************************************************************
 180 *                           P R I V A T E   D A T A
 181 ********************************************************************************
 182 */
 183
 184
 185
 186
 187 #if CFG_WMT_WAKELOCK_SUPPORT
 188 static OSAL_SLEEPABLE_LOCK gOsSLock;
 189 static struct wake_lock wmtWakeLock;
 190 #endif
 191
 192 irq_cb wmt_plat_bgf_irq_cb = NULL;
 193 device_audio_if_cb wmt_plat_audio_if_cb = NULL;
 194 const static fp_set_pin gfp_set_pin_table[] =
 195 {
 196     [PIN_LDO] = wmt_plat_ldo_ctrl,
 197     [PIN_PMU] = wmt_plat_pmu_ctrl,
 198     [PIN_RTC] = wmt_plat_rtc_ctrl,
 199     [PIN_RST] = wmt_plat_rst_ctrl,
 200     [PIN_BGF_EINT] = wmt_plat_bgf_eint_ctrl,
 201     [PIN_WIFI_EINT] = wmt_plat_wifi_eint_ctrl,
 202     [PIN_ALL_EINT] = wmt_plat_all_eint_ctrl,
 203     [PIN_UART_GRP] = wmt_plat_uart_ctrl,
 204     [PIN_PCM_GRP] = wmt_plat_pcm_ctrl,
 205     [PIN_I2S_GRP] = wmt_plat_i2s_ctrl,
 206     [PIN_SDIO_GRP] = wmt_plat_sdio_pin_ctrl,
 207     [PIN_GPS_SYNC] = wmt_plat_gps_sync_ctrl,
 208     [PIN_GPS_LNA] = wmt_plat_gps_lna_ctrl,
 209
 210 };
 211
 212 /*******************************************************************************
 213 *                              F U N C T I O N S
 214 ********************************************************************************
 215 */
 216
 217 /*!
 218  * \brief audio control callback function for CMB_STUB on ALPS
 219  *
 220  * A platform function required for dynamic binding with CMB_STUB on ALPS.
 221  *
 222  * \param state desired audio interface state to use
 223  * \param flag audio interface control options
 224  *
 225  * \retval 0 operation success
 226  * \retval -1 invalid parameters
 227  * \retval < 0 error for operation fail
 228  */
 229 INT32 wmt_plat_audio_ctrl (CMB_STUB_AIF_X state, CMB_STUB_AIF_CTRL ctrl)
 230 {
 231     INT32 iRet = 0;
 232     UINT32 pinShare;
 233
 234     /* input sanity check */
 235     if ( (CMB_STUB_AIF_MAX <= state)
 236         || (CMB_STUB_AIF_CTRL_MAX <= ctrl) ) {
 237         iRet = -1;
 238         WMT_ERR_FUNC("WMT-PLAT: invalid para, state(%d), ctrl(%d),iRet(%d) \n", state, ctrl, iRet);
 239         return iRet;
 240     }
 241     if (0/*I2S/PCM share pin*/) {
 242         // TODO: [FixMe][GeorgeKuo] how about MT6575? The following is applied to MT6573E1 only!!
 243         pinShare = 1;
 244         WMT_INFO_FUNC( "PCM/I2S pin share\n");
 245     }
 246     else{ //E1 later
 247         pinShare = 0;
 248         WMT_INFO_FUNC( "PCM/I2S pin seperate\n");
 249     }
 250
 251     iRet = 0;
 252
 253     /* set host side first */
 254     switch (state) {
 255     case CMB_STUB_AIF_0:
 256         /* BT_PCM_OFF & FM line in/out */
 257         iRet += wmt_plat_gpio_ctrl(PIN_PCM_GRP, PIN_STA_DEINIT);
 258         iRet += wmt_plat_gpio_ctrl(PIN_I2S_GRP, PIN_STA_DEINIT);
 259         break;
 260
 261     case CMB_STUB_AIF_1:
 262         iRet += wmt_plat_gpio_ctrl(PIN_PCM_GRP, PIN_STA_INIT);
 263         iRet += wmt_plat_gpio_ctrl(PIN_I2S_GRP, PIN_STA_DEINIT);
 264         break;
 265
 266     case CMB_STUB_AIF_2:
 267         iRet += wmt_plat_gpio_ctrl(PIN_PCM_GRP, PIN_STA_DEINIT);
 268         iRet += wmt_plat_gpio_ctrl(PIN_I2S_GRP, PIN_STA_INIT);
 269         break;
 270
 271     case CMB_STUB_AIF_3:
 272         iRet += wmt_plat_gpio_ctrl(PIN_PCM_GRP, PIN_STA_INIT);
 273         iRet += wmt_plat_gpio_ctrl(PIN_I2S_GRP, PIN_STA_INIT);
 274         break;
 275
 276     default:
 277         /* FIXME: move to cust folder? */
 278         WMT_ERR_FUNC("invalid state [%d]\n", state);
 279         return -1;
 280         break;
 281     }
 282
 283     if (CMB_STUB_AIF_CTRL_EN == ctrl) {
 284         WMT_INFO_FUNC("call chip aif setting \n");
 285         /* need to control chip side GPIO */
 286         //iRet += wmt_lib_set_aif(state, (pinShare) ? MTK_WCN_BOOL_TRUE : MTK_WCN_BOOL_FALSE);
 287                 if (NULL != wmt_plat_audio_if_cb)
 288                 {
 289                     iRet += (*wmt_plat_audio_if_cb)(state, (pinShare) ? MTK_WCN_BOOL_TRUE : MTK_WCN_BOOL_FALSE);
 290                 }
 291                 else
 292                 {
 293                     WMT_WARN_FUNC("wmt_plat_audio_if_cb is not registered \n");
 294                     iRet -= 1;
 295                 }
 296     }
 297     else {
 298         WMT_INFO_FUNC("skip chip aif setting \n");
 299     }
 300     return iRet;
 301
 302 }
 303
 304 #if CFG_WMT_PS_SUPPORT
 305 irqreturn_t irq_handler(int i, void *arg)
 306 {
 307     wmt_plat_bgf_eirq_cb();
 308     return IRQ_HANDLED;
 309 }
 310 #endif
 311
 312 static VOID
 313 wmt_plat_bgf_eirq_cb (VOID)
 314 {
 315
 316 #if CFG_WMT_PS_SUPPORT
 317         //#error "need to disable EINT here"
 318                 //wmt_lib_ps_irq_cb();
 319                 if (NULL != wmt_plat_bgf_irq_cb)
 320                 {
 321                         (*(wmt_plat_bgf_irq_cb))();
 322                 }
 323                 else
 324                 {
 325                         WMT_WARN_FUNC("WMT-PLAT: wmt_plat_bgf_irq_cb not registered\n");
 326                 }
 327 #else
 328                 return;
 329 #endif
 330 }
 331
 332
 333
 334 VOID wmt_lib_plat_irq_cb_reg (irq_cb bgf_irq_cb)
 335 {
 336     wmt_plat_bgf_irq_cb = bgf_irq_cb;
 337 }
 338
 339 VOID wmt_lib_plat_aif_cb_reg (device_audio_if_cb aif_ctrl_cb)
 340 {
 341     wmt_plat_audio_if_cb = aif_ctrl_cb;
 342 }
 343
 344
 345
 346
 347
 348
 349 INT32
 350 wmt_plat_init (P_PWR_SEQ_TIME pPwrSeqTime)
 351 {
 352     //CMB_STUB_CB stub_cb;
 353     /*PWR_SEQ_TIME pwr_seq_time;*/
 354     INT32 iret;
 355
 356     //stub_cb.aif_ctrl_cb = wmt_plat_audio_ctrl;
 357     //stub_cb.func_ctrl_cb = wmt_plat_func_ctrl;
 358     //stub_cb.size = sizeof(stub_cb);
 359
 360     /* register to cmb_stub */
 361     //iret = mtk_wcn_cmb_stub_reg(&stub_cb);
 362
 363     /* init cmb_hw */
 364     iret += mtk_wcn_cmb_hw_init(pPwrSeqTime);
 365
 366     /*init wmt function ctrl wakelock if wake lock is supported by host platform*/
 367     #ifdef CFG_WMT_WAKELOCK_SUPPORT
 368     wake_lock_init(&wmtWakeLock, WAKE_LOCK_SUSPEND, "wmtFuncCtrl");
 369     osal_sleepable_lock_init(&gOsSLock);
 370     #endif
 371
 372     spin_lock_init(&g_balance_lock);
 373
 374     WMT_DBG_FUNC("WMT-PLAT: ALPS platform init (%d)\n", iret);
 375
 376     return 0;
 377 }
 378
 379
 380 INT32
 381 wmt_plat_deinit (VOID)
 382 {
 383     INT32 iret;
 384
 385     /* 1. de-init cmb_hw */
 386     iret = mtk_wcn_cmb_hw_deinit();
 387     /* 2. unreg to cmb_stub */
 388     iret += mtk_wcn_cmb_stub_unreg();
 389     /*3. wmt wakelock deinit*/
 390     #ifdef CFG_WMT_WAKELOCK_SUPPORT
 391     wake_lock_destroy(&wmtWakeLock);
 392     osal_sleepable_lock_deinit(&gOsSLock);
 393     WMT_DBG_FUNC("destroy wmtWakeLock\n");
 394     #endif
 395     WMT_DBG_FUNC("WMT-PLAT: ALPS platform init (%d)\n", iret);
 396
 397     return 0;
 398 }
 399
 400 INT32 wmt_plat_sdio_ctrl (WMT_SDIO_SLOT_NUM sdioPortType, ENUM_FUNC_STATE on)
 401 {
 402     if (FUNC_OFF == on)  {
 403         /* add control logic here to generate SDIO CARD REMOVAL event to mmc/sd
 404          * controller. SDIO card removal operation and remove success messages
 405          * are expected.
 406          */
 407     }
 408     else {
 409         /* add control logic here to generate SDIO CARD INSERTION event to mmc/sd
 410          * controller. SDIO card detection operation and detect success messages
 411          * are expected.
 412          */
 413     }
 414     return 0;
 415 }
 416
 417 #if 0
 418 INT32
 419 wmt_plat_irq_ctrl (
 420     ENUM_FUNC_STATE state
 421     )
 422 {
 423     return -1;
 424 }
 425 #endif
 426
 427 static INT32
 428 wmt_plat_dump_pin_conf (VOID)
 429 {
 430     WMT_INFO_FUNC( "[WMT-PLAT]=>dump wmt pin configuration start<=\n");
 431     WMT_INFO_FUNC( "[WMT-PLAT]=>dump wmt pin configuration emds<=\n");
 432     return 0;
 433 }
 434
 435
 436 INT32 wmt_plat_pwr_ctrl (
 437     ENUM_FUNC_STATE state
 438     )
 439 {
 440     INT32 ret = -1;
 441
 442     switch (state) {
 443     case FUNC_ON:
 444         // TODO:[ChangeFeature][George] always output this or by request throuth /proc or sysfs?
 445         wmt_plat_dump_pin_conf();
 446         ret = mtk_wcn_cmb_hw_pwr_on();
 447         break;
 448
 449     case FUNC_OFF:
 450         ret = mtk_wcn_cmb_hw_pwr_off();
 451         break;
 452
 453     case FUNC_RST:
 454         ret = mtk_wcn_cmb_hw_rst();
 455         break;
 456
 457     default:
 458         WMT_WARN_FUNC("WMT-PLAT:Warnning, invalid state(%d) in pwr_ctrl\n", state);
 459         break;
 460     }
 461
 462     return ret;
 463 }
 464
 465 INT32 wmt_plat_ps_ctrl (ENUM_FUNC_STATE state)
 466 {
 467     return -1;
 468 }
 469
 470 INT32
 471 wmt_plat_eirq_ctrl (
 472     ENUM_PIN_ID id,
 473     ENUM_PIN_STATE state
 474     )
 475 {
 476     INT32 iRet;
 477     unsigned int flags;
 478     // TODO: [ChangeFeature][GeorgeKuo]: use another function to handle this, as done in gpio_ctrls
 479
 480     if ( (PIN_STA_INIT != state )
 481         && (PIN_STA_DEINIT != state )
 482         && (PIN_STA_EINT_EN != state )
 483         && (PIN_STA_EINT_DIS != state ) ) {
 484         iRet = -1;
 485         WMT_WARN_FUNC("WMT-PLAT:invalid PIN_STATE(%d) in eirq_ctrl for PIN(%d), ret(%d) \n", state, id, iRet);
 486         return iRet;
 487     }
 488
 489     iRet = -2;
 490     switch (id) {
 491     case PIN_BGF_EINT:
 492         if (PIN_STA_INIT == state) {
 493             /*request irq,low level triggered*/
 494         //iRet = request_irq(INT_6620, irq_handler,  IRQF_TRIGGER_LOW | IRQF_DISABLED, "MTK6620_BT", NULL);
 495
 496
 497             g_balance_flag = 1;//do not modify this value
 498             WMT_INFO_FUNC("WMT-PLAT:BGFInt (init) \n");
 499         }
 500         else if (PIN_STA_EINT_EN == state) {
 501             /*enable irq*/
 502             spin_lock_irqsave(&g_balance_lock,flags);
 503             if(g_balance_flag)
 504             {
 505                 /*if enter this case, the bgf eint has been enabled,so skip it.*/
 506                 WMT_INFO_FUNC("BGF_EINT has been enabled,g_balance_flag(%d)!\n",g_balance_flag);
 507             }
 508             else
 509             {
 510                 /*do real irq enable implement is this case*/
 511                     //enable_irq(INT_6620);
 512                 g_balance_flag++;
 513                 WMT_INFO_FUNC("WMT-PLAT:BGFInt (en),g_balance_flag(%d)\n",g_balance_flag);
 514             }
 515             spin_unlock_irqrestore(&g_balance_lock,flags);
 516         }
 517         else if (PIN_STA_EINT_DIS == state) {
 518             /*disable irq*/
 519             spin_lock_irqsave(&g_balance_lock,flags);
 520             if(!g_balance_flag)
 521             {
 522                 /*if enter this case, the bgf eint has been disabled,so skip it.*/
 523                 WMT_INFO_FUNC("BGF_EINT has been disabled,g_balance_flag(%d)!\n",g_balance_flag);
 524             }
 525             else
 526             {
 527                 /*do real irq disable implement is this case*/
 528                     //disable_irq_nosync(INT_6620);
 529                 g_balance_flag--;
 530                 WMT_INFO_FUNC("WMT-PLAT:BGFInt (dis) g_balance_flag(%d)\n",g_balance_flag);
 531             }
 532             spin_unlock_irqrestore(&g_balance_lock,flags);
 533         }
 534         else {
 535             /* de-init: free irq*/
 536             //free_irq(INT_6620,NULL);
 537             WMT_INFO_FUNC("WMT-PLAT:BGFInt (deinit) \n");
 538
 539         }
 540         iRet = 0;
 541         break;
 542
 543     case PIN_ALL_EINT:
 544 #if 0
 545         if (PIN_STA_INIT == state) {
 546
 547             WMT_DBG_FUNC("WMT-PLAT:ALLInt (INIT but not used yet) \n");
 548         }
 549         else if (PIN_STA_EINT_EN == state) {
 550              WMT_DBG_FUNC("WMT-PLAT:ALLInt (EN but not used yet) \n");
 551         }
 552         else if (PIN_STA_EINT_DIS == state) {
 553             WMT_DBG_FUNC("WMT-PLAT:ALLInt (DIS but not used yet) \n");
 554         }
 555         else {
 556
 557             WMT_DBG_FUNC("WMT-PLAT:ALLInt (DEINIT but not used yet) \n");
 558             /* de-init: nothing to do in ALPS, such as un-registration... */
 559         }
 560 #else
 561         WMT_DBG_FUNC("WMT-PLAT:ALLInt (not used yet) \n");
 562 #endif
 563         iRet = 0;
 564         break;
 565
 566     default:
 567         WMT_WARN_FUNC("WMT-PLAT:unsupported EIRQ(PIN_ID:%d) in eirq_ctrl, ret (%d)\n", id, iRet);
 568         iRet = -1;
 569         break;
 570     }
 571
 572     return iRet;
 573
 574 }
 575
 576 INT32 wmt_plat_gpio_ctrl (
 577     ENUM_PIN_ID id,
 578     ENUM_PIN_STATE state
 579     )
 580 {
 581     if ( (PIN_ID_MAX > id)
 582         && (PIN_STA_MAX > state) ) {
 583
 584         // TODO: [FixMe][GeorgeKuo] do sanity check to const function table when init and skip checking here
 585         if (gfp_set_pin_table[id]) {
 586             return (*(gfp_set_pin_table[id]))(state); /* .handler */
 587         }
 588         else {
 589             WMT_WARN_FUNC("WMT-PLAT: null fp for gpio_ctrl(%d)\n", id);
 590             return -2;
 591         }
 592     }
 593         WMT_ERR_FUNC("WMT-PLAT:[out of range] id(%d), state (%d)\n", id, state);
 594     return -1;
 595 }
 596
 597 INT32
 598 wmt_plat_ldo_ctrl (
 599     ENUM_PIN_STATE state
 600     )
 601 {
 602     switch(state)
 603     {
 604     case PIN_STA_INIT:
 605         /*set to gpio output low, disable pull*/
 606         WMT_DBG_FUNC("WMT-PLAT:LDO init (out 0) \n");
 607         break;
 608
 609     case PIN_STA_OUT_H:
 610         WMT_DBG_FUNC("WMT-PLAT:LDO (out 1) \n");
 611         break;
 612
 613     case PIN_STA_OUT_L:
 614         WMT_DBG_FUNC("WMT-PLAT:LDO (out 0) \n");
 615         break;
 616
 617     case PIN_STA_IN_L:
 618     case PIN_STA_DEINIT:
 619         /*set to gpio input low, pull down enable*/
 620         WMT_DBG_FUNC("WMT-PLAT:LDO deinit (in pd) \n");
 621         break;
 622
 623     default:
 624         WMT_WARN_FUNC("WMT-PLAT:Warnning, invalid state(%d) on LDO\n", state);
 625         break;
 626     }
 627     return 0;
 628 }
 629
 630 INT32
 631 wmt_plat_pmu_ctrl (
 632     ENUM_PIN_STATE state
 633     )
 634 {
 635     switch(state)
 636     {
 637     case PIN_STA_INIT:
 638         /*set to gpio output low, disable pull*/
 639
 640         printk("WMT-PLAT:PMU init (out 0) \n");
 641         break;
 642
 643     case PIN_STA_OUT_H:
 644
 645         printk("WMT-PLAT:PMU (out 1) \n");
 646         break;
 647
 648     case PIN_STA_OUT_L:
 649
 650         printk("WMT-PLAT:PMU (out 0) \n");
 651         break;
 652
 653     case PIN_STA_IN_L:
 654     case PIN_STA_DEINIT:
 655         /*set to gpio input low, pull down enable*/
 656
 657         printk("WMT-PLAT:PMU deinit (in pd) \n");
 658         break;
 659
 660     default:
 661         printk("WMT-PLAT:Warnning, invalid state(%d) on PMU\n", state);
 662         break;
 663     }
 664
 665     return 0;
 666 }
 667
 668 INT32
 669 wmt_plat_rtc_ctrl (
 670     ENUM_PIN_STATE state
 671     )
 672 {
 673     switch(state)
 674     {
 675     case PIN_STA_INIT:
 676         WMT_DBG_FUNC("WMT-PLAT:RTC init \n");
 677         break;
 678
 679     default:
 680         WMT_WARN_FUNC("WMT-PLAT:Warnning, invalid state(%d) on RTC\n", state);
 681         break;
 682     }
 683     return 0;
 684 }
 685
 686
 687 INT32
 688 wmt_plat_rst_ctrl (
 689     ENUM_PIN_STATE state
 690     )
 691 {
 692     switch(state)
 693     {
 694         case PIN_STA_INIT:
 695             /*set to gpio output low, disable pull*/
 696
 697             printk("WMT-PLAT:RST init (out 0) \n");
 698             break;
 699
 700         case PIN_STA_OUT_H:
 701
 702             printk("WMT-PLAT:RST (out 1) \n");
 703             break;
 704
 705         case PIN_STA_OUT_L:
 706
 707             printk("WMT-PLAT:RST (out 0) \n");
 708             break;
 709
 710         case PIN_STA_IN_L:
 711         case PIN_STA_DEINIT:
 712             /*set to gpio input low, pull down enable*/
 713
 714             printk("WMT-PLAT:RST deinit (in pd) \n");
 715             break;
 716
 717         default:
 718             printk("WMT-PLAT:Warnning, invalid state(%d) on RST\n", state);
 719             break;
 720     }
 721
 722     return 0;
 723 }
 724
 725 INT32
 726 wmt_plat_bgf_eint_ctrl (
 727     ENUM_PIN_STATE state
 728     )
 729 {
 730
 731     switch(state)
 732     {
 733         case PIN_STA_INIT:
 734             /*set to gpio input low, pull down eanble*/
 735
 736             WMT_DBG_FUNC("WMT-PLAT:BGFInt init(in pd) \n");
 737             break;
 738
 739         case PIN_STA_MUX:
 740             /* first: set to EINT mode,interrupt input, pull up enable*/
 741
 742             WMT_DBG_FUNC("WMT-PLAT:BGFInt mux (eint) \n");
 743
 744             /* second: enable bgf irq wake up host function*/
 745             do {
 746                 int iret;
 747                 //iret = enable_irq_wake(g_bgf_irq);//enable bgf irq wake up host function
 748                 //WMT_INFO_FUNC("enable_irq_wake(bgf:%d)++, ret(%d)\n", g_bgf_irq, iret);
 749             } while (0);
 750             break;
 751
 752         case PIN_STA_IN_L:
 753         case PIN_STA_DEINIT:
 754             /* first: disable bgf irq wake up host function*/
 755             do {
 756                 int iret;
 757                 //iret = disable_irq_wake(g_bgf_irq);//disable bgf irq wake up host function
 758                 if (iret) {
 759                     //WMT_WARN_FUNC("disable_irq_wake(bgf:%d) fail(%d)\n", g_bgf_irq, iret);
 760                     iret = 0;
 761                 }
 762                 else {
 763                     //WMT_INFO_FUNC("disable_irq_wake(bgf:%d)--, ret(%d)\n", g_bgf_irq, iret);
 764                 }
 765             } while (0);
 766
 767             /* second: set to gpio input low, pull down enable*/
 768             WMT_DBG_FUNC("WMT-PLAT:BGFInt deinit(in pd) \n");
 769             break;
 770
 771         default:
 772             WMT_WARN_FUNC("WMT-PLAT:Warnning, invalid state(%d) on BGF EINT\n", state);
 773             break;
 774     }
 775
 776     return 0;
 777 }
 778
 779
 780 INT32 wmt_plat_wifi_eint_ctrl(ENUM_PIN_STATE state)
 781 {
 782 #if 0
 783     switch(state)
 784     {
 785         case PIN_STA_INIT:
 786             break;
 787         case PIN_STA_MUX:
 788
 789             break;
 790         case PIN_STA_EINT_EN:
 791             break;
 792         case PIN_STA_EINT_DIS:
 793             break;
 794         case PIN_STA_IN_L:
 795         case PIN_STA_DEINIT:
 796             /*set to gpio input low, pull down enable*/
 797             break;
 798         default:
 799             WMT_WARN_FUNC("WMT-PLAT:Warnning, invalid state(%d) on WIFI EINT\n", state);
 800             break;
 801     }
 802 #else
 803     WMT_INFO_FUNC("WMT-PLAT:WIFI EINT is controlled by MSDC driver \n");
 804 #endif
 805     return 0;
 806 }
 807
 808
 809 INT32
 810 wmt_plat_all_eint_ctrl (
 811     ENUM_PIN_STATE state
 812     )
 813 {
 814     switch(state)
 815     {
 816         case PIN_STA_INIT:
 817                   /*set to gpio input low, pull down eanble*/
 818             WMT_DBG_FUNC("WMT-PLAT:ALLInt init(in pd) \n");
 819             break;
 820
 821         case PIN_STA_MUX:
 822                   /*set to gpio EINT mode, pull down enable*/
 823             break;
 824
 825         case PIN_STA_IN_L:
 826         case PIN_STA_DEINIT:
 827             /*set to gpio input low, pull down enable*/
 828             break;
 829
 830         default:
 831             WMT_WARN_FUNC("WMT-PLAT:Warnning, invalid state(%d) on ALL EINT\n", state);
 832             break;
 833     }
 834     return 0;
 835 }
 836
 837 INT32 wmt_plat_uart_ctrl(ENUM_PIN_STATE state)
 838 {
 839     switch(state)
 840     {
 841     case PIN_STA_MUX:
 842     case PIN_STA_INIT:
 843         WMT_DBG_FUNC("WMT-PLAT:UART init (mode_01, uart) \n");
 844         break;
 845     case PIN_STA_IN_L:
 846     case PIN_STA_DEINIT:
 847         WMT_DBG_FUNC("WMT-PLAT:UART deinit (out 0) \n");
 848         break;
 849
 850     default:
 851         WMT_WARN_FUNC("WMT-PLAT:Warnning, invalid state(%d) on UART Group\n", state);
 852         break;
 853     }
 854
 855     return 0;
 856 }
 857
 858
 859 INT32 wmt_plat_pcm_ctrl(ENUM_PIN_STATE state)
 860 {
 861     switch(state)
 862     {
 863     case PIN_STA_MUX:
 864     case PIN_STA_INIT:
 865           /*set to PCM function*/
 866         WMT_DBG_FUNC("WMT-PLAT:PCM init (pcm) \n");
 867         break;
 868
 869     case PIN_STA_IN_L:
 870     case PIN_STA_DEINIT:
 871         WMT_DBG_FUNC("WMT-PLAT:PCM deinit (out 0) \n");
 872         break;
 873
 874     default:
 875         WMT_WARN_FUNC("WMT-PLAT:Warnning, invalid state(%d) on PCM Group\n", state);
 876         break;
 877     }
 878     return 0;
 879 }
 880
 881
 882 INT32 wmt_plat_i2s_ctrl(ENUM_PIN_STATE state)
 883 {
 884 #ifndef FM_ANALOG_INPUT
 885     switch(state)
 886     {
 887     case PIN_STA_INIT:
 888     case PIN_STA_MUX:
 889     /*set to I2S function*/
 890         WMT_DBG_FUNC("WMT-PLAT:I2S init \n");
 891         break;
 892     case PIN_STA_IN_L:
 893     case PIN_STA_DEINIT:
 894     /*set to gpio input low, pull down enable*/
 895         WMT_DBG_FUNC("WMT-PLAT:I2S deinit (out 0) \n");
 896         break;
 897     default:
 898         WMT_WARN_FUNC("WMT-PLAT:Warnning, invalid state(%d) on I2S Group\n", state);
 899         break;
 900     }
 901 #else
 902         WMT_INFO_FUNC( "[MT6620]warnning:FM analog mode is set, no I2S GPIO settings should be modified by combo driver\n");
 903 #endif
 904
 905     return 0;
 906 }
 907
 908 INT32
 909 wmt_plat_sdio_pin_ctrl (
 910     ENUM_PIN_STATE state
 911     )
 912 {
 913     switch (state) {
 914     case PIN_STA_INIT:
 915     case PIN_STA_MUX:
 916         break;
 917     case PIN_STA_DEINIT:
 918         break;
 919     default:
 920         WMT_WARN_FUNC("WMT-PLAT:Warnning, invalid state(%d) on SDIO Group\n", state);
 921         break;
 922     }
 923     return 0;
 924 }
 925
 926 static INT32
 927 wmt_plat_gps_sync_ctrl (
 928     ENUM_PIN_STATE state
 929     )
 930 {
 931     switch (state) {
 932     case PIN_STA_INIT:
 933     case PIN_STA_DEINIT:
 934     /*set GPS_SYNC GPIO to GPIO mode, pull disable,output low*/
 935         break;
 936
 937     case PIN_STA_MUX:
 938     /*set GPS_SYNC GPIO to GPS_SYNC function*/
 939         break;
 940
 941     default:
 942         break;
 943     }
 944     return 0;
 945 }
 946
 947
 948 static INT32
 949 wmt_plat_gps_lna_ctrl (
 950         ENUM_PIN_STATE state
 951         )
 952 {
 953     switch (state) {
 954     case PIN_STA_INIT:
 955     case PIN_STA_DEINIT:
 956     /*set GPS_LNA GPIO to GPIO mode, pull disable,output low*/
 957         break;
 958     case PIN_STA_OUT_H:
 959     /*set GPS_LNA GPIO to GPIO mode, pull disable,output high*/
 960         break;
 961     case PIN_STA_OUT_L:
 962     /*set GPS_LNA GPIO to GPIO mode, pull disable,output low*/
 963         break;
 964
 965     default:
 966         WMT_WARN_FUNC("%d mode not defined for  gps lna pin !!!\n", state);
 967         break;
 968     }
 969     return 0;
 970
 971 }
 972
 973
 974
 975 INT32 wmt_plat_wake_lock_ctrl(ENUM_WL_OP opId)
 976 {
 977 #ifdef CFG_WMT_WAKELOCK_SUPPORT
 978     static INT32 counter = 0;
 979
 980
 981     osal_lock_sleepable_lock( &gOsSLock);
 982     if (WL_OP_GET == opId)
 983     {
 984         ++counter;
 985     }else if (WL_OP_PUT == opId)
 986     {
 987         --counter;
 988     }
 989     osal_unlock_sleepable_lock( &gOsSLock);
 990     if (WL_OP_GET == opId && counter == 1)
 991     {
 992         wake_lock(&wmtWakeLock);
 993         WMT_DBG_FUNC("WMT-PLAT: after wake_lock(%d), counter(%d)\n", wake_lock_active(&wmtWakeLock), counter);
 994
 995     }
 996     else if (WL_OP_PUT == opId && counter == 0)
 997     {
 998         wake_unlock(&wmtWakeLock);
 999         WMT_DBG_FUNC("WMT-PLAT: after wake_unlock(%d), counter(%d)\n", wake_lock_active(&wmtWakeLock), counter);
1000     }
1001     else
1002     {
1003         WMT_WARN_FUNC("WMT-PLAT: wakelock status(%d), counter(%d)\n", wake_lock_active(&wmtWakeLock), counter);
1004     }
1005     return 0;
1006 #else
1007     WMT_WARN_FUNC("WMT-PLAT: host awake function is not supported.");
1008     return 0;
1009
1010 #endif
1011 }
1012