forked from ~ljy/RK356X_SDK_RELEASE
blame | history | patch | commit | commitdiff
hc
2024-05-11 04dd17822334871b23ea2862f7798fb0e0007777 
 kernel/drivers/net/usb/pegasus.c
....@@ -1,9 +1,6 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
12 /*
23  *  Copyright (c) 1999-2013 Petko Manolov (petkan@nucleusys.com)
3
- *
4
- * This program is free software; you can redistribute it and/or modify
5
- * it under the terms of the GNU General Public License version 2 as
6
- * published by the Free Software Foundation.
74  *
85  *	ChangeLog:
96  *		....	Most of the time spent on reading sources & docs.
....@@ -57,6 +54,7 @@
5754 #undef	PEGASUS_WRITE_EEPROM
5855 #define	BMSR_MEDIA	(BMSR_10HALF | BMSR_10FULL | BMSR_100HALF | \
5956 			BMSR_100FULL | BMSR_ANEGCAPABLE)
57
+#define CARRIER_CHECK_DELAY (2 * HZ)
6058 
6159 static bool loopback;
6260 static bool mii_mode;
....@@ -126,61 +124,41 @@
126124 
127125 static int get_registers(pegasus_t *pegasus, __u16 indx, __u16 size, void *data)
128126 {
129
-	u8 *buf;
130
-	int ret;
131
-
132
-	buf = kmalloc(size, GFP_NOIO);
133
-	if (!buf)
134
-		return -ENOMEM;
135
-
136
-	ret = usb_control_msg(pegasus->usb, usb_rcvctrlpipe(pegasus->usb, 0),
137
-			      PEGASUS_REQ_GET_REGS, PEGASUS_REQT_READ, 0,
138
-			      indx, buf, size, 1000);
139
-	if (ret < 0)
140
-		netif_dbg(pegasus, drv, pegasus->net,
141
-			  "%s returned %d\n", __func__, ret);
142
-	else if (ret <= size)
143
-		memcpy(data, buf, ret);
144
-	kfree(buf);
145
-	return ret;
127
+	return usb_control_msg_recv(pegasus->usb, 0, PEGASUS_REQ_GET_REGS,
128
+				   PEGASUS_REQT_READ, 0, indx, data, size,
129
+				   1000, GFP_NOIO);
146130 }
147131 
148132 static int set_registers(pegasus_t *pegasus, __u16 indx, __u16 size,
149133 			 const void *data)
150134 {
151
-	u8 *buf;
152135 	int ret;
153136 
154
-	buf = kmemdup(data, size, GFP_NOIO);
155
-	if (!buf)
156
-		return -ENOMEM;
157
-
158
-	ret = usb_control_msg(pegasus->usb, usb_sndctrlpipe(pegasus->usb, 0),
159
-			      PEGASUS_REQ_SET_REGS, PEGASUS_REQT_WRITE, 0,
160
-			      indx, buf, size, 100);
137
+	ret = usb_control_msg_send(pegasus->usb, 0, PEGASUS_REQ_SET_REGS,
138
+				    PEGASUS_REQT_WRITE, 0, indx, data, size,
139
+				    1000, GFP_NOIO);
161140 	if (ret < 0)
162
-		netif_dbg(pegasus, drv, pegasus->net,
163
-			  "%s returned %d\n", __func__, ret);
164
-	kfree(buf);
141
+		netif_dbg(pegasus, drv, pegasus->net, "%s failed with %d\n", __func__, ret);
142
+
165143 	return ret;
166144 }
167145 
146
+/*
147
+ * There is only one way to write to a single ADM8511 register and this is via
148
+ * specific control request.  'data' is ignored by the device, but it is here to
149
+ * not break the API.
150
+ */
168151 static int set_register(pegasus_t *pegasus, __u16 indx, __u8 data)
169152 {
170
-	u8 *buf;
153
+	void *buf = &data;
171154 	int ret;
172155 
173
-	buf = kmemdup(&data, 1, GFP_NOIO);
174
-	if (!buf)
175
-		return -ENOMEM;
176
-
177
-	ret = usb_control_msg(pegasus->usb, usb_sndctrlpipe(pegasus->usb, 0),
178
-			      PEGASUS_REQ_SET_REG, PEGASUS_REQT_WRITE, data,
179
-			      indx, buf, 1, 1000);
156
+	ret = usb_control_msg_send(pegasus->usb, 0, PEGASUS_REQ_SET_REG,
157
+				    PEGASUS_REQT_WRITE, data, indx, buf, 1,
158
+				    1000, GFP_NOIO);
180159 	if (ret < 0)
181
-		netif_dbg(pegasus, drv, pegasus->net,
182
-			  "%s returned %d\n", __func__, ret);
183
-	kfree(buf);
160
+		netif_dbg(pegasus, drv, pegasus->net, "%s failed with %d\n", __func__, ret);
161
+
184162 	return ret;
185163 }
186164 
....@@ -221,10 +199,9 @@
221199 
222200 static int __mii_op(pegasus_t *p, __u8 phy, __u8 indx, __u16 *regd, __u8 cmd)
223201 {
224
-	int i;
225
-	__u8 data[4] = { phy, 0, 0, indx };
202
+	int i, ret;
226203 	__le16 regdi;
227
-	int ret = -ETIMEDOUT;
204
+	__u8 data[4] = { phy, 0, 0, indx };
228205 
229206 	if (cmd & PHY_WRITE) {
230207 		__le16 *t = (__le16 *) & data[1];
....@@ -240,12 +217,15 @@
240217 		if (data[0] & PHY_DONE)
241218 			break;
242219 	}
243
-	if (i >= REG_TIMEOUT)
220
+	if (i >= REG_TIMEOUT) {
221
+		ret = -ETIMEDOUT;
244222 		goto fail;
223
+	}
245224 	if (cmd & PHY_READ) {
246225 		ret = get_registers(p, PhyData, 2, &regdi);
226
+		if (ret < 0)
227
+			goto fail;
247228 		*regd = le16_to_cpu(regdi);
248
-		return ret;
249229 	}
250230 	return 0;
251231 fail:
....@@ -268,9 +248,13 @@
268248 static int mdio_read(struct net_device *dev, int phy_id, int loc)
269249 {
270250 	pegasus_t *pegasus = netdev_priv(dev);
251
+	int ret;
271252 	u16 res;
272253 
273
-	read_mii_word(pegasus, phy_id, loc, &res);
254
+	ret = read_mii_word(pegasus, phy_id, loc, &res);
255
+	if (ret < 0)
256
+		return ret;
257
+
274258 	return (int)res;
275259 }
276260 
....@@ -284,10 +268,9 @@
284268 
285269 static int read_eprom_word(pegasus_t *pegasus, __u8 index, __u16 *retdata)
286270 {
287
-	int i;
288
-	__u8 tmp = 0;
271
+	int ret, i;
289272 	__le16 retdatai;
290
-	int ret;
273
+	__u8 tmp = 0;
291274 
292275 	set_register(pegasus, EpromCtrl, 0);
293276 	set_register(pegasus, EpromOffset, index);
....@@ -295,21 +278,25 @@
295278 
296279 	for (i = 0; i < REG_TIMEOUT; i++) {
297280 		ret = get_registers(pegasus, EpromCtrl, 1, &tmp);
281
+		if (ret < 0)
282
+			goto fail;
298283 		if (tmp & EPROM_DONE)
299284 			break;
300
-		if (ret == -ESHUTDOWN)
301
-			goto fail;
302285 	}
303
-	if (i >= REG_TIMEOUT)
286
+	if (i >= REG_TIMEOUT) {
287
+		ret = -ETIMEDOUT;
304288 		goto fail;
289
+	}
305290 
306291 	ret = get_registers(pegasus, EpromData, 2, &retdatai);
292
+	if (ret < 0)
293
+		goto fail;
307294 	*retdata = le16_to_cpu(retdatai);
308295 	return ret;
309296 
310297 fail:
311
-	netif_warn(pegasus, drv, pegasus->net, "%s failed\n", __func__);
312
-	return -ETIMEDOUT;
298
+	netif_dbg(pegasus, drv, pegasus->net, "%s failed\n", __func__);
299
+	return ret;
313300 }
314301 
315302 #ifdef	PEGASUS_WRITE_EEPROM
....@@ -357,43 +344,64 @@
357344 	return ret;
358345 
359346 fail:
360
-	netif_warn(pegasus, drv, pegasus->net, "%s failed\n", __func__);
347
+	netif_dbg(pegasus, drv, pegasus->net, "%s failed\n", __func__);
361348 	return -ETIMEDOUT;
362349 }
363
-#endif				/* PEGASUS_WRITE_EEPROM */
350
+#endif	/* PEGASUS_WRITE_EEPROM */
364351 
365
-static inline void get_node_id(pegasus_t *pegasus, __u8 *id)
352
+static inline int get_node_id(pegasus_t *pegasus, u8 *id)
366353 {
367
-	int i;
368
-	__u16 w16;
354
+	int i, ret;
355
+	u16 w16;
369356 
370357 	for (i = 0; i < 3; i++) {
371
-		read_eprom_word(pegasus, i, &w16);
358
+		ret = read_eprom_word(pegasus, i, &w16);
359
+		if (ret < 0)
360
+			return ret;
372361 		((__le16 *) id)[i] = cpu_to_le16(w16);
373362 	}
363
+
364
+	return 0;
374365 }
375366 
376367 static void set_ethernet_addr(pegasus_t *pegasus)
377368 {
378
-	__u8 node_id[6];
369
+	int ret;
370
+	u8 node_id[6];
379371 
380372 	if (pegasus->features & PEGASUS_II) {
381
-		get_registers(pegasus, 0x10, sizeof(node_id), node_id);
373
+		ret = get_registers(pegasus, 0x10, sizeof(node_id), node_id);
374
+		if (ret < 0)
375
+			goto err;
382376 	} else {
383
-		get_node_id(pegasus, node_id);
384
-		set_registers(pegasus, EthID, sizeof(node_id), node_id);
377
+		ret = get_node_id(pegasus, node_id);
378
+		if (ret < 0)
379
+			goto err;
380
+		ret = set_registers(pegasus, EthID, sizeof(node_id), node_id);
381
+		if (ret < 0)
382
+			goto err;
385383 	}
384
+
386385 	memcpy(pegasus->net->dev_addr, node_id, sizeof(node_id));
386
+
387
+	return;
388
+err:
389
+	eth_hw_addr_random(pegasus->net);
390
+	netif_dbg(pegasus, drv, pegasus->net, "software assigned MAC address.\n");
391
+
392
+	return;
387393 }
388394 
389395 static inline int reset_mac(pegasus_t *pegasus)
390396 {
397
+	int ret, i;
391398 	__u8 data = 0x8;
392
-	int i;
393399 
394400 	set_register(pegasus, EthCtrl1, data);
395401 	for (i = 0; i < REG_TIMEOUT; i++) {
396
-		get_registers(pegasus, EthCtrl1, 1, &data);
402
+		ret = get_registers(pegasus, EthCtrl1, 1, &data);
403
+		if (ret < 0)
404
+			goto fail;
397405 		if (~data & 0x08) {
398406 			if (loopback)
399407 				break;
....@@ -416,22 +424,29 @@
416424 	}
417425 	if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_ELCON) {
418426 		__u16 auxmode;
419
-		read_mii_word(pegasus, 3, 0x1b, &auxmode);
427
+		ret = read_mii_word(pegasus, 3, 0x1b, &auxmode);
428
+		if (ret < 0)
429
+			goto fail;
420430 		auxmode |= 4;
421431 		write_mii_word(pegasus, 3, 0x1b, &auxmode);
422432 	}
423433 
424434 	return 0;
435
+fail:
436
+	netif_dbg(pegasus, drv, pegasus->net, "%s failed\n", __func__);
437
+	return ret;
425438 }
426439 
427440 static int enable_net_traffic(struct net_device *dev, struct usb_device *usb)
428441 {
429
-	__u16 linkpart;
430
-	__u8 data[4];
431442 	pegasus_t *pegasus = netdev_priv(dev);
432443 	int ret;
444
+	__u16 linkpart;
445
+	__u8 data[4];
433446 
434
-	read_mii_word(pegasus, pegasus->phy, MII_LPA, &linkpart);
447
+	ret = read_mii_word(pegasus, pegasus->phy, MII_LPA, &linkpart);
448
+	if (ret < 0)
449
+		goto fail;
435450 	data[0] = 0xc8; /* TX & RX enable, append status, no CRC */
436451 	data[1] = 0;
437452 	if (linkpart & (ADVERTISE_100FULL | ADVERTISE_10FULL))
....@@ -449,11 +464,16 @@
449464 	    usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS2 ||
450465 	    usb_dev_id[pegasus->dev_index].vendor == VENDOR_DLINK) {
451466 		u16 auxmode;
452
-		read_mii_word(pegasus, 0, 0x1b, &auxmode);
467
+		ret = read_mii_word(pegasus, 0, 0x1b, &auxmode);
468
+		if (ret < 0)
469
+			goto fail;
453470 		auxmode |= 4;
454471 		write_mii_word(pegasus, 0, 0x1b, &auxmode);
455472 	}
456473 
474
+	return ret;
475
+fail:
476
+	netif_dbg(pegasus, drv, pegasus->net, "%s failed\n", __func__);
457477 	return ret;
458478 }
459479 
....@@ -461,9 +481,9 @@
461481 {
462482 	pegasus_t *pegasus = urb->context;
463483 	struct net_device *net;
484
+	u8 *buf = urb->transfer_buffer;
464485 	int rx_status, count = urb->actual_length;
465486 	int status = urb->status;
466
-	u8 *buf = urb->transfer_buffer;
467487 	__u16 pkt_len;
468488 
469489 	if (!pegasus)
....@@ -631,7 +651,7 @@
631651 		return;
632652 	default:
633653 		netif_info(pegasus, tx_err, net, "TX status %d\n", status);
634
-		/* FALL THROUGH */
654
+		fallthrough;
635655 	case 0:
636656 		break;
637657 	}
....@@ -696,7 +716,7 @@
696716 			  "can't resubmit interrupt urb, %d\n", res);
697717 }
698718 
699
-static void pegasus_tx_timeout(struct net_device *net)
719
+static void pegasus_tx_timeout(struct net_device *net, unsigned int txqueue)
700720 {
701721 	pegasus_t *pegasus = netdev_priv(net);
702722 	netif_warn(pegasus, timer, net, "tx timeout\n");
....@@ -841,7 +861,7 @@
841861 	if (!pegasus->rx_skb)
842862 		goto exit;
843863 
844
-	res = set_registers(pegasus, EthID, 6, net->dev_addr);
864
+	set_registers(pegasus, EthID, 6, net->dev_addr);
845865 
846866 	usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
847867 			  usb_rcvbulkpipe(pegasus->usb, 1),
....@@ -1017,9 +1037,9 @@
10171037 	switch (cmd) {
10181038 	case SIOCDEVPRIVATE:
10191039 		data[0] = pegasus->phy;
1040
+		fallthrough;
10201041 	case SIOCDEVPRIVATE + 1:
1021
-		read_mii_word(pegasus, data[0], data[1] & 0x1f, &data[3]);
1022
-		res = 0;
1042
+		res = read_mii_word(pegasus, data[0], data[1] & 0x1f, &data[3]);
10231043 		break;
10241044 	case SIOCDEVPRIVATE + 2:
10251045 		if (!capable(CAP_NET_ADMIN))
....@@ -1053,22 +1073,25 @@
10531073 
10541074 static __u8 mii_phy_probe(pegasus_t *pegasus)
10551075 {
1056
-	int i;
1076
+	int i, ret;
10571077 	__u16 tmp;
10581078 
10591079 	for (i = 0; i < 32; i++) {
1060
-		read_mii_word(pegasus, i, MII_BMSR, &tmp);
1080
+		ret = read_mii_word(pegasus, i, MII_BMSR, &tmp);
1081
+		if (ret < 0)
1082
+			goto fail;
10611083 		if (tmp == 0 || tmp == 0xffff || (tmp & BMSR_MEDIA) == 0)
10621084 			continue;
10631085 		else
10641086 			return i;
10651087 	}
1066
-
1088
+fail:
10671089 	return 0xff;
10681090 }
10691091 
10701092 static inline void setup_pegasus_II(pegasus_t *pegasus)
10711093 {
1094
+	int ret;
10721095 	__u8 data = 0xa5;
10731096 
10741097 	set_register(pegasus, Reg1d, 0);
....@@ -1080,7 +1103,9 @@
10801103 		set_register(pegasus, Reg7b, 2);
10811104 
10821105 	set_register(pegasus, 0x83, data);
1083
-	get_registers(pegasus, 0x83, 1, &data);
1106
+	ret = get_registers(pegasus, 0x83, 1, &data);
1107
+	if (ret < 0)
1108
+		goto fail;
10841109 
10851110 	if (data == 0xa5)
10861111 		pegasus->chip = 0x8513;
....@@ -1095,19 +1120,18 @@
10951120 		set_register(pegasus, Reg81, 6);
10961121 	else
10971122 		set_register(pegasus, Reg81, 2);
1123
+
1124
+	return;
1125
+fail:
1126
+	netif_dbg(pegasus, drv, pegasus->net, "%s failed\n", __func__);
10981127 }
1099
-
1100
-
1101
-static int pegasus_count;
1102
-static struct workqueue_struct *pegasus_workqueue;
1103
-#define CARRIER_CHECK_DELAY (2 * HZ)
11041128 
11051129 static void check_carrier(struct work_struct *work)
11061130 {
11071131 	pegasus_t *pegasus = container_of(work, pegasus_t, carrier_check.work);
11081132 	set_carrier(pegasus->net);
11091133 	if (!(pegasus->flags & PEGASUS_UNPLUG)) {
1110
-		queue_delayed_work(pegasus_workqueue, &pegasus->carrier_check,
1134
+		queue_delayed_work(system_long_wq, &pegasus->carrier_check,
11111135 			CARRIER_CHECK_DELAY);
11121136 	}
11131137 }
....@@ -1128,18 +1152,6 @@
11281152 	return 0;
11291153 }
11301154 
1131
-/* we rely on probe() and remove() being serialized so we
1132
- * don't need extra locking on pegasus_count.
1133
- */
1134
-static void pegasus_dec_workqueue(void)
1135
-{
1136
-	pegasus_count--;
1137
-	if (pegasus_count == 0) {
1138
-		destroy_workqueue(pegasus_workqueue);
1139
-		pegasus_workqueue = NULL;
1140
-	}
1141
-}
1142
-
11431155 static int pegasus_probe(struct usb_interface *intf,
11441156 			 const struct usb_device_id *id)
11451157 {
....@@ -1151,14 +1163,6 @@
11511163 
11521164 	if (pegasus_blacklisted(dev))
11531165 		return -ENODEV;
1154
-
1155
-	if (pegasus_count == 0) {
1156
-		pegasus_workqueue = alloc_workqueue("pegasus", WQ_MEM_RECLAIM,
1157
-						    0);
1158
-		if (!pegasus_workqueue)
1159
-			return -ENOMEM;
1160
-	}
1161
-	pegasus_count++;
11621166 
11631167 	net = alloc_etherdev(sizeof(struct pegasus));
11641168 	if (!net)
....@@ -1219,7 +1223,7 @@
12191223 	res = register_netdev(net);
12201224 	if (res)
12211225 		goto out3;
1222
-	queue_delayed_work(pegasus_workqueue, &pegasus->carrier_check,
1226
+	queue_delayed_work(system_long_wq, &pegasus->carrier_check,
12231227 			   CARRIER_CHECK_DELAY);
12241228 	dev_info(&intf->dev, "%s, %s, %pM\n", net->name,
12251229 		 usb_dev_id[dev_index].name, net->dev_addr);
....@@ -1232,7 +1236,6 @@
12321236 out1:
12331237 	free_netdev(net);
12341238 out:
1235
-	pegasus_dec_workqueue();
12361239 	return res;
12371240 }
12381241 
....@@ -1247,7 +1250,7 @@
12471250 	}
12481251 
12491252 	pegasus->flags |= PEGASUS_UNPLUG;
1250
-	cancel_delayed_work(&pegasus->carrier_check);
1253
+	cancel_delayed_work_sync(&pegasus->carrier_check);
12511254 	unregister_netdev(pegasus->net);
12521255 	unlink_all_urbs(pegasus);
12531256 	free_all_urbs(pegasus);
....@@ -1256,7 +1259,6 @@
12561259 		pegasus->rx_skb = NULL;
12571260 	}
12581261 	free_netdev(pegasus->net);
1259
-	pegasus_dec_workqueue();
12601262 }
12611263 
12621264 static int pegasus_suspend(struct usb_interface *intf, pm_message_t message)
....@@ -1264,7 +1266,7 @@
12641266 	struct pegasus *pegasus = usb_get_intfdata(intf);
12651267 
12661268 	netif_device_detach(pegasus->net);
1267
-	cancel_delayed_work(&pegasus->carrier_check);
1269
+	cancel_delayed_work_sync(&pegasus->carrier_check);
12681270 	if (netif_running(pegasus->net)) {
12691271 		usb_kill_urb(pegasus->rx_urb);
12701272 		usb_kill_urb(pegasus->intr_urb);
....@@ -1286,7 +1288,7 @@
12861288 		pegasus->intr_urb->actual_length = 0;
12871289 		intr_callback(pegasus->intr_urb);
12881290 	}
1289
-	queue_delayed_work(pegasus_workqueue, &pegasus->carrier_check,
1291
+	queue_delayed_work(system_long_wq, &pegasus->carrier_check,
12901292 				CARRIER_CHECK_DELAY);
12911293 	return 0;
12921294 }