← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-armadaxp/trusty

« back to all changes in this revision

Viewing changes to net/mac80211/rx.c

  • Committer: Package Import Robot
  • Author(s): Michael Casadevall, Bryan Wu, Dann Frazier, Michael Casadeall
  • Date: 2012-03-10 15:00:54 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120310150054-flugb39zon8vvgwe
Tags: 3.2.0-1600.1
[ Bryan Wu ]
* UBUNTU: import debian/debian.env and debian.armadaxp

[ Dann Frazier ]
* ARM: Armada XP: remove trailing '/' in dirnames in mvRules.mk

[ Michael Casadeall ]
* tools: add some tools for Marvell Armada XP processor
* kernel: timer tick hacking from Marvell
* kernel: Sheeva Errata: add delay on Sheeva when powering down
* net: add Marvell NFP netfilter
* net: socket and skb modifications made by Marvell
* miscdevice: add minor IDs for some Marvell Armada drivers
* fs: introduce memory pool for splice()
* video: EDID detection updates from Marvell Armada XP patchset
* video: backlight: add Marvell Dove LCD backlight driver
* video: display: add THS8200 display driver
* video: framebuffer: add Marvell Dove and Armada XP processor onchip LCD controller driver
* usbtest: add Interrupt transfer testing by Marvell Armada XP code
* usb: ehci: add support for Marvell EHCI controler
* tty/serial: 8250: add support for Marvell Armada XP processor and DeviceTree work
* rtc: add support for Marvell Armada XP onchip RTC controller
* net: pppoe: add Marvell ethernet NFP hook in PPPoE networking driver
* mtd: nand: add support for Marvell Armada XP Nand Flash Controller
* mtd: maps: add Marvell Armada XP specific map driver
* mmc: add support for Marvell Armada XP MMC/SD host controller
* i2c: add support for Marvell Armada XP onchip i2c bus controller
* hwmon: add Kconfig option for Armada XP onchip thermal sensor driver
* dmaengine: add Net DMA support for splice and update Marvell XOR DMA engine driver
* ata: add support for Marvell Armada XP SATA controller and update some quirks
* ARM: add Marvell Armada XP machine to mach-types
* ARM: oprofile: add support for Marvell PJ4B core
* ARM: mm: more ARMv6 switches for Marvell Armada XP
* ARM: remove static declaration to allow compilation
* ARM: alignment access fault trick
* ARM: mm: skip some fault fixing when run on NONE SMP ARMv6 mode during early abort event
* ARM: mm: add Marvell Sheeva CPU Architecture for PJ4B
* ARM: introduce optimized copy operation for Marvell Armada XP
* ARM: SAUCE: hardware breakpoint trick for Marvell Armada XP
* ARM: big endian and little endian tricks for Marvell Armada XP
* ARM: SAUCE: Add Marvell Armada XP build rules to arch/arm/kernel/Makefile
* ARM: vfp: add special handling for Marvell Armada XP
* ARM: add support for Marvell U-Boot
* ARM: add mv_controller_num for ARM PCI drivers
* ARM: add support for local PMUs, general SMP tweaks and cache flushing
* ARM: add Marvell device identifies in glue-proc.h
* ARM: add IPC driver support for Marvell platforms
* ARM: add DMA mapping for Marvell platforms
* ARM: add Sheeva errata and PJ4B code for booting
* ARM: update Kconfig and Makefile to include Marvell Armada XP platforms
* ARM: Armada XP: import LSP from Marvell for Armada XP 3.2 kernel enablement

Show diffs side-by-side

added added

removed removed

Lines of Context:
net/mac80211/rx.c
16
16
#include <linux/netdevice.h>
17
17
#include <linux/etherdevice.h>
18
18
#include <linux/rcupdate.h>
 
19
#include <linux/export.h>
19
20
#include <net/mac80211.h>
20
21
#include <net/ieee80211_radiotap.h>
21
22
 
