drivers/net/wireless/wl12xx/tx.c

   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 "wl12xx.h"
  29 #include "io.h"
  30 #include "reg.h"
  31 #include "ps.h"
  32 #include "tx.h"
  33
  34 static 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)
  40                 ret = wl12xx_cmd_set_default_wep_key(wl, id,
  41                                                      wl->ap_bcast_hlid);
  42         else
  43                 ret = wl12xx_cmd_set_default_wep_key(wl, id, wl->sta_hlid);
  44
  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
  52 static int wl1271_alloc_tx_id(struct wl1271 *wl, struct sk_buff *skb)
  53 {
  54         int id;
  55
  56         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
  66 static void wl1271_free_tx_id(struct wl1271 *wl, int id)
  67 {
  68         if (__test_and_clear_bit(id, wl->tx_frames_map)) {
  69                 if (unlikely(wl->tx_frames_cnt == ACX_TX_DESCRIPTORS))
  70                         clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
  71
  72                 wl->tx_frames[id] = NULL;
  73                 wl->tx_frames_cnt--;
  74         }
  75 }
  76
  77 static int wl1271_tx_update_filters(struct wl1271 *wl,
  78                                                  struct sk_buff *skb)
  79 {
  80         struct ieee80211_hdr *hdr;
  81         int ret;
  82
  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
  95         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;
 106 out:
 107         return 0;
 108 }
 109
 110 static 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
 126 static void wl1271_tx_regulate_link(struct wl1271 *wl, u8 hlid)
 127 {
 128         bool fw_ps;
 129         u8 tx_pkts;
 130
 131         /* only regulate station links */
 132         if (hlid < WL1271_AP_STA_HLID_START)
 133                 return;
 134
 135         fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
 136         tx_pkts = wl->links[hlid].allocated_pkts;
 137
 138         /*
 139          * if in FW PS and there is enough data in FW we can put the link
 140          * into high-level PS and clean out its TX queues.
 141          */
 142         if (fw_ps && tx_pkts >= WL1271_PS_STA_MAX_PACKETS)
 143                 wl1271_ps_link_start(wl, hlid, true);
 144 }
 145
 146 bool wl12xx_is_dummy_packet(struct wl1271 *wl, struct sk_buff *skb)
 147 {
 148         return wl->dummy_packet == skb;
 149 }
 150
 151 u8 wl12xx_tx_get_hlid_ap(struct wl1271 *wl, struct sk_buff *skb)
 152 {
 153         struct ieee80211_tx_info *control = IEEE80211_SKB_CB(skb);
 154
 155         if (control->control.sta) {
 156                 struct wl1271_station *wl_sta;
 157
 158                 wl_sta = (struct wl1271_station *)
 159                                 control->control.sta->drv_priv;
 160                 return wl_sta->hlid;
 161         } else {
 162                 struct ieee80211_hdr *hdr;
 163
 164                 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags))
 165                         return wl->system_hlid;
 166
 167                 hdr = (struct ieee80211_hdr *)skb->data;
 168                 if (ieee80211_is_mgmt(hdr->frame_control))
 169                         return wl->ap_global_hlid;
 170                 else
 171                         return wl->ap_bcast_hlid;
 172         }
 173 }
 174
 175 static u8 wl1271_tx_get_hlid(struct wl1271 *wl, struct sk_buff *skb)
 176 {
 177         if (wl12xx_is_dummy_packet(wl, skb))
 178                 return wl->system_hlid;
 179
 180         if (wl->bss_type == BSS_TYPE_AP_BSS)
 181                 return wl12xx_tx_get_hlid_ap(wl, skb);
 182
 183         if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags) ||
 184             test_bit(WL1271_FLAG_IBSS_JOINED, &wl->flags))
 185                 return wl->sta_hlid;
 186         else
 187                 return wl->dev_hlid;
 188 }
 189
 190 static unsigned int wl12xx_calc_packet_alignment(struct wl1271 *wl,
 191                                                 unsigned int packet_length)
 192 {
 193         if (wl->quirks & WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT)
 194                 return ALIGN(packet_length, WL12XX_BUS_BLOCK_SIZE);
 195         else
 196                 return ALIGN(packet_length, WL1271_TX_ALIGN_TO);
 197 }
 198
 199 static int wl1271_tx_allocate(struct wl1271 *wl, struct sk_buff *skb, u32 extra,
 200                                 u32 buf_offset, u8 hlid)
 201 {
 202         struct wl1271_tx_hw_descr *desc;
 203         u32 total_len = skb->len + sizeof(struct wl1271_tx_hw_descr) + extra;
 204         u32 len;
 205         u32 total_blocks;
 206         int id, ret = -EBUSY, ac;
 207         u32 spare_blocks = wl->tx_spare_blocks;
 208
 209         if (buf_offset + total_len > WL1271_AGGR_BUFFER_SIZE)
 210                 return -EAGAIN;
 211
 212         /* allocate free identifier for the packet */
 213         id = wl1271_alloc_tx_id(wl, skb);
 214         if (id < 0)
 215                 return id;
 216
 217         /* approximate the number of blocks required for this packet
 218            in the firmware */
 219         len = wl12xx_calc_packet_alignment(wl, total_len);
 220
 221         /* in case of a dummy packet, use default amount of spare mem blocks */
 222         if (unlikely(wl12xx_is_dummy_packet(wl, skb)))
 223                 spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
 224
 225         total_blocks = (len + TX_HW_BLOCK_SIZE - 1) / TX_HW_BLOCK_SIZE +
 226                 spare_blocks;
 227
 228         if (total_blocks <= wl->tx_blocks_available) {
 229                 desc = (struct wl1271_tx_hw_descr *)skb_push(
 230                         skb, total_len - skb->len);
 231
 232                 /* HW descriptor fields change between wl127x and wl128x */
 233                 if (wl->chip.id == CHIP_ID_1283_PG20) {
 234                         desc->wl128x_mem.total_mem_blocks = total_blocks;
 235                 } else {
 236                         desc->wl127x_mem.extra_blocks = spare_blocks;
 237                         desc->wl127x_mem.total_mem_blocks = total_blocks;
 238                 }
 239
 240                 desc->id = id;
 241
 242                 wl->tx_blocks_available -= total_blocks;
 243                 wl->tx_allocated_blocks += total_blocks;
 244
 245                 ac = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
 246                 wl->tx_allocated_pkts[ac]++;
 247
 248                 if (wl->bss_type == BSS_TYPE_AP_BSS &&
 249                     hlid >= WL1271_AP_STA_HLID_START)
 250                         wl->links[hlid].allocated_pkts++;
 251
 252                 ret = 0;
 253
 254                 wl1271_debug(DEBUG_TX,
 255                              "tx_allocate: size: %d, blocks: %d, id: %d",
 256                              total_len, total_blocks, id);
 257         } else {
 258                 wl1271_free_tx_id(wl, id);
 259         }
 260
 261         return ret;
 262 }
 263
 264 static void wl1271_tx_fill_hdr(struct wl1271 *wl, struct sk_buff *skb,
 265                               u32 extra, struct ieee80211_tx_info *control,
 266                               u8 hlid)
 267 {
 268         struct timespec ts;
 269         struct wl1271_tx_hw_descr *desc;
 270         int aligned_len, ac, rate_idx;
 271         s64 hosttime;
 272         u16 tx_attr;
 273
 274         desc = (struct wl1271_tx_hw_descr *) skb->data;
 275
 276         /* relocate space for security header */
 277         if (extra) {
 278                 void *framestart = skb->data + sizeof(*desc);
 279                 u16 fc = *(u16 *)(framestart + extra);
 280                 int hdrlen = ieee80211_hdrlen(cpu_to_le16(fc));
 281                 memmove(framestart, framestart + extra, hdrlen);
 282         }
 283
 284         /* configure packet life time */
 285         getnstimeofday(&ts);
 286         hosttime = (timespec_to_ns(&ts) >> 10);
 287         desc->start_time = cpu_to_le32(hosttime - wl->time_offset);
 288
 289         if (wl->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 (wl12xx_is_dummy_packet(wl, skb)) {
 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 = ((~wl->session_counter) <<
 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 {
 309                 /* configure the tx attributes */
 310                 tx_attr =
 311                         wl->session_counter << TX_HW_ATTR_OFST_SESSION_COUNTER;
 312         }
 313
 314         desc->hlid = hlid;
 315
 316         if (wl->bss_type != BSS_TYPE_AP_BSS) {
 317                 /* if the packets are destined for AP (have a STA entry)
 318                    send them with AP rate policies, otherwise use default
 319                    basic rates */
 320                 if (control->control.sta)
 321                         rate_idx = ACX_TX_AP_FULL_RATE;
 322                 else
 323                         rate_idx = ACX_TX_BASIC_RATE;
 324         } else {
 325                 if (hlid == wl->ap_global_hlid)
 326                         rate_idx = ACX_TX_AP_MODE_MGMT_RATE;
 327                 else if (hlid == wl->ap_bcast_hlid)
 328                         rate_idx = ACX_TX_AP_MODE_BCST_RATE;
 329                 else
 330                         rate_idx = ac;
 331         }
 332
 333         tx_attr |= rate_idx << TX_HW_ATTR_OFST_RATE_POLICY;
 334         desc->reserved = 0;
 335
 336         aligned_len = wl12xx_calc_packet_alignment(wl, skb->len);
 337
 338         if (wl->chip.id == CHIP_ID_1283_PG20) {
 339                 desc->wl128x_mem.extra_bytes = aligned_len - skb->len;
 340                 desc->length = cpu_to_le16(aligned_len >> 2);
 341
 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);
 348         } else {
 349                 int pad;
 350
 351                 /* Store the aligned length in terms of words */
 352                 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
 358                 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);
 364         }
 365
 366         desc->tx_attr = cpu_to_le16(tx_attr);
 367 }
 368
 369 /* caller must hold wl->mutex */
 370 static int wl1271_prepare_tx_frame(struct wl1271 *wl, struct sk_buff *skb,
 371                                                         u32 buf_offset)
 372 {
 373         struct ieee80211_tx_info *info;
 374         u32 extra = 0;
 375         int ret = 0;
 376         u32 total_len;
 377         u8 hlid;
 378
 379         if (!skb)
 380                 return -EINVAL;
 381
 382         info = IEEE80211_SKB_CB(skb);
 383
 384         if (info->control.hw_key &&
 385             info->control.hw_key->cipher == WLAN_CIPHER_SUITE_TKIP)
 386                 extra = WL1271_TKIP_IV_SPACE;
 387
 388         if (info->control.hw_key) {
 389                 bool is_wep;
 390                 u8 idx = info->control.hw_key->hw_key_idx;
 391                 u32 cipher = info->control.hw_key->cipher;
 392
 393                 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);
 398                         if (ret < 0)
 399                                 return ret;
 400                         wl->default_key = idx;
 401                 }
 402         }
 403
 404         hlid = wl1271_tx_get_hlid(wl, skb);
 405         if (hlid == WL12XX_INVALID_LINK_ID) {
 406                 wl1271_error("invalid hlid. dropping skb 0x%p", skb);
 407                 return -EINVAL;
 408         }
 409
 410         ret = wl1271_tx_allocate(wl, skb, extra, buf_offset, hlid);
 411         if (ret < 0)
 412                 return ret;
 413
 414         wl1271_tx_fill_hdr(wl, skb, extra, info, hlid);
 415
 416         if (wl->bss_type == BSS_TYPE_AP_BSS) {
 417                 wl1271_tx_ap_update_inconnection_sta(wl, skb);
 418                 wl1271_tx_regulate_link(wl, hlid);
 419         } else {
 420                 wl1271_tx_update_filters(wl, skb);
 421         }
 422
 423         /*
 424          * The length of each packet is stored in terms of
 425          * words. Thus, we must pad the skb data to make sure its
 426          * length is aligned.  The number of padding bytes is computed
 427          * and set in wl1271_tx_fill_hdr.
 428          * In special cases, we want to align to a specific block size
 429          * (eg. for wl128x with SDIO we align to 256).
 430          */
 431         total_len = wl12xx_calc_packet_alignment(wl, skb->len);
 432
 433         memcpy(wl->aggr_buf + buf_offset, skb->data, skb->len);
 434         memset(wl->aggr_buf + buf_offset + skb->len, 0, total_len - skb->len);
 435
 436         /* Revert side effects in the dummy packet skb, so it can be reused */
 437         if (wl12xx_is_dummy_packet(wl, skb))
 438                 skb_pull(skb, sizeof(struct wl1271_tx_hw_descr));
 439
 440         return total_len;
 441 }
 442
 443 u32 wl1271_tx_enabled_rates_get(struct wl1271 *wl, u32 rate_set)
 444 {
 445         struct ieee80211_supported_band *band;
 446         u32 enabled_rates = 0;
 447         int bit;
 448
 449         band = wl->hw->wiphy->bands[wl->band];
 450         for (bit = 0; bit < band->n_bitrates; bit++) {
 451                 if (rate_set & 0x1)
 452                         enabled_rates |= band->bitrates[bit].hw_value;
 453                 rate_set >>= 1;
 454         }
 455
 456         /* MCS rates indication are on bits 16 - 23 */
 457         rate_set >>= HW_HT_RATES_OFFSET - band->n_bitrates;
 458
 459         for (bit = 0; bit < 8; bit++) {
 460                 if (rate_set & 0x1)
 461                         enabled_rates |= (CONF_HW_BIT_RATE_MCS_0 << bit);
 462                 rate_set >>= 1;
 463         }
 464
 465         return enabled_rates;
 466 }
 467
 468 void wl1271_handle_tx_low_watermark(struct wl1271 *wl)
 469 {
 470         unsigned long flags;
 471         int i;
 472
 473         for (i = 0; i < NUM_TX_QUEUES; i++) {
 474                 if (test_bit(i, &wl->stopped_queues_map) &&
 475                     wl->tx_queue_count[i] <= WL1271_TX_QUEUE_LOW_WATERMARK) {
 476                         /* firmware buffer has space, restart queues */
 477                         spin_lock_irqsave(&wl->wl_lock, flags);
 478                         ieee80211_wake_queue(wl->hw,
 479                                              wl1271_tx_get_mac80211_queue(i));
 480                         clear_bit(i, &wl->stopped_queues_map);
 481                         spin_unlock_irqrestore(&wl->wl_lock, flags);
 482                 }
 483         }
 484 }
 485
 486 static struct sk_buff_head *wl1271_select_queue(struct wl1271 *wl,
 487                                                 struct sk_buff_head *queues)
 488 {
 489         int i, q = -1, ac;
 490         u32 min_pkts = 0xffffffff;
 491
 492         /*
 493          * Find a non-empty ac where:
 494          * 1. There are packets to transmit
 495          * 2. The FW has the least allocated blocks
 496          *
 497          * We prioritize the ACs according to VO>VI>BE>BK
 498          */
 499         for (i = 0; i < NUM_TX_QUEUES; i++) {
 500                 ac = wl1271_tx_get_queue(i);
 501                 if (!skb_queue_empty(&queues[ac]) &&
 502                     (wl->tx_allocated_pkts[ac] < min_pkts)) {
 503                         q = ac;
 504                         min_pkts = wl->tx_allocated_pkts[q];
 505                 }
 506         }
 507
 508         if (q == -1)
 509                 return NULL;
 510
 511         return &queues[q];
 512 }
 513
 514 static struct sk_buff *wl1271_sta_skb_dequeue(struct wl1271 *wl)
 515 {
 516         struct sk_buff *skb = NULL;
 517         unsigned long flags;
 518         struct sk_buff_head *queue;
 519
 520         queue = wl1271_select_queue(wl, wl->tx_queue);
 521         if (!queue)
 522                 goto out;
 523
 524         skb = skb_dequeue(queue);
 525
 526 out:
 527         if (skb) {
 528                 int q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
 529                 spin_lock_irqsave(&wl->wl_lock, flags);
 530                 wl->tx_queue_count[q]--;
 531                 spin_unlock_irqrestore(&wl->wl_lock, flags);
 532         }
 533
 534         return skb;
 535 }
 536
 537 static struct sk_buff *wl1271_ap_skb_dequeue(struct wl1271 *wl)
 538 {
 539         struct sk_buff *skb = NULL;
 540         unsigned long flags;
 541         int i, h, start_hlid;
 542         struct sk_buff_head *queue;
 543
 544         /* start from the link after the last one */
 545         start_hlid = (wl->last_tx_hlid + 1) % AP_MAX_LINKS;
 546
 547         /* dequeue according to AC, round robin on each link */
 548         for (i = 0; i < AP_MAX_LINKS; i++) {
 549                 h = (start_hlid + i) % AP_MAX_LINKS;
 550
 551                 /* only consider connected stations */
 552                 if (h >= WL1271_AP_STA_HLID_START &&
 553                     !test_bit(h - WL1271_AP_STA_HLID_START, wl->ap_hlid_map))
 554                         continue;
 555
 556                 queue = wl1271_select_queue(wl, wl->links[h].tx_queue);
 557                 if (!queue)
 558                         continue;
 559
 560                 skb = skb_dequeue(queue);
 561                 if (skb)
 562                         break;
 563         }
 564
 565         if (skb) {
 566                 int q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
 567                 wl->last_tx_hlid = h;
 568                 spin_lock_irqsave(&wl->wl_lock, flags);
 569                 wl->tx_queue_count[q]--;
 570                 spin_unlock_irqrestore(&wl->wl_lock, flags);
 571         } else {
 572                 wl->last_tx_hlid = 0;
 573         }
 574
 575         return skb;
 576 }
 577
 578 static struct sk_buff *wl1271_skb_dequeue(struct wl1271 *wl)
 579 {
 580         unsigned long flags;
 581         struct sk_buff *skb = NULL;
 582
 583         if (wl->bss_type == BSS_TYPE_AP_BSS)
 584                 skb = wl1271_ap_skb_dequeue(wl);
 585         else
 586                 skb = wl1271_sta_skb_dequeue(wl);
 587
 588         if (!skb &&
 589             test_and_clear_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags)) {
 590                 int q;
 591
 592                 skb = wl->dummy_packet;
 593                 q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
 594                 spin_lock_irqsave(&wl->wl_lock, flags);
 595                 wl->tx_queue_count[q]--;
 596                 spin_unlock_irqrestore(&wl->wl_lock, flags);
 597         }
 598
 599         return skb;
 600 }
 601
 602 static void wl1271_skb_queue_head(struct wl1271 *wl, struct sk_buff *skb)
 603 {
 604         unsigned long flags;
 605         int q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
 606
 607         if (wl12xx_is_dummy_packet(wl, skb)) {
 608                 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
 609         } else if (wl->bss_type == BSS_TYPE_AP_BSS) {
 610                 u8 hlid = wl1271_tx_get_hlid(wl, skb);
 611                 skb_queue_head(&wl->links[hlid].tx_queue[q], skb);
 612
 613                 /* make sure we dequeue the same packet next time */
 614                 wl->last_tx_hlid = (hlid + AP_MAX_LINKS - 1) % AP_MAX_LINKS;
 615         } else {
 616                 skb_queue_head(&wl->tx_queue[q], skb);
 617         }
 618
 619         spin_lock_irqsave(&wl->wl_lock, flags);
 620         wl->tx_queue_count[q]++;
 621         spin_unlock_irqrestore(&wl->wl_lock, flags);
 622 }
 623
 624 static bool wl1271_tx_is_data_present(struct sk_buff *skb)
 625 {
 626         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)(skb->data);
 627
 628         return ieee80211_is_data_present(hdr->frame_control);
 629 }
 630
 631 void wl1271_tx_work_locked(struct wl1271 *wl)
 632 {
 633         struct sk_buff *skb;
 634         u32 buf_offset = 0;
 635         bool sent_packets = false;
 636         bool had_data = false;
 637         bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
 638         int ret;
 639
 640         if (unlikely(wl->state == WL1271_STATE_OFF))
 641                 return;
 642
 643         while ((skb = wl1271_skb_dequeue(wl))) {
 644                 if (wl1271_tx_is_data_present(skb))
 645                         had_data = true;
 646
 647                 ret = wl1271_prepare_tx_frame(wl, skb, buf_offset);
 648                 if (ret == -EAGAIN) {
 649                         /*
 650                          * Aggregation buffer is full.
 651                          * Flush buffer and try again.
 652                          */
 653                         wl1271_skb_queue_head(wl, skb);
 654                         wl1271_write(wl, WL1271_SLV_MEM_DATA, wl->aggr_buf,
 655                                      buf_offset, true);
 656                         sent_packets = true;
 657                         buf_offset = 0;
 658                         continue;
 659                 } else if (ret == -EBUSY) {
 660                         /*
 661                          * Firmware buffer is full.
 662                          * Queue back last skb, and stop aggregating.
 663                          */
 664                         wl1271_skb_queue_head(wl, skb);
 665                         /* No work left, avoid scheduling redundant tx work */
 666                         set_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
 667                         goto out_ack;
 668                 } else if (ret < 0) {
 669                         dev_kfree_skb(skb);
 670                         goto out_ack;
 671                 }
 672                 buf_offset += ret;
 673                 wl->tx_packets_count++;
 674         }
 675
 676 out_ack:
 677         if (buf_offset) {
 678                 wl1271_write(wl, WL1271_SLV_MEM_DATA, wl->aggr_buf,
 679                                 buf_offset, true);
 680                 sent_packets = true;
 681         }
 682         if (sent_packets) {
 683                 /*
 684                  * Interrupt the firmware with the new packets. This is only
 685                  * required for older hardware revisions
 686                  */
 687                 if (wl->quirks & WL12XX_QUIRK_END_OF_TRANSACTION)
 688                         wl1271_write32(wl, WL1271_HOST_WR_ACCESS,
 689                                        wl->tx_packets_count);
 690
 691                 wl1271_handle_tx_low_watermark(wl);
 692         }
 693         if (!is_ap && wl->conf.rx_streaming.interval && had_data &&
 694             (wl->conf.rx_streaming.always ||
 695              test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags))) {
 696                 u32 timeout = wl->conf.rx_streaming.duration;
 697
 698                 /* enable rx streaming */
 699                 if (!test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags))
 700                         ieee80211_queue_work(wl->hw,
 701                                              &wl->rx_streaming_enable_work);
 702
 703                 mod_timer(&wl->rx_streaming_timer,
 704                           jiffies + msecs_to_jiffies(timeout));
 705         }
 706 }
 707
 708 void wl1271_tx_work(struct work_struct *work)
 709 {
 710         struct wl1271 *wl = container_of(work, struct wl1271, tx_work);
 711         int ret;
 712
 713         mutex_lock(&wl->mutex);
 714         ret = wl1271_ps_elp_wakeup(wl);
 715         if (ret < 0)
 716                 goto out;
 717
 718         wl1271_tx_work_locked(wl);
 719
 720         wl1271_ps_elp_sleep(wl);
 721 out:
 722         mutex_unlock(&wl->mutex);
 723 }
 724
 725 static void wl1271_tx_complete_packet(struct wl1271 *wl,
 726                                       struct wl1271_tx_hw_res_descr *result)
 727 {
 728         struct ieee80211_tx_info *info;
 729         struct sk_buff *skb;
 730         int id = result->id;
 731         int rate = -1;
 732         u8 retries = 0;
 733
 734         /* check for id legality */
 735         if (unlikely(id >= ACX_TX_DESCRIPTORS || wl->tx_frames[id] == NULL)) {
 736                 wl1271_warning("TX result illegal id: %d", id);
 737                 return;
 738         }
 739
 740         skb = wl->tx_frames[id];
 741         info = IEEE80211_SKB_CB(skb);
 742
 743         if (wl12xx_is_dummy_packet(wl, skb)) {
 744                 wl1271_free_tx_id(wl, id);
 745                 return;
 746         }
 747
 748         /* update the TX status info */
 749         if (result->status == TX_SUCCESS) {
 750                 if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
 751                         info->flags |= IEEE80211_TX_STAT_ACK;
 752                 rate = wl1271_rate_to_idx(result->rate_class_index, wl->band);
 753                 retries = result->ack_failures;
 754         } else if (result->status == TX_RETRY_EXCEEDED) {
 755                 wl->stats.excessive_retries++;
 756                 retries = result->ack_failures;
 757         }
 758
 759         info->status.rates[0].idx = rate;
 760         info->status.rates[0].count = retries;
 761         info->status.rates[0].flags = 0;
 762         info->status.ack_signal = -1;
 763
 764         wl->stats.retry_count += result->ack_failures;
 765
 766         /*
 767          * update sequence number only when relevant, i.e. only in
 768          * sessions of TKIP, AES and GEM (not in open or WEP sessions)
 769          */
 770         if (info->control.hw_key &&
 771             (info->control.hw_key->cipher == WLAN_CIPHER_SUITE_TKIP ||
 772              info->control.hw_key->cipher == WLAN_CIPHER_SUITE_CCMP ||
 773              info->control.hw_key->cipher == WL1271_CIPHER_SUITE_GEM)) {
 774                 u8 fw_lsb = result->tx_security_sequence_number_lsb;
 775                 u8 cur_lsb = wl->tx_security_last_seq_lsb;
 776
 777                 /*
 778                  * update security sequence number, taking care of potential
 779                  * wrap-around
 780                  */
 781                 wl->tx_security_seq += (fw_lsb - cur_lsb + 256) % 256;
 782                 wl->tx_security_last_seq_lsb = fw_lsb;
 783         }
 784
 785         /* remove private header from packet */
 786         skb_pull(skb, sizeof(struct wl1271_tx_hw_descr));
 787
 788         /* remove TKIP header space if present */
 789         if (info->control.hw_key &&
 790             info->control.hw_key->cipher == WLAN_CIPHER_SUITE_TKIP) {
 791                 int hdrlen = ieee80211_get_hdrlen_from_skb(skb);
 792                 memmove(skb->data + WL1271_TKIP_IV_SPACE, skb->data, hdrlen);
 793                 skb_pull(skb, WL1271_TKIP_IV_SPACE);
 794         }
 795
 796         wl1271_debug(DEBUG_TX, "tx status id %u skb 0x%p failures %u rate 0x%x"
 797                      " status 0x%x",
 798                      result->id, skb, result->ack_failures,
 799                      result->rate_class_index, result->status);
 800
 801         /* return the packet to the stack */
 802         skb_queue_tail(&wl->deferred_tx_queue, skb);
 803         queue_work(wl->freezable_wq, &wl->netstack_work);
 804         wl1271_free_tx_id(wl, result->id);
 805 }
 806
 807 /* Called upon reception of a TX complete interrupt */
 808 void wl1271_tx_complete(struct wl1271 *wl)
 809 {
 810         struct wl1271_acx_mem_map *memmap =
 811                 (struct wl1271_acx_mem_map *)wl->target_mem_map;
 812         u32 count, fw_counter;
 813         u32 i;
 814
 815         /* read the tx results from the chipset */
 816         wl1271_read(wl, le32_to_cpu(memmap->tx_result),
 817                     wl->tx_res_if, sizeof(*wl->tx_res_if), false);
 818         fw_counter = le32_to_cpu(wl->tx_res_if->tx_result_fw_counter);
 819
 820         /* write host counter to chipset (to ack) */
 821         wl1271_write32(wl, le32_to_cpu(memmap->tx_result) +
 822                        offsetof(struct wl1271_tx_hw_res_if,
 823                                 tx_result_host_counter), fw_counter);
 824
 825         count = fw_counter - wl->tx_results_count;
 826         wl1271_debug(DEBUG_TX, "tx_complete received, packets: %d", count);
 827
 828         /* verify that the result buffer is not getting overrun */
 829         if (unlikely(count > TX_HW_RESULT_QUEUE_LEN))
 830                 wl1271_warning("TX result overflow from chipset: %d", count);
 831
 832         /* process the results */
 833         for (i = 0; i < count; i++) {
 834                 struct wl1271_tx_hw_res_descr *result;
 835                 u8 offset = wl->tx_results_count & TX_HW_RESULT_QUEUE_LEN_MASK;
 836
 837                 /* process the packet */
 838                 result =  &(wl->tx_res_if->tx_results_queue[offset]);
 839                 wl1271_tx_complete_packet(wl, result);
 840
 841                 wl->tx_results_count++;
 842         }
 843 }
 844
 845 void wl1271_tx_reset_link_queues(struct wl1271 *wl, u8 hlid)
 846 {
 847         struct sk_buff *skb;
 848         int i;
 849         unsigned long flags;
 850         struct ieee80211_tx_info *info;
 851         int total[NUM_TX_QUEUES];
 852
 853         for (i = 0; i < NUM_TX_QUEUES; i++) {
 854                 total[i] = 0;
 855                 while ((skb = skb_dequeue(&wl->links[hlid].tx_queue[i]))) {
 856                         wl1271_debug(DEBUG_TX, "link freeing skb 0x%p", skb);
 857
 858                         if (!wl12xx_is_dummy_packet(wl, skb)) {
 859                                 info = IEEE80211_SKB_CB(skb);
 860                                 info->status.rates[0].idx = -1;
 861                                 info->status.rates[0].count = 0;
 862                                 ieee80211_tx_status_ni(wl->hw, skb);
 863                         }
 864
 865                         total[i]++;
 866                 }
 867         }
 868
 869         spin_lock_irqsave(&wl->wl_lock, flags);
 870         for (i = 0; i < NUM_TX_QUEUES; i++)
 871                 wl->tx_queue_count[i] -= total[i];
 872         spin_unlock_irqrestore(&wl->wl_lock, flags);
 873
 874         wl1271_handle_tx_low_watermark(wl);
 875 }
 876
 877 /* caller must hold wl->mutex and TX must be stopped */
 878 void wl1271_tx_reset(struct wl1271 *wl, bool reset_tx_queues)
 879 {
 880         int i;
 881         struct sk_buff *skb;
 882         struct ieee80211_tx_info *info;
 883
 884         /* TX failure */
 885         if (wl->bss_type == BSS_TYPE_AP_BSS) {
 886                 for (i = 0; i < AP_MAX_LINKS; i++) {
 887                         wl1271_tx_reset_link_queues(wl, i);
 888                         wl->links[i].allocated_pkts = 0;
 889                         wl->links[i].prev_freed_pkts = 0;
 890                 }
 891
 892                 wl->last_tx_hlid = 0;
 893         } else {
 894                 for (i = 0; i < NUM_TX_QUEUES; i++) {
 895                         while ((skb = skb_dequeue(&wl->tx_queue[i]))) {
 896                                 wl1271_debug(DEBUG_TX, "freeing skb 0x%p",
 897                                              skb);
 898
 899                                 if (!wl12xx_is_dummy_packet(wl, skb)) {
 900                                         info = IEEE80211_SKB_CB(skb);
 901                                         info->status.rates[0].idx = -1;
 902                                         info->status.rates[0].count = 0;
 903                                         ieee80211_tx_status_ni(wl->hw, skb);
 904                                 }
 905                         }
 906                         wl->tx_queue_count[i] = 0;
 907                 }
 908         }
 909
 910         wl->stopped_queues_map = 0;
 911
 912         /*
 913          * Make sure the driver is at a consistent state, in case this
 914          * function is called from a context other than interface removal.
 915          * This call will always wake the TX queues.
 916          */
 917         if (reset_tx_queues)
 918                 wl1271_handle_tx_low_watermark(wl);
 919
 920         for (i = 0; i < ACX_TX_DESCRIPTORS; i++) {
 921                 if (wl->tx_frames[i] == NULL)
 922                         continue;
 923
 924                 skb = wl->tx_frames[i];
 925                 wl1271_free_tx_id(wl, i);
 926                 wl1271_debug(DEBUG_TX, "freeing skb 0x%p", skb);
 927
 928                 if (!wl12xx_is_dummy_packet(wl, skb)) {
 929                         /*
 930                          * Remove private headers before passing the skb to
 931                          * mac80211
 932                          */
 933                         info = IEEE80211_SKB_CB(skb);
 934                         skb_pull(skb, sizeof(struct wl1271_tx_hw_descr));
 935                         if (info->control.hw_key &&
 936                             info->control.hw_key->cipher ==
 937                             WLAN_CIPHER_SUITE_TKIP) {
 938                                 int hdrlen = ieee80211_get_hdrlen_from_skb(skb);
 939                                 memmove(skb->data + WL1271_TKIP_IV_SPACE,
 940                                         skb->data, hdrlen);
 941                                 skb_pull(skb, WL1271_TKIP_IV_SPACE);
 942                         }
 943
 944                         info->status.rates[0].idx = -1;
 945                         info->status.rates[0].count = 0;
 946
 947                         ieee80211_tx_status_ni(wl->hw, skb);
 948                 }
 949         }
 950 }
 951
 952 #define WL1271_TX_FLUSH_TIMEOUT 500000
 953
 954 /* caller must *NOT* hold wl->mutex */
 955 void wl1271_tx_flush(struct wl1271 *wl)
 956 {
 957         unsigned long timeout;
 958         timeout = jiffies + usecs_to_jiffies(WL1271_TX_FLUSH_TIMEOUT);
 959
 960         while (!time_after(jiffies, timeout)) {
 961                 mutex_lock(&wl->mutex);
 962                 wl1271_debug(DEBUG_TX, "flushing tx buffer: %d %d",
 963                              wl->tx_frames_cnt,
 964                              wl1271_tx_total_queue_count(wl));
 965                 if ((wl->tx_frames_cnt == 0) &&
 966                     (wl1271_tx_total_queue_count(wl) == 0)) {
 967                         mutex_unlock(&wl->mutex);
 968                         return;
 969                 }
 970                 mutex_unlock(&wl->mutex);
 971                 msleep(1);
 972         }
 973
 974         wl1271_warning("Unable to flush all TX buffers, timed out.");
 975 }
 976
 977 u32 wl1271_tx_min_rate_get(struct wl1271 *wl)
 978 {
 979         int i;
 980         u32 rate = 0;
 981
 982         if (!wl->basic_rate_set) {
 983                 WARN_ON(1);
 984                 wl->basic_rate_set = wl->conf.tx.basic_rate;
 985         }
 986
 987         for (i = 0; !rate; i++) {
 988                 if ((wl->basic_rate_set >> i) & 0x1)
 989                         rate = 1 << i;
 990         }
 991
 992         return rate;
 993 }