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; }