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 #if 0
 127 static 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 }
 146 #endif
 147
 148 static bool wl12xx_is_dummy_packet(struct wl1271 *wl, struct sk_buff *skb)
 149 {
 150         return wl->dummy_packet == skb;
 151 }
 152
 153 u8 wl12xx_tx_get_hlid_ap(struct wl1271 *wl, struct sk_buff *skb)
 154 {
 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
 166                 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags))
 167                         return wl->system_hlid;
 168
 169                 hdr = (struct ieee80211_hdr *)skb->data;
 170                 if (ieee80211_is_mgmt(hdr->frame_control))
 171                         return wl->ap_global_hlid;
 172                 else
 173                         return wl->ap_bcast_hlid;
 174         }
 175 }
 176
 177 static 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             test_bit(WL1271_FLAG_IBSS_JOINED, &wl->flags))
 187                 return wl->sta_hlid;
 188         else
 189                 return wl->dev_hlid;
 190 }
 191
 192 static unsigned int wl12xx_calc_packet_alignment(struct wl1271 *wl,
 193                                                 unsigned int packet_length)
 194 {
 195         if (wl->quirks & WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT)
 196                 return ALIGN(packet_length, WL12XX_BUS_BLOCK_SIZE);
 197         else
 198                 return ALIGN(packet_length, WL1271_TX_ALIGN_TO);
 199 }
 200
 201 static int wl1271_tx_allocate(struct wl1271 *wl, struct sk_buff *skb, u32 extra,
 202                                 u32 buf_offset, u8 hlid)
 203 {
 204         struct wl1271_tx_hw_descr *desc;
 205         u32 total_len = skb->len + sizeof(struct wl1271_tx_hw_descr) + extra;
 206         u32 len;
 207         u32 total_blocks;
 208         int id, ret = -EBUSY;
 209
 210         /* we use 1 spare block */
 211         u32 spare_blocks = 1;
 212
 213         if (buf_offset + total_len > WL1271_AGGR_BUFFER_SIZE)
 214                 return -EAGAIN;
 215
 216         /* allocate free identifier for the packet */
 217         id = wl1271_alloc_tx_id(wl, skb);
 218         if (id < 0)
 219                 return id;
 220
 221         /* approximate the number of blocks required for this packet
 222            in the firmware */
 223         len = wl12xx_calc_packet_alignment(wl, total_len);
 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                 wl->tx_allocated_pkts++;
 246
 247                 if (wl->bss_type == BSS_TYPE_AP_BSS)
 248                         wl->links[hlid].allocated_blks += total_blocks;
 249
 250                 ret = 0;
 251
 252                 wl1271_debug(DEBUG_TX,
 253                              "tx_allocate: size: %d, blocks: %d, id: %d",
 254                              total_len, total_blocks, id);
 255         } else {
 256                 wl1271_free_tx_id(wl, id);
 257         }
 258
 259         return ret;
 260 }
 261
 262 static void wl1271_tx_fill_hdr(struct wl1271 *wl, struct sk_buff *skb,
 263                               u32 extra, struct ieee80211_tx_info *control,
 264                               u8 hlid)
 265 {
 266         struct timespec ts;
 267         struct wl1271_tx_hw_descr *desc;
 268         int aligned_len, ac, rate_idx;
 269         s64 hosttime;
 270         u16 tx_attr;
 271
 272         desc = (struct wl1271_tx_hw_descr *) skb->data;
 273
 274         /* relocate space for security header */
 275         if (extra) {
 276                 void *framestart = skb->data + sizeof(*desc);
 277                 u16 fc = *(u16 *)(framestart + extra);
 278                 int hdrlen = ieee80211_hdrlen(cpu_to_le16(fc));
 279                 memmove(framestart, framestart + extra, hdrlen);
 280         }
 281
 282         /* configure packet life time */
 283         getnstimeofday(&ts);
 284         hosttime = (timespec_to_ns(&ts) >> 10);
 285         desc->start_time = cpu_to_le32(hosttime - wl->time_offset);
 286
 287         if (wl->bss_type != BSS_TYPE_AP_BSS)
 288                 desc->life_time = cpu_to_le16(TX_HW_MGMT_PKT_LIFETIME_TU);
 289         else
 290                 desc->life_time = cpu_to_le16(TX_HW_AP_MODE_PKT_LIFETIME_TU);
 291
 292         /* queue */
 293         ac = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
 294         desc->tid = skb->priority;
 295
 296         if (wl12xx_is_dummy_packet(wl, skb)) {
 297                 /*
 298                  * FW expects the dummy packet to have an invalid session id -
 299                  * any session id that is different than the one set in the join
 300                  */
 301                 tx_attr = ((~wl->session_counter) <<
 302                            TX_HW_ATTR_OFST_SESSION_COUNTER) &
 303                            TX_HW_ATTR_SESSION_COUNTER;
 304
 305                 tx_attr |= TX_HW_ATTR_TX_DUMMY_REQ;
 306         } else {
 307                 /* configure the tx attributes */
 308                 tx_attr =
 309                         wl->session_counter << TX_HW_ATTR_OFST_SESSION_COUNTER;
 310         }
 311
 312         desc->hlid = hlid;
 313
 314         if (wl->bss_type != BSS_TYPE_AP_BSS) {
 315                 /* if the packets are destined for AP (have a STA entry)
 316                    send them with AP rate policies, otherwise use default
 317                    basic rates */
 318                 if (control->control.sta)
 319                         rate_idx = ACX_TX_AP_FULL_RATE;
 320                 else
 321                         rate_idx = ACX_TX_BASIC_RATE;
 322         } else {
 323                 if (hlid == wl->ap_global_hlid)
 324                         rate_idx = ACX_TX_AP_MODE_MGMT_RATE;
 325                 else if (hlid == wl->ap_bcast_hlid)
 326                         rate_idx = ACX_TX_AP_MODE_BCST_RATE;
 327                 else
 328                         rate_idx = ac;
 329         }
 330
 331         tx_attr |= rate_idx << TX_HW_ATTR_OFST_RATE_POLICY;
 332         desc->reserved = 0;
 333
 334         aligned_len = wl12xx_calc_packet_alignment(wl, skb->len);
 335
 336         if (wl->chip.id == CHIP_ID_1283_PG20) {
 337                 desc->wl128x_mem.extra_bytes = aligned_len - skb->len;
 338                 desc->length = cpu_to_le16(aligned_len >> 2);
 339
 340                 wl1271_debug(DEBUG_TX, "tx_fill_hdr: hlid: %d "
 341                              "tx_attr: 0x%x len: %d life: %d mem: %d",
 342                              desc->hlid, tx_attr,
 343                              le16_to_cpu(desc->length),
 344                              le16_to_cpu(desc->life_time),
 345                              desc->wl128x_mem.total_mem_blocks);
 346         } else {
 347                 int pad;
 348
 349                 /* Store the aligned length in terms of words */
 350                 desc->length = cpu_to_le16(aligned_len >> 2);
 351
 352                 /* calculate number of padding bytes */
 353                 pad = aligned_len - skb->len;
 354                 tx_attr |= pad << TX_HW_ATTR_OFST_LAST_WORD_PAD;
 355
 356                 wl1271_debug(DEBUG_TX, "tx_fill_hdr: pad: %d hlid: %d "
 357                              "tx_attr: 0x%x len: %d life: %d mem: %d", pad,
 358                              desc->hlid, tx_attr,
 359                              le16_to_cpu(desc->length),
 360                              le16_to_cpu(desc->life_time),
 361                              desc->wl127x_mem.total_mem_blocks);
 362         }
 363
 364         desc->tx_attr = cpu_to_le16(tx_attr);
 365 }
 366
 367 /* caller must hold wl->mutex */
 368 static int wl1271_prepare_tx_frame(struct wl1271 *wl, struct sk_buff *skb,
 369                                                         u32 buf_offset)
 370 {
 371         struct ieee80211_tx_info *info;
 372         u32 extra = 0;
 373         int ret = 0;
 374         u32 total_len;
 375         u8 hlid;
 376
 377         if (!skb)
 378                 return -EINVAL;
 379
 380         info = IEEE80211_SKB_CB(skb);
 381
 382         if (info->control.hw_key &&
 383             info->control.hw_key->cipher == WLAN_CIPHER_SUITE_TKIP)
 384                 extra = WL1271_TKIP_IV_SPACE;
 385
 386         if (info->control.hw_key) {
 387                 bool is_wep;
 388                 u8 idx = info->control.hw_key->hw_key_idx;
 389                 u32 cipher = info->control.hw_key->cipher;
 390
 391                 is_wep = (cipher == WLAN_CIPHER_SUITE_WEP40) ||
 392                          (cipher == WLAN_CIPHER_SUITE_WEP104);
 393
 394                 if (unlikely(is_wep && wl->default_key != idx)) {
 395                         ret = wl1271_set_default_wep_key(wl, idx);
 396                         if (ret < 0)
 397                                 return ret;
 398                         wl->default_key = idx;
 399                 }
 400         }
 401
 402         hlid = wl1271_tx_get_hlid(wl, skb);
 403         if (hlid == WL12XX_INVALID_LINK_ID) {
 404                 wl1271_error("invalid hlid. dropping skb 0x%p", skb);
 405                 return -EINVAL;
 406         }
 407
 408         ret = wl1271_tx_allocate(wl, skb, extra, buf_offset, hlid);
 409         if (ret < 0)
 410                 return ret;
 411
 412         wl1271_tx_fill_hdr(wl, skb, extra, info, hlid);
 413
 414         if (wl->bss_type == BSS_TYPE_AP_BSS) {
 415                 wl1271_tx_ap_update_inconnection_sta(wl, skb);
 416 #if 0
 417                 wl1271_tx_regulate_link(wl, hlid);
 418 #endif
 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 #ifdef CONFIG_WL12XX_HT
 457         /* MCS rates indication are on bits 16 - 23 */
 458         rate_set >>= HW_HT_RATES_OFFSET - band->n_bitrates;
 459
 460         for (bit = 0; bit < 8; bit++) {
 461                 if (rate_set & 0x1)
 462                         enabled_rates |= (CONF_HW_BIT_RATE_MCS_0 << bit);
 463                 rate_set >>= 1;
 464         }
 465 #endif
 466
 467         return enabled_rates;
 468 }
 469
 470 void wl1271_handle_tx_low_watermark(struct wl1271 *wl)
 471 {
 472         unsigned long flags;
 473         int i;
 474
 475         for (i = 0; i < NUM_TX_QUEUES; i++) {
 476                 if (test_bit(i, &wl->stopped_queues_map) &&
 477                     wl->tx_queue_count[i] <= WL1271_TX_QUEUE_LOW_WATERMARK) {
 478                         /* firmware buffer has space, restart queues */
 479                         spin_lock_irqsave(&wl->wl_lock, flags);
 480                         ieee80211_wake_queue(wl->hw,
 481                                              wl1271_tx_get_mac80211_queue(i));
 482                         clear_bit(i, &wl->stopped_queues_map);
 483                         spin_unlock_irqrestore(&wl->wl_lock, flags);
 484                 }
 485         }
 486 }
 487
 488 static struct sk_buff *wl1271_sta_skb_dequeue(struct wl1271 *wl)
 489 {
 490         struct sk_buff *skb = NULL;
 491         unsigned long flags;
 492
 493         skb = skb_dequeue(&wl->tx_queue[CONF_TX_AC_VO]);
 494         if (skb)
 495                 goto out;
 496         skb = skb_dequeue(&wl->tx_queue[CONF_TX_AC_VI]);
 497         if (skb)
 498                 goto out;
 499         skb = skb_dequeue(&wl->tx_queue[CONF_TX_AC_BE]);
 500         if (skb)
 501                 goto out;
 502         skb = skb_dequeue(&wl->tx_queue[CONF_TX_AC_BK]);
 503
 504 out:
 505         if (skb) {
 506                 int q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
 507                 spin_lock_irqsave(&wl->wl_lock, flags);
 508                 wl->tx_queue_count[q]--;
 509                 spin_unlock_irqrestore(&wl->wl_lock, flags);
 510         }
 511
 512         return skb;
 513 }
 514
 515 static struct sk_buff *wl1271_ap_skb_dequeue(struct wl1271 *wl)
 516 {
 517         struct sk_buff *skb = NULL;
 518         unsigned long flags;
 519         int i, h, start_hlid;
 520
 521         /* start from the link after the last one */
 522         start_hlid = (wl->last_tx_hlid + 1) % AP_MAX_LINKS;
 523
 524         /* dequeue according to AC, round robin on each link */
 525         for (i = 0; i < AP_MAX_LINKS; i++) {
 526                 h = (start_hlid + i) % AP_MAX_LINKS;
 527
 528                 skb = skb_dequeue(&wl->links[h].tx_queue[CONF_TX_AC_VO]);
 529                 if (skb)
 530                         goto out;
 531                 skb = skb_dequeue(&wl->links[h].tx_queue[CONF_TX_AC_VI]);
 532                 if (skb)
 533                         goto out;
 534                 skb = skb_dequeue(&wl->links[h].tx_queue[CONF_TX_AC_BE]);
 535                 if (skb)
 536                         goto out;
 537                 skb = skb_dequeue(&wl->links[h].tx_queue[CONF_TX_AC_BK]);
 538                 if (skb)
 539                         goto out;
 540         }
 541
 542 out:
 543         if (skb) {
 544                 int q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
 545                 wl->last_tx_hlid = h;
 546                 spin_lock_irqsave(&wl->wl_lock, flags);
 547                 wl->tx_queue_count[q]--;
 548                 spin_unlock_irqrestore(&wl->wl_lock, flags);
 549         } else {
 550                 wl->last_tx_hlid = 0;
 551         }
 552
 553         return skb;
 554 }
 555
 556 static struct sk_buff *wl1271_skb_dequeue(struct wl1271 *wl)
 557 {
 558         unsigned long flags;
 559         struct sk_buff *skb = NULL;
 560
 561         if (wl->bss_type == BSS_TYPE_AP_BSS)
 562                 skb = wl1271_ap_skb_dequeue(wl);
 563         else
 564                 skb = wl1271_sta_skb_dequeue(wl);
 565
 566         if (!skb &&
 567             test_and_clear_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags)) {
 568                 int q;
 569
 570                 skb = wl->dummy_packet;
 571                 q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
 572                 spin_lock_irqsave(&wl->wl_lock, flags);
 573                 wl->tx_queue_count[q]--;
 574                 spin_unlock_irqrestore(&wl->wl_lock, flags);
 575         }
 576
 577         return skb;
 578 }
 579
 580 static void wl1271_skb_queue_head(struct wl1271 *wl, struct sk_buff *skb)
 581 {
 582         unsigned long flags;
 583         int q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
 584
 585         if (wl12xx_is_dummy_packet(wl, skb)) {
 586                 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
 587         } else if (wl->bss_type == BSS_TYPE_AP_BSS) {
 588                 u8 hlid = wl1271_tx_get_hlid(wl, skb);
 589                 skb_queue_head(&wl->links[hlid].tx_queue[q], skb);
 590
 591                 /* make sure we dequeue the same packet next time */
 592                 wl->last_tx_hlid = (hlid + AP_MAX_LINKS - 1) % AP_MAX_LINKS;
 593         } else {
 594                 skb_queue_head(&wl->tx_queue[q], skb);
 595         }
 596
 597         spin_lock_irqsave(&wl->wl_lock, flags);
 598         wl->tx_queue_count[q]++;
 599         spin_unlock_irqrestore(&wl->wl_lock, flags);
 600 }
 601
 602 static bool wl1271_tx_is_data_present(struct sk_buff *skb)
 603 {
 604         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)(skb->data);
 605
 606         return ieee80211_is_data_present(hdr->frame_control);
 607 }
 608
 609 void wl1271_tx_work_locked(struct wl1271 *wl)
 610 {
 611         struct sk_buff *skb;
 612         u32 buf_offset = 0;
 613         bool sent_packets = false;
 614         bool had_data = false;
 615         bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
 616         int ret;
 617
 618         if (unlikely(wl->state == WL1271_STATE_OFF))
 619                 return;
 620
 621         while ((skb = wl1271_skb_dequeue(wl))) {
 622                 if (wl1271_tx_is_data_present(skb))
 623                         had_data = true;
 624
 625                 ret = wl1271_prepare_tx_frame(wl, skb, buf_offset);
 626                 if (ret == -EAGAIN) {
 627                         /*
 628                          * Aggregation buffer is full.
 629                          * Flush buffer and try again.
 630                          */
 631                         wl1271_skb_queue_head(wl, skb);
 632                         wl1271_write(wl, WL1271_SLV_MEM_DATA, wl->aggr_buf,
 633                                      buf_offset, true);
 634                         sent_packets = true;
 635                         buf_offset = 0;
 636                         continue;
 637                 } else if (ret == -EBUSY) {
 638                         /*
 639                          * Firmware buffer is full.
 640                          * Queue back last skb, and stop aggregating.
 641                          */
 642                         wl1271_skb_queue_head(wl, skb);
 643                         /* No work left, avoid scheduling redundant tx work */
 644                         set_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
 645                         goto out_ack;
 646                 } else if (ret < 0) {
 647                         dev_kfree_skb(skb);
 648                         goto out_ack;
 649                 }
 650                 buf_offset += ret;
 651                 wl->tx_packets_count++;
 652         }
 653
 654 out_ack:
 655         if (buf_offset) {
 656                 wl1271_write(wl, WL1271_SLV_MEM_DATA, wl->aggr_buf,
 657                                 buf_offset, true);
 658                 sent_packets = true;
 659         }
 660         if (sent_packets) {
 661                 /*
 662                  * Interrupt the firmware with the new packets. This is only
 663                  * required for older hardware revisions
 664                  */
 665                 if (wl->quirks & WL12XX_QUIRK_END_OF_TRANSACTION)
 666                         wl1271_write32(wl, WL1271_HOST_WR_ACCESS,
 667                                        wl->tx_packets_count);
 668
 669                 wl1271_handle_tx_low_watermark(wl);
 670         }
 671         if (!is_ap && wl->conf.rx_streaming.interval && had_data &&
 672             (wl->conf.rx_streaming.always ||
 673              test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags))) {
 674                 u32 timeout = wl->conf.rx_streaming.duration;
 675
 676                 /* enable rx streaming */
 677                 if (!test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags))
 678                         ieee80211_queue_work(wl->hw,
 679                                              &wl->rx_streaming_enable_work);
 680
 681                 mod_timer(&wl->rx_streaming_timer,
 682                           jiffies + msecs_to_jiffies(timeout));
 683         }
 684 }
 685
 686 void wl1271_tx_work(struct work_struct *work)
 687 {
 688         struct wl1271 *wl = container_of(work, struct wl1271, tx_work);
 689         int ret;
 690
 691         mutex_lock(&wl->mutex);
 692         ret = wl1271_ps_elp_wakeup(wl);
 693         if (ret < 0)
 694                 goto out;
 695
 696         wl1271_tx_work_locked(wl);
 697
 698         wl1271_ps_elp_sleep(wl);
 699 out:
 700         mutex_unlock(&wl->mutex);
 701 }
 702
 703 static void wl1271_tx_complete_packet(struct wl1271 *wl,
 704                                       struct wl1271_tx_hw_res_descr *result)
 705 {
 706         struct ieee80211_tx_info *info;
 707         struct sk_buff *skb;
 708         int id = result->id;
 709         int rate = -1;
 710         u8 retries = 0;
 711
 712         /* check for id legality */
 713         if (unlikely(id >= ACX_TX_DESCRIPTORS || wl->tx_frames[id] == NULL)) {
 714                 wl1271_warning("TX result illegal id: %d", id);
 715                 return;
 716         }
 717
 718         skb = wl->tx_frames[id];
 719         info = IEEE80211_SKB_CB(skb);
 720
 721         if (wl12xx_is_dummy_packet(wl, skb)) {
 722                 wl1271_free_tx_id(wl, id);
 723                 return;
 724         }
 725
 726         /* update the TX status info */
 727         if (result->status == TX_SUCCESS) {
 728                 if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
 729                         info->flags |= IEEE80211_TX_STAT_ACK;
 730                 rate = wl1271_rate_to_idx(result->rate_class_index, wl->band);
 731                 retries = result->ack_failures;
 732         } else if (result->status == TX_RETRY_EXCEEDED) {
 733                 wl->stats.excessive_retries++;
 734                 retries = result->ack_failures;
 735         }
 736
 737         info->status.rates[0].idx = rate;
 738         info->status.rates[0].count = retries;
 739         info->status.rates[0].flags = 0;
 740         info->status.ack_signal = -1;
 741
 742         wl->stats.retry_count += result->ack_failures;
 743
 744         /*
 745          * update sequence number only when relevant, i.e. only in
 746          * sessions of TKIP, AES and GEM (not in open or WEP sessions)
 747          */
 748         if (info->control.hw_key &&
 749             (info->control.hw_key->cipher == WLAN_CIPHER_SUITE_TKIP ||
 750              info->control.hw_key->cipher == WLAN_CIPHER_SUITE_CCMP ||
 751              info->control.hw_key->cipher == WL1271_CIPHER_SUITE_GEM)) {
 752                 u8 fw_lsb = result->tx_security_sequence_number_lsb;
 753                 u8 cur_lsb = wl->tx_security_last_seq_lsb;
 754
 755                 /*
 756                  * update security sequence number, taking care of potential
 757                  * wrap-around
 758                  */
 759                 wl->tx_security_seq += (fw_lsb - cur_lsb + 256) % 256;
 760                 wl->tx_security_last_seq_lsb = fw_lsb;
 761         }
 762
 763         /* remove private header from packet */
 764         skb_pull(skb, sizeof(struct wl1271_tx_hw_descr));
 765
 766         /* remove TKIP header space if present */
 767         if (info->control.hw_key &&
 768             info->control.hw_key->cipher == WLAN_CIPHER_SUITE_TKIP) {
 769                 int hdrlen = ieee80211_get_hdrlen_from_skb(skb);
 770                 memmove(skb->data + WL1271_TKIP_IV_SPACE, skb->data, hdrlen);
 771                 skb_pull(skb, WL1271_TKIP_IV_SPACE);
 772         }
 773
 774         wl1271_debug(DEBUG_TX, "tx status id %u skb 0x%p failures %u rate 0x%x"
 775                      " status 0x%x",
 776                      result->id, skb, result->ack_failures,
 777                      result->rate_class_index, result->status);
 778
 779         /* return the packet to the stack */
 780         skb_queue_tail(&wl->deferred_tx_queue, skb);
 781         queue_work(wl->freezable_wq, &wl->netstack_work);
 782         wl1271_free_tx_id(wl, result->id);
 783 }
 784
 785 /* Called upon reception of a TX complete interrupt */
 786 void wl1271_tx_complete(struct wl1271 *wl)
 787 {
 788         struct wl1271_acx_mem_map *memmap =
 789                 (struct wl1271_acx_mem_map *)wl->target_mem_map;
 790         u32 count, fw_counter;
 791         u32 i;
 792
 793         /* read the tx results from the chipset */
 794         wl1271_read(wl, le32_to_cpu(memmap->tx_result),
 795                     wl->tx_res_if, sizeof(*wl->tx_res_if), false);
 796         fw_counter = le32_to_cpu(wl->tx_res_if->tx_result_fw_counter);
 797
 798         /* write host counter to chipset (to ack) */
 799         wl1271_write32(wl, le32_to_cpu(memmap->tx_result) +
 800                        offsetof(struct wl1271_tx_hw_res_if,
 801                                 tx_result_host_counter), fw_counter);
 802
 803         count = fw_counter - wl->tx_results_count;
 804         wl1271_debug(DEBUG_TX, "tx_complete received, packets: %d", count);
 805
 806         /* verify that the result buffer is not getting overrun */
 807         if (unlikely(count > TX_HW_RESULT_QUEUE_LEN))
 808                 wl1271_warning("TX result overflow from chipset: %d", count);
 809
 810         /* process the results */
 811         for (i = 0; i < count; i++) {
 812                 struct wl1271_tx_hw_res_descr *result;
 813                 u8 offset = wl->tx_results_count & TX_HW_RESULT_QUEUE_LEN_MASK;
 814
 815                 /* process the packet */
 816                 result =  &(wl->tx_res_if->tx_results_queue[offset]);
 817                 wl1271_tx_complete_packet(wl, result);
 818
 819                 wl->tx_results_count++;
 820         }
 821 }
 822
 823 void wl1271_tx_reset_link_queues(struct wl1271 *wl, u8 hlid)
 824 {
 825         struct sk_buff *skb;
 826         int i;
 827         unsigned long flags;
 828         struct ieee80211_tx_info *info;
 829         int total[NUM_TX_QUEUES];
 830
 831         for (i = 0; i < NUM_TX_QUEUES; i++) {
 832                 total[i] = 0;
 833                 while ((skb = skb_dequeue(&wl->links[hlid].tx_queue[i]))) {
 834                         wl1271_debug(DEBUG_TX, "link freeing skb 0x%p", skb);
 835
 836                         if (!wl12xx_is_dummy_packet(wl, skb)) {
 837                                 info = IEEE80211_SKB_CB(skb);
 838                                 info->status.rates[0].idx = -1;
 839                                 info->status.rates[0].count = 0;
 840                                 ieee80211_tx_status_ni(wl->hw, skb);
 841                         }
 842
 843                         total[i]++;
 844                 }
 845         }
 846
 847         spin_lock_irqsave(&wl->wl_lock, flags);
 848         for (i = 0; i < NUM_TX_QUEUES; i++)
 849                 wl->tx_queue_count[i] -= total[i];
 850         spin_unlock_irqrestore(&wl->wl_lock, flags);
 851
 852         wl1271_handle_tx_low_watermark(wl);
 853 }
 854
 855 /* caller must hold wl->mutex and TX must be stopped */
 856 void wl1271_tx_reset(struct wl1271 *wl, bool reset_tx_queues)
 857 {
 858         int i;
 859         struct sk_buff *skb;
 860         struct ieee80211_tx_info *info;
 861
 862         /* TX failure */
 863         if (wl->bss_type == BSS_TYPE_AP_BSS) {
 864                 for (i = 0; i < AP_MAX_LINKS; i++) {
 865                         wl1271_tx_reset_link_queues(wl, i);
 866                         wl->links[i].allocated_blks = 0;
 867                         wl->links[i].prev_freed_blks = 0;
 868                 }
 869
 870                 wl->last_tx_hlid = 0;
 871         } else {
 872                 for (i = 0; i < NUM_TX_QUEUES; i++) {
 873                         while ((skb = skb_dequeue(&wl->tx_queue[i]))) {
 874                                 wl1271_debug(DEBUG_TX, "freeing skb 0x%p",
 875                                              skb);
 876
 877                                 if (!wl12xx_is_dummy_packet(wl, skb)) {
 878                                         info = IEEE80211_SKB_CB(skb);
 879                                         info->status.rates[0].idx = -1;
 880                                         info->status.rates[0].count = 0;
 881                                         ieee80211_tx_status_ni(wl->hw, skb);
 882                                 }
 883                         }
 884                         wl->tx_queue_count[i] = 0;
 885                 }
 886         }
 887
 888         wl->stopped_queues_map = 0;
 889
 890         /*
 891          * Make sure the driver is at a consistent state, in case this
 892          * function is called from a context other than interface removal.
 893          * This call will always wake the TX queues.
 894          */
 895         if (reset_tx_queues)
 896                 wl1271_handle_tx_low_watermark(wl);
 897
 898         for (i = 0; i < ACX_TX_DESCRIPTORS; i++) {
 899                 if (wl->tx_frames[i] == NULL)
 900                         continue;
 901
 902                 skb = wl->tx_frames[i];
 903                 wl1271_free_tx_id(wl, i);
 904                 wl1271_debug(DEBUG_TX, "freeing skb 0x%p", skb);
 905
 906                 if (!wl12xx_is_dummy_packet(wl, skb)) {
 907                         /*
 908                          * Remove private headers before passing the skb to
 909                          * mac80211
 910                          */
 911                         info = IEEE80211_SKB_CB(skb);
 912                         skb_pull(skb, sizeof(struct wl1271_tx_hw_descr));
 913                         if (info->control.hw_key &&
 914                             info->control.hw_key->cipher ==
 915                             WLAN_CIPHER_SUITE_TKIP) {
 916                                 int hdrlen = ieee80211_get_hdrlen_from_skb(skb);
 917                                 memmove(skb->data + WL1271_TKIP_IV_SPACE,
 918                                         skb->data, hdrlen);
 919                                 skb_pull(skb, WL1271_TKIP_IV_SPACE);
 920                         }
 921
 922                         info->status.rates[0].idx = -1;
 923                         info->status.rates[0].count = 0;
 924
 925                         ieee80211_tx_status_ni(wl->hw, skb);
 926                 }
 927         }
 928 }
 929
 930 #define WL1271_TX_FLUSH_TIMEOUT 500000
 931
 932 /* caller must *NOT* hold wl->mutex */
 933 void wl1271_tx_flush(struct wl1271 *wl)
 934 {
 935         unsigned long timeout;
 936         timeout = jiffies + usecs_to_jiffies(WL1271_TX_FLUSH_TIMEOUT);
 937
 938         while (!time_after(jiffies, timeout)) {
 939                 mutex_lock(&wl->mutex);
 940                 wl1271_debug(DEBUG_TX, "flushing tx buffer: %d %d",
 941                              wl->tx_frames_cnt,
 942                              wl1271_tx_total_queue_count(wl));
 943                 if ((wl->tx_frames_cnt == 0) &&
 944                     (wl1271_tx_total_queue_count(wl) == 0)) {
 945                         mutex_unlock(&wl->mutex);
 946                         return;
 947                 }
 948                 mutex_unlock(&wl->mutex);
 949                 msleep(1);
 950         }
 951
 952         wl1271_warning("Unable to flush all TX buffers, timed out.");
 953 }
 954
 955 u32 wl1271_tx_min_rate_get(struct wl1271 *wl)
 956 {
 957         int i;
 958         u32 rate = 0;
 959
 960         if (!wl->basic_rate_set) {
 961                 WARN_ON(1);
 962                 wl->basic_rate_set = wl->conf.tx.basic_rate;
 963         }
 964
 965         for (i = 0; !rate; i++) {
 966                 if ((wl->basic_rate_set >> i) & 0x1)
 967                         rate = 1 << i;
 968         }
 969
 970         return rate;
 971 }