C++ sdio_unregister_driver函数代码示例

int emapi_sdio_init(unsigned long arg)
{
	int rc = 0;
	unsigned long cmd;

	get_user(cmd, (unsigned long *) arg);

	switch (cmd) {
		case 0:
#ifdef CONFIG_WIFI_CONTROL_FUNC
			wifi_add_dev();
#else
			printk(KERN_CRIT "EMAPI: fail to power on\n");
#endif
			mdelay(50);
			break;
		case 1:
			if (emapi.sdio_status)
				sdio_unregister_driver(&emapi_sdio_drv);
#ifdef CONFIG_WIFI_CONTROL_FUNC
			wifi_del_dev();
#else	
			printk(KERN_CRIT "EMAPI: fail to power off\n");
#endif
			emapi.sdio_status = 0;
			mdelay(50);
			break;
		case 2:
			rc = sdio_register_driver(&emapi_sdio_drv);
			if (rc < 0) {
	   			printk("emapi sdio driver init error\n");
				goto error;
			}
			emapi.sdio_status = 1;
			break;
		default:
			printk("unkown command\n");
			rc = -EINVAL;
			goto error;
	};
	return rc;
error:
	if (emapi_sdio_drv.drv.bus != NULL)
		sdio_unregister_driver(&emapi_sdio_drv);
#ifdef CONFIG_WIFI_CONTROL_FUNC
	wifi_del_dev();
#else	
	printk(KERN_CRIT "EMAPI: fail to power off\n");
#endif
	return rc;
}

static void __exit rtw_drv_halt(void)
{
//	DBG_871X(KERN_INFO "+%s", __func__);
	RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("+rtw_drv_halt\n"));

	rtw_suspend_lock_uninit();
	drvpriv.drv_registered = _FALSE;

	sdio_unregister_driver(&drvpriv.r871xs_drv);

#if defined(CONFIG_CONCURRENT_MODE) || defined(CONFIG_DUALMAC_CONCURRENT)
	_rtw_mutex_free(&drvpriv.h2c_fwcmd_mutex);
	_rtw_mutex_free(&drvpriv.setch_mutex);
	_rtw_mutex_free(&drvpriv.setbw_mutex);
	_rtw_mutex_free(&drvpriv.hw_init_mutex);
#endif

#if defined(CONFIG_MMC_SUNXI_POWER_CONTROL)
	sunximmc_rescan_card(SDIOID, 0);
	rtl8189es_sdio_poweroff();
	printk("[rtl8189es] %s: remove card, power off.\n", __FUNCTION__);
#endif

//	DBG_871X(KERN_INFO "-%s", __func__);
	RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("-rtw_drv_halt\n"));
}

void
HIFShutDownDevice(HIF_DEVICE *device)
{
    AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: +HIFShutDownDevice\n"));
    if (device != NULL) {
        AR_DEBUG_ASSERT(device->func != NULL);
    } else {
            /* since we are unloading the driver anyways, reset all cards in case the SDIO card
             * is externally powered and we are unloading the SDIO stack.  This avoids the problem when
             * the SDIO stack is reloaded and attempts are made to re-enumerate a card that is already
             * enumerated */
        AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: HIFShutDownDevice, resetting\n"));
        ResetAllCards();

        /* Unregister with bus driver core */
        if (registered) {
            registered = 0;
            AR_DEBUG_PRINTF(ATH_DEBUG_TRACE,
                            ("AR6000: Unregistering with the bus driver\n"));
            sdio_unregister_driver(&ar6k_driver);
            AR_DEBUG_PRINTF(ATH_DEBUG_TRACE,
                            ("AR6000: Unregistered\n"));
        }
    }
    AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: -HIFShutDownDevice\n"));
}

/*
 * This function cleans up the SDIO driver.
 *
 * The following major steps are followed for cleanup -
 *      - Resume the device if its suspended
 *      - Disconnect the device if connected
 *      - Shutdown the firmware
 *      - Unregister the device from SDIO bus.
 */
static void
mwifiex_sdio_cleanup_module(void)
{
	struct mwifiex_adapter *adapter = g_adapter;
	int i;

	if (down_interruptible(&add_remove_card_sem))
		goto exit_sem_err;

	if (!adapter || !adapter->priv_num)
		goto exit;

	if (adapter->is_suspended)
		mwifiex_sdio_resume(adapter->dev);

	for (i = 0; i < adapter->priv_num; i++)
		if ((GET_BSS_ROLE(adapter->priv[i]) == MWIFIEX_BSS_ROLE_STA) &&
		    adapter->priv[i]->media_connected)
			mwifiex_deauthenticate(adapter->priv[i], NULL);

	if (!adapter->surprise_removed)
		mwifiex_init_shutdown_fw(mwifiex_get_priv(adapter,
							  MWIFIEX_BSS_ROLE_ANY),
					 MWIFIEX_FUNC_SHUTDOWN);

exit:
	up(&add_remove_card_sem);

exit_sem_err:
	sdio_unregister_driver(&mwifiex_sdio);
}

