Exemplo n.º 1
0
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;
}
Exemplo n.º 2
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;
}
Exemplo n.º 4
0
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;

}
Exemplo n.º 6
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;
}
Exemplo n.º 7
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;
}
Exemplo n.º 8
0
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;
}
Exemplo n.º 9
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;
}
Exemplo n.º 10
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;
}
Exemplo n.º 11
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;
}
Exemplo n.º 12
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;
}
Exemplo n.º 13
0
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;
}
Exemplo n.º 14
0
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;
}
Exemplo n.º 15
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;
}
Exemplo n.º 16
0
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");
}
Exemplo n.º 17
0
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;
}
Exemplo n.º 18
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
}
Exemplo n.º 19
0
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];
}
Exemplo n.º 20
0
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);
	}
}
Exemplo n.º 21
0
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;
}
Exemplo n.º 22
0
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;
}
Exemplo n.º 23
0
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;
}
Exemplo n.º 24
0
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;
}
Exemplo n.º 25
0
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;
}
Exemplo n.º 26
0
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;
}
Exemplo n.º 27
0
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
}
Exemplo n.º 28
0
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;
}
Exemplo n.º 29
0
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;
}
Exemplo n.º 30
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
}