aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wireless/iwlwifi/iwl-agn.c
diff options
context:
space:
mode:
authorWey-Yi Guy <wey-yi.w.guy@intel.com>2011-11-10 09:55:11 -0500
committerJohn W. Linville <linville@tuxdriver.com>2011-11-11 12:32:53 -0500
commit7335613ae27ae148fde720caccbfbbd9afa7465d (patch)
tree4a0abce10b0fc00fc92ca26df351950500653b9e /drivers/net/wireless/iwlwifi/iwl-agn.c
parentde7f5f92dbda0652dcb850fd02762e628556f645 (diff)
iwlwifi: move all mac80211 related functions to one place
There are many mac80211 callback functions in the driver, as current implementation, those functions are scatter everywhere which is very difficult to find and maintain, move all the mac80211 callback functions into single file. There should be no functional changes Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com> Signed-off-by: John W. Linville <linville@tuxdriver.com>
Diffstat (limited to 'drivers/net/wireless/iwlwifi/iwl-agn.c')
-rw-r--r--drivers/net/wireless/iwlwifi/iwl-agn.c1477
1 files changed, 3 insertions, 1474 deletions
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn.c b/drivers/net/wireless/iwlwifi/iwl-agn.c
index 7514b17193ad..e235e84de8b4 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn.c
@@ -508,16 +508,7 @@ static void iwl_init_context(struct iwl_priv *priv, u32 ucode_flags)
508 BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2); 508 BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);
509} 509}
510 510
511
512struct iwlagn_ucode_capabilities {
513 u32 max_probe_length;
514 u32 standard_phy_calibration_size;
515 u32 flags;
516};
517
518static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context); 511static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context);
519static int iwlagn_mac_setup_register(struct iwl_priv *priv,
520 struct iwlagn_ucode_capabilities *capa);
521 512
522#define UCODE_EXPERIMENTAL_INDEX 100 513#define UCODE_EXPERIMENTAL_INDEX 100
523#define UCODE_EXPERIMENTAL_TAG "exp" 514#define UCODE_EXPERIMENTAL_TAG "exp"
@@ -1307,7 +1298,7 @@ int iwl_alive_start(struct iwl_priv *priv)
1307 1298
1308static void iwl_cancel_deferred_work(struct iwl_priv *priv); 1299static void iwl_cancel_deferred_work(struct iwl_priv *priv);
1309 1300
1310static void __iwl_down(struct iwl_priv *priv) 1301void __iwl_down(struct iwl_priv *priv)
1311{ 1302{
1312 int exit_pending; 1303 int exit_pending;
1313 1304
@@ -1370,7 +1361,7 @@ static void __iwl_down(struct iwl_priv *priv)
1370 priv->beacon_skb = NULL; 1361 priv->beacon_skb = NULL;
1371} 1362}
1372 1363
1373static void iwl_down(struct iwl_priv *priv) 1364void iwl_down(struct iwl_priv *priv)
1374{ 1365{
1375 mutex_lock(&priv->shrd->mutex); 1366 mutex_lock(&priv->shrd->mutex);
1376 __iwl_down(priv); 1367 __iwl_down(priv);
@@ -1379,55 +1370,6 @@ static void iwl_down(struct iwl_priv *priv)
1379 iwl_cancel_deferred_work(priv); 1370 iwl_cancel_deferred_work(priv);
1380} 1371}
1381 1372
1382#define MAX_HW_RESTARTS 5
1383
1384static int __iwl_up(struct iwl_priv *priv)
1385{
1386 struct iwl_rxon_context *ctx;
1387 int ret;
1388
1389 lockdep_assert_held(&priv->shrd->mutex);
1390
1391 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status)) {
1392 IWL_WARN(priv, "Exit pending; will not bring the NIC up\n");
1393 return -EIO;
1394 }
1395
1396 for_each_context(priv, ctx) {
1397 ret = iwlagn_alloc_bcast_station(priv, ctx);
1398 if (ret) {
1399 iwl_dealloc_bcast_stations(priv);
1400 return ret;
1401 }
1402 }
1403
1404 ret = iwlagn_run_init_ucode(priv);
1405 if (ret) {
1406 IWL_ERR(priv, "Failed to run INIT ucode: %d\n", ret);
1407 goto error;
1408 }
1409
1410 ret = iwlagn_load_ucode_wait_alive(priv, IWL_UCODE_REGULAR);
1411 if (ret) {
1412 IWL_ERR(priv, "Failed to start RT ucode: %d\n", ret);
1413 goto error;
1414 }
1415
1416 ret = iwl_alive_start(priv);
1417 if (ret)
1418 goto error;
1419 return 0;
1420
1421 error:
1422 set_bit(STATUS_EXIT_PENDING, &priv->shrd->status);
1423 __iwl_down(priv);
1424 clear_bit(STATUS_EXIT_PENDING, &priv->shrd->status);
1425
1426 IWL_ERR(priv, "Unable to initialize device.\n");
1427 return ret;
1428}
1429
1430
1431/***************************************************************************** 1373/*****************************************************************************
1432 * 1374 *
1433 * Workqueue callbacks 1375 * Workqueue callbacks
@@ -1455,7 +1397,7 @@ static void iwl_bg_run_time_calib_work(struct work_struct *work)
1455 mutex_unlock(&priv->shrd->mutex); 1397 mutex_unlock(&priv->shrd->mutex);
1456} 1398}
1457 1399
1458static void iwlagn_prepare_restart(struct iwl_priv *priv) 1400void iwlagn_prepare_restart(struct iwl_priv *priv)
1459{ 1401{
1460 struct iwl_rxon_context *ctx; 1402 struct iwl_rxon_context *ctx;
1461 bool bt_full_concurrent; 1403 bool bt_full_concurrent;
@@ -1512,1181 +1454,8 @@ static void iwl_bg_restart(struct work_struct *data)
1512 } 1454 }
1513} 1455}
1514 1456
1515/*****************************************************************************
1516 *
1517 * mac80211 entry point functions
1518 *
1519 *****************************************************************************/
1520
1521static const struct ieee80211_iface_limit iwlagn_sta_ap_limits[] = {
1522 {
1523 .max = 1,
1524 .types = BIT(NL80211_IFTYPE_STATION),
1525 },
1526 {
1527 .max = 1,
1528 .types = BIT(NL80211_IFTYPE_AP),
1529 },
1530};
1531
1532static const struct ieee80211_iface_limit iwlagn_2sta_limits[] = {
1533 {
1534 .max = 2,
1535 .types = BIT(NL80211_IFTYPE_STATION),
1536 },
1537};
1538
1539static const struct ieee80211_iface_limit iwlagn_p2p_sta_go_limits[] = {
1540 {
1541 .max = 1,
1542 .types = BIT(NL80211_IFTYPE_STATION),
1543 },
1544 {
1545 .max = 1,
1546 .types = BIT(NL80211_IFTYPE_P2P_GO) |
1547 BIT(NL80211_IFTYPE_AP),
1548 },
1549};
1550
1551static const struct ieee80211_iface_limit iwlagn_p2p_2sta_limits[] = {
1552 {
1553 .max = 2,
1554 .types = BIT(NL80211_IFTYPE_STATION),
1555 },
1556 {
1557 .max = 1,
1558 .types = BIT(NL80211_IFTYPE_P2P_CLIENT),
1559 },
1560};
1561
1562static const struct ieee80211_iface_combination
1563iwlagn_iface_combinations_dualmode[] = {
1564 { .num_different_channels = 1,
1565 .max_interfaces = 2,
1566 .beacon_int_infra_match = true,
1567 .limits = iwlagn_sta_ap_limits,
1568 .n_limits = ARRAY_SIZE(iwlagn_sta_ap_limits),
1569 },
1570 { .num_different_channels = 1,
1571 .max_interfaces = 2,
1572 .limits = iwlagn_2sta_limits,
1573 .n_limits = ARRAY_SIZE(iwlagn_2sta_limits),
1574 },
1575};
1576
1577static const struct ieee80211_iface_combination
1578iwlagn_iface_combinations_p2p[] = {
1579 { .num_different_channels = 1,
1580 .max_interfaces = 2,
1581 .beacon_int_infra_match = true,
1582 .limits = iwlagn_p2p_sta_go_limits,
1583 .n_limits = ARRAY_SIZE(iwlagn_p2p_sta_go_limits),
1584 },
1585 { .num_different_channels = 1,
1586 .max_interfaces = 2,
1587 .limits = iwlagn_p2p_2sta_limits,
1588 .n_limits = ARRAY_SIZE(iwlagn_p2p_2sta_limits),
1589 },
1590};
1591
1592/*
1593 * Not a mac80211 entry point function, but it fits in with all the
1594 * other mac80211 functions grouped here.
1595 */
1596static int iwlagn_mac_setup_register(struct iwl_priv *priv,
1597 struct iwlagn_ucode_capabilities *capa)
1598{
1599 int ret;
1600 struct ieee80211_hw *hw = priv->hw;
1601 struct iwl_rxon_context *ctx;
1602
1603 hw->rate_control_algorithm = "iwl-agn-rs";
1604
1605 /* Tell mac80211 our characteristics */
1606 hw->flags = IEEE80211_HW_SIGNAL_DBM |
1607 IEEE80211_HW_AMPDU_AGGREGATION |
1608 IEEE80211_HW_NEED_DTIM_PERIOD |
1609 IEEE80211_HW_SPECTRUM_MGMT |
1610 IEEE80211_HW_REPORTS_TX_ACK_STATUS;
1611
1612 /*
1613 * Including the following line will crash some AP's. This
1614 * workaround removes the stimulus which causes the crash until
1615 * the AP software can be fixed.
1616 hw->max_tx_aggregation_subframes = LINK_QUAL_AGG_FRAME_LIMIT_DEF;
1617 */
1618
1619 hw->flags |= IEEE80211_HW_SUPPORTS_PS |
1620 IEEE80211_HW_SUPPORTS_DYNAMIC_PS;
1621
1622 if (priv->cfg->sku & EEPROM_SKU_CAP_11N_ENABLE)
1623 hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS |
1624 IEEE80211_HW_SUPPORTS_STATIC_SMPS;
1625
1626 if (capa->flags & IWL_UCODE_TLV_FLAGS_MFP)
1627 hw->flags |= IEEE80211_HW_MFP_CAPABLE;
1628
1629 hw->sta_data_size = sizeof(struct iwl_station_priv);
1630 hw->vif_data_size = sizeof(struct iwl_vif_priv);
1631
1632 for_each_context(priv, ctx) {
1633 hw->wiphy->interface_modes |= ctx->interface_modes;
1634 hw->wiphy->interface_modes |= ctx->exclusive_interface_modes;
1635 }
1636
1637 BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);
1638
1639 if (hw->wiphy->interface_modes & BIT(NL80211_IFTYPE_P2P_CLIENT)) {
1640 hw->wiphy->iface_combinations = iwlagn_iface_combinations_p2p;
1641 hw->wiphy->n_iface_combinations =
1642 ARRAY_SIZE(iwlagn_iface_combinations_p2p);
1643 } else if (hw->wiphy->interface_modes & BIT(NL80211_IFTYPE_AP)) {
1644 hw->wiphy->iface_combinations = iwlagn_iface_combinations_dualmode;
1645 hw->wiphy->n_iface_combinations =
1646 ARRAY_SIZE(iwlagn_iface_combinations_dualmode);
1647 }
1648
1649 hw->wiphy->max_remain_on_channel_duration = 1000;
1650
1651 hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY |
1652 WIPHY_FLAG_DISABLE_BEACON_HINTS |
1653 WIPHY_FLAG_IBSS_RSN;
1654
1655 if (trans(priv)->ucode_wowlan.code.len &&
1656 device_can_wakeup(bus(priv)->dev)) {
1657 hw->wiphy->wowlan.flags = WIPHY_WOWLAN_MAGIC_PKT |
1658 WIPHY_WOWLAN_DISCONNECT |
1659 WIPHY_WOWLAN_EAP_IDENTITY_REQ |
1660 WIPHY_WOWLAN_RFKILL_RELEASE;
1661 if (!iwlagn_mod_params.sw_crypto)
1662 hw->wiphy->wowlan.flags |=
1663 WIPHY_WOWLAN_SUPPORTS_GTK_REKEY |
1664 WIPHY_WOWLAN_GTK_REKEY_FAILURE;
1665
1666 hw->wiphy->wowlan.n_patterns = IWLAGN_WOWLAN_MAX_PATTERNS;
1667 hw->wiphy->wowlan.pattern_min_len =
1668 IWLAGN_WOWLAN_MIN_PATTERN_LEN;
1669 hw->wiphy->wowlan.pattern_max_len =
1670 IWLAGN_WOWLAN_MAX_PATTERN_LEN;
1671 }
1672
1673 if (iwlagn_mod_params.power_save)
1674 hw->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
1675 else
1676 hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
1677
1678 hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX;
1679 /* we create the 802.11 header and a zero-length SSID element */
1680 hw->wiphy->max_scan_ie_len = capa->max_probe_length - 24 - 2;
1681
1682 /* Default value; 4 EDCA QOS priorities */
1683 hw->queues = 4;
1684
1685 hw->max_listen_interval = IWL_CONN_MAX_LISTEN_INTERVAL;
1686
1687 if (priv->bands[IEEE80211_BAND_2GHZ].n_channels)
1688 priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
1689 &priv->bands[IEEE80211_BAND_2GHZ];
1690 if (priv->bands[IEEE80211_BAND_5GHZ].n_channels)
1691 priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
1692 &priv->bands[IEEE80211_BAND_5GHZ];
1693
1694 iwl_leds_init(priv);
1695
1696 ret = ieee80211_register_hw(priv->hw);
1697 if (ret) {
1698 IWL_ERR(priv, "Failed to register hw (error %d)\n", ret);
1699 return ret;
1700 }
1701 priv->mac80211_registered = 1;
1702
1703 return 0;
1704}
1705
1706
1707static int iwlagn_mac_start(struct ieee80211_hw *hw)
1708{
1709 struct iwl_priv *priv = hw->priv;
1710 int ret;
1711
1712 IWL_DEBUG_MAC80211(priv, "enter\n");
1713
1714 /* we should be verifying the device is ready to be opened */
1715 mutex_lock(&priv->shrd->mutex);
1716 ret = __iwl_up(priv);
1717 mutex_unlock(&priv->shrd->mutex);
1718 if (ret)
1719 return ret;
1720
1721 IWL_DEBUG_INFO(priv, "Start UP work done.\n");
1722
1723 /* Now we should be done, and the READY bit should be set. */
1724 if (WARN_ON(!test_bit(STATUS_READY, &priv->shrd->status)))
1725 ret = -EIO;
1726
1727 iwlagn_led_enable(priv);
1728
1729 priv->is_open = 1;
1730 IWL_DEBUG_MAC80211(priv, "leave\n");
1731 return 0;
1732}
1733
1734static void iwlagn_mac_stop(struct ieee80211_hw *hw)
1735{
1736 struct iwl_priv *priv = hw->priv;
1737
1738 IWL_DEBUG_MAC80211(priv, "enter\n");
1739
1740 if (!priv->is_open)
1741 return;
1742
1743 priv->is_open = 0;
1744
1745 iwl_down(priv);
1746
1747 flush_workqueue(priv->shrd->workqueue);
1748
1749 /* User space software may expect getting rfkill changes
1750 * even if interface is down */
1751 iwl_write32(bus(priv), CSR_INT, 0xFFFFFFFF);
1752 iwl_enable_rfkill_int(priv);
1753
1754 IWL_DEBUG_MAC80211(priv, "leave\n");
1755}
1756
1757#ifdef CONFIG_PM_SLEEP
1758static int iwlagn_send_patterns(struct iwl_priv *priv,
1759 struct cfg80211_wowlan *wowlan)
1760{
1761 struct iwlagn_wowlan_patterns_cmd *pattern_cmd;
1762 struct iwl_host_cmd cmd = {
1763 .id = REPLY_WOWLAN_PATTERNS,
1764 .dataflags[0] = IWL_HCMD_DFL_NOCOPY,
1765 .flags = CMD_SYNC,
1766 };
1767 int i, err;
1768
1769 if (!wowlan->n_patterns)
1770 return 0;
1771
1772 cmd.len[0] = sizeof(*pattern_cmd) +
1773 wowlan->n_patterns * sizeof(struct iwlagn_wowlan_pattern);
1774
1775 pattern_cmd = kmalloc(cmd.len[0], GFP_KERNEL);
1776 if (!pattern_cmd)
1777 return -ENOMEM;
1778
1779 pattern_cmd->n_patterns = cpu_to_le32(wowlan->n_patterns);
1780
1781 for (i = 0; i < wowlan->n_patterns; i++) {
1782 int mask_len = DIV_ROUND_UP(wowlan->patterns[i].pattern_len, 8);
1783
1784 memcpy(&pattern_cmd->patterns[i].mask,
1785 wowlan->patterns[i].mask, mask_len);
1786 memcpy(&pattern_cmd->patterns[i].pattern,
1787 wowlan->patterns[i].pattern,
1788 wowlan->patterns[i].pattern_len);
1789 pattern_cmd->patterns[i].mask_size = mask_len;
1790 pattern_cmd->patterns[i].pattern_size =
1791 wowlan->patterns[i].pattern_len;
1792 }
1793
1794 cmd.data[0] = pattern_cmd;
1795 err = iwl_trans_send_cmd(trans(priv), &cmd);
1796 kfree(pattern_cmd);
1797 return err;
1798}
1799#endif
1800
1801static void iwlagn_mac_set_rekey_data(struct ieee80211_hw *hw,
1802 struct ieee80211_vif *vif,
1803 struct cfg80211_gtk_rekey_data *data)
1804{
1805 struct iwl_priv *priv = hw->priv;
1806
1807 if (iwlagn_mod_params.sw_crypto)
1808 return;
1809
1810 IWL_DEBUG_MAC80211(priv, "enter\n");
1811 mutex_lock(&priv->shrd->mutex);
1812
1813 if (priv->contexts[IWL_RXON_CTX_BSS].vif != vif)
1814 goto out;
1815
1816 memcpy(priv->kek, data->kek, NL80211_KEK_LEN);
1817 memcpy(priv->kck, data->kck, NL80211_KCK_LEN);
1818 priv->replay_ctr = cpu_to_le64(be64_to_cpup((__be64 *)&data->replay_ctr));
1819 priv->have_rekey_data = true;
1820
1821 out:
1822 mutex_unlock(&priv->shrd->mutex);
1823 IWL_DEBUG_MAC80211(priv, "leave\n");
1824}
1825
1826struct wowlan_key_data {
1827 struct iwl_rxon_context *ctx;
1828 struct iwlagn_wowlan_rsc_tsc_params_cmd *rsc_tsc;
1829 struct iwlagn_wowlan_tkip_params_cmd *tkip;
1830 const u8 *bssid;
1831 bool error, use_rsc_tsc, use_tkip;
1832};
1833
1834#ifdef CONFIG_PM_SLEEP
1835static void iwlagn_convert_p1k(u16 *p1k, __le16 *out)
1836{
1837 int i;
1838
1839 for (i = 0; i < IWLAGN_P1K_SIZE; i++)
1840 out[i] = cpu_to_le16(p1k[i]);
1841}
1842
1843static void iwlagn_wowlan_program_keys(struct ieee80211_hw *hw,
1844 struct ieee80211_vif *vif,
1845 struct ieee80211_sta *sta,
1846 struct ieee80211_key_conf *key,
1847 void *_data)
1848{
1849 struct iwl_priv *priv = hw->priv;
1850 struct wowlan_key_data *data = _data;
1851 struct iwl_rxon_context *ctx = data->ctx;
1852 struct aes_sc *aes_sc, *aes_tx_sc = NULL;
1853 struct tkip_sc *tkip_sc, *tkip_tx_sc = NULL;
1854 struct iwlagn_p1k_cache *rx_p1ks;
1855 u8 *rx_mic_key;
1856 struct ieee80211_key_seq seq;
1857 u32 cur_rx_iv32 = 0;
1858 u16 p1k[IWLAGN_P1K_SIZE];
1859 int ret, i;
1860
1861 mutex_lock(&priv->shrd->mutex);
1862
1863 if ((key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
1864 key->cipher == WLAN_CIPHER_SUITE_WEP104) &&
1865 !sta && !ctx->key_mapping_keys)
1866 ret = iwl_set_default_wep_key(priv, ctx, key);
1867 else
1868 ret = iwl_set_dynamic_key(priv, ctx, key, sta);
1869
1870 if (ret) {
1871 IWL_ERR(priv, "Error setting key during suspend!\n");
1872 data->error = true;
1873 }
1874
1875 switch (key->cipher) {
1876 case WLAN_CIPHER_SUITE_TKIP:
1877 if (sta) {
1878 tkip_sc = data->rsc_tsc->all_tsc_rsc.tkip.unicast_rsc;
1879 tkip_tx_sc = &data->rsc_tsc->all_tsc_rsc.tkip.tsc;
1880
1881 rx_p1ks = data->tkip->rx_uni;
1882
1883 ieee80211_get_key_tx_seq(key, &seq);
1884 tkip_tx_sc->iv16 = cpu_to_le16(seq.tkip.iv16);
1885 tkip_tx_sc->iv32 = cpu_to_le32(seq.tkip.iv32);
1886
1887 ieee80211_get_tkip_p1k_iv(key, seq.tkip.iv32, p1k);
1888 iwlagn_convert_p1k(p1k, data->tkip->tx.p1k);
1889
1890 memcpy(data->tkip->mic_keys.tx,
1891 &key->key[NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY],
1892 IWLAGN_MIC_KEY_SIZE);
1893
1894 rx_mic_key = data->tkip->mic_keys.rx_unicast;
1895 } else {
1896 tkip_sc = data->rsc_tsc->all_tsc_rsc.tkip.multicast_rsc;
1897 rx_p1ks = data->tkip->rx_multi;
1898 rx_mic_key = data->tkip->mic_keys.rx_mcast;
1899 }
1900
1901 /*
1902 * For non-QoS this relies on the fact that both the uCode and
1903 * mac80211 use TID 0 (as they need to to avoid replay attacks)
1904 * for checking the IV in the frames.
1905 */
1906 for (i = 0; i < IWLAGN_NUM_RSC; i++) {
1907 ieee80211_get_key_rx_seq(key, i, &seq);
1908 tkip_sc[i].iv16 = cpu_to_le16(seq.tkip.iv16);
1909 tkip_sc[i].iv32 = cpu_to_le32(seq.tkip.iv32);
1910 /* wrapping isn't allowed, AP must rekey */
1911 if (seq.tkip.iv32 > cur_rx_iv32)
1912 cur_rx_iv32 = seq.tkip.iv32;
1913 }
1914
1915 ieee80211_get_tkip_rx_p1k(key, data->bssid, cur_rx_iv32, p1k);
1916 iwlagn_convert_p1k(p1k, rx_p1ks[0].p1k);
1917 ieee80211_get_tkip_rx_p1k(key, data->bssid,
1918 cur_rx_iv32 + 1, p1k);
1919 iwlagn_convert_p1k(p1k, rx_p1ks[1].p1k);
1920
1921 memcpy(rx_mic_key,
1922 &key->key[NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY],
1923 IWLAGN_MIC_KEY_SIZE);
1924
1925 data->use_tkip = true;
1926 data->use_rsc_tsc = true;
1927 break;
1928 case WLAN_CIPHER_SUITE_CCMP:
1929 if (sta) {
1930 u8 *pn = seq.ccmp.pn;
1931
1932 aes_sc = data->rsc_tsc->all_tsc_rsc.aes.unicast_rsc;
1933 aes_tx_sc = &data->rsc_tsc->all_tsc_rsc.aes.tsc;
1934
1935 ieee80211_get_key_tx_seq(key, &seq);
1936 aes_tx_sc->pn = cpu_to_le64(
1937 (u64)pn[5] |
1938 ((u64)pn[4] << 8) |
1939 ((u64)pn[3] << 16) |
1940 ((u64)pn[2] << 24) |
1941 ((u64)pn[1] << 32) |
1942 ((u64)pn[0] << 40));
1943 } else
1944 aes_sc = data->rsc_tsc->all_tsc_rsc.aes.multicast_rsc;
1945
1946 /*
1947 * For non-QoS this relies on the fact that both the uCode and
1948 * mac80211 use TID 0 for checking the IV in the frames.
1949 */
1950 for (i = 0; i < IWLAGN_NUM_RSC; i++) {
1951 u8 *pn = seq.ccmp.pn;
1952
1953 ieee80211_get_key_rx_seq(key, i, &seq);
1954 aes_sc->pn = cpu_to_le64(
1955 (u64)pn[5] |
1956 ((u64)pn[4] << 8) |
1957 ((u64)pn[3] << 16) |
1958 ((u64)pn[2] << 24) |
1959 ((u64)pn[1] << 32) |
1960 ((u64)pn[0] << 40));
1961 }
1962 data->use_rsc_tsc = true;
1963 break;
1964 }
1965
1966 mutex_unlock(&priv->shrd->mutex);
1967}
1968
1969static int iwlagn_mac_suspend(struct ieee80211_hw *hw,
1970 struct cfg80211_wowlan *wowlan)
1971{
1972 struct iwl_priv *priv = hw->priv;
1973 struct iwlagn_wowlan_wakeup_filter_cmd wakeup_filter_cmd;
1974 struct iwl_rxon_cmd rxon;
1975 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
1976 struct iwlagn_wowlan_kek_kck_material_cmd kek_kck_cmd;
1977 struct iwlagn_wowlan_tkip_params_cmd tkip_cmd = {};
1978 struct wowlan_key_data key_data = {
1979 .ctx = ctx,
1980 .bssid = ctx->active.bssid_addr,
1981 .use_rsc_tsc = false,
1982 .tkip = &tkip_cmd,
1983 .use_tkip = false,
1984 };
1985 struct iwlagn_d3_config_cmd d3_cfg_cmd = {};
1986 int ret, i;
1987 u16 seq;
1988
1989 if (WARN_ON(!wowlan))
1990 return -EINVAL;
1991
1992 IWL_DEBUG_MAC80211(priv, "enter\n");
1993 mutex_lock(&priv->shrd->mutex);
1994
1995 /* Don't attempt WoWLAN when not associated, tear down instead. */
1996 if (!ctx->vif || ctx->vif->type != NL80211_IFTYPE_STATION ||
1997 !iwl_is_associated_ctx(ctx)) {
1998 ret = 1;
1999 goto out;
2000 }
2001
2002 key_data.rsc_tsc = kzalloc(sizeof(*key_data.rsc_tsc), GFP_KERNEL);
2003 if (!key_data.rsc_tsc) {
2004 ret = -ENOMEM;
2005 goto out;
2006 }
2007
2008 memset(&wakeup_filter_cmd, 0, sizeof(wakeup_filter_cmd));
2009
2010 /*
2011 * We know the last used seqno, and the uCode expects to know that
2012 * one, it will increment before TX.
2013 */
2014 seq = le16_to_cpu(priv->last_seq_ctl) & IEEE80211_SCTL_SEQ;
2015 wakeup_filter_cmd.non_qos_seq = cpu_to_le16(seq);
2016
2017 /*
2018 * For QoS counters, we store the one to use next, so subtract 0x10
2019 * since the uCode will add 0x10 before using the value.
2020 */
2021 for (i = 0; i < 8; i++) {
2022 seq = priv->shrd->tid_data[IWL_AP_ID][i].seq_number;
2023 seq -= 0x10;
2024 wakeup_filter_cmd.qos_seq[i] = cpu_to_le16(seq);
2025 }
2026
2027 if (wowlan->disconnect)
2028 wakeup_filter_cmd.enabled |=
2029 cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_BEACON_MISS |
2030 IWLAGN_WOWLAN_WAKEUP_LINK_CHANGE);
2031 if (wowlan->magic_pkt)
2032 wakeup_filter_cmd.enabled |=
2033 cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_MAGIC_PACKET);
2034 if (wowlan->gtk_rekey_failure)
2035 wakeup_filter_cmd.enabled |=
2036 cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_GTK_REKEY_FAIL);
2037 if (wowlan->eap_identity_req)
2038 wakeup_filter_cmd.enabled |=
2039 cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_EAP_IDENT_REQ);
2040 if (wowlan->four_way_handshake)
2041 wakeup_filter_cmd.enabled |=
2042 cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_4WAY_HANDSHAKE);
2043 if (wowlan->n_patterns)
2044 wakeup_filter_cmd.enabled |=
2045 cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_PATTERN_MATCH);
2046
2047 if (wowlan->rfkill_release)
2048 d3_cfg_cmd.wakeup_flags |=
2049 cpu_to_le32(IWLAGN_D3_WAKEUP_RFKILL);
2050
2051 iwl_scan_cancel_timeout(priv, 200);
2052
2053 memcpy(&rxon, &ctx->active, sizeof(rxon));
2054
2055 iwl_trans_stop_device(trans(priv));
2056
2057 priv->shrd->wowlan = true;
2058
2059 ret = iwlagn_load_ucode_wait_alive(priv, IWL_UCODE_WOWLAN);
2060 if (ret)
2061 goto error;
2062
2063 /* now configure WoWLAN ucode */
2064 ret = iwl_alive_start(priv);
2065 if (ret)
2066 goto error;
2067
2068 memcpy(&ctx->staging, &rxon, sizeof(rxon));
2069 ret = iwlagn_commit_rxon(priv, ctx);
2070 if (ret)
2071 goto error;
2072
2073 ret = iwl_power_update_mode(priv, true);
2074 if (ret)
2075 goto error;
2076
2077 if (!iwlagn_mod_params.sw_crypto) {
2078 /* mark all keys clear */
2079 priv->ucode_key_table = 0;
2080 ctx->key_mapping_keys = 0;
2081
2082 /*
2083 * This needs to be unlocked due to lock ordering
2084 * constraints. Since we're in the suspend path
2085 * that isn't really a problem though.
2086 */
2087 mutex_unlock(&priv->shrd->mutex);
2088 ieee80211_iter_keys(priv->hw, ctx->vif,
2089 iwlagn_wowlan_program_keys,
2090 &key_data);
2091 mutex_lock(&priv->shrd->mutex);
2092 if (key_data.error) {
2093 ret = -EIO;
2094 goto error;
2095 }
2096
2097 if (key_data.use_rsc_tsc) {
2098 struct iwl_host_cmd rsc_tsc_cmd = {
2099 .id = REPLY_WOWLAN_TSC_RSC_PARAMS,
2100 .flags = CMD_SYNC,
2101 .data[0] = key_data.rsc_tsc,
2102 .dataflags[0] = IWL_HCMD_DFL_NOCOPY,
2103 .len[0] = sizeof(*key_data.rsc_tsc),
2104 };
2105
2106 ret = iwl_trans_send_cmd(trans(priv), &rsc_tsc_cmd);
2107 if (ret)
2108 goto error;
2109 }
2110
2111 if (key_data.use_tkip) {
2112 ret = iwl_trans_send_cmd_pdu(trans(priv),
2113 REPLY_WOWLAN_TKIP_PARAMS,
2114 CMD_SYNC, sizeof(tkip_cmd),
2115 &tkip_cmd);
2116 if (ret)
2117 goto error;
2118 }
2119
2120 if (priv->have_rekey_data) {
2121 memset(&kek_kck_cmd, 0, sizeof(kek_kck_cmd));
2122 memcpy(kek_kck_cmd.kck, priv->kck, NL80211_KCK_LEN);
2123 kek_kck_cmd.kck_len = cpu_to_le16(NL80211_KCK_LEN);
2124 memcpy(kek_kck_cmd.kek, priv->kek, NL80211_KEK_LEN);
2125 kek_kck_cmd.kek_len = cpu_to_le16(NL80211_KEK_LEN);
2126 kek_kck_cmd.replay_ctr = priv->replay_ctr;
2127
2128 ret = iwl_trans_send_cmd_pdu(trans(priv),
2129 REPLY_WOWLAN_KEK_KCK_MATERIAL,
2130 CMD_SYNC, sizeof(kek_kck_cmd),
2131 &kek_kck_cmd);
2132 if (ret)
2133 goto error;
2134 }
2135 }
2136
2137 ret = iwl_trans_send_cmd_pdu(trans(priv), REPLY_D3_CONFIG, CMD_SYNC,
2138 sizeof(d3_cfg_cmd), &d3_cfg_cmd);
2139 if (ret)
2140 goto error;
2141
2142 ret = iwl_trans_send_cmd_pdu(trans(priv), REPLY_WOWLAN_WAKEUP_FILTER,
2143 CMD_SYNC, sizeof(wakeup_filter_cmd),
2144 &wakeup_filter_cmd);
2145 if (ret)
2146 goto error;
2147
2148 ret = iwlagn_send_patterns(priv, wowlan);
2149 if (ret)
2150 goto error;
2151
2152 device_set_wakeup_enable(bus(priv)->dev, true);
2153
2154 /* Now let the ucode operate on its own */
2155 iwl_write32(bus(priv), CSR_UCODE_DRV_GP1_SET,
2156 CSR_UCODE_DRV_GP1_BIT_D3_CFG_COMPLETE);
2157
2158 goto out;
2159
2160 error:
2161 priv->shrd->wowlan = false;
2162 iwlagn_prepare_restart(priv);
2163 ieee80211_restart_hw(priv->hw);
2164 out:
2165 mutex_unlock(&priv->shrd->mutex);
2166 kfree(key_data.rsc_tsc);
2167 IWL_DEBUG_MAC80211(priv, "leave\n");
2168
2169 return ret;
2170}
2171
2172static int iwlagn_mac_resume(struct ieee80211_hw *hw)
2173{
2174 struct iwl_priv *priv = hw->priv;
2175 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
2176 struct ieee80211_vif *vif;
2177 unsigned long flags;
2178 u32 base, status = 0xffffffff;
2179 int ret = -EIO;
2180
2181 IWL_DEBUG_MAC80211(priv, "enter\n");
2182 mutex_lock(&priv->shrd->mutex);
2183
2184 iwl_write32(bus(priv), CSR_UCODE_DRV_GP1_CLR,
2185 CSR_UCODE_DRV_GP1_BIT_D3_CFG_COMPLETE);
2186
2187 base = priv->device_pointers.error_event_table;
2188 if (iwlagn_hw_valid_rtc_data_addr(base)) {
2189 spin_lock_irqsave(&bus(priv)->reg_lock, flags);
2190 ret = iwl_grab_nic_access_silent(bus(priv));
2191 if (ret == 0) {
2192 iwl_write32(bus(priv), HBUS_TARG_MEM_RADDR, base);
2193 status = iwl_read32(bus(priv), HBUS_TARG_MEM_RDAT);
2194 iwl_release_nic_access(bus(priv));
2195 }
2196 spin_unlock_irqrestore(&bus(priv)->reg_lock, flags);
2197
2198#ifdef CONFIG_IWLWIFI_DEBUGFS
2199 if (ret == 0) {
2200 struct iwl_trans *trans = trans(priv);
2201 if (!priv->wowlan_sram)
2202 priv->wowlan_sram =
2203 kzalloc(trans->ucode_wowlan.data.len,
2204 GFP_KERNEL);
2205
2206 if (priv->wowlan_sram)
2207 _iwl_read_targ_mem_words(
2208 bus(priv), 0x800000, priv->wowlan_sram,
2209 trans->ucode_wowlan.data.len / 4);
2210 }
2211#endif
2212 }
2213
2214 /* we'll clear ctx->vif during iwlagn_prepare_restart() */
2215 vif = ctx->vif;
2216
2217 priv->shrd->wowlan = false;
2218
2219 device_set_wakeup_enable(bus(priv)->dev, false);
2220
2221 iwlagn_prepare_restart(priv);
2222
2223 memset((void *)&ctx->active, 0, sizeof(ctx->active));
2224 iwl_connection_init_rx_config(priv, ctx);
2225 iwlagn_set_rxon_chain(priv, ctx);
2226
2227 mutex_unlock(&priv->shrd->mutex);
2228 IWL_DEBUG_MAC80211(priv, "leave\n");
2229
2230 ieee80211_resume_disconnect(vif);
2231
2232 return 1;
2233}
2234#endif
2235
2236static void iwlagn_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
2237{
2238 struct iwl_priv *priv = hw->priv;
2239
2240 IWL_DEBUG_MACDUMP(priv, "enter\n");
2241
2242 IWL_DEBUG_TX(priv, "dev->xmit(%d bytes) at rate 0x%02x\n", skb->len,
2243 ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate);
2244
2245 if (iwlagn_tx_skb(priv, skb))
2246 dev_kfree_skb_any(skb);
2247
2248 IWL_DEBUG_MACDUMP(priv, "leave\n");
2249}
2250
2251static void iwlagn_mac_update_tkip_key(struct ieee80211_hw *hw,
2252 struct ieee80211_vif *vif,
2253 struct ieee80211_key_conf *keyconf,
2254 struct ieee80211_sta *sta,
2255 u32 iv32, u16 *phase1key)
2256{
2257 struct iwl_priv *priv = hw->priv;
2258
2259 iwl_update_tkip_key(priv, vif, keyconf, sta, iv32, phase1key);
2260}
2261
2262static int iwlagn_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2263 struct ieee80211_vif *vif,
2264 struct ieee80211_sta *sta,
2265 struct ieee80211_key_conf *key)
2266{
2267 struct iwl_priv *priv = hw->priv;
2268 struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
2269 struct iwl_rxon_context *ctx = vif_priv->ctx;
2270 int ret;
2271 bool is_default_wep_key = false;
2272
2273 IWL_DEBUG_MAC80211(priv, "enter\n");
2274
2275 if (iwlagn_mod_params.sw_crypto) {
2276 IWL_DEBUG_MAC80211(priv, "leave - hwcrypto disabled\n");
2277 return -EOPNOTSUPP;
2278 }
2279
2280 /*
2281 * We could program these keys into the hardware as well, but we
2282 * don't expect much multicast traffic in IBSS and having keys
2283 * for more stations is probably more useful.
2284 *
2285 * Mark key TX-only and return 0.
2286 */
2287 if (vif->type == NL80211_IFTYPE_ADHOC &&
2288 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
2289 key->hw_key_idx = WEP_INVALID_OFFSET;
2290 return 0;
2291 }
2292
2293 /* If they key was TX-only, accept deletion */
2294 if (cmd == DISABLE_KEY && key->hw_key_idx == WEP_INVALID_OFFSET)
2295 return 0;
2296
2297 mutex_lock(&priv->shrd->mutex);
2298 iwl_scan_cancel_timeout(priv, 100);
2299
2300 BUILD_BUG_ON(WEP_INVALID_OFFSET == IWLAGN_HW_KEY_DEFAULT);
2301
2302 /*
2303 * If we are getting WEP group key and we didn't receive any key mapping
2304 * so far, we are in legacy wep mode (group key only), otherwise we are
2305 * in 1X mode.
2306 * In legacy wep mode, we use another host command to the uCode.
2307 */
2308 if ((key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
2309 key->cipher == WLAN_CIPHER_SUITE_WEP104) && !sta) {
2310 if (cmd == SET_KEY)
2311 is_default_wep_key = !ctx->key_mapping_keys;
2312 else
2313 is_default_wep_key =
2314 key->hw_key_idx == IWLAGN_HW_KEY_DEFAULT;
2315 }
2316
2317
2318 switch (cmd) {
2319 case SET_KEY:
2320 if (is_default_wep_key) {
2321 ret = iwl_set_default_wep_key(priv, vif_priv->ctx, key);
2322 break;
2323 }
2324 ret = iwl_set_dynamic_key(priv, vif_priv->ctx, key, sta);
2325 if (ret) {
2326 /*
2327 * can't add key for RX, but we don't need it
2328 * in the device for TX so still return 0
2329 */
2330 ret = 0;
2331 key->hw_key_idx = WEP_INVALID_OFFSET;
2332 }
2333
2334 IWL_DEBUG_MAC80211(priv, "enable hwcrypto key\n");
2335 break;
2336 case DISABLE_KEY:
2337 if (is_default_wep_key)
2338 ret = iwl_remove_default_wep_key(priv, ctx, key);
2339 else
2340 ret = iwl_remove_dynamic_key(priv, ctx, key, sta);
2341
2342 IWL_DEBUG_MAC80211(priv, "disable hwcrypto key\n");
2343 break;
2344 default:
2345 ret = -EINVAL;
2346 }
2347
2348 mutex_unlock(&priv->shrd->mutex);
2349 IWL_DEBUG_MAC80211(priv, "leave\n");
2350
2351 return ret;
2352}
2353
2354static int iwlagn_mac_ampdu_action(struct ieee80211_hw *hw,
2355 struct ieee80211_vif *vif,
2356 enum ieee80211_ampdu_mlme_action action,
2357 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
2358 u8 buf_size)
2359{
2360 struct iwl_priv *priv = hw->priv;
2361 int ret = -EINVAL;
2362 struct iwl_station_priv *sta_priv = (void *) sta->drv_priv;
2363 struct iwl_rxon_context *ctx = iwl_rxon_ctx_from_vif(vif);
2364
2365 IWL_DEBUG_HT(priv, "A-MPDU action on addr %pM tid %d\n",
2366 sta->addr, tid);
2367
2368 if (!(priv->cfg->sku & EEPROM_SKU_CAP_11N_ENABLE))
2369 return -EACCES;
2370
2371 IWL_DEBUG_MAC80211(priv, "enter\n");
2372 mutex_lock(&priv->shrd->mutex);
2373
2374 switch (action) {
2375 case IEEE80211_AMPDU_RX_START:
2376 IWL_DEBUG_HT(priv, "start Rx\n");
2377 ret = iwl_sta_rx_agg_start(priv, sta, tid, *ssn);
2378 break;
2379 case IEEE80211_AMPDU_RX_STOP:
2380 IWL_DEBUG_HT(priv, "stop Rx\n");
2381 ret = iwl_sta_rx_agg_stop(priv, sta, tid);
2382 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status))
2383 ret = 0;
2384 break;
2385 case IEEE80211_AMPDU_TX_START:
2386 IWL_DEBUG_HT(priv, "start Tx\n");
2387 ret = iwlagn_tx_agg_start(priv, vif, sta, tid, ssn);
2388 break;
2389 case IEEE80211_AMPDU_TX_STOP:
2390 IWL_DEBUG_HT(priv, "stop Tx\n");
2391 ret = iwlagn_tx_agg_stop(priv, vif, sta, tid);
2392 if ((ret == 0) && (priv->agg_tids_count > 0)) {
2393 priv->agg_tids_count--;
2394 IWL_DEBUG_HT(priv, "priv->agg_tids_count = %u\n",
2395 priv->agg_tids_count);
2396 }
2397 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status))
2398 ret = 0;
2399 if (!priv->agg_tids_count && priv->cfg->ht_params &&
2400 priv->cfg->ht_params->use_rts_for_aggregation) {
2401 /*
2402 * switch off RTS/CTS if it was previously enabled
2403 */
2404 sta_priv->lq_sta.lq.general_params.flags &=
2405 ~LINK_QUAL_FLAGS_SET_STA_TLC_RTS_MSK;
2406 iwl_send_lq_cmd(priv, iwl_rxon_ctx_from_vif(vif),
2407 &sta_priv->lq_sta.lq, CMD_ASYNC, false);
2408 }
2409 break;
2410 case IEEE80211_AMPDU_TX_OPERATIONAL:
2411 buf_size = min_t(int, buf_size, LINK_QUAL_AGG_FRAME_LIMIT_DEF);
2412
2413 iwl_trans_tx_agg_setup(trans(priv), ctx->ctxid, iwl_sta_id(sta),
2414 tid, buf_size);
2415
2416 /*
2417 * If the limit is 0, then it wasn't initialised yet,
2418 * use the default. We can do that since we take the
2419 * minimum below, and we don't want to go above our
2420 * default due to hardware restrictions.
2421 */
2422 if (sta_priv->max_agg_bufsize == 0)
2423 sta_priv->max_agg_bufsize =
2424 LINK_QUAL_AGG_FRAME_LIMIT_DEF;
2425
2426 /*
2427 * Even though in theory the peer could have different
2428 * aggregation reorder buffer sizes for different sessions,
2429 * our ucode doesn't allow for that and has a global limit
2430 * for each station. Therefore, use the minimum of all the
2431 * aggregation sessions and our default value.
2432 */
2433 sta_priv->max_agg_bufsize =
2434 min(sta_priv->max_agg_bufsize, buf_size);
2435
2436 if (priv->cfg->ht_params &&
2437 priv->cfg->ht_params->use_rts_for_aggregation) {
2438 /*
2439 * switch to RTS/CTS if it is the prefer protection
2440 * method for HT traffic
2441 */
2442
2443 sta_priv->lq_sta.lq.general_params.flags |=
2444 LINK_QUAL_FLAGS_SET_STA_TLC_RTS_MSK;
2445 }
2446 priv->agg_tids_count++;
2447 IWL_DEBUG_HT(priv, "priv->agg_tids_count = %u\n",
2448 priv->agg_tids_count);
2449
2450 sta_priv->lq_sta.lq.agg_params.agg_frame_cnt_limit =
2451 sta_priv->max_agg_bufsize;
2452
2453 iwl_send_lq_cmd(priv, iwl_rxon_ctx_from_vif(vif),
2454 &sta_priv->lq_sta.lq, CMD_ASYNC, false);
2455
2456 IWL_INFO(priv, "Tx aggregation enabled on ra = %pM tid = %d\n",
2457 sta->addr, tid);
2458 ret = 0;
2459 break;
2460 }
2461 mutex_unlock(&priv->shrd->mutex);
2462 IWL_DEBUG_MAC80211(priv, "leave\n");
2463 return ret;
2464}
2465
2466static int iwlagn_mac_sta_add(struct ieee80211_hw *hw,
2467 struct ieee80211_vif *vif,
2468 struct ieee80211_sta *sta)
2469{
2470 struct iwl_priv *priv = hw->priv;
2471 struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
2472 struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
2473 bool is_ap = vif->type == NL80211_IFTYPE_STATION;
2474 int ret = 0;
2475 u8 sta_id;
2476
2477 IWL_DEBUG_MAC80211(priv, "received request to add station %pM\n",
2478 sta->addr);
2479 mutex_lock(&priv->shrd->mutex);
2480 IWL_DEBUG_INFO(priv, "proceeding to add station %pM\n",
2481 sta->addr);
2482 sta_priv->sta_id = IWL_INVALID_STATION;
2483
2484 atomic_set(&sta_priv->pending_frames, 0);
2485 if (vif->type == NL80211_IFTYPE_AP)
2486 sta_priv->client = true;
2487
2488 ret = iwl_add_station_common(priv, vif_priv->ctx, sta->addr,
2489 is_ap, sta, &sta_id);
2490 if (ret) {
2491 IWL_ERR(priv, "Unable to add station %pM (%d)\n",
2492 sta->addr, ret);
2493 /* Should we return success if return code is EEXIST ? */
2494 goto out;
2495 }
2496
2497 sta_priv->sta_id = sta_id;
2498 1457
2499 /* Initialize rate scaling */
2500 IWL_DEBUG_INFO(priv, "Initializing rate scaling for station %pM\n",
2501 sta->addr);
2502 iwl_rs_rate_init(priv, sta, sta_id);
2503 out:
2504 mutex_unlock(&priv->shrd->mutex);
2505 IWL_DEBUG_MAC80211(priv, "leave\n");
2506 1458
2507 return ret;
2508}
2509
2510static void iwlagn_mac_channel_switch(struct ieee80211_hw *hw,
2511 struct ieee80211_channel_switch *ch_switch)
2512{
2513 struct iwl_priv *priv = hw->priv;
2514 const struct iwl_channel_info *ch_info;
2515 struct ieee80211_conf *conf = &hw->conf;
2516 struct ieee80211_channel *channel = ch_switch->channel;
2517 struct iwl_ht_config *ht_conf = &priv->current_ht_config;
2518 /*
2519 * MULTI-FIXME
2520 * When we add support for multiple interfaces, we need to
2521 * revisit this. The channel switch command in the device
2522 * only affects the BSS context, but what does that really
2523 * mean? And what if we get a CSA on the second interface?
2524 * This needs a lot of work.
2525 */
2526 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
2527 u16 ch;
2528
2529 IWL_DEBUG_MAC80211(priv, "enter\n");
2530
2531 mutex_lock(&priv->shrd->mutex);
2532
2533 if (iwl_is_rfkill(priv->shrd))
2534 goto out;
2535
2536 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status) ||
2537 test_bit(STATUS_SCANNING, &priv->shrd->status) ||
2538 test_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->shrd->status))
2539 goto out;
2540
2541 if (!iwl_is_associated_ctx(ctx))
2542 goto out;
2543
2544 if (!priv->cfg->lib->set_channel_switch)
2545 goto out;
2546
2547 ch = channel->hw_value;
2548 if (le16_to_cpu(ctx->active.channel) == ch)
2549 goto out;
2550
2551 ch_info = iwl_get_channel_info(priv, channel->band, ch);
2552 if (!is_channel_valid(ch_info)) {
2553 IWL_DEBUG_MAC80211(priv, "invalid channel\n");
2554 goto out;
2555 }
2556
2557 spin_lock_irq(&priv->shrd->lock);
2558
2559 priv->current_ht_config.smps = conf->smps_mode;
2560
2561 /* Configure HT40 channels */
2562 ctx->ht.enabled = conf_is_ht(conf);
2563 if (ctx->ht.enabled) {
2564 if (conf_is_ht40_minus(conf)) {
2565 ctx->ht.extension_chan_offset =
2566 IEEE80211_HT_PARAM_CHA_SEC_BELOW;
2567 ctx->ht.is_40mhz = true;
2568 } else if (conf_is_ht40_plus(conf)) {
2569 ctx->ht.extension_chan_offset =
2570 IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
2571 ctx->ht.is_40mhz = true;
2572 } else {
2573 ctx->ht.extension_chan_offset =
2574 IEEE80211_HT_PARAM_CHA_SEC_NONE;
2575 ctx->ht.is_40mhz = false;
2576 }
2577 } else
2578 ctx->ht.is_40mhz = false;
2579
2580 if ((le16_to_cpu(ctx->staging.channel) != ch))
2581 ctx->staging.flags = 0;
2582
2583 iwl_set_rxon_channel(priv, channel, ctx);
2584 iwl_set_rxon_ht(priv, ht_conf);
2585 iwl_set_flags_for_band(priv, ctx, channel->band, ctx->vif);
2586
2587 spin_unlock_irq(&priv->shrd->lock);
2588
2589 iwl_set_rate(priv);
2590 /*
2591 * at this point, staging_rxon has the
2592 * configuration for channel switch
2593 */
2594 set_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->shrd->status);
2595 priv->switch_channel = cpu_to_le16(ch);
2596 if (priv->cfg->lib->set_channel_switch(priv, ch_switch)) {
2597 clear_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->shrd->status);
2598 priv->switch_channel = 0;
2599 ieee80211_chswitch_done(ctx->vif, false);
2600 }
2601
2602out:
2603 mutex_unlock(&priv->shrd->mutex);
2604 IWL_DEBUG_MAC80211(priv, "leave\n");
2605}
2606
2607static void iwlagn_configure_filter(struct ieee80211_hw *hw,
2608 unsigned int changed_flags,
2609 unsigned int *total_flags,
2610 u64 multicast)
2611{
2612 struct iwl_priv *priv = hw->priv;
2613 __le32 filter_or = 0, filter_nand = 0;
2614 struct iwl_rxon_context *ctx;
2615
2616#define CHK(test, flag) do { \
2617 if (*total_flags & (test)) \
2618 filter_or |= (flag); \
2619 else \
2620 filter_nand |= (flag); \
2621 } while (0)
2622
2623 IWL_DEBUG_MAC80211(priv, "Enter: changed: 0x%x, total: 0x%x\n",
2624 changed_flags, *total_flags);
2625
2626 CHK(FIF_OTHER_BSS | FIF_PROMISC_IN_BSS, RXON_FILTER_PROMISC_MSK);
2627 /* Setting _just_ RXON_FILTER_CTL2HOST_MSK causes FH errors */
2628 CHK(FIF_CONTROL, RXON_FILTER_CTL2HOST_MSK | RXON_FILTER_PROMISC_MSK);
2629 CHK(FIF_BCN_PRBRESP_PROMISC, RXON_FILTER_BCON_AWARE_MSK);
2630
2631#undef CHK
2632
2633 mutex_lock(&priv->shrd->mutex);
2634
2635 for_each_context(priv, ctx) {
2636 ctx->staging.filter_flags &= ~filter_nand;
2637 ctx->staging.filter_flags |= filter_or;
2638
2639 /*
2640 * Not committing directly because hardware can perform a scan,
2641 * but we'll eventually commit the filter flags change anyway.
2642 */
2643 }
2644
2645 mutex_unlock(&priv->shrd->mutex);
2646
2647 /*
2648 * Receiving all multicast frames is always enabled by the
2649 * default flags setup in iwl_connection_init_rx_config()
2650 * since we currently do not support programming multicast
2651 * filters into the device.
2652 */
2653 *total_flags &= FIF_OTHER_BSS | FIF_ALLMULTI | FIF_PROMISC_IN_BSS |
2654 FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
2655}
2656
2657static void iwlagn_mac_flush(struct ieee80211_hw *hw, bool drop)
2658{
2659 struct iwl_priv *priv = hw->priv;
2660
2661 mutex_lock(&priv->shrd->mutex);
2662 IWL_DEBUG_MAC80211(priv, "enter\n");
2663
2664 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status)) {
2665 IWL_DEBUG_TX(priv, "Aborting flush due to device shutdown\n");
2666 goto done;
2667 }
2668 if (iwl_is_rfkill(priv->shrd)) {
2669 IWL_DEBUG_TX(priv, "Aborting flush due to RF Kill\n");
2670 goto done;
2671 }
2672
2673 /*
2674 * mac80211 will not push any more frames for transmit
2675 * until the flush is completed
2676 */
2677 if (drop) {
2678 IWL_DEBUG_MAC80211(priv, "send flush command\n");
2679 if (iwlagn_txfifo_flush(priv, IWL_DROP_ALL)) {
2680 IWL_ERR(priv, "flush request fail\n");
2681 goto done;
2682 }
2683 }
2684 IWL_DEBUG_MAC80211(priv, "wait transmit/flush all frames\n");
2685 iwl_trans_wait_tx_queue_empty(trans(priv));
2686done:
2687 mutex_unlock(&priv->shrd->mutex);
2688 IWL_DEBUG_MAC80211(priv, "leave\n");
2689}
2690 1459
2691void iwlagn_disable_roc(struct iwl_priv *priv) 1460void iwlagn_disable_roc(struct iwl_priv *priv)
2692{ 1461{
@@ -2720,160 +1489,6 @@ static void iwlagn_disable_roc_work(struct work_struct *work)
2720 mutex_unlock(&priv->shrd->mutex); 1489 mutex_unlock(&priv->shrd->mutex);
2721} 1490}
2722 1491
2723static int iwlagn_mac_remain_on_channel(struct ieee80211_hw *hw,
2724 struct ieee80211_channel *channel,
2725 enum nl80211_channel_type channel_type,
2726 int duration)
2727{
2728 struct iwl_priv *priv = hw->priv;
2729 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_PAN];
2730 int err = 0;
2731
2732 if (!(priv->shrd->valid_contexts & BIT(IWL_RXON_CTX_PAN)))
2733 return -EOPNOTSUPP;
2734
2735 if (!(ctx->interface_modes & BIT(NL80211_IFTYPE_P2P_CLIENT)))
2736 return -EOPNOTSUPP;
2737
2738 IWL_DEBUG_MAC80211(priv, "enter\n");
2739 mutex_lock(&priv->shrd->mutex);
2740
2741 if (test_bit(STATUS_SCAN_HW, &priv->shrd->status)) {
2742 err = -EBUSY;
2743 goto out;
2744 }
2745
2746 priv->hw_roc_channel = channel;
2747 priv->hw_roc_chantype = channel_type;
2748 priv->hw_roc_duration = duration;
2749 priv->hw_roc_start_notified = false;
2750 cancel_delayed_work(&priv->hw_roc_disable_work);
2751
2752 if (!ctx->is_active) {
2753 ctx->is_active = true;
2754 ctx->staging.dev_type = RXON_DEV_TYPE_P2P;
2755 memcpy(ctx->staging.node_addr,
2756 priv->contexts[IWL_RXON_CTX_BSS].staging.node_addr,
2757 ETH_ALEN);
2758 memcpy(ctx->staging.bssid_addr,
2759 priv->contexts[IWL_RXON_CTX_BSS].staging.node_addr,
2760 ETH_ALEN);
2761 err = iwlagn_commit_rxon(priv, ctx);
2762 if (err)
2763 goto out;
2764 ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK |
2765 RXON_FILTER_PROMISC_MSK |
2766 RXON_FILTER_CTL2HOST_MSK;
2767
2768 err = iwlagn_commit_rxon(priv, ctx);
2769 if (err) {
2770 iwlagn_disable_roc(priv);
2771 goto out;
2772 }
2773 priv->hw_roc_setup = true;
2774 }
2775
2776 err = iwl_scan_initiate(priv, ctx->vif, IWL_SCAN_ROC, channel->band);
2777 if (err)
2778 iwlagn_disable_roc(priv);
2779
2780 out:
2781 mutex_unlock(&priv->shrd->mutex);
2782 IWL_DEBUG_MAC80211(priv, "leave\n");
2783
2784 return err;
2785}
2786
2787static int iwlagn_mac_cancel_remain_on_channel(struct ieee80211_hw *hw)
2788{
2789 struct iwl_priv *priv = hw->priv;
2790
2791 if (!(priv->shrd->valid_contexts & BIT(IWL_RXON_CTX_PAN)))
2792 return -EOPNOTSUPP;
2793
2794 IWL_DEBUG_MAC80211(priv, "enter\n");
2795 mutex_lock(&priv->shrd->mutex);
2796 iwl_scan_cancel_timeout(priv, priv->hw_roc_duration);
2797 iwlagn_disable_roc(priv);
2798 mutex_unlock(&priv->shrd->mutex);
2799 IWL_DEBUG_MAC80211(priv, "leave\n");
2800
2801 return 0;
2802}
2803
2804static int iwlagn_mac_tx_sync(struct ieee80211_hw *hw,
2805 struct ieee80211_vif *vif,
2806 const u8 *bssid,
2807 enum ieee80211_tx_sync_type type)
2808{
2809 struct iwl_priv *priv = hw->priv;
2810 struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
2811 struct iwl_rxon_context *ctx = vif_priv->ctx;
2812 int ret;
2813 u8 sta_id;
2814
2815 IWL_DEBUG_MAC80211(priv, "enter\n");
2816 mutex_lock(&priv->shrd->mutex);
2817
2818 if (iwl_is_associated_ctx(ctx)) {
2819 ret = 0;
2820 goto out;
2821 }
2822
2823 if (ctx->preauth_bssid || test_bit(STATUS_SCAN_HW, &priv->shrd->status)) {
2824 ret = -EBUSY;
2825 goto out;
2826 }
2827
2828 ret = iwl_add_station_common(priv, ctx, bssid, true, NULL, &sta_id);
2829 if (ret)
2830 goto out;
2831
2832 if (WARN_ON(sta_id != ctx->ap_sta_id)) {
2833 ret = -EIO;
2834 goto out_remove_sta;
2835 }
2836
2837 memcpy(ctx->bssid, bssid, ETH_ALEN);
2838 ctx->preauth_bssid = true;
2839
2840 ret = iwlagn_commit_rxon(priv, ctx);
2841
2842 if (ret == 0)
2843 goto out;
2844
2845 out_remove_sta:
2846 iwl_remove_station(priv, sta_id, bssid);
2847 out:
2848 mutex_unlock(&priv->shrd->mutex);
2849 IWL_DEBUG_MAC80211(priv, "leave\n");
2850
2851 return ret;
2852}
2853
2854static void iwlagn_mac_finish_tx_sync(struct ieee80211_hw *hw,
2855 struct ieee80211_vif *vif,
2856 const u8 *bssid,
2857 enum ieee80211_tx_sync_type type)
2858{
2859 struct iwl_priv *priv = hw->priv;
2860 struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
2861 struct iwl_rxon_context *ctx = vif_priv->ctx;
2862
2863 IWL_DEBUG_MAC80211(priv, "enter\n");
2864 mutex_lock(&priv->shrd->mutex);
2865
2866 if (iwl_is_associated_ctx(ctx))
2867 goto out;
2868
2869 iwl_remove_station(priv, ctx->ap_sta_id, bssid);
2870 ctx->preauth_bssid = false;
2871 /* no need to commit */
2872 out:
2873 mutex_unlock(&priv->shrd->mutex);
2874 IWL_DEBUG_MAC80211(priv, "leave\n");
2875}
2876
2877/***************************************************************************** 1492/*****************************************************************************
2878 * 1493 *
2879 * driver setup and teardown 1494 * driver setup and teardown
@@ -3029,76 +1644,7 @@ static void iwl_uninit_drv(struct iwl_priv *priv)
3029#endif 1644#endif
3030} 1645}
3031 1646
3032static void iwlagn_mac_rssi_callback(struct ieee80211_hw *hw,
3033 enum ieee80211_rssi_event rssi_event)
3034{
3035 struct iwl_priv *priv = hw->priv;
3036
3037 IWL_DEBUG_MAC80211(priv, "enter\n");
3038 mutex_lock(&priv->shrd->mutex);
3039
3040 if (priv->cfg->bt_params &&
3041 priv->cfg->bt_params->advanced_bt_coexist) {
3042 if (rssi_event == RSSI_EVENT_LOW)
3043 priv->bt_enable_pspoll = true;
3044 else if (rssi_event == RSSI_EVENT_HIGH)
3045 priv->bt_enable_pspoll = false;
3046
3047 iwlagn_send_advance_bt_config(priv);
3048 } else {
3049 IWL_DEBUG_MAC80211(priv, "Advanced BT coex disabled,"
3050 "ignoring RSSI callback\n");
3051 }
3052 1647
3053 mutex_unlock(&priv->shrd->mutex);
3054 IWL_DEBUG_MAC80211(priv, "leave\n");
3055}
3056
3057static int iwlagn_mac_set_tim(struct ieee80211_hw *hw,
3058 struct ieee80211_sta *sta, bool set)
3059{
3060 struct iwl_priv *priv = hw->priv;
3061
3062 queue_work(priv->shrd->workqueue, &priv->beacon_update);
3063
3064 return 0;
3065}
3066
3067struct ieee80211_ops iwlagn_hw_ops = {
3068 .tx = iwlagn_mac_tx,
3069 .start = iwlagn_mac_start,
3070 .stop = iwlagn_mac_stop,
3071#ifdef CONFIG_PM_SLEEP
3072 .suspend = iwlagn_mac_suspend,
3073 .resume = iwlagn_mac_resume,
3074#endif
3075 .add_interface = iwlagn_mac_add_interface,
3076 .remove_interface = iwlagn_mac_remove_interface,
3077 .change_interface = iwlagn_mac_change_interface,
3078 .config = iwlagn_mac_config,
3079 .configure_filter = iwlagn_configure_filter,
3080 .set_key = iwlagn_mac_set_key,
3081 .update_tkip_key = iwlagn_mac_update_tkip_key,
3082 .set_rekey_data = iwlagn_mac_set_rekey_data,
3083 .conf_tx = iwlagn_mac_conf_tx,
3084 .bss_info_changed = iwlagn_bss_info_changed,
3085 .ampdu_action = iwlagn_mac_ampdu_action,
3086 .hw_scan = iwlagn_mac_hw_scan,
3087 .sta_notify = iwlagn_mac_sta_notify,
3088 .sta_add = iwlagn_mac_sta_add,
3089 .sta_remove = iwlagn_mac_sta_remove,
3090 .channel_switch = iwlagn_mac_channel_switch,
3091 .flush = iwlagn_mac_flush,
3092 .tx_last_beacon = iwlagn_mac_tx_last_beacon,
3093 .remain_on_channel = iwlagn_mac_remain_on_channel,
3094 .cancel_remain_on_channel = iwlagn_mac_cancel_remain_on_channel,
3095 .rssi_callback = iwlagn_mac_rssi_callback,
3096 CFG80211_TESTMODE_CMD(iwlagn_mac_testmode_cmd)
3097 CFG80211_TESTMODE_DUMP(iwlagn_mac_testmode_dump)
3098 .tx_sync = iwlagn_mac_tx_sync,
3099 .finish_tx_sync = iwlagn_mac_finish_tx_sync,
3100 .set_tim = iwlagn_mac_set_tim,
3101};
3102 1648
3103static u32 iwl_hw_detect(struct iwl_priv *priv) 1649static u32 iwl_hw_detect(struct iwl_priv *priv)
3104{ 1650{
@@ -3132,24 +1678,7 @@ static int iwl_set_hw_params(struct iwl_priv *priv)
3132 return priv->cfg->lib->set_hw_params(priv); 1678 return priv->cfg->lib->set_hw_params(priv);
3133} 1679}
3134 1680
3135/* This function both allocates and initializes hw and priv. */
3136static struct ieee80211_hw *iwl_alloc_all(void)
3137{
3138 struct iwl_priv *priv;
3139 /* mac80211 allocates memory for this device instance, including
3140 * space for this driver's private structure */
3141 struct ieee80211_hw *hw;
3142
3143 hw = ieee80211_alloc_hw(sizeof(struct iwl_priv), &iwlagn_hw_ops);
3144 if (!hw)
3145 goto out;
3146 1681
3147 priv = hw->priv;
3148 priv->hw = hw;
3149
3150out:
3151 return hw;
3152}
3153 1682
3154int iwl_probe(struct iwl_bus *bus, const struct iwl_trans_ops *trans_ops, 1683int iwl_probe(struct iwl_bus *bus, const struct iwl_trans_ops *trans_ops,
3155 struct iwl_cfg *cfg) 1684 struct iwl_cfg *cfg)
generated by cgit v1.2.2 (git 2.25.0) at 2024-09-21 19:22:28 -0400