add r8169 read mac form eeprom

hc

2024-02-19 1c055e55a242a33e574e48be530e06770a210dcd

 kernel/drivers/net/ethernet/qlogic/qede/qede_rdma.c
..
..
@@ -1,34 +1,9 @@
1
+// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
1
2
 /* QLogic qedr NIC Driver
2
3
  * Copyright (c) 2015-2017  QLogic Corporation
3
- *
4
- * This software is available to you under a choice of one of two
5
- * licenses.  You may choose to be licensed under the terms of the GNU
6
- * General Public License (GPL) Version 2, available from the file
7
- * COPYING in the main directory of this source tree, or the
8
- * OpenIB.org BSD license below:
9
- *
10
- *     Redistribution and use in source and binary forms, with or
11
- *     without modification, are permitted provided that the following
12
- *     conditions are met:
13
- *
14
- *      - Redistributions of source code must retain the above
15
- *        copyright notice, this list of conditions and the following
16
- *        disclaimer.
17
- *
18
- *      - Redistributions in binary form must reproduce the above
19
- *        copyright notice, this list of conditions and the following
20
- *        disclaimer in the documentation and /or other materials
21
- *        provided with the distribution.
22
- *
23
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30
- * SOFTWARE.
4
+ * Copyright (c) 2019-2020 Marvell International Ltd.
31
5
  */
6
+
32
7
 #include <linux/pci.h>
33
8
 #include <linux/netdevice.h>
34
9
 #include <linux/list.h>
..
..
@@ -50,6 +25,8 @@
50
25
 	if (!qedr_drv)
51
26
 		return;
52
27
 
28
+	/* Leftovers from previous error recovery */
29
+	edev->rdma_info.exp_recovery = false;
53
30
 	edev->rdma_info.qedr_dev = qedr_drv->add(edev->cdev, edev->pdev,
54
31
 						 edev->ndev);
55
32
 }
..
..
@@ -103,23 +80,29 @@
103
80
 
104
81
 	qede_rdma_cleanup_event(edev);
105
82
 	destroy_workqueue(edev->rdma_info.rdma_wq);
83
+	edev->rdma_info.rdma_wq = NULL;
106
84
 }
107
85
 
108
-int qede_rdma_dev_add(struct qede_dev *edev)
86
+int qede_rdma_dev_add(struct qede_dev *edev, bool recovery)
109
87
 {
110
-	int rc = 0;
88
+	int rc;
111
89
 
112
-	if (qede_rdma_supported(edev)) {
113
-		rc = qede_rdma_create_wq(edev);
114
-		if (rc)
115
-			return rc;
90
+	if (!qede_rdma_supported(edev))
91
+		return 0;
116
92
 
117
-		INIT_LIST_HEAD(&edev->rdma_info.entry);
118
-		mutex_lock(&qedr_dev_list_lock);
119
-		list_add_tail(&edev->rdma_info.entry, &qedr_dev_list);
120
-		_qede_rdma_dev_add(edev);
121
-		mutex_unlock(&qedr_dev_list_lock);
122
-	}
93
+	/* Cannot start qedr while recovering since it wasn't fully stopped */
94
+	if (recovery)
95
+		return 0;
96
+
97
+	rc = qede_rdma_create_wq(edev);
98
+	if (rc)
99
+		return rc;
100
+
101
+	INIT_LIST_HEAD(&edev->rdma_info.entry);
102
+	mutex_lock(&qedr_dev_list_lock);
103
+	list_add_tail(&edev->rdma_info.entry, &qedr_dev_list);
104
+	_qede_rdma_dev_add(edev);
105
+	mutex_unlock(&qedr_dev_list_lock);
123
106
 
124
107
 	return rc;
125
108
 }
..
..
@@ -128,19 +111,30 @@
128
111
 {
129
112
 	if (qedr_drv && qedr_drv->remove && edev->rdma_info.qedr_dev)
130
113
 		qedr_drv->remove(edev->rdma_info.qedr_dev);
131
-	edev->rdma_info.qedr_dev = NULL;
132
114
 }
133
115
 
134
-void qede_rdma_dev_remove(struct qede_dev *edev)
116
+void qede_rdma_dev_remove(struct qede_dev *edev, bool recovery)
135
117
 {
136
118
 	if (!qede_rdma_supported(edev))
137
119
 		return;
138
120
 
139
-	qede_rdma_destroy_wq(edev);
140
-	mutex_lock(&qedr_dev_list_lock);
141
-	_qede_rdma_dev_remove(edev);
142
-	list_del(&edev->rdma_info.entry);
143
-	mutex_unlock(&qedr_dev_list_lock);
121
+	/* Cannot remove qedr while recovering since it wasn't fully stopped */
122
+	if (!recovery) {
123
+		qede_rdma_destroy_wq(edev);
124
+		mutex_lock(&qedr_dev_list_lock);
125
+		if (!edev->rdma_info.exp_recovery)
126
+			_qede_rdma_dev_remove(edev);
127
+		edev->rdma_info.qedr_dev = NULL;
128
+		list_del(&edev->rdma_info.entry);
129
+		mutex_unlock(&qedr_dev_list_lock);
130
+	} else {
131
+		if (!edev->rdma_info.exp_recovery) {
132
+			mutex_lock(&qedr_dev_list_lock);
133
+			_qede_rdma_dev_remove(edev);
134
+			mutex_unlock(&qedr_dev_list_lock);
135
+		}
136
+		edev->rdma_info.exp_recovery = true;
137
+	}
144
138
 }
145
139
 
146
140
 static void _qede_rdma_dev_open(struct qede_dev *edev)
..
..
@@ -222,7 +216,8 @@
222
216
 
223
217
 	mutex_lock(&qedr_dev_list_lock);
224
218
 	list_for_each_entry(edev, &qedr_dev_list, rdma_info.entry) {
225
-		if (edev->rdma_info.qedr_dev)
219
+		/* If device has experienced recovery it was already removed */
220
+		if (edev->rdma_info.qedr_dev && !edev->rdma_info.exp_recovery)
226
221
 			_qede_rdma_dev_remove(edev);
227
222
 	}
228
223
 	qedr_drv = NULL;
..
..
@@ -237,6 +232,15 @@
237
232
 
238
233
 	if (qedr_drv && edev->rdma_info.qedr_dev && qedr_drv->notify)
239
234
 		qedr_drv->notify(edev->rdma_info.qedr_dev, QEDE_CHANGE_ADDR);
235
+}
236
+
237
+static void qede_rdma_change_mtu(struct qede_dev *edev)
238
+{
239
+	if (qede_rdma_supported(edev)) {
240
+		if (qedr_drv && edev->rdma_info.qedr_dev && qedr_drv->notify)
241
+			qedr_drv->notify(edev->rdma_info.qedr_dev,
242
+					 QEDE_CHANGE_MTU);
243
+	}
240
244
 }
241
245
 
242
246
 static struct qede_rdma_event_work *
..
..
@@ -292,6 +296,9 @@
292
296
 	case QEDE_CHANGE_ADDR:
293
297
 		qede_rdma_changeaddr(edev);
294
298
 		break;
299
+	case QEDE_CHANGE_MTU:
300
+		qede_rdma_change_mtu(edev);
301
+		break;
295
302
 	default:
296
303
 		DP_NOTICE(edev, "Invalid rdma event %d", event);
297
304
 	}
..
..
@@ -302,7 +309,11 @@
302
309
 {
303
310
 	struct qede_rdma_event_work *event_node;
304
311
 
305
-	if (!edev->rdma_info.qedr_dev)
312
+	/* If a recovery was experienced avoid adding the event */
313
+	if (edev->rdma_info.exp_recovery)
314
+		return;
315
+
316
+	if (!edev->rdma_info.qedr_dev || !edev->rdma_info.rdma_wq)
306
317
 		return;
307
318
 
308
319
 	/* We don't want the cleanup flow to start while we're allocating and
..
..
@@ -339,3 +350,8 @@
339
350
 {
340
351
 	qede_rdma_add_event(edev, QEDE_CHANGE_ADDR);
341
352
 }
353
+
354
+void qede_rdma_event_change_mtu(struct qede_dev *edev)
355
+{
356
+	qede_rdma_add_event(edev, QEDE_CHANGE_MTU);
357
+}