/****************************************************************************** * * Copyright(c) 2007 - 2019 Realtek Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms of version 2 of the GNU General Public License as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for * more details. * *****************************************************************************/ #define _HCI_INTF_C_ #include #include #include #ifndef CONFIG_SDIO_HCI #error "CONFIG_SDIO_HCI shall be on!\n" #endif #ifdef CONFIG_RTL8822B #include /* rtl8822bs_set_hal_ops() */ #endif /* CONFIG_RTL8822B */ #ifdef CONFIG_RTL8822C #include #endif /* CONFIG_RTL8822C */ #ifdef CONFIG_RTL8723F #include /* rtl8723fs_set_hal_ops() */ #endif /* CONFIG_RTL8723F */ #ifdef CONFIG_PLATFORM_INTEL_BYT #ifdef CONFIG_ACPI #include #include #include "rtw_android.h" #endif static int wlan_en_gpio = -1; #endif /* CONFIG_PLATFORM_INTEL_BYT */ #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[] = { #ifdef CONFIG_RTL8723B { SDIO_DEVICE(0x024c, 0xB723), .driver_data = RTL8723B}, #endif #ifdef CONFIG_RTL8188E { SDIO_DEVICE(0x024c, 0x8179), .driver_data = RTL8188E}, #endif /* CONFIG_RTL8188E */ #ifdef CONFIG_RTL8821A { SDIO_DEVICE(0x024c, 0x8821), .driver_data = RTL8821}, #endif /* CONFIG_RTL8821A */ #ifdef CONFIG_RTL8192E { SDIO_DEVICE(0x024c, 0x818B), .driver_data = RTL8192E}, #endif /* CONFIG_RTL8192E */ #ifdef CONFIG_RTL8703B { SDIO_DEVICE(0x024c, 0xB703), .driver_data = RTL8703B}, #endif #ifdef CONFIG_RTL8188F {SDIO_DEVICE(0x024c, 0xF179), .driver_data = RTL8188F}, #endif #ifdef CONFIG_RTL8188GTV {SDIO_DEVICE(0x024c, 0x018C), .driver_data = RTL8188GTV}, #endif #ifdef CONFIG_RTL8822B {SDIO_DEVICE(0x024c, 0xB822), .driver_data = RTL8822B}, #endif #ifdef CONFIG_RTL8723D { SDIO_DEVICE(0x024c, 0xD723), .driver_data = RTL8723D}, { SDIO_DEVICE(0x024c, 0xD724), .driver_data = RTL8723D}, #endif #ifdef CONFIG_RTL8192F { SDIO_DEVICE(0x024c, 0x818C), .driver_data = RTL8192F},/*A CUT*/ { SDIO_DEVICE(0x024c, 0xF192), .driver_data = RTL8192F},/*B CUT*/ { SDIO_DEVICE(0x024c, 0xA725), .driver_data = RTL8192F},/*8725AS*/ #endif /* CONFIG_RTL8192F */ #ifdef CONFIG_RTL8821C {SDIO_DEVICE(0x024C, 0xB821), .driver_data = RTL8821C}, {SDIO_DEVICE(0x024C, 0xC821), .driver_data = RTL8821C}, {SDIO_DEVICE(0x024C, 0x8733), .driver_data = RTL8821C}, /* 8733AS */ {SDIO_DEVICE(0x024C, 0xC80C), .driver_data = RTL8821C}, /* 8821CSH-VQ */ #endif #ifdef CONFIG_RTL8822C {SDIO_DEVICE(0x024c, 0xC822), .class = SDIO_CLASS_WLAN, .driver_data = RTL8822C}, {SDIO_DEVICE(0x024c, 0xD821), .class = SDIO_CLASS_WLAN, .driver_data = RTL8822C}, /* 8821DS */ #endif #ifdef CONFIG_RTL8723F {SDIO_DEVICE(0x024c, 0xB733), .class = SDIO_CLASS_WLAN, .driver_data = RTL8723F}, #endif #if defined(RTW_ENABLE_WIFI_CONTROL_FUNC) /* temporarily add this to accept all sdio wlan id */ { SDIO_DEVICE_CLASS(SDIO_CLASS_WLAN) }, #endif { /* end: all zeroes */ }, }; MODULE_DEVICE_TABLE(sdio, sdio_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); #ifdef CONFIG_SDIO_HOOK_DEV_SHUTDOWN static void rtw_dev_shutdown(struct device *dev); #endif static int rtw_sdio_resume(struct device *dev); static int rtw_sdio_suspend(struct device *dev); extern void rtw_dev_unload(PADAPTER padapter); #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29)) static const struct dev_pm_ops rtw_sdio_pm_ops = { .suspend = rtw_sdio_suspend, .resume = rtw_sdio_resume, }; #endif 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 = (char *)DRV_NAME, .r871xs_drv.id_table = sdio_ids, .r871xs_drv.drv = { #ifdef CONFIG_SDIO_HOOK_DEV_SHUTDOWN .shutdown = rtw_dev_shutdown, #endif #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29)) .pm = &rtw_sdio_pm_ops, #endif } }; static struct rtw_if_operations sdio_ops = { .read = rtw_sdio_raw_read, .write = rtw_sdio_raw_write, }; static void sd_sync_int_hdl(struct sdio_func *func) { struct dvobj_priv *psdpriv; psdpriv = sdio_get_drvdata(func); if (!dvobj_get_primary_adapter(psdpriv)) { RTW_INFO("%s primary adapter == NULL\n", __func__); return; } rtw_sdio_set_irq_thd(psdpriv, current); sd_int_hdl(dvobj_get_primary_adapter(psdpriv)); rtw_sdio_set_irq_thd(psdpriv, NULL); } 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++; RTW_PRINT("%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; } 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++; RTW_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; extern unsigned int oob_gpio; static irqreturn_t gpio_hostwakeup_irq_thread(int irq, void *data) { PADAPTER padapter = (PADAPTER)data; RTW_PRINT("gpio_hostwakeup_irq_thread\n"); /* Disable interrupt before calling handler */ /* disable_irq_nosync(oob_irq); */ #ifdef CONFIG_PLATFORM_ARM_SUN6I return 0; #else return IRQ_HANDLED; #endif } static u8 gpio_hostwakeup_alloc_irq(PADAPTER padapter) { int err; u32 status = 0; if (oob_irq == 0) { RTW_INFO("oob_irq ZERO!\n"); return _FAIL; } RTW_INFO("%s : oob_irq = %d\n", __func__, oob_irq); #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 32)) status = IRQF_NO_SUSPEND; #endif if (HIGH_ACTIVE_DEV2HST) status |= IRQF_TRIGGER_RISING; else status |= IRQF_TRIGGER_FALLING; err = request_threaded_irq(oob_irq, gpio_hostwakeup_irq_thread, NULL, status, "rtw_wifi_gpio_wakeup", padapter); if (err < 0) { RTW_INFO("Oops: can't allocate gpio irq %d err:%d\n", oob_irq, err); return _FALSE; } else RTW_INFO("allocate gpio irq %d ok\n", oob_irq); #ifndef CONFIG_PLATFORM_ARM_SUN8I enable_irq_wake(oob_irq); #endif return _SUCCESS; } static void gpio_hostwakeup_free_irq(PADAPTER padapter) { wifi_free_gpio(oob_gpio); if (oob_irq == 0) return; #ifndef CONFIG_PLATFORM_ARM_SUN8I disable_irq_wake(oob_irq); #endif free_irq(oob_irq, padapter); } #endif void dump_sdio_card_info(void *sel, struct dvobj_priv *dvobj) { PSDIO_DATA psdio_data = &dvobj->intf_data; struct mmc_card *card = psdio_data->card; int i; RTW_PRINT_SEL(sel, "== SDIO Card Info ==\n"); RTW_PRINT_SEL(sel, " card: %p\n", card); RTW_PRINT_SEL(sel, " clock: %d Hz\n", psdio_data->clock); RTW_PRINT_SEL(sel, " timing spec: "); switch (psdio_data->timing) { case MMC_TIMING_LEGACY: _RTW_PRINT_SEL(sel, "legacy"); break; case MMC_TIMING_MMC_HS: _RTW_PRINT_SEL(sel, "mmc high-speed"); break; case MMC_TIMING_SD_HS: _RTW_PRINT_SEL(sel, "sd high-speed"); break; #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 0, 0) #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 8, 0) case MMC_TIMING_UHS_SDR12: _RTW_PRINT_SEL(sel, "sd uhs SDR12"); break; case MMC_TIMING_UHS_SDR25: _RTW_PRINT_SEL(sel, "sd uhs SDR25"); break; #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3, 8, 0) */ case MMC_TIMING_UHS_SDR50: _RTW_PRINT_SEL(sel, "sd uhs SDR50"); break; #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 16, 0) case MMC_TIMING_MMC_DDR52: _RTW_PRINT_SEL(sel, "mmc DDR52"); break; #endif case MMC_TIMING_UHS_SDR104: _RTW_PRINT_SEL(sel, "sd uhs SDR104"); break; case MMC_TIMING_UHS_DDR50: _RTW_PRINT_SEL(sel, "sd uhs DDR50"); break; #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 3, 0) case MMC_TIMING_MMC_HS200: _RTW_PRINT_SEL(sel, "mmc HS200"); break; #endif #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 16, 0) case MMC_TIMING_MMC_HS400: _RTW_PRINT_SEL(sel, "mmc HS400"); break; #endif #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3, 0, 0) */ default: _RTW_PRINT_SEL(sel, "unknown(%d)", psdio_data->timing); break; } _RTW_PRINT_SEL(sel, "\n"); RTW_PRINT_SEL(sel, " sd3_bus_mode: %s\n", (psdio_data->sd3_bus_mode) ? "TRUE" : "FALSE"); rtw_warn_on(card->sdio_funcs != sdio_get_num_of_func(dvobj)); RTW_PRINT_SEL(sel, " func num: %u\n", card->sdio_funcs); for (i = 0; card->sdio_func[i]; i++) { RTW_PRINT_SEL(sel, " func%u: %p%s\n" , card->sdio_func[i]->num, card->sdio_func[i] , psdio_data->func == card->sdio_func[i] ? " (*)" : ""); } RTW_PRINT_SEL(sel, "================\n"); } #define SDIO_CARD_INFO_DUMP(dvobj) dump_sdio_card_info(RTW_DBGDUMP, dvobj) #ifdef DBG_SDIO #if (DBG_SDIO >= 2) void rtw_sdio_dbg_reg_free(struct dvobj_priv *d) { struct sdio_data *sdio; u8 *buf; u32 size; sdio = &d->intf_data; buf = sdio->dbg_msg; size = sdio->dbg_msg_size; if (buf){ sdio->dbg_msg = NULL; sdio->dbg_msg_size = 0; rtw_mfree(buf, size); } buf = sdio->reg_mac; if (buf) { sdio->reg_mac = NULL; rtw_mfree(buf, 0x800); } buf = sdio->reg_mac_ext; if (buf) { sdio->reg_mac_ext = NULL; rtw_mfree(buf, 0x800); } buf = sdio->reg_local; if (buf) { sdio->reg_local = NULL; rtw_mfree(buf, 0x100); } buf = sdio->reg_cia; if (buf) { sdio->reg_cia = NULL; rtw_mfree(buf, 0x200); } } void rtw_sdio_dbg_reg_alloc(struct dvobj_priv *d) { struct sdio_data *sdio; u8 *buf; sdio = &d->intf_data; buf = _rtw_zmalloc(0x800); if (buf) sdio->reg_mac = buf; buf = _rtw_zmalloc(0x800); if (buf) sdio->reg_mac_ext = buf; buf = _rtw_zmalloc(0x100); if (buf) sdio->reg_local = buf; buf = _rtw_zmalloc(0x200); if (buf) sdio->reg_cia = buf; } #endif /* DBG_SDIO >= 2 */ static void sdio_dbg_init(struct dvobj_priv *d) { struct sdio_data *sdio; sdio = &d->intf_data; sdio->cmd52_err_cnt = 0; sdio->cmd53_err_cnt = 0; #if (DBG_SDIO >= 1) sdio->reg_dump_mark = 0; #endif /* DBG_SDIO >= 1 */ #if (DBG_SDIO >= 3) sdio->dbg_enable = 0; sdio->err_stop = 0; sdio->err_test = 0; sdio->err_test_triggered = 0; #endif /* DBG_SDIO >= 3 */ } static void sdio_dbg_deinit(struct dvobj_priv *d) { #if (DBG_SDIO >= 2) rtw_sdio_dbg_reg_free(d); #endif /* DBG_SDIO >= 2 */ } #endif /* DBG_SDIO */ 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++; RTW_PRINT("%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++; RTW_PRINT("%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; psdio_data->card = func->card; psdio_data->timing = func->card->host->ios.timing; psdio_data->clock = func->card->host->ios.clock; psdio_data->func_number = func->card->sdio_funcs; psdio_data->sd3_bus_mode = _FALSE; #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 0, 0) if (psdio_data->timing <= MMC_TIMING_UHS_DDR50 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 8, 0) && psdio_data->timing >= MMC_TIMING_UHS_SDR12 #else && psdio_data->timing >= MMC_TIMING_UHS_SDR50 #endif ) psdio_data->sd3_bus_mode = _TRUE; #endif #ifdef DBG_SDIO sdio_dbg_init(dvobj); #endif /* DBG_SDIO */ SDIO_CARD_INFO_DUMP(dvobj); release: sdio_release_host(func); if (err) return _FAIL; return _SUCCESS; } void sdio_deinit(struct dvobj_priv *dvobj) { struct sdio_func *func; int err; 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++; RTW_ERR("%s: sdio_disable_func(%d)\n", __func__, err); } sdio_release_host(func); } #ifdef DBG_SDIO sdio_dbg_deinit(dvobj); #endif /* DBG_SDIO */ } u8 sdio_get_num_of_func(struct dvobj_priv *dvobj) { return dvobj->intf_data.func_number; } static void rtw_decide_chip_type_by_device_id(struct dvobj_priv *dvobj, const struct sdio_device_id *pdid) { dvobj->chip_type = pdid->driver_data; #if defined(CONFIG_RTL8188E) if (dvobj->chip_type == RTL8188E) { dvobj->HardwareType = HARDWARE_TYPE_RTL8188ES; RTW_INFO("CHIP TYPE: RTL8188E\n"); } #endif #if defined(CONFIG_RTL8723B) if (dvobj->chip_type == RTL8723B) { dvobj->HardwareType = HARDWARE_TYPE_RTL8723BS; RTW_INFO("CHIP TYPE: RTL8723B\n"); } #endif #if defined(CONFIG_RTL8821A) if (dvobj->chip_type == RTL8821) { dvobj->HardwareType = HARDWARE_TYPE_RTL8821S; RTW_INFO("CHIP TYPE: RTL8821A\n"); } #endif #if defined(CONFIG_RTL8192E) if (dvobj->chip_type == RTL8192E) { dvobj->HardwareType = HARDWARE_TYPE_RTL8192ES; RTW_INFO("CHIP TYPE: RTL8192E\n"); } #endif #if defined(CONFIG_RTL8703B) if (dvobj->chip_type == RTL8703B) { dvobj->HardwareType = HARDWARE_TYPE_RTL8703BS; RTW_INFO("CHIP TYPE: RTL8703B\n"); } #endif #if defined(CONFIG_RTL8723D) if (dvobj->chip_type == RTL8723D) { dvobj->HardwareType = HARDWARE_TYPE_RTL8723DS; RTW_INFO("CHIP TYPE: RTL8723D\n"); } #endif #if defined(CONFIG_RTL8188F) if (dvobj->chip_type == RTL8188F) { dvobj->HardwareType = HARDWARE_TYPE_RTL8188FS; RTW_INFO("CHIP TYPE: RTL8188F\n"); } #endif #if defined(CONFIG_RTL8188GTV) if (dvobj->chip_type == RTL8188GTV) { dvobj->HardwareType = HARDWARE_TYPE_RTL8188GTVS; RTW_INFO("CHIP TYPE: RTL8188GTV\n"); } #endif #if defined(CONFIG_RTL8822B) if (dvobj->chip_type == RTL8822B) { dvobj->HardwareType = HARDWARE_TYPE_RTL8822BS; RTW_INFO("CHIP TYPE: RTL8822B\n"); } #endif #if defined(CONFIG_RTL8821C) if (dvobj->chip_type == RTL8821C) { dvobj->HardwareType = HARDWARE_TYPE_RTL8821CS; RTW_INFO("CHIP TYPE: RTL8821C\n"); } #endif #if defined(CONFIG_RTL8192F) if (dvobj->chip_type == RTL8192F) { dvobj->HardwareType = HARDWARE_TYPE_RTL8192FS; RTW_INFO("CHIP TYPE: RTL8192F\n"); } #endif #if defined(CONFIG_RTL8822C) if (dvobj->chip_type == RTL8822C) { dvobj->HardwareType = HARDWARE_TYPE_RTL8822CS; RTW_INFO("CHIP TYPE: RTL8822C\n"); } #endif #if defined(CONFIG_RTL8723F) if (dvobj->chip_type == RTL8723F) { dvobj->HardwareType = HARDWARE_TYPE_RTL8723FS; RTW_INFO("CHIP TYPE: RTL8723F\n"); } #endif } static struct dvobj_priv *sdio_dvobj_init(struct sdio_func *func, const struct sdio_device_id *pdid) { int status = _FAIL; struct dvobj_priv *dvobj = NULL; PSDIO_DATA psdio; dvobj = devobj_init(); if (dvobj == NULL) goto exit; dvobj->intf_ops = &sdio_ops; sdio_set_drvdata(func, dvobj); psdio = &dvobj->intf_data; psdio->func = func; if (sdio_init(dvobj) != _SUCCESS) { goto free_dvobj; } dvobj->interface_type = RTW_SDIO; rtw_decide_chip_type_by_device_id(dvobj, pdid); 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); sdio_free_irq(dvobj); devobj_deinit(dvobj); } return; } u8 rtw_set_hal_ops(PADAPTER padapter) { /* alloc memory for HAL DATA */ if (rtw_hal_data_init(padapter) == _FAIL) return _FAIL; #if defined(CONFIG_RTL8188E) if (rtw_get_chip_type(padapter) == RTL8188E) rtl8188es_set_hal_ops(padapter); #endif #if defined(CONFIG_RTL8723B) if (rtw_get_chip_type(padapter) == RTL8723B) rtl8723bs_set_hal_ops(padapter); #endif #if defined(CONFIG_RTL8821A) if (rtw_get_chip_type(padapter) == RTL8821) rtl8821as_set_hal_ops(padapter); #endif #if defined(CONFIG_RTL8192E) if (rtw_get_chip_type(padapter) == RTL8192E) rtl8192es_set_hal_ops(padapter); #endif #if defined(CONFIG_RTL8703B) if (rtw_get_chip_type(padapter) == RTL8703B) rtl8703bs_set_hal_ops(padapter); #endif #if defined(CONFIG_RTL8723D) if (rtw_get_chip_type(padapter) == RTL8723D) rtl8723ds_set_hal_ops(padapter); #endif #if defined(CONFIG_RTL8188F) if (rtw_get_chip_type(padapter) == RTL8188F) rtl8188fs_set_hal_ops(padapter); #endif #if defined(CONFIG_RTL8188GTV) if (rtw_get_chip_type(padapter) == RTL8188GTV) rtl8188gtvs_set_hal_ops(padapter); #endif #if defined(CONFIG_RTL8822B) if (rtw_get_chip_type(padapter) == RTL8822B) rtl8822bs_set_hal_ops(padapter); #endif #if defined(CONFIG_RTL8821C) if (rtw_get_chip_type(padapter) == RTL8821C) { if (rtl8821cs_set_hal_ops(padapter) == _FAIL) return _FAIL; } #endif #if defined(CONFIG_RTL8192F) if (rtw_get_chip_type(padapter) == RTL8192F) rtl8192fs_set_hal_ops(padapter); #endif #if defined(CONFIG_RTL8822C) if (rtw_get_chip_type(padapter) == RTL8822C) rtl8822cs_set_hal_ops(padapter); #endif #if defined(CONFIG_RTL8723F) if (rtw_get_chip_type(padapter) == RTL8723F) rtl8723fs_set_hal_ops(padapter); #endif if (rtw_hal_ops_check(padapter) == _FAIL) return _FAIL; if (hal_spec_init(padapter) == _FAIL) return _FAIL; return _SUCCESS; } static void sd_intf_start(PADAPTER padapter) { if (padapter == NULL) { RTW_ERR("%s: padapter is NULL!\n", __func__); return; } /* hal dep */ rtw_hal_enable_interrupt(padapter); } static void sd_intf_stop(PADAPTER padapter) { if (padapter == NULL) { RTW_ERR("%s: padapter is NULL!\n", __func__); return; } /* hal dep */ rtw_hal_disable_interrupt(padapter); } #ifdef RTW_SUPPORT_PLATFORM_SHUTDOWN PADAPTER g_test_adapter = NULL; #endif /* RTW_SUPPORT_PLATFORM_SHUTDOWN */ _adapter *rtw_sdio_primary_adapter_init(struct dvobj_priv *dvobj) { int status = _FAIL; PADAPTER padapter = NULL; padapter = (_adapter *)rtw_zvmalloc(sizeof(*padapter)); if (padapter == NULL) goto exit; if (loadparam(padapter) != _SUCCESS) goto free_adapter; #ifdef RTW_SUPPORT_PLATFORM_SHUTDOWN g_test_adapter = padapter; #endif /* RTW_SUPPORT_PLATFORM_SHUTDOWN */ padapter->dvobj = dvobj; rtw_set_drv_stopped(padapter);/*init*/ dvobj->padapters[dvobj->iface_nums++] = padapter; padapter->iface_id = IFACE_ID0; /* set adapter_type/iface type for primary padapter */ padapter->isprimary = _TRUE; padapter->adapter_type = PRIMARY_ADAPTER; #ifdef CONFIG_MI_WITH_MBSSID_CAM padapter->hw_port = HW_PORT0; #else padapter->hw_port = HW_PORT0; #endif /* 3 3. init driver special setting, interface, OS and hardware relative */ /* 4 3.1 set hardware operation functions */ if (rtw_set_hal_ops(padapter) == _FAIL) goto free_hal_data; /* 3 5. initialize Chip version */ padapter->intf_start = &sd_intf_start; padapter->intf_stop = &sd_intf_stop; if (rtw_init_io_priv(padapter, sdio_set_intf_ops) == _FAIL) { goto free_hal_data; } rtw_hal_read_chip_version(padapter); rtw_hal_chip_configure(padapter); #ifdef CONFIG_BT_COEXIST rtw_btcoex_Initialize(padapter); #endif rtw_btcoex_wifionly_initialize(padapter); /* 3 6. read efuse/eeprom data */ if (rtw_hal_read_chip_info(padapter) == _FAIL) goto free_hal_data; /* 3 7. init driver common data */ if (rtw_init_drv_sw(padapter) == _FAIL) { goto free_hal_data; } /* 3 8. get WLan MAC address */ /* set mac addr */ rtw_macaddr_cfg(adapter_mac_addr(padapter), get_hal_mac_addr(padapter)); #ifdef CONFIG_MI_WITH_MBSSID_CAM rtw_mbid_camid_alloc(padapter, adapter_mac_addr(padapter)); #endif #ifdef CONFIG_P2P rtw_init_wifidirect_addrs(padapter, adapter_mac_addr(padapter), adapter_mac_addr(padapter)); #endif /* CONFIG_P2P */ rtw_hal_disable_interrupt(padapter); RTW_INFO("bDriverStopped:%s, bSurpriseRemoved:%s, bup:%d, hw_init_completed:%d\n" , rtw_is_drv_stopped(padapter) ? "True" : "False" , rtw_is_surprise_removed(padapter) ? "True" : "False" , padapter->bup , rtw_get_hw_init_completed(padapter) ); status = _SUCCESS; free_hal_data: if (status != _SUCCESS && padapter->HalData) rtw_hal_free_data(padapter); free_adapter: if (status != _SUCCESS && padapter) { #ifdef RTW_HALMAC rtw_halmac_deinit_adapter(dvobj); #endif rtw_vmfree((u8 *)padapter, sizeof(*padapter)); padapter = NULL; } exit: return padapter; } static void rtw_sdio_primary_adapter_deinit(_adapter *padapter) { struct mlme_priv *pmlmepriv = &padapter->mlmepriv; if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE)) rtw_disassoc_cmd(padapter, 0, RTW_CMDF_DIRECTLY); #ifdef CONFIG_AP_MODE if (MLME_IS_AP(padapter) || MLME_IS_MESH(padapter)) { free_mlme_ap_info(padapter); #ifdef CONFIG_HOSTAPD_MLME hostapd_mode_unload(padapter); #endif } #endif #ifdef CONFIG_GPIO_WAKEUP #ifdef CONFIG_PLATFORM_ARM_SUN6I sw_gpio_eint_set_enable(gpio_eint_wlan, 0); sw_gpio_irq_free(eint_wlan_handle); #else gpio_hostwakeup_free_irq(padapter); #endif #endif /*rtw_cancel_all_timer(if1);*/ #ifdef CONFIG_WOWLAN adapter_to_pwrctl(padapter)->wowlan_mode = _FALSE; RTW_PRINT("%s wowlan_mode:%d\n", __func__, adapter_to_pwrctl(padapter)->wowlan_mode); #endif /* CONFIG_WOWLAN */ rtw_dev_unload(padapter); RTW_INFO("+r871xu_dev_remove, hw_init_completed=%d\n", rtw_get_hw_init_completed(padapter)); rtw_free_drv_sw(padapter); /* TODO: use rtw_os_ndevs_deinit instead at the first stage of driver's dev deinit function */ rtw_os_ndev_free(padapter); #ifdef RTW_HALMAC rtw_halmac_deinit_adapter(adapter_to_dvobj(padapter)); #endif /* RTW_HALMAC */ rtw_vmfree((u8 *)padapter, sizeof(_adapter)); #ifdef CONFIG_PLATFORM_RTD2880B RTW_INFO("wlan link down\n"); rtd2885_wlan_netlink_sendMsg("linkdown", "8712"); #endif #ifdef RTW_SUPPORT_PLATFORM_SHUTDOWN g_test_adapter = NULL; #endif /* RTW_SUPPORT_PLATFORM_SHUTDOWN */ } /* * 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; #ifdef CONFIG_CONCURRENT_MODE int i; #endif PADAPTER padapter = NULL; struct dvobj_priv *dvobj; #ifdef CONFIG_PLATFORM_INTEL_BYT #ifdef CONFIG_ACPI acpi_handle handle; struct acpi_device *adev; #endif #if defined(CONFIG_ACPI) && defined(CONFIG_GPIO_WAKEUP) handle = ACPI_HANDLE(&func->dev); if (handle) { /* Dont try to do acpi pm for the wifi module */ if (!handle || acpi_bus_get_device(handle, &adev)) RTW_INFO("Could not get acpi pointer!\n"); else { adev->flags.power_manageable = 0; RTW_INFO("Disabling ACPI power management support!\n"); } oob_gpio = acpi_get_gpio_by_index(&func->dev, 0, NULL); RTW_INFO("rtw_drv_init: ACPI_HANDLE found oob_gpio %d!\n", oob_gpio); wifi_configure_gpio(); } else RTW_INFO("rtw_drv_init: ACPI_HANDLE NOT found!\n"); #endif #if defined(CONFIG_ACPI) if (&func->dev && ACPI_HANDLE(&func->dev)) { wlan_en_gpio = acpi_get_gpio_by_index(&func->dev, 1, NULL); RTW_INFO("rtw_drv_init: ACPI_HANDLE found wlan_en %d!\n", wlan_en_gpio); } else RTW_INFO("rtw_drv_init: ACPI_HANDLE NOT found!\n"); #endif #endif /* CONFIG_PLATFORM_INTEL_BYT */ dvobj = sdio_dvobj_init(func, id); if (dvobj == NULL) { goto exit; } padapter = rtw_sdio_primary_adapter_init(dvobj); if (padapter == NULL) { RTW_INFO("rtw_init_primary_adapter Failed!\n"); goto free_dvobj; } #ifdef CONFIG_CONCURRENT_MODE if (padapter->registrypriv.virtual_iface_num > (CONFIG_IFACE_NUMBER - 1)) padapter->registrypriv.virtual_iface_num = (CONFIG_IFACE_NUMBER - 1); for (i = 0; i < padapter->registrypriv.virtual_iface_num; i++) { if (rtw_drv_add_vir_if(padapter, sdio_set_intf_ops) == NULL) { RTW_INFO("rtw_drv_add_iface failed! (%d)\n", i); goto free_if_vir; } } #endif /* dev_alloc_name && register_netdev */ if (rtw_os_ndevs_init(dvobj) != _SUCCESS) goto free_if_vir; #ifdef CONFIG_HOSTAPD_MLME hostapd_mode_init(padapter); #endif #ifdef CONFIG_PLATFORM_RTD2880B RTW_INFO("wlan link up\n"); rtd2885_wlan_netlink_sendMsg("linkup", "8712"); #endif if (sdio_alloc_irq(dvobj) != _SUCCESS) goto os_ndevs_deinit; #ifdef CONFIG_GPIO_WAKEUP #ifdef CONFIG_PLATFORM_ARM_SUN6I eint_wlan_handle = sw_gpio_irq_request(gpio_eint_wlan, TRIG_EDGE_NEGATIVE, (peint_handle)gpio_hostwakeup_irq_thread, NULL); if (!eint_wlan_handle) { RTW_INFO("%s: request irq failed\n", __func__); return -1; } #else gpio_hostwakeup_alloc_irq(padapter); #endif #endif #ifdef CONFIG_GLOBAL_UI_PID if (ui_pid[1] != 0) { RTW_INFO("ui_pid[1]:%d\n", ui_pid[1]); rtw_signal_process(ui_pid[1], SIGUSR2); } #endif status = _SUCCESS; os_ndevs_deinit: if (status != _SUCCESS) rtw_os_ndevs_deinit(dvobj); free_if_vir: if (status != _SUCCESS) { #ifdef CONFIG_CONCURRENT_MODE rtw_drv_stop_vir_ifaces(dvobj); rtw_drv_free_vir_ifaces(dvobj); #endif } if (status != _SUCCESS && padapter) rtw_sdio_primary_adapter_deinit(padapter); 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 pwrctrl_priv *pwrctl = dvobj_to_pwrctl(dvobj); PADAPTER padapter = dvobj_get_primary_adapter(dvobj); dvobj->processing_dev_remove = _TRUE; /* TODO: use rtw_os_ndevs_deinit instead at the first stage of driver's dev deinit function */ rtw_os_ndevs_unregister(dvobj); if (!rtw_is_surprise_removed(padapter)) { int err; /* test surprise remove */ sdio_claim_host(func); sdio_readb(func, 0, &err); sdio_release_host(func); if (err == -ENOMEDIUM) { rtw_set_surprise_removed(padapter); RTW_INFO("%s: device had been removed!\n", __func__); } } #if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_ANDROID_POWER) rtw_unregister_early_suspend(pwrctl); #endif if (GET_HAL_DATA(padapter)->bFWReady == _TRUE) { 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_set_drv_stopped(padapter); /*for stop thread*/ rtw_stop_cmd_thread(padapter); #ifdef CONFIG_CONCURRENT_MODE rtw_drv_stop_vir_ifaces(dvobj); #endif #ifdef CONFIG_BT_COEXIST #ifdef CONFIG_BT_COEXIST_SOCKET_TRX if (GET_HAL_DATA(padapter)->EEPROMBluetoothCoexist) rtw_btcoex_close_socket(padapter); #endif rtw_btcoex_HaltNotify(padapter); #endif rtw_sdio_primary_adapter_deinit(padapter); #ifdef CONFIG_CONCURRENT_MODE rtw_drv_free_vir_ifaces(dvobj); #endif sdio_dvobj_deinit(func); } #ifdef CONFIG_SDIO_HOOK_DEV_SHUTDOWN static void rtw_dev_shutdown(struct device *dev) { struct sdio_func *func = dev_to_sdio_func(dev); if (func == NULL) return; RTW_INFO("==> %s !\n", __func__); rtw_dev_remove(func); RTW_INFO("<== %s !\n", __func__); } #endif 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 = NULL; struct dvobj_priv *psdpriv = NULL; struct pwrctrl_priv *pwrpriv = NULL; _adapter *padapter = NULL; struct debug_priv *pdbgpriv = NULL; int ret = 0; #ifdef CONFIG_RTW_SDIO_PM_KEEP_POWER #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)) mmc_pm_flag_t pm_flag = 0; #endif #endif if (dev == NULL) return ret; func = dev_to_sdio_func(dev); if(func == NULL) return ret; psdpriv = sdio_get_drvdata(func); if (psdpriv == NULL) goto exit; pwrpriv = dvobj_to_pwrctl(psdpriv); padapter = dvobj_get_primary_adapter(psdpriv); pdbgpriv = &psdpriv->drv_dbg; if (rtw_is_drv_stopped(padapter)) { RTW_INFO("%s bDriverStopped == _TRUE\n", __func__); goto exit; } if (pwrpriv->bInSuspend == _TRUE) { RTW_INFO("%s bInSuspend = %d\n", __func__, pwrpriv->bInSuspend); pdbgpriv->dbg_suspend_error_cnt++; goto exit; } ret = rtw_suspend_common(padapter); exit: #ifdef CONFIG_RTW_SDIO_PM_KEEP_POWER #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)) /* Android 4.0 don't support WIFI close power */ /* or power down or clock will close after wifi resume, */ /* this is sprd's bug in Android 4.0, but sprd don't */ /* want to fix it. */ /* we have test power under 8723as, power consumption is ok */ pm_flag = sdio_get_host_pm_caps(func); RTW_INFO("cmd: %s: suspend: PM flag = 0x%x\n", sdio_func_id(func), pm_flag); if (!(pm_flag & MMC_PM_KEEP_POWER)) { RTW_INFO("%s: cannot remain alive while host is suspended\n", sdio_func_id(func)); if (pdbgpriv) pdbgpriv->dbg_suspend_error_cnt++; return -ENOSYS; } else { RTW_INFO("cmd: suspend with MMC_PM_KEEP_POWER\n"); sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER); } #endif #endif return ret; } int rtw_resume_process(_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++; RTW_INFO("%s bInSuspend = %d\n", __FUNCTION__, 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 pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(psdpriv); _adapter *padapter = dvobj_get_primary_adapter(psdpriv); struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; int ret = 0; struct debug_priv *pdbgpriv = &psdpriv->drv_dbg; RTW_INFO("==> %s (%s:%d)\n", __FUNCTION__, current->comm, current->pid); pdbgpriv->dbg_resume_cnt++; #ifdef CONFIG_PLATFORM_INTEL_BYT if (0) #else if (pwrpriv->wowlan_mode || pwrpriv->wowlan_ap_mode) #endif { rtw_resume_lock_suspend(); ret = rtw_resume_process(padapter); rtw_resume_unlock_suspend(); } else { #ifdef CONFIG_RESUME_IN_WORKQUEUE rtw_resume_in_workqueue(pwrpriv); #else if (rtw_is_earlysuspend_registered(pwrpriv)) { /* jeff: bypass resume here, do in late_resume */ rtw_set_do_late_resume(pwrpriv, _TRUE); } else { rtw_resume_lock_suspend(); ret = rtw_resume_process(padapter); rtw_resume_unlock_suspend(); } #endif } pmlmeext->last_scan_time = rtw_get_current_time(); RTW_INFO("<======== %s return %d\n", __FUNCTION__, ret); return ret; } static int __init rtw_drv_entry(void) { int ret = 0; RTW_PRINT("module init start\n"); dump_drv_version(RTW_DBGDUMP); #ifdef BTCOEXVERSION RTW_PRINT(DRV_NAME" BT-Coex version = %s\n", BTCOEXVERSION); #endif /* BTCOEXVERSION */ #ifndef CONFIG_PLATFORM_INTEL_BYT rtw_android_wifictrl_func_add(); #endif /* !CONFIG_PLATFORM_INTEL_BYT */ ret = platform_wifi_power_on(); if (ret) { RTW_INFO("%s: power on failed!!(%d)\n", __FUNCTION__, ret); ret = -1; goto exit; } sdio_drvpriv.drv_registered = _TRUE; rtw_suspend_lock_init(); rtw_drv_proc_init(); rtw_nlrtw_init(); #ifdef CONFIG_PLATFORM_CMAP_INTFS cmap_intfs_init(); #endif rtw_ndev_notifier_register(); rtw_inetaddr_notifier_register(); ret = sdio_register_driver(&sdio_drvpriv.r871xs_drv); if (ret != 0) { sdio_drvpriv.drv_registered = _FALSE; rtw_suspend_lock_uninit(); rtw_drv_proc_deinit(); rtw_nlrtw_deinit(); #ifdef CONFIG_PLATFORM_CMAP_INTFS cmap_intfs_deinit(); #endif rtw_ndev_notifier_unregister(); rtw_inetaddr_notifier_unregister(); RTW_INFO("%s: register driver failed!!(%d)\n", __FUNCTION__, ret); goto poweroff; } goto exit; poweroff: platform_wifi_power_off(); exit: RTW_PRINT("module init ret=%d\n", ret); return ret; } static void __exit rtw_drv_halt(void) { RTW_PRINT("module exit start\n"); sdio_drvpriv.drv_registered = _FALSE; sdio_unregister_driver(&sdio_drvpriv.r871xs_drv); rtw_android_wifictrl_func_del(); platform_wifi_power_off(); rtw_suspend_lock_uninit(); rtw_drv_proc_deinit(); rtw_nlrtw_deinit(); #ifdef CONFIG_PLATFORM_CMAP_INTFS cmap_intfs_deinit(); #endif rtw_ndev_notifier_unregister(); rtw_inetaddr_notifier_unregister(); RTW_PRINT("module exit success\n"); rtw_mstat_dump(RTW_DBGDUMP); } #ifdef CONFIG_PLATFORM_INTEL_BYT int rtw_sdio_set_power(int on) { if (wlan_en_gpio >= 0) { if (on) gpio_set_value(wlan_en_gpio, 1); else gpio_set_value(wlan_en_gpio, 0); } return 0; } #endif /* CONFIG_PLATFORM_INTEL_BYT */ module_init(rtw_drv_entry); module_exit(rtw_drv_halt);