static int __init smssdio_module_init(void)
{
int ret = 0;
printk(KERN_INFO "smssdio: Siano SMS1xxx SDIO driver\n");
printk(KERN_INFO "smssdio: Copyright Pierre Ossman\n");
ret = sdio_register_driver(&smssdio_driver);
return ret;
}
/*
* module init
*/
int sdio_function_init(void)
{
int error = 0;
sd_trace(("bcmsdh_sdmmc: %s Enter\n", __FUNCTION__));
gInstance = kzalloc(sizeof(BCMSDH_SDMMC_INSTANCE), GFP_KERNEL);
if (!gInstance)
return -ENOMEM;
error = sdio_register_driver(&bcmsdh_sdmmc_driver);
return error;
}
/*
* module init
*/
int bcmsdh_register_client_driver(void)
{
gInstance = kzalloc(sizeof(BCMSDH_SDMMC_INSTANCE), GFP_KERNEL);
if (!gInstance)
return -ENOMEM;
#if !defined(OOB_INTR_ONLY)
mutex_init(&gInstance->claim_host_mutex); // terence 20140926: fix for claim host issue
#endif
return sdio_register_driver(&bcmsdh_sdmmc_driver);
}
static int __init wl1271_init(void)
{
int ret;
ret = sdio_register_driver(&wl1271_sdio_driver);
if (ret < 0) {
wl1271_error("failed to register sdio driver: %d", ret);
goto out;
}
out:
return ret;
}
static int __init iwmct_init(void)
{
int rc;
/* Default log filter settings */
iwmct_log_set_filter(LOG_SRC_ALL, LOG_SEV_FILTER_RUNTIME);
iwmct_log_set_filter(LOG_SRC_FW_MSG, LOG_SEV_FW_FILTER_ALL);
iwmct_log_set_fw_filter(LOG_SRC_ALL, FW_LOG_SEV_FILTER_RUNTIME);
rc = sdio_register_driver(&iwmct_driver);
return rc;
}
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 int __init wl1251_sdio_init(void)
{
int err;
err = platform_driver_register(&wl1251_platform_driver);
if (err) {
wl1251_error("failed to register platform driver: %d", err);
return err;
}
err = sdio_register_driver(&wl1251_sdio_driver);
if (err)
wl1251_error("failed to register sdio driver: %d", err);
return err;
}
/**
* @brief This function registers the bt module in bus driver.
*
* @return An int pointer that keeps returned value
*/
int *
sbi_register(void)
{
int *ret;
ENTER();
if (sdio_register_driver(&sdio_bt) != 0) {
PRINTM(FATAL, "BT: SD Driver Registration Failed \n");
LEAVE();
return NULL;
} else
ret = (int *) 1;
LEAVE();
return ret;
}
/**
* @brief This function registers the IF module in bus driver
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
mlan_status
woal_bus_register(void)
{
mlan_status ret = MLAN_STATUS_SUCCESS;
ENTER();
/* SDIO Driver Registration */
if (sdio_register_driver(&wlan_sdio)) {
PRINTM(MFATAL, "SDIO Driver Registration Failed \n");
LEAVE();
return MLAN_STATUS_FAILURE;
}
LEAVE();
return ret;
}
static int __init rtw_drv_entry(void)
{
int ret = 0;
/*depends on sunxi power control */
#if defined CONFIG_MMC_SUNXI_POWER_CONTROL
unsigned int mod_sel = mmc_pm_get_mod_type();
if(mod_sel == SUNXI_SDIO_WIFI_NUM_RTL8189ES) {
rtl8189es_sdio_powerup();
sunximmc_rescan_card(SDIOID, 1);
printk("[rtl8189es] %s: power up, rescan card.\n", __FUNCTION__);
} else {
ret = -1;
printk("[rtl8189es] %s: mod_sel = %d is incorrect.\n", __FUNCTION__, mod_sel);
}
#endif
if(ret != 0)
goto exit;
// DBG_871X(KERN_INFO "+%s", __func__);
RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("+rtw_drv_entry\n"));
DBG_871X(KERN_NOTICE DRV_NAME " driver version " DRIVERVERSION "\n");
rtw_suspend_lock_init();
#if defined(CONFIG_CONCURRENT_MODE) || defined(CONFIG_DUALMAC_CONCURRENT)
//init global variable
_rtw_mutex_init(&drvpriv.h2c_fwcmd_mutex);
_rtw_mutex_init(&drvpriv.setch_mutex);
_rtw_mutex_init(&drvpriv.setbw_mutex);
_rtw_mutex_init(&drvpriv.hw_init_mutex);
#endif
drvpriv.drv_registered = _TRUE;
ret = sdio_register_driver(&drvpriv.r871xs_drv);
exit:
// DBG_871X(KERN_INFO "-%s: ret=%d", __func__, ret);
RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("-rtw_drv_entry: ret=%d\n", ret));
return ret;
}
/* ------ Functions ------ */
int HIFInit(OSDRV_CALLBACKS *callbacks)
{
int r;
AR_DEBUG_ASSERT(callbacks != NULL);
A_REGISTER_MODULE_DEBUG_INFO(hif);
/* store the callback handlers */
osdrvCallbacks = *callbacks;
/* Register with bus driver core */
registered = 1;
r = sdio_register_driver(&ath6kl_hifdev_driver);
if (r < 0)
return r;
return 0;
}
/**
* @brief This function registers the bt module in bus driver.
*
* @return An int pointer that keeps returned value
*/
int *
sbi_register(void)
{
int *ret;
ENTER();
if (multi_fn == BIT(2))
sdio_bt.id_table = bt_fn2_ids;
if (sdio_register_driver(&sdio_bt) != 0) {
PRINTM(FATAL, "BT: SD Driver Registration Failed \n");
LEAVE();
return NULL;
} else
ret = (int *) 1;
LEAVE();
return ret;
}
/* ------ Functions ------ */
A_STATUS HIFInit(OSDRV_CALLBACKS *callbacks)
{
int status;
AR_DEBUG_ASSERT(callbacks != NULL);
/* store the callback handlers */
osdrvCallbacks = *callbacks;
/* Register with bus driver core */
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: HIFInit registering\n"));
registered = 1;
status = sdio_register_driver(&ar6k_driver);
AR_DEBUG_ASSERT(status==0);
if (status != 0) {
return A_ERROR;
}
return A_OK;
}
/*
* module init
*/
int sdio_function_init(void)
{
int error = 0;
sd_trace(("bcmsdh_sdmmc: %s Enter\n", __FUNCTION__));
gInstance = kzalloc(sizeof(BCMSDH_SDMMC_INSTANCE), GFP_KERNEL);
if (!gInstance)
return -ENOMEM;
bzero(&sdmmc_dev, sizeof(sdmmc_dev));
error = sdio_register_driver(&bcmsdh_sdmmc_driver);
#if defined(CONFIG_BRCM_LGE_WL_HOSTWAKEUP)
if (!error) {
dhd_register_early_suspend();
DHD_TRACE(("%s: registered with Android PM\n", __FUNCTION__));
}
#endif /* defined(CONFIG_BRCM_LGE_WL_HOSTWAKEUP) */
return error;
}
/* Init Module function -> Called by insmod */
static int __init cw1200_sdio_init(void)
{
const struct cw1200_platform_data_sdio *pdata;
int ret;
/* FIXME -- this won't support multiple devices */
pdata = global_plat_data;
if (cw1200_sdio_on(pdata)) {
ret = -1;
goto err;
}
ret = sdio_register_driver(&sdio_driver);
if (ret)
goto err;
return 0;
err:
cw1200_sdio_off(pdata);
return ret;
}
static int __init iwm_sdio_init_module(void)
{
return sdio_register_driver(&iwm_sdio_driver);
}
int sdio_func_reg_notify(void* semaphore)
{
notify_semaphore = semaphore;
return sdio_register_driver(&dummy_sdmmc_driver);
}
static int /*__init*/ esp_sdio_init(void)
{
#define ESP_WAIT_UP_TIME_MS 11000
int err;
u64 ver;
int retry = 3;
bool powerup = false;
int edf_ret = 0;
esp_dbg(ESP_DBG_TRACE, "%s \n", __func__);
#ifdef DRIVER_VER
ver = DRIVER_VER;
esp_dbg(ESP_SHOW, "\n***** EAGLE DRIVER VER:%llx*****\n\n", ver);
#endif
edf_ret = esp_debugfs_init();
request_init_conf();
esp_wakelock_init();
esp_wake_lock();
do {
sema_init(&esp_powerup_sem, 0);
sif_platform_target_poweron();
sif_platform_rescan_card(1);
err = sdio_register_driver(&esp_sdio_dummy_driver);
if (err) {
esp_dbg(ESP_DBG_ERROR, "eagle sdio driver registration failed, error code: %d\n", err);
goto _fail;
}
if (down_timeout(&esp_powerup_sem,
msecs_to_jiffies(ESP_WAIT_UP_TIME_MS)) == 0)
{
powerup = true;
msleep(200);
break;
}
esp_dbg(ESP_SHOW, "%s ------ RETRY ------ \n", __func__);
sif_record_retry_config();
sdio_unregister_driver(&esp_sdio_dummy_driver);
sif_platform_rescan_card(0);
sif_platform_target_poweroff();
} while (retry--);
if (!powerup) {
esp_dbg(ESP_DBG_ERROR, "eagle sdio can not power up!\n");
err = -ENODEV;
goto _fail;
}
esp_dbg(ESP_SHOW, "%s power up OK\n", __func__);
sdio_unregister_driver(&esp_sdio_dummy_driver);
sif_sdio_state = ESP_SDIO_STATE_FIRST_INIT;
sema_init(&esp_powerup_sem, 0);
sdio_register_driver(&esp_sdio_driver);
if ((down_timeout(&esp_powerup_sem,
msecs_to_jiffies(ESP_WAIT_UP_TIME_MS)) == 0 ) && sif_get_ate_config() == 0) {
if(sif_sdio_state == ESP_SDIO_STATE_FIRST_NORMAL_EXIT){
sdio_unregister_driver(&esp_sdio_driver);
sif_platform_rescan_card(0);
msleep(100);
sif_platform_rescan_card(1);
sif_sdio_state = ESP_SDIO_STATE_SECOND_INIT;
sdio_register_driver(&esp_sdio_driver);
}
}
esp_register_early_suspend();
esp_wake_unlock();
return err;
_fail:
esp_wake_unlock();
esp_wakelock_destroy();
return err;
}
//static
//KAL_INT32 __init mtlte_sys_sdio_driver_init(void)
int mtlte_sys_sdio_driver_init(void)
{
int ret = KAL_SUCCESS ;
KAL_RAWPRINT(("[INIT] =======> lte_sdio_driver_init\n"));
lte_dev.card_exist = 0 ;
lte_dev.sdio_func = NULL;
/* init thread related parameters */
init_waitqueue_head(<e_dev.sdio_thread_wq);
#ifdef MT_LTE_AUTO_CALIBRATION
autok_module_init();
#endif
/* init the hif layer */
if ((ret = mtlte_hif_sdio_init()) != KAL_SUCCESS){
KAL_RAWPRINT(("[INIT] XXXXXX lte_sdio_driver_init -mtlte_hif_sdio_init fail \n"));
goto HIF_INITFAIL ;
}
/* init the data flow layer */
if ((ret = mtlte_df_init()) != KAL_SUCCESS){
KAL_RAWPRINT(("[INIT] XXXXXX lte_sdio_driver_init -mtlte_df_init fail \n"));
goto DF_INITFAIL ;
}
if ((ret = mtlte_expt_init()) != KAL_SUCCESS){
KAL_RAWPRINT(("[INIT] XXXXXX lte_sdio_driver_init -mtlte_expt_init fail \n"));
goto DF_INITFAIL ;
}
#if EMCS_SDIO_DRVTST
if ((ret = mtlte_dev_test_drvinit()) != KAL_SUCCESS){
KAL_RAWPRINT(("[INIT] XXXXXX lte_sdio_driver_init -mtlte_dev_test_drvinit fail \n"));
goto TEST_DRV_INITFAIL ;
}
#endif
if ((ret = sdio_register_driver(&mtlte_driver)) != KAL_SUCCESS){
KAL_RAWPRINT(("[INIT] XXXXXX lte_sdio_driver_init -sdio_register_driver fail \n"));
goto SDIO_REG_FAIL ;
}
KAL_AQUIREMUTEX(<e_dev.thread_kick_lock) ;
if ((ret = sdio_onoff_module_init()) != KAL_SUCCESS){
KAL_RAWPRINT(("[INIT] XXXXXX lte_sdio_driver_init - onoff_char_dev register fail \n"));
goto ONOFF_DEV_FAIL ;
}
KAL_RAWPRINT(("[INIT] <======= lte_sdio_driver_init\n"));
return ret ;
ONOFF_DEV_FAIL:
sdio_unregister_driver(&mtlte_driver);
SDIO_REG_FAIL :
#if EMCS_SDIO_DRVTST
mtlte_dev_test_drvdeinit() ;
TEST_DRV_INITFAIL :
#endif
mtlte_df_deinit() ;
DF_INITFAIL :
mtlte_hif_sdio_deinit() ;
HIF_INITFAIL :
KAL_RAWPRINT(("[INIT FAIL] <======= lte_sdio_driver_init\n"));
return ret ;
}
static int __init wl1271_init(void)
{
return sdio_register_driver(&wl1271_sdio_driver);
}
/* bus register interface */
int brcmf_bus_register(void)
{
brcmf_dbg(TRACE, "Enter\n");
return sdio_register_driver(&brcmf_sdmmc_driver);
}
/*
* module init
*/
int bcmsdh_register_client_driver(void)
{
return sdio_register_driver(&bcmsdh_sdmmc_driver);
}
static int wimax_probe(struct platform_device *pdev)
{
struct wimax732_platform_data *pdata = pdev->dev.platform_data;
struct device *dev_t;
int error = 0;
int err;
int i;
dump_debug("SDIO driver installing... " WIMAX_DRIVER_VERSION_STRING);
pdata->swmxctl_dev.minor = SWMXGPIOMINOR;
pdata->swmxctl_dev.name = "swmxctl";
pdata->swmxctl_dev.fops = &swmx_fops;
mutex_init(&pdata->g_cfg->power_mutex);
mutex_init(&pdata->g_cfg->rx_lock);
misc_register(&pdata->swmxctl_dev);
if (error < 0) {
dump_debug("misc_register() failed");
return error;
}
for (i = 0; i < ARRAY_SIZE(adapter_table); i++)
adapter_table[i].driver_data =
(unsigned long) pdev->dev.platform_data;
/* register SDIO driver */
error = sdio_register_driver(&adapter_driver);
if (error < 0) {
dump_debug("sdio_register_driver() failed");
return error;
}
pdata->g_cfg->card_removed = true;
pdata->g_cfg->wimax_suspend_prepare = false;
cmc7xx_register_pm_notifier(pdata);
pdata->power(0);
/*Wimax sys entry*/
pdata->wimax_class = class_create(THIS_MODULE, "wimax");
if (IS_ERR(pdata->wimax_class))
dump_debug("%s: class create"
" failed\n", __func__);
dev_t = device_create(pdata->wimax_class, NULL,
MKDEV(SWMXGPIOMINOR, 0), "%s", "cmc732");
if (IS_ERR(dev_t)) {
dump_debug("%s: class create"
" failed\n", __func__);
}
err = device_create_file(dev_t, &dev_attr_eeprom);
if (err < 0) {
dump_debug("%s: Failed to create device file(%s)\n",
__func__, dev_attr_eeprom.attr.name);
}
err = device_create_file(dev_t, &dev_attr_onoff);
if (err < 0) {
dump_debug("%s: Failed to create device file(%s)\n",
__func__, dev_attr_onoff.attr.name);
}
err = device_create_file(dev_t, &dev_attr_wmxuart);
if (err < 0) {
dump_debug("%s: Failed to create device file(%s)\n",
__func__, dev_attr_wmxuart.attr.name);
}
err = device_create_file(dev_t, &dev_attr_dump);
if (err < 0) {
dump_debug("%s: Failed to create device file(%s)\n",
__func__, dev_attr_dump.attr.name);
}
err = device_create_file(dev_t, &dev_attr_sleepmode);
if (err < 0) {
dump_debug("%s: Failed to create device file(%s)\n",
__func__, dev_attr_sleepmode.attr.name);
}
dev_set_drvdata(dev_t, pdata);
/* End of Sysfs */
#ifndef DRIVER_BIT_BANG
if (wmxeeprom_init())
dump_debug("wmxeeprom_init() failed");
#endif
/* initialize wake locks */
wake_lock_init(&pdata->g_cfg->wimax_wake_lock,
WAKE_LOCK_SUSPEND, "wimax_wakeup");
wake_lock_init(&pdata->g_cfg->wimax_rxtx_lock,
WAKE_LOCK_SUSPEND, "wimax_rxtx");
wake_lock_init(&pdata->g_cfg->wimax_tx_lock,
WAKE_LOCK_SUSPEND, "wimax_tx");
return error;
}
