carlfw/src/wlantx.c

   1 /*
   2  * carl9170 firmware - used by the ar9170 wireless device
   3  *
   4  * WLAN transmit and tx status
   5  *
   6  * Copyright (c) 2000-2005 ZyDAS Technology Corporation
   7  * Copyright (c) 2007-2009 Atheros Communications, Inc.
   8  * Copyright    2009    Johannes Berg <johannes@sipsolutions.net>
   9  * Copyright 2009-2012  Christian Lamparter <chunkeey@googlemail.com>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License along
  22  * with this program; If not, see <http://www.gnu.org/licenses/>.
  23  */
  24
  25 #include "carl9170.h"
  26 #include "shared/phy.h"
  27 #include "hostif.h"
  28 #include "timer.h"
  29 #include "wl.h"
  30 #include "printf.h"
  31 #include "rf.h"
  32 #include "linux/ieee80211.h"
  33 #include "wol.h"
  34
  35 static void wlan_txunstuck(unsigned int qidx)
  36 {
  37         struct dma_queue *queue = &fw.wlan.tx_queue[qidx];
  38         struct dma_desc *iter;
  39
  40         /*
  41          * walk up to the last descriptor which hasn't been
  42          * processed by the hardware before it bailed out
  43          * due to a TX error.
  44          * Note: if there was no more "pending" frame
  45          * in the queue, it iter will be on the
  46          *    queue->terminator (which is fine)
  47          */
  48         __for_each_desc_bits(iter, queue, AR9170_OWN_BITS_SW);
  49
  50         set_wlan_txq_dma_addr(qidx, ((uint32_t) iter) | 1);
  51         wlan_trigger(BIT(qidx));
  52 }
  53
  54 #ifdef CONFIG_CARL9170FW_DMA_QUEUE_BUMP
  55 static void wlan_txupdate(unsigned int qidx)
  56 {
  57         struct dma_queue *queue = &fw.wlan.tx_queue[qidx];
  58         struct dma_desc *iter;
  59         /* comment in wlan_txunstuck applies here too. */
  60         __for_each_desc_bits(iter, queue, AR9170_OWN_BITS_SW);
  61
  62         set_wlan_txq_dma_addr(qidx, ((uint32_t) iter));
  63         wlan_trigger(BIT(qidx));
  64 }
  65
  66 void wlan_dma_bump(unsigned int qidx)
  67 {
  68         unsigned int offset = qidx;
  69         uint32_t status, trigger;
  70
  71         status = get(AR9170_MAC_REG_DMA_STATUS) >> 12;
  72         trigger = get(AR9170_MAC_REG_DMA_TRIGGER) >> 12;
  73
  74         while (offset != 0) {
  75                 status >>= 4;
  76                 trigger >>= 4;
  77                 offset--;
  78         }
  79
  80         status &= 0xf;
  81         trigger &= 0xf;
  82
  83         if ((trigger == 0xa) && (status == 0x8)) {
  84                 DBG("UNSTUCK");
  85                 wlan_txunstuck(qidx);
  86         } else {
  87                 DBG("UPDATE");
  88                 wlan_txupdate(qidx);
  89         }
  90 }
  91 #else
  92 void wlan_dma_bump(unsigned int __unused qidx)
  93 {
  94 }
  95 #endif /* CONFIG_CARL9170FW_DMA_QUEUE_BUMP */
  96
  97 void wlan_send_buffered_tx_status(void)
  98 {
  99         unsigned int len;
 100
 101         while (fw.wlan.tx_status_pending) {
 102                 len = min((unsigned int)fw.wlan.tx_status_pending,
 103                           CARL9170_RSP_TX_STATUS_NUM);
 104                 len = min(len, CARL9170_TX_STATUS_NUM - fw.wlan.tx_status_head_idx);
 105
 106                 /*
 107                  * rather than memcpy each individual request into a large buffer,
 108                  * we _splice_ them all together.
 109                  *
 110                  * The only downside is however that we have to be careful around
 111                  * the edges of the tx_status_cache.
 112                  *
 113                  * Note:
 114                  * Each tx_status is about 2 bytes. However every command package
 115                  * must have a size which is a multiple of 4.
 116                  */
 117
 118                 send_cmd_to_host((len * sizeof(struct carl9170_tx_status) + 3) & ~3,
 119                                  CARL9170_RSP_TXCOMP, len, (void *)
 120                                  &fw.wlan.tx_status_cache[fw.wlan.tx_status_head_idx]);
 121
 122                 fw.wlan.tx_status_pending -= len;
 123                 fw.wlan.tx_status_head_idx += len;
 124                 fw.wlan.tx_status_head_idx %= CARL9170_TX_STATUS_NUM;
 125         }
 126 }
 127
 128 static struct carl9170_tx_status *wlan_get_tx_status_buffer(void)
 129 {
 130         struct carl9170_tx_status *tmp;
 131
 132         tmp = &fw.wlan.tx_status_cache[fw.wlan.tx_status_tail_idx++];
 133         fw.wlan.tx_status_tail_idx %= CARL9170_TX_STATUS_NUM;
 134
 135         if (fw.wlan.tx_status_pending == CARL9170_TX_STATUS_NUM)
 136                 wlan_send_buffered_tx_status();
 137
 138         fw.wlan.tx_status_pending++;
 139
 140         return tmp;
 141 }
 142
 143 /* generate _aggregated_ tx_status for the host */
 144 void wlan_tx_complete(struct carl9170_tx_superframe *super,
 145                       bool txs)
 146 {
 147         struct carl9170_tx_status *status;
 148
 149         status = wlan_get_tx_status_buffer();
 150
 151         /*
 152          * The *unique* cookie and AC_ID is used by the driver for
 153          * frame lookup.
 154          */
 155         status->cookie = super->s.cookie;
 156         status->queue = super->s.queue;
 157         super->s.cookie = 0;
 158
 159         /*
 160          * This field holds the number of tries of the rate in
 161          * the rate index field (rix).
 162          */
 163         status->rix = super->s.rix;
 164         status->tries = super->s.cnt;
 165         status->success = (txs) ? 1 : 0;
 166 }
 167
 168 static bool wlan_tx_consume_retry(struct carl9170_tx_superframe *super)
 169 {
 170         /* check if this was the last possible retry with this rate */
 171         if (unlikely(super->s.cnt >= super->s.ri[super->s.rix].tries)) {
 172                 /* end of the road - indicate tx failure */
 173                 if (unlikely(super->s.rix == CARL9170_TX_MAX_RETRY_RATES))
 174                         return false;
 175
 176                 /* check if there are alternative rates available */
 177                 if (!super->s.rr[super->s.rix].set)
 178                         return false;
 179
 180                 /* try next retry rate */
 181                 super->f.hdr.phy.set = super->s.rr[super->s.rix].set;
 182
 183                 /* finally - mark the old rate as USED */
 184                 super->s.rix++;
 185
 186                 /* update MAC flags */
 187                 super->f.hdr.mac.erp_prot = super->s.ri[super->s.rix].erp_prot;
 188                 super->f.hdr.mac.ampdu = super->s.ri[super->s.rix].ampdu;
 189
 190                 /* reinitialize try counter */
 191                 super->s.cnt = 1;
 192         } else {
 193                 /* just increase retry counter */
 194                 super->s.cnt++;
 195         }
 196
 197         return true;
 198 }
 199
 200 static inline u16 get_tid(struct ieee80211_hdr *hdr)
 201 {
 202         return (ieee80211_get_qos_ctl(hdr))[0] & IEEE80211_QOS_CTL_TID_MASK;
 203 }
 204
 205 /* This function will only work on uint32_t-aligned pointers! */
 206 static bool same_hdr(const void *_d0, const void *_d1)
 207 {
 208         const uint32_t *d0 = _d0;
 209         const uint32_t *d1 = _d1;
 210
 211         /* BUG_ON((unsigned long)d0 & 3 || (unsigned long)d1 & 3)) */
 212         return !((d0[0] ^ d1[0]) |                      /* FC + DU */
 213                  (d0[1] ^ d1[1]) |                      /* addr1 */
 214                  (d0[2] ^ d1[2]) | (d0[3] ^ d1[3]) |    /* addr2 + addr3 */
 215                  (d0[4] ^ d1[4]));                      /* addr3 */
 216 }
 217
 218 static inline bool same_aggr(struct ieee80211_hdr *a, struct ieee80211_hdr *b)
 219 {
 220         return (get_tid(a) == get_tid(b)) || same_hdr(a, b);
 221 }
 222
 223 static void wlan_tx_ampdu_reset(unsigned int qidx)
 224 {
 225         fw.wlan.ampdu_prev[qidx] = NULL;
 226 }
 227
 228 static void wlan_tx_ampdu_end(unsigned int qidx)
 229 {
 230         struct carl9170_tx_superframe *ht_prev = fw.wlan.ampdu_prev[qidx];
 231
 232         if (ht_prev)
 233                 ht_prev->f.hdr.mac.ba_end = 1;
 234
 235         wlan_tx_ampdu_reset(qidx);
 236 }
 237
 238 static void wlan_tx_ampdu(struct carl9170_tx_superframe *super)
 239 {
 240         unsigned int qidx = super->s.queue;
 241         struct carl9170_tx_superframe *ht_prev = fw.wlan.ampdu_prev[qidx];
 242
 243         if (super->f.hdr.mac.ampdu) {
 244                 if (ht_prev &&
 245                     !same_aggr(&super->f.data.i3e, &ht_prev->f.data.i3e))
 246                         ht_prev->f.hdr.mac.ba_end = 1;
 247                 else
 248                         super->f.hdr.mac.ba_end = 0;
 249
 250                 fw.wlan.ampdu_prev[qidx] = super;
 251         } else {
 252                 wlan_tx_ampdu_end(qidx);
 253         }
 254 }
 255
 256 /* for all tries */
 257 static void __wlan_tx(struct dma_desc *desc)
 258 {
 259         struct carl9170_tx_superframe *super = get_super(desc);
 260
 261         if (unlikely(super->s.fill_in_tsf)) {
 262                 struct ieee80211_mgmt *mgmt = (void *) &super->f.data.i3e;
 263                 uint32_t tmptsf[2];
 264
 265                 /*
 266                  * Truth be told: this is a hack.
 267                  *
 268                  * The *real* TSF is definitely going to be higher/older.
 269                  * But this hardware emulation code is head and shoulders
 270                  * above anything a driver can possibly do.
 271                  *
 272                  * (even, if it's got an accurate atomic clock source).
 273                  */
 274
 275                 read_tsf(tmptsf);
 276                 memcpy(&mgmt->u.probe_resp.timestamp, tmptsf, sizeof(tmptsf));
 277         }
 278
 279         wlan_tx_ampdu(super);
 280
 281 #if (defined CONFIG_CARL9170FW_DEBUG) && (defined CONFIG_CARL9170FW_RADIO_FUNCTIONS)
 282         BUG_ON(fw.phy.psm.state != CARL9170_PSM_WAKE);
 283 #endif /* CONFIG_CARL9170FW_DEBUG && CONFIG_CARL9170FW_RADIO_FUNCTIONS */
 284
 285         /* insert desc into the right queue */
 286         dma_put(&fw.wlan.tx_queue[super->s.queue], desc);
 287 }
 288
 289 static void wlan_assign_seq(struct ieee80211_hdr *hdr, unsigned int vif)
 290 {
 291         hdr->seq_ctrl &= cpu_to_le16(~IEEE80211_SCTL_SEQ);
 292         hdr->seq_ctrl |= cpu_to_le16(fw.wlan.sequence[vif]);
 293
 294         if (ieee80211_is_first_frag(hdr->seq_ctrl))
 295                 fw.wlan.sequence[vif] += 0x10;
 296 }
 297
 298 /* prepares frame for the first transmission */
 299 static void _wlan_tx(struct dma_desc *desc)
 300 {
 301         struct carl9170_tx_superframe *super = get_super(desc);
 302
 303         if (unlikely(super->s.assign_seq))
 304                 wlan_assign_seq(&super->f.data.i3e, super->s.vif_id);
 305
 306         if (unlikely(super->s.ampdu_commit_density)) {
 307                 set(AR9170_MAC_REG_AMPDU_DENSITY,
 308                     MOD_VAL(AR9170_MAC_AMPDU_DENSITY,
 309                             get(AR9170_MAC_REG_AMPDU_DENSITY),
 310                             super->s.ampdu_density));
 311         }
 312
 313         if (unlikely(super->s.ampdu_commit_factor)) {
 314                 set(AR9170_MAC_REG_AMPDU_FACTOR,
 315                     MOD_VAL(AR9170_MAC_AMPDU_FACTOR,
 316                             get(AR9170_MAC_REG_AMPDU_FACTOR),
 317                             8 << super->s.ampdu_factor));
 318         }
 319 }
 320
 321 /* propagate transmission status back to the driver */
 322 static bool wlan_tx_status(struct dma_queue *queue,
 323                            struct dma_desc *desc)
 324 {
 325         struct carl9170_tx_superframe *super = get_super(desc);
 326         unsigned int qidx = super->s.queue;
 327         bool txfail = false, success;
 328
 329         success = true;
 330
 331         /* update hangcheck */
 332         fw.wlan.last_super_num[qidx] = 0;
 333
 334         /*
 335          * Note:
 336          * There could be a corner case when the TXFAIL is set
 337          * even though the frame was properly ACKed by the peer:
 338          *   a BlockAckReq with the immediate policy will cause
 339          *   the receiving peer to produce a BlockACK unfortunately
 340          *   the MAC in this chip seems to be expecting a legacy
 341          *   ACK and marks the BAR as failed!
 342          */
 343
 344         if (!!(desc->ctrl & AR9170_CTRL_FAIL)) {
 345                 txfail = !!(desc->ctrl & AR9170_CTRL_TXFAIL);
 346
 347                 /* reset retry indicator flags */
 348                 desc->ctrl &= ~(AR9170_CTRL_TXFAIL | AR9170_CTRL_BAFAIL);
 349
 350                 /*
 351                  * Note: wlan_tx_consume_retry will override the old
 352                  * phy [CCK,OFDM, HT, BW20/40, MCS...] and mac vectors
 353                  * [AMPDU,RTS/CTS,...] therefore be careful when they
 354                  * are used.
 355                  */
 356                 if (wlan_tx_consume_retry(super)) {
 357                         /*
 358                          * retry for simple and aggregated 802.11 frames.
 359                          *
 360                          * Note: We must not mess up the original frame
 361                          * order.
 362                          */
 363
 364                         if (!super->f.hdr.mac.ampdu) {
 365                                 /*
 366                                  * 802.11 - 7.1.3.1.5.
 367                                  * set "Retry Field" for consecutive attempts
 368                                  *
 369                                  * Note: For AMPDU see:
 370                                  * 802.11n 9.9.1.6 "Retransmit Procedures"
 371                                  */
 372                                 super->f.data.i3e.frame_control |=
 373                                         cpu_to_le16(IEEE80211_FCTL_RETRY);
 374                         }
 375
 376                         if (txfail) {
 377                                 /* Normal TX Failure */
 378
 379                                 /* demise descriptor ownership back to the hardware */
 380                                 dma_rearm(desc);
 381
 382                                 /*
 383                                  * And this will get the queue going again.
 384                                  * To understand why: you have to get the HW
 385                                  * specs... But sadly I never saw them.
 386                                  */
 387                                 wlan_txunstuck(qidx);
 388
 389                                 /* abort cycle - this is necessary due to HW design */
 390                                 goto out;
 391                         } else {
 392                                 /* (HT-) BlockACK failure */
 393
 394                                 /*
 395                                  * Unlink the failed attempt and put it into
 396                                  * the retry queue. The caller routine must
 397                                  * be aware of this so the frames don't get lost.
 398                                  */
 399
 400 #ifndef CONFIG_CARL9170FW_DEBUG
 401                                 dma_unlink_head(queue);
 402 #else /* CONFIG_CARL9170FW_DEBUG */
 403                                 BUG_ON(dma_unlink_head(queue) != desc);
 404 #endif /* CONFIG_CARL9170FW_DEBUG */
 405                                 dma_put(&fw.wlan.tx_retry, desc);
 406                                 goto out;
 407                         }
 408                 } else {
 409                         /* out of frame attempts - discard frame */
 410                         success = false;
 411                 }
 412         }
 413
 414 #ifndef CONFIG_CARL9170FW_DEBUG
 415         dma_unlink_head(queue);
 416 #else /* CONFIG_CARL9170FW_DEBUG */
 417         BUG_ON(dma_unlink_head(queue) != desc);
 418 #endif /* CONFIG_CARL9170FW_DEBUG */
 419         if (txfail) {
 420                 /*
 421                  * Issue the queue bump,
 422                  * We need to do this in case this was the frame's last
 423                  * possible retry attempt and it unfortunately: it failed.
 424                  */
 425
 426                 wlan_txunstuck(qidx);
 427         }
 428
 429         unhide_super(desc);
 430
 431         if (unlikely(super == fw.wlan.fw_desc_data)) {
 432                 fw.wlan.fw_desc = desc;
 433                 fw.wlan.fw_desc_available = 1;
 434
 435                 if (fw.wlan.fw_desc_callback)
 436                         fw.wlan.fw_desc_callback(super, success);
 437
 438                 goto out;
 439         }
 440
 441         if (unlikely(super->s.cab))
 442                 fw.wlan.cab_queue_len[super->s.vif_id]--;
 443
 444         wlan_tx_complete(super, success);
 445
 446         if (ieee80211_is_back_req(super->f.data.i3e.frame_control)) {
 447                 fw.wlan.queued_bar--;
 448         }
 449
 450         /* recycle freed descriptors */
 451         dma_reclaim(&fw.pta.down_queue, desc);
 452         down_trigger();
 453 out:
 454         /*
 455          * if we encounter a frame which run out of (normal)
 456          * tx retries we have to stop too.
 457          */
 458         return !txfail;
 459 }
 460
 461 void handle_wlan_tx_completion(void)
 462 {
 463         struct dma_desc *desc;
 464         int i;
 465
 466         for (i = AR9170_TXQ_SPECIAL; i >= AR9170_TXQ0; i--) {
 467                 __while_desc_bits(desc, &fw.wlan.tx_queue[i], AR9170_OWN_BITS_SW) {
 468                         if (!wlan_tx_status(&fw.wlan.tx_queue[i], desc)) {
 469                                 /* termination requested. */
 470                                 break;
 471                         }
 472                 }
 473
 474                 wlan_tx_ampdu_reset(i);
 475
 476                 for_each_desc(desc, &fw.wlan.tx_retry)
 477                         __wlan_tx(desc);
 478
 479                 wlan_tx_ampdu_end(i);
 480                 if (!queue_empty(&fw.wlan.tx_queue[i]))
 481                         wlan_trigger(BIT(i));
 482         }
 483 }
 484
 485 void __hot wlan_tx(struct dma_desc *desc)
 486 {
 487         struct carl9170_tx_superframe *super = DESC_PAYLOAD(desc);
 488
 489         if (ieee80211_is_back_req(super->f.data.i3e.frame_control)) {
 490                 fw.wlan.queued_bar++;
 491         }
 492
 493         /* initialize rate control struct */
 494         super->s.rix = 0;
 495         super->s.cnt = 1;
 496         hide_super(desc);
 497
 498         if (unlikely(super->s.cab)) {
 499                 fw.wlan.cab_queue_len[super->s.vif_id]++;
 500                 dma_put(&fw.wlan.cab_queue[super->s.vif_id], desc);
 501                 return;
 502         }
 503
 504         _wlan_tx(desc);
 505         __wlan_tx(desc);
 506         wlan_trigger(BIT(super->s.queue));
 507 }
 508
 509 void wlan_tx_fw(struct carl9170_tx_superdesc *super, fw_desc_callback_t cb)
 510 {
 511         if (!fw.wlan.fw_desc_available)
 512                 return;
 513
 514         fw.wlan.fw_desc_available = 0;
 515
 516         /* Format BlockAck */
 517         fw.wlan.fw_desc->ctrl = AR9170_CTRL_FS_BIT | AR9170_CTRL_LS_BIT;
 518         fw.wlan.fw_desc->status = AR9170_OWN_BITS_SW;
 519
 520         fw.wlan.fw_desc->totalLen = fw.wlan.fw_desc->dataSize = super->len;
 521         fw.wlan.fw_desc_data = fw.wlan.fw_desc->dataAddr = super;
 522         fw.wlan.fw_desc->nextAddr = fw.wlan.fw_desc->lastAddr =
 523                 fw.wlan.fw_desc;
 524         fw.wlan.fw_desc_callback = cb;
 525         wlan_tx(fw.wlan.fw_desc);
 526 }
 527
 528 void wlan_send_buffered_ba(void)
 529 {
 530         struct carl9170_tx_ba_superframe *baf = &dma_mem.reserved.ba.ba;
 531         struct ieee80211_ba *ba = (struct ieee80211_ba *) &baf->f.ba;
 532         struct carl9170_bar_ctx *ctx;
 533
 534         if (likely(!fw.wlan.queued_ba))
 535                 return;
 536
 537         /* there's no point to continue when the ba_desc is not available. */
 538         if (!fw.wlan.fw_desc_available)
 539                 return;
 540
 541         ctx = &fw.wlan.ba_cache[fw.wlan.ba_head_idx];
 542         fw.wlan.ba_head_idx++;
 543         fw.wlan.ba_head_idx %= CONFIG_CARL9170FW_BACK_REQS_NUM;
 544         fw.wlan.queued_ba--;
 545
 546         baf->s.len = sizeof(struct carl9170_tx_superdesc) +
 547                      sizeof(struct ar9170_tx_hwdesc) +
 548                      sizeof(struct ieee80211_ba);
 549         baf->s.ri[0].tries = 1;
 550         baf->s.cookie = 0;
 551         baf->s.queue = AR9170_TXQ_VO;
 552         baf->f.hdr.length = sizeof(struct ieee80211_ba) + FCS_LEN;
 553
 554         baf->f.hdr.mac.no_ack = 1;
 555
 556         baf->f.hdr.phy.modulation = 1; /* OFDM */
 557         baf->f.hdr.phy.tx_power = 34; /* 17 dBm */
 558         baf->f.hdr.phy.chains = 1;
 559         baf->f.hdr.phy.mcs = AR9170_TXRX_PHY_RATE_OFDM_6M;
 560
 561         /* format outgoing BA */
 562         ba->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_BACK);
 563         ba->duration = cpu_to_le16(0);
 564
 565         /* the BAR contains all necessary MACs. All we need is to swap them */
 566         memcpy(ba->ra, ctx->ta, 6);
 567         memcpy(ba->ta, ctx->ra, 6);
 568
 569         /*
 570          * Unfortunately, we cannot look into the hardware's scoreboard.
 571          * Therefore we have to proceed as described in 802.11n 9.10.7.5
 572          * and send a null BlockAck.
 573          */
 574         memset(ba->bitmap, 0x0, sizeof(ba->bitmap));
 575
 576         /*
 577          * Both, the original firmare and ath9k set the NO ACK flag in
 578          * the BA Ack Policy subfield.
 579          */
 580         ba->control = ctx->control | cpu_to_le16(1);
 581         ba->start_seq_num = ctx->start_seq_num;
 582         wlan_tx_fw(&baf->s, NULL);
 583 }
 584
 585 void wlan_cab_flush_queue(const unsigned int vif)
 586 {
 587         struct dma_queue *cab_queue = &fw.wlan.cab_queue[vif];
 588         struct dma_desc *desc;
 589
 590         /* move queued frames into the main tx queues */
 591         for_each_desc(desc, cab_queue) {
 592                 struct carl9170_tx_superframe *super = get_super(desc);
 593                 if (!queue_empty(cab_queue)) {
 594                         /*
 595                          * Set MOREDATA flag for all,
 596                          * but the last queued frame.
 597                          * see: 802.11-2007 11.2.1.5 f)
 598                          *
 599                          * This is actually the reason to why
 600                          * we need to prevent the reentry.
 601                          */
 602
 603                         super->f.data.i3e.frame_control |=
 604                                 cpu_to_le16(IEEE80211_FCTL_MOREDATA);
 605                 } else {
 606                         super->f.data.i3e.frame_control &=
 607                                 cpu_to_le16(~IEEE80211_FCTL_MOREDATA);
 608                 }
 609
 610                 /* ready to roll! */
 611                 _wlan_tx(desc);
 612                 __wlan_tx(desc);
 613                 wlan_trigger(BIT(super->s.queue));
 614         }
 615 }
 616
 617 static uint8_t *beacon_find_ie(uint8_t ie, void *addr,
 618                                const unsigned int len)
 619 {
 620         struct ieee80211_mgmt *mgmt = addr;
 621         uint8_t *pos, *end;
 622
 623         pos = mgmt->u.beacon.variable;
 624         end = (uint8_t *) ((unsigned long)mgmt + (len - FCS_LEN));
 625         while (pos < end) {
 626                 if (pos + 2 + pos[1] > end)
 627                         return NULL;
 628
 629                 if (pos[0] == ie)
 630                         return pos;
 631
 632                 pos += pos[1] + 2;
 633         }
 634
 635         return NULL;
 636 }
 637
 638 void wlan_modify_beacon(const unsigned int vif,
 639         const unsigned int addr, const unsigned int len)
 640 {
 641         uint8_t *_ie;
 642         struct ieee80211_tim_ie *ie;
 643
 644         _ie = beacon_find_ie(WLAN_EID_TIM, (void *)addr, len);
 645         if (likely(_ie)) {
 646                 ie = (struct ieee80211_tim_ie *) &_ie[2];
 647
 648                 if (!queue_empty(&fw.wlan.cab_queue[vif]) && (ie->dtim_count == 0)) {
 649                         /* schedule DTIM transfer */
 650                         fw.wlan.cab_flush_trigger[vif] = CARL9170_CAB_TRIGGER_ARMED;
 651                 } else if ((fw.wlan.cab_queue_len[vif] == 0) && (fw.wlan.cab_flush_trigger[vif])) {
 652                         /* undo all chances to the beacon structure */
 653                         ie->bitmap_ctrl &= ~0x1;
 654                         fw.wlan.cab_flush_trigger[vif] = CARL9170_CAB_TRIGGER_EMPTY;
 655                 }
 656
 657                 /* Triggered by CARL9170_CAB_TRIGGER_ARMED || CARL9170_CAB_TRIGGER_DEFER */
 658                 if (fw.wlan.cab_flush_trigger[vif]) {
 659                         /* Set the almighty Multicast Traffic Indication Bit. */
 660                         ie->bitmap_ctrl |= 0x1;
 661                 }
 662         }
 663
 664         /*
 665          * Ideally, the sequence number should be assigned by the TX arbiter
 666          * hardware. But AFAIK that's not possible, so we have to go for the
 667          * next best thing and write it into the beacon fifo during the open
 668          * beacon update window.
 669          */
 670
 671         wlan_assign_seq((struct ieee80211_hdr *)addr, vif);
 672 }
 673
 674 void wlan_send_buffered_cab(void)
 675 {
 676         unsigned int i;
 677
 678         for (i = 0; i < CARL9170_INTF_NUM; i++) {
 679                 if (unlikely(fw.wlan.cab_flush_trigger[i] == CARL9170_CAB_TRIGGER_ARMED)) {
 680                         /*
 681                          * This is hardcoded into carl9170usb driver.
 682                          *
 683                          * The driver must set the PRETBTT event to beacon_interval -
 684                          * CARL9170_PRETBTT_KUS (usually 6) Kus.
 685                          *
 686                          * But still, we can only do so much about 802.11-2007 9.3.2.1 &
 687                          * 11.2.1.6. Let's hope the current solution is adequate enough.
 688                          */
 689
 690                         if (is_after_msecs(fw.wlan.cab_flush_time, (CARL9170_TBTT_DELTA))) {
 691                                 wlan_cab_flush_queue(i);
 692
 693                                 /*
 694                                  * This prevents the code from sending new BC/MC frames
 695                                  * which were queued after the previous buffered traffic
 696                                  * has been sent out... They will have to wait until the
 697                                  * next DTIM beacon comes along.
 698                                  */
 699                                 fw.wlan.cab_flush_trigger[i] = CARL9170_CAB_TRIGGER_DEFER;
 700                         }
 701                 }
 702
 703         }
 704 }