VOID CFG80211_RFKillStatusUpdate( IN PVOID pAd, IN BOOLEAN active) { struct wiphy *pWiphy; CFG80211_CB *pCfg80211_CB; RTMP_DRIVER_80211_CB_GET(pAd, &pCfg80211_CB); pWiphy = pCfg80211_CB->pCfg80211_Wdev->wiphy; wiphy_rfkill_set_hw_state(pWiphy, !active); return; }
static int CFG80211_OpsRFKill( IN struct wiphy *pWiphy) { VOID *pAd; BOOLEAN active; MAC80211_PAD_GET(pAd, pWiphy); RTMP_DRIVER_80211_RFKILL(pAd, &active); wiphy_rfkill_set_hw_state(pWiphy, !active); return active; }
/* * precondition: perimeter lock has been acquired */ bool wl_rfkill_set_hw_state(struct wl_info *wl) { bool blocked = wlc_check_radio_disabled(wl->wlc); WL_NONE("%s: update hw state: blocked=%s\n", __func__, blocked ? "true" : "false"); WL_UNLOCK(wl); wiphy_rfkill_set_hw_state(wl->pub->ieee_hw->wiphy, blocked); if (blocked) wiphy_rfkill_start_polling(wl->pub->ieee_hw->wiphy); WL_LOCK(wl); return blocked; }
void rtl8187_rfkill_poll(struct ieee80211_hw *hw) { bool enabled; struct rtl8187_priv *priv = hw->priv; mutex_lock(&priv->conf_mutex); enabled = rtl8187_is_radio_enabled(priv); if (unlikely(enabled != priv->rfkill_off)) { priv->rfkill_off = enabled; printk(KERN_INFO "rtl8187: wireless radio switch turned %s\n", enabled ? "on" : "off"); wiphy_rfkill_set_hw_state(hw->wiphy, !enabled); } mutex_unlock(&priv->conf_mutex); }
static int iwl_trans_start_device(struct iwl_priv *priv) { int ret; priv->ucode_owner = IWL_OWNERSHIP_DRIVER; if ((priv->cfg->sku & EEPROM_SKU_CAP_AMT_ENABLE) && iwl_trans_prepare_card_hw(priv)) { IWL_WARN(priv, "Exit HW not ready\n"); return -EIO; } /* If platform's RF_KILL switch is NOT set to KILL */ if (iwl_read32(priv, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW) clear_bit(STATUS_RF_KILL_HW, &priv->status); else set_bit(STATUS_RF_KILL_HW, &priv->status); if (iwl_is_rfkill(priv)) { wiphy_rfkill_set_hw_state(priv->hw->wiphy, true); iwl_enable_interrupts(priv); return -ERFKILL; } iwl_write32(priv, CSR_INT, 0xFFFFFFFF); ret = iwl_nic_init(priv); if (ret) { IWL_ERR(priv, "Unable to init nic\n"); return ret; } /* make sure rfkill handshake bits are cleared */ iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL); iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED); /* clear (again), then enable host interrupts */ iwl_write32(priv, CSR_INT, 0xFFFFFFFF); iwl_enable_interrupts(priv); /* really make sure rfkill handshake bits are cleared */ iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL); iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL); return 0; }
/* * called from both kernel as from this kernel module (error flow on attach) * precondition: perimeter lock is not acquired. */ static void brcms_remove(struct bcma_device *pdev) { struct ieee80211_hw *hw = bcma_get_drvdata(pdev); struct brcms_info *wl = hw->priv; if (wl->wlc) { wiphy_rfkill_set_hw_state(wl->pub->ieee_hw->wiphy, false); wiphy_rfkill_stop_polling(wl->pub->ieee_hw->wiphy); ieee80211_unregister_hw(hw); } brcms_free(wl); bcma_set_drvdata(pdev, NULL); ieee80211_free_hw(hw); }
bool rtl8192_rfkill_init(struct net_device *dev) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); struct wireless_dev *wdev = &priv->rtllib->wdev; bool radio_enabled; bool valid = rtl8192_is_radio_enabled(dev, &radio_enabled); if (valid) { priv->rfkill_off = radio_enabled; printk(KERN_INFO "rtl8192: wireless switch is %s\n", priv->rfkill_off ? "on" : "off"); wiphy_rfkill_set_hw_state(wdev->wiphy, !priv->rfkill_off); wiphy_rfkill_start_polling(wdev->wiphy); return true; } else { return false; } }
void b43legacy_rfkill_poll(struct ieee80211_hw *hw) { struct b43legacy_wl *wl = hw_to_b43legacy_wl(hw); struct b43legacy_wldev *dev = wl->current_dev; struct ssb_bus *bus = dev->dev->bus; bool enabled; bool brought_up = false; mutex_lock(&wl->mutex); if (unlikely(b43legacy_status(dev) < B43legacy_STAT_INITIALIZED)) { if (ssb_bus_powerup(bus, 0)) { mutex_unlock(&wl->mutex); return; } ssb_device_enable(dev->dev, 0); brought_up = true; } enabled = b43legacy_is_hw_radio_enabled(dev); if (unlikely(enabled != dev->radio_hw_enable)) { dev->radio_hw_enable = enabled; b43legacyinfo(wl, "Radio hardware status changed to %s\n", enabled ? "ENABLED" : "DISABLED"); wiphy_rfkill_set_hw_state(hw->wiphy, !enabled); if (enabled != dev->phy.radio_on) { if (enabled) b43legacy_radio_turn_on(dev); else b43legacy_radio_turn_off(dev, 0); } } if (brought_up) { ssb_device_disable(dev->dev, 0); ssb_bus_may_powerdown(bus); } mutex_unlock(&wl->mutex); }
void rtl_init_rfkill(struct ieee80211_hw *hw) { struct rtl_priv *rtlpriv = rtl_priv(hw); bool radio_state; bool blocked; u8 valid = 0; radio_state = rtlpriv->cfg->ops->radio_onoff_checking(hw, &valid); /*set init state to that of switch */ rtlpriv->rfkill.rfkill_state = radio_state; printk(KERN_INFO "rtlwifi: wireless switch is %s\n", rtlpriv->rfkill.rfkill_state ? "on" : "off"); if (valid) { rtlpriv->rfkill.rfkill_state = radio_state; blocked = (rtlpriv->rfkill.rfkill_state == 1) ? 0 : 1; wiphy_rfkill_set_hw_state(hw->wiphy, blocked); } wiphy_rfkill_start_polling(hw->wiphy); }
/* * called from both kernel as from this kernel module. * precondition: perimeter lock is not acquired. */ static void brcms_remove(struct pci_dev *pdev) { struct brcms_info *wl; struct ieee80211_hw *hw; int status; hw = pci_get_drvdata(pdev); wl = HW_TO_WL(hw); if (!wl) { pr_err("wl: brcms_remove: pci_get_drvdata failed\n"); return; } LOCK(wl); status = brcms_c_chipmatch(pdev->vendor, pdev->device); UNLOCK(wl); if (!status) { wiphy_err(wl->wiphy, "wl: brcms_remove: chipmatch " "failed\n"); return; } if (wl->wlc) { wiphy_rfkill_set_hw_state(wl->pub->ieee_hw->wiphy, false); wiphy_rfkill_stop_polling(wl->pub->ieee_hw->wiphy); ieee80211_unregister_hw(hw); LOCK(wl); brcms_down(wl); UNLOCK(wl); } pci_disable_device(pdev); brcms_free(wl); pci_set_drvdata(pdev, NULL); ieee80211_free_hw(hw); }
/* * called from both kernel as from wl_*() * precondition: perimeter lock is not acquired. */ static void wl_remove(struct pci_dev *pdev) { struct wl_info *wl; struct ieee80211_hw *hw; int status; hw = pci_get_drvdata(pdev); wl = HW_TO_WL(hw); if (!wl) { WL_ERROR("wl: wl_remove: pci_get_drvdata failed\n"); return; } WL_LOCK(wl); status = wlc_chipmatch(pdev->vendor, pdev->device); WL_UNLOCK(wl); if (!status) { WL_ERROR("wl: wl_remove: wlc_chipmatch failed\n"); return; } if (wl->wlc) { wiphy_rfkill_set_hw_state(wl->pub->ieee_hw->wiphy, false); wiphy_rfkill_stop_polling(wl->pub->ieee_hw->wiphy); ieee80211_unregister_hw(hw); WL_LOCK(wl); wl_down(wl); WL_UNLOCK(wl); WL_NONE("%s: Down\n", __func__); } pci_disable_device(pdev); wl_free(wl); pci_set_drvdata(pdev, NULL); ieee80211_free_hw(hw); }