| // |
| // |
| // Copyright (c) 2004-2010 Atheros Communications Inc. |
| // All rights reserved. |
| // |
| // |
| // |
| // |
| // Permission to use, copy, modify, and/or distribute this software for any |
| // purpose with or without fee is hereby granted, provided that the above |
| // copyright notice and this permission notice appear in all copies. |
| // |
| // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
| // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
| // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
| // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
| // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
| // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| // |
| // |
| // |
| // |
| // |
| // |
| |
| /* |
| * Implementation of system power management |
| */ |
| |
| #include "ar6000_drv.h" |
| #include <linux/inetdevice.h> |
| |
| #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15) |
| #include <linux/platform_device.h> |
| #endif |
| #include "wlan_config.h" |
| |
| #ifdef CONFIG_HAS_WAKELOCK |
| #include <linux/wakelock.h> |
| #endif |
| |
| #ifdef CONFIG_PLAT_AMBARELLA |
| #include <mach/board.h> |
| #include <plat/sd.h> |
| #endif |
| |
| #define WOW_ENABLE_MAX_INTERVAL 1 |
| #define WOW_SET_SCAN_PARAMS 1 |
| |
| extern unsigned int wmitimeout; |
| extern unsigned int num_device; |
| #if WLAN_CONFIG_FIRST_SCAN_2G_ONLY |
| extern unsigned int first_scan_2g_only; |
| #endif |
| extern unsigned int psm_info; |
| #ifdef CONFIG_PM |
| struct platform_device *g_pdev = NULL; |
| |
| #if PLAT_WOW_GPIO_PIN || PLAT_WLAN_CHIP_PWD_PIN |
| #include <linux/gpio.h> |
| #endif |
| |
| #if defined(CONFIG_MMC_MSM) && defined(CONFIG_ARCH_MSM9615) |
| #include <linux/gpio.h> |
| #include <linux/regulator/consumer.h> |
| #endif |
| |
| #if PLAT_WOW_GPIO_PIN |
| static int wow_irq; |
| #endif /* PLAT_WOW_GPIO_PIN */ |
| |
| #ifdef CONFIG_HAS_WAKELOCK |
| struct wake_lock ar6k_suspend_wake_lock; |
| struct wake_lock ar6k_wow_wake_lock; |
| #endif |
| #endif /* CONFIG_PM */ |
| |
| #ifdef ANDROID_ENV |
| extern void android_ar6k_check_wow_status(AR_SOFTC_T *ar, struct sk_buff *skb, A_BOOL isEvent); |
| #endif |
| #undef ATH_MODULE_NAME |
| #define ATH_MODULE_NAME pm |
| #define ATH_DEBUG_PM ATH_DEBUG_MAKE_MODULE_MASK(0) |
| |
| #ifdef DEBUG |
| static ATH_DEBUG_MASK_DESCRIPTION pm_debug_desc[] = { |
| { ATH_DEBUG_PM , "System power management"}, |
| }; |
| |
| ATH_DEBUG_INSTANTIATE_MODULE_VAR(pm, |
| "pm", |
| "System Power Management", |
| ATH_DEBUG_MASK_DEFAULTS | ATH_DEBUG_PM, |
| ATH_DEBUG_DESCRIPTION_COUNT(pm_debug_desc), |
| pm_debug_desc); |
| |
| #endif /* DEBUG */ |
| |
| A_STATUS ar6000_exit_cut_power_state(AR_SOFTC_T *ar); |
| |
| #ifdef CONFIG_PM |
| static void ar6k_send_asleep_event_to_app(AR_SOFTC_DEV_T *arPriv, A_BOOL asleep) |
| { |
| char buf[128]; |
| union iwreq_data wrqu; |
| |
| snprintf(buf, sizeof(buf), "HOST_ASLEEP=%s", asleep ? "asleep" : "awake"); |
| A_MEMZERO(&wrqu, sizeof(wrqu)); |
| wrqu.data.length = strlen(buf); |
| wireless_send_event(arPriv->arNetDev, IWEVCUSTOM, &wrqu, buf); |
| } |
| |
| static void ar6000_set_host_sleep_mode_callback(void *ptr) |
| { |
| AR_SOFTC_T *ar = (AR_SOFTC_T *)ptr; |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM, ("%s: set host sleep mode cmd processed event arrived", __func__)); |
| ar->sleep_mode_cmd_completed = TRUE; |
| wake_up(&(ar->sleep_mode_cmd_completed_event)); |
| } |
| |
| static void ar6000_wow_resume(AR_SOFTC_T *ar) |
| { |
| HIF_DEVICE_POWER_CHANGE_TYPE config; |
| AR_SOFTC_DEV_T *arPriv; |
| AR_SOFTC_STA_T *arSta; |
| A_UINT8 i; |
| |
| if (ar->arWowState!= WLAN_WOW_STATE_NONE) { |
| config = HIF_DEVICE_POWER_UP; |
| HIFConfigureDevice(ar->arHifDevice, |
| HIF_DEVICE_POWER_STATE_CHANGE, |
| &config, |
| sizeof(HIF_DEVICE_POWER_CHANGE_TYPE)); |
| |
| } |
| |
| for(i = 0; i < num_device; i++) { |
| arPriv = ar->arDev[i]; |
| arSta = &arPriv->arSta; |
| |
| /* |
| * Free all wlan_nodes (scanned APs that we detected previously) |
| * because during the time we were suspended, the device may have |
| * been moved to a new location and these APs scanned for before |
| * suspend may not be valid |
| */ |
| wmi_free_allnodes(arPriv->arWmi); |
| |
| if (ar->arWowState!= WLAN_WOW_STATE_NONE) { |
| A_UINT16 fg_start_period = (arSta->scParams.fg_start_period==0) ? 1 : arSta->scParams.fg_start_period; |
| A_UINT16 bg_period = (arSta->scParams.bg_period==0) ? 60 : arSta->scParams.bg_period; |
| WMI_SET_HOST_SLEEP_MODE_CMD hostSleepMode = {TRUE, FALSE}; |
| ar->arWowState = WLAN_WOW_STATE_NONE; |
| #ifdef CONFIG_HAS_WAKELOCK |
| wake_lock_timeout(&ar6k_wow_wake_lock, 5); |
| #endif |
| /* |
| * Clear the callback function. We do not need to wait while resuming. |
| */ |
| wmi_set_host_sleep_mode_event_fn_ptr(arPriv->arWmi, NULL, NULL); |
| if (wmi_set_host_sleep_mode_cmd(arPriv->arWmi, &hostSleepMode)!=A_OK) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Fail to setup restore host awake\n")); |
| } |
| |
| if (arPriv->arNetworkType!=AP_NETWORK) { |
| #if WOW_SET_SCAN_PARAMS |
| wmi_scanparams_cmd(arPriv->arWmi, fg_start_period, |
| arSta->scParams.fg_end_period, |
| bg_period, |
| arSta->scParams.minact_chdwell_time, |
| arSta->scParams.maxact_chdwell_time, |
| arSta->scParams.pas_chdwell_time, |
| arSta->scParams.shortScanRatio, |
| arSta->scParams.scanCtrlFlags, |
| arSta->scParams.max_dfsch_act_time, |
| arSta->scParams.maxact_scan_per_ssid); |
| #else |
| (void)fg_start_period; |
| (void)bg_period; |
| #endif |
| |
| |
| #if WOW_ENABLE_MAX_INTERVAL /* we don't do it if the power consumption is already good enough. */ |
| if (wmi_listeninterval_cmd(arPriv->arWmi, arSta->arListenIntervalT, arSta->arListenIntervalB) != A_OK) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Fail to restore WoW listen interval %d\n", arSta->arListenIntervalT)); |
| } else { |
| if (wmi_bmisstime_cmd(arPriv->arWmi, arSta->arBmissTimeT, arSta->arBmissTimeB) != A_OK) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Fail to restore WoW bmiss %d\n", arSta->arBmissTimeT)); |
| } |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM, ("WoW does not invoked. skip resume")); |
| } |
| #endif |
| } |
| ar6k_send_asleep_event_to_app(arPriv, FALSE); |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM, ("Resume WoW successfully\n")); |
| ar->isHostAsleep = 0; |
| } else { |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM, ("WoW does not invoked. skip resume")); |
| } |
| } |
| |
| ar->arWlanPowerState = WLAN_POWER_STATE_ON; |
| } |
| |
| static void ar6000_wow_suspend(AR_SOFTC_T *ar) |
| { |
| struct net_device *ndev; |
| AR_SOFTC_DEV_T *arPriv; |
| AR_SOFTC_STA_T *arSta; |
| A_INT32 i, j; |
| A_STATUS status; |
| A_UINT32 timeremaining; |
| #define WOW_LIST_ID 1 |
| /* Setup WoW for unicast & Arp request for our own IP |
| * disable background scan. Set listen interval into 1000 TUs |
| * Enable keepliave for 110 seconds |
| */ |
| struct in_ifaddr **ifap = NULL; |
| struct in_ifaddr *ifa = NULL; |
| HIF_DEVICE_POWER_CHANGE_TYPE config; |
| struct in_device *in_dev; |
| WMI_ADD_WOW_PATTERN_CMD addWowCmd = { .filter = { 0 } }; |
| WMI_DEL_WOW_PATTERN_CMD delWowCmd; |
| WMI_SET_HOST_SLEEP_MODE_CMD hostSleepMode = {FALSE, TRUE}; |
| WMI_SET_WOW_MODE_CMD wowMode = { .enable_wow = TRUE, |
| .hostReqDelay = 500 };/*500 ms delay*/ |
| |
| if (ar->arWowState!= WLAN_WOW_STATE_NONE) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("System already go into wow mode!\n")); |
| return; |
| } |
| |
| ar6000_TxDataCleanup(ar); /* IMPORTANT, otherwise there will be 11mA after listen interval as 1000*/ |
| |
| for(j = 0; j< num_device; j++) |
| { |
| arPriv = ar->arDev[j]; |
| arSta = &arPriv->arSta; |
| ndev = arPriv->arNetDev; |
| /* clear up our WoW pattern first */ |
| for (i=0; i<WOW_MAX_FILTERS_PER_LIST; ++i) { |
| delWowCmd.filter_list_id = WOW_LIST_ID; |
| delWowCmd.filter_id = i; |
| wmi_del_wow_pattern_cmd(arPriv->arWmi, &delWowCmd); |
| } |
| |
| if (arPriv->arNetworkType == AP_NETWORK) { |
| /* setup all unicast IP packet pattern for WoW */ |
| #if WLAN_CONFIG_SIMPLE_WOW_AP_MODE |
| /* IP packets except boradcast */ |
| A_UINT8 allData[] = { 0x08 }; /* Either IP 0x0800, ARP 0x0806 or EAPOL-like 0x8800 */ |
| A_UINT8 allMask[] = { 0x7f }; |
| A_MEMZERO(&addWowCmd, sizeof(addWowCmd)); |
| addWowCmd.filter_list_id = WOW_LIST_ID; |
| addWowCmd.filter_size = sizeof(allMask); |
| addWowCmd.filter_offset = 20; |
| status = wmi_add_wow_pattern_cmd(ar->arWmi, &addWowCmd, allData, allMask, addWowCmd.filter_size); |
| if (status != A_OK) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Fail to add WoW simple pattern for AP mode\n")); |
| } |
| #else |
| /* Unicast IP, EAPOL-like and ARP packets */ |
| A_UINT8 unicastData[] = { |
| 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, |
| 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x08, }; |
| A_UINT8 unicastMask[] = { |
| 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, |
| 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f }; |
| A_UINT8 discoverData[] = { 0xe0, 0x00, 0x00, 0xf8 }; |
| A_UINT8 discoverMask[] = { 0xf0, 0x00, 0x00, 0xf8 }; |
| A_UINT8 arpData[] = { 0x08, 0x06 }; |
| A_UINT8 arpMask[] = { 0xff, 0xff }; |
| A_UINT8 dhcpData[] = { |
| 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, |
| 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x08, 0x00, |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0x00, 0x00, 0x00, 0x43 /* port 67 */ |
| }; |
| A_UINT8 dhcpMask[] = { |
| 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, |
| 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0x00, 0x00, 0xff, 0xff /* port 67 */ |
| }; |
| A_MEMZERO(&addWowCmd, sizeof(addWowCmd)); |
| addWowCmd.filter_list_id = WOW_LIST_ID; |
| addWowCmd.filter_size = sizeof(unicastMask); |
| addWowCmd.filter_offset = 0; |
| status = wmi_add_wow_pattern_cmd(arPriv->arWmi, &addWowCmd, unicastData, unicastMask, addWowCmd.filter_size); |
| if (status != A_OK) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Fail to add WoW unicast IP pattern for AP mode\n")); |
| } |
| /* setup all ARP packet pattern for WoW */ |
| A_MEMZERO(&addWowCmd, sizeof(addWowCmd)); |
| addWowCmd.filter_list_id = WOW_LIST_ID; |
| addWowCmd.filter_size = sizeof(arpMask); |
| addWowCmd.filter_offset = 20; |
| status = wmi_add_wow_pattern_cmd(arPriv->arWmi, &addWowCmd, arpData, arpMask, addWowCmd.filter_size); |
| if (status != A_OK) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Fail to add WoW ARP pattern for AP mode\n")); |
| } |
| /* Setup multicast pattern for mDNS 224.0.0.251, SSDP 239.255.255.250 and LLMNR 224.0.0.252*/ |
| A_MEMZERO(&addWowCmd, sizeof(addWowCmd)); |
| addWowCmd.filter_list_id = WOW_LIST_ID; |
| addWowCmd.filter_size = sizeof(discoverMask); |
| addWowCmd.filter_offset = 38; |
| status = wmi_add_wow_pattern_cmd(arPriv->arWmi, &addWowCmd, discoverData, discoverMask, addWowCmd.filter_size); |
| if (status != A_OK) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Fail to add mDNS/SSDP/LLMNR pattern for AP mode WoW\n")); |
| } |
| /* setup all DHCP broadcast packet pattern for WoW */ |
| A_MEMZERO(&addWowCmd, sizeof(addWowCmd)); |
| addWowCmd.filter_list_id = WOW_LIST_ID; |
| addWowCmd.filter_size = sizeof(dhcpMask); |
| addWowCmd.filter_offset = 0; |
| status = wmi_add_wow_pattern_cmd(arPriv->arWmi, &addWowCmd, dhcpData, dhcpMask, addWowCmd.filter_size); |
| if (status != A_OK) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Fail to add WoW DHCP broadcast pattern for AP mode\n")); |
| } |
| #endif /* WLAN_CONFIG_SIMPLE_WOW_AP_MODE */ |
| } else { |
| /* station mode */ |
| A_UINT8 macMask[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; |
| A_UINT16 wow_listen_interval = A_MAX_WOW_LISTEN_INTERVAL; |
| #if WOW_ENABLE_MAX_INTERVAL /* we don't do it if the power consumption is already good enough. */ |
| if (wmi_listeninterval_cmd(arPriv->arWmi, wow_listen_interval, 0) != A_OK) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Fail to setup WoW listen interval %d\n", wow_listen_interval)); |
| } else { |
| /* |
| * The default bmiss is 1500ms when listen interval is 100ms |
| * We set listen interval x 15 times as bmiss time here |
| */ |
| A_UINT16 bmissTime = wow_listen_interval*15; |
| if (bmissTime > MAX_BMISS_TIME) { |
| bmissTime = MAX_BMISS_TIME; |
| } |
| if (wmi_bmisstime_cmd(arPriv->arWmi, bmissTime, 0) != A_OK) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Fail to setup WoW bmiss %d\n", bmissTime)); |
| } |
| } |
| #else |
| (void)wow_listen_interval; |
| #endif |
| |
| #if WOW_SET_SCAN_PARAMS |
| status = wmi_scanparams_cmd(arPriv->arWmi, 0xFFFF, 0, 0xFFFF, 0, 0, 0, 0, 0, 0, 0); |
| #endif |
| /* setup unicast packet pattern for WoW */ |
| if (ndev->dev_addr[1]) { |
| A_MEMZERO(&addWowCmd, sizeof(addWowCmd)); |
| addWowCmd.filter_list_id = WOW_LIST_ID; |
| addWowCmd.filter_size = 6; /* MAC address */ |
| addWowCmd.filter_offset = 0; |
| status = wmi_add_wow_pattern_cmd(arPriv->arWmi, &addWowCmd, ndev->dev_addr, macMask, addWowCmd.filter_size); |
| if (status != A_OK) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Fail to add WoW pattern\n")); |
| } |
| } |
| |
| /* Setup multicast pattern for mDNS 224.0.0.251, SSDP 239.255.255.250 and LLMNR 224.0.0.252*/ |
| if ( ndev->flags & IFF_ALLMULTI || |
| #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 34) |
| (ndev->flags & IFF_MULTICAST && ndev->mc_count>0) ) |
| #else |
| (ndev->flags & IFF_MULTICAST && netdev_mc_count(ndev)>0) ) |
| #endif |
| { |
| A_UINT8 discoverData[] = { 0xe0, 0x00, 0x00, 0xf8 }; |
| A_UINT8 discoverMask[] = { 0xf0, 0x00, 0x00, 0xf8 }; |
| A_MEMZERO(&addWowCmd, sizeof(addWowCmd)); |
| addWowCmd.filter_list_id = WOW_LIST_ID; |
| addWowCmd.filter_size = sizeof(discoverMask); |
| addWowCmd.filter_offset = 38; |
| status = wmi_add_wow_pattern_cmd(arPriv->arWmi, &addWowCmd, discoverData, discoverMask, addWowCmd.filter_size); |
| if (status != A_OK) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Fail to add mDNS/SSDP/LLMNR pattern for WoW\n")); |
| } |
| } |
| |
| ar6k_send_asleep_event_to_app(arPriv, TRUE); |
| } |
| |
| ar->arWowState = WLAN_WOW_STATE_SUSPENDING; |
| |
| /* setup ARP request for our own IP */ |
| #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15) |
| if ((in_dev = __in_dev_get_rtnl(ndev)) != NULL) { |
| for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; ifap = &ifa->ifa_next) { |
| if (!strcmp(ndev->name, ifa->ifa_label)) { |
| break; /* found */ |
| } |
| } |
| } |
| #endif |
| |
| if (ifa && ifa->ifa_local) { |
| WMI_SET_IP_CMD ipCmd; |
| memset(&ipCmd, 0, sizeof(ipCmd)); |
| ipCmd.ips[0] = ifa->ifa_local; |
| status = wmi_set_ip_cmd(arPriv->arWmi, &ipCmd); |
| if (status != A_OK) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Fail to setup IP for ARP agent\n")); |
| } |
| } |
| |
| #ifndef ATH6K_CONFIG_OTA_MODE |
| AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("AR6K: %s: psm.info is %d (0: MAX_PERF_POWER, 1:REC_POWER)\n", __FUNCTION__, psm_info)); |
| wmi_powermode_cmd_w_psminfo(arPriv->arWmi, psm_info, REC_POWER); |
| #endif |
| |
| status = wmi_set_wow_mode_cmd(arPriv->arWmi, &wowMode); |
| if (status != A_OK) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Fail to enable wow mode\n")); |
| } |
| /* |
| * Set the callback function for processing of the last WMI command before suspending, |
| * so that we can wait for the HTC credit report to come in before proceeding. |
| */ |
| ar->sleep_mode_cmd_completed = FALSE; |
| wmi_set_host_sleep_mode_event_fn_ptr(arPriv->arWmi, ar6000_set_host_sleep_mode_callback, ar); |
| status = wmi_set_host_sleep_mode_cmd(arPriv->arWmi, &hostSleepMode); |
| if (status != A_OK) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Fail to set host asleep\n")); |
| } |
| |
| /* |
| * Wait for the WMI_SET_HOST_SLEEP_MODE_CMD_PROCESSED_EVENTID to come in. This is |
| * guaranteed to happen either AFTER the credit report for the |
| * WMI_SET_HOST_SLEEP_MODE_CMD arrives, or simultaneously along with the event. |
| * This should never take longer than a few ms, so if 2 seconds have elapsed and |
| * we still do not get the event, there's a problem with the WLAN chip. Just continue, |
| * (the user will have to unload the driver manually). It's better than taking down |
| * the entire OS. |
| */ |
| timeremaining = wait_event_interruptible_timeout(ar->sleep_mode_cmd_completed_event, (ar->sleep_mode_cmd_completed == TRUE), 2*HZ); |
| if (!timeremaining) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Expected a WMI_SET_HOST_SLEEP_MODE_CMD_PROCESSED event but it never arrived\n")); |
| } |
| |
| if (ar->arTxPending[ar->arControlEp]) { |
| A_UINT32 timeleft = wait_event_interruptible_timeout(arPriv->arEvent, |
| ar->arTxPending[ar->arControlEp] == 0, wmitimeout * HZ); |
| if (!timeleft || signal_pending(current)) { |
| /* what can I do? wow resume at once */ |
| |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Fail to setup WoW. Pending wmi control data %d\n", ar->arTxPending[ar->arControlEp])); |
| } |
| } |
| } |
| |
| status = hifWaitForPendingRecv(ar->arHifDevice); |
| |
| config = HIF_DEVICE_POWER_DOWN; |
| status = HIFConfigureDevice(ar->arHifDevice, |
| HIF_DEVICE_POWER_STATE_CHANGE, |
| &config, |
| sizeof(HIF_DEVICE_POWER_CHANGE_TYPE)); |
| |
| ar->arWowState = WLAN_WOW_STATE_SUSPENDED; |
| ar->arWlanPowerState = WLAN_POWER_STATE_WOW; |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM, ("Setup WoW successfully\n")); |
| } |
| |
| A_STATUS ar6000_suspend_ev(void *context) |
| { |
| A_STATUS status = A_OK; |
| AR_SOFTC_T *ar = (AR_SOFTC_T *)context; |
| A_INT16 pmmode = ar->arSuspendConfig; |
| A_INT32 i; |
| A_BOOL needWow = FALSE; |
| wow_not_connected: |
| switch (pmmode) { |
| case WLAN_SUSPEND_WOW: |
| for(i = 0; i< num_device; i++) { |
| if (ar->arDev[i]->arConnected) { |
| needWow = TRUE; |
| break; |
| } |
| } |
| if (ar->arWmiReady && ar->arWlanState==WLAN_ENABLED && needWow) { |
| ar6000_wow_suspend(ar); |
| status = A_EBUSY; |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM,("%s:Suspend for wow mode %d\n", __func__, ar->arWlanPowerState)); |
| } else { |
| pmmode = ar->arWow2Config; |
| goto wow_not_connected; |
| } |
| break; |
| case WLAN_SUSPEND_CUT_PWR: |
| /* fall through */ |
| case WLAN_SUSPEND_CUT_PWR_IF_BT_OFF: |
| /* fall through */ |
| case WLAN_SUSPEND_DEEP_SLEEP: |
| /* fall through */ |
| default: |
| status = ar6000_update_wlan_pwr_state(ar, WLAN_DISABLED, TRUE); |
| if (ar->arWlanPowerState==WLAN_POWER_STATE_ON || |
| ar->arWlanPowerState==WLAN_POWER_STATE_WOW) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM, ("Strange suspend state for not wow mode %d", ar->arWlanPowerState)); |
| } |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM,("%s:Suspend for %d mode pwr %d status %d\n", __func__, pmmode, ar->arWlanPowerState, status)); |
| if (ar->arWlanPowerState==WLAN_POWER_STATE_CUT_PWR) { |
| status = A_OK; |
| } else { |
| status = A_EBUSY; /* don't let mmc call sdio_init after resume */ |
| } |
| break; |
| } |
| |
| for(i = 0; i < num_device; i++) { |
| AR_SOFTC_DEV_T *arPriv = ar->arDev[i]; |
| AR_SOFTC_STA_T *arSta = &arPriv->arSta; |
| if (arSta->scan_triggered) { |
| ar6000_scanComplete_event(arPriv, A_OK); |
| } |
| } |
| return status; |
| } |
| |
| A_STATUS ar6000_resume_ev(void *context) |
| { |
| AR_SOFTC_T *ar = (AR_SOFTC_T *)context; |
| A_UINT16 powerState = ar->arWlanPowerState; |
| |
| #ifdef CONFIG_HAS_WAKELOCK |
| wake_lock(&ar6k_suspend_wake_lock); |
| #endif |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM, ("%s: enter previous state %d wowState %d\n", __func__, powerState, ar->arWowState)); |
| switch (powerState) { |
| case WLAN_POWER_STATE_WOW: |
| ar6000_wow_resume(ar); |
| break; |
| case WLAN_POWER_STATE_CUT_PWR: |
| /* fall through */ |
| case WLAN_POWER_STATE_DEEP_SLEEP: |
| ar6000_update_wlan_pwr_state(ar, WLAN_ENABLED, TRUE); |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM,("%s:Resume for %d mode pwr %d\n", __func__, powerState, ar->arWlanPowerState)); |
| break; |
| case WLAN_POWER_STATE_ON: |
| break; |
| default: |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Strange SDIO bus power mode!!\n")); |
| break; |
| } |
| #ifdef CONFIG_HAS_WAKELOCK |
| wake_unlock(&ar6k_suspend_wake_lock); |
| #endif |
| return A_OK; |
| } |
| |
| void ar6000_check_wow_status(AR_SOFTC_T *ar, struct sk_buff *skb, A_BOOL isEvent) |
| { |
| /* EV85521 */ |
| if (in_interrupt()) { |
| if (ar->arWowState == WLAN_WOW_STATE_SUSPENDED) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_WARN, ("AR6K: %s called in interrupt context\n", __func__)); |
| } |
| return; |
| } |
| |
| if (ar->arWowState != WLAN_WOW_STATE_NONE) { |
| if (ar->arWowState==WLAN_WOW_STATE_SUSPENDING) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM,("\n%s: Received IRQ while we are wow suspending!!!\n\n", __func__)); |
| return; |
| } |
| /* Wow resume from irq interrupt */ |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM, ("%s: WoW resume from irq thread status %d\n", __func__, ar->arWlanPowerState)); |
| ar6000_wow_resume(ar); |
| } else { |
| #ifdef ANDROID_ENV |
| android_ar6k_check_wow_status(ar, skb, isEvent); |
| #endif |
| } |
| } |
| |
| A_STATUS ar6000_power_change_ev(void *context, A_UINT32 config) |
| { |
| AR_SOFTC_T *ar = (AR_SOFTC_T *)context; |
| A_STATUS status = A_OK; |
| |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM, ("%s: power change event callback %d \n", __func__, config)); |
| switch (config) { |
| case HIF_DEVICE_POWER_UP: |
| ar6000_restart_endpoint(ar); |
| #ifdef ANDROID_ENV |
| ar->arResumeDone = TRUE; |
| wake_up(&(ar->arDev[0]->arEvent)); |
| #endif /* ANDROID_ENV */ |
| status = A_OK; |
| break; |
| case HIF_DEVICE_POWER_DOWN: |
| case HIF_DEVICE_POWER_CUT: |
| status = A_OK; |
| break; |
| } |
| return status; |
| } |
| |
| #if PLAT_WOW_GPIO_PIN |
| static irqreturn_t |
| ar6000_wow_irq(int irq, void *dev_id) |
| { |
| gpio_clear_detect_status(wow_irq); |
| #ifdef CONFIG_HAS_WAKELOCK |
| wake_lock_timeout(&ar6k_wow_wake_lock, 3*HZ); |
| #else |
| /* TODO: What should I do if there is no wake lock?? */ |
| #endif |
| return IRQ_HANDLED; |
| } |
| #endif /* PLAT_WOW_GPIO_PIN */ |
| |
| #if PLAT_WLAN_CHIP_PWD_PIN |
| void plat_setup_power_stub(AR_SOFTC_T *ar, int on, int detect) |
| { |
| A_BOOL chip_pwd_low_val; |
| |
| if (on) { |
| chip_pwd_low_val = 1; |
| } else { |
| chip_pwd_low_val = 0; |
| } |
| ambarella_set_gpio_output(&ambarella_board_generic.wifi_power, chip_pwd_low_val); |
| |
| } |
| #endif /* PLAT_WLAN_CHIP_PWD_PIN */ |
| |
| #if defined(CONFIG_MMC_MSM) && defined(CONFIG_ARCH_MSM9615) |
| |
| struct wlan_regulator { |
| const char *vreg_name; /* Regulator Name */ |
| int min_uV; /* Minimum voltage at which AR6003 can operate */ |
| int max_uV; /* Maximum voltage at which AR6003 can operate */ |
| int load_uA; /* Current which will be drawn from regulator (Worst case) */ |
| int delay_mT; /* Time from this operation to next */ |
| struct regulator *vreg; /* Regulator Handle */ |
| }; |
| |
| |
| static struct wlan_regulator regulator_table[] = { |
| {"wlan_vreg", 1710000, 1890000, 86000, 5, NULL} |
| }; |
| |
| static void msm9615_wifi_power_down(struct wlan_regulator *regulators, A_UINT32 size) |
| { |
| int rc = 0; |
| int i; |
| |
| if (!regulators) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("msm9615_wifi_power_down: NULL pointer passed!!!\n")); |
| return; |
| } |
| |
| for (i = size - 1; i >= 0; i--) { |
| |
| if (!regulators[i].vreg) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("msm9615_wifi_power_down: vreg is NULL!!!\n")); |
| continue; |
| } |
| |
| rc = regulator_disable(regulators[i].vreg); |
| |
| if (rc) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Failed to disable regulator: %s, rc: %d\n", |
| regulators[i].vreg_name, rc)); |
| } |
| |
| rc = regulator_set_voltage(regulators[i].vreg, 0, regulators[i].max_uV); |
| |
| if (rc) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Failed to set regulator voltage: %s, rc: %d\n", |
| regulators[i].vreg_name, rc)); |
| } |
| |
| rc = regulator_set_optimum_mode(regulators[i].vreg, 0); |
| |
| if (rc < 0) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Failed to set regulator optimum mode: %s, rc: %d\n", |
| regulators[i].vreg_name, rc)); |
| } |
| |
| regulator_put(regulators[i].vreg); |
| regulators[i].vreg = NULL; |
| } |
| } |
| |
| static int msm9615_wifi_power_up(struct wlan_regulator *regulators, A_UINT32 size) |
| { |
| int rc = 0; |
| int i = 0; |
| |
| if (!g_pdev) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("msm9615_wifi_power_up: Platform device is NULL!!!\n")); |
| rc = -ENODEV; |
| goto fail; |
| } |
| |
| if (!regulators) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("msm9615_wifi_power_up: NULL pointer passed!!!")); |
| rc = -EINVAL; |
| goto fail; |
| } |
| |
| for (i = 0; i < size; i++) { |
| |
| regulators[i].vreg = regulator_get(&g_pdev->dev, regulators[i].vreg_name); |
| |
| if (!regulators[i].vreg || IS_ERR(regulators[i].vreg)) { |
| rc = PTR_ERR(regulators[i].vreg); |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Failed to get regulator: %s, rc: %d\n", |
| regulators[i].vreg_name, rc)); |
| regulators[i].vreg = NULL; |
| goto fail; |
| } |
| |
| rc = regulator_set_voltage(regulators[i].vreg, regulators[i].min_uV, regulators[i].max_uV); |
| |
| if (rc) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Failed to set regulator voltage: %s, rc: %d\n", |
| regulators[i].vreg_name, rc)); |
| goto fail; |
| } |
| |
| rc = regulator_set_optimum_mode(regulators[i].vreg, regulators[i].load_uA); |
| |
| if (rc < 0) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Failed to set regulator optimum mode: %s, rc: %d\n", |
| regulators[i].vreg_name, rc)); |
| goto fail; |
| } |
| |
| rc = regulator_enable(regulators[i].vreg); |
| if (rc) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Failed to enable regulator: %s, rc: %d\n", |
| regulators[i].vreg_name, rc)); |
| goto fail; |
| } |
| |
| A_MDELAY(regulators[i].delay_mT); |
| } |
| |
| return rc; |
| |
| fail: |
| msm9615_wifi_power_down(regulators, i + 1); |
| return rc; |
| } |
| |
| static struct gpio wifi_gpios[] = { |
| { MSM9615_WLAN_PM_ENABLE_PIN, GPIOF_OUT_INIT_LOW, "wlan_pm_enable" }, |
| { MSM9615_WLAN_CHIP_PWD_PIN, GPIOF_OUT_INIT_LOW, "wlan_chip_pwd_l" }, |
| }; |
| |
| int msm9615_wifi_power(AR_SOFTC_T *ar, int on) |
| { |
| int rc = 0; |
| |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM, ("msm9615_wifi_power: %s\n", on ? "on" : "off")); |
| |
| do { |
| if (on) { |
| rc = msm9615_wifi_power_up(regulator_table, ARRAY_SIZE(regulator_table)); |
| |
| if (rc) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("msm9615_wifi_power: Power UP failed!!!\n")); |
| break; |
| } |
| |
| rc = gpio_request_array(wifi_gpios, ARRAY_SIZE(wifi_gpios)); |
| |
| if (rc) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Cannot request GPIO!!!")); |
| |
| msm9615_wifi_power_down(regulator_table, ARRAY_SIZE(regulator_table)); |
| break; |
| } |
| |
| gpio_set_value(MSM9615_WLAN_PM_ENABLE_PIN, 1); |
| A_MDELAY(100); |
| gpio_set_value(MSM9615_WLAN_CHIP_PWD_PIN, 1); |
| } else { |
| |
| gpio_set_value(MSM9615_WLAN_CHIP_PWD_PIN, 0); |
| gpio_set_value(MSM9615_WLAN_PM_ENABLE_PIN, 0); |
| |
| gpio_free_array(wifi_gpios, ARRAY_SIZE(wifi_gpios)); |
| |
| msm9615_wifi_power_down(regulator_table, ARRAY_SIZE(regulator_table)); |
| } |
| |
| } while (0); |
| |
| return rc; |
| } |
| #endif /* defined(CONFIG_MMC_MSM) && defined(CONFIG_ARCH_MSM9615) */ |
| |
| #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15) |
| static int ar6000_pm_probe(struct platform_device *pdev) |
| { |
| |
| g_pdev = pdev; |
| |
| plat_setup_power(NULL, 1, 1); |
| return 0; |
| } |
| |
| static int ar6000_pm_remove(struct platform_device *pdev) |
| { |
| plat_setup_power(NULL, 0, 1); |
| return 0; |
| } |
| |
| static int ar6000_pm_suspend(struct platform_device *pdev, pm_message_t state) |
| { |
| return 0; |
| } |
| |
| static int ar6000_pm_resume(struct platform_device *pdev) |
| { |
| int i; |
| extern struct net_device *ar6000_devices[MAX_AR6000]; |
| |
| for (i=0; ar6000_devices[i]; ++i) { |
| AR_SOFTC_DEV_T *arPriv = (AR_SOFTC_DEV_T *)ar6k_priv(ar6000_devices[i]); |
| AR_SOFTC_T *ar = (AR_SOFTC_T *)arPriv->arSoftc; |
| |
| if (ar && ar->arPlatPowerOff) { |
| A_BOOL wlanOff = ar->arWlanOff; |
| A_UINT16 powerState = ar->arWlanPowerState; |
| A_BOOL btOff = ar->arBTOff; |
| |
| if (!wlanOff) { |
| if (powerState == WLAN_POWER_STATE_CUT_PWR) { |
| plat_setup_power(ar, 1, 0); |
| ar->arPlatPowerOff = FALSE; |
| } |
| } |
| #ifdef CONFIG_PM |
| else if (wlanOff) { |
| A_BOOL allowCutPwr = ((!ar->arBTSharing) || btOff); |
| if ((powerState==WLAN_POWER_STATE_CUT_PWR) && (!allowCutPwr)) { |
| plat_setup_power(ar, 1, 0); |
| ar->arPlatPowerOff = FALSE; |
| } |
| } |
| #endif /* CONFIG_PM */ |
| } |
| } |
| return 0; |
| } |
| |
| static struct platform_driver ar6000_pm_device = { |
| .probe = ar6000_pm_probe, |
| .remove = ar6000_pm_remove, |
| .suspend = ar6000_pm_suspend, |
| .resume = ar6000_pm_resume, |
| .driver = { |
| .name = "wlan_ar6000_pm_dev", |
| }, |
| }; |
| #endif |
| #endif /* CONFIG_PM */ |
| |
| A_STATUS |
| ar6000_setup_cut_power_state(struct ar6_softc *ar, AR6000_WLAN_STATE state) |
| { |
| A_STATUS status = A_OK; |
| HIF_DEVICE_POWER_CHANGE_TYPE config; |
| |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM, ("%s: Cut power %d %d \n", __func__,state, ar->arWlanPowerState)); |
| #ifdef CONFIG_PM |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM, ("Wlan OFF %d BT OFf %d \n", ar->arWlanOff, ar->arBTOff)); |
| #endif |
| do { |
| if (state == WLAN_ENABLED) { |
| /* Not in cut power state.. exit */ |
| if (ar->arWlanPowerState != WLAN_POWER_STATE_CUT_PWR) { |
| break; |
| } |
| |
| if (ar->arPlatPowerOff) { |
| plat_setup_power(ar, 1, 0); |
| ar->arPlatPowerOff = FALSE; |
| } |
| |
| /* Change the state to ON */ |
| ar->arWlanPowerState = WLAN_POWER_STATE_ON; |
| |
| #ifdef ANDROID_ENV |
| ar->arResumeDone = FALSE; |
| #endif /* ANDROID_ENV */ |
| |
| /* Indicate POWER_UP to HIF */ |
| config = HIF_DEVICE_POWER_UP; |
| status = HIFConfigureDevice(ar->arHifDevice, |
| HIF_DEVICE_POWER_STATE_CHANGE, |
| &config, |
| sizeof(HIF_DEVICE_POWER_CHANGE_TYPE)); |
| |
| if (status == A_PENDING) { |
| #ifdef ANDROID_ENV |
| /* Wait for resume done event */ |
| A_UINT32 timeleft = wait_event_interruptible_timeout(ar->arDev[0]->arEvent, |
| (ar->arResumeDone == TRUE), wmitimeout * HZ); |
| if (!timeleft || signal_pending(current)) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000 : Failed to get resume done event \n")); |
| status = A_ERROR; |
| break; |
| } |
| #endif |
| status = A_OK; |
| } else if (status == A_OK) { |
| ar6000_restart_endpoint(ar); |
| #ifdef ANDROID_ENV |
| ar->arResumeDone = TRUE; |
| #endif /* ANDROID_ENV */ |
| status = A_OK; |
| } |
| } else if (state == WLAN_DISABLED) { |
| |
| |
| /* Already in cut power state.. exit */ |
| if (ar->arWlanPowerState == WLAN_POWER_STATE_CUT_PWR) { |
| break; |
| } |
| ar6000_stop_endpoint(ar, TRUE, FALSE); |
| |
| config = HIF_DEVICE_POWER_CUT; |
| status = HIFConfigureDevice(ar->arHifDevice, |
| HIF_DEVICE_POWER_STATE_CHANGE, |
| &config, |
| sizeof(HIF_DEVICE_POWER_CHANGE_TYPE)); |
| |
| plat_setup_power(ar, 0, 0); |
| ar->arPlatPowerOff = TRUE; |
| |
| ar->arWlanPowerState = WLAN_POWER_STATE_CUT_PWR; |
| } |
| } while (0); |
| |
| return status; |
| } |
| |
| A_STATUS |
| ar6000_setup_deep_sleep_state(struct ar6_softc *ar, AR6000_WLAN_STATE state) |
| { |
| A_STATUS status = A_OK; |
| |
| HIF_DEVICE_POWER_CHANGE_TYPE config; |
| AR_SOFTC_DEV_T *arPriv; |
| AR_SOFTC_STA_T *arSta; |
| A_UINT8 i; |
| |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM, ("%s: Deep sleep %d %d \n", __func__,state, ar->arWlanPowerState)); |
| #ifdef CONFIG_PM |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM, ("Wlan OFF %d BT OFf %d \n", ar->arWlanOff, ar->arBTOff)); |
| #endif |
| do { |
| WMI_SET_HOST_SLEEP_MODE_CMD hostSleepMode; |
| |
| if (state == WLAN_ENABLED) { |
| A_UINT16 fg_start_period; |
| |
| /* Not in deep sleep state.. exit */ |
| if (ar->arWlanPowerState != WLAN_POWER_STATE_DEEP_SLEEP) { |
| if (ar->arWlanPowerState != WLAN_POWER_STATE_ON) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Strange state when we resume from deep sleep %d\n", ar->arWlanPowerState)); |
| } |
| break; |
| } |
| |
| /* Indicate POWER_UP to HIF */ |
| config = HIF_DEVICE_POWER_UP; |
| status = HIFConfigureDevice(ar->arHifDevice, |
| HIF_DEVICE_POWER_STATE_CHANGE, |
| &config, |
| sizeof(HIF_DEVICE_POWER_CHANGE_TYPE)); |
| |
| for(i = 0; i < num_device; i++) |
| { |
| arPriv = ar->arDev[i]; |
| arSta = &arPriv->arSta; |
| |
| /* |
| * Free all wlan_nodes (scanned APs that we detected previously) |
| * because during the time we were suspended, the device may have |
| * been moved to a new location and these APs scanned for before |
| * suspend may not be valid |
| */ |
| wmi_free_allnodes(arPriv->arWmi); |
| |
| fg_start_period = (arSta->scParams.fg_start_period==0) ? 1 : arSta->scParams.fg_start_period; |
| hostSleepMode.awake = TRUE; |
| hostSleepMode.asleep = FALSE; |
| |
| /* |
| * Clear the callback function. We do not need to wait while resuming. |
| */ |
| wmi_set_host_sleep_mode_event_fn_ptr(arPriv->arWmi, NULL, NULL); |
| if ((status=wmi_set_host_sleep_mode_cmd(arPriv->arWmi, &hostSleepMode)) != A_OK) { |
| break; |
| } |
| |
| /* Change the state to ON */ |
| ar->arWlanPowerState = WLAN_POWER_STATE_ON; |
| |
| /* Enable foreground scanning */ |
| if ((status=wmi_scanparams_cmd(arPriv->arWmi, fg_start_period, |
| arSta->scParams.fg_end_period, |
| arSta->scParams.bg_period, |
| arSta->scParams.minact_chdwell_time, |
| arSta->scParams.maxact_chdwell_time, |
| arSta->scParams.pas_chdwell_time, |
| arSta->scParams.shortScanRatio, |
| arSta->scParams.scanCtrlFlags, |
| arSta->scParams.max_dfsch_act_time, |
| arSta->scParams.maxact_scan_per_ssid)) != A_OK) |
| { |
| break; |
| } |
| |
| if (arPriv->arSsidLen) { |
| if (ar6000_connect_to_ap(arPriv) != A_OK) { |
| /* no need to report error if connection failed */ |
| break; |
| } |
| } |
| } |
| } else if (state == WLAN_DISABLED){ |
| #ifdef CONFIG_PM |
| A_UINT32 timeremaining; |
| #endif |
| WMI_SET_WOW_MODE_CMD wowMode = { .enable_wow = FALSE }; |
| |
| /* Already in deep sleep state.. exit */ |
| if (ar->arWlanPowerState != WLAN_POWER_STATE_ON) { |
| if (ar->arWlanPowerState != WLAN_POWER_STATE_DEEP_SLEEP) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Strange state when we suspend for deep sleep %d\n", ar->arWlanPowerState)); |
| } |
| break; |
| } |
| |
| for(i = 0; i < num_device; i++) |
| { |
| arPriv = ar->arDev[i]; |
| arSta = &arPriv->arSta; |
| /* make sure we disable wow for deep sleep */ |
| if ((status=wmi_set_wow_mode_cmd(arPriv->arWmi, &wowMode))!=A_OK) { |
| break; |
| } |
| |
| /* Disconnect from the AP and disable foreground scanning */ |
| AR6000_SPIN_LOCK(&arPriv->arPrivLock, 0); |
| if (arPriv->arConnected == TRUE || arSta->arConnectPending == TRUE) { |
| AR6000_SPIN_UNLOCK(&arPriv->arPrivLock, 0); |
| ar6000_disconnect(arPriv); |
| } else { |
| AR6000_SPIN_UNLOCK(&arPriv->arPrivLock, 0); |
| } |
| |
| if ((status=wmi_scanparams_cmd(arPriv->arWmi, 0xFFFF, 0, 0, 0, 0, 0, 0, 0, 0, 0)) != A_OK) { |
| break; |
| } |
| ar6000_TxDataCleanup(ar); |
| #ifndef ATH6K_CONFIG_OTA_MODE |
| AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("AR6K: %s: psm.info is %d (0: MAX_PERF_POWER, 1:REC_POWER)\n", __FUNCTION__, psm_info)); |
| wmi_powermode_cmd_w_psminfo(arPriv->arWmi, psm_info, REC_POWER); |
| #endif |
| |
| hostSleepMode.awake = FALSE; |
| hostSleepMode.asleep = TRUE; |
| |
| #ifdef CONFIG_PM |
| /* |
| * Set the callback function for processing of the last WMI command before suspending, |
| * so that we can wait for the HTC credit report to come in before proceeding. |
| */ |
| ar->sleep_mode_cmd_completed = FALSE; |
| wmi_set_host_sleep_mode_event_fn_ptr(arPriv->arWmi, ar6000_set_host_sleep_mode_callback, ar); |
| if ((status=wmi_set_host_sleep_mode_cmd(arPriv->arWmi, &hostSleepMode))!=A_OK) { |
| break; |
| } |
| |
| /* |
| * Wait for the WMI_SET_HOST_SLEEP_MODE_CMD_PROCESSED_EVENTID to come in. This is |
| * guaranteed to happen either AFTER the credit report for the |
| * WMI_SET_HOST_SLEEP_MODE_CMD arrives, or simultaneously along with the event. |
| * This should never take longer than a few ms, so if 2 seconds have elapsed and |
| * we still do not get the event, there's a problem with the WLAN chip. Just continue, |
| * (the user will have to unload the driver manually). It's better than taking down |
| * the entire OS. |
| */ |
| timeremaining = wait_event_interruptible_timeout(ar->sleep_mode_cmd_completed_event, (ar->sleep_mode_cmd_completed == TRUE), 2*HZ); |
| if (!timeremaining) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Expected a WMI_SET_HOST_SLEEP_MODE_CMD_PROCESSED event but it never arrived\n")); |
| } |
| |
| if (ar->arTxPending[ar->arControlEp]) { |
| A_UINT32 timeleft = wait_event_interruptible_timeout(arPriv->arEvent, |
| ar->arTxPending[ar->arControlEp] == 0, wmitimeout * HZ); |
| if (!timeleft || signal_pending(current)) { |
| status = A_ERROR; |
| break; |
| } |
| } |
| #endif |
| } |
| status = hifWaitForPendingRecv(ar->arHifDevice); |
| |
| config = HIF_DEVICE_POWER_DOWN; |
| status = HIFConfigureDevice(ar->arHifDevice, |
| HIF_DEVICE_POWER_STATE_CHANGE, |
| &config, |
| sizeof(HIF_DEVICE_POWER_CHANGE_TYPE)); |
| |
| ar->arWlanPowerState = WLAN_POWER_STATE_DEEP_SLEEP; |
| } |
| } while (0); |
| |
| if (status!=A_OK) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Fail to enter/exit deep sleep %d\n", state)); |
| } |
| |
| return status; |
| } |
| |
| A_STATUS |
| ar6000_update_wlan_pwr_state(struct ar6_softc *ar, AR6000_WLAN_STATE state, A_BOOL pmEvent) |
| { |
| A_STATUS status = A_OK; |
| A_UINT16 powerState, oldPowerState; |
| AR6000_WLAN_STATE oldstate = ar->arWlanState; |
| A_BOOL wlanOff = ar->arWlanOff; |
| #ifdef CONFIG_PM |
| A_BOOL btOff = ar->arBTOff; |
| #endif /* CONFIG_PM */ |
| A_UINT8 i; |
| AR_SOFTC_DEV_T *arPriv; |
| |
| if ((state!=WLAN_DISABLED && state!=WLAN_ENABLED)) { |
| return A_ERROR; |
| } |
| |
| if (ar->bIsDestroyProgress) { |
| return A_EBUSY; |
| } |
| |
| if (down_interruptible(&ar->arSem)) { |
| return A_ERROR; |
| } |
| |
| if (ar->bIsDestroyProgress) { |
| up(&ar->arSem); |
| return A_EBUSY; |
| } |
| |
| ar->arWlanState = wlanOff ? WLAN_DISABLED : state; |
| oldPowerState = ar->arWlanPowerState; |
| if (state == WLAN_ENABLED) { |
| powerState = ar->arWlanPowerState; |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM, ("WLAN PWR set to ENABLE^^\n")); |
| if (!wlanOff) { |
| if (powerState == WLAN_POWER_STATE_DEEP_SLEEP) { |
| status = ar6000_setup_deep_sleep_state(ar, WLAN_ENABLED); |
| } else if (powerState == WLAN_POWER_STATE_CUT_PWR) { |
| status = ar6000_setup_cut_power_state(ar, WLAN_ENABLED); |
| } |
| } |
| #ifdef CONFIG_PM |
| else if (pmEvent && wlanOff) { |
| A_BOOL allowCutPwr = ((!ar->arBTSharing) || btOff); |
| if ((powerState==WLAN_POWER_STATE_CUT_PWR) && (!allowCutPwr)) { |
| /* Come out of cut power */ |
| ar6000_setup_cut_power_state(ar, WLAN_ENABLED); |
| status = ar6000_setup_deep_sleep_state(ar, WLAN_DISABLED); |
| } |
| } |
| #endif /* CONFIG_PM */ |
| } else if (state == WLAN_DISABLED) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM, ("WLAN PWR set to DISABLED~\n")); |
| powerState = WLAN_POWER_STATE_DEEP_SLEEP; |
| #ifdef CONFIG_PM |
| if (pmEvent) { /* disable due to suspend */ |
| A_BOOL suspendCutPwr = (ar->arSuspendConfig == WLAN_SUSPEND_CUT_PWR || |
| (ar->arSuspendConfig == WLAN_SUSPEND_WOW && |
| ar->arWow2Config==WLAN_SUSPEND_CUT_PWR)); |
| A_BOOL suspendCutIfBtOff = ((ar->arSuspendConfig == |
| WLAN_SUSPEND_CUT_PWR_IF_BT_OFF || |
| (ar->arSuspendConfig == WLAN_SUSPEND_WOW && |
| ar->arWow2Config==WLAN_SUSPEND_CUT_PWR_IF_BT_OFF)) && |
| (!ar->arBTSharing || btOff)); |
| if ((suspendCutPwr) || |
| (suspendCutIfBtOff) || |
| (ar->arWlanPowerState==WLAN_POWER_STATE_CUT_PWR)) |
| { |
| if (!wlanOff || ar->arWlanPowerState!=WLAN_POWER_STATE_DEEP_SLEEP) { |
| powerState = WLAN_POWER_STATE_CUT_PWR; |
| } |
| } |
| } else { |
| if ((wlanOff) && |
| (ar->arWlanOffConfig == WLAN_OFF_CUT_PWR) && |
| (!ar->arBTSharing || btOff)) |
| { |
| /* For BT clock sharing designs, CUT_POWER depend on BT state */ |
| powerState = WLAN_POWER_STATE_CUT_PWR; |
| } |
| } |
| #endif /* CONFIG_PM */ |
| |
| if (powerState == WLAN_POWER_STATE_DEEP_SLEEP) { |
| if (ar->arWlanPowerState == WLAN_POWER_STATE_CUT_PWR) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM, ("Load firmware before set to deep sleep\n")); |
| ar6000_setup_cut_power_state(ar, WLAN_ENABLED); |
| } |
| status = ar6000_setup_deep_sleep_state(ar, WLAN_DISABLED); |
| } else if (powerState == WLAN_POWER_STATE_CUT_PWR) { |
| status = ar6000_setup_cut_power_state(ar, WLAN_DISABLED); |
| } |
| |
| } |
| |
| if (status!=A_OK) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Fail to setup WLAN state %d\n", ar->arWlanState)); |
| ar->arWlanState = oldstate; |
| } else if (status == A_OK) { |
| WMI_REPORT_SLEEP_STATE_EVENT wmiSleepEvent, *pSleepEvent = NULL; |
| if ((ar->arWlanPowerState == WLAN_POWER_STATE_ON) && (oldPowerState != WLAN_POWER_STATE_ON)) { |
| wmiSleepEvent.sleepState = WMI_REPORT_SLEEP_STATUS_IS_AWAKE; |
| pSleepEvent = &wmiSleepEvent; |
| } else if ((ar->arWlanPowerState != WLAN_POWER_STATE_ON) && (oldPowerState == WLAN_POWER_STATE_ON)) { |
| wmiSleepEvent.sleepState = WMI_REPORT_SLEEP_STATUS_IS_DEEP_SLEEP; |
| pSleepEvent = &wmiSleepEvent; |
| } |
| if (pSleepEvent) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM, ("SENT WLAN Sleep Event %d\n", wmiSleepEvent.sleepState)); |
| for(i = 0; i < num_device; i++) |
| { |
| arPriv = ar->arDev[i]; |
| ar6000_send_event_to_app(arPriv, WMI_REPORT_SLEEP_STATE_EVENTID, (A_UINT8*)pSleepEvent, |
| sizeof(WMI_REPORT_SLEEP_STATE_EVENTID)); |
| } |
| } |
| } |
| up(&ar->arSem); |
| return status; |
| } |
| |
| A_STATUS |
| ar6000_set_bt_hw_state(struct ar6_softc *ar, A_UINT32 enable) |
| { |
| #ifdef CONFIG_PM |
| A_BOOL off = (enable == 0); |
| A_STATUS status; |
| if (ar->arBTOff == off) { |
| return A_OK; |
| } |
| ar->arBTOff = off; |
| status = ar6000_update_wlan_pwr_state(ar, ar->arWlanOff ? WLAN_DISABLED : WLAN_ENABLED, FALSE); |
| return status; |
| #else |
| return A_OK; |
| #endif |
| } |
| |
| A_STATUS |
| ar6000_set_wlan_state(struct ar6_softc *ar, AR6000_WLAN_STATE state) |
| { |
| A_INT32 i; |
| A_STATUS status; |
| A_BOOL off = (state == WLAN_DISABLED); |
| return A_OK; |
| |
| if (ar->arWlanOff == off) { |
| return A_OK; |
| } |
| |
| #if WLAN_CONFIG_FIRST_SCAN_2G_ONLY |
| if(!off) { |
| first_scan_2g_only = 1; |
| AR_DEBUG_PRINTF(ATH_DEBUG_PM, ("AR6K: first_scan_2g_only = 1\n")); |
| } |
| #endif |
| |
| ar->arWlanOff = off; |
| status = ar6000_update_wlan_pwr_state(ar, state, FALSE); |
| for(i = 0; i < num_device; i++) { |
| AR_SOFTC_DEV_T *arPriv = ar->arDev[i]; |
| AR_SOFTC_STA_T *arSta = &arPriv->arSta; |
| if (arSta->scan_triggered) { |
| ar6000_scanComplete_event(arPriv, A_OK); |
| } |
| } |
| return status; |
| } |
| |
| void ar6000_pm_init() |
| { |
| A_REGISTER_MODULE_DEBUG_INFO(pm); |
| #ifdef CONFIG_PM |
| #ifdef CONFIG_HAS_WAKELOCK |
| wake_lock_init(&ar6k_suspend_wake_lock, WAKE_LOCK_SUSPEND, "ar6k_suspend"); |
| wake_lock_init(&ar6k_wow_wake_lock, WAKE_LOCK_SUSPEND, "ar6k_wow"); |
| #endif |
| /* |
| * Register ar6000_pm_device into system. |
| * We should also add platform_device into the first item of array |
| * of devices[] in file arch/xxx/mach-xxx/board-xxxx.c |
| */ |
| #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15) |
| if (platform_driver_register(&ar6000_pm_device)) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000: fail to register the power control driver.\n")); |
| } |
| #endif |
| |
| #if PLAT_WOW_GPIO_PIN |
| wow_irq = gpio_to_irq(PLAT_WOW_GPIO_PIN); |
| if (wow_irq) { |
| int ret; |
| ret = request_irq(wow_irq, ar6000_wow_irq, |
| IRQF_SHARED | IRQF_TRIGGER_RISING, |
| "ar6000" "sdiowakeup", &wow_irq); |
| if (!ret) { |
| ret = enable_irq_wake(wow_irq); |
| if (ret < 0) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Couldn't enable WoW IRQ as wakeup interrupt")); |
| } |
| } |
| } |
| #endif /* PLAT_WOW_GPIO_PIN */ |
| #endif /* CONFIG_PM */ |
| } |
| |
| void ar6000_pm_exit() |
| { |
| #ifdef CONFIG_PM |
| #if PLAT_WOW_GPIO_PIN |
| if (wow_irq) { |
| if (disable_irq_wake(wow_irq)) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Couldn't disable hostwake IRQ wakeup mode\n")); |
| } |
| free_irq(wow_irq, &wow_irq); |
| wow_irq = 0; |
| } |
| #endif /* PLAT_WOW_GPIO_PIN */ |
| |
| #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15) |
| platform_driver_unregister(&ar6000_pm_device); |
| #endif |
| #ifdef CONFIG_HAS_WAKELOCK |
| wake_lock_destroy(&ar6k_suspend_wake_lock); |
| wake_lock_destroy(&ar6k_wow_wake_lock); |
| #endif |
| #endif /* CONFIG_PM */ |
| } |
| |
