[linux-block.git] / drivers / staging / rtl8723bs / os_dep / sdio_intf.c

// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
 *
 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
 *
 ******************************************************************************/
#define _HCI_INTF_C_

#include <drv_types.h>
#include <rtw_debug.h>
#include <linux/jiffies.h>

#ifndef dev_to_sdio_func
#define dev_to_sdio_func(d)     container_of(d, struct sdio_func, dev)
#endif

static const struct sdio_device_id sdio_ids[] =
{
	{ SDIO_DEVICE(0x024c, 0x0523), },
	{ SDIO_DEVICE(0x024c, 0x0623), },
	{ SDIO_DEVICE(0x024c, 0x0626), },
	{ SDIO_DEVICE(0x024c, 0xb723), },
	{ /* end: all zeroes */				},
};
static const struct acpi_device_id acpi_ids[] __used = {
	{"OBDA8723", 0x0000},
	{}
};

MODULE_DEVICE_TABLE(sdio, sdio_ids);
MODULE_DEVICE_TABLE(acpi, acpi_ids);

static int rtw_drv_init(struct sdio_func *func, const struct sdio_device_id *id);
static void rtw_dev_remove(struct sdio_func *func);
static int rtw_sdio_resume(struct device *dev);
static int rtw_sdio_suspend(struct device *dev);

static const struct dev_pm_ops rtw_sdio_pm_ops = {
	.suspend	= rtw_sdio_suspend,
	.resume	= rtw_sdio_resume,
};

struct sdio_drv_priv {
	struct sdio_driver r871xs_drv;
	int drv_registered;
};

static struct sdio_drv_priv sdio_drvpriv = {
	.r871xs_drv.probe = rtw_drv_init,
	.r871xs_drv.remove = rtw_dev_remove,
	.r871xs_drv.name = "rtl8723bs",
	.r871xs_drv.id_table = sdio_ids,
	.r871xs_drv.drv = {
		.pm = &rtw_sdio_pm_ops,
	}
};

static void sd_sync_int_hdl(struct sdio_func *func)
{
	struct dvobj_priv *psdpriv;


	psdpriv = sdio_get_drvdata(func);

	if (!psdpriv->if1) {
		DBG_871X("%s if1 == NULL\n", __func__);
		return;
	}

	rtw_sdio_set_irq_thd(psdpriv, current);
	sd_int_hdl(psdpriv->if1);
	rtw_sdio_set_irq_thd(psdpriv, NULL);
}

static int sdio_alloc_irq(struct dvobj_priv *dvobj)
{
	PSDIO_DATA psdio_data;
	struct sdio_func *func;
	int err;

	psdio_data = &dvobj->intf_data;
	func = psdio_data->func;

	sdio_claim_host(func);

	err = sdio_claim_irq(func, &sd_sync_int_hdl);
	if (err)
	{
		dvobj->drv_dbg.dbg_sdio_alloc_irq_error_cnt++;
		printk(KERN_CRIT "%s: sdio_claim_irq FAIL(%d)!\n", __func__, err);
	}
	else
	{
		dvobj->drv_dbg.dbg_sdio_alloc_irq_cnt++;
		dvobj->irq_alloc = 1;
	}

	sdio_release_host(func);

	return err?_FAIL:_SUCCESS;
}

static void sdio_free_irq(struct dvobj_priv *dvobj)
{
    PSDIO_DATA psdio_data;
    struct sdio_func *func;
    int err;

    if (dvobj->irq_alloc) {
        psdio_data = &dvobj->intf_data;
        func = psdio_data->func;

        if (func) {
            sdio_claim_host(func);
            err = sdio_release_irq(func);
            if (err)
            {
				dvobj->drv_dbg.dbg_sdio_free_irq_error_cnt++;
				DBG_871X_LEVEL(_drv_err_,"%s: sdio_release_irq FAIL(%d)!\n", __func__, err);
            }
            else
		dvobj->drv_dbg.dbg_sdio_free_irq_cnt++;
            sdio_release_host(func);
        }
        dvobj->irq_alloc = 0;
    }
}

#ifdef CONFIG_GPIO_WAKEUP
extern unsigned int oob_irq;
static irqreturn_t gpio_hostwakeup_irq_thread(int irq, void *data)
{
	struct adapter *padapter = data;
	DBG_871X_LEVEL(_drv_always_, "gpio_hostwakeup_irq_thread\n");
	/* Disable interrupt before calling handler */
	/* disable_irq_nosync(oob_irq); */
	rtw_lock_suspend_timeout(HZ/2);
	return IRQ_HANDLED;
}

static u8 gpio_hostwakeup_alloc_irq(struct adapter *padapter)
{
	int err;
	if (oob_irq == 0) {
		DBG_871X("oob_irq ZERO!\n");
		return _FAIL;
	}
	/* dont set it IRQF_TRIGGER_LOW, or wowlan */
	/* power is high after suspend */
	/* and failing can prevent can not sleep issue if */
	/* wifi gpio12 pin is not linked with CPU */
	err = request_threaded_irq(oob_irq, gpio_hostwakeup_irq_thread, NULL,
		/* IRQF_TRIGGER_LOW | IRQF_ONESHOT, */
		IRQF_TRIGGER_FALLING,
		"rtw_wifi_gpio_wakeup", padapter);
	if (err < 0) {
		DBG_871X("Oops: can't allocate gpio irq %d err:%d\n", oob_irq, err);
		return false;
	} else {
		DBG_871X("allocate gpio irq %d ok\n", oob_irq);
	}

	enable_irq_wake(oob_irq);
	return _SUCCESS;
}

static void gpio_hostwakeup_free_irq(struct adapter *padapter)
{
	if (oob_irq == 0)
		return;

	disable_irq_wake(oob_irq);
	free_irq(oob_irq, padapter);
}
#endif

