drivers/net/wireless/ath/carl9170/rx.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
carl9170_dbg_message
carl9170_handle_ps
carl9170_check_sequence
carl9170_cmd_callback
carl9170_handle_command_response
carl9170_rx_mac_status
carl9170_rx_phy_status
carl9170_rx_copy_data
carl9170_find_ie
carl9170_ps_beacon
carl9170_ba_check
carl9170_ampdu_check
carl9170_handle_mpdu
carl9170_rx_untie_data
carl9170_rx_untie_cmds
__carl9170_rx
carl9170_rx_stream
carl9170_rx
   1 /*
   2  * Atheros CARL9170 driver
   3  *
   4  * 802.11 & command trap routines
   5  *
   6  * Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
   7  * Copyright 2009, 2010, Christian Lamparter <chunkeey@googlemail.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; see the file COPYING.  If not, see
  21  * http://www.gnu.org/licenses/.
  22  *
  23  * This file incorporates work covered by the following copyright and
  24  * permission notice:
  25  *    Copyright (c) 2007-2008 Atheros Communications, Inc.
  26  *
  27  *    Permission to use, copy, modify, and/or distribute this software for any
  28  *    purpose with or without fee is hereby granted, provided that the above
  29  *    copyright notice and this permission notice appear in all copies.
  30  *
  31  *    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  32  *    WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  33  *    MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  34  *    ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  35  *    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  36  *    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  37  *    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  38  */
  39 
  40 #include <linux/slab.h>
  41 #include <linux/module.h>
  42 #include <linux/etherdevice.h>
  43 #include <linux/crc32.h>
  44 #include <net/mac80211.h>
  45 #include "carl9170.h"
  46 #include "hw.h"
  47 #include "cmd.h"
  48 
  49 static void carl9170_dbg_message(struct ar9170 *ar, const char *buf, u32 len)
  50 {
  51         bool restart = false;
  52         enum carl9170_restart_reasons reason = CARL9170_RR_NO_REASON;
  53 
  54         if (len > 3) {
  55                 if (memcmp(buf, CARL9170_ERR_MAGIC, 3) == 0) {
  56                         ar->fw.err_counter++;
  57                         if (ar->fw.err_counter > 3) {
  58                                 restart = true;
  59                                 reason = CARL9170_RR_TOO_MANY_FIRMWARE_ERRORS;
  60                         }
  61                 }
  62 
  63                 if (memcmp(buf, CARL9170_BUG_MAGIC, 3) == 0) {
  64                         ar->fw.bug_counter++;
  65                         restart = true;
  66                         reason = CARL9170_RR_FATAL_FIRMWARE_ERROR;
  67                 }
  68         }
  69 
  70         wiphy_info(ar->hw->wiphy, "FW: %.*s\n", len, buf);
  71 
  72         if (restart)
  73                 carl9170_restart(ar, reason);
  74 }
  75 
  76 static void carl9170_handle_ps(struct ar9170 *ar, struct carl9170_rsp *rsp)
  77 {
  78         u32 ps;
  79         bool new_ps;
  80 
  81         ps = le32_to_cpu(rsp->psm.state);
  82 
  83         new_ps = (ps & CARL9170_PSM_COUNTER) != CARL9170_PSM_WAKE;
  84         if (ar->ps.state != new_ps) {
  85                 if (!new_ps) {
  86                         ar->ps.sleep_ms = jiffies_to_msecs(jiffies -
  87                                 ar->ps.last_action);
  88                 }
  89 
  90                 ar->ps.last_action = jiffies;
  91 
  92                 ar->ps.state = new_ps;
  93         }
  94 }
  95 
  96 static int carl9170_check_sequence(struct ar9170 *ar, unsigned int seq)
  97 {
  98         if (ar->cmd_seq < -1)
  99                 return 0;
 100 
 101         /*
 102          * Initialize Counter
 103          */
 104         if (ar->cmd_seq < 0)
 105                 ar->cmd_seq = seq;
 106 
 107         /*
 108          * The sequence is strictly monotonic increasing and it never skips!
 109          *
 110          * Therefore we can safely assume that whenever we received an
 111          * unexpected sequence we have lost some valuable data.
 112          */
 113         if (seq != ar->cmd_seq) {
 114                 int count;
 115 
 116                 count = (seq - ar->cmd_seq) % ar->fw.cmd_bufs;
 117 
 118                 wiphy_err(ar->hw->wiphy, "lost %d command responses/traps! "
 119                           "w:%d g:%d\n", count, ar->cmd_seq, seq);
 120 
 121                 carl9170_restart(ar, CARL9170_RR_LOST_RSP);
 122                 return -EIO;
 123         }
 124 
 125         ar->cmd_seq = (ar->cmd_seq + 1) % ar->fw.cmd_bufs;
 126         return 0;
 127 }
 128 
 129 static void carl9170_cmd_callback(struct ar9170 *ar, u32 len, void *buffer)
 130 {
 131         /*
 132          * Some commands may have a variable response length
 133          * and we cannot predict the correct length in advance.
 134          * So we only check if we provided enough space for the data.
 135          */
 136         if (unlikely(ar->readlen != (len - 4))) {
 137                 dev_warn(&ar->udev->dev, "received invalid command response:"
 138                          "got %d, instead of %d\n", len - 4, ar->readlen);
 139                 print_hex_dump_bytes("carl9170 cmd:", DUMP_PREFIX_OFFSET,
 140                         ar->cmd_buf, (ar->cmd.hdr.len + 4) & 0x3f);
 141                 print_hex_dump_bytes("carl9170 rsp:", DUMP_PREFIX_OFFSET,
 142                         buffer, len);
 143                 /*
 144                  * Do not complete. The command times out,
 145                  * and we get a stack trace from there.
 146                  */
 147                 carl9170_restart(ar, CARL9170_RR_INVALID_RSP);
 148         }
 149 
 150         spin_lock(&ar->cmd_lock);
 151         if (ar->readbuf) {
 152                 if (len >= 4)
 153                         memcpy(ar->readbuf, buffer + 4, len - 4);
 154 
 155                 ar->readbuf = NULL;
 156         }
 157         complete(&ar->cmd_wait);
 158         spin_unlock(&ar->cmd_lock);
 159 }
 160 
 161 void carl9170_handle_command_response(struct ar9170 *ar, void *buf, u32 len)
 162 {
 163         struct carl9170_rsp *cmd = buf;
 164         struct ieee80211_vif *vif;
 165 
 166         if ((cmd->hdr.cmd & CARL9170_RSP_FLAG) != CARL9170_RSP_FLAG) {
 167                 if (!(cmd->hdr.cmd & CARL9170_CMD_ASYNC_FLAG))
 168                         carl9170_cmd_callback(ar, len, buf);
 169 
 170                 return;
 171         }
 172 
 173         if (unlikely(cmd->hdr.len != (len - 4))) {
 174                 if (net_ratelimit()) {
 175                         wiphy_err(ar->hw->wiphy, "FW: received over-/under"
 176                                 "sized event %x (%d, but should be %d).\n",
 177                                cmd->hdr.cmd, cmd->hdr.len, len - 4);
 178 
 179                         print_hex_dump_bytes("dump:", DUMP_PREFIX_NONE,
 180                                              buf, len);
 181                 }
 182 
 183                 return;
 184         }
 185 
 186         /* hardware event handlers */
 187         switch (cmd->hdr.cmd) {
 188         case CARL9170_RSP_PRETBTT:
 189                 /* pre-TBTT event */
 190                 rcu_read_lock();
 191                 vif = carl9170_get_main_vif(ar);
 192 
 193                 if (!vif) {
 194                         rcu_read_unlock();
 195                         break;
 196                 }
 197 
 198                 switch (vif->type) {
 199                 case NL80211_IFTYPE_STATION:
 200                         carl9170_handle_ps(ar, cmd);
 201                         break;
 202 
 203                 case NL80211_IFTYPE_AP:
 204                 case NL80211_IFTYPE_ADHOC:
 205                 case NL80211_IFTYPE_MESH_POINT:
 206                         carl9170_update_beacon(ar, true);
 207                         break;
 208 
 209                 default:
 210                         break;
 211                 }
 212                 rcu_read_unlock();
 213 
 214                 break;
 215 
 216 
 217         case CARL9170_RSP_TXCOMP:
 218                 /* TX status notification */
 219                 carl9170_tx_process_status(ar, cmd);
 220                 break;
 221 
 222         case CARL9170_RSP_BEACON_CONFIG:
 223                 /*
 224                  * (IBSS) beacon send notification
 225                  * bytes: 04 c2 XX YY B4 B3 B2 B1
 226                  *
 227                  * XX always 80
 228                  * YY always 00
 229                  * B1-B4 "should" be the number of send out beacons.
 230                  */
 231                 break;
 232 
 233         case CARL9170_RSP_ATIM:
 234                 /* End of Atim Window */
 235                 break;
 236 
 237         case CARL9170_RSP_WATCHDOG:
 238                 /* Watchdog Interrupt */
 239                 carl9170_restart(ar, CARL9170_RR_WATCHDOG);
 240                 break;
 241 
 242         case CARL9170_RSP_TEXT:
 243                 /* firmware debug */
 244                 carl9170_dbg_message(ar, (char *)buf + 4, len - 4);
 245                 break;
 246 
 247         case CARL9170_RSP_HEXDUMP:
 248                 wiphy_dbg(ar->hw->wiphy, "FW: HD %d\n", len - 4);
 249                 print_hex_dump_bytes("FW:", DUMP_PREFIX_NONE,
 250                                      (char *)buf + 4, len - 4);
 251                 break;
 252 
 253         case CARL9170_RSP_RADAR:
 254                 if (!net_ratelimit())
 255                         break;
 256 
 257                 wiphy_info(ar->hw->wiphy, "FW: RADAR! Please report this "
 258                        "incident to linux-wireless@vger.kernel.org !\n");
 259                 break;
 260 
 261         case CARL9170_RSP_GPIO:
 262 #ifdef CONFIG_CARL9170_WPC
 263                 if (ar->wps.pbc) {
 264                         bool state = !!(cmd->gpio.gpio & cpu_to_le32(
 265                                 AR9170_GPIO_PORT_WPS_BUTTON_PRESSED));
 266 
 267                         if (state != ar->wps.pbc_state) {
 268                                 ar->wps.pbc_state = state;
 269                                 input_report_key(ar->wps.pbc, KEY_WPS_BUTTON,
 270                                                  state);
 271                                 input_sync(ar->wps.pbc);
 272                         }
 273                 }
 274 #endif /* CONFIG_CARL9170_WPC */
 275                 break;
 276 
 277         case CARL9170_RSP_BOOT:
 278                 complete(&ar->fw_boot_wait);
 279                 break;
 280 
 281         default:
 282                 wiphy_err(ar->hw->wiphy, "FW: received unhandled event %x\n",
 283                         cmd->hdr.cmd);
 284                 print_hex_dump_bytes("dump:", DUMP_PREFIX_NONE, buf, len);
 285                 break;
 286         }
 287 }
 288 
 289 static int carl9170_rx_mac_status(struct ar9170 *ar,
 290         struct ar9170_rx_head *head, struct ar9170_rx_macstatus *mac,
 291         struct ieee80211_rx_status *status)
 292 {
 293         struct ieee80211_channel *chan;
 294         u8 error, decrypt;
 295 
 296         BUILD_BUG_ON(sizeof(struct ar9170_rx_head) != 12);
 297         BUILD_BUG_ON(sizeof(struct ar9170_rx_macstatus) != 4);
 298 
 299         error = mac->error;
 300 
 301         if (error & AR9170_RX_ERROR_WRONG_RA) {
 302                 if (!ar->sniffer_enabled)
 303                         return -EINVAL;
 304         }
 305 
 306         if (error & AR9170_RX_ERROR_PLCP) {
 307                 if (!(ar->filter_state & FIF_PLCPFAIL))
 308                         return -EINVAL;
 309 
 310                 status->flag |= RX_FLAG_FAILED_PLCP_CRC;
 311         }
 312 
 313         if (error & AR9170_RX_ERROR_FCS) {
 314                 ar->tx_fcs_errors++;
 315 
 316                 if (!(ar->filter_state & FIF_FCSFAIL))
 317                         return -EINVAL;
 318 
 319                 status->flag |= RX_FLAG_FAILED_FCS_CRC;
 320         }
 321 
 322         decrypt = ar9170_get_decrypt_type(mac);
 323         if (!(decrypt & AR9170_RX_ENC_SOFTWARE) &&
 324             decrypt != AR9170_ENC_ALG_NONE) {
 325                 if ((decrypt == AR9170_ENC_ALG_TKIP) &&
 326                     (error & AR9170_RX_ERROR_MMIC))
 327                         status->flag |= RX_FLAG_MMIC_ERROR;
 328 
 329                 status->flag |= RX_FLAG_DECRYPTED;
 330         }
 331 
 332         if (error & AR9170_RX_ERROR_DECRYPT && !ar->sniffer_enabled)
 333                 return -ENODATA;
 334 
 335         error &= ~(AR9170_RX_ERROR_MMIC |
 336                    AR9170_RX_ERROR_FCS |
 337                    AR9170_RX_ERROR_WRONG_RA |
 338                    AR9170_RX_ERROR_DECRYPT |
 339                    AR9170_RX_ERROR_PLCP);
 340 
 341         /* drop any other error frames */
 342         if (unlikely(error)) {
 343                 /* TODO: update netdevice's RX dropped/errors statistics */
 344 
 345                 if (net_ratelimit())
 346                         wiphy_dbg(ar->hw->wiphy, "received frame with "
 347                                "suspicious error code (%#x).\n", error);
 348 
 349                 return -EINVAL;
 350         }
 351 
 352         chan = ar->channel;
 353         if (chan) {
 354                 status->band = chan->band;
 355                 status->freq = chan->center_freq;
 356         }
 357 
 358         switch (mac->status & AR9170_RX_STATUS_MODULATION) {
 359         case AR9170_RX_STATUS_MODULATION_CCK:
 360                 if (mac->status & AR9170_RX_STATUS_SHORT_PREAMBLE)
 361                         status->enc_flags |= RX_ENC_FLAG_SHORTPRE;
 362                 switch (head->plcp[0]) {
 363                 case AR9170_RX_PHY_RATE_CCK_1M:
 364                         status->rate_idx = 0;
 365                         break;
 366                 case AR9170_RX_PHY_RATE_CCK_2M:
 367                         status->rate_idx = 1;
 368                         break;
 369                 case AR9170_RX_PHY_RATE_CCK_5M:
 370                         status->rate_idx = 2;
 371                         break;
 372                 case AR9170_RX_PHY_RATE_CCK_11M:
 373                         status->rate_idx = 3;
 374                         break;
 375                 default:
 376                         if (net_ratelimit()) {
 377                                 wiphy_err(ar->hw->wiphy, "invalid plcp cck "
 378                                        "rate (%x).\n", head->plcp[0]);
 379                         }
 380 
 381                         return -EINVAL;
 382                 }
 383                 break;
 384 
 385         case AR9170_RX_STATUS_MODULATION_DUPOFDM:
 386         case AR9170_RX_STATUS_MODULATION_OFDM:
 387                 switch (head->plcp[0] & 0xf) {
 388                 case AR9170_TXRX_PHY_RATE_OFDM_6M:
 389                         status->rate_idx = 0;
 390                         break;
 391                 case AR9170_TXRX_PHY_RATE_OFDM_9M:
 392                         status->rate_idx = 1;
 393                         break;
 394                 case AR9170_TXRX_PHY_RATE_OFDM_12M:
 395                         status->rate_idx = 2;
 396                         break;
 397                 case AR9170_TXRX_PHY_RATE_OFDM_18M:
 398                         status->rate_idx = 3;
 399                         break;
 400                 case AR9170_TXRX_PHY_RATE_OFDM_24M:
 401                         status->rate_idx = 4;
 402                         break;
 403                 case AR9170_TXRX_PHY_RATE_OFDM_36M:
 404                         status->rate_idx = 5;
 405                         break;
 406                 case AR9170_TXRX_PHY_RATE_OFDM_48M:
 407                         status->rate_idx = 6;
 408                         break;
 409                 case AR9170_TXRX_PHY_RATE_OFDM_54M:
 410                         status->rate_idx = 7;
 411                         break;
 412                 default:
 413                         if (net_ratelimit()) {
 414                                 wiphy_err(ar->hw->wiphy, "invalid plcp ofdm "
 415                                         "rate (%x).\n", head->plcp[0]);
 416                         }
 417 
 418                         return -EINVAL;
 419                 }
 420                 if (status->band == NL80211_BAND_2GHZ)
 421                         status->rate_idx += 4;
 422                 break;
 423 
 424         case AR9170_RX_STATUS_MODULATION_HT:
 425                 if (head->plcp[3] & 0x80)
 426                         status->bw = RATE_INFO_BW_40;
 427                 if (head->plcp[6] & 0x80)
 428                         status->enc_flags |= RX_ENC_FLAG_SHORT_GI;
 429 
 430                 status->rate_idx = clamp(head->plcp[3] & 0x7f, 0, 75);
 431                 status->encoding = RX_ENC_HT;
 432                 break;
 433 
 434         default:
 435                 BUG();
 436                 return -ENOSYS;
 437         }
 438 
 439         return 0;
 440 }
 441 
 442 static void carl9170_rx_phy_status(struct ar9170 *ar,
 443         struct ar9170_rx_phystatus *phy, struct ieee80211_rx_status *status)
 444 {
 445         int i;
 446 
 447         BUILD_BUG_ON(sizeof(struct ar9170_rx_phystatus) != 20);
 448 
 449         for (i = 0; i < 3; i++)
 450                 if (phy->rssi[i] != 0x80)
 451                         status->antenna |= BIT(i);
 452 
 453         /* post-process RSSI */
 454         for (i = 0; i < 7; i++)
 455                 if (phy->rssi[i] & 0x80)
 456                         phy->rssi[i] = ((~phy->rssi[i] & 0x7f) + 1) & 0x7f;
 457 
 458         /* TODO: we could do something with phy_errors */
 459         status->signal = ar->noise[0] + phy->rssi_combined;
 460 }
 461 
 462 static struct sk_buff *carl9170_rx_copy_data(u8 *buf, int len)
 463 {
 464         struct sk_buff *skb;
 465         int reserved = 0;
 466         struct ieee80211_hdr *hdr = (void *) buf;
 467 
 468         if (ieee80211_is_data_qos(hdr->frame_control)) {
 469                 u8 *qc = ieee80211_get_qos_ctl(hdr);
 470                 reserved += NET_IP_ALIGN;
 471 
 472                 if (*qc & IEEE80211_QOS_CTL_A_MSDU_PRESENT)
 473                         reserved += NET_IP_ALIGN;
 474         }
 475 
 476         if (ieee80211_has_a4(hdr->frame_control))
 477                 reserved += NET_IP_ALIGN;
 478 
 479         reserved = 32 + (reserved & NET_IP_ALIGN);
 480 
 481         skb = dev_alloc_skb(len + reserved);
 482         if (likely(skb)) {
 483                 skb_reserve(skb, reserved);
 484                 skb_put_data(skb, buf, len);
 485         }
 486 
 487         return skb;
 488 }
 489 
 490 static u8 *carl9170_find_ie(u8 *data, unsigned int len, u8 ie)
 491 {
 492         struct ieee80211_mgmt *mgmt = (void *)data;
 493         u8 *pos, *end;
 494 
 495         pos = (u8 *)mgmt->u.beacon.variable;
 496         end = data + len;
 497         while (pos < end) {
 498                 if (pos + 2 + pos[1] > end)
 499                         return NULL;
 500 
 501                 if (pos[0] == ie)
 502                         return pos;
 503 
 504                 pos += 2 + pos[1];
 505         }
 506         return NULL;
 507 }
 508 
 509 /*
 510  * NOTE:
 511  *
 512  * The firmware is in charge of waking up the device just before
 513  * the AP is expected to transmit the next beacon.
 514  *
 515  * This leaves the driver with the important task of deciding when
 516  * to set the PHY back to bed again.
 517  */
 518 static void carl9170_ps_beacon(struct ar9170 *ar, void *data, unsigned int len)
 519 {
 520         struct ieee80211_hdr *hdr = data;
 521         struct ieee80211_tim_ie *tim_ie;
 522         struct ath_common *common = &ar->common;
 523         u8 *tim;
 524         u8 tim_len;
 525         bool cam;
 526 
 527         if (likely(!(ar->hw->conf.flags & IEEE80211_CONF_PS)))
 528                 return;
 529 
 530         /* min. beacon length + FCS_LEN */
 531         if (len <= 40 + FCS_LEN)
 532                 return;
 533 
 534         /* check if this really is a beacon */
 535         /* and only beacons from the associated BSSID, please */
 536         if (!ath_is_mybeacon(common, hdr) || !common->curaid)
 537                 return;
 538 
 539         ar->ps.last_beacon = jiffies;
 540 
 541         tim = carl9170_find_ie(data, len - FCS_LEN, WLAN_EID_TIM);
 542         if (!tim)
 543                 return;
 544 
 545         if (tim[1] < sizeof(*tim_ie))
 546                 return;
 547 
 548         tim_len = tim[1];
 549         tim_ie = (struct ieee80211_tim_ie *) &tim[2];
 550 
 551         if (!WARN_ON_ONCE(!ar->hw->conf.ps_dtim_period))
 552                 ar->ps.dtim_counter = (tim_ie->dtim_count - 1) %
 553                         ar->hw->conf.ps_dtim_period;
 554 
 555         /* Check whenever the PHY can be turned off again. */
 556 
 557         /* 1. What about buffered unicast traffic for our AID? */
 558         cam = ieee80211_check_tim(tim_ie, tim_len, ar->common.curaid);
 559 
 560         /* 2. Maybe the AP wants to send multicast/broadcast data? */
 561         cam |= !!(tim_ie->bitmap_ctrl & 0x01);
 562 
 563         if (!cam) {
 564                 /* back to low-power land. */
 565                 ar->ps.off_override &= ~PS_OFF_BCN;
 566                 carl9170_ps_check(ar);
 567         } else {
 568                 /* force CAM */
 569                 ar->ps.off_override |= PS_OFF_BCN;
 570         }
 571 }
 572 
 573 static void carl9170_ba_check(struct ar9170 *ar, void *data, unsigned int len)
 574 {
 575         struct ieee80211_bar *bar = data;
 576         struct carl9170_bar_list_entry *entry;
 577         unsigned int queue;
 578 
 579         if (likely(!ieee80211_is_back(bar->frame_control)))
 580                 return;
 581 
 582         if (len <= sizeof(*bar) + FCS_LEN)
 583                 return;
 584 
 585         queue = TID_TO_WME_AC(((le16_to_cpu(bar->control) &
 586                 IEEE80211_BAR_CTRL_TID_INFO_MASK) >>
 587                 IEEE80211_BAR_CTRL_TID_INFO_SHIFT) & 7);
 588 
 589         rcu_read_lock();
 590         list_for_each_entry_rcu(entry, &ar->bar_list[queue], list) {
 591                 struct sk_buff *entry_skb = entry->skb;
 592                 struct _carl9170_tx_superframe *super = (void *)entry_skb->data;
 593                 struct ieee80211_bar *entry_bar = (void *)super->frame_data;
 594 
 595 #define TID_CHECK(a, b) (                                               \
 596         ((a) & cpu_to_le16(IEEE80211_BAR_CTRL_TID_INFO_MASK)) ==        \
 597         ((b) & cpu_to_le16(IEEE80211_BAR_CTRL_TID_INFO_MASK)))          \
 598 
 599                 if (bar->start_seq_num == entry_bar->start_seq_num &&
 600                     TID_CHECK(bar->control, entry_bar->control) &&
 601                     ether_addr_equal_64bits(bar->ra, entry_bar->ta) &&
 602                     ether_addr_equal_64bits(bar->ta, entry_bar->ra)) {
 603                         struct ieee80211_tx_info *tx_info;
 604 
 605                         tx_info = IEEE80211_SKB_CB(entry_skb);
 606                         tx_info->flags |= IEEE80211_TX_STAT_ACK;
 607 
 608                         spin_lock_bh(&ar->bar_list_lock[queue]);
 609                         list_del_rcu(&entry->list);
 610                         spin_unlock_bh(&ar->bar_list_lock[queue]);
 611                         kfree_rcu(entry, head);
 612                         break;
 613                 }
 614         }
 615         rcu_read_unlock();
 616 
 617 #undef TID_CHECK
 618 }
 619 
 620 static bool carl9170_ampdu_check(struct ar9170 *ar, u8 *buf, u8 ms,
 621                                  struct ieee80211_rx_status *rx_status)
 622 {
 623         __le16 fc;
 624 
 625         if ((ms & AR9170_RX_STATUS_MPDU) == AR9170_RX_STATUS_MPDU_SINGLE) {
 626                 /*
 627                  * This frame is not part of an aMPDU.
 628                  * Therefore it is not subjected to any
 629                  * of the following content restrictions.
 630                  */
 631                 return true;
 632         }
 633 
 634         rx_status->flag |= RX_FLAG_AMPDU_DETAILS | RX_FLAG_AMPDU_LAST_KNOWN;
 635         rx_status->ampdu_reference = ar->ampdu_ref;
 636 
 637         /*
 638          * "802.11n - 7.4a.3 A-MPDU contents" describes in which contexts
 639          * certain frame types can be part of an aMPDU.
 640          *
 641          * In order to keep the processing cost down, I opted for a
 642          * stateless filter solely based on the frame control field.
 643          */
 644 
 645         fc = ((struct ieee80211_hdr *)buf)->frame_control;
 646         if (ieee80211_is_data_qos(fc) && ieee80211_is_data_present(fc))
 647                 return true;
 648 
 649         if (ieee80211_is_ack(fc) || ieee80211_is_back(fc) ||
 650             ieee80211_is_back_req(fc))
 651                 return true;
 652 
 653         if (ieee80211_is_action(fc))
 654                 return true;
 655 
 656         return false;
 657 }
 658 
 659 static int carl9170_handle_mpdu(struct ar9170 *ar, u8 *buf, int len,
 660                                 struct ieee80211_rx_status *status)
 661 {
 662         struct sk_buff *skb;
 663 
 664         /* (driver) frame trap handler
 665          *
 666          * Because power-saving mode handing has to be implemented by
 667          * the driver/firmware. We have to check each incoming beacon
 668          * from the associated AP, if there's new data for us (either
 669          * broadcast/multicast or unicast) we have to react quickly.
 670          *
 671          * So, if you have you want to add additional frame trap
 672          * handlers, this would be the perfect place!
 673          */
 674 
 675         carl9170_ps_beacon(ar, buf, len);
 676 
 677         carl9170_ba_check(ar, buf, len);
 678 
 679         skb = carl9170_rx_copy_data(buf, len);
 680         if (!skb)
 681                 return -ENOMEM;
 682 
 683         memcpy(IEEE80211_SKB_RXCB(skb), status, sizeof(*status));
 684         ieee80211_rx(ar->hw, skb);
 685         return 0;
 686 }
 687 
 688 /*
 689  * If the frame alignment is right (or the kernel has
 690  * CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS), and there
 691  * is only a single MPDU in the USB frame, then we could
 692  * submit to mac80211 the SKB directly. However, since
 693  * there may be multiple packets in one SKB in stream
 694  * mode, and we need to observe the proper ordering,
 695  * this is non-trivial.
 696  */
 697 static void carl9170_rx_untie_data(struct ar9170 *ar, u8 *buf, int len)
 698 {
 699         struct ar9170_rx_head *head;
 700         struct ar9170_rx_macstatus *mac;
 701         struct ar9170_rx_phystatus *phy = NULL;
 702         struct ieee80211_rx_status status;
 703         int mpdu_len;
 704         u8 mac_status;
 705 
 706         if (!IS_STARTED(ar))
 707                 return;
 708 
 709         if (unlikely(len < sizeof(*mac)))
 710                 goto drop;
 711 
 712         memset(&status, 0, sizeof(status));
 713 
 714         mpdu_len = len - sizeof(*mac);
 715 
 716         mac = (void *)(buf + mpdu_len);
 717         mac_status = mac->status;
 718         switch (mac_status & AR9170_RX_STATUS_MPDU) {
 719         case AR9170_RX_STATUS_MPDU_FIRST:
 720                 ar->ampdu_ref++;
 721                 /* Aggregated MPDUs start with an PLCP header */
 722                 if (likely(mpdu_len >= sizeof(struct ar9170_rx_head))) {
 723                         head = (void *) buf;
 724 
 725                         /*
 726                          * The PLCP header needs to be cached for the
 727                          * following MIDDLE + LAST A-MPDU packets.
 728                          *
 729                          * So, if you are wondering why all frames seem
 730                          * to share a common RX status information,
 731                          * then you have the answer right here...
 732                          */
 733                         memcpy(&ar->rx_plcp, (void *) buf,
 734                                sizeof(struct ar9170_rx_head));
 735 
 736                         mpdu_len -= sizeof(struct ar9170_rx_head);
 737                         buf += sizeof(struct ar9170_rx_head);
 738 
 739                         ar->rx_has_plcp = true;
 740                 } else {
 741                         if (net_ratelimit()) {
 742                                 wiphy_err(ar->hw->wiphy, "plcp info "
 743                                         "is clipped.\n");
 744                         }
 745 
 746                         goto drop;
 747                 }
 748                 break;
 749 
 750         case AR9170_RX_STATUS_MPDU_LAST:
 751                 status.flag |= RX_FLAG_AMPDU_IS_LAST;
 752 
 753                 /*
 754                  * The last frame of an A-MPDU has an extra tail
 755                  * which does contain the phy status of the whole
 756                  * aggregate.
 757                  */
 758                 if (likely(mpdu_len >= sizeof(struct ar9170_rx_phystatus))) {
 759                         mpdu_len -= sizeof(struct ar9170_rx_phystatus);
 760                         phy = (void *)(buf + mpdu_len);
 761                 } else {
 762                         if (net_ratelimit()) {
 763                                 wiphy_err(ar->hw->wiphy, "frame tail "
 764                                         "is clipped.\n");
 765                         }
 766 
 767                         goto drop;
 768                 }
 769                 /* fall through */
 770 
 771         case AR9170_RX_STATUS_MPDU_MIDDLE:
 772                 /*  These are just data + mac status */
 773                 if (unlikely(!ar->rx_has_plcp)) {
 774                         if (!net_ratelimit())
 775                                 return;
 776 
 777                         wiphy_err(ar->hw->wiphy, "rx stream does not start "
 778                                         "with a first_mpdu frame tag.\n");
 779 
 780                         goto drop;
 781                 }
 782 
 783                 head = &ar->rx_plcp;
 784                 break;
 785 
 786         case AR9170_RX_STATUS_MPDU_SINGLE:
 787                 /* single mpdu has both: plcp (head) and phy status (tail) */
 788                 head = (void *) buf;
 789 
 790                 mpdu_len -= sizeof(struct ar9170_rx_head);
 791                 mpdu_len -= sizeof(struct ar9170_rx_phystatus);
 792 
 793                 buf += sizeof(struct ar9170_rx_head);
 794                 phy = (void *)(buf + mpdu_len);
 795                 break;
 796 
 797         default:
 798                 BUG();
 799                 break;
 800         }
 801 
 802         /* FC + DU + RA + FCS */
 803         if (unlikely(mpdu_len < (2 + 2 + ETH_ALEN + FCS_LEN)))
 804                 goto drop;
 805 
 806         if (unlikely(carl9170_rx_mac_status(ar, head, mac, &status)))
 807                 goto drop;
 808 
 809         if (!carl9170_ampdu_check(ar, buf, mac_status, &status))
 810                 goto drop;
 811 
 812         if (phy)
 813                 carl9170_rx_phy_status(ar, phy, &status);
 814         else
 815                 status.flag |= RX_FLAG_NO_SIGNAL_VAL;
 816 
 817         if (carl9170_handle_mpdu(ar, buf, mpdu_len, &status))
 818                 goto drop;
 819 
 820         return;
 821 drop:
 822         ar->rx_dropped++;
 823 }
 824 
 825 static void carl9170_rx_untie_cmds(struct ar9170 *ar, const u8 *respbuf,
 826                                    const unsigned int resplen)
 827 {
 828         struct carl9170_rsp *cmd;
 829         int i = 0;
 830 
 831         while (i < resplen) {
 832                 cmd = (void *) &respbuf[i];
 833 
 834                 i += cmd->hdr.len + 4;
 835                 if (unlikely(i > resplen))
 836                         break;
 837 
 838                 if (carl9170_check_sequence(ar, cmd->hdr.seq))
 839                         break;
 840 
 841                 carl9170_handle_command_response(ar, cmd, cmd->hdr.len + 4);
 842         }
 843 
 844         if (unlikely(i != resplen)) {
 845                 if (!net_ratelimit())
 846                         return;
 847 
 848                 wiphy_err(ar->hw->wiphy, "malformed firmware trap:\n");
 849                 print_hex_dump_bytes("rxcmd:", DUMP_PREFIX_OFFSET,
 850                                      respbuf, resplen);
 851         }
 852 }
 853 
 854 static void __carl9170_rx(struct ar9170 *ar, u8 *buf, unsigned int len)
 855 {
 856         unsigned int i = 0;
 857 
 858         /* weird thing, but this is the same in the original driver */
 859         while (len > 2 && i < 12 && buf[0] == 0xff && buf[1] == 0xff) {
 860                 i += 2;
 861                 len -= 2;
 862                 buf += 2;
 863         }
 864 
 865         if (unlikely(len < 4))
 866                 return;
 867 
 868         /* found the 6 * 0xffff marker? */
 869         if (i == 12)
 870                 carl9170_rx_untie_cmds(ar, buf, len);
 871         else
 872                 carl9170_rx_untie_data(ar, buf, len);
 873 }
 874 
 875 static void carl9170_rx_stream(struct ar9170 *ar, void *buf, unsigned int len)
 876 {
 877         unsigned int tlen, wlen = 0, clen = 0;
 878         struct ar9170_stream *rx_stream;
 879         u8 *tbuf;
 880 
 881         tbuf = buf;
 882         tlen = len;
 883 
 884         while (tlen >= 4) {
 885                 rx_stream = (void *) tbuf;
 886                 clen = le16_to_cpu(rx_stream->length);
 887                 wlen = ALIGN(clen, 4);
 888 
 889                 /* check if this is stream has a valid tag.*/
 890                 if (rx_stream->tag != cpu_to_le16(AR9170_RX_STREAM_TAG)) {
 891                         /*
 892                          * TODO: handle the highly unlikely event that the
 893                          * corrupted stream has the TAG at the right position.
 894                          */
 895 
 896                         /* check if the frame can be repaired. */
 897                         if (!ar->rx_failover_missing) {
 898 
 899                                 /* this is not "short read". */
 900                                 if (net_ratelimit()) {
 901                                         wiphy_err(ar->hw->wiphy,
 902                                                 "missing tag!\n");
 903                                 }
 904 
 905                                 __carl9170_rx(ar, tbuf, tlen);
 906                                 return;
 907                         }
 908 
 909                         if (ar->rx_failover_missing > tlen) {
 910                                 if (net_ratelimit()) {
 911                                         wiphy_err(ar->hw->wiphy,
 912                                                 "possible multi "
 913                                                 "stream corruption!\n");
 914                                         goto err_telluser;
 915                                 } else {
 916                                         goto err_silent;
 917                                 }
 918                         }
 919 
 920                         skb_put_data(ar->rx_failover, tbuf, tlen);
 921                         ar->rx_failover_missing -= tlen;
 922 
 923                         if (ar->rx_failover_missing <= 0) {
 924                                 /*
 925                                  * nested carl9170_rx_stream call!
 926                                  *
 927                                  * termination is guaranteed, even when the
 928                                  * combined frame also have an element with
 929                                  * a bad tag.
 930                                  */
 931 
 932                                 ar->rx_failover_missing = 0;
 933                                 carl9170_rx_stream(ar, ar->rx_failover->data,
 934                                                    ar->rx_failover->len);
 935 
 936                                 skb_reset_tail_pointer(ar->rx_failover);
 937                                 skb_trim(ar->rx_failover, 0);
 938                         }
 939 
 940                         return;
 941                 }
 942 
 943                 /* check if stream is clipped */
 944                 if (wlen > tlen - 4) {
 945                         if (ar->rx_failover_missing) {
 946                                 /* TODO: handle double stream corruption. */
 947                                 if (net_ratelimit()) {
 948                                         wiphy_err(ar->hw->wiphy, "double rx "
 949                                                 "stream corruption!\n");
 950                                         goto err_telluser;
 951                                 } else {
 952                                         goto err_silent;
 953                                 }
 954                         }
 955 
 956                         /*
 957                          * save incomplete data set.
 958                          * the firmware will resend the missing bits when
 959                          * the rx - descriptor comes round again.
 960                          */
 961 
 962                         skb_put_data(ar->rx_failover, tbuf, tlen);
 963                         ar->rx_failover_missing = clen - tlen;
 964                         return;
 965                 }
 966                 __carl9170_rx(ar, rx_stream->payload, clen);
 967 
 968                 tbuf += wlen + 4;
 969                 tlen -= wlen + 4;
 970         }
 971 
 972         if (tlen) {
 973                 if (net_ratelimit()) {
 974                         wiphy_err(ar->hw->wiphy, "%d bytes of unprocessed "
 975                                 "data left in rx stream!\n", tlen);
 976                 }
 977 
 978                 goto err_telluser;
 979         }
 980 
 981         return;
 982 
 983 err_telluser:
 984         wiphy_err(ar->hw->wiphy, "damaged RX stream data [want:%d, "
 985                 "data:%d, rx:%d, pending:%d ]\n", clen, wlen, tlen,
 986                 ar->rx_failover_missing);
 987 
 988         if (ar->rx_failover_missing)
 989                 print_hex_dump_bytes("rxbuf:", DUMP_PREFIX_OFFSET,
 990                                      ar->rx_failover->data,
 991                                      ar->rx_failover->len);
 992 
 993         print_hex_dump_bytes("stream:", DUMP_PREFIX_OFFSET,
 994                              buf, len);
 995 
 996         wiphy_err(ar->hw->wiphy, "please check your hardware and cables, if "
 997                 "you see this message frequently.\n");
 998 
 999 err_silent:
1000         if (ar->rx_failover_missing) {
1001                 skb_reset_tail_pointer(ar->rx_failover);
1002                 skb_trim(ar->rx_failover, 0);
1003                 ar->rx_failover_missing = 0;
1004         }
1005 }
1006 
1007 void carl9170_rx(struct ar9170 *ar, void *buf, unsigned int len)
1008 {
1009         if (ar->fw.rx_stream)
1010                 carl9170_rx_stream(ar, buf, len);
1011         else
1012                 __carl9170_rx(ar, buf, len);
1013 }
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/net/wireless/ath/carl9170/rx.c

DEFINITIONS
