INT32 mtk_wcn_cmb_hw_deinit(VOID) { WMT_WARN_FUNC ("mtk_wcn_cmb_hw_deinit start, set to default hw init sequence parameters\n"); gPwrSeqTime.ldoStableTime = DFT_LDO_STABLE_TIME; gPwrSeqTime.offStableTime = DFT_OFF_STABLE_TIME; gPwrSeqTime.onStableTime = DFT_ON_STABLE_TIME; gPwrSeqTime.rstStableTime = DFT_RST_STABLE_TIME; gPwrSeqTime.rtcStableTime = DFT_RTC_STABLE_TIME; WMT_WARN_FUNC("mtk_wcn_cmb_hw_deinit finish\n"); return 0; }
INT32 wmt_ctrl_tx_ex ( const UINT8 *pData, const UINT32 size, UINT32 *writtenSize, const MTK_WCN_BOOL bRawFlag ) { P_DEV_WMT pDev = &gDevWmt; /* single instance */ INT32 iRet; if (NULL != writtenSize) { *writtenSize = 0; } /* sanity check */ if (0 == size) { WMT_WARN_FUNC("size to tx is 0\n"); osal_assert(size); return -1; } /* if STP is not enabled yet, can't use this function. Use tx_raw instead */ if ( !osal_test_bit(WMT_STAT_STP_OPEN, &pDev->state) || !osal_test_bit(WMT_STAT_STP_EN, &pDev->state) ) { WMT_ERR_FUNC("wmt state(0x%lx) \n", pDev->state); osal_assert(osal_test_bit(WMT_STAT_STP_EN, &pDev->state)); osal_assert(osal_test_bit(WMT_STAT_STP_OPEN, &pDev->state)); return -2; } /* sanity ok, proceeding tx operation */ /*retval = mtk_wcn_stp_send_data(data, size, WMTDRV_TYPE_WMT);*/ mtk_wcn_stp_flush_rx_queue(WMT_TASK_INDX); if (bRawFlag) { iRet = mtk_wcn_stp_send_data_raw(pData, size, WMT_TASK_INDX); } else { iRet = mtk_wcn_stp_send_data(pData, size, WMT_TASK_INDX); } if (iRet != size){ WMT_WARN_FUNC("write(%d) written(%d)\n", size, iRet); osal_assert(iRet == size); } if (writtenSize) { *writtenSize = iRet; } return 0; }
static MTK_WCN_BOOL mtk_wcn_wmt_func_ctrl ( ENUM_WMTDRV_TYPE_T type, ENUM_WMT_OPID_T opId ) { P_OSAL_OP pOp; MTK_WCN_BOOL bRet; P_OSAL_SIGNAL pSignal; pOp = wmt_lib_get_free_op(); if (!pOp) { WMT_WARN_FUNC("get_free_lxop fail\n"); return MTK_WCN_BOOL_FALSE; } pSignal = &pOp->signal; pOp->op.opId = opId; pOp->op.au4OpData[0] = type; pSignal->timeoutValue= (WMT_OPID_FUNC_ON == pOp->op.opId) ? MAX_FUNC_ON_TIME : MAX_FUNC_OFF_TIME; WMT_INFO_FUNC("OPID(%d) type(%d) start\n", pOp->op.opId, pOp->op.au4OpData[0]); /*do not check return value, we will do this either way*/ wmt_lib_host_awake_get(); /*wake up chip first*/ if (DISABLE_PSM_MONITOR()) { WMT_ERR_FUNC("wake up failed\n"); wmt_lib_put_op_to_free_queue(pOp); return MTK_WCN_BOOL_FALSE; } bRet = wmt_lib_put_act_op(pOp); ENABLE_PSM_MONITOR(); wmt_lib_host_awake_put(); if (MTK_WCN_BOOL_FALSE == bRet) { WMT_WARN_FUNC("OPID(%d) type(%d) fail\n", pOp->op.opId, pOp->op.au4OpData[0]); } else{ WMT_INFO_FUNC("OPID(%d) type(%d) ok\n", pOp->op.opId, pOp->op.au4OpData[0]); } return bRet; }
INT32 wmt_plat_eirq_ctrl ( ENUM_PIN_ID id, ENUM_PIN_STATE state ) { INT32 iRet = 0; // TODO: [ChangeFeature][GeorgeKuo]: use another function to handle this, as done in gpio_ctrls if ( (PIN_STA_INIT != state ) && (PIN_STA_DEINIT != state ) && (PIN_STA_EINT_EN != state ) && (PIN_STA_EINT_DIS != state ) ) { iRet = -1; WMT_WARN_FUNC("WMT-PLAT:invalid PIN_STATE(%d) in eirq_ctrl for PIN(%d), ret(%d) \n", state, id, iRet); return iRet; } switch (id) { case PIN_BGF_EINT: if (PIN_STA_INIT == state) { iRet = request_irq(g_bgf_irq, bgf_irq_handler, IRQF_TRIGGER_LOW | IRQF_DISABLED, "MTK6620_BT", NULL); if (iRet) { WMT_INFO_FUNC("WMT-PLAT: request IRQ fail for BGF IRQ : %d\n", g_bgf_irq); } else { enable_irq_wake(g_bgf_irq); } WMT_INFO_FUNC("WMT-PLAT:BGF Int requested...%s, iRet=%d\n", iRet?"fail":"success.", iRet); } else if (PIN_STA_EINT_EN == state) { enable_irq(g_bgf_irq); } else if (PIN_STA_EINT_DIS == state) { disable_irq_nosync(g_bgf_irq); } else { disable_irq_wake(g_bgf_irq); free_irq(g_bgf_irq,NULL); WMT_INFO_FUNC("WMT-PLAT:BGFInt (deinit) \n"); } break; case PIN_ALL_EINT: break; case PIN_WIFI_EINT: break; default: WMT_WARN_FUNC("WMT-PLAT:unsupported EIRQ(PIN_ID:%d) in eirq_ctrl\n", id); break; } return iRet; }
static INT32 wmt_plat_gps_lna_ctrl ( ENUM_PIN_STATE state ) { switch (state) { case PIN_STA_INIT: aml_gpio_enable_mtk (MTK_GPS_LNA); case PIN_STA_DEINIT: /*set GPS_LNA GPIO to GPIO mode, pull disable,output low*/ aml_gpio_init_configure_mtk(MTK_GPS_LNA,0); aml_gpio_input_mtk(MTK_GPS_LNA); break; case PIN_STA_OUT_H: /*set GPS_LNA GPIO to GPIO mode, pull disable,output high*/ aml_gpio_init_configure_mtk(MTK_GPS_LNA,1); break; case PIN_STA_OUT_L: /*set GPS_LNA GPIO to GPIO mode, pull disable,output low*/ aml_gpio_init_configure_mtk(MTK_GPS_LNA,0); break; default: WMT_WARN_FUNC("%d mode not defined for gps lna pin !!!\n", state); break; } return 0; }
INT32 mtk_wcn_cmb_hw_init ( P_PWR_SEQ_TIME pPwrSeqTime ) { if (NULL != pPwrSeqTime && pPwrSeqTime->ldoStableTime > 0 && pPwrSeqTime->rtcStableTime > 0 && pPwrSeqTime->offStableTime > DFT_OFF_STABLE_TIME && pPwrSeqTime->onStableTime > DFT_ON_STABLE_TIME && pPwrSeqTime->rstStableTime > DFT_RST_STABLE_TIME ) { /*memcpy may be more performance*/ WMT_DBG_FUNC("setting hw init sequence parameters\n"); osal_memcpy(&gPwrSeqTime, pPwrSeqTime, osal_sizeof(gPwrSeqTime)); } else { WMT_WARN_FUNC("invalid pPwrSeqTime parameter, use default hw init sequence parameters\n"); gPwrSeqTime.ldoStableTime = DFT_LDO_STABLE_TIME; gPwrSeqTime.offStableTime = DFT_OFF_STABLE_TIME; gPwrSeqTime.onStableTime = DFT_ON_STABLE_TIME; gPwrSeqTime.rstStableTime = DFT_RST_STABLE_TIME; gPwrSeqTime.rtcStableTime = DFT_RTC_STABLE_TIME; } mtk_wcn_cmb_hw_dmp_seq(); return 0; }
INT32 wmt_plat_pwr_ctrl(ENUM_FUNC_STATE state) { INT32 ret = -1; switch (state) { case FUNC_ON: /* TODO:[ChangeFeature][George] always output this or by request throuth /proc or sysfs? */ wmt_plat_dump_pin_conf(); ret = mtk_wcn_cmb_hw_pwr_on(); break; case FUNC_OFF: ret = mtk_wcn_cmb_hw_pwr_off(); break; case FUNC_RST: ret = mtk_wcn_cmb_hw_rst(); break; default: WMT_WARN_FUNC ("WMT-PLAT:Warnning, invalid state(%d) in pwr_ctrl\n", state); break; } return ret; }
INT32 wmt_plat_ldo_ctrl(ENUM_PIN_STATE state) { switch (state) { case PIN_STA_INIT: /*set to gpio output low, disable pull*/ WMT_DBG_FUNC("WMT-PLAT:LDO init (out 0) \n"); break; case PIN_STA_OUT_H: WMT_DBG_FUNC("WMT-PLAT:LDO (out 1) \n"); break; case PIN_STA_OUT_L: WMT_DBG_FUNC("WMT-PLAT:LDO (out 0) \n"); break; case PIN_STA_IN_L: case PIN_STA_DEINIT: /*set to gpio input low, pull down enable*/ WMT_DBG_FUNC("WMT-PLAT:LDO deinit (in pd) \n"); break; default: WMT_WARN_FUNC("WMT-PLAT:Warnning, invalid state(%d) on LDO\n", state); break; } return 0; }
INT32 wmt_plat_all_eint_ctrl(ENUM_PIN_STATE state) { switch (state) { case PIN_STA_INIT: /*set to gpio input low, pull down eanble*/ WMT_DBG_FUNC("WMT-PLAT:ALLInt init(in pd) \n"); break; case PIN_STA_MUX: /*set to gpio EINT mode, pull down enable*/ break; case PIN_STA_IN_L: case PIN_STA_DEINIT: /*set to gpio input low, pull down enable*/ break; default: WMT_WARN_FUNC ("WMT-PLAT:Warnning, invalid state(%d) on ALL EINT\n", state); break; } return 0; }
INT32 wmt_plat_uart_ctrl(ENUM_PIN_STATE state) { switch(state) { case PIN_STA_MUX: case PIN_STA_INIT: mt_set_gpio_mode(GPIO_COMBO_URXD_PIN, GPIO_COMBO_URXD_PIN_M_URXD); mt_set_gpio_mode(GPIO_COMBO_UTXD_PIN, GPIO_COMBO_UTXD_PIN_M_UTXD); WMT_DBG_FUNC("WMT-PLAT:UART init (mode_01, uart) \n"); break; case PIN_STA_IN_L: case PIN_STA_DEINIT: mt_set_gpio_mode(GPIO_COMBO_URXD_PIN, GPIO_COMBO_URXD_PIN_M_GPIO); mt_set_gpio_dir(GPIO_COMBO_URXD_PIN, GPIO_DIR_OUT); mt_set_gpio_out(GPIO_COMBO_URXD_PIN, GPIO_OUT_ZERO); mt_set_gpio_mode(GPIO_COMBO_UTXD_PIN, GPIO_COMBO_UTXD_PIN_M_GPIO); mt_set_gpio_dir(GPIO_COMBO_UTXD_PIN, GPIO_DIR_OUT); mt_set_gpio_out(GPIO_COMBO_UTXD_PIN, GPIO_OUT_ZERO); WMT_DBG_FUNC("WMT-PLAT:UART deinit (out 0) \n"); break; case PIN_STA_IN_PU: mt_set_gpio_mode(GPIO_COMBO_URXD_PIN, GPIO_COMBO_URXD_PIN_M_GPIO); mt_set_gpio_dir(GPIO_COMBO_URXD_PIN, GPIO_DIR_IN); mt_set_gpio_pull_enable(GPIO_COMBO_URXD_PIN, GPIO_PULL_ENABLE); mt_set_gpio_pull_select(GPIO_COMBO_URXD_PIN, GPIO_PULL_UP); default: WMT_WARN_FUNC("WMT-PLAT:Warnning, invalid state(%d) on UART Group\n", state); break; } return 0; }
INT32 wmt_plat_i2s_ctrl(ENUM_PIN_STATE state) { #ifndef FM_ANALOG_INPUT switch (state) { case PIN_STA_INIT: case PIN_STA_MUX: /*set to I2S function*/ WMT_DBG_FUNC("WMT-PLAT:I2S init \n"); break; case PIN_STA_IN_L: case PIN_STA_DEINIT: /*set to gpio input low, pull down enable*/ WMT_DBG_FUNC("WMT-PLAT:I2S deinit (out 0) \n"); break; default: WMT_WARN_FUNC ("WMT-PLAT:Warnning, invalid state(%d) on I2S Group\n", state); break; } #else WMT_INFO_FUNC ("[MT6620]warnning:FM analog mode is set, no I2S GPIO settings should be modified by combo driver\n"); #endif return 0; }
INT32 wmt_ctrl_stp_conf(P_WMT_CTRL_DATA pWmtCtrlData) { INT32 iRet = -1; P_DEV_WMT pDev = &gDevWmt; /* single instance */ UINT32 type; UINT32 value; if (!osal_test_bit(WMT_STAT_STP_OPEN, &pDev->state)) { WMT_WARN_FUNC("CTRL_STP_ENABLE but invalid Handle of WmtStp \n"); return -1; } type = pWmtCtrlData->au4CtrlData[0]; value = pWmtCtrlData->au4CtrlData[1]; iRet = wmt_ctrl_stp_conf_ex(type, value); if (!iRet) { if (WMT_STP_CONF_EN == type) { if (value) { osal_set_bit(WMT_STAT_STP_EN, &pDev->state); WMT_DBG_FUNC("enable STP\n"); } else { osal_clear_bit(WMT_STAT_STP_EN, &pDev->state); WMT_DBG_FUNC("disable STP\n"); } } } return iRet; }
ssize_t WMT_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos) { INT32 iRet = 0; UINT8 wrBuf[NAME_MAX + 1] = { 0 }; INT32 copySize = (count < NAME_MAX) ? count : NAME_MAX; WMT_LOUD_FUNC("count:%d copySize:%d\n", count, copySize); if (copySize > 0) { if (copy_from_user(wrBuf, buf, copySize)) { iRet = -EFAULT; goto write_done; } iRet = copySize; wrBuf[NAME_MAX] = '\0'; if (!strncasecmp(wrBuf, "ok", NAME_MAX)) { WMT_DBG_FUNC("resp str ok\n"); /* pWmtDevCtx->cmd_result = 0; */ wmt_lib_trigger_cmd_signal(0); } else { WMT_WARN_FUNC("warning resp str (%s)\n", wrBuf); /* pWmtDevCtx->cmd_result = -1; */ wmt_lib_trigger_cmd_signal(-1); } /* complete(&pWmtDevCtx->cmd_comp); */ } write_done: return iRet; }
static int WMT_open(struct inode *inode, struct file *file) { long ret; WMT_INFO_FUNC("major %d minor %d (pid %d)\n", imajor(inode), iminor(inode), current->pid ); ret = wait_event_timeout(gWmtInitWq, gWmtInitDone != 0, msecs_to_jiffies(WMT_DEV_INIT_TO_MS)); if (!ret) { WMT_WARN_FUNC("wait wmt init timeout (%d)ms (%d)jiffies, return -EIO\n", WMT_DEV_INIT_TO_MS, msecs_to_jiffies(WMT_DEV_INIT_TO_MS)); return -EIO; } if (atomic_inc_return(&gWmtRefCnt) == 1) { WMT_INFO_FUNC("1st call (%d)\n", ret); } return 0; }
INT32 wmt_ctrl_host_baudrate_set(P_WMT_CTRL_DATA pWmtCtrlData) { INT32 iRet = -1; char cmdStr[NAME_MAX + 1] = {0}; UINT32 u4Baudrate = pWmtCtrlData->au4CtrlData[0]; UINT32 u4FlowCtrl = pWmtCtrlData->au4CtrlData[1]; WMT_DBG_FUNC("baud(%d), flowctrl(%d) \n", u4Baudrate, u4FlowCtrl); if (osal_test_bit(WMT_STAT_STP_OPEN, &gDevWmt.state)) { osal_snprintf(cmdStr, NAME_MAX, "baud_%d_%d", u4Baudrate, u4FlowCtrl); iRet = wmt_ctrl_ul_cmd(&gDevWmt, cmdStr); if (iRet) { WMT_WARN_FUNC("CTRL_BAUDRATE baud(%d), flowctrl(%d) fail(%d) \n", u4Baudrate, pWmtCtrlData->au4CtrlData[1], iRet); } else { WMT_DBG_FUNC("CTRL_BAUDRATE baud(%d), flowctrl(%d) ok\n", u4Baudrate, u4FlowCtrl); } } else { WMT_INFO_FUNC("CTRL_BAUDRATE but invalid Handle of WmtStp \n"); } return iRet; }
static void WMT_exit (void) { dev_t dev = MKDEV(gWmtMajor, 0); #if defined(CONFIG_THERMAL) && defined(CONFIG_THERMAL_OPEN) wmt_tm_deinit_rt(); wmt_tm_deinit(); #endif wmt_lib_deinit(); #if CFG_WMT_DBG_SUPPORT wmt_dev_dbg_remove(); #endif cdev_del(&gWmtCdev); unregister_chrdev_region(dev, WMT_DEV_NUM); gWmtMajor = -1; #ifdef MTK_WMT_WAKELOCK_SUPPORT WMT_WARN_FUNC("destroy func_on_off_wake_lock\n"); wake_lock_destroy(&func_on_off_wake_lock); #endif stp_drv_exit(); WMT_INFO_FUNC("done\n"); }
INT32 wmt_plat_wifi_eint_ctrl(ENUM_PIN_STATE state) { #if 0 switch (state) { case PIN_STA_INIT: break; case PIN_STA_MUX: break; case PIN_STA_EINT_EN: break; case PIN_STA_EINT_DIS: break; case PIN_STA_IN_L: case PIN_STA_DEINIT: /*set to gpio input low, pull down enable*/ break; default: WMT_WARN_FUNC ("WMT-PLAT:Warnning, invalid state(%d) on WIFI EINT\n", state); break; } #else WMT_INFO_FUNC("WMT-PLAT:WIFI EINT is controlled by MSDC driver \n"); #endif return 0; }
static INT32 wmt_plat_gps_lna_ctrl ( ENUM_PIN_STATE state ) { #ifdef GPIO_GPS_LNA_PIN switch (state) { case PIN_STA_INIT: case PIN_STA_DEINIT: mt_set_gpio_pull_enable(GPIO_GPS_LNA_PIN, GPIO_PULL_DISABLE); mt_set_gpio_dir(GPIO_GPS_LNA_PIN, GPIO_DIR_OUT); mt_set_gpio_mode(GPIO_GPS_LNA_PIN, GPIO_GPS_LNA_PIN_M_GPIO); mt_set_gpio_out(GPIO_GPS_LNA_PIN, GPIO_OUT_ZERO); break; case PIN_STA_OUT_H: mt_set_gpio_out(GPIO_GPS_LNA_PIN, GPIO_OUT_ONE); break; case PIN_STA_OUT_L: mt_set_gpio_out(GPIO_GPS_LNA_PIN, GPIO_OUT_ZERO); break; default: WMT_WARN_FUNC("%d mode not defined for gps lna pin !!!\n", state); break; } return 0; #else WMT_WARN_FUNC("host gps lna pin not defined!!!\n") return 0; #endif }
INT8 mtk_wcn_wmt_therm_ctrl(ENUM_WMTTHERM_TYPE_T eType) #endif { P_OSAL_OP pOp; P_WMT_OP pOpData; MTK_WCN_BOOL bRet; P_OSAL_SIGNAL pSignal; /*parameter validation check */ if (WMTTHERM_MAX < eType || WMTTHERM_ENABLE > eType) { WMT_ERR_FUNC("invalid thermal control command (%d)\n", eType); return MTK_WCN_BOOL_FALSE; } /*check if chip support thermal control function or not */ bRet = wmt_lib_is_therm_ctrl_support(); if (MTK_WCN_BOOL_FALSE == bRet) { WMT_DBG_FUNC("thermal ctrl function not supported\n"); return MTK_WCN_BOOL_FALSE; } pOp = wmt_lib_get_free_op(); if (!pOp) { WMT_DBG_FUNC("get_free_lxop fail\n"); return MTK_WCN_BOOL_FALSE; } pSignal = &pOp->signal; pOpData = &pOp->op; pOpData->opId = WMT_OPID_THERM_CTRL; /*parameter fill */ pOpData->au4OpData[0] = eType; pSignal->timeoutValue = MAX_EACH_WMT_CMD; WMT_DBG_FUNC("OPID(%d) type(%d) start\n", pOp->op.opId, pOp->op.au4OpData[0]); if (DISABLE_PSM_MONITOR()) { WMT_ERR_FUNC("wake up failed\n"); wmt_lib_put_op_to_free_queue(pOp); return -1; } bRet = wmt_lib_put_act_op(pOp); ENABLE_PSM_MONITOR(); if (MTK_WCN_BOOL_FALSE == bRet) { WMT_WARN_FUNC("OPID(%d) type(%d) fail\n\n", pOpData->opId, pOpData->au4OpData[0]); /*0xFF means read error occurs */ pOpData->au4OpData[1] = (eType == WMTTHERM_READ) ? 0xFF : MTK_WCN_BOOL_FALSE; /*will return to function driver */ } else { WMT_DBG_FUNC("OPID(%d) type(%d) return(%d) ok\n\n", pOpData->opId, pOpData->au4OpData[0], pOpData->au4OpData[1]); } /*return value will be put to lxop->op.au4OpData[1] */ WMT_DBG_FUNC("therm ctrl type(%d), iRet(0x%08x)\n", eType, pOpData->au4OpData[1]); return (INT8) pOpData->au4OpData[1]; }
INT32 mtk_wcn_consys_stp_btif_parser_wmt_evt(const UINT8 *str, UINT32 len) { if (!stpBtifId) { WMT_WARN_FUNC("NULL BTIF ID reference!\n"); return -1; } else { return (INT32) mtk_wcn_btif_parser_wmt_evt(stpBtifId, str, len); } }
INT32 mtk_wcn_consys_stp_btif_rx_cb_register(MTK_WCN_BTIF_RX_CB rx_cb) { INT32 iRet = 0; if (!stpBtifId) { WMT_WARN_FUNC("NULL BTIF ID reference\n!"); iRet = -1; } else { iRet = mtk_wcn_btif_rx_cb_register(stpBtifId, rx_cb); if (iRet) { WMT_WARN_FUNC("STP register rxcb to btif fail(%d)\n", iRet); iRet = -2; } else { WMT_DBG_FUNC("STP register rxcb to btif OK\n"); } } return iRet; }
INT32 wmt_ctrl_sdio_hw(P_WMT_CTRL_DATA pWmtCtrlData) { INT32 iRet = 0; UINT32 statBit = WMT_STAT_SDIO1_ON; P_DEV_WMT pDev = &gDevWmt; /* single instance */ WMT_SDIO_SLOT_NUM sdioSlotNum = pWmtCtrlData->au4CtrlData[0]; ENUM_FUNC_STATE funcState = pWmtCtrlData->au4CtrlData[1]; if ((WMT_SDIO_SLOT_INVALID == sdioSlotNum) || (WMT_SDIO_SLOT_MAX <= sdioSlotNum)) { WMT_WARN_FUNC("CTRL_SDIO_SLOT(%d) but invalid slot num \n", sdioSlotNum); return -1; } WMT_DBG_FUNC("WMT_CTRL_SDIO_HW (0x%x, %d)\n", sdioSlotNum, funcState); if (WMT_SDIO_SLOT_SDIO2 == sdioSlotNum) { statBit = WMT_STAT_SDIO2_ON; } if (funcState) { if (osal_test_and_set_bit(statBit, &pDev->state)) { WMT_WARN_FUNC("CTRL_SDIO_SLOT slotNum(%d) already ON \n", sdioSlotNum); //still return 0 iRet = 0; } else { iRet = wmt_plat_sdio_ctrl(sdioSlotNum, FUNC_ON); } } else { if (osal_test_and_clear_bit(statBit, &pDev->state)) { iRet = wmt_plat_sdio_ctrl(sdioSlotNum, FUNC_OFF); } else { WMT_WARN_FUNC("CTRL_SDIO_SLOT slotNum(%d) already OFF \n", sdioSlotNum); //still return 0 iRet = 0; } } return iRet; }
INT32 mtk_wcn_consys_stp_btif_logger_ctrl(ENUM_BTIF_DBG_ID flag) { INT32 iRet = 0; if (!stpBtifId) { WMT_WARN_FUNC("NULL BTIF ID reference!\n"); iRet = -1; } else { iRet = mtk_wcn_btif_dbg_ctrl(stpBtifId, flag); if (iRet) { WMT_WARN_FUNC("STP btif log dbg ctrl fail(%d)\n", iRet); iRet = -2; } else { WMT_INFO_FUNC("stp btif log dbg ctrl ok,flag(%d)\n", flag); } } return iRet; }
INT32 mtk_wcn_consys_stp_btif_close(VOID) { INT32 iRet = 0; if (!stpBtifId) { WMT_WARN_FUNC("NULL BTIF ID reference!\n"); iRet = -1; } else { iRet = mtk_wcn_btif_close(stpBtifId); if (iRet) { WMT_WARN_FUNC("STP close btif fail(%d)\n", iRet); iRet = -2; } else { stpBtifId = 0; WMT_DBG_FUNC("STP close btif OK\n"); } } return iRet; }
INT32 mtk_wcn_consys_stp_btif_wakeup(VOID) { INT32 iRet = 0; if (!stpBtifId) { WMT_WARN_FUNC("NULL BTIF ID reference!\n"); iRet = -1; } else { iRet = mtk_wcn_btif_wakeup_consys(stpBtifId); if (iRet) { WMT_WARN_FUNC("STP btif wakeup consys fail(%d)\n", iRet); iRet = -2; } else { WMT_DBG_FUNC("STP btif wakeup consys ok\n"); } } return iRet; }
INT32 mtk_wcn_consys_stp_btif_lpbk_ctrl(ENUM_BTIF_LPBK_MODE mode) { INT32 iRet = 0; if (!stpBtifId) { WMT_WARN_FUNC("NULL BTIF ID reference!\n"); iRet = -1; } else { iRet = mtk_wcn_btif_loopback_ctrl(stpBtifId, mode); if (iRet) { WMT_WARN_FUNC("STP btif lpbk ctrl fail(%d)\n", iRet); iRet = -2; } else { WMT_INFO_FUNC("stp btif lpbk ctrl ok,mode(%d)\n", mode); } } return iRet; }
INT32 wmt_plat_wake_lock_ctrl(ENUM_WL_OP opId) { #ifdef CFG_WMT_WAKELOCK_SUPPORT static INT32 counter = 0; INT32 ret = 0; ret = osal_lock_sleepable_lock( &gOsSLock); if (ret) { WMT_ERR_FUNC("--->lock gOsSLock failed, ret=%d\n", ret); return ret; } if (WL_OP_GET == opId) { ++counter; }else if (WL_OP_PUT == opId) { --counter; } osal_unlock_sleepable_lock( &gOsSLock); if (WL_OP_GET == opId && counter == 1) { wake_lock(&wmtWakeLock); WMT_DBG_FUNC("WMT-PLAT: after wake_lock(%d), counter(%d)\n", wake_lock_active(&wmtWakeLock), counter); } else if (WL_OP_PUT == opId && counter == 0) { wake_unlock(&wmtWakeLock); WMT_DBG_FUNC("WMT-PLAT: after wake_unlock(%d), counter(%d)\n", wake_lock_active(&wmtWakeLock), counter); } else { WMT_WARN_FUNC("WMT-PLAT: wakelock status(%d), counter(%d)\n", wake_lock_active(&wmtWakeLock), counter); } return 0; #else WMT_WARN_FUNC("WMT-PLAT: host awake function is not supported."); return 0; #endif }
MTK_WCN_BOOL mtk_wcn_wmt_dsns_ctrl(ENUM_WMTDSNS_TYPE_T eType) #endif { P_OSAL_OP pOp; P_WMT_OP pOpData; MTK_WCN_BOOL bRet; P_OSAL_SIGNAL pSignal; if (WMTDSNS_MAX <= eType) { WMT_ERR_FUNC("invalid desense control command (%d)\n", eType); return MTK_WCN_BOOL_FALSE; } /*check if chip support thermal control function or not */ bRet = wmt_lib_is_dsns_ctrl_support(); if (MTK_WCN_BOOL_FALSE == bRet) { WMT_ERR_FUNC("thermal ctrl function not supported\n"); return MTK_WCN_BOOL_FALSE; } pOp = wmt_lib_get_free_op(); if (!pOp) { WMT_DBG_FUNC("get_free_lxop fail\n"); return MTK_WCN_BOOL_FALSE; } pSignal = &pOp->signal; pOpData = &pOp->op; pOpData->opId = WMT_OPID_DSNS; pSignal->timeoutValue = MAX_EACH_WMT_CMD; /*parameter fill */ if ((WMTDSNS_FM_DISABLE <= eType) && (WMTDSNS_FM_GPS_ENABLE >= eType)) { pOpData->au4OpData[0] = WMTDRV_TYPE_FM; pOpData->au4OpData[1] = eType; } WMT_INFO_FUNC("OPID(%d) type(%d) start\n", pOp->op.opId, pOp->op.au4OpData[0]); if (DISABLE_PSM_MONITOR()) { WMT_ERR_FUNC("wake up failed\n"); wmt_lib_put_op_to_free_queue(pOp); return MTK_WCN_BOOL_FALSE; } bRet = wmt_lib_put_act_op(pOp); ENABLE_PSM_MONITOR(); if (MTK_WCN_BOOL_FALSE == bRet) { WMT_WARN_FUNC("OPID(%d) type(%d) fail\n\n", pOpData->opId, pOpData->au4OpData[0]); } else { WMT_INFO_FUNC("OPID(%d) type(%d) ok\n\n", pOpData->opId, pOpData->au4OpData[0]); } return bRet; }
static INT32 mtk_wmt_func_off_background(void) { if (MTK_WCN_BOOL_FALSE == mtk_wcn_wmt_func_off(WMTDRV_TYPE_LPBK)) { WMT_WARN_FUNC("WMT turn off LPBK fail\n"); } else { WMT_INFO_FUNC("WMT turn off LPBK suceed"); } return 0; }
static INT32 wmt_plat_gps_lna_ctrl(ENUM_PIN_STATE state) { #ifdef GPIO_GPS_LNA_PIN switch (state) { case PIN_STA_INIT: case PIN_STA_DEINIT: mt_set_gpio_pull_enable(GPIO_GPS_LNA_PIN, GPIO_PULL_DISABLE); mt_set_gpio_dir(GPIO_GPS_LNA_PIN, GPIO_DIR_OUT); mt_set_gpio_mode(GPIO_GPS_LNA_PIN, GPIO_GPS_LNA_PIN_M_GPIO); mt_set_gpio_out(GPIO_GPS_LNA_PIN, GPIO_OUT_ZERO); break; case PIN_STA_OUT_H: mt_set_gpio_out(GPIO_GPS_LNA_PIN, GPIO_OUT_ONE); break; case PIN_STA_OUT_L: mt_set_gpio_out(GPIO_GPS_LNA_PIN, GPIO_OUT_ZERO); break; default: WMT_WARN_FUNC("%d mode not defined for gps lna pin !!!\n", state); break; } return 0; #else #ifdef CONFIG_MTK_MT6306_SUPPORT WMT_WARN_FUNC("/******************************************************************/\n"); WMT_WARN_FUNC("use MT6306 GPIO7 for gps lna pin.\n this HARD CODE may hurt other system module, if GPIO7 of MT6306 is not defined as GPS_LNA function\n"); WMT_WARN_FUNC("/******************************************************************/\n"); switch (state) { case PIN_STA_INIT: case PIN_STA_DEINIT: mt6306_set_gpio_dir (GPIO7, GPIO_DIR_OUT); mt6306_set_gpio_out (GPIO7, GPIO_OUT_ZERO); break; case PIN_STA_OUT_H: mt6306_set_gpio_out (GPIO7, GPIO_OUT_ONE); break; case PIN_STA_OUT_L: mt6306_set_gpio_out (GPIO7, GPIO_OUT_ZERO); break; default: WMT_WARN_FUNC("%d mode not defined for gps lna pin !!!\n", state); break; } #else WMT_WARN_FUNC("host gps lna pin not defined!!!\n"); WMT_WARN_FUNC("if you donot use eighter AP or MT6306's pin as GPS_LNA, please customize your own GPS_LNA related code here\n"); #endif return 0; #endif }