334
335
{
335
336
        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
336
337
        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
337
 
        int tid;
 
338
        int tid, seqno_idx, security_idx;
338
339
 
339
340
        /* does the frame have a qos control field? */
340
341
        if (ieee80211_is_data_qos(hdr->frame_control)) {
341
342
                u8 *qc = ieee80211_get_qos_ctl(hdr);
342
343
                /* frame has qos control */
343
344
                tid = *qc & IEEE80211_QOS_CTL_TID_MASK;
344
 
                if (*qc & IEEE80211_QOS_CONTROL_A_MSDU_PRESENT)
 
345
                if (*qc & IEEE80211_QOS_CTL_A_MSDU_PRESENT)
345
346
                        status->rx_flags |= IEEE80211_RX_AMSDU;
 
347
 
 
348
                seqno_idx = tid;
 
349
                security_idx = tid;
346
350
        } else {
347
351
                /*
348
352
                 * IEEE 802.11-2007, 7.1.3.4.1 ("Sequence Number field"):
355
359
                 *
356
360
                 * We also use that counter for non-QoS STAs.
357
361
                 */
358
 
                tid = NUM_RX_DATA_QUEUES - 1;
 
362
                seqno_idx = NUM_RX_DATA_QUEUES;
 
363
                security_idx = 0;
 
364
                if (ieee80211_is_mgmt(hdr->frame_control))
 
365
                        security_idx = NUM_RX_DATA_QUEUES;
 
366
                tid = 0;
359
367
        }
360
368
 
361
 
        rx->queue = tid;
 
369
        rx->seqno_idx = seqno_idx;
 
370
        rx->security_idx = security_idx;
362
371
        /* Set skb->priority to 1d tag if highest order bit of TID is not set.
363
372
         * For now, set skb->priority to 0 for other cases. */
364
373
        rx->skb->priority = (tid > 7) ? 0 : tid;
412
421
                return RX_CONTINUE;
413
422
 
414
423
        if (test_bit(SCAN_HW_SCANNING, &local->scanning) ||
415
 
            test_bit(SCAN_SW_SCANNING, &local->scanning) ||
416
424
            local->sched_scanning)
417
425
                return ieee80211_scan_rx(rx->sdata, skb);
418
426
 
 
427
        if (test_bit(SCAN_SW_SCANNING, &local->scanning)) {
 
428
                /* drop all the other packets during a software scan anyway */
 
429
                if (ieee80211_scan_rx(rx->sdata, skb) != RX_QUEUED)
 
430
                        dev_kfree_skb(skb);
 
431
                return RX_QUEUED;
 
432
        }
 
433
 
419
434
        /* scanning finished during invoking of handlers */
420
435
        I802_DEBUG_INC(local->rx_handlers_drop_passive_scan);
421
436
        return RX_DROP_UNUSABLE;
471
486
ieee80211_rx_mesh_check(struct ieee80211_rx_data *rx)
472
487
{
473
488
        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
474
 
        unsigned int hdrlen = ieee80211_hdrlen(hdr->frame_control);
475
489
        char *dev_addr = rx->sdata->vif.addr;
476
490
 
477
491
        if (ieee80211_is_data(hdr->frame_control)) {
519
533
 
520
534
        }
521
535
 
522
 
#define msh_h_get(h, l) ((struct ieee80211s_hdr *) ((u8 *)h + l))
523
 
 
524
 
        if (ieee80211_is_data(hdr->frame_control) &&
525
 
            is_multicast_ether_addr(hdr->addr1) &&
526
 
            mesh_rmc_check(hdr->addr3, msh_h_get(hdr, hdrlen), rx->sdata))
527
 
                return RX_DROP_MONITOR;
528
 
#undef msh_h_get
529
 
 
530
536
        return RX_CONTINUE;
531
537
}
532
538
 
610
616
        index = seq_sub(tid_agg_rx->head_seq_num, tid_agg_rx->ssn) %
611
617
                                                tid_agg_rx->buf_size;
612
618
        if (!tid_agg_rx->reorder_buf[index] &&
613
 
            tid_agg_rx->stored_mpdu_num > 1) {
 
619
            tid_agg_rx->stored_mpdu_num) {
614
620
                /*
615
621
                 * No buffers ready to be released, but check whether any
616
622
                 * frames in the reorder buffer have timed out.
813
819
        /* Drop duplicate 802.11 retransmissions (IEEE 802.11 Chap. 9.2.9) */
814
820
        if (rx->sta && !is_multicast_ether_addr(hdr->addr1)) {
815
821
                if (unlikely(ieee80211_has_retry(hdr->frame_control) &&
816
 
                             rx->sta->last_seq_ctrl[rx->queue] ==
 
822
                             rx->sta->last_seq_ctrl[rx->seqno_idx] ==
817
823
                             hdr->seq_ctrl)) {
818
824
                        if (status->rx_flags & IEEE80211_RX_RA_MATCH) {
819
825
                                rx->local->dot11FrameDuplicateCount++;
821
827
                        }
822
828
                        return RX_DROP_UNUSABLE;
823
829
                } else
824
 
                        rx->sta->last_seq_ctrl[rx->queue] = hdr->seq_ctrl;
 
830
                        rx->sta->last_seq_ctrl[rx->seqno_idx] = hdr->seq_ctrl;
825
831
        }
826
832
 
827
833
        if (unlikely(rx->skb->len < 16)) {
845
851
                      ieee80211_is_pspoll(hdr->frame_control)) &&
846
852
                     rx->sdata->vif.type != NL80211_IFTYPE_ADHOC &&
847
853
                     rx->sdata->vif.type != NL80211_IFTYPE_WDS &&
848
 
                     (!rx->sta || !test_sta_flags(rx->sta, WLAN_STA_ASSOC))))
 
854
                     (!rx->sta || !test_sta_flag(rx->sta, WLAN_STA_ASSOC)))) {
 
855
                if (rx->sta && rx->sta->dummy &&
 
856
                    ieee80211_is_data_present(hdr->frame_control)) {
 
857
                        u16 ethertype;
 
858
                        u8 *payload;
 
859
 
 
860
                        payload = rx->skb->data +
 
861
                                ieee80211_hdrlen(hdr->frame_control);
 
862
                        ethertype = (payload[6] << 8) | payload[7];
 
863
                        if (cpu_to_be16(ethertype) ==
 
864
                            rx->sdata->control_port_protocol)
 
865
                                return RX_CONTINUE;
 
866
                }
849
867
                return RX_DROP_MONITOR;
 
868
        }
850
869
 
851
870
        return RX_CONTINUE;
852
871
}
1014
1033
        }
1015
1034
 
1016
1035
        if (rx->key) {
 
1036
                if (unlikely(rx->key->flags & KEY_FLAG_TAINTED))
 
1037
                        return RX_DROP_MONITOR;
 
1038
 
1017
1039
                rx->key->tx_rx_count++;
1018
1040
                /* TODO: add threshold stuff again */
1019
1041
        } else {
1098
1120
        struct ieee80211_local *local = sdata->local;
1099
1121
 
1100
1122
        atomic_inc(&sdata->bss->num_sta_ps);
1101
 
        set_sta_flags(sta, WLAN_STA_PS_STA);
 
1123
        set_sta_flag(sta, WLAN_STA_PS_STA);
1102
1124
        if (!(local->hw.flags & IEEE80211_HW_AP_LINK_PS))
1103
1125
                drv_sta_notify(local, sdata, STA_NOTIFY_SLEEP, &sta->sta);
1104
1126
#ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
1118
1140
               sdata->name, sta->sta.addr, sta->sta.aid);
1119
1141
#endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
1120
1142
 
1121
 
        if (test_sta_flags(sta, WLAN_STA_PS_DRIVER)) {
 
1143
        if (test_sta_flag(sta, WLAN_STA_PS_DRIVER)) {
1122
1144
#ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
1123
1145
                printk(KERN_DEBUG "%s: STA %pM aid %d driver-ps-blocked\n",
1124
1146
                       sdata->name, sta->sta.addr, sta->sta.aid);
1137
1159
        WARN_ON(!(sta_inf->local->hw.flags & IEEE80211_HW_AP_LINK_PS));
1138
1160
 
1139
1161
        /* Don't let the same PS state be set twice */
1140
 
        in_ps = test_sta_flags(sta_inf, WLAN_STA_PS_STA);
 
1162
        in_ps = test_sta_flag(sta_inf, WLAN_STA_PS_STA);
1141
1163
        if ((start && in_ps) || (!start && !in_ps))
1142
1164
                return -EINVAL;
1143
1165
 
1151
1173
EXPORT_SYMBOL(ieee80211_sta_ps_transition);
1152
1174
 
1153
1175
static ieee80211_rx_result debug_noinline
 
1176
ieee80211_rx_h_uapsd_and_pspoll(struct ieee80211_rx_data *rx)
 
1177
{
 
1178
        struct ieee80211_sub_if_data *sdata = rx->sdata;
 
1179
        struct ieee80211_hdr *hdr = (void *)rx->skb->data;
 
1180
        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
 
1181
        int tid, ac;
 
1182
 
 
1183
        if (!rx->sta || !(status->rx_flags & IEEE80211_RX_RA_MATCH))
 
1184
                return RX_CONTINUE;
 
1185
 
 
1186
        if (sdata->vif.type != NL80211_IFTYPE_AP &&
 
1187
            sdata->vif.type != NL80211_IFTYPE_AP_VLAN)
 
1188
                return RX_CONTINUE;
 
1189
 
 
1190
        /*
 
1191
         * The device handles station powersave, so don't do anything about
 
1192
         * uAPSD and PS-Poll frames (the latter shouldn't even come up from
 
1193
         * it to mac80211 since they're handled.)
 
1194
         */
 
1195
        if (sdata->local->hw.flags & IEEE80211_HW_AP_LINK_PS)
 
1196
                return RX_CONTINUE;
 
1197
 
 
1198
        /*
 
1199
         * Don't do anything if the station isn't already asleep. In
 
1200
         * the uAPSD case, the station will probably be marked asleep,
 
1201
         * in the PS-Poll case the station must be confused ...
 
1202
         */
 
1203
        if (!test_sta_flag(rx->sta, WLAN_STA_PS_STA))
 
1204
                return RX_CONTINUE;
 
1205
 
 
1206
        if (unlikely(ieee80211_is_pspoll(hdr->frame_control))) {
 
1207
                if (!test_sta_flag(rx->sta, WLAN_STA_SP)) {
 
1208
                        if (!test_sta_flag(rx->sta, WLAN_STA_PS_DRIVER))
 
1209
                                ieee80211_sta_ps_deliver_poll_response(rx->sta);
 
1210
                        else
 
1211
                                set_sta_flag(rx->sta, WLAN_STA_PSPOLL);
 
1212
                }
 
1213
 
 
1214
                /* Free PS Poll skb here instead of returning RX_DROP that would
 
1215
                 * count as an dropped frame. */
 
1216
                dev_kfree_skb(rx->skb);
 
1217
 
 
1218
                return RX_QUEUED;
 
1219
        } else if (!ieee80211_has_morefrags(hdr->frame_control) &&
 
1220
                   !(status->rx_flags & IEEE80211_RX_DEFERRED_RELEASE) &&
 
1221
                   ieee80211_has_pm(hdr->frame_control) &&
 
1222
                   (ieee80211_is_data_qos(hdr->frame_control) ||
 
1223
                    ieee80211_is_qos_nullfunc(hdr->frame_control))) {
 
1224
                tid = *ieee80211_get_qos_ctl(hdr) & IEEE80211_QOS_CTL_TID_MASK;
 
1225
                ac = ieee802_1d_to_ac[tid & 7];
 
1226
 
 
1227
                /*
 
1228
                 * If this AC is not trigger-enabled do nothing.
 
1229
                 *
 
1230
                 * NB: This could/should check a separate bitmap of trigger-
 
1231
                 * enabled queues, but for now we only implement uAPSD w/o
 
1232
                 * TSPEC changes to the ACs, so they're always the same.
 
1233
                 */
 
1234
                if (!(rx->sta->sta.uapsd_queues & BIT(ac)))
 
1235
                        return RX_CONTINUE;
 
1236
 
 
1237
                /* if we are in a service period, do nothing */
 
1238
                if (test_sta_flag(rx->sta, WLAN_STA_SP))
 
1239
                        return RX_CONTINUE;
 
1240
 
 
1241
                if (!test_sta_flag(rx->sta, WLAN_STA_PS_DRIVER))
 
1242
                        ieee80211_sta_ps_deliver_uapsd(rx->sta);
 
1243
                else
 
1244
                        set_sta_flag(rx->sta, WLAN_STA_UAPSD);
 
1245
        }
 
1246
 
 
1247
        return RX_CONTINUE;
 
1248
}
 
1249
 
 
1250
static ieee80211_rx_result debug_noinline
1154
1251
ieee80211_rx_h_sta_process(struct ieee80211_rx_data *rx)
1155
1252
{
1156
1253
        struct sta_info *sta = rx->sta;
1208
1305
            !(status->rx_flags & IEEE80211_RX_DEFERRED_RELEASE) &&
1209
1306
            (rx->sdata->vif.type == NL80211_IFTYPE_AP ||
1210
1307
             rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN)) {
1211
 
                if (test_sta_flags(sta, WLAN_STA_PS_STA)) {
 
1308
                if (test_sta_flag(sta, WLAN_STA_PS_STA)) {
1212
1309
                        /*
1213
1310
                         * Ignore doze->wake transitions that are
1214
1311
                         * indicated by non-data frames, the standard
1377
1474
        if (frag == 0) {
1378
1475
                /* This is the first fragment of a new frame. */
1379
1476
                entry = ieee80211_reassemble_add(rx->sdata, frag, seq,
1380
 
                                                 rx->queue, &(rx->skb));
 
1477
                                                 rx->seqno_idx, &(rx->skb));
1381
1478
                if (rx->key && rx->key->conf.cipher == WLAN_CIPHER_SUITE_CCMP &&
1382
1479
                    ieee80211_has_protected(fc)) {
1383
 
                        int queue = ieee80211_is_mgmt(fc) ?
1384
 
                                NUM_RX_DATA_QUEUES : rx->queue;
 
1480
                        int queue = rx->security_idx;
1385
1481
                        /* Store CCMP PN so that we can verify that the next
1386
1482
                         * fragment has a sequential PN value. */
1387
1483
                        entry->ccmp = 1;
1395
1491
        /* This is a fragment for a frame that should already be pending in
1396
1492
         * fragment cache. Add this fragment to the end of the pending entry.
1397
1493
         */
1398
 
        entry = ieee80211_reassemble_find(rx->sdata, frag, seq, rx->queue, hdr);
 
1494
        entry = ieee80211_reassemble_find(rx->sdata, frag, seq,
 
1495
                                          rx->seqno_idx, hdr);
1399
1496
        if (!entry) {
1400
1497
                I802_DEBUG_INC(rx->local->rx_handlers_drop_defrag);
1401
1498
                return RX_DROP_MONITOR;
1415
1512
                        if (pn[i])
1416
1513
                                break;
1417
1514
                }
1418
 
                queue = ieee80211_is_mgmt(fc) ?
1419
 
                        NUM_RX_DATA_QUEUES : rx->queue;
 
1515
                queue = rx->security_idx;
1420
1516
                rpn = rx->key->u.ccmp.rx_pn[queue];
1421
1517
                if (memcmp(pn, rpn, CCMP_PN_LEN))
1422
1518
                        return RX_DROP_UNUSABLE;
1462
1558
}
1463
1559
 
1464
1560
static ieee80211_rx_result debug_noinline
1465
 
ieee80211_rx_h_ps_poll(struct ieee80211_rx_data *rx)
1466
 
{
1467
 
        struct ieee80211_sub_if_data *sdata = rx->sdata;
1468
 
        __le16 fc = ((struct ieee80211_hdr *)rx->skb->data)->frame_control;
1469
 
        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
1470
 
 
1471
 
        if (likely(!rx->sta || !ieee80211_is_pspoll(fc) ||
1472
 
                   !(status->rx_flags & IEEE80211_RX_RA_MATCH)))
1473
 
                return RX_CONTINUE;
1474
 
 
1475
 
        if ((sdata->vif.type != NL80211_IFTYPE_AP) &&
1476
 
            (sdata->vif.type != NL80211_IFTYPE_AP_VLAN))
1477
 
                return RX_DROP_UNUSABLE;
1478
 
 
1479
 
        if (!test_sta_flags(rx->sta, WLAN_STA_PS_DRIVER))
1480
 
                ieee80211_sta_ps_deliver_poll_response(rx->sta);
1481
 
        else
1482
 
                set_sta_flags(rx->sta, WLAN_STA_PSPOLL);
1483
 
 
1484
 
        /* Free PS Poll skb here instead of returning RX_DROP that would
1485
 
         * count as an dropped frame. */
1486
 
        dev_kfree_skb(rx->skb);
1487
 
 
1488
 
        return RX_QUEUED;
1489
 
}
1490
 
 
1491
 
static ieee80211_rx_result debug_noinline
1492
1561
ieee80211_rx_h_remove_qos_control(struct ieee80211_rx_data *rx)
1493
1562
{
1494
1563
        u8 *data = rx->skb->data;
1511
1580
ieee80211_802_1x_port_control(struct ieee80211_rx_data *rx)
1512
1581
{
1513
1582
        if (unlikely(!rx->sta ||
1514
 
            !test_sta_flags(rx->sta, WLAN_STA_AUTHORIZED)))
 
1583
            !test_sta_flag(rx->sta, WLAN_STA_AUTHORIZED)))
1515
1584
                return -EACCES;
1516
1585
 
1517
1586
        return 0;
1554
1623
        if (status->flag & RX_FLAG_DECRYPTED)
1555
1624
                return 0;
1556
1625
 
1557
 
        if (rx->sta && test_sta_flags(rx->sta, WLAN_STA_MFP)) {
 
1626
        if (rx->sta && test_sta_flag(rx->sta, WLAN_STA_MFP)) {
1558
1627
                if (unlikely(!ieee80211_has_protected(fc) &&
1559
1628
                             ieee80211_is_unicast_robust_mgmt_frame(rx->skb) &&
1560
1629
                             rx->key)) {
1820
1889
        hdrlen = ieee80211_hdrlen(hdr->frame_control);
1821
1890
        mesh_hdr = (struct ieee80211s_hdr *) (skb->data + hdrlen);
1822
1891
 
 
1892
        /* frame is in RMC, don't forward */
 
1893
        if (ieee80211_is_data(hdr->frame_control) &&
 
1894
            is_multicast_ether_addr(hdr->addr1) &&
 
1895
            mesh_rmc_check(hdr->addr3, mesh_hdr, rx->sdata))
 
1896
                return RX_DROP_MONITOR;
 
1897
 
1823
1898
        if (!ieee80211_is_data(hdr->frame_control))
1824
1899
                return RX_CONTINUE;
1825
1900
 
1827
1902
                /* illegal frame */
1828
1903
                return RX_DROP_MONITOR;
1829
1904
 
 
1905
        if (ieee80211_queue_stopped(&local->hw, skb_get_queue_mapping(skb))) {
 
1906
                IEEE80211_IFSTA_MESH_CTR_INC(&sdata->u.mesh,
 
1907
                                                dropped_frames_congestion);
 
1908
                return RX_DROP_MONITOR;
 
1909
        }
 
1910
 
1830
1911
        if (mesh_hdr->flags & MESH_FLAGS_AE) {
1831
1912
                struct mesh_path *mppath;
1832
1913
                char *proxied_addr;
1882
1963
                        memset(info, 0, sizeof(*info));
1883
1964
                        info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
1884
1965
                        info->control.vif = &rx->sdata->vif;
1885
 
                        skb_set_queue_mapping(skb,
1886
 
                                ieee80211_select_queue(rx->sdata, fwd_skb));
1887
 
                        ieee80211_set_qos_hdr(local, skb);
1888
 
                        if (is_multicast_ether_addr(fwd_hdr->addr1))
 
1966
                        if (is_multicast_ether_addr(fwd_hdr->addr1)) {
1889
1967
                                IEEE80211_IFSTA_MESH_CTR_INC(&sdata->u.mesh,
1890
1968
                                                                fwded_mcast);
1891
 
                        else {
 
1969
                                skb_set_queue_mapping(fwd_skb,
 
1970
                                        ieee80211_select_queue(sdata, fwd_skb));
 
1971
                                ieee80211_set_qos_hdr(sdata, fwd_skb);
 
1972
                        } else {
1892
1973
                                int err;
1893
1974
                                /*
1894
1975
                                 * Save TA to addr1 to send TA a path error if a
2213
2294
                        goto handled;
2214
2295
                }
2215
2296
                break;
 
2297
        case WLAN_CATEGORY_SELF_PROTECTED:
 
2298
                switch (mgmt->u.action.u.self_prot.action_code) {
 
2299
                case WLAN_SP_MESH_PEERING_OPEN:
 
2300
                case WLAN_SP_MESH_PEERING_CLOSE:
 
2301
                case WLAN_SP_MESH_PEERING_CONFIRM:
 
2302
                        if (!ieee80211_vif_is_mesh(&sdata->vif))
 
2303
                                goto invalid;
 
2304
                        if (sdata->u.mesh.security != IEEE80211_MESH_SEC_NONE)
 
2305
                                /* userspace handles this frame */
 
2306
                                break;
 
2307
                        goto queue;
 
2308
                case WLAN_SP_MGK_INFORM:
 
2309
                case WLAN_SP_MGK_ACK:
 
2310
                        if (!ieee80211_vif_is_mesh(&sdata->vif))
 
2311
                                goto invalid;
 
2312
                        break;
 
2313
                }
 
2314
                break;
2216
2315
        case WLAN_CATEGORY_MESH_ACTION:
2217
2316
                if (!ieee80211_vif_is_mesh(&sdata->vif))
2218
2317
                        break;
2219
 
                goto queue;
2220
 
        case WLAN_CATEGORY_MESH_PATH_SEL:
2221
 
                if (!mesh_path_sel_is_hwmp(sdata))
 
2318
                if (mesh_action_is_path_sel(mgmt) &&
 
2319
                  (!mesh_path_sel_is_hwmp(sdata)))
2222
2320
                        break;
2223
2321
                goto queue;
2224
2322
        }
2527
2625
 
2528
2626
                CALL_RXH(ieee80211_rx_h_decrypt)
2529
2627
                CALL_RXH(ieee80211_rx_h_check_more_data)
 
2628
                CALL_RXH(ieee80211_rx_h_uapsd_and_pspoll)
2530
2629
                CALL_RXH(ieee80211_rx_h_sta_process)
2531
2630
                CALL_RXH(ieee80211_rx_h_defragment)
2532
 
                CALL_RXH(ieee80211_rx_h_ps_poll)
2533
2631
                CALL_RXH(ieee80211_rx_h_michael_mic_verify)
2534
2632
                /* must be after MMIC verify so header is counted in MPDU mic */
 
2633
#ifdef CONFIG_MAC80211_MESH
 
2634
                if (ieee80211_vif_is_mesh(&rx->sdata->vif))
 
2635
                        CALL_RXH(ieee80211_rx_h_mesh_fwding);
 
2636
#endif
2535
2637
                CALL_RXH(ieee80211_rx_h_remove_qos_control)
2536
2638
                CALL_RXH(ieee80211_rx_h_amsdu)
2537
 
#ifdef CONFIG_MAC80211_MESH
2538
 
                if (ieee80211_vif_is_mesh(&rx->sdata->vif))
2539
 
                        CALL_RXH(ieee80211_rx_h_mesh_fwding);
2540
 
#endif
2541
2639
                CALL_RXH(ieee80211_rx_h_data)
2542
2640
                CALL_RXH(ieee80211_rx_h_ctrl);
2543
2641
                CALL_RXH(ieee80211_rx_h_mgmt_check)
2593
2691
                .sta = sta,
2594
2692
                .sdata = sta->sdata,
2595
2693
                .local = sta->local,
2596
 
                .queue = tid,
 
2694
                /* This is OK -- must be QoS data frame */
 
2695
                .security_idx = tid,
 
2696
                .seqno_idx = tid,
2597
2697
                .flags = 0,
2598
2698
        };
2599
2699
        struct tid_ampdu_rx *tid_agg_rx;
2677
2777
                } else if (!ieee80211_bssid_match(bssid,
2678
2778
                                        sdata->vif.addr)) {
2679
2779
                        if (!(status->rx_flags & IEEE80211_RX_IN_SCAN) &&
2680
 
                            !ieee80211_is_beacon(hdr->frame_control))
 
2780
                            !ieee80211_is_beacon(hdr->frame_control) &&
 
2781
                            !(ieee80211_is_action(hdr->frame_control) &&
 
2782
                              sdata->vif.p2p))
2681
2783
                                return 0;
2682
2784
                        status->rx_flags &= ~IEEE80211_RX_RA_MATCH;
2683
2785
                }
2762
2864
                local->dot11ReceivedFragmentCount++;
2763
2865
 
2764
2866
        if (unlikely(test_bit(SCAN_HW_SCANNING, &local->scanning) ||
2765
 
                     test_bit(SCAN_SW_SCANNING, &local->scanning)))
 
2867
                     test_bit(SCAN_OFF_CHANNEL, &local->scanning)))
2766
2868
                status->rx_flags |= IEEE80211_RX_IN_SCAN;
2767
2869
 
2768
2870
        if (ieee80211_is_mgmt(fc))
2782
2884
        if (ieee80211_is_data(fc)) {
2783
2885
                prev_sta = NULL;
2784
2886
 
2785
 
                for_each_sta_info(local, hdr->addr2, sta, tmp) {
 
2887
                for_each_sta_info_rx(local, hdr->addr2, sta, tmp) {
2786
2888
                        if (!prev_sta) {
2787
2889
                                prev_sta = sta;
2788
2890
                                continue;
2826
2928
                        continue;
2827
2929
                }
2828
2930
 
2829
 
                rx.sta = sta_info_get_bss(prev, hdr->addr2);
 
2931
                rx.sta = sta_info_get_bss_rx(prev, hdr->addr2);
2830
2932
                rx.sdata = prev;
2831
2933
                ieee80211_prepare_and_rx_handle(&rx, skb, false);
2832
2934
 
2834
2936
        }
2835
2937
 
2836
2938
        if (prev) {
2837
 
                rx.sta = sta_info_get_bss(prev, hdr->addr2);
 
2939
                rx.sta = sta_info_get_bss_rx(prev, hdr->addr2);
2838
2940
                rx.sdata = prev;
2839
2941
 
2840
2942
                if (ieee80211_prepare_and_rx_handle(&rx, skb, true))