lael-labs/linux

Documentation/devicetree/bindings/net/ethernet.txt+1−1

@@ -10,7 +10,7 @@ The following properties are common to the Ethernet controllers: · 9 unmodified lines
10	- max-frame-size: number, maximum transfer unit (IEEE defined MTU), rather than	10	- max-frame-size: number, maximum transfer unit (IEEE defined MTU), rather than
11	the maximum frame size (there's contradiction in ePAPR).	11	the maximum frame size (there's contradiction in ePAPR).
12	- phy-mode: string, operation mode of the PHY interface; supported values are	12	- phy-mode: string, operation mode of the PHY interface; supported values are
13	"mii", "gmii", "sgmii", "tbi", "rev-mii", "rmii", "rgmii", "rgmii-id",	13	"mii", "gmii", "sgmii", "qsgmii", "tbi", "rev-mii", "rmii", "rgmii", "rgmii-id",
14	"rgmii-rxid", "rgmii-txid", "rtbi", "smii", "xgmii"; this is now a de-facto	14	"rgmii-rxid", "rgmii-txid", "rtbi", "smii", "xgmii"; this is now a de-facto
15	standard property;	15	standard property;
16	- phy-connection-type: the same as "phy-mode" property but described in ePAPR;	16	- phy-connection-type: the same as "phy-mode" property but described in ePAPR;

drivers/isdn/icn/icn.c+5−6

 	ulong a;
 	ulong flags;
 	int i;
-	char cbuf[60];
+	char cbuf[80];
 	isdn_ctrl cmd;
 	icn_cdef cdef;
 	char __user *arg;
 			break;
 		if ((c->arg & 255) < ICN_BCH) {
 			char *p;
-			char dial[50];
 			char dcode[4];
 			a = c->arg;
 			} else
 				/* Normal Dial */
 				strcpy(dcode, "CAL");
-			strcpy(dial, p);
+			snprintf(cbuf, sizeof(cbuf),
-			sprintf(cbuf, "%02d;D%s_R%s,%02d,%02d,%s\n", (int) (a + 1),
+				 "%02d;D%s_R%s,%02d,%02d,%s\n", (int) (a + 1),
-				dcode, dial, c->parm.setup.si1,
+				 dcode, p, c->parm.setup.si1,
-				c->parm.setup.si2, c->parm.setup.eazmsn);
+				 c->parm.setup.si2, c->parm.setup.eazmsn);
 			i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
 		}
 		break;

drivers/net/ethernet/broadcom/tg3.c+3−1

@@ -12286,7 +12286,9 @@ static int tg3_set_ringparam(struct net_device dev, struct ethtool_ringparam e · 12285 unmodified lines
12286	if (tg3_flag(tp, MAX_RXPEND_64) &&	12286	if (tg3_flag(tp, MAX_RXPEND_64) &&
12287	tp->rx_pending > 63)	12287	tp->rx_pending > 63)
12288	tp->rx_pending = 63;	12288	tp->rx_pending = 63;
12289	tp->rx_jumbo_pending = ering->rx_jumbo_pending;	12289
		12290	if (tg3_flag(tp, JUMBO_RING_ENABLE))
		12291	tp->rx_jumbo_pending = ering->rx_jumbo_pending;
12290		12292
12291	for (i = 0; i < tp->irq_max; i++)	12293	for (i = 0; i < tp->irq_max; i++)
12292	tp->napi[i].tx_pending = ering->tx_pending;	12294	tp->napi[i].tx_pending = ering->tx_pending;

drivers/net/ethernet/marvell/mvneta.c+34−39

@@ -89,8 +89,9 @@ · 88 unmodified lines
89	#define MVNETA_TX_IN_PRGRS BIT(1)	89	#define MVNETA_TX_IN_PRGRS BIT(1)
90	#define MVNETA_TX_FIFO_EMPTY BIT(8)	90	#define MVNETA_TX_FIFO_EMPTY BIT(8)
91	#define MVNETA_RX_MIN_FRAME_SIZE 0x247c	91	#define MVNETA_RX_MIN_FRAME_SIZE 0x247c
92	#define MVNETA_SGMII_SERDES_CFG 0x24A0	92	#define MVNETA_SERDES_CFG 0x24A0
93	#define MVNETA_SGMII_SERDES_PROTO 0x0cc7	93	#define MVNETA_SGMII_SERDES_PROTO 0x0cc7
		94	#define MVNETA_QSGMII_SERDES_PROTO 0x0667
94	#define MVNETA_TYPE_PRIO 0x24bc	95	#define MVNETA_TYPE_PRIO 0x24bc
95	#define MVNETA_FORCE_UNI BIT(21)	96	#define MVNETA_FORCE_UNI BIT(21)
96	#define MVNETA_TXQ_CMD_1 0x24e4	97	#define MVNETA_TXQ_CMD_1 0x24e4
@@ -711,35 +712,6 @@ static void mvneta_rxq_bm_disable(struct mvneta_port *pp, · 614 unmodified lines
711	mvreg_write(pp, MVNETA_RXQ_CONFIG_REG(rxq->id), val);	712	mvreg_write(pp, MVNETA_RXQ_CONFIG_REG(rxq->id), val);
712	}	713	}
713		714
714
715
716	/* Sets the RGMII Enable bit (RGMIIEn) in port MAC control register */
717	static void mvneta_gmac_rgmii_set(struct mvneta_port *pp, int enable)
718	{
719	u32 val;
720
721	val = mvreg_read(pp, MVNETA_GMAC_CTRL_2);
722
723	if (enable)
724	val \|= MVNETA_GMAC2_PORT_RGMII;
725	else
726	val &= ~MVNETA_GMAC2_PORT_RGMII;
727
728	mvreg_write(pp, MVNETA_GMAC_CTRL_2, val);
729	}
730
731	/* Config SGMII port */
732	static void mvneta_port_sgmii_config(struct mvneta_port *pp)
733	{
734	u32 val;
735
736	val = mvreg_read(pp, MVNETA_GMAC_CTRL_2);
737	val \|= MVNETA_GMAC2_PCS_ENABLE;
738	mvreg_write(pp, MVNETA_GMAC_CTRL_2, val);
739
740	mvreg_write(pp, MVNETA_SGMII_SERDES_CFG, MVNETA_SGMII_SERDES_PROTO);
741	}
742
743	/* Start the Ethernet port RX and TX activity */	715	/* Start the Ethernet port RX and TX activity */
744	static void mvneta_port_up(struct mvneta_port *pp)	716	static void mvneta_port_up(struct mvneta_port *pp)
745	{	717	{
@@ -2749,26 +2721,44 @@ static void mvneta_conf_mbus_windows(struct mvneta_port *pp, · 2003 unmodified lines
2749	}	2721	}
2750		2722
2751	/* Power up the port */	2723	/* Power up the port */
2752	static void mvneta_port_power_up(struct mvneta_port *pp, int phy_mode)	2724	static int mvneta_port_power_up(struct mvneta_port *pp, int phy_mode)
2753	{	2725	{
2754	u32 val;	2726	u32 ctrl;
2755		2727
2756	/* MAC Cause register should be cleared */	2728	/* MAC Cause register should be cleared */
2757	mvreg_write(pp, MVNETA_UNIT_INTR_CAUSE, 0);	2729	mvreg_write(pp, MVNETA_UNIT_INTR_CAUSE, 0);
2758		2730
2759	if (phy_mode == PHY_INTERFACE_MODE_SGMII)	2731	ctrl = mvreg_read(pp, MVNETA_GMAC_CTRL_2);
2760	mvneta_port_sgmii_config(pp);
2761		2732
2762	mvneta_gmac_rgmii_set(pp, 1);	2733	/* Even though it might look weird, when we're configured in
		2734	* SGMII or QSGMII mode, the RGMII bit needs to be set.
		2735	*/
		2736	switch(phy_mode) {
		2737	case PHY_INTERFACE_MODE_QSGMII:
		2738	mvreg_write(pp, MVNETA_SERDES_CFG, MVNETA_QSGMII_SERDES_PROTO);
		2739	ctrl \|= MVNETA_GMAC2_PCS_ENABLE \| MVNETA_GMAC2_PORT_RGMII;
		2740	break;
		2741	case PHY_INTERFACE_MODE_SGMII:
		2742	mvreg_write(pp, MVNETA_SERDES_CFG, MVNETA_SGMII_SERDES_PROTO);
		2743	ctrl \|= MVNETA_GMAC2_PCS_ENABLE \| MVNETA_GMAC2_PORT_RGMII;
		2744	break;
		2745	case PHY_INTERFACE_MODE_RGMII:
		2746	case PHY_INTERFACE_MODE_RGMII_ID:
		2747	ctrl \|= MVNETA_GMAC2_PORT_RGMII;
		2748	break;
		2749	default:
		2750	return -EINVAL;
		2751	}
2763		2752
2764	/* Cancel Port Reset */	2753	/* Cancel Port Reset */
2765	val = mvreg_read(pp, MVNETA_GMAC_CTRL_2);	2754	ctrl &= ~MVNETA_GMAC2_PORT_RESET;
2766	val &= ~MVNETA_GMAC2_PORT_RESET;	2755	mvreg_write(pp, MVNETA_GMAC_CTRL_2, ctrl);
2767	mvreg_write(pp, MVNETA_GMAC_CTRL_2, val);
2768		2756
2769	while ((mvreg_read(pp, MVNETA_GMAC_CTRL_2) &	2757	while ((mvreg_read(pp, MVNETA_GMAC_CTRL_2) &
2770	MVNETA_GMAC2_PORT_RESET) != 0)	2758	MVNETA_GMAC2_PORT_RESET) != 0)
2771	continue;	2759	continue;
		2760
		2761	return 0;
2772	}	2762	}
2773		2763
2774	/* Device initialization routine */	2764	/* Device initialization routine */
@@ -2879,7 +2869,12 @@ static int mvneta_probe(struct platform_device *pdev) · 104 unmodified lines
2879	dev_err(&pdev->dev, "can't init eth hal\n");	2869	dev_err(&pdev->dev, "can't init eth hal\n");
2880	goto err_free_stats;	2870	goto err_free_stats;
2881	}	2871	}
2882	mvneta_port_power_up(pp, phy_mode);	2872
		2873	err = mvneta_port_power_up(pp, phy_mode);
		2874	if (err < 0) {
		2875	dev_err(&pdev->dev, "can't power up port\n");
		2876	goto err_deinit;
		2877	}
2883		2878
2884	dram_target_info = mv_mbus_dram_info();	2879	dram_target_info = mv_mbus_dram_info();
2885	if (dram_target_info)	2880	if (dram_target_info)

drivers/net/ethernet/mellanox/mlx4/en_cq.c+0−1

@@ -66,7 +66,6 @@ int mlx4_en_create_cq(struct mlx4_en_priv *priv, · 65 unmodified lines
66		66
67	cq->ring = ring;	67	cq->ring = ring;
68	cq->is_tx = mode;	68	cq->is_tx = mode;
69	spin_lock_init(&cq->lock);
70		69
71	/* Allocate HW buffers on provided NUMA node.	70	/* Allocate HW buffers on provided NUMA node.
72	* dev->numa_node is used in mtt range allocation flow.	71	* dev->numa_node is used in mtt range allocation flow.

drivers/net/ethernet/mellanox/mlx4/en_netdev.c+1−5

 {
 	struct mlx4_en_priv *priv = netdev_priv(dev);
 	struct mlx4_en_cq *cq;
-	unsigned long flags;
 	int i;
 	for (i = 0; i < priv->rx_ring_num; i++) {
 		cq = priv->rx_cq[i];
-		spin_lock_irqsave(&cq->lock, flags);
+		napi_schedule(&cq->napi);
-		napi_synchronize(&cq->napi);
-		mlx4_en_process_rx_cq(dev, cq, 0);
-		spin_unlock_irqrestore(&cq->lock, flags);
 	}
 }
 #endif

drivers/net/ethernet/mellanox/mlx4/mlx4_en.h+0−1

@@ -319,7 +319,6 @@ struct mlx4_en_cq { · 318 unmodified lines
319	struct mlx4_cq mcq;	319	struct mlx4_cq mcq;
320	struct mlx4_hwq_resources wqres;	320	struct mlx4_hwq_resources wqres;
321	int ring;	321	int ring;
322	spinlock_t lock;
323	struct net_device *dev;	322	struct net_device *dev;
324	struct napi_struct napi;	323	struct napi_struct napi;
325	int size;	324	int size;

drivers/net/ethernet/sfc/ef10.c+11−1

 	/* If it was a port reset, trigger reallocation of MC resources.
 	 * Note that on an MC reset nothing needs to be done now because we'll
 	 * detect the MC reset later and handle it then.
+	 * For an FLR, we never get an MC reset event, but the MC has reset all
+	 * resources assigned to us, so we have to trigger reallocation now.
 	 */
-	if (reset_type == RESET_TYPE_ALL && !rc)
+	if ((reset_type == RESET_TYPE_ALL ||
+	     reset_type == RESET_TYPE_MCDI_TIMEOUT) && !rc)
 		efx_ef10_reset_mc_allocations(efx);
 	return rc;
 }
 	return 0;
 }
+static void efx_ef10_prepare_flr(struct efx_nic *efx)
+{
+	atomic_set(&efx->active_queues, 0);
+}
 static bool efx_ef10_filter_equal(const struct efx_filter_spec *left,
 				  const struct efx_filter_spec *right)
 {
 	.probe_port = efx_mcdi_port_probe,
 	.remove_port = efx_mcdi_port_remove,
 	.fini_dmaq = efx_ef10_fini_dmaq,
+	.prepare_flr = efx_ef10_prepare_flr,
+	.finish_flr = efx_port_dummy_op_void,
 	.describe_stats = efx_ef10_describe_stats,
 	.update_stats = efx_ef10_update_stats,
 	.start_stats = efx_mcdi_mac_start_stats,

drivers/net/ethernet/sfc/efx.c+16−3

 	[RESET_TYPE_RECOVER_OR_ALL]     = "RECOVER_OR_ALL",
 	[RESET_TYPE_WORLD]              = "WORLD",
 	[RESET_TYPE_RECOVER_OR_DISABLE] = "RECOVER_OR_DISABLE",
+	[RESET_TYPE_MC_BIST]		= "MC_BIST",
 	[RESET_TYPE_DISABLE]            = "DISABLE",
 	[RESET_TYPE_TX_WATCHDOG]        = "TX_WATCHDOG",
 	[RESET_TYPE_INT_ERROR]          = "INT_ERROR",
 	[RESET_TYPE_DMA_ERROR]          = "DMA_ERROR",
 	[RESET_TYPE_TX_SKIP]            = "TX_SKIP",
 	[RESET_TYPE_MC_FAILURE]         = "MC_FAILURE",
-	[RESET_TYPE_MC_BIST]		= "MC_BIST",
+	[RESET_TYPE_MCDI_TIMEOUT]	= "MCDI_TIMEOUT (FLR)",
 };
 /* Reset workqueue. If any NIC has a hardware failure then a reset will be
 	/* Check that it is appropriate to restart the interface. All
 	 * of these flags are safe to read under just the rtnl lock */