static u32 sdio_init(struct dvobj_priv *dvobj)
{
	PSDIO_DATA psdio_data;
	struct sdio_func *func;
	int err;

	psdio_data = &dvobj->intf_data;
	func = psdio_data->func;

	/* 3 1. init SDIO bus */
	sdio_claim_host(func);

	err = sdio_enable_func(func);
	if (err) {
		dvobj->drv_dbg.dbg_sdio_init_error_cnt++;
		DBG_8192C(KERN_CRIT "%s: sdio_enable_func FAIL(%d)!\n", __func__, err);
		goto release;
	}

	err = sdio_set_block_size(func, 512);
	if (err) {
		dvobj->drv_dbg.dbg_sdio_init_error_cnt++;
		DBG_8192C(KERN_CRIT "%s: sdio_set_block_size FAIL(%d)!\n", __func__, err);
		goto release;
	}
	psdio_data->block_transfer_len = 512;
	psdio_data->tx_block_mode = 1;
	psdio_data->rx_block_mode = 1;

release:
	sdio_release_host(func);

	if (err)
		return _FAIL;
	return _SUCCESS;
}

static void sdio_deinit(struct dvobj_priv *dvobj)
{
	struct sdio_func *func;
	int err;


	RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("+sdio_deinit\n"));

	func = dvobj->intf_data.func;

	if (func) {
		sdio_claim_host(func);
		err = sdio_disable_func(func);
		if (err)
		{
			dvobj->drv_dbg.dbg_sdio_deinit_error_cnt++;
			DBG_8192C(KERN_ERR "%s: sdio_disable_func(%d)\n", __func__, err);
		}

		if (dvobj->irq_alloc) {
			err = sdio_release_irq(func);
			if (err)
			{
				dvobj->drv_dbg.dbg_sdio_free_irq_error_cnt++;
				DBG_8192C(KERN_ERR "%s: sdio_release_irq(%d)\n", __func__, err);
			}
			else
				dvobj->drv_dbg.dbg_sdio_free_irq_cnt++;
		}

		sdio_release_host(func);
	}
}
static struct dvobj_priv *sdio_dvobj_init(struct sdio_func *func)
{
	int status = _FAIL;
	struct dvobj_priv *dvobj = NULL;
	PSDIO_DATA psdio;

	dvobj = devobj_init();
	if (dvobj == NULL) {
		goto exit;
	}

	sdio_set_drvdata(func, dvobj);

	psdio = &dvobj->intf_data;
	psdio->func = func;

	if (sdio_init(dvobj) != _SUCCESS) {
		RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("%s: initialize SDIO Failed!\n", __func__));
		goto free_dvobj;
	}
	rtw_reset_continual_io_error(dvobj);
	status = _SUCCESS;

free_dvobj:
	if (status != _SUCCESS && dvobj) {
		sdio_set_drvdata(func, NULL);

		devobj_deinit(dvobj);

		dvobj = NULL;
	}
exit:
	return dvobj;
}

static void sdio_dvobj_deinit(struct sdio_func *func)
{
	struct dvobj_priv *dvobj = sdio_get_drvdata(func);

	sdio_set_drvdata(func, NULL);
	if (dvobj) {
		sdio_deinit(dvobj);
		devobj_deinit(dvobj);
	}
	return;
}

void rtw_set_hal_ops(struct adapter *padapter)
{
	/* alloc memory for HAL DATA */
	rtw_hal_data_init(padapter);

	rtl8723bs_set_hal_ops(padapter);
}

static void sd_intf_start(struct adapter *padapter)
{
	if (padapter == NULL) {
		DBG_8192C(KERN_ERR "%s: padapter is NULL!\n", __func__);
		return;
	}

	/*  hal dep */
	rtw_hal_enable_interrupt(padapter);
}

static void sd_intf_stop(struct adapter *padapter)
{
	if (padapter == NULL) {
		DBG_8192C(KERN_ERR "%s: padapter is NULL!\n", __func__);
		return;
	}

	/*  hal dep */
	rtw_hal_disable_interrupt(padapter);
}


static struct adapter *rtw_sdio_if1_init(struct dvobj_priv *dvobj, const struct sdio_device_id  *pdid)
{
	int status = _FAIL;
	struct net_device *pnetdev;
	struct adapter *padapter = NULL;
	PSDIO_DATA psdio = &dvobj->intf_data;

	padapter = vzalloc(sizeof(*padapter));
	if (padapter == NULL) {
		goto exit;
	}

	padapter->dvobj = dvobj;
	dvobj->if1 = padapter;

	padapter->bDriverStopped =true;

	dvobj->padapters = padapter;
	padapter->iface_id = 0;

	/* 3 1. init network device data */
	pnetdev = rtw_init_netdev(padapter);
	if (!pnetdev)
		goto free_adapter;

	SET_NETDEV_DEV(pnetdev, dvobj_to_dev(dvobj));

	padapter = rtw_netdev_priv(pnetdev);

	rtw_wdev_alloc(padapter, dvobj_to_dev(dvobj));

	/* 3 3. init driver special setting, interface, OS and hardware relative */

	/* 4 3.1 set hardware operation functions */
	rtw_set_hal_ops(padapter);


	/* 3 5. initialize Chip version */
	padapter->intf_start = &sd_intf_start;
	padapter->intf_stop = &sd_intf_stop;

	padapter->intf_init = &sdio_init;
	padapter->intf_deinit = &sdio_deinit;
	padapter->intf_alloc_irq = &sdio_alloc_irq;
	padapter->intf_free_irq = &sdio_free_irq;

