]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blob - drivers/net/usb/lan78xx.c
projects / mirror_ubuntu-hirsute-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'threads-v5.9' of git://git.kernel.org/pub/scm/linux/kernel/git/brauner...
[mirror_ubuntu-hirsute-kernel.git] / drivers / net / usb / lan78xx.c
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
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
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
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
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
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 */
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
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
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
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
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
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
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
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
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
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
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
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
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 */
1030 static inline u32 lan78xx_hash(char addr[ETH_ALEN])
1031 {
1032 return (ether_crc(ETH_ALEN, addr) >> 23) & 0x1ff;
1033 }
1034
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
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
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
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;
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 phy_read_status(phydev);
1171
1172 if (!phydev->link && dev->link_on) {
1173 dev->link_on = false;
1174
1175 /* reset MAC */
1176 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1177 if (unlikely(ret < 0))
1178 return -EIO;
1179 buf |= MAC_CR_RST_;
1180 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1181 if (unlikely(ret < 0))
1182 return -EIO;
1183
1184 del_timer(&dev->stat_monitor);
1185 } else if (phydev->link && !dev->link_on) {
1186 dev->link_on = true;
1187
1188 phy_ethtool_ksettings_get(phydev, &ecmd);
1189
1190 if (dev->udev->speed == USB_SPEED_SUPER) {
1191 if (ecmd.base.speed == 1000) {
1192 /* disable U2 */
1193 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1194 buf &= ~USB_CFG1_DEV_U2_INIT_EN_;
1195 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1196 /* enable U1 */
1197 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1198 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1199 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1200 } else {
1201 /* enable U1 & U2 */
1202 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1203 buf |= USB_CFG1_DEV_U2_INIT_EN_;
1204 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1205 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1206 }
1207 }
1208
1209 ladv = phy_read(phydev, MII_ADVERTISE);
1210 if (ladv < 0)
1211 return ladv;
1212
1213 radv = phy_read(phydev, MII_LPA);
1214 if (radv < 0)
1215 return radv;
1216
1217 netif_dbg(dev, link, dev->net,
1218 "speed: %u duplex: %d anadv: 0x%04x anlpa: 0x%04x",
1219 ecmd.base.speed, ecmd.base.duplex, ladv, radv);
1220
1221 ret = lan78xx_update_flowcontrol(dev, ecmd.base.duplex, ladv,
1222 radv);
1223
1224 if (!timer_pending(&dev->stat_monitor)) {
1225 dev->delta = 1;
1226 mod_timer(&dev->stat_monitor,
1227 jiffies + STAT_UPDATE_TIMER);
1228 }
1229
1230 tasklet_schedule(&dev->bh);
1231 }
1232
1233 return ret;
1234 }
1235
1236 /* some work can't be done in tasklets, so we use keventd
1237 *
1238 * NOTE: annoying asymmetry: if it's active, schedule_work() fails,
1239 * but tasklet_schedule() doesn't. hope the failure is rare.
1240 */
1241 static void lan78xx_defer_kevent(struct lan78xx_net *dev, int work)
1242 {
1243 set_bit(work, &dev->flags);
1244 if (!schedule_delayed_work(&dev->wq, 0))
1245 netdev_err(dev->net, "kevent %d may have been dropped\n", work);
1246 }
1247
1248 static void lan78xx_status(struct lan78xx_net *dev, struct urb *urb)
1249 {
1250 u32 intdata;
1251
1252 if (urb->actual_length != 4) {
1253 netdev_warn(dev->net,
1254 "unexpected urb length %d", urb->actual_length);
1255 return;
1256 }
1257
1258 intdata = get_unaligned_le32(urb->transfer_buffer);
1259
1260 if (intdata & INT_ENP_PHY_INT) {
1261 netif_dbg(dev, link, dev->net, "PHY INTR: 0x%08x\n", intdata);
1262 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
1263
1264 if (dev->domain_data.phyirq > 0) {
1265 local_irq_disable();
1266 generic_handle_irq(dev->domain_data.phyirq);
1267 local_irq_enable();
1268 }
1269 } else
1270 netdev_warn(dev->net,
1271 "unexpected interrupt: 0x%08x\n", intdata);
1272 }
1273
1274 static int lan78xx_ethtool_get_eeprom_len(struct net_device *netdev)
1275 {
1276 return MAX_EEPROM_SIZE;
1277 }
1278
1279 static int lan78xx_ethtool_get_eeprom(struct net_device *netdev,
1280 struct ethtool_eeprom *ee, u8 *data)
1281 {
1282 struct lan78xx_net *dev = netdev_priv(netdev);
1283 int ret;
1284
1285 ret = usb_autopm_get_interface(dev->intf);
1286 if (ret)
1287 return ret;
1288
1289 ee->magic = LAN78XX_EEPROM_MAGIC;
1290
1291 ret = lan78xx_read_raw_eeprom(dev, ee->offset, ee->len, data);
1292
1293 usb_autopm_put_interface(dev->intf);
1294
1295 return ret;
1296 }
1297
1298 static int lan78xx_ethtool_set_eeprom(struct net_device *netdev,
1299 struct ethtool_eeprom *ee, u8 *data)
1300 {
1301 struct lan78xx_net *dev = netdev_priv(netdev);
1302 int ret;
1303
1304 ret = usb_autopm_get_interface(dev->intf);
1305 if (ret)
1306 return ret;
1307
1308 /* Invalid EEPROM_INDICATOR at offset zero will result in a failure
1309 * to load data from EEPROM
1310 */
1311 if (ee->magic == LAN78XX_EEPROM_MAGIC)
1312 ret = lan78xx_write_raw_eeprom(dev, ee->offset, ee->len, data);
1313 else if ((ee->magic == LAN78XX_OTP_MAGIC) &&
1314 (ee->offset == 0) &&
1315 (ee->len == 512) &&
1316 (data[0] == OTP_INDICATOR_1))
1317 ret = lan78xx_write_raw_otp(dev, ee->offset, ee->len, data);
1318
1319 usb_autopm_put_interface(dev->intf);
1320
1321 return ret;
1322 }
1323
1324 static void lan78xx_get_strings(struct net_device *netdev, u32 stringset,
1325 u8 *data)
1326 {
1327 if (stringset == ETH_SS_STATS)
1328 memcpy(data, lan78xx_gstrings, sizeof(lan78xx_gstrings));
1329 }
1330
1331 static int lan78xx_get_sset_count(struct net_device *netdev, int sset)
1332 {
1333 if (sset == ETH_SS_STATS)
1334 return ARRAY_SIZE(lan78xx_gstrings);
1335 else
1336 return -EOPNOTSUPP;
1337 }
1338
1339 static void lan78xx_get_stats(struct net_device *netdev,
1340 struct ethtool_stats *stats, u64 *data)
1341 {
1342 struct lan78xx_net *dev = netdev_priv(netdev);
1343
1344 lan78xx_update_stats(dev);
1345
1346 mutex_lock(&dev->stats.access_lock);
1347 memcpy(data, &dev->stats.curr_stat, sizeof(dev->stats.curr_stat));
1348 mutex_unlock(&dev->stats.access_lock);
1349 }
1350
1351 static void lan78xx_get_wol(struct net_device *netdev,
1352 struct ethtool_wolinfo *wol)
1353 {
1354 struct lan78xx_net *dev = netdev_priv(netdev);
1355 int ret;
1356 u32 buf;
1357 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1358
1359 if (usb_autopm_get_interface(dev->intf) < 0)
1360 return;
1361
1362 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1363 if (unlikely(ret < 0)) {
1364 wol->supported = 0;
1365 wol->wolopts = 0;
1366 } else {
1367 if (buf & USB_CFG_RMT_WKP_) {
1368 wol->supported = WAKE_ALL;
1369 wol->wolopts = pdata->wol;
1370 } else {
1371 wol->supported = 0;
1372 wol->wolopts = 0;
1373 }
1374 }
1375
1376 usb_autopm_put_interface(dev->intf);
1377 }
1378
1379 static int lan78xx_set_wol(struct net_device *netdev,
1380 struct ethtool_wolinfo *wol)
1381 {
1382 struct lan78xx_net *dev = netdev_priv(netdev);
1383 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1384 int ret;
1385
1386 ret = usb_autopm_get_interface(dev->intf);
1387 if (ret < 0)
1388 return ret;
1389
1390 if (wol->wolopts & ~WAKE_ALL)
1391 return -EINVAL;
1392
1393 pdata->wol = wol->wolopts;
1394
1395 device_set_wakeup_enable(&dev->udev->dev, (bool)wol->wolopts);
1396
1397 phy_ethtool_set_wol(netdev->phydev, wol);
1398
1399 usb_autopm_put_interface(dev->intf);
1400
1401 return ret;
1402 }
1403
1404 static int lan78xx_get_eee(struct net_device *net, struct ethtool_eee *edata)
1405 {
1406 struct lan78xx_net *dev = netdev_priv(net);
1407 struct phy_device *phydev = net->phydev;
1408 int ret;
1409 u32 buf;
1410
1411 ret = usb_autopm_get_interface(dev->intf);
1412 if (ret < 0)
1413 return ret;
1414
1415 ret = phy_ethtool_get_eee(phydev, edata);
1416 if (ret < 0)
1417 goto exit;
1418
1419 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1420 if (buf & MAC_CR_EEE_EN_) {
1421 edata->eee_enabled = true;
1422 edata->eee_active = !!(edata->advertised &
1423 edata->lp_advertised);
1424 edata->tx_lpi_enabled = true;
1425 /* EEE_TX_LPI_REQ_DLY & tx_lpi_timer are same uSec unit */
1426 ret = lan78xx_read_reg(dev, EEE_TX_LPI_REQ_DLY, &buf);
1427 edata->tx_lpi_timer = buf;
1428 } else {
1429 edata->eee_enabled = false;
1430 edata->eee_active = false;
1431 edata->tx_lpi_enabled = false;
1432 edata->tx_lpi_timer = 0;
1433 }
1434
1435 ret = 0;
1436 exit:
1437 usb_autopm_put_interface(dev->intf);
1438
1439 return ret;
1440 }
1441
1442 static int lan78xx_set_eee(struct net_device *net, struct ethtool_eee *edata)
1443 {
1444 struct lan78xx_net *dev = netdev_priv(net);
1445 int ret;
1446 u32 buf;
1447
1448 ret = usb_autopm_get_interface(dev->intf);
1449 if (ret < 0)
1450 return ret;
1451
1452 if (edata->eee_enabled) {
1453 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1454 buf |= MAC_CR_EEE_EN_;
1455 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1456
1457 phy_ethtool_set_eee(net->phydev, edata);
1458
1459 buf = (u32)edata->tx_lpi_timer;
1460 ret = lan78xx_write_reg(dev, EEE_TX_LPI_REQ_DLY, buf);
1461 } else {
1462 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1463 buf &= ~MAC_CR_EEE_EN_;
1464 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1465 }
1466
1467 usb_autopm_put_interface(dev->intf);
1468
1469 return 0;
1470 }
1471
1472 static u32 lan78xx_get_link(struct net_device *net)
1473 {
1474 phy_read_status(net->phydev);
1475
1476 return net->phydev->link;
1477 }
1478
1479 static void lan78xx_get_drvinfo(struct net_device *net,
1480 struct ethtool_drvinfo *info)
1481 {
1482 struct lan78xx_net *dev = netdev_priv(net);
1483
1484 strncpy(info->driver, DRIVER_NAME, sizeof(info->driver));
1485 usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
1486 }
1487
1488 static u32 lan78xx_get_msglevel(struct net_device *net)
1489 {
1490 struct lan78xx_net *dev = netdev_priv(net);
1491
1492 return dev->msg_enable;
1493 }
1494
1495 static void lan78xx_set_msglevel(struct net_device *net, u32 level)
1496 {
1497 struct lan78xx_net *dev = netdev_priv(net);
1498
1499 dev->msg_enable = level;
1500 }
1501
1502 static int lan78xx_get_link_ksettings(struct net_device *net,
1503 struct ethtool_link_ksettings *cmd)
1504 {
1505 struct lan78xx_net *dev = netdev_priv(net);
1506 struct phy_device *phydev = net->phydev;
1507 int ret;
1508
1509 ret = usb_autopm_get_interface(dev->intf);
1510 if (ret < 0)
1511 return ret;
1512
1513 phy_ethtool_ksettings_get(phydev, cmd);
1514
1515 usb_autopm_put_interface(dev->intf);
1516
1517 return ret;
1518 }
1519
1520 static int lan78xx_set_link_ksettings(struct net_device *net,
1521 const struct ethtool_link_ksettings *cmd)
1522 {
1523 struct lan78xx_net *dev = netdev_priv(net);
1524 struct phy_device *phydev = net->phydev;
1525 int ret = 0;
1526 int temp;
1527
1528 ret = usb_autopm_get_interface(dev->intf);
1529 if (ret < 0)
1530 return ret;
1531
1532 /* change speed & duplex */
1533 ret = phy_ethtool_ksettings_set(phydev, cmd);
1534
1535 if (!cmd->base.autoneg) {
1536 /* force link down */
1537 temp = phy_read(phydev, MII_BMCR);
1538 phy_write(phydev, MII_BMCR, temp | BMCR_LOOPBACK);
1539 mdelay(1);
1540 phy_write(phydev, MII_BMCR, temp);
1541 }
1542
1543 usb_autopm_put_interface(dev->intf);
1544
1545 return ret;
1546 }
1547
1548 static void lan78xx_get_pause(struct net_device *net,
1549 struct ethtool_pauseparam *pause)
1550 {
1551 struct lan78xx_net *dev = netdev_priv(net);
1552 struct phy_device *phydev = net->phydev;
1553 struct ethtool_link_ksettings ecmd;
1554
1555 phy_ethtool_ksettings_get(phydev, &ecmd);
1556
1557 pause->autoneg = dev->fc_autoneg;
1558
1559 if (dev->fc_request_control & FLOW_CTRL_TX)
1560 pause->tx_pause = 1;
1561
1562 if (dev->fc_request_control & FLOW_CTRL_RX)
1563 pause->rx_pause = 1;
1564 }
1565
1566 static int lan78xx_set_pause(struct net_device *net,
1567 struct ethtool_pauseparam *pause)
1568 {
1569 struct lan78xx_net *dev = netdev_priv(net);
1570 struct phy_device *phydev = net->phydev;
1571 struct ethtool_link_ksettings ecmd;
1572 int ret;
1573
1574 phy_ethtool_ksettings_get(phydev, &ecmd);
1575
1576 if (pause->autoneg && !ecmd.base.autoneg) {
1577 ret = -EINVAL;
1578 goto exit;
1579 }
1580
1581 dev->fc_request_control = 0;
1582 if (pause->rx_pause)
1583 dev->fc_request_control |= FLOW_CTRL_RX;
1584
1585 if (pause->tx_pause)
1586 dev->fc_request_control |= FLOW_CTRL_TX;
1587
1588 if (ecmd.base.autoneg) {
1589 __ETHTOOL_DECLARE_LINK_MODE_MASK(fc) = { 0, };
1590 u32 mii_adv;
1591
1592 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,
1593 ecmd.link_modes.advertising);
1594 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
1595 ecmd.link_modes.advertising);
1596 mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
1597 mii_adv_to_linkmode_adv_t(fc, mii_adv);
1598 linkmode_or(ecmd.link_modes.advertising, fc,
1599 ecmd.link_modes.advertising);
1600
1601 phy_ethtool_ksettings_set(phydev, &ecmd);
1602 }
1603
1604 dev->fc_autoneg = pause->autoneg;
1605
1606 ret = 0;
1607 exit:
1608 return ret;
1609 }
1610
1611 static int lan78xx_get_regs_len(struct net_device *netdev)
1612 {
1613 if (!netdev->phydev)
1614 return (sizeof(lan78xx_regs));
1615 else
1616 return (sizeof(lan78xx_regs) + PHY_REG_SIZE);
1617 }
1618
1619 static void
1620 lan78xx_get_regs(struct net_device *netdev, struct ethtool_regs *regs,
1621 void *buf)
1622 {
1623 u32 *data = buf;
1624 int i, j;
1625 struct lan78xx_net *dev = netdev_priv(netdev);
1626
1627 /* Read Device/MAC registers */
1628 for (i = 0; i < ARRAY_SIZE(lan78xx_regs); i++)
1629 lan78xx_read_reg(dev, lan78xx_regs[i], &data[i]);
1630
1631 if (!netdev->phydev)
1632 return;
1633
1634 /* Read PHY registers */
1635 for (j = 0; j < 32; i++, j++)
1636 data[i] = phy_read(netdev->phydev, j);
1637 }
1638
1639 static const struct ethtool_ops lan78xx_ethtool_ops = {
1640 .get_link = lan78xx_get_link,
1641 .nway_reset = phy_ethtool_nway_reset,
1642 .get_drvinfo = lan78xx_get_drvinfo,
1643 .get_msglevel = lan78xx_get_msglevel,
1644 .set_msglevel = lan78xx_set_msglevel,
1645 .get_eeprom_len = lan78xx_ethtool_get_eeprom_len,
1646 .get_eeprom = lan78xx_ethtool_get_eeprom,
1647 .set_eeprom = lan78xx_ethtool_set_eeprom,
1648 .get_ethtool_stats = lan78xx_get_stats,
1649 .get_sset_count = lan78xx_get_sset_count,
1650 .get_strings = lan78xx_get_strings,
1651 .get_wol = lan78xx_get_wol,
1652 .set_wol = lan78xx_set_wol,
1653 .get_eee = lan78xx_get_eee,
1654 .set_eee = lan78xx_set_eee,
1655 .get_pauseparam = lan78xx_get_pause,
1656 .set_pauseparam = lan78xx_set_pause,
1657 .get_link_ksettings = lan78xx_get_link_ksettings,
1658 .set_link_ksettings = lan78xx_set_link_ksettings,
1659 .get_regs_len = lan78xx_get_regs_len,
1660 .get_regs = lan78xx_get_regs,
1661 };
1662
1663 static void lan78xx_init_mac_address(struct lan78xx_net *dev)
1664 {
1665 u32 addr_lo, addr_hi;
1666 int ret;
1667 u8 addr[6];
1668
1669 ret = lan78xx_read_reg(dev, RX_ADDRL, &addr_lo);
1670 ret = lan78xx_read_reg(dev, RX_ADDRH, &addr_hi);
1671
1672 addr[0] = addr_lo & 0xFF;
1673 addr[1] = (addr_lo >> 8) & 0xFF;
1674 addr[2] = (addr_lo >> 16) & 0xFF;
1675 addr[3] = (addr_lo >> 24) & 0xFF;
1676 addr[4] = addr_hi & 0xFF;
1677 addr[5] = (addr_hi >> 8) & 0xFF;
1678
1679 if (!is_valid_ether_addr(addr)) {
1680 if (!eth_platform_get_mac_address(&dev->udev->dev, addr)) {
1681 /* valid address present in Device Tree */
1682 netif_dbg(dev, ifup, dev->net,
1683 "MAC address read from Device Tree");
1684 } else if (((lan78xx_read_eeprom(dev, EEPROM_MAC_OFFSET,
1685 ETH_ALEN, addr) == 0) ||
1686 (lan78xx_read_otp(dev, EEPROM_MAC_OFFSET,
1687 ETH_ALEN, addr) == 0)) &&
1688 is_valid_ether_addr(addr)) {
1689 /* eeprom values are valid so use them */
1690 netif_dbg(dev, ifup, dev->net,
1691 "MAC address read from EEPROM");
1692 } else {
1693 /* generate random MAC */
1694 eth_random_addr(addr);
1695 netif_dbg(dev, ifup, dev->net,
1696 "MAC address set to random addr");
1697 }
1698
1699 addr_lo = addr[0] | (addr[1] << 8) |
1700 (addr[2] << 16) | (addr[3] << 24);
1701 addr_hi = addr[4] | (addr[5] << 8);
1702
1703 ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
1704 ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
1705 }
1706
1707 ret = lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
1708 ret = lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
1709
1710 ether_addr_copy(dev->net->dev_addr, addr);
1711 }
1712
1713 /* MDIO read and write wrappers for phylib */
1714 static int lan78xx_mdiobus_read(struct mii_bus *bus, int phy_id, int idx)
1715 {
1716 struct lan78xx_net *dev = bus->priv;
1717 u32 val, addr;
1718 int ret;
1719
1720 ret = usb_autopm_get_interface(dev->intf);
1721 if (ret < 0)
1722 return ret;
1723
1724 mutex_lock(&dev->phy_mutex);
1725
1726 /* confirm MII not busy */
1727 ret = lan78xx_phy_wait_not_busy(dev);
1728 if (ret < 0)
1729 goto done;
1730
1731 /* set the address, index & direction (read from PHY) */
1732 addr = mii_access(phy_id, idx, MII_READ);
1733 ret = lan78xx_write_reg(dev, MII_ACC, addr);
1734
1735 ret = lan78xx_phy_wait_not_busy(dev);
1736 if (ret < 0)
1737 goto done;
1738
1739 ret = lan78xx_read_reg(dev, MII_DATA, &val);
1740
1741 ret = (int)(val & 0xFFFF);
1742
1743 done:
1744 mutex_unlock(&dev->phy_mutex);
1745 usb_autopm_put_interface(dev->intf);
1746
1747 return ret;
1748 }
1749
1750 static int lan78xx_mdiobus_write(struct mii_bus *bus, int phy_id, int idx,
1751 u16 regval)
1752 {
1753 struct lan78xx_net *dev = bus->priv;
1754 u32 val, addr;
1755 int ret;
1756
1757 ret = usb_autopm_get_interface(dev->intf);
1758 if (ret < 0)
1759 return ret;
1760
1761 mutex_lock(&dev->phy_mutex);
1762
1763 /* confirm MII not busy */
1764 ret = lan78xx_phy_wait_not_busy(dev);
1765 if (ret < 0)
1766 goto done;
1767
1768 val = (u32)regval;
1769 ret = lan78xx_write_reg(dev, MII_DATA, val);
1770
1771 /* set the address, index & direction (write to PHY) */
1772 addr = mii_access(phy_id, idx, MII_WRITE);
1773 ret = lan78xx_write_reg(dev, MII_ACC, addr);
1774
1775 ret = lan78xx_phy_wait_not_busy(dev);
1776 if (ret < 0)
1777 goto done;
1778
1779 done:
1780 mutex_unlock(&dev->phy_mutex);
1781 usb_autopm_put_interface(dev->intf);
1782 return 0;
1783 }
1784
1785 static int lan78xx_mdio_init(struct lan78xx_net *dev)
1786 {
1787 struct device_node *node;
1788 int ret;
1789
1790 dev->mdiobus = mdiobus_alloc();
1791 if (!dev->mdiobus) {
1792 netdev_err(dev->net, "can't allocate MDIO bus\n");
1793 return -ENOMEM;
1794 }
1795
1796 dev->mdiobus->priv = (void *)dev;
1797 dev->mdiobus->read = lan78xx_mdiobus_read;
1798 dev->mdiobus->write = lan78xx_mdiobus_write;
1799 dev->mdiobus->name = "lan78xx-mdiobus";
1800 dev->mdiobus->parent = &dev->udev->dev;
1801
1802 snprintf(dev->mdiobus->id, MII_BUS_ID_SIZE, "usb-%03d:%03d",
1803 dev->udev->bus->busnum, dev->udev->devnum);
1804
1805 switch (dev->chipid) {
1806 case ID_REV_CHIP_ID_7800_:
1807 case ID_REV_CHIP_ID_7850_:
1808 /* set to internal PHY id */
1809 dev->mdiobus->phy_mask = ~(1 << 1);
1810 break;
1811 case ID_REV_CHIP_ID_7801_:
1812 /* scan thru PHYAD[2..0] */
1813 dev->mdiobus->phy_mask = ~(0xFF);
1814 break;
1815 }
1816
1817 node = of_get_child_by_name(dev->udev->dev.of_node, "mdio");
1818 ret = of_mdiobus_register(dev->mdiobus, node);
1819 of_node_put(node);
1820 if (ret) {
1821 netdev_err(dev->net, "can't register MDIO bus\n");
1822 goto exit1;
1823 }
1824
1825 netdev_dbg(dev->net, "registered mdiobus bus %s\n", dev->mdiobus->id);
1826 return 0;
1827 exit1:
1828 mdiobus_free(dev->mdiobus);
1829 return ret;
1830 }
1831
1832 static void lan78xx_remove_mdio(struct lan78xx_net *dev)
1833 {
1834 mdiobus_unregister(dev->mdiobus);
1835 mdiobus_free(dev->mdiobus);
1836 }
1837
1838 static void lan78xx_link_status_change(struct net_device *net)
1839 {
1840 struct phy_device *phydev = net->phydev;
1841 int ret, temp;
1842
1843 /* At forced 100 F/H mode, chip may fail to set mode correctly
1844 * when cable is switched between long(~50+m) and short one.
1845 * As workaround, set to 10 before setting to 100
1846 * at forced 100 F/H mode.
1847 */
1848 if (!phydev->autoneg && (phydev->speed == 100)) {
1849 /* disable phy interrupt */
1850 temp = phy_read(phydev, LAN88XX_INT_MASK);
1851 temp &= ~LAN88XX_INT_MASK_MDINTPIN_EN_;
1852 ret = phy_write(phydev, LAN88XX_INT_MASK, temp);
1853
1854 temp = phy_read(phydev, MII_BMCR);
1855 temp &= ~(BMCR_SPEED100 | BMCR_SPEED1000);
1856 phy_write(phydev, MII_BMCR, temp); /* set to 10 first */
1857 temp |= BMCR_SPEED100;
1858 phy_write(phydev, MII_BMCR, temp); /* set to 100 later */
1859
1860 /* clear pending interrupt generated while workaround */
1861 temp = phy_read(phydev, LAN88XX_INT_STS);
1862
1863 /* enable phy interrupt back */
1864 temp = phy_read(phydev, LAN88XX_INT_MASK);
1865 temp |= LAN88XX_INT_MASK_MDINTPIN_EN_;
1866 ret = phy_write(phydev, LAN88XX_INT_MASK, temp);
1867 }
1868 }
1869
1870 static int irq_map(struct irq_domain *d, unsigned int irq,
1871 irq_hw_number_t hwirq)
1872 {
1873 struct irq_domain_data *data = d->host_data;
1874
1875 irq_set_chip_data(irq, data);
1876 irq_set_chip_and_handler(irq, data->irqchip, data->irq_handler);
1877 irq_set_noprobe(irq);
1878
1879 return 0;
1880 }
1881
1882 static void irq_unmap(struct irq_domain *d, unsigned int irq)
1883 {
1884 irq_set_chip_and_handler(irq, NULL, NULL);
1885 irq_set_chip_data(irq, NULL);
1886 }
1887
1888 static const struct irq_domain_ops chip_domain_ops = {
1889 .map = irq_map,
1890 .unmap = irq_unmap,
1891 };
1892
1893 static void lan78xx_irq_mask(struct irq_data *irqd)
1894 {
1895 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1896
1897 data->irqenable &= ~BIT(irqd_to_hwirq(irqd));
1898 }
1899
1900 static void lan78xx_irq_unmask(struct irq_data *irqd)
1901 {
1902 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1903
1904 data->irqenable |= BIT(irqd_to_hwirq(irqd));
1905 }
1906
1907 static void lan78xx_irq_bus_lock(struct irq_data *irqd)
1908 {
1909 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1910
1911 mutex_lock(&data->irq_lock);
1912 }
1913
1914 static void lan78xx_irq_bus_sync_unlock(struct irq_data *irqd)
1915 {
1916 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1917 struct lan78xx_net *dev =
1918 container_of(data, struct lan78xx_net, domain_data);
1919 u32 buf;
1920 int ret;
1921
1922 /* call register access here because irq_bus_lock & irq_bus_sync_unlock
1923 * are only two callbacks executed in non-atomic contex.
1924 */
1925 ret = lan78xx_read_reg(dev, INT_EP_CTL, &buf);
1926 if (buf != data->irqenable)
1927 ret = lan78xx_write_reg(dev, INT_EP_CTL, data->irqenable);
1928
1929 mutex_unlock(&data->irq_lock);
1930 }
1931
1932 static struct irq_chip lan78xx_irqchip = {
1933 .name = "lan78xx-irqs",
1934 .irq_mask = lan78xx_irq_mask,
1935 .irq_unmask = lan78xx_irq_unmask,
1936 .irq_bus_lock = lan78xx_irq_bus_lock,
1937 .irq_bus_sync_unlock = lan78xx_irq_bus_sync_unlock,
1938 };
1939
1940 static int lan78xx_setup_irq_domain(struct lan78xx_net *dev)
1941 {
1942 struct device_node *of_node;
1943 struct irq_domain *irqdomain;
1944 unsigned int irqmap = 0;
1945 u32 buf;
1946 int ret = 0;
1947
1948 of_node = dev->udev->dev.parent->of_node;
1949
1950 mutex_init(&dev->domain_data.irq_lock);
1951
1952 lan78xx_read_reg(dev, INT_EP_CTL, &buf);
1953 dev->domain_data.irqenable = buf;
1954
1955 dev->domain_data.irqchip = &lan78xx_irqchip;
1956 dev->domain_data.irq_handler = handle_simple_irq;
1957
1958 irqdomain = irq_domain_add_simple(of_node, MAX_INT_EP, 0,
1959 &chip_domain_ops, &dev->domain_data);
1960 if (irqdomain) {
1961 /* create mapping for PHY interrupt */
1962 irqmap = irq_create_mapping(irqdomain, INT_EP_PHY);
1963 if (!irqmap) {
1964 irq_domain_remove(irqdomain);
1965
1966 irqdomain = NULL;
1967 ret = -EINVAL;
1968 }
1969 } else {
1970 ret = -EINVAL;
1971 }
1972
1973 dev->domain_data.irqdomain = irqdomain;
1974 dev->domain_data.phyirq = irqmap;
1975
1976 return ret;
1977 }
1978
1979 static void lan78xx_remove_irq_domain(struct lan78xx_net *dev)
1980 {
1981 if (dev->domain_data.phyirq > 0) {
1982 irq_dispose_mapping(dev->domain_data.phyirq);
1983
1984 if (dev->domain_data.irqdomain)
1985 irq_domain_remove(dev->domain_data.irqdomain);
1986 }
1987 dev->domain_data.phyirq = 0;
1988 dev->domain_data.irqdomain = NULL;
1989 }
1990
1991 static int lan8835_fixup(struct phy_device *phydev)
1992 {
1993 int buf;
1994 int ret;
1995 struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
1996
1997 /* LED2/PME_N/IRQ_N/RGMII_ID pin to IRQ_N mode */
1998 buf = phy_read_mmd(phydev, MDIO_MMD_PCS, 0x8010);
1999 buf &= ~0x1800;
2000 buf |= 0x0800;
2001 phy_write_mmd(phydev, MDIO_MMD_PCS, 0x8010, buf);
2002
2003 /* RGMII MAC TXC Delay Enable */
2004 ret = lan78xx_write_reg(dev, MAC_RGMII_ID,
2005 MAC_RGMII_ID_TXC_DELAY_EN_);
2006
2007 /* RGMII TX DLL Tune Adjust */
2008 ret = lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
2009
2010 dev->interface = PHY_INTERFACE_MODE_RGMII_TXID;
2011
2012 return 1;
2013 }
2014
2015 static int ksz9031rnx_fixup(struct phy_device *phydev)
2016 {
2017 struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
2018
2019 /* Micrel9301RNX PHY configuration */
2020 /* RGMII Control Signal Pad Skew */
2021 phy_write_mmd(phydev, MDIO_MMD_WIS, 4, 0x0077);
2022 /* RGMII RX Data Pad Skew */
2023 phy_write_mmd(phydev, MDIO_MMD_WIS, 5, 0x7777);
2024 /* RGMII RX Clock Pad Skew */
2025 phy_write_mmd(phydev, MDIO_MMD_WIS, 8, 0x1FF);
2026
2027 dev->interface = PHY_INTERFACE_MODE_RGMII_RXID;
2028
2029 return 1;
2030 }
2031
2032 static struct phy_device *lan7801_phy_init(struct lan78xx_net *dev)
2033 {
2034 u32 buf;
2035 int ret;
2036 struct fixed_phy_status fphy_status = {
2037 .link = 1,
2038 .speed = SPEED_1000,
2039 .duplex = DUPLEX_FULL,
2040 };
2041 struct phy_device *phydev;
2042
2043 phydev = phy_find_first(dev->mdiobus);
2044 if (!phydev) {
2045 netdev_dbg(dev->net, "PHY Not Found!! Registering Fixed PHY\n");
2046 phydev = fixed_phy_register(PHY_POLL, &fphy_status, NULL);
2047 if (IS_ERR(phydev)) {
2048 netdev_err(dev->net, "No PHY/fixed_PHY found\n");
2049 return NULL;
2050 }
2051 netdev_dbg(dev->net, "Registered FIXED PHY\n");
2052 dev->interface = PHY_INTERFACE_MODE_RGMII;
2053 ret = lan78xx_write_reg(dev, MAC_RGMII_ID,
2054 MAC_RGMII_ID_TXC_DELAY_EN_);
2055 ret = lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
2056 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2057 buf |= HW_CFG_CLK125_EN_;
2058 buf |= HW_CFG_REFCLK25_EN_;
2059 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2060 } else {
2061 if (!phydev->drv) {
2062 netdev_err(dev->net, "no PHY driver found\n");
2063 return NULL;
2064 }
2065 dev->interface = PHY_INTERFACE_MODE_RGMII;
2066 /* external PHY fixup for KSZ9031RNX */
2067 ret = phy_register_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0,
2068 ksz9031rnx_fixup);
2069 if (ret < 0) {
2070 netdev_err(dev->net, "Failed to register fixup for PHY_KSZ9031RNX\n");
2071 return NULL;
2072 }
2073 /* external PHY fixup for LAN8835 */
2074 ret = phy_register_fixup_for_uid(PHY_LAN8835, 0xfffffff0,
2075 lan8835_fixup);
2076 if (ret < 0) {
2077 netdev_err(dev->net, "Failed to register fixup for PHY_LAN8835\n");
2078 return NULL;
2079 }
2080 /* add more external PHY fixup here if needed */
2081
2082 phydev->is_internal = false;
2083 }
2084 return phydev;
2085 }
2086
2087 static int lan78xx_phy_init(struct lan78xx_net *dev)
2088 {
2089 __ETHTOOL_DECLARE_LINK_MODE_MASK(fc) = { 0, };
2090 int ret;
2091 u32 mii_adv;
2092 struct phy_device *phydev;
2093
2094 switch (dev->chipid) {
2095 case ID_REV_CHIP_ID_7801_:
2096 phydev = lan7801_phy_init(dev);
2097 if (!phydev) {
2098 netdev_err(dev->net, "lan7801: PHY Init Failed");
2099 return -EIO;
2100 }
2101 break;
2102
2103 case ID_REV_CHIP_ID_7800_:
2104 case ID_REV_CHIP_ID_7850_:
2105 phydev = phy_find_first(dev->mdiobus);
2106 if (!phydev) {
2107 netdev_err(dev->net, "no PHY found\n");
2108 return -EIO;
2109 }
2110 phydev->is_internal = true;
2111 dev->interface = PHY_INTERFACE_MODE_GMII;
2112 break;
2113
2114 default:
2115 netdev_err(dev->net, "Unknown CHIP ID found\n");
2116 return -EIO;
2117 }
2118
2119 /* if phyirq is not set, use polling mode in phylib */
2120 if (dev->domain_data.phyirq > 0)
2121 phydev->irq = dev->domain_data.phyirq;
2122 else
2123 phydev->irq = 0;
2124 netdev_dbg(dev->net, "phydev->irq = %d\n", phydev->irq);
2125
2126 /* set to AUTOMDIX */
2127 phydev->mdix = ETH_TP_MDI_AUTO;
2128
2129 ret = phy_connect_direct(dev->net, phydev,
2130 lan78xx_link_status_change,
2131 dev->interface);
2132 if (ret) {
2133 netdev_err(dev->net, "can't attach PHY to %s\n",
2134 dev->mdiobus->id);
2135 if (dev->chipid == ID_REV_CHIP_ID_7801_) {
2136 if (phy_is_pseudo_fixed_link(phydev)) {
2137 fixed_phy_unregister(phydev);
2138 } else {
2139 phy_unregister_fixup_for_uid(PHY_KSZ9031RNX,
2140 0xfffffff0);
2141 phy_unregister_fixup_for_uid(PHY_LAN8835,
2142 0xfffffff0);
2143 }
2144 }
2145 return -EIO;
2146 }
2147
2148 /* MAC doesn't support 1000T Half */
2149 phy_remove_link_mode(phydev, ETHTOOL_LINK_MODE_1000baseT_Half_BIT);
2150
2151 /* support both flow controls */
2152 dev->fc_request_control = (FLOW_CTRL_RX | FLOW_CTRL_TX);
2153 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2154 phydev->advertising);
2155 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2156 phydev->advertising);
2157 mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
2158 mii_adv_to_linkmode_adv_t(fc, mii_adv);
2159 linkmode_or(phydev->advertising, fc, phydev->advertising);
2160
2161 if (phydev->mdio.dev.of_node) {
2162 u32 reg;
2163 int len;
2164
2165 len = of_property_count_elems_of_size(phydev->mdio.dev.of_node,
2166 "microchip,led-modes",
2167 sizeof(u32));
2168 if (len >= 0) {
2169 /* Ensure the appropriate LEDs are enabled */
2170 lan78xx_read_reg(dev, HW_CFG, &reg);
2171 reg &= ~(HW_CFG_LED0_EN_ |
2172 HW_CFG_LED1_EN_ |
2173 HW_CFG_LED2_EN_ |
2174 HW_CFG_LED3_EN_);
2175 reg |= (len > 0) * HW_CFG_LED0_EN_ |
2176 (len > 1) * HW_CFG_LED1_EN_ |
2177 (len > 2) * HW_CFG_LED2_EN_ |
2178 (len > 3) * HW_CFG_LED3_EN_;
2179 lan78xx_write_reg(dev, HW_CFG, reg);
2180 }
2181 }
2182
2183 genphy_config_aneg(phydev);
2184
2185 dev->fc_autoneg = phydev->autoneg;
2186
2187 return 0;
2188 }
2189
2190 static int lan78xx_set_rx_max_frame_length(struct lan78xx_net *dev, int size)
2191 {
2192 int ret = 0;
2193 u32 buf;
2194 bool rxenabled;
2195
2196 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
2197
2198 rxenabled = ((buf & MAC_RX_RXEN_) != 0);
2199
2200 if (rxenabled) {
2201 buf &= ~MAC_RX_RXEN_;
2202 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2203 }
2204
2205 /* add 4 to size for FCS */
2206 buf &= ~MAC_RX_MAX_SIZE_MASK_;
2207 buf |= (((size + 4) << MAC_RX_MAX_SIZE_SHIFT_) & MAC_RX_MAX_SIZE_MASK_);
2208
2209 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2210
2211 if (rxenabled) {
2212 buf |= MAC_RX_RXEN_;
2213 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2214 }
2215
2216 return 0;
2217 }
2218
2219 static int unlink_urbs(struct lan78xx_net *dev, struct sk_buff_head *q)
2220 {
2221 struct sk_buff *skb;
2222 unsigned long flags;
2223 int count = 0;
2224
2225 spin_lock_irqsave(&q->lock, flags);
2226 while (!skb_queue_empty(q)) {
2227 struct skb_data *entry;
2228 struct urb *urb;
2229 int ret;
2230
2231 skb_queue_walk(q, skb) {
2232 entry = (struct skb_data *)skb->cb;
2233 if (entry->state != unlink_start)
2234 goto found;
2235 }
2236 break;
2237 found:
2238 entry->state = unlink_start;
2239 urb = entry->urb;
2240
2241 /* Get reference count of the URB to avoid it to be
2242 * freed during usb_unlink_urb, which may trigger
2243 * use-after-free problem inside usb_unlink_urb since
2244 * usb_unlink_urb is always racing with .complete
2245 * handler(include defer_bh).
2246 */
2247 usb_get_urb(urb);
2248 spin_unlock_irqrestore(&q->lock, flags);
2249 /* during some PM-driven resume scenarios,
2250 * these (async) unlinks complete immediately
2251 */
2252 ret = usb_unlink_urb(urb);
2253 if (ret != -EINPROGRESS && ret != 0)
2254 netdev_dbg(dev->net, "unlink urb err, %d\n", ret);
2255 else
2256 count++;
2257 usb_put_urb(urb);
2258 spin_lock_irqsave(&q->lock, flags);
2259 }
2260 spin_unlock_irqrestore(&q->lock, flags);
2261 return count;
2262 }
2263
2264 static int lan78xx_change_mtu(struct net_device *netdev, int new_mtu)
2265 {
2266 struct lan78xx_net *dev = netdev_priv(netdev);
2267 int ll_mtu = new_mtu + netdev->hard_header_len;
2268 int old_hard_mtu = dev->hard_mtu;
2269 int old_rx_urb_size = dev->rx_urb_size;
2270 int ret;
2271
2272 /* no second zero-length packet read wanted after mtu-sized packets */
2273 if ((ll_mtu % dev->maxpacket) == 0)
2274 return -EDOM;
2275
2276 ret = lan78xx_set_rx_max_frame_length(dev, new_mtu + VLAN_ETH_HLEN);
2277
2278 netdev->mtu = new_mtu;
2279
2280 dev->hard_mtu = netdev->mtu + netdev->hard_header_len;
2281 if (dev->rx_urb_size == old_hard_mtu) {
2282 dev->rx_urb_size = dev->hard_mtu;
2283 if (dev->rx_urb_size > old_rx_urb_size) {
2284 if (netif_running(dev->net)) {
2285 unlink_urbs(dev, &dev->rxq);
2286 tasklet_schedule(&dev->bh);
2287 }
2288 }
2289 }
2290
2291 return 0;
2292 }
2293
2294 static int lan78xx_set_mac_addr(struct net_device *netdev, void *p)
2295 {
2296 struct lan78xx_net *dev = netdev_priv(netdev);
2297 struct sockaddr *addr = p;
2298 u32 addr_lo, addr_hi;
2299 int ret;
2300
2301 if (netif_running(netdev))
2302 return -EBUSY;
2303
2304 if (!is_valid_ether_addr(addr->sa_data))
2305 return -EADDRNOTAVAIL;
2306
2307 ether_addr_copy(netdev->dev_addr, addr->sa_data);
2308
2309 addr_lo = netdev->dev_addr[0] |
2310 netdev->dev_addr[1] << 8 |
2311 netdev->dev_addr[2] << 16 |
2312 netdev->dev_addr[3] << 24;
2313 addr_hi = netdev->dev_addr[4] |
2314 netdev->dev_addr[5] << 8;
2315
2316 ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
2317 ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
2318
2319 /* Added to support MAC address changes */
2320 ret = lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
2321 ret = lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
2322
2323 return 0;
2324 }
2325
2326 /* Enable or disable Rx checksum offload engine */
2327 static int lan78xx_set_features(struct net_device *netdev,
2328 netdev_features_t features)
2329 {
2330 struct lan78xx_net *dev = netdev_priv(netdev);
2331 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2332 unsigned long flags;
2333 int ret;
2334
2335 spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
2336
2337 if (features & NETIF_F_RXCSUM) {
2338 pdata->rfe_ctl |= RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_;
2339 pdata->rfe_ctl |= RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_;
2340 } else {
2341 pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_);
2342 pdata->rfe_ctl &= ~(RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_);
2343 }
2344
2345 if (features & NETIF_F_HW_VLAN_CTAG_RX)
2346 pdata->rfe_ctl |= RFE_CTL_VLAN_STRIP_;
2347 else
2348 pdata->rfe_ctl &= ~RFE_CTL_VLAN_STRIP_;
2349
2350 if (features & NETIF_F_HW_VLAN_CTAG_FILTER)
2351 pdata->rfe_ctl |= RFE_CTL_VLAN_FILTER_;
2352 else
2353 pdata->rfe_ctl &= ~RFE_CTL_VLAN_FILTER_;
2354
2355 spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
2356
2357 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2358
2359 return 0;
2360 }
2361
2362 static void lan78xx_deferred_vlan_write(struct work_struct *param)
2363 {
2364 struct lan78xx_priv *pdata =
2365 container_of(param, struct lan78xx_priv, set_vlan);
2366 struct lan78xx_net *dev = pdata->dev;
2367
2368 lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, 0,
2369 DP_SEL_VHF_VLAN_LEN, pdata->vlan_table);
2370 }
2371
2372 static int lan78xx_vlan_rx_add_vid(struct net_device *netdev,
2373 __be16 proto, u16 vid)
2374 {
2375 struct lan78xx_net *dev = netdev_priv(netdev);
2376 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2377 u16 vid_bit_index;
2378 u16 vid_dword_index;
2379
2380 vid_dword_index = (vid >> 5) & 0x7F;
2381 vid_bit_index = vid & 0x1F;
2382
2383 pdata->vlan_table[vid_dword_index] |= (1 << vid_bit_index);
2384
2385 /* defer register writes to a sleepable context */
2386 schedule_work(&pdata->set_vlan);
2387
2388 return 0;
2389 }
2390
2391 static int lan78xx_vlan_rx_kill_vid(struct net_device *netdev,
2392 __be16 proto, u16 vid)
2393 {
2394 struct lan78xx_net *dev = netdev_priv(netdev);
2395 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2396 u16 vid_bit_index;
2397 u16 vid_dword_index;
2398
2399 vid_dword_index = (vid >> 5) & 0x7F;
2400 vid_bit_index = vid & 0x1F;
2401
2402 pdata->vlan_table[vid_dword_index] &= ~(1 << vid_bit_index);
2403
2404 /* defer register writes to a sleepable context */
2405 schedule_work(&pdata->set_vlan);
2406
2407 return 0;
2408 }
2409
2410 static void lan78xx_init_ltm(struct lan78xx_net *dev)
2411 {
2412 int ret;
2413 u32 buf;
2414 u32 regs[6] = { 0 };
2415
2416 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
2417 if (buf & USB_CFG1_LTM_ENABLE_) {
2418 u8 temp[2];
2419 /* Get values from EEPROM first */
2420 if (lan78xx_read_eeprom(dev, 0x3F, 2, temp) == 0) {
2421 if (temp[0] == 24) {
2422 ret = lan78xx_read_raw_eeprom(dev,
2423 temp[1] * 2,
2424 24,
2425 (u8 *)regs);
2426 if (ret < 0)
2427 return;
2428 }
2429 } else if (lan78xx_read_otp(dev, 0x3F, 2, temp) == 0) {
2430 if (temp[0] == 24) {
2431 ret = lan78xx_read_raw_otp(dev,
2432 temp[1] * 2,
2433 24,
2434 (u8 *)regs);
2435 if (ret < 0)
2436 return;
2437 }
2438 }
2439 }
2440
2441 lan78xx_write_reg(dev, LTM_BELT_IDLE0, regs[0]);
2442 lan78xx_write_reg(dev, LTM_BELT_IDLE1, regs[1]);
2443 lan78xx_write_reg(dev, LTM_BELT_ACT0, regs[2]);
2444 lan78xx_write_reg(dev, LTM_BELT_ACT1, regs[3]);
2445 lan78xx_write_reg(dev, LTM_INACTIVE0, regs[4]);
2446 lan78xx_write_reg(dev, LTM_INACTIVE1, regs[5]);
2447 }
2448
2449 static int lan78xx_reset(struct lan78xx_net *dev)
2450 {
2451 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2452 u32 buf;
2453 int ret = 0;
2454 unsigned long timeout;
2455 u8 sig;
2456
2457 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2458 buf |= HW_CFG_LRST_;
2459 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2460
2461 timeout = jiffies + HZ;
2462 do {
2463 mdelay(1);
2464 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2465 if (time_after(jiffies, timeout)) {
2466 netdev_warn(dev->net,
2467 "timeout on completion of LiteReset");
2468 return -EIO;
2469 }
2470 } while (buf & HW_CFG_LRST_);
2471
2472 lan78xx_init_mac_address(dev);
2473
2474 /* save DEVID for later usage */
2475 ret = lan78xx_read_reg(dev, ID_REV, &buf);
2476 dev->chipid = (buf & ID_REV_CHIP_ID_MASK_) >> 16;
2477 dev->chiprev = buf & ID_REV_CHIP_REV_MASK_;
2478
2479 /* Respond to the IN token with a NAK */
2480 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2481 buf |= USB_CFG_BIR_;
2482 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2483
2484 /* Init LTM */
2485 lan78xx_init_ltm(dev);
2486
2487 if (dev->udev->speed == USB_SPEED_SUPER) {
2488 buf = DEFAULT_BURST_CAP_SIZE / SS_USB_PKT_SIZE;
2489 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2490 dev->rx_qlen = 4;
2491 dev->tx_qlen = 4;
2492 } else if (dev->udev->speed == USB_SPEED_HIGH) {
2493 buf = DEFAULT_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
2494 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2495 dev->rx_qlen = RX_MAX_QUEUE_MEMORY / dev->rx_urb_size;
2496 dev->tx_qlen = RX_MAX_QUEUE_MEMORY / dev->hard_mtu;
2497 } else {
2498 buf = DEFAULT_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
2499 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2500 dev->rx_qlen = 4;
2501 dev->tx_qlen = 4;
2502 }
2503
2504 ret = lan78xx_write_reg(dev, BURST_CAP, buf);
2505 ret = lan78xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
2506
2507 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2508 buf |= HW_CFG_MEF_;
2509 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2510
2511 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2512 buf |= USB_CFG_BCE_;
2513 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2514
2515 /* set FIFO sizes */
2516 buf = (MAX_RX_FIFO_SIZE - 512) / 512;
2517 ret = lan78xx_write_reg(dev, FCT_RX_FIFO_END, buf);
2518
2519 buf = (MAX_TX_FIFO_SIZE - 512) / 512;
2520 ret = lan78xx_write_reg(dev, FCT_TX_FIFO_END, buf);
2521
2522 ret = lan78xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
2523 ret = lan78xx_write_reg(dev, FLOW, 0);
2524 ret = lan78xx_write_reg(dev, FCT_FLOW, 0);
2525
2526 /* Don't need rfe_ctl_lock during initialisation */
2527 ret = lan78xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
2528 pdata->rfe_ctl |= RFE_CTL_BCAST_EN_ | RFE_CTL_DA_PERFECT_;
2529 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2530
2531 /* Enable or disable checksum offload engines */
2532 lan78xx_set_features(dev->net, dev->net->features);
2533
2534 lan78xx_set_multicast(dev->net);
2535
2536 /* reset PHY */
2537 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
2538 buf |= PMT_CTL_PHY_RST_;
2539 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
2540
2541 timeout = jiffies + HZ;
2542 do {
2543 mdelay(1);
2544 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
2545 if (time_after(jiffies, timeout)) {
2546 netdev_warn(dev->net, "timeout waiting for PHY Reset");
2547 return -EIO;
2548 }
2549 } while ((buf & PMT_CTL_PHY_RST_) || !(buf & PMT_CTL_READY_));
2550
2551 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
2552 /* LAN7801 only has RGMII mode */
2553 if (dev->chipid == ID_REV_CHIP_ID_7801_)
2554 buf &= ~MAC_CR_GMII_EN_;
2555
2556 if (dev->chipid == ID_REV_CHIP_ID_7800_) {
2557 ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
2558 if (!ret && sig != EEPROM_INDICATOR) {
2559 /* Implies there is no external eeprom. Set mac speed */
2560 netdev_info(dev->net, "No External EEPROM. Setting MAC Speed\n");
2561 buf |= MAC_CR_AUTO_DUPLEX_ | MAC_CR_AUTO_SPEED_;
2562 }
2563 }
2564 ret = lan78xx_write_reg(dev, MAC_CR, buf);
2565
2566 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
2567 buf |= MAC_TX_TXEN_;
2568 ret = lan78xx_write_reg(dev, MAC_TX, buf);
2569
2570 ret = lan78xx_read_reg(dev, FCT_TX_CTL, &buf);
2571 buf |= FCT_TX_CTL_EN_;
2572 ret = lan78xx_write_reg(dev, FCT_TX_CTL, buf);
2573
2574 ret = lan78xx_set_rx_max_frame_length(dev,
2575 dev->net->mtu + VLAN_ETH_HLEN);
2576
2577 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
2578 buf |= MAC_RX_RXEN_;
2579 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2580
2581 ret = lan78xx_read_reg(dev, FCT_RX_CTL, &buf);
2582 buf |= FCT_RX_CTL_EN_;
2583 ret = lan78xx_write_reg(dev, FCT_RX_CTL, buf);
2584
2585 return 0;
2586 }
2587
2588 static void lan78xx_init_stats(struct lan78xx_net *dev)
2589 {
2590 u32 *p;
2591 int i;
2592
2593 /* initialize for stats update
2594 * some counters are 20bits and some are 32bits
2595 */
2596 p = (u32 *)&dev->stats.rollover_max;
2597 for (i = 0; i < (sizeof(dev->stats.rollover_max) / (sizeof(u32))); i++)
2598 p[i] = 0xFFFFF;
2599
2600 dev->stats.rollover_max.rx_unicast_byte_count = 0xFFFFFFFF;
2601 dev->stats.rollover_max.rx_broadcast_byte_count = 0xFFFFFFFF;
2602 dev->stats.rollover_max.rx_multicast_byte_count = 0xFFFFFFFF;
2603 dev->stats.rollover_max.eee_rx_lpi_transitions = 0xFFFFFFFF;
2604 dev->stats.rollover_max.eee_rx_lpi_time = 0xFFFFFFFF;
2605 dev->stats.rollover_max.tx_unicast_byte_count = 0xFFFFFFFF;
2606 dev->stats.rollover_max.tx_broadcast_byte_count = 0xFFFFFFFF;
2607 dev->stats.rollover_max.tx_multicast_byte_count = 0xFFFFFFFF;
2608 dev->stats.rollover_max.eee_tx_lpi_transitions = 0xFFFFFFFF;
2609 dev->stats.rollover_max.eee_tx_lpi_time = 0xFFFFFFFF;
2610
2611 set_bit(EVENT_STAT_UPDATE, &dev->flags);
2612 }
2613
2614 static int lan78xx_open(struct net_device *net)
2615 {
2616 struct lan78xx_net *dev = netdev_priv(net);
2617 int ret;
2618
2619 ret = usb_autopm_get_interface(dev->intf);
2620 if (ret < 0)
2621 goto out;
2622
2623 phy_start(net->phydev);
2624
2625 netif_dbg(dev, ifup, dev->net, "phy initialised successfully");
2626
2627 /* for Link Check */
2628 if (dev->urb_intr) {
2629 ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
2630 if (ret < 0) {
2631 netif_err(dev, ifup, dev->net,
2632 "intr submit %d\n", ret);
2633 goto done;
2634 }
2635 }
2636
2637 lan78xx_init_stats(dev);
2638
2639 set_bit(EVENT_DEV_OPEN, &dev->flags);
2640
2641 netif_start_queue(net);
2642
2643 dev->link_on = false;
2644
2645 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
2646 done:
2647 usb_autopm_put_interface(dev->intf);
2648
2649 out:
2650 return ret;
2651 }
2652
2653 static void lan78xx_terminate_urbs(struct lan78xx_net *dev)
2654 {
2655 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);
2656 DECLARE_WAITQUEUE(wait, current);
2657 int temp;
2658
2659 /* ensure there are no more active urbs */
2660 add_wait_queue(&unlink_wakeup, &wait);
2661 set_current_state(TASK_UNINTERRUPTIBLE);
2662 dev->wait = &unlink_wakeup;
2663 temp = unlink_urbs(dev, &dev->txq) + unlink_urbs(dev, &dev->rxq);
2664
2665 /* maybe wait for deletions to finish. */
2666 while (!skb_queue_empty(&dev->rxq) &&
2667 !skb_queue_empty(&dev->txq) &&
2668 !skb_queue_empty(&dev->done)) {
2669 schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
2670 set_current_state(TASK_UNINTERRUPTIBLE);
2671 netif_dbg(dev, ifdown, dev->net,
2672 "waited for %d urb completions\n", temp);
2673 }
2674 set_current_state(TASK_RUNNING);
2675 dev->wait = NULL;
2676 remove_wait_queue(&unlink_wakeup, &wait);
2677 }
2678
2679 static int lan78xx_stop(struct net_device *net)
2680 {
2681 struct lan78xx_net *dev = netdev_priv(net);
2682
2683 if (timer_pending(&dev->stat_monitor))
2684 del_timer_sync(&dev->stat_monitor);
2685
2686 if (net->phydev)
2687 phy_stop(net->phydev);
2688
2689 clear_bit(EVENT_DEV_OPEN, &dev->flags);
2690 netif_stop_queue(net);
2691
2692 netif_info(dev, ifdown, dev->net,
2693 "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
2694 net->stats.rx_packets, net->stats.tx_packets,
2695 net->stats.rx_errors, net->stats.tx_errors);
2696
2697 lan78xx_terminate_urbs(dev);
2698
2699 usb_kill_urb(dev->urb_intr);
2700
2701 skb_queue_purge(&dev->rxq_pause);
2702
2703 /* deferred work (task, timer, softirq) must also stop.
2704 * can't flush_scheduled_work() until we drop rtnl (later),
2705 * else workers could deadlock; so make workers a NOP.
2706 */
2707 dev->flags = 0;
2708 cancel_delayed_work_sync(&dev->wq);
2709 tasklet_kill(&dev->bh);
2710
2711 usb_autopm_put_interface(dev->intf);
2712
2713 return 0;
2714 }
2715
2716 static struct sk_buff *lan78xx_tx_prep(struct lan78xx_net *dev,
2717 struct sk_buff *skb, gfp_t flags)
2718 {
2719 u32 tx_cmd_a, tx_cmd_b;
2720 void *ptr;
2721
2722 if (skb_cow_head(skb, TX_OVERHEAD)) {
2723 dev_kfree_skb_any(skb);
2724 return NULL;
2725 }
2726
2727 if (skb_linearize(skb)) {
2728 dev_kfree_skb_any(skb);
2729 return NULL;
2730 }
2731
2732 tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN_MASK_) | TX_CMD_A_FCS_;
2733
2734 if (skb->ip_summed == CHECKSUM_PARTIAL)
2735 tx_cmd_a |= TX_CMD_A_IPE_ | TX_CMD_A_TPE_;
2736
2737 tx_cmd_b = 0;
2738 if (skb_is_gso(skb)) {
2739 u16 mss = max(skb_shinfo(skb)->gso_size, TX_CMD_B_MSS_MIN_);
2740
2741 tx_cmd_b = (mss << TX_CMD_B_MSS_SHIFT_) & TX_CMD_B_MSS_MASK_;
2742
2743 tx_cmd_a |= TX_CMD_A_LSO_;
2744 }
2745
2746 if (skb_vlan_tag_present(skb)) {
2747 tx_cmd_a |= TX_CMD_A_IVTG_;
2748 tx_cmd_b |= skb_vlan_tag_get(skb) & TX_CMD_B_VTAG_MASK_;
2749 }
2750
2751 ptr = skb_push(skb, 8);
2752 put_unaligned_le32(tx_cmd_a, ptr);
2753 put_unaligned_le32(tx_cmd_b, ptr + 4);
2754
2755 return skb;
2756 }
2757
2758 static enum skb_state defer_bh(struct lan78xx_net *dev, struct sk_buff *skb,
2759 struct sk_buff_head *list, enum skb_state state)
2760 {
2761 unsigned long flags;
2762 enum skb_state old_state;
2763 struct skb_data *entry = (struct skb_data *)skb->cb;
2764
2765 spin_lock_irqsave(&list->lock, flags);
2766 old_state = entry->state;
2767 entry->state = state;
2768
2769 __skb_unlink(skb, list);
2770 spin_unlock(&list->lock);
2771 spin_lock(&dev->done.lock);
2772
2773 __skb_queue_tail(&dev->done, skb);
2774 if (skb_queue_len(&dev->done) == 1)
2775 tasklet_schedule(&dev->bh);
2776 spin_unlock_irqrestore(&dev->done.lock, flags);
2777
2778 return old_state;
2779 }
2780
2781 static void tx_complete(struct urb *urb)
2782 {
2783 struct sk_buff *skb = (struct sk_buff *)urb->context;
2784 struct skb_data *entry = (struct skb_data *)skb->cb;
2785 struct lan78xx_net *dev = entry->dev;
2786
2787 if (urb->status == 0) {
2788 dev->net->stats.tx_packets += entry->num_of_packet;
2789 dev->net->stats.tx_bytes += entry->length;
2790 } else {
2791 dev->net->stats.tx_errors++;
2792
2793 switch (urb->status) {
2794 case -EPIPE:
2795 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
2796 break;
2797
2798 /* software-driven interface shutdown */
2799 case -ECONNRESET:
2800 case -ESHUTDOWN:
2801 break;
2802
2803 case -EPROTO:
2804 case -ETIME:
2805 case -EILSEQ:
2806 netif_stop_queue(dev->net);
2807 break;
2808 default:
2809 netif_dbg(dev, tx_err, dev->net,
2810 "tx err %d\n", entry->urb->status);
2811 break;
2812 }
2813 }
2814
2815 usb_autopm_put_interface_async(dev->intf);
2816
2817 defer_bh(dev, skb, &dev->txq, tx_done);
2818 }
2819
2820 static void lan78xx_queue_skb(struct sk_buff_head *list,
2821 struct sk_buff *newsk, enum skb_state state)
2822 {
2823 struct skb_data *entry = (struct skb_data *)newsk->cb;
2824
2825 __skb_queue_tail(list, newsk);
2826 entry->state = state;
2827 }
2828
2829 static netdev_tx_t
2830 lan78xx_start_xmit(struct sk_buff *skb, struct net_device *net)
2831 {
2832 struct lan78xx_net *dev = netdev_priv(net);
2833 struct sk_buff *skb2 = NULL;
2834
2835 if (skb) {
2836 skb_tx_timestamp(skb);
2837 skb2 = lan78xx_tx_prep(dev, skb, GFP_ATOMIC);
2838 }
2839
2840 if (skb2) {
2841 skb_queue_tail(&dev->txq_pend, skb2);
2842
2843 /* throttle TX patch at slower than SUPER SPEED USB */
2844 if ((dev->udev->speed < USB_SPEED_SUPER) &&
2845 (skb_queue_len(&dev->txq_pend) > 10))
2846 netif_stop_queue(net);
2847 } else {
2848 netif_dbg(dev, tx_err, dev->net,
2849 "lan78xx_tx_prep return NULL\n");
2850 dev->net->stats.tx_errors++;
2851 dev->net->stats.tx_dropped++;
2852 }
2853
2854 tasklet_schedule(&dev->bh);
2855
2856 return NETDEV_TX_OK;
2857 }
2858
2859 static int lan78xx_bind(struct lan78xx_net *dev, struct usb_interface *intf)
2860 {
2861 struct lan78xx_priv *pdata = NULL;
2862 int ret;
2863 int i;
2864
2865 dev->data[0] = (unsigned long)kzalloc(sizeof(*pdata), GFP_KERNEL);
2866
2867 pdata = (struct lan78xx_priv *)(dev->data[0]);
2868 if (!pdata) {
2869 netdev_warn(dev->net, "Unable to allocate lan78xx_priv");
2870 return -ENOMEM;
2871 }
2872
2873 pdata->dev = dev;
2874
2875 spin_lock_init(&pdata->rfe_ctl_lock);
2876 mutex_init(&pdata->dataport_mutex);
2877
2878 INIT_WORK(&pdata->set_multicast, lan78xx_deferred_multicast_write);
2879
2880 for (i = 0; i < DP_SEL_VHF_VLAN_LEN; i++)
2881 pdata->vlan_table[i] = 0;
2882
2883 INIT_WORK(&pdata->set_vlan, lan78xx_deferred_vlan_write);
2884
2885 dev->net->features = 0;
2886
2887 if (DEFAULT_TX_CSUM_ENABLE)
2888 dev->net->features |= NETIF_F_HW_CSUM;
2889
2890 if (DEFAULT_RX_CSUM_ENABLE)
2891 dev->net->features |= NETIF_F_RXCSUM;
2892
2893 if (DEFAULT_TSO_CSUM_ENABLE)
2894 dev->net->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_SG;
2895
2896 if (DEFAULT_VLAN_RX_OFFLOAD)
2897 dev->net->features |= NETIF_F_HW_VLAN_CTAG_RX;
2898
2899 if (DEFAULT_VLAN_FILTER_ENABLE)
2900 dev->net->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
2901
2902 dev->net->hw_features = dev->net->features;
2903
2904 ret = lan78xx_setup_irq_domain(dev);
2905 if (ret < 0) {
2906 netdev_warn(dev->net,
2907 "lan78xx_setup_irq_domain() failed : %d", ret);
2908 goto out1;
2909 }
2910
2911 dev->net->hard_header_len += TX_OVERHEAD;
2912 dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
2913
2914 /* Init all registers */
2915 ret = lan78xx_reset(dev);
2916 if (ret) {
2917 netdev_warn(dev->net, "Registers INIT FAILED....");
2918 goto out2;
2919 }
2920
2921 ret = lan78xx_mdio_init(dev);
2922 if (ret) {
2923 netdev_warn(dev->net, "MDIO INIT FAILED.....");
2924 goto out2;
2925 }
2926
2927 dev->net->flags |= IFF_MULTICAST;
2928
2929 pdata->wol = WAKE_MAGIC;
2930
2931 return ret;
2932
2933 out2:
2934 lan78xx_remove_irq_domain(dev);
2935
2936 out1:
2937 netdev_warn(dev->net, "Bind routine FAILED");
2938 cancel_work_sync(&pdata->set_multicast);
2939 cancel_work_sync(&pdata->set_vlan);
2940 kfree(pdata);
2941 return ret;
2942 }
2943
2944 static void lan78xx_unbind(struct lan78xx_net *dev, struct usb_interface *intf)
2945 {
2946 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2947
2948 lan78xx_remove_irq_domain(dev);
2949
2950 lan78xx_remove_mdio(dev);
2951
2952 if (pdata) {
2953 cancel_work_sync(&pdata->set_multicast);
2954 cancel_work_sync(&pdata->set_vlan);
2955 netif_dbg(dev, ifdown, dev->net, "free pdata");
2956 kfree(pdata);
2957 pdata = NULL;
2958 dev->data[0] = 0;
2959 }
2960 }
2961
2962 static void lan78xx_rx_csum_offload(struct lan78xx_net *dev,
2963 struct sk_buff *skb,
2964 u32 rx_cmd_a, u32 rx_cmd_b)
2965 {
2966 /* HW Checksum offload appears to be flawed if used when not stripping
2967 * VLAN headers. Drop back to S/W checksums under these conditions.
2968 */
2969 if (!(dev->net->features & NETIF_F_RXCSUM) ||
2970 unlikely(rx_cmd_a & RX_CMD_A_ICSM_) ||
2971 ((rx_cmd_a & RX_CMD_A_FVTG_) &&
2972 !(dev->net->features & NETIF_F_HW_VLAN_CTAG_RX))) {
2973 skb->ip_summed = CHECKSUM_NONE;
2974 } else {
2975 skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT_));
2976 skb->ip_summed = CHECKSUM_COMPLETE;
2977 }
2978 }
2979
2980 static void lan78xx_rx_vlan_offload(struct lan78xx_net *dev,
2981 struct sk_buff *skb,
2982 u32 rx_cmd_a, u32 rx_cmd_b)
2983 {
2984 if ((dev->net->features & NETIF_F_HW_VLAN_CTAG_RX) &&
2985 (rx_cmd_a & RX_CMD_A_FVTG_))
2986 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
2987 (rx_cmd_b & 0xffff));
2988 }
2989
2990 static void lan78xx_skb_return(struct lan78xx_net *dev, struct sk_buff *skb)
2991 {
2992 int status;
2993
2994 if (test_bit(EVENT_RX_PAUSED, &dev->flags)) {
2995 skb_queue_tail(&dev->rxq_pause, skb);
2996 return;
2997 }
2998
2999 dev->net->stats.rx_packets++;
3000 dev->net->stats.rx_bytes += skb->len;
3001
3002 skb->protocol = eth_type_trans(skb, dev->net);
3003
3004 netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
3005 skb->len + sizeof(struct ethhdr), skb->protocol);
3006 memset(skb->cb, 0, sizeof(struct skb_data));
3007
3008 if (skb_defer_rx_timestamp(skb))
3009 return;
3010
3011 status = netif_rx(skb);
3012 if (status != NET_RX_SUCCESS)
3013 netif_dbg(dev, rx_err, dev->net,
3014 "netif_rx status %d\n", status);
3015 }
3016
3017 static int lan78xx_rx(struct lan78xx_net *dev, struct sk_buff *skb)
3018 {
3019 if (skb->len < dev->net->hard_header_len)
3020 return 0;
3021
3022 while (skb->len > 0) {
3023 u32 rx_cmd_a, rx_cmd_b, align_count, size;
3024 u16 rx_cmd_c;
3025 struct sk_buff *skb2;
3026 unsigned char *packet;
3027
3028 rx_cmd_a = get_unaligned_le32(skb->data);
3029 skb_pull(skb, sizeof(rx_cmd_a));
3030
3031 rx_cmd_b = get_unaligned_le32(skb->data);
3032 skb_pull(skb, sizeof(rx_cmd_b));
3033
3034 rx_cmd_c = get_unaligned_le16(skb->data);
3035 skb_pull(skb, sizeof(rx_cmd_c));
3036
3037 packet = skb->data;
3038
3039 /* get the packet length */
3040 size = (rx_cmd_a & RX_CMD_A_LEN_MASK_);
3041 align_count = (4 - ((size + RXW_PADDING) % 4)) % 4;
3042
3043 if (unlikely(rx_cmd_a & RX_CMD_A_RED_)) {
3044 netif_dbg(dev, rx_err, dev->net,
3045 "Error rx_cmd_a=0x%08x", rx_cmd_a);
3046 } else {
3047 /* last frame in this batch */
3048 if (skb->len == size) {
3049 lan78xx_rx_csum_offload(dev, skb,
3050 rx_cmd_a, rx_cmd_b);
3051 lan78xx_rx_vlan_offload(dev, skb,
3052 rx_cmd_a, rx_cmd_b);
3053
3054 skb_trim(skb, skb->len - 4); /* remove fcs */
3055 skb->truesize = size + sizeof(struct sk_buff);
3056
3057 return 1;
3058 }
3059
3060 skb2 = skb_clone(skb, GFP_ATOMIC);
3061 if (unlikely(!skb2)) {
3062 netdev_warn(dev->net, "Error allocating skb");
3063 return 0;
3064 }
3065
3066 skb2->len = size;
3067 skb2->data = packet;
3068 skb_set_tail_pointer(skb2, size);
3069
3070 lan78xx_rx_csum_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
3071 lan78xx_rx_vlan_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
3072
3073 skb_trim(skb2, skb2->len - 4); /* remove fcs */
3074 skb2->truesize = size + sizeof(struct sk_buff);
3075
3076 lan78xx_skb_return(dev, skb2);
3077 }
3078
3079 skb_pull(skb, size);
3080
3081 /* padding bytes before the next frame starts */
3082 if (skb->len)
3083 skb_pull(skb, align_count);
3084 }
3085
3086 return 1;
3087 }
3088
3089 static inline void rx_process(struct lan78xx_net *dev, struct sk_buff *skb)
3090 {
3091 if (!lan78xx_rx(dev, skb)) {
3092 dev->net->stats.rx_errors++;
3093 goto done;
3094 }
3095
3096 if (skb->len) {
3097 lan78xx_skb_return(dev, skb);
3098 return;
3099 }
3100
3101 netif_dbg(dev, rx_err, dev->net, "drop\n");
3102 dev->net->stats.rx_errors++;
3103 done:
3104 skb_queue_tail(&dev->done, skb);
3105 }
3106
3107 static void rx_complete(struct urb *urb);
3108
3109 static int rx_submit(struct lan78xx_net *dev, struct urb *urb, gfp_t flags)
3110 {
3111 struct sk_buff *skb;
3112 struct skb_data *entry;
3113 unsigned long lockflags;
3114 size_t size = dev->rx_urb_size;
3115 int ret = 0;
3116
3117 skb = netdev_alloc_skb_ip_align(dev->net, size);
3118 if (!skb) {
3119 usb_free_urb(urb);
3120 return -ENOMEM;
3121 }
3122
3123 entry = (struct skb_data *)skb->cb;
3124 entry->urb = urb;
3125 entry->dev = dev;
3126 entry->length = 0;
3127
3128 usb_fill_bulk_urb(urb, dev->udev, dev->pipe_in,
3129 skb->data, size, rx_complete, skb);
3130
3131 spin_lock_irqsave(&dev->rxq.lock, lockflags);
3132
3133 if (netif_device_present(dev->net) &&
3134 netif_running(dev->net) &&
3135 !test_bit(EVENT_RX_HALT, &dev->flags) &&
3136 !test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3137 ret = usb_submit_urb(urb, GFP_ATOMIC);
3138 switch (ret) {
3139 case 0:
3140 lan78xx_queue_skb(&dev->rxq, skb, rx_start);
3141 break;
3142 case -EPIPE:
3143 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3144 break;
3145 case -ENODEV:
3146 netif_dbg(dev, ifdown, dev->net, "device gone\n");
3147 netif_device_detach(dev->net);
3148 break;
3149 case -EHOSTUNREACH:
3150 ret = -ENOLINK;
3151 break;
3152 default:
3153 netif_dbg(dev, rx_err, dev->net,
3154 "rx submit, %d\n", ret);
3155 tasklet_schedule(&dev->bh);
3156 }
3157 } else {
3158 netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
3159 ret = -ENOLINK;
3160 }
3161 spin_unlock_irqrestore(&dev->rxq.lock, lockflags);
3162 if (ret) {
3163 dev_kfree_skb_any(skb);
3164 usb_free_urb(urb);
3165 }
3166 return ret;
3167 }
3168
3169 static void rx_complete(struct urb *urb)
3170 {
3171 struct sk_buff *skb = (struct sk_buff *)urb->context;
3172 struct skb_data *entry = (struct skb_data *)skb->cb;
3173 struct lan78xx_net *dev = entry->dev;
3174 int urb_status = urb->status;
3175 enum skb_state state;
3176
3177 skb_put(skb, urb->actual_length);
3178 state = rx_done;
3179 entry->urb = NULL;
3180
3181 switch (urb_status) {
3182 case 0:
3183 if (skb->len < dev->net->hard_header_len) {
3184 state = rx_cleanup;
3185 dev->net->stats.rx_errors++;
3186 dev->net->stats.rx_length_errors++;
3187 netif_dbg(dev, rx_err, dev->net,
3188 "rx length %d\n", skb->len);
3189 }
3190 usb_mark_last_busy(dev->udev);
3191 break;
3192 case -EPIPE:
3193 dev->net->stats.rx_errors++;
3194 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3195 /* FALLTHROUGH */
3196 case -ECONNRESET: /* async unlink */
3197 case -ESHUTDOWN: /* hardware gone */
3198 netif_dbg(dev, ifdown, dev->net,
3199 "rx shutdown, code %d\n", urb_status);
3200 state = rx_cleanup;
3201 entry->urb = urb;
3202 urb = NULL;
3203 break;
3204 case -EPROTO:
3205 case -ETIME:
3206 case -EILSEQ:
3207 dev->net->stats.rx_errors++;
3208 state = rx_cleanup;
3209 entry->urb = urb;
3210 urb = NULL;
3211 break;
3212
3213 /* data overrun ... flush fifo? */
3214 case -EOVERFLOW:
3215 dev->net->stats.rx_over_errors++;
3216 /* FALLTHROUGH */
3217
3218 default:
3219 state = rx_cleanup;
3220 dev->net->stats.rx_errors++;
3221 netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
3222 break;
3223 }
3224
3225 state = defer_bh(dev, skb, &dev->rxq, state);
3226
3227 if (urb) {
3228 if (netif_running(dev->net) &&
3229 !test_bit(EVENT_RX_HALT, &dev->flags) &&
3230 state != unlink_start) {
3231 rx_submit(dev, urb, GFP_ATOMIC);
3232 return;
3233 }
3234 usb_free_urb(urb);
3235 }
3236 netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n");
3237 }
3238
3239 static void lan78xx_tx_bh(struct lan78xx_net *dev)
3240 {
3241 int length;
3242 struct urb *urb = NULL;
3243 struct skb_data *entry;
3244 unsigned long flags;
3245 struct sk_buff_head *tqp = &dev->txq_pend;
3246 struct sk_buff *skb, *skb2;
3247 int ret;
3248 int count, pos;
3249 int skb_totallen, pkt_cnt;
3250
3251 skb_totallen = 0;
3252 pkt_cnt = 0;
3253 count = 0;
3254 length = 0;
3255 spin_lock_irqsave(&tqp->lock, flags);
3256 skb_queue_walk(tqp, skb) {
3257 if (skb_is_gso(skb)) {
3258 if (!skb_queue_is_first(tqp, skb)) {
3259 /* handle previous packets first */
3260 break;
3261 }
3262 count = 1;
3263 length = skb->len - TX_OVERHEAD;
3264 __skb_unlink(skb, tqp);
3265 spin_unlock_irqrestore(&tqp->lock, flags);
3266 goto gso_skb;
3267 }
3268
3269 if ((skb_totallen + skb->len) > MAX_SINGLE_PACKET_SIZE)
3270 break;
3271 skb_totallen = skb->len + roundup(skb_totallen, sizeof(u32));
3272 pkt_cnt++;
3273 }
3274 spin_unlock_irqrestore(&tqp->lock, flags);
3275
3276 /* copy to a single skb */
3277 skb = alloc_skb(skb_totallen, GFP_ATOMIC);
3278 if (!skb)
3279 goto drop;
3280
3281 skb_put(skb, skb_totallen);
3282
3283 for (count = pos = 0; count < pkt_cnt; count++) {
3284 skb2 = skb_dequeue(tqp);
3285 if (skb2) {
3286 length += (skb2->len - TX_OVERHEAD);
3287 memcpy(skb->data + pos, skb2->data, skb2->len);
3288 pos += roundup(skb2->len, sizeof(u32));
3289 dev_kfree_skb(skb2);
3290 }
3291 }
3292
3293 gso_skb:
3294 urb = usb_alloc_urb(0, GFP_ATOMIC);
3295 if (!urb)
3296 goto drop;
3297
3298 entry = (struct skb_data *)skb->cb;
3299 entry->urb = urb;
3300 entry->dev = dev;
3301 entry->length = length;
3302 entry->num_of_packet = count;
3303
3304 spin_lock_irqsave(&dev->txq.lock, flags);
3305 ret = usb_autopm_get_interface_async(dev->intf);
3306 if (ret < 0) {
3307 spin_unlock_irqrestore(&dev->txq.lock, flags);
3308 goto drop;
3309 }
3310
3311 usb_fill_bulk_urb(urb, dev->udev, dev->pipe_out,
3312 skb->data, skb->len, tx_complete, skb);
3313
3314 if (length % dev->maxpacket == 0) {
3315 /* send USB_ZERO_PACKET */
3316 urb->transfer_flags |= URB_ZERO_PACKET;
3317 }
3318
3319 #ifdef CONFIG_PM
3320 /* if this triggers the device is still a sleep */
3321 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3322 /* transmission will be done in resume */
3323 usb_anchor_urb(urb, &dev->deferred);
3324 /* no use to process more packets */
3325 netif_stop_queue(dev->net);
3326 usb_put_urb(urb);
3327 spin_unlock_irqrestore(&dev->txq.lock, flags);
3328 netdev_dbg(dev->net, "Delaying transmission for resumption\n");
3329 return;
3330 }
3331 #endif
3332
3333 ret = usb_submit_urb(urb, GFP_ATOMIC);
3334 switch (ret) {
3335 case 0:
3336 netif_trans_update(dev->net);
3337 lan78xx_queue_skb(&dev->txq, skb, tx_start);
3338 if (skb_queue_len(&dev->txq) >= dev->tx_qlen)
3339 netif_stop_queue(dev->net);
3340 break;
3341 case -EPIPE:
3342 netif_stop_queue(dev->net);
3343 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
3344 usb_autopm_put_interface_async(dev->intf);
3345 break;
3346 default:
3347 usb_autopm_put_interface_async(dev->intf);
3348 netif_dbg(dev, tx_err, dev->net,
3349 "tx: submit urb err %d\n", ret);
3350 break;
3351 }
3352
3353 spin_unlock_irqrestore(&dev->txq.lock, flags);
3354
3355 if (ret) {
3356 netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", ret);
3357 drop:
3358 dev->net->stats.tx_dropped++;
3359 if (skb)
3360 dev_kfree_skb_any(skb);
3361 usb_free_urb(urb);
3362 } else
3363 netif_dbg(dev, tx_queued, dev->net,
3364 "> tx, len %d, type 0x%x\n", length, skb->protocol);
3365 }
3366
3367 static void lan78xx_rx_bh(struct lan78xx_net *dev)
3368 {
3369 struct urb *urb;
3370 int i;
3371
3372 if (skb_queue_len(&dev->rxq) < dev->rx_qlen) {
3373 for (i = 0; i < 10; i++) {
3374 if (skb_queue_len(&dev->rxq) >= dev->rx_qlen)
3375 break;
3376 urb = usb_alloc_urb(0, GFP_ATOMIC);
3377 if (urb)
3378 if (rx_submit(dev, urb, GFP_ATOMIC) == -ENOLINK)
3379 return;
3380 }
3381
3382 if (skb_queue_len(&dev->rxq) < dev->rx_qlen)
3383 tasklet_schedule(&dev->bh);
3384 }
3385 if (skb_queue_len(&dev->txq) < dev->tx_qlen)
3386 netif_wake_queue(dev->net);
3387 }
3388
3389 static void lan78xx_bh(unsigned long param)
3390 {
3391 struct lan78xx_net *dev = (struct lan78xx_net *)param;
3392 struct sk_buff *skb;
3393 struct skb_data *entry;
3394
3395 while ((skb = skb_dequeue(&dev->done))) {
3396 entry = (struct skb_data *)(skb->cb);
3397 switch (entry->state) {
3398 case rx_done:
3399 entry->state = rx_cleanup;
3400 rx_process(dev, skb);
3401 continue;
3402 case tx_done:
3403 usb_free_urb(entry->urb);
3404 dev_kfree_skb(skb);
3405 continue;
3406 case rx_cleanup:
3407 usb_free_urb(entry->urb);
3408 dev_kfree_skb(skb);
3409 continue;
3410 default:
3411 netdev_dbg(dev->net, "skb state %d\n", entry->state);
3412 return;
3413 }
3414 }
3415
3416 if (netif_device_present(dev->net) && netif_running(dev->net)) {
3417 /* reset update timer delta */
3418 if (timer_pending(&dev->stat_monitor) && (dev->delta != 1)) {
3419 dev->delta = 1;
3420 mod_timer(&dev->stat_monitor,
3421 jiffies + STAT_UPDATE_TIMER);
3422 }
3423
3424 if (!skb_queue_empty(&dev->txq_pend))
3425 lan78xx_tx_bh(dev);
3426
3427 if (!timer_pending(&dev->delay) &&
3428 !test_bit(EVENT_RX_HALT, &dev->flags))
3429 lan78xx_rx_bh(dev);
3430 }
3431 }
3432
3433 static void lan78xx_delayedwork(struct work_struct *work)
3434 {
3435 int status;
3436 struct lan78xx_net *dev;
3437
3438 dev = container_of(work, struct lan78xx_net, wq.work);
3439
3440 if (test_bit(EVENT_TX_HALT, &dev->flags)) {
3441 unlink_urbs(dev, &dev->txq);
3442 status = usb_autopm_get_interface(dev->intf);
3443 if (status < 0)
3444 goto fail_pipe;
3445 status = usb_clear_halt(dev->udev, dev->pipe_out);
3446 usb_autopm_put_interface(dev->intf);
3447 if (status < 0 &&
3448 status != -EPIPE &&
3449 status != -ESHUTDOWN) {
3450 if (netif_msg_tx_err(dev))
3451 fail_pipe:
3452 netdev_err(dev->net,
3453 "can't clear tx halt, status %d\n",
3454 status);
3455 } else {
3456 clear_bit(EVENT_TX_HALT, &dev->flags);
3457 if (status != -ESHUTDOWN)
3458 netif_wake_queue(dev->net);
3459 }
3460 }
3461 if (test_bit(EVENT_RX_HALT, &dev->flags)) {
3462 unlink_urbs(dev, &dev->rxq);
3463 status = usb_autopm_get_interface(dev->intf);
3464 if (status < 0)
3465 goto fail_halt;
3466 status = usb_clear_halt(dev->udev, dev->pipe_in);
3467 usb_autopm_put_interface(dev->intf);
3468 if (status < 0 &&
3469 status != -EPIPE &&
3470 status != -ESHUTDOWN) {
3471 if (netif_msg_rx_err(dev))
3472 fail_halt:
3473 netdev_err(dev->net,
3474 "can't clear rx halt, status %d\n",
3475 status);
3476 } else {
3477 clear_bit(EVENT_RX_HALT, &dev->flags);
3478 tasklet_schedule(&dev->bh);
3479 }
3480 }
3481
3482 if (test_bit(EVENT_LINK_RESET, &dev->flags)) {
3483 int ret = 0;
3484
3485 clear_bit(EVENT_LINK_RESET, &dev->flags);
3486 status = usb_autopm_get_interface(dev->intf);
3487 if (status < 0)
3488 goto skip_reset;
3489 if (lan78xx_link_reset(dev) < 0) {
3490 usb_autopm_put_interface(dev->intf);
3491 skip_reset:
3492 netdev_info(dev->net, "link reset failed (%d)\n",
3493 ret);
3494 } else {
3495 usb_autopm_put_interface(dev->intf);
3496 }
3497 }
3498
3499 if (test_bit(EVENT_STAT_UPDATE, &dev->flags)) {
3500 lan78xx_update_stats(dev);
3501
3502 clear_bit(EVENT_STAT_UPDATE, &dev->flags);
3503
3504 mod_timer(&dev->stat_monitor,
3505 jiffies + (STAT_UPDATE_TIMER * dev->delta));
3506
3507 dev->delta = min((dev->delta * 2), 50);
3508 }
3509 }
3510
3511 static void intr_complete(struct urb *urb)
3512 {
3513 struct lan78xx_net *dev = urb->context;
3514 int status = urb->status;
3515
3516 switch (status) {
3517 /* success */
3518 case 0:
3519 lan78xx_status(dev, urb);
3520 break;
3521
3522 /* software-driven interface shutdown */
3523 case -ENOENT: /* urb killed */
3524 case -ESHUTDOWN: /* hardware gone */
3525 netif_dbg(dev, ifdown, dev->net,
3526 "intr shutdown, code %d\n", status);
3527 return;
3528
3529 /* NOTE: not throttling like RX/TX, since this endpoint
3530 * already polls infrequently
3531 */
3532 default:
3533 netdev_dbg(dev->net, "intr status %d\n", status);
3534 break;
3535 }
3536
3537 if (!netif_running(dev->net))
3538 return;
3539
3540 memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
3541 status = usb_submit_urb(urb, GFP_ATOMIC);
3542 if (status != 0)
3543 netif_err(dev, timer, dev->net,
3544 "intr resubmit --> %d\n", status);
3545 }
3546
3547 static void lan78xx_disconnect(struct usb_interface *intf)
3548 {
3549 struct lan78xx_net *dev;
3550 struct usb_device *udev;
3551 struct net_device *net;
3552 struct phy_device *phydev;
3553
3554 dev = usb_get_intfdata(intf);
3555 usb_set_intfdata(intf, NULL);
3556 if (!dev)
3557 return;
3558
3559 udev = interface_to_usbdev(intf);
3560 net = dev->net;
3561 phydev = net->phydev;
3562
3563 phy_unregister_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0);
3564 phy_unregister_fixup_for_uid(PHY_LAN8835, 0xfffffff0);
3565
3566 phy_disconnect(net->phydev);
3567
3568 if (phy_is_pseudo_fixed_link(phydev))
3569 fixed_phy_unregister(phydev);
3570
3571 unregister_netdev(net);
3572
3573 cancel_delayed_work_sync(&dev->wq);
3574
3575 usb_scuttle_anchored_urbs(&dev->deferred);
3576
3577 lan78xx_unbind(dev, intf);
3578
3579 usb_kill_urb(dev->urb_intr);
3580 usb_free_urb(dev->urb_intr);
3581
3582 free_netdev(net);
3583 usb_put_dev(udev);
3584 }
3585
3586 static void lan78xx_tx_timeout(struct net_device *net, unsigned int txqueue)
3587 {
3588 struct lan78xx_net *dev = netdev_priv(net);
3589
3590 unlink_urbs(dev, &dev->txq);
3591 tasklet_schedule(&dev->bh);
3592 }
3593
3594 static netdev_features_t lan78xx_features_check(struct sk_buff *skb,
3595 struct net_device *netdev,
3596 netdev_features_t features)
3597 {
3598 if (skb->len + TX_OVERHEAD > MAX_SINGLE_PACKET_SIZE)
3599 features &= ~NETIF_F_GSO_MASK;
3600
3601 features = vlan_features_check(skb, features);
3602 features = vxlan_features_check(skb, features);
3603
3604 return features;
3605 }
3606
3607 static const struct net_device_ops lan78xx_netdev_ops = {
3608 .ndo_open = lan78xx_open,
3609 .ndo_stop = lan78xx_stop,
3610 .ndo_start_xmit = lan78xx_start_xmit,
3611 .ndo_tx_timeout = lan78xx_tx_timeout,
3612 .ndo_change_mtu = lan78xx_change_mtu,
3613 .ndo_set_mac_address = lan78xx_set_mac_addr,
3614 .ndo_validate_addr = eth_validate_addr,
3615 .ndo_do_ioctl = phy_do_ioctl_running,
3616 .ndo_set_rx_mode = lan78xx_set_multicast,
3617 .ndo_set_features = lan78xx_set_features,
3618 .ndo_vlan_rx_add_vid = lan78xx_vlan_rx_add_vid,
3619 .ndo_vlan_rx_kill_vid = lan78xx_vlan_rx_kill_vid,
3620 .ndo_features_check = lan78xx_features_check,
3621 };
3622
3623 static void lan78xx_stat_monitor(struct timer_list *t)
3624 {
3625 struct lan78xx_net *dev = from_timer(dev, t, stat_monitor);
3626
3627 lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE);
3628 }
3629
3630 static int lan78xx_probe(struct usb_interface *intf,
3631 const struct usb_device_id *id)
3632 {
3633 struct usb_host_endpoint *ep_blkin, *ep_blkout, *ep_intr;
3634 struct lan78xx_net *dev;
3635 struct net_device *netdev;
3636 struct usb_device *udev;
3637 int ret;
3638 unsigned maxp;
3639 unsigned period;
3640 u8 *buf = NULL;
3641
3642 udev = interface_to_usbdev(intf);
3643 udev = usb_get_dev(udev);
3644
3645 netdev = alloc_etherdev(sizeof(struct lan78xx_net));
3646 if (!netdev) {
3647 dev_err(&intf->dev, "Error: OOM\n");
3648 ret = -ENOMEM;
3649 goto out1;
3650 }
3651
3652 /* netdev_printk() needs this */
3653 SET_NETDEV_DEV(netdev, &intf->dev);
3654
3655 dev = netdev_priv(netdev);
3656 dev->udev = udev;
3657 dev->intf = intf;
3658 dev->net = netdev;
3659 dev->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
3660 | NETIF_MSG_PROBE | NETIF_MSG_LINK);
3661
3662 skb_queue_head_init(&dev->rxq);
3663 skb_queue_head_init(&dev->txq);
3664 skb_queue_head_init(&dev->done);
3665 skb_queue_head_init(&dev->rxq_pause);
3666 skb_queue_head_init(&dev->txq_pend);
3667 mutex_init(&dev->phy_mutex);
3668
3669 tasklet_init(&dev->bh, lan78xx_bh, (unsigned long)dev);
3670 INIT_DELAYED_WORK(&dev->wq, lan78xx_delayedwork);
3671 init_usb_anchor(&dev->deferred);
3672
3673 netdev->netdev_ops = &lan78xx_netdev_ops;
3674 netdev->watchdog_timeo = TX_TIMEOUT_JIFFIES;
3675 netdev->ethtool_ops = &lan78xx_ethtool_ops;
3676
3677 dev->delta = 1;
3678 timer_setup(&dev->stat_monitor, lan78xx_stat_monitor, 0);
3679
3680 mutex_init(&dev->stats.access_lock);
3681
3682 if (intf->cur_altsetting->desc.bNumEndpoints < 3) {
3683 ret = -ENODEV;
3684 goto out2;
3685 }
3686
3687 dev->pipe_in = usb_rcvbulkpipe(udev, BULK_IN_PIPE);
3688 ep_blkin = usb_pipe_endpoint(udev, dev->pipe_in);
3689 if (!ep_blkin || !usb_endpoint_is_bulk_in(&ep_blkin->desc)) {
3690 ret = -ENODEV;
3691 goto out2;
3692 }
3693
3694 dev->pipe_out = usb_sndbulkpipe(udev, BULK_OUT_PIPE);
3695 ep_blkout = usb_pipe_endpoint(udev, dev->pipe_out);
3696 if (!ep_blkout || !usb_endpoint_is_bulk_out(&ep_blkout->desc)) {
3697 ret = -ENODEV;
3698 goto out2;
3699 }
3700
3701 ep_intr = &intf->cur_altsetting->endpoint[2];
3702 if (!usb_endpoint_is_int_in(&ep_intr->desc)) {
3703 ret = -ENODEV;
3704 goto out2;
3705 }
3706
3707 dev->pipe_intr = usb_rcvintpipe(dev->udev,
3708 usb_endpoint_num(&ep_intr->desc));
3709
3710 ret = lan78xx_bind(dev, intf);
3711 if (ret < 0)
3712 goto out2;
3713
3714 if (netdev->mtu > (dev->hard_mtu - netdev->hard_header_len))
3715 netdev->mtu = dev->hard_mtu - netdev->hard_header_len;
3716
3717 /* MTU range: 68 - 9000 */
3718 netdev->max_mtu = MAX_SINGLE_PACKET_SIZE;
3719 netif_set_gso_max_size(netdev, MAX_SINGLE_PACKET_SIZE - MAX_HEADER);
3720
3721 period = ep_intr->desc.bInterval;
3722 maxp = usb_maxpacket(dev->udev, dev->pipe_intr, 0);
3723 buf = kmalloc(maxp, GFP_KERNEL);
3724 if (buf) {
3725 dev->urb_intr = usb_alloc_urb(0, GFP_KERNEL);
3726 if (!dev->urb_intr) {
3727 ret = -ENOMEM;
3728 kfree(buf);
3729 goto out3;
3730 } else {
3731 usb_fill_int_urb(dev->urb_intr, dev->udev,
3732 dev->pipe_intr, buf, maxp,
3733 intr_complete, dev, period);
3734 dev->urb_intr->transfer_flags |= URB_FREE_BUFFER;
3735 }
3736 }
3737
3738 dev->maxpacket = usb_maxpacket(dev->udev, dev->pipe_out, 1);
3739
3740 /* driver requires remote-wakeup capability during autosuspend. */
3741 intf->needs_remote_wakeup = 1;
3742
3743 ret = lan78xx_phy_init(dev);
3744 if (ret < 0)
3745 goto out4;
3746
3747 ret = register_netdev(netdev);
3748 if (ret != 0) {
3749 netif_err(dev, probe, netdev, "couldn't register the device\n");
3750 goto out5;
3751 }
3752
3753 usb_set_intfdata(intf, dev);
3754
3755 ret = device_set_wakeup_enable(&udev->dev, true);
3756
3757 /* Default delay of 2sec has more overhead than advantage.
3758 * Set to 10sec as default.
3759 */
3760 pm_runtime_set_autosuspend_delay(&udev->dev,
3761 DEFAULT_AUTOSUSPEND_DELAY);
3762
3763 return 0;
3764
3765 out5:
3766 phy_disconnect(netdev->phydev);
3767 out4:
3768 usb_free_urb(dev->urb_intr);
3769 out3:
3770 lan78xx_unbind(dev, intf);
3771 out2:
3772 free_netdev(netdev);
3773 out1:
3774 usb_put_dev(udev);
3775
3776 return ret;
3777 }
3778
3779 static u16 lan78xx_wakeframe_crc16(const u8 *buf, int len)
3780 {
3781 const u16 crc16poly = 0x8005;
3782 int i;
3783 u16 bit, crc, msb;
3784 u8 data;
3785
3786 crc = 0xFFFF;
3787 for (i = 0; i < len; i++) {
3788 data = *buf++;
3789 for (bit = 0; bit < 8; bit++) {
3790 msb = crc >> 15;
3791 crc <<= 1;
3792
3793 if (msb ^ (u16)(data & 1)) {
3794 crc ^= crc16poly;
3795 crc |= (u16)0x0001U;
3796 }
3797 data >>= 1;
3798 }
3799 }
3800
3801 return crc;
3802 }
3803
3804 static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
3805 {
3806 u32 buf;
3807 int ret;
3808 int mask_index;
3809 u16 crc;
3810 u32 temp_wucsr;
3811 u32 temp_pmt_ctl;
3812 const u8 ipv4_multicast[3] = { 0x01, 0x00, 0x5E };
3813 const u8 ipv6_multicast[3] = { 0x33, 0x33 };
3814 const u8 arp_type[2] = { 0x08, 0x06 };
3815
3816 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3817 buf &= ~MAC_TX_TXEN_;
3818 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3819 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3820 buf &= ~MAC_RX_RXEN_;
3821 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3822
3823 ret = lan78xx_write_reg(dev, WUCSR, 0);
3824 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3825 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3826
3827 temp_wucsr = 0;
3828
3829 temp_pmt_ctl = 0;
3830 ret = lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl);
3831 temp_pmt_ctl &= ~PMT_CTL_RES_CLR_WKP_EN_;
3832 temp_pmt_ctl |= PMT_CTL_RES_CLR_WKP_STS_;
3833
3834 for (mask_index = 0; mask_index < NUM_OF_WUF_CFG; mask_index++)
3835 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), 0);
3836
3837 mask_index = 0;
3838 if (wol & WAKE_PHY) {
3839 temp_pmt_ctl |= PMT_CTL_PHY_WAKE_EN_;
3840
3841 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3842 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3843 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3844 }
3845 if (wol & WAKE_MAGIC) {
3846 temp_wucsr |= WUCSR_MPEN_;
3847
3848 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3849 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3850 temp_pmt_ctl |= PMT_CTL_SUS_MODE_3_;
3851 }
3852 if (wol & WAKE_BCAST) {
3853 temp_wucsr |= WUCSR_BCST_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_MCAST) {
3860 temp_wucsr |= WUCSR_WAKE_EN_;
3861
3862 /* set WUF_CFG & WUF_MASK for IPv4 Multicast */
3863 crc = lan78xx_wakeframe_crc16(ipv4_multicast, 3);
3864 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3865 WUF_CFGX_EN_ |
3866 WUF_CFGX_TYPE_MCAST_ |
3867 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3868 (crc & WUF_CFGX_CRC16_MASK_));
3869
3870 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7);
3871 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3872 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3873 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3874 mask_index++;
3875
3876 /* for IPv6 Multicast */
3877 crc = lan78xx_wakeframe_crc16(ipv6_multicast, 2);
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), 3);
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 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3891 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3892 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3893 }
3894 if (wol & WAKE_UCAST) {
3895 temp_wucsr |= WUCSR_PFDA_EN_;
3896
3897 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3898 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3899 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3900 }
3901 if (wol & WAKE_ARP) {
3902 temp_wucsr |= WUCSR_WAKE_EN_;
3903
3904 /* set WUF_CFG & WUF_MASK
3905 * for packettype (offset 12,13) = ARP (0x0806)
3906 */
3907 crc = lan78xx_wakeframe_crc16(arp_type, 2);
3908 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3909 WUF_CFGX_EN_ |
3910 WUF_CFGX_TYPE_ALL_ |
3911 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3912 (crc & WUF_CFGX_CRC16_MASK_));
3913
3914 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000);
3915 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3916 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3917 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3918 mask_index++;
3919
3920 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3921 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3922 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3923 }
3924
3925 ret = lan78xx_write_reg(dev, WUCSR, temp_wucsr);
3926
3927 /* when multiple WOL bits are set */
3928 if (hweight_long((unsigned long)wol) > 1) {
3929 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3930 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3931 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3932 }
3933 ret = lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl);
3934
3935 /* clear WUPS */
3936 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3937 buf |= PMT_CTL_WUPS_MASK_;
3938 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3939
3940 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3941 buf |= MAC_RX_RXEN_;
3942 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3943
3944 return 0;
3945 }
3946
3947 static int lan78xx_suspend(struct usb_interface *intf, pm_message_t message)
3948 {
3949 struct lan78xx_net *dev = usb_get_intfdata(intf);
3950 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
3951 u32 buf;
3952 int ret;
3953
3954 if (!dev->suspend_count++) {
3955 spin_lock_irq(&dev->txq.lock);
3956 /* don't autosuspend while transmitting */
3957 if ((skb_queue_len(&dev->txq) ||
3958 skb_queue_len(&dev->txq_pend)) &&
3959 PMSG_IS_AUTO(message)) {
3960 spin_unlock_irq(&dev->txq.lock);
3961 ret = -EBUSY;
3962 goto out;
3963 } else {
3964 set_bit(EVENT_DEV_ASLEEP, &dev->flags);
3965 spin_unlock_irq(&dev->txq.lock);
3966 }
3967
3968 /* stop TX & RX */
3969 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3970 buf &= ~MAC_TX_TXEN_;
3971 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3972 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3973 buf &= ~MAC_RX_RXEN_;
3974 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3975
3976 /* empty out the rx and queues */
3977 netif_device_detach(dev->net);
3978 lan78xx_terminate_urbs(dev);
3979 usb_kill_urb(dev->urb_intr);
3980
3981 /* reattach */
3982 netif_device_attach(dev->net);
3983 }
3984
3985 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3986 del_timer(&dev->stat_monitor);
3987
3988 if (PMSG_IS_AUTO(message)) {
3989 /* auto suspend (selective suspend) */
3990 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3991 buf &= ~MAC_TX_TXEN_;
3992 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3993 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3994 buf &= ~MAC_RX_RXEN_;
3995 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3996
3997 ret = lan78xx_write_reg(dev, WUCSR, 0);
3998 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3999 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4000
4001 /* set goodframe wakeup */
4002 ret = lan78xx_read_reg(dev, WUCSR, &buf);
4003
4004 buf |= WUCSR_RFE_WAKE_EN_;
4005 buf |= WUCSR_STORE_WAKE_;
4006
4007 ret = lan78xx_write_reg(dev, WUCSR, buf);
4008
4009 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4010
4011 buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
4012 buf |= PMT_CTL_RES_CLR_WKP_STS_;
4013
4014 buf |= PMT_CTL_PHY_WAKE_EN_;
4015 buf |= PMT_CTL_WOL_EN_;
4016 buf &= ~PMT_CTL_SUS_MODE_MASK_;
4017 buf |= PMT_CTL_SUS_MODE_3_;
4018
4019 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4020
4021 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4022
4023 buf |= PMT_CTL_WUPS_MASK_;
4024
4025 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4026
4027 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
4028 buf |= MAC_RX_RXEN_;
4029 ret = lan78xx_write_reg(dev, MAC_RX, buf);
4030 } else {
4031 lan78xx_set_suspend(dev, pdata->wol);
4032 }
4033 }
4034
4035 ret = 0;
4036 out:
4037 return ret;
4038 }
4039
4040 static int lan78xx_resume(struct usb_interface *intf)
4041 {
4042 struct lan78xx_net *dev = usb_get_intfdata(intf);
4043 struct sk_buff *skb;
4044 struct urb *res;
4045 int ret;
4046 u32 buf;
4047
4048 if (!timer_pending(&dev->stat_monitor)) {
4049 dev->delta = 1;
4050 mod_timer(&dev->stat_monitor,
4051 jiffies + STAT_UPDATE_TIMER);
4052 }
4053
4054 if (!--dev->suspend_count) {
4055 /* resume interrupt URBs */
4056 if (dev->urb_intr && test_bit(EVENT_DEV_OPEN, &dev->flags))
4057 usb_submit_urb(dev->urb_intr, GFP_NOIO);
4058
4059 spin_lock_irq(&dev->txq.lock);
4060 while ((res = usb_get_from_anchor(&dev->deferred))) {
4061 skb = (struct sk_buff *)res->context;
4062 ret = usb_submit_urb(res, GFP_ATOMIC);
4063 if (ret < 0) {
4064 dev_kfree_skb_any(skb);
4065 usb_free_urb(res);
4066 usb_autopm_put_interface_async(dev->intf);
4067 } else {
4068 netif_trans_update(dev->net);
4069 lan78xx_queue_skb(&dev->txq, skb, tx_start);
4070 }
4071 }
4072
4073 clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
4074 spin_unlock_irq(&dev->txq.lock);
4075
4076 if (test_bit(EVENT_DEV_OPEN, &dev->flags)) {
4077 if (!(skb_queue_len(&dev->txq) >= dev->tx_qlen))
4078 netif_start_queue(dev->net);
4079 tasklet_schedule(&dev->bh);
4080 }
4081 }
4082
4083 ret = lan78xx_write_reg(dev, WUCSR2, 0);
4084 ret = lan78xx_write_reg(dev, WUCSR, 0);
4085 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4086
4087 ret = lan78xx_write_reg(dev, WUCSR2, WUCSR2_NS_RCD_ |
4088 WUCSR2_ARP_RCD_ |
4089 WUCSR2_IPV6_TCPSYN_RCD_ |
4090 WUCSR2_IPV4_TCPSYN_RCD_);
4091
4092 ret = lan78xx_write_reg(dev, WUCSR, WUCSR_EEE_TX_WAKE_ |
4093 WUCSR_EEE_RX_WAKE_ |
4094 WUCSR_PFDA_FR_ |
4095 WUCSR_RFE_WAKE_FR_ |
4096 WUCSR_WUFR_ |
4097 WUCSR_MPR_ |
4098 WUCSR_BCST_FR_);
4099
4100 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
4101 buf |= MAC_TX_TXEN_;
4102 ret = lan78xx_write_reg(dev, MAC_TX, buf);
4103
4104 return 0;
4105 }
4106
4107 static int lan78xx_reset_resume(struct usb_interface *intf)
4108 {
4109 struct lan78xx_net *dev = usb_get_intfdata(intf);
4110
4111 lan78xx_reset(dev);
4112
4113 phy_start(dev->net->phydev);
4114
4115 return lan78xx_resume(intf);
4116 }
4117
4118 static const struct usb_device_id products[] = {
4119 {
4120 /* LAN7800 USB Gigabit Ethernet Device */
4121 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7800_USB_PRODUCT_ID),
4122 },
4123 {
4124 /* LAN7850 USB Gigabit Ethernet Device */
4125 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7850_USB_PRODUCT_ID),
4126 },
4127 {
4128 /* LAN7801 USB Gigabit Ethernet Device */
4129 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7801_USB_PRODUCT_ID),
4130 },
4131 {},
4132 };
4133 MODULE_DEVICE_TABLE(usb, products);
4134
4135 static struct usb_driver lan78xx_driver = {
4136 .name = DRIVER_NAME,
4137 .id_table = products,
4138 .probe = lan78xx_probe,
4139 .disconnect = lan78xx_disconnect,
4140 .suspend = lan78xx_suspend,
4141 .resume = lan78xx_resume,
4142 .reset_resume = lan78xx_reset_resume,
4143 .supports_autosuspend = 1,
4144 .disable_hub_initiated_lpm = 1,
4145 };
4146
4147 module_usb_driver(lan78xx_driver);
4148
4149 MODULE_AUTHOR(DRIVER_AUTHOR);
4150 MODULE_DESCRIPTION(DRIVER_DESC);
4151 MODULE_LICENSE("GPL");
Ubuntu Hirsute Linux kernel mirror