~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,3 +1,4 @@
	1	+// SPDX-License-Identifier: GPL-2.0-or-later
1	2	/**************************************************************************/
2	3	/* */
3	4	/* IBM System i and System p Virtual NIC Device Driver */
..	..	@@ -6,18 +7,6 @@
6	7	/* Thomas Falcon (tlfalcon@linux.vnet.ibm.com) */
7	8	/* John Allen (jallen@linux.vnet.ibm.com) */
8	9	/* */
9		-/* This program is free software; you can redistribute it and/or modify */
10		-/* it under the terms of the GNU General Public License as published by */
11		-/* the Free Software Foundation; either version 2 of the License, or */
12		-/* (at your option) any later version. */
13		-/* */
14		-/* This program is distributed in the hope that it will be useful, */
15		-/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
16		-/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
17		-/* GNU General Public License for more details. */
18		-/* */
19		-/* You should have received a copy of the GNU General Public License */
20		-/* along with this program. */
21	10	/* */
22	11	/* This module contains the implementation of a virtual ethernet device */
23	12	/* for use with IBM i/p Series LPAR Linux. It utilizes the logical LAN */
..	..	@@ -108,18 +97,18 @@
108	97	static union sub_crq ibmvnic_next_scrq(struct ibmvnic_adapter ,
109	98	struct ibmvnic_sub_crq_queue *);
110	99	static int ibmvnic_poll(struct napi_struct *napi, int data);
111		-static void send_map_query(struct ibmvnic_adapter *adapter);
	100	+static void send_query_map(struct ibmvnic_adapter *adapter);
112	101	static int send_request_map(struct ibmvnic_adapter *, dma_addr_t, __be32, u8);
113	102	static int send_request_unmap(struct ibmvnic_adapter *, u8);
114	103	static int send_login(struct ibmvnic_adapter *adapter);
115		-static void send_cap_queries(struct ibmvnic_adapter *adapter);
	104	+static void send_query_cap(struct ibmvnic_adapter *adapter);
116	105	static int init_sub_crqs(struct ibmvnic_adapter *);
117	106	static int init_sub_crq_irqs(struct ibmvnic_adapter *adapter);
118		-static int ibmvnic_init(struct ibmvnic_adapter *);
119		-static int ibmvnic_reset_init(struct ibmvnic_adapter *);
	107	+static int ibmvnic_reset_init(struct ibmvnic_adapter *, bool reset);
120	108	static void release_crq_queue(struct ibmvnic_adapter *);
121		-static int __ibmvnic_set_mac(struct net_device netdev, struct sockaddr p);
	109	+static int __ibmvnic_set_mac(struct net_device , u8 );
122	110	static int init_crq_queue(struct ibmvnic_adapter *adapter);
	111	+static int send_query_phys_parms(struct ibmvnic_adapter *adapter);
123	112
124	113	struct ibmvnic_stat {
125	114	char name[ETH_GSTRING_LEN];
..	..	@@ -128,7 +117,7 @@
128	117
129	118	#define IBMVNIC_STAT_OFF(stat) (offsetof(struct ibmvnic_adapter, stats) + \
130	119	offsetof(struct ibmvnic_statistics, stat))
131		-#define IBMVNIC_GET_STAT(a, off) (((u64 )(((unsigned long)(a)) + off)))
	120	+#define IBMVNIC_GET_STAT(a, off) (((u64 )(((unsigned long)(a)) + (off))))
132	121
133	122	static const struct ibmvnic_stat ibmvnic_stats[] = {
134	123	{"rx_packets", IBMVNIC_STAT_OFF(rx_packets)},
..	..	@@ -169,6 +158,40 @@
169	158	return rc;
170	159	}
171	160
	161	+/**
	162	+ * ibmvnic_wait_for_completion - Check device state and wait for completion
	163	+ * @adapter: private device data
	164	+ * @comp_done: completion structure to wait for
	165	+ * @timeout: time to wait in milliseconds
	166	+ *
	167	+ * Wait for a completion signal or until the timeout limit is reached
	168	+ * while checking that the device is still active.
	169	+ */
	170	+static int ibmvnic_wait_for_completion(struct ibmvnic_adapter *adapter,
	171	+ struct completion *comp_done,
	172	+ unsigned long timeout)
	173	+{
	174	+ struct net_device *netdev;
	175	+ unsigned long div_timeout;
	176	+ u8 retry;
	177	+
	178	+ netdev = adapter->netdev;
	179	+ retry = 5;
	180	+ div_timeout = msecs_to_jiffies(timeout / retry);
	181	+ while (true) {
	182	+ if (!adapter->crq.active) {
	183	+ netdev_err(netdev, "Device down!\n");
	184	+ return -ENODEV;
	185	+ }
	186	+ if (!retry--)
	187	+ break;
	188	+ if (wait_for_completion_timeout(comp_done, div_timeout))
	189	+ return 0;
	190	+ }
	191	+ netdev_err(netdev, "Operation timed out.\n");
	192	+ return -ETIMEDOUT;
	193	+}
	194	+
172	195	static int alloc_long_term_buff(struct ibmvnic_adapter *adapter,
173	196	struct ibmvnic_long_term_buff *ltb, int size)
174	197	{
..	..	@@ -186,22 +209,38 @@
186	209	ltb->map_id = adapter->map_id;
187	210	adapter->map_id++;
188	211
189		- init_completion(&adapter->fw_done);
190		- rc = send_request_map(adapter, ltb->addr,
191		- ltb->size, ltb->map_id);
	212	+ mutex_lock(&adapter->fw_lock);
	213	+ adapter->fw_done_rc = 0;
	214	+ reinit_completion(&adapter->fw_done);
	215	+
	216	+ rc = send_request_map(adapter, ltb->addr, ltb->size, ltb->map_id);
192	217	if (rc) {
193		- dma_free_coherent(dev, ltb->size, ltb->buff, ltb->addr);
194		- return rc;
	218	+ dev_err(dev, "send_request_map failed, rc = %d\n", rc);
	219	+ goto out;
195	220	}
196		- wait_for_completion(&adapter->fw_done);
	221	+
	222	+ rc = ibmvnic_wait_for_completion(adapter, &adapter->fw_done, 10000);
	223	+ if (rc) {
	224	+ dev_err(dev,
	225	+ "Long term map request aborted or timed out,rc = %d\n",
	226	+ rc);
	227	+ goto out;
	228	+ }
197	229
198	230	if (adapter->fw_done_rc) {
199	231	dev_err(dev, "Couldn't map long term buffer,rc = %d\n",
200	232	adapter->fw_done_rc);
201		- dma_free_coherent(dev, ltb->size, ltb->buff, ltb->addr);
202		- return -1;
	233	+ rc = -1;
	234	+ goto out;
203	235	}
204		- return 0;
	236	+ rc = 0;
	237	+out:
	238	+ if (rc) {
	239	+ dma_free_coherent(dev, ltb->size, ltb->buff, ltb->addr);
	240	+ ltb->buff = NULL;
	241	+ }
	242	+ mutex_unlock(&adapter->fw_lock);
	243	+ return rc;
205	244	}
206	245
207	246	static void free_long_term_buff(struct ibmvnic_adapter *adapter,
..	..	@@ -221,27 +260,44 @@
221	260	adapter->reset_reason != VNIC_RESET_TIMEOUT)
222	261	send_request_unmap(adapter, ltb->map_id);
223	262	dma_free_coherent(dev, ltb->size, ltb->buff, ltb->addr);
	263	+ ltb->buff = NULL;
	264	+ ltb->map_id = 0;
224	265	}
225	266
226	267	static int reset_long_term_buff(struct ibmvnic_adapter *adapter,
227	268	struct ibmvnic_long_term_buff *ltb)
228	269	{
	270	+ struct device *dev = &adapter->vdev->dev;
229	271	int rc;
230	272
231	273	memset(ltb->buff, 0, ltb->size);
232	274
233		- init_completion(&adapter->fw_done);
	275	+ mutex_lock(&adapter->fw_lock);
	276	+ adapter->fw_done_rc = 0;
	277	+
	278	+ reinit_completion(&adapter->fw_done);
234	279	rc = send_request_map(adapter, ltb->addr, ltb->size, ltb->map_id);
235		- if (rc)
	280	+ if (rc) {
	281	+ mutex_unlock(&adapter->fw_lock);
236	282	return rc;
237		- wait_for_completion(&adapter->fw_done);
	283	+ }
	284	+
	285	+ rc = ibmvnic_wait_for_completion(adapter, &adapter->fw_done, 10000);
	286	+ if (rc) {
	287	+ dev_info(dev,
	288	+ "Reset failed, long term map request timed out or aborted\n");
	289	+ mutex_unlock(&adapter->fw_lock);
	290	+ return rc;
	291	+ }
238	292
239	293	if (adapter->fw_done_rc) {
240		- dev_info(&adapter->vdev->dev,
	294	+ dev_info(dev,
241	295	"Reset failed, attempting to free and reallocate buffer\n");
242	296	free_long_term_buff(adapter, ltb);
	297	+ mutex_unlock(&adapter->fw_lock);
243	298	return alloc_long_term_buff(adapter, ltb, ltb->size);
244	299	}
	300	+ mutex_unlock(&adapter->fw_lock);
245	301	return 0;
246	302	}
247	303
..	..	@@ -249,8 +305,7 @@
249	305	{
250	306	int i;
251	307
252		- for (i = 0; i < be32_to_cpu(adapter->login_rsp_buf->num_rxadd_subcrqs);
253		- i++)
	308	+ for (i = 0; i < adapter->num_active_rx_pools; i++)
254	309	adapter->rx_pool[i].active = 0;
255	310	}
256	311
..	..	@@ -258,6 +313,7 @@
258	313	struct ibmvnic_rx_pool *pool)
259	314	{
260	315	int count = pool->size - atomic_read(&pool->available);
	316	+ u64 handle = adapter->rx_scrq[pool->index]->handle;
261	317	struct device *dev = &adapter->vdev->dev;
262	318	int buffers_added = 0;
263	319	unsigned long lpar_rc;
..	..	@@ -266,17 +322,12 @@
266	322	unsigned int offset;
267	323	dma_addr_t dma_addr;
268	324	unsigned char *dst;
269		- u64 *handle_array;
270	325	int shift = 0;
271	326	int index;
272	327	int i;
273	328
274	329	if (!pool->active)
275	330	return;
276		-
277		- handle_array = (u64 )((u8 )(adapter->login_rsp_buf) +
278		- be32_to_cpu(adapter->login_rsp_buf->
279		- off_rxadd_subcrqs));
280	331
281	332	for (i = 0; i < count; ++i) {
282	333	skb = alloc_skb(pool->buff_size, GFP_ATOMIC);
..	..	@@ -321,8 +372,7 @@
321	372	#endif
322	373	sub_crq.rx_add.len = cpu_to_be32(pool->buff_size << shift);
323	374
324		- lpar_rc = send_subcrq(adapter, handle_array[pool->index],
325		- &sub_crq);
	375	+ lpar_rc = send_subcrq(adapter, handle, &sub_crq);
326	376	if (lpar_rc != H_SUCCESS)
327	377	goto failure;
328	378
..	..	@@ -359,11 +409,12 @@
359	409	int i;
360	410
361	411	adapter->replenish_task_cycles++;
362		- for (i = 0; i < be32_to_cpu(adapter->login_rsp_buf->num_rxadd_subcrqs);
363		- i++) {
	412	+ for (i = 0; i < adapter->num_active_rx_pools; i++) {
364	413	if (adapter->rx_pool[i].active)
365	414	replenish_rx_pool(adapter, &adapter->rx_pool[i]);
366	415	}
	416	+
	417	+ netdev_dbg(adapter->netdev, "Replenished %d pools\n", i);
367	418	}
368	419
369	420	static void release_stats_buffers(struct ibmvnic_adapter *adapter)
..	..	@@ -427,22 +478,23 @@
427	478	static int reset_rx_pools(struct ibmvnic_adapter *adapter)
428	479	{
429	480	struct ibmvnic_rx_pool *rx_pool;
	481	+ u64 buff_size;
430	482	int rx_scrqs;
431	483	int i, j, rc;
432		- u64 *size_array;
433	484
434		- size_array = (u64 )((u8 )(adapter->login_rsp_buf) +
435		- be32_to_cpu(adapter->login_rsp_buf->off_rxadd_buff_size));
	485	+ if (!adapter->rx_pool)
	486	+ return -1;
436	487
437		- rx_scrqs = be32_to_cpu(adapter->login_rsp_buf->num_rxadd_subcrqs);
	488	+ buff_size = adapter->cur_rx_buf_sz;
	489	+ rx_scrqs = adapter->num_active_rx_pools;
438	490	for (i = 0; i < rx_scrqs; i++) {
439	491	rx_pool = &adapter->rx_pool[i];
440	492
441	493	netdev_dbg(adapter->netdev, "Re-setting rx_pool[%d]\n", i);
442	494
443		- if (rx_pool->buff_size != be64_to_cpu(size_array[i])) {
	495	+ if (rx_pool->buff_size != buff_size) {
444	496	free_long_term_buff(adapter, &rx_pool->long_term_buff);
445		- rx_pool->buff_size = be64_to_cpu(size_array[i]);
	497	+ rx_pool->buff_size = buff_size;
446	498	rc = alloc_long_term_buff(adapter,
447	499	&rx_pool->long_term_buff,
448	500	rx_pool->size *
..	..	@@ -510,13 +562,11 @@
510	562	struct device *dev = &adapter->vdev->dev;
511	563	struct ibmvnic_rx_pool *rx_pool;
512	564	int rxadd_subcrqs;
513		- u64 *size_array;
	565	+ u64 buff_size;
514	566	int i, j;
515	567
516		- rxadd_subcrqs =
517		- be32_to_cpu(adapter->login_rsp_buf->num_rxadd_subcrqs);
518		- size_array = (u64 )((u8 )(adapter->login_rsp_buf) +
519		- be32_to_cpu(adapter->login_rsp_buf->off_rxadd_buff_size));
	568	+ rxadd_subcrqs = adapter->num_active_rx_scrqs;
	569	+ buff_size = adapter->cur_rx_buf_sz;
520	570
521	571	adapter->rx_pool = kcalloc(rxadd_subcrqs,
522	572	sizeof(struct ibmvnic_rx_pool),
..	..	@@ -534,11 +584,11 @@
534	584	netdev_dbg(adapter->netdev,
535	585	"Initializing rx_pool[%d], %lld buffs, %lld bytes each\n",
536	586	i, adapter->req_rx_add_entries_per_subcrq,
537		- be64_to_cpu(size_array[i]));
	587	+ buff_size);
538	588
539	589	rx_pool->size = adapter->req_rx_add_entries_per_subcrq;
540	590	rx_pool->index = i;
541		- rx_pool->buff_size = be64_to_cpu(size_array[i]);
	591	+ rx_pool->buff_size = buff_size;
542	592	rx_pool->active = 1;
543	593
544	594	rx_pool->free_map = kcalloc(rx_pool->size, sizeof(int),
..	..	@@ -601,7 +651,10 @@
601	651	int tx_scrqs;
602	652	int i, rc;
603	653
604		- tx_scrqs = be32_to_cpu(adapter->login_rsp_buf->num_txsubm_subcrqs);
	654	+ if (!adapter->tx_pool)
	655	+ return -1;
	656	+
	657	+ tx_scrqs = adapter->num_active_tx_pools;
605	658	for (i = 0; i < tx_scrqs; i++) {
606	659	rc = reset_one_tx_pool(adapter, &adapter->tso_pool[i]);
607	660	if (rc)
..	..	@@ -690,7 +743,7 @@
690	743	int tx_subcrqs;
691	744	int i, rc;
692	745
693		- tx_subcrqs = be32_to_cpu(adapter->login_rsp_buf->num_txsubm_subcrqs);
	746	+ tx_subcrqs = adapter->num_active_tx_scrqs;
694	747	adapter->tx_pool = kcalloc(tx_subcrqs,
695	748	sizeof(struct ibmvnic_tx_pool), GFP_KERNEL);
696	749	if (!adapter->tx_pool)
..	..	@@ -782,11 +835,8 @@
782	835	return;
783	836
784	837	for (i = 0; i < adapter->num_active_rx_napi; i++) {
785		- if (&adapter->napi[i]) {
786		- netdev_dbg(adapter->netdev,
787		- "Releasing napi[%d]\n", i);
788		- netif_napi_del(&adapter->napi[i]);
789		- }
	838	+ netdev_dbg(adapter->netdev, "Releasing napi[%d]\n", i);
	839	+ netif_napi_del(&adapter->napi[i]);
790	840	}
791	841
792	842	kfree(adapter->napi);
..	..	@@ -798,7 +848,7 @@
798	848	static int ibmvnic_login(struct net_device *netdev)
799	849	{
800	850	struct ibmvnic_adapter *adapter = netdev_priv(netdev);
801		- unsigned long timeout = msecs_to_jiffies(30000);
	851	+ unsigned long timeout = msecs_to_jiffies(20000);
802	852	int retry_count = 0;
803	853	int retries = 10;
804	854	bool retry;
..	..	@@ -814,10 +864,8 @@
814	864	adapter->init_done_rc = 0;
815	865	reinit_completion(&adapter->init_done);
816	866	rc = send_login(adapter);
817		- if (rc) {
818		- netdev_warn(netdev, "Unable to login\n");
	867	+ if (rc)
819	868	return rc;
820		- }
821	869
822	870	if (!wait_for_completion_timeout(&adapter->init_done,
823	871	timeout)) {
..	..	@@ -846,7 +894,7 @@
846	894	"Received partial success, retrying...\n");
847	895	adapter->init_done_rc = 0;
848	896	reinit_completion(&adapter->init_done);
849		- send_cap_queries(adapter);
	897	+ send_query_cap(adapter);
850	898	if (!wait_for_completion_timeout(&adapter->init_done,
851	899	timeout)) {
852	900	netdev_warn(netdev,
..	..	@@ -873,12 +921,9 @@
873	921	}
874	922	} while (retry);
875	923
876		- /* handle pending MAC address changes after successful login */
877		- if (adapter->mac_change_pending) {
878		- __ibmvnic_set_mac(netdev, &adapter->desired.mac);
879		- adapter->mac_change_pending = false;
880		- }
	924	+ __ibmvnic_set_mac(netdev, adapter->mac_addr);
881	925
	926	+ netdev_dbg(netdev, "[S:%d] Login succeeded\n", adapter->state);
882	927	return 0;
883	928	}
884	929
..	..	@@ -902,13 +947,14 @@
902	947	release_rx_pools(adapter);
903	948
904	949	release_napi(adapter);
	950	+ release_login_buffer(adapter);
905	951	release_login_rsp_buffer(adapter);
906	952	}
907	953
908	954	static int set_link_state(struct ibmvnic_adapter *adapter, u8 link_state)
909	955	{
910	956	struct net_device *netdev = adapter->netdev;
911		- unsigned long timeout = msecs_to_jiffies(30000);
	957	+ unsigned long timeout = msecs_to_jiffies(20000);
912	958	union ibmvnic_crq crq;
913	959	bool resend;
914	960	int rc;
..	..	@@ -936,7 +982,7 @@
936	982	return -1;
937	983	}
938	984
939		- if (adapter->init_done_rc == 1) {
	985	+ if (adapter->init_done_rc == PARTIALSUCCESS) {
940	986	/* Partuial success, delay and re-send */
941	987	mdelay(1000);
942	988	resend = true;
..	..	@@ -981,13 +1027,25 @@
981	1027	if (adapter->vpd->buff)
982	1028	len = adapter->vpd->len;
983	1029
984		- init_completion(&adapter->fw_done);
	1030	+ mutex_lock(&adapter->fw_lock);
	1031	+ adapter->fw_done_rc = 0;
	1032	+ reinit_completion(&adapter->fw_done);
	1033	+
985	1034	crq.get_vpd_size.first = IBMVNIC_CRQ_CMD;
986	1035	crq.get_vpd_size.cmd = GET_VPD_SIZE;
987	1036	rc = ibmvnic_send_crq(adapter, &crq);
988		- if (rc)
	1037	+ if (rc) {
	1038	+ mutex_unlock(&adapter->fw_lock);
989	1039	return rc;
990		- wait_for_completion(&adapter->fw_done);
	1040	+ }
	1041	+
	1042	+ rc = ibmvnic_wait_for_completion(adapter, &adapter->fw_done, 10000);
	1043	+ if (rc) {
	1044	+ dev_err(dev, "Could not retrieve VPD size, rc = %d\n", rc);
	1045	+ mutex_unlock(&adapter->fw_lock);
	1046	+ return rc;
	1047	+ }
	1048	+ mutex_unlock(&adapter->fw_lock);
991	1049
992	1050	if (!adapter->vpd->len)
993	1051	return -ENODATA;
..	..	@@ -1014,7 +1072,10 @@
1014	1072	return -ENOMEM;
1015	1073	}
1016	1074
	1075	+ mutex_lock(&adapter->fw_lock);
	1076	+ adapter->fw_done_rc = 0;
1017	1077	reinit_completion(&adapter->fw_done);
	1078	+
1018	1079	crq.get_vpd.first = IBMVNIC_CRQ_CMD;
1019	1080	crq.get_vpd.cmd = GET_VPD;
1020	1081	crq.get_vpd.ioba = cpu_to_be32(adapter->vpd->dma_addr);
..	..	@@ -1023,10 +1084,20 @@
1023	1084	if (rc) {
1024	1085	kfree(adapter->vpd->buff);
1025	1086	adapter->vpd->buff = NULL;
	1087	+ mutex_unlock(&adapter->fw_lock);
1026	1088	return rc;
1027	1089	}
1028		- wait_for_completion(&adapter->fw_done);
1029	1090
	1091	+ rc = ibmvnic_wait_for_completion(adapter, &adapter->fw_done, 10000);
	1092	+ if (rc) {
	1093	+ dev_err(dev, "Unable to retrieve VPD, rc = %d\n", rc);
	1094	+ kfree(adapter->vpd->buff);
	1095	+ adapter->vpd->buff = NULL;
	1096	+ mutex_unlock(&adapter->fw_lock);
	1097	+ return rc;
	1098	+ }
	1099	+
	1100	+ mutex_unlock(&adapter->fw_lock);
1030	1101	return 0;
1031	1102	}
1032	1103
..	..	@@ -1056,7 +1127,7 @@
1056	1127	if (rc)
1057	1128	return rc;
1058	1129
1059		- send_map_query(adapter);
	1130	+ send_query_map(adapter);
1060	1131
1061	1132	rc = init_rx_pools(netdev);
1062	1133	if (rc)
..	..	@@ -1127,19 +1198,27 @@
1127	1198	if (adapter->state != VNIC_CLOSED) {
1128	1199	rc = ibmvnic_login(netdev);
1129	1200	if (rc)
1130		- return rc;
	1201	+ goto out;
1131	1202
1132	1203	rc = init_resources(adapter);
1133	1204	if (rc) {
1134	1205	netdev_err(netdev, "failed to initialize resources\n");
1135	1206	release_resources(adapter);
1136		- return rc;
	1207	+ goto out;
1137	1208	}
1138	1209	}
1139	1210
1140	1211	rc = __ibmvnic_open(netdev);
1141		- netif_carrier_on(netdev);
1142	1212
	1213	+out:
	1214	+ /*
	1215	+ * If open fails due to a pending failover, set device state and
	1216	+ * return. Device operation will be handled by reset routine.
	1217	+ */
	1218	+ if (rc && adapter->failover_pending) {
	1219	+ adapter->state = VNIC_OPEN;
	1220	+ rc = 0;
	1221	+ }
1143	1222	return rc;
1144	1223	}
1145	1224
..	..	@@ -1245,7 +1324,7 @@
1245	1324	struct ibmvnic_adapter *adapter = netdev_priv(netdev);
1246	1325
1247	1326	/* ensure that transmissions are stopped if called by do_reset */
1248		- if (adapter->resetting)
	1327	+ if (test_bit(0, &adapter->resetting))
1249	1328	netif_tx_disable(netdev);
1250	1329	else
1251	1330	netif_tx_stop_all_queues(netdev);
..	..	@@ -1272,6 +1351,10 @@
1272	1351	{
1273	1352	struct ibmvnic_adapter *adapter = netdev_priv(netdev);
1274	1353	int rc;
	1354	+
	1355	+ netdev_dbg(netdev, "[S:%d FOP:%d FRR:%d] Closing\n",
	1356	+ adapter->state, adapter->failover_pending,
	1357	+ adapter->force_reset_recovery);
1275	1358
1276	1359	/* If device failover is pending, just set device state and return.
1277	1360	* Device operation will be handled by reset routine.
..	..	@@ -1459,14 +1542,12 @@
1459	1542	unsigned int offset;
1460	1543	int num_entries = 1;
1461	1544	unsigned char *dst;
1462		- u64 *handle_array;
1463	1545	int index = 0;
1464	1546	u8 proto = 0;
	1547	+ u64 handle;
1465	1548	netdev_tx_t ret = NETDEV_TX_OK;
1466	1549
1467		- if (adapter->resetting) {
1468		- if (!netif_subqueue_stopped(netdev, skb))
1469		- netif_stop_subqueue(netdev, queue_num);
	1550	+ if (test_bit(0, &adapter->resetting)) {
1470	1551	dev_kfree_skb_any(skb);
1471	1552
1472	1553	tx_send_failed++;
..	..	@@ -1488,8 +1569,7 @@
1488	1569
1489	1570	tx_scrq = adapter->tx_scrq[queue_num];
1490	1571	txq = netdev_get_tx_queue(netdev, skb_get_queue_mapping(skb));
1491		- handle_array = (u64 )((u8 )(adapter->login_rsp_buf) +
1492		- be32_to_cpu(adapter->login_rsp_buf->off_txsubm_subcrqs));
	1572	+ handle = tx_scrq->handle;
1493	1573
1494	1574	index = tx_pool->free_map[tx_pool->consumer_index];
1495	1575
..	..	@@ -1521,7 +1601,7 @@
1521	1601
1522	1602	memcpy(dst + cur,
1523	1603	page_address(skb_frag_page(frag)) +
1524		- frag->page_offset, skb_frag_size(frag));
	1604	+ skb_frag_off(frag), skb_frag_size(frag));
1525	1605	cur += skb_frag_size(frag);
1526	1606	}
1527	1607	} else {
..	..	@@ -1604,14 +1684,14 @@
1604	1684	ret = NETDEV_TX_OK;
1605	1685	goto tx_err_out;
1606	1686	}
1607		- lpar_rc = send_subcrq_indirect(adapter, handle_array[queue_num],
	1687	+ lpar_rc = send_subcrq_indirect(adapter, handle,
1608	1688	(u64)tx_buff->indir_dma,
1609	1689	(u64)num_entries);
1610	1690	dma_unmap_single(dev, tx_buff->indir_dma,
1611	1691	sizeof(tx_buff->indir_arr), DMA_TO_DEVICE);
1612	1692	} else {
1613	1693	tx_buff->num_entries = num_entries;
1614		- lpar_rc = send_subcrq(adapter, handle_array[queue_num],
	1694	+ lpar_rc = send_subcrq(adapter, handle,
1615	1695	&tx_crq);
1616	1696	}
1617	1697	if (lpar_rc != H_SUCCESS) {
..	..	@@ -1712,28 +1792,45 @@
1712	1792	}
1713	1793	}
1714	1794
1715		-static int __ibmvnic_set_mac(struct net_device netdev, struct sockaddr p)
	1795	+static int __ibmvnic_set_mac(struct net_device netdev, u8 dev_addr)
1716	1796	{
1717	1797	struct ibmvnic_adapter *adapter = netdev_priv(netdev);
1718		- struct sockaddr *addr = p;
1719	1798	union ibmvnic_crq crq;
1720	1799	int rc;
1721	1800
1722		- if (!is_valid_ether_addr(addr->sa_data))
1723		- return -EADDRNOTAVAIL;
	1801	+ if (!is_valid_ether_addr(dev_addr)) {
	1802	+ rc = -EADDRNOTAVAIL;
	1803	+ goto err;
	1804	+ }
1724	1805
1725	1806	memset(&crq, 0, sizeof(crq));
1726	1807	crq.change_mac_addr.first = IBMVNIC_CRQ_CMD;
1727	1808	crq.change_mac_addr.cmd = CHANGE_MAC_ADDR;
1728		- ether_addr_copy(&crq.change_mac_addr.mac_addr[0], addr->sa_data);
	1809	+ ether_addr_copy(&crq.change_mac_addr.mac_addr[0], dev_addr);
1729	1810
1730		- init_completion(&adapter->fw_done);
	1811	+ mutex_lock(&adapter->fw_lock);
	1812	+ adapter->fw_done_rc = 0;
	1813	+ reinit_completion(&adapter->fw_done);
	1814	+
1731	1815	rc = ibmvnic_send_crq(adapter, &crq);
1732		- if (rc)
1733		- return rc;
1734		- wait_for_completion(&adapter->fw_done);
	1816	+ if (rc) {
	1817	+ rc = -EIO;
	1818	+ mutex_unlock(&adapter->fw_lock);
	1819	+ goto err;
	1820	+ }
	1821	+
	1822	+ rc = ibmvnic_wait_for_completion(adapter, &adapter->fw_done, 10000);
1735	1823	/* netdev->dev_addr is changed in handle_change_mac_rsp function */
1736		- return adapter->fw_done_rc ? -EIO : 0;
	1824	+ if (rc \|\| adapter->fw_done_rc) {
	1825	+ rc = -EIO;
	1826	+ mutex_unlock(&adapter->fw_lock);
	1827	+ goto err;
	1828	+ }
	1829	+ mutex_unlock(&adapter->fw_lock);
	1830	+ return 0;
	1831	+err:
	1832	+ ether_addr_copy(adapter->mac_addr, netdev->dev_addr);
	1833	+ return rc;
1737	1834	}
1738	1835
1739	1836	static int ibmvnic_set_mac(struct net_device netdev, void p)
..	..	@@ -1742,14 +1839,100 @@
1742	1839	struct sockaddr *addr = p;
1743	1840	int rc;
1744	1841
1745		- if (adapter->state == VNIC_PROBED) {
1746		- memcpy(&adapter->desired.mac, addr, sizeof(struct sockaddr));
1747		- adapter->mac_change_pending = true;
1748		- return 0;
	1842	+ rc = 0;
	1843	+ if (!is_valid_ether_addr(addr->sa_data))
	1844	+ return -EADDRNOTAVAIL;
	1845	+
	1846	+ ether_addr_copy(adapter->mac_addr, addr->sa_data);
	1847	+ if (adapter->state != VNIC_PROBED)
	1848	+ rc = __ibmvnic_set_mac(netdev, addr->sa_data);
	1849	+
	1850	+ return rc;
	1851	+}
	1852	+
	1853	+/**
	1854	+ * do_change_param_reset returns zero if we are able to keep processing reset
	1855	+ * events, or non-zero if we hit a fatal error and must halt.
	1856	+ */
	1857	+static int do_change_param_reset(struct ibmvnic_adapter *adapter,
	1858	+ struct ibmvnic_rwi *rwi,
	1859	+ u32 reset_state)
	1860	+{
	1861	+ struct net_device *netdev = adapter->netdev;
	1862	+ int i, rc;
	1863	+
	1864	+ netdev_dbg(adapter->netdev, "Change param resetting driver (%d)\n",
	1865	+ rwi->reset_reason);
	1866	+
	1867	+ netif_carrier_off(netdev);
	1868	+ adapter->reset_reason = rwi->reset_reason;
	1869	+
	1870	+ ibmvnic_cleanup(netdev);
	1871	+
	1872	+ if (reset_state == VNIC_OPEN) {
	1873	+ rc = __ibmvnic_close(netdev);
	1874	+ if (rc)
	1875	+ goto out;
1749	1876	}
1750	1877
1751		- rc = __ibmvnic_set_mac(netdev, addr);
	1878	+ release_resources(adapter);
	1879	+ release_sub_crqs(adapter, 1);
	1880	+ release_crq_queue(adapter);
1752	1881
	1882	+ adapter->state = VNIC_PROBED;
	1883	+
	1884	+ rc = init_crq_queue(adapter);
	1885	+
	1886	+ if (rc) {
	1887	+ netdev_err(adapter->netdev,
	1888	+ "Couldn't initialize crq. rc=%d\n", rc);
	1889	+ return rc;
	1890	+ }
	1891	+
	1892	+ rc = ibmvnic_reset_init(adapter, true);
	1893	+ if (rc) {
	1894	+ rc = IBMVNIC_INIT_FAILED;
	1895	+ goto out;
	1896	+ }
	1897	+
	1898	+ /* If the adapter was in PROBE state prior to the reset,
	1899	+ * exit here.
	1900	+ */
	1901	+ if (reset_state == VNIC_PROBED)
	1902	+ goto out;
	1903	+
	1904	+ rc = ibmvnic_login(netdev);
	1905	+ if (rc) {
	1906	+ goto out;
	1907	+ }
	1908	+
	1909	+ rc = init_resources(adapter);
	1910	+ if (rc)
	1911	+ goto out;
	1912	+
	1913	+ ibmvnic_disable_irqs(adapter);
	1914	+
	1915	+ adapter->state = VNIC_CLOSED;
	1916	+
	1917	+ if (reset_state == VNIC_CLOSED)
	1918	+ return 0;
	1919	+
	1920	+ rc = __ibmvnic_open(netdev);
	1921	+ if (rc) {
	1922	+ rc = IBMVNIC_OPEN_FAILED;
	1923	+ goto out;
	1924	+ }
	1925	+
	1926	+ /* refresh device's multicast list */
	1927	+ ibmvnic_set_multi(netdev);
	1928	+
	1929	+ /* kick napi */
	1930	+ for (i = 0; i < adapter->req_rx_queues; i++)
	1931	+ napi_schedule(&adapter->napi[i]);
	1932	+
	1933	+out:
	1934	+ if (rc)
	1935	+ adapter->state = reset_state;
1753	1936	return rc;
1754	1937	}
1755	1938
..	..	@@ -1765,8 +1948,19 @@
1765	1948	struct net_device *netdev = adapter->netdev;
1766	1949	int rc;
1767	1950
1768		- netdev_dbg(adapter->netdev, "Re-setting driver (%d)\n",
1769		- rwi->reset_reason);
	1951	+ netdev_dbg(adapter->netdev,
	1952	+ "[S:%d FOP:%d] Reset reason %d, reset_state %d\n",
	1953	+ adapter->state, adapter->failover_pending,
	1954	+ rwi->reset_reason, reset_state);
	1955	+
	1956	+ rtnl_lock();
	1957	+ /*
	1958	+ * Now that we have the rtnl lock, clear any pending failover.
	1959	+ * This will ensure ibmvnic_open() has either completed or will
	1960	+ * block until failover is complete.
	1961	+ */
	1962	+ if (rwi->reset_reason == VNIC_RESET_FAILOVER)
	1963	+ adapter->failover_pending = false;
1770	1964
1771	1965	netif_carrier_off(netdev);
1772	1966	adapter->reset_reason = rwi->reset_reason;
..	..	@@ -1781,16 +1975,25 @@
1781	1975	if (reset_state == VNIC_OPEN &&
1782	1976	adapter->reset_reason != VNIC_RESET_MOBILITY &&
1783	1977	adapter->reset_reason != VNIC_RESET_FAILOVER) {
1784		- rc = __ibmvnic_close(netdev);
1785		- if (rc)
1786		- return rc;
1787		- }
	1978	+ adapter->state = VNIC_CLOSING;
1788	1979
1789		- if (adapter->reset_reason == VNIC_RESET_CHANGE_PARAM \|\|
1790		- adapter->wait_for_reset) {
1791		- release_resources(adapter);
1792		- release_sub_crqs(adapter, 1);
1793		- release_crq_queue(adapter);
	1980	+ /* Release the RTNL lock before link state change and
	1981	+ * re-acquire after the link state change to allow
	1982	+ * linkwatch_event to grab the RTNL lock and run during
	1983	+ * a reset.
	1984	+ */
	1985	+ rtnl_unlock();
	1986	+ rc = set_link_state(adapter, IBMVNIC_LOGICAL_LNK_DN);
	1987	+ rtnl_lock();
	1988	+ if (rc)
	1989	+ goto out;
	1990	+
	1991	+ if (adapter->state != VNIC_CLOSING) {
	1992	+ rc = -1;
	1993	+ goto out;
	1994	+ }
	1995	+
	1996	+ adapter->state = VNIC_CLOSED;
1794	1997	}
1795	1998
1796	1999	if (adapter->reset_reason != VNIC_RESET_NON_FATAL) {
..	..	@@ -1799,50 +2002,54 @@
1799	2002	*/
1800	2003	adapter->state = VNIC_PROBED;
1801	2004
1802		- if (adapter->wait_for_reset) {
1803		- rc = init_crq_queue(adapter);
1804		- } else if (adapter->reset_reason == VNIC_RESET_MOBILITY) {
	2005	+ if (adapter->reset_reason == VNIC_RESET_MOBILITY) {
1805	2006	rc = ibmvnic_reenable_crq_queue(adapter);
1806	2007	release_sub_crqs(adapter, 1);
1807	2008	} else {
1808	2009	rc = ibmvnic_reset_crq(adapter);
1809		- if (!rc)
	2010	+ if (rc == H_CLOSED \|\| rc == H_SUCCESS) {
1810	2011	rc = vio_enable_interrupts(adapter->vdev);
	2012	+ if (rc)
	2013	+ netdev_err(adapter->netdev,
	2014	+ "Reset failed to enable interrupts. rc=%d\n",
	2015	+ rc);
	2016	+ }
1811	2017	}
1812	2018
1813	2019	if (rc) {
1814	2020	netdev_err(adapter->netdev,
1815		- "Couldn't initialize crq. rc=%d\n", rc);
1816		- return rc;
	2021	+ "Reset couldn't initialize crq. rc=%d\n", rc);
	2022	+ goto out;
1817	2023	}
1818	2024
1819		- rc = ibmvnic_reset_init(adapter);
1820		- if (rc)
1821		- return IBMVNIC_INIT_FAILED;
	2025	+ rc = ibmvnic_reset_init(adapter, true);
	2026	+ if (rc) {
	2027	+ rc = IBMVNIC_INIT_FAILED;
	2028	+ goto out;
	2029	+ }
1822	2030
1823	2031	/* If the adapter was in PROBE state prior to the reset,
1824	2032	* exit here.
1825	2033	*/
1826		- if (reset_state == VNIC_PROBED)
1827		- return 0;
	2034	+ if (reset_state == VNIC_PROBED) {
	2035	+ rc = 0;
	2036	+ goto out;
	2037	+ }
1828	2038
1829	2039	rc = ibmvnic_login(netdev);
1830	2040	if (rc) {
1831		- adapter->state = reset_state;
1832		- return rc;
	2041	+ goto out;
1833	2042	}
1834	2043
1835		- if (adapter->reset_reason == VNIC_RESET_CHANGE_PARAM \|\|
1836		- adapter->wait_for_reset) {
1837		- rc = init_resources(adapter);
1838		- if (rc)
1839		- return rc;
1840		- } else if (adapter->req_rx_queues != old_num_rx_queues \|\|
1841		- adapter->req_tx_queues != old_num_tx_queues \|\|
1842		- adapter->req_rx_add_entries_per_subcrq !=
1843		- old_num_rx_slots \|\|
1844		- adapter->req_tx_entries_per_subcrq !=
1845		- old_num_tx_slots) {
	2044	+ if (adapter->req_rx_queues != old_num_rx_queues \|\|
	2045	+ adapter->req_tx_queues != old_num_tx_queues \|\|
	2046	+ adapter->req_rx_add_entries_per_subcrq !=
	2047	+ old_num_rx_slots \|\|
	2048	+ adapter->req_tx_entries_per_subcrq !=
	2049	+ old_num_tx_slots \|\|
	2050	+ !adapter->rx_pool \|\|
	2051	+ !adapter->tso_pool \|\|
	2052	+ !adapter->tx_pool) {
1846	2053	release_rx_pools(adapter);
1847	2054	release_tx_pools(adapter);
1848	2055	release_napi(adapter);
..	..	@@ -1850,46 +2057,58 @@
1850	2057
1851	2058	rc = init_resources(adapter);
1852	2059	if (rc)
1853		- return rc;
	2060	+ goto out;
1854	2061
1855	2062	} else {
1856	2063	rc = reset_tx_pools(adapter);
1857		- if (rc)
1858		- return rc;
	2064	+ if (rc) {
	2065	+ netdev_dbg(adapter->netdev, "reset tx pools failed (%d)\n",
	2066	+ rc);
	2067	+ goto out;
	2068	+ }
1859	2069
1860	2070	rc = reset_rx_pools(adapter);
1861		- if (rc)
1862		- return rc;
	2071	+ if (rc) {
	2072	+ netdev_dbg(adapter->netdev, "reset rx pools failed (%d)\n",
	2073	+ rc);
	2074	+ goto out;
	2075	+ }
1863	2076	}
1864	2077	ibmvnic_disable_irqs(adapter);
1865	2078	}
1866	2079	adapter->state = VNIC_CLOSED;
1867	2080
1868		- if (reset_state == VNIC_CLOSED)
1869		- return 0;
	2081	+ if (reset_state == VNIC_CLOSED) {
	2082	+ rc = 0;
	2083	+ goto out;
	2084	+ }
1870	2085
1871	2086	rc = __ibmvnic_open(netdev);
1872	2087	if (rc) {
1873		- if (list_empty(&adapter->rwi_list))
1874		- adapter->state = VNIC_CLOSED;
1875		- else
1876		- adapter->state = reset_state;
1877		-
1878		- return 0;
	2088	+ rc = IBMVNIC_OPEN_FAILED;
	2089	+ goto out;
1879	2090	}
1880	2091
1881	2092	/* refresh device's multicast list */
1882	2093	ibmvnic_set_multi(netdev);
1883	2094
1884		- if (adapter->reset_reason != VNIC_RESET_FAILOVER &&
1885		- adapter->reset_reason != VNIC_RESET_CHANGE_PARAM) {
	2095	+ if (adapter->reset_reason == VNIC_RESET_FAILOVER \|\|
	2096	+ adapter->reset_reason == VNIC_RESET_MOBILITY) {
1886	2097	call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, netdev);
1887	2098	call_netdevice_notifiers(NETDEV_RESEND_IGMP, netdev);
1888	2099	}
1889	2100
1890		- netif_carrier_on(netdev);
	2101	+ rc = 0;
1891	2102
1892		- return 0;
	2103	+out:
	2104	+ /* restore the adapter state if reset failed */
	2105	+ if (rc)
	2106	+ adapter->state = reset_state;
	2107	+ rtnl_unlock();
	2108	+
	2109	+ netdev_dbg(adapter->netdev, "[S:%d FOP:%d] Reset done, rc %d\n",
	2110	+ adapter->state, adapter->failover_pending, rc);
	2111	+ return rc;
1893	2112	}
1894	2113
1895	2114	static int do_hard_reset(struct ibmvnic_adapter *adapter,
..	..	@@ -1919,48 +2138,48 @@
1919	2138	if (rc) {
1920	2139	netdev_err(adapter->netdev,
1921	2140	"Couldn't initialize crq. rc=%d\n", rc);
1922		- return rc;
	2141	+ goto out;
1923	2142	}
1924	2143
1925		- rc = ibmvnic_init(adapter);
	2144	+ rc = ibmvnic_reset_init(adapter, false);
1926	2145	if (rc)
1927		- return rc;
	2146	+ goto out;
1928	2147
1929	2148	/* If the adapter was in PROBE state prior to the reset,
1930	2149	* exit here.
1931	2150	*/
1932	2151	if (reset_state == VNIC_PROBED)
1933		- return 0;
	2152	+ goto out;
1934	2153
1935	2154	rc = ibmvnic_login(netdev);
1936		- if (rc) {
1937		- adapter->state = VNIC_PROBED;
1938		- return 0;
1939		- }
	2155	+ if (rc)
	2156	+ goto out;
1940	2157
1941	2158	rc = init_resources(adapter);
1942	2159	if (rc)
1943		- return rc;
	2160	+ goto out;
1944	2161
1945	2162	ibmvnic_disable_irqs(adapter);
1946	2163	adapter->state = VNIC_CLOSED;
1947	2164
1948	2165	if (reset_state == VNIC_CLOSED)
1949		- return 0;
	2166	+ goto out;
1950	2167
1951	2168	rc = __ibmvnic_open(netdev);
1952	2169	if (rc) {
1953		- if (list_empty(&adapter->rwi_list))
1954		- adapter->state = VNIC_CLOSED;
1955		- else
1956		- adapter->state = reset_state;
1957		-
1958		- return 0;
	2170	+ rc = IBMVNIC_OPEN_FAILED;
	2171	+ goto out;
1959	2172	}
1960	2173
1961		- netif_carrier_on(netdev);
1962		-
1963		- return 0;
	2174	+ call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, netdev);
	2175	+ call_netdevice_notifiers(NETDEV_RESEND_IGMP, netdev);
	2176	+out:
	2177	+ /* restore adapter state if reset failed */
	2178	+ if (rc)
	2179	+ adapter->state = reset_state;
	2180	+ netdev_dbg(adapter->netdev, "[S:%d FOP:%d] Hard reset done, rc %d\n",
	2181	+ adapter->state, adapter->failover_pending, rc);
	2182	+ return rc;
1964	2183	}
1965	2184
1966	2185	static struct ibmvnic_rwi get_next_rwi(struct ibmvnic_adapter adapter)
..	..	@@ -1982,76 +2201,107 @@
1982	2201	return rwi;
1983	2202	}
1984	2203
1985		-static void free_all_rwi(struct ibmvnic_adapter *adapter)
1986		-{
1987		- struct ibmvnic_rwi *rwi;
1988		-
1989		- rwi = get_next_rwi(adapter);
1990		- while (rwi) {
1991		- kfree(rwi);
1992		- rwi = get_next_rwi(adapter);
1993		- }
1994		-}
1995		-
1996	2204	static void __ibmvnic_reset(struct work_struct *work)
1997	2205	{
1998	2206	struct ibmvnic_rwi *rwi;
1999	2207	struct ibmvnic_adapter *adapter;
2000		- struct net_device *netdev;
2001		- bool we_lock_rtnl = false;
	2208	+ bool saved_state = false;
	2209	+ unsigned long flags;
2002	2210	u32 reset_state;
2003	2211	int rc = 0;
2004	2212
2005	2213	adapter = container_of(work, struct ibmvnic_adapter, ibmvnic_reset);
2006		- netdev = adapter->netdev;
2007	2214
2008		- /* netif_set_real_num_xx_queues needs to take rtnl lock here
2009		- * unless wait_for_reset is set, in which case the rtnl lock
2010		- * has already been taken before initializing the reset
2011		- */
2012		- if (!adapter->wait_for_reset) {
2013		- rtnl_lock();
2014		- we_lock_rtnl = true;
	2215	+ if (test_and_set_bit_lock(0, &adapter->resetting)) {
	2216	+ schedule_delayed_work(&adapter->ibmvnic_delayed_reset,
	2217	+ IBMVNIC_RESET_DELAY);
	2218	+ return;
2015	2219	}
2016		- reset_state = adapter->state;
2017	2220
2018	2221	rwi = get_next_rwi(adapter);
2019	2222	while (rwi) {
	2223	+ spin_lock_irqsave(&adapter->state_lock, flags);
	2224	+
2020	2225	if (adapter->state == VNIC_REMOVING \|\|
2021	2226	adapter->state == VNIC_REMOVED) {
	2227	+ spin_unlock_irqrestore(&adapter->state_lock, flags);
2022	2228	kfree(rwi);
2023	2229	rc = EBUSY;
2024	2230	break;
2025	2231	}
2026	2232
2027		- if (adapter->force_reset_recovery) {
2028		- adapter->force_reset_recovery = false;
2029		- rc = do_hard_reset(adapter, rwi, reset_state);
	2233	+ if (!saved_state) {
	2234	+ reset_state = adapter->state;
	2235	+ saved_state = true;
	2236	+ }
	2237	+ spin_unlock_irqrestore(&adapter->state_lock, flags);
	2238	+
	2239	+ if (rwi->reset_reason == VNIC_RESET_CHANGE_PARAM) {
	2240	+ /* CHANGE_PARAM requestor holds rtnl_lock */
	2241	+ rc = do_change_param_reset(adapter, rwi, reset_state);
	2242	+ } else if (adapter->force_reset_recovery) {
	2243	+ /*
	2244	+ * Since we are doing a hard reset now, clear the
	2245	+ * failover_pending flag so we don't ignore any
	2246	+ * future MOBILITY or other resets.
	2247	+ */
	2248	+ adapter->failover_pending = false;
	2249	+
	2250	+ /* Transport event occurred during previous reset */
	2251	+ if (adapter->wait_for_reset) {
	2252	+ /* Previous was CHANGE_PARAM; caller locked */
	2253	+ adapter->force_reset_recovery = false;
	2254	+ rc = do_hard_reset(adapter, rwi, reset_state);
	2255	+ } else {
	2256	+ rtnl_lock();
	2257	+ adapter->force_reset_recovery = false;
	2258	+ rc = do_hard_reset(adapter, rwi, reset_state);
	2259	+ rtnl_unlock();
	2260	+ }
	2261	+ if (rc) {
	2262	+ /* give backing device time to settle down */
	2263	+ netdev_dbg(adapter->netdev,
	2264	+ "[S:%d] Hard reset failed, waiting 60 secs\n",
	2265	+ adapter->state);
	2266	+ set_current_state(TASK_UNINTERRUPTIBLE);
	2267	+ schedule_timeout(60 * HZ);
	2268	+ }
2030	2269	} else {
2031	2270	rc = do_reset(adapter, rwi, reset_state);
2032	2271	}
2033	2272	kfree(rwi);
2034		- if (rc && rc != IBMVNIC_INIT_FAILED &&
2035		- !adapter->force_reset_recovery)
2036		- break;
	2273	+ adapter->last_reset_time = jiffies;
	2274	+
	2275	+ if (rc)
	2276	+ netdev_dbg(adapter->netdev, "Reset failed, rc=%d\n", rc);
2037	2277
2038	2278	rwi = get_next_rwi(adapter);
	2279	+
	2280	+ if (rwi && (rwi->reset_reason == VNIC_RESET_FAILOVER \|\|
	2281	+ rwi->reset_reason == VNIC_RESET_MOBILITY))
	2282	+ adapter->force_reset_recovery = true;
2039	2283	}
2040	2284
2041	2285	if (adapter->wait_for_reset) {
2042		- adapter->wait_for_reset = false;
2043	2286	adapter->reset_done_rc = rc;
2044	2287	complete(&adapter->reset_done);
2045	2288	}
2046	2289
2047		- if (rc) {
2048		- netdev_dbg(adapter->netdev, "Reset failed\n");
2049		- free_all_rwi(adapter);
2050		- }
	2290	+ clear_bit_unlock(0, &adapter->resetting);
2051	2291
2052		- adapter->resetting = false;
2053		- if (we_lock_rtnl)
2054		- rtnl_unlock();
	2292	+ netdev_dbg(adapter->netdev,
	2293	+ "[S:%d FRR:%d WFR:%d] Done processing resets\n",
	2294	+ adapter->state, adapter->force_reset_recovery,
	2295	+ adapter->wait_for_reset);
	2296	+}
	2297	+
	2298	+static void __ibmvnic_delayed_reset(struct work_struct *work)
	2299	+{
	2300	+ struct ibmvnic_adapter *adapter;
	2301	+
	2302	+ adapter = container_of(work, struct ibmvnic_adapter,
	2303	+ ibmvnic_delayed_reset.work);
	2304	+ __ibmvnic_reset(&adapter->ibmvnic_reset);
2055	2305	}
2056	2306
2057	2307	static int ibmvnic_reset(struct ibmvnic_adapter *adapter,
..	..	@@ -2063,9 +2313,17 @@
2063	2313	unsigned long flags;
2064	2314	int ret;
2065	2315
	2316	+ spin_lock_irqsave(&adapter->rwi_lock, flags);
	2317	+
	2318	+ /*
	2319	+ * If failover is pending don't schedule any other reset.
	2320	+ * Instead let the failover complete. If there is already a
	2321	+ * a failover reset scheduled, we will detect and drop the
	2322	+ * duplicate reset when walking the ->rwi_list below.
	2323	+ */
2066	2324	if (adapter->state == VNIC_REMOVING \|\|
2067	2325	adapter->state == VNIC_REMOVED \|\|
2068		- adapter->failover_pending) {
	2326	+ (adapter->failover_pending && reason != VNIC_RESET_FAILOVER)) {
2069	2327	ret = EBUSY;
2070	2328	netdev_dbg(netdev, "Adapter removing or pending failover, skipping reset\n");
2071	2329	goto err;
..	..	@@ -2073,17 +2331,16 @@
2073	2331
2074	2332	if (adapter->state == VNIC_PROBING) {
2075	2333	netdev_warn(netdev, "Adapter reset during probe\n");
2076		- ret = adapter->init_done_rc = EAGAIN;
	2334	+ adapter->init_done_rc = EAGAIN;
	2335	+ ret = EAGAIN;
2077	2336	goto err;
2078	2337	}
2079		-
2080		- spin_lock_irqsave(&adapter->rwi_lock, flags);
2081	2338
2082	2339	list_for_each(entry, &adapter->rwi_list) {
2083	2340	tmp = list_entry(entry, struct ibmvnic_rwi, list);
2084	2341	if (tmp->reset_reason == reason) {
2085		- netdev_dbg(netdev, "Skipping matching reset\n");
2086		- spin_unlock_irqrestore(&adapter->rwi_lock, flags);
	2342	+ netdev_dbg(netdev, "Skipping matching reset, reason=%d\n",
	2343	+ reason);
2087	2344	ret = EBUSY;
2088	2345	goto err;
2089	2346	}
..	..	@@ -2091,8 +2348,6 @@
2091	2348
2092	2349	rwi = kzalloc(sizeof(*rwi), GFP_ATOMIC);
2093	2350	if (!rwi) {
2094		- spin_unlock_irqrestore(&adapter->rwi_lock, flags);
2095		- ibmvnic_close(netdev);
2096	2351	ret = ENOMEM;
2097	2352	goto err;
2098	2353	}
..	..	@@ -2100,27 +2355,43 @@
2100	2355	* flush reset queue and process this reset
2101	2356	*/
2102	2357	if (adapter->force_reset_recovery && !list_empty(&adapter->rwi_list)) {
2103		- list_for_each_safe(entry, tmp_entry, &adapter->rwi_list)
	2358	+ list_for_each_safe(entry, tmp_entry, &adapter->rwi_list) {
2104	2359	list_del(entry);
	2360	+ kfree(list_entry(entry, struct ibmvnic_rwi, list));
	2361	+ }
2105	2362	}
2106	2363	rwi->reset_reason = reason;
2107	2364	list_add_tail(&rwi->list, &adapter->rwi_list);
2108		- spin_unlock_irqrestore(&adapter->rwi_lock, flags);
2109		- adapter->resetting = true;
2110	2365	netdev_dbg(adapter->netdev, "Scheduling reset (reason %d)\n", reason);
2111	2366	schedule_work(&adapter->ibmvnic_reset);
2112	2367
2113		- return 0;
	2368	+ ret = 0;
2114	2369	err:
2115		- if (adapter->wait_for_reset)
2116		- adapter->wait_for_reset = false;
	2370	+ /* ibmvnic_close() below can block, so drop the lock first */
	2371	+ spin_unlock_irqrestore(&adapter->rwi_lock, flags);
	2372	+
	2373	+ if (ret == ENOMEM)
	2374	+ ibmvnic_close(netdev);
	2375	+
2117	2376	return -ret;
2118	2377	}
2119	2378
2120		-static void ibmvnic_tx_timeout(struct net_device *dev)
	2379	+static void ibmvnic_tx_timeout(struct net_device *dev, unsigned int txqueue)
2121	2380	{
2122	2381	struct ibmvnic_adapter *adapter = netdev_priv(dev);
2123	2382
	2383	+ if (test_bit(0, &adapter->resetting)) {
	2384	+ netdev_err(adapter->netdev,
	2385	+ "Adapter is resetting, skip timeout reset\n");
	2386	+ return;
	2387	+ }
	2388	+ /* No queuing up reset until at least 5 seconds (default watchdog val)
	2389	+ * after last reset
	2390	+ */
	2391	+ if (time_before(jiffies, (adapter->last_reset_time + dev->watchdog_timeo))) {
	2392	+ netdev_dbg(dev, "Not yet time to tx timeout.\n");
	2393	+ return;
	2394	+ }
2124	2395	ibmvnic_reset(adapter, VNIC_RESET_TIMEOUT);
2125	2396	}
2126	2397
..	..	@@ -2153,7 +2424,7 @@
2153	2424	u16 offset;
2154	2425	u8 flags = 0;
2155	2426
2156		- if (unlikely(adapter->resetting &&
	2427	+ if (unlikely(test_bit(0, &adapter->resetting) &&
2157	2428	adapter->reset_reason != VNIC_RESET_NON_FATAL)) {
2158	2429	enable_scrq_irq(adapter, adapter->rx_scrq[scrq_num]);
2159	2430	napi_complete_done(napi, frames_processed);
..	..	@@ -2252,12 +2523,19 @@
2252	2523	adapter->fallback.rx_entries = adapter->req_rx_add_entries_per_subcrq;
2253	2524	adapter->fallback.tx_entries = adapter->req_tx_entries_per_subcrq;
2254	2525
2255		- init_completion(&adapter->reset_done);
	2526	+ reinit_completion(&adapter->reset_done);
2256	2527	adapter->wait_for_reset = true;
2257	2528	rc = ibmvnic_reset(adapter, VNIC_RESET_CHANGE_PARAM);
2258		- if (rc)
2259		- return rc;
2260		- wait_for_completion(&adapter->reset_done);
	2529	+
	2530	+ if (rc) {
	2531	+ ret = rc;
	2532	+ goto out;
	2533	+ }
	2534	+ rc = ibmvnic_wait_for_completion(adapter, &adapter->reset_done, 60000);
	2535	+ if (rc) {
	2536	+ ret = -ENODEV;
	2537	+ goto out;
	2538	+ }
2261	2539
2262	2540	ret = 0;
2263	2541	if (adapter->reset_done_rc) {
..	..	@@ -2268,13 +2546,21 @@
2268	2546	adapter->desired.rx_entries = adapter->fallback.rx_entries;
2269	2547	adapter->desired.tx_entries = adapter->fallback.tx_entries;
2270	2548
2271		- init_completion(&adapter->reset_done);
	2549	+ reinit_completion(&adapter->reset_done);
2272	2550	adapter->wait_for_reset = true;
2273	2551	rc = ibmvnic_reset(adapter, VNIC_RESET_CHANGE_PARAM);
2274		- if (rc)
2275		- return ret;
2276		- wait_for_completion(&adapter->reset_done);
	2552	+ if (rc) {
	2553	+ ret = rc;
	2554	+ goto out;
	2555	+ }
	2556	+ rc = ibmvnic_wait_for_completion(adapter, &adapter->reset_done,
	2557	+ 60000);
	2558	+ if (rc) {
	2559	+ ret = -ENODEV;
	2560	+ goto out;
	2561	+ }
2277	2562	}
	2563	+out:
2278	2564	adapter->wait_for_reset = false;
2279	2565
2280	2566	return ret;
..	..	@@ -2323,22 +2609,19 @@
2323	2609	static int ibmvnic_get_link_ksettings(struct net_device *netdev,
2324	2610	struct ethtool_link_ksettings *cmd)
2325	2611	{
2326		- u32 supported, advertising;
	2612	+ struct ibmvnic_adapter *adapter = netdev_priv(netdev);
	2613	+ int rc;
2327	2614
2328		- supported = (SUPPORTED_1000baseT_Full \| SUPPORTED_Autoneg \|
2329		- SUPPORTED_FIBRE);
2330		- advertising = (ADVERTISED_1000baseT_Full \| ADVERTISED_Autoneg \|
2331		- ADVERTISED_FIBRE);
2332		- cmd->base.speed = SPEED_1000;
2333		- cmd->base.duplex = DUPLEX_FULL;
	2615	+ rc = send_query_phys_parms(adapter);
	2616	+ if (rc) {
	2617	+ adapter->speed = SPEED_UNKNOWN;
	2618	+ adapter->duplex = DUPLEX_UNKNOWN;
	2619	+ }
	2620	+ cmd->base.speed = adapter->speed;
	2621	+ cmd->base.duplex = adapter->duplex;
2334	2622	cmd->base.port = PORT_FIBRE;
2335	2623	cmd->base.phy_address = 0;
2336	2624	cmd->base.autoneg = AUTONEG_ENABLE;
2337		-
2338		- ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
2339		- supported);
2340		- ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
2341		- advertising);
2342	2625
2343	2626	return 0;
2344	2627	}
..	..	@@ -2504,15 +2787,17 @@
2504	2787	cpu_to_be32(sizeof(struct ibmvnic_statistics));
2505	2788
2506	2789	/* Wait for data to be written */
2507		- init_completion(&adapter->stats_done);
	2790	+ reinit_completion(&adapter->stats_done);
2508	2791	rc = ibmvnic_send_crq(adapter, &crq);
2509	2792	if (rc)
2510	2793	return;
2511		- wait_for_completion(&adapter->stats_done);
	2794	+ rc = ibmvnic_wait_for_completion(adapter, &adapter->stats_done, 10000);
	2795	+ if (rc)
	2796	+ return;
2512	2797
2513	2798	for (i = 0; i < ARRAY_SIZE(ibmvnic_stats); i++)
2514		- data[i] = be64_to_cpu(IBMVNIC_GET_STAT(adapter,
2515		- ibmvnic_stats[i].offset));
	2799	+ data[i] = be64_to_cpu(IBMVNIC_GET_STAT
	2800	+ (adapter, ibmvnic_stats[i].offset));
2516	2801
2517	2802	for (j = 0; j < adapter->req_tx_queues; j++) {
2518	2803	data[i] = adapter->tx_stats_buffers[j].packets;
..	..	@@ -2555,15 +2840,24 @@
2555	2840	{
2556	2841	int rc;
2557	2842
	2843	+ if (!scrq) {
	2844	+ netdev_dbg(adapter->netdev, "Invalid scrq reset.\n");
	2845	+ return -EINVAL;
	2846	+ }
	2847	+
2558	2848	if (scrq->irq) {
2559	2849	free_irq(scrq->irq, scrq);
2560	2850	irq_dispose_mapping(scrq->irq);
2561	2851	scrq->irq = 0;
2562	2852	}
2563		-
2564		- memset(scrq->msgs, 0, 4 * PAGE_SIZE);
2565		- atomic_set(&scrq->used, 0);
2566		- scrq->cur = 0;
	2853	+ if (scrq->msgs) {
	2854	+ memset(scrq->msgs, 0, 4 * PAGE_SIZE);
	2855	+ atomic_set(&scrq->used, 0);
	2856	+ scrq->cur = 0;
	2857	+ } else {
	2858	+ netdev_dbg(adapter->netdev, "Invalid scrq reset\n");
	2859	+ return -EINVAL;
	2860	+ }
2567	2861
2568	2862	rc = h_reg_sub_crq(adapter->vdev->unit_address, scrq->msg_token,
2569	2863	4 * PAGE_SIZE, &scrq->crq_num, &scrq->hw_irq);
..	..	@@ -2759,12 +3053,15 @@
2759	3053	return 1;
2760	3054	}
2761	3055
2762		- if (adapter->resetting &&
	3056	+ if (test_bit(0, &adapter->resetting) &&
2763	3057	adapter->reset_reason == VNIC_RESET_MOBILITY) {
2764	3058	u64 val = (0xff000000) \| scrq->hw_irq;
2765	3059
2766	3060	rc = plpar_hcall_norets(H_EOI, val);
2767		- if (rc)
	3061	+ /* H_EOI would fail with rc = H_FUNCTION when running
	3062	+ * in XIVE mode which is expected, but not an error.
	3063	+ */
	3064	+ if (rc && rc != H_FUNCTION)
2768	3065	dev_err(dev, "H_EOI FAILED irq 0x%llx. rc=%ld\n",
2769	3066	val, rc);
2770	3067	}
..	..	@@ -2907,8 +3204,10 @@
2907	3204	goto req_tx_irq_failed;
2908	3205	}
2909	3206
	3207	+ snprintf(scrq->name, sizeof(scrq->name), "ibmvnic-%x-tx%d",
	3208	+ adapter->vdev->unit_address, i);
2910	3209	rc = request_irq(scrq->irq, ibmvnic_interrupt_tx,
2911		- 0, "ibmvnic_tx", scrq);
	3210	+ 0, scrq->name, scrq);
2912	3211
2913	3212	if (rc) {
2914	3213	dev_err(dev, "Couldn't register tx irq 0x%x. rc=%d\n",
..	..	@@ -2928,8 +3227,10 @@
2928	3227	dev_err(dev, "Error mapping irq\n");
2929	3228	goto req_rx_irq_failed;
2930	3229	}
	3230	+ snprintf(scrq->name, sizeof(scrq->name), "ibmvnic-%x-rx%d",
	3231	+ adapter->vdev->unit_address, i);
2931	3232	rc = request_irq(scrq->irq, ibmvnic_interrupt_rx,
2932		- 0, "ibmvnic_rx", scrq);
	3233	+ 0, scrq->name, scrq);
2933	3234	if (rc) {
2934	3235	dev_err(dev, "Couldn't register rx irq 0x%x. rc=%d\n",
2935	3236	scrq->irq, rc);
..	..	@@ -3039,7 +3340,7 @@
3039	3340	return -1;
3040	3341	}
3041	3342
3042		-static void ibmvnic_send_req_caps(struct ibmvnic_adapter *adapter, int retry)
	3343	+static void send_request_cap(struct ibmvnic_adapter *adapter, int retry)
3043	3344	{
3044	3345	struct device *dev = &adapter->vdev->dev;
3045	3346	union ibmvnic_crq crq;
..	..	@@ -3335,8 +3636,7 @@
3335	3636	if (rc) {
3336	3637	if (rc == H_CLOSED) {
3337	3638	dev_warn(dev, "CRQ Queue closed\n");
3338		- if (adapter->resetting)
3339		- ibmvnic_reset(adapter, VNIC_RESET_FATAL);
	3639	+ /* do not reset, report the fail, wait for passive init from server */
3340	3640	}
3341	3641
3342	3642	dev_warn(dev, "Send error (rc=%d)\n", rc);
..	..	@@ -3347,14 +3647,31 @@
3347	3647
3348	3648	static int ibmvnic_send_crq_init(struct ibmvnic_adapter *adapter)
3349	3649	{
	3650	+ struct device *dev = &adapter->vdev->dev;
3350	3651	union ibmvnic_crq crq;
	3652	+ int retries = 100;
	3653	+ int rc;
3351	3654
3352	3655	memset(&crq, 0, sizeof(crq));
3353	3656	crq.generic.first = IBMVNIC_CRQ_INIT_CMD;
3354	3657	crq.generic.cmd = IBMVNIC_CRQ_INIT;
3355	3658	netdev_dbg(adapter->netdev, "Sending CRQ init\n");
3356	3659
3357		- return ibmvnic_send_crq(adapter, &crq);
	3660	+ do {
	3661	+ rc = ibmvnic_send_crq(adapter, &crq);
	3662	+ if (rc != H_CLOSED)
	3663	+ break;
	3664	+ retries--;
	3665	+ msleep(50);
	3666	+
	3667	+ } while (retries > 0);
	3668	+
	3669	+ if (rc) {
	3670	+ dev_err(dev, "Failed to send init request, rc = %d\n", rc);
	3671	+ return rc;
	3672	+ }
	3673	+
	3674	+ return 0;
3358	3675	}
3359	3676
3360	3677	static int send_version_xchg(struct ibmvnic_adapter *adapter)
..	..	@@ -3423,15 +3740,16 @@
3423	3740	struct ibmvnic_login_rsp_buffer *login_rsp_buffer;
3424	3741	struct ibmvnic_login_buffer *login_buffer;
3425	3742	struct device *dev = &adapter->vdev->dev;
	3743	+ struct vnic_login_client_data *vlcd;
3426	3744	dma_addr_t rsp_buffer_token;
3427	3745	dma_addr_t buffer_token;
3428	3746	size_t rsp_buffer_size;
3429	3747	union ibmvnic_crq crq;
	3748	+ int client_data_len;
3430	3749	size_t buffer_size;
3431	3750	__be64 *tx_list_p;
3432	3751	__be64 *rx_list_p;
3433		- int client_data_len;
3434		- struct vnic_login_client_data *vlcd;
	3752	+ int rc;
3435	3753	int i;
3436	3754
3437	3755	if (!adapter->tx_scrq \|\| !adapter->rx_scrq) {
..	..	@@ -3440,7 +3758,9 @@
3440	3758	return -1;
3441	3759	}
3442	3760
	3761	+ release_login_buffer(adapter);
3443	3762	release_login_rsp_buffer(adapter);
	3763	+
3444	3764	client_data_len = vnic_client_data_len(adapter);
3445	3765
3446	3766	buffer_size =
..	..	@@ -3535,16 +3855,25 @@
3535	3855	crq.login.cmd = LOGIN;
3536	3856	crq.login.ioba = cpu_to_be32(buffer_token);
3537	3857	crq.login.len = cpu_to_be32(buffer_size);
3538		- ibmvnic_send_crq(adapter, &crq);
	3858	+
	3859	+ adapter->login_pending = true;
	3860	+ rc = ibmvnic_send_crq(adapter, &crq);
	3861	+ if (rc) {
	3862	+ adapter->login_pending = false;
	3863	+ netdev_err(adapter->netdev, "Failed to send login, rc=%d\n", rc);
	3864	+ goto buf_rsp_map_failed;
	3865	+ }
3539	3866
3540	3867	return 0;
3541	3868
3542	3869	buf_rsp_map_failed:
3543	3870	kfree(login_rsp_buffer);
	3871	+ adapter->login_rsp_buf = NULL;
3544	3872	buf_rsp_alloc_failed:
3545	3873	dma_unmap_single(dev, buffer_token, buffer_size, DMA_TO_DEVICE);
3546	3874	buf_map_failed:
3547	3875	kfree(login_buffer);
	3876	+ adapter->login_buf = NULL;
3548	3877	buf_alloc_failed:
3549	3878	return -1;
3550	3879	}
..	..	@@ -3574,7 +3903,7 @@
3574	3903	return ibmvnic_send_crq(adapter, &crq);
3575	3904	}
3576	3905
3577		-static void send_map_query(struct ibmvnic_adapter *adapter)
	3906	+static void send_query_map(struct ibmvnic_adapter *adapter)
3578	3907	{
3579	3908	union ibmvnic_crq crq;
3580	3909
..	..	@@ -3585,7 +3914,7 @@
3585	3914	}
3586	3915
3587	3916	/* Send a series of CRQs requesting various capabilities of the VNIC server */
3588		-static void send_cap_queries(struct ibmvnic_adapter *adapter)
	3917	+static void send_query_cap(struct ibmvnic_adapter *adapter)
3589	3918	{
3590	3919	union ibmvnic_crq crq;
3591	3920	int cap_reqs;
..	..	@@ -3716,6 +4045,113 @@
3716	4045	WARN_ON(cap_reqs != 0);
3717	4046	}
3718	4047
	4048	+static void send_query_ip_offload(struct ibmvnic_adapter *adapter)
	4049	+{
	4050	+ int buf_sz = sizeof(struct ibmvnic_query_ip_offload_buffer);
	4051	+ struct device *dev = &adapter->vdev->dev;
	4052	+ union ibmvnic_crq crq;
	4053	+
	4054	+ adapter->ip_offload_tok =
	4055	+ dma_map_single(dev,
	4056	+ &adapter->ip_offload_buf,
	4057	+ buf_sz,
	4058	+ DMA_FROM_DEVICE);
	4059	+
	4060	+ if (dma_mapping_error(dev, adapter->ip_offload_tok)) {
	4061	+ if (!firmware_has_feature(FW_FEATURE_CMO))
	4062	+ dev_err(dev, "Couldn't map offload buffer\n");
	4063	+ return;
	4064	+ }
	4065	+
	4066	+ memset(&crq, 0, sizeof(crq));
	4067	+ crq.query_ip_offload.first = IBMVNIC_CRQ_CMD;
	4068	+ crq.query_ip_offload.cmd = QUERY_IP_OFFLOAD;
	4069	+ crq.query_ip_offload.len = cpu_to_be32(buf_sz);
	4070	+ crq.query_ip_offload.ioba =
	4071	+ cpu_to_be32(adapter->ip_offload_tok);
	4072	+
	4073	+ ibmvnic_send_crq(adapter, &crq);
	4074	+}
	4075	+
	4076	+static void send_control_ip_offload(struct ibmvnic_adapter *adapter)
	4077	+{
	4078	+ struct ibmvnic_control_ip_offload_buffer *ctrl_buf = &adapter->ip_offload_ctrl;
	4079	+ struct ibmvnic_query_ip_offload_buffer *buf = &adapter->ip_offload_buf;
	4080	+ struct device *dev = &adapter->vdev->dev;
	4081	+ netdev_features_t old_hw_features = 0;
	4082	+ union ibmvnic_crq crq;
	4083	+
	4084	+ adapter->ip_offload_ctrl_tok =
	4085	+ dma_map_single(dev,
	4086	+ ctrl_buf,
	4087	+ sizeof(adapter->ip_offload_ctrl),
	4088	+ DMA_TO_DEVICE);
	4089	+
	4090	+ if (dma_mapping_error(dev, adapter->ip_offload_ctrl_tok)) {
	4091	+ dev_err(dev, "Couldn't map ip offload control buffer\n");
	4092	+ return;
	4093	+ }
	4094	+
	4095	+ ctrl_buf->len = cpu_to_be32(sizeof(adapter->ip_offload_ctrl));
	4096	+ ctrl_buf->version = cpu_to_be32(INITIAL_VERSION_IOB);
	4097	+ ctrl_buf->ipv4_chksum = buf->ipv4_chksum;
	4098	+ ctrl_buf->ipv6_chksum = buf->ipv6_chksum;
	4099	+ ctrl_buf->tcp_ipv4_chksum = buf->tcp_ipv4_chksum;
	4100	+ ctrl_buf->udp_ipv4_chksum = buf->udp_ipv4_chksum;
	4101	+ ctrl_buf->tcp_ipv6_chksum = buf->tcp_ipv6_chksum;
	4102	+ ctrl_buf->udp_ipv6_chksum = buf->udp_ipv6_chksum;
	4103	+ ctrl_buf->large_tx_ipv4 = buf->large_tx_ipv4;
	4104	+ ctrl_buf->large_tx_ipv6 = buf->large_tx_ipv6;
	4105	+
	4106	+ /* large_rx disabled for now, additional features needed */
	4107	+ ctrl_buf->large_rx_ipv4 = 0;
	4108	+ ctrl_buf->large_rx_ipv6 = 0;
	4109	+
	4110	+ if (adapter->state != VNIC_PROBING) {
	4111	+ old_hw_features = adapter->netdev->hw_features;
	4112	+ adapter->netdev->hw_features = 0;
	4113	+ }
	4114	+
	4115	+ adapter->netdev->hw_features = NETIF_F_SG \| NETIF_F_GSO \| NETIF_F_GRO;
	4116	+
	4117	+ if (buf->tcp_ipv4_chksum \|\| buf->udp_ipv4_chksum)
	4118	+ adapter->netdev->hw_features \|= NETIF_F_IP_CSUM;
	4119	+
	4120	+ if (buf->tcp_ipv6_chksum \|\| buf->udp_ipv6_chksum)
	4121	+ adapter->netdev->hw_features \|= NETIF_F_IPV6_CSUM;
	4122	+
	4123	+ if ((adapter->netdev->features &
	4124	+ (NETIF_F_IP_CSUM \| NETIF_F_IPV6_CSUM)))
	4125	+ adapter->netdev->hw_features \|= NETIF_F_RXCSUM;
	4126	+
	4127	+ if (buf->large_tx_ipv4)
	4128	+ adapter->netdev->hw_features \|= NETIF_F_TSO;
	4129	+ if (buf->large_tx_ipv6)
	4130	+ adapter->netdev->hw_features \|= NETIF_F_TSO6;
	4131	+
	4132	+ if (adapter->state == VNIC_PROBING) {
	4133	+ adapter->netdev->features \|= adapter->netdev->hw_features;
	4134	+ } else if (old_hw_features != adapter->netdev->hw_features) {
	4135	+ netdev_features_t tmp = 0;
	4136	+
	4137	+ /* disable features no longer supported */
	4138	+ adapter->netdev->features &= adapter->netdev->hw_features;
	4139	+ /* turn on features now supported if previously enabled */
	4140	+ tmp = (old_hw_features ^ adapter->netdev->hw_features) &
	4141	+ adapter->netdev->hw_features;
	4142	+ adapter->netdev->features \|=
	4143	+ tmp & adapter->netdev->wanted_features;
	4144	+ }
	4145	+
	4146	+ memset(&crq, 0, sizeof(crq));
	4147	+ crq.control_ip_offload.first = IBMVNIC_CRQ_CMD;
	4148	+ crq.control_ip_offload.cmd = CONTROL_IP_OFFLOAD;
	4149	+ crq.control_ip_offload.len =
	4150	+ cpu_to_be32(sizeof(adapter->ip_offload_ctrl));
	4151	+ crq.control_ip_offload.ioba = cpu_to_be32(adapter->ip_offload_ctrl_tok);
	4152	+ ibmvnic_send_crq(adapter, &crq);
	4153	+}
	4154	+
3719	4155	static void handle_vpd_size_rsp(union ibmvnic_crq *crq,
3720	4156	struct ibmvnic_adapter *adapter)
3721	4157	{
..	..	@@ -3785,7 +4221,6 @@
3785	4221	{
3786	4222	struct device *dev = &adapter->vdev->dev;
3787	4223	struct ibmvnic_query_ip_offload_buffer *buf = &adapter->ip_offload_buf;
3788		- union ibmvnic_crq crq;
3789	4224	int i;
3790	4225
3791	4226	dma_unmap_single(dev, adapter->ip_offload_tok,
..	..	@@ -3835,57 +4270,7 @@
3835	4270	netdev_dbg(adapter->netdev, "off_ipv6_ext_hd = %d\n",
3836	4271	buf->off_ipv6_ext_headers);
3837	4272
3838		- adapter->ip_offload_ctrl_tok =
3839		- dma_map_single(dev, &adapter->ip_offload_ctrl,
3840		- sizeof(adapter->ip_offload_ctrl), DMA_TO_DEVICE);
3841		-
3842		- if (dma_mapping_error(dev, adapter->ip_offload_ctrl_tok)) {
3843		- dev_err(dev, "Couldn't map ip offload control buffer\n");
3844		- return;
3845		- }
3846		-
3847		- adapter->ip_offload_ctrl.len =
3848		- cpu_to_be32(sizeof(adapter->ip_offload_ctrl));
3849		- adapter->ip_offload_ctrl.version = cpu_to_be32(INITIAL_VERSION_IOB);
3850		- adapter->ip_offload_ctrl.ipv4_chksum = buf->ipv4_chksum;
3851		- adapter->ip_offload_ctrl.ipv6_chksum = buf->ipv6_chksum;
3852		- adapter->ip_offload_ctrl.tcp_ipv4_chksum = buf->tcp_ipv4_chksum;
3853		- adapter->ip_offload_ctrl.udp_ipv4_chksum = buf->udp_ipv4_chksum;
3854		- adapter->ip_offload_ctrl.tcp_ipv6_chksum = buf->tcp_ipv6_chksum;
3855		- adapter->ip_offload_ctrl.udp_ipv6_chksum = buf->udp_ipv6_chksum;
3856		- adapter->ip_offload_ctrl.large_tx_ipv4 = buf->large_tx_ipv4;
3857		- adapter->ip_offload_ctrl.large_tx_ipv6 = buf->large_tx_ipv6;
3858		-
3859		- /* large_rx disabled for now, additional features needed */
3860		- adapter->ip_offload_ctrl.large_rx_ipv4 = 0;
3861		- adapter->ip_offload_ctrl.large_rx_ipv6 = 0;
3862		-
3863		- adapter->netdev->features = NETIF_F_SG \| NETIF_F_GSO;
3864		-
3865		- if (buf->tcp_ipv4_chksum \|\| buf->udp_ipv4_chksum)
3866		- adapter->netdev->features \|= NETIF_F_IP_CSUM;
3867		-
3868		- if (buf->tcp_ipv6_chksum \|\| buf->udp_ipv6_chksum)
3869		- adapter->netdev->features \|= NETIF_F_IPV6_CSUM;
3870		-
3871		- if ((adapter->netdev->features &
3872		- (NETIF_F_IP_CSUM \| NETIF_F_IPV6_CSUM)))
3873		- adapter->netdev->features \|= NETIF_F_RXCSUM;
3874		-
3875		- if (buf->large_tx_ipv4)
3876		- adapter->netdev->features \|= NETIF_F_TSO;
3877		- if (buf->large_tx_ipv6)
3878		- adapter->netdev->features \|= NETIF_F_TSO6;
3879		-
3880		- adapter->netdev->hw_features \|= adapter->netdev->features;
3881		-
3882		- memset(&crq, 0, sizeof(crq));
3883		- crq.control_ip_offload.first = IBMVNIC_CRQ_CMD;
3884		- crq.control_ip_offload.cmd = CONTROL_IP_OFFLOAD;
3885		- crq.control_ip_offload.len =
3886		- cpu_to_be32(sizeof(adapter->ip_offload_ctrl));
3887		- crq.control_ip_offload.ioba = cpu_to_be32(adapter->ip_offload_ctrl_tok);
3888		- ibmvnic_send_crq(adapter, &crq);
	4273	+ send_control_ip_offload(adapter);
3889	4274	}
3890	4275
3891	4276	static const char *ibmvnic_fw_err_cause(u16 cause)
..	..	@@ -3942,8 +4327,13 @@
3942	4327	dev_err(dev, "Error %ld in CHANGE_MAC_ADDR_RSP\n", rc);
3943	4328	goto out;
3944	4329	}
3945		- memcpy(netdev->dev_addr, &crq->change_mac_addr_rsp.mac_addr[0],
3946		- ETH_ALEN);
	4330	+ /* crq->change_mac_addr.mac_addr is the requested one
	4331	+ * crq->change_mac_addr_rsp.mac_addr is the returned valid one.
	4332	+ */
	4333	+ ether_addr_copy(netdev->dev_addr,
	4334	+ &crq->change_mac_addr_rsp.mac_addr[0]);
	4335	+ ether_addr_copy(adapter->mac_addr,
	4336	+ &crq->change_mac_addr_rsp.mac_addr[0]);
3947	4337	out:
3948	4338	complete(&adapter->fw_done);
3949	4339	return rc;
..	..	@@ -4013,7 +4403,7 @@
4013	4403	be64_to_cpu(crq->request_capability_rsp.number);
4014	4404	}
4015	4405
4016		- ibmvnic_send_req_caps(adapter, 1);
	4406	+ send_request_cap(adapter, 1);
4017	4407	return;
4018	4408	default:
4019	4409	dev_err(dev, "Error %d in request cap rsp\n",
..	..	@@ -4023,30 +4413,8 @@
4023	4413
4024	4414	/* Done receiving requested capabilities, query IP offload support */
4025	4415	if (atomic_read(&adapter->running_cap_crqs) == 0) {
4026		- union ibmvnic_crq newcrq;
4027		- int buf_sz = sizeof(struct ibmvnic_query_ip_offload_buffer);
4028		- struct ibmvnic_query_ip_offload_buffer *ip_offload_buf =
4029		- &adapter->ip_offload_buf;
4030		-
4031	4416	adapter->wait_capability = false;
4032		- adapter->ip_offload_tok = dma_map_single(dev, ip_offload_buf,
4033		- buf_sz,
4034		- DMA_FROM_DEVICE);
4035		-
4036		- if (dma_mapping_error(dev, adapter->ip_offload_tok)) {
4037		- if (!firmware_has_feature(FW_FEATURE_CMO))
4038		- dev_err(dev, "Couldn't map offload buffer\n");
4039		- return;
4040		- }
4041		-
4042		- memset(&newcrq, 0, sizeof(newcrq));
4043		- newcrq.query_ip_offload.first = IBMVNIC_CRQ_CMD;
4044		- newcrq.query_ip_offload.cmd = QUERY_IP_OFFLOAD;
4045		- newcrq.query_ip_offload.len = cpu_to_be32(buf_sz);
4046		- newcrq.query_ip_offload.ioba =
4047		- cpu_to_be32(adapter->ip_offload_tok);
4048		-
4049		- ibmvnic_send_crq(adapter, &newcrq);
	4417	+ send_query_ip_offload(adapter);
4050	4418	}
4051	4419	}
4052	4420
..	..	@@ -4057,7 +4425,21 @@
4057	4425	struct net_device *netdev = adapter->netdev;
4058	4426	struct ibmvnic_login_rsp_buffer *login_rsp = adapter->login_rsp_buf;
4059	4427	struct ibmvnic_login_buffer *login = adapter->login_buf;
	4428	+ u64 *tx_handle_array;
	4429	+ u64 *rx_handle_array;
	4430	+ int num_tx_pools;
	4431	+ int num_rx_pools;
	4432	+ u64 *size_array;
4060	4433	int i;
	4434	+
	4435	+ /* CHECK: Test/set of login_pending does not need to be atomic
	4436	+ * because only ibmvnic_tasklet tests/clears this.
	4437	+ */
	4438	+ if (!adapter->login_pending) {
	4439	+ netdev_warn(netdev, "Ignoring unexpected login response\n");
	4440	+ return 0;
	4441	+ }
	4442	+ adapter->login_pending = false;
4061	4443
4062	4444	dma_unmap_single(dev, adapter->login_buf_token, adapter->login_buf_sz,
4063	4445	DMA_TO_DEVICE);
..	..	@@ -4096,9 +4478,33 @@
4096	4478	adapter->req_rx_add_queues !=
4097	4479	be32_to_cpu(login_rsp->num_rxadd_subcrqs))) {
4098	4480	dev_err(dev, "FATAL: Inconsistent login and login rsp\n");
4099		- ibmvnic_remove(adapter->vdev);
	4481	+ ibmvnic_reset(adapter, VNIC_RESET_FATAL);
4100	4482	return -EIO;
4101	4483	}
	4484	+ size_array = (u64 )((u8 )(adapter->login_rsp_buf) +
	4485	+ be32_to_cpu(adapter->login_rsp_buf->off_rxadd_buff_size));
	4486	+ /* variable buffer sizes are not supported, so just read the
	4487	+ * first entry.
	4488	+ */
	4489	+ adapter->cur_rx_buf_sz = be64_to_cpu(size_array[0]);
	4490	+
	4491	+ num_tx_pools = be32_to_cpu(adapter->login_rsp_buf->num_txsubm_subcrqs);
	4492	+ num_rx_pools = be32_to_cpu(adapter->login_rsp_buf->num_rxadd_subcrqs);
	4493	+
	4494	+ tx_handle_array = (u64 )((u8 )(adapter->login_rsp_buf) +
	4495	+ be32_to_cpu(adapter->login_rsp_buf->off_txsubm_subcrqs));
	4496	+ rx_handle_array = (u64 )((u8 )(adapter->login_rsp_buf) +
	4497	+ be32_to_cpu(adapter->login_rsp_buf->off_rxadd_subcrqs));
	4498	+
	4499	+ for (i = 0; i < num_tx_pools; i++)
	4500	+ adapter->tx_scrq[i]->handle = tx_handle_array[i];
	4501	+
	4502	+ for (i = 0; i < num_rx_pools; i++)
	4503	+ adapter->rx_scrq[i]->handle = rx_handle_array[i];
	4504	+
	4505	+ adapter->num_active_tx_scrqs = num_tx_pools;
	4506	+ adapter->num_active_rx_scrqs = num_rx_pools;
	4507	+ release_login_rsp_buffer(adapter);
4102	4508	release_login_buffer(adapter);
4103	4509	complete(&adapter->init_done);
4104	4510
..	..	@@ -4308,8 +4714,92 @@
4308	4714	out:
4309	4715	if (atomic_read(&adapter->running_cap_crqs) == 0) {
4310	4716	adapter->wait_capability = false;
4311		- ibmvnic_send_req_caps(adapter, 0);
	4717	+ send_request_cap(adapter, 0);
4312	4718	}
	4719	+}
	4720	+
	4721	+static int send_query_phys_parms(struct ibmvnic_adapter *adapter)
	4722	+{
	4723	+ union ibmvnic_crq crq;
	4724	+ int rc;
	4725	+
	4726	+ memset(&crq, 0, sizeof(crq));
	4727	+ crq.query_phys_parms.first = IBMVNIC_CRQ_CMD;
	4728	+ crq.query_phys_parms.cmd = QUERY_PHYS_PARMS;
	4729	+
	4730	+ mutex_lock(&adapter->fw_lock);
	4731	+ adapter->fw_done_rc = 0;
	4732	+ reinit_completion(&adapter->fw_done);
	4733	+
	4734	+ rc = ibmvnic_send_crq(adapter, &crq);
	4735	+ if (rc) {
	4736	+ mutex_unlock(&adapter->fw_lock);
	4737	+ return rc;
	4738	+ }
	4739	+
	4740	+ rc = ibmvnic_wait_for_completion(adapter, &adapter->fw_done, 10000);
	4741	+ if (rc) {
	4742	+ mutex_unlock(&adapter->fw_lock);
	4743	+ return rc;
	4744	+ }
	4745	+
	4746	+ mutex_unlock(&adapter->fw_lock);
	4747	+ return adapter->fw_done_rc ? -EIO : 0;
	4748	+}
	4749	+
	4750	+static int handle_query_phys_parms_rsp(union ibmvnic_crq *crq,
	4751	+ struct ibmvnic_adapter *adapter)
	4752	+{
	4753	+ struct net_device *netdev = adapter->netdev;
	4754	+ int rc;
	4755	+ __be32 rspeed = cpu_to_be32(crq->query_phys_parms_rsp.speed);
	4756	+
	4757	+ rc = crq->query_phys_parms_rsp.rc.code;
	4758	+ if (rc) {
	4759	+ netdev_err(netdev, "Error %d in QUERY_PHYS_PARMS\n", rc);
	4760	+ return rc;
	4761	+ }
	4762	+ switch (rspeed) {
	4763	+ case IBMVNIC_10MBPS:
	4764	+ adapter->speed = SPEED_10;
	4765	+ break;
	4766	+ case IBMVNIC_100MBPS:
	4767	+ adapter->speed = SPEED_100;
	4768	+ break;
	4769	+ case IBMVNIC_1GBPS:
	4770	+ adapter->speed = SPEED_1000;
	4771	+ break;
	4772	+ case IBMVNIC_10GBPS:
	4773	+ adapter->speed = SPEED_10000;
	4774	+ break;
	4775	+ case IBMVNIC_25GBPS:
	4776	+ adapter->speed = SPEED_25000;
	4777	+ break;
	4778	+ case IBMVNIC_40GBPS:
	4779	+ adapter->speed = SPEED_40000;
	4780	+ break;
	4781	+ case IBMVNIC_50GBPS:
	4782	+ adapter->speed = SPEED_50000;
	4783	+ break;
	4784	+ case IBMVNIC_100GBPS:
	4785	+ adapter->speed = SPEED_100000;
	4786	+ break;
	4787	+ case IBMVNIC_200GBPS:
	4788	+ adapter->speed = SPEED_200000;
	4789	+ break;
	4790	+ default:
	4791	+ if (netif_carrier_ok(netdev))
	4792	+ netdev_warn(netdev, "Unknown speed 0x%08x\n", rspeed);
	4793	+ adapter->speed = SPEED_UNKNOWN;
	4794	+ }
	4795	+ if (crq->query_phys_parms_rsp.flags1 & IBMVNIC_FULL_DUPLEX)
	4796	+ adapter->duplex = DUPLEX_FULL;
	4797	+ else if (crq->query_phys_parms_rsp.flags1 & IBMVNIC_HALF_DUPLEX)
	4798	+ adapter->duplex = DUPLEX_HALF;
	4799	+ else
	4800	+ adapter->duplex = DUPLEX_UNKNOWN;
	4801	+
	4802	+ return rc;
4313	4803	}
4314	4804
4315	4805	static void ibmvnic_handle_crq(union ibmvnic_crq *crq,
..	..	@@ -4330,12 +4820,31 @@
4330	4820	case IBMVNIC_CRQ_INIT:
4331	4821	dev_info(dev, "Partner initialized\n");
4332	4822	adapter->from_passive_init = true;
4333		- adapter->failover_pending = false;
	4823	+ /* Discard any stale login responses from prev reset.
	4824	+ * CHECK: should we clear even on INIT_COMPLETE?
	4825	+ */
	4826	+ adapter->login_pending = false;
	4827	+
4334	4828	if (!completion_done(&adapter->init_done)) {
4335	4829	complete(&adapter->init_done);
4336	4830	adapter->init_done_rc = -EIO;
4337	4831	}
4338		- ibmvnic_reset(adapter, VNIC_RESET_FAILOVER);
	4832	+ rc = ibmvnic_reset(adapter, VNIC_RESET_FAILOVER);
	4833	+ if (rc && rc != -EBUSY) {
	4834	+ /* We were unable to schedule the failover
	4835	+ * reset either because the adapter was still
	4836	+ * probing (eg: during kexec) or we could not
	4837	+ * allocate memory. Clear the failover_pending
	4838	+ * flag since no one else will. We ignore
	4839	+ * EBUSY because it means either FAILOVER reset
	4840	+ * is already scheduled or the adapter is
	4841	+ * being removed.
	4842	+ */
	4843	+ netdev_err(netdev,
	4844	+ "Error %ld scheduling failover reset\n",
	4845	+ rc);
	4846	+ adapter->failover_pending = false;
	4847	+ }
4339	4848	break;
4340	4849	case IBMVNIC_CRQ_INIT_COMPLETE:
4341	4850	dev_info(dev, "Partner initialization complete\n");
..	..	@@ -4349,7 +4858,23 @@
4349	4858	case IBMVNIC_CRQ_XPORT_EVENT:
4350	4859	netif_carrier_off(netdev);
4351	4860	adapter->crq.active = false;
4352		- if (adapter->resetting)
	4861	+ /* terminate any thread waiting for a response
	4862	+ * from the device
	4863	+ */
	4864	+ if (!completion_done(&adapter->fw_done)) {
	4865	+ adapter->fw_done_rc = -EIO;
	4866	+ complete(&adapter->fw_done);
	4867	+ }
	4868	+
	4869	+ /* if we got here during crq-init, retry crq-init */
	4870	+ if (!completion_done(&adapter->init_done)) {
	4871	+ adapter->init_done_rc = -EAGAIN;
	4872	+ complete(&adapter->init_done);
	4873	+ }
	4874	+
	4875	+ if (!completion_done(&adapter->stats_done))
	4876	+ complete(&adapter->stats_done);
	4877	+ if (test_bit(0, &adapter->resetting))
4353	4878	adapter->force_reset_recovery = true;
4354	4879	if (gen_crq->cmd == IBMVNIC_PARTITION_MIGRATED) {
4355	4880	dev_info(dev, "Migrated, re-enabling adapter\n");
..	..	@@ -4383,7 +4908,7 @@
4383	4908	be16_to_cpu(crq->version_exchange_rsp.version);
4384	4909	dev_info(dev, "Partner protocol version is %d\n",
4385	4910	ibmvnic_version);
4386		- send_cap_queries(adapter);
	4911	+ send_query_cap(adapter);
4387	4912	break;
4388	4913	case QUERY_CAPABILITY_RSP:
4389	4914	handle_query_cap_rsp(crq, adapter);
..	..	@@ -4421,6 +4946,10 @@
4421	4946	crq->link_state_indication.phys_link_state;
4422	4947	adapter->logical_link_state =
4423	4948	crq->link_state_indication.logical_link_state;
	4949	+ if (adapter->phys_link_state && adapter->logical_link_state)
	4950	+ netif_carrier_on(netdev);
	4951	+ else
	4952	+ netif_carrier_off(netdev);
4424	4953	break;
4425	4954	case CHANGE_MAC_ADDR_RSP:
4426	4955	netdev_dbg(netdev, "Got MAC address change Response\n");
..	..	@@ -4458,6 +4987,10 @@
4458	4987	case GET_VPD_RSP:
4459	4988	handle_vpd_rsp(crq, adapter);
4460	4989	break;
	4990	+ case QUERY_PHYS_PARMS_RSP:
	4991	+ adapter->fw_done_rc = handle_query_phys_parms_rsp(crq, adapter);
	4992	+ complete(&adapter->fw_done);
	4993	+ break;
4461	4994	default:
4462	4995	netdev_err(netdev, "Got an invalid cmd type 0x%02x\n",
4463	4996	gen_crq->cmd);
..	..	@@ -4472,9 +5005,9 @@
4472	5005	return IRQ_HANDLED;
4473	5006	}
4474	5007
4475		-static void ibmvnic_tasklet(void *data)
	5008	+static void ibmvnic_tasklet(struct tasklet_struct *t)
4476	5009	{
4477		- struct ibmvnic_adapter *adapter = data;
	5010	+ struct ibmvnic_adapter *adapter = from_tasklet(adapter, t, tasklet);
4478	5011	struct ibmvnic_crq_queue *queue = &adapter->crq;
4479	5012	union ibmvnic_crq *crq;
4480	5013	unsigned long flags;
..	..	@@ -4612,12 +5145,12 @@
4612	5145
4613	5146	retrc = 0;
4614	5147
4615		- tasklet_init(&adapter->tasklet, (void *)ibmvnic_tasklet,
4616		- (unsigned long)adapter);
	5148	+ tasklet_setup(&adapter->tasklet, (void *)ibmvnic_tasklet);
4617	5149
4618	5150	netdev_dbg(adapter->netdev, "registering irq 0x%x\n", vdev->irq);
4619		- rc = request_irq(vdev->irq, ibmvnic_interrupt, 0, IBMVNIC_NAME,
4620		- adapter);
	5151	+ snprintf(crq->name, sizeof(crq->name), "ibmvnic-%x",
	5152	+ adapter->vdev->unit_address);
	5153	+ rc = request_irq(vdev->irq, ibmvnic_interrupt, 0, crq->name, adapter);
4621	5154	if (rc) {
4622	5155	dev_err(dev, "Couldn't register irq 0x%x. rc=%d\n",
4623	5156	vdev->irq, rc);
..	..	@@ -4651,21 +5184,26 @@
4651	5184	return retrc;
4652	5185	}
4653	5186
4654		-static int ibmvnic_reset_init(struct ibmvnic_adapter *adapter)
	5187	+static int ibmvnic_reset_init(struct ibmvnic_adapter *adapter, bool reset)
4655	5188	{
4656	5189	struct device *dev = &adapter->vdev->dev;
4657		- unsigned long timeout = msecs_to_jiffies(30000);
4658		- u64 old_num_rx_queues, old_num_tx_queues;
	5190	+ unsigned long timeout = msecs_to_jiffies(20000);
	5191	+ u64 old_num_rx_queues = adapter->req_rx_queues;
	5192	+ u64 old_num_tx_queues = adapter->req_tx_queues;
4659	5193	int rc;
4660	5194
4661	5195	adapter->from_passive_init = false;
4662	5196
4663		- old_num_rx_queues = adapter->req_rx_queues;
4664		- old_num_tx_queues = adapter->req_tx_queues;
	5197	+ if (reset)
	5198	+ reinit_completion(&adapter->init_done);
4665	5199
4666		- reinit_completion(&adapter->init_done);
4667	5200	adapter->init_done_rc = 0;
4668		- ibmvnic_send_crq_init(adapter);
	5201	+ rc = ibmvnic_send_crq_init(adapter);
	5202	+ if (rc) {
	5203	+ dev_err(dev, "Send crq init failed with error %d\n", rc);
	5204	+ return rc;
	5205	+ }
	5206	+
4669	5207	if (!wait_for_completion_timeout(&adapter->init_done, timeout)) {
4670	5208	dev_err(dev, "Initialization sequence timed out\n");
4671	5209	return -1;
..	..	@@ -4682,61 +5220,29 @@
4682	5220	return -1;
4683	5221	}
4684	5222
4685		- if (adapter->resetting && !adapter->wait_for_reset &&
	5223	+ if (reset &&
	5224	+ test_bit(0, &adapter->resetting) && !adapter->wait_for_reset &&
4686	5225	adapter->reset_reason != VNIC_RESET_MOBILITY) {
4687	5226	if (adapter->req_rx_queues != old_num_rx_queues \|\|
4688	5227	adapter->req_tx_queues != old_num_tx_queues) {
4689	5228	release_sub_crqs(adapter, 0);
4690	5229	rc = init_sub_crqs(adapter);
4691	5230	} else {
	5231	+ /* no need to reinitialize completely, but we do
	5232	+ * need to clean up transmits that were in flight
	5233	+ * when we processed the reset. Failure to do so
	5234	+ * will confound the upper layer, usually TCP, by
	5235	+ * creating the illusion of transmits that are
	5236	+ * awaiting completion.
	5237	+ */
	5238	+ clean_tx_pools(adapter);
	5239	+
4692	5240	rc = reset_sub_crq_queues(adapter);
4693	5241	}
4694	5242	} else {
4695	5243	rc = init_sub_crqs(adapter);
4696	5244	}
4697	5245
4698		- if (rc) {
4699		- dev_err(dev, "Initialization of sub crqs failed\n");
4700		- release_crq_queue(adapter);
4701		- return rc;
4702		- }
4703		-
4704		- rc = init_sub_crq_irqs(adapter);
4705		- if (rc) {
4706		- dev_err(dev, "Failed to initialize sub crq irqs\n");
4707		- release_crq_queue(adapter);
4708		- }
4709		-
4710		- return rc;
4711		-}
4712		-
4713		-static int ibmvnic_init(struct ibmvnic_adapter *adapter)
4714		-{
4715		- struct device *dev = &adapter->vdev->dev;
4716		- unsigned long timeout = msecs_to_jiffies(30000);
4717		- int rc;
4718		-
4719		- adapter->from_passive_init = false;
4720		-
4721		- adapter->init_done_rc = 0;
4722		- ibmvnic_send_crq_init(adapter);
4723		- if (!wait_for_completion_timeout(&adapter->init_done, timeout)) {
4724		- dev_err(dev, "Initialization sequence timed out\n");
4725		- return -1;
4726		- }
4727		-
4728		- if (adapter->init_done_rc) {
4729		- release_crq_queue(adapter);
4730		- return adapter->init_done_rc;
4731		- }
4732		-
4733		- if (adapter->from_passive_init) {
4734		- adapter->state = VNIC_OPEN;
4735		- adapter->from_passive_init = false;
4736		- return -1;
4737		- }
4738		-
4739		- rc = init_sub_crqs(adapter);
4740	5246	if (rc) {
4741	5247	dev_err(dev, "Initialization of sub crqs failed\n");
4742	5248	release_crq_queue(adapter);
..	..	@@ -4783,6 +5289,7 @@
4783	5289	dev_set_drvdata(&dev->dev, netdev);
4784	5290	adapter->vdev = dev;
4785	5291	adapter->netdev = netdev;
	5292	+ adapter->login_pending = false;
4786	5293
4787	5294	ether_addr_copy(adapter->mac_addr, mac_addr_p);
4788	5295	ether_addr_copy(netdev->dev_addr, adapter->mac_addr);
..	..	@@ -4794,12 +5301,17 @@
4794	5301	spin_lock_init(&adapter->stats_lock);
4795	5302
4796	5303	INIT_WORK(&adapter->ibmvnic_reset, __ibmvnic_reset);
	5304	+ INIT_DELAYED_WORK(&adapter->ibmvnic_delayed_reset,
	5305	+ __ibmvnic_delayed_reset);
4797	5306	INIT_LIST_HEAD(&adapter->rwi_list);
4798	5307	spin_lock_init(&adapter->rwi_lock);
	5308	+ spin_lock_init(&adapter->state_lock);
	5309	+ mutex_init(&adapter->fw_lock);
4799	5310	init_completion(&adapter->init_done);
4800		- adapter->resetting = false;
4801		-
4802		- adapter->mac_change_pending = false;
	5311	+ init_completion(&adapter->fw_done);
	5312	+ init_completion(&adapter->reset_done);
	5313	+ init_completion(&adapter->stats_done);
	5314	+ clear_bit(0, &adapter->resetting);
4803	5315
4804	5316	do {
4805	5317	rc = init_crq_queue(adapter);
..	..	@@ -4809,7 +5321,7 @@
4809	5321	goto ibmvnic_init_fail;
4810	5322	}
4811	5323
4812		- rc = ibmvnic_init(adapter);
	5324	+ rc = ibmvnic_reset_init(adapter, false);
4813	5325	if (rc && rc != EAGAIN)
4814	5326	goto ibmvnic_init_fail;
4815	5327	} while (rc == EAGAIN);
..	..	@@ -4831,16 +5343,18 @@
4831	5343	goto ibmvnic_dev_file_err;
4832	5344
4833	5345	netif_carrier_off(netdev);
	5346	+
	5347	+ adapter->state = VNIC_PROBED;
	5348	+
	5349	+ adapter->wait_for_reset = false;
	5350	+ adapter->last_reset_time = jiffies;
	5351	+
4834	5352	rc = register_netdev(netdev);
4835	5353	if (rc) {
4836	5354	dev_err(&dev->dev, "failed to register netdev rc=%d\n", rc);
4837	5355	goto ibmvnic_register_fail;
4838	5356	}
4839	5357	dev_info(&dev->dev, "ibmvnic registered\n");
4840		-
4841		- adapter->state = VNIC_PROBED;
4842		-
4843		- adapter->wait_for_reset = false;
4844	5358
4845	5359	return 0;
4846	5360
..	..	@@ -4856,6 +5370,7 @@
4856	5370	ibmvnic_init_fail:
4857	5371	release_sub_crqs(adapter, 1);
4858	5372	release_crq_queue(adapter);
	5373	+ mutex_destroy(&adapter->fw_lock);
4859	5374	free_netdev(netdev);
4860	5375
4861	5376	return rc;
..	..	@@ -4865,8 +5380,26 @@
4865	5380	{
4866	5381	struct net_device *netdev = dev_get_drvdata(&dev->dev);
4867	5382	struct ibmvnic_adapter *adapter = netdev_priv(netdev);
	5383	+ unsigned long flags;
4868	5384
	5385	+ spin_lock_irqsave(&adapter->state_lock, flags);
	5386	+
	5387	+ /* If ibmvnic_reset() is scheduling a reset, wait for it to
	5388	+ * finish. Then, set the state to REMOVING to prevent it from
	5389	+ * scheduling any more work and to have reset functions ignore
	5390	+ * any resets that have already been scheduled. Drop the lock
	5391	+ * after setting state, so __ibmvnic_reset() which is called
	5392	+ * from the flush_work() below, can make progress.
	5393	+ */
	5394	+ spin_lock(&adapter->rwi_lock);
4869	5395	adapter->state = VNIC_REMOVING;
	5396	+ spin_unlock(&adapter->rwi_lock);
	5397	+
	5398	+ spin_unlock_irqrestore(&adapter->state_lock, flags);
	5399	+
	5400	+ flush_work(&adapter->ibmvnic_reset);
	5401	+ flush_delayed_work(&adapter->ibmvnic_delayed_reset);
	5402	+
4870	5403	rtnl_lock();
4871	5404	unregister_netdevice(netdev);
4872	5405
..	..	@@ -4880,6 +5413,7 @@
4880	5413	adapter->state = VNIC_REMOVED;
4881	5414
4882	5415	rtnl_unlock();
	5416	+ mutex_destroy(&adapter->fw_lock);
4883	5417	device_remove_file(&dev->dev, &dev_attr_failover);
4884	5418	free_netdev(netdev);
4885	5419	dev_set_drvdata(&dev->dev, NULL);
..	..	@@ -4945,8 +5479,7 @@
4945	5479	for (i = 0; i < adapter->req_tx_queues + adapter->req_rx_queues; i++)
4946	5480	ret += 4 * PAGE_SIZE; /* the scrq message queue */
4947	5481
4948		- for (i = 0; i < be32_to_cpu(adapter->login_rsp_buf->num_rxadd_subcrqs);
4949		- i++)
	5482	+ for (i = 0; i < adapter->num_active_rx_pools; i++)
4950	5483	ret += adapter->rx_pool[i].size *
4951	5484	IOMMU_PAGE_ALIGN(adapter->rx_pool[i].buff_size, tbl);
4952	5485