	if (rtw_init_io_priv(padapter, sdio_set_intf_ops) == _FAIL)
	{
		RT_TRACE(_module_hci_intfs_c_, _drv_err_,
			("rtw_drv_init: Can't init io_priv\n"));
		goto free_hal_data;
	}

	rtw_hal_read_chip_version(padapter);

	rtw_hal_chip_configure(padapter);

	rtw_btcoex_Initialize(padapter);

	/* 3 6. read efuse/eeprom data */
	rtw_hal_read_chip_info(padapter);

	/* 3 7. init driver common data */
	if (rtw_init_drv_sw(padapter) == _FAIL) {
		RT_TRACE(_module_hci_intfs_c_, _drv_err_,
			 ("rtw_drv_init: Initialize driver software resource Failed!\n"));
		goto free_hal_data;
	}

	/* 3 8. get WLan MAC address */
	/*  set mac addr */
	rtw_macaddr_cfg(&psdio->func->dev, padapter->eeprompriv.mac_addr);

	rtw_hal_disable_interrupt(padapter);

	DBG_871X("bDriverStopped:%d, bSurpriseRemoved:%d, bup:%d, hw_init_completed:%d\n"
		, padapter->bDriverStopped
		, padapter->bSurpriseRemoved
		, padapter->bup
		, padapter->hw_init_completed
	);

	status = _SUCCESS;

free_hal_data:
	if (status != _SUCCESS && padapter->HalData)
		kfree(padapter->HalData);

	if (status != _SUCCESS) {
		rtw_wdev_unregister(padapter->rtw_wdev);
		rtw_wdev_free(padapter->rtw_wdev);
	}

free_adapter:
	if (status != _SUCCESS) {
		if (pnetdev)
			rtw_free_netdev(pnetdev);
		else
			vfree((u8 *)padapter);
		padapter = NULL;
	}
exit:
	return padapter;
}

static void rtw_sdio_if1_deinit(struct adapter *if1)
{
	struct net_device *pnetdev = if1->pnetdev;
	struct mlme_priv *pmlmepriv = &if1->mlmepriv;

	if (check_fwstate(pmlmepriv, _FW_LINKED))
		rtw_disassoc_cmd(if1, 0, false);

	free_mlme_ap_info(if1);

#ifdef CONFIG_GPIO_WAKEUP
	gpio_hostwakeup_free_irq(if1);
#endif

	rtw_cancel_all_timer(if1);

#ifdef CONFIG_WOWLAN
	adapter_to_pwrctl(if1)->wowlan_mode =false;
	DBG_871X_LEVEL(_drv_always_, "%s wowlan_mode:%d\n", __func__, adapter_to_pwrctl(if1)->wowlan_mode);
#endif /* CONFIG_WOWLAN */

	rtw_dev_unload(if1);
	DBG_871X("+r871xu_dev_remove, hw_init_completed =%d\n", if1->hw_init_completed);

	if (if1->rtw_wdev) {
		rtw_wdev_free(if1->rtw_wdev);
	}

	rtw_free_drv_sw(if1);

	if (pnetdev)
		rtw_free_netdev(pnetdev);
}

/*
 * drv_init() - a device potentially for us
 *
 * notes: drv_init() is called when the bus driver has located a card for us to support.
 *        We accept the new device by returning 0.
 */
static int rtw_drv_init(
	struct sdio_func *func,
	const struct sdio_device_id *id)
{
	int status = _FAIL;
	struct adapter *if1 = NULL, *if2 = NULL;
	struct dvobj_priv *dvobj;

	dvobj = sdio_dvobj_init(func);
	if (dvobj == NULL) {
		RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("initialize device object priv Failed!\n"));
		goto exit;
	}

	if1 = rtw_sdio_if1_init(dvobj, id);
	if (if1 == NULL) {
		DBG_871X("rtw_init_primarystruct adapter Failed!\n");
		goto free_dvobj;
	}

	/* dev_alloc_name && register_netdev */
	status = rtw_drv_register_netdev(if1);
	if (status != _SUCCESS) {
		goto free_if2;
	}

	if (sdio_alloc_irq(dvobj) != _SUCCESS)
		goto free_if2;

#ifdef	CONFIG_GPIO_WAKEUP
	gpio_hostwakeup_alloc_irq(if1);
#endif

	RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("-871x_drv - drv_init, success!\n"));

	rtw_ndev_notifier_register();
	status = _SUCCESS;

free_if2:
	if (status != _SUCCESS && if2) {
	}
	if (status != _SUCCESS && if1) {
		rtw_sdio_if1_deinit(if1);
	}
free_dvobj:
	if (status != _SUCCESS)
		sdio_dvobj_deinit(func);
exit:
	return status == _SUCCESS?0:-ENODEV;
}

static void rtw_dev_remove(struct sdio_func *func)
{
	struct dvobj_priv *dvobj = sdio_get_drvdata(func);
	struct adapter *padapter = dvobj->if1;

	RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("+rtw_dev_remove\n"));

	dvobj->processing_dev_remove = true;

	rtw_unregister_netdevs(dvobj);

	if (padapter->bSurpriseRemoved == false) {
		int err;

		/* test surprise remove */
		sdio_claim_host(func);
		sdio_readb(func, 0, &err);
		sdio_release_host(func);
		if (err == -ENOMEDIUM) {
			padapter->bSurpriseRemoved = true;
			DBG_871X(KERN_NOTICE "%s: device had been removed!\n", __func__);
		}
	}

	rtw_ps_deny(padapter, PS_DENY_DRV_REMOVE);

	rtw_pm_set_ips(padapter, IPS_NONE);
	rtw_pm_set_lps(padapter, PS_MODE_ACTIVE);

	LeaveAllPowerSaveMode(padapter);

	rtw_btcoex_HaltNotify(padapter);

	rtw_sdio_if1_deinit(padapter);

	sdio_dvobj_deinit(func);

	RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("-rtw_dev_remove\n"));
}

