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