Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 1 | /* |
| 2 | * This file is part of wl1271 |
| 3 | * |
| 4 | * Copyright (C) 2009 Nokia Corporation |
| 5 | * |
| 6 | * Contact: Luciano Coelho <luciano.coelho@nokia.com> |
| 7 | * |
| 8 | * This program is free software; you can redistribute it and/or |
| 9 | * modify it under the terms of the GNU General Public License |
| 10 | * version 2 as published by the Free Software Foundation. |
| 11 | * |
| 12 | * This program is distributed in the hope that it will be useful, but |
| 13 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 15 | * General Public License for more details. |
| 16 | * |
| 17 | * You should have received a copy of the GNU General Public License |
| 18 | * along with this program; if not, write to the Free Software |
| 19 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA |
| 20 | * 02110-1301 USA |
| 21 | * |
| 22 | */ |
| 23 | |
| 24 | #include <linux/kernel.h> |
| 25 | #include <linux/module.h> |
Arik Nemtsov | c6c8a65 | 2010-10-16 20:27:53 +0200 | [diff] [blame] | 26 | #include <linux/etherdevice.h> |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 27 | |
Shahar Levi | 00d2010 | 2010-11-08 11:20:10 +0000 | [diff] [blame] | 28 | #include "wl12xx.h" |
Luciano Coelho | 0f4e312 | 2011-10-07 11:02:42 +0300 | [diff] [blame] | 29 | #include "debug.h" |
Shahar Levi | 00d2010 | 2010-11-08 11:20:10 +0000 | [diff] [blame] | 30 | #include "io.h" |
| 31 | #include "reg.h" |
| 32 | #include "ps.h" |
| 33 | #include "tx.h" |
Arik Nemtsov | 56d4f8f | 2011-08-25 12:43:13 +0300 | [diff] [blame] | 34 | #include "event.h" |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 35 | |
Eliad Peller | 536129c | 2011-10-05 11:55:45 +0200 | [diff] [blame] | 36 | static int wl1271_set_default_wep_key(struct wl1271 *wl, |
| 37 | struct wl12xx_vif *wlvif, u8 id) |
Arik Nemtsov | 7f179b4 | 2010-10-16 21:39:06 +0200 | [diff] [blame] | 38 | { |
| 39 | int ret; |
Eliad Peller | 536129c | 2011-10-05 11:55:45 +0200 | [diff] [blame] | 40 | bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS); |
Arik Nemtsov | 7f179b4 | 2010-10-16 21:39:06 +0200 | [diff] [blame] | 41 | |
| 42 | if (is_ap) |
Eliad Peller | c690ec8 | 2011-08-14 13:17:07 +0300 | [diff] [blame] | 43 | ret = wl12xx_cmd_set_default_wep_key(wl, id, |
Eliad Peller | a8ab39a | 2011-10-05 11:55:54 +0200 | [diff] [blame] | 44 | wlvif->ap.bcast_hlid); |
Arik Nemtsov | 7f179b4 | 2010-10-16 21:39:06 +0200 | [diff] [blame] | 45 | else |
Eliad Peller | 154da67 | 2011-10-05 11:55:53 +0200 | [diff] [blame] | 46 | ret = wl12xx_cmd_set_default_wep_key(wl, id, wlvif->sta.hlid); |
Arik Nemtsov | 7f179b4 | 2010-10-16 21:39:06 +0200 | [diff] [blame] | 47 | |
| 48 | if (ret < 0) |
| 49 | return ret; |
| 50 | |
| 51 | wl1271_debug(DEBUG_CRYPT, "default wep key idx: %d", (int)id); |
| 52 | return 0; |
| 53 | } |
| 54 | |
Ido Yariv | 25eeb9e | 2010-10-12 16:20:06 +0200 | [diff] [blame] | 55 | static int wl1271_alloc_tx_id(struct wl1271 *wl, struct sk_buff *skb) |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 56 | { |
Ido Yariv | 25eeb9e | 2010-10-12 16:20:06 +0200 | [diff] [blame] | 57 | int id; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 58 | |
Ido Yariv | 25eeb9e | 2010-10-12 16:20:06 +0200 | [diff] [blame] | 59 | id = find_first_zero_bit(wl->tx_frames_map, ACX_TX_DESCRIPTORS); |
| 60 | if (id >= ACX_TX_DESCRIPTORS) |
| 61 | return -EBUSY; |
| 62 | |
| 63 | __set_bit(id, wl->tx_frames_map); |
| 64 | wl->tx_frames[id] = skb; |
| 65 | wl->tx_frames_cnt++; |
| 66 | return id; |
| 67 | } |
| 68 | |
| 69 | static void wl1271_free_tx_id(struct wl1271 *wl, int id) |
| 70 | { |
| 71 | if (__test_and_clear_bit(id, wl->tx_frames_map)) { |
Ido Yariv | ef2e300 | 2011-04-18 16:44:11 +0300 | [diff] [blame] | 72 | if (unlikely(wl->tx_frames_cnt == ACX_TX_DESCRIPTORS)) |
| 73 | clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags); |
| 74 | |
Ido Yariv | 25eeb9e | 2010-10-12 16:20:06 +0200 | [diff] [blame] | 75 | wl->tx_frames[id] = NULL; |
| 76 | wl->tx_frames_cnt--; |
| 77 | } |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 78 | } |
| 79 | |
Ohad Ben-Cohen | c574518 | 2011-03-30 16:35:59 +0200 | [diff] [blame] | 80 | static int wl1271_tx_update_filters(struct wl1271 *wl, |
Eliad Peller | 7edebf5 | 2011-10-05 11:55:52 +0200 | [diff] [blame] | 81 | struct wl12xx_vif *wlvif, |
| 82 | struct sk_buff *skb) |
Ohad Ben-Cohen | c574518 | 2011-03-30 16:35:59 +0200 | [diff] [blame] | 83 | { |
| 84 | struct ieee80211_hdr *hdr; |
Eliad Peller | 251c177 | 2011-08-14 13:17:17 +0300 | [diff] [blame] | 85 | int ret; |
Ohad Ben-Cohen | c574518 | 2011-03-30 16:35:59 +0200 | [diff] [blame] | 86 | |
Eliad Peller | df4c849 | 2011-09-15 16:05:47 +0300 | [diff] [blame] | 87 | hdr = (struct ieee80211_hdr *)skb->data; |
Ohad Ben-Cohen | c574518 | 2011-03-30 16:35:59 +0200 | [diff] [blame] | 88 | |
| 89 | /* |
| 90 | * stop bssid-based filtering before transmitting authentication |
| 91 | * requests. this way the hw will never drop authentication |
| 92 | * responses coming from BSSIDs it isn't familiar with (e.g. on |
| 93 | * roaming) |
| 94 | */ |
| 95 | if (!ieee80211_is_auth(hdr->frame_control)) |
| 96 | return 0; |
| 97 | |
Eliad Peller | afaf8bd | 2011-10-05 11:55:57 +0200 | [diff] [blame] | 98 | if (wlvif->dev_hlid != WL12XX_INVALID_LINK_ID) |
Eliad Peller | 251c177 | 2011-08-14 13:17:17 +0300 | [diff] [blame] | 99 | goto out; |
| 100 | |
| 101 | wl1271_debug(DEBUG_CMD, "starting device role for roaming"); |
Eliad Peller | 679a673 | 2011-10-11 11:55:44 +0200 | [diff] [blame] | 102 | ret = wl12xx_start_dev(wl, wlvif); |
Eliad Peller | 251c177 | 2011-08-14 13:17:17 +0300 | [diff] [blame] | 103 | if (ret < 0) |
| 104 | goto out; |
| 105 | out: |
Eliad Peller | 08c1d1c | 2011-08-14 13:17:04 +0300 | [diff] [blame] | 106 | return 0; |
Ohad Ben-Cohen | c574518 | 2011-03-30 16:35:59 +0200 | [diff] [blame] | 107 | } |
| 108 | |
Arik Nemtsov | 99a2775 | 2011-02-23 00:22:25 +0200 | [diff] [blame] | 109 | static void wl1271_tx_ap_update_inconnection_sta(struct wl1271 *wl, |
| 110 | struct sk_buff *skb) |
| 111 | { |
| 112 | struct ieee80211_hdr *hdr; |
| 113 | |
| 114 | /* |
| 115 | * add the station to the known list before transmitting the |
| 116 | * authentication response. this way it won't get de-authed by FW |
| 117 | * when transmitting too soon. |
| 118 | */ |
| 119 | hdr = (struct ieee80211_hdr *)(skb->data + |
| 120 | sizeof(struct wl1271_tx_hw_descr)); |
| 121 | if (ieee80211_is_auth(hdr->frame_control)) |
| 122 | wl1271_acx_set_inconnection_sta(wl, hdr->addr1); |
| 123 | } |
| 124 | |
Eliad Peller | c7ffb90 | 2011-10-05 11:56:05 +0200 | [diff] [blame] | 125 | static void wl1271_tx_regulate_link(struct wl1271 *wl, |
| 126 | struct wl12xx_vif *wlvif, |
| 127 | u8 hlid) |
Arik Nemtsov | b622d99 | 2011-02-23 00:22:31 +0200 | [diff] [blame] | 128 | { |
Arik Nemtsov | da03209 | 2011-08-25 12:43:15 +0300 | [diff] [blame] | 129 | bool fw_ps, single_sta; |
Arik Nemtsov | 9b17f1b | 2011-08-14 13:17:35 +0300 | [diff] [blame] | 130 | u8 tx_pkts; |
Arik Nemtsov | b622d99 | 2011-02-23 00:22:31 +0200 | [diff] [blame] | 131 | |
Eliad Peller | c7ffb90 | 2011-10-05 11:56:05 +0200 | [diff] [blame] | 132 | if (WARN_ON(!test_bit(hlid, wlvif->links_map))) |
Arik Nemtsov | b622d99 | 2011-02-23 00:22:31 +0200 | [diff] [blame] | 133 | return; |
| 134 | |
| 135 | fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map); |
Arik Nemtsov | 9b17f1b | 2011-08-14 13:17:35 +0300 | [diff] [blame] | 136 | tx_pkts = wl->links[hlid].allocated_pkts; |
Arik Nemtsov | da03209 | 2011-08-25 12:43:15 +0300 | [diff] [blame] | 137 | single_sta = (wl->active_sta_count == 1); |
Arik Nemtsov | b622d99 | 2011-02-23 00:22:31 +0200 | [diff] [blame] | 138 | |
| 139 | /* |
| 140 | * if in FW PS and there is enough data in FW we can put the link |
| 141 | * into high-level PS and clean out its TX queues. |
Arik Nemtsov | da03209 | 2011-08-25 12:43:15 +0300 | [diff] [blame] | 142 | * Make an exception if this is the only connected station. In this |
| 143 | * case FW-memory congestion is not a problem. |
Arik Nemtsov | b622d99 | 2011-02-23 00:22:31 +0200 | [diff] [blame] | 144 | */ |
Arik Nemtsov | da03209 | 2011-08-25 12:43:15 +0300 | [diff] [blame] | 145 | if (!single_sta && fw_ps && tx_pkts >= WL1271_PS_STA_MAX_PACKETS) |
Eliad Peller | 6e8cd33 | 2011-10-10 10:13:13 +0200 | [diff] [blame] | 146 | wl12xx_ps_link_start(wl, wlvif, hlid, true); |
Arik Nemtsov | b622d99 | 2011-02-23 00:22:31 +0200 | [diff] [blame] | 147 | } |
| 148 | |
Arik Nemtsov | f8e0af6 | 2011-08-25 12:43:12 +0300 | [diff] [blame] | 149 | bool wl12xx_is_dummy_packet(struct wl1271 *wl, struct sk_buff *skb) |
Eliad Peller | f4df1bd | 2011-08-14 13:17:15 +0300 | [diff] [blame] | 150 | { |
| 151 | return wl->dummy_packet == skb; |
| 152 | } |
| 153 | |
Eliad Peller | a8ab39a | 2011-10-05 11:55:54 +0200 | [diff] [blame] | 154 | u8 wl12xx_tx_get_hlid_ap(struct wl1271 *wl, struct wl12xx_vif *wlvif, |
| 155 | struct sk_buff *skb) |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 156 | { |
| 157 | struct ieee80211_tx_info *control = IEEE80211_SKB_CB(skb); |
| 158 | |
| 159 | if (control->control.sta) { |
| 160 | struct wl1271_station *wl_sta; |
| 161 | |
| 162 | wl_sta = (struct wl1271_station *) |
| 163 | control->control.sta->drv_priv; |
| 164 | return wl_sta->hlid; |
| 165 | } else { |
| 166 | struct ieee80211_hdr *hdr; |
| 167 | |
Eliad Peller | 53d40d0 | 2011-10-10 10:13:02 +0200 | [diff] [blame] | 168 | if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) |
Eliad Peller | f4df1bd | 2011-08-14 13:17:15 +0300 | [diff] [blame] | 169 | return wl->system_hlid; |
| 170 | |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 171 | hdr = (struct ieee80211_hdr *)skb->data; |
| 172 | if (ieee80211_is_mgmt(hdr->frame_control)) |
Eliad Peller | a8ab39a | 2011-10-05 11:55:54 +0200 | [diff] [blame] | 173 | return wlvif->ap.global_hlid; |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 174 | else |
Eliad Peller | a8ab39a | 2011-10-05 11:55:54 +0200 | [diff] [blame] | 175 | return wlvif->ap.bcast_hlid; |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 176 | } |
| 177 | } |
| 178 | |
Eliad Peller | d6a3cc2 | 2011-10-10 10:12:51 +0200 | [diff] [blame] | 179 | u8 wl12xx_tx_get_hlid(struct wl1271 *wl, struct wl12xx_vif *wlvif, |
| 180 | struct sk_buff *skb) |
Eliad Peller | f4df1bd | 2011-08-14 13:17:15 +0300 | [diff] [blame] | 181 | { |
Eliad Peller | df4c849 | 2011-09-15 16:05:47 +0300 | [diff] [blame] | 182 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; |
| 183 | |
Eliad Peller | 0f16801 | 2011-10-11 13:52:25 +0200 | [diff] [blame] | 184 | if (!wlvif || wl12xx_is_dummy_packet(wl, skb)) |
Eliad Peller | f4df1bd | 2011-08-14 13:17:15 +0300 | [diff] [blame] | 185 | return wl->system_hlid; |
| 186 | |
Eliad Peller | 536129c | 2011-10-05 11:55:45 +0200 | [diff] [blame] | 187 | if (wlvif->bss_type == BSS_TYPE_AP_BSS) |
Eliad Peller | a8ab39a | 2011-10-05 11:55:54 +0200 | [diff] [blame] | 188 | return wl12xx_tx_get_hlid_ap(wl, wlvif, skb); |
Eliad Peller | f4df1bd | 2011-08-14 13:17:15 +0300 | [diff] [blame] | 189 | |
Eliad Peller | 7edebf5 | 2011-10-05 11:55:52 +0200 | [diff] [blame] | 190 | wl1271_tx_update_filters(wl, wlvif, skb); |
Eliad Peller | df4c849 | 2011-09-15 16:05:47 +0300 | [diff] [blame] | 191 | |
Eliad Peller | ba8447f | 2011-10-10 10:13:00 +0200 | [diff] [blame] | 192 | if ((test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) || |
Eliad Peller | eee514e | 2011-10-10 10:13:01 +0200 | [diff] [blame] | 193 | test_bit(WLVIF_FLAG_IBSS_JOINED, &wlvif->flags)) && |
Eliad Peller | df4c849 | 2011-09-15 16:05:47 +0300 | [diff] [blame] | 194 | !ieee80211_is_auth(hdr->frame_control) && |
| 195 | !ieee80211_is_assoc_req(hdr->frame_control)) |
Eliad Peller | 154da67 | 2011-10-05 11:55:53 +0200 | [diff] [blame] | 196 | return wlvif->sta.hlid; |
Eliad Peller | f4df1bd | 2011-08-14 13:17:15 +0300 | [diff] [blame] | 197 | else |
Eliad Peller | afaf8bd | 2011-10-05 11:55:57 +0200 | [diff] [blame] | 198 | return wlvif->dev_hlid; |
Eliad Peller | f4df1bd | 2011-08-14 13:17:15 +0300 | [diff] [blame] | 199 | } |
| 200 | |
Ido Yariv | 0da13da | 2011-03-31 10:06:58 +0200 | [diff] [blame] | 201 | static unsigned int wl12xx_calc_packet_alignment(struct wl1271 *wl, |
| 202 | unsigned int packet_length) |
| 203 | { |
Luciano Coelho | ce39def | 2011-11-03 08:44:41 +0200 | [diff] [blame] | 204 | if (wl->quirks & WL12XX_QUIRK_NO_BLOCKSIZE_ALIGNMENT) |
Ido Yariv | 0da13da | 2011-03-31 10:06:58 +0200 | [diff] [blame] | 205 | return ALIGN(packet_length, WL1271_TX_ALIGN_TO); |
Luciano Coelho | ce39def | 2011-11-03 08:44:41 +0200 | [diff] [blame] | 206 | else |
| 207 | return ALIGN(packet_length, WL12XX_BUS_BLOCK_SIZE); |
Ido Yariv | 0da13da | 2011-03-31 10:06:58 +0200 | [diff] [blame] | 208 | } |
| 209 | |
Eliad Peller | a32d0cd | 2011-10-10 10:12:55 +0200 | [diff] [blame] | 210 | static int wl1271_tx_allocate(struct wl1271 *wl, struct wl12xx_vif *wlvif, |
Eliad Peller | 536129c | 2011-10-05 11:55:45 +0200 | [diff] [blame] | 211 | struct sk_buff *skb, u32 extra, u32 buf_offset, |
| 212 | u8 hlid) |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 213 | { |
| 214 | struct wl1271_tx_hw_descr *desc; |
| 215 | u32 total_len = skb->len + sizeof(struct wl1271_tx_hw_descr) + extra; |
Shahar Levi | 48a6147 | 2011-03-06 16:32:08 +0200 | [diff] [blame] | 216 | u32 len; |
Juuso Oikarinen | 5c9417f | 2010-02-22 08:38:39 +0200 | [diff] [blame] | 217 | u32 total_blocks; |
Arik Nemtsov | 742246f | 2011-08-14 13:17:33 +0300 | [diff] [blame] | 218 | int id, ret = -EBUSY, ac; |
Guy Eilam | e9eb8cb | 2011-08-16 19:49:12 +0300 | [diff] [blame] | 219 | u32 spare_blocks = wl->tx_spare_blocks; |
Eliad Peller | a32d0cd | 2011-10-10 10:12:55 +0200 | [diff] [blame] | 220 | bool is_dummy = false; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 221 | |
Ido Yariv | a19606b | 2010-09-30 13:28:28 +0200 | [diff] [blame] | 222 | if (buf_offset + total_len > WL1271_AGGR_BUFFER_SIZE) |
Ido Yariv | 6c6e669 | 2010-10-12 14:49:09 +0200 | [diff] [blame] | 223 | return -EAGAIN; |
Ido Yariv | a19606b | 2010-09-30 13:28:28 +0200 | [diff] [blame] | 224 | |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 225 | /* allocate free identifier for the packet */ |
Ido Yariv | 25eeb9e | 2010-10-12 16:20:06 +0200 | [diff] [blame] | 226 | id = wl1271_alloc_tx_id(wl, skb); |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 227 | if (id < 0) |
| 228 | return id; |
| 229 | |
| 230 | /* approximate the number of blocks required for this packet |
| 231 | in the firmware */ |
Ido Yariv | 0da13da | 2011-03-31 10:06:58 +0200 | [diff] [blame] | 232 | len = wl12xx_calc_packet_alignment(wl, total_len); |
Shahar Levi | 48a6147 | 2011-03-06 16:32:08 +0200 | [diff] [blame] | 233 | |
Guy Eilam | e9eb8cb | 2011-08-16 19:49:12 +0300 | [diff] [blame] | 234 | /* in case of a dummy packet, use default amount of spare mem blocks */ |
Eliad Peller | a32d0cd | 2011-10-10 10:12:55 +0200 | [diff] [blame] | 235 | if (unlikely(wl12xx_is_dummy_packet(wl, skb))) { |
| 236 | is_dummy = true; |
Guy Eilam | e9eb8cb | 2011-08-16 19:49:12 +0300 | [diff] [blame] | 237 | spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT; |
Eliad Peller | a32d0cd | 2011-10-10 10:12:55 +0200 | [diff] [blame] | 238 | } |
Guy Eilam | e9eb8cb | 2011-08-16 19:49:12 +0300 | [diff] [blame] | 239 | |
Shahar Levi | 48a6147 | 2011-03-06 16:32:08 +0200 | [diff] [blame] | 240 | total_blocks = (len + TX_HW_BLOCK_SIZE - 1) / TX_HW_BLOCK_SIZE + |
Luciano Coelho | e7ddf54 | 2011-03-10 15:24:57 +0200 | [diff] [blame] | 241 | spare_blocks; |
Shahar Levi | 48a6147 | 2011-03-06 16:32:08 +0200 | [diff] [blame] | 242 | |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 243 | if (total_blocks <= wl->tx_blocks_available) { |
| 244 | desc = (struct wl1271_tx_hw_descr *)skb_push( |
| 245 | skb, total_len - skb->len); |
| 246 | |
Shahar Levi | ae77ecc | 2011-03-06 16:32:13 +0200 | [diff] [blame] | 247 | /* HW descriptor fields change between wl127x and wl128x */ |
| 248 | if (wl->chip.id == CHIP_ID_1283_PG20) { |
| 249 | desc->wl128x_mem.total_mem_blocks = total_blocks; |
| 250 | } else { |
Luciano Coelho | e7ddf54 | 2011-03-10 15:24:57 +0200 | [diff] [blame] | 251 | desc->wl127x_mem.extra_blocks = spare_blocks; |
Shahar Levi | ae77ecc | 2011-03-06 16:32:13 +0200 | [diff] [blame] | 252 | desc->wl127x_mem.total_mem_blocks = total_blocks; |
| 253 | } |
| 254 | |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 255 | desc->id = id; |
| 256 | |
| 257 | wl->tx_blocks_available -= total_blocks; |
Arik Nemtsov | 7bb5d6c | 2011-08-14 13:17:00 +0300 | [diff] [blame] | 258 | wl->tx_allocated_blocks += total_blocks; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 259 | |
Arik Nemtsov | 742246f | 2011-08-14 13:17:33 +0300 | [diff] [blame] | 260 | ac = wl1271_tx_get_queue(skb_get_queue_mapping(skb)); |
| 261 | wl->tx_allocated_pkts[ac]++; |
Arik Nemtsov | bf54e30 | 2011-08-14 13:17:32 +0300 | [diff] [blame] | 262 | |
Eliad Peller | 0f16801 | 2011-10-11 13:52:25 +0200 | [diff] [blame] | 263 | if (!is_dummy && wlvif && |
| 264 | wlvif->bss_type == BSS_TYPE_AP_BSS && |
Eliad Peller | c7ffb90 | 2011-10-05 11:56:05 +0200 | [diff] [blame] | 265 | test_bit(hlid, wlvif->ap.sta_hlid_map)) |
Arik Nemtsov | 9b17f1b | 2011-08-14 13:17:35 +0300 | [diff] [blame] | 266 | wl->links[hlid].allocated_pkts++; |
Arik Nemtsov | 09039f4 | 2011-02-23 00:22:30 +0200 | [diff] [blame] | 267 | |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 268 | ret = 0; |
| 269 | |
| 270 | wl1271_debug(DEBUG_TX, |
| 271 | "tx_allocate: size: %d, blocks: %d, id: %d", |
| 272 | total_len, total_blocks, id); |
Juuso Oikarinen | 781608c | 2010-05-24 11:18:17 +0300 | [diff] [blame] | 273 | } else { |
Ido Yariv | 25eeb9e | 2010-10-12 16:20:06 +0200 | [diff] [blame] | 274 | wl1271_free_tx_id(wl, id); |
Juuso Oikarinen | 781608c | 2010-05-24 11:18:17 +0300 | [diff] [blame] | 275 | } |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 276 | |
| 277 | return ret; |
| 278 | } |
| 279 | |
Eliad Peller | a32d0cd | 2011-10-10 10:12:55 +0200 | [diff] [blame] | 280 | static void wl1271_tx_fill_hdr(struct wl1271 *wl, struct wl12xx_vif *wlvif, |
Eliad Peller | 536129c | 2011-10-05 11:55:45 +0200 | [diff] [blame] | 281 | struct sk_buff *skb, u32 extra, |
| 282 | struct ieee80211_tx_info *control, u8 hlid) |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 283 | { |
Juuso Oikarinen | ac5e1e3 | 2010-02-22 08:38:38 +0200 | [diff] [blame] | 284 | struct timespec ts; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 285 | struct wl1271_tx_hw_descr *desc; |
Shahar Levi | 48a6147 | 2011-03-06 16:32:08 +0200 | [diff] [blame] | 286 | int aligned_len, ac, rate_idx; |
Juuso Oikarinen | ac5e1e3 | 2010-02-22 08:38:38 +0200 | [diff] [blame] | 287 | s64 hosttime; |
John W. Linville | cf00f37 | 2011-12-08 16:15:58 -0500 | [diff] [blame^] | 288 | u16 tx_attr = 0; |
Eliad Peller | a32d0cd | 2011-10-10 10:12:55 +0200 | [diff] [blame] | 289 | bool is_dummy; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 290 | |
| 291 | desc = (struct wl1271_tx_hw_descr *) skb->data; |
| 292 | |
Juuso Oikarinen | 1e2b797 | 2009-10-08 21:56:20 +0300 | [diff] [blame] | 293 | /* relocate space for security header */ |
| 294 | if (extra) { |
| 295 | void *framestart = skb->data + sizeof(*desc); |
| 296 | u16 fc = *(u16 *)(framestart + extra); |
Luciano Coelho | d0f63b2 | 2009-10-15 10:33:29 +0300 | [diff] [blame] | 297 | int hdrlen = ieee80211_hdrlen(cpu_to_le16(fc)); |
Juuso Oikarinen | 1e2b797 | 2009-10-08 21:56:20 +0300 | [diff] [blame] | 298 | memmove(framestart, framestart + extra, hdrlen); |
| 299 | } |
| 300 | |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 301 | /* configure packet life time */ |
Juuso Oikarinen | ac5e1e3 | 2010-02-22 08:38:38 +0200 | [diff] [blame] | 302 | getnstimeofday(&ts); |
| 303 | hosttime = (timespec_to_ns(&ts) >> 10); |
| 304 | desc->start_time = cpu_to_le32(hosttime - wl->time_offset); |
Arik Nemtsov | c6c8a65 | 2010-10-16 20:27:53 +0200 | [diff] [blame] | 305 | |
Eliad Peller | a32d0cd | 2011-10-10 10:12:55 +0200 | [diff] [blame] | 306 | is_dummy = wl12xx_is_dummy_packet(wl, skb); |
Eliad Peller | 0f16801 | 2011-10-11 13:52:25 +0200 | [diff] [blame] | 307 | if (is_dummy || !wlvif || wlvif->bss_type != BSS_TYPE_AP_BSS) |
Arik Nemtsov | c6c8a65 | 2010-10-16 20:27:53 +0200 | [diff] [blame] | 308 | desc->life_time = cpu_to_le16(TX_HW_MGMT_PKT_LIFETIME_TU); |
| 309 | else |
| 310 | desc->life_time = cpu_to_le16(TX_HW_AP_MODE_PKT_LIFETIME_TU); |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 311 | |
Eliad Peller | db674d2 | 2011-03-16 23:03:54 +0200 | [diff] [blame] | 312 | /* queue */ |
Kalle Valo | c6999d8 | 2010-02-18 13:25:41 +0200 | [diff] [blame] | 313 | ac = wl1271_tx_get_queue(skb_get_queue_mapping(skb)); |
Eliad Peller | db674d2 | 2011-03-16 23:03:54 +0200 | [diff] [blame] | 314 | desc->tid = skb->priority; |
Arik Nemtsov | c6c8a65 | 2010-10-16 20:27:53 +0200 | [diff] [blame] | 315 | |
Eliad Peller | a32d0cd | 2011-10-10 10:12:55 +0200 | [diff] [blame] | 316 | if (is_dummy) { |
Shahar Levi | ae47c45 | 2011-03-06 16:32:14 +0200 | [diff] [blame] | 317 | /* |
| 318 | * FW expects the dummy packet to have an invalid session id - |
| 319 | * any session id that is different than the one set in the join |
| 320 | */ |
Eliad Peller | 98b8625 | 2011-10-05 11:55:55 +0200 | [diff] [blame] | 321 | tx_attr = (SESSION_COUNTER_INVALID << |
Shahar Levi | ae47c45 | 2011-03-06 16:32:14 +0200 | [diff] [blame] | 322 | TX_HW_ATTR_OFST_SESSION_COUNTER) & |
| 323 | TX_HW_ATTR_SESSION_COUNTER; |
| 324 | |
| 325 | tx_attr |= TX_HW_ATTR_TX_DUMMY_REQ; |
Eliad Peller | 0f16801 | 2011-10-11 13:52:25 +0200 | [diff] [blame] | 326 | } else if (wlvif) { |
Shahar Levi | ae47c45 | 2011-03-06 16:32:14 +0200 | [diff] [blame] | 327 | /* configure the tx attributes */ |
Eliad Peller | 98b8625 | 2011-10-05 11:55:55 +0200 | [diff] [blame] | 328 | tx_attr = wlvif->session_counter << |
| 329 | TX_HW_ATTR_OFST_SESSION_COUNTER; |
Shahar Levi | ae47c45 | 2011-03-06 16:32:14 +0200 | [diff] [blame] | 330 | } |
| 331 | |
Eliad Peller | 79b122d | 2011-08-14 13:17:11 +0300 | [diff] [blame] | 332 | desc->hlid = hlid; |
Eliad Peller | 0f16801 | 2011-10-11 13:52:25 +0200 | [diff] [blame] | 333 | if (is_dummy || !wlvif) |
Eliad Peller | a32d0cd | 2011-10-10 10:12:55 +0200 | [diff] [blame] | 334 | rate_idx = 0; |
| 335 | else if (wlvif->bss_type != BSS_TYPE_AP_BSS) { |
Arik Nemtsov | c6c8a65 | 2010-10-16 20:27:53 +0200 | [diff] [blame] | 336 | /* if the packets are destined for AP (have a STA entry) |
| 337 | send them with AP rate policies, otherwise use default |
| 338 | basic rates */ |
Eliad Peller | 8a0f2ee | 2011-11-01 09:23:52 +0200 | [diff] [blame] | 339 | if (control->flags & IEEE80211_TX_CTL_NO_CCK_RATE) |
| 340 | rate_idx = wlvif->sta.p2p_rate_idx; |
| 341 | else if (control->control.sta) |
Eliad Peller | e5a359f | 2011-10-10 10:13:15 +0200 | [diff] [blame] | 342 | rate_idx = wlvif->sta.ap_rate_idx; |
Arik Nemtsov | c6c8a65 | 2010-10-16 20:27:53 +0200 | [diff] [blame] | 343 | else |
Eliad Peller | e5a359f | 2011-10-10 10:13:15 +0200 | [diff] [blame] | 344 | rate_idx = wlvif->sta.basic_rate_idx; |
Arik Nemtsov | c6c8a65 | 2010-10-16 20:27:53 +0200 | [diff] [blame] | 345 | } else { |
Eliad Peller | a8ab39a | 2011-10-05 11:55:54 +0200 | [diff] [blame] | 346 | if (hlid == wlvif->ap.global_hlid) |
Eliad Peller | e5a359f | 2011-10-10 10:13:15 +0200 | [diff] [blame] | 347 | rate_idx = wlvif->ap.mgmt_rate_idx; |
Eliad Peller | a8ab39a | 2011-10-05 11:55:54 +0200 | [diff] [blame] | 348 | else if (hlid == wlvif->ap.bcast_hlid) |
Eliad Peller | e5a359f | 2011-10-10 10:13:15 +0200 | [diff] [blame] | 349 | rate_idx = wlvif->ap.bcast_rate_idx; |
Arik Nemtsov | e51ae9b | 2011-08-14 13:17:21 +0300 | [diff] [blame] | 350 | else |
Eliad Peller | e5a359f | 2011-10-10 10:13:15 +0200 | [diff] [blame] | 351 | rate_idx = wlvif->ap.ucast_rate_idx[ac]; |
Arik Nemtsov | c6c8a65 | 2010-10-16 20:27:53 +0200 | [diff] [blame] | 352 | } |
| 353 | |
| 354 | tx_attr |= rate_idx << TX_HW_ATTR_OFST_RATE_POLICY; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 355 | desc->reserved = 0; |
| 356 | |
Ido Yariv | 0da13da | 2011-03-31 10:06:58 +0200 | [diff] [blame] | 357 | aligned_len = wl12xx_calc_packet_alignment(wl, skb->len); |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 358 | |
Ido Yariv | 0da13da | 2011-03-31 10:06:58 +0200 | [diff] [blame] | 359 | if (wl->chip.id == CHIP_ID_1283_PG20) { |
Shahar Levi | 48a6147 | 2011-03-06 16:32:08 +0200 | [diff] [blame] | 360 | desc->wl128x_mem.extra_bytes = aligned_len - skb->len; |
| 361 | desc->length = cpu_to_le16(aligned_len >> 2); |
Shahar Levi | ae77ecc | 2011-03-06 16:32:13 +0200 | [diff] [blame] | 362 | |
| 363 | wl1271_debug(DEBUG_TX, "tx_fill_hdr: hlid: %d " |
| 364 | "tx_attr: 0x%x len: %d life: %d mem: %d", |
| 365 | desc->hlid, tx_attr, |
| 366 | le16_to_cpu(desc->length), |
| 367 | le16_to_cpu(desc->life_time), |
| 368 | desc->wl128x_mem.total_mem_blocks); |
Shahar Levi | 48a6147 | 2011-03-06 16:32:08 +0200 | [diff] [blame] | 369 | } else { |
| 370 | int pad; |
| 371 | |
Ido Yariv | 0da13da | 2011-03-31 10:06:58 +0200 | [diff] [blame] | 372 | /* Store the aligned length in terms of words */ |
Shahar Levi | 48a6147 | 2011-03-06 16:32:08 +0200 | [diff] [blame] | 373 | desc->length = cpu_to_le16(aligned_len >> 2); |
| 374 | |
| 375 | /* calculate number of padding bytes */ |
| 376 | pad = aligned_len - skb->len; |
| 377 | tx_attr |= pad << TX_HW_ATTR_OFST_LAST_WORD_PAD; |
| 378 | |
Shahar Levi | ae77ecc | 2011-03-06 16:32:13 +0200 | [diff] [blame] | 379 | wl1271_debug(DEBUG_TX, "tx_fill_hdr: pad: %d hlid: %d " |
| 380 | "tx_attr: 0x%x len: %d life: %d mem: %d", pad, |
| 381 | desc->hlid, tx_attr, |
| 382 | le16_to_cpu(desc->length), |
| 383 | le16_to_cpu(desc->life_time), |
| 384 | desc->wl127x_mem.total_mem_blocks); |
Shahar Levi | 48a6147 | 2011-03-06 16:32:08 +0200 | [diff] [blame] | 385 | } |
Luciano Coelho | d0f63b2 | 2009-10-15 10:33:29 +0300 | [diff] [blame] | 386 | |
| 387 | desc->tx_attr = cpu_to_le16(tx_attr); |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 388 | } |
| 389 | |
| 390 | /* caller must hold wl->mutex */ |
Eliad Peller | a32d0cd | 2011-10-10 10:12:55 +0200 | [diff] [blame] | 391 | static int wl1271_prepare_tx_frame(struct wl1271 *wl, struct wl12xx_vif *wlvif, |
| 392 | struct sk_buff *skb, u32 buf_offset) |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 393 | { |
| 394 | struct ieee80211_tx_info *info; |
| 395 | u32 extra = 0; |
| 396 | int ret = 0; |
Ido Yariv | a19606b | 2010-09-30 13:28:28 +0200 | [diff] [blame] | 397 | u32 total_len; |
Arik Nemtsov | 09039f4 | 2011-02-23 00:22:30 +0200 | [diff] [blame] | 398 | u8 hlid; |
Eliad Peller | 536129c | 2011-10-05 11:55:45 +0200 | [diff] [blame] | 399 | bool is_dummy; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 400 | |
| 401 | if (!skb) |
| 402 | return -EINVAL; |
| 403 | |
| 404 | info = IEEE80211_SKB_CB(skb); |
| 405 | |
Eliad Peller | 536129c | 2011-10-05 11:55:45 +0200 | [diff] [blame] | 406 | /* TODO: handle dummy packets on multi-vifs */ |
| 407 | is_dummy = wl12xx_is_dummy_packet(wl, skb); |
Eliad Peller | 536129c | 2011-10-05 11:55:45 +0200 | [diff] [blame] | 408 | |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 409 | if (info->control.hw_key && |
Johannes Berg | 97359d1 | 2010-08-10 09:46:38 +0200 | [diff] [blame] | 410 | info->control.hw_key->cipher == WLAN_CIPHER_SUITE_TKIP) |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 411 | extra = WL1271_TKIP_IV_SPACE; |
| 412 | |
| 413 | if (info->control.hw_key) { |
Arik Nemtsov | 7f179b4 | 2010-10-16 21:39:06 +0200 | [diff] [blame] | 414 | bool is_wep; |
| 415 | u8 idx = info->control.hw_key->hw_key_idx; |
| 416 | u32 cipher = info->control.hw_key->cipher; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 417 | |
Arik Nemtsov | 7f179b4 | 2010-10-16 21:39:06 +0200 | [diff] [blame] | 418 | is_wep = (cipher == WLAN_CIPHER_SUITE_WEP40) || |
| 419 | (cipher == WLAN_CIPHER_SUITE_WEP104); |
| 420 | |
Eliad Peller | f75c753f | 2011-10-05 11:55:59 +0200 | [diff] [blame] | 421 | if (unlikely(is_wep && wlvif->default_key != idx)) { |
Eliad Peller | 536129c | 2011-10-05 11:55:45 +0200 | [diff] [blame] | 422 | ret = wl1271_set_default_wep_key(wl, wlvif, idx); |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 423 | if (ret < 0) |
| 424 | return ret; |
Eliad Peller | f75c753f | 2011-10-05 11:55:59 +0200 | [diff] [blame] | 425 | wlvif->default_key = idx; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 426 | } |
| 427 | } |
Eliad Peller | d6a3cc2 | 2011-10-10 10:12:51 +0200 | [diff] [blame] | 428 | hlid = wl12xx_tx_get_hlid(wl, wlvif, skb); |
Eliad Peller | 79b122d | 2011-08-14 13:17:11 +0300 | [diff] [blame] | 429 | if (hlid == WL12XX_INVALID_LINK_ID) { |
Eliad Peller | e0d6253 | 2011-11-08 16:07:52 +0200 | [diff] [blame] | 430 | wl1271_error("invalid hlid. dropping skb 0x%p", skb); |
Eliad Peller | 79b122d | 2011-08-14 13:17:11 +0300 | [diff] [blame] | 431 | return -EINVAL; |
| 432 | } |
Arik Nemtsov | 09039f4 | 2011-02-23 00:22:30 +0200 | [diff] [blame] | 433 | |
Eliad Peller | a32d0cd | 2011-10-10 10:12:55 +0200 | [diff] [blame] | 434 | ret = wl1271_tx_allocate(wl, wlvif, skb, extra, buf_offset, hlid); |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 435 | if (ret < 0) |
| 436 | return ret; |
| 437 | |
Eliad Peller | a32d0cd | 2011-10-10 10:12:55 +0200 | [diff] [blame] | 438 | wl1271_tx_fill_hdr(wl, wlvif, skb, extra, info, hlid); |
Arik Nemtsov | fae2fd7 | 2011-06-26 10:36:04 +0300 | [diff] [blame] | 439 | |
Eliad Peller | 0f16801 | 2011-10-11 13:52:25 +0200 | [diff] [blame] | 440 | if (!is_dummy && wlvif && wlvif->bss_type == BSS_TYPE_AP_BSS) { |
Arik Nemtsov | 99a2775 | 2011-02-23 00:22:25 +0200 | [diff] [blame] | 441 | wl1271_tx_ap_update_inconnection_sta(wl, skb); |
Eliad Peller | c7ffb90 | 2011-10-05 11:56:05 +0200 | [diff] [blame] | 442 | wl1271_tx_regulate_link(wl, wlvif, hlid); |
Arik Nemtsov | b622d99 | 2011-02-23 00:22:31 +0200 | [diff] [blame] | 443 | } |
Arik Nemtsov | 99a2775 | 2011-02-23 00:22:25 +0200 | [diff] [blame] | 444 | |
Ido Yariv | a19606b | 2010-09-30 13:28:28 +0200 | [diff] [blame] | 445 | /* |
Shahar Levi | 48a6147 | 2011-03-06 16:32:08 +0200 | [diff] [blame] | 446 | * The length of each packet is stored in terms of |
| 447 | * words. Thus, we must pad the skb data to make sure its |
| 448 | * length is aligned. The number of padding bytes is computed |
| 449 | * and set in wl1271_tx_fill_hdr. |
| 450 | * In special cases, we want to align to a specific block size |
| 451 | * (eg. for wl128x with SDIO we align to 256). |
Ido Yariv | a19606b | 2010-09-30 13:28:28 +0200 | [diff] [blame] | 452 | */ |
Ido Yariv | 0da13da | 2011-03-31 10:06:58 +0200 | [diff] [blame] | 453 | total_len = wl12xx_calc_packet_alignment(wl, skb->len); |
Shahar Levi | 48a6147 | 2011-03-06 16:32:08 +0200 | [diff] [blame] | 454 | |
Ido Yariv | a19606b | 2010-09-30 13:28:28 +0200 | [diff] [blame] | 455 | memcpy(wl->aggr_buf + buf_offset, skb->data, skb->len); |
| 456 | memset(wl->aggr_buf + buf_offset + skb->len, 0, total_len - skb->len); |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 457 | |
Ido Yariv | 990f5de | 2011-03-31 10:06:59 +0200 | [diff] [blame] | 458 | /* Revert side effects in the dummy packet skb, so it can be reused */ |
Eliad Peller | 536129c | 2011-10-05 11:55:45 +0200 | [diff] [blame] | 459 | if (is_dummy) |
Ido Yariv | 990f5de | 2011-03-31 10:06:59 +0200 | [diff] [blame] | 460 | skb_pull(skb, sizeof(struct wl1271_tx_hw_descr)); |
| 461 | |
Ido Yariv | a19606b | 2010-09-30 13:28:28 +0200 | [diff] [blame] | 462 | return total_len; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 463 | } |
| 464 | |
Eliad Peller | af7fbb2 | 2011-09-19 13:51:42 +0300 | [diff] [blame] | 465 | u32 wl1271_tx_enabled_rates_get(struct wl1271 *wl, u32 rate_set, |
| 466 | enum ieee80211_band rate_band) |
Juuso Oikarinen | 830fb67 | 2009-12-11 15:41:06 +0200 | [diff] [blame] | 467 | { |
| 468 | struct ieee80211_supported_band *band; |
| 469 | u32 enabled_rates = 0; |
| 470 | int bit; |
| 471 | |
Eliad Peller | af7fbb2 | 2011-09-19 13:51:42 +0300 | [diff] [blame] | 472 | band = wl->hw->wiphy->bands[rate_band]; |
Juuso Oikarinen | 830fb67 | 2009-12-11 15:41:06 +0200 | [diff] [blame] | 473 | for (bit = 0; bit < band->n_bitrates; bit++) { |
| 474 | if (rate_set & 0x1) |
| 475 | enabled_rates |= band->bitrates[bit].hw_value; |
| 476 | rate_set >>= 1; |
| 477 | } |
| 478 | |
Shahar Levi | 1835785 | 2010-10-13 16:09:41 +0200 | [diff] [blame] | 479 | /* MCS rates indication are on bits 16 - 23 */ |
| 480 | rate_set >>= HW_HT_RATES_OFFSET - band->n_bitrates; |
| 481 | |
| 482 | for (bit = 0; bit < 8; bit++) { |
| 483 | if (rate_set & 0x1) |
| 484 | enabled_rates |= (CONF_HW_BIT_RATE_MCS_0 << bit); |
| 485 | rate_set >>= 1; |
| 486 | } |
Shahar Levi | 1835785 | 2010-10-13 16:09:41 +0200 | [diff] [blame] | 487 | |
Juuso Oikarinen | 830fb67 | 2009-12-11 15:41:06 +0200 | [diff] [blame] | 488 | return enabled_rates; |
| 489 | } |
| 490 | |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 491 | void wl1271_handle_tx_low_watermark(struct wl1271 *wl) |
Ido Yariv | 2fe33e8 | 2010-10-12 14:49:12 +0200 | [diff] [blame] | 492 | { |
| 493 | unsigned long flags; |
Arik Nemtsov | 708bb3c | 2011-06-24 13:03:37 +0300 | [diff] [blame] | 494 | int i; |
Ido Yariv | 2fe33e8 | 2010-10-12 14:49:12 +0200 | [diff] [blame] | 495 | |
Arik Nemtsov | 708bb3c | 2011-06-24 13:03:37 +0300 | [diff] [blame] | 496 | for (i = 0; i < NUM_TX_QUEUES; i++) { |
| 497 | if (test_bit(i, &wl->stopped_queues_map) && |
Arik Nemtsov | f1a4638 | 2011-07-07 14:25:23 +0300 | [diff] [blame] | 498 | wl->tx_queue_count[i] <= WL1271_TX_QUEUE_LOW_WATERMARK) { |
Arik Nemtsov | 708bb3c | 2011-06-24 13:03:37 +0300 | [diff] [blame] | 499 | /* firmware buffer has space, restart queues */ |
| 500 | spin_lock_irqsave(&wl->wl_lock, flags); |
| 501 | ieee80211_wake_queue(wl->hw, |
| 502 | wl1271_tx_get_mac80211_queue(i)); |
| 503 | clear_bit(i, &wl->stopped_queues_map); |
| 504 | spin_unlock_irqrestore(&wl->wl_lock, flags); |
| 505 | } |
Ido Yariv | 2fe33e8 | 2010-10-12 14:49:12 +0200 | [diff] [blame] | 506 | } |
| 507 | } |
| 508 | |
Arik Nemtsov | 742246f | 2011-08-14 13:17:33 +0300 | [diff] [blame] | 509 | static struct sk_buff_head *wl1271_select_queue(struct wl1271 *wl, |
| 510 | struct sk_buff_head *queues) |
| 511 | { |
| 512 | int i, q = -1, ac; |
| 513 | u32 min_pkts = 0xffffffff; |
| 514 | |
| 515 | /* |
| 516 | * Find a non-empty ac where: |
| 517 | * 1. There are packets to transmit |
| 518 | * 2. The FW has the least allocated blocks |
| 519 | * |
| 520 | * We prioritize the ACs according to VO>VI>BE>BK |
| 521 | */ |
| 522 | for (i = 0; i < NUM_TX_QUEUES; i++) { |
| 523 | ac = wl1271_tx_get_queue(i); |
| 524 | if (!skb_queue_empty(&queues[ac]) && |
| 525 | (wl->tx_allocated_pkts[ac] < min_pkts)) { |
| 526 | q = ac; |
| 527 | min_pkts = wl->tx_allocated_pkts[q]; |
| 528 | } |
| 529 | } |
| 530 | |
| 531 | if (q == -1) |
| 532 | return NULL; |
| 533 | |
| 534 | return &queues[q]; |
| 535 | } |
| 536 | |
Eliad Peller | d6a3cc2 | 2011-10-10 10:12:51 +0200 | [diff] [blame] | 537 | static struct sk_buff *wl12xx_lnk_skb_dequeue(struct wl1271 *wl, |
| 538 | struct wl1271_link *lnk) |
Juuso Oikarinen | 6742f55 | 2010-12-13 09:52:37 +0200 | [diff] [blame] | 539 | { |
Eliad Peller | d6a3cc2 | 2011-10-10 10:12:51 +0200 | [diff] [blame] | 540 | struct sk_buff *skb; |
Juuso Oikarinen | 6742f55 | 2010-12-13 09:52:37 +0200 | [diff] [blame] | 541 | unsigned long flags; |
Arik Nemtsov | 742246f | 2011-08-14 13:17:33 +0300 | [diff] [blame] | 542 | struct sk_buff_head *queue; |
Juuso Oikarinen | 6742f55 | 2010-12-13 09:52:37 +0200 | [diff] [blame] | 543 | |
Eliad Peller | d6a3cc2 | 2011-10-10 10:12:51 +0200 | [diff] [blame] | 544 | queue = wl1271_select_queue(wl, lnk->tx_queue); |
Arik Nemtsov | 742246f | 2011-08-14 13:17:33 +0300 | [diff] [blame] | 545 | if (!queue) |
Eliad Peller | d6a3cc2 | 2011-10-10 10:12:51 +0200 | [diff] [blame] | 546 | return NULL; |
Arik Nemtsov | 742246f | 2011-08-14 13:17:33 +0300 | [diff] [blame] | 547 | |
| 548 | skb = skb_dequeue(queue); |
Juuso Oikarinen | 6742f55 | 2010-12-13 09:52:37 +0200 | [diff] [blame] | 549 | if (skb) { |
Arik Nemtsov | f1a4638 | 2011-07-07 14:25:23 +0300 | [diff] [blame] | 550 | int q = wl1271_tx_get_queue(skb_get_queue_mapping(skb)); |
Juuso Oikarinen | 6742f55 | 2010-12-13 09:52:37 +0200 | [diff] [blame] | 551 | spin_lock_irqsave(&wl->wl_lock, flags); |
Arik Nemtsov | f1a4638 | 2011-07-07 14:25:23 +0300 | [diff] [blame] | 552 | wl->tx_queue_count[q]--; |
Juuso Oikarinen | 6742f55 | 2010-12-13 09:52:37 +0200 | [diff] [blame] | 553 | spin_unlock_irqrestore(&wl->wl_lock, flags); |
| 554 | } |
| 555 | |
| 556 | return skb; |
| 557 | } |
| 558 | |
Eliad Peller | d6a3cc2 | 2011-10-10 10:12:51 +0200 | [diff] [blame] | 559 | static struct sk_buff *wl12xx_vif_skb_dequeue(struct wl1271 *wl, |
| 560 | struct wl12xx_vif *wlvif) |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 561 | { |
| 562 | struct sk_buff *skb = NULL; |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 563 | int i, h, start_hlid; |
| 564 | |
| 565 | /* start from the link after the last one */ |
Eliad Peller | 4438aca | 2011-10-10 10:12:50 +0200 | [diff] [blame] | 566 | start_hlid = (wlvif->last_tx_hlid + 1) % WL12XX_MAX_LINKS; |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 567 | |
| 568 | /* dequeue according to AC, round robin on each link */ |
Eliad Peller | c7ffb90 | 2011-10-05 11:56:05 +0200 | [diff] [blame] | 569 | for (i = 0; i < WL12XX_MAX_LINKS; i++) { |
| 570 | h = (start_hlid + i) % WL12XX_MAX_LINKS; |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 571 | |
Arik Nemtsov | 742246f | 2011-08-14 13:17:33 +0300 | [diff] [blame] | 572 | /* only consider connected stations */ |
Eliad Peller | c7ffb90 | 2011-10-05 11:56:05 +0200 | [diff] [blame] | 573 | if (!test_bit(h, wlvif->links_map)) |
Arik Nemtsov | 742246f | 2011-08-14 13:17:33 +0300 | [diff] [blame] | 574 | continue; |
| 575 | |
Eliad Peller | d6a3cc2 | 2011-10-10 10:12:51 +0200 | [diff] [blame] | 576 | skb = wl12xx_lnk_skb_dequeue(wl, &wl->links[h]); |
| 577 | if (!skb) |
Arik Nemtsov | 742246f | 2011-08-14 13:17:33 +0300 | [diff] [blame] | 578 | continue; |
| 579 | |
Eliad Peller | d6a3cc2 | 2011-10-10 10:12:51 +0200 | [diff] [blame] | 580 | wlvif->last_tx_hlid = h; |
| 581 | break; |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 582 | } |
| 583 | |
Eliad Peller | d6a3cc2 | 2011-10-10 10:12:51 +0200 | [diff] [blame] | 584 | if (!skb) |
Eliad Peller | 4438aca | 2011-10-10 10:12:50 +0200 | [diff] [blame] | 585 | wlvif->last_tx_hlid = 0; |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 586 | |
| 587 | return skb; |
| 588 | } |
| 589 | |
Eliad Peller | a32d0cd | 2011-10-10 10:12:55 +0200 | [diff] [blame] | 590 | static struct sk_buff *wl1271_skb_dequeue(struct wl1271 *wl) |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 591 | { |
Ido Yariv | 990f5de | 2011-03-31 10:06:59 +0200 | [diff] [blame] | 592 | unsigned long flags; |
Eliad Peller | e4120df | 2011-10-10 10:13:17 +0200 | [diff] [blame] | 593 | struct wl12xx_vif *wlvif = wl->last_wlvif; |
Ido Yariv | 990f5de | 2011-03-31 10:06:59 +0200 | [diff] [blame] | 594 | struct sk_buff *skb = NULL; |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 595 | |
Eliad Peller | e4120df | 2011-10-10 10:13:17 +0200 | [diff] [blame] | 596 | if (wlvif) { |
| 597 | wl12xx_for_each_wlvif_continue(wl, wlvif) { |
| 598 | skb = wl12xx_vif_skb_dequeue(wl, wlvif); |
| 599 | if (skb) { |
| 600 | wl->last_wlvif = wlvif; |
| 601 | break; |
| 602 | } |
| 603 | } |
| 604 | } |
| 605 | |
| 606 | /* do another pass */ |
| 607 | if (!skb) { |
| 608 | wl12xx_for_each_wlvif(wl, wlvif) { |
| 609 | skb = wl12xx_vif_skb_dequeue(wl, wlvif); |
| 610 | if (skb) { |
| 611 | wl->last_wlvif = wlvif; |
| 612 | break; |
| 613 | } |
| 614 | } |
Eliad Peller | a32d0cd | 2011-10-10 10:12:55 +0200 | [diff] [blame] | 615 | } |
| 616 | |
Eliad Peller | 0f16801 | 2011-10-11 13:52:25 +0200 | [diff] [blame] | 617 | if (!skb) |
| 618 | skb = wl12xx_lnk_skb_dequeue(wl, &wl->links[wl->system_hlid]); |
| 619 | |
Ido Yariv | 990f5de | 2011-03-31 10:06:59 +0200 | [diff] [blame] | 620 | if (!skb && |
| 621 | test_and_clear_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags)) { |
Arik Nemtsov | f1a4638 | 2011-07-07 14:25:23 +0300 | [diff] [blame] | 622 | int q; |
| 623 | |
Ido Yariv | 990f5de | 2011-03-31 10:06:59 +0200 | [diff] [blame] | 624 | skb = wl->dummy_packet; |
Arik Nemtsov | f1a4638 | 2011-07-07 14:25:23 +0300 | [diff] [blame] | 625 | q = wl1271_tx_get_queue(skb_get_queue_mapping(skb)); |
Ido Yariv | 990f5de | 2011-03-31 10:06:59 +0200 | [diff] [blame] | 626 | spin_lock_irqsave(&wl->wl_lock, flags); |
Arik Nemtsov | f1a4638 | 2011-07-07 14:25:23 +0300 | [diff] [blame] | 627 | wl->tx_queue_count[q]--; |
Ido Yariv | 990f5de | 2011-03-31 10:06:59 +0200 | [diff] [blame] | 628 | spin_unlock_irqrestore(&wl->wl_lock, flags); |
| 629 | } |
| 630 | |
| 631 | return skb; |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 632 | } |
| 633 | |
Eliad Peller | d6a3cc2 | 2011-10-10 10:12:51 +0200 | [diff] [blame] | 634 | static void wl1271_skb_queue_head(struct wl1271 *wl, struct wl12xx_vif *wlvif, |
Eliad Peller | 536129c | 2011-10-05 11:55:45 +0200 | [diff] [blame] | 635 | struct sk_buff *skb) |
Juuso Oikarinen | 6742f55 | 2010-12-13 09:52:37 +0200 | [diff] [blame] | 636 | { |
| 637 | unsigned long flags; |
| 638 | int q = wl1271_tx_get_queue(skb_get_queue_mapping(skb)); |
| 639 | |
Ido Yariv | 990f5de | 2011-03-31 10:06:59 +0200 | [diff] [blame] | 640 | if (wl12xx_is_dummy_packet(wl, skb)) { |
| 641 | set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags); |
Eliad Peller | d6a3cc2 | 2011-10-10 10:12:51 +0200 | [diff] [blame] | 642 | } else { |
| 643 | u8 hlid = wl12xx_tx_get_hlid(wl, wlvif, skb); |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 644 | skb_queue_head(&wl->links[hlid].tx_queue[q], skb); |
| 645 | |
| 646 | /* make sure we dequeue the same packet next time */ |
Eliad Peller | 4438aca | 2011-10-10 10:12:50 +0200 | [diff] [blame] | 647 | wlvif->last_tx_hlid = (hlid + WL12XX_MAX_LINKS - 1) % |
Eliad Peller | d6a3cc2 | 2011-10-10 10:12:51 +0200 | [diff] [blame] | 648 | WL12XX_MAX_LINKS; |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 649 | } |
| 650 | |
Juuso Oikarinen | 6742f55 | 2010-12-13 09:52:37 +0200 | [diff] [blame] | 651 | spin_lock_irqsave(&wl->wl_lock, flags); |
Arik Nemtsov | f1a4638 | 2011-07-07 14:25:23 +0300 | [diff] [blame] | 652 | wl->tx_queue_count[q]++; |
Juuso Oikarinen | 6742f55 | 2010-12-13 09:52:37 +0200 | [diff] [blame] | 653 | spin_unlock_irqrestore(&wl->wl_lock, flags); |
| 654 | } |
| 655 | |
Eliad Peller | 77ddaa1 | 2011-05-15 11:10:29 +0300 | [diff] [blame] | 656 | static bool wl1271_tx_is_data_present(struct sk_buff *skb) |
| 657 | { |
| 658 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)(skb->data); |
| 659 | |
| 660 | return ieee80211_is_data_present(hdr->frame_control); |
| 661 | } |
| 662 | |
Eliad Peller | 9eb599e | 2011-10-10 10:12:59 +0200 | [diff] [blame] | 663 | void wl12xx_rearm_rx_streaming(struct wl1271 *wl, unsigned long *active_hlids) |
| 664 | { |
| 665 | struct wl12xx_vif *wlvif; |
| 666 | u32 timeout; |
| 667 | u8 hlid; |
| 668 | |
| 669 | if (!wl->conf.rx_streaming.interval) |
| 670 | return; |
| 671 | |
| 672 | if (!wl->conf.rx_streaming.always && |
| 673 | !test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)) |
| 674 | return; |
| 675 | |
| 676 | timeout = wl->conf.rx_streaming.duration; |
| 677 | wl12xx_for_each_wlvif_sta(wl, wlvif) { |
| 678 | bool found = false; |
| 679 | for_each_set_bit(hlid, active_hlids, WL12XX_MAX_LINKS) { |
| 680 | if (test_bit(hlid, wlvif->links_map)) { |
| 681 | found = true; |
| 682 | break; |
| 683 | } |
| 684 | } |
| 685 | |
| 686 | if (!found) |
| 687 | continue; |
| 688 | |
| 689 | /* enable rx streaming */ |
Eliad Peller | 0744bdb | 2011-10-10 10:13:05 +0200 | [diff] [blame] | 690 | if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags)) |
Eliad Peller | 9eb599e | 2011-10-10 10:12:59 +0200 | [diff] [blame] | 691 | ieee80211_queue_work(wl->hw, |
| 692 | &wlvif->rx_streaming_enable_work); |
| 693 | |
| 694 | mod_timer(&wlvif->rx_streaming_timer, |
| 695 | jiffies + msecs_to_jiffies(timeout)); |
| 696 | } |
| 697 | } |
| 698 | |
Eliad Peller | a32d0cd | 2011-10-10 10:12:55 +0200 | [diff] [blame] | 699 | void wl1271_tx_work_locked(struct wl1271 *wl) |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 700 | { |
Eliad Peller | a32d0cd | 2011-10-10 10:12:55 +0200 | [diff] [blame] | 701 | struct wl12xx_vif *wlvif; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 702 | struct sk_buff *skb; |
Eliad Peller | 9eb599e | 2011-10-10 10:12:59 +0200 | [diff] [blame] | 703 | struct wl1271_tx_hw_descr *desc; |
Ido Yariv | 6c6e669 | 2010-10-12 14:49:09 +0200 | [diff] [blame] | 704 | u32 buf_offset = 0; |
| 705 | bool sent_packets = false; |
Eliad Peller | 9eb599e | 2011-10-10 10:12:59 +0200 | [diff] [blame] | 706 | unsigned long active_hlids[BITS_TO_LONGS(WL12XX_MAX_LINKS)] = {0}; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 707 | int ret; |
| 708 | |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 709 | if (unlikely(wl->state == WL1271_STATE_OFF)) |
Eliad Peller | c1b193e | 2011-03-23 22:22:15 +0200 | [diff] [blame] | 710 | return; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 711 | |
Eliad Peller | a32d0cd | 2011-10-10 10:12:55 +0200 | [diff] [blame] | 712 | while ((skb = wl1271_skb_dequeue(wl))) { |
Eliad Peller | 0f16801 | 2011-10-11 13:52:25 +0200 | [diff] [blame] | 713 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); |
Eliad Peller | 9eb599e | 2011-10-10 10:12:59 +0200 | [diff] [blame] | 714 | bool has_data = false; |
| 715 | |
Eliad Peller | a32d0cd | 2011-10-10 10:12:55 +0200 | [diff] [blame] | 716 | wlvif = NULL; |
Eliad Peller | 0f16801 | 2011-10-11 13:52:25 +0200 | [diff] [blame] | 717 | if (!wl12xx_is_dummy_packet(wl, skb) && info->control.vif) |
| 718 | wlvif = wl12xx_vif_to_data(info->control.vif); |
Eliad Peller | a32d0cd | 2011-10-10 10:12:55 +0200 | [diff] [blame] | 719 | |
Eliad Peller | 9eb599e | 2011-10-10 10:12:59 +0200 | [diff] [blame] | 720 | has_data = wlvif && wl1271_tx_is_data_present(skb); |
Eliad Peller | a32d0cd | 2011-10-10 10:12:55 +0200 | [diff] [blame] | 721 | ret = wl1271_prepare_tx_frame(wl, wlvif, skb, buf_offset); |
Ido Yariv | 6c6e669 | 2010-10-12 14:49:09 +0200 | [diff] [blame] | 722 | if (ret == -EAGAIN) { |
Ido Yariv | a19606b | 2010-09-30 13:28:28 +0200 | [diff] [blame] | 723 | /* |
Ido Yariv | 6c6e669 | 2010-10-12 14:49:09 +0200 | [diff] [blame] | 724 | * Aggregation buffer is full. |
| 725 | * Flush buffer and try again. |
| 726 | */ |
Eliad Peller | d6a3cc2 | 2011-10-10 10:12:51 +0200 | [diff] [blame] | 727 | wl1271_skb_queue_head(wl, wlvif, skb); |
Ido Yariv | 6c6e669 | 2010-10-12 14:49:09 +0200 | [diff] [blame] | 728 | wl1271_write(wl, WL1271_SLV_MEM_DATA, wl->aggr_buf, |
Juuso Oikarinen | 6742f55 | 2010-12-13 09:52:37 +0200 | [diff] [blame] | 729 | buf_offset, true); |
Ido Yariv | 6c6e669 | 2010-10-12 14:49:09 +0200 | [diff] [blame] | 730 | sent_packets = true; |
| 731 | buf_offset = 0; |
| 732 | continue; |
| 733 | } else if (ret == -EBUSY) { |
| 734 | /* |
| 735 | * Firmware buffer is full. |
Ido Yariv | a19606b | 2010-09-30 13:28:28 +0200 | [diff] [blame] | 736 | * Queue back last skb, and stop aggregating. |
| 737 | */ |
Eliad Peller | d6a3cc2 | 2011-10-10 10:12:51 +0200 | [diff] [blame] | 738 | wl1271_skb_queue_head(wl, wlvif, skb); |
Ido Yariv | a522550 | 2010-10-12 14:49:10 +0200 | [diff] [blame] | 739 | /* No work left, avoid scheduling redundant tx work */ |
| 740 | set_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags); |
Juuso Oikarinen | ffb591c | 2010-02-22 08:38:31 +0200 | [diff] [blame] | 741 | goto out_ack; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 742 | } else if (ret < 0) { |
| 743 | dev_kfree_skb(skb); |
Juuso Oikarinen | ffb591c | 2010-02-22 08:38:31 +0200 | [diff] [blame] | 744 | goto out_ack; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 745 | } |
Ido Yariv | a19606b | 2010-09-30 13:28:28 +0200 | [diff] [blame] | 746 | buf_offset += ret; |
| 747 | wl->tx_packets_count++; |
Eliad Peller | 9eb599e | 2011-10-10 10:12:59 +0200 | [diff] [blame] | 748 | if (has_data) { |
| 749 | desc = (struct wl1271_tx_hw_descr *) skb->data; |
| 750 | __set_bit(desc->hlid, active_hlids); |
| 751 | } |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 752 | } |
| 753 | |
Juuso Oikarinen | ffb591c | 2010-02-22 08:38:31 +0200 | [diff] [blame] | 754 | out_ack: |
Ido Yariv | a19606b | 2010-09-30 13:28:28 +0200 | [diff] [blame] | 755 | if (buf_offset) { |
| 756 | wl1271_write(wl, WL1271_SLV_MEM_DATA, wl->aggr_buf, |
| 757 | buf_offset, true); |
Ido Yariv | 6c6e669 | 2010-10-12 14:49:09 +0200 | [diff] [blame] | 758 | sent_packets = true; |
| 759 | } |
| 760 | if (sent_packets) { |
Ido Yariv | 606ea9f | 2011-03-01 15:14:39 +0200 | [diff] [blame] | 761 | /* |
| 762 | * Interrupt the firmware with the new packets. This is only |
| 763 | * required for older hardware revisions |
| 764 | */ |
| 765 | if (wl->quirks & WL12XX_QUIRK_END_OF_TRANSACTION) |
| 766 | wl1271_write32(wl, WL1271_HOST_WR_ACCESS, |
| 767 | wl->tx_packets_count); |
| 768 | |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 769 | wl1271_handle_tx_low_watermark(wl); |
Ido Yariv | a19606b | 2010-09-30 13:28:28 +0200 | [diff] [blame] | 770 | } |
Eliad Peller | 9eb599e | 2011-10-10 10:12:59 +0200 | [diff] [blame] | 771 | wl12xx_rearm_rx_streaming(wl, active_hlids); |
Ido Yariv | a522550 | 2010-10-12 14:49:10 +0200 | [diff] [blame] | 772 | } |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 773 | |
Ido Yariv | a522550 | 2010-10-12 14:49:10 +0200 | [diff] [blame] | 774 | void wl1271_tx_work(struct work_struct *work) |
| 775 | { |
| 776 | struct wl1271 *wl = container_of(work, struct wl1271, tx_work); |
Eliad Peller | c1b193e | 2011-03-23 22:22:15 +0200 | [diff] [blame] | 777 | int ret; |
Ido Yariv | a522550 | 2010-10-12 14:49:10 +0200 | [diff] [blame] | 778 | |
| 779 | mutex_lock(&wl->mutex); |
Eliad Peller | c1b193e | 2011-03-23 22:22:15 +0200 | [diff] [blame] | 780 | ret = wl1271_ps_elp_wakeup(wl); |
| 781 | if (ret < 0) |
| 782 | goto out; |
| 783 | |
Eliad Peller | a32d0cd | 2011-10-10 10:12:55 +0200 | [diff] [blame] | 784 | wl1271_tx_work_locked(wl); |
Eliad Peller | c1b193e | 2011-03-23 22:22:15 +0200 | [diff] [blame] | 785 | |
Eliad Peller | c75bbcd | 2011-04-04 10:38:47 +0300 | [diff] [blame] | 786 | wl1271_ps_elp_sleep(wl); |
Eliad Peller | c1b193e | 2011-03-23 22:22:15 +0200 | [diff] [blame] | 787 | out: |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 788 | mutex_unlock(&wl->mutex); |
| 789 | } |
| 790 | |
| 791 | static void wl1271_tx_complete_packet(struct wl1271 *wl, |
| 792 | struct wl1271_tx_hw_res_descr *result) |
| 793 | { |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 794 | struct ieee80211_tx_info *info; |
Eliad Peller | 48e93e4 | 2011-10-10 10:12:58 +0200 | [diff] [blame] | 795 | struct ieee80211_vif *vif; |
| 796 | struct wl12xx_vif *wlvif; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 797 | struct sk_buff *skb; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 798 | int id = result->id; |
Juuso Oikarinen | 31627dc | 2010-03-26 12:53:12 +0200 | [diff] [blame] | 799 | int rate = -1; |
| 800 | u8 retries = 0; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 801 | |
| 802 | /* check for id legality */ |
Juuso Oikarinen | ffb591c | 2010-02-22 08:38:31 +0200 | [diff] [blame] | 803 | if (unlikely(id >= ACX_TX_DESCRIPTORS || wl->tx_frames[id] == NULL)) { |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 804 | wl1271_warning("TX result illegal id: %d", id); |
| 805 | return; |
| 806 | } |
| 807 | |
| 808 | skb = wl->tx_frames[id]; |
| 809 | info = IEEE80211_SKB_CB(skb); |
| 810 | |
Ido Yariv | 990f5de | 2011-03-31 10:06:59 +0200 | [diff] [blame] | 811 | if (wl12xx_is_dummy_packet(wl, skb)) { |
Shahar Levi | ae47c45 | 2011-03-06 16:32:14 +0200 | [diff] [blame] | 812 | wl1271_free_tx_id(wl, id); |
| 813 | return; |
| 814 | } |
| 815 | |
Eliad Peller | 48e93e4 | 2011-10-10 10:12:58 +0200 | [diff] [blame] | 816 | /* info->control is valid as long as we don't update info->status */ |
| 817 | vif = info->control.vif; |
| 818 | wlvif = wl12xx_vif_to_data(vif); |
| 819 | |
Juuso Oikarinen | 31627dc | 2010-03-26 12:53:12 +0200 | [diff] [blame] | 820 | /* update the TX status info */ |
| 821 | if (result->status == TX_SUCCESS) { |
| 822 | if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 823 | info->flags |= IEEE80211_TX_STAT_ACK; |
Eliad Peller | 1b92f15 | 2011-10-10 10:13:09 +0200 | [diff] [blame] | 824 | rate = wl1271_rate_to_idx(result->rate_class_index, |
| 825 | wlvif->band); |
Juuso Oikarinen | 31627dc | 2010-03-26 12:53:12 +0200 | [diff] [blame] | 826 | retries = result->ack_failures; |
| 827 | } else if (result->status == TX_RETRY_EXCEEDED) { |
| 828 | wl->stats.excessive_retries++; |
| 829 | retries = result->ack_failures; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 830 | } |
| 831 | |
Juuso Oikarinen | 31627dc | 2010-03-26 12:53:12 +0200 | [diff] [blame] | 832 | info->status.rates[0].idx = rate; |
| 833 | info->status.rates[0].count = retries; |
| 834 | info->status.rates[0].flags = 0; |
| 835 | info->status.ack_signal = -1; |
| 836 | |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 837 | wl->stats.retry_count += result->ack_failures; |
| 838 | |
Oz Krakowski | b992c68 | 2011-06-26 10:36:02 +0300 | [diff] [blame] | 839 | /* |
| 840 | * update sequence number only when relevant, i.e. only in |
| 841 | * sessions of TKIP, AES and GEM (not in open or WEP sessions) |
| 842 | */ |
| 843 | if (info->control.hw_key && |
| 844 | (info->control.hw_key->cipher == WLAN_CIPHER_SUITE_TKIP || |
| 845 | info->control.hw_key->cipher == WLAN_CIPHER_SUITE_CCMP || |
| 846 | info->control.hw_key->cipher == WL1271_CIPHER_SUITE_GEM)) { |
| 847 | u8 fw_lsb = result->tx_security_sequence_number_lsb; |
Eliad Peller | 48e93e4 | 2011-10-10 10:12:58 +0200 | [diff] [blame] | 848 | u8 cur_lsb = wlvif->tx_security_last_seq_lsb; |
Oz Krakowski | b992c68 | 2011-06-26 10:36:02 +0300 | [diff] [blame] | 849 | |
| 850 | /* |
| 851 | * update security sequence number, taking care of potential |
| 852 | * wrap-around |
| 853 | */ |
Eliad Peller | 48e93e4 | 2011-10-10 10:12:58 +0200 | [diff] [blame] | 854 | wlvif->tx_security_seq += (fw_lsb - cur_lsb) & 0xff; |
| 855 | wlvif->tx_security_last_seq_lsb = fw_lsb; |
Oz Krakowski | b992c68 | 2011-06-26 10:36:02 +0300 | [diff] [blame] | 856 | } |
Juuso Oikarinen | ac4e4ce | 2009-10-08 21:56:19 +0300 | [diff] [blame] | 857 | |
Juuso Oikarinen | 1e2b797 | 2009-10-08 21:56:20 +0300 | [diff] [blame] | 858 | /* remove private header from packet */ |
| 859 | skb_pull(skb, sizeof(struct wl1271_tx_hw_descr)); |
| 860 | |
| 861 | /* remove TKIP header space if present */ |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 862 | if (info->control.hw_key && |
Johannes Berg | 97359d1 | 2010-08-10 09:46:38 +0200 | [diff] [blame] | 863 | info->control.hw_key->cipher == WLAN_CIPHER_SUITE_TKIP) { |
Juuso Oikarinen | 1e2b797 | 2009-10-08 21:56:20 +0300 | [diff] [blame] | 864 | int hdrlen = ieee80211_get_hdrlen_from_skb(skb); |
| 865 | memmove(skb->data + WL1271_TKIP_IV_SPACE, skb->data, hdrlen); |
| 866 | skb_pull(skb, WL1271_TKIP_IV_SPACE); |
| 867 | } |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 868 | |
| 869 | wl1271_debug(DEBUG_TX, "tx status id %u skb 0x%p failures %u rate 0x%x" |
| 870 | " status 0x%x", |
| 871 | result->id, skb, result->ack_failures, |
| 872 | result->rate_class_index, result->status); |
| 873 | |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 874 | /* return the packet to the stack */ |
Ido Yariv | a620865 | 2011-03-01 15:14:41 +0200 | [diff] [blame] | 875 | skb_queue_tail(&wl->deferred_tx_queue, skb); |
Eliad Peller | 92ef896 | 2011-06-07 12:50:46 +0300 | [diff] [blame] | 876 | queue_work(wl->freezable_wq, &wl->netstack_work); |
Ido Yariv | 25eeb9e | 2010-10-12 16:20:06 +0200 | [diff] [blame] | 877 | wl1271_free_tx_id(wl, result->id); |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 878 | } |
| 879 | |
| 880 | /* Called upon reception of a TX complete interrupt */ |
Juuso Oikarinen | ffb591c | 2010-02-22 08:38:31 +0200 | [diff] [blame] | 881 | void wl1271_tx_complete(struct wl1271 *wl) |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 882 | { |
| 883 | struct wl1271_acx_mem_map *memmap = |
| 884 | (struct wl1271_acx_mem_map *)wl->target_mem_map; |
Juuso Oikarinen | ffb591c | 2010-02-22 08:38:31 +0200 | [diff] [blame] | 885 | u32 count, fw_counter; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 886 | u32 i; |
| 887 | |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 888 | /* read the tx results from the chipset */ |
Teemu Paasikivi | 7b048c5 | 2010-02-18 13:25:55 +0200 | [diff] [blame] | 889 | wl1271_read(wl, le32_to_cpu(memmap->tx_result), |
| 890 | wl->tx_res_if, sizeof(*wl->tx_res_if), false); |
Juuso Oikarinen | ffb591c | 2010-02-22 08:38:31 +0200 | [diff] [blame] | 891 | fw_counter = le32_to_cpu(wl->tx_res_if->tx_result_fw_counter); |
| 892 | |
| 893 | /* write host counter to chipset (to ack) */ |
| 894 | wl1271_write32(wl, le32_to_cpu(memmap->tx_result) + |
| 895 | offsetof(struct wl1271_tx_hw_res_if, |
| 896 | tx_result_host_counter), fw_counter); |
| 897 | |
| 898 | count = fw_counter - wl->tx_results_count; |
Juuso Oikarinen | 06f7bc7 | 2010-02-22 08:38:33 +0200 | [diff] [blame] | 899 | wl1271_debug(DEBUG_TX, "tx_complete received, packets: %d", count); |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 900 | |
| 901 | /* verify that the result buffer is not getting overrun */ |
Juuso Oikarinen | ffb591c | 2010-02-22 08:38:31 +0200 | [diff] [blame] | 902 | if (unlikely(count > TX_HW_RESULT_QUEUE_LEN)) |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 903 | wl1271_warning("TX result overflow from chipset: %d", count); |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 904 | |
| 905 | /* process the results */ |
| 906 | for (i = 0; i < count; i++) { |
| 907 | struct wl1271_tx_hw_res_descr *result; |
| 908 | u8 offset = wl->tx_results_count & TX_HW_RESULT_QUEUE_LEN_MASK; |
| 909 | |
| 910 | /* process the packet */ |
| 911 | result = &(wl->tx_res_if->tx_results_queue[offset]); |
| 912 | wl1271_tx_complete_packet(wl, result); |
| 913 | |
| 914 | wl->tx_results_count++; |
| 915 | } |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 916 | } |
| 917 | |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 918 | void wl1271_tx_reset_link_queues(struct wl1271 *wl, u8 hlid) |
| 919 | { |
| 920 | struct sk_buff *skb; |
Arik Nemtsov | f1a4638 | 2011-07-07 14:25:23 +0300 | [diff] [blame] | 921 | int i; |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 922 | unsigned long flags; |
Arik Nemtsov | 1d36cd8 | 2011-02-23 00:22:27 +0200 | [diff] [blame] | 923 | struct ieee80211_tx_info *info; |
Arik Nemtsov | f1a4638 | 2011-07-07 14:25:23 +0300 | [diff] [blame] | 924 | int total[NUM_TX_QUEUES]; |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 925 | |
| 926 | for (i = 0; i < NUM_TX_QUEUES; i++) { |
Arik Nemtsov | f1a4638 | 2011-07-07 14:25:23 +0300 | [diff] [blame] | 927 | total[i] = 0; |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 928 | while ((skb = skb_dequeue(&wl->links[hlid].tx_queue[i]))) { |
| 929 | wl1271_debug(DEBUG_TX, "link freeing skb 0x%p", skb); |
Arik Nemtsov | 79ebec7 | 2011-08-14 13:17:18 +0300 | [diff] [blame] | 930 | |
| 931 | if (!wl12xx_is_dummy_packet(wl, skb)) { |
| 932 | info = IEEE80211_SKB_CB(skb); |
| 933 | info->status.rates[0].idx = -1; |
| 934 | info->status.rates[0].count = 0; |
| 935 | ieee80211_tx_status_ni(wl->hw, skb); |
| 936 | } |
| 937 | |
Arik Nemtsov | f1a4638 | 2011-07-07 14:25:23 +0300 | [diff] [blame] | 938 | total[i]++; |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 939 | } |
| 940 | } |
| 941 | |
| 942 | spin_lock_irqsave(&wl->wl_lock, flags); |
Arik Nemtsov | f1a4638 | 2011-07-07 14:25:23 +0300 | [diff] [blame] | 943 | for (i = 0; i < NUM_TX_QUEUES; i++) |
| 944 | wl->tx_queue_count[i] -= total[i]; |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 945 | spin_unlock_irqrestore(&wl->wl_lock, flags); |
| 946 | |
| 947 | wl1271_handle_tx_low_watermark(wl); |
| 948 | } |
| 949 | |
Arik Nemtsov | 7dece1c | 2011-04-18 14:15:28 +0300 | [diff] [blame] | 950 | /* caller must hold wl->mutex and TX must be stopped */ |
Eliad Peller | d6a3cc2 | 2011-10-10 10:12:51 +0200 | [diff] [blame] | 951 | void wl12xx_tx_reset_wlvif(struct wl1271 *wl, struct wl12xx_vif *wlvif) |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 952 | { |
Eliad Peller | d6a3cc2 | 2011-10-10 10:12:51 +0200 | [diff] [blame] | 953 | int i; |
| 954 | |
| 955 | /* TX failure */ |
| 956 | for_each_set_bit(i, wlvif->links_map, WL12XX_MAX_LINKS) { |
| 957 | if (wlvif->bss_type == BSS_TYPE_AP_BSS) |
| 958 | wl1271_free_sta(wl, wlvif, i); |
| 959 | else |
| 960 | wlvif->sta.ba_rx_bitmap = 0; |
| 961 | |
| 962 | wl1271_tx_reset_link_queues(wl, i); |
| 963 | wl->links[i].allocated_pkts = 0; |
| 964 | wl->links[i].prev_freed_pkts = 0; |
| 965 | } |
| 966 | wlvif->last_tx_hlid = 0; |
| 967 | |
| 968 | } |
| 969 | /* caller must hold wl->mutex and TX must be stopped */ |
| 970 | void wl12xx_tx_reset(struct wl1271 *wl, bool reset_tx_queues) |
| 971 | { |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 972 | int i; |
| 973 | struct sk_buff *skb; |
Arik Nemtsov | 1d36cd8 | 2011-02-23 00:22:27 +0200 | [diff] [blame] | 974 | struct ieee80211_tx_info *info; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 975 | |
Arik Nemtsov | f1acea9 | 2011-08-25 12:43:17 +0300 | [diff] [blame] | 976 | for (i = 0; i < NUM_TX_QUEUES; i++) |
| 977 | wl->tx_queue_count[i] = 0; |
| 978 | |
Arik Nemtsov | 708bb3c | 2011-06-24 13:03:37 +0300 | [diff] [blame] | 979 | wl->stopped_queues_map = 0; |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 980 | |
Ido Yariv | 2fe33e8 | 2010-10-12 14:49:12 +0200 | [diff] [blame] | 981 | /* |
| 982 | * Make sure the driver is at a consistent state, in case this |
| 983 | * function is called from a context other than interface removal. |
Arik Nemtsov | 7dece1c | 2011-04-18 14:15:28 +0300 | [diff] [blame] | 984 | * This call will always wake the TX queues. |
Ido Yariv | 2fe33e8 | 2010-10-12 14:49:12 +0200 | [diff] [blame] | 985 | */ |
Arik Nemtsov | 7dece1c | 2011-04-18 14:15:28 +0300 | [diff] [blame] | 986 | if (reset_tx_queues) |
| 987 | wl1271_handle_tx_low_watermark(wl); |
Ido Yariv | 2fe33e8 | 2010-10-12 14:49:12 +0200 | [diff] [blame] | 988 | |
Ido Yariv | 50e9f74 | 2011-02-28 00:16:13 +0200 | [diff] [blame] | 989 | for (i = 0; i < ACX_TX_DESCRIPTORS; i++) { |
| 990 | if (wl->tx_frames[i] == NULL) |
| 991 | continue; |
| 992 | |
| 993 | skb = wl->tx_frames[i]; |
| 994 | wl1271_free_tx_id(wl, i); |
| 995 | wl1271_debug(DEBUG_TX, "freeing skb 0x%p", skb); |
| 996 | |
Ido Yariv | 990f5de | 2011-03-31 10:06:59 +0200 | [diff] [blame] | 997 | if (!wl12xx_is_dummy_packet(wl, skb)) { |
Shahar Levi | ae47c45 | 2011-03-06 16:32:14 +0200 | [diff] [blame] | 998 | /* |
| 999 | * Remove private headers before passing the skb to |
| 1000 | * mac80211 |
| 1001 | */ |
| 1002 | info = IEEE80211_SKB_CB(skb); |
| 1003 | skb_pull(skb, sizeof(struct wl1271_tx_hw_descr)); |
| 1004 | if (info->control.hw_key && |
| 1005 | info->control.hw_key->cipher == |
| 1006 | WLAN_CIPHER_SUITE_TKIP) { |
| 1007 | int hdrlen = ieee80211_get_hdrlen_from_skb(skb); |
| 1008 | memmove(skb->data + WL1271_TKIP_IV_SPACE, |
| 1009 | skb->data, hdrlen); |
| 1010 | skb_pull(skb, WL1271_TKIP_IV_SPACE); |
| 1011 | } |
| 1012 | |
| 1013 | info->status.rates[0].idx = -1; |
| 1014 | info->status.rates[0].count = 0; |
| 1015 | |
Eliad Peller | c27d3ac | 2011-06-07 10:40:39 +0300 | [diff] [blame] | 1016 | ieee80211_tx_status_ni(wl->hw, skb); |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 1017 | } |
Ido Yariv | 50e9f74 | 2011-02-28 00:16:13 +0200 | [diff] [blame] | 1018 | } |
Juuso Oikarinen | 781608c | 2010-05-24 11:18:17 +0300 | [diff] [blame] | 1019 | } |
| 1020 | |
| 1021 | #define WL1271_TX_FLUSH_TIMEOUT 500000 |
| 1022 | |
| 1023 | /* caller must *NOT* hold wl->mutex */ |
| 1024 | void wl1271_tx_flush(struct wl1271 *wl) |
| 1025 | { |
| 1026 | unsigned long timeout; |
| 1027 | timeout = jiffies + usecs_to_jiffies(WL1271_TX_FLUSH_TIMEOUT); |
| 1028 | |
| 1029 | while (!time_after(jiffies, timeout)) { |
| 1030 | mutex_lock(&wl->mutex); |
Arik Nemtsov | a8c0ddb | 2011-02-23 00:22:26 +0200 | [diff] [blame] | 1031 | wl1271_debug(DEBUG_TX, "flushing tx buffer: %d %d", |
Arik Nemtsov | f1a4638 | 2011-07-07 14:25:23 +0300 | [diff] [blame] | 1032 | wl->tx_frames_cnt, |
| 1033 | wl1271_tx_total_queue_count(wl)); |
| 1034 | if ((wl->tx_frames_cnt == 0) && |
| 1035 | (wl1271_tx_total_queue_count(wl) == 0)) { |
Juuso Oikarinen | 781608c | 2010-05-24 11:18:17 +0300 | [diff] [blame] | 1036 | mutex_unlock(&wl->mutex); |
| 1037 | return; |
| 1038 | } |
| 1039 | mutex_unlock(&wl->mutex); |
| 1040 | msleep(1); |
| 1041 | } |
| 1042 | |
| 1043 | wl1271_warning("Unable to flush all TX buffers, timed out."); |
Luciano Coelho | f5fc0f8 | 2009-08-06 16:25:28 +0300 | [diff] [blame] | 1044 | } |
Arik Nemtsov | e0fe371 | 2010-10-16 18:19:53 +0200 | [diff] [blame] | 1045 | |
Eliad Peller | af7fbb2 | 2011-09-19 13:51:42 +0300 | [diff] [blame] | 1046 | u32 wl1271_tx_min_rate_get(struct wl1271 *wl, u32 rate_set) |
Arik Nemtsov | e0fe371 | 2010-10-16 18:19:53 +0200 | [diff] [blame] | 1047 | { |
Eliad Peller | af7fbb2 | 2011-09-19 13:51:42 +0300 | [diff] [blame] | 1048 | if (WARN_ON(!rate_set)) |
| 1049 | return 0; |
Arik Nemtsov | e0fe371 | 2010-10-16 18:19:53 +0200 | [diff] [blame] | 1050 | |
Eliad Peller | af7fbb2 | 2011-09-19 13:51:42 +0300 | [diff] [blame] | 1051 | return BIT(__ffs(rate_set)); |
Arik Nemtsov | e0fe371 | 2010-10-16 18:19:53 +0200 | [diff] [blame] | 1052 | } |