extern int pm_netdev_open(struct net_device *pnetdev, u8 bnormal);
extern int pm_netdev_close(struct net_device *pnetdev, u8 bnormal);

static int rtw_sdio_suspend(struct device *dev)
{
	struct sdio_func *func =dev_to_sdio_func(dev);
	struct dvobj_priv *psdpriv = sdio_get_drvdata(func);
	struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(psdpriv);
	struct adapter *padapter = psdpriv->if1;
	struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;

	if (padapter->bDriverStopped == true)
	{
		DBG_871X("%s bDriverStopped = %d\n", __func__, padapter->bDriverStopped);
		return 0;
	}

	if (pwrpriv->bInSuspend == true)
	{
		DBG_871X("%s bInSuspend = %d\n", __func__, pwrpriv->bInSuspend);
		pdbgpriv->dbg_suspend_error_cnt++;
		return 0;
	}

	return rtw_suspend_common(padapter);
}

static int rtw_resume_process(struct adapter *padapter)
{
	struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
	struct dvobj_priv *psdpriv = padapter->dvobj;
	struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;

	if (pwrpriv->bInSuspend == false)
	{
		pdbgpriv->dbg_resume_error_cnt++;
		DBG_871X("%s bInSuspend = %d\n", __func__, pwrpriv->bInSuspend);
		return -1;
	}

	return rtw_resume_common(padapter);
}

static int rtw_sdio_resume(struct device *dev)
{
	struct sdio_func *func =dev_to_sdio_func(dev);
	struct dvobj_priv *psdpriv = sdio_get_drvdata(func);
	struct adapter *padapter = psdpriv->if1;
	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
	int ret = 0;
	struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;

	DBG_871X("==> %s (%s:%d)\n", __func__, current->comm, current->pid);

	pdbgpriv->dbg_resume_cnt++;

	ret = rtw_resume_process(padapter);

	pmlmeext->last_scan_time = jiffies;
	DBG_871X("<========  %s return %d\n", __func__, ret);
	return ret;
}

static int __init rtw_drv_entry(void)
{
	int ret = 0;

	DBG_871X_LEVEL(_drv_always_, "module init start\n");
	dump_drv_version(RTW_DBGDUMP);
#ifdef BTCOEXVERSION
	DBG_871X_LEVEL(_drv_always_, "rtl8723bs BT-Coex version = %s\n", BTCOEXVERSION);
#endif /*  BTCOEXVERSION */

	sdio_drvpriv.drv_registered = true;
	rtw_drv_proc_init();

	ret = sdio_register_driver(&sdio_drvpriv.r871xs_drv);
	if (ret != 0)
	{
		sdio_drvpriv.drv_registered = false;
		rtw_drv_proc_deinit();
		rtw_ndev_notifier_unregister();
		DBG_871X("%s: register driver failed!!(%d)\n", __func__, ret);
		goto exit;
	}

	goto exit;

exit:
	DBG_871X_LEVEL(_drv_always_, "module init ret =%d\n", ret);
	return ret;
}

static void __exit rtw_drv_halt(void)
{
	DBG_871X_LEVEL(_drv_always_, "module exit start\n");

	sdio_drvpriv.drv_registered = false;

	sdio_unregister_driver(&sdio_drvpriv.r871xs_drv);

	rtw_drv_proc_deinit();
	rtw_ndev_notifier_unregister();

	DBG_871X_LEVEL(_drv_always_, "module exit success\n");

	rtw_mstat_dump(RTW_DBGDUMP);
}


module_init(rtw_drv_entry);
module_exit(rtw_drv_halt);
Commit	Line	Data
58391efd	1	// SPDX-License-Identifier: GPL-2.0
554c0a3a HG	2	/******************************************************************************
	3	*
	4	* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
	5	*
554c0a3a HG	6	******************************************************************************/
	7	#define _HCI_INTF_C_
	8
	9	#include <drv_types.h>
	10	#include <rtw_debug.h>
	11	#include <linux/jiffies.h>
	12
	13	#ifndef dev_to_sdio_func
	14	#define dev_to_sdio_func(d) container_of(d, struct sdio_func, dev)
	15	#endif
	16
	17	static const struct sdio_device_id sdio_ids[] =
	18	{
	19	{ SDIO_DEVICE(0x024c, 0x0523), },
	20	{ SDIO_DEVICE(0x024c, 0x0623), },
	21	{ SDIO_DEVICE(0x024c, 0x0626), },
	22	{ SDIO_DEVICE(0x024c, 0xb723), },
	23	{ /* end: all zeroes */ },
	24	};
