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