Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net
Pull networking fixes from David Miller:
"First post-Sandy pull request"
1) Fix antenna gain handling and initialization of chan->max_reg_power
in wireless, from Felix Fietkau.
2) Fix nexthop handling in H.232 conntrack helper, from Julian
Anastasov.
3) Only process 80211 mesh config header in certain kinds of frames,
from Javier Cardona.
4) 80211 management frame header length needs to be validated, from
Johannes Berg.
5) Don't access free'd SKBs in ath9k driver, from Felix Fietkay.
6) Test for permanent state correctly in VXLAN driver, from Stephen
Hemminger.
7) BNX2X bug fixes from Yaniv Rosner and Dmitry Kravkov.
8) Fix off by one errors in bonding, from Nikolay ALeksandrov.
9) Fix divide by zero in TCP-Illinois congestion control. From Jesper
Dangaard Brouer.
10) TCP metrics code says "Yo dawg, I heard you like sizeof, so I did a
sizeof of a sizeof, so you can size your size" Fix from Julian
Anastasov.
11) Several drivers do mdiobus_free without first doing an
mdiobus_unregister leading to stray pointer references. Fix from
Peter Senna Tschudin.
12) Fix OOPS in l2tp_eth_create() error path, it's another danling
pointer kinda situation. Fix from Tom Parkin.
13) Hardware driven by the vmxnet driver can't handle larger than 16K
fragments, so split them up when necessary. From Eric Dumazet.
14) Handle zero length data length in tcp_send_rcvq() properly. Fix
from Pavel Emelyanov.
* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net: (38 commits)
tcp-repair: Handle zero-length data put in rcv queue
vmxnet3: must split too big fragments
l2tp: fix oops in l2tp_eth_create() error path
cxgb4: Fix unable to get UP event from the LLD
drivers/net/phy/mdio-bitbang.c: Call mdiobus_unregister before mdiobus_free
drivers/net/ethernet/nxp/lpc_eth.c: Call mdiobus_unregister before mdiobus_free
bnx2x: fix HW initialization using fw 7.8.x
tcp: Fix double sizeof in new tcp_metrics code
net: fix divide by zero in tcp algorithm illinois
net: sctp: Fix typo in net/sctp
bonding: fix second off-by-one error
bonding: fix off-by-one error
bnx2x: Disable FCoE for 57840 since not yet supported by FW
bnx2x: Fix no link on 577xx 10G-baseT
bnx2x: Fix unrecognized SFP+ module after driver is loaded
bnx2x: Fix potential incorrect link speed provision
bnx2x: Restore global registers back to default.
bnx2x: Fix link down in 57712 following LFA
bnx2x: Fix 57810 1G-KR link against certain switches.
ixgbe: PTP get_ts_info missing software support
...
+319
-128
+2
-2
drivers/net/bonding/bond_sysfs.c
+2
-2
drivers/net/bonding/bond_sysfs.c
···
1060
1060
goto out;
1061
1061
}
1062
1062
1063
-
sscanf(buf, "%16s", ifname); /* IFNAMSIZ */
1063
+
sscanf(buf, "%15s", ifname); /* IFNAMSIZ */
1064
1064
1065
1065
/* check to see if we are clearing primary */
1066
1066
if (!strlen(ifname) || buf[0] == '\n') {
···
1237
1237
goto out;
1238
1238
}
1239
1239
1240
-
sscanf(buf, "%16s", ifname); /* IFNAMSIZ */
1240
+
sscanf(buf, "%15s", ifname); /* IFNAMSIZ */
1241
1241
1242
1242
/* check to see if we are clearing active */
1243
1243
if (!strlen(ifname) || buf[0] == '\n') {
+113
-45
drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c
+113
-45
drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c
···
137
137
#define LINK_20GTFD LINK_STATUS_SPEED_AND_DUPLEX_20GTFD
138
138
#define LINK_20GXFD LINK_STATUS_SPEED_AND_DUPLEX_20GXFD
139
139
140
-
140
+
#define LINK_UPDATE_MASK \
141
+
(LINK_STATUS_SPEED_AND_DUPLEX_MASK | \
142
+
LINK_STATUS_LINK_UP | \
143
+
LINK_STATUS_PHYSICAL_LINK_FLAG | \
144
+
LINK_STATUS_AUTO_NEGOTIATE_COMPLETE | \
145
+
LINK_STATUS_RX_FLOW_CONTROL_FLAG_MASK | \
146
+
LINK_STATUS_TX_FLOW_CONTROL_FLAG_MASK | \
147
+
LINK_STATUS_PARALLEL_DETECTION_FLAG_MASK | \
148
+
LINK_STATUS_LINK_PARTNER_SYMMETRIC_PAUSE | \
149
+
LINK_STATUS_LINK_PARTNER_ASYMMETRIC_PAUSE)
141
150
142
151
#define SFP_EEPROM_CON_TYPE_ADDR 0x2
143
152
#define SFP_EEPROM_CON_TYPE_VAL_LC 0x7
···
3304
3295
DEFAULT_PHY_DEV_ADDR);
3305
3296
}
3306
3297
3298
+
static void bnx2x_xgxs_specific_func(struct bnx2x_phy *phy,
3299
+
struct link_params *params,
3300
+
u32 action)
3301
+
{
3302
+
struct bnx2x *bp = params->bp;
3303
+
switch (action) {
3304
+
case PHY_INIT:
3305
+
/* Set correct devad */
3306
+
REG_WR(bp, NIG_REG_XGXS0_CTRL_MD_ST + params->port*0x18, 0);
3307
+
REG_WR(bp, NIG_REG_XGXS0_CTRL_MD_DEVAD + params->port*0x18,
3308
+
phy->def_md_devad);
3309
+
break;
3310
+
}
3311
+
}
3312
+
3307
3313
static void bnx2x_xgxs_deassert(struct link_params *params)
3308
3314
{
3309
3315
struct bnx2x *bp = params->bp;
···
3333
3309
REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_3_CLEAR, val);
3334
3310
udelay(500);
3335
3311
REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_3_SET, val);
3336
-
3337
-
REG_WR(bp, NIG_REG_XGXS0_CTRL_MD_ST + port*0x18, 0);
3338
-
REG_WR(bp, NIG_REG_XGXS0_CTRL_MD_DEVAD + port*0x18,
3339
-
params->phy[INT_PHY].def_md_devad);
3312
+
bnx2x_xgxs_specific_func(¶ms->phy[INT_PHY], params,
3313
+
PHY_INIT);
3340
3314
}
3341
3315
3342
3316
static void bnx2x_calc_ieee_aneg_adv(struct bnx2x_phy *phy,
···
3567
3545
static void bnx2x_warpcore_enable_AN_KR(struct bnx2x_phy *phy,
3568
3546
struct link_params *params,
3569
3547
struct link_vars *vars) {
3570
-
u16 val16 = 0, lane, i;
3548
+
u16 lane, i, cl72_ctrl, an_adv = 0;
3549
+
u16 ucode_ver;
3571
3550
struct bnx2x *bp = params->bp;
3572
3551
static struct bnx2x_reg_set reg_set[] = {
3573
3552
{MDIO_WC_DEVAD, MDIO_WC_REG_SERDESDIGITAL_CONTROL1000X2, 0x7},
3574
-
{MDIO_AN_DEVAD, MDIO_WC_REG_PAR_DET_10G_CTRL, 0},
3575
-
{MDIO_WC_DEVAD, MDIO_WC_REG_CL72_USERB0_CL72_MISC1_CONTROL, 0},
3576
-
{MDIO_WC_DEVAD, MDIO_WC_REG_XGXSBLK1_LANECTRL0, 0xff},
3577
-
{MDIO_WC_DEVAD, MDIO_WC_REG_XGXSBLK1_LANECTRL1, 0x5555},
3578
3553
{MDIO_PMA_DEVAD, MDIO_WC_REG_IEEE0BLK_AUTONEGNP, 0x0},
3579
3554
{MDIO_WC_DEVAD, MDIO_WC_REG_RX66_CONTROL, 0x7415},
3580
3555
{MDIO_WC_DEVAD, MDIO_WC_REG_SERDESDIGITAL_MISC2, 0x6190},
···
3584
3565
bnx2x_cl45_write(bp, phy, reg_set[i].devad, reg_set[i].reg,
3585
3566
reg_set[i].val);
3586
3567
3568
+
bnx2x_cl45_read(bp, phy, MDIO_WC_DEVAD,
3569
+
MDIO_WC_REG_CL72_USERB0_CL72_MISC1_CONTROL, &cl72_ctrl);
3570
+
cl72_ctrl &= 0xf8ff;
3571
+
cl72_ctrl |= 0x3800;
3572
+
bnx2x_cl45_write(bp, phy, MDIO_WC_DEVAD,
3573
+
MDIO_WC_REG_CL72_USERB0_CL72_MISC1_CONTROL, cl72_ctrl);
3574
+
3587
3575
/* Check adding advertisement for 1G KX */
3588
3576
if (((vars->line_speed == SPEED_AUTO_NEG) &&
3589
3577
(phy->speed_cap_mask & PORT_HW_CFG_SPEED_CAPABILITY_D0_1G)) ||
3590
3578
(vars->line_speed == SPEED_1000)) {
3591
3579
u32 addr = MDIO_WC_REG_SERDESDIGITAL_CONTROL1000X2;
3592
-
val16 |= (1<<5);
3580
+
an_adv |= (1<<5);
3593
3581
3594
3582
/* Enable CL37 1G Parallel Detect */
3595
3583
bnx2x_cl45_read_or_write(bp, phy, MDIO_WC_DEVAD, addr, 0x1);
···
3606
3580
(phy->speed_cap_mask & PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)) ||
3607
3581
(vars->line_speed == SPEED_10000)) {
3608
3582
/* Check adding advertisement for 10G KR */
3609
-
val16 |= (1<<7);
3583
+
an_adv |= (1<<7);
3610
3584
/* Enable 10G Parallel Detect */
3585
+
CL22_WR_OVER_CL45(bp, phy, MDIO_REG_BANK_AER_BLOCK,
3586
+
MDIO_AER_BLOCK_AER_REG, 0);
3587
+
3611
3588
bnx2x_cl45_write(bp, phy, MDIO_AN_DEVAD,
3612
3589
MDIO_WC_REG_PAR_DET_10G_CTRL, 1);
3613
-
3590
+
bnx2x_set_aer_mmd(params, phy);
3614
3591
DP(NETIF_MSG_LINK, "Advertize 10G\n");
3615
3592
}
3616
3593
···
3633
3604
3634
3605
/* Advertised speeds */
3635
3606
bnx2x_cl45_write(bp, phy, MDIO_AN_DEVAD,
3636
-
MDIO_WC_REG_AN_IEEE1BLK_AN_ADVERTISEMENT1, val16);
3607
+
MDIO_WC_REG_AN_IEEE1BLK_AN_ADVERTISEMENT1, an_adv);
3637
3608
3638
3609
/* Advertised and set FEC (Forward Error Correction) */
3639
3610
bnx2x_cl45_write(bp, phy, MDIO_AN_DEVAD,
···
3657
3628
/* Set KR Autoneg Work-Around flag for Warpcore version older than D108
3658
3629
*/
3659
3630
bnx2x_cl45_read(bp, phy, MDIO_WC_DEVAD,
3660
-
MDIO_WC_REG_UC_INFO_B1_VERSION, &val16);
3661
-
if (val16 < 0xd108) {
3662
-
DP(NETIF_MSG_LINK, "Enable AN KR work-around\n");
3631
+
MDIO_WC_REG_UC_INFO_B1_VERSION, &ucode_ver);
3632
+
if (ucode_ver < 0xd108) {
3633
+
DP(NETIF_MSG_LINK, "Enable AN KR work-around. WC ver:0x%x\n",
3634
+
ucode_ver);
3663
3635
vars->rx_tx_asic_rst = MAX_KR_LINK_RETRY;
3664
3636
}
3665
3637
bnx2x_cl45_read_or_write(bp, phy, MDIO_WC_DEVAD,
···
3681
3651
struct link_vars *vars)
3682
3652
{
3683
3653
struct bnx2x *bp = params->bp;
3684
-
u16 i;
3654
+
u16 val16, i, lane;
3685
3655
static struct bnx2x_reg_set reg_set[] = {
3686
3656
/* Disable Autoneg */
3687
3657
{MDIO_WC_DEVAD, MDIO_WC_REG_SERDESDIGITAL_CONTROL1000X2, 0x7},
3688
-
{MDIO_AN_DEVAD, MDIO_WC_REG_PAR_DET_10G_CTRL, 0},
3689
3658
{MDIO_WC_DEVAD, MDIO_WC_REG_CL72_USERB0_CL72_MISC1_CONTROL,
3690
3659
0x3f00},
3691
3660
{MDIO_AN_DEVAD, MDIO_WC_REG_AN_IEEE1BLK_AN_ADVERTISEMENT1, 0},
3692
3661
{MDIO_AN_DEVAD, MDIO_WC_REG_IEEE0BLK_MIICNTL, 0x0},
3693
3662
{MDIO_WC_DEVAD, MDIO_WC_REG_DIGITAL3_UP1, 0x1},
3694
3663
{MDIO_WC_DEVAD, MDIO_WC_REG_DIGITAL5_MISC7, 0xa},
3695
-
/* Disable CL36 PCS Tx */
3696
-
{MDIO_WC_DEVAD, MDIO_WC_REG_XGXSBLK1_LANECTRL0, 0x0},
3697
-
/* Double Wide Single Data Rate @ pll rate */
3698
-
{MDIO_WC_DEVAD, MDIO_WC_REG_XGXSBLK1_LANECTRL1, 0xFFFF},
3699
3664
/* Leave cl72 training enable, needed for KR */
3700
3665
{MDIO_PMA_DEVAD,
3701
3666
MDIO_WC_REG_PMD_IEEE9BLK_TENGBASE_KR_PMD_CONTROL_REGISTER_150,
···
3701
3676
bnx2x_cl45_write(bp, phy, reg_set[i].devad, reg_set[i].reg,
3702
3677
reg_set[i].val);
3703
3678
3704
-
/* Leave CL72 enabled */
3705
-
bnx2x_cl45_read_or_write(bp, phy, MDIO_WC_DEVAD,
3706
-
MDIO_WC_REG_CL72_USERB0_CL72_MISC1_CONTROL,
3707
-
0x3800);
3679
+
lane = bnx2x_get_warpcore_lane(phy, params);
3680
+
/* Global registers */
3681
+
CL22_WR_OVER_CL45(bp, phy, MDIO_REG_BANK_AER_BLOCK,
3682
+
MDIO_AER_BLOCK_AER_REG, 0);
3683
+
/* Disable CL36 PCS Tx */
3684
+
bnx2x_cl45_read(bp, phy, MDIO_WC_DEVAD,
3685
+
MDIO_WC_REG_XGXSBLK1_LANECTRL0, &val16);
3686
+
val16 &= ~(0x0011 << lane);
3687
+
bnx2x_cl45_write(bp, phy, MDIO_WC_DEVAD,
3688
+
MDIO_WC_REG_XGXSBLK1_LANECTRL0, val16);
3708
3689
3690
+
bnx2x_cl45_read(bp, phy, MDIO_WC_DEVAD,
3691
+
MDIO_WC_REG_XGXSBLK1_LANECTRL1, &val16);
3692
+
val16 |= (0x0303 << (lane << 1));
3693
+
bnx2x_cl45_write(bp, phy, MDIO_WC_DEVAD,
3694
+
MDIO_WC_REG_XGXSBLK1_LANECTRL1, val16);
3695
+
/* Restore AER */
3696
+
bnx2x_set_aer_mmd(params, phy);
3709
3697
/* Set speed via PMA/PMD register */
3710
3698
bnx2x_cl45_write(bp, phy, MDIO_PMA_DEVAD,
3711
3699
MDIO_WC_REG_IEEE0BLK_MIICNTL, 0x2040);
···
4341
4303
struct link_params *params)
4342
4304
{
4343
4305
struct bnx2x *bp = params->bp;
4344
-
u16 val16;
4306
+
u16 val16, lane;
4345
4307
bnx2x_sfp_e3_set_transmitter(params, phy, 0);
4346
4308
bnx2x_set_mdio_clk(bp, params->chip_id, params->port);
4347
4309
bnx2x_set_aer_mmd(params, phy);
···
4377
4339
bnx2x_cl45_write(bp, phy, MDIO_WC_DEVAD,
4378
4340
MDIO_WC_REG_XGXSBLK1_LANECTRL2,
4379
4341
val16 & 0xff00);
4342
+
4343
+
lane = bnx2x_get_warpcore_lane(phy, params);
4344
+
/* Disable CL36 PCS Tx */
4345
+
bnx2x_cl45_read(bp, phy, MDIO_WC_DEVAD,
4346
+
MDIO_WC_REG_XGXSBLK1_LANECTRL0, &val16);
4347
+
val16 |= (0x11 << lane);
4348
+
if (phy->flags & FLAGS_WC_DUAL_MODE)
4349
+
val16 |= (0x22 << lane);
4350
+
bnx2x_cl45_write(bp, phy, MDIO_WC_DEVAD,
4351
+
MDIO_WC_REG_XGXSBLK1_LANECTRL0, val16);
4352
+
4353
+
bnx2x_cl45_read(bp, phy, MDIO_WC_DEVAD,
4354
+
MDIO_WC_REG_XGXSBLK1_LANECTRL1, &val16);
4355
+
val16 &= ~(0x0303 << (lane << 1));
4356
+
val16 |= (0x0101 << (lane << 1));
4357
+
if (phy->flags & FLAGS_WC_DUAL_MODE) {
4358
+
val16 &= ~(0x0c0c << (lane << 1));
4359
+
val16 |= (0x0404 << (lane << 1));
4360
+
}
4361
+
4362
+
bnx2x_cl45_write(bp, phy, MDIO_WC_DEVAD,
4363
+
MDIO_WC_REG_XGXSBLK1_LANECTRL1, val16);
4364
+
/* Restore AER */
4365
+
bnx2x_set_aer_mmd(params, phy);
4380
4366
4381
4367
}
4382
4368
···
6358
6296
vars->mac_type = MAC_TYPE_NONE;
6359
6297
6360
6298
/* Update shared memory */
6361
-
vars->link_status &= ~(LINK_STATUS_SPEED_AND_DUPLEX_MASK |
6362
-
LINK_STATUS_LINK_UP |
6363
-
LINK_STATUS_PHYSICAL_LINK_FLAG |
6364
-
LINK_STATUS_AUTO_NEGOTIATE_COMPLETE |
6365
-
LINK_STATUS_RX_FLOW_CONTROL_FLAG_MASK |
6366
-
LINK_STATUS_TX_FLOW_CONTROL_FLAG_MASK |
6367
-
LINK_STATUS_PARALLEL_DETECTION_FLAG_MASK |
6368
-
LINK_STATUS_LINK_PARTNER_SYMMETRIC_PAUSE |
6369
-
LINK_STATUS_LINK_PARTNER_ASYMMETRIC_PAUSE);
6299
+
vars->link_status &= ~LINK_UPDATE_MASK;
6370
6300
vars->line_speed = 0;
6371
6301
bnx2x_update_mng(params, vars->link_status);
6372
6302
···
6506
6452
u16 ext_phy_line_speed = 0, prev_line_speed = vars->line_speed;
6507
6453
u8 active_external_phy = INT_PHY;
6508
6454
vars->phy_flags &= ~PHY_HALF_OPEN_CONN_FLAG;
6455
+
vars->link_status &= ~LINK_UPDATE_MASK;
6509
6456
for (phy_index = INT_PHY; phy_index < params->num_phys;
6510
6457
phy_index++) {
6511
6458
phy_vars[phy_index].flow_ctrl = 0;
···
7634
7579
static int bnx2x_warpcore_read_sfp_module_eeprom(struct bnx2x_phy *phy,
7635
7580
struct link_params *params,
7636
7581
u16 addr, u8 byte_cnt,
7637
-
u8 *o_buf)
7582
+
u8 *o_buf, u8 is_init)
7638
7583
{
7639
7584
int rc = 0;
7640
7585
u8 i, j = 0, cnt = 0;
···
7651
7596
/* 4 byte aligned address */
7652
7597
addr32 = addr & (~0x3);
7653
7598
do {
7654
-
if (cnt == I2C_WA_PWR_ITER) {
7599
+
if ((!is_init) && (cnt == I2C_WA_PWR_ITER)) {
7655
7600
bnx2x_warpcore_power_module(params, phy, 0);
7656
7601
/* Note that 100us are not enough here */
7657
-
usleep_range(1000,1000);
7602
+
usleep_range(1000, 2000);
7658
7603
bnx2x_warpcore_power_module(params, phy, 1);
7659
7604
}
7660
7605
rc = bnx2x_bsc_read(params, phy, 0xa0, addr32, 0, byte_cnt,
···
7774
7719
break;
7775
7720
case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT:
7776
7721
rc = bnx2x_warpcore_read_sfp_module_eeprom(phy, params, addr,
7777
-
byte_cnt, o_buf);
7722
+
byte_cnt, o_buf, 0);
7778
7723
break;
7779
7724
}
7780
7725
return rc;
···
7978
7923
7979
7924
{
7980
7925
u8 val;
7926
+
int rc;
7981
7927
struct bnx2x *bp = params->bp;
7982
7928
u16 timeout;
7983
7929
/* Initialization time after hot-plug may take up to 300ms for
···
7986
7930
*/
7987
7931
7988
7932
for (timeout = 0; timeout < 60; timeout++) {
7989
-
if (bnx2x_read_sfp_module_eeprom(phy, params, 1, 1, &val)
7990
-
== 0) {
7933
+
if (phy->type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT)
7934
+
rc = bnx2x_warpcore_read_sfp_module_eeprom(phy,
7935
+
params, 1,
7936
+
1, &val, 1);
7937
+
else
7938
+
rc = bnx2x_read_sfp_module_eeprom(phy, params, 1, 1,
7939
+
&val);
7940
+
if (rc == 0) {
7991
7941
DP(NETIF_MSG_LINK,
7992
7942
"SFP+ module initialization took %d ms\n",
7993
7943
timeout * 5);
···
8001
7939
}
8002
7940
usleep_range(5000, 10000);
8003
7941
}
8004
-
return -EINVAL;
7942
+
rc = bnx2x_read_sfp_module_eeprom(phy, params, 1, 1, &val);
7943
+
return rc;
8005
7944
}
8006
7945
8007
7946
static void bnx2x_8727_power_module(struct bnx2x *bp,
···
11056
10993
.format_fw_ver = (format_fw_ver_t)NULL,
11057
10994
.hw_reset = (hw_reset_t)NULL,
11058
10995
.set_link_led = (set_link_led_t)NULL,
11059
-
.phy_specific_func = (phy_specific_func_t)NULL
10996
+
.phy_specific_func = (phy_specific_func_t)bnx2x_xgxs_specific_func
11060
10997
};
11061
10998
static struct bnx2x_phy phy_warpcore = {
11062
10999
.type = PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT,
···
11528
11465
phy->media_type = ETH_PHY_BASE_T;
11529
11466
break;
11530
11467
case PORT_HW_CFG_NET_SERDES_IF_XFI:
11468
+
phy->supported &= (SUPPORTED_1000baseT_Full |
11469
+
SUPPORTED_10000baseT_Full |
11470
+
SUPPORTED_FIBRE |
11471
+
SUPPORTED_Pause |
11472
+
SUPPORTED_Asym_Pause);
11531
11473
phy->media_type = ETH_PHY_XFP_FIBER;
11532
11474
break;
11533
11475
case PORT_HW_CFG_NET_SERDES_IF_SFI:
+11
-2
drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
+11
-2
drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
···
6794
6794
6795
6795
bnx2x_init_block(bp, BLOCK_DORQ, init_phase);
6796
6796
6797
+
bnx2x_init_block(bp, BLOCK_BRB1, init_phase);
6798
+
6797
6799
if (CHIP_IS_E1(bp) || CHIP_IS_E1H(bp)) {
6798
-
bnx2x_init_block(bp, BLOCK_BRB1, init_phase);
6799
6800
6800
6801
if (IS_MF(bp))
6801
6802
low = ((bp->flags & ONE_PORT_FLAG) ? 160 : 246);
···
11903
11902
/* disable FCOE L2 queue for E1x */
11904
11903
if (CHIP_IS_E1x(bp))
11905
11904
bp->flags |= NO_FCOE_FLAG;
11906
-
11905
+
/* disable FCOE for 57840 device, until FW supports it */
11906
+
switch (ent->driver_data) {
11907
+
case BCM57840_O:
11908
+
case BCM57840_4_10:
11909
+
case BCM57840_2_20:
11910
+
case BCM57840_MFO:
11911
+
case BCM57840_MF:
11912
+
bp->flags |= NO_FCOE_FLAG;
11913
+
}
11907
11914
#endif
11908
11915
11909
11916
-10
drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
-10
drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
···
3416
3416
finicsum, cfcsum);
3417
3417
3418
3418
/*
3419
-
* If we're a pure NIC driver then disable all offloading facilities.
3420
-
* This will allow the firmware to optimize aspects of the hardware
3421
-
* configuration which will result in improved performance.
3422
-
*/
3423
-
caps_cmd.ofldcaps = 0;
3424
-
caps_cmd.iscsicaps = 0;
3425
-
caps_cmd.rdmacaps = 0;
3426
-
caps_cmd.fcoecaps = 0;
3427
-
3428
-
/*
3429
3419
* And now tell the firmware to use the configuration we just loaded.
3430
3420
*/
3431
3421
caps_cmd.op_to_write =
+3
drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c
+3
drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c
···
2673
2673
case ixgbe_mac_X540:
2674
2674
case ixgbe_mac_82599EB:
2675
2675
info->so_timestamping =
2676
+
SOF_TIMESTAMPING_TX_SOFTWARE |
2677
+
SOF_TIMESTAMPING_RX_SOFTWARE |
2678
+
SOF_TIMESTAMPING_SOFTWARE |
2676
2679
SOF_TIMESTAMPING_TX_HARDWARE |
2677
2680
SOF_TIMESTAMPING_RX_HARDWARE |
2678
2681
SOF_TIMESTAMPING_RAW_HARDWARE;
+1
drivers/net/ethernet/nxp/lpc_eth.c
+1
drivers/net/ethernet/nxp/lpc_eth.c
+1
drivers/net/phy/mdio-bitbang.c
+1
drivers/net/phy/mdio-bitbang.c
+45
-20
drivers/net/vmxnet3/vmxnet3_drv.c
+45
-20
drivers/net/vmxnet3/vmxnet3_drv.c
···
744
744
745
745
for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
746
746
const struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i];
747
+
u32 buf_size;
747
748
748
-
tbi = tq->buf_info + tq->tx_ring.next2fill;
749
-
tbi->map_type = VMXNET3_MAP_PAGE;
750
-
tbi->dma_addr = skb_frag_dma_map(&adapter->pdev->dev, frag,
751
-
0, skb_frag_size(frag),
752
-
DMA_TO_DEVICE);
749
+
buf_offset = 0;
750
+
len = skb_frag_size(frag);
751
+
while (len) {
752
+
tbi = tq->buf_info + tq->tx_ring.next2fill;
753
+
if (len < VMXNET3_MAX_TX_BUF_SIZE) {
754
+
buf_size = len;
755
+
dw2 |= len;
756
+
} else {
757
+
buf_size = VMXNET3_MAX_TX_BUF_SIZE;
758
+
/* spec says that for TxDesc.len, 0 == 2^14 */
759
+
}
760
+
tbi->map_type = VMXNET3_MAP_PAGE;
761
+
tbi->dma_addr = skb_frag_dma_map(&adapter->pdev->dev, frag,
762
+
buf_offset, buf_size,
763
+
DMA_TO_DEVICE);
753
764
754
-
tbi->len = skb_frag_size(frag);
765
+
tbi->len = buf_size;
755
766
756
-
gdesc = tq->tx_ring.base + tq->tx_ring.next2fill;
757
-
BUG_ON(gdesc->txd.gen == tq->tx_ring.gen);
767
+
gdesc = tq->tx_ring.base + tq->tx_ring.next2fill;
768
+
BUG_ON(gdesc->txd.gen == tq->tx_ring.gen);
758
769
759
-
gdesc->txd.addr = cpu_to_le64(tbi->dma_addr);
760
-
gdesc->dword[2] = cpu_to_le32(dw2 | skb_frag_size(frag));
761
-
gdesc->dword[3] = 0;
770
+
gdesc->txd.addr = cpu_to_le64(tbi->dma_addr);
771
+
gdesc->dword[2] = cpu_to_le32(dw2);
772
+
gdesc->dword[3] = 0;
762
773
763
-
dev_dbg(&adapter->netdev->dev,
764
-
"txd[%u]: 0x%llu %u %u\n",
765
-
tq->tx_ring.next2fill, le64_to_cpu(gdesc->txd.addr),
766
-
le32_to_cpu(gdesc->dword[2]), gdesc->dword[3]);
767
-
vmxnet3_cmd_ring_adv_next2fill(&tq->tx_ring);
768
-
dw2 = tq->tx_ring.gen << VMXNET3_TXD_GEN_SHIFT;
774
+
dev_dbg(&adapter->netdev->dev,
775
+
"txd[%u]: 0x%llu %u %u\n",
776
+
tq->tx_ring.next2fill, le64_to_cpu(gdesc->txd.addr),
777
+
le32_to_cpu(gdesc->dword[2]), gdesc->dword[3]);
778
+
vmxnet3_cmd_ring_adv_next2fill(&tq->tx_ring);
779
+
dw2 = tq->tx_ring.gen << VMXNET3_TXD_GEN_SHIFT;
780
+
781
+
len -= buf_size;
782
+
buf_offset += buf_size;
783
+
}
769
784
}
770
785
771
786
ctx->eop_txd = gdesc;
···
901
886
}
902
887
}
903
888
889
+
static int txd_estimate(const struct sk_buff *skb)
890
+
{
891
+
int count = VMXNET3_TXD_NEEDED(skb_headlen(skb)) + 1;
892
+
int i;
893
+
894
+
for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
895
+
const struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i];
896
+
897
+
count += VMXNET3_TXD_NEEDED(skb_frag_size(frag));
898
+
}
899
+
return count;
900
+
}
904
901
905
902
/*
906
903
* Transmits a pkt thru a given tq
···
941
914
union Vmxnet3_GenericDesc tempTxDesc;
942
915
#endif
943
916
944
-
/* conservatively estimate # of descriptors to use */
945
-
count = VMXNET3_TXD_NEEDED(skb_headlen(skb)) +
946
-
skb_shinfo(skb)->nr_frags + 1;
917
+
count = txd_estimate(skb);
947
918
948
919
ctx.ipv4 = (vlan_get_protocol(skb) == cpu_to_be16(ETH_P_IP));
949
920
+1
-1
drivers/net/vxlan.c
+1
-1
drivers/net/vxlan.c
+8
-2
drivers/net/wireless/ath/ath9k/xmit.c
+8
-2
drivers/net/wireless/ath/ath9k/xmit.c
···
312
312
}
313
313
314
314
bf = list_first_entry(&sc->tx.txbuf, struct ath_buf, list);
315
+
bf->bf_next = NULL;
315
316
list_del(&bf->list);
316
317
317
318
spin_unlock_bh(&sc->tx.txbuflock);
···
394
393
u16 seq_st = 0, acked_cnt = 0, txfail_cnt = 0, seq_first;
395
394
u32 ba[WME_BA_BMP_SIZE >> 5];
396
395
int isaggr, txfail, txpending, sendbar = 0, needreset = 0, nbad = 0;
397
-
bool rc_update = true;
396
+
bool rc_update = true, isba;
398
397
struct ieee80211_tx_rate rates[4];
399
398
struct ath_frame_info *fi;
400
399
int nframes;
···
438
437
tidno = ieee80211_get_qos_ctl(hdr)[0] & IEEE80211_QOS_CTL_TID_MASK;
439
438
tid = ATH_AN_2_TID(an, tidno);
440
439
seq_first = tid->seq_start;
440
+
isba = ts->ts_flags & ATH9K_TX_BA;
441
441
442
442
/*
443
443
* The hardware occasionally sends a tx status for the wrong TID.
444
444
* In this case, the BA status cannot be considered valid and all
445
445
* subframes need to be retransmitted
446
+
*
447
+
* Only BlockAcks have a TID and therefore normal Acks cannot be
448
+
* checked
446
449
*/
447
-
if (tidno != ts->tid)
450
+
if (isba && tidno != ts->tid)
448
451
txok = false;
449
452
450
453
isaggr = bf_isaggr(bf);
···
1779
1774
list_add_tail(&bf->list, &bf_head);
1780
1775
bf->bf_state.bf_type = 0;
1781
1776
1777
+
bf->bf_next = NULL;
1782
1778
bf->bf_lastbf = bf;
1783
1779
ath_tx_fill_desc(sc, bf, txq, fi->framelen);
1784
1780
ath_tx_txqaddbuf(sc, txq, &bf_head, false);
+1
-1
drivers/net/wireless/rt2x00/rt2800lib.c
+1
-1
drivers/net/wireless/rt2x00/rt2800lib.c
+9
include/net/cfg80211.h
+9
include/net/cfg80211.h
···
2652
2652
unsigned int __attribute_const__ ieee80211_hdrlen(__le16 fc);
2653
2653
2654
2654
/**
2655
+
* ieee80211_get_mesh_hdrlen - get mesh extension header length
2656
+
* @meshhdr: the mesh extension header, only the flags field
2657
+
* (first byte) will be accessed
2658
+
* Returns the length of the extension header, which is always at
2659
+
* least 6 bytes and at most 18 if address 5 and 6 are present.
2660
+
*/
2661
+
unsigned int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr *meshhdr);
2662
+
2663
+
/**
2655
2664
* DOC: Data path helpers
2656
2665
*
2657
2666
* In addition to generic utilities, cfg80211 also offers
+3
-1
net/ipv4/netfilter/iptable_nat.c
+3
-1
net/ipv4/netfilter/iptable_nat.c
···
184
184
185
185
if ((ct->tuplehash[dir].tuple.src.u3.ip !=
186
186
ct->tuplehash[!dir].tuple.dst.u3.ip) ||
187
-
(ct->tuplehash[dir].tuple.src.u.all !=
187
+
(ct->tuplehash[dir].tuple.dst.protonum != IPPROTO_ICMP &&
188
+
ct->tuplehash[dir].tuple.src.u.all !=
188
189
ct->tuplehash[!dir].tuple.dst.u.all))
189
190
if (nf_xfrm_me_harder(skb, AF_INET) < 0)
190
191
ret = NF_DROP;
···
222
221
}
223
222
#ifdef CONFIG_XFRM
224
223
else if (!(IPCB(skb)->flags & IPSKB_XFRM_TRANSFORMED) &&
224
+
ct->tuplehash[dir].tuple.dst.protonum != IPPROTO_ICMP &&
225
225
ct->tuplehash[dir].tuple.dst.u.all !=
226
226
ct->tuplehash[!dir].tuple.src.u.all)
227
227
if (nf_xfrm_me_harder(skb, AF_INET) < 0)
+5
-3
net/ipv4/tcp_illinois.c
+5
-3
net/ipv4/tcp_illinois.c
···
313
313
.tcpv_rttcnt = ca->cnt_rtt,
314
314
.tcpv_minrtt = ca->base_rtt,
315
315
};
316
-
u64 t = ca->sum_rtt;
317
316
318
-
do_div(t, ca->cnt_rtt);
319
-
info.tcpv_rtt = t;
317
+
if (info.tcpv_rttcnt > 0) {
318
+
u64 t = ca->sum_rtt;
320
319
320
+
do_div(t, info.tcpv_rttcnt);
321
+
info.tcpv_rtt = t;
322
+
}
321
323
nla_put(skb, INET_DIAG_VEGASINFO, sizeof(info), &info);
322
324
}
323
325
}
+3
net/ipv4/tcp_input.c
+3
net/ipv4/tcp_input.c
+1
-1
net/ipv4/tcp_metrics.c
+1
-1
net/ipv4/tcp_metrics.c
···
864
864
}
865
865
a = info->attrs[TCP_METRICS_ATTR_ADDR_IPV6];
866
866
if (a) {
867
-
if (nla_len(a) != sizeof(sizeof(struct in6_addr)))
867
+
if (nla_len(a) != sizeof(struct in6_addr))
868
868
return -EINVAL;
869
869
addr->family = AF_INET6;
870
870
memcpy(addr->addr.a6, nla_data(a), sizeof(addr->addr.a6));
+3
-1
net/ipv6/netfilter/ip6table_nat.c
+3
-1
net/ipv6/netfilter/ip6table_nat.c
···
186
186
187
187
if (!nf_inet_addr_cmp(&ct->tuplehash[dir].tuple.src.u3,
188
188
&ct->tuplehash[!dir].tuple.dst.u3) ||
189
-
(ct->tuplehash[dir].tuple.src.u.all !=
189
+
(ct->tuplehash[dir].tuple.dst.protonum != IPPROTO_ICMPV6 &&
190
+
ct->tuplehash[dir].tuple.src.u.all !=
190
191
ct->tuplehash[!dir].tuple.dst.u.all))
191
192
if (nf_xfrm_me_harder(skb, AF_INET6) < 0)
192
193
ret = NF_DROP;
···
223
222
}
224
223
#ifdef CONFIG_XFRM
225
224
else if (!(IP6CB(skb)->flags & IP6SKB_XFRM_TRANSFORMED) &&
225
+
ct->tuplehash[dir].tuple.dst.protonum != IPPROTO_ICMPV6 &&
226
226
ct->tuplehash[dir].tuple.dst.u.all !=
227
227
ct->tuplehash[!dir].tuple.src.u.all)
228
228
if (nf_xfrm_me_harder(skb, AF_INET6))
+2
-2
net/ipv6/netfilter/nf_conntrack_reasm.c
+2
-2
net/ipv6/netfilter/nf_conntrack_reasm.c
···
85
85
{ }
86
86
};
87
87
88
-
static int __net_init nf_ct_frag6_sysctl_register(struct net *net)
88
+
static int nf_ct_frag6_sysctl_register(struct net *net)
89
89
{
90
90
struct ctl_table *table;
91
91
struct ctl_table_header *hdr;
···
127
127
}
128
128
129
129
#else
130
-
static int __net_init nf_ct_frag6_sysctl_register(struct net *net)
130
+
static int nf_ct_frag6_sysctl_register(struct net *net)
131
131
{
132
132
return 0;
133
133
}
+1
net/l2tp/l2tp_eth.c
+1
net/l2tp/l2tp_eth.c
+1
-1
net/mac80211/ibss.c
+1
-1
net/mac80211/ibss.c
···
1108
1108
sdata->u.ibss.state = IEEE80211_IBSS_MLME_SEARCH;
1109
1109
sdata->u.ibss.ibss_join_req = jiffies;
1110
1110
1111
-
memcpy(sdata->u.ibss.ssid, params->ssid, IEEE80211_MAX_SSID_LEN);
1111
+
memcpy(sdata->u.ibss.ssid, params->ssid, params->ssid_len);
1112
1112
sdata->u.ibss.ssid_len = params->ssid_len;
1113
1113
1114
1114
mutex_unlock(&sdata->u.ibss.mtx);
+55
-17
net/mac80211/rx.c
+55
-17
net/mac80211/rx.c
···
531
531
532
532
if (ieee80211_is_action(hdr->frame_control)) {
533
533
u8 category;
534
+
535
+
/* make sure category field is present */
536
+
if (rx->skb->len < IEEE80211_MIN_ACTION_SIZE)
537
+
return RX_DROP_MONITOR;
538
+
534
539
mgmt = (struct ieee80211_mgmt *)hdr;
535
540
category = mgmt->u.action.category;
536
541
if (category != WLAN_CATEGORY_MESH_ACTION &&
···
888
883
*/
889
884
if (rx->sta && rx->sdata->vif.type == NL80211_IFTYPE_STATION &&
890
885
ieee80211_is_data_present(hdr->frame_control)) {
891
-
u16 ethertype;
892
-
u8 *payload;
886
+
unsigned int hdrlen;
887
+
__be16 ethertype;
893
888
894
-
payload = rx->skb->data +
895
-
ieee80211_hdrlen(hdr->frame_control);
896
-
ethertype = (payload[6] << 8) | payload[7];
897
-
if (cpu_to_be16(ethertype) ==
898
-
rx->sdata->control_port_protocol)
889
+
hdrlen = ieee80211_hdrlen(hdr->frame_control);
890
+
891
+
if (rx->skb->len < hdrlen + 8)
892
+
return RX_DROP_MONITOR;
893
+
894
+
skb_copy_bits(rx->skb, hdrlen + 6, ðertype, 2);
895
+
if (ethertype == rx->sdata->control_port_protocol)
899
896
return RX_CONTINUE;
900
897
}
901
898
···
1469
1462
1470
1463
hdr = (struct ieee80211_hdr *)rx->skb->data;
1471
1464
fc = hdr->frame_control;
1465
+
1466
+
if (ieee80211_is_ctl(fc))
1467
+
return RX_CONTINUE;
1468
+
1472
1469
sc = le16_to_cpu(hdr->seq_ctrl);
1473
1470
frag = sc & IEEE80211_SCTL_FRAG;
1474
1471
1475
1472
if (likely((!ieee80211_has_morefrags(fc) && frag == 0) ||
1476
-
(rx->skb)->len < 24 ||
1477
1473
is_multicast_ether_addr(hdr->addr1))) {
1478
1474
/* not fragmented */
1479
1475
goto out;
···
1899
1889
1900
1890
hdr = (struct ieee80211_hdr *) skb->data;
1901
1891
hdrlen = ieee80211_hdrlen(hdr->frame_control);
1892
+
1893
+
/* make sure fixed part of mesh header is there, also checks skb len */
1894
+
if (!pskb_may_pull(rx->skb, hdrlen + 6))
1895
+
return RX_DROP_MONITOR;
1896
+
1897
+
mesh_hdr = (struct ieee80211s_hdr *) (skb->data + hdrlen);
1898
+
1899
+
/* make sure full mesh header is there, also checks skb len */
1900
+
if (!pskb_may_pull(rx->skb,
1901
+
hdrlen + ieee80211_get_mesh_hdrlen(mesh_hdr)))
1902
+
return RX_DROP_MONITOR;
1903
+
1904
+
/* reload pointers */
1905
+
hdr = (struct ieee80211_hdr *) skb->data;
1902
1906
mesh_hdr = (struct ieee80211s_hdr *) (skb->data + hdrlen);
1903
1907
1904
1908
/* frame is in RMC, don't forward */
···
1921
1897
mesh_rmc_check(hdr->addr3, mesh_hdr, rx->sdata))
1922
1898
return RX_DROP_MONITOR;
1923
1899
1924
-
if (!ieee80211_is_data(hdr->frame_control))
1900
+
if (!ieee80211_is_data(hdr->frame_control) ||
1901
+
!(status->rx_flags & IEEE80211_RX_RA_MATCH))
1925
1902
return RX_CONTINUE;
1926
1903
1927
1904
if (!mesh_hdr->ttl)
···
1936
1911
if (is_multicast_ether_addr(hdr->addr1)) {
1937
1912
mpp_addr = hdr->addr3;
1938
1913
proxied_addr = mesh_hdr->eaddr1;
1939
-
} else {
1914
+
} else if (mesh_hdr->flags & MESH_FLAGS_AE_A5_A6) {
1915
+
/* has_a4 already checked in ieee80211_rx_mesh_check */
1940
1916
mpp_addr = hdr->addr4;
1941
1917
proxied_addr = mesh_hdr->eaddr2;
1918
+
} else {
1919
+
return RX_DROP_MONITOR;
1942
1920
}
1943
1921
1944
1922
rcu_read_lock();
···
1969
1941
}
1970
1942
skb_set_queue_mapping(skb, q);
1971
1943
1972
-
if (!(status->rx_flags & IEEE80211_RX_RA_MATCH))
1973
-
goto out;
1974
-
1975
1944
if (!--mesh_hdr->ttl) {
1976
1945
IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, dropped_frames_ttl);
1977
-
return RX_DROP_MONITOR;
1946
+
goto out;
1978
1947
}
1979
1948
1980
1949
if (!ifmsh->mshcfg.dot11MeshForwarding)
···
2378
2353
}
2379
2354
break;
2380
2355
case WLAN_CATEGORY_SELF_PROTECTED:
2356
+
if (len < (IEEE80211_MIN_ACTION_SIZE +
2357
+
sizeof(mgmt->u.action.u.self_prot.action_code)))
2358
+
break;
2359
+
2381
2360
switch (mgmt->u.action.u.self_prot.action_code) {
2382
2361
case WLAN_SP_MESH_PEERING_OPEN:
2383
2362
case WLAN_SP_MESH_PEERING_CLOSE:
···
2400
2371
}
2401
2372
break;
2402
2373
case WLAN_CATEGORY_MESH_ACTION:
2374
+
if (len < (IEEE80211_MIN_ACTION_SIZE +
2375
+
sizeof(mgmt->u.action.u.mesh_action.action_code)))
2376
+
break;
2377
+
2403
2378
if (!ieee80211_vif_is_mesh(&sdata->vif))
2404
2379
break;
2405
2380
if (mesh_action_is_path_sel(mgmt) &&
···
2946
2913
if (ieee80211_is_data(fc) || ieee80211_is_mgmt(fc))
2947
2914
local->dot11ReceivedFragmentCount++;
2948
2915
2949
-
if (ieee80211_is_mgmt(fc))
2950
-
err = skb_linearize(skb);
2951
-
else
2916
+
if (ieee80211_is_mgmt(fc)) {
2917
+
/* drop frame if too short for header */
2918
+
if (skb->len < ieee80211_hdrlen(fc))
2919
+
err = -ENOBUFS;
2920
+
else
2921
+
err = skb_linearize(skb);
2922
+
} else {
2952
2923
err = !pskb_may_pull(skb, ieee80211_hdrlen(fc));
2924
+
}
2953
2925
2954
2926
if (err) {
2955
2927
dev_kfree_skb(skb);
+35
-7
net/mac80211/util.c
+35
-7
net/mac80211/util.c
···
643
643
break;
644
644
}
645
645
646
-
if (id != WLAN_EID_VENDOR_SPECIFIC &&
647
-
id != WLAN_EID_QUIET &&
648
-
test_bit(id, seen_elems)) {
649
-
elems->parse_error = true;
650
-
left -= elen;
651
-
pos += elen;
652
-
continue;
646
+
switch (id) {
647
+
case WLAN_EID_SSID:
648
+
case WLAN_EID_SUPP_RATES:
649
+
case WLAN_EID_FH_PARAMS:
650
+
case WLAN_EID_DS_PARAMS:
651
+
case WLAN_EID_CF_PARAMS:
652
+
case WLAN_EID_TIM:
653
+
case WLAN_EID_IBSS_PARAMS:
654
+
case WLAN_EID_CHALLENGE:
655
+
case WLAN_EID_RSN:
656
+
case WLAN_EID_ERP_INFO:
657
+
case WLAN_EID_EXT_SUPP_RATES:
658
+
case WLAN_EID_HT_CAPABILITY:
659
+
case WLAN_EID_HT_OPERATION:
660
+
case WLAN_EID_VHT_CAPABILITY:
661
+
case WLAN_EID_VHT_OPERATION:
662
+
case WLAN_EID_MESH_ID:
663
+
case WLAN_EID_MESH_CONFIG:
664
+
case WLAN_EID_PEER_MGMT:
665
+
case WLAN_EID_PREQ:
666
+
case WLAN_EID_PREP:
667
+
case WLAN_EID_PERR:
668
+
case WLAN_EID_RANN:
669
+
case WLAN_EID_CHANNEL_SWITCH:
670
+
case WLAN_EID_EXT_CHANSWITCH_ANN:
671
+
case WLAN_EID_COUNTRY:
672
+
case WLAN_EID_PWR_CONSTRAINT:
673
+
case WLAN_EID_TIMEOUT_INTERVAL:
674
+
if (test_bit(id, seen_elems)) {
675
+
elems->parse_error = true;
676
+
left -= elen;
677
+
pos += elen;
678
+
continue;
679
+
}
680
+
break;
653
681
}
654
682
655
683
if (calc_crc && id < 64 && (filter & (1ULL << id)))
+2
-1
net/netfilter/nf_conntrack_h323_main.c
+2
-1
net/netfilter/nf_conntrack_h323_main.c
···
753
753
flowi4_to_flowi(&fl1), false)) {
754
754
if (!afinfo->route(&init_net, (struct dst_entry **)&rt2,
755
755
flowi4_to_flowi(&fl2), false)) {
756
-
if (rt1->rt_gateway == rt2->rt_gateway &&
756
+
if (rt_nexthop(rt1, fl1.daddr) ==
757
+
rt_nexthop(rt2, fl2.daddr) &&
757
758
rt1->dst.dev == rt2->dst.dev)
758
759
ret = 1;
759
760
dst_release(&rt2->dst);
+1
-1
net/sctp/socket.c
+1
-1
net/sctp/socket.c
···
974
974
void *addr_buf;
975
975
struct sctp_af *af;
976
976
977
-
SCTP_DEBUG_PRINTK("sctp_setsocktopt_bindx: sk %p addrs %p"
977
+
SCTP_DEBUG_PRINTK("sctp_setsockopt_bindx: sk %p addrs %p"
978
978
" addrs_size %d opt %d\n", sk, addrs, addrs_size, op);
979
979
980
980
if (unlikely(addrs_size <= 0))
+1
-2
net/wireless/core.c
+1
-2
net/wireless/core.c
···
526
526
for (i = 0; i < sband->n_channels; i++) {
527
527
sband->channels[i].orig_flags =
528
528
sband->channels[i].flags;
529
-
sband->channels[i].orig_mag =
530
-
sband->channels[i].max_antenna_gain;
529
+
sband->channels[i].orig_mag = INT_MAX;
531
530
sband->channels[i].orig_mpwr =
532
531
sband->channels[i].max_power;
533
532
sband->channels[i].band = band;
+3
-2
net/wireless/reg.c
+3
-2
net/wireless/reg.c
···
908
908
map_regdom_flags(reg_rule->flags) | bw_flags;
909
909
chan->max_antenna_gain = chan->orig_mag =
910
910
(int) MBI_TO_DBI(power_rule->max_antenna_gain);
911
-
chan->max_power = chan->orig_mpwr =
911
+
chan->max_reg_power = chan->max_power = chan->orig_mpwr =
912
912
(int) MBM_TO_DBM(power_rule->max_eirp);
913
913
return;
914
914
}
···
1331
1331
1332
1332
chan->flags |= map_regdom_flags(reg_rule->flags) | bw_flags;
1333
1333
chan->max_antenna_gain = (int) MBI_TO_DBI(power_rule->max_antenna_gain);
1334
-
chan->max_power = (int) MBM_TO_DBM(power_rule->max_eirp);
1334
+
chan->max_reg_power = chan->max_power =
1335
+
(int) MBM_TO_DBM(power_rule->max_eirp);
1335
1336
}
1336
1337
1337
1338
static void handle_band_custom(struct wiphy *wiphy, enum ieee80211_band band,
+8
-6
net/wireless/util.c
+8
-6
net/wireless/util.c
···
309
309
}
310
310
EXPORT_SYMBOL(ieee80211_get_hdrlen_from_skb);
311
311
312
-
static int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr *meshhdr)
312
+
unsigned int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr *meshhdr)
313
313
{
314
314
int ae = meshhdr->flags & MESH_FLAGS_AE;
315
-
/* 7.1.3.5a.2 */
315
+
/* 802.11-2012, 8.2.4.7.3 */
316
316
switch (ae) {
317
+
default:
317
318
case 0:
318
319
return 6;
319
320
case MESH_FLAGS_AE_A4:
320
321
return 12;
321
322
case MESH_FLAGS_AE_A5_A6:
322
323
return 18;
323
-
case (MESH_FLAGS_AE_A4 | MESH_FLAGS_AE_A5_A6):
324
-
return 24;
325
-
default:
326
-
return 6;
327
324
}
328
325
}
326
+
EXPORT_SYMBOL(ieee80211_get_mesh_hdrlen);
329
327
330
328
int ieee80211_data_to_8023(struct sk_buff *skb, const u8 *addr,
331
329
enum nl80211_iftype iftype)
···
371
373
/* make sure meshdr->flags is on the linear part */
372
374
if (!pskb_may_pull(skb, hdrlen + 1))
373
375
return -1;
376
+
if (meshdr->flags & MESH_FLAGS_AE_A4)
377
+
return -1;
374
378
if (meshdr->flags & MESH_FLAGS_AE_A5_A6) {
375
379
skb_copy_bits(skb, hdrlen +
376
380
offsetof(struct ieee80211s_hdr, eaddr1),
···
396
396
(struct ieee80211s_hdr *) (skb->data + hdrlen);
397
397
/* make sure meshdr->flags is on the linear part */
398
398
if (!pskb_may_pull(skb, hdrlen + 1))
399
+
return -1;
400
+
if (meshdr->flags & MESH_FLAGS_AE_A5_A6)
399
401
return -1;
400
402
if (meshdr->flags & MESH_FLAGS_AE_A4)
401
403
skb_copy_bits(skb, hdrlen +