blob: 057db6f86bee1b70ddc5dbbcbfa0b45503f2cfb3 [file] [log] [blame]
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001/*
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 Nemtsovc6c8a652010-10-16 20:27:53 +020026#include <linux/etherdevice.h>
Luciano Coelhof5fc0f82009-08-06 16:25:28 +030027
Shahar Levi00d20102010-11-08 11:20:10 +000028#include "wl12xx.h"
29#include "io.h"
30#include "reg.h"
31#include "ps.h"
32#include "tx.h"
Luciano Coelhof5fc0f82009-08-06 16:25:28 +030033
Arik Nemtsov7f179b42010-10-16 21:39:06 +020034static int wl1271_set_default_wep_key(struct wl1271 *wl, u8 id)
35{
36 int ret;
37 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
38
39 if (is_ap)
Eliad Pellerc690ec82011-08-14 13:17:07 +030040 ret = wl12xx_cmd_set_default_wep_key(wl, id,
41 WL1271_AP_BROADCAST_HLID);
Arik Nemtsov7f179b42010-10-16 21:39:06 +020042 else
Eliad Pellerc690ec82011-08-14 13:17:07 +030043 ret = wl12xx_cmd_set_default_wep_key(wl, id, wl->sta_hlid);
Arik Nemtsov7f179b42010-10-16 21:39:06 +020044
45 if (ret < 0)
46 return ret;
47
48 wl1271_debug(DEBUG_CRYPT, "default wep key idx: %d", (int)id);
49 return 0;
50}
51
Ido Yariv25eeb9e2010-10-12 16:20:06 +020052static int wl1271_alloc_tx_id(struct wl1271 *wl, struct sk_buff *skb)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +030053{
Ido Yariv25eeb9e2010-10-12 16:20:06 +020054 int id;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +030055
Ido Yariv25eeb9e2010-10-12 16:20:06 +020056 id = find_first_zero_bit(wl->tx_frames_map, ACX_TX_DESCRIPTORS);
57 if (id >= ACX_TX_DESCRIPTORS)
58 return -EBUSY;
59
60 __set_bit(id, wl->tx_frames_map);
61 wl->tx_frames[id] = skb;
62 wl->tx_frames_cnt++;
63 return id;
64}
65
66static void wl1271_free_tx_id(struct wl1271 *wl, int id)
67{
68 if (__test_and_clear_bit(id, wl->tx_frames_map)) {
Ido Yarivef2e3002011-04-18 16:44:11 +030069 if (unlikely(wl->tx_frames_cnt == ACX_TX_DESCRIPTORS))
70 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
71
Ido Yariv25eeb9e2010-10-12 16:20:06 +020072 wl->tx_frames[id] = NULL;
73 wl->tx_frames_cnt--;
74 }
Luciano Coelhof5fc0f82009-08-06 16:25:28 +030075}
76
Ohad Ben-Cohenc5745182011-03-30 16:35:59 +020077static int wl1271_tx_update_filters(struct wl1271 *wl,
78 struct sk_buff *skb)
79{
80 struct ieee80211_hdr *hdr;
Eliad Peller251c1772011-08-14 13:17:17 +030081 int ret;
Ohad Ben-Cohenc5745182011-03-30 16:35:59 +020082
83 hdr = (struct ieee80211_hdr *)(skb->data +
84 sizeof(struct wl1271_tx_hw_descr));
85
86 /*
87 * stop bssid-based filtering before transmitting authentication
88 * requests. this way the hw will never drop authentication
89 * responses coming from BSSIDs it isn't familiar with (e.g. on
90 * roaming)
91 */
92 if (!ieee80211_is_auth(hdr->frame_control))
93 return 0;
94
Eliad Peller251c1772011-08-14 13:17:17 +030095 if (wl->dev_hlid != WL12XX_INVALID_LINK_ID)
96 goto out;
97
98 wl1271_debug(DEBUG_CMD, "starting device role for roaming");
99 ret = wl12xx_cmd_role_start_dev(wl);
100 if (ret < 0)
101 goto out;
102
103 ret = wl12xx_roc(wl, wl->dev_role_id);
104 if (ret < 0)
105 goto out;
106out:
Eliad Peller08c1d1c2011-08-14 13:17:04 +0300107 return 0;
Ohad Ben-Cohenc5745182011-03-30 16:35:59 +0200108}
109
Arik Nemtsov99a27752011-02-23 00:22:25 +0200110static void wl1271_tx_ap_update_inconnection_sta(struct wl1271 *wl,
111 struct sk_buff *skb)
112{
113 struct ieee80211_hdr *hdr;
114
115 /*
116 * add the station to the known list before transmitting the
117 * authentication response. this way it won't get de-authed by FW
118 * when transmitting too soon.
119 */
120 hdr = (struct ieee80211_hdr *)(skb->data +
121 sizeof(struct wl1271_tx_hw_descr));
122 if (ieee80211_is_auth(hdr->frame_control))
123 wl1271_acx_set_inconnection_sta(wl, hdr->addr1);
124}
125
Eliad Pellerdbe25cb2011-08-14 13:17:03 +0300126#if 0
Arik Nemtsovb622d992011-02-23 00:22:31 +0200127static void wl1271_tx_regulate_link(struct wl1271 *wl, u8 hlid)
128{
129 bool fw_ps;
130 u8 tx_blks;
131
132 /* only regulate station links */
133 if (hlid < WL1271_AP_STA_HLID_START)
134 return;
135
136 fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
137 tx_blks = wl->links[hlid].allocated_blks;
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.
142 */
143 if (fw_ps && tx_blks >= WL1271_PS_STA_MAX_BLOCKS)
144 wl1271_ps_link_start(wl, hlid, true);
145}
Eliad Pellerdbe25cb2011-08-14 13:17:03 +0300146#endif
Arik Nemtsovb622d992011-02-23 00:22:31 +0200147
Eliad Pellerf4df1bd2011-08-14 13:17:15 +0300148static bool wl12xx_is_dummy_packet(struct wl1271 *wl, struct sk_buff *skb)
149{
150 return wl->dummy_packet == skb;
151}
152
153u8 wl12xx_tx_get_hlid_ap(struct wl1271 *wl, struct sk_buff *skb)
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200154{
155 struct ieee80211_tx_info *control = IEEE80211_SKB_CB(skb);
156
157 if (control->control.sta) {
158 struct wl1271_station *wl_sta;
159
160 wl_sta = (struct wl1271_station *)
161 control->control.sta->drv_priv;
162 return wl_sta->hlid;
163 } else {
164 struct ieee80211_hdr *hdr;
165
Eliad Pellerf4df1bd2011-08-14 13:17:15 +0300166 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags))
167 return wl->system_hlid;
168
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200169 hdr = (struct ieee80211_hdr *)skb->data;
170 if (ieee80211_is_mgmt(hdr->frame_control))
171 return WL1271_AP_GLOBAL_HLID;
172 else
173 return WL1271_AP_BROADCAST_HLID;
174 }
175}
176
Eliad Pellerf4df1bd2011-08-14 13:17:15 +0300177static u8 wl1271_tx_get_hlid(struct wl1271 *wl, struct sk_buff *skb)
178{
179 if (wl12xx_is_dummy_packet(wl, skb))
180 return wl->system_hlid;
181
182 if (wl->bss_type == BSS_TYPE_AP_BSS)
183 return wl12xx_tx_get_hlid_ap(wl, skb);
184
185 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
186 return wl->sta_hlid;
187 else
188 return wl->dev_hlid;
189}
190
Ido Yariv0da13da2011-03-31 10:06:58 +0200191static unsigned int wl12xx_calc_packet_alignment(struct wl1271 *wl,
192 unsigned int packet_length)
193{
194 if (wl->quirks & WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT)
195 return ALIGN(packet_length, WL12XX_BUS_BLOCK_SIZE);
196 else
197 return ALIGN(packet_length, WL1271_TX_ALIGN_TO);
198}
199
Ido Yariva19606b2010-09-30 13:28:28 +0200200static int wl1271_tx_allocate(struct wl1271 *wl, struct sk_buff *skb, u32 extra,
Arik Nemtsov09039f42011-02-23 00:22:30 +0200201 u32 buf_offset, u8 hlid)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300202{
203 struct wl1271_tx_hw_descr *desc;
204 u32 total_len = skb->len + sizeof(struct wl1271_tx_hw_descr) + extra;
Shahar Levi48a61472011-03-06 16:32:08 +0200205 u32 len;
Juuso Oikarinen5c9417f2010-02-22 08:38:39 +0200206 u32 total_blocks;
Arik Nemtsov7bb5d6c2011-08-14 13:17:00 +0300207 int id, ret = -EBUSY;
Luciano Coelhoe7ddf542011-03-10 15:24:57 +0200208
Arik Nemtsov29207432011-08-14 13:17:02 +0300209 /* we use 1 spare block */
210 u32 spare_blocks = 1;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300211
Ido Yariva19606b2010-09-30 13:28:28 +0200212 if (buf_offset + total_len > WL1271_AGGR_BUFFER_SIZE)
Ido Yariv6c6e6692010-10-12 14:49:09 +0200213 return -EAGAIN;
Ido Yariva19606b2010-09-30 13:28:28 +0200214
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300215 /* allocate free identifier for the packet */
Ido Yariv25eeb9e2010-10-12 16:20:06 +0200216 id = wl1271_alloc_tx_id(wl, skb);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300217 if (id < 0)
218 return id;
219
220 /* approximate the number of blocks required for this packet
221 in the firmware */
Ido Yariv0da13da2011-03-31 10:06:58 +0200222 len = wl12xx_calc_packet_alignment(wl, total_len);
Shahar Levi48a61472011-03-06 16:32:08 +0200223
224 total_blocks = (len + TX_HW_BLOCK_SIZE - 1) / TX_HW_BLOCK_SIZE +
Luciano Coelhoe7ddf542011-03-10 15:24:57 +0200225 spare_blocks;
Shahar Levi48a61472011-03-06 16:32:08 +0200226
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300227 if (total_blocks <= wl->tx_blocks_available) {
228 desc = (struct wl1271_tx_hw_descr *)skb_push(
229 skb, total_len - skb->len);
230
Shahar Leviae77ecc2011-03-06 16:32:13 +0200231 /* HW descriptor fields change between wl127x and wl128x */
232 if (wl->chip.id == CHIP_ID_1283_PG20) {
233 desc->wl128x_mem.total_mem_blocks = total_blocks;
234 } else {
Luciano Coelhoe7ddf542011-03-10 15:24:57 +0200235 desc->wl127x_mem.extra_blocks = spare_blocks;
Shahar Leviae77ecc2011-03-06 16:32:13 +0200236 desc->wl127x_mem.total_mem_blocks = total_blocks;
237 }
238
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300239 desc->id = id;
240
241 wl->tx_blocks_available -= total_blocks;
Arik Nemtsov7bb5d6c2011-08-14 13:17:00 +0300242 wl->tx_allocated_blocks += total_blocks;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300243
Arik Nemtsov09039f42011-02-23 00:22:30 +0200244 if (wl->bss_type == BSS_TYPE_AP_BSS)
245 wl->links[hlid].allocated_blks += total_blocks;
246
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300247 ret = 0;
248
249 wl1271_debug(DEBUG_TX,
250 "tx_allocate: size: %d, blocks: %d, id: %d",
251 total_len, total_blocks, id);
Juuso Oikarinen781608c2010-05-24 11:18:17 +0300252 } else {
Ido Yariv25eeb9e2010-10-12 16:20:06 +0200253 wl1271_free_tx_id(wl, id);
Juuso Oikarinen781608c2010-05-24 11:18:17 +0300254 }
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300255
256 return ret;
257}
258
Ido Yariva19606b2010-09-30 13:28:28 +0200259static void wl1271_tx_fill_hdr(struct wl1271 *wl, struct sk_buff *skb,
Arik Nemtsov09039f42011-02-23 00:22:30 +0200260 u32 extra, struct ieee80211_tx_info *control,
261 u8 hlid)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300262{
Juuso Oikarinenac5e1e32010-02-22 08:38:38 +0200263 struct timespec ts;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300264 struct wl1271_tx_hw_descr *desc;
Shahar Levi48a61472011-03-06 16:32:08 +0200265 int aligned_len, ac, rate_idx;
Juuso Oikarinenac5e1e32010-02-22 08:38:38 +0200266 s64 hosttime;
Luciano Coelhod0f63b22009-10-15 10:33:29 +0300267 u16 tx_attr;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300268
269 desc = (struct wl1271_tx_hw_descr *) skb->data;
270
Juuso Oikarinen1e2b7972009-10-08 21:56:20 +0300271 /* relocate space for security header */
272 if (extra) {
273 void *framestart = skb->data + sizeof(*desc);
274 u16 fc = *(u16 *)(framestart + extra);
Luciano Coelhod0f63b22009-10-15 10:33:29 +0300275 int hdrlen = ieee80211_hdrlen(cpu_to_le16(fc));
Juuso Oikarinen1e2b7972009-10-08 21:56:20 +0300276 memmove(framestart, framestart + extra, hdrlen);
277 }
278
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300279 /* configure packet life time */
Juuso Oikarinenac5e1e32010-02-22 08:38:38 +0200280 getnstimeofday(&ts);
281 hosttime = (timespec_to_ns(&ts) >> 10);
282 desc->start_time = cpu_to_le32(hosttime - wl->time_offset);
Arik Nemtsovc6c8a652010-10-16 20:27:53 +0200283
284 if (wl->bss_type != BSS_TYPE_AP_BSS)
285 desc->life_time = cpu_to_le16(TX_HW_MGMT_PKT_LIFETIME_TU);
286 else
287 desc->life_time = cpu_to_le16(TX_HW_AP_MODE_PKT_LIFETIME_TU);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300288
Eliad Pellerdb674d22011-03-16 23:03:54 +0200289 /* queue */
Kalle Valoc6999d82010-02-18 13:25:41 +0200290 ac = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
Eliad Pellerdb674d22011-03-16 23:03:54 +0200291 desc->tid = skb->priority;
Arik Nemtsovc6c8a652010-10-16 20:27:53 +0200292
Ido Yariv990f5de2011-03-31 10:06:59 +0200293 if (wl12xx_is_dummy_packet(wl, skb)) {
Shahar Leviae47c452011-03-06 16:32:14 +0200294 /*
295 * FW expects the dummy packet to have an invalid session id -
296 * any session id that is different than the one set in the join
297 */
298 tx_attr = ((~wl->session_counter) <<
299 TX_HW_ATTR_OFST_SESSION_COUNTER) &
300 TX_HW_ATTR_SESSION_COUNTER;
301
302 tx_attr |= TX_HW_ATTR_TX_DUMMY_REQ;
Shahar Leviae47c452011-03-06 16:32:14 +0200303 } else {
304 /* configure the tx attributes */
305 tx_attr =
306 wl->session_counter << TX_HW_ATTR_OFST_SESSION_COUNTER;
307 }
308
Eliad Peller79b122d2011-08-14 13:17:11 +0300309 desc->hlid = hlid;
Arik Nemtsovc6c8a652010-10-16 20:27:53 +0200310
Eliad Peller79b122d2011-08-14 13:17:11 +0300311 if (wl->bss_type != BSS_TYPE_AP_BSS) {
Arik Nemtsovc6c8a652010-10-16 20:27:53 +0200312 /* if the packets are destined for AP (have a STA entry)
313 send them with AP rate policies, otherwise use default
314 basic rates */
315 if (control->control.sta)
316 rate_idx = ACX_TX_AP_FULL_RATE;
317 else
318 rate_idx = ACX_TX_BASIC_RATE;
319 } else {
Arik Nemtsov09039f42011-02-23 00:22:30 +0200320 switch (hlid) {
321 case WL1271_AP_GLOBAL_HLID:
322 rate_idx = ACX_TX_AP_MODE_MGMT_RATE;
323 break;
324 case WL1271_AP_BROADCAST_HLID:
325 rate_idx = ACX_TX_AP_MODE_BCST_RATE;
326 break;
327 default:
Arik Nemtsovc6c8a652010-10-16 20:27:53 +0200328 rate_idx = ac;
Arik Nemtsov09039f42011-02-23 00:22:30 +0200329 break;
Arik Nemtsovc6c8a652010-10-16 20:27:53 +0200330 }
331 }
332
333 tx_attr |= rate_idx << TX_HW_ATTR_OFST_RATE_POLICY;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300334 desc->reserved = 0;
335
Ido Yariv0da13da2011-03-31 10:06:58 +0200336 aligned_len = wl12xx_calc_packet_alignment(wl, skb->len);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300337
Ido Yariv0da13da2011-03-31 10:06:58 +0200338 if (wl->chip.id == CHIP_ID_1283_PG20) {
Shahar Levi48a61472011-03-06 16:32:08 +0200339 desc->wl128x_mem.extra_bytes = aligned_len - skb->len;
340 desc->length = cpu_to_le16(aligned_len >> 2);
Shahar Leviae77ecc2011-03-06 16:32:13 +0200341
342 wl1271_debug(DEBUG_TX, "tx_fill_hdr: hlid: %d "
343 "tx_attr: 0x%x len: %d life: %d mem: %d",
344 desc->hlid, tx_attr,
345 le16_to_cpu(desc->length),
346 le16_to_cpu(desc->life_time),
347 desc->wl128x_mem.total_mem_blocks);
Shahar Levi48a61472011-03-06 16:32:08 +0200348 } else {
349 int pad;
350
Ido Yariv0da13da2011-03-31 10:06:58 +0200351 /* Store the aligned length in terms of words */
Shahar Levi48a61472011-03-06 16:32:08 +0200352 desc->length = cpu_to_le16(aligned_len >> 2);
353
354 /* calculate number of padding bytes */
355 pad = aligned_len - skb->len;
356 tx_attr |= pad << TX_HW_ATTR_OFST_LAST_WORD_PAD;
357
Shahar Leviae77ecc2011-03-06 16:32:13 +0200358 wl1271_debug(DEBUG_TX, "tx_fill_hdr: pad: %d hlid: %d "
359 "tx_attr: 0x%x len: %d life: %d mem: %d", pad,
360 desc->hlid, tx_attr,
361 le16_to_cpu(desc->length),
362 le16_to_cpu(desc->life_time),
363 desc->wl127x_mem.total_mem_blocks);
Shahar Levi48a61472011-03-06 16:32:08 +0200364 }
Luciano Coelhod0f63b22009-10-15 10:33:29 +0300365
366 desc->tx_attr = cpu_to_le16(tx_attr);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300367}
368
369/* caller must hold wl->mutex */
Ido Yariva19606b2010-09-30 13:28:28 +0200370static int wl1271_prepare_tx_frame(struct wl1271 *wl, struct sk_buff *skb,
371 u32 buf_offset)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300372{
373 struct ieee80211_tx_info *info;
374 u32 extra = 0;
375 int ret = 0;
Ido Yariva19606b2010-09-30 13:28:28 +0200376 u32 total_len;
Arik Nemtsov09039f42011-02-23 00:22:30 +0200377 u8 hlid;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300378
379 if (!skb)
380 return -EINVAL;
381
382 info = IEEE80211_SKB_CB(skb);
383
384 if (info->control.hw_key &&
Johannes Berg97359d12010-08-10 09:46:38 +0200385 info->control.hw_key->cipher == WLAN_CIPHER_SUITE_TKIP)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300386 extra = WL1271_TKIP_IV_SPACE;
387
388 if (info->control.hw_key) {
Arik Nemtsov7f179b42010-10-16 21:39:06 +0200389 bool is_wep;
390 u8 idx = info->control.hw_key->hw_key_idx;
391 u32 cipher = info->control.hw_key->cipher;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300392
Arik Nemtsov7f179b42010-10-16 21:39:06 +0200393 is_wep = (cipher == WLAN_CIPHER_SUITE_WEP40) ||
394 (cipher == WLAN_CIPHER_SUITE_WEP104);
395
396 if (unlikely(is_wep && wl->default_key != idx)) {
397 ret = wl1271_set_default_wep_key(wl, idx);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300398 if (ret < 0)
399 return ret;
Juuso Oikarinenee444cf2010-02-18 13:25:50 +0200400 wl->default_key = idx;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300401 }
402 }
403
Eliad Pellerf4df1bd2011-08-14 13:17:15 +0300404 hlid = wl1271_tx_get_hlid(wl, skb);
Eliad Peller79b122d2011-08-14 13:17:11 +0300405 if (hlid == WL12XX_INVALID_LINK_ID) {
406 wl1271_error("invalid hlid. dropping skb 0x%p", skb);
407 return -EINVAL;
408 }
Arik Nemtsov09039f42011-02-23 00:22:30 +0200409
410 ret = wl1271_tx_allocate(wl, skb, extra, buf_offset, hlid);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300411 if (ret < 0)
412 return ret;
413
Arik Nemtsovfae2fd72011-06-26 10:36:04 +0300414 wl1271_tx_fill_hdr(wl, skb, extra, info, hlid);
415
Arik Nemtsovb622d992011-02-23 00:22:31 +0200416 if (wl->bss_type == BSS_TYPE_AP_BSS) {
Arik Nemtsov99a27752011-02-23 00:22:25 +0200417 wl1271_tx_ap_update_inconnection_sta(wl, skb);
Eliad Pellerdbe25cb2011-08-14 13:17:03 +0300418#if 0
Arik Nemtsovb622d992011-02-23 00:22:31 +0200419 wl1271_tx_regulate_link(wl, hlid);
Eliad Pellerdbe25cb2011-08-14 13:17:03 +0300420#endif
Ohad Ben-Cohenc5745182011-03-30 16:35:59 +0200421 } else {
422 wl1271_tx_update_filters(wl, skb);
Arik Nemtsovb622d992011-02-23 00:22:31 +0200423 }
Arik Nemtsov99a27752011-02-23 00:22:25 +0200424
Ido Yariva19606b2010-09-30 13:28:28 +0200425 /*
Shahar Levi48a61472011-03-06 16:32:08 +0200426 * The length of each packet is stored in terms of
427 * words. Thus, we must pad the skb data to make sure its
428 * length is aligned. The number of padding bytes is computed
429 * and set in wl1271_tx_fill_hdr.
430 * In special cases, we want to align to a specific block size
431 * (eg. for wl128x with SDIO we align to 256).
Ido Yariva19606b2010-09-30 13:28:28 +0200432 */
Ido Yariv0da13da2011-03-31 10:06:58 +0200433 total_len = wl12xx_calc_packet_alignment(wl, skb->len);
Shahar Levi48a61472011-03-06 16:32:08 +0200434
Ido Yariva19606b2010-09-30 13:28:28 +0200435 memcpy(wl->aggr_buf + buf_offset, skb->data, skb->len);
436 memset(wl->aggr_buf + buf_offset + skb->len, 0, total_len - skb->len);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300437
Ido Yariv990f5de2011-03-31 10:06:59 +0200438 /* Revert side effects in the dummy packet skb, so it can be reused */
439 if (wl12xx_is_dummy_packet(wl, skb))
440 skb_pull(skb, sizeof(struct wl1271_tx_hw_descr));
441
Ido Yariva19606b2010-09-30 13:28:28 +0200442 return total_len;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300443}
444
Juuso Oikarinenebba60c2010-04-01 11:38:20 +0300445u32 wl1271_tx_enabled_rates_get(struct wl1271 *wl, u32 rate_set)
Juuso Oikarinen830fb672009-12-11 15:41:06 +0200446{
447 struct ieee80211_supported_band *band;
448 u32 enabled_rates = 0;
449 int bit;
450
451 band = wl->hw->wiphy->bands[wl->band];
452 for (bit = 0; bit < band->n_bitrates; bit++) {
453 if (rate_set & 0x1)
454 enabled_rates |= band->bitrates[bit].hw_value;
455 rate_set >>= 1;
456 }
457
Shahar Levi00d20102010-11-08 11:20:10 +0000458#ifdef CONFIG_WL12XX_HT
Shahar Levi18357852010-10-13 16:09:41 +0200459 /* MCS rates indication are on bits 16 - 23 */
460 rate_set >>= HW_HT_RATES_OFFSET - band->n_bitrates;
461
462 for (bit = 0; bit < 8; bit++) {
463 if (rate_set & 0x1)
464 enabled_rates |= (CONF_HW_BIT_RATE_MCS_0 << bit);
465 rate_set >>= 1;
466 }
467#endif
468
Juuso Oikarinen830fb672009-12-11 15:41:06 +0200469 return enabled_rates;
470}
471
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200472void wl1271_handle_tx_low_watermark(struct wl1271 *wl)
Ido Yariv2fe33e82010-10-12 14:49:12 +0200473{
474 unsigned long flags;
Arik Nemtsov708bb3c2011-06-24 13:03:37 +0300475 int i;
Ido Yariv2fe33e82010-10-12 14:49:12 +0200476
Arik Nemtsov708bb3c2011-06-24 13:03:37 +0300477 for (i = 0; i < NUM_TX_QUEUES; i++) {
478 if (test_bit(i, &wl->stopped_queues_map) &&
Arik Nemtsovf1a46382011-07-07 14:25:23 +0300479 wl->tx_queue_count[i] <= WL1271_TX_QUEUE_LOW_WATERMARK) {
Arik Nemtsov708bb3c2011-06-24 13:03:37 +0300480 /* firmware buffer has space, restart queues */
481 spin_lock_irqsave(&wl->wl_lock, flags);
482 ieee80211_wake_queue(wl->hw,
483 wl1271_tx_get_mac80211_queue(i));
484 clear_bit(i, &wl->stopped_queues_map);
485 spin_unlock_irqrestore(&wl->wl_lock, flags);
486 }
Ido Yariv2fe33e82010-10-12 14:49:12 +0200487 }
488}
489
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200490static struct sk_buff *wl1271_sta_skb_dequeue(struct wl1271 *wl)
Juuso Oikarinen6742f552010-12-13 09:52:37 +0200491{
492 struct sk_buff *skb = NULL;
493 unsigned long flags;
494
Arik Nemtsov7bb5d6c2011-08-14 13:17:00 +0300495 skb = skb_dequeue(&wl->tx_queue[CONF_TX_AC_VO]);
496 if (skb)
Juuso Oikarinen6742f552010-12-13 09:52:37 +0200497 goto out;
Arik Nemtsov7bb5d6c2011-08-14 13:17:00 +0300498 skb = skb_dequeue(&wl->tx_queue[CONF_TX_AC_VI]);
499 if (skb)
500 goto out;
501 skb = skb_dequeue(&wl->tx_queue[CONF_TX_AC_BE]);
502 if (skb)
503 goto out;
504 skb = skb_dequeue(&wl->tx_queue[CONF_TX_AC_BK]);
Juuso Oikarinen6742f552010-12-13 09:52:37 +0200505
506out:
507 if (skb) {
Arik Nemtsovf1a46382011-07-07 14:25:23 +0300508 int q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
Juuso Oikarinen6742f552010-12-13 09:52:37 +0200509 spin_lock_irqsave(&wl->wl_lock, flags);
Arik Nemtsovf1a46382011-07-07 14:25:23 +0300510 wl->tx_queue_count[q]--;
Juuso Oikarinen6742f552010-12-13 09:52:37 +0200511 spin_unlock_irqrestore(&wl->wl_lock, flags);
512 }
513
514 return skb;
515}
516
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200517static struct sk_buff *wl1271_ap_skb_dequeue(struct wl1271 *wl)
518{
519 struct sk_buff *skb = NULL;
520 unsigned long flags;
521 int i, h, start_hlid;
522
523 /* start from the link after the last one */
524 start_hlid = (wl->last_tx_hlid + 1) % AP_MAX_LINKS;
525
526 /* dequeue according to AC, round robin on each link */
527 for (i = 0; i < AP_MAX_LINKS; i++) {
528 h = (start_hlid + i) % AP_MAX_LINKS;
529
Arik Nemtsov7bb5d6c2011-08-14 13:17:00 +0300530 skb = skb_dequeue(&wl->links[h].tx_queue[CONF_TX_AC_VO]);
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200531 if (skb)
Arik Nemtsov7bb5d6c2011-08-14 13:17:00 +0300532 goto out;
533 skb = skb_dequeue(&wl->links[h].tx_queue[CONF_TX_AC_VI]);
534 if (skb)
535 goto out;
536 skb = skb_dequeue(&wl->links[h].tx_queue[CONF_TX_AC_BE]);
537 if (skb)
538 goto out;
539 skb = skb_dequeue(&wl->links[h].tx_queue[CONF_TX_AC_BK]);
540 if (skb)
541 goto out;
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200542 }
543
Arik Nemtsov7bb5d6c2011-08-14 13:17:00 +0300544out:
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200545 if (skb) {
Arik Nemtsovf1a46382011-07-07 14:25:23 +0300546 int q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200547 wl->last_tx_hlid = h;
548 spin_lock_irqsave(&wl->wl_lock, flags);
Arik Nemtsovf1a46382011-07-07 14:25:23 +0300549 wl->tx_queue_count[q]--;
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200550 spin_unlock_irqrestore(&wl->wl_lock, flags);
551 } else {
552 wl->last_tx_hlid = 0;
553 }
554
555 return skb;
556}
557
558static struct sk_buff *wl1271_skb_dequeue(struct wl1271 *wl)
559{
Ido Yariv990f5de2011-03-31 10:06:59 +0200560 unsigned long flags;
561 struct sk_buff *skb = NULL;
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200562
Ido Yariv990f5de2011-03-31 10:06:59 +0200563 if (wl->bss_type == BSS_TYPE_AP_BSS)
564 skb = wl1271_ap_skb_dequeue(wl);
565 else
566 skb = wl1271_sta_skb_dequeue(wl);
567
568 if (!skb &&
569 test_and_clear_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags)) {
Arik Nemtsovf1a46382011-07-07 14:25:23 +0300570 int q;
571
Ido Yariv990f5de2011-03-31 10:06:59 +0200572 skb = wl->dummy_packet;
Arik Nemtsovf1a46382011-07-07 14:25:23 +0300573 q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
Ido Yariv990f5de2011-03-31 10:06:59 +0200574 spin_lock_irqsave(&wl->wl_lock, flags);
Arik Nemtsovf1a46382011-07-07 14:25:23 +0300575 wl->tx_queue_count[q]--;
Ido Yariv990f5de2011-03-31 10:06:59 +0200576 spin_unlock_irqrestore(&wl->wl_lock, flags);
577 }
578
579 return skb;
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200580}
581
Juuso Oikarinen6742f552010-12-13 09:52:37 +0200582static void wl1271_skb_queue_head(struct wl1271 *wl, struct sk_buff *skb)
583{
584 unsigned long flags;
585 int q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
586
Ido Yariv990f5de2011-03-31 10:06:59 +0200587 if (wl12xx_is_dummy_packet(wl, skb)) {
588 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
589 } else if (wl->bss_type == BSS_TYPE_AP_BSS) {
Eliad Pellerf4df1bd2011-08-14 13:17:15 +0300590 u8 hlid = wl1271_tx_get_hlid(wl, skb);
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200591 skb_queue_head(&wl->links[hlid].tx_queue[q], skb);
592
593 /* make sure we dequeue the same packet next time */
594 wl->last_tx_hlid = (hlid + AP_MAX_LINKS - 1) % AP_MAX_LINKS;
595 } else {
596 skb_queue_head(&wl->tx_queue[q], skb);
597 }
598
Juuso Oikarinen6742f552010-12-13 09:52:37 +0200599 spin_lock_irqsave(&wl->wl_lock, flags);
Arik Nemtsovf1a46382011-07-07 14:25:23 +0300600 wl->tx_queue_count[q]++;
Juuso Oikarinen6742f552010-12-13 09:52:37 +0200601 spin_unlock_irqrestore(&wl->wl_lock, flags);
602}
603
Eliad Peller77ddaa12011-05-15 11:10:29 +0300604static bool wl1271_tx_is_data_present(struct sk_buff *skb)
605{
606 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)(skb->data);
607
608 return ieee80211_is_data_present(hdr->frame_control);
609}
610
Ido Yariva5225502010-10-12 14:49:10 +0200611void wl1271_tx_work_locked(struct wl1271 *wl)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300612{
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300613 struct sk_buff *skb;
Ido Yariv6c6e6692010-10-12 14:49:09 +0200614 u32 buf_offset = 0;
615 bool sent_packets = false;
Eliad Peller77ddaa12011-05-15 11:10:29 +0300616 bool had_data = false;
617 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300618 int ret;
619
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300620 if (unlikely(wl->state == WL1271_STATE_OFF))
Eliad Pellerc1b193e2011-03-23 22:22:15 +0200621 return;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300622
Juuso Oikarinen6742f552010-12-13 09:52:37 +0200623 while ((skb = wl1271_skb_dequeue(wl))) {
Eliad Peller77ddaa12011-05-15 11:10:29 +0300624 if (wl1271_tx_is_data_present(skb))
625 had_data = true;
626
Ido Yariva19606b2010-09-30 13:28:28 +0200627 ret = wl1271_prepare_tx_frame(wl, skb, buf_offset);
Ido Yariv6c6e6692010-10-12 14:49:09 +0200628 if (ret == -EAGAIN) {
Ido Yariva19606b2010-09-30 13:28:28 +0200629 /*
Ido Yariv6c6e6692010-10-12 14:49:09 +0200630 * Aggregation buffer is full.
631 * Flush buffer and try again.
632 */
Juuso Oikarinen6742f552010-12-13 09:52:37 +0200633 wl1271_skb_queue_head(wl, skb);
Ido Yariv6c6e6692010-10-12 14:49:09 +0200634 wl1271_write(wl, WL1271_SLV_MEM_DATA, wl->aggr_buf,
Juuso Oikarinen6742f552010-12-13 09:52:37 +0200635 buf_offset, true);
Ido Yariv6c6e6692010-10-12 14:49:09 +0200636 sent_packets = true;
637 buf_offset = 0;
638 continue;
639 } else if (ret == -EBUSY) {
640 /*
641 * Firmware buffer is full.
Ido Yariva19606b2010-09-30 13:28:28 +0200642 * Queue back last skb, and stop aggregating.
643 */
Juuso Oikarinen6742f552010-12-13 09:52:37 +0200644 wl1271_skb_queue_head(wl, skb);
Ido Yariva5225502010-10-12 14:49:10 +0200645 /* No work left, avoid scheduling redundant tx work */
646 set_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
Juuso Oikarinenffb591c2010-02-22 08:38:31 +0200647 goto out_ack;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300648 } else if (ret < 0) {
649 dev_kfree_skb(skb);
Juuso Oikarinenffb591c2010-02-22 08:38:31 +0200650 goto out_ack;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300651 }
Ido Yariva19606b2010-09-30 13:28:28 +0200652 buf_offset += ret;
653 wl->tx_packets_count++;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300654 }
655
Juuso Oikarinenffb591c2010-02-22 08:38:31 +0200656out_ack:
Ido Yariva19606b2010-09-30 13:28:28 +0200657 if (buf_offset) {
658 wl1271_write(wl, WL1271_SLV_MEM_DATA, wl->aggr_buf,
659 buf_offset, true);
Ido Yariv6c6e6692010-10-12 14:49:09 +0200660 sent_packets = true;
661 }
662 if (sent_packets) {
Ido Yariv606ea9f2011-03-01 15:14:39 +0200663 /*
664 * Interrupt the firmware with the new packets. This is only
665 * required for older hardware revisions
666 */
667 if (wl->quirks & WL12XX_QUIRK_END_OF_TRANSACTION)
668 wl1271_write32(wl, WL1271_HOST_WR_ACCESS,
669 wl->tx_packets_count);
670
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200671 wl1271_handle_tx_low_watermark(wl);
Ido Yariva19606b2010-09-30 13:28:28 +0200672 }
Eliad Peller77ddaa12011-05-15 11:10:29 +0300673 if (!is_ap && wl->conf.rx_streaming.interval && had_data &&
674 (wl->conf.rx_streaming.always ||
675 test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags))) {
676 u32 timeout = wl->conf.rx_streaming.duration;
677
678 /* enable rx streaming */
679 if (!test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags))
680 ieee80211_queue_work(wl->hw,
681 &wl->rx_streaming_enable_work);
682
683 mod_timer(&wl->rx_streaming_timer,
684 jiffies + msecs_to_jiffies(timeout));
685 }
Ido Yariva5225502010-10-12 14:49:10 +0200686}
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300687
Ido Yariva5225502010-10-12 14:49:10 +0200688void wl1271_tx_work(struct work_struct *work)
689{
690 struct wl1271 *wl = container_of(work, struct wl1271, tx_work);
Eliad Pellerc1b193e2011-03-23 22:22:15 +0200691 int ret;
Ido Yariva5225502010-10-12 14:49:10 +0200692
693 mutex_lock(&wl->mutex);
Eliad Pellerc1b193e2011-03-23 22:22:15 +0200694 ret = wl1271_ps_elp_wakeup(wl);
695 if (ret < 0)
696 goto out;
697
Ido Yariva5225502010-10-12 14:49:10 +0200698 wl1271_tx_work_locked(wl);
Eliad Pellerc1b193e2011-03-23 22:22:15 +0200699
Eliad Pellerc75bbcd2011-04-04 10:38:47 +0300700 wl1271_ps_elp_sleep(wl);
Eliad Pellerc1b193e2011-03-23 22:22:15 +0200701out:
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300702 mutex_unlock(&wl->mutex);
703}
704
705static void wl1271_tx_complete_packet(struct wl1271 *wl,
706 struct wl1271_tx_hw_res_descr *result)
707{
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300708 struct ieee80211_tx_info *info;
709 struct sk_buff *skb;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300710 int id = result->id;
Juuso Oikarinen31627dc2010-03-26 12:53:12 +0200711 int rate = -1;
712 u8 retries = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300713
714 /* check for id legality */
Juuso Oikarinenffb591c2010-02-22 08:38:31 +0200715 if (unlikely(id >= ACX_TX_DESCRIPTORS || wl->tx_frames[id] == NULL)) {
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300716 wl1271_warning("TX result illegal id: %d", id);
717 return;
718 }
719
720 skb = wl->tx_frames[id];
721 info = IEEE80211_SKB_CB(skb);
722
Ido Yariv990f5de2011-03-31 10:06:59 +0200723 if (wl12xx_is_dummy_packet(wl, skb)) {
Shahar Leviae47c452011-03-06 16:32:14 +0200724 wl1271_free_tx_id(wl, id);
725 return;
726 }
727
Juuso Oikarinen31627dc2010-03-26 12:53:12 +0200728 /* update the TX status info */
729 if (result->status == TX_SUCCESS) {
730 if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300731 info->flags |= IEEE80211_TX_STAT_ACK;
Teemu Paasikivi6a2de932010-10-14 11:00:04 +0200732 rate = wl1271_rate_to_idx(result->rate_class_index, wl->band);
Juuso Oikarinen31627dc2010-03-26 12:53:12 +0200733 retries = result->ack_failures;
734 } else if (result->status == TX_RETRY_EXCEEDED) {
735 wl->stats.excessive_retries++;
736 retries = result->ack_failures;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300737 }
738
Juuso Oikarinen31627dc2010-03-26 12:53:12 +0200739 info->status.rates[0].idx = rate;
740 info->status.rates[0].count = retries;
741 info->status.rates[0].flags = 0;
742 info->status.ack_signal = -1;
743
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300744 wl->stats.retry_count += result->ack_failures;
745
Oz Krakowskib992c682011-06-26 10:36:02 +0300746 /*
747 * update sequence number only when relevant, i.e. only in
748 * sessions of TKIP, AES and GEM (not in open or WEP sessions)
749 */
750 if (info->control.hw_key &&
751 (info->control.hw_key->cipher == WLAN_CIPHER_SUITE_TKIP ||
752 info->control.hw_key->cipher == WLAN_CIPHER_SUITE_CCMP ||
753 info->control.hw_key->cipher == WL1271_CIPHER_SUITE_GEM)) {
754 u8 fw_lsb = result->tx_security_sequence_number_lsb;
755 u8 cur_lsb = wl->tx_security_last_seq_lsb;
756
757 /*
758 * update security sequence number, taking care of potential
759 * wrap-around
760 */
761 wl->tx_security_seq += (fw_lsb - cur_lsb + 256) % 256;
762 wl->tx_security_last_seq_lsb = fw_lsb;
763 }
Juuso Oikarinenac4e4ce2009-10-08 21:56:19 +0300764
Juuso Oikarinen1e2b7972009-10-08 21:56:20 +0300765 /* remove private header from packet */
766 skb_pull(skb, sizeof(struct wl1271_tx_hw_descr));
767
768 /* remove TKIP header space if present */
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300769 if (info->control.hw_key &&
Johannes Berg97359d12010-08-10 09:46:38 +0200770 info->control.hw_key->cipher == WLAN_CIPHER_SUITE_TKIP) {
Juuso Oikarinen1e2b7972009-10-08 21:56:20 +0300771 int hdrlen = ieee80211_get_hdrlen_from_skb(skb);
772 memmove(skb->data + WL1271_TKIP_IV_SPACE, skb->data, hdrlen);
773 skb_pull(skb, WL1271_TKIP_IV_SPACE);
774 }
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300775
776 wl1271_debug(DEBUG_TX, "tx status id %u skb 0x%p failures %u rate 0x%x"
777 " status 0x%x",
778 result->id, skb, result->ack_failures,
779 result->rate_class_index, result->status);
780
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300781 /* return the packet to the stack */
Ido Yariva6208652011-03-01 15:14:41 +0200782 skb_queue_tail(&wl->deferred_tx_queue, skb);
Eliad Peller92ef8962011-06-07 12:50:46 +0300783 queue_work(wl->freezable_wq, &wl->netstack_work);
Ido Yariv25eeb9e2010-10-12 16:20:06 +0200784 wl1271_free_tx_id(wl, result->id);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300785}
786
787/* Called upon reception of a TX complete interrupt */
Juuso Oikarinenffb591c2010-02-22 08:38:31 +0200788void wl1271_tx_complete(struct wl1271 *wl)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300789{
790 struct wl1271_acx_mem_map *memmap =
791 (struct wl1271_acx_mem_map *)wl->target_mem_map;
Juuso Oikarinenffb591c2010-02-22 08:38:31 +0200792 u32 count, fw_counter;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300793 u32 i;
794
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300795 /* read the tx results from the chipset */
Teemu Paasikivi7b048c52010-02-18 13:25:55 +0200796 wl1271_read(wl, le32_to_cpu(memmap->tx_result),
797 wl->tx_res_if, sizeof(*wl->tx_res_if), false);
Juuso Oikarinenffb591c2010-02-22 08:38:31 +0200798 fw_counter = le32_to_cpu(wl->tx_res_if->tx_result_fw_counter);
799
800 /* write host counter to chipset (to ack) */
801 wl1271_write32(wl, le32_to_cpu(memmap->tx_result) +
802 offsetof(struct wl1271_tx_hw_res_if,
803 tx_result_host_counter), fw_counter);
804
805 count = fw_counter - wl->tx_results_count;
Juuso Oikarinen06f7bc72010-02-22 08:38:33 +0200806 wl1271_debug(DEBUG_TX, "tx_complete received, packets: %d", count);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300807
808 /* verify that the result buffer is not getting overrun */
Juuso Oikarinenffb591c2010-02-22 08:38:31 +0200809 if (unlikely(count > TX_HW_RESULT_QUEUE_LEN))
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300810 wl1271_warning("TX result overflow from chipset: %d", count);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300811
812 /* process the results */
813 for (i = 0; i < count; i++) {
814 struct wl1271_tx_hw_res_descr *result;
815 u8 offset = wl->tx_results_count & TX_HW_RESULT_QUEUE_LEN_MASK;
816
817 /* process the packet */
818 result = &(wl->tx_res_if->tx_results_queue[offset]);
819 wl1271_tx_complete_packet(wl, result);
820
821 wl->tx_results_count++;
822 }
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300823}
824
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200825void wl1271_tx_reset_link_queues(struct wl1271 *wl, u8 hlid)
826{
827 struct sk_buff *skb;
Arik Nemtsovf1a46382011-07-07 14:25:23 +0300828 int i;
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200829 unsigned long flags;
Arik Nemtsov1d36cd82011-02-23 00:22:27 +0200830 struct ieee80211_tx_info *info;
Arik Nemtsovf1a46382011-07-07 14:25:23 +0300831 int total[NUM_TX_QUEUES];
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200832
833 for (i = 0; i < NUM_TX_QUEUES; i++) {
Arik Nemtsovf1a46382011-07-07 14:25:23 +0300834 total[i] = 0;
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200835 while ((skb = skb_dequeue(&wl->links[hlid].tx_queue[i]))) {
836 wl1271_debug(DEBUG_TX, "link freeing skb 0x%p", skb);
Arik Nemtsov79ebec72011-08-14 13:17:18 +0300837
838 if (!wl12xx_is_dummy_packet(wl, skb)) {
839 info = IEEE80211_SKB_CB(skb);
840 info->status.rates[0].idx = -1;
841 info->status.rates[0].count = 0;
842 ieee80211_tx_status_ni(wl->hw, skb);
843 }
844
Arik Nemtsovf1a46382011-07-07 14:25:23 +0300845 total[i]++;
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200846 }
847 }
848
849 spin_lock_irqsave(&wl->wl_lock, flags);
Arik Nemtsovf1a46382011-07-07 14:25:23 +0300850 for (i = 0; i < NUM_TX_QUEUES; i++)
851 wl->tx_queue_count[i] -= total[i];
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200852 spin_unlock_irqrestore(&wl->wl_lock, flags);
853
854 wl1271_handle_tx_low_watermark(wl);
855}
856
Arik Nemtsov7dece1c2011-04-18 14:15:28 +0300857/* caller must hold wl->mutex and TX must be stopped */
858void wl1271_tx_reset(struct wl1271 *wl, bool reset_tx_queues)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300859{
860 int i;
861 struct sk_buff *skb;
Arik Nemtsov1d36cd82011-02-23 00:22:27 +0200862 struct ieee80211_tx_info *info;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300863
864 /* TX failure */
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200865 if (wl->bss_type == BSS_TYPE_AP_BSS) {
Arik Nemtsov09039f42011-02-23 00:22:30 +0200866 for (i = 0; i < AP_MAX_LINKS; i++) {
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200867 wl1271_tx_reset_link_queues(wl, i);
Arik Nemtsov09039f42011-02-23 00:22:30 +0200868 wl->links[i].allocated_blks = 0;
869 wl->links[i].prev_freed_blks = 0;
870 }
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200871
872 wl->last_tx_hlid = 0;
873 } else {
874 for (i = 0; i < NUM_TX_QUEUES; i++) {
875 while ((skb = skb_dequeue(&wl->tx_queue[i]))) {
876 wl1271_debug(DEBUG_TX, "freeing skb 0x%p",
877 skb);
Shahar Leviae47c452011-03-06 16:32:14 +0200878
Ido Yariv990f5de2011-03-31 10:06:59 +0200879 if (!wl12xx_is_dummy_packet(wl, skb)) {
Shahar Leviae47c452011-03-06 16:32:14 +0200880 info = IEEE80211_SKB_CB(skb);
881 info->status.rates[0].idx = -1;
882 info->status.rates[0].count = 0;
Eliad Pellerc27d3ac2011-06-07 10:40:39 +0300883 ieee80211_tx_status_ni(wl->hw, skb);
Shahar Leviae47c452011-03-06 16:32:14 +0200884 }
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200885 }
Arik Nemtsovf1a46382011-07-07 14:25:23 +0300886 wl->tx_queue_count[i] = 0;
Juuso Oikarinen6742f552010-12-13 09:52:37 +0200887 }
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300888 }
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200889
Arik Nemtsov708bb3c2011-06-24 13:03:37 +0300890 wl->stopped_queues_map = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300891
Ido Yariv2fe33e82010-10-12 14:49:12 +0200892 /*
893 * Make sure the driver is at a consistent state, in case this
894 * function is called from a context other than interface removal.
Arik Nemtsov7dece1c2011-04-18 14:15:28 +0300895 * This call will always wake the TX queues.
Ido Yariv2fe33e82010-10-12 14:49:12 +0200896 */
Arik Nemtsov7dece1c2011-04-18 14:15:28 +0300897 if (reset_tx_queues)
898 wl1271_handle_tx_low_watermark(wl);
Ido Yariv2fe33e82010-10-12 14:49:12 +0200899
Ido Yariv50e9f742011-02-28 00:16:13 +0200900 for (i = 0; i < ACX_TX_DESCRIPTORS; i++) {
901 if (wl->tx_frames[i] == NULL)
902 continue;
903
904 skb = wl->tx_frames[i];
905 wl1271_free_tx_id(wl, i);
906 wl1271_debug(DEBUG_TX, "freeing skb 0x%p", skb);
907
Ido Yariv990f5de2011-03-31 10:06:59 +0200908 if (!wl12xx_is_dummy_packet(wl, skb)) {
Shahar Leviae47c452011-03-06 16:32:14 +0200909 /*
910 * Remove private headers before passing the skb to
911 * mac80211
912 */
913 info = IEEE80211_SKB_CB(skb);
914 skb_pull(skb, sizeof(struct wl1271_tx_hw_descr));
915 if (info->control.hw_key &&
916 info->control.hw_key->cipher ==
917 WLAN_CIPHER_SUITE_TKIP) {
918 int hdrlen = ieee80211_get_hdrlen_from_skb(skb);
919 memmove(skb->data + WL1271_TKIP_IV_SPACE,
920 skb->data, hdrlen);
921 skb_pull(skb, WL1271_TKIP_IV_SPACE);
922 }
923
924 info->status.rates[0].idx = -1;
925 info->status.rates[0].count = 0;
926
Eliad Pellerc27d3ac2011-06-07 10:40:39 +0300927 ieee80211_tx_status_ni(wl->hw, skb);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300928 }
Ido Yariv50e9f742011-02-28 00:16:13 +0200929 }
Juuso Oikarinen781608c2010-05-24 11:18:17 +0300930}
931
932#define WL1271_TX_FLUSH_TIMEOUT 500000
933
934/* caller must *NOT* hold wl->mutex */
935void wl1271_tx_flush(struct wl1271 *wl)
936{
937 unsigned long timeout;
938 timeout = jiffies + usecs_to_jiffies(WL1271_TX_FLUSH_TIMEOUT);
939
940 while (!time_after(jiffies, timeout)) {
941 mutex_lock(&wl->mutex);
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +0200942 wl1271_debug(DEBUG_TX, "flushing tx buffer: %d %d",
Arik Nemtsovf1a46382011-07-07 14:25:23 +0300943 wl->tx_frames_cnt,
944 wl1271_tx_total_queue_count(wl));
945 if ((wl->tx_frames_cnt == 0) &&
946 (wl1271_tx_total_queue_count(wl) == 0)) {
Juuso Oikarinen781608c2010-05-24 11:18:17 +0300947 mutex_unlock(&wl->mutex);
948 return;
949 }
950 mutex_unlock(&wl->mutex);
951 msleep(1);
952 }
953
954 wl1271_warning("Unable to flush all TX buffers, timed out.");
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300955}
Arik Nemtsove0fe3712010-10-16 18:19:53 +0200956
957u32 wl1271_tx_min_rate_get(struct wl1271 *wl)
958{
959 int i;
960 u32 rate = 0;
961
962 if (!wl->basic_rate_set) {
963 WARN_ON(1);
964 wl->basic_rate_set = wl->conf.tx.basic_rate;
965 }
966
967 for (i = 0; !rate; i++) {
968 if ((wl->basic_rate_set >> i) & 0x1)
969 rate = 1 << i;
970 }
971
972 return rate;
973}