/* Init Module function -> Called by insmod */
static int __init cw1200_sdio_init(void)
{
	const struct cw1200_platform_data *pdata;
	int ret;

	pdata = cw1200_get_platform_data();

	ret = sdio_register_driver(&sdio_driver);
	if (ret)
		goto err_reg;

	if (pdata->power_ctrl) {
		ret = pdata->power_ctrl(pdata, true);
		if (ret)
			goto err_power;
	}

	ret = cw1200_sdio_on(pdata);
	if (ret)
		goto err_on;

	return 0;

err_on:
	if (pdata->power_ctrl)
		pdata->power_ctrl(pdata, false);
err_power:
	sdio_unregister_driver(&sdio_driver);
err_reg:
	return ret;
}

//static
//void __exit mtlte_sys_sdio_driver_exit(void)
void mtlte_sys_sdio_driver_exit(void)
{
    KAL_RAWPRINT(("[EXIT] =======> lte_sdio_driver_exit\n"));

    sdio_onoff_module_exit();

    KAL_DESTROYMUTEX(&lte_dev.thread_kick_lock) ;

    sdio_unregister_driver(&mtlte_driver);
    KAL_RAWPRINT(("[EXIT] sdio_unregister_driver OK. \n"));       


#if EMCS_SDIO_DRVTST		
    mtlte_dev_test_drvdeinit() ;    
    KAL_RAWPRINT(("[EXIT] mtlte_dev_test_drvdeinit OK. \n")); 
#endif   

    /* denit the expt layer */
    mtlte_expt_deinit() ;
    KAL_RAWPRINT(("[EXIT] mtlte_expt_deinit OK. \n")); 

    /* denit the data flow layer */
    mtlte_df_deinit() ;
    KAL_RAWPRINT(("[EXIT] mtlte_df_deinit OK. \n")); 

    /* denit the hif layer */
    mtlte_hif_sdio_deinit() ;
    KAL_RAWPRINT(("[EXIT] mtlte_hif_sdio_deinit OK. \n")); 

#ifdef MT_LTE_AUTO_CALIBRATION        
    autok_module_exit();
#endif

    KAL_RAWPRINT(("[EXIT] <======= lte_sdio_driver_exit\n"));
}

/** 
 *  @brief This function de-registers the bt module in bus driver.
 *  
 *  @return 	   N/A
 */
void
sbi_unregister(void)
{
    ENTER();
    unregister = TRUE;
    sdio_unregister_driver(&sdio_bt);
    LEAVE();
}

int sdio_detect_exit(void)
{
	g_func = NULL;
	//register to mmc driver
	sdio_unregister_driver(&mtk_sdio_client_drv);
	WMT_DETECT_INFO_FUNC("sdio_unregister_driver\n");
	return 0;
}

void sdio_function_cleanup(void)
{
	sd_trace(("%s Enter\n", __func__));

	sdio_unregister_driver(&bcmsdh_sdmmc_driver);

	kfree(gInstance);
}

/*
 * module cleanup
*/
void bcmsdh_unregister_client_driver(void)
{
	sdio_unregister_driver(&bcmsdh_sdmmc_driver);
#ifdef GLOBAL_SDMMC_INSTANCE
	if (gInstance)
		kfree(gInstance);
#endif
}

/* Called at Driver Unloading */
static void __exit cw1200_sdio_exit(void)
{
	const struct cw1200_platform_data *pdata;
	pdata = cw1200_get_platform_data();
	sdio_unregister_driver(&sdio_driver);
	cw1200_sdio_off(pdata);
	if (pdata->power_ctrl)
		pdata->power_ctrl(pdata, false);
}

/* Called at Driver Unloading */
static void __exit cw1200_sdio_exit(void)
{
	const struct cw1200_platform_data_sdio *pdata;

	/* FIXME -- this won't support multiple devices */
	pdata = global_plat_data;
	sdio_unregister_driver(&sdio_driver);
	cw1200_sdio_off(pdata);
}

void brcmf_sdio_exit(void)
{
	brcmf_dbg(SDIO, "Enter\n");

	if (brcmfmac_sdio_pdata)
		platform_driver_unregister(&brcmf_sdio_pd);
	else
		sdio_unregister_driver(&brcmf_sdmmc_driver);
}

void linux_sdio_deinit(void *pv)
{

	/**
	 *      TODO :
	 **/


	sdio_unregister_driver(&wilc_bus);
}

/**
 *  @brief This function de-registers the IF module in bus driver
 *
 *  @return         N/A
 */
void
woal_bus_unregister(void)
{
	ENTER();

	/* SDIO Driver Unregistration */
	sdio_unregister_driver(&wlan_sdio);

	LEAVE();
}