-	if (efx->port_enabled || !netif_running(efx->net_dev))
+	if (efx->port_enabled || !netif_running(efx->net_dev) ||
+	    efx->reset_pending)
 		return;
 	efx_start_port(efx);
 {
 	EFX_ASSERT_RESET_SERIALISED(efx);
+	if (method == RESET_TYPE_MCDI_TIMEOUT)
+		efx->type->prepare_flr(efx);
 	efx_stop_all(efx);
 	efx_disable_interrupts(efx);
 	EFX_ASSERT_RESET_SERIALISED(efx);
+	if (method == RESET_TYPE_MCDI_TIMEOUT)
+		efx->type->finish_flr(efx);
+	/* Ensure that SRAM is initialised even if we're disabling the device */
 	rc = efx->type->init(efx);
 	if (rc) {
 		netif_err(efx, drv, efx->net_dev, "failed to initialise NIC\n");
 	/* Clear flags for the scopes we covered.  We assume the NIC and
 	 * driver are now quiescent so that there is no race here.
 	 */
-	efx->reset_pending &= -(1 << (method + 1));
+	if (method < RESET_TYPE_MAX_METHOD)
+		efx->reset_pending &= -(1 << (method + 1));
+	else /* it doesn't fit into the well-ordered scope hierarchy */
+		__clear_bit(method, &efx->reset_pending);
 	/* Reinitialise bus-mastering, which may have been turned off before
 	 * the reset was scheduled. This is still appropriate, even in the
 	case RESET_TYPE_DISABLE:
 	case RESET_TYPE_RECOVER_OR_DISABLE:
 	case RESET_TYPE_MC_BIST:
+	case RESET_TYPE_MCDI_TIMEOUT:
 		method = type;
 		netif_dbg(efx, drv, efx->net_dev, "scheduling %s reset\n",
 			  RESET_TYPE(method));

drivers/net/ethernet/sfc/enum.h+16−7

  * @RESET_TYPE_WORLD: Reset as much as possible
  * @RESET_TYPE_RECOVER_OR_DISABLE: Try to recover. Apply RESET_TYPE_DISABLE if
  * unsuccessful.
+ * @RESET_TYPE_MC_BIST: MC entering BIST mode.
  * @RESET_TYPE_DISABLE: Reset datapath, MAC and PHY; leave NIC disabled
  * @RESET_TYPE_TX_WATCHDOG: reset due to TX watchdog
  * @RESET_TYPE_INT_ERROR: reset due to internal error
  * @RESET_TYPE_DMA_ERROR: DMA error
  * @RESET_TYPE_TX_SKIP: hardware completed empty tx descriptors
  * @RESET_TYPE_MC_FAILURE: MC reboot/assertion
+ * @RESET_TYPE_MCDI_TIMEOUT: MCDI timeout.
  */
 enum reset_type {
-	RESET_TYPE_INVISIBLE = 0,
+	RESET_TYPE_INVISIBLE,
-	RESET_TYPE_RECOVER_OR_ALL = 1,
+	RESET_TYPE_RECOVER_OR_ALL,
-	RESET_TYPE_ALL = 2,
+	RESET_TYPE_ALL,
-	RESET_TYPE_WORLD = 3,
+	RESET_TYPE_WORLD,
-	RESET_TYPE_RECOVER_OR_DISABLE = 4,
+	RESET_TYPE_RECOVER_OR_DISABLE,
-	RESET_TYPE_DISABLE = 5,
+	RESET_TYPE_MC_BIST,
+	RESET_TYPE_DISABLE,
 	RESET_TYPE_MAX_METHOD,
 	RESET_TYPE_TX_WATCHDOG,
 	RESET_TYPE_INT_ERROR,
 	RESET_TYPE_DMA_ERROR,
 	RESET_TYPE_TX_SKIP,
 	RESET_TYPE_MC_FAILURE,
-	RESET_TYPE_MC_BIST,
+	/* RESET_TYPE_MCDI_TIMEOUT is actually a method, not just a reason, but
+	 * it doesn't fit the scope hierarchy (not well-ordered by inclusion).
+	 * We encode this by having its enum value be greater than
+	 * RESET_TYPE_MAX_METHOD. This also prevents issuing it with
+	 * efx_ioctl_reset.
+	 */
+	RESET_TYPE_MCDI_TIMEOUT,
 	RESET_TYPE_MAX,
 };

drivers/net/ethernet/sfc/falcon.c+4−0

 	.fini_dmaq = efx_farch_fini_dmaq,
 	.prepare_flush = falcon_prepare_flush,
 	.finish_flush = efx_port_dummy_op_void,
+	.prepare_flr = efx_port_dummy_op_void,
+	.finish_flr = efx_farch_finish_flr,
 	.describe_stats = falcon_describe_nic_stats,
 	.update_stats = falcon_update_nic_stats,
 	.start_stats = falcon_start_nic_stats,
 	.fini_dmaq = efx_farch_fini_dmaq,
 	.prepare_flush = falcon_prepare_flush,
 	.finish_flush = efx_port_dummy_op_void,
+	.prepare_flr = efx_port_dummy_op_void,
+	.finish_flr = efx_farch_finish_flr,
 	.describe_stats = falcon_describe_nic_stats,
 	.update_stats = falcon_update_nic_stats,
 	.start_stats = falcon_start_nic_stats,

drivers/net/ethernet/sfc/farch.c+22−0

@@ -741,6 +741,28 @@ int efx_farch_fini_dmaq(struct efx_nic *efx) · 740 unmodified lines
741	return rc;	741	return rc;
742	}	742	}
743		743
		744	/* Reset queue and flush accounting after FLR
		745	*
		746	* One possible cause of FLR recovery is that DMA may be failing (eg. if bus
		747	* mastering was disabled), in which case we don't receive (RXQ) flush
		748	* completion events. This means that efx->rxq_flush_outstanding remained at 4
		749	* after the FLR; also, efx->active_queues was non-zero (as no flush completion
		750	* events were received, and we didn't go through efx_check_tx_flush_complete())
		751	* If we don't fix this up, on the next call to efx_realloc_channels() we won't
		752	* flush any RX queues because efx->rxq_flush_outstanding is at the limit of 4
		753	* for batched flush requests; and the efx->active_queues gets messed up because
		754	* we keep incrementing for the newly initialised queues, but it never went to
		755	* zero previously. Then we get a timeout every time we try to restart the
		756	* queues, as it doesn't go back to zero when we should be flushing the queues.
		757	*/
		758	void efx_farch_finish_flr(struct efx_nic *efx)
		759	{
		760	atomic_set(&efx->rxq_flush_pending, 0);
		761	atomic_set(&efx->rxq_flush_outstanding, 0);
		762	atomic_set(&efx->active_queues, 0);
		763	}
		764
		765
744	/**************************************************************************	766	/**************************************************************************
745	*	767	*
746	* Event queue processing	768	* Event queue processing

drivers/net/ethernet/sfc/mcdi.c+44−11

@@ -52,12 +52,7 @@ static void efx_mcdi_timeout_async(unsigned long context); · 51 unmodified lines
52	static int efx_mcdi_drv_attach(struct efx_nic *efx, bool driver_operating,	52	static int efx_mcdi_drv_attach(struct efx_nic *efx, bool driver_operating,
53	bool *was_attached_out);	53	bool *was_attached_out);
54	static bool efx_mcdi_poll_once(struct efx_nic *efx);	54	static bool efx_mcdi_poll_once(struct efx_nic *efx);
55		55	static void efx_mcdi_abandon(struct efx_nic *efx);
56	static inline struct efx_mcdi_iface efx_mcdi(struct efx_nic efx)
57	{
58	EFX_BUG_ON_PARANOID(!efx->mcdi);
59	return &efx->mcdi->iface;
60	}
61		56
62	int efx_mcdi_init(struct efx_nic *efx)	57	int efx_mcdi_init(struct efx_nic *efx)
63	{	58	{
@@ -558,6 +553,8 @@ static int _efx_mcdi_rpc_finish(struct efx_nic *efx, unsigned cmd, size_t inlen, · 494 unmodified lines
558	rc = 0;	553	rc = 0;
559	}	554	}
560		555
		556	efx_mcdi_abandon(efx);
		557
561	/* Close the race with efx_mcdi_ev_cpl() executing just too late	558	/* Close the race with efx_mcdi_ev_cpl() executing just too late
562	* and completing a request we've just cancelled, by ensuring	559	* and completing a request we've just cancelled, by ensuring
563	* that the seqno check therein fails.	560	* that the seqno check therein fails.
@@ -672,6 +669,9 @@ int efx_mcdi_rpc_start(struct efx_nic *efx, unsigned cmd, · 108 unmodified lines
672	if (efx->mc_bist_for_other_fn)	669	if (efx->mc_bist_for_other_fn)
673	return -ENETDOWN;	670	return -ENETDOWN;
674		671
		672	if (mcdi->mode == MCDI_MODE_FAIL)
		673	return -ENETDOWN;
		674
675	efx_mcdi_acquire_sync(mcdi);	675	efx_mcdi_acquire_sync(mcdi);
676	efx_mcdi_send_request(efx, cmd, inbuf, inlen);	676	efx_mcdi_send_request(efx, cmd, inbuf, inlen);
677	return 0;	677	return 0;
@@ -812,7 +812,11 @@ void efx_mcdi_mode_poll(struct efx_nic *efx) · 134 unmodified lines
812	return;	812	return;
813		813
814	mcdi = efx_mcdi(efx);	814	mcdi = efx_mcdi(efx);
815	if (mcdi->mode == MCDI_MODE_POLL)	815	/* If already in polling mode, nothing to do.
		816	* If in fail-fast state, don't switch to polled completion.
		817	* FLR recovery will do that later.
		818	*/
		819	if (mcdi->mode == MCDI_MODE_POLL \|\| mcdi->mode == MCDI_MODE_FAIL)
816	return;	820	return;
817		821
818	/* We can switch from event completion to polled completion, because	822	/* We can switch from event completion to polled completion, because
@@ -841,8 +845,8 @@ void efx_mcdi_flush_async(struct efx_nic *efx) · 22 unmodified lines
841		845
842	mcdi = efx_mcdi(efx);	846	mcdi = efx_mcdi(efx);
843		847
844	/* We must be in polling mode so no more requests can be queued */	848	/* We must be in poll or fail mode so no more requests can be queued */
845	BUG_ON(mcdi->mode != MCDI_MODE_POLL);	849	BUG_ON(mcdi->mode == MCDI_MODE_EVENTS);
846		850
847	del_timer_sync(&mcdi->async_timer);	851	del_timer_sync(&mcdi->async_timer);
848		852
@@ -875,8 +879,11 @@ void efx_mcdi_mode_event(struct efx_nic *efx) · 26 unmodified lines
875	return;	879	return;
876		880
877	mcdi = efx_mcdi(efx);	881	mcdi = efx_mcdi(efx);
878		882	/* If already in event completion mode, nothing to do.
879	if (mcdi->mode == MCDI_MODE_EVENTS)	883	* If in fail-fast state, don't switch to event completion. FLR
		884	* recovery will do that later.
		885	*/
		886	if (mcdi->mode == MCDI_MODE_EVENTS \|\| mcdi->mode == MCDI_MODE_FAIL)
880	return;	887	return;
881		888
882	/* We can't switch from polled to event completion in the middle of a	889	/* We can't switch from polled to event completion in the middle of a
@@ -966,6 +973,19 @@ static void efx_mcdi_ev_bist(struct efx_nic *efx) · 83 unmodified lines
966	spin_unlock(&mcdi->iface_lock);	973	spin_unlock(&mcdi->iface_lock);
967	}	974	}
968		975
		976	/* MCDI timeouts seen, so make all MCDI calls fail-fast and issue an FLR to try
		977	* to recover.
		978	*/
		979	static void efx_mcdi_abandon(struct efx_nic *efx)
		980	{
		981	struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
		982
		983	if (xchg(&mcdi->mode, MCDI_MODE_FAIL) == MCDI_MODE_FAIL)
		984	return; /* it had already been done */
		985	netif_dbg(efx, hw, efx->net_dev, "MCDI is timing out; trying to recover\n");
		986	efx_schedule_reset(efx, RESET_TYPE_MCDI_TIMEOUT);
		987	}
		988
969	/* Called from falcon_process_eventq for MCDI events */	989	/* Called from falcon_process_eventq for MCDI events */
970	void efx_mcdi_process_event(struct efx_channel *channel,	990	void efx_mcdi_process_event(struct efx_channel *channel,
971	efx_qword_t *event)	991	efx_qword_t *event)
@@ -1512,6 +1532,19 @@ int efx_mcdi_reset(struct efx_nic *efx, enum reset_type method) · 540 unmodified lines
1512	{	1532	{
1513	int rc;	1533	int rc;
1514		1534
		1535	/* If MCDI is down, we can't handle_assertion */
		1536	if (method == RESET_TYPE_MCDI_TIMEOUT) {
		1537	rc = pci_reset_function(efx->pci_dev);
		1538	if (rc)
		1539	return rc;
		1540	/* Re-enable polled MCDI completion */
		1541	if (efx->mcdi) {
		1542	struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
		1543	mcdi->mode = MCDI_MODE_POLL;
		1544	}
		1545	return 0;
		1546	}
		1547
1515	/* Recover from a failed assertion pre-reset */	1548	/* Recover from a failed assertion pre-reset */
1516	rc = efx_mcdi_handle_assertion(efx);	1549	rc = efx_mcdi_handle_assertion(efx);
1517	if (rc)	1550	if (rc)

drivers/net/ethernet/sfc/mcdi.h+13−0

 	MCDI_STATE_COMPLETED,
 };
+/**
+ * enum efx_mcdi_mode - MCDI transaction mode
+ * @MCDI_MODE_POLL: poll for MCDI completion, until timeout
+ * @MCDI_MODE_EVENTS: wait for an mcdi_event.  On timeout, poll once
+ * @MCDI_MODE_FAIL: we think MCDI is dead, so fail-fast all calls
+ */
 enum efx_mcdi_mode {
 	MCDI_MODE_POLL,
 	MCDI_MODE_EVENTS,
+	MCDI_MODE_FAIL,
 };
 /**
 	u32 fn_flags;
 };
+static inline struct efx_mcdi_iface *efx_mcdi(struct efx_nic *efx)
+{
+	EFX_BUG_ON_PARANOID(!efx->mcdi);
+	return &efx->mcdi->iface;
+}
 #ifdef CONFIG_SFC_MCDI_MON
 static inline struct efx_mcdi_mon *efx_mcdi_mon(struct efx_nic *efx)
 {

drivers/net/ethernet/sfc/net_driver.h+4−0

  *	(for Falcon architecture)
  * @finish_flush: Clean up after flushing the DMA queues (for Falcon
  *	architecture)
+ * @prepare_flr: Prepare for an FLR
+ * @finish_flr: Clean up after an FLR
  * @describe_stats: Describe statistics for ethtool
  * @update_stats: Update statistics not provided by event handling.
  *	Either argument may be %NULL.
 	int (*fini_dmaq)(struct efx_nic *efx);
 	void (*prepare_flush)(struct efx_nic *efx);
 	void (*finish_flush)(struct efx_nic *efx);
+	void (*prepare_flr)(struct efx_nic *efx);
+	void (*finish_flr)(struct efx_nic *efx);
 	size_t (*describe_stats)(struct efx_nic *efx, u8 *names);
 	size_t (*update_stats)(struct efx_nic *efx, u64 *full_stats,
 			       struct rtnl_link_stats64 *core_stats);

drivers/net/ethernet/sfc/nic.h+1−0

@@ -757,6 +757,7 @@ static inline int efx_nic_irq_test_irq_cpu(struct efx_nic *efx) · 756 unmodified lines
757	int efx_nic_flush_queues(struct efx_nic *efx);	757	int efx_nic_flush_queues(struct efx_nic *efx);
758	void siena_prepare_flush(struct efx_nic *efx);	758	void siena_prepare_flush(struct efx_nic *efx);
759	int efx_farch_fini_dmaq(struct efx_nic *efx);	759	int efx_farch_fini_dmaq(struct efx_nic *efx);
		760	void efx_farch_finish_flr(struct efx_nic *efx);
760	void siena_finish_flush(struct efx_nic *efx);	761	void siena_finish_flush(struct efx_nic *efx);
761	void falcon_start_nic_stats(struct efx_nic *efx);	762	void falcon_start_nic_stats(struct efx_nic *efx);
762	void falcon_stop_nic_stats(struct efx_nic *efx);	763	void falcon_stop_nic_stats(struct efx_nic *efx);

drivers/net/ethernet/sfc/siena.c+2−0

 	.fini_dmaq = efx_farch_fini_dmaq,
 	.prepare_flush = siena_prepare_flush,
 	.finish_flush = siena_finish_flush,
+	.prepare_flr = efx_port_dummy_op_void,
+	.finish_flr = efx_farch_finish_flr,
 	.describe_stats = siena_describe_nic_stats,
 	.update_stats = siena_update_nic_stats,
 	.start_stats = efx_mcdi_mac_start_stats,

drivers/net/phy/mdio-gpio.c+47−21

 struct mdio_gpio_info {
 	struct mdiobb_ctrl ctrl;
-	int mdc, mdio;
+	int mdc, mdio, mdo;
+	int mdc_active_low, mdio_active_low, mdo_active_low;
 };
 static void *mdio_gpio_of_get_data(struct platform_device *pdev)
 {
 	struct device_node *np = pdev->dev.of_node;
 	struct mdio_gpio_platform_data *pdata;
+	enum of_gpio_flags flags;
 	int ret;
 	pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
 	if (!pdata)
 		return NULL;
-	ret = of_get_gpio(np, 0);
+	ret = of_get_gpio_flags(np, 0, &flags);
 	if (ret < 0)
 		return NULL;
 	pdata->mdc = ret;
+	pdata->mdc_active_low = flags & OF_GPIO_ACTIVE_LOW;
-	ret = of_get_gpio(np, 1);
+	ret = of_get_gpio_flags(np, 1, &flags);
 	if (ret < 0)
 		return NULL;
 	pdata->mdio = ret;
+	pdata->mdio_active_low = flags & OF_GPIO_ACTIVE_LOW;
+	ret = of_get_gpio_flags(np, 2, &flags);
+	if (ret > 0) {
+		pdata->mdo = ret;
+		pdata->mdo_active_low = flags & OF_GPIO_ACTIVE_LOW;
+	}
 	return pdata;
 }
 	struct mdio_gpio_info *bitbang =
 		container_of(ctrl, struct mdio_gpio_info, ctrl);
+	if (bitbang->mdo) {
+		/* Separate output pin. Always set its value to high
+		 * when changing direction. If direction is input,
+		 * assume the pin serves as pull-up. If direction is
+		 * output, the default value is high.
+		 */
+		gpio_set_value(bitbang->mdo, 1 ^ bitbang->mdo_active_low);
+		return;
+	}
 	if (dir)