e6d09371	25	static const struct acpi_device_id acpi_ids[] __used = {
554c0a3a HG	26	{"OBDA8723", 0x0000},
	27	{}
	28	};
	29
	30	MODULE_DEVICE_TABLE(sdio, sdio_ids);
	31	MODULE_DEVICE_TABLE(acpi, acpi_ids);
	32
	33	static int rtw_drv_init(struct sdio_func func, const struct sdio_device_id id);
	34	static void rtw_dev_remove(struct sdio_func *func);
	35	static int rtw_sdio_resume(struct device *dev);
	36	static int rtw_sdio_suspend(struct device *dev);
	37
	38	static const struct dev_pm_ops rtw_sdio_pm_ops = {
	39	.suspend = rtw_sdio_suspend,
	40	.resume = rtw_sdio_resume,
	41	};
	42
	43	struct sdio_drv_priv {
	44	struct sdio_driver r871xs_drv;
	45	int drv_registered;
	46	};
	47
	48	static struct sdio_drv_priv sdio_drvpriv = {
	49	.r871xs_drv.probe = rtw_drv_init,
	50	.r871xs_drv.remove = rtw_dev_remove,
	51	.r871xs_drv.name = "rtl8723bs",
	52	.r871xs_drv.id_table = sdio_ids,
	53	.r871xs_drv.drv = {
	54	.pm = &rtw_sdio_pm_ops,
	55	}
	56	};
	57
	58	static void sd_sync_int_hdl(struct sdio_func *func)
	59	{
	60	struct dvobj_priv *psdpriv;
	61
	62
	63	psdpriv = sdio_get_drvdata(func);
	64
	65	if (!psdpriv->if1) {
	66	DBG_871X("%s if1 == NULL\n", __func__);
	67	return;
	68	}
	69
	70	rtw_sdio_set_irq_thd(psdpriv, current);
	71	sd_int_hdl(psdpriv->if1);
	72	rtw_sdio_set_irq_thd(psdpriv, NULL);
	73	}
	74
	75	static int sdio_alloc_irq(struct dvobj_priv *dvobj)
	76	{
	77	PSDIO_DATA psdio_data;
	78	struct sdio_func *func;
	79	int err;
	80
	81	psdio_data = &dvobj->intf_data;
	82	func = psdio_data->func;
	83
	84	sdio_claim_host(func);
	85
	86	err = sdio_claim_irq(func, &sd_sync_int_hdl);
	87	if (err)
	88	{
	89	dvobj->drv_dbg.dbg_sdio_alloc_irq_error_cnt++;
90	printk(KERN_CRIT "%s: sdio_claim_irq FAIL(%d)!\n", __func__, err);
91	}
92	else
93	{
94	dvobj->drv_dbg.dbg_sdio_alloc_irq_cnt++;
95	dvobj->irq_alloc = 1;
96	}
97
98	sdio_release_host(func);
99
100	return err?_FAIL:_SUCCESS;
101	}
102
103	static void sdio_free_irq(struct dvobj_priv *dvobj)
104	{
105	PSDIO_DATA psdio_data;
106	struct sdio_func *func;
107	int err;
108
109	if (dvobj->irq_alloc) {
110	psdio_data = &dvobj->intf_data;
111	func = psdio_data->func;
112
113	if (func) {
114	sdio_claim_host(func);
115	err = sdio_release_irq(func);
116	if (err)
117	{
118	dvobj->drv_dbg.dbg_sdio_free_irq_error_cnt++;
119	DBG_871X_LEVEL(_drv_err_,"%s: sdio_release_irq FAIL(%d)!\n", __func__, err);
120	}
121	else
122	dvobj->drv_dbg.dbg_sdio_free_irq_cnt++;
123	sdio_release_host(func);
124	}
125	dvobj->irq_alloc = 0;
126	}
127	}
128
129	#ifdef CONFIG_GPIO_WAKEUP
130	extern unsigned int oob_irq;
131	static irqreturn_t gpio_hostwakeup_irq_thread(int irq, void *data)
132	{
67e3e07e	133	struct adapter *padapter = data;
554c0a3a HG	134	DBG_871X_LEVEL(_drv_always_, "gpio_hostwakeup_irq_thread\n");
	135	/* Disable interrupt before calling handler */
	136	/* disable_irq_nosync(oob_irq); */
	137	rtw_lock_suspend_timeout(HZ/2);
	138	return IRQ_HANDLED;
	139	}
	140
	141	static u8 gpio_hostwakeup_alloc_irq(struct adapter *padapter)
	142	{
	143	int err;
	144	if (oob_irq == 0) {
	145	DBG_871X("oob_irq ZERO!\n");
	146	return _FAIL;
	147	}
	148	/* dont set it IRQF_TRIGGER_LOW, or wowlan */
	149	/* power is high after suspend */
	150	/* and failing can prevent can not sleep issue if */
	151	/* wifi gpio12 pin is not linked with CPU */
	152	err = request_threaded_irq(oob_irq, gpio_hostwakeup_irq_thread, NULL,
	153	/* IRQF_TRIGGER_LOW \| IRQF_ONESHOT, */
	154	IRQF_TRIGGER_FALLING,
	155	"rtw_wifi_gpio_wakeup", padapter);
	156	if (err < 0) {
	157	DBG_871X("Oops: can't allocate gpio irq %d err:%d\n", oob_irq, err);
	158	return false;
	159	} else {
	160	DBG_871X("allocate gpio irq %d ok\n", oob_irq);
	161	}
	162
	163	enable_irq_wake(oob_irq);
	164	return _SUCCESS;
	165	}
	166
	167	static void gpio_hostwakeup_free_irq(struct adapter *padapter)
	168	{
	169	if (oob_irq == 0)
	170	return;
	171
	172	disable_irq_wake(oob_irq);
	173	free_irq(oob_irq, padapter);
	174	}
	175	#endif
	176
	177	static u32 sdio_init(struct dvobj_priv *dvobj)
	178	{
	179	PSDIO_DATA psdio_data;
	180	struct sdio_func *func;
	181	int err;
	182
	183	psdio_data = &dvobj->intf_data;
	184	func = psdio_data->func;
	185
	186	/* 3 1. init SDIO bus */
	187	sdio_claim_host(func);
	188
	189	err = sdio_enable_func(func);
	190	if (err) {
	191	dvobj->drv_dbg.dbg_sdio_init_error_cnt++;
	192	DBG_8192C(KERN_CRIT "%s: sdio_enable_func FAIL(%d)!\n", __func__, err);
	193	goto release;
	194	}
	195
	196	err = sdio_set_block_size(func, 512);
	197	if (err) {
198	dvobj->drv_dbg.dbg_sdio_init_error_cnt++;
199	DBG_8192C(KERN_CRIT "%s: sdio_set_block_size FAIL(%d)!\n", __func__, err);
200	goto release;
201	}
202	psdio_data->block_transfer_len = 512;
203	psdio_data->tx_block_mode = 1;
204	psdio_data->rx_block_mode = 1;
205
206	release:
207	sdio_release_host(func);
208
209	if (err)
210	return _FAIL;
211	return _SUCCESS;
212	}
213
214	static void sdio_deinit(struct dvobj_priv *dvobj)
215	{
216	struct sdio_func *func;
217	int err;
218
219
220	RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("+sdio_deinit\n"));
221
222	func = dvobj->intf_data.func;
223
224	if (func) {
225	sdio_claim_host(func);
226	err = sdio_disable_func(func);
227	if (err)
228	{
229	dvobj->drv_dbg.dbg_sdio_deinit_error_cnt++;
230	DBG_8192C(KERN_ERR "%s: sdio_disable_func(%d)\n", __func__, err);
231	}
232
233	if (dvobj->irq_alloc) {
234	err = sdio_release_irq(func);
235	if (err)
236	{
237	dvobj->drv_dbg.dbg_sdio_free_irq_error_cnt++;
238	DBG_8192C(KERN_ERR "%s: sdio_release_irq(%d)\n", __func__, err);
239	}
240	else
241	dvobj->drv_dbg.dbg_sdio_free_irq_cnt++;
242	}
243
244	sdio_release_host(func);
245	}
246	}
247	static struct dvobj_priv sdio_dvobj_init(struct sdio_func func)
248	{
249	int status = _FAIL;
250	struct dvobj_priv *dvobj = NULL;
251	PSDIO_DATA psdio;
252
ea82fc15 BZ	253	dvobj = devobj_init();
ea82fc15 BZ	254	if (dvobj == NULL) {
554c0a3a HG	255	goto exit;
	256	}
	257
	258	sdio_set_drvdata(func, dvobj);
	259
	260	psdio = &dvobj->intf_data;
	261	psdio->func = func;
	262
	263	if (sdio_init(dvobj) != _SUCCESS) {
	264	RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("%s: initialize SDIO Failed!\n", __func__));
	265	goto free_dvobj;
	266	}
	267	rtw_reset_continual_io_error(dvobj);
	268	status = _SUCCESS;
	269
	270	free_dvobj:
	271	if (status != _SUCCESS && dvobj) {
	272	sdio_set_drvdata(func, NULL);
	273
	274	devobj_deinit(dvobj);
	275
	276	dvobj = NULL;
	277	}
	278	exit:
	279	return dvobj;
	280	}
	281
	282	static void sdio_dvobj_deinit(struct sdio_func *func)
	283	{
	284	struct dvobj_priv *dvobj = sdio_get_drvdata(func);
	285
	286	sdio_set_drvdata(func, NULL);
	287	if (dvobj) {
	288	sdio_deinit(dvobj);
	289	devobj_deinit(dvobj);
	290	}
	291	return;
	292	}
	293
	294	void rtw_set_hal_ops(struct adapter *padapter)
	295	{
	296	/* alloc memory for HAL DATA */
	297	rtw_hal_data_init(padapter);
	298
	299	rtl8723bs_set_hal_ops(padapter);
	300	}
	301
	302	static void sd_intf_start(struct adapter *padapter)
	303	{
	304	if (padapter == NULL) {
	305	DBG_8192C(KERN_ERR "%s: padapter is NULL!\n", __func__);
	306	return;
	307	}
	308
	309	/* hal dep */
	310	rtw_hal_enable_interrupt(padapter);
	311	}
	312
	313	static void sd_intf_stop(struct adapter *padapter)
	314	{
	315	if (padapter == NULL) {
	316	DBG_8192C(KERN_ERR "%s: padapter is NULL!\n", __func__);
	317	return;
	318	}
319
320	/* hal dep */
321	rtw_hal_disable_interrupt(padapter);
322	}
323
324
325	static struct adapter rtw_sdio_if1_init(struct dvobj_priv dvobj, const struct sdio_device_id *pdid)
326	{
327	int status = _FAIL;
328	struct net_device *pnetdev;
329	struct adapter *padapter = NULL;
330	PSDIO_DATA psdio = &dvobj->intf_data;
331
8b6c7a34	332	padapter = vzalloc(sizeof(*padapter));
ea82fc15	333	if (padapter == NULL) {
554c0a3a HG	334	goto exit;
	335	}
	336
	337	padapter->dvobj = dvobj;
	338	dvobj->if1 = padapter;
	339
	340	padapter->bDriverStopped =true;
	341
	342	dvobj->padapters = padapter;
	343	padapter->iface_id = 0;
	344
	345	/* 3 1. init network device data */
	346	pnetdev = rtw_init_netdev(padapter);
	347	if (!pnetdev)
	348	goto free_adapter;
	349
	350	SET_NETDEV_DEV(pnetdev, dvobj_to_dev(dvobj));
	351
	352	padapter = rtw_netdev_priv(pnetdev);
	353
	354	rtw_wdev_alloc(padapter, dvobj_to_dev(dvobj));
	355
	356	/* 3 3. init driver special setting, interface, OS and hardware relative */
	357
	358	/* 4 3.1 set hardware operation functions */
	359	rtw_set_hal_ops(padapter);
	360
	361
	362	/* 3 5. initialize Chip version */
	363	padapter->intf_start = &sd_intf_start;
	364	padapter->intf_stop = &sd_intf_stop;
	365
	366	padapter->intf_init = &sdio_init;
	367	padapter->intf_deinit = &sdio_deinit;
	368	padapter->intf_alloc_irq = &sdio_alloc_irq;
	369	padapter->intf_free_irq = &sdio_free_irq;
	370
	371	if (rtw_init_io_priv(padapter, sdio_set_intf_ops) == _FAIL)
	372	{
	373	RT_TRACE(_module_hci_intfs_c_, _drv_err_,
	374	("rtw_drv_init: Can't init io_priv\n"));
	375	goto free_hal_data;
	376	}
	377
	378	rtw_hal_read_chip_version(padapter);
	379
	380	rtw_hal_chip_configure(padapter);
	381
	382	rtw_btcoex_Initialize(padapter);
	383
	384	/* 3 6. read efuse/eeprom data */
	385	rtw_hal_read_chip_info(padapter);
	386
	387	/* 3 7. init driver common data */
	388	if (rtw_init_drv_sw(padapter) == _FAIL) {
	389	RT_TRACE(_module_hci_intfs_c_, _drv_err_,
	390	("rtw_drv_init: Initialize driver software resource Failed!\n"));
	391	goto free_hal_data;
	392	}
	393
	394	/* 3 8. get WLan MAC address */
	395	/* set mac addr */
	396	rtw_macaddr_cfg(&psdio->func->dev, padapter->eeprompriv.mac_addr);
	397
398	rtw_hal_disable_interrupt(padapter);
399
400	DBG_871X("bDriverStopped:%d, bSurpriseRemoved:%d, bup:%d, hw_init_completed:%d\n"
401	, padapter->bDriverStopped
402	, padapter->bSurpriseRemoved
403	, padapter->bup
404	, padapter->hw_init_completed
405	);
406
407	status = _SUCCESS;
408
409	free_hal_data:
410	if (status != _SUCCESS && padapter->HalData)
411	kfree(padapter->HalData);
412
413	if (status != _SUCCESS) {
414	rtw_wdev_unregister(padapter->rtw_wdev);
415	rtw_wdev_free(padapter->rtw_wdev);
416	}
417
418	free_adapter:
419	if (status != _SUCCESS) {
420	if (pnetdev)
421	rtw_free_netdev(pnetdev);
422	else
423	vfree((u8 *)padapter);
424	padapter = NULL;
425	}
426	exit:
427	return padapter;
428	}
429
430	static void rtw_sdio_if1_deinit(struct adapter *if1)
431	{
432	struct net_device *pnetdev = if1->pnetdev;
433	struct mlme_priv *pmlmepriv = &if1->mlmepriv;
434
435	if (check_fwstate(pmlmepriv, _FW_LINKED))
436	rtw_disassoc_cmd(if1, 0, false);
437
438	free_mlme_ap_info(if1);
439
440	#ifdef CONFIG_GPIO_WAKEUP
441	gpio_hostwakeup_free_irq(if1);
442	#endif
443
444	rtw_cancel_all_timer(if1);
445
446	#ifdef CONFIG_WOWLAN
447	adapter_to_pwrctl(if1)->wowlan_mode =false;
448	DBG_871X_LEVEL(_drv_always_, "%s wowlan_mode:%d\n", __func__, adapter_to_pwrctl(if1)->wowlan_mode);
449	#endif /* CONFIG_WOWLAN */
450
451	rtw_dev_unload(if1);
452	DBG_871X("+r871xu_dev_remove, hw_init_completed =%d\n", if1->hw_init_completed);
453
454	if (if1->rtw_wdev) {
455	rtw_wdev_free(if1->rtw_wdev);
456	}
457
458	rtw_free_drv_sw(if1);
459
460	if (pnetdev)
461	rtw_free_netdev(pnetdev);
462	}
463
464	/*
465	* drv_init() - a device potentially for us
466	*
467	* notes: drv_init() is called when the bus driver has located a card for us to support.
468	* We accept the new device by returning 0.
469	*/
470	static int rtw_drv_init(
471	struct sdio_func *func,
472	const struct sdio_device_id *id)
473	{
474	int status = _FAIL;
475	struct adapter if1 = NULL, if2 = NULL;
476	struct dvobj_priv *dvobj;
477
ea82fc15 BZ	478	dvobj = sdio_dvobj_init(func);
ea82fc15 BZ	479	if (dvobj == NULL) {
554c0a3a HG	480	RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("initialize device object priv Failed!\n"));
	481	goto exit;
	482	}
	483
