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