-		gpio_direction_output(bitbang->mdio, 1);
+		gpio_direction_output(bitbang->mdio,
+				      1 ^ bitbang->mdio_active_low);
 	else
 		gpio_direction_input(bitbang->mdio);
 }
 	struct mdio_gpio_info *bitbang =
 		container_of(ctrl, struct mdio_gpio_info, ctrl);
-	return gpio_get_value(bitbang->mdio);
+	return gpio_get_value(bitbang->mdio) ^ bitbang->mdio_active_low;
 }
 static void mdio_set(struct mdiobb_ctrl *ctrl, int what)
 	struct mdio_gpio_info *bitbang =
 		container_of(ctrl, struct mdio_gpio_info, ctrl);
-	gpio_set_value(bitbang->mdio, what);
+	if (bitbang->mdo)
+		gpio_set_value(bitbang->mdo, what ^ bitbang->mdo_active_low);
+	else
+		gpio_set_value(bitbang->mdio, what ^ bitbang->mdio_active_low);
 }
 static void mdc_set(struct mdiobb_ctrl *ctrl, int what)
 	struct mdio_gpio_info *bitbang =
 		container_of(ctrl, struct mdio_gpio_info, ctrl);
-	gpio_set_value(bitbang->mdc, what);
+	gpio_set_value(bitbang->mdc, what ^ bitbang->mdc_active_low);
 }
 static struct mdiobb_ops mdio_gpio_ops = {
 	struct mdio_gpio_info *bitbang;
 	int i;
-	bitbang = kzalloc(sizeof(*bitbang), GFP_KERNEL);
+	bitbang = devm_kzalloc(dev, sizeof(*bitbang), GFP_KERNEL);
 	if (!bitbang)
 		goto out;
 	bitbang->ctrl.ops = &mdio_gpio_ops;
 	bitbang->ctrl.reset = pdata->reset;
 	bitbang->mdc = pdata->mdc;
+	bitbang->mdc_active_low = pdata->mdc_active_low;
 	bitbang->mdio = pdata->mdio;
+	bitbang->mdio_active_low = pdata->mdio_active_low;
+	bitbang->mdo = pdata->mdo;
+	bitbang->mdo_active_low = pdata->mdo_active_low;
 	new_bus = alloc_mdio_bitbang(&bitbang->ctrl);
 	if (!new_bus)
-		goto out_free_bitbang;
+		goto out;
 	new_bus->name = "GPIO Bitbanged MDIO",
 	snprintf(new_bus->id, MII_BUS_ID_SIZE, "gpio-%x", bus_id);
-	if (gpio_request(bitbang->mdc, "mdc"))
+	if (devm_gpio_request(dev, bitbang->mdc, "mdc"))
+		goto out_free_bus;
+	if (devm_gpio_request(dev, bitbang->mdio, "mdio"))
 		goto out_free_bus;
-	if (gpio_request(bitbang->mdio, "mdio"))
+	if (bitbang->mdo) {
-		goto out_free_mdc;
+		if (devm_gpio_request(dev, bitbang->mdo, "mdo"))
+			goto out_free_bus;
+		gpio_direction_output(bitbang->mdo, 1);
+		gpio_direction_input(bitbang->mdio);
+	}
 	gpio_direction_output(bitbang->mdc, 0);
 	return new_bus;
-out_free_mdc:
-	gpio_free(bitbang->mdc);
 out_free_bus:
 	free_mdio_bitbang(new_bus);
-out_free_bitbang:
-	kfree(bitbang);
 out:
 	return NULL;
 }
 static void mdio_gpio_bus_deinit(struct device *dev)
 {
 	struct mii_bus *bus = dev_get_drvdata(dev);
-	struct mdio_gpio_info *bitbang = bus->priv;
-	dev_set_drvdata(dev, NULL);
-	gpio_free(bitbang->mdio);
-	gpio_free(bitbang->mdc);
 	free_mdio_bitbang(bus);
-	kfree(bitbang);
 }
 static void mdio_gpio_bus_destroy(struct device *dev)

drivers/net/wireless/cw1200/debug.c+2−0

@@ -41,6 +41,8 @@ static const char * const cw1200_debug_link_id[] = { · 40 unmodified lines
41	"REQ",	41	"REQ",
42	"SOFT",	42	"SOFT",
43	"HARD",	43	"HARD",
		44	"RESET",
		45	"RESET_REMAP",
44	};	46	};
45		47
46	static const char *cw1200_debug_mode(int mode)	48	static const char *cw1200_debug_mode(int mode)

drivers/net/wireless/iwlwifi/iwl-7000.c+3−2

 #include "iwl-agn-hw.h"
 /* Highest firmware API version supported */
-#define IWL7260_UCODE_API_MAX	8
+#define IWL7260_UCODE_API_MAX	9
-#define IWL3160_UCODE_API_MAX	8
+#define IWL3160_UCODE_API_MAX	9
 /* Oldest version we won't warn about */
 #define IWL7260_UCODE_API_OK	8
 MODULE_FIRMWARE(IWL7260_MODULE_FIRMWARE(IWL7260_UCODE_API_OK));
 MODULE_FIRMWARE(IWL3160_MODULE_FIRMWARE(IWL3160_UCODE_API_OK));
+MODULE_FIRMWARE(IWL7265_MODULE_FIRMWARE(IWL7260_UCODE_API_OK));

drivers/net/wireless/iwlwifi/mvm/coex.c+11−7

 		cpu_to_le32(0xcc00aaaa),
 		cpu_to_le32(0x0000aaaa),
 		cpu_to_le32(0xc0004000),
-		cpu_to_le32(0x00000000),
+		cpu_to_le32(0x00004000),
 		cpu_to_le32(0xf0005000),
 		cpu_to_le32(0xf0005000),
 	},
 		/* Tx Tx disabled */
 		cpu_to_le32(0xaaaaaaaa),
 		cpu_to_le32(0xaaaaaaaa),
-		cpu_to_le32(0xaaaaaaaa),
+		cpu_to_le32(0xeeaaaaaa),
 		cpu_to_le32(0xaaaaaaaa),
 		cpu_to_le32(0xcc00ff28),
 		cpu_to_le32(0x0000aaaa),
 		cpu_to_le32(0xcc00aaaa),
 		cpu_to_le32(0x0000aaaa),
-		cpu_to_le32(0xC0004000),
+		cpu_to_le32(0xc0004000),
-		cpu_to_le32(0xC0004000),
+		cpu_to_le32(0xc0004000),
-		cpu_to_le32(0xF0005000),
+		cpu_to_le32(0xf0005000),
-		cpu_to_le32(0xF0005000),
+		cpu_to_le32(0xf0005000),
 	},
 };
 	struct iwl_rx_packet *pkt = rxb_addr(rxb);
 	u32 ant_isolation = le32_to_cpup((void *)pkt->data);
 	u8 __maybe_unused lower_bound, upper_bound;
+	int ret;
 	u8 lut;
 	struct iwl_bt_coex_cmd *bt_cmd;
 	memcpy(bt_cmd->bt4_corun_lut40, antenna_coupling_ranges[lut].lut20,
 	       sizeof(bt_cmd->bt4_corun_lut40));
-	return 0;
+	ret = iwl_mvm_send_cmd(mvm, &cmd);
+	kfree(bt_cmd);
+	return ret;
 }

drivers/net/wireless/iwlwifi/mvm/mac80211.c+1−0