ea82fc15 BZ	484	if1 = rtw_sdio_if1_init(dvobj, id);
ea82fc15 BZ	485	if (if1 == NULL) {
554c0a3a HG	486	DBG_871X("rtw_init_primarystruct adapter Failed!\n");
	487	goto free_dvobj;
	488	}
	489
	490	/* dev_alloc_name && register_netdev */
ea82fc15 BZ	491	status = rtw_drv_register_netdev(if1);
ea82fc15 BZ	492	if (status != _SUCCESS) {
554c0a3a HG	493	goto free_if2;
	494	}
	495
	496	if (sdio_alloc_irq(dvobj) != _SUCCESS)
	497	goto free_if2;
	498
	499	#ifdef CONFIG_GPIO_WAKEUP
	500	gpio_hostwakeup_alloc_irq(if1);
	501	#endif
	502
	503	RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("-871x_drv - drv_init, success!\n"));
	504
	505	rtw_ndev_notifier_register();
	506	status = _SUCCESS;
	507
	508	free_if2:
	509	if (status != _SUCCESS && if2) {
	510	}
	511	if (status != _SUCCESS && if1) {
	512	rtw_sdio_if1_deinit(if1);
	513	}
	514	free_dvobj:
	515	if (status != _SUCCESS)
	516	sdio_dvobj_deinit(func);
	517	exit:
	518	return status == _SUCCESS?0:-ENODEV;
	519	}
	520
	521	static void rtw_dev_remove(struct sdio_func *func)
	522	{
	523	struct dvobj_priv *dvobj = sdio_get_drvdata(func);
	524	struct adapter *padapter = dvobj->if1;
	525
	526	RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("+rtw_dev_remove\n"));
	527
	528	dvobj->processing_dev_remove = true;
	529
	530	rtw_unregister_netdevs(dvobj);
	531
	532	if (padapter->bSurpriseRemoved == false) {
	533	int err;
	534
	535	/* test surprise remove */
	536	sdio_claim_host(func);
	537	sdio_readb(func, 0, &err);
	538	sdio_release_host(func);
	539	if (err == -ENOMEDIUM) {
	540	padapter->bSurpriseRemoved = true;
	541	DBG_871X(KERN_NOTICE "%s: device had been removed!\n", __func__);
	542	}
	543	}
	544
	545	rtw_ps_deny(padapter, PS_DENY_DRV_REMOVE);
	546
	547	rtw_pm_set_ips(padapter, IPS_NONE);
	548	rtw_pm_set_lps(padapter, PS_MODE_ACTIVE);
	549
	550	LeaveAllPowerSaveMode(padapter);
	551
	552	rtw_btcoex_HaltNotify(padapter);
	553
	554	rtw_sdio_if1_deinit(padapter);
	555
	556	sdio_dvobj_deinit(func);
557
558	RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("-rtw_dev_remove\n"));
559	}
560
561	extern int pm_netdev_open(struct net_device *pnetdev, u8 bnormal);
562	extern int pm_netdev_close(struct net_device *pnetdev, u8 bnormal);
563
564	static int rtw_sdio_suspend(struct device *dev)
565	{
566	struct sdio_func *func =dev_to_sdio_func(dev);
567	struct dvobj_priv *psdpriv = sdio_get_drvdata(func);
568	struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(psdpriv);
569	struct adapter *padapter = psdpriv->if1;
570	struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
571
572	if (padapter->bDriverStopped == true)
573	{
574	DBG_871X("%s bDriverStopped = %d\n", __func__, padapter->bDriverStopped);
575	return 0;
576	}
577
578	if (pwrpriv->bInSuspend == true)
579	{
580	DBG_871X("%s bInSuspend = %d\n", __func__, pwrpriv->bInSuspend);
581	pdbgpriv->dbg_suspend_error_cnt++;
582	return 0;
583	}
584
585	return rtw_suspend_common(padapter);
586	}
587
588	static int rtw_resume_process(struct adapter *padapter)
589	{
590	struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
591	struct dvobj_priv *psdpriv = padapter->dvobj;
592	struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
593
594	if (pwrpriv->bInSuspend == false)
595	{
596	pdbgpriv->dbg_resume_error_cnt++;
597	DBG_871X("%s bInSuspend = %d\n", __func__, pwrpriv->bInSuspend);
598	return -1;
599	}
600
601	return rtw_resume_common(padapter);
602	}
603
604	static int rtw_sdio_resume(struct device *dev)
605	{
606	struct sdio_func *func =dev_to_sdio_func(dev);
607	struct dvobj_priv *psdpriv = sdio_get_drvdata(func);
554c0a3a HG	608	struct adapter *padapter = psdpriv->if1;
	609	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
	610	int ret = 0;
	611	struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
	612
	613	DBG_871X("==> %s (%s:%d)\n", __func__, current->comm, current->pid);
	614
	615	pdbgpriv->dbg_resume_cnt++;
	616
0a561b0f MS	617	ret = rtw_resume_process(padapter);
0a561b0f MS	618
554c0a3a HG	619	pmlmeext->last_scan_time = jiffies;
	620	DBG_871X("<======== %s return %d\n", __func__, ret);
	621	return ret;
554c0a3a HG	622	}
	623
	624	static int __init rtw_drv_entry(void)
	625	{
	626	int ret = 0;
	627
	628	DBG_871X_LEVEL(_drv_always_, "module init start\n");
	629	dump_drv_version(RTW_DBGDUMP);
	630	#ifdef BTCOEXVERSION
	631	DBG_871X_LEVEL(_drv_always_, "rtl8723bs BT-Coex version = %s\n", BTCOEXVERSION);
	632	#endif /* BTCOEXVERSION */
	633
	634	sdio_drvpriv.drv_registered = true;
	635	rtw_drv_proc_init();
	636
	637	ret = sdio_register_driver(&sdio_drvpriv.r871xs_drv);
	638	if (ret != 0)
	639	{
	640	sdio_drvpriv.drv_registered = false;
	641	rtw_drv_proc_deinit();
	642	rtw_ndev_notifier_unregister();
	643	DBG_871X("%s: register driver failed!!(%d)\n", __func__, ret);
	644	goto exit;
	645	}
	646
	647	goto exit;
	648
	649	exit:
	650	DBG_871X_LEVEL(_drv_always_, "module init ret =%d\n", ret);
	651	return ret;
	652	}
	653
	654	static void __exit rtw_drv_halt(void)
	655	{
	656	DBG_871X_LEVEL(_drv_always_, "module exit start\n");
	657
	658	sdio_drvpriv.drv_registered = false;
	659
	660	sdio_unregister_driver(&sdio_drvpriv.r871xs_drv);
	661
	662	rtw_drv_proc_deinit();
	663	rtw_ndev_notifier_unregister();
	664
	665	DBG_871X_LEVEL(_drv_always_, "module exit success\n");
	666
	667	rtw_mstat_dump(RTW_DBGDUMP);
	668	}
	669
	670
	671	module_init(rtw_drv_entry);
	672	module_exit(rtw_drv_halt);