Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6
* 'master' of master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6:
[NETFILTER]: Fix NULL pointer dereference in nf_nat_move_storage()
[SUNHME]: VLAN support for sunhme
[CHELSIO]: Fix skb->dev setting.
[NETFILTER]: fix compat_nf_sockopt typo
[INET]: Fix potential kfree on vmalloc-ed area of request_sock_queue
[VIA_VELOCITY]: Don't oops on MTU change.
iwl4965: fix not correctly dealing with hotunplug
rt2x00: Fix chipset revision validation
iwl3945: place CCK rates in front of OFDM for supported rates
mac80211: Fix queuing of scan containing a SSID
+223
-111
+1
-1
drivers/net/chelsio/sge.c
+1
-1
drivers/net/chelsio/sge.c
···
1379
1379
}
1380
1380
__skb_pull(skb, sizeof(*p));
1381
1381
1382
-
skb->dev->last_rx = jiffies;
1383
1382
st = per_cpu_ptr(sge->port_stats[p->iff], smp_processor_id());
1384
1383
st->rx_packets++;
1385
1384
1386
1385
skb->protocol = eth_type_trans(skb, adapter->port[p->iff].dev);
1386
+
skb->dev->last_rx = jiffies;
1387
1387
if ((adapter->flags & RX_CSUM_ENABLED) && p->csum == 0xffff &&
1388
1388
skb->protocol == htons(ETH_P_IP) &&
1389
1389
(skb->data[9] == IPPROTO_TCP || skb->data[9] == IPPROTO_UDP)) {
+11
-6
drivers/net/sunhme.c
+11
-6
drivers/net/sunhme.c
···
1281
1281
skb->dev = dev;
1282
1282
1283
1283
/* Because we reserve afterwards. */
1284
-
skb_put(skb, (ETH_FRAME_LEN + RX_OFFSET));
1284
+
skb_put(skb, (ETH_FRAME_LEN + RX_OFFSET + 4));
1285
1285
hme_write_rxd(hp, &hb->happy_meal_rxd[i],
1286
1286
(RXFLAG_OWN | ((RX_BUF_ALLOC_SIZE - RX_OFFSET) << 16)),
1287
1287
hme_dma_map(hp, skb->data, RX_BUF_ALLOC_SIZE, DMA_FROMDEVICE));
···
1700
1700
HMD(("tx old[%08x] and rx [%08x] ON!\n",
1701
1701
hme_read32(hp, bregs + BMAC_TXCFG),
1702
1702
hme_read32(hp, bregs + BMAC_RXCFG)));
1703
+
1704
+
/* Set larger TX/RX size to allow for 802.1q */
1705
+
hme_write32(hp, bregs + BMAC_TXMAX, ETH_FRAME_LEN + 8);
1706
+
hme_write32(hp, bregs + BMAC_RXMAX, ETH_FRAME_LEN + 8);
1707
+
1703
1708
hme_write32(hp, bregs + BMAC_TXCFG,
1704
1709
hme_read32(hp, bregs + BMAC_TXCFG) | BIGMAC_TXCFG_ENABLE);
1705
1710
hme_write32(hp, bregs + BMAC_RXCFG,
···
2044
2039
hme_dma_unmap(hp, dma_addr, RX_BUF_ALLOC_SIZE, DMA_FROMDEVICE);
2045
2040
hp->rx_skbs[elem] = new_skb;
2046
2041
new_skb->dev = dev;
2047
-
skb_put(new_skb, (ETH_FRAME_LEN + RX_OFFSET));
2042
+
skb_put(new_skb, (ETH_FRAME_LEN + RX_OFFSET + 4));
2048
2043
hme_write_rxd(hp, this,
2049
2044
(RXFLAG_OWN|((RX_BUF_ALLOC_SIZE-RX_OFFSET)<<16)),
2050
2045
hme_dma_map(hp, new_skb->data, RX_BUF_ALLOC_SIZE, DMA_FROMDEVICE));
···
2814
2809
dev->watchdog_timeo = 5*HZ;
2815
2810
dev->ethtool_ops = &hme_ethtool_ops;
2816
2811
2817
-
/* Happy Meal can do it all... except VLAN. */
2818
-
dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_VLAN_CHALLENGED;
2812
+
/* Happy Meal can do it all... */
2813
+
dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;
2819
2814
2820
2815
dev->irq = sdev->irqs[0];
2821
2816
···
3148
3143
dev->irq = pdev->irq;
3149
3144
dev->dma = 0;
3150
3145
3151
-
/* Happy Meal can do it all... except VLAN. */
3152
-
dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_VLAN_CHALLENGED;
3146
+
/* Happy Meal can do it all... */
3147
+
dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;
3153
3148
3154
3149
#if defined(CONFIG_SBUS) && defined(CONFIG_PCI)
3155
3150
/* Hook up PCI register/dma accessors. */
+5
drivers/net/via-velocity.c
+5
drivers/net/via-velocity.c
+48
-8
drivers/net/wireless/iwlwifi/iwl-3945-rs.c
+48
-8
drivers/net/wireless/iwlwifi/iwl-3945-rs.c
···
71
71
};
72
72
73
73
static s32 iwl_expected_tpt_g[IWL_RATE_COUNT] = {
74
-
0, 0, 76, 104, 130, 168, 191, 202, 7, 13, 35, 58
74
+
7, 13, 35, 58, 0, 0, 76, 104, 130, 168, 191, 202
75
75
};
76
76
77
77
static s32 iwl_expected_tpt_g_prot[IWL_RATE_COUNT] = {
78
-
0, 0, 0, 80, 93, 113, 123, 125, 7, 13, 35, 58
78
+
7, 13, 35, 58, 0, 0, 0, 80, 93, 113, 123, 125
79
79
};
80
80
81
81
static s32 iwl_expected_tpt_a[IWL_RATE_COUNT] = {
82
-
40, 57, 72, 98, 121, 154, 177, 186, 0, 0, 0, 0
82
+
0, 0, 0, 0, 40, 57, 72, 98, 121, 154, 177, 186
83
83
};
84
84
85
85
static s32 iwl_expected_tpt_b[IWL_RATE_COUNT] = {
86
-
0, 0, 0, 0, 0, 0, 0, 0, 7, 13, 35, 58
86
+
7, 13, 35, 58, 0, 0, 0, 0, 0, 0, 0, 0
87
87
};
88
88
89
89
struct iwl_tpt_entry {
···
350
350
351
351
sta->last_txrate = sta->txrate;
352
352
353
+
/* For MODE_IEEE80211A mode it start at IWL_FIRST_OFDM_RATE */
354
+
if (local->hw.conf.phymode == MODE_IEEE80211A)
355
+
sta->last_txrate += IWL_FIRST_OFDM_RATE;
356
+
353
357
IWL_DEBUG_RATE("leave\n");
354
358
}
355
359
···
421
417
IWL_DEBUG_RATE("leave\n");
422
418
}
423
419
420
+
421
+
/*
422
+
* get ieee prev rate from rate scale table.
423
+
* for A and B mode we need to overright prev
424
+
* value
425
+
*/
426
+
static int rs_adjust_next_rate(struct iwl_priv *priv, int rate)
427
+
{
428
+
int next_rate = iwl_get_prev_ieee_rate(rate);
429
+
430
+
switch (priv->phymode) {
431
+
case MODE_IEEE80211A:
432
+
if (rate == IWL_RATE_12M_INDEX)
433
+
next_rate = IWL_RATE_9M_INDEX;
434
+
else if (rate == IWL_RATE_6M_INDEX)
435
+
next_rate = IWL_RATE_6M_INDEX;
436
+
break;
437
+
case MODE_IEEE80211B:
438
+
if (rate == IWL_RATE_11M_INDEX_TABLE)
439
+
next_rate = IWL_RATE_5M_INDEX_TABLE;
440
+
break;
441
+
default:
442
+
break;
443
+
}
444
+
445
+
return next_rate;
446
+
}
424
447
/**
425
448
* rs_tx_status - Update rate control values based on Tx results
426
449
*
···
510
479
last_index = scale_rate_index;
511
480
} else {
512
481
current_count = priv->retry_rate;
513
-
last_index = iwl_get_prev_ieee_rate(scale_rate_index);
482
+
last_index = rs_adjust_next_rate(priv,
483
+
scale_rate_index);
514
484
}
515
485
516
486
/* Update this rate accounting for as many retries
···
526
494
527
495
if (retries)
528
496
scale_rate_index =
529
-
iwl_get_prev_ieee_rate(scale_rate_index);
497
+
rs_adjust_next_rate(priv, scale_rate_index);
530
498
}
499
+
531
500
532
501
/* Update the last index window with success/failure based on ACK */
533
502
IWL_DEBUG_RATE("Update rate %d with %s.\n",
···
705
672
}
706
673
707
674
rate_mask = sta->supp_rates;
708
-
index = min(sta->txrate & 0xffff, IWL_RATE_COUNT - 1);
675
+
index = min(sta->last_txrate & 0xffff, IWL_RATE_COUNT - 1);
676
+
677
+
if (priv->phymode == (u8) MODE_IEEE80211A)
678
+
rate_mask = rate_mask << IWL_FIRST_OFDM_RATE;
709
679
710
680
rs_priv = (void *)sta->rate_ctrl_priv;
711
681
···
837
801
out:
838
802
839
803
sta->last_txrate = index;
840
-
sta->txrate = sta->last_txrate;
804
+
if (priv->phymode == (u8) MODE_IEEE80211A)
805
+
sta->txrate = sta->last_txrate - IWL_FIRST_OFDM_RATE;
806
+
else
807
+
sta->txrate = sta->last_txrate;
808
+
841
809
sta_info_put(sta);
842
810
843
811
IWL_DEBUG_RATE("leave: %d\n", index);
+24
-5
drivers/net/wireless/iwlwifi/iwl-3945-rs.h
+24
-5
drivers/net/wireless/iwlwifi/iwl-3945-rs.h
···
36
36
u8 next_rs; /* next rate used in rs algo */
37
37
u8 prev_rs_tgg; /* previous rate used in TGG rs algo */
38
38
u8 next_rs_tgg; /* next rate used in TGG rs algo */
39
+
u8 table_rs_index; /* index in rate scale table cmd */
40
+
u8 prev_table_rs; /* prev in rate table cmd */
41
+
39
42
};
40
43
41
44
enum {
42
-
IWL_RATE_6M_INDEX = 0,
45
+
IWL_RATE_1M_INDEX = 0,
46
+
IWL_RATE_2M_INDEX,
47
+
IWL_RATE_5M_INDEX,
48
+
IWL_RATE_11M_INDEX,
49
+
IWL_RATE_6M_INDEX,
43
50
IWL_RATE_9M_INDEX,
44
51
IWL_RATE_12M_INDEX,
45
52
IWL_RATE_18M_INDEX,
···
54
47
IWL_RATE_36M_INDEX,
55
48
IWL_RATE_48M_INDEX,
56
49
IWL_RATE_54M_INDEX,
57
-
IWL_RATE_1M_INDEX,
58
-
IWL_RATE_2M_INDEX,
59
-
IWL_RATE_5M_INDEX,
60
-
IWL_RATE_11M_INDEX,
61
50
IWL_RATE_COUNT,
62
51
IWL_RATE_INVM_INDEX,
63
52
IWL_RATE_INVALID = IWL_RATE_INVM_INDEX
53
+
};
54
+
55
+
enum {
56
+
IWL_RATE_6M_INDEX_TABLE = 0,
57
+
IWL_RATE_9M_INDEX_TABLE,
58
+
IWL_RATE_12M_INDEX_TABLE,
59
+
IWL_RATE_18M_INDEX_TABLE,
60
+
IWL_RATE_24M_INDEX_TABLE,
61
+
IWL_RATE_36M_INDEX_TABLE,
62
+
IWL_RATE_48M_INDEX_TABLE,
63
+
IWL_RATE_54M_INDEX_TABLE,
64
+
IWL_RATE_1M_INDEX_TABLE,
65
+
IWL_RATE_2M_INDEX_TABLE,
66
+
IWL_RATE_5M_INDEX_TABLE,
67
+
IWL_RATE_11M_INDEX_TABLE,
68
+
IWL_RATE_INVM_INDEX_TABLE = IWL_RATE_INVM_INDEX,
64
69
};
65
70
66
71
enum {
+68
-56
drivers/net/wireless/iwlwifi/iwl-3945.c
+68
-56
drivers/net/wireless/iwlwifi/iwl-3945.c
···
54
54
IWL_RATE_##rp##M_INDEX, \
55
55
IWL_RATE_##rn##M_INDEX, \
56
56
IWL_RATE_##pp##M_INDEX, \
57
-
IWL_RATE_##np##M_INDEX }
57
+
IWL_RATE_##np##M_INDEX, \
58
+
IWL_RATE_##r##M_INDEX_TABLE, \
59
+
IWL_RATE_##ip##M_INDEX_TABLE }
58
60
59
61
/*
60
62
* Parameter order:
···
67
65
*
68
66
*/
69
67
const struct iwl_rate_info iwl_rates[IWL_RATE_COUNT] = {
68
+
IWL_DECLARE_RATE_INFO(1, INV, 2, INV, 2, INV, 2), /* 1mbps */
69
+
IWL_DECLARE_RATE_INFO(2, 1, 5, 1, 5, 1, 5), /* 2mbps */
70
+
IWL_DECLARE_RATE_INFO(5, 2, 6, 2, 11, 2, 11), /*5.5mbps */
71
+
IWL_DECLARE_RATE_INFO(11, 9, 12, 5, 12, 5, 18), /* 11mbps */
70
72
IWL_DECLARE_RATE_INFO(6, 5, 9, 5, 11, 5, 11), /* 6mbps */
71
73
IWL_DECLARE_RATE_INFO(9, 6, 11, 5, 11, 5, 11), /* 9mbps */
72
74
IWL_DECLARE_RATE_INFO(12, 11, 18, 11, 18, 11, 18), /* 12mbps */
···
79
73
IWL_DECLARE_RATE_INFO(36, 24, 48, 24, 48, 24, 48), /* 36mbps */
80
74
IWL_DECLARE_RATE_INFO(48, 36, 54, 36, 54, 36, 54), /* 48mbps */
81
75
IWL_DECLARE_RATE_INFO(54, 48, INV, 48, INV, 48, INV),/* 54mbps */
82
-
IWL_DECLARE_RATE_INFO(1, INV, 2, INV, 2, INV, 2), /* 1mbps */
83
-
IWL_DECLARE_RATE_INFO(2, 1, 5, 1, 5, 1, 5), /* 2mbps */
84
-
IWL_DECLARE_RATE_INFO(5, 2, 6, 2, 11, 2, 11), /*5.5mbps */
85
-
IWL_DECLARE_RATE_INFO(11, 9, 12, 5, 12, 5, 18), /* 11mbps */
86
76
};
87
77
88
78
/* 1 = enable the iwl_disable_events() function */
···
664
662
cmd->cmd.tx.tx_flags = tx_flags;
665
663
666
664
/* OFDM */
667
-
cmd->cmd.tx.supp_rates[0] = rate_mask & IWL_OFDM_RATES_MASK;
665
+
cmd->cmd.tx.supp_rates[0] =
666
+
((rate_mask & IWL_OFDM_RATES_MASK) >> IWL_FIRST_OFDM_RATE) & 0xFF;
668
667
669
668
/* CCK */
670
-
cmd->cmd.tx.supp_rates[1] = (rate_mask >> 8) & 0xF;
669
+
cmd->cmd.tx.supp_rates[1] = (rate_mask & 0xF);
671
670
672
671
IWL_DEBUG_RATE("Tx sta id: %d, rate: %d (plcp), flags: 0x%4X "
673
672
"cck/ofdm mask: 0x%x/0x%x\n", sta_id,
···
1435
1432
/* use this channel group's 6Mbit clipping/saturation pwr,
1436
1433
* but cap at regulatory scan power restriction (set during init
1437
1434
* based on eeprom channel data) for this channel. */
1438
-
power = min(ch_info->scan_power, clip_pwrs[IWL_RATE_6M_INDEX]);
1435
+
power = min(ch_info->scan_power, clip_pwrs[IWL_RATE_6M_INDEX_TABLE]);
1439
1436
1440
1437
/* further limit to user's max power preference.
1441
1438
* FIXME: Other spectrum management power limitations do not
···
1450
1447
* *index*. */
1451
1448
power_index = ch_info->power_info[rate_index].power_table_index
1452
1449
- (power - ch_info->power_info
1453
-
[IWL_RATE_6M_INDEX].requested_power) * 2;
1450
+
[IWL_RATE_6M_INDEX_TABLE].requested_power) * 2;
1454
1451
1455
1452
/* store reference index that we use when adjusting *all* scan
1456
1453
* powers. So we can accommodate user (all channel) or spectrum
···
1479
1476
*/
1480
1477
int iwl_hw_reg_send_txpower(struct iwl_priv *priv)
1481
1478
{
1482
-
int rate_idx;
1479
+
int rate_idx, i;
1483
1480
const struct iwl_channel_info *ch_info = NULL;
1484
1481
struct iwl_txpowertable_cmd txpower = {
1485
1482
.channel = priv->active_rxon.channel,
···
1503
1500
}
1504
1501
1505
1502
/* fill cmd with power settings for all rates for current channel */
1506
-
for (rate_idx = 0; rate_idx < IWL_RATE_COUNT; rate_idx++) {
1507
-
txpower.power[rate_idx].tpc = ch_info->power_info[rate_idx].tpc;
1508
-
txpower.power[rate_idx].rate = iwl_rates[rate_idx].plcp;
1503
+
/* Fill OFDM rate */
1504
+
for (rate_idx = IWL_FIRST_OFDM_RATE, i = 0;
1505
+
rate_idx <= IWL_LAST_OFDM_RATE; rate_idx++, i++) {
1506
+
1507
+
txpower.power[i].tpc = ch_info->power_info[i].tpc;
1508
+
txpower.power[i].rate = iwl_rates[rate_idx].plcp;
1509
1509
1510
1510
IWL_DEBUG_POWER("ch %d:%d rf %d dsp %3d rate code 0x%02x\n",
1511
1511
le16_to_cpu(txpower.channel),
1512
1512
txpower.band,
1513
-
txpower.power[rate_idx].tpc.tx_gain,
1514
-
txpower.power[rate_idx].tpc.dsp_atten,
1515
-
txpower.power[rate_idx].rate);
1513
+
txpower.power[i].tpc.tx_gain,
1514
+
txpower.power[i].tpc.dsp_atten,
1515
+
txpower.power[i].rate);
1516
+
}
1517
+
/* Fill CCK rates */
1518
+
for (rate_idx = IWL_FIRST_CCK_RATE;
1519
+
rate_idx <= IWL_LAST_CCK_RATE; rate_idx++, i++) {
1520
+
txpower.power[i].tpc = ch_info->power_info[i].tpc;
1521
+
txpower.power[i].rate = iwl_rates[rate_idx].plcp;
1522
+
1523
+
IWL_DEBUG_POWER("ch %d:%d rf %d dsp %3d rate code 0x%02x\n",
1524
+
le16_to_cpu(txpower.channel),
1525
+
txpower.band,
1526
+
txpower.power[i].tpc.tx_gain,
1527
+
txpower.power[i].tpc.dsp_atten,
1528
+
txpower.power[i].rate);
1516
1529
}
1517
1530
1518
1531
return iwl_send_cmd_pdu(priv, REPLY_TX_PWR_TABLE_CMD,
1519
-
sizeof(struct iwl_txpowertable_cmd), &txpower);
1532
+
sizeof(struct iwl_txpowertable_cmd), &txpower);
1520
1533
1521
1534
}
1522
1535
···
1568
1549
power_info = ch_info->power_info;
1569
1550
1570
1551
/* update OFDM Txpower settings */
1571
-
for (i = IWL_FIRST_OFDM_RATE; i <= IWL_LAST_OFDM_RATE;
1552
+
for (i = IWL_RATE_6M_INDEX_TABLE; i <= IWL_RATE_54M_INDEX_TABLE;
1572
1553
i++, ++power_info) {
1573
1554
int delta_idx;
1574
1555
···
1592
1573
* ... all CCK power settings for a given channel are the *same*. */
1593
1574
if (power_changed) {
1594
1575
power =
1595
-
ch_info->power_info[IWL_RATE_12M_INDEX].
1576
+
ch_info->power_info[IWL_RATE_12M_INDEX_TABLE].
1596
1577
requested_power + IWL_CCK_FROM_OFDM_POWER_DIFF;
1597
1578
1598
1579
/* do all CCK rates' iwl_channel_power_info structures */
1599
-
for (i = IWL_FIRST_CCK_RATE; i <= IWL_LAST_CCK_RATE; i++) {
1580
+
for (i = IWL_RATE_1M_INDEX_TABLE; i <= IWL_RATE_11M_INDEX_TABLE; i++) {
1600
1581
power_info->requested_power = power;
1601
1582
power_info->base_power_index =
1602
-
ch_info->power_info[IWL_RATE_12M_INDEX].
1583
+
ch_info->power_info[IWL_RATE_12M_INDEX_TABLE].
1603
1584
base_power_index + IWL_CCK_FROM_OFDM_INDEX_DIFF;
1604
1585
++power_info;
1605
1586
}
···
1693
1674
for (scan_tbl_index = 0;
1694
1675
scan_tbl_index < IWL_NUM_SCAN_RATES; scan_tbl_index++) {
1695
1676
s32 actual_index = (scan_tbl_index == 0) ?
1696
-
IWL_RATE_1M_INDEX : IWL_RATE_6M_INDEX;
1677
+
IWL_RATE_1M_INDEX_TABLE : IWL_RATE_6M_INDEX_TABLE;
1697
1678
iwl_hw_reg_set_scan_power(priv, scan_tbl_index,
1698
1679
actual_index, clip_pwrs,
1699
1680
ch_info, a_band);
···
1924
1905
for (rate_index = 0;
1925
1906
rate_index < IWL_RATE_COUNT; rate_index++, clip_pwrs++) {
1926
1907
switch (rate_index) {
1927
-
case IWL_RATE_36M_INDEX:
1908
+
case IWL_RATE_36M_INDEX_TABLE:
1928
1909
if (i == 0) /* B/G */
1929
1910
*clip_pwrs = satur_pwr;
1930
1911
else /* A */
1931
1912
*clip_pwrs = satur_pwr - 5;
1932
1913
break;
1933
-
case IWL_RATE_48M_INDEX:
1914
+
case IWL_RATE_48M_INDEX_TABLE:
1934
1915
if (i == 0)
1935
1916
*clip_pwrs = satur_pwr - 7;
1936
1917
else
1937
1918
*clip_pwrs = satur_pwr - 10;
1938
1919
break;
1939
-
case IWL_RATE_54M_INDEX:
1920
+
case IWL_RATE_54M_INDEX_TABLE:
1940
1921
if (i == 0)
1941
1922
*clip_pwrs = satur_pwr - 9;
1942
1923
else
···
2050
2031
}
2051
2032
2052
2033
/* set tx power for CCK rates, based on OFDM 12 Mbit settings*/
2053
-
pwr_info = &ch_info->power_info[IWL_RATE_12M_INDEX];
2034
+
pwr_info = &ch_info->power_info[IWL_RATE_12M_INDEX_TABLE];
2054
2035
power = pwr_info->requested_power +
2055
2036
IWL_CCK_FROM_OFDM_POWER_DIFF;
2056
2037
pwr_index = pwr_info->power_table_index +
···
2066
2047
/* fill each CCK rate's iwl_channel_power_info structure
2067
2048
* NOTE: All CCK-rate Txpwrs are the same for a given chnl!
2068
2049
* NOTE: CCK rates start at end of OFDM rates! */
2069
-
for (rate_index = IWL_OFDM_RATES;
2070
-
rate_index < IWL_RATE_COUNT; rate_index++) {
2071
-
pwr_info = &ch_info->power_info[rate_index];
2050
+
for (rate_index = 0;
2051
+
rate_index < IWL_CCK_RATES; rate_index++) {
2052
+
pwr_info = &ch_info->power_info[rate_index+IWL_OFDM_RATES];
2072
2053
pwr_info->requested_power = power;
2073
2054
pwr_info->power_table_index = pwr_index;
2074
2055
pwr_info->base_power_index = base_pwr_index;
···
2080
2061
for (scan_tbl_index = 0;
2081
2062
scan_tbl_index < IWL_NUM_SCAN_RATES; scan_tbl_index++) {
2082
2063
s32 actual_index = (scan_tbl_index == 0) ?
2083
-
IWL_RATE_1M_INDEX : IWL_RATE_6M_INDEX;
2064
+
IWL_RATE_1M_INDEX_TABLE : IWL_RATE_6M_INDEX_TABLE;
2084
2065
iwl_hw_reg_set_scan_power(priv, scan_tbl_index,
2085
2066
actual_index, clip_pwrs, ch_info, a_band);
2086
2067
}
···
2158
2139
*/
2159
2140
int iwl3945_init_hw_rate_table(struct iwl_priv *priv)
2160
2141
{
2161
-
int rc, i;
2142
+
int rc, i, index, prev_index;
2162
2143
struct iwl_rate_scaling_cmd rate_cmd = {
2163
2144
.reserved = {0, 0, 0},
2164
2145
};
2165
2146
struct iwl_rate_scaling_info *table = rate_cmd.table;
2166
2147
2167
2148
for (i = 0; i < ARRAY_SIZE(iwl_rates); i++) {
2168
-
table[i].rate_n_flags =
2149
+
index = iwl_rates[i].table_rs_index;
2150
+
2151
+
table[index].rate_n_flags =
2169
2152
iwl_hw_set_rate_n_flags(iwl_rates[i].plcp, 0);
2170
-
table[i].try_cnt = priv->retry_rate;
2171
-
table[i].next_rate_index = iwl_get_prev_ieee_rate(i);
2153
+
table[index].try_cnt = priv->retry_rate;
2154
+
prev_index = iwl_get_prev_ieee_rate(i);
2155
+
table[index].next_rate_index = iwl_rates[prev_index].table_rs_index;
2172
2156
}
2173
2157
2174
2158
switch (priv->phymode) {
···
2179
2157
IWL_DEBUG_RATE("Select A mode rate scale\n");
2180
2158
/* If one of the following CCK rates is used,
2181
2159
* have it fall back to the 6M OFDM rate */
2182
-
for (i = IWL_FIRST_CCK_RATE; i <= IWL_LAST_CCK_RATE; i++)
2183
-
table[i].next_rate_index = IWL_FIRST_OFDM_RATE;
2160
+
for (i = IWL_RATE_1M_INDEX_TABLE; i <= IWL_RATE_11M_INDEX_TABLE; i++)
2161
+
table[i].next_rate_index = iwl_rates[IWL_FIRST_OFDM_RATE].table_rs_index;
2184
2162
2185
2163
/* Don't fall back to CCK rates */
2186
-
table[IWL_RATE_12M_INDEX].next_rate_index = IWL_RATE_9M_INDEX;
2164
+
table[IWL_RATE_12M_INDEX_TABLE].next_rate_index = IWL_RATE_9M_INDEX_TABLE;
2187
2165
2188
2166
/* Don't drop out of OFDM rates */
2189
-
table[IWL_FIRST_OFDM_RATE].next_rate_index =
2190
-
IWL_FIRST_OFDM_RATE;
2167
+
table[IWL_RATE_6M_INDEX_TABLE].next_rate_index =
2168
+
iwl_rates[IWL_FIRST_OFDM_RATE].table_rs_index;
2191
2169
break;
2192
2170
2193
2171
case MODE_IEEE80211B:
2194
2172
IWL_DEBUG_RATE("Select B mode rate scale\n");
2195
2173
/* If an OFDM rate is used, have it fall back to the
2196
2174
* 1M CCK rates */
2197
-
for (i = IWL_FIRST_OFDM_RATE; i <= IWL_LAST_OFDM_RATE; i++)
2198
-
table[i].next_rate_index = IWL_FIRST_CCK_RATE;
2175
+
for (i = IWL_RATE_6M_INDEX_TABLE; i <= IWL_RATE_54M_INDEX_TABLE; i++)
2176
+
table[i].next_rate_index = iwl_rates[IWL_FIRST_CCK_RATE].table_rs_index;
2199
2177
2200
2178
/* CCK shouldn't fall back to OFDM... */
2201
-
table[IWL_RATE_11M_INDEX].next_rate_index = IWL_RATE_5M_INDEX;
2179
+
table[IWL_RATE_11M_INDEX_TABLE].next_rate_index = IWL_RATE_5M_INDEX_TABLE;
2202
2180
break;
2203
2181
2204
2182
default:
···
2270
2248
tx_beacon_cmd->tx.tx_flags = (TX_CMD_FLG_SEQ_CTL_MSK |
2271
2249
TX_CMD_FLG_TSF_MSK);
2272
2250
2273
-
/* supp_rates[0] == OFDM */
2274
-
tx_beacon_cmd->tx.supp_rates[0] = IWL_OFDM_BASIC_RATES_MASK;
2251
+
/* supp_rates[0] == OFDM start at IWL_FIRST_OFDM_RATE*/
2252
+
tx_beacon_cmd->tx.supp_rates[0] =
2253
+
(IWL_OFDM_BASIC_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
2275
2254
2276
-
/* supp_rates[1] == CCK
2277
-
*
2278
-
* NOTE: IWL_*_RATES_MASK are not in the order that supp_rates
2279
-
* expects so we have to shift them around.
2280
-
*
2281
-
* supp_rates expects:
2282
-
* CCK rates are bit0..3
2283
-
*
2284
-
* However IWL_*_RATES_MASK has:
2285
-
* CCK rates are bit8..11
2286
-
*/
2287
2255
tx_beacon_cmd->tx.supp_rates[1] =
2288
-
(IWL_CCK_BASIC_RATES_MASK >> 8) & 0xF;
2256
+
(IWL_CCK_BASIC_RATES_MASK & 0xF);
2289
2257
2290
2258
return (sizeof(struct iwl_tx_beacon_cmd) + frame_size);
2291
2259
}
+2
-2
drivers/net/wireless/iwlwifi/iwl3945-base.c
+2
-2
drivers/net/wireless/iwlwifi/iwl3945-base.c
···
5332
5332
/* 5.2GHz channels start after the 2.4GHz channels */
5333
5333
modes[A].mode = MODE_IEEE80211A;
5334
5334
modes[A].channels = &channels[ARRAY_SIZE(iwl_eeprom_band_1)];
5335
-
modes[A].rates = rates;
5335
+
modes[A].rates = &rates[4];
5336
5336
modes[A].num_rates = 8; /* just OFDM */
5337
5337
modes[A].num_channels = 0;
5338
5338
5339
5339
modes[B].mode = MODE_IEEE80211B;
5340
5340
modes[B].channels = channels;
5341
-
modes[B].rates = &rates[8];
5341
+
modes[B].rates = rates;
5342
5342
modes[B].num_rates = 4; /* just CCK */
5343
5343
modes[B].num_channels = 0;
5344
5344
+5
-3
drivers/net/wireless/iwlwifi/iwl4965-base.c
+5
-3
drivers/net/wireless/iwlwifi/iwl4965-base.c
···
5156
5156
}
5157
5157
5158
5158
if ((inta == 0xFFFFFFFF) || ((inta & 0xFFFFFFF0) == 0xa5a5a5a0)) {
5159
-
/* Hardware disappeared */
5159
+
/* Hardware disappeared. It might have already raised
5160
+
* an interrupt */
5160
5161
IWL_WARNING("HARDWARE GONE?? INTA == 0x%080x\n", inta);
5161
-
goto none;
5162
+
goto unplugged;
5162
5163
}
5163
5164
5164
5165
IWL_DEBUG_ISR("ISR inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
···
5167
5166
5168
5167
/* iwl_irq_tasklet() will service interrupts and re-enable them */
5169
5168
tasklet_schedule(&priv->irq_tasklet);
5170
-
spin_unlock(&priv->lock);
5171
5169
5170
+
unplugged:
5171
+
spin_unlock(&priv->lock);
5172
5172
return IRQ_HANDLED;
5173
5173
5174
5174
none:
+2
-2
drivers/net/wireless/rt2x00/rt2500pci.c
+2
-2
drivers/net/wireless/rt2x00/rt2500pci.c
···
620
620
* up to version C the link tuning should halt after 20
621
621
* seconds.
622
622
*/
623
-
if (rt2x00_get_rev(&rt2x00dev->chip) < RT2560_VERSION_D &&
623
+
if (rt2x00_rev(&rt2x00dev->chip) < RT2560_VERSION_D &&
624
624
rt2x00dev->link.count > 20)
625
625
return;
626
626
···
630
630
* Chipset versions C and lower should directly continue
631
631
* to the dynamic CCA tuning.
632
632
*/
633
-
if (rt2x00_get_rev(&rt2x00dev->chip) < RT2560_VERSION_D)
633
+
if (rt2x00_rev(&rt2x00dev->chip) < RT2560_VERSION_D)
634
634
goto dynamic_cca_tune;
635
635
636
636
/*
+2
-2
drivers/net/wireless/rt2x00/rt2500usb.c
+2
-2
drivers/net/wireless/rt2x00/rt2500usb.c
···
753
753
rt2x00_set_field16(®, MAC_CSR1_HOST_READY, 1);
754
754
rt2500usb_register_write(rt2x00dev, MAC_CSR1, reg);
755
755
756
-
if (rt2x00_get_rev(&rt2x00dev->chip) >= RT2570_VERSION_C) {
756
+
if (rt2x00_rev(&rt2x00dev->chip) >= RT2570_VERSION_C) {
757
757
rt2500usb_register_read(rt2x00dev, PHY_CSR2, ®);
758
758
reg &= ~0x0002;
759
759
} else {
···
1257
1257
rt2500usb_register_read(rt2x00dev, MAC_CSR0, ®);
1258
1258
rt2x00_set_chip(rt2x00dev, RT2570, value, reg);
1259
1259
1260
-
if (rt2x00_rev(&rt2x00dev->chip, 0xffff0)) {
1260
+
if (!rt2x00_check_rev(&rt2x00dev->chip, 0)) {
1261
1261
ERROR(rt2x00dev, "Invalid RT chipset detected.\n");
1262
1262
return -ENODEV;
1263
1263
}
+5
-3
drivers/net/wireless/rt2x00/rt2x00.h
+5
-3
drivers/net/wireless/rt2x00/rt2x00.h
···
751
751
return (chipset->rf == chip);
752
752
}
753
753
754
-
static inline u16 rt2x00_get_rev(const struct rt2x00_chip *chipset)
754
+
static inline u16 rt2x00_rev(const struct rt2x00_chip *chipset)
755
755
{
756
756
return chipset->rev;
757
757
}
758
758
759
-
static inline u16 rt2x00_rev(const struct rt2x00_chip *chipset, const u32 mask)
759
+
static inline u16 rt2x00_check_rev(const struct rt2x00_chip *chipset,
760
+
const u32 rev)
760
761
{
761
-
return chipset->rev & mask;
762
+
return (((chipset->rev & 0xffff0) == rev) &&
763
+
!!(chipset->rev & 0x0000f));
762
764
}
763
765
764
766
/*
+1
-1
drivers/net/wireless/rt2x00/rt73usb.c
+1
-1
drivers/net/wireless/rt2x00/rt73usb.c
···
1486
1486
rt73usb_register_read(rt2x00dev, MAC_CSR0, ®);
1487
1487
rt2x00_set_chip(rt2x00dev, RT2571, value, reg);
1488
1488
1489
-
if (!rt2x00_rev(&rt2x00dev->chip, 0x25730)) {
1489
+
if (!rt2x00_check_rev(&rt2x00dev->chip, 0x25730)) {
1490
1490
ERROR(rt2x00dev, "Invalid RT chipset detected.\n");
1491
1491
return -ENODEV;
1492
1492
}
+1
-17
include/net/request_sock.h
+1
-17
include/net/request_sock.h
···
124
124
extern int reqsk_queue_alloc(struct request_sock_queue *queue,
125
125
unsigned int nr_table_entries);
126
126
127
-
static inline struct listen_sock *reqsk_queue_yank_listen_sk(struct request_sock_queue *queue)
128
-
{
129
-
struct listen_sock *lopt;
130
-
131
-
write_lock_bh(&queue->syn_wait_lock);
132
-
lopt = queue->listen_opt;
133
-
queue->listen_opt = NULL;
134
-
write_unlock_bh(&queue->syn_wait_lock);
135
-
136
-
return lopt;
137
-
}
138
-
139
-
static inline void __reqsk_queue_destroy(struct request_sock_queue *queue)
140
-
{
141
-
kfree(reqsk_queue_yank_listen_sk(queue));
142
-
}
143
-
127
+
extern void __reqsk_queue_destroy(struct request_sock_queue *queue);
144
128
extern void reqsk_queue_destroy(struct request_sock_queue *queue);
145
129
146
130
static inline struct request_sock *
+35
net/core/request_sock.c
+35
net/core/request_sock.c
···
71
71
72
72
EXPORT_SYMBOL(reqsk_queue_alloc);
73
73
74
+
void __reqsk_queue_destroy(struct request_sock_queue *queue)
75
+
{
76
+
struct listen_sock *lopt;
77
+
size_t lopt_size;
78
+
79
+
/*
80
+
* this is an error recovery path only
81
+
* no locking needed and the lopt is not NULL
82
+
*/
83
+
84
+
lopt = queue->listen_opt;
85
+
lopt_size = sizeof(struct listen_sock) +
86
+
lopt->nr_table_entries * sizeof(struct request_sock *);
87
+
88
+
if (lopt_size > PAGE_SIZE)
89
+
vfree(lopt);
90
+
else
91
+
kfree(lopt);
92
+
}
93
+
94
+
EXPORT_SYMBOL(__reqsk_queue_destroy);
95
+
96
+
static inline struct listen_sock *reqsk_queue_yank_listen_sk(
97
+
struct request_sock_queue *queue)
98
+
{
99
+
struct listen_sock *lopt;
100
+
101
+
write_lock_bh(&queue->syn_wait_lock);
102
+
lopt = queue->listen_opt;
103
+
queue->listen_opt = NULL;
104
+
write_unlock_bh(&queue->syn_wait_lock);
105
+
106
+
return lopt;
107
+
}
108
+
74
109
void reqsk_queue_destroy(struct request_sock_queue *queue)
75
110
{
76
111
/* make all the listen_opt local to us */
+2
net/mac80211/ieee80211_i.h
+2
net/mac80211/ieee80211_i.h
···
242
242
u8 bssid[ETH_ALEN], prev_bssid[ETH_ALEN];
243
243
u8 ssid[IEEE80211_MAX_SSID_LEN];
244
244
size_t ssid_len;
245
+
u8 scan_ssid[IEEE80211_MAX_SSID_LEN];
246
+
size_t scan_ssid_len;
245
247
u16 aid;
246
248
u16 ap_capab, capab;
247
249
u8 *extra_ie; /* to be added to the end of AssocReq */
+7
-1
net/mac80211/ieee80211_sta.c
+7
-1
net/mac80211/ieee80211_sta.c
···
2002
2002
if (ifsta->state != IEEE80211_AUTHENTICATE &&
2003
2003
ifsta->state != IEEE80211_ASSOCIATE &&
2004
2004
test_and_clear_bit(IEEE80211_STA_REQ_SCAN, &ifsta->request)) {
2005
-
ieee80211_sta_start_scan(dev, NULL, 0);
2005
+
if (ifsta->scan_ssid_len)
2006
+
ieee80211_sta_start_scan(dev, ifsta->scan_ssid, ifsta->scan_ssid_len);
2007
+
else
2008
+
ieee80211_sta_start_scan(dev, NULL, 0);
2006
2009
return;
2007
2010
}
2008
2011
···
2875
2872
return -EBUSY;
2876
2873
}
2877
2874
2875
+
ifsta->scan_ssid_len = ssid_len;
2876
+
if (ssid_len)
2877
+
memcpy(ifsta->scan_ssid, ssid, ssid_len);
2878
2878
set_bit(IEEE80211_STA_REQ_SCAN, &ifsta->request);
2879
2879
queue_work(local->hw.workqueue, &ifsta->work);
2880
2880
return 0;
+1
-1
net/netfilter/nf_conntrack_extend.c
+1
-1
net/netfilter/nf_conntrack_extend.c
+3
-3
net/netfilter/nf_sockopt.c
+3
-3
net/netfilter/nf_sockopt.c
···
143
143
if (ops->compat_get)
144
144
ret = ops->compat_get(sk, val, opt, len);
145
145
else
146
-
ret = ops->get(sk, val, ops, len);
146
+
ret = ops->get(sk, val, opt, len);
147
147
} else {
148
148
if (ops->compat_set)
149
-
ret = ops->compat_set(sk, val, ops, *len);
149
+
ret = ops->compat_set(sk, val, opt, *len);
150
150
else
151
-
ret = ops->set(sk, val, ops, *len);
151
+
ret = ops->set(sk, val, opt, *len);
152
152
}
153
153
154
154
module_put(ops->owner);