@@ -1332,6 +1332,7 @@ static void iwl_mvm_bss_info_changed_station(struct iwl_mvm *mvm, · 1331 unmodified lines
1332	*/	1332	*/
1333	iwl_mvm_remove_time_event(mvm, mvmvif,	1333	iwl_mvm_remove_time_event(mvm, mvmvif,
1334	&mvmvif->time_event_data);	1334	&mvmvif->time_event_data);
		1335	iwl_mvm_sf_update(mvm, vif, false);
1335	WARN_ON(iwl_mvm_enable_beacon_filter(mvm, vif, CMD_SYNC));	1336	WARN_ON(iwl_mvm_enable_beacon_filter(mvm, vif, CMD_SYNC));
1336	} else if (changes & (BSS_CHANGED_PS \| BSS_CHANGED_P2P_PS \|	1337	} else if (changes & (BSS_CHANGED_PS \| BSS_CHANGED_P2P_PS \|
1337	BSS_CHANGED_QOS)) {	1338	BSS_CHANGED_QOS)) {

drivers/net/wireless/iwlwifi/mvm/rs.c+165−96

@@ -59,7 +59,7 @@ · 58 unmodified lines
59	/* max allowed rate miss before sync LQ cmd */	59	/* max allowed rate miss before sync LQ cmd */
60	#define IWL_MISSED_RATE_MAX 15	60	#define IWL_MISSED_RATE_MAX 15
61	#define RS_STAY_IN_COLUMN_TIMEOUT (5*HZ)	61	#define RS_STAY_IN_COLUMN_TIMEOUT (5*HZ)
62		62	#define RS_IDLE_TIMEOUT (5*HZ)
63		63
64	static u8 rs_ht_to_legacy[] = {	64	static u8 rs_ht_to_legacy[] = {
65	[IWL_RATE_MCS_0_INDEX] = IWL_RATE_6M_INDEX,	65	[IWL_RATE_MCS_0_INDEX] = IWL_RATE_6M_INDEX,
@@ -142,7 +142,7 @@ enum rs_column_mode { · 76 unmodified lines
142	RS_MIMO2,	142	RS_MIMO2,
143	};	143	};
144		144
145	#define MAX_NEXT_COLUMNS 5	145	#define MAX_NEXT_COLUMNS 7
146	#define MAX_COLUMN_CHECKS 3	146	#define MAX_COLUMN_CHECKS 3
147		147
148	typedef bool (allow_column_func_t) (struct iwl_mvm mvm,	148	typedef bool (allow_column_func_t) (struct iwl_mvm mvm,
@@ -212,8 +212,10 @@ static const struct rs_tx_column rs_tx_columns[] = { · 63 unmodified lines
212	RS_COLUMN_LEGACY_ANT_B,	212	RS_COLUMN_LEGACY_ANT_B,
213	RS_COLUMN_SISO_ANT_A,	213	RS_COLUMN_SISO_ANT_A,
214	RS_COLUMN_SISO_ANT_B,	214	RS_COLUMN_SISO_ANT_B,
215	RS_COLUMN_MIMO2,	215	RS_COLUMN_INVALID,
216	RS_COLUMN_MIMO2_SGI,	216	RS_COLUMN_INVALID,
		217	RS_COLUMN_INVALID,
		218	RS_COLUMN_INVALID,
217	},	219	},
218	},	220	},
219	[RS_COLUMN_LEGACY_ANT_B] = {	221	[RS_COLUMN_LEGACY_ANT_B] = {
@@ -223,8 +225,10 @@ static const struct rs_tx_column rs_tx_columns[] = { · 3 unmodified lines
223	RS_COLUMN_LEGACY_ANT_A,	225	RS_COLUMN_LEGACY_ANT_A,
224	RS_COLUMN_SISO_ANT_A,	226	RS_COLUMN_SISO_ANT_A,
225	RS_COLUMN_SISO_ANT_B,	227	RS_COLUMN_SISO_ANT_B,
226	RS_COLUMN_MIMO2,	228	RS_COLUMN_INVALID,
227	RS_COLUMN_MIMO2_SGI,	229	RS_COLUMN_INVALID,
		230	RS_COLUMN_INVALID,
		231	RS_COLUMN_INVALID,
228	},	232	},
229	},	233	},
230	[RS_COLUMN_SISO_ANT_A] = {	234	[RS_COLUMN_SISO_ANT_A] = {
@@ -235,7 +239,9 @@ static const struct rs_tx_column rs_tx_columns[] = { · 4 unmodified lines
235	RS_COLUMN_MIMO2,	239	RS_COLUMN_MIMO2,
236	RS_COLUMN_SISO_ANT_A_SGI,	240	RS_COLUMN_SISO_ANT_A_SGI,
237	RS_COLUMN_SISO_ANT_B_SGI,	241	RS_COLUMN_SISO_ANT_B_SGI,
238	RS_COLUMN_MIMO2_SGI,	242	RS_COLUMN_LEGACY_ANT_A,
		243	RS_COLUMN_LEGACY_ANT_B,
		244	RS_COLUMN_INVALID,
239	},	245	},
240	.checks = {	246	.checks = {
241	rs_siso_allow,	247	rs_siso_allow,
@@ -249,7 +255,9 @@ static const struct rs_tx_column rs_tx_columns[] = { · 7 unmodified lines
249	RS_COLUMN_MIMO2,	255	RS_COLUMN_MIMO2,
250	RS_COLUMN_SISO_ANT_B_SGI,	256	RS_COLUMN_SISO_ANT_B_SGI,
251	RS_COLUMN_SISO_ANT_A_SGI,	257	RS_COLUMN_SISO_ANT_A_SGI,
252	RS_COLUMN_MIMO2_SGI,	258	RS_COLUMN_LEGACY_ANT_A,
		259	RS_COLUMN_LEGACY_ANT_B,
		260	RS_COLUMN_INVALID,
253	},	261	},
254	.checks = {	262	.checks = {
255	rs_siso_allow,	263	rs_siso_allow,
@@ -265,6 +273,8 @@ static const struct rs_tx_column rs_tx_columns[] = { · 9 unmodified lines
265	RS_COLUMN_SISO_ANT_A,	273	RS_COLUMN_SISO_ANT_A,
266	RS_COLUMN_SISO_ANT_B,	274	RS_COLUMN_SISO_ANT_B,
267	RS_COLUMN_MIMO2,	275	RS_COLUMN_MIMO2,
		276	RS_COLUMN_LEGACY_ANT_A,
		277	RS_COLUMN_LEGACY_ANT_B,
268	},	278	},
269	.checks = {	279	.checks = {
270	rs_siso_allow,	280	rs_siso_allow,
@@ -281,6 +291,8 @@ static const struct rs_tx_column rs_tx_columns[] = { · 10 unmodified lines
281	RS_COLUMN_SISO_ANT_B,	291	RS_COLUMN_SISO_ANT_B,
282	RS_COLUMN_SISO_ANT_A,	292	RS_COLUMN_SISO_ANT_A,
283	RS_COLUMN_MIMO2,	293	RS_COLUMN_MIMO2,
		294	RS_COLUMN_LEGACY_ANT_A,
		295	RS_COLUMN_LEGACY_ANT_B,
284	},	296	},
285	.checks = {	297	.checks = {
286	rs_siso_allow,	298	rs_siso_allow,
@@ -296,6 +308,8 @@ static const struct rs_tx_column rs_tx_columns[] = { · 9 unmodified lines
296	RS_COLUMN_SISO_ANT_A_SGI,	308	RS_COLUMN_SISO_ANT_A_SGI,
297	RS_COLUMN_SISO_ANT_B_SGI,	309	RS_COLUMN_SISO_ANT_B_SGI,
298	RS_COLUMN_MIMO2_SGI,	310	RS_COLUMN_MIMO2_SGI,
		311	RS_COLUMN_LEGACY_ANT_A,
		312	RS_COLUMN_LEGACY_ANT_B,
299	},	313	},
300	.checks = {	314	.checks = {
301	rs_mimo_allow,	315	rs_mimo_allow,
@@ -311,6 +325,8 @@ static const struct rs_tx_column rs_tx_columns[] = { · 9 unmodified lines
311	RS_COLUMN_SISO_ANT_A,	325	RS_COLUMN_SISO_ANT_A,
312	RS_COLUMN_SISO_ANT_B,	326	RS_COLUMN_SISO_ANT_B,
313	RS_COLUMN_MIMO2,	327	RS_COLUMN_MIMO2,
		328	RS_COLUMN_LEGACY_ANT_A,
		329	RS_COLUMN_LEGACY_ANT_B,
314	},	330	},
315	.checks = {	331	.checks = {
316	rs_mimo_allow,	332	rs_mimo_allow,
@@ -503,10 +519,12 @@ static void rs_rate_scale_clear_window(struct iwl_rate_scale_data *window) · 186 unmodified lines
503	window->average_tpt = IWL_INVALID_VALUE;	519	window->average_tpt = IWL_INVALID_VALUE;
504	}	520	}
505		521
506	static void rs_rate_scale_clear_tbl_windows(struct iwl_scale_tbl_info *tbl)	522	static void rs_rate_scale_clear_tbl_windows(struct iwl_mvm *mvm,
		523	struct iwl_scale_tbl_info *tbl)
507	{	524	{
508	int i;	525	int i;
509		526
		527	IWL_DEBUG_RATE(mvm, "Clearing up window stats\n");
510	for (i = 0; i < IWL_RATE_COUNT; i++)	528	for (i = 0; i < IWL_RATE_COUNT; i++)
511	rs_rate_scale_clear_window(&tbl->win[i]);	529	rs_rate_scale_clear_window(&tbl->win[i]);
512	}	530	}
@@ -992,6 +1010,13 @@ static void rs_tx_status(void mvm_r, struct ieee80211_supported_band sband, · 479 unmodified lines
992	return;	1010	return;
993	}	1011	}
994		1012
		1013	#ifdef CPTCFG_MAC80211_DEBUGFS
		1014	/* Disable last tx check if we are debugging with fixed rate */
		1015	if (lq_sta->dbg_fixed_rate) {
		1016	IWL_DEBUG_RATE(mvm, "Fixed rate. avoid rate scaling\n");
		1017	return;
		1018	}
		1019	#endif
995	if (!ieee80211_is_data(hdr->frame_control) \|\|	1020	if (!ieee80211_is_data(hdr->frame_control) \|\|
996	info->flags & IEEE80211_TX_CTL_NO_ACK)	1021	info->flags & IEEE80211_TX_CTL_NO_ACK)
997	return;	1022	return;
@@ -1034,6 +1059,18 @@ static void rs_tx_status(void mvm_r, struct ieee80211_supported_band sband, · 36 unmodified lines
1034	mac_index++;	1059	mac_index++;
1035	}	1060	}
1036		1061
		1062	if (time_after(jiffies,
		1063	(unsigned long)(lq_sta->last_tx + RS_IDLE_TIMEOUT))) {
		1064	int tid;
		1065	IWL_DEBUG_RATE(mvm, "Tx idle for too long. reinit rs\n");
		1066	for (tid = 0; tid < IWL_MAX_TID_COUNT; tid++)
		1067	ieee80211_stop_tx_ba_session(sta, tid);
		1068
		1069	iwl_mvm_rs_rate_init(mvm, sta, sband->band, false);
		1070	return;
		1071	}
		1072	lq_sta->last_tx = jiffies;
		1073
1037	/* Here we actually compare this rate to the latest LQ command */	1074	/* Here we actually compare this rate to the latest LQ command */
1038	if ((mac_index < 0) \|\|	1075	if ((mac_index < 0) \|\|
1039	(rate.sgi != !!(mac_flags & IEEE80211_TX_RC_SHORT_GI)) \|\|	1076	(rate.sgi != !!(mac_flags & IEEE80211_TX_RC_SHORT_GI)) \|\|
@@ -1186,9 +1223,26 @@ static void rs_set_stay_in_table(struct iwl_mvm *mvm, u8 is_legacy, · 146 unmodified lines
1186	lq_sta->visited_columns = 0;	1223	lq_sta->visited_columns = 0;
1187	}	1224	}
1188		1225
		1226	static int rs_get_max_allowed_rate(struct iwl_lq_sta *lq_sta,
		1227	const struct rs_tx_column *column)
		1228	{
		1229	switch (column->mode) {
		1230	case RS_LEGACY:
		1231	return lq_sta->max_legacy_rate_idx;
		1232	case RS_SISO:
		1233	return lq_sta->max_siso_rate_idx;
		1234	case RS_MIMO2:
		1235	return lq_sta->max_mimo2_rate_idx;
		1236	default:
		1237	WARN_ON_ONCE(1);
		1238	}
		1239
		1240	return lq_sta->max_legacy_rate_idx;
		1241	}
		1242
1189	static const u16 rs_get_expected_tpt_table(struct iwl_lq_sta lq_sta,	1243	static const u16 rs_get_expected_tpt_table(struct iwl_lq_sta lq_sta,
1190	const struct rs_tx_column *column,	1244	const struct rs_tx_column *column,
1191	u32 bw)	1245	u32 bw)
1192	{	1246	{
1193	/* Used to choose among HT tables */	1247	/* Used to choose among HT tables */
1194	const u16 (*ht_tbl_pointer)[IWL_RATE_COUNT];	1248	const u16 (*ht_tbl_pointer)[IWL_RATE_COUNT];
@@ -1438,7 +1492,7 @@ static void rs_stay_in_table(struct iwl_lq_sta *lq_sta, bool force_search) · 243 unmodified lines
1438		1492
1439	IWL_DEBUG_RATE(mvm,	1493	IWL_DEBUG_RATE(mvm,
1440	"LQ: stay in table clear win\n");	1494	"LQ: stay in table clear win\n");
1441	rs_rate_scale_clear_tbl_windows(tbl);	1495	rs_rate_scale_clear_tbl_windows(mvm, tbl);
1442	}	1496	}
1443	}	1497	}
1444		1498
@@ -1446,8 +1500,7 @@ static void rs_stay_in_table(struct iwl_lq_sta *lq_sta, bool force_search) · 1 unmodified line
1446	* bitmaps and stats in active table (this will become the new	1500	* bitmaps and stats in active table (this will become the new
1447	* "search" table). */	1501	* "search" table). */
1448	if (lq_sta->rs_state == RS_STATE_SEARCH_CYCLE_STARTED) {	1502	if (lq_sta->rs_state == RS_STATE_SEARCH_CYCLE_STARTED) {
1449	IWL_DEBUG_RATE(mvm, "Clearing up window stats\n");	1503	rs_rate_scale_clear_tbl_windows(mvm, tbl);
1450	rs_rate_scale_clear_tbl_windows(tbl);
1451	}	1504	}
1452	}	1505	}
1453	}	1506	}
@@ -1485,14 +1538,14 @@ static enum rs_column rs_get_next_column(struct iwl_mvm *mvm, · 31 unmodified lines
1485	struct ieee80211_sta *sta,	1538	struct ieee80211_sta *sta,
1486	struct iwl_scale_tbl_info *tbl)	1539	struct iwl_scale_tbl_info *tbl)
1487	{	1540	{
1488	int i, j, n;	1541	int i, j, max_rate;
1489	enum rs_column next_col_id;	1542	enum rs_column next_col_id;
1490	const struct rs_tx_column *curr_col = &rs_tx_columns[tbl->column];	1543	const struct rs_tx_column *curr_col = &rs_tx_columns[tbl->column];
1491	const struct rs_tx_column *next_col;	1544	const struct rs_tx_column *next_col;
1492	allow_column_func_t allow_func;	1545	allow_column_func_t allow_func;
1493	u8 valid_ants = mvm->fw->valid_tx_ant;	1546	u8 valid_ants = mvm->fw->valid_tx_ant;
1494	const u16 *expected_tpt_tbl;	1547	const u16 *expected_tpt_tbl;
1495	s32 tpt, max_expected_tpt;	1548	u16 tpt, max_expected_tpt;
1496		1549
1497	for (i = 0; i < MAX_NEXT_COLUMNS; i++) {	1550	for (i = 0; i < MAX_NEXT_COLUMNS; i++) {
1498	next_col_id = curr_col->next_columns[i];	1551	next_col_id = curr_col->next_columns[i];
@@ -1535,11 +1588,11 @@ static enum rs_column rs_get_next_column(struct iwl_mvm *mvm, · 36 unmodified lines
1535	if (WARN_ON_ONCE(!expected_tpt_tbl))	1588	if (WARN_ON_ONCE(!expected_tpt_tbl))
1536	continue;	1589	continue;
1537		1590
1538	max_expected_tpt = 0;	1591	max_rate = rs_get_max_allowed_rate(lq_sta, next_col);
1539	for (n = 0; n < IWL_RATE_COUNT; n++)	1592	if (WARN_ON_ONCE(max_rate == IWL_RATE_INVALID))
1540	if (expected_tpt_tbl[n] > max_expected_tpt)	1593	continue;
1541	max_expected_tpt = expected_tpt_tbl[n];
1542		1594
		1595	max_expected_tpt = expected_tpt_tbl[max_rate];
1543	if (tpt >= max_expected_tpt) {	1596	if (tpt >= max_expected_tpt) {
1544	IWL_DEBUG_RATE(mvm,	1597	IWL_DEBUG_RATE(mvm,
1545	"Skip column %d: can't beat current TPT. Max expected %d current %d\n",	1598	"Skip column %d: can't beat current TPT. Max expected %d current %d\n",
@@ -1547,14 +1600,15 @@ static enum rs_column rs_get_next_column(struct iwl_mvm *mvm, · 1 unmodified line
1547	continue;	1600	continue;
1548	}	1601	}
1549		1602
		1603	IWL_DEBUG_RATE(mvm,
		1604	"Found potential column %d. Max expected %d current %d\n",
		1605	next_col_id, max_expected_tpt, tpt);
1550	break;	1606	break;
1551	}	1607	}
1552		1608
1553	if (i == MAX_NEXT_COLUMNS)	1609	if (i == MAX_NEXT_COLUMNS)
1554	return RS_COLUMN_INVALID;	1610	return RS_COLUMN_INVALID;
1555		1611
1556	IWL_DEBUG_RATE(mvm, "Found potential column %d\n", next_col_id);
1557
1558	return next_col_id;	1612	return next_col_id;
1559	}	1613	}
1560		1614
@@ -1640,85 +1694,76 @@ static enum rs_action rs_get_rate_action(struct iwl_mvm *mvm, · 79 unmodified lines
1640	{	1694	{
1641	enum rs_action action = RS_ACTION_STAY;	1695	enum rs_action action = RS_ACTION_STAY;
1642		1696
1643	/* Too many failures, decrease rate */
1644	if ((sr <= RS_SR_FORCE_DECREASE) \|\| (current_tpt == 0)) {	1697	if ((sr <= RS_SR_FORCE_DECREASE) \|\| (current_tpt == 0)) {
1645	IWL_DEBUG_RATE(mvm,	1698	IWL_DEBUG_RATE(mvm,
1646	"decrease rate because of low SR\n");	1699	"Decrease rate because of low SR\n");
1647	action = RS_ACTION_DOWNSCALE;	1700	return RS_ACTION_DOWNSCALE;
1648	/* No throughput measured yet for adjacent rates; try increase. */
1649	} else if ((low_tpt == IWL_INVALID_VALUE) &&
1650	(high_tpt == IWL_INVALID_VALUE)) {
1651	if (high != IWL_RATE_INVALID && sr >= IWL_RATE_INCREASE_TH) {
1652	IWL_DEBUG_RATE(mvm,
1653	"Good SR and no high rate measurement. "
1654	"Increase rate\n");
1655	action = RS_ACTION_UPSCALE;
1656	} else if (low != IWL_RATE_INVALID) {
1657	IWL_DEBUG_RATE(mvm,
1658	"Remain in current rate\n");
1659	action = RS_ACTION_STAY;
1660	}
1661	}	1701	}
1662		1702
1663	/* Both adjacent throughputs are measured, but neither one has better	1703	if ((low_tpt == IWL_INVALID_VALUE) &&
1664	* throughput; we're using the best rate, don't change it!	1704	(high_tpt == IWL_INVALID_VALUE) &&
1665	*/	1705	(high != IWL_RATE_INVALID)) {
1666	else if ((low_tpt != IWL_INVALID_VALUE) &&
1667	(high_tpt != IWL_INVALID_VALUE) &&
1668	(low_tpt < current_tpt) &&
1669	(high_tpt < current_tpt)) {
1670	IWL_DEBUG_RATE(mvm,	1706	IWL_DEBUG_RATE(mvm,
1671	"Both high and low are worse. "	1707	"No data about high/low rates. Increase rate\n");
1672	"Maintain rate\n");	1708	return RS_ACTION_UPSCALE;
1673	action = RS_ACTION_STAY;
1674	}	1709	}
1675		1710
1676	/* At least one adjacent rate's throughput is measured,	1711	if ((high_tpt == IWL_INVALID_VALUE) &&
1677	* and may have better performance.	1712	(high != IWL_RATE_INVALID) &&
1678	*/	1713	(low_tpt != IWL_INVALID_VALUE) &&
1679	else {	1714	(low_tpt < current_tpt)) {
1680	/* Higher adjacent rate's throughput is measured */	1715	IWL_DEBUG_RATE(mvm,
1681	if (high_tpt != IWL_INVALID_VALUE) {	1716	"No data about high rate and low rate is worse. Increase rate\n");
1682	/* Higher rate has better throughput */	1717	return RS_ACTION_UPSCALE;
1683	if (high_tpt > current_tpt &&	1718	}
1684	sr >= IWL_RATE_INCREASE_TH) {
1685	IWL_DEBUG_RATE(mvm,
1686	"Higher rate is better and good "
1687	"SR. Increate rate\n");
1688	action = RS_ACTION_UPSCALE;
1689	} else {
1690	IWL_DEBUG_RATE(mvm,
1691	"Higher rate isn't better OR "
1692	"no good SR. Maintain rate\n");
1693	action = RS_ACTION_STAY;
1694	}
1695		1719
1696	/* Lower adjacent rate's throughput is measured */	1720	if ((high_tpt != IWL_INVALID_VALUE) &&
1697	} else if (low_tpt != IWL_INVALID_VALUE) {	1721	(high_tpt > current_tpt)) {
1698	/* Lower rate has better throughput */	1722	IWL_DEBUG_RATE(mvm,
1699	if (low_tpt > current_tpt) {	1723	"Higher rate is better. Increate rate\n");
1700	IWL_DEBUG_RATE(mvm,	1724	return RS_ACTION_UPSCALE;
1701	"Lower rate is better. "
1702	"Decrease rate\n");
1703	action = RS_ACTION_DOWNSCALE;
1704	} else if (sr >= IWL_RATE_INCREASE_TH) {
1705	IWL_DEBUG_RATE(mvm,
1706	"Lower rate isn't better and "
1707	"good SR. Increase rate\n");
1708	action = RS_ACTION_UPSCALE;
1709	}
1710	}
1711	}	1725	}
1712		1726
1713	/* Sanity check; asked for decrease, but success rate or throughput	1727	if ((low_tpt != IWL_INVALID_VALUE) &&
1714	* has been good at old rate. Don't change it.	1728	(high_tpt != IWL_INVALID_VALUE) &&
1715	*/	1729	(low_tpt < current_tpt) &&
1716	if ((action == RS_ACTION_DOWNSCALE) && (low != IWL_RATE_INVALID) &&	1730	(high_tpt < current_tpt)) {
1717	((sr > IWL_RATE_HIGH_TH) \|\|	1731	IWL_DEBUG_RATE(mvm,
1718	(current_tpt > (100 * tbl->expected_tpt[low])))) {	1732	"Both high and low are worse. Maintain rate\n");
		1733	return RS_ACTION_STAY;
		1734	}
		1735
		1736	if ((low_tpt != IWL_INVALID_VALUE) &&
		1737	(low_tpt > current_tpt)) {
		1738	IWL_DEBUG_RATE(mvm,
		1739	"Lower rate is better\n");
		1740	action = RS_ACTION_DOWNSCALE;
		1741	goto out;
		1742	}
		1743
		1744	if ((low_tpt == IWL_INVALID_VALUE) &&
		1745	(low != IWL_RATE_INVALID)) {
1719	IWL_DEBUG_RATE(mvm,	1746	IWL_DEBUG_RATE(mvm,
1720	"Sanity check failed. Maintain rate\n");	1747	"No data about lower rate\n");
1721	action = RS_ACTION_STAY;	1748	action = RS_ACTION_DOWNSCALE;
		1749	goto out;
		1750	}
		1751
		1752	IWL_DEBUG_RATE(mvm, "Maintain rate\n");
		1753
		1754	out:
		1755	if ((action == RS_ACTION_DOWNSCALE) && (low != IWL_RATE_INVALID)) {
		1756	if (sr >= RS_SR_NO_DECREASE) {
		1757	IWL_DEBUG_RATE(mvm,
		1758	"SR is above NO DECREASE. Avoid downscale\n");
		1759	action = RS_ACTION_STAY;
		1760	} else if (current_tpt > (100 * tbl->expected_tpt[low])) {
		1761	IWL_DEBUG_RATE(mvm,
		1762	"Current TPT is higher than max expected in low rate. Avoid downscale\n");
		1763	action = RS_ACTION_STAY;
		1764	} else {
		1765	IWL_DEBUG_RATE(mvm, "Decrease rate\n");
		1766	}
1722	}	1767	}
1723		1768
1724	return action;	1769	return action;
@@ -1792,6 +1837,7 @@ static void rs_rate_scale_perform(struct iwl_mvm *mvm, · 67 unmodified lines
1792	"Aggregation changed: prev %d current %d. Update expected TPT table\n",	1837	"Aggregation changed: prev %d current %d. Update expected TPT table\n",
1793	prev_agg, lq_sta->is_agg);	1838	prev_agg, lq_sta->is_agg);
1794	rs_set_expected_tpt_table(lq_sta, tbl);	1839	rs_set_expected_tpt_table(lq_sta, tbl);
		1840	rs_rate_scale_clear_tbl_windows(mvm, tbl);
1795	}	1841	}
1796		1842
1797	/* current tx rate */	1843	/* current tx rate */
@@ -2021,7 +2067,7 @@ lq_update: · 223 unmodified lines
2021	if (lq_sta->search_better_tbl) {	2067	if (lq_sta->search_better_tbl) {
2022	/* Access the "search" table, clear its history. */	2068	/* Access the "search" table, clear its history. */
2023	tbl = &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);	2069	tbl = &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
2024	rs_rate_scale_clear_tbl_windows(tbl);	2070	rs_rate_scale_clear_tbl_windows(mvm, tbl);
2025		2071
2026	/* Use new "search" start rate */	2072	/* Use new "search" start rate */
2027	index = tbl->rate.index;	2073	index = tbl->rate.index;
@@ -2042,8 +2088,18 @@ lq_update: · 14 unmodified lines
2042	* stay with best antenna legacy modulation for a while	2088	* stay with best antenna legacy modulation for a while
2043	* before next round of mode comparisons. */	2089	* before next round of mode comparisons. */
2044	tbl1 = &(lq_sta->lq_info[lq_sta->active_tbl]);	2090	tbl1 = &(lq_sta->lq_info[lq_sta->active_tbl]);
2045	if (is_legacy(&tbl1->rate) && !sta->ht_cap.ht_supported) {	2091	if (is_legacy(&tbl1->rate)) {
2046	IWL_DEBUG_RATE(mvm, "LQ: STAY in legacy table\n");	2092	IWL_DEBUG_RATE(mvm, "LQ: STAY in legacy table\n");
		2093
		2094	if (tid != IWL_MAX_TID_COUNT) {
		2095	tid_data = &sta_priv->tid_data[tid];
		2096	if (tid_data->state != IWL_AGG_OFF) {
		2097	IWL_DEBUG_RATE(mvm,
		2098	"Stop aggregation on tid %d\n",
		2099	tid);
		2100	ieee80211_stop_tx_ba_session(sta, tid);
		2101	}
		2102	}
2047	rs_set_stay_in_table(mvm, 1, lq_sta);	2103	rs_set_stay_in_table(mvm, 1, lq_sta);
2048	} else {	2104	} else {
2049	/* If we're in an HT mode, and all 3 mode switch actions	2105	/* If we're in an HT mode, and all 3 mode switch actions
@@ -2342,9 +2398,10 @@ void iwl_mvm_rs_rate_init(struct iwl_mvm mvm, struct ieee80211_sta sta, · 292 unmodified lines
2342	lq_sta->lq.sta_id = sta_priv->sta_id;	2398	lq_sta->lq.sta_id = sta_priv->sta_id;
2343		2399
2344	for (j = 0; j < LQ_SIZE; j++)	2400	for (j = 0; j < LQ_SIZE; j++)
2345	rs_rate_scale_clear_tbl_windows(&lq_sta->lq_info[j]);	2401	rs_rate_scale_clear_tbl_windows(mvm, &lq_sta->lq_info[j]);
2346		2402
2347	lq_sta->flush_timer = 0;	2403	lq_sta->flush_timer = 0;
		2404	lq_sta->last_tx = jiffies;
2348		2405
2349	IWL_DEBUG_RATE(mvm,	2406	IWL_DEBUG_RATE(mvm,
2350	"LQ: * rate scale station global init for station %d *\n",	2407	"LQ: * rate scale station global init for station %d *\n",
@@ -2388,11 +2445,22 @@ void iwl_mvm_rs_rate_init(struct iwl_mvm mvm, struct ieee80211_sta sta, · 37 unmodified lines
2388	lq_sta->is_vht = true;	2445	lq_sta->is_vht = true;
2389	}	2446	}
2390		2447
2391	IWL_DEBUG_RATE(mvm,	2448	lq_sta->max_legacy_rate_idx = find_last_bit(&lq_sta->active_legacy_rate,
2392	"SISO-RATE=%X MIMO2-RATE=%X VHT=%d\n",	2449	BITS_PER_LONG);
		2450	lq_sta->max_siso_rate_idx = find_last_bit(&lq_sta->active_siso_rate,
		2451	BITS_PER_LONG);
		2452	lq_sta->max_mimo2_rate_idx = find_last_bit(&lq_sta->active_mimo2_rate,
		2453	BITS_PER_LONG);
		2454
		2455	IWL_DEBUG_RATE(mvm, "RATE MASK: LEGACY=%lX SISO=%lX MIMO2=%lX VHT=%d\n",
		2456	lq_sta->active_legacy_rate,
2393	lq_sta->active_siso_rate,	2457	lq_sta->active_siso_rate,
2394	lq_sta->active_mimo2_rate,	2458	lq_sta->active_mimo2_rate,
2395	lq_sta->is_vht);	2459	lq_sta->is_vht);
		2460	IWL_DEBUG_RATE(mvm, "MAX RATE: LEGACY=%d SISO=%d MIMO2=%d\n",
		2461	lq_sta->max_legacy_rate_idx,
		2462	lq_sta->max_siso_rate_idx,
		2463	lq_sta->max_mimo2_rate_idx);
2396		2464
2397	/* These values will be overridden later */	2465	/* These values will be overridden later */
2398	lq_sta->lq.single_stream_ant_msk =	2466	lq_sta->lq.single_stream_ant_msk =
@@ -2547,6 +2615,7 @@ static void rs_build_rates_table(struct iwl_mvm *mvm, · 148 unmodified lines
2547	if (is_siso(&rate)) {	2615	if (is_siso(&rate)) {
2548	num_rates = RS_SECONDARY_SISO_NUM_RATES;	2616	num_rates = RS_SECONDARY_SISO_NUM_RATES;
2549	num_retries = RS_SECONDARY_SISO_RETRIES;	2617	num_retries = RS_SECONDARY_SISO_RETRIES;
		2618	lq_cmd->mimo_delim = index;
2550	} else if (is_legacy(&rate)) {	2619	} else if (is_legacy(&rate)) {
2551	num_rates = RS_SECONDARY_LEGACY_NUM_RATES;	2620	num_rates = RS_SECONDARY_LEGACY_NUM_RATES;
2552	num_retries = RS_LEGACY_RETRIES_PER_RATE;	2621	num_retries = RS_LEGACY_RETRIES_PER_RATE;
@@ -2749,7 +2818,7 @@ static ssize_t rs_sta_dbgfs_scale_table_read(struct file *file, · 196 unmodified lines
2749	return -ENOMEM;	2818	return -ENOMEM;
2750		2819
2751	desc += sprintf(buff+desc, "sta_id %d\n", lq_sta->lq.sta_id);	2820	desc += sprintf(buff+desc, "sta_id %d\n", lq_sta->lq.sta_id);
2752	desc += sprintf(buff+desc, "failed=%d success=%d rate=0%X\n",	2821	desc += sprintf(buff+desc, "failed=%d success=%d rate=0%lX\n",
2753	lq_sta->total_failed, lq_sta->total_success,	2822	lq_sta->total_failed, lq_sta->total_success,
2754	lq_sta->active_legacy_rate);	2823	lq_sta->active_legacy_rate);
2755	desc += sprintf(buff+desc, "fixed rate 0x%X\n",	2824	desc += sprintf(buff+desc, "fixed rate 0x%X\n",

drivers/net/wireless/iwlwifi/mvm/rs.h+11−3

 #define IWL_RATE_HIGH_TH		10880	/*  85% */
 #define IWL_RATE_INCREASE_TH		6400	/*  50% */
 #define RS_SR_FORCE_DECREASE		1920	/*  15% */
+#define RS_SR_NO_DECREASE		10880	/*  85% */
 #define LINK_QUAL_AGG_TIME_LIMIT_DEF	(4000) /* 4 milliseconds */
 #define LINK_QUAL_AGG_TIME_LIMIT_MAX	(8000)
 	u32 visited_columns;    /* Bitmask marking which Tx columns were
 				 * explored during a search cycle
 				 */
+	u64 last_tx;
 	bool is_vht;
 	enum ieee80211_band band;
 	/* The following are bitmaps of rates; IWL_RATE_6M_MASK, etc. */
-	u16 active_legacy_rate;
+	unsigned long active_legacy_rate;
-	u16 active_siso_rate;
+	unsigned long active_siso_rate;
-	u16 active_mimo2_rate;
+	unsigned long active_mimo2_rate;
+	/* Highest rate per Tx mode */
+	u8 max_legacy_rate_idx;
+	u8 max_siso_rate_idx;
+	u8 max_mimo2_rate_idx;
 	s8 max_rate_idx;     /* Max rate set by user */
 	u8 missed_rate_counter;

drivers/net/wireless/iwlwifi/mvm/sf.c+2−1

 				return -EINVAL;
 			if (changed_vif->type != NL80211_IFTYPE_STATION) {
 				new_state = SF_UNINIT;
-			} else if (changed_vif->bss_conf.assoc) {
+			} else if (changed_vif->bss_conf.assoc &&
+				   changed_vif->bss_conf.dtim_period) {
 				mvmvif = iwl_mvm_vif_from_mac80211(changed_vif);
 				sta_id = mvmvif->ap_sta_id;
 				new_state = SF_FULL_ON;

drivers/net/wireless/iwlwifi/pcie/drv.c+2−0

 	{IWL_PCI_DEVICE(0x095A, 0x500A, iwl7265_2n_cfg)},
 	{IWL_PCI_DEVICE(0x095B, 0x5200, iwl7265_2n_cfg)},
 	{IWL_PCI_DEVICE(0x095A, 0x5002, iwl7265_n_cfg)},
+	{IWL_PCI_DEVICE(0x095A, 0x5102, iwl7265_n_cfg)},
 	{IWL_PCI_DEVICE(0x095B, 0x5202, iwl7265_n_cfg)},
 	{IWL_PCI_DEVICE(0x095A, 0x9010, iwl7265_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x095A, 0x9012, iwl7265_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x095A, 0x9110, iwl7265_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x095A, 0x9112, iwl7265_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x095A, 0x9210, iwl7265_2ac_cfg)},
+	{IWL_PCI_DEVICE(0x095A, 0x9200, iwl7265_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x095A, 0x9510, iwl7265_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x095A, 0x9310, iwl7265_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x095A, 0x9410, iwl7265_2ac_cfg)},

drivers/net/wireless/mwifiex/main.c+6−6

 			while ((skb = skb_dequeue(&adapter->usb_rx_data_q)))
 				mwifiex_handle_rx_packet(adapter, skb);
+		/* Check for event */
+		if (adapter->event_received) {
+			adapter->event_received = false;
+			mwifiex_process_event(adapter);
+		}
 		/* Check for Cmd Resp */
 		if (adapter->cmd_resp_received) {
 			adapter->cmd_resp_received = false;
 			}
 		}
-		/* Check for event */
-		if (adapter->event_received) {
-			adapter->event_received = false;
-			mwifiex_process_event(adapter);
-		}
 		/* Check if we need to confirm Sleep Request
 		   received previously */
 		if (adapter->ps_state == PS_STATE_PRE_SLEEP) {

drivers/net/wireless/mwifiex/sta_ioctl.c+4−3

 	int status;
 	/* Wait for completion */
-	status = wait_event_interruptible(adapter->cmd_wait_q.wait,
+	status = wait_event_interruptible_timeout(adapter->cmd_wait_q.wait,
-					  *(cmd_queued->condition));
+						  *(cmd_queued->condition),
-	if (status) {
+						  (12 * HZ));
+	if (status <= 0) {
 		dev_err(adapter->dev, "cmd_wait_q terminated: %d\n", status);
 		mwifiex_cancel_all_pending_cmd(adapter);
 		return status;

drivers/net/wireless/rsi/rsi_91x_core.c+1−1

@@ -88,7 +88,7 @@ static u8 rsi_core_determine_hal_queue(struct rsi_common *common) · 87 unmodified lines
88	bool recontend_queue = false;	88	bool recontend_queue = false;
89	u32 q_len = 0;	89	u32 q_len = 0;
90	u8 q_num = INVALID_QUEUE;	90	u8 q_num = INVALID_QUEUE;
91	u8 ii, min = 0;	91	u8 ii = 0, min = 0;
92		92
93	if (skb_queue_len(&common->tx_queue[MGMT_SOFT_Q])) {	93	if (skb_queue_len(&common->tx_queue[MGMT_SOFT_Q])) {
94	if (!common->mgmt_q_block)	94	if (!common->mgmt_q_block)

drivers/net/wireless/rsi/rsi_91x_mgmt.c+11−10

 	rsi_dbg(MGMT_TX_ZONE,
 		"%s: Sending scan req frame\n", __func__);
-	skb = dev_alloc_skb(FRAME_DESC_SZ);
-	if (!skb) {
-		rsi_dbg(ERR_ZONE, "%s: Failed in allocation of skb\n",
-			__func__);
-		return -ENOMEM;
-	}
-	memset(skb->data, 0, FRAME_DESC_SZ);
-	mgmt_frame = (struct rsi_mac_frame *)skb->data;
 	if (common->band == IEEE80211_BAND_5GHZ) {
 		if ((channel >= 36) && (channel <= 64))
 			channel = ((channel - 32) / 4);
 		}
 	}
+	skb = dev_alloc_skb(FRAME_DESC_SZ);
+	if (!skb) {
+		rsi_dbg(ERR_ZONE, "%s: Failed in allocation of skb\n",
+			__func__);
+		return -ENOMEM;
+	}
+	memset(skb->data, 0, FRAME_DESC_SZ);
+	mgmt_frame = (struct rsi_mac_frame *)skb->data;
 	mgmt_frame->desc_word[0] = cpu_to_le16(RSI_WIFI_MGMT_Q << 12);
 	mgmt_frame->desc_word[1] = cpu_to_le16(SCAN_REQUEST);
 	mgmt_frame->desc_word[4] = cpu_to_le16(channel);
 	if (!selected_rates) {
 		rsi_dbg(ERR_ZONE, "%s: Failed in allocation of mem\n",
 			__func__);
+		dev_kfree_skb(skb);
 		return -ENOMEM;
 	}

drivers/net/wireless/ti/wl18xx/event.h+20−0

@@ -68,6 +68,26 @@ struct wl18xx_event_mailbox { · 67 unmodified lines
68		68
69	/* bitmap of inactive stations (by HLID) */	69	/* bitmap of inactive stations (by HLID) */
70	__le32 inactive_sta_bitmap;	70	__le32 inactive_sta_bitmap;
		71
		72	/* rx BA win size indicated by RX_BA_WIN_SIZE_CHANGE_EVENT_ID */
		73	u8 rx_ba_role_id;
		74	u8 rx_ba_link_id;
		75	u8 rx_ba_win_size;
		76	u8 padding;
		77
		78	/* smart config */
		79	u8 sc_ssid_len;
		80	u8 sc_pwd_len;
		81	u8 sc_token_len;
		82	u8 padding1;
		83	u8 sc_ssid[32];
		84	u8 sc_pwd[32];
		85	u8 sc_token[32];
		86
		87	/* smart config sync channel */
		88	u8 sc_sync_channel;
		89	u8 sc_sync_band;
		90	u8 padding2[2];
71	} __packed;	91	} __packed;
72		92
73	int wl18xx_wait_for_event(struct wl1271 *wl, enum wlcore_wait_event event,	93	int wl18xx_wait_for_event(struct wl1271 *wl, enum wlcore_wait_event event,

drivers/net/wireless/ti/wlcore/event.c+5−0

 void wlcore_event_dummy_packet(struct wl1271 *wl)
 {
+	if (wl->plt) {
+		wl1271_info("Got DUMMY_PACKET event in PLT mode.  FW bug, ignoring.");
+		return;
+	}
 	wl1271_debug(DEBUG_EVENT, "DUMMY_PACKET_ID_EVENT_ID");
 	wl1271_tx_dummy_packet(wl);
 }

include/linux/mdio-gpio.h+5−0

 	/* GPIO numbers for bus pins */
 	unsigned int mdc;
 	unsigned int mdio;
+	unsigned int mdo;
+	bool mdc_active_low;
+	bool mdio_active_low;
+	bool mdo_active_low;
 	unsigned int phy_mask;
 	int irqs[PHY_MAX_ADDR];

include/linux/phy.h+3−0

 	PHY_INTERFACE_MODE_SMII,
 	PHY_INTERFACE_MODE_XGMII,
 	PHY_INTERFACE_MODE_MOCA,
+	PHY_INTERFACE_MODE_QSGMII,
 	PHY_INTERFACE_MODE_MAX,
 } phy_interface_t;
 		return "xgmii";
 	case PHY_INTERFACE_MODE_MOCA:
 		return "moca";
+	case PHY_INTERFACE_MODE_QSGMII:
+		return "qsgmii";
 	default:
 		return "unknown";
 	}

include/net/flow.h+9−1

 #include <linux/in6.h>
 #include <linux/atomic.h>
+/*
+ * ifindex generation is per-net namespace, and loopback is
+ * always the 1st device in ns (see net_dev_init), thus any
+ * loopback device should get ifindex 1
+ */
+#define LOOPBACK_IFINDEX	1
 struct flowi_common {
 	int	flowic_oif;
 	int	flowic_iif;
 				      __be16 dport, __be16 sport)
 {
 	fl4->flowi4_oif = oif;
-	fl4->flowi4_iif = 0;
+	fl4->flowi4_iif = LOOPBACK_IFINDEX;
 	fl4->flowi4_mark = mark;
 	fl4->flowi4_tos = tos;
 	fl4->flowi4_scope = scope;

include/net/net_namespace.h+1−8

 #include <linux/list.h>
 #include <linux/sysctl.h>
+#include <net/flow.h>
 #include <net/netns/core.h>
 #include <net/netns/mib.h>
 #include <net/netns/unix.h>
 	atomic_t		fnhe_genid;
 };
-/*
- * ifindex generation is per-net namespace, and loopback is
- * always the 1st device in ns (see net_dev_init), thus any
- * loopback device should get ifindex 1
- */
-#define LOOPBACK_IFINDEX	1
 #include <linux/seq_file_net.h>
 /* Init's network namespace */

include/net/sctp/structs.h+3−1

 	/* SCTP-AUTH: endpoint shared keys */
 	struct list_head endpoint_shared_keys;
 	__u16 active_key_id;
+	__u8  auth_enable;
 };
 /* Recover the outter endpoint structure. */
 int sctp_has_association(struct net *net, const union sctp_addr *laddr,
 			 const union sctp_addr *paddr);
-int sctp_verify_init(struct net *net, const struct sctp_association *asoc,
+int sctp_verify_init(struct net *net, const struct sctp_endpoint *ep,
+		     const struct sctp_association *asoc,
 		     sctp_cid_t, sctp_init_chunk_t *peer_init,
 		     struct sctp_chunk *chunk, struct sctp_chunk **err_chunk);
 int sctp_process_init(struct sctp_association *, struct sctp_chunk *chunk,

kernel/seccomp.c+2−0

 		goto free_prog;
 	/* Allocate a new seccomp_filter */
+	ret = -ENOMEM;
 	filter = kzalloc(sizeof(struct seccomp_filter) +
 			 sizeof(struct sock_filter_int) * new_len,
 			 GFP_KERNEL|__GFP_NOWARN);
 	ret = sk_convert_filter(fp, fprog->len, filter->insnsi, &new_len);
 	if (ret)
 		goto free_filter;
+	kfree(fp);
 	atomic_set(&filter->usage, 1);
 	filter->len = new_len;

net/8021q/vlan_dev.c+41−5

@@ -493,10 +493,48 @@ static void vlan_dev_change_rx_flags(struct net_device *dev, int change) · 492 unmodified lines
493	}	493	}
494	}	494	}
495		495
		496	static int vlan_calculate_locking_subclass(struct net_device *real_dev)
		497	{
		498	int subclass = 0;
		499
		500	while (is_vlan_dev(real_dev)) {
		501	subclass++;
		502	real_dev = vlan_dev_priv(real_dev)->real_dev;
		503	}
		504
		505	return subclass;
		506	}
		507
		508	static void vlan_dev_mc_sync(struct net_device to, struct net_device from)
		509	{
		510	int err = 0, subclass;
		511
		512	subclass = vlan_calculate_locking_subclass(to);
		513
		514	spin_lock_nested(&to->addr_list_lock, subclass);
		515	err = __hw_addr_sync(&to->mc, &from->mc, to->addr_len);
		516	if (!err)
		517	__dev_set_rx_mode(to);
		518	spin_unlock(&to->addr_list_lock);
		519	}
		520
		521	static void vlan_dev_uc_sync(struct net_device to, struct net_device from)
		522	{
		523	int err = 0, subclass;
		524
		525	subclass = vlan_calculate_locking_subclass(to);
		526
		527	spin_lock_nested(&to->addr_list_lock, subclass);
		528	err = __hw_addr_sync(&to->uc, &from->uc, to->addr_len);
		529	if (!err)
		530	__dev_set_rx_mode(to);
		531	spin_unlock(&to->addr_list_lock);
		532	}
		533
496	static void vlan_dev_set_rx_mode(struct net_device *vlan_dev)	534	static void vlan_dev_set_rx_mode(struct net_device *vlan_dev)
497	{	535	{
498	dev_mc_sync(vlan_dev_priv(vlan_dev)->real_dev, vlan_dev);	536	vlan_dev_mc_sync(vlan_dev_priv(vlan_dev)->real_dev, vlan_dev);
499	dev_uc_sync(vlan_dev_priv(vlan_dev)->real_dev, vlan_dev);	537	vlan_dev_uc_sync(vlan_dev_priv(vlan_dev)->real_dev, vlan_dev);
500	}	538	}
501		539
502	/*	540	/*
@@ -608,9 +646,7 @@ static int vlan_dev_init(struct net_device *dev) · 105 unmodified lines
608		646
609	SET_NETDEV_DEVTYPE(dev, &vlan_type);	647	SET_NETDEV_DEVTYPE(dev, &vlan_type);
610		648
611	if (is_vlan_dev(real_dev))	649	subclass = vlan_calculate_locking_subclass(dev);
612	subclass = 1;
613
614	vlan_dev_set_lockdep_class(dev, subclass);	650	vlan_dev_set_lockdep_class(dev, subclass);
615		651
616	vlan_dev_priv(dev)->vlan_pcpu_stats = netdev_alloc_pcpu_stats(struct vlan_pcpu_stats);	652	vlan_dev_priv(dev)->vlan_pcpu_stats = netdev_alloc_pcpu_stats(struct vlan_pcpu_stats);

net/core/dev.c+1−0

@@ -5238,6 +5238,7 @@ void __dev_set_rx_mode(struct net_device *dev) · 5237 unmodified lines
5238	if (ops->ndo_set_rx_mode)	5238	if (ops->ndo_set_rx_mode)
5239	ops->ndo_set_rx_mode(dev);	5239	ops->ndo_set_rx_mode(dev);
5240	}	5240	}
		5241	EXPORT_SYMBOL(__dev_set_rx_mode);
5241		5242
5242	void dev_set_rx_mode(struct net_device *dev)	5243	void dev_set_rx_mode(struct net_device *dev)
5243	{	5244	{

net/ipv4/fib_frontend.c+1−1

@@ -250,7 +250,7 @@ static int __fib_validate_source(struct sk_buff *skb, __be32 src, __be32 dst, · 249 unmodified lines
250	bool dev_match;	250	bool dev_match;
251		251
252	fl4.flowi4_oif = 0;	252	fl4.flowi4_oif = 0;
253	fl4.flowi4_iif = oif;	253	fl4.flowi4_iif = oif ? : LOOPBACK_IFINDEX;
254	fl4.daddr = src;	254	fl4.daddr = src;
255	fl4.saddr = dst;	255	fl4.saddr = dst;
256	fl4.flowi4_tos = tos;	256	fl4.flowi4_tos = tos;

net/ipv4/fib_semantics.c+1−0

@@ -631,6 +631,7 @@ static int fib_check_nh(struct fib_config cfg, struct fib_info fi, · 630 unmodified lines
631	.daddr = nh->nh_gw,	631	.daddr = nh->nh_gw,
632	.flowi4_scope = cfg->fc_scope + 1,	632	.flowi4_scope = cfg->fc_scope + 1,
633	.flowi4_oif = nh->nh_oif,	633	.flowi4_oif = nh->nh_oif,
		634	.flowi4_iif = LOOPBACK_IFINDEX,
634	};	635	};
635		636
636	/* It is not necessary, but requires a bit of thinking */	637	/* It is not necessary, but requires a bit of thinking */

net/ipv4/ip_tunnel.c+7−8

 int ip_tunnel_ioctl(struct net_device *dev, struct ip_tunnel_parm *p, int cmd)
 {
 	int err = 0;
-	struct ip_tunnel *t;
+	struct ip_tunnel *t = netdev_priv(dev);
-	struct net *net = dev_net(dev);
+	struct net *net = t->net;
-	struct ip_tunnel *tunnel = netdev_priv(dev);
+	struct ip_tunnel_net *itn = net_generic(net, t->ip_tnl_net_id);
-	struct ip_tunnel_net *itn = net_generic(net, tunnel->ip_tnl_net_id);
 	BUG_ON(!itn->fb_tunnel_dev);
 	switch (cmd) {
 	case SIOCGETTUNNEL:
-		t = NULL;
+		if (dev == itn->fb_tunnel_dev) {
-		if (dev == itn->fb_tunnel_dev)
 			t = ip_tunnel_find(itn, p, itn->fb_tunnel_dev->type);
-		if (t == NULL)
+			if (t == NULL)
-			t = netdev_priv(dev);
+				t = netdev_priv(dev);
+		}
 		memcpy(p, &t->parms, sizeof(*p));
 		break;

net/ipv4/ipmr.c+1−1

@@ -455,7 +455,7 @@ static netdev_tx_t reg_vif_xmit(struct sk_buff skb, struct net_device dev) · 454 unmodified lines
455	struct mr_table *mrt;	455	struct mr_table *mrt;
456	struct flowi4 fl4 = {	456	struct flowi4 fl4 = {
457	.flowi4_oif = dev->ifindex,	457	.flowi4_oif = dev->ifindex,
458	.flowi4_iif = skb->skb_iif,	458	.flowi4_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
459	.flowi4_mark = skb->mark,	459	.flowi4_mark = skb->mark,
460	};	460	};
461	int err;	461	int err;

net/ipv4/netfilter/ipt_rpfilter.c+1−4

@@ -89,11 +89,8 @@ static bool rpfilter_mt(const struct sk_buff skb, struct xt_action_param par) · 88 unmodified lines
89	if (ipv4_is_multicast(iph->daddr)) {	89	if (ipv4_is_multicast(iph->daddr)) {
90	if (ipv4_is_zeronet(iph->saddr))	90	if (ipv4_is_zeronet(iph->saddr))
91	return ipv4_is_local_multicast(iph->daddr) ^ invert;	91	return ipv4_is_local_multicast(iph->daddr) ^ invert;
92	flow.flowi4_iif = 0;
93	} else {
94	flow.flowi4_iif = LOOPBACK_IFINDEX;
95	}	92	}
96		93	flow.flowi4_iif = LOOPBACK_IFINDEX;
97	flow.daddr = iph->saddr;	94	flow.daddr = iph->saddr;
98	flow.saddr = rpfilter_get_saddr(iph->daddr);	95	flow.saddr = rpfilter_get_saddr(iph->daddr);
99	flow.flowi4_oif = 0;	96	flow.flowi4_oif = 0;

net/ipv4/route.c+1−2

@@ -1700,8 +1700,7 @@ static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr, · 1699 unmodified lines
1700		1700
1701	if (res.type == RTN_LOCAL) {	1701	if (res.type == RTN_LOCAL) {
1702	err = fib_validate_source(skb, saddr, daddr, tos,	1702	err = fib_validate_source(skb, saddr, daddr, tos,
1703	LOOPBACK_IFINDEX,	1703	0, dev, in_dev, &itag);
1704	dev, in_dev, &itag);
1705	if (err < 0)	1704	if (err < 0)
1706	goto martian_source_keep_err;	1705	goto martian_source_keep_err;
1707	goto local_input;	1706	goto local_input;

net/ipv6/ip6_tunnel.c+4−4

 	int err = 0;
 	struct ip6_tnl_parm p;
 	struct __ip6_tnl_parm p1;
-	struct ip6_tnl *t = NULL;
+	struct ip6_tnl *t = netdev_priv(dev);
-	struct net *net = dev_net(dev);
+	struct net *net = t->net;
 	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
 	switch (cmd) {
 			}
 			ip6_tnl_parm_from_user(&p1, &p);
 			t = ip6_tnl_locate(net, &p1, 0);
+			if (t == NULL)
+				t = netdev_priv(dev);
 		} else {
 			memset(&p, 0, sizeof(p));
 		}
-		if (t == NULL)
-			t = netdev_priv(dev);
 		ip6_tnl_parm_to_user(&p, &t->parms);
 		if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof (p))) {
 			err = -EFAULT;

net/ipv6/ip6mr.c+1−1

@@ -700,7 +700,7 @@ static netdev_tx_t reg_vif_xmit(struct sk_buff *skb, · 699 unmodified lines
700	struct mr6_table *mrt;	700	struct mr6_table *mrt;
701	struct flowi6 fl6 = {	701	struct flowi6 fl6 = {
702	.flowi6_oif = dev->ifindex,	702	.flowi6_oif = dev->ifindex,
703	.flowi6_iif = skb->skb_iif,	703	.flowi6_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
704	.flowi6_mark = skb->mark,	704	.flowi6_mark = skb->mark,
705	};	705	};
706	int err;	706	int err;

net/ipv6/sit.c+4−13

 	int err = 0;
 	struct ip_tunnel_parm p;
 	struct ip_tunnel_prl prl;
-	struct ip_tunnel *t;
+	struct ip_tunnel *t = netdev_priv(dev);
-	struct net *net = dev_net(dev);
+	struct net *net = t->net;
 	struct sit_net *sitn = net_generic(net, sit_net_id);
 #ifdef CONFIG_IPV6_SIT_6RD
 	struct ip_tunnel_6rd ip6rd;
 #ifdef CONFIG_IPV6_SIT_6RD
 	case SIOCGET6RD:
 #endif
-		t = NULL;
 		if (dev == sitn->fb_tunnel_dev) {
 			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
 				err = -EFAULT;
 				break;
 			}
 			t = ipip6_tunnel_locate(net, &p, 0);
+			if (t == NULL)
+				t = netdev_priv(dev);
 		}
-		if (t == NULL)
-			t = netdev_priv(dev);
 		err = -EFAULT;
 		if (cmd == SIOCGETTUNNEL) {
 		err = -EINVAL;
 		if (dev == sitn->fb_tunnel_dev)
 			goto done;
-		err = -ENOENT;
-		if (!(t = netdev_priv(dev)))
-			goto done;
 		err = ipip6_tunnel_get_prl(t, ifr->ifr_ifru.ifru_data);
 		break;
 		err = -EFAULT;
 		if (copy_from_user(&prl, ifr->ifr_ifru.ifru_data, sizeof(prl)))
 			goto done;
-		err = -ENOENT;
-		if (!(t = netdev_priv(dev)))
-			goto done;
 		switch (cmd) {
 		case SIOCDELPRL:
 				   sizeof(ip6rd)))
 			goto done;
-		t = netdev_priv(dev);
 		if (cmd != SIOCDEL6RD) {
 			err = ipip6_tunnel_update_6rd(t, &ip6rd);
 			if (err < 0)

net/mac80211/chan.c+9−2

 	if (!local->use_chanctx) {
 		local->_oper_chandef = *chandef;
-		ieee80211_hw_config(local, 0);
+		ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
 	} else {
 		err = drv_add_chanctx(local, ctx);
 		if (err) {
 			check_single_channel = true;
 		local->hw.conf.radar_enabled = false;
-		ieee80211_hw_config(local, 0);
+		ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
 	} else {
 		drv_remove_chanctx(local, ctx);
 	}
 		rx_chains_static = max(rx_chains_static, needed_static);
 		rx_chains_dynamic = max(rx_chains_dynamic, needed_dynamic);
 	}
+	/* Disable SMPS for the monitor interface */
+	sdata = rcu_dereference(local->monitor_sdata);
+	if (sdata &&
+	    rcu_access_pointer(sdata->vif.chanctx_conf) == &chanctx->conf)
+		rx_chains_dynamic = rx_chains_static = local->rx_chains;
 	rcu_read_unlock();
 	if (!local->use_chanctx) {

net/mac80211/main.c+3−1

 	list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 		if (!rcu_access_pointer(sdata->vif.chanctx_conf))
 			continue;
+		if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
+			continue;
 		power = min(power, sdata->vif.bss_conf.txpower);
 	}
 	rcu_read_unlock();
 {
 	struct ieee80211_local *local = sdata->local;
-	if (!changed)
+	if (!changed || sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
 		return;
 	drv_bss_info_changed(local, sdata, &sdata->vif.bss_conf, changed);

net/mac80211/offchannel.c+1−0

@@ -355,6 +355,7 @@ void ieee80211_sw_roc_work(struct work_struct *work) · 354 unmodified lines
355	struct ieee80211_roc_work *dep;	355	struct ieee80211_roc_work *dep;
356		356
357	/* start this ROC */	357	/* start this ROC */
		358	ieee80211_offchannel_stop_vifs(local);
358		359
359	/* switch channel etc */	360	/* switch channel etc */
360	ieee80211_recalc_idle(local);	361	ieee80211_recalc_idle(local);

net/mac80211/status.c+1−0

@@ -618,6 +618,7 @@ void ieee80211_tx_status(struct ieee80211_hw hw, struct sk_buff skb) · 617 unmodified lines
618	sta, true, acked);	618	sta, true, acked);
619		619
620	if ((local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL) &&	620	if ((local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL) &&
		621	(ieee80211_is_data(hdr->frame_control)) &&
621	(rates_idx != -1))	622	(rates_idx != -1))
622	sta->last_tx_rate = info->status.rates[rates_idx];	623	sta->last_tx_rate = info->status.rates[rates_idx];
623		624

net/sctp/auth.c+6−11

  */
 int sctp_auth_asoc_init_active_key(struct sctp_association *asoc, gfp_t gfp)
 {
-	struct net *net = sock_net(asoc->base.sk);
 	struct sctp_auth_bytes	*secret;
 	struct sctp_shared_key *ep_key;
 	/* If we don't support AUTH, or peer is not capable
 	 * we don't need to do anything.
 	 */
-	if (!net->sctp.auth_enable || !asoc->peer.auth_capable)
+	if (!asoc->ep->auth_enable || !asoc->peer.auth_capable)
 		return 0;
 	/* If the key_id is non-zero and we couldn't find an
  */
 int sctp_auth_init_hmacs(struct sctp_endpoint *ep, gfp_t gfp)
 {
-	struct net *net = sock_net(ep->base.sk);
 	struct crypto_hash *tfm = NULL;
 	__u16   id;
-	/* if the transforms are already allocted, we are done */
+	/* If AUTH extension is disabled, we are done */
-	if (!net->sctp.auth_enable) {
+	if (!ep->auth_enable) {
 		ep->auth_hmacs = NULL;
 		return 0;
 	}
+	/* If the transforms are already allocated, we are done */
 	if (ep->auth_hmacs)
 		return 0;
 /* Check if peer requested that this chunk is authenticated */
 int sctp_auth_send_cid(sctp_cid_t chunk, const struct sctp_association *asoc)
 {
-	struct net  *net;
 	if (!asoc)
 		return 0;
-	net = sock_net(asoc->base.sk);
+	if (!asoc->ep->auth_enable || !asoc->peer.auth_capable)
-	if (!net->sctp.auth_enable || !asoc->peer.auth_capable)
 		return 0;
 	return __sctp_auth_cid(chunk, asoc->peer.peer_chunks);
 /* Check if we requested that peer authenticate this chunk. */
 int sctp_auth_recv_cid(sctp_cid_t chunk, const struct sctp_association *asoc)
 {
-	struct net *net;
 	if (!asoc)
 		return 0;
-	net = sock_net(asoc->base.sk);
+	if (!asoc->ep->auth_enable)
-	if (!net->sctp.auth_enable)
 		return 0;
 	return __sctp_auth_cid(chunk,

net/sctp/endpointola.c+2−1

@@ -68,7 +68,8 @@ static struct sctp_endpoint sctp_endpoint_init(struct sctp_endpoint ep, · 67 unmodified lines
68	if (!ep->digest)	68	if (!ep->digest)
69	return NULL;	69	return NULL;
70		70
71	if (net->sctp.auth_enable) {	71	ep->auth_enable = net->sctp.auth_enable;
		72	if (ep->auth_enable) {
72	/* Allocate space for HMACS and CHUNKS authentication	73	/* Allocate space for HMACS and CHUNKS authentication
73	* variables. There are arrays that we encode directly	74	* variables. There are arrays that we encode directly
74	* into parameters to make the rest of the operations easier.	75	* into parameters to make the rest of the operations easier.

net/sctp/sm_make_chunk.c+17−15

@@ -219,6 +219,7 @@ struct sctp_chunk sctp_make_init(const struct sctp_association asoc, · 218 unmodified lines
219	gfp_t gfp, int vparam_len)	219	gfp_t gfp, int vparam_len)
220	{	220	{
221	struct net *net = sock_net(asoc->base.sk);	221	struct net *net = sock_net(asoc->base.sk);
		222	struct sctp_endpoint *ep = asoc->ep;
222	sctp_inithdr_t init;	223	sctp_inithdr_t init;
223	union sctp_params addrs;	224	union sctp_params addrs;
224	size_t chunksize;	225	size_t chunksize;
@@ -278,7 +279,7 @@ struct sctp_chunk sctp_make_init(const struct sctp_association asoc, · 53 unmodified lines
278	chunksize += vparam_len;	279	chunksize += vparam_len;
279		280
280	/* Account for AUTH related parameters */	281	/* Account for AUTH related parameters */
281	if (net->sctp.auth_enable) {	282	if (ep->auth_enable) {
282	/* Add random parameter length*/	283	/* Add random parameter length*/
283	chunksize += sizeof(asoc->c.auth_random);	284	chunksize += sizeof(asoc->c.auth_random);
284		285
@@ -363,7 +364,7 @@ struct sctp_chunk sctp_make_init(const struct sctp_association asoc, · 78 unmodified lines
363	}	364	}
364		365
365	/* Add SCTP-AUTH chunks to the parameter list */	366	/* Add SCTP-AUTH chunks to the parameter list */
366	if (net->sctp.auth_enable) {	367	if (ep->auth_enable) {
367	sctp_addto_chunk(retval, sizeof(asoc->c.auth_random),	368	sctp_addto_chunk(retval, sizeof(asoc->c.auth_random),
368	asoc->c.auth_random);	369	asoc->c.auth_random);
369	if (auth_hmacs)	370	if (auth_hmacs)
@@ -2010,7 +2011,7 @@ static void sctp_process_ext_param(struct sctp_association *asoc, · 1640 unmodified lines
2010	/* if the peer reports AUTH, assume that he	2011	/* if the peer reports AUTH, assume that he
2011	* supports AUTH.	2012	* supports AUTH.
2012	*/	2013	*/
2013	if (net->sctp.auth_enable)	2014	if (asoc->ep->auth_enable)
2014	asoc->peer.auth_capable = 1;	2015	asoc->peer.auth_capable = 1;
2015	break;	2016	break;
2016	case SCTP_CID_ASCONF:	2017	case SCTP_CID_ASCONF:
@@ -2102,6 +2103,7 @@ static sctp_ierror_t sctp_process_unk_param(const struct sctp_association *asoc, · 85 unmodified lines
2102	* SCTP_IERROR_NO_ERROR - continue with the chunk	2103	* SCTP_IERROR_NO_ERROR - continue with the chunk
2103	*/	2104	*/
2104	static sctp_ierror_t sctp_verify_param(struct net *net,	2105	static sctp_ierror_t sctp_verify_param(struct net *net,
		2106	const struct sctp_endpoint *ep,
2105	const struct sctp_association *asoc,	2107	const struct sctp_association *asoc,
2106	union sctp_params param,	2108	union sctp_params param,
2107	sctp_cid_t cid,	2109	sctp_cid_t cid,
@@ -2152,7 +2154,7 @@ static sctp_ierror_t sctp_verify_param(struct net *net, · 44 unmodified lines
2152	goto fallthrough;	2154	goto fallthrough;
2153		2155
2154	case SCTP_PARAM_RANDOM:	2156	case SCTP_PARAM_RANDOM:
2155	if (!net->sctp.auth_enable)	2157	if (!ep->auth_enable)
2156	goto fallthrough;	2158	goto fallthrough;
2157		2159
2158	/* SCTP-AUTH: Secion 6.1	2160	/* SCTP-AUTH: Secion 6.1
@@ -2169,7 +2171,7 @@ static sctp_ierror_t sctp_verify_param(struct net *net, · 10 unmodified lines
2169	break;	2171	break;
2170		2172
2171	case SCTP_PARAM_CHUNKS:	2173	case SCTP_PARAM_CHUNKS:
2172	if (!net->sctp.auth_enable)	2174	if (!ep->auth_enable)
2173	goto fallthrough;	2175	goto fallthrough;
2174		2176
2175	/* SCTP-AUTH: Section 3.2	2177	/* SCTP-AUTH: Section 3.2
@@ -2185,7 +2187,7 @@ static sctp_ierror_t sctp_verify_param(struct net *net, · 9 unmodified lines
2185	break;	2187	break;
2186		2188
2187	case SCTP_PARAM_HMAC_ALGO:	2189	case SCTP_PARAM_HMAC_ALGO:
2188	if (!net->sctp.auth_enable)	2190	if (!ep->auth_enable)
2189	goto fallthrough;	2191	goto fallthrough;
2190		2192
2191	hmacs = (struct sctp_hmac_algo_param *)param.p;	2193	hmacs = (struct sctp_hmac_algo_param *)param.p;
@@ -2220,10 +2222,9 @@ fallthrough: · 28 unmodified lines
2220	}	2222	}
2221		2223
2222	/* Verify the INIT packet before we process it. */	2224	/* Verify the INIT packet before we process it. */
2223	int sctp_verify_init(struct net net, const struct sctp_association asoc,	2225	int sctp_verify_init(struct net net, const struct sctp_endpoint ep,
2224	sctp_cid_t cid,	2226	const struct sctp_association *asoc, sctp_cid_t cid,
2225	sctp_init_chunk_t *peer_init,	2227	sctp_init_chunk_t peer_init, struct sctp_chunk chunk,
2226	struct sctp_chunk *chunk,
2227	struct sctp_chunk **errp)	2228	struct sctp_chunk **errp)
2228	{	2229	{
2229	union sctp_params param;	2230	union sctp_params param;
@@ -2264,8 +2265,8 @@ int sctp_verify_init(struct net net, const struct sctp_association asoc, · 34 unmodified lines
2264		2265
2265	/* Verify all the variable length parameters */	2266	/* Verify all the variable length parameters */
2266	sctp_walk_params(param, peer_init, init_hdr.params) {	2267	sctp_walk_params(param, peer_init, init_hdr.params) {
2267		2268	result = sctp_verify_param(net, ep, asoc, param, cid,
2268	result = sctp_verify_param(net, asoc, param, cid, chunk, errp);	2269	chunk, errp);
2269	switch (result) {	2270	switch (result) {
2270	case SCTP_IERROR_ABORT:	2271	case SCTP_IERROR_ABORT:
2271	case SCTP_IERROR_NOMEM:	2272	case SCTP_IERROR_NOMEM:
@@ -2497,6 +2498,7 @@ static int sctp_process_param(struct sctp_association *asoc, · 225 unmodified lines
2497	struct sctp_af *af;	2498	struct sctp_af *af;
2498	union sctp_addr_param *addr_param;	2499	union sctp_addr_param *addr_param;
2499	struct sctp_transport *t;	2500	struct sctp_transport *t;
		2501	struct sctp_endpoint *ep = asoc->ep;
2500		2502
2501	/* We maintain all INIT parameters in network byte order all the	2503	/* We maintain all INIT parameters in network byte order all the
2502	* time. This allows us to not worry about whether the parameters	2504	* time. This allows us to not worry about whether the parameters
@@ -2636,7 +2638,7 @@ do_addr_param: · 133 unmodified lines
2636	goto fall_through;	2638	goto fall_through;
2637		2639
2638	case SCTP_PARAM_RANDOM:	2640	case SCTP_PARAM_RANDOM:
2639	if (!net->sctp.auth_enable)	2641	if (!ep->auth_enable)
2640	goto fall_through;	2642	goto fall_through;
2641		2643
2642	/* Save peer's random parameter */	2644	/* Save peer's random parameter */
@@ -2649,7 +2651,7 @@ do_addr_param: · 6 unmodified lines
2649	break;	2651	break;
2650		2652
2651	case SCTP_PARAM_HMAC_ALGO:	2653	case SCTP_PARAM_HMAC_ALGO:
2652	if (!net->sctp.auth_enable)	2654	if (!ep->auth_enable)
2653	goto fall_through;	2655	goto fall_through;
2654		2656
2655	/* Save peer's HMAC list */	2657	/* Save peer's HMAC list */
@@ -2665,7 +2667,7 @@ do_addr_param: · 9 unmodified lines
2665	break;	2667	break;
2666		2668
2667	case SCTP_PARAM_CHUNKS:	2669	case SCTP_PARAM_CHUNKS:
2668	if (!net->sctp.auth_enable)	2670	if (!ep->auth_enable)
2669	goto fall_through;	2671	goto fall_through;
2670		2672
2671	asoc->peer.peer_chunks = kmemdup(param.p,	2673	asoc->peer.peer_chunks = kmemdup(param.p,

net/sctp/sm_statefuns.c+3−3

@@ -357,7 +357,7 @@ sctp_disposition_t sctp_sf_do_5_1B_init(struct net *net, · 356 unmodified lines
357		357
358	/* Verify the INIT chunk before processing it. */	358	/* Verify the INIT chunk before processing it. */
359	err_chunk = NULL;	359	err_chunk = NULL;
360	if (!sctp_verify_init(net, asoc, chunk->chunk_hdr->type,	360	if (!sctp_verify_init(net, ep, asoc, chunk->chunk_hdr->type,
361	(sctp_init_chunk_t *)chunk->chunk_hdr, chunk,	361	(sctp_init_chunk_t *)chunk->chunk_hdr, chunk,
362	&err_chunk)) {	362	&err_chunk)) {
363	/* This chunk contains fatal error. It is to be discarded.	363	/* This chunk contains fatal error. It is to be discarded.
@@ -524,7 +524,7 @@ sctp_disposition_t sctp_sf_do_5_1C_ack(struct net *net, · 160 unmodified lines
524		524
525	/* Verify the INIT chunk before processing it. */	525	/* Verify the INIT chunk before processing it. */
526	err_chunk = NULL;	526	err_chunk = NULL;
527	if (!sctp_verify_init(net, asoc, chunk->chunk_hdr->type,	527	if (!sctp_verify_init(net, ep, asoc, chunk->chunk_hdr->type,
528	(sctp_init_chunk_t *)chunk->chunk_hdr, chunk,	528	(sctp_init_chunk_t *)chunk->chunk_hdr, chunk,
529	&err_chunk)) {	529	&err_chunk)) {
530		530
@@ -1430,7 +1430,7 @@ static sctp_disposition_t sctp_sf_do_unexpected_init( · 899 unmodified lines
1430		1430
1431	/* Verify the INIT chunk before processing it. */	1431	/* Verify the INIT chunk before processing it. */
1432	err_chunk = NULL;	1432	err_chunk = NULL;
1433	if (!sctp_verify_init(net, asoc, chunk->chunk_hdr->type,	1433	if (!sctp_verify_init(net, ep, asoc, chunk->chunk_hdr->type,
1434	(sctp_init_chunk_t *)chunk->chunk_hdr, chunk,	1434	(sctp_init_chunk_t *)chunk->chunk_hdr, chunk,
1435	&err_chunk)) {	1435	&err_chunk)) {
1436	/* This chunk contains fatal error. It is to be discarded.	1436	/* This chunk contains fatal error. It is to be discarded.

net/sctp/socket.c+26−28

 				      char __user *optval,
 				      unsigned int optlen)
 {
-	struct net *net = sock_net(sk);
+	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
 	struct sctp_authchunk val;
-	if (!net->sctp.auth_enable)
+	if (!ep->auth_enable)
 		return -EACCES;
 	if (optlen != sizeof(struct sctp_authchunk))
 	}
 	/* add this chunk id to the endpoint */
-	return sctp_auth_ep_add_chunkid(sctp_sk(sk)->ep, val.sauth_chunk);
+	return sctp_auth_ep_add_chunkid(ep, val.sauth_chunk);
 }
 /*
 				      char __user *optval,
 				      unsigned int optlen)
 {
-	struct net *net = sock_net(sk);
+	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
 	struct sctp_hmacalgo *hmacs;
 	u32 idents;
 	int err;
-	if (!net->sctp.auth_enable)
+	if (!ep->auth_enable)
 		return -EACCES;
 	if (optlen < sizeof(struct sctp_hmacalgo))
 		goto out;
 	}
-	err = sctp_auth_ep_set_hmacs(sctp_sk(sk)->ep, hmacs);
+	err = sctp_auth_ep_set_hmacs(ep, hmacs);
 out:
 	kfree(hmacs);
 	return err;
 				    char __user *optval,
 				    unsigned int optlen)
 {
-	struct net *net = sock_net(sk);
+	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
 	struct sctp_authkey *authkey;
 	struct sctp_association *asoc;
 	int ret;
-	if (!net->sctp.auth_enable)
+	if (!ep->auth_enable)
 		return -EACCES;
 	if (optlen <= sizeof(struct sctp_authkey))
 		goto out;
 	}
-	ret = sctp_auth_set_key(sctp_sk(sk)->ep, asoc, authkey);
+	ret = sctp_auth_set_key(ep, asoc, authkey);
 out:
 	kzfree(authkey);
 	return ret;
 				      char __user *optval,
 				      unsigned int optlen)
 {
-	struct net *net = sock_net(sk);
+	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
 	struct sctp_authkeyid val;
 	struct sctp_association *asoc;
-	if (!net->sctp.auth_enable)
+	if (!ep->auth_enable)
 		return -EACCES;
 	if (optlen != sizeof(struct sctp_authkeyid))
 	if (!asoc && val.scact_assoc_id && sctp_style(sk, UDP))
 		return -EINVAL;
-	return sctp_auth_set_active_key(sctp_sk(sk)->ep, asoc,
+	return sctp_auth_set_active_key(ep, asoc, val.scact_keynumber);
-					val.scact_keynumber);
 }
 /*
 				   char __user *optval,
 				   unsigned int optlen)
 {
-	struct net *net = sock_net(sk);
+	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
 	struct sctp_authkeyid val;
 	struct sctp_association *asoc;
-	if (!net->sctp.auth_enable)
+	if (!ep->auth_enable)
 		return -EACCES;
 	if (optlen != sizeof(struct sctp_authkeyid))
 	if (!asoc && val.scact_assoc_id && sctp_style(sk, UDP))
 		return -EINVAL;
-	return sctp_auth_del_key_id(sctp_sk(sk)->ep, asoc,
+	return sctp_auth_del_key_id(ep, asoc, val.scact_keynumber);
-				    val.scact_keynumber);
 }
 static int sctp_getsockopt_hmac_ident(struct sock *sk, int len,
 				    char __user *optval, int __user *optlen)
 {
-	struct net *net = sock_net(sk);
+	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
 	struct sctp_hmacalgo  __user *p = (void __user *)optval;
 	struct sctp_hmac_algo_param *hmacs;
 	__u16 data_len = 0;
 	u32 num_idents;
-	if (!net->sctp.auth_enable)
+	if (!ep->auth_enable)
 		return -EACCES;
-	hmacs = sctp_sk(sk)->ep->auth_hmacs_list;
+	hmacs = ep->auth_hmacs_list;
 	data_len = ntohs(hmacs->param_hdr.length) - sizeof(sctp_paramhdr_t);
 	if (len < sizeof(struct sctp_hmacalgo) + data_len)
 static int sctp_getsockopt_active_key(struct sock *sk, int len,
 				    char __user *optval, int __user *optlen)
 {
-	struct net *net = sock_net(sk);
+	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
 	struct sctp_authkeyid val;
 	struct sctp_association *asoc;
-	if (!net->sctp.auth_enable)
+	if (!ep->auth_enable)
 		return -EACCES;
 	if (len < sizeof(struct sctp_authkeyid))
 	if (asoc)
 		val.scact_keynumber = asoc->active_key_id;
 	else
-		val.scact_keynumber = sctp_sk(sk)->ep->active_key_id;
+		val.scact_keynumber = ep->active_key_id;
 	len = sizeof(struct sctp_authkeyid);
 	if (put_user(len, optlen))
 static int sctp_getsockopt_peer_auth_chunks(struct sock *sk, int len,
 				    char __user *optval, int __user *optlen)
 {
-	struct net *net = sock_net(sk);
+	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
 	struct sctp_authchunks __user *p = (void __user *)optval;
 	struct sctp_authchunks val;
 	struct sctp_association *asoc;
 	u32    num_chunks = 0;
 	char __user *to;
-	if (!net->sctp.auth_enable)
+	if (!ep->auth_enable)
 		return -EACCES;
 	if (len < sizeof(struct sctp_authchunks))
 static int sctp_getsockopt_local_auth_chunks(struct sock *sk, int len,
 				    char __user *optval, int __user *optlen)
 {
-	struct net *net = sock_net(sk);
+	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
 	struct sctp_authchunks __user *p = (void __user *)optval;
 	struct sctp_authchunks val;
 	struct sctp_association *asoc;
 	u32    num_chunks = 0;
 	char __user *to;
-	if (!net->sctp.auth_enable)
+	if (!ep->auth_enable)
 		return -EACCES;
 	if (len < sizeof(struct sctp_authchunks))
 	if (asoc)
 		ch = (struct sctp_chunks_param *)asoc->c.auth_chunks;
 	else
-		ch = sctp_sk(sk)->ep->auth_chunk_list;
+		ch = ep->auth_chunk_list;
 	if (!ch)
 		goto num;

net/sctp/sysctl.c+35−1

@@ -64,6 +64,9 @@ static int proc_sctp_do_rto_min(struct ctl_table *ctl, int write, · 63 unmodified lines
64	static int proc_sctp_do_rto_max(struct ctl_table *ctl, int write,	64	static int proc_sctp_do_rto_max(struct ctl_table *ctl, int write,
65	void __user buffer, size_t lenp,	65	void __user buffer, size_t lenp,
66	loff_t *ppos);	66	loff_t *ppos);
		67	static int proc_sctp_do_auth(struct ctl_table *ctl, int write,
		68	void __user buffer, size_t lenp,
		69	loff_t *ppos);
67		70
68	static struct ctl_table sctp_table[] = {	71	static struct ctl_table sctp_table[] = {
69	{	72	{
@@ -266,7 +269,7 @@ static struct ctl_table sctp_net_table[] = { · 196 unmodified lines
266	.data = &init_net.sctp.auth_enable,	269	.data = &init_net.sctp.auth_enable,
267	.maxlen = sizeof(int),	270	.maxlen = sizeof(int),
268	.mode = 0644,	271	.mode = 0644,
269	.proc_handler = proc_dointvec,	272	.proc_handler = proc_sctp_do_auth,
270	},	273	},
271	{	274	{
272	.procname = "addr_scope_policy",	275	.procname = "addr_scope_policy",
@@ -400,6 +403,37 @@ static int proc_sctp_do_rto_max(struct ctl_table *ctl, int write, · 127 unmodified lines
400	return ret;	403	return ret;
401	}	404	}
402		405
		406	static int proc_sctp_do_auth(struct ctl_table *ctl, int write,
		407	void __user buffer, size_t lenp,
		408	loff_t *ppos)
		409	{
		410	struct net *net = current->nsproxy->net_ns;
		411	struct ctl_table tbl;
		412	int new_value, ret;
		413
		414	memset(&tbl, 0, sizeof(struct ctl_table));
		415	tbl.maxlen = sizeof(unsigned int);
		416
		417	if (write)
		418	tbl.data = &new_value;
		419	else
		420	tbl.data = &net->sctp.auth_enable;
		421
		422	ret = proc_dointvec(&tbl, write, buffer, lenp, ppos);
		423
		424	if (write) {
		425	struct sock *sk = net->sctp.ctl_sock;
		426
		427	net->sctp.auth_enable = new_value;
		428	/* Update the value in the control socket */
		429	lock_sock(sk);
		430	sctp_sk(sk)->ep->auth_enable = new_value;
		431	release_sock(sk);
		432	}
		433
		434	return ret;
		435	}
		436
403	int sctp_sysctl_net_register(struct net *net)	437	int sctp_sysctl_net_register(struct net *net)
404	{	438	{
405	struct ctl_table *table = sctp_net_table;	439	struct ctl_table *table = sctp_net_table;

net/socket.c+2−2

@@ -1880,8 +1880,8 @@ out: · 1879 unmodified lines
1880	* Receive a datagram from a socket.	1880	* Receive a datagram from a socket.
1881	*/	1881	*/
1882		1882
1883	asmlinkage long sys_recv(int fd, void __user *ubuf, size_t size,	1883	SYSCALL_DEFINE4(recv, int, fd, void __user *, ubuf, size_t, size,
1884	unsigned int flags)	1884	unsigned int, flags)
1885	{	1885	{
1886	return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL);	1886	return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL);
1887	}	1887	}