1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (C) 2015 Microchip Technology
4 */
5 #include <linux/version.h>
6 #include <linux/module.h>
7 #include <linux/netdevice.h>
8 #include <linux/etherdevice.h>
9 #include <linux/ethtool.h>
10 #include <linux/usb.h>
11 #include <linux/crc32.h>
12 #include <linux/signal.h>
13 #include <linux/slab.h>
14 #include <linux/if_vlan.h>
15 #include <linux/uaccess.h>
16 #include <linux/linkmode.h>
17 #include <linux/list.h>
18 #include <linux/ip.h>
19 #include <linux/ipv6.h>
20 #include <linux/mdio.h>
21 #include <linux/phy.h>
22 #include <net/ip6_checksum.h>
23 #include <net/vxlan.h>
24 #include <linux/interrupt.h>
25 #include <linux/irqdomain.h>
26 #include <linux/irq.h>
27 #include <linux/irqchip/chained_irq.h>
28 #include <linux/microchipphy.h>
29 #include <linux/phy_fixed.h>
30 #include <linux/of_mdio.h>
31 #include <linux/of_net.h>
32 #include "lan78xx.h"
33
34 #define DRIVER_AUTHOR "WOOJUNG HUH <woojung.huh@microchip.com>"
35 #define DRIVER_DESC "LAN78XX USB 3.0 Gigabit Ethernet Devices"
36 #define DRIVER_NAME "lan78xx"
37
38 #define TX_TIMEOUT_JIFFIES (5 * HZ)
39 #define THROTTLE_JIFFIES (HZ / 8)
40 #define UNLINK_TIMEOUT_MS 3
41
42 #define RX_MAX_QUEUE_MEMORY (60 * 1518)
43
44 #define SS_USB_PKT_SIZE (1024)
45 #define HS_USB_PKT_SIZE (512)
46 #define FS_USB_PKT_SIZE (64)
47
48 #define MAX_RX_FIFO_SIZE (12 * 1024)
49 #define MAX_TX_FIFO_SIZE (12 * 1024)
50 #define DEFAULT_BURST_CAP_SIZE (MAX_TX_FIFO_SIZE)
51 #define DEFAULT_BULK_IN_DELAY (0x0800)
52 #define MAX_SINGLE_PACKET_SIZE (9000)
53 #define DEFAULT_TX_CSUM_ENABLE (true)
54 #define DEFAULT_RX_CSUM_ENABLE (true)
55 #define DEFAULT_TSO_CSUM_ENABLE (true)
56 #define DEFAULT_VLAN_FILTER_ENABLE (true)
57 #define DEFAULT_VLAN_RX_OFFLOAD (true)
58 #define TX_OVERHEAD (8)
59 #define RXW_PADDING 2
60
61 #define LAN78XX_USB_VENDOR_ID (0x0424)
62 #define LAN7800_USB_PRODUCT_ID (0x7800)
63 #define LAN7850_USB_PRODUCT_ID (0x7850)
64 #define LAN7801_USB_PRODUCT_ID (0x7801)
65 #define LAN78XX_EEPROM_MAGIC (0x78A5)
66 #define LAN78XX_OTP_MAGIC (0x78F3)
67
68 #define MII_READ 1
69 #define MII_WRITE 0
70
71 #define EEPROM_INDICATOR (0xA5)
72 #define EEPROM_MAC_OFFSET (0x01)
73 #define MAX_EEPROM_SIZE 512
74 #define OTP_INDICATOR_1 (0xF3)
75 #define OTP_INDICATOR_2 (0xF7)
76
77 #define WAKE_ALL (WAKE_PHY | WAKE_UCAST | \
78 WAKE_MCAST | WAKE_BCAST | \
79 WAKE_ARP | WAKE_MAGIC)
80
81 /* USB related defines */
82 #define BULK_IN_PIPE 1
83 #define BULK_OUT_PIPE 2
84
85 /* default autosuspend delay (mSec)*/
86 #define DEFAULT_AUTOSUSPEND_DELAY (10 * 1000)
87
88 /* statistic update interval (mSec) */
89 #define STAT_UPDATE_TIMER (1 * 1000)
90
91 /* defines interrupts from interrupt EP */
92 #define MAX_INT_EP (32)
93 #define INT_EP_INTEP (31)
94 #define INT_EP_OTP_WR_DONE (28)
95 #define INT_EP_EEE_TX_LPI_START (26)
96 #define INT_EP_EEE_TX_LPI_STOP (25)
97 #define INT_EP_EEE_RX_LPI (24)
98 #define INT_EP_MAC_RESET_TIMEOUT (23)
99 #define INT_EP_RDFO (22)
100 #define INT_EP_TXE (21)
101 #define INT_EP_USB_STATUS (20)
102 #define INT_EP_TX_DIS (19)
103 #define INT_EP_RX_DIS (18)
104 #define INT_EP_PHY (17)
105 #define INT_EP_DP (16)
106 #define INT_EP_MAC_ERR (15)
107 #define INT_EP_TDFU (14)
108 #define INT_EP_TDFO (13)
109 #define INT_EP_UTX (12)
110 #define INT_EP_GPIO_11 (11)
111 #define INT_EP_GPIO_10 (10)
112 #define INT_EP_GPIO_9 (9)
113 #define INT_EP_GPIO_8 (8)
114 #define INT_EP_GPIO_7 (7)
115 #define INT_EP_GPIO_6 (6)
116 #define INT_EP_GPIO_5 (5)
117 #define INT_EP_GPIO_4 (4)
118 #define INT_EP_GPIO_3 (3)
119 #define INT_EP_GPIO_2 (2)
120 #define INT_EP_GPIO_1 (1)
121 #define INT_EP_GPIO_0 (0)
122
123 static const char lan78xx_gstrings[][ETH_GSTRING_LEN] = {
124 "RX FCS Errors",
125 "RX Alignment Errors",
126 "Rx Fragment Errors",
127 "RX Jabber Errors",
128 "RX Undersize Frame Errors",
129 "RX Oversize Frame Errors",
130 "RX Dropped Frames",
131 "RX Unicast Byte Count",
132 "RX Broadcast Byte Count",
133 "RX Multicast Byte Count",
134 "RX Unicast Frames",
135 "RX Broadcast Frames",
136 "RX Multicast Frames",
137 "RX Pause Frames",
138 "RX 64 Byte Frames",
139 "RX 65 - 127 Byte Frames",
140 "RX 128 - 255 Byte Frames",
141 "RX 256 - 511 Bytes Frames",
142 "RX 512 - 1023 Byte Frames",
143 "RX 1024 - 1518 Byte Frames",
144 "RX Greater 1518 Byte Frames",
145 "EEE RX LPI Transitions",
146 "EEE RX LPI Time",
147 "TX FCS Errors",
148 "TX Excess Deferral Errors",
149 "TX Carrier Errors",
150 "TX Bad Byte Count",
151 "TX Single Collisions",
152 "TX Multiple Collisions",
153 "TX Excessive Collision",
154 "TX Late Collisions",
155 "TX Unicast Byte Count",
156 "TX Broadcast Byte Count",
157 "TX Multicast Byte Count",
158 "TX Unicast Frames",
159 "TX Broadcast Frames",
160 "TX Multicast Frames",
161 "TX Pause Frames",
162 "TX 64 Byte Frames",
163 "TX 65 - 127 Byte Frames",
164 "TX 128 - 255 Byte Frames",
165 "TX 256 - 511 Bytes Frames",
166 "TX 512 - 1023 Byte Frames",
167 "TX 1024 - 1518 Byte Frames",
168 "TX Greater 1518 Byte Frames",
169 "EEE TX LPI Transitions",
170 "EEE TX LPI Time",
171 };
172
173 struct lan78xx_statstage {
174 u32 rx_fcs_errors;
175 u32 rx_alignment_errors;
176 u32 rx_fragment_errors;
177 u32 rx_jabber_errors;
178 u32 rx_undersize_frame_errors;
179 u32 rx_oversize_frame_errors;
180 u32 rx_dropped_frames;
181 u32 rx_unicast_byte_count;
182 u32 rx_broadcast_byte_count;
183 u32 rx_multicast_byte_count;
184 u32 rx_unicast_frames;
185 u32 rx_broadcast_frames;
186 u32 rx_multicast_frames;
187 u32 rx_pause_frames;
188 u32 rx_64_byte_frames;
189 u32 rx_65_127_byte_frames;
190 u32 rx_128_255_byte_frames;
191 u32 rx_256_511_bytes_frames;
192 u32 rx_512_1023_byte_frames;
193 u32 rx_1024_1518_byte_frames;
194 u32 rx_greater_1518_byte_frames;
195 u32 eee_rx_lpi_transitions;
196 u32 eee_rx_lpi_time;
197 u32 tx_fcs_errors;
198 u32 tx_excess_deferral_errors;
199 u32 tx_carrier_errors;
200 u32 tx_bad_byte_count;
201 u32 tx_single_collisions;
202 u32 tx_multiple_collisions;
203 u32 tx_excessive_collision;
204 u32 tx_late_collisions;
205 u32 tx_unicast_byte_count;
206 u32 tx_broadcast_byte_count;
207 u32 tx_multicast_byte_count;
208 u32 tx_unicast_frames;
209 u32 tx_broadcast_frames;
210 u32 tx_multicast_frames;
211 u32 tx_pause_frames;
212 u32 tx_64_byte_frames;
213 u32 tx_65_127_byte_frames;
214 u32 tx_128_255_byte_frames;
215 u32 tx_256_511_bytes_frames;
216 u32 tx_512_1023_byte_frames;
217 u32 tx_1024_1518_byte_frames;
218 u32 tx_greater_1518_byte_frames;
219 u32 eee_tx_lpi_transitions;
220 u32 eee_tx_lpi_time;
221 };
222
223 struct lan78xx_statstage64 {
224 u64 rx_fcs_errors;
225 u64 rx_alignment_errors;
226 u64 rx_fragment_errors;
227 u64 rx_jabber_errors;
228 u64 rx_undersize_frame_errors;
229 u64 rx_oversize_frame_errors;
230 u64 rx_dropped_frames;
231 u64 rx_unicast_byte_count;
232 u64 rx_broadcast_byte_count;
233 u64 rx_multicast_byte_count;
234 u64 rx_unicast_frames;
235 u64 rx_broadcast_frames;
236 u64 rx_multicast_frames;
237 u64 rx_pause_frames;
238 u64 rx_64_byte_frames;
239 u64 rx_65_127_byte_frames;
240 u64 rx_128_255_byte_frames;
241 u64 rx_256_511_bytes_frames;
242 u64 rx_512_1023_byte_frames;
243 u64 rx_1024_1518_byte_frames;
244 u64 rx_greater_1518_byte_frames;
245 u64 eee_rx_lpi_transitions;
246 u64 eee_rx_lpi_time;
247 u64 tx_fcs_errors;
248 u64 tx_excess_deferral_errors;
249 u64 tx_carrier_errors;
250 u64 tx_bad_byte_count;
251 u64 tx_single_collisions;
252 u64 tx_multiple_collisions;
253 u64 tx_excessive_collision;
254 u64 tx_late_collisions;
255 u64 tx_unicast_byte_count;
256 u64 tx_broadcast_byte_count;
257 u64 tx_multicast_byte_count;
258 u64 tx_unicast_frames;
259 u64 tx_broadcast_frames;
260 u64 tx_multicast_frames;
261 u64 tx_pause_frames;
262 u64 tx_64_byte_frames;
263 u64 tx_65_127_byte_frames;
264 u64 tx_128_255_byte_frames;
265 u64 tx_256_511_bytes_frames;
266 u64 tx_512_1023_byte_frames;
267 u64 tx_1024_1518_byte_frames;
268 u64 tx_greater_1518_byte_frames;
269 u64 eee_tx_lpi_transitions;
270 u64 eee_tx_lpi_time;
271 };
272
273 static u32 lan78xx_regs[] = {
274 ID_REV,
275 INT_STS,
276 HW_CFG,
277 PMT_CTL,
278 E2P_CMD,
279 E2P_DATA,
280 USB_STATUS,
281 VLAN_TYPE,
282 MAC_CR,
283 MAC_RX,
284 MAC_TX,
285 FLOW,
286 ERR_STS,
287 MII_ACC,
288 MII_DATA,
289 EEE_TX_LPI_REQ_DLY,
290 EEE_TW_TX_SYS,
291 EEE_TX_LPI_REM_DLY,
292 WUCSR
293 };
294
295 #define PHY_REG_SIZE (32 * sizeof(u32))
296
297 struct lan78xx_net;
298
299 struct lan78xx_priv {
300 struct lan78xx_net *dev;
301 u32 rfe_ctl;
302 u32 mchash_table[DP_SEL_VHF_HASH_LEN]; /* multicat hash table */
303 u32 pfilter_table[NUM_OF_MAF][2]; /* perfect filter table */
304 u32 vlan_table[DP_SEL_VHF_VLAN_LEN];
305 struct mutex dataport_mutex; /* for dataport access */
306 spinlock_t rfe_ctl_lock; /* for rfe register access */
307 struct work_struct set_multicast;
308 struct work_struct set_vlan;
309 u32 wol;
310 };
311
312 enum skb_state {
313 illegal = 0,
314 tx_start,
315 tx_done,
316 rx_start,
317 rx_done,
318 rx_cleanup,
319 unlink_start
320 };
321
322 struct skb_data { /* skb->cb is one of these */
323 struct urb *urb;
324 struct lan78xx_net *dev;
325 enum skb_state state;
326 size_t length;
327 int num_of_packet;
328 };
329
330 struct usb_context {
331 struct usb_ctrlrequest req;
332 struct lan78xx_net *dev;
333 };
334
335 #define EVENT_TX_HALT 0
336 #define EVENT_RX_HALT 1
337 #define EVENT_RX_MEMORY 2
338 #define EVENT_STS_SPLIT 3
339 #define EVENT_LINK_RESET 4
340 #define EVENT_RX_PAUSED 5
341 #define EVENT_DEV_WAKING 6
342 #define EVENT_DEV_ASLEEP 7
343 #define EVENT_DEV_OPEN 8
344 #define EVENT_STAT_UPDATE 9
345
346 struct statstage {
347 struct mutex access_lock; /* for stats access */
348 struct lan78xx_statstage saved;
349 struct lan78xx_statstage rollover_count;
350 struct lan78xx_statstage rollover_max;
351 struct lan78xx_statstage64 curr_stat;
352 };
353
354 struct irq_domain_data {
355 struct irq_domain *irqdomain;
356 unsigned int phyirq;
357 struct irq_chip *irqchip;
358 irq_flow_handler_t irq_handler;
359 u32 irqenable;
360 struct mutex irq_lock; /* for irq bus access */
361 };
362
363 struct lan78xx_net {
364 struct net_device *net;
365 struct usb_device *udev;
366 struct usb_interface *intf;
367 void *driver_priv;
368
369 int rx_qlen;
370 int tx_qlen;
371 struct sk_buff_head rxq;
372 struct sk_buff_head txq;
373 struct sk_buff_head done;
374 struct sk_buff_head rxq_pause;
375 struct sk_buff_head txq_pend;
376
377 struct tasklet_struct bh;
378 struct delayed_work wq;
379
380 int msg_enable;
381
382 struct urb *urb_intr;
383 struct usb_anchor deferred;
384
385 struct mutex phy_mutex; /* for phy access */
386 unsigned pipe_in, pipe_out, pipe_intr;
387
388 u32 hard_mtu; /* count any extra framing */
389 size_t rx_urb_size; /* size for rx urbs */
390
391 unsigned long flags;
392
393 wait_queue_head_t *wait;
394 unsigned char suspend_count;
395
396 unsigned maxpacket;
397 struct timer_list delay;
398 struct timer_list stat_monitor;
399
400 unsigned long data[5];
401
402 int link_on;
403 u8 mdix_ctrl;
404
405 u32 chipid;
406 u32 chiprev;
407 struct mii_bus *mdiobus;
408 phy_interface_t interface;
409
410 int fc_autoneg;
411 u8 fc_request_control;
412
413 int delta;
414 struct statstage stats;
415
416 struct irq_domain_data domain_data;
417 };
418
419 /* define external phy id */
420 #define PHY_LAN8835 (0x0007C130)
421 #define PHY_KSZ9031RNX (0x00221620)
422
423 /* use ethtool to change the level for any given device */
424 static int msg_level = -1;
425 module_param(msg_level, int, 0);
426 MODULE_PARM_DESC(msg_level, "Override default message level");
427
lan78xx_read_reg(struct lan78xx_net * dev,u32 index,u32 * data)428 static int lan78xx_read_reg(struct lan78xx_net *dev, u32 index, u32 *data)
429 {
430 u32 *buf = kmalloc(sizeof(u32), GFP_KERNEL);
431 int ret;
432
433 if (!buf)
434 return -ENOMEM;
435
436 ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
437 USB_VENDOR_REQUEST_READ_REGISTER,
438 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
439 0, index, buf, 4, USB_CTRL_GET_TIMEOUT);
440 if (likely(ret >= 0)) {
441 le32_to_cpus(buf);
442 *data = *buf;
443 } else {
444 netdev_warn(dev->net,
445 "Failed to read register index 0x%08x. ret = %d",
446 index, ret);
447 }
448
449 kfree(buf);
450
451 return ret;
452 }
453
lan78xx_write_reg(struct lan78xx_net * dev,u32 index,u32 data)454 static int lan78xx_write_reg(struct lan78xx_net *dev, u32 index, u32 data)
455 {
456 u32 *buf = kmalloc(sizeof(u32), GFP_KERNEL);
457 int ret;
458
459 if (!buf)
460 return -ENOMEM;
461
462 *buf = data;
463 cpu_to_le32s(buf);
464
465 ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
466 USB_VENDOR_REQUEST_WRITE_REGISTER,
467 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
468 0, index, buf, 4, USB_CTRL_SET_TIMEOUT);
469 if (unlikely(ret < 0)) {
470 netdev_warn(dev->net,
471 "Failed to write register index 0x%08x. ret = %d",
472 index, ret);
473 }
474
475 kfree(buf);
476
477 return ret;
478 }
479
lan78xx_read_stats(struct lan78xx_net * dev,struct lan78xx_statstage * data)480 static int lan78xx_read_stats(struct lan78xx_net *dev,
481 struct lan78xx_statstage *data)
482 {
483 int ret = 0;
484 int i;
485 struct lan78xx_statstage *stats;
486 u32 *src;
487 u32 *dst;
488
489 stats = kmalloc(sizeof(*stats), GFP_KERNEL);
490 if (!stats)
491 return -ENOMEM;
492
493 ret = usb_control_msg(dev->udev,
494 usb_rcvctrlpipe(dev->udev, 0),
495 USB_VENDOR_REQUEST_GET_STATS,
496 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
497 0,
498 0,
499 (void *)stats,
500 sizeof(*stats),
501 USB_CTRL_SET_TIMEOUT);
502 if (likely(ret >= 0)) {
503 src = (u32 *)stats;
504 dst = (u32 *)data;
505 for (i = 0; i < sizeof(*stats)/sizeof(u32); i++) {
506 le32_to_cpus(&src[i]);
507 dst[i] = src[i];
508 }
509 } else {
510 netdev_warn(dev->net,
511 "Failed to read stat ret = %d", ret);
512 }
513
514 kfree(stats);
515
516 return ret;
517 }
518
519 #define check_counter_rollover(struct1, dev_stats, member) { \
520 if (struct1->member < dev_stats.saved.member) \
521 dev_stats.rollover_count.member++; \
522 }
523
lan78xx_check_stat_rollover(struct lan78xx_net * dev,struct lan78xx_statstage * stats)524 static void lan78xx_check_stat_rollover(struct lan78xx_net *dev,
525 struct lan78xx_statstage *stats)
526 {
527 check_counter_rollover(stats, dev->stats, rx_fcs_errors);
528 check_counter_rollover(stats, dev->stats, rx_alignment_errors);
529 check_counter_rollover(stats, dev->stats, rx_fragment_errors);
530 check_counter_rollover(stats, dev->stats, rx_jabber_errors);
531 check_counter_rollover(stats, dev->stats, rx_undersize_frame_errors);
532 check_counter_rollover(stats, dev->stats, rx_oversize_frame_errors);
533 check_counter_rollover(stats, dev->stats, rx_dropped_frames);
534 check_counter_rollover(stats, dev->stats, rx_unicast_byte_count);
535 check_counter_rollover(stats, dev->stats, rx_broadcast_byte_count);
536 check_counter_rollover(stats, dev->stats, rx_multicast_byte_count);
537 check_counter_rollover(stats, dev->stats, rx_unicast_frames);
538 check_counter_rollover(stats, dev->stats, rx_broadcast_frames);
539 check_counter_rollover(stats, dev->stats, rx_multicast_frames);
540 check_counter_rollover(stats, dev->stats, rx_pause_frames);
541 check_counter_rollover(stats, dev->stats, rx_64_byte_frames);
542 check_counter_rollover(stats, dev->stats, rx_65_127_byte_frames);
543 check_counter_rollover(stats, dev->stats, rx_128_255_byte_frames);
544 check_counter_rollover(stats, dev->stats, rx_256_511_bytes_frames);
545 check_counter_rollover(stats, dev->stats, rx_512_1023_byte_frames);
546 check_counter_rollover(stats, dev->stats, rx_1024_1518_byte_frames);
547 check_counter_rollover(stats, dev->stats, rx_greater_1518_byte_frames);
548 check_counter_rollover(stats, dev->stats, eee_rx_lpi_transitions);
549 check_counter_rollover(stats, dev->stats, eee_rx_lpi_time);
550 check_counter_rollover(stats, dev->stats, tx_fcs_errors);
551 check_counter_rollover(stats, dev->stats, tx_excess_deferral_errors);
552 check_counter_rollover(stats, dev->stats, tx_carrier_errors);
553 check_counter_rollover(stats, dev->stats, tx_bad_byte_count);
554 check_counter_rollover(stats, dev->stats, tx_single_collisions);
555 check_counter_rollover(stats, dev->stats, tx_multiple_collisions);
556 check_counter_rollover(stats, dev->stats, tx_excessive_collision);
557 check_counter_rollover(stats, dev->stats, tx_late_collisions);
558 check_counter_rollover(stats, dev->stats, tx_unicast_byte_count);
559 check_counter_rollover(stats, dev->stats, tx_broadcast_byte_count);
560 check_counter_rollover(stats, dev->stats, tx_multicast_byte_count);
561 check_counter_rollover(stats, dev->stats, tx_unicast_frames);
562 check_counter_rollover(stats, dev->stats, tx_broadcast_frames);
563 check_counter_rollover(stats, dev->stats, tx_multicast_frames);
564 check_counter_rollover(stats, dev->stats, tx_pause_frames);
565 check_counter_rollover(stats, dev->stats, tx_64_byte_frames);
566 check_counter_rollover(stats, dev->stats, tx_65_127_byte_frames);
567 check_counter_rollover(stats, dev->stats, tx_128_255_byte_frames);
568 check_counter_rollover(stats, dev->stats, tx_256_511_bytes_frames);
569 check_counter_rollover(stats, dev->stats, tx_512_1023_byte_frames);
570 check_counter_rollover(stats, dev->stats, tx_1024_1518_byte_frames);
571 check_counter_rollover(stats, dev->stats, tx_greater_1518_byte_frames);
572 check_counter_rollover(stats, dev->stats, eee_tx_lpi_transitions);
573 check_counter_rollover(stats, dev->stats, eee_tx_lpi_time);
574
575 memcpy(&dev->stats.saved, stats, sizeof(struct lan78xx_statstage));
576 }
577
lan78xx_update_stats(struct lan78xx_net * dev)578 static void lan78xx_update_stats(struct lan78xx_net *dev)
579 {
580 u32 *p, *count, *max;
581 u64 *data;
582 int i;
583 struct lan78xx_statstage lan78xx_stats;
584
585 if (usb_autopm_get_interface(dev->intf) < 0)
586 return;
587
588 p = (u32 *)&lan78xx_stats;
589 count = (u32 *)&dev->stats.rollover_count;
590 max = (u32 *)&dev->stats.rollover_max;
591 data = (u64 *)&dev->stats.curr_stat;
592
593 mutex_lock(&dev->stats.access_lock);
594
595 if (lan78xx_read_stats(dev, &lan78xx_stats) > 0)
596 lan78xx_check_stat_rollover(dev, &lan78xx_stats);
597
598 for (i = 0; i < (sizeof(lan78xx_stats) / (sizeof(u32))); i++)
599 data[i] = (u64)p[i] + ((u64)count[i] * ((u64)max[i] + 1));
600
601 mutex_unlock(&dev->stats.access_lock);
602
603 usb_autopm_put_interface(dev->intf);
604 }
605
606 /* Loop until the read is completed with timeout called with phy_mutex held */
lan78xx_phy_wait_not_busy(struct lan78xx_net * dev)607 static int lan78xx_phy_wait_not_busy(struct lan78xx_net *dev)
608 {
609 unsigned long start_time = jiffies;
610 u32 val;
611 int ret;
612
613 do {
614 ret = lan78xx_read_reg(dev, MII_ACC, &val);
615 if (unlikely(ret < 0))
616 return -EIO;
617
618 if (!(val & MII_ACC_MII_BUSY_))
619 return 0;
620 } while (!time_after(jiffies, start_time + HZ));
621
622 return -EIO;
623 }
624
mii_access(int id,int index,int read)625 static inline u32 mii_access(int id, int index, int read)
626 {
627 u32 ret;
628
629 ret = ((u32)id << MII_ACC_PHY_ADDR_SHIFT_) & MII_ACC_PHY_ADDR_MASK_;
630 ret |= ((u32)index << MII_ACC_MIIRINDA_SHIFT_) & MII_ACC_MIIRINDA_MASK_;
631 if (read)
632 ret |= MII_ACC_MII_READ_;
633 else
634 ret |= MII_ACC_MII_WRITE_;
635 ret |= MII_ACC_MII_BUSY_;
636
637 return ret;
638 }
639
lan78xx_wait_eeprom(struct lan78xx_net * dev)640 static int lan78xx_wait_eeprom(struct lan78xx_net *dev)
641 {
642 unsigned long start_time = jiffies;
643 u32 val;
644 int ret;
645
646 do {
647 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
648 if (unlikely(ret < 0))
649 return -EIO;
650
651 if (!(val & E2P_CMD_EPC_BUSY_) ||
652 (val & E2P_CMD_EPC_TIMEOUT_))
653 break;
654 usleep_range(40, 100);
655 } while (!time_after(jiffies, start_time + HZ));
656
657 if (val & (E2P_CMD_EPC_TIMEOUT_ | E2P_CMD_EPC_BUSY_)) {
658 netdev_warn(dev->net, "EEPROM read operation timeout");
659 return -EIO;
660 }
661
662 return 0;
663 }
664
lan78xx_eeprom_confirm_not_busy(struct lan78xx_net * dev)665 static int lan78xx_eeprom_confirm_not_busy(struct lan78xx_net *dev)
666 {
667 unsigned long start_time = jiffies;
668 u32 val;
669 int ret;
670
671 do {
672 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
673 if (unlikely(ret < 0))
674 return -EIO;
675
676 if (!(val & E2P_CMD_EPC_BUSY_))
677 return 0;
678
679 usleep_range(40, 100);
680 } while (!time_after(jiffies, start_time + HZ));
681
682 netdev_warn(dev->net, "EEPROM is busy");
683 return -EIO;
684 }
685
lan78xx_read_raw_eeprom(struct lan78xx_net * dev,u32 offset,u32 length,u8 * data)686 static int lan78xx_read_raw_eeprom(struct lan78xx_net *dev, u32 offset,
687 u32 length, u8 *data)
688 {
689 u32 val;
690 u32 saved;
691 int i, ret;
692 int retval;
693
694 /* depends on chip, some EEPROM pins are muxed with LED function.
695 * disable & restore LED function to access EEPROM.
696 */
697 ret = lan78xx_read_reg(dev, HW_CFG, &val);
698 saved = val;
699 if (dev->chipid == ID_REV_CHIP_ID_7800_) {
700 val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);
701 ret = lan78xx_write_reg(dev, HW_CFG, val);
702 }
703
704 retval = lan78xx_eeprom_confirm_not_busy(dev);
705 if (retval)
706 return retval;
707
708 for (i = 0; i < length; i++) {
709 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_READ_;
710 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
711 ret = lan78xx_write_reg(dev, E2P_CMD, val);
712 if (unlikely(ret < 0)) {
713 retval = -EIO;
714 goto exit;
715 }
716
717 retval = lan78xx_wait_eeprom(dev);
718 if (retval < 0)
719 goto exit;
720
721 ret = lan78xx_read_reg(dev, E2P_DATA, &val);
722 if (unlikely(ret < 0)) {
723 retval = -EIO;
724 goto exit;
725 }
726
727 data[i] = val & 0xFF;
728 offset++;
729 }
730
731 retval = 0;
732 exit:
733 if (dev->chipid == ID_REV_CHIP_ID_7800_)
734 ret = lan78xx_write_reg(dev, HW_CFG, saved);
735
736 return retval;
737 }
738
lan78xx_read_eeprom(struct lan78xx_net * dev,u32 offset,u32 length,u8 * data)739 static int lan78xx_read_eeprom(struct lan78xx_net *dev, u32 offset,
740 u32 length, u8 *data)
741 {
742 u8 sig;
743 int ret;
744
745 ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
746 if ((ret == 0) && (sig == EEPROM_INDICATOR))
747 ret = lan78xx_read_raw_eeprom(dev, offset, length, data);
748 else
749 ret = -EINVAL;
750
751 return ret;
752 }
753
lan78xx_write_raw_eeprom(struct lan78xx_net * dev,u32 offset,u32 length,u8 * data)754 static int lan78xx_write_raw_eeprom(struct lan78xx_net *dev, u32 offset,
755 u32 length, u8 *data)
756 {
757 u32 val;
758 u32 saved;
759 int i, ret;
760 int retval;
761
762 /* depends on chip, some EEPROM pins are muxed with LED function.
763 * disable & restore LED function to access EEPROM.
764 */
765 ret = lan78xx_read_reg(dev, HW_CFG, &val);
766 saved = val;
767 if (dev->chipid == ID_REV_CHIP_ID_7800_) {
768 val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);
769 ret = lan78xx_write_reg(dev, HW_CFG, val);
770 }
771
772 retval = lan78xx_eeprom_confirm_not_busy(dev);
773 if (retval)
774 goto exit;
775
776 /* Issue write/erase enable command */
777 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_EWEN_;
778 ret = lan78xx_write_reg(dev, E2P_CMD, val);
779 if (unlikely(ret < 0)) {
780 retval = -EIO;
781 goto exit;
782 }
783
784 retval = lan78xx_wait_eeprom(dev);
785 if (retval < 0)
786 goto exit;
787
788 for (i = 0; i < length; i++) {
789 /* Fill data register */
790 val = data[i];
791 ret = lan78xx_write_reg(dev, E2P_DATA, val);
792 if (ret < 0) {
793 retval = -EIO;
794 goto exit;
795 }
796
797 /* Send "write" command */
798 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_WRITE_;
799 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
800 ret = lan78xx_write_reg(dev, E2P_CMD, val);
801 if (ret < 0) {
802 retval = -EIO;
803 goto exit;
804 }
805
806 retval = lan78xx_wait_eeprom(dev);
807 if (retval < 0)
808 goto exit;
809
810 offset++;
811 }
812
813 retval = 0;
814 exit:
815 if (dev->chipid == ID_REV_CHIP_ID_7800_)
816 ret = lan78xx_write_reg(dev, HW_CFG, saved);
817
818 return retval;
819 }
820
lan78xx_read_raw_otp(struct lan78xx_net * dev,u32 offset,u32 length,u8 * data)821 static int lan78xx_read_raw_otp(struct lan78xx_net *dev, u32 offset,
822 u32 length, u8 *data)
823 {
824 int i;
825 int ret;
826 u32 buf;
827 unsigned long timeout;
828
829 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
830
831 if (buf & OTP_PWR_DN_PWRDN_N_) {
832 /* clear it and wait to be cleared */
833 ret = lan78xx_write_reg(dev, OTP_PWR_DN, 0);
834
835 timeout = jiffies + HZ;
836 do {
837 usleep_range(1, 10);
838 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
839 if (time_after(jiffies, timeout)) {
840 netdev_warn(dev->net,
841 "timeout on OTP_PWR_DN");
842 return -EIO;
843 }
844 } while (buf & OTP_PWR_DN_PWRDN_N_);
845 }
846
847 for (i = 0; i < length; i++) {
848 ret = lan78xx_write_reg(dev, OTP_ADDR1,
849 ((offset + i) >> 8) & OTP_ADDR1_15_11);
850 ret = lan78xx_write_reg(dev, OTP_ADDR2,
851 ((offset + i) & OTP_ADDR2_10_3));
852
853 ret = lan78xx_write_reg(dev, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_);
854 ret = lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
855
856 timeout = jiffies + HZ;
857 do {
858 udelay(1);
859 ret = lan78xx_read_reg(dev, OTP_STATUS, &buf);
860 if (time_after(jiffies, timeout)) {
861 netdev_warn(dev->net,
862 "timeout on OTP_STATUS");
863 return -EIO;
864 }
865 } while (buf & OTP_STATUS_BUSY_);
866
867 ret = lan78xx_read_reg(dev, OTP_RD_DATA, &buf);
868
869 data[i] = (u8)(buf & 0xFF);
870 }
871
872 return 0;
873 }
874
lan78xx_write_raw_otp(struct lan78xx_net * dev,u32 offset,u32 length,u8 * data)875 static int lan78xx_write_raw_otp(struct lan78xx_net *dev, u32 offset,
876 u32 length, u8 *data)
877 {
878 int i;
879 int ret;
880 u32 buf;
881 unsigned long timeout;
882
883 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
884
885 if (buf & OTP_PWR_DN_PWRDN_N_) {
886 /* clear it and wait to be cleared */
887 ret = lan78xx_write_reg(dev, OTP_PWR_DN, 0);
888
889 timeout = jiffies + HZ;
890 do {
891 udelay(1);
892 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
893 if (time_after(jiffies, timeout)) {
894 netdev_warn(dev->net,
895 "timeout on OTP_PWR_DN completion");
896 return -EIO;
897 }
898 } while (buf & OTP_PWR_DN_PWRDN_N_);
899 }
900
901 /* set to BYTE program mode */
902 ret = lan78xx_write_reg(dev, OTP_PRGM_MODE, OTP_PRGM_MODE_BYTE_);
903
904 for (i = 0; i < length; i++) {
905 ret = lan78xx_write_reg(dev, OTP_ADDR1,
906 ((offset + i) >> 8) & OTP_ADDR1_15_11);
907 ret = lan78xx_write_reg(dev, OTP_ADDR2,
908 ((offset + i) & OTP_ADDR2_10_3));
909 ret = lan78xx_write_reg(dev, OTP_PRGM_DATA, data[i]);
910 ret = lan78xx_write_reg(dev, OTP_TST_CMD, OTP_TST_CMD_PRGVRFY_);
911 ret = lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
912
913 timeout = jiffies + HZ;
914 do {
915 udelay(1);
916 ret = lan78xx_read_reg(dev, OTP_STATUS, &buf);
917 if (time_after(jiffies, timeout)) {
918 netdev_warn(dev->net,
919 "Timeout on OTP_STATUS completion");
920 return -EIO;
921 }
922 } while (buf & OTP_STATUS_BUSY_);
923 }
924
925 return 0;
926 }
927
lan78xx_read_otp(struct lan78xx_net * dev,u32 offset,u32 length,u8 * data)928 static int lan78xx_read_otp(struct lan78xx_net *dev, u32 offset,
929 u32 length, u8 *data)
930 {
931 u8 sig;
932 int ret;
933
934 ret = lan78xx_read_raw_otp(dev, 0, 1, &sig);
935
936 if (ret == 0) {
937 if (sig == OTP_INDICATOR_2)
938 offset += 0x100;
939 else if (sig != OTP_INDICATOR_1)
940 ret = -EINVAL;
941 if (!ret)
942 ret = lan78xx_read_raw_otp(dev, offset, length, data);
943 }
944
945 return ret;
946 }
947
lan78xx_dataport_wait_not_busy(struct lan78xx_net * dev)948 static int lan78xx_dataport_wait_not_busy(struct lan78xx_net *dev)
949 {
950 int i, ret;
951
952 for (i = 0; i < 100; i++) {
953 u32 dp_sel;
954
955 ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
956 if (unlikely(ret < 0))
957 return -EIO;
958
959 if (dp_sel & DP_SEL_DPRDY_)
960 return 0;
961
962 usleep_range(40, 100);
963 }
964
965 netdev_warn(dev->net, "lan78xx_dataport_wait_not_busy timed out");
966
967 return -EIO;
968 }
969
lan78xx_dataport_write(struct lan78xx_net * dev,u32 ram_select,u32 addr,u32 length,u32 * buf)970 static int lan78xx_dataport_write(struct lan78xx_net *dev, u32 ram_select,
971 u32 addr, u32 length, u32 *buf)
972 {
973 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
974 u32 dp_sel;
975 int i, ret;
976
977 if (usb_autopm_get_interface(dev->intf) < 0)
978 return 0;
979
980 mutex_lock(&pdata->dataport_mutex);
981
982 ret = lan78xx_dataport_wait_not_busy(dev);
983 if (ret < 0)
984 goto done;
985
986 ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
987
988 dp_sel &= ~DP_SEL_RSEL_MASK_;
989 dp_sel |= ram_select;
990 ret = lan78xx_write_reg(dev, DP_SEL, dp_sel);
991
992 for (i = 0; i < length; i++) {
993 ret = lan78xx_write_reg(dev, DP_ADDR, addr + i);
994
995 ret = lan78xx_write_reg(dev, DP_DATA, buf[i]);
996
997 ret = lan78xx_write_reg(dev, DP_CMD, DP_CMD_WRITE_);
998
999 ret = lan78xx_dataport_wait_not_busy(dev);
1000 if (ret < 0)
1001 goto done;
1002 }
1003
1004 done:
1005 mutex_unlock(&pdata->dataport_mutex);
1006 usb_autopm_put_interface(dev->intf);
1007
1008 return ret;
1009 }
1010
lan78xx_set_addr_filter(struct lan78xx_priv * pdata,int index,u8 addr[ETH_ALEN])1011 static void lan78xx_set_addr_filter(struct lan78xx_priv *pdata,
1012 int index, u8 addr[ETH_ALEN])
1013 {
1014 u32 temp;
1015
1016 if ((pdata) && (index > 0) && (index < NUM_OF_MAF)) {
1017 temp = addr[3];
1018 temp = addr[2] | (temp << 8);
1019 temp = addr[1] | (temp << 8);
1020 temp = addr[0] | (temp << 8);
1021 pdata->pfilter_table[index][1] = temp;
1022 temp = addr[5];
1023 temp = addr[4] | (temp << 8);
1024 temp |= MAF_HI_VALID_ | MAF_HI_TYPE_DST_;
1025 pdata->pfilter_table[index][0] = temp;
1026 }
1027 }
1028
1029 /* returns hash bit number for given MAC address */
lan78xx_hash(char addr[ETH_ALEN])1030 static inline u32 lan78xx_hash(char addr[ETH_ALEN])
1031 {
1032 return (ether_crc(ETH_ALEN, addr) >> 23) & 0x1ff;
1033 }
1034
lan78xx_deferred_multicast_write(struct work_struct * param)1035 static void lan78xx_deferred_multicast_write(struct work_struct *param)
1036 {
1037 struct lan78xx_priv *pdata =
1038 container_of(param, struct lan78xx_priv, set_multicast);
1039 struct lan78xx_net *dev = pdata->dev;
1040 int i;
1041 int ret;
1042
1043 netif_dbg(dev, drv, dev->net, "deferred multicast write 0x%08x\n",
1044 pdata->rfe_ctl);
1045
1046 lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, DP_SEL_VHF_VLAN_LEN,
1047 DP_SEL_VHF_HASH_LEN, pdata->mchash_table);
1048
1049 for (i = 1; i < NUM_OF_MAF; i++) {
1050 ret = lan78xx_write_reg(dev, MAF_HI(i), 0);
1051 ret = lan78xx_write_reg(dev, MAF_LO(i),
1052 pdata->pfilter_table[i][1]);
1053 ret = lan78xx_write_reg(dev, MAF_HI(i),
1054 pdata->pfilter_table[i][0]);
1055 }
1056
1057 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
1058 }
1059
lan78xx_set_multicast(struct net_device * netdev)1060 static void lan78xx_set_multicast(struct net_device *netdev)
1061 {
1062 struct lan78xx_net *dev = netdev_priv(netdev);
1063 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1064 unsigned long flags;
1065 int i;
1066
1067 spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
1068
1069 pdata->rfe_ctl &= ~(RFE_CTL_UCAST_EN_ | RFE_CTL_MCAST_EN_ |
1070 RFE_CTL_DA_PERFECT_ | RFE_CTL_MCAST_HASH_);
1071
1072 for (i = 0; i < DP_SEL_VHF_HASH_LEN; i++)
1073 pdata->mchash_table[i] = 0;
1074 /* pfilter_table[0] has own HW address */
1075 for (i = 1; i < NUM_OF_MAF; i++) {
1076 pdata->pfilter_table[i][0] =
1077 pdata->pfilter_table[i][1] = 0;
1078 }
1079
1080 pdata->rfe_ctl |= RFE_CTL_BCAST_EN_;
1081
1082 if (dev->net->flags & IFF_PROMISC) {
1083 netif_dbg(dev, drv, dev->net, "promiscuous mode enabled");
1084 pdata->rfe_ctl |= RFE_CTL_MCAST_EN_ | RFE_CTL_UCAST_EN_;
1085 } else {
1086 if (dev->net->flags & IFF_ALLMULTI) {
1087 netif_dbg(dev, drv, dev->net,
1088 "receive all multicast enabled");
1089 pdata->rfe_ctl |= RFE_CTL_MCAST_EN_;
1090 }
1091 }
1092
1093 if (netdev_mc_count(dev->net)) {
1094 struct netdev_hw_addr *ha;
1095 int i;
1096
1097 netif_dbg(dev, drv, dev->net, "receive multicast hash filter");
1098
1099 pdata->rfe_ctl |= RFE_CTL_DA_PERFECT_;
1100
1101 i = 1;
1102 netdev_for_each_mc_addr(ha, netdev) {
1103 /* set first 32 into Perfect Filter */
1104 if (i < 33) {
1105 lan78xx_set_addr_filter(pdata, i, ha->addr);
1106 } else {
1107 u32 bitnum = lan78xx_hash(ha->addr);
1108
1109 pdata->mchash_table[bitnum / 32] |=
1110 (1 << (bitnum % 32));
1111 pdata->rfe_ctl |= RFE_CTL_MCAST_HASH_;
1112 }
1113 i++;
1114 }
1115 }
1116
1117 spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
1118
1119 /* defer register writes to a sleepable context */
1120 schedule_work(&pdata->set_multicast);
1121 }
1122
lan78xx_update_flowcontrol(struct lan78xx_net * dev,u8 duplex,u16 lcladv,u16 rmtadv)1123 static int lan78xx_update_flowcontrol(struct lan78xx_net *dev, u8 duplex,
1124 u16 lcladv, u16 rmtadv)
1125 {
1126 u32 flow = 0, fct_flow = 0;
1127 int ret;
1128 u8 cap;
1129
1130 if (dev->fc_autoneg)
1131 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
1132 else
1133 cap = dev->fc_request_control;
1134
1135 if (cap & FLOW_CTRL_TX)
1136 flow |= (FLOW_CR_TX_FCEN_ | 0xFFFF);
1137
1138 if (cap & FLOW_CTRL_RX)
1139 flow |= FLOW_CR_RX_FCEN_;
1140
1141 if (dev->udev->speed == USB_SPEED_SUPER)
1142 fct_flow = 0x817;
1143 else if (dev->udev->speed == USB_SPEED_HIGH)
1144 fct_flow = 0x211;
1145
1146 netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s",
1147 (cap & FLOW_CTRL_RX ? "enabled" : "disabled"),
1148 (cap & FLOW_CTRL_TX ? "enabled" : "disabled"));
1149
1150 ret = lan78xx_write_reg(dev, FCT_FLOW, fct_flow);
1151
1152 /* threshold value should be set before enabling flow */
1153 ret = lan78xx_write_reg(dev, FLOW, flow);
1154
1155 return 0;
1156 }
1157
lan78xx_link_reset(struct lan78xx_net * dev)1158 static int lan78xx_link_reset(struct lan78xx_net *dev)
1159 {
1160 struct phy_device *phydev = dev->net->phydev;
1161 struct ethtool_link_ksettings ecmd;
1162 int ladv, radv, ret, link;
1163 u32 buf;
1164
1165 /* clear LAN78xx interrupt status */
1166 ret = lan78xx_write_reg(dev, INT_STS, INT_STS_PHY_INT_);
1167 if (unlikely(ret < 0))
1168 return -EIO;
1169
1170 mutex_lock(&phydev->lock);
1171 phy_read_status(phydev);
1172 link = phydev->link;
1173 mutex_unlock(&phydev->lock);
1174
1175 if (!link && dev->link_on) {
1176 dev->link_on = false;
1177
1178 /* reset MAC */
1179 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1180 if (unlikely(ret < 0))
1181 return -EIO;
1182 buf |= MAC_CR_RST_;
1183 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1184 if (unlikely(ret < 0))
1185 return -EIO;
1186
1187 del_timer(&dev->stat_monitor);
1188 } else if (link && !dev->link_on) {
1189 dev->link_on = true;
1190
1191 phy_ethtool_ksettings_get(phydev, &ecmd);
1192
1193 if (dev->udev->speed == USB_SPEED_SUPER) {
1194 if (ecmd.base.speed == 1000) {
1195 /* disable U2 */
1196 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1197 buf &= ~USB_CFG1_DEV_U2_INIT_EN_;
1198 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1199 /* enable U1 */
1200 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1201 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1202 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1203 } else {
1204 /* enable U1 & U2 */
1205 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1206 buf |= USB_CFG1_DEV_U2_INIT_EN_;
1207 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1208 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1209 }
1210 }
1211
1212 ladv = phy_read(phydev, MII_ADVERTISE);
1213 if (ladv < 0)
1214 return ladv;
1215
1216 radv = phy_read(phydev, MII_LPA);
1217 if (radv < 0)
1218 return radv;
1219
1220 netif_dbg(dev, link, dev->net,
1221 "speed: %u duplex: %d anadv: 0x%04x anlpa: 0x%04x",
1222 ecmd.base.speed, ecmd.base.duplex, ladv, radv);
1223
1224 ret = lan78xx_update_flowcontrol(dev, ecmd.base.duplex, ladv,
1225 radv);
1226
1227 if (!timer_pending(&dev->stat_monitor)) {
1228 dev->delta = 1;
1229 mod_timer(&dev->stat_monitor,
1230 jiffies + STAT_UPDATE_TIMER);
1231 }
1232
1233 tasklet_schedule(&dev->bh);
1234 }
1235
1236 return ret;
1237 }
1238
1239 /* some work can't be done in tasklets, so we use keventd
1240 *
1241 * NOTE: annoying asymmetry: if it's active, schedule_work() fails,
1242 * but tasklet_schedule() doesn't. hope the failure is rare.
1243 */
lan78xx_defer_kevent(struct lan78xx_net * dev,int work)1244 static void lan78xx_defer_kevent(struct lan78xx_net *dev, int work)
1245 {
1246 set_bit(work, &dev->flags);
1247 if (!schedule_delayed_work(&dev->wq, 0))
1248 netdev_err(dev->net, "kevent %d may have been dropped\n", work);
1249 }
1250
lan78xx_status(struct lan78xx_net * dev,struct urb * urb)1251 static void lan78xx_status(struct lan78xx_net *dev, struct urb *urb)
1252 {
1253 u32 intdata;
1254
1255 if (urb->actual_length != 4) {
1256 netdev_warn(dev->net,
1257 "unexpected urb length %d", urb->actual_length);
1258 return;
1259 }
1260
1261 intdata = get_unaligned_le32(urb->transfer_buffer);
1262
1263 if (intdata & INT_ENP_PHY_INT) {
1264 netif_dbg(dev, link, dev->net, "PHY INTR: 0x%08x\n", intdata);
1265 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
1266
1267 if (dev->domain_data.phyirq > 0) {
1268 local_irq_disable();
1269 generic_handle_irq(dev->domain_data.phyirq);
1270 local_irq_enable();
1271 }
1272 } else
1273 netdev_warn(dev->net,
1274 "unexpected interrupt: 0x%08x\n", intdata);
1275 }
1276
lan78xx_ethtool_get_eeprom_len(struct net_device * netdev)1277 static int lan78xx_ethtool_get_eeprom_len(struct net_device *netdev)
1278 {
1279 return MAX_EEPROM_SIZE;
1280 }
1281
lan78xx_ethtool_get_eeprom(struct net_device * netdev,struct ethtool_eeprom * ee,u8 * data)1282 static int lan78xx_ethtool_get_eeprom(struct net_device *netdev,
1283 struct ethtool_eeprom *ee, u8 *data)
1284 {
1285 struct lan78xx_net *dev = netdev_priv(netdev);
1286 int ret;
1287
1288 ret = usb_autopm_get_interface(dev->intf);
1289 if (ret)
1290 return ret;
1291
1292 ee->magic = LAN78XX_EEPROM_MAGIC;
1293
1294 ret = lan78xx_read_raw_eeprom(dev, ee->offset, ee->len, data);
1295
1296 usb_autopm_put_interface(dev->intf);
1297
1298 return ret;
1299 }
1300
lan78xx_ethtool_set_eeprom(struct net_device * netdev,struct ethtool_eeprom * ee,u8 * data)1301 static int lan78xx_ethtool_set_eeprom(struct net_device *netdev,
1302 struct ethtool_eeprom *ee, u8 *data)
1303 {
1304 struct lan78xx_net *dev = netdev_priv(netdev);
1305 int ret;
1306
1307 ret = usb_autopm_get_interface(dev->intf);
1308 if (ret)
1309 return ret;
1310
1311 /* Invalid EEPROM_INDICATOR at offset zero will result in a failure
1312 * to load data from EEPROM
1313 */
1314 if (ee->magic == LAN78XX_EEPROM_MAGIC)
1315 ret = lan78xx_write_raw_eeprom(dev, ee->offset, ee->len, data);
1316 else if ((ee->magic == LAN78XX_OTP_MAGIC) &&
1317 (ee->offset == 0) &&
1318 (ee->len == 512) &&
1319 (data[0] == OTP_INDICATOR_1))
1320 ret = lan78xx_write_raw_otp(dev, ee->offset, ee->len, data);
1321
1322 usb_autopm_put_interface(dev->intf);
1323
1324 return ret;
1325 }
1326
lan78xx_get_strings(struct net_device * netdev,u32 stringset,u8 * data)1327 static void lan78xx_get_strings(struct net_device *netdev, u32 stringset,
1328 u8 *data)
1329 {
1330 if (stringset == ETH_SS_STATS)
1331 memcpy(data, lan78xx_gstrings, sizeof(lan78xx_gstrings));
1332 }
1333
lan78xx_get_sset_count(struct net_device * netdev,int sset)1334 static int lan78xx_get_sset_count(struct net_device *netdev, int sset)
1335 {
1336 if (sset == ETH_SS_STATS)
1337 return ARRAY_SIZE(lan78xx_gstrings);
1338 else
1339 return -EOPNOTSUPP;
1340 }
1341
lan78xx_get_stats(struct net_device * netdev,struct ethtool_stats * stats,u64 * data)1342 static void lan78xx_get_stats(struct net_device *netdev,
1343 struct ethtool_stats *stats, u64 *data)
1344 {
1345 struct lan78xx_net *dev = netdev_priv(netdev);
1346
1347 lan78xx_update_stats(dev);
1348
1349 mutex_lock(&dev->stats.access_lock);
1350 memcpy(data, &dev->stats.curr_stat, sizeof(dev->stats.curr_stat));
1351 mutex_unlock(&dev->stats.access_lock);
1352 }
1353
lan78xx_get_wol(struct net_device * netdev,struct ethtool_wolinfo * wol)1354 static void lan78xx_get_wol(struct net_device *netdev,
1355 struct ethtool_wolinfo *wol)
1356 {
1357 struct lan78xx_net *dev = netdev_priv(netdev);
1358 int ret;
1359 u32 buf;
1360 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1361
1362 if (usb_autopm_get_interface(dev->intf) < 0)
1363 return;
1364
1365 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1366 if (unlikely(ret < 0)) {
1367 wol->supported = 0;
1368 wol->wolopts = 0;
1369 } else {
1370 if (buf & USB_CFG_RMT_WKP_) {
1371 wol->supported = WAKE_ALL;
1372 wol->wolopts = pdata->wol;
1373 } else {
1374 wol->supported = 0;
1375 wol->wolopts = 0;
1376 }
1377 }
1378
1379 usb_autopm_put_interface(dev->intf);
1380 }
1381
lan78xx_set_wol(struct net_device * netdev,struct ethtool_wolinfo * wol)1382 static int lan78xx_set_wol(struct net_device *netdev,
1383 struct ethtool_wolinfo *wol)
1384 {
1385 struct lan78xx_net *dev = netdev_priv(netdev);
1386 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1387 int ret;
1388
1389 ret = usb_autopm_get_interface(dev->intf);
1390 if (ret < 0)
1391 return ret;
1392
1393 if (wol->wolopts & ~WAKE_ALL)
1394 return -EINVAL;
1395
1396 pdata->wol = wol->wolopts;
1397
1398 device_set_wakeup_enable(&dev->udev->dev, (bool)wol->wolopts);
1399
1400 phy_ethtool_set_wol(netdev->phydev, wol);
1401
1402 usb_autopm_put_interface(dev->intf);
1403
1404 return ret;
1405 }
1406
lan78xx_get_eee(struct net_device * net,struct ethtool_eee * edata)1407 static int lan78xx_get_eee(struct net_device *net, struct ethtool_eee *edata)
1408 {
1409 struct lan78xx_net *dev = netdev_priv(net);
1410 struct phy_device *phydev = net->phydev;
1411 int ret;
1412 u32 buf;
1413
1414 ret = usb_autopm_get_interface(dev->intf);
1415 if (ret < 0)
1416 return ret;
1417
1418 ret = phy_ethtool_get_eee(phydev, edata);
1419 if (ret < 0)
1420 goto exit;
1421
1422 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1423 if (buf & MAC_CR_EEE_EN_) {
1424 edata->eee_enabled = true;
1425 edata->eee_active = !!(edata->advertised &
1426 edata->lp_advertised);
1427 edata->tx_lpi_enabled = true;
1428 /* EEE_TX_LPI_REQ_DLY & tx_lpi_timer are same uSec unit */
1429 ret = lan78xx_read_reg(dev, EEE_TX_LPI_REQ_DLY, &buf);
1430 edata->tx_lpi_timer = buf;
1431 } else {
1432 edata->eee_enabled = false;
1433 edata->eee_active = false;
1434 edata->tx_lpi_enabled = false;
1435 edata->tx_lpi_timer = 0;
1436 }
1437
1438 ret = 0;
1439 exit:
1440 usb_autopm_put_interface(dev->intf);
1441
1442 return ret;
1443 }
1444
lan78xx_set_eee(struct net_device * net,struct ethtool_eee * edata)1445 static int lan78xx_set_eee(struct net_device *net, struct ethtool_eee *edata)
1446 {
1447 struct lan78xx_net *dev = netdev_priv(net);
1448 int ret;
1449 u32 buf;
1450
1451 ret = usb_autopm_get_interface(dev->intf);
1452 if (ret < 0)
1453 return ret;
1454
1455 if (edata->eee_enabled) {
1456 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1457 buf |= MAC_CR_EEE_EN_;
1458 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1459
1460 phy_ethtool_set_eee(net->phydev, edata);
1461
1462 buf = (u32)edata->tx_lpi_timer;
1463 ret = lan78xx_write_reg(dev, EEE_TX_LPI_REQ_DLY, buf);
1464 } else {
1465 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1466 buf &= ~MAC_CR_EEE_EN_;
1467 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1468 }
1469
1470 usb_autopm_put_interface(dev->intf);
1471
1472 return 0;
1473 }
1474
lan78xx_get_link(struct net_device * net)1475 static u32 lan78xx_get_link(struct net_device *net)
1476 {
1477 u32 link;
1478
1479 mutex_lock(&net->phydev->lock);
1480 phy_read_status(net->phydev);
1481 link = net->phydev->link;
1482 mutex_unlock(&net->phydev->lock);
1483
1484 return link;
1485 }
1486
lan78xx_get_drvinfo(struct net_device * net,struct ethtool_drvinfo * info)1487 static void lan78xx_get_drvinfo(struct net_device *net,
1488 struct ethtool_drvinfo *info)
1489 {
1490 struct lan78xx_net *dev = netdev_priv(net);
1491
1492 strncpy(info->driver, DRIVER_NAME, sizeof(info->driver));
1493 usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
1494 }
1495
lan78xx_get_msglevel(struct net_device * net)1496 static u32 lan78xx_get_msglevel(struct net_device *net)
1497 {
1498 struct lan78xx_net *dev = netdev_priv(net);
1499
1500 return dev->msg_enable;
1501 }
1502
lan78xx_set_msglevel(struct net_device * net,u32 level)1503 static void lan78xx_set_msglevel(struct net_device *net, u32 level)
1504 {
1505 struct lan78xx_net *dev = netdev_priv(net);
1506
1507 dev->msg_enable = level;
1508 }
1509
lan78xx_get_link_ksettings(struct net_device * net,struct ethtool_link_ksettings * cmd)1510 static int lan78xx_get_link_ksettings(struct net_device *net,
1511 struct ethtool_link_ksettings *cmd)
1512 {
1513 struct lan78xx_net *dev = netdev_priv(net);
1514 struct phy_device *phydev = net->phydev;
1515 int ret;
1516
1517 ret = usb_autopm_get_interface(dev->intf);
1518 if (ret < 0)
1519 return ret;
1520
1521 phy_ethtool_ksettings_get(phydev, cmd);
1522
1523 usb_autopm_put_interface(dev->intf);
1524
1525 return ret;
1526 }
1527
lan78xx_set_link_ksettings(struct net_device * net,const struct ethtool_link_ksettings * cmd)1528 static int lan78xx_set_link_ksettings(struct net_device *net,
1529 const struct ethtool_link_ksettings *cmd)
1530 {
1531 struct lan78xx_net *dev = netdev_priv(net);
1532 struct phy_device *phydev = net->phydev;
1533 int ret = 0;
1534 int temp;
1535
1536 ret = usb_autopm_get_interface(dev->intf);
1537 if (ret < 0)
1538 return ret;
1539
1540 /* change speed & duplex */
1541 ret = phy_ethtool_ksettings_set(phydev, cmd);
1542
1543 if (!cmd->base.autoneg) {
1544 /* force link down */
1545 temp = phy_read(phydev, MII_BMCR);
1546 phy_write(phydev, MII_BMCR, temp | BMCR_LOOPBACK);
1547 mdelay(1);
1548 phy_write(phydev, MII_BMCR, temp);
1549 }
1550
1551 usb_autopm_put_interface(dev->intf);
1552
1553 return ret;
1554 }
1555
lan78xx_get_pause(struct net_device * net,struct ethtool_pauseparam * pause)1556 static void lan78xx_get_pause(struct net_device *net,
1557 struct ethtool_pauseparam *pause)
1558 {
1559 struct lan78xx_net *dev = netdev_priv(net);
1560 struct phy_device *phydev = net->phydev;
1561 struct ethtool_link_ksettings ecmd;
1562
1563 phy_ethtool_ksettings_get(phydev, &ecmd);
1564
1565 pause->autoneg = dev->fc_autoneg;
1566
1567 if (dev->fc_request_control & FLOW_CTRL_TX)
1568 pause->tx_pause = 1;
1569
1570 if (dev->fc_request_control & FLOW_CTRL_RX)
1571 pause->rx_pause = 1;
1572 }
1573
lan78xx_set_pause(struct net_device * net,struct ethtool_pauseparam * pause)1574 static int lan78xx_set_pause(struct net_device *net,
1575 struct ethtool_pauseparam *pause)
1576 {
1577 struct lan78xx_net *dev = netdev_priv(net);
1578 struct phy_device *phydev = net->phydev;
1579 struct ethtool_link_ksettings ecmd;
1580 int ret;
1581
1582 phy_ethtool_ksettings_get(phydev, &ecmd);
1583
1584 if (pause->autoneg && !ecmd.base.autoneg) {
1585 ret = -EINVAL;
1586 goto exit;
1587 }
1588
1589 dev->fc_request_control = 0;
1590 if (pause->rx_pause)
1591 dev->fc_request_control |= FLOW_CTRL_RX;
1592
1593 if (pause->tx_pause)
1594 dev->fc_request_control |= FLOW_CTRL_TX;
1595
1596 if (ecmd.base.autoneg) {
1597 __ETHTOOL_DECLARE_LINK_MODE_MASK(fc) = { 0, };
1598 u32 mii_adv;
1599
1600 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,
1601 ecmd.link_modes.advertising);
1602 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
1603 ecmd.link_modes.advertising);
1604 mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
1605 mii_adv_to_linkmode_adv_t(fc, mii_adv);
1606 linkmode_or(ecmd.link_modes.advertising, fc,
1607 ecmd.link_modes.advertising);
1608
1609 phy_ethtool_ksettings_set(phydev, &ecmd);
1610 }
1611
1612 dev->fc_autoneg = pause->autoneg;
1613
1614 ret = 0;
1615 exit:
1616 return ret;
1617 }
1618
lan78xx_get_regs_len(struct net_device * netdev)1619 static int lan78xx_get_regs_len(struct net_device *netdev)
1620 {
1621 if (!netdev->phydev)
1622 return (sizeof(lan78xx_regs));
1623 else
1624 return (sizeof(lan78xx_regs) + PHY_REG_SIZE);
1625 }
1626
1627 static void
lan78xx_get_regs(struct net_device * netdev,struct ethtool_regs * regs,void * buf)1628 lan78xx_get_regs(struct net_device *netdev, struct ethtool_regs *regs,
1629 void *buf)
1630 {
1631 u32 *data = buf;
1632 int i, j;
1633 struct lan78xx_net *dev = netdev_priv(netdev);
1634
1635 /* Read Device/MAC registers */
1636 for (i = 0; i < ARRAY_SIZE(lan78xx_regs); i++)
1637 lan78xx_read_reg(dev, lan78xx_regs[i], &data[i]);
1638
1639 if (!netdev->phydev)
1640 return;
1641
1642 /* Read PHY registers */
1643 for (j = 0; j < 32; i++, j++)
1644 data[i] = phy_read(netdev->phydev, j);
1645 }
1646
1647 static const struct ethtool_ops lan78xx_ethtool_ops = {
1648 .get_link = lan78xx_get_link,
1649 .nway_reset = phy_ethtool_nway_reset,
1650 .get_drvinfo = lan78xx_get_drvinfo,
1651 .get_msglevel = lan78xx_get_msglevel,
1652 .set_msglevel = lan78xx_set_msglevel,
1653 .get_eeprom_len = lan78xx_ethtool_get_eeprom_len,
1654 .get_eeprom = lan78xx_ethtool_get_eeprom,
1655 .set_eeprom = lan78xx_ethtool_set_eeprom,
1656 .get_ethtool_stats = lan78xx_get_stats,
1657 .get_sset_count = lan78xx_get_sset_count,
1658 .get_strings = lan78xx_get_strings,
1659 .get_wol = lan78xx_get_wol,
1660 .set_wol = lan78xx_set_wol,
1661 .get_eee = lan78xx_get_eee,
1662 .set_eee = lan78xx_set_eee,
1663 .get_pauseparam = lan78xx_get_pause,
1664 .set_pauseparam = lan78xx_set_pause,
1665 .get_link_ksettings = lan78xx_get_link_ksettings,
1666 .set_link_ksettings = lan78xx_set_link_ksettings,
1667 .get_regs_len = lan78xx_get_regs_len,
1668 .get_regs = lan78xx_get_regs,
1669 };
1670
lan78xx_init_mac_address(struct lan78xx_net * dev)1671 static void lan78xx_init_mac_address(struct lan78xx_net *dev)
1672 {
1673 u32 addr_lo, addr_hi;
1674 int ret;
1675 u8 addr[6];
1676
1677 ret = lan78xx_read_reg(dev, RX_ADDRL, &addr_lo);
1678 ret = lan78xx_read_reg(dev, RX_ADDRH, &addr_hi);
1679
1680 addr[0] = addr_lo & 0xFF;
1681 addr[1] = (addr_lo >> 8) & 0xFF;
1682 addr[2] = (addr_lo >> 16) & 0xFF;
1683 addr[3] = (addr_lo >> 24) & 0xFF;
1684 addr[4] = addr_hi & 0xFF;
1685 addr[5] = (addr_hi >> 8) & 0xFF;
1686
1687 if (!is_valid_ether_addr(addr)) {
1688 if (!eth_platform_get_mac_address(&dev->udev->dev, addr)) {
1689 /* valid address present in Device Tree */
1690 netif_dbg(dev, ifup, dev->net,
1691 "MAC address read from Device Tree");
1692 } else if (((lan78xx_read_eeprom(dev, EEPROM_MAC_OFFSET,
1693 ETH_ALEN, addr) == 0) ||
1694 (lan78xx_read_otp(dev, EEPROM_MAC_OFFSET,
1695 ETH_ALEN, addr) == 0)) &&
1696 is_valid_ether_addr(addr)) {
1697 /* eeprom values are valid so use them */
1698 netif_dbg(dev, ifup, dev->net,
1699 "MAC address read from EEPROM");
1700 } else {
1701 /* generate random MAC */
1702 eth_random_addr(addr);
1703 netif_dbg(dev, ifup, dev->net,
1704 "MAC address set to random addr");
1705 }
1706
1707 addr_lo = addr[0] | (addr[1] << 8) |
1708 (addr[2] << 16) | (addr[3] << 24);
1709 addr_hi = addr[4] | (addr[5] << 8);
1710
1711 ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
1712 ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
1713 }
1714
1715 ret = lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
1716 ret = lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
1717
1718 ether_addr_copy(dev->net->dev_addr, addr);
1719 }
1720
1721 /* MDIO read and write wrappers for phylib */
lan78xx_mdiobus_read(struct mii_bus * bus,int phy_id,int idx)1722 static int lan78xx_mdiobus_read(struct mii_bus *bus, int phy_id, int idx)
1723 {
1724 struct lan78xx_net *dev = bus->priv;
1725 u32 val, addr;
1726 int ret;
1727
1728 ret = usb_autopm_get_interface(dev->intf);
1729 if (ret < 0)
1730 return ret;
1731
1732 mutex_lock(&dev->phy_mutex);
1733
1734 /* confirm MII not busy */
1735 ret = lan78xx_phy_wait_not_busy(dev);
1736 if (ret < 0)
1737 goto done;
1738
1739 /* set the address, index & direction (read from PHY) */
1740 addr = mii_access(phy_id, idx, MII_READ);
1741 ret = lan78xx_write_reg(dev, MII_ACC, addr);
1742
1743 ret = lan78xx_phy_wait_not_busy(dev);
1744 if (ret < 0)
1745 goto done;
1746
1747 ret = lan78xx_read_reg(dev, MII_DATA, &val);
1748
1749 ret = (int)(val & 0xFFFF);
1750
1751 done:
1752 mutex_unlock(&dev->phy_mutex);
1753 usb_autopm_put_interface(dev->intf);
1754
1755 return ret;
1756 }
1757
lan78xx_mdiobus_write(struct mii_bus * bus,int phy_id,int idx,u16 regval)1758 static int lan78xx_mdiobus_write(struct mii_bus *bus, int phy_id, int idx,
1759 u16 regval)
1760 {
1761 struct lan78xx_net *dev = bus->priv;
1762 u32 val, addr;
1763 int ret;
1764
1765 ret = usb_autopm_get_interface(dev->intf);
1766 if (ret < 0)
1767 return ret;
1768
1769 mutex_lock(&dev->phy_mutex);
1770
1771 /* confirm MII not busy */
1772 ret = lan78xx_phy_wait_not_busy(dev);
1773 if (ret < 0)
1774 goto done;
1775
1776 val = (u32)regval;
1777 ret = lan78xx_write_reg(dev, MII_DATA, val);
1778
1779 /* set the address, index & direction (write to PHY) */
1780 addr = mii_access(phy_id, idx, MII_WRITE);
1781 ret = lan78xx_write_reg(dev, MII_ACC, addr);
1782
1783 ret = lan78xx_phy_wait_not_busy(dev);
1784 if (ret < 0)
1785 goto done;
1786
1787 done:
1788 mutex_unlock(&dev->phy_mutex);
1789 usb_autopm_put_interface(dev->intf);
1790 return 0;
1791 }
1792
lan78xx_mdio_init(struct lan78xx_net * dev)1793 static int lan78xx_mdio_init(struct lan78xx_net *dev)
1794 {
1795 struct device_node *node;
1796 int ret;
1797
1798 dev->mdiobus = mdiobus_alloc();
1799 if (!dev->mdiobus) {
1800 netdev_err(dev->net, "can't allocate MDIO bus\n");
1801 return -ENOMEM;
1802 }
1803
1804 dev->mdiobus->priv = (void *)dev;
1805 dev->mdiobus->read = lan78xx_mdiobus_read;
1806 dev->mdiobus->write = lan78xx_mdiobus_write;
1807 dev->mdiobus->name = "lan78xx-mdiobus";
1808 dev->mdiobus->parent = &dev->udev->dev;
1809
1810 snprintf(dev->mdiobus->id, MII_BUS_ID_SIZE, "usb-%03d:%03d",
1811 dev->udev->bus->busnum, dev->udev->devnum);
1812
1813 switch (dev->chipid) {
1814 case ID_REV_CHIP_ID_7800_:
1815 case ID_REV_CHIP_ID_7850_:
1816 /* set to internal PHY id */
1817 dev->mdiobus->phy_mask = ~(1 << 1);
1818 break;
1819 case ID_REV_CHIP_ID_7801_:
1820 /* scan thru PHYAD[2..0] */
1821 dev->mdiobus->phy_mask = ~(0xFF);
1822 break;
1823 }
1824
1825 node = of_get_child_by_name(dev->udev->dev.of_node, "mdio");
1826 ret = of_mdiobus_register(dev->mdiobus, node);
1827 of_node_put(node);
1828 if (ret) {
1829 netdev_err(dev->net, "can't register MDIO bus\n");
1830 goto exit1;
1831 }
1832
1833 netdev_dbg(dev->net, "registered mdiobus bus %s\n", dev->mdiobus->id);
1834 return 0;
1835 exit1:
1836 mdiobus_free(dev->mdiobus);
1837 return ret;
1838 }
1839
lan78xx_remove_mdio(struct lan78xx_net * dev)1840 static void lan78xx_remove_mdio(struct lan78xx_net *dev)
1841 {
1842 mdiobus_unregister(dev->mdiobus);
1843 mdiobus_free(dev->mdiobus);
1844 }
1845
lan78xx_link_status_change(struct net_device * net)1846 static void lan78xx_link_status_change(struct net_device *net)
1847 {
1848 struct phy_device *phydev = net->phydev;
1849 int ret, temp;
1850
1851 /* At forced 100 F/H mode, chip may fail to set mode correctly
1852 * when cable is switched between long(~50+m) and short one.
1853 * As workaround, set to 10 before setting to 100
1854 * at forced 100 F/H mode.
1855 */
1856 if (!phydev->autoneg && (phydev->speed == 100)) {
1857 /* disable phy interrupt */
1858 temp = phy_read(phydev, LAN88XX_INT_MASK);
1859 temp &= ~LAN88XX_INT_MASK_MDINTPIN_EN_;
1860 ret = phy_write(phydev, LAN88XX_INT_MASK, temp);
1861
1862 temp = phy_read(phydev, MII_BMCR);
1863 temp &= ~(BMCR_SPEED100 | BMCR_SPEED1000);
1864 phy_write(phydev, MII_BMCR, temp); /* set to 10 first */
1865 temp |= BMCR_SPEED100;
1866 phy_write(phydev, MII_BMCR, temp); /* set to 100 later */
1867
1868 /* clear pending interrupt generated while workaround */
1869 temp = phy_read(phydev, LAN88XX_INT_STS);
1870
1871 /* enable phy interrupt back */
1872 temp = phy_read(phydev, LAN88XX_INT_MASK);
1873 temp |= LAN88XX_INT_MASK_MDINTPIN_EN_;
1874 ret = phy_write(phydev, LAN88XX_INT_MASK, temp);
1875 }
1876 }
1877
irq_map(struct irq_domain * d,unsigned int irq,irq_hw_number_t hwirq)1878 static int irq_map(struct irq_domain *d, unsigned int irq,
1879 irq_hw_number_t hwirq)
1880 {
1881 struct irq_domain_data *data = d->host_data;
1882
1883 irq_set_chip_data(irq, data);
1884 irq_set_chip_and_handler(irq, data->irqchip, data->irq_handler);
1885 irq_set_noprobe(irq);
1886
1887 return 0;
1888 }
1889
irq_unmap(struct irq_domain * d,unsigned int irq)1890 static void irq_unmap(struct irq_domain *d, unsigned int irq)
1891 {
1892 irq_set_chip_and_handler(irq, NULL, NULL);
1893 irq_set_chip_data(irq, NULL);
1894 }
1895
1896 static const struct irq_domain_ops chip_domain_ops = {
1897 .map = irq_map,
1898 .unmap = irq_unmap,
1899 };
1900
lan78xx_irq_mask(struct irq_data * irqd)1901 static void lan78xx_irq_mask(struct irq_data *irqd)
1902 {
1903 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1904
1905 data->irqenable &= ~BIT(irqd_to_hwirq(irqd));
1906 }
1907
lan78xx_irq_unmask(struct irq_data * irqd)1908 static void lan78xx_irq_unmask(struct irq_data *irqd)
1909 {
1910 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1911
1912 data->irqenable |= BIT(irqd_to_hwirq(irqd));
1913 }
1914
lan78xx_irq_bus_lock(struct irq_data * irqd)1915 static void lan78xx_irq_bus_lock(struct irq_data *irqd)
1916 {
1917 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1918
1919 mutex_lock(&data->irq_lock);
1920 }
1921
lan78xx_irq_bus_sync_unlock(struct irq_data * irqd)1922 static void lan78xx_irq_bus_sync_unlock(struct irq_data *irqd)
1923 {
1924 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1925 struct lan78xx_net *dev =
1926 container_of(data, struct lan78xx_net, domain_data);
1927 u32 buf;
1928 int ret;
1929
1930 /* call register access here because irq_bus_lock & irq_bus_sync_unlock
1931 * are only two callbacks executed in non-atomic contex.
1932 */
1933 ret = lan78xx_read_reg(dev, INT_EP_CTL, &buf);
1934 if (buf != data->irqenable)
1935 ret = lan78xx_write_reg(dev, INT_EP_CTL, data->irqenable);
1936
1937 mutex_unlock(&data->irq_lock);
1938 }
1939
1940 static struct irq_chip lan78xx_irqchip = {
1941 .name = "lan78xx-irqs",
1942 .irq_mask = lan78xx_irq_mask,
1943 .irq_unmask = lan78xx_irq_unmask,
1944 .irq_bus_lock = lan78xx_irq_bus_lock,
1945 .irq_bus_sync_unlock = lan78xx_irq_bus_sync_unlock,
1946 };
1947
lan78xx_setup_irq_domain(struct lan78xx_net * dev)1948 static int lan78xx_setup_irq_domain(struct lan78xx_net *dev)
1949 {
1950 struct device_node *of_node;
1951 struct irq_domain *irqdomain;
1952 unsigned int irqmap = 0;
1953 u32 buf;
1954 int ret = 0;
1955
1956 of_node = dev->udev->dev.parent->of_node;
1957
1958 mutex_init(&dev->domain_data.irq_lock);
1959
1960 lan78xx_read_reg(dev, INT_EP_CTL, &buf);
1961 dev->domain_data.irqenable = buf;
1962
1963 dev->domain_data.irqchip = &lan78xx_irqchip;
1964 dev->domain_data.irq_handler = handle_simple_irq;
1965
1966 irqdomain = irq_domain_add_simple(of_node, MAX_INT_EP, 0,
1967 &chip_domain_ops, &dev->domain_data);
1968 if (irqdomain) {
1969 /* create mapping for PHY interrupt */
1970 irqmap = irq_create_mapping(irqdomain, INT_EP_PHY);
1971 if (!irqmap) {
1972 irq_domain_remove(irqdomain);
1973
1974 irqdomain = NULL;
1975 ret = -EINVAL;
1976 }
1977 } else {
1978 ret = -EINVAL;
1979 }
1980
1981 dev->domain_data.irqdomain = irqdomain;
1982 dev->domain_data.phyirq = irqmap;
1983
1984 return ret;
1985 }
1986
lan78xx_remove_irq_domain(struct lan78xx_net * dev)1987 static void lan78xx_remove_irq_domain(struct lan78xx_net *dev)
1988 {
1989 if (dev->domain_data.phyirq > 0) {
1990 irq_dispose_mapping(dev->domain_data.phyirq);
1991
1992 if (dev->domain_data.irqdomain)
1993 irq_domain_remove(dev->domain_data.irqdomain);
1994 }
1995 dev->domain_data.phyirq = 0;
1996 dev->domain_data.irqdomain = NULL;
1997 }
1998
lan8835_fixup(struct phy_device * phydev)1999 static int lan8835_fixup(struct phy_device *phydev)
2000 {
2001 int buf;
2002 int ret;
2003 struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
2004
2005 /* LED2/PME_N/IRQ_N/RGMII_ID pin to IRQ_N mode */
2006 buf = phy_read_mmd(phydev, MDIO_MMD_PCS, 0x8010);
2007 buf &= ~0x1800;
2008 buf |= 0x0800;
2009 phy_write_mmd(phydev, MDIO_MMD_PCS, 0x8010, buf);
2010
2011 /* RGMII MAC TXC Delay Enable */
2012 ret = lan78xx_write_reg(dev, MAC_RGMII_ID,
2013 MAC_RGMII_ID_TXC_DELAY_EN_);
2014
2015 /* RGMII TX DLL Tune Adjust */
2016 ret = lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
2017
2018 dev->interface = PHY_INTERFACE_MODE_RGMII_TXID;
2019
2020 return 1;
2021 }
2022
ksz9031rnx_fixup(struct phy_device * phydev)2023 static int ksz9031rnx_fixup(struct phy_device *phydev)
2024 {
2025 struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
2026
2027 /* Micrel9301RNX PHY configuration */
2028 /* RGMII Control Signal Pad Skew */
2029 phy_write_mmd(phydev, MDIO_MMD_WIS, 4, 0x0077);
2030 /* RGMII RX Data Pad Skew */
2031 phy_write_mmd(phydev, MDIO_MMD_WIS, 5, 0x7777);
2032 /* RGMII RX Clock Pad Skew */
2033 phy_write_mmd(phydev, MDIO_MMD_WIS, 8, 0x1FF);
2034
2035 dev->interface = PHY_INTERFACE_MODE_RGMII_RXID;
2036
2037 return 1;
2038 }
2039
lan7801_phy_init(struct lan78xx_net * dev)2040 static struct phy_device *lan7801_phy_init(struct lan78xx_net *dev)
2041 {
2042 u32 buf;
2043 int ret;
2044 struct fixed_phy_status fphy_status = {
2045 .link = 1,
2046 .speed = SPEED_1000,
2047 .duplex = DUPLEX_FULL,
2048 };
2049 struct phy_device *phydev;
2050
2051 phydev = phy_find_first(dev->mdiobus);
2052 if (!phydev) {
2053 netdev_dbg(dev->net, "PHY Not Found!! Registering Fixed PHY\n");
2054 phydev = fixed_phy_register(PHY_POLL, &fphy_status, NULL);
2055 if (IS_ERR(phydev)) {
2056 netdev_err(dev->net, "No PHY/fixed_PHY found\n");
2057 return NULL;
2058 }
2059 netdev_dbg(dev->net, "Registered FIXED PHY\n");
2060 dev->interface = PHY_INTERFACE_MODE_RGMII;
2061 ret = lan78xx_write_reg(dev, MAC_RGMII_ID,
2062 MAC_RGMII_ID_TXC_DELAY_EN_);
2063 ret = lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
2064 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2065 buf |= HW_CFG_CLK125_EN_;
2066 buf |= HW_CFG_REFCLK25_EN_;
2067 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2068 } else {
2069 if (!phydev->drv) {
2070 netdev_err(dev->net, "no PHY driver found\n");
2071 return NULL;
2072 }
2073 dev->interface = PHY_INTERFACE_MODE_RGMII;
2074 /* external PHY fixup for KSZ9031RNX */
2075 ret = phy_register_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0,
2076 ksz9031rnx_fixup);
2077 if (ret < 0) {
2078 netdev_err(dev->net, "Failed to register fixup for PHY_KSZ9031RNX\n");
2079 return NULL;
2080 }
2081 /* external PHY fixup for LAN8835 */
2082 ret = phy_register_fixup_for_uid(PHY_LAN8835, 0xfffffff0,
2083 lan8835_fixup);
2084 if (ret < 0) {
2085 netdev_err(dev->net, "Failed to register fixup for PHY_LAN8835\n");
2086 return NULL;
2087 }
2088 /* add more external PHY fixup here if needed */
2089
2090 phydev->is_internal = false;
2091 }
2092 return phydev;
2093 }
2094
lan78xx_phy_init(struct lan78xx_net * dev)2095 static int lan78xx_phy_init(struct lan78xx_net *dev)
2096 {
2097 __ETHTOOL_DECLARE_LINK_MODE_MASK(fc) = { 0, };
2098 int ret;
2099 u32 mii_adv;
2100 struct phy_device *phydev;
2101
2102 switch (dev->chipid) {
2103 case ID_REV_CHIP_ID_7801_:
2104 phydev = lan7801_phy_init(dev);
2105 if (!phydev) {
2106 netdev_err(dev->net, "lan7801: PHY Init Failed");
2107 return -EIO;
2108 }
2109 break;
2110
2111 case ID_REV_CHIP_ID_7800_:
2112 case ID_REV_CHIP_ID_7850_:
2113 phydev = phy_find_first(dev->mdiobus);
2114 if (!phydev) {
2115 netdev_err(dev->net, "no PHY found\n");
2116 return -EIO;
2117 }
2118 phydev->is_internal = true;
2119 dev->interface = PHY_INTERFACE_MODE_GMII;
2120 break;
2121
2122 default:
2123 netdev_err(dev->net, "Unknown CHIP ID found\n");
2124 return -EIO;
2125 }
2126
2127 /* if phyirq is not set, use polling mode in phylib */
2128 if (dev->domain_data.phyirq > 0)
2129 phydev->irq = dev->domain_data.phyirq;
2130 else
2131 phydev->irq = 0;
2132 netdev_dbg(dev->net, "phydev->irq = %d\n", phydev->irq);
2133
2134 /* set to AUTOMDIX */
2135 phydev->mdix = ETH_TP_MDI_AUTO;
2136
2137 ret = phy_connect_direct(dev->net, phydev,
2138 lan78xx_link_status_change,
2139 dev->interface);
2140 if (ret) {
2141 netdev_err(dev->net, "can't attach PHY to %s\n",
2142 dev->mdiobus->id);
2143 if (dev->chipid == ID_REV_CHIP_ID_7801_) {
2144 if (phy_is_pseudo_fixed_link(phydev)) {
2145 fixed_phy_unregister(phydev);
2146 } else {
2147 phy_unregister_fixup_for_uid(PHY_KSZ9031RNX,
2148 0xfffffff0);
2149 phy_unregister_fixup_for_uid(PHY_LAN8835,
2150 0xfffffff0);
2151 }
2152 }
2153 return -EIO;
2154 }
2155
2156 /* MAC doesn't support 1000T Half */
2157 phy_remove_link_mode(phydev, ETHTOOL_LINK_MODE_1000baseT_Half_BIT);
2158
2159 /* support both flow controls */
2160 dev->fc_request_control = (FLOW_CTRL_RX | FLOW_CTRL_TX);
2161 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2162 phydev->advertising);
2163 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2164 phydev->advertising);
2165 mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
2166 mii_adv_to_linkmode_adv_t(fc, mii_adv);
2167 linkmode_or(phydev->advertising, fc, phydev->advertising);
2168
2169 if (phydev->mdio.dev.of_node) {
2170 u32 reg;
2171 int len;
2172
2173 len = of_property_count_elems_of_size(phydev->mdio.dev.of_node,
2174 "microchip,led-modes",
2175 sizeof(u32));
2176 if (len >= 0) {
2177 /* Ensure the appropriate LEDs are enabled */
2178 lan78xx_read_reg(dev, HW_CFG, ®);
2179 reg &= ~(HW_CFG_LED0_EN_ |
2180 HW_CFG_LED1_EN_ |
2181 HW_CFG_LED2_EN_ |
2182 HW_CFG_LED3_EN_);
2183 reg |= (len > 0) * HW_CFG_LED0_EN_ |
2184 (len > 1) * HW_CFG_LED1_EN_ |
2185 (len > 2) * HW_CFG_LED2_EN_ |
2186 (len > 3) * HW_CFG_LED3_EN_;
2187 lan78xx_write_reg(dev, HW_CFG, reg);
2188 }
2189 }
2190
2191 genphy_config_aneg(phydev);
2192
2193 dev->fc_autoneg = phydev->autoneg;
2194
2195 return 0;
2196 }
2197
lan78xx_set_rx_max_frame_length(struct lan78xx_net * dev,int size)2198 static int lan78xx_set_rx_max_frame_length(struct lan78xx_net *dev, int size)
2199 {
2200 int ret = 0;
2201 u32 buf;
2202 bool rxenabled;
2203
2204 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
2205
2206 rxenabled = ((buf & MAC_RX_RXEN_) != 0);
2207
2208 if (rxenabled) {
2209 buf &= ~MAC_RX_RXEN_;
2210 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2211 }
2212
2213 /* add 4 to size for FCS */
2214 buf &= ~MAC_RX_MAX_SIZE_MASK_;
2215 buf |= (((size + 4) << MAC_RX_MAX_SIZE_SHIFT_) & MAC_RX_MAX_SIZE_MASK_);
2216
2217 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2218
2219 if (rxenabled) {
2220 buf |= MAC_RX_RXEN_;
2221 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2222 }
2223
2224 return 0;
2225 }
2226
unlink_urbs(struct lan78xx_net * dev,struct sk_buff_head * q)2227 static int unlink_urbs(struct lan78xx_net *dev, struct sk_buff_head *q)
2228 {
2229 struct sk_buff *skb;
2230 unsigned long flags;
2231 int count = 0;
2232
2233 spin_lock_irqsave(&q->lock, flags);
2234 while (!skb_queue_empty(q)) {
2235 struct skb_data *entry;
2236 struct urb *urb;
2237 int ret;
2238
2239 skb_queue_walk(q, skb) {
2240 entry = (struct skb_data *)skb->cb;
2241 if (entry->state != unlink_start)
2242 goto found;
2243 }
2244 break;
2245 found:
2246 entry->state = unlink_start;
2247 urb = entry->urb;
2248
2249 /* Get reference count of the URB to avoid it to be
2250 * freed during usb_unlink_urb, which may trigger
2251 * use-after-free problem inside usb_unlink_urb since
2252 * usb_unlink_urb is always racing with .complete
2253 * handler(include defer_bh).
2254 */
2255 usb_get_urb(urb);
2256 spin_unlock_irqrestore(&q->lock, flags);
2257 /* during some PM-driven resume scenarios,
2258 * these (async) unlinks complete immediately
2259 */
2260 ret = usb_unlink_urb(urb);
2261 if (ret != -EINPROGRESS && ret != 0)
2262 netdev_dbg(dev->net, "unlink urb err, %d\n", ret);
2263 else
2264 count++;
2265 usb_put_urb(urb);
2266 spin_lock_irqsave(&q->lock, flags);
2267 }
2268 spin_unlock_irqrestore(&q->lock, flags);
2269 return count;
2270 }
2271
lan78xx_change_mtu(struct net_device * netdev,int new_mtu)2272 static int lan78xx_change_mtu(struct net_device *netdev, int new_mtu)
2273 {
2274 struct lan78xx_net *dev = netdev_priv(netdev);
2275 int ll_mtu = new_mtu + netdev->hard_header_len;
2276 int old_hard_mtu = dev->hard_mtu;
2277 int old_rx_urb_size = dev->rx_urb_size;
2278 int ret;
2279
2280 /* no second zero-length packet read wanted after mtu-sized packets */
2281 if ((ll_mtu % dev->maxpacket) == 0)
2282 return -EDOM;
2283
2284 ret = lan78xx_set_rx_max_frame_length(dev, new_mtu + VLAN_ETH_HLEN);
2285
2286 netdev->mtu = new_mtu;
2287
2288 dev->hard_mtu = netdev->mtu + netdev->hard_header_len;
2289 if (dev->rx_urb_size == old_hard_mtu) {
2290 dev->rx_urb_size = dev->hard_mtu;
2291 if (dev->rx_urb_size > old_rx_urb_size) {
2292 if (netif_running(dev->net)) {
2293 unlink_urbs(dev, &dev->rxq);
2294 tasklet_schedule(&dev->bh);
2295 }
2296 }
2297 }
2298
2299 return 0;
2300 }
2301
lan78xx_set_mac_addr(struct net_device * netdev,void * p)2302 static int lan78xx_set_mac_addr(struct net_device *netdev, void *p)
2303 {
2304 struct lan78xx_net *dev = netdev_priv(netdev);
2305 struct sockaddr *addr = p;
2306 u32 addr_lo, addr_hi;
2307 int ret;
2308
2309 if (netif_running(netdev))
2310 return -EBUSY;
2311
2312 if (!is_valid_ether_addr(addr->sa_data))
2313 return -EADDRNOTAVAIL;
2314
2315 ether_addr_copy(netdev->dev_addr, addr->sa_data);
2316
2317 addr_lo = netdev->dev_addr[0] |
2318 netdev->dev_addr[1] << 8 |
2319 netdev->dev_addr[2] << 16 |
2320 netdev->dev_addr[3] << 24;
2321 addr_hi = netdev->dev_addr[4] |
2322 netdev->dev_addr[5] << 8;
2323
2324 ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
2325 ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
2326
2327 /* Added to support MAC address changes */
2328 ret = lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
2329 ret = lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
2330
2331 return 0;
2332 }
2333
2334 /* Enable or disable Rx checksum offload engine */
lan78xx_set_features(struct net_device * netdev,netdev_features_t features)2335 static int lan78xx_set_features(struct net_device *netdev,
2336 netdev_features_t features)
2337 {
2338 struct lan78xx_net *dev = netdev_priv(netdev);
2339 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2340 unsigned long flags;
2341 int ret;
2342
2343 spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
2344
2345 if (features & NETIF_F_RXCSUM) {
2346 pdata->rfe_ctl |= RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_;
2347 pdata->rfe_ctl |= RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_;
2348 } else {
2349 pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_);
2350 pdata->rfe_ctl &= ~(RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_);
2351 }
2352
2353 if (features & NETIF_F_HW_VLAN_CTAG_RX)
2354 pdata->rfe_ctl |= RFE_CTL_VLAN_STRIP_;
2355 else
2356 pdata->rfe_ctl &= ~RFE_CTL_VLAN_STRIP_;
2357
2358 if (features & NETIF_F_HW_VLAN_CTAG_FILTER)
2359 pdata->rfe_ctl |= RFE_CTL_VLAN_FILTER_;
2360 else
2361 pdata->rfe_ctl &= ~RFE_CTL_VLAN_FILTER_;
2362
2363 spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
2364
2365 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2366
2367 return 0;
2368 }
2369
lan78xx_deferred_vlan_write(struct work_struct * param)2370 static void lan78xx_deferred_vlan_write(struct work_struct *param)
2371 {
2372 struct lan78xx_priv *pdata =
2373 container_of(param, struct lan78xx_priv, set_vlan);
2374 struct lan78xx_net *dev = pdata->dev;
2375
2376 lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, 0,
2377 DP_SEL_VHF_VLAN_LEN, pdata->vlan_table);
2378 }
2379
lan78xx_vlan_rx_add_vid(struct net_device * netdev,__be16 proto,u16 vid)2380 static int lan78xx_vlan_rx_add_vid(struct net_device *netdev,
2381 __be16 proto, u16 vid)
2382 {
2383 struct lan78xx_net *dev = netdev_priv(netdev);
2384 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2385 u16 vid_bit_index;
2386 u16 vid_dword_index;
2387
2388 vid_dword_index = (vid >> 5) & 0x7F;
2389 vid_bit_index = vid & 0x1F;
2390
2391 pdata->vlan_table[vid_dword_index] |= (1 << vid_bit_index);
2392
2393 /* defer register writes to a sleepable context */
2394 schedule_work(&pdata->set_vlan);
2395
2396 return 0;
2397 }
2398
lan78xx_vlan_rx_kill_vid(struct net_device * netdev,__be16 proto,u16 vid)2399 static int lan78xx_vlan_rx_kill_vid(struct net_device *netdev,
2400 __be16 proto, u16 vid)
2401 {
2402 struct lan78xx_net *dev = netdev_priv(netdev);
2403 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2404 u16 vid_bit_index;
2405 u16 vid_dword_index;
2406
2407 vid_dword_index = (vid >> 5) & 0x7F;
2408 vid_bit_index = vid & 0x1F;
2409
2410 pdata->vlan_table[vid_dword_index] &= ~(1 << vid_bit_index);
2411
2412 /* defer register writes to a sleepable context */
2413 schedule_work(&pdata->set_vlan);
2414
2415 return 0;
2416 }
2417
lan78xx_init_ltm(struct lan78xx_net * dev)2418 static void lan78xx_init_ltm(struct lan78xx_net *dev)
2419 {
2420 int ret;
2421 u32 buf;
2422 u32 regs[6] = { 0 };
2423
2424 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
2425 if (buf & USB_CFG1_LTM_ENABLE_) {
2426 u8 temp[2];
2427 /* Get values from EEPROM first */
2428 if (lan78xx_read_eeprom(dev, 0x3F, 2, temp) == 0) {
2429 if (temp[0] == 24) {
2430 ret = lan78xx_read_raw_eeprom(dev,
2431 temp[1] * 2,
2432 24,
2433 (u8 *)regs);
2434 if (ret < 0)
2435 return;
2436 }
2437 } else if (lan78xx_read_otp(dev, 0x3F, 2, temp) == 0) {
2438 if (temp[0] == 24) {
2439 ret = lan78xx_read_raw_otp(dev,
2440 temp[1] * 2,
2441 24,
2442 (u8 *)regs);
2443 if (ret < 0)
2444 return;
2445 }
2446 }
2447 }
2448
2449 lan78xx_write_reg(dev, LTM_BELT_IDLE0, regs[0]);
2450 lan78xx_write_reg(dev, LTM_BELT_IDLE1, regs[1]);
2451 lan78xx_write_reg(dev, LTM_BELT_ACT0, regs[2]);
2452 lan78xx_write_reg(dev, LTM_BELT_ACT1, regs[3]);
2453 lan78xx_write_reg(dev, LTM_INACTIVE0, regs[4]);
2454 lan78xx_write_reg(dev, LTM_INACTIVE1, regs[5]);
2455 }
2456
lan78xx_reset(struct lan78xx_net * dev)2457 static int lan78xx_reset(struct lan78xx_net *dev)
2458 {
2459 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2460 u32 buf;
2461 int ret = 0;
2462 unsigned long timeout;
2463 u8 sig;
2464
2465 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2466 buf |= HW_CFG_LRST_;
2467 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2468
2469 timeout = jiffies + HZ;
2470 do {
2471 mdelay(1);
2472 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2473 if (time_after(jiffies, timeout)) {
2474 netdev_warn(dev->net,
2475 "timeout on completion of LiteReset");
2476 return -EIO;
2477 }
2478 } while (buf & HW_CFG_LRST_);
2479
2480 lan78xx_init_mac_address(dev);
2481
2482 /* save DEVID for later usage */
2483 ret = lan78xx_read_reg(dev, ID_REV, &buf);
2484 dev->chipid = (buf & ID_REV_CHIP_ID_MASK_) >> 16;
2485 dev->chiprev = buf & ID_REV_CHIP_REV_MASK_;
2486
2487 /* Respond to the IN token with a NAK */
2488 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2489 buf |= USB_CFG_BIR_;
2490 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2491
2492 /* Init LTM */
2493 lan78xx_init_ltm(dev);
2494
2495 if (dev->udev->speed == USB_SPEED_SUPER) {
2496 buf = DEFAULT_BURST_CAP_SIZE / SS_USB_PKT_SIZE;
2497 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2498 dev->rx_qlen = 4;
2499 dev->tx_qlen = 4;
2500 } else if (dev->udev->speed == USB_SPEED_HIGH) {
2501 buf = DEFAULT_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
2502 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2503 dev->rx_qlen = RX_MAX_QUEUE_MEMORY / dev->rx_urb_size;
2504 dev->tx_qlen = RX_MAX_QUEUE_MEMORY / dev->hard_mtu;
2505 } else {
2506 buf = DEFAULT_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
2507 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2508 dev->rx_qlen = 4;
2509 dev->tx_qlen = 4;
2510 }
2511
2512 ret = lan78xx_write_reg(dev, BURST_CAP, buf);
2513 ret = lan78xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
2514
2515 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2516 buf |= HW_CFG_MEF_;
2517 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2518
2519 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2520 buf |= USB_CFG_BCE_;
2521 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2522
2523 /* set FIFO sizes */
2524 buf = (MAX_RX_FIFO_SIZE - 512) / 512;
2525 ret = lan78xx_write_reg(dev, FCT_RX_FIFO_END, buf);
2526
2527 buf = (MAX_TX_FIFO_SIZE - 512) / 512;
2528 ret = lan78xx_write_reg(dev, FCT_TX_FIFO_END, buf);
2529
2530 ret = lan78xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
2531 ret = lan78xx_write_reg(dev, FLOW, 0);
2532 ret = lan78xx_write_reg(dev, FCT_FLOW, 0);
2533
2534 /* Don't need rfe_ctl_lock during initialisation */
2535 ret = lan78xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
2536 pdata->rfe_ctl |= RFE_CTL_BCAST_EN_ | RFE_CTL_DA_PERFECT_;
2537 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2538
2539 /* Enable or disable checksum offload engines */
2540 lan78xx_set_features(dev->net, dev->net->features);
2541
2542 lan78xx_set_multicast(dev->net);
2543
2544 /* reset PHY */
2545 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
2546 buf |= PMT_CTL_PHY_RST_;
2547 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
2548
2549 timeout = jiffies + HZ;
2550 do {
2551 mdelay(1);
2552 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
2553 if (time_after(jiffies, timeout)) {
2554 netdev_warn(dev->net, "timeout waiting for PHY Reset");
2555 return -EIO;
2556 }
2557 } while ((buf & PMT_CTL_PHY_RST_) || !(buf & PMT_CTL_READY_));
2558
2559 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
2560 /* LAN7801 only has RGMII mode */
2561 if (dev->chipid == ID_REV_CHIP_ID_7801_)
2562 buf &= ~MAC_CR_GMII_EN_;
2563
2564 if (dev->chipid == ID_REV_CHIP_ID_7800_) {
2565 ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
2566 if (!ret && sig != EEPROM_INDICATOR) {
2567 /* Implies there is no external eeprom. Set mac speed */
2568 netdev_info(dev->net, "No External EEPROM. Setting MAC Speed\n");
2569 buf |= MAC_CR_AUTO_DUPLEX_ | MAC_CR_AUTO_SPEED_;
2570 }
2571 }
2572 ret = lan78xx_write_reg(dev, MAC_CR, buf);
2573
2574 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
2575 buf |= MAC_TX_TXEN_;
2576 ret = lan78xx_write_reg(dev, MAC_TX, buf);
2577
2578 ret = lan78xx_read_reg(dev, FCT_TX_CTL, &buf);
2579 buf |= FCT_TX_CTL_EN_;
2580 ret = lan78xx_write_reg(dev, FCT_TX_CTL, buf);
2581
2582 ret = lan78xx_set_rx_max_frame_length(dev,
2583 dev->net->mtu + VLAN_ETH_HLEN);
2584
2585 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
2586 buf |= MAC_RX_RXEN_;
2587 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2588
2589 ret = lan78xx_read_reg(dev, FCT_RX_CTL, &buf);
2590 buf |= FCT_RX_CTL_EN_;
2591 ret = lan78xx_write_reg(dev, FCT_RX_CTL, buf);
2592
2593 return 0;
2594 }
2595
lan78xx_init_stats(struct lan78xx_net * dev)2596 static void lan78xx_init_stats(struct lan78xx_net *dev)
2597 {
2598 u32 *p;
2599 int i;
2600
2601 /* initialize for stats update
2602 * some counters are 20bits and some are 32bits
2603 */
2604 p = (u32 *)&dev->stats.rollover_max;
2605 for (i = 0; i < (sizeof(dev->stats.rollover_max) / (sizeof(u32))); i++)
2606 p[i] = 0xFFFFF;
2607
2608 dev->stats.rollover_max.rx_unicast_byte_count = 0xFFFFFFFF;
2609 dev->stats.rollover_max.rx_broadcast_byte_count = 0xFFFFFFFF;
2610 dev->stats.rollover_max.rx_multicast_byte_count = 0xFFFFFFFF;
2611 dev->stats.rollover_max.eee_rx_lpi_transitions = 0xFFFFFFFF;
2612 dev->stats.rollover_max.eee_rx_lpi_time = 0xFFFFFFFF;
2613 dev->stats.rollover_max.tx_unicast_byte_count = 0xFFFFFFFF;
2614 dev->stats.rollover_max.tx_broadcast_byte_count = 0xFFFFFFFF;
2615 dev->stats.rollover_max.tx_multicast_byte_count = 0xFFFFFFFF;
2616 dev->stats.rollover_max.eee_tx_lpi_transitions = 0xFFFFFFFF;
2617 dev->stats.rollover_max.eee_tx_lpi_time = 0xFFFFFFFF;
2618
2619 set_bit(EVENT_STAT_UPDATE, &dev->flags);
2620 }
2621
lan78xx_open(struct net_device * net)2622 static int lan78xx_open(struct net_device *net)
2623 {
2624 struct lan78xx_net *dev = netdev_priv(net);
2625 int ret;
2626
2627 ret = usb_autopm_get_interface(dev->intf);
2628 if (ret < 0)
2629 goto out;
2630
2631 phy_start(net->phydev);
2632
2633 netif_dbg(dev, ifup, dev->net, "phy initialised successfully");
2634
2635 /* for Link Check */
2636 if (dev->urb_intr) {
2637 ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
2638 if (ret < 0) {
2639 netif_err(dev, ifup, dev->net,
2640 "intr submit %d\n", ret);
2641 goto done;
2642 }
2643 }
2644
2645 lan78xx_init_stats(dev);
2646
2647 set_bit(EVENT_DEV_OPEN, &dev->flags);
2648
2649 netif_start_queue(net);
2650
2651 dev->link_on = false;
2652
2653 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
2654 done:
2655 usb_autopm_put_interface(dev->intf);
2656
2657 out:
2658 return ret;
2659 }
2660
lan78xx_terminate_urbs(struct lan78xx_net * dev)2661 static void lan78xx_terminate_urbs(struct lan78xx_net *dev)
2662 {
2663 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);
2664 DECLARE_WAITQUEUE(wait, current);
2665 int temp;
2666
2667 /* ensure there are no more active urbs */
2668 add_wait_queue(&unlink_wakeup, &wait);
2669 set_current_state(TASK_UNINTERRUPTIBLE);
2670 dev->wait = &unlink_wakeup;
2671 temp = unlink_urbs(dev, &dev->txq) + unlink_urbs(dev, &dev->rxq);
2672
2673 /* maybe wait for deletions to finish. */
2674 while (!skb_queue_empty(&dev->rxq) &&
2675 !skb_queue_empty(&dev->txq) &&
2676 !skb_queue_empty(&dev->done)) {
2677 schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
2678 set_current_state(TASK_UNINTERRUPTIBLE);
2679 netif_dbg(dev, ifdown, dev->net,
2680 "waited for %d urb completions\n", temp);
2681 }
2682 set_current_state(TASK_RUNNING);
2683 dev->wait = NULL;
2684 remove_wait_queue(&unlink_wakeup, &wait);
2685 }
2686
lan78xx_stop(struct net_device * net)2687 static int lan78xx_stop(struct net_device *net)
2688 {
2689 struct lan78xx_net *dev = netdev_priv(net);
2690
2691 if (timer_pending(&dev->stat_monitor))
2692 del_timer_sync(&dev->stat_monitor);
2693
2694 if (net->phydev)
2695 phy_stop(net->phydev);
2696
2697 clear_bit(EVENT_DEV_OPEN, &dev->flags);
2698 netif_stop_queue(net);
2699
2700 netif_info(dev, ifdown, dev->net,
2701 "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
2702 net->stats.rx_packets, net->stats.tx_packets,
2703 net->stats.rx_errors, net->stats.tx_errors);
2704
2705 lan78xx_terminate_urbs(dev);
2706
2707 usb_kill_urb(dev->urb_intr);
2708
2709 skb_queue_purge(&dev->rxq_pause);
2710
2711 /* deferred work (task, timer, softirq) must also stop.
2712 * can't flush_scheduled_work() until we drop rtnl (later),
2713 * else workers could deadlock; so make workers a NOP.
2714 */
2715 dev->flags = 0;
2716 cancel_delayed_work_sync(&dev->wq);
2717 tasklet_kill(&dev->bh);
2718
2719 usb_autopm_put_interface(dev->intf);
2720
2721 return 0;
2722 }
2723
lan78xx_tx_prep(struct lan78xx_net * dev,struct sk_buff * skb,gfp_t flags)2724 static struct sk_buff *lan78xx_tx_prep(struct lan78xx_net *dev,
2725 struct sk_buff *skb, gfp_t flags)
2726 {
2727 u32 tx_cmd_a, tx_cmd_b;
2728 void *ptr;
2729
2730 if (skb_cow_head(skb, TX_OVERHEAD)) {
2731 dev_kfree_skb_any(skb);
2732 return NULL;
2733 }
2734
2735 if (skb_linearize(skb)) {
2736 dev_kfree_skb_any(skb);
2737 return NULL;
2738 }
2739
2740 tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN_MASK_) | TX_CMD_A_FCS_;
2741
2742 if (skb->ip_summed == CHECKSUM_PARTIAL)
2743 tx_cmd_a |= TX_CMD_A_IPE_ | TX_CMD_A_TPE_;
2744
2745 tx_cmd_b = 0;
2746 if (skb_is_gso(skb)) {
2747 u16 mss = max(skb_shinfo(skb)->gso_size, TX_CMD_B_MSS_MIN_);
2748
2749 tx_cmd_b = (mss << TX_CMD_B_MSS_SHIFT_) & TX_CMD_B_MSS_MASK_;
2750
2751 tx_cmd_a |= TX_CMD_A_LSO_;
2752 }
2753
2754 if (skb_vlan_tag_present(skb)) {
2755 tx_cmd_a |= TX_CMD_A_IVTG_;
2756 tx_cmd_b |= skb_vlan_tag_get(skb) & TX_CMD_B_VTAG_MASK_;
2757 }
2758
2759 ptr = skb_push(skb, 8);
2760 put_unaligned_le32(tx_cmd_a, ptr);
2761 put_unaligned_le32(tx_cmd_b, ptr + 4);
2762
2763 return skb;
2764 }
2765
defer_bh(struct lan78xx_net * dev,struct sk_buff * skb,struct sk_buff_head * list,enum skb_state state)2766 static enum skb_state defer_bh(struct lan78xx_net *dev, struct sk_buff *skb,
2767 struct sk_buff_head *list, enum skb_state state)
2768 {
2769 unsigned long flags;
2770 enum skb_state old_state;
2771 struct skb_data *entry = (struct skb_data *)skb->cb;
2772
2773 spin_lock_irqsave(&list->lock, flags);
2774 old_state = entry->state;
2775 entry->state = state;
2776
2777 __skb_unlink(skb, list);
2778 spin_unlock(&list->lock);
2779 spin_lock(&dev->done.lock);
2780
2781 __skb_queue_tail(&dev->done, skb);
2782 if (skb_queue_len(&dev->done) == 1)
2783 tasklet_schedule(&dev->bh);
2784 spin_unlock_irqrestore(&dev->done.lock, flags);
2785
2786 return old_state;
2787 }
2788
tx_complete(struct urb * urb)2789 static void tx_complete(struct urb *urb)
2790 {
2791 struct sk_buff *skb = (struct sk_buff *)urb->context;
2792 struct skb_data *entry = (struct skb_data *)skb->cb;
2793 struct lan78xx_net *dev = entry->dev;
2794
2795 if (urb->status == 0) {
2796 dev->net->stats.tx_packets += entry->num_of_packet;
2797 dev->net->stats.tx_bytes += entry->length;
2798 } else {
2799 dev->net->stats.tx_errors++;
2800
2801 switch (urb->status) {
2802 case -EPIPE:
2803 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
2804 break;
2805
2806 /* software-driven interface shutdown */
2807 case -ECONNRESET:
2808 case -ESHUTDOWN:
2809 break;
2810
2811 case -EPROTO:
2812 case -ETIME:
2813 case -EILSEQ:
2814 netif_stop_queue(dev->net);
2815 break;
2816 default:
2817 netif_dbg(dev, tx_err, dev->net,
2818 "tx err %d\n", entry->urb->status);
2819 break;
2820 }
2821 }
2822
2823 usb_autopm_put_interface_async(dev->intf);
2824
2825 defer_bh(dev, skb, &dev->txq, tx_done);
2826 }
2827
lan78xx_queue_skb(struct sk_buff_head * list,struct sk_buff * newsk,enum skb_state state)2828 static void lan78xx_queue_skb(struct sk_buff_head *list,
2829 struct sk_buff *newsk, enum skb_state state)
2830 {
2831 struct skb_data *entry = (struct skb_data *)newsk->cb;
2832
2833 __skb_queue_tail(list, newsk);
2834 entry->state = state;
2835 }
2836
2837 static netdev_tx_t
lan78xx_start_xmit(struct sk_buff * skb,struct net_device * net)2838 lan78xx_start_xmit(struct sk_buff *skb, struct net_device *net)
2839 {
2840 struct lan78xx_net *dev = netdev_priv(net);
2841 struct sk_buff *skb2 = NULL;
2842
2843 if (skb) {
2844 skb_tx_timestamp(skb);
2845 skb2 = lan78xx_tx_prep(dev, skb, GFP_ATOMIC);
2846 }
2847
2848 if (skb2) {
2849 skb_queue_tail(&dev->txq_pend, skb2);
2850
2851 /* throttle TX patch at slower than SUPER SPEED USB */
2852 if ((dev->udev->speed < USB_SPEED_SUPER) &&
2853 (skb_queue_len(&dev->txq_pend) > 10))
2854 netif_stop_queue(net);
2855 } else {
2856 netif_dbg(dev, tx_err, dev->net,
2857 "lan78xx_tx_prep return NULL\n");
2858 dev->net->stats.tx_errors++;
2859 dev->net->stats.tx_dropped++;
2860 }
2861
2862 tasklet_schedule(&dev->bh);
2863
2864 return NETDEV_TX_OK;
2865 }
2866
lan78xx_bind(struct lan78xx_net * dev,struct usb_interface * intf)2867 static int lan78xx_bind(struct lan78xx_net *dev, struct usb_interface *intf)
2868 {
2869 struct lan78xx_priv *pdata = NULL;
2870 int ret;
2871 int i;
2872
2873 dev->data[0] = (unsigned long)kzalloc(sizeof(*pdata), GFP_KERNEL);
2874
2875 pdata = (struct lan78xx_priv *)(dev->data[0]);
2876 if (!pdata) {
2877 netdev_warn(dev->net, "Unable to allocate lan78xx_priv");
2878 return -ENOMEM;
2879 }
2880
2881 pdata->dev = dev;
2882
2883 spin_lock_init(&pdata->rfe_ctl_lock);
2884 mutex_init(&pdata->dataport_mutex);
2885
2886 INIT_WORK(&pdata->set_multicast, lan78xx_deferred_multicast_write);
2887
2888 for (i = 0; i < DP_SEL_VHF_VLAN_LEN; i++)
2889 pdata->vlan_table[i] = 0;
2890
2891 INIT_WORK(&pdata->set_vlan, lan78xx_deferred_vlan_write);
2892
2893 dev->net->features = 0;
2894
2895 if (DEFAULT_TX_CSUM_ENABLE)
2896 dev->net->features |= NETIF_F_HW_CSUM;
2897
2898 if (DEFAULT_RX_CSUM_ENABLE)
2899 dev->net->features |= NETIF_F_RXCSUM;
2900
2901 if (DEFAULT_TSO_CSUM_ENABLE)
2902 dev->net->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_SG;
2903
2904 if (DEFAULT_VLAN_RX_OFFLOAD)
2905 dev->net->features |= NETIF_F_HW_VLAN_CTAG_RX;
2906
2907 if (DEFAULT_VLAN_FILTER_ENABLE)
2908 dev->net->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
2909
2910 dev->net->hw_features = dev->net->features;
2911
2912 ret = lan78xx_setup_irq_domain(dev);
2913 if (ret < 0) {
2914 netdev_warn(dev->net,
2915 "lan78xx_setup_irq_domain() failed : %d", ret);
2916 goto out1;
2917 }
2918
2919 dev->net->hard_header_len += TX_OVERHEAD;
2920 dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
2921
2922 /* Init all registers */
2923 ret = lan78xx_reset(dev);
2924 if (ret) {
2925 netdev_warn(dev->net, "Registers INIT FAILED....");
2926 goto out2;
2927 }
2928
2929 ret = lan78xx_mdio_init(dev);
2930 if (ret) {
2931 netdev_warn(dev->net, "MDIO INIT FAILED.....");
2932 goto out2;
2933 }
2934
2935 dev->net->flags |= IFF_MULTICAST;
2936
2937 pdata->wol = WAKE_MAGIC;
2938
2939 return ret;
2940
2941 out2:
2942 lan78xx_remove_irq_domain(dev);
2943
2944 out1:
2945 netdev_warn(dev->net, "Bind routine FAILED");
2946 cancel_work_sync(&pdata->set_multicast);
2947 cancel_work_sync(&pdata->set_vlan);
2948 kfree(pdata);
2949 return ret;
2950 }
2951
lan78xx_unbind(struct lan78xx_net * dev,struct usb_interface * intf)2952 static void lan78xx_unbind(struct lan78xx_net *dev, struct usb_interface *intf)
2953 {
2954 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2955
2956 lan78xx_remove_irq_domain(dev);
2957
2958 lan78xx_remove_mdio(dev);
2959
2960 if (pdata) {
2961 cancel_work_sync(&pdata->set_multicast);
2962 cancel_work_sync(&pdata->set_vlan);
2963 netif_dbg(dev, ifdown, dev->net, "free pdata");
2964 kfree(pdata);
2965 pdata = NULL;
2966 dev->data[0] = 0;
2967 }
2968 }
2969
lan78xx_rx_csum_offload(struct lan78xx_net * dev,struct sk_buff * skb,u32 rx_cmd_a,u32 rx_cmd_b)2970 static void lan78xx_rx_csum_offload(struct lan78xx_net *dev,
2971 struct sk_buff *skb,
2972 u32 rx_cmd_a, u32 rx_cmd_b)
2973 {
2974 /* HW Checksum offload appears to be flawed if used when not stripping
2975 * VLAN headers. Drop back to S/W checksums under these conditions.
2976 */
2977 if (!(dev->net->features & NETIF_F_RXCSUM) ||
2978 unlikely(rx_cmd_a & RX_CMD_A_ICSM_) ||
2979 ((rx_cmd_a & RX_CMD_A_FVTG_) &&
2980 !(dev->net->features & NETIF_F_HW_VLAN_CTAG_RX))) {
2981 skb->ip_summed = CHECKSUM_NONE;
2982 } else {
2983 skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT_));
2984 skb->ip_summed = CHECKSUM_COMPLETE;
2985 }
2986 }
2987
lan78xx_rx_vlan_offload(struct lan78xx_net * dev,struct sk_buff * skb,u32 rx_cmd_a,u32 rx_cmd_b)2988 static void lan78xx_rx_vlan_offload(struct lan78xx_net *dev,
2989 struct sk_buff *skb,
2990 u32 rx_cmd_a, u32 rx_cmd_b)
2991 {
2992 if ((dev->net->features & NETIF_F_HW_VLAN_CTAG_RX) &&
2993 (rx_cmd_a & RX_CMD_A_FVTG_))
2994 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
2995 (rx_cmd_b & 0xffff));
2996 }
2997
lan78xx_skb_return(struct lan78xx_net * dev,struct sk_buff * skb)2998 static void lan78xx_skb_return(struct lan78xx_net *dev, struct sk_buff *skb)
2999 {
3000 int status;
3001
3002 if (test_bit(EVENT_RX_PAUSED, &dev->flags)) {
3003 skb_queue_tail(&dev->rxq_pause, skb);
3004 return;
3005 }
3006
3007 dev->net->stats.rx_packets++;
3008 dev->net->stats.rx_bytes += skb->len;
3009
3010 skb->protocol = eth_type_trans(skb, dev->net);
3011
3012 netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
3013 skb->len + sizeof(struct ethhdr), skb->protocol);
3014 memset(skb->cb, 0, sizeof(struct skb_data));
3015
3016 if (skb_defer_rx_timestamp(skb))
3017 return;
3018
3019 status = netif_rx(skb);
3020 if (status != NET_RX_SUCCESS)
3021 netif_dbg(dev, rx_err, dev->net,
3022 "netif_rx status %d\n", status);
3023 }
3024
lan78xx_rx(struct lan78xx_net * dev,struct sk_buff * skb)3025 static int lan78xx_rx(struct lan78xx_net *dev, struct sk_buff *skb)
3026 {
3027 if (skb->len < dev->net->hard_header_len)
3028 return 0;
3029
3030 while (skb->len > 0) {
3031 u32 rx_cmd_a, rx_cmd_b, align_count, size;
3032 u16 rx_cmd_c;
3033 struct sk_buff *skb2;
3034 unsigned char *packet;
3035
3036 rx_cmd_a = get_unaligned_le32(skb->data);
3037 skb_pull(skb, sizeof(rx_cmd_a));
3038
3039 rx_cmd_b = get_unaligned_le32(skb->data);
3040 skb_pull(skb, sizeof(rx_cmd_b));
3041
3042 rx_cmd_c = get_unaligned_le16(skb->data);
3043 skb_pull(skb, sizeof(rx_cmd_c));
3044
3045 packet = skb->data;
3046
3047 /* get the packet length */
3048 size = (rx_cmd_a & RX_CMD_A_LEN_MASK_);
3049 align_count = (4 - ((size + RXW_PADDING) % 4)) % 4;
3050
3051 if (unlikely(rx_cmd_a & RX_CMD_A_RED_)) {
3052 netif_dbg(dev, rx_err, dev->net,
3053 "Error rx_cmd_a=0x%08x", rx_cmd_a);
3054 } else {
3055 /* last frame in this batch */
3056 if (skb->len == size) {
3057 lan78xx_rx_csum_offload(dev, skb,
3058 rx_cmd_a, rx_cmd_b);
3059 lan78xx_rx_vlan_offload(dev, skb,
3060 rx_cmd_a, rx_cmd_b);
3061
3062 skb_trim(skb, skb->len - 4); /* remove fcs */
3063 skb->truesize = size + sizeof(struct sk_buff);
3064
3065 return 1;
3066 }
3067
3068 skb2 = skb_clone(skb, GFP_ATOMIC);
3069 if (unlikely(!skb2)) {
3070 netdev_warn(dev->net, "Error allocating skb");
3071 return 0;
3072 }
3073
3074 skb2->len = size;
3075 skb2->data = packet;
3076 skb_set_tail_pointer(skb2, size);
3077
3078 lan78xx_rx_csum_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
3079 lan78xx_rx_vlan_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
3080
3081 skb_trim(skb2, skb2->len - 4); /* remove fcs */
3082 skb2->truesize = size + sizeof(struct sk_buff);
3083
3084 lan78xx_skb_return(dev, skb2);
3085 }
3086
3087 skb_pull(skb, size);
3088
3089 /* padding bytes before the next frame starts */
3090 if (skb->len)
3091 skb_pull(skb, align_count);
3092 }
3093
3094 return 1;
3095 }
3096
rx_process(struct lan78xx_net * dev,struct sk_buff * skb)3097 static inline void rx_process(struct lan78xx_net *dev, struct sk_buff *skb)
3098 {
3099 if (!lan78xx_rx(dev, skb)) {
3100 dev->net->stats.rx_errors++;
3101 goto done;
3102 }
3103
3104 if (skb->len) {
3105 lan78xx_skb_return(dev, skb);
3106 return;
3107 }
3108
3109 netif_dbg(dev, rx_err, dev->net, "drop\n");
3110 dev->net->stats.rx_errors++;
3111 done:
3112 skb_queue_tail(&dev->done, skb);
3113 }
3114
3115 static void rx_complete(struct urb *urb);
3116
rx_submit(struct lan78xx_net * dev,struct urb * urb,gfp_t flags)3117 static int rx_submit(struct lan78xx_net *dev, struct urb *urb, gfp_t flags)
3118 {
3119 struct sk_buff *skb;
3120 struct skb_data *entry;
3121 unsigned long lockflags;
3122 size_t size = dev->rx_urb_size;
3123 int ret = 0;
3124
3125 skb = netdev_alloc_skb_ip_align(dev->net, size);
3126 if (!skb) {
3127 usb_free_urb(urb);
3128 return -ENOMEM;
3129 }
3130
3131 entry = (struct skb_data *)skb->cb;
3132 entry->urb = urb;
3133 entry->dev = dev;
3134 entry->length = 0;
3135
3136 usb_fill_bulk_urb(urb, dev->udev, dev->pipe_in,
3137 skb->data, size, rx_complete, skb);
3138
3139 spin_lock_irqsave(&dev->rxq.lock, lockflags);
3140
3141 if (netif_device_present(dev->net) &&
3142 netif_running(dev->net) &&
3143 !test_bit(EVENT_RX_HALT, &dev->flags) &&
3144 !test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3145 ret = usb_submit_urb(urb, GFP_ATOMIC);
3146 switch (ret) {
3147 case 0:
3148 lan78xx_queue_skb(&dev->rxq, skb, rx_start);
3149 break;
3150 case -EPIPE:
3151 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3152 break;
3153 case -ENODEV:
3154 netif_dbg(dev, ifdown, dev->net, "device gone\n");
3155 netif_device_detach(dev->net);
3156 break;
3157 case -EHOSTUNREACH:
3158 ret = -ENOLINK;
3159 break;
3160 default:
3161 netif_dbg(dev, rx_err, dev->net,
3162 "rx submit, %d\n", ret);
3163 tasklet_schedule(&dev->bh);
3164 }
3165 } else {
3166 netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
3167 ret = -ENOLINK;
3168 }
3169 spin_unlock_irqrestore(&dev->rxq.lock, lockflags);
3170 if (ret) {
3171 dev_kfree_skb_any(skb);
3172 usb_free_urb(urb);
3173 }
3174 return ret;
3175 }
3176
rx_complete(struct urb * urb)3177 static void rx_complete(struct urb *urb)
3178 {
3179 struct sk_buff *skb = (struct sk_buff *)urb->context;
3180 struct skb_data *entry = (struct skb_data *)skb->cb;
3181 struct lan78xx_net *dev = entry->dev;
3182 int urb_status = urb->status;
3183 enum skb_state state;
3184
3185 skb_put(skb, urb->actual_length);
3186 state = rx_done;
3187 entry->urb = NULL;
3188
3189 switch (urb_status) {
3190 case 0:
3191 if (skb->len < dev->net->hard_header_len) {
3192 state = rx_cleanup;
3193 dev->net->stats.rx_errors++;
3194 dev->net->stats.rx_length_errors++;
3195 netif_dbg(dev, rx_err, dev->net,
3196 "rx length %d\n", skb->len);
3197 }
3198 usb_mark_last_busy(dev->udev);
3199 break;
3200 case -EPIPE:
3201 dev->net->stats.rx_errors++;
3202 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3203 fallthrough;
3204 case -ECONNRESET: /* async unlink */
3205 case -ESHUTDOWN: /* hardware gone */
3206 netif_dbg(dev, ifdown, dev->net,
3207 "rx shutdown, code %d\n", urb_status);
3208 state = rx_cleanup;
3209 entry->urb = urb;
3210 urb = NULL;
3211 break;
3212 case -EPROTO:
3213 case -ETIME:
3214 case -EILSEQ:
3215 dev->net->stats.rx_errors++;
3216 state = rx_cleanup;
3217 entry->urb = urb;
3218 urb = NULL;
3219 break;
3220
3221 /* data overrun ... flush fifo? */
3222 case -EOVERFLOW:
3223 dev->net->stats.rx_over_errors++;
3224 fallthrough;
3225
3226 default:
3227 state = rx_cleanup;
3228 dev->net->stats.rx_errors++;
3229 netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
3230 break;
3231 }
3232
3233 state = defer_bh(dev, skb, &dev->rxq, state);
3234
3235 if (urb) {
3236 if (netif_running(dev->net) &&
3237 !test_bit(EVENT_RX_HALT, &dev->flags) &&
3238 state != unlink_start) {
3239 rx_submit(dev, urb, GFP_ATOMIC);
3240 return;
3241 }
3242 usb_free_urb(urb);
3243 }
3244 netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n");
3245 }
3246
lan78xx_tx_bh(struct lan78xx_net * dev)3247 static void lan78xx_tx_bh(struct lan78xx_net *dev)
3248 {
3249 int length;
3250 struct urb *urb = NULL;
3251 struct skb_data *entry;
3252 unsigned long flags;
3253 struct sk_buff_head *tqp = &dev->txq_pend;
3254 struct sk_buff *skb, *skb2;
3255 int ret;
3256 int count, pos;
3257 int skb_totallen, pkt_cnt;
3258
3259 skb_totallen = 0;
3260 pkt_cnt = 0;
3261 count = 0;
3262 length = 0;
3263 spin_lock_irqsave(&tqp->lock, flags);
3264 skb_queue_walk(tqp, skb) {
3265 if (skb_is_gso(skb)) {
3266 if (!skb_queue_is_first(tqp, skb)) {
3267 /* handle previous packets first */
3268 break;
3269 }
3270 count = 1;
3271 length = skb->len - TX_OVERHEAD;
3272 __skb_unlink(skb, tqp);
3273 spin_unlock_irqrestore(&tqp->lock, flags);
3274 goto gso_skb;
3275 }
3276
3277 if ((skb_totallen + skb->len) > MAX_SINGLE_PACKET_SIZE)
3278 break;
3279 skb_totallen = skb->len + roundup(skb_totallen, sizeof(u32));
3280 pkt_cnt++;
3281 }
3282 spin_unlock_irqrestore(&tqp->lock, flags);
3283
3284 /* copy to a single skb */
3285 skb = alloc_skb(skb_totallen, GFP_ATOMIC);
3286 if (!skb)
3287 goto drop;
3288
3289 skb_put(skb, skb_totallen);
3290
3291 for (count = pos = 0; count < pkt_cnt; count++) {
3292 skb2 = skb_dequeue(tqp);
3293 if (skb2) {
3294 length += (skb2->len - TX_OVERHEAD);
3295 memcpy(skb->data + pos, skb2->data, skb2->len);
3296 pos += roundup(skb2->len, sizeof(u32));
3297 dev_kfree_skb(skb2);
3298 }
3299 }
3300
3301 gso_skb:
3302 urb = usb_alloc_urb(0, GFP_ATOMIC);
3303 if (!urb)
3304 goto drop;
3305
3306 entry = (struct skb_data *)skb->cb;
3307 entry->urb = urb;
3308 entry->dev = dev;
3309 entry->length = length;
3310 entry->num_of_packet = count;
3311
3312 spin_lock_irqsave(&dev->txq.lock, flags);
3313 ret = usb_autopm_get_interface_async(dev->intf);
3314 if (ret < 0) {
3315 spin_unlock_irqrestore(&dev->txq.lock, flags);
3316 goto drop;
3317 }
3318
3319 usb_fill_bulk_urb(urb, dev->udev, dev->pipe_out,
3320 skb->data, skb->len, tx_complete, skb);
3321
3322 if (length % dev->maxpacket == 0) {
3323 /* send USB_ZERO_PACKET */
3324 urb->transfer_flags |= URB_ZERO_PACKET;
3325 }
3326
3327 #ifdef CONFIG_PM
3328 /* if this triggers the device is still a sleep */
3329 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3330 /* transmission will be done in resume */
3331 usb_anchor_urb(urb, &dev->deferred);
3332 /* no use to process more packets */
3333 netif_stop_queue(dev->net);
3334 usb_put_urb(urb);
3335 spin_unlock_irqrestore(&dev->txq.lock, flags);
3336 netdev_dbg(dev->net, "Delaying transmission for resumption\n");
3337 return;
3338 }
3339 #endif
3340
3341 ret = usb_submit_urb(urb, GFP_ATOMIC);
3342 switch (ret) {
3343 case 0:
3344 netif_trans_update(dev->net);
3345 lan78xx_queue_skb(&dev->txq, skb, tx_start);
3346 if (skb_queue_len(&dev->txq) >= dev->tx_qlen)
3347 netif_stop_queue(dev->net);
3348 break;
3349 case -EPIPE:
3350 netif_stop_queue(dev->net);
3351 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
3352 usb_autopm_put_interface_async(dev->intf);
3353 break;
3354 default:
3355 usb_autopm_put_interface_async(dev->intf);
3356 netif_dbg(dev, tx_err, dev->net,
3357 "tx: submit urb err %d\n", ret);
3358 break;
3359 }
3360
3361 spin_unlock_irqrestore(&dev->txq.lock, flags);
3362
3363 if (ret) {
3364 netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", ret);
3365 drop:
3366 dev->net->stats.tx_dropped++;
3367 if (skb)
3368 dev_kfree_skb_any(skb);
3369 usb_free_urb(urb);
3370 } else
3371 netif_dbg(dev, tx_queued, dev->net,
3372 "> tx, len %d, type 0x%x\n", length, skb->protocol);
3373 }
3374
lan78xx_rx_bh(struct lan78xx_net * dev)3375 static void lan78xx_rx_bh(struct lan78xx_net *dev)
3376 {
3377 struct urb *urb;
3378 int i;
3379
3380 if (skb_queue_len(&dev->rxq) < dev->rx_qlen) {
3381 for (i = 0; i < 10; i++) {
3382 if (skb_queue_len(&dev->rxq) >= dev->rx_qlen)
3383 break;
3384 urb = usb_alloc_urb(0, GFP_ATOMIC);
3385 if (urb)
3386 if (rx_submit(dev, urb, GFP_ATOMIC) == -ENOLINK)
3387 return;
3388 }
3389
3390 if (skb_queue_len(&dev->rxq) < dev->rx_qlen)
3391 tasklet_schedule(&dev->bh);
3392 }
3393 if (skb_queue_len(&dev->txq) < dev->tx_qlen)
3394 netif_wake_queue(dev->net);
3395 }
3396
lan78xx_bh(unsigned long param)3397 static void lan78xx_bh(unsigned long param)
3398 {
3399 struct lan78xx_net *dev = (struct lan78xx_net *)param;
3400 struct sk_buff *skb;
3401 struct skb_data *entry;
3402
3403 while ((skb = skb_dequeue(&dev->done))) {
3404 entry = (struct skb_data *)(skb->cb);
3405 switch (entry->state) {
3406 case rx_done:
3407 entry->state = rx_cleanup;
3408 rx_process(dev, skb);
3409 continue;
3410 case tx_done:
3411 usb_free_urb(entry->urb);
3412 dev_kfree_skb(skb);
3413 continue;
3414 case rx_cleanup:
3415 usb_free_urb(entry->urb);
3416 dev_kfree_skb(skb);
3417 continue;
3418 default:
3419 netdev_dbg(dev->net, "skb state %d\n", entry->state);
3420 return;
3421 }
3422 }
3423
3424 if (netif_device_present(dev->net) && netif_running(dev->net)) {
3425 /* reset update timer delta */
3426 if (timer_pending(&dev->stat_monitor) && (dev->delta != 1)) {
3427 dev->delta = 1;
3428 mod_timer(&dev->stat_monitor,
3429 jiffies + STAT_UPDATE_TIMER);
3430 }
3431
3432 if (!skb_queue_empty(&dev->txq_pend))
3433 lan78xx_tx_bh(dev);
3434
3435 if (!timer_pending(&dev->delay) &&
3436 !test_bit(EVENT_RX_HALT, &dev->flags))
3437 lan78xx_rx_bh(dev);
3438 }
3439 }
3440
lan78xx_delayedwork(struct work_struct * work)3441 static void lan78xx_delayedwork(struct work_struct *work)
3442 {
3443 int status;
3444 struct lan78xx_net *dev;
3445
3446 dev = container_of(work, struct lan78xx_net, wq.work);
3447
3448 if (test_bit(EVENT_TX_HALT, &dev->flags)) {
3449 unlink_urbs(dev, &dev->txq);
3450 status = usb_autopm_get_interface(dev->intf);
3451 if (status < 0)
3452 goto fail_pipe;
3453 status = usb_clear_halt(dev->udev, dev->pipe_out);
3454 usb_autopm_put_interface(dev->intf);
3455 if (status < 0 &&
3456 status != -EPIPE &&
3457 status != -ESHUTDOWN) {
3458 if (netif_msg_tx_err(dev))
3459 fail_pipe:
3460 netdev_err(dev->net,
3461 "can't clear tx halt, status %d\n",
3462 status);
3463 } else {
3464 clear_bit(EVENT_TX_HALT, &dev->flags);
3465 if (status != -ESHUTDOWN)
3466 netif_wake_queue(dev->net);
3467 }
3468 }
3469 if (test_bit(EVENT_RX_HALT, &dev->flags)) {
3470 unlink_urbs(dev, &dev->rxq);
3471 status = usb_autopm_get_interface(dev->intf);
3472 if (status < 0)
3473 goto fail_halt;
3474 status = usb_clear_halt(dev->udev, dev->pipe_in);
3475 usb_autopm_put_interface(dev->intf);
3476 if (status < 0 &&
3477 status != -EPIPE &&
3478 status != -ESHUTDOWN) {
3479 if (netif_msg_rx_err(dev))
3480 fail_halt:
3481 netdev_err(dev->net,
3482 "can't clear rx halt, status %d\n",
3483 status);
3484 } else {
3485 clear_bit(EVENT_RX_HALT, &dev->flags);
3486 tasklet_schedule(&dev->bh);
3487 }
3488 }
3489
3490 if (test_bit(EVENT_LINK_RESET, &dev->flags)) {
3491 int ret = 0;
3492
3493 clear_bit(EVENT_LINK_RESET, &dev->flags);
3494 status = usb_autopm_get_interface(dev->intf);
3495 if (status < 0)
3496 goto skip_reset;
3497 if (lan78xx_link_reset(dev) < 0) {
3498 usb_autopm_put_interface(dev->intf);
3499 skip_reset:
3500 netdev_info(dev->net, "link reset failed (%d)\n",
3501 ret);
3502 } else {
3503 usb_autopm_put_interface(dev->intf);
3504 }
3505 }
3506
3507 if (test_bit(EVENT_STAT_UPDATE, &dev->flags)) {
3508 lan78xx_update_stats(dev);
3509
3510 clear_bit(EVENT_STAT_UPDATE, &dev->flags);
3511
3512 mod_timer(&dev->stat_monitor,
3513 jiffies + (STAT_UPDATE_TIMER * dev->delta));
3514
3515 dev->delta = min((dev->delta * 2), 50);
3516 }
3517 }
3518
intr_complete(struct urb * urb)3519 static void intr_complete(struct urb *urb)
3520 {
3521 struct lan78xx_net *dev = urb->context;
3522 int status = urb->status;
3523
3524 switch (status) {
3525 /* success */
3526 case 0:
3527 lan78xx_status(dev, urb);
3528 break;
3529
3530 /* software-driven interface shutdown */
3531 case -ENOENT: /* urb killed */
3532 case -ESHUTDOWN: /* hardware gone */
3533 netif_dbg(dev, ifdown, dev->net,
3534 "intr shutdown, code %d\n", status);
3535 return;
3536
3537 /* NOTE: not throttling like RX/TX, since this endpoint
3538 * already polls infrequently
3539 */
3540 default:
3541 netdev_dbg(dev->net, "intr status %d\n", status);
3542 break;
3543 }
3544
3545 if (!netif_running(dev->net))
3546 return;
3547
3548 memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
3549 status = usb_submit_urb(urb, GFP_ATOMIC);
3550 if (status != 0)
3551 netif_err(dev, timer, dev->net,
3552 "intr resubmit --> %d\n", status);
3553 }
3554
lan78xx_disconnect(struct usb_interface * intf)3555 static void lan78xx_disconnect(struct usb_interface *intf)
3556 {
3557 struct lan78xx_net *dev;
3558 struct usb_device *udev;
3559 struct net_device *net;
3560 struct phy_device *phydev;
3561
3562 dev = usb_get_intfdata(intf);
3563 usb_set_intfdata(intf, NULL);
3564 if (!dev)
3565 return;
3566
3567 udev = interface_to_usbdev(intf);
3568 net = dev->net;
3569 phydev = net->phydev;
3570
3571 phy_unregister_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0);
3572 phy_unregister_fixup_for_uid(PHY_LAN8835, 0xfffffff0);
3573
3574 phy_disconnect(net->phydev);
3575
3576 if (phy_is_pseudo_fixed_link(phydev))
3577 fixed_phy_unregister(phydev);
3578
3579 unregister_netdev(net);
3580
3581 cancel_delayed_work_sync(&dev->wq);
3582
3583 usb_scuttle_anchored_urbs(&dev->deferred);
3584
3585 lan78xx_unbind(dev, intf);
3586
3587 usb_kill_urb(dev->urb_intr);
3588 usb_free_urb(dev->urb_intr);
3589
3590 free_netdev(net);
3591 usb_put_dev(udev);
3592 }
3593
lan78xx_tx_timeout(struct net_device * net,unsigned int txqueue)3594 static void lan78xx_tx_timeout(struct net_device *net, unsigned int txqueue)
3595 {
3596 struct lan78xx_net *dev = netdev_priv(net);
3597
3598 unlink_urbs(dev, &dev->txq);
3599 tasklet_schedule(&dev->bh);
3600 }
3601
lan78xx_features_check(struct sk_buff * skb,struct net_device * netdev,netdev_features_t features)3602 static netdev_features_t lan78xx_features_check(struct sk_buff *skb,
3603 struct net_device *netdev,
3604 netdev_features_t features)
3605 {
3606 if (skb->len + TX_OVERHEAD > MAX_SINGLE_PACKET_SIZE)
3607 features &= ~NETIF_F_GSO_MASK;
3608
3609 features = vlan_features_check(skb, features);
3610 features = vxlan_features_check(skb, features);
3611
3612 return features;
3613 }
3614
3615 static const struct net_device_ops lan78xx_netdev_ops = {
3616 .ndo_open = lan78xx_open,
3617 .ndo_stop = lan78xx_stop,
3618 .ndo_start_xmit = lan78xx_start_xmit,
3619 .ndo_tx_timeout = lan78xx_tx_timeout,
3620 .ndo_change_mtu = lan78xx_change_mtu,
3621 .ndo_set_mac_address = lan78xx_set_mac_addr,
3622 .ndo_validate_addr = eth_validate_addr,
3623 .ndo_do_ioctl = phy_do_ioctl_running,
3624 .ndo_set_rx_mode = lan78xx_set_multicast,
3625 .ndo_set_features = lan78xx_set_features,
3626 .ndo_vlan_rx_add_vid = lan78xx_vlan_rx_add_vid,
3627 .ndo_vlan_rx_kill_vid = lan78xx_vlan_rx_kill_vid,
3628 .ndo_features_check = lan78xx_features_check,
3629 };
3630
lan78xx_stat_monitor(struct timer_list * t)3631 static void lan78xx_stat_monitor(struct timer_list *t)
3632 {
3633 struct lan78xx_net *dev = from_timer(dev, t, stat_monitor);
3634
3635 lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE);
3636 }
3637
lan78xx_probe(struct usb_interface * intf,const struct usb_device_id * id)3638 static int lan78xx_probe(struct usb_interface *intf,
3639 const struct usb_device_id *id)
3640 {
3641 struct usb_host_endpoint *ep_blkin, *ep_blkout, *ep_intr;
3642 struct lan78xx_net *dev;
3643 struct net_device *netdev;
3644 struct usb_device *udev;
3645 int ret;
3646 unsigned maxp;
3647 unsigned period;
3648 u8 *buf = NULL;
3649
3650 udev = interface_to_usbdev(intf);
3651 udev = usb_get_dev(udev);
3652
3653 netdev = alloc_etherdev(sizeof(struct lan78xx_net));
3654 if (!netdev) {
3655 dev_err(&intf->dev, "Error: OOM\n");
3656 ret = -ENOMEM;
3657 goto out1;
3658 }
3659
3660 /* netdev_printk() needs this */
3661 SET_NETDEV_DEV(netdev, &intf->dev);
3662
3663 dev = netdev_priv(netdev);
3664 dev->udev = udev;
3665 dev->intf = intf;
3666 dev->net = netdev;
3667 dev->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
3668 | NETIF_MSG_PROBE | NETIF_MSG_LINK);
3669
3670 skb_queue_head_init(&dev->rxq);
3671 skb_queue_head_init(&dev->txq);
3672 skb_queue_head_init(&dev->done);
3673 skb_queue_head_init(&dev->rxq_pause);
3674 skb_queue_head_init(&dev->txq_pend);
3675 mutex_init(&dev->phy_mutex);
3676
3677 tasklet_init(&dev->bh, lan78xx_bh, (unsigned long)dev);
3678 INIT_DELAYED_WORK(&dev->wq, lan78xx_delayedwork);
3679 init_usb_anchor(&dev->deferred);
3680
3681 netdev->netdev_ops = &lan78xx_netdev_ops;
3682 netdev->watchdog_timeo = TX_TIMEOUT_JIFFIES;
3683 netdev->ethtool_ops = &lan78xx_ethtool_ops;
3684
3685 dev->delta = 1;
3686 timer_setup(&dev->stat_monitor, lan78xx_stat_monitor, 0);
3687
3688 mutex_init(&dev->stats.access_lock);
3689
3690 if (intf->cur_altsetting->desc.bNumEndpoints < 3) {
3691 ret = -ENODEV;
3692 goto out2;
3693 }
3694
3695 dev->pipe_in = usb_rcvbulkpipe(udev, BULK_IN_PIPE);
3696 ep_blkin = usb_pipe_endpoint(udev, dev->pipe_in);
3697 if (!ep_blkin || !usb_endpoint_is_bulk_in(&ep_blkin->desc)) {
3698 ret = -ENODEV;
3699 goto out2;
3700 }
3701
3702 dev->pipe_out = usb_sndbulkpipe(udev, BULK_OUT_PIPE);
3703 ep_blkout = usb_pipe_endpoint(udev, dev->pipe_out);
3704 if (!ep_blkout || !usb_endpoint_is_bulk_out(&ep_blkout->desc)) {
3705 ret = -ENODEV;
3706 goto out2;
3707 }
3708
3709 ep_intr = &intf->cur_altsetting->endpoint[2];
3710 if (!usb_endpoint_is_int_in(&ep_intr->desc)) {
3711 ret = -ENODEV;
3712 goto out2;
3713 }
3714
3715 dev->pipe_intr = usb_rcvintpipe(dev->udev,
3716 usb_endpoint_num(&ep_intr->desc));
3717
3718 ret = lan78xx_bind(dev, intf);
3719 if (ret < 0)
3720 goto out2;
3721
3722 if (netdev->mtu > (dev->hard_mtu - netdev->hard_header_len))
3723 netdev->mtu = dev->hard_mtu - netdev->hard_header_len;
3724
3725 /* MTU range: 68 - 9000 */
3726 netdev->max_mtu = MAX_SINGLE_PACKET_SIZE;
3727 netif_set_gso_max_size(netdev, MAX_SINGLE_PACKET_SIZE - MAX_HEADER);
3728
3729 period = ep_intr->desc.bInterval;
3730 maxp = usb_maxpacket(dev->udev, dev->pipe_intr, 0);
3731 buf = kmalloc(maxp, GFP_KERNEL);
3732 if (buf) {
3733 dev->urb_intr = usb_alloc_urb(0, GFP_KERNEL);
3734 if (!dev->urb_intr) {
3735 ret = -ENOMEM;
3736 kfree(buf);
3737 goto out3;
3738 } else {
3739 usb_fill_int_urb(dev->urb_intr, dev->udev,
3740 dev->pipe_intr, buf, maxp,
3741 intr_complete, dev, period);
3742 dev->urb_intr->transfer_flags |= URB_FREE_BUFFER;
3743 }
3744 }
3745
3746 dev->maxpacket = usb_maxpacket(dev->udev, dev->pipe_out, 1);
3747
3748 /* Reject broken descriptors. */
3749 if (dev->maxpacket == 0) {
3750 ret = -ENODEV;
3751 goto out4;
3752 }
3753
3754 /* driver requires remote-wakeup capability during autosuspend. */
3755 intf->needs_remote_wakeup = 1;
3756
3757 ret = lan78xx_phy_init(dev);
3758 if (ret < 0)
3759 goto out4;
3760
3761 ret = register_netdev(netdev);
3762 if (ret != 0) {
3763 netif_err(dev, probe, netdev, "couldn't register the device\n");
3764 goto out5;
3765 }
3766
3767 usb_set_intfdata(intf, dev);
3768
3769 ret = device_set_wakeup_enable(&udev->dev, true);
3770
3771 /* Default delay of 2sec has more overhead than advantage.
3772 * Set to 10sec as default.
3773 */
3774 pm_runtime_set_autosuspend_delay(&udev->dev,
3775 DEFAULT_AUTOSUSPEND_DELAY);
3776
3777 return 0;
3778
3779 out5:
3780 phy_disconnect(netdev->phydev);
3781 out4:
3782 usb_free_urb(dev->urb_intr);
3783 out3:
3784 lan78xx_unbind(dev, intf);
3785 out2:
3786 free_netdev(netdev);
3787 out1:
3788 usb_put_dev(udev);
3789
3790 return ret;
3791 }
3792
lan78xx_wakeframe_crc16(const u8 * buf,int len)3793 static u16 lan78xx_wakeframe_crc16(const u8 *buf, int len)
3794 {
3795 const u16 crc16poly = 0x8005;
3796 int i;
3797 u16 bit, crc, msb;
3798 u8 data;
3799
3800 crc = 0xFFFF;
3801 for (i = 0; i < len; i++) {
3802 data = *buf++;
3803 for (bit = 0; bit < 8; bit++) {
3804 msb = crc >> 15;
3805 crc <<= 1;
3806
3807 if (msb ^ (u16)(data & 1)) {
3808 crc ^= crc16poly;
3809 crc |= (u16)0x0001U;
3810 }
3811 data >>= 1;
3812 }
3813 }
3814
3815 return crc;
3816 }
3817
lan78xx_set_suspend(struct lan78xx_net * dev,u32 wol)3818 static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
3819 {
3820 u32 buf;
3821 int ret;
3822 int mask_index;
3823 u16 crc;
3824 u32 temp_wucsr;
3825 u32 temp_pmt_ctl;
3826 const u8 ipv4_multicast[3] = { 0x01, 0x00, 0x5E };
3827 const u8 ipv6_multicast[3] = { 0x33, 0x33 };
3828 const u8 arp_type[2] = { 0x08, 0x06 };
3829
3830 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3831 buf &= ~MAC_TX_TXEN_;
3832 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3833 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3834 buf &= ~MAC_RX_RXEN_;
3835 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3836
3837 ret = lan78xx_write_reg(dev, WUCSR, 0);
3838 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3839 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3840
3841 temp_wucsr = 0;
3842
3843 temp_pmt_ctl = 0;
3844 ret = lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl);
3845 temp_pmt_ctl &= ~PMT_CTL_RES_CLR_WKP_EN_;
3846 temp_pmt_ctl |= PMT_CTL_RES_CLR_WKP_STS_;
3847
3848 for (mask_index = 0; mask_index < NUM_OF_WUF_CFG; mask_index++)
3849 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), 0);
3850
3851 mask_index = 0;
3852 if (wol & WAKE_PHY) {
3853 temp_pmt_ctl |= PMT_CTL_PHY_WAKE_EN_;
3854
3855 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3856 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3857 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3858 }
3859 if (wol & WAKE_MAGIC) {
3860 temp_wucsr |= WUCSR_MPEN_;
3861
3862 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3863 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3864 temp_pmt_ctl |= PMT_CTL_SUS_MODE_3_;
3865 }
3866 if (wol & WAKE_BCAST) {
3867 temp_wucsr |= WUCSR_BCST_EN_;
3868
3869 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3870 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3871 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3872 }
3873 if (wol & WAKE_MCAST) {
3874 temp_wucsr |= WUCSR_WAKE_EN_;
3875
3876 /* set WUF_CFG & WUF_MASK for IPv4 Multicast */
3877 crc = lan78xx_wakeframe_crc16(ipv4_multicast, 3);
3878 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3879 WUF_CFGX_EN_ |
3880 WUF_CFGX_TYPE_MCAST_ |
3881 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3882 (crc & WUF_CFGX_CRC16_MASK_));
3883
3884 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7);
3885 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3886 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3887 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3888 mask_index++;
3889
3890 /* for IPv6 Multicast */
3891 crc = lan78xx_wakeframe_crc16(ipv6_multicast, 2);
3892 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3893 WUF_CFGX_EN_ |
3894 WUF_CFGX_TYPE_MCAST_ |
3895 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3896 (crc & WUF_CFGX_CRC16_MASK_));
3897
3898 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 3);
3899 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3900 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3901 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3902 mask_index++;
3903
3904 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3905 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3906 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3907 }
3908 if (wol & WAKE_UCAST) {
3909 temp_wucsr |= WUCSR_PFDA_EN_;
3910
3911 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3912 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3913 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3914 }
3915 if (wol & WAKE_ARP) {
3916 temp_wucsr |= WUCSR_WAKE_EN_;
3917
3918 /* set WUF_CFG & WUF_MASK
3919 * for packettype (offset 12,13) = ARP (0x0806)
3920 */
3921 crc = lan78xx_wakeframe_crc16(arp_type, 2);
3922 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3923 WUF_CFGX_EN_ |
3924 WUF_CFGX_TYPE_ALL_ |
3925 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3926 (crc & WUF_CFGX_CRC16_MASK_));
3927
3928 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000);
3929 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3930 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3931 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3932 mask_index++;
3933
3934 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3935 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3936 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3937 }
3938
3939 ret = lan78xx_write_reg(dev, WUCSR, temp_wucsr);
3940
3941 /* when multiple WOL bits are set */
3942 if (hweight_long((unsigned long)wol) > 1) {
3943 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3944 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3945 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3946 }
3947 ret = lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl);
3948
3949 /* clear WUPS */
3950 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3951 buf |= PMT_CTL_WUPS_MASK_;
3952 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3953
3954 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3955 buf |= MAC_RX_RXEN_;
3956 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3957
3958 return 0;
3959 }
3960
lan78xx_suspend(struct usb_interface * intf,pm_message_t message)3961 static int lan78xx_suspend(struct usb_interface *intf, pm_message_t message)
3962 {
3963 struct lan78xx_net *dev = usb_get_intfdata(intf);
3964 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
3965 u32 buf;
3966 int ret;
3967
3968 if (!dev->suspend_count++) {
3969 spin_lock_irq(&dev->txq.lock);
3970 /* don't autosuspend while transmitting */
3971 if ((skb_queue_len(&dev->txq) ||
3972 skb_queue_len(&dev->txq_pend)) &&
3973 PMSG_IS_AUTO(message)) {
3974 spin_unlock_irq(&dev->txq.lock);
3975 ret = -EBUSY;
3976 goto out;
3977 } else {
3978 set_bit(EVENT_DEV_ASLEEP, &dev->flags);
3979 spin_unlock_irq(&dev->txq.lock);
3980 }
3981
3982 /* stop TX & RX */
3983 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3984 buf &= ~MAC_TX_TXEN_;
3985 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3986 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3987 buf &= ~MAC_RX_RXEN_;
3988 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3989
3990 /* empty out the rx and queues */
3991 netif_device_detach(dev->net);
3992 lan78xx_terminate_urbs(dev);
3993 usb_kill_urb(dev->urb_intr);
3994
3995 /* reattach */
3996 netif_device_attach(dev->net);
3997 }
3998
3999 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
4000 del_timer(&dev->stat_monitor);
4001
4002 if (PMSG_IS_AUTO(message)) {
4003 /* auto suspend (selective suspend) */
4004 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
4005 buf &= ~MAC_TX_TXEN_;
4006 ret = lan78xx_write_reg(dev, MAC_TX, buf);
4007 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
4008 buf &= ~MAC_RX_RXEN_;
4009 ret = lan78xx_write_reg(dev, MAC_RX, buf);
4010
4011 ret = lan78xx_write_reg(dev, WUCSR, 0);
4012 ret = lan78xx_write_reg(dev, WUCSR2, 0);
4013 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4014
4015 /* set goodframe wakeup */
4016 ret = lan78xx_read_reg(dev, WUCSR, &buf);
4017
4018 buf |= WUCSR_RFE_WAKE_EN_;
4019 buf |= WUCSR_STORE_WAKE_;
4020
4021 ret = lan78xx_write_reg(dev, WUCSR, buf);
4022
4023 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4024
4025 buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
4026 buf |= PMT_CTL_RES_CLR_WKP_STS_;
4027
4028 buf |= PMT_CTL_PHY_WAKE_EN_;
4029 buf |= PMT_CTL_WOL_EN_;
4030 buf &= ~PMT_CTL_SUS_MODE_MASK_;
4031 buf |= PMT_CTL_SUS_MODE_3_;
4032
4033 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4034
4035 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4036
4037 buf |= PMT_CTL_WUPS_MASK_;
4038
4039 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4040
4041 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
4042 buf |= MAC_RX_RXEN_;
4043 ret = lan78xx_write_reg(dev, MAC_RX, buf);
4044 } else {
4045 lan78xx_set_suspend(dev, pdata->wol);
4046 }
4047 }
4048
4049 ret = 0;
4050 out:
4051 return ret;
4052 }
4053
lan78xx_resume(struct usb_interface * intf)4054 static int lan78xx_resume(struct usb_interface *intf)
4055 {
4056 struct lan78xx_net *dev = usb_get_intfdata(intf);
4057 struct sk_buff *skb;
4058 struct urb *res;
4059 int ret;
4060 u32 buf;
4061
4062 if (!timer_pending(&dev->stat_monitor)) {
4063 dev->delta = 1;
4064 mod_timer(&dev->stat_monitor,
4065 jiffies + STAT_UPDATE_TIMER);
4066 }
4067
4068 if (!--dev->suspend_count) {
4069 /* resume interrupt URBs */
4070 if (dev->urb_intr && test_bit(EVENT_DEV_OPEN, &dev->flags))
4071 usb_submit_urb(dev->urb_intr, GFP_NOIO);
4072
4073 spin_lock_irq(&dev->txq.lock);
4074 while ((res = usb_get_from_anchor(&dev->deferred))) {
4075 skb = (struct sk_buff *)res->context;
4076 ret = usb_submit_urb(res, GFP_ATOMIC);
4077 if (ret < 0) {
4078 dev_kfree_skb_any(skb);
4079 usb_free_urb(res);
4080 usb_autopm_put_interface_async(dev->intf);
4081 } else {
4082 netif_trans_update(dev->net);
4083 lan78xx_queue_skb(&dev->txq, skb, tx_start);
4084 }
4085 }
4086
4087 clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
4088 spin_unlock_irq(&dev->txq.lock);
4089
4090 if (test_bit(EVENT_DEV_OPEN, &dev->flags)) {
4091 if (!(skb_queue_len(&dev->txq) >= dev->tx_qlen))
4092 netif_start_queue(dev->net);
4093 tasklet_schedule(&dev->bh);
4094 }
4095 }
4096
4097 ret = lan78xx_write_reg(dev, WUCSR2, 0);
4098 ret = lan78xx_write_reg(dev, WUCSR, 0);
4099 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4100
4101 ret = lan78xx_write_reg(dev, WUCSR2, WUCSR2_NS_RCD_ |
4102 WUCSR2_ARP_RCD_ |
4103 WUCSR2_IPV6_TCPSYN_RCD_ |
4104 WUCSR2_IPV4_TCPSYN_RCD_);
4105
4106 ret = lan78xx_write_reg(dev, WUCSR, WUCSR_EEE_TX_WAKE_ |
4107 WUCSR_EEE_RX_WAKE_ |
4108 WUCSR_PFDA_FR_ |
4109 WUCSR_RFE_WAKE_FR_ |
4110 WUCSR_WUFR_ |
4111 WUCSR_MPR_ |
4112 WUCSR_BCST_FR_);
4113
4114 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
4115 buf |= MAC_TX_TXEN_;
4116 ret = lan78xx_write_reg(dev, MAC_TX, buf);
4117
4118 return 0;
4119 }
4120
lan78xx_reset_resume(struct usb_interface * intf)4121 static int lan78xx_reset_resume(struct usb_interface *intf)
4122 {
4123 struct lan78xx_net *dev = usb_get_intfdata(intf);
4124
4125 lan78xx_reset(dev);
4126
4127 phy_start(dev->net->phydev);
4128
4129 return lan78xx_resume(intf);
4130 }
4131
4132 static const struct usb_device_id products[] = {
4133 {
4134 /* LAN7800 USB Gigabit Ethernet Device */
4135 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7800_USB_PRODUCT_ID),
4136 },
4137 {
4138 /* LAN7850 USB Gigabit Ethernet Device */
4139 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7850_USB_PRODUCT_ID),
4140 },
4141 {
4142 /* LAN7801 USB Gigabit Ethernet Device */
4143 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7801_USB_PRODUCT_ID),
4144 },
4145 {},
4146 };
4147 MODULE_DEVICE_TABLE(usb, products);
4148
4149 static struct usb_driver lan78xx_driver = {
4150 .name = DRIVER_NAME,
4151 .id_table = products,
4152 .probe = lan78xx_probe,
4153 .disconnect = lan78xx_disconnect,
4154 .suspend = lan78xx_suspend,
4155 .resume = lan78xx_resume,
4156 .reset_resume = lan78xx_reset_resume,
4157 .supports_autosuspend = 1,
4158 .disable_hub_initiated_lpm = 1,
4159 };
4160
4161 module_usb_driver(lan78xx_driver);
4162
4163 MODULE_AUTHOR(DRIVER_AUTHOR);
4164 MODULE_DESCRIPTION(DRIVER_DESC);
4165 MODULE_LICENSE("GPL");
4166