projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
KVM: x86: zero apic_arb_prio on reset
[deliverable/linux.git] / drivers / net / usb / lan78xx.c
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/mii.h>
23 #include <linux/usb.h>
24 #include <linux/crc32.h>
25 #include <linux/signal.h>
26 #include <linux/slab.h>
27 #include <linux/if_vlan.h>
28 #include <linux/uaccess.h>
29 #include <linux/list.h>
30 #include <linux/ip.h>
31 #include <linux/ipv6.h>
32 #include <linux/mdio.h>
33 #include <net/ip6_checksum.h>
34 #include "lan78xx.h"
35
36 #define DRIVER_AUTHOR "WOOJUNG HUH <woojung.huh@microchip.com>"
37 #define DRIVER_DESC "LAN78XX USB 3.0 Gigabit Ethernet Devices"
38 #define DRIVER_NAME "lan78xx"
39 #define DRIVER_VERSION "1.0.0"
40
41 #define TX_TIMEOUT_JIFFIES (5 * HZ)
42 #define THROTTLE_JIFFIES (HZ / 8)
43 #define UNLINK_TIMEOUT_MS 3
44
45 #define RX_MAX_QUEUE_MEMORY (60 * 1518)
46
47 #define SS_USB_PKT_SIZE (1024)
48 #define HS_USB_PKT_SIZE (512)
49 #define FS_USB_PKT_SIZE (64)
50
51 #define MAX_RX_FIFO_SIZE (12 * 1024)
52 #define MAX_TX_FIFO_SIZE (12 * 1024)
53 #define DEFAULT_BURST_CAP_SIZE (MAX_TX_FIFO_SIZE)
54 #define DEFAULT_BULK_IN_DELAY (0x0800)
55 #define MAX_SINGLE_PACKET_SIZE (9000)
56 #define DEFAULT_TX_CSUM_ENABLE (true)
57 #define DEFAULT_RX_CSUM_ENABLE (true)
58 #define DEFAULT_TSO_CSUM_ENABLE (true)
59 #define DEFAULT_VLAN_FILTER_ENABLE (true)
60 #define INTERNAL_PHY_ID (2) /* 2: GMII */
61 #define TX_OVERHEAD (8)
62 #define RXW_PADDING 2
63
64 #define LAN78XX_USB_VENDOR_ID (0x0424)
65 #define LAN7800_USB_PRODUCT_ID (0x7800)
66 #define LAN7850_USB_PRODUCT_ID (0x7850)
67 #define LAN78XX_EEPROM_MAGIC (0x78A5)
68 #define LAN78XX_OTP_MAGIC (0x78F3)
69
70 #define MII_READ 1
71 #define MII_WRITE 0
72
73 #define EEPROM_INDICATOR (0xA5)
74 #define EEPROM_MAC_OFFSET (0x01)
75 #define MAX_EEPROM_SIZE 512
76 #define OTP_INDICATOR_1 (0xF3)
77 #define OTP_INDICATOR_2 (0xF7)
78
79 #define WAKE_ALL (WAKE_PHY | WAKE_UCAST | \
80 WAKE_MCAST | WAKE_BCAST | \
81 WAKE_ARP | WAKE_MAGIC)
82
83 /* USB related defines */
84 #define BULK_IN_PIPE 1
85 #define BULK_OUT_PIPE 2
86
87 /* default autosuspend delay (mSec)*/
88 #define DEFAULT_AUTOSUSPEND_DELAY (10 * 1000)
89
90 static const char lan78xx_gstrings[][ETH_GSTRING_LEN] = {
91 "RX FCS Errors",
92 "RX Alignment Errors",
93 "Rx Fragment Errors",
94 "RX Jabber Errors",
95 "RX Undersize Frame Errors",
96 "RX Oversize Frame Errors",
97 "RX Dropped Frames",
98 "RX Unicast Byte Count",
99 "RX Broadcast Byte Count",
100 "RX Multicast Byte Count",
101 "RX Unicast Frames",
102 "RX Broadcast Frames",
103 "RX Multicast Frames",
104 "RX Pause Frames",
105 "RX 64 Byte Frames",
106 "RX 65 - 127 Byte Frames",
107 "RX 128 - 255 Byte Frames",
108 "RX 256 - 511 Bytes Frames",
109 "RX 512 - 1023 Byte Frames",
110 "RX 1024 - 1518 Byte Frames",
111 "RX Greater 1518 Byte Frames",
112 "EEE RX LPI Transitions",
113 "EEE RX LPI Time",
114 "TX FCS Errors",
115 "TX Excess Deferral Errors",
116 "TX Carrier Errors",
117 "TX Bad Byte Count",
118 "TX Single Collisions",
119 "TX Multiple Collisions",
120 "TX Excessive Collision",
121 "TX Late Collisions",
122 "TX Unicast Byte Count",
123 "TX Broadcast Byte Count",
124 "TX Multicast Byte Count",
125 "TX Unicast Frames",
126 "TX Broadcast Frames",
127 "TX Multicast Frames",
128 "TX Pause Frames",
129 "TX 64 Byte Frames",
130 "TX 65 - 127 Byte Frames",
131 "TX 128 - 255 Byte Frames",
132 "TX 256 - 511 Bytes Frames",
133 "TX 512 - 1023 Byte Frames",
134 "TX 1024 - 1518 Byte Frames",
135 "TX Greater 1518 Byte Frames",
136 "EEE TX LPI Transitions",
137 "EEE TX LPI Time",
138 };
139
140 struct lan78xx_statstage {
141 u32 rx_fcs_errors;
142 u32 rx_alignment_errors;
143 u32 rx_fragment_errors;
144 u32 rx_jabber_errors;
145 u32 rx_undersize_frame_errors;
146 u32 rx_oversize_frame_errors;
147 u32 rx_dropped_frames;
148 u32 rx_unicast_byte_count;
149 u32 rx_broadcast_byte_count;
150 u32 rx_multicast_byte_count;
151 u32 rx_unicast_frames;
152 u32 rx_broadcast_frames;
153 u32 rx_multicast_frames;
154 u32 rx_pause_frames;
155 u32 rx_64_byte_frames;
156 u32 rx_65_127_byte_frames;
157 u32 rx_128_255_byte_frames;
158 u32 rx_256_511_bytes_frames;
159 u32 rx_512_1023_byte_frames;
160 u32 rx_1024_1518_byte_frames;
161 u32 rx_greater_1518_byte_frames;
162 u32 eee_rx_lpi_transitions;
163 u32 eee_rx_lpi_time;
164 u32 tx_fcs_errors;
165 u32 tx_excess_deferral_errors;
166 u32 tx_carrier_errors;
167 u32 tx_bad_byte_count;
168 u32 tx_single_collisions;
169 u32 tx_multiple_collisions;
170 u32 tx_excessive_collision;
171 u32 tx_late_collisions;
172 u32 tx_unicast_byte_count;
173 u32 tx_broadcast_byte_count;
174 u32 tx_multicast_byte_count;
175 u32 tx_unicast_frames;
176 u32 tx_broadcast_frames;
177 u32 tx_multicast_frames;
178 u32 tx_pause_frames;
179 u32 tx_64_byte_frames;
180 u32 tx_65_127_byte_frames;
181 u32 tx_128_255_byte_frames;
182 u32 tx_256_511_bytes_frames;
183 u32 tx_512_1023_byte_frames;
184 u32 tx_1024_1518_byte_frames;
185 u32 tx_greater_1518_byte_frames;
186 u32 eee_tx_lpi_transitions;
187 u32 eee_tx_lpi_time;
188 };
189
190 struct lan78xx_net;
191
192 struct lan78xx_priv {
193 struct lan78xx_net *dev;
194 u32 rfe_ctl;
195 u32 mchash_table[DP_SEL_VHF_HASH_LEN]; /* multicat hash table */
196 u32 pfilter_table[NUM_OF_MAF][2]; /* perfect filter table */
197 u32 vlan_table[DP_SEL_VHF_VLAN_LEN];
198 struct mutex dataport_mutex; /* for dataport access */
199 spinlock_t rfe_ctl_lock; /* for rfe register access */
200 struct work_struct set_multicast;
201 struct work_struct set_vlan;
202 u32 wol;
203 };
204
205 enum skb_state {
206 illegal = 0,
207 tx_start,
208 tx_done,
209 rx_start,
210 rx_done,
211 rx_cleanup,
212 unlink_start
213 };
214
215 struct skb_data { /* skb->cb is one of these */
216 struct urb *urb;
217 struct lan78xx_net *dev;
218 enum skb_state state;
219 size_t length;
220 };
221
222 struct usb_context {
223 struct usb_ctrlrequest req;
224 struct lan78xx_net *dev;
225 };
226
227 #define EVENT_TX_HALT 0
228 #define EVENT_RX_HALT 1
229 #define EVENT_RX_MEMORY 2
230 #define EVENT_STS_SPLIT 3
231 #define EVENT_LINK_RESET 4
232 #define EVENT_RX_PAUSED 5
233 #define EVENT_DEV_WAKING 6
234 #define EVENT_DEV_ASLEEP 7
235 #define EVENT_DEV_OPEN 8
236
237 struct lan78xx_net {
238 struct net_device *net;
239 struct usb_device *udev;
240 struct usb_interface *intf;
241 void *driver_priv;
242
243 int rx_qlen;
244 int tx_qlen;
245 struct sk_buff_head rxq;
246 struct sk_buff_head txq;
247 struct sk_buff_head done;
248 struct sk_buff_head rxq_pause;
249 struct sk_buff_head txq_pend;
250
251 struct tasklet_struct bh;
252 struct delayed_work wq;
253
254 struct usb_host_endpoint *ep_blkin;
255 struct usb_host_endpoint *ep_blkout;
256 struct usb_host_endpoint *ep_intr;
257
258 int msg_enable;
259
260 struct urb *urb_intr;
261 struct usb_anchor deferred;
262
263 struct mutex phy_mutex; /* for phy access */
264 unsigned pipe_in, pipe_out, pipe_intr;
265
266 u32 hard_mtu; /* count any extra framing */
267 size_t rx_urb_size; /* size for rx urbs */
268
269 unsigned long flags;
270
271 wait_queue_head_t *wait;
272 unsigned char suspend_count;
273
274 unsigned maxpacket;
275 struct timer_list delay;
276
277 unsigned long data[5];
278 struct mii_if_info mii;
279
280 int link_on;
281 u8 mdix_ctrl;
282 };
283
284 /* use ethtool to change the level for any given device */
285 static int msg_level = -1;
286 module_param(msg_level, int, 0);
287 MODULE_PARM_DESC(msg_level, "Override default message level");
288
289 static int lan78xx_read_reg(struct lan78xx_net *dev, u32 index, u32 *data)
290 {
291 u32 *buf = kmalloc(sizeof(u32), GFP_KERNEL);
292 int ret;
293
294 if (!buf)
295 return -ENOMEM;
296
297 ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
298 USB_VENDOR_REQUEST_READ_REGISTER,
299 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
300 0, index, buf, 4, USB_CTRL_GET_TIMEOUT);
301 if (likely(ret >= 0)) {
302 le32_to_cpus(buf);
303 *data = *buf;
304 } else {
305 netdev_warn(dev->net,
306 "Failed to read register index 0x%08x. ret = %d",
307 index, ret);
308 }
309
310 kfree(buf);
311
312 return ret;
313 }
314
315 static int lan78xx_write_reg(struct lan78xx_net *dev, u32 index, u32 data)
316 {
317 u32 *buf = kmalloc(sizeof(u32), GFP_KERNEL);
318 int ret;
319
320 if (!buf)
321 return -ENOMEM;
322
323 *buf = data;
324 cpu_to_le32s(buf);
325
326 ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
327 USB_VENDOR_REQUEST_WRITE_REGISTER,
328 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
329 0, index, buf, 4, USB_CTRL_SET_TIMEOUT);
330 if (unlikely(ret < 0)) {
331 netdev_warn(dev->net,
332 "Failed to write register index 0x%08x. ret = %d",
333 index, ret);
334 }
335
336 kfree(buf);
337
338 return ret;
339 }
340
341 static int lan78xx_read_stats(struct lan78xx_net *dev,
342 struct lan78xx_statstage *data)
343 {
344 int ret = 0;
345 int i;
346 struct lan78xx_statstage *stats;
347 u32 *src;
348 u32 *dst;
349
350 stats = kmalloc(sizeof(*stats), GFP_KERNEL);
351 if (!stats)
352 return -ENOMEM;
353
354 ret = usb_control_msg(dev->udev,
355 usb_rcvctrlpipe(dev->udev, 0),
356 USB_VENDOR_REQUEST_GET_STATS,
357 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
358 0,
359 0,
360 (void *)stats,
361 sizeof(*stats),
362 USB_CTRL_SET_TIMEOUT);
363 if (likely(ret >= 0)) {
364 src = (u32 *)stats;
365 dst = (u32 *)data;
366 for (i = 0; i < sizeof(*stats)/sizeof(u32); i++) {
367 le32_to_cpus(&src[i]);
368 dst[i] = src[i];
369 }
370 } else {
371 netdev_warn(dev->net,
372 "Failed to read stat ret = 0x%x", ret);
373 }
374
375 kfree(stats);
376
377 return ret;
378 }
379
380 /* Loop until the read is completed with timeout called with phy_mutex held */
381 static int lan78xx_phy_wait_not_busy(struct lan78xx_net *dev)
382 {
383 unsigned long start_time = jiffies;
384 u32 val;
385 int ret;
386
387 do {
388 ret = lan78xx_read_reg(dev, MII_ACC, &val);
389 if (unlikely(ret < 0))
390 return -EIO;
391
392 if (!(val & MII_ACC_MII_BUSY_))
393 return 0;
394 } while (!time_after(jiffies, start_time + HZ));
395
396 return -EIO;
397 }
398
399 static inline u32 mii_access(int id, int index, int read)
400 {
401 u32 ret;
402
403 ret = ((u32)id << MII_ACC_PHY_ADDR_SHIFT_) & MII_ACC_PHY_ADDR_MASK_;
404 ret |= ((u32)index << MII_ACC_MIIRINDA_SHIFT_) & MII_ACC_MIIRINDA_MASK_;
405 if (read)
406 ret |= MII_ACC_MII_READ_;
407 else
408 ret |= MII_ACC_MII_WRITE_;
409 ret |= MII_ACC_MII_BUSY_;
410
411 return ret;
412 }
413
414 static int lan78xx_mdio_read(struct net_device *netdev, int phy_id, int idx)
415 {
416 struct lan78xx_net *dev = netdev_priv(netdev);
417 u32 val, addr;
418 int ret;
419
420 ret = usb_autopm_get_interface(dev->intf);
421 if (ret < 0)
422 return ret;
423
424 mutex_lock(&dev->phy_mutex);
425
426 /* confirm MII not busy */
427 ret = lan78xx_phy_wait_not_busy(dev);
428 if (ret < 0)
429 goto done;
430
431 /* set the address, index & direction (read from PHY) */
432 phy_id &= dev->mii.phy_id_mask;
433 idx &= dev->mii.reg_num_mask;
434 addr = mii_access(phy_id, idx, MII_READ);
435 ret = lan78xx_write_reg(dev, MII_ACC, addr);
436
437 ret = lan78xx_phy_wait_not_busy(dev);
438 if (ret < 0)
439 goto done;
440
441 ret = lan78xx_read_reg(dev, MII_DATA, &val);
442
443 ret = (int)(val & 0xFFFF);
444
445 done:
446 mutex_unlock(&dev->phy_mutex);
447 usb_autopm_put_interface(dev->intf);
448 return ret;
449 }
450
451 static void lan78xx_mdio_write(struct net_device *netdev, int phy_id,
452 int idx, int regval)
453 {
454 struct lan78xx_net *dev = netdev_priv(netdev);
455 u32 val, addr;
456 int ret;
457
458 if (usb_autopm_get_interface(dev->intf) < 0)
459 return;
460
461 mutex_lock(&dev->phy_mutex);
462
463 /* confirm MII not busy */
464 ret = lan78xx_phy_wait_not_busy(dev);
465 if (ret < 0)
466 goto done;
467
468 val = regval;
469 ret = lan78xx_write_reg(dev, MII_DATA, val);
470
471 /* set the address, index & direction (write to PHY) */
472 phy_id &= dev->mii.phy_id_mask;
473 idx &= dev->mii.reg_num_mask;
474 addr = mii_access(phy_id, idx, MII_WRITE);
475 ret = lan78xx_write_reg(dev, MII_ACC, addr);
476
477 ret = lan78xx_phy_wait_not_busy(dev);
478 if (ret < 0)
479 goto done;
480
481 done:
482 mutex_unlock(&dev->phy_mutex);
483 usb_autopm_put_interface(dev->intf);
484 }
485
486 static void lan78xx_mmd_write(struct net_device *netdev, int phy_id,
487 int mmddev, int mmdidx, int regval)
488 {
489 struct lan78xx_net *dev = netdev_priv(netdev);
490 u32 val, addr;
491 int ret;
492
493 if (usb_autopm_get_interface(dev->intf) < 0)
494 return;
495
496 mutex_lock(&dev->phy_mutex);
497
498 /* confirm MII not busy */
499 ret = lan78xx_phy_wait_not_busy(dev);
500 if (ret < 0)
501 goto done;
502
503 mmddev &= 0x1F;
504
505 /* set up device address for MMD */
506 ret = lan78xx_write_reg(dev, MII_DATA, mmddev);
507
508 phy_id &= dev->mii.phy_id_mask;
509 addr = mii_access(phy_id, PHY_MMD_CTL, MII_WRITE);
510 ret = lan78xx_write_reg(dev, MII_ACC, addr);
511
512 ret = lan78xx_phy_wait_not_busy(dev);
513 if (ret < 0)
514 goto done;
515
516 /* select register of MMD */
517 val = mmdidx;
518 ret = lan78xx_write_reg(dev, MII_DATA, val);
519
520 phy_id &= dev->mii.phy_id_mask;
521 addr = mii_access(phy_id, PHY_MMD_REG_DATA, MII_WRITE);
522 ret = lan78xx_write_reg(dev, MII_ACC, addr);
523
524 ret = lan78xx_phy_wait_not_busy(dev);
525 if (ret < 0)
526 goto done;
527
528 /* select register data for MMD */
529 val = PHY_MMD_CTRL_OP_DNI_ | mmddev;
530 ret = lan78xx_write_reg(dev, MII_DATA, val);
531
532 phy_id &= dev->mii.phy_id_mask;
533 addr = mii_access(phy_id, PHY_MMD_CTL, MII_WRITE);
534 ret = lan78xx_write_reg(dev, MII_ACC, addr);
535
536 ret = lan78xx_phy_wait_not_busy(dev);
537 if (ret < 0)
538 goto done;
539
540 /* write to MMD */
541 val = regval;
542 ret = lan78xx_write_reg(dev, MII_DATA, val);
543
544 phy_id &= dev->mii.phy_id_mask;
545 addr = mii_access(phy_id, PHY_MMD_REG_DATA, MII_WRITE);
546 ret = lan78xx_write_reg(dev, MII_ACC, addr);
547
548 ret = lan78xx_phy_wait_not_busy(dev);
549 if (ret < 0)
550 goto done;
551
552 done:
553 mutex_unlock(&dev->phy_mutex);
554 usb_autopm_put_interface(dev->intf);
555 }
556
557 static int lan78xx_mmd_read(struct net_device *netdev, int phy_id,
558 int mmddev, int mmdidx)
559 {
560 struct lan78xx_net *dev = netdev_priv(netdev);
561 u32 val, addr;
562 int ret;
563
564 ret = usb_autopm_get_interface(dev->intf);
565 if (ret < 0)
566 return ret;
567
568 mutex_lock(&dev->phy_mutex);
569
570 /* confirm MII not busy */
571 ret = lan78xx_phy_wait_not_busy(dev);
572 if (ret < 0)
573 goto done;
574
575 /* set up device address for MMD */
576 ret = lan78xx_write_reg(dev, MII_DATA, mmddev);
577
578 phy_id &= dev->mii.phy_id_mask;
579 addr = mii_access(phy_id, PHY_MMD_CTL, MII_WRITE);
580 ret = lan78xx_write_reg(dev, MII_ACC, addr);
581
582 ret = lan78xx_phy_wait_not_busy(dev);
583 if (ret < 0)
584 goto done;
585
586 /* select register of MMD */
587 val = mmdidx;
588 ret = lan78xx_write_reg(dev, MII_DATA, val);
589
590 phy_id &= dev->mii.phy_id_mask;
591 addr = mii_access(phy_id, PHY_MMD_REG_DATA, MII_WRITE);
592 ret = lan78xx_write_reg(dev, MII_ACC, addr);
593
594 ret = lan78xx_phy_wait_not_busy(dev);
595 if (ret < 0)
596 goto done;
597
598 /* select register data for MMD */
599 val = PHY_MMD_CTRL_OP_DNI_ | mmddev;
600 ret = lan78xx_write_reg(dev, MII_DATA, val);
601
602 phy_id &= dev->mii.phy_id_mask;
603 addr = mii_access(phy_id, PHY_MMD_CTL, MII_WRITE);
604 ret = lan78xx_write_reg(dev, MII_ACC, addr);
605
606 ret = lan78xx_phy_wait_not_busy(dev);
607 if (ret < 0)
608 goto done;
609
610 /* set the address, index & direction (read from PHY) */
611 phy_id &= dev->mii.phy_id_mask;
612 addr = mii_access(phy_id, PHY_MMD_REG_DATA, MII_READ);
613 ret = lan78xx_write_reg(dev, MII_ACC, addr);
614
615 ret = lan78xx_phy_wait_not_busy(dev);
616 if (ret < 0)
617 goto done;
618
619 /* read from MMD */
620 ret = lan78xx_read_reg(dev, MII_DATA, &val);
621
622 ret = (int)(val & 0xFFFF);
623
624 done:
625 mutex_unlock(&dev->phy_mutex);
626 usb_autopm_put_interface(dev->intf);
627 return ret;
628 }
629
630 static int lan78xx_wait_eeprom(struct lan78xx_net *dev)
631 {
632 unsigned long start_time = jiffies;
633 u32 val;
634 int ret;
635
636 do {
637 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
638 if (unlikely(ret < 0))
639 return -EIO;
640
641 if (!(val & E2P_CMD_EPC_BUSY_) ||
642 (val & E2P_CMD_EPC_TIMEOUT_))
643 break;
644 usleep_range(40, 100);
645 } while (!time_after(jiffies, start_time + HZ));
646
647 if (val & (E2P_CMD_EPC_TIMEOUT_ | E2P_CMD_EPC_BUSY_)) {
648 netdev_warn(dev->net, "EEPROM read operation timeout");
649 return -EIO;
650 }
651
652 return 0;
653 }
654
655 static int lan78xx_eeprom_confirm_not_busy(struct lan78xx_net *dev)
656 {
657 unsigned long start_time = jiffies;
658 u32 val;
659 int ret;
660
661 do {
662 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
663 if (unlikely(ret < 0))
664 return -EIO;
665
666 if (!(val & E2P_CMD_EPC_BUSY_))
667 return 0;
668
669 usleep_range(40, 100);
670 } while (!time_after(jiffies, start_time + HZ));
671
672 netdev_warn(dev->net, "EEPROM is busy");
673 return -EIO;
674 }
675
676 static int lan78xx_read_raw_eeprom(struct lan78xx_net *dev, u32 offset,
677 u32 length, u8 *data)
678 {
679 u32 val;
680 int i, ret;
681
682 ret = lan78xx_eeprom_confirm_not_busy(dev);
683 if (ret)
684 return ret;
685
686 for (i = 0; i < length; i++) {
687 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_READ_;
688 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
689 ret = lan78xx_write_reg(dev, E2P_CMD, val);
690 if (unlikely(ret < 0))
691 return -EIO;
692
693 ret = lan78xx_wait_eeprom(dev);
694 if (ret < 0)
695 return ret;
696
697 ret = lan78xx_read_reg(dev, E2P_DATA, &val);
698 if (unlikely(ret < 0))
699 return -EIO;
700
701 data[i] = val & 0xFF;
702 offset++;
703 }
704
705 return 0;
706 }
707
708 static int lan78xx_read_eeprom(struct lan78xx_net *dev, u32 offset,
709 u32 length, u8 *data)
710 {
711 u8 sig;
712 int ret;
713
714 ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
715 if ((ret == 0) && (sig == EEPROM_INDICATOR))
716 ret = lan78xx_read_raw_eeprom(dev, offset, length, data);
717 else
718 ret = -EINVAL;
719
720 return ret;
721 }
722
723 static int lan78xx_write_raw_eeprom(struct lan78xx_net *dev, u32 offset,
724 u32 length, u8 *data)
725 {
726 u32 val;
727 int i, ret;
728
729 ret = lan78xx_eeprom_confirm_not_busy(dev);
730 if (ret)
731 return ret;
732
733 /* Issue write/erase enable command */
734 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_EWEN_;
735 ret = lan78xx_write_reg(dev, E2P_CMD, val);
736 if (unlikely(ret < 0))
737 return -EIO;
738
739 ret = lan78xx_wait_eeprom(dev);
740 if (ret < 0)
741 return ret;
742
743 for (i = 0; i < length; i++) {
744 /* Fill data register */
745 val = data[i];
746 ret = lan78xx_write_reg(dev, E2P_DATA, val);
747 if (ret < 0)
748 return ret;
749
750 /* Send "write" command */
751 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_WRITE_;
752 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
753 ret = lan78xx_write_reg(dev, E2P_CMD, val);
754 if (ret < 0)
755 return ret;
756
757 ret = lan78xx_wait_eeprom(dev);
758 if (ret < 0)
759 return ret;
760
761 offset++;
762 }
763
764 return 0;
765 }
766
767 static int lan78xx_read_raw_otp(struct lan78xx_net *dev, u32 offset,
768 u32 length, u8 *data)
769 {
770 int i;
771 int ret;
772 u32 buf;
773 unsigned long timeout;
774
775 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
776
777 if (buf & OTP_PWR_DN_PWRDN_N_) {
778 /* clear it and wait to be cleared */
779 ret = lan78xx_write_reg(dev, OTP_PWR_DN, 0);
780
781 timeout = jiffies + HZ;
782 do {
783 usleep_range(1, 10);
784 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
785 if (time_after(jiffies, timeout)) {
786 netdev_warn(dev->net,
787 "timeout on OTP_PWR_DN");
788 return -EIO;
789 }
790 } while (buf & OTP_PWR_DN_PWRDN_N_);
791 }
792
793 for (i = 0; i < length; i++) {
794 ret = lan78xx_write_reg(dev, OTP_ADDR1,
795 ((offset + i) >> 8) & OTP_ADDR1_15_11);
796 ret = lan78xx_write_reg(dev, OTP_ADDR2,
797 ((offset + i) & OTP_ADDR2_10_3));
798
799 ret = lan78xx_write_reg(dev, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_);
800 ret = lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
801
802 timeout = jiffies + HZ;
803 do {
804 udelay(1);
805 ret = lan78xx_read_reg(dev, OTP_STATUS, &buf);
806 if (time_after(jiffies, timeout)) {
807 netdev_warn(dev->net,
808 "timeout on OTP_STATUS");
809 return -EIO;
810 }
811 } while (buf & OTP_STATUS_BUSY_);
812
813 ret = lan78xx_read_reg(dev, OTP_RD_DATA, &buf);
814
815 data[i] = (u8)(buf & 0xFF);
816 }
817
818 return 0;
819 }
820
821 static int lan78xx_read_otp(struct lan78xx_net *dev, u32 offset,
822 u32 length, u8 *data)
823 {
824 u8 sig;
825 int ret;
826
827 ret = lan78xx_read_raw_otp(dev, 0, 1, &sig);
828
829 if (ret == 0) {
830 if (sig == OTP_INDICATOR_1)
831 offset = offset;
832 else if (sig == OTP_INDICATOR_2)
833 offset += 0x100;
834 else
835 ret = -EINVAL;
836 ret = lan78xx_read_raw_otp(dev, offset, length, data);
837 }
838
839 return ret;
840 }
841
842 static int lan78xx_dataport_wait_not_busy(struct lan78xx_net *dev)
843 {
844 int i, ret;
845
846 for (i = 0; i < 100; i++) {
847 u32 dp_sel;
848
849 ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
850 if (unlikely(ret < 0))
851 return -EIO;
852
853 if (dp_sel & DP_SEL_DPRDY_)
854 return 0;
855
856 usleep_range(40, 100);
857 }
858
859 netdev_warn(dev->net, "lan78xx_dataport_wait_not_busy timed out");
860
861 return -EIO;
862 }
863
864 static int lan78xx_dataport_write(struct lan78xx_net *dev, u32 ram_select,
865 u32 addr, u32 length, u32 *buf)
866 {
867 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
868 u32 dp_sel;
869 int i, ret;
870
871 if (usb_autopm_get_interface(dev->intf) < 0)
872 return 0;
873
874 mutex_lock(&pdata->dataport_mutex);
875
876 ret = lan78xx_dataport_wait_not_busy(dev);
877 if (ret < 0)
878 goto done;
879
880 ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
881
882 dp_sel &= ~DP_SEL_RSEL_MASK_;
883 dp_sel |= ram_select;
884 ret = lan78xx_write_reg(dev, DP_SEL, dp_sel);
885
886 for (i = 0; i < length; i++) {
887 ret = lan78xx_write_reg(dev, DP_ADDR, addr + i);
888
889 ret = lan78xx_write_reg(dev, DP_DATA, buf[i]);
890
891 ret = lan78xx_write_reg(dev, DP_CMD, DP_CMD_WRITE_);
892
893 ret = lan78xx_dataport_wait_not_busy(dev);
894 if (ret < 0)
895 goto done;
896 }
897
898 done:
899 mutex_unlock(&pdata->dataport_mutex);
900 usb_autopm_put_interface(dev->intf);
901
902 return ret;
903 }
904
905 static void lan78xx_set_addr_filter(struct lan78xx_priv *pdata,
906 int index, u8 addr[ETH_ALEN])
907 {
908 u32 temp;
909
910 if ((pdata) && (index > 0) && (index < NUM_OF_MAF)) {
911 temp = addr[3];
912 temp = addr[2] | (temp << 8);
913 temp = addr[1] | (temp << 8);
914 temp = addr[0] | (temp << 8);
915 pdata->pfilter_table[index][1] = temp;
916 temp = addr[5];
917 temp = addr[4] | (temp << 8);
918 temp |= MAF_HI_VALID_ | MAF_HI_TYPE_DST_;
919 pdata->pfilter_table[index][0] = temp;
920 }
921 }
922
923 /* returns hash bit number for given MAC address */
924 static inline u32 lan78xx_hash(char addr[ETH_ALEN])
925 {
926 return (ether_crc(ETH_ALEN, addr) >> 23) & 0x1ff;
927 }
928
929 static void lan78xx_deferred_multicast_write(struct work_struct *param)
930 {
931 struct lan78xx_priv *pdata =
932 container_of(param, struct lan78xx_priv, set_multicast);
933 struct lan78xx_net *dev = pdata->dev;
934 int i;
935 int ret;
936
937 netif_dbg(dev, drv, dev->net, "deferred multicast write 0x%08x\n",
938 pdata->rfe_ctl);
939
940 lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, DP_SEL_VHF_VLAN_LEN,
941 DP_SEL_VHF_HASH_LEN, pdata->mchash_table);
942
943 for (i = 1; i < NUM_OF_MAF; i++) {
944 ret = lan78xx_write_reg(dev, MAF_HI(i), 0);
945 ret = lan78xx_write_reg(dev, MAF_LO(i),
946 pdata->pfilter_table[i][1]);
947 ret = lan78xx_write_reg(dev, MAF_HI(i),
948 pdata->pfilter_table[i][0]);
949 }
950
951 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
952 }
953
954 static void lan78xx_set_multicast(struct net_device *netdev)
955 {
956 struct lan78xx_net *dev = netdev_priv(netdev);
957 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
958 unsigned long flags;
959 int i;
960
961 spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
962
963 pdata->rfe_ctl &= ~(RFE_CTL_UCAST_EN_ | RFE_CTL_MCAST_EN_ |
964 RFE_CTL_DA_PERFECT_ | RFE_CTL_MCAST_HASH_);
965
966 for (i = 0; i < DP_SEL_VHF_HASH_LEN; i++)
967 pdata->mchash_table[i] = 0;
968 /* pfilter_table[0] has own HW address */
969 for (i = 1; i < NUM_OF_MAF; i++) {
970 pdata->pfilter_table[i][0] =
971 pdata->pfilter_table[i][1] = 0;
972 }
973
974 pdata->rfe_ctl |= RFE_CTL_BCAST_EN_;
975
976 if (dev->net->flags & IFF_PROMISC) {
977 netif_dbg(dev, drv, dev->net, "promiscuous mode enabled");
978 pdata->rfe_ctl |= RFE_CTL_MCAST_EN_ | RFE_CTL_UCAST_EN_;
979 } else {
980 if (dev->net->flags & IFF_ALLMULTI) {
981 netif_dbg(dev, drv, dev->net,
982 "receive all multicast enabled");
983 pdata->rfe_ctl |= RFE_CTL_MCAST_EN_;
984 }
985 }
986
987 if (netdev_mc_count(dev->net)) {
988 struct netdev_hw_addr *ha;
989 int i;
990
991 netif_dbg(dev, drv, dev->net, "receive multicast hash filter");
992
993 pdata->rfe_ctl |= RFE_CTL_DA_PERFECT_;
994
995 i = 1;
996 netdev_for_each_mc_addr(ha, netdev) {
997 /* set first 32 into Perfect Filter */
998 if (i < 33) {
999 lan78xx_set_addr_filter(pdata, i, ha->addr);
1000 } else {
1001 u32 bitnum = lan78xx_hash(ha->addr);
1002
1003 pdata->mchash_table[bitnum / 32] |=
1004 (1 << (bitnum % 32));
1005 pdata->rfe_ctl |= RFE_CTL_MCAST_HASH_;
1006 }
1007 i++;
1008 }
1009 }
1010
1011 spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
1012
1013 /* defer register writes to a sleepable context */
1014 schedule_work(&pdata->set_multicast);
1015 }
1016
1017 static int lan78xx_update_flowcontrol(struct lan78xx_net *dev, u8 duplex,
1018 u16 lcladv, u16 rmtadv)
1019 {
1020 u32 flow = 0, fct_flow = 0;
1021 int ret;
1022
1023 u8 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
1024
1025 if (cap & FLOW_CTRL_TX)
1026 flow = (FLOW_CR_TX_FCEN_ | 0xFFFF);
1027
1028 if (cap & FLOW_CTRL_RX)
1029 flow |= FLOW_CR_RX_FCEN_;
1030
1031 if (dev->udev->speed == USB_SPEED_SUPER)
1032 fct_flow = 0x817;
1033 else if (dev->udev->speed == USB_SPEED_HIGH)
1034 fct_flow = 0x211;
1035
1036 netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s",
1037 (cap & FLOW_CTRL_RX ? "enabled" : "disabled"),
1038 (cap & FLOW_CTRL_TX ? "enabled" : "disabled"));
1039
1040 ret = lan78xx_write_reg(dev, FCT_FLOW, fct_flow);
1041
1042 /* threshold value should be set before enabling flow */
1043 ret = lan78xx_write_reg(dev, FLOW, flow);
1044
1045 return 0;
1046 }
1047
1048 static int lan78xx_link_reset(struct lan78xx_net *dev)
1049 {
1050 struct mii_if_info *mii = &dev->mii;
1051 struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET };
1052 int ladv, radv, ret;
1053 u32 buf;
1054
1055 /* clear PHY interrupt status */
1056 /* VTSE PHY */
1057 ret = lan78xx_mdio_read(dev->net, mii->phy_id, PHY_VTSE_INT_STS);
1058 if (unlikely(ret < 0))
1059 return -EIO;
1060
1061 /* clear LAN78xx interrupt status */
1062 ret = lan78xx_write_reg(dev, INT_STS, INT_STS_PHY_INT_);
1063 if (unlikely(ret < 0))
1064 return -EIO;
1065
1066 if (!mii_link_ok(mii) && dev->link_on) {
1067 dev->link_on = false;
1068 netif_carrier_off(dev->net);
1069
1070 /* reset MAC */
1071 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1072 if (unlikely(ret < 0))
1073 return -EIO;
1074 buf |= MAC_CR_RST_;
1075 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1076 if (unlikely(ret < 0))
1077 return -EIO;
1078 } else if (mii_link_ok(mii) && !dev->link_on) {
1079 dev->link_on = true;
1080
1081 mii_check_media(mii, 1, 1);
1082 mii_ethtool_gset(&dev->mii, &ecmd);
1083
1084 mii->mdio_read(mii->dev, mii->phy_id, PHY_VTSE_INT_STS);
1085
1086 if (dev->udev->speed == USB_SPEED_SUPER) {
1087 if (ethtool_cmd_speed(&ecmd) == 1000) {
1088 /* disable U2 */
1089 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1090 buf &= ~USB_CFG1_DEV_U2_INIT_EN_;
1091 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1092 /* enable U1 */
1093 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1094 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1095 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1096 } else {
1097 /* enable U1 & U2 */
1098 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1099 buf |= USB_CFG1_DEV_U2_INIT_EN_;
1100 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1101 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1102 }
1103 }
1104
1105 ladv = lan78xx_mdio_read(dev->net, mii->phy_id, MII_ADVERTISE);
1106 if (ladv < 0)
1107 return ladv;
1108
1109 radv = lan78xx_mdio_read(dev->net, mii->phy_id, MII_LPA);
1110 if (radv < 0)
1111 return radv;
1112
1113 netif_dbg(dev, link, dev->net,
1114 "speed: %u duplex: %d anadv: 0x%04x anlpa: 0x%04x",
1115 ethtool_cmd_speed(&ecmd), ecmd.duplex, ladv, radv);
1116
1117 ret = lan78xx_update_flowcontrol(dev, ecmd.duplex, ladv, radv);
1118 netif_carrier_on(dev->net);
1119 }
1120
1121 return ret;
1122 }
1123
1124 /* some work can't be done in tasklets, so we use keventd
1125 *
1126 * NOTE: annoying asymmetry: if it's active, schedule_work() fails,
1127 * but tasklet_schedule() doesn't. hope the failure is rare.
1128 */
1129 void lan78xx_defer_kevent(struct lan78xx_net *dev, int work)
1130 {
1131 set_bit(work, &dev->flags);
1132 if (!schedule_delayed_work(&dev->wq, 0))
1133 netdev_err(dev->net, "kevent %d may have been dropped\n", work);
1134 }
1135
1136 static void lan78xx_status(struct lan78xx_net *dev, struct urb *urb)
1137 {
1138 u32 intdata;
1139
1140 if (urb->actual_length != 4) {
1141 netdev_warn(dev->net,
1142 "unexpected urb length %d", urb->actual_length);
1143 return;
1144 }
1145
1146 memcpy(&intdata, urb->transfer_buffer, 4);
1147 le32_to_cpus(&intdata);
1148
1149 if (intdata & INT_ENP_PHY_INT) {
1150 netif_dbg(dev, link, dev->net, "PHY INTR: 0x%08x\n", intdata);
1151 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
1152 } else
1153 netdev_warn(dev->net,
1154 "unexpected interrupt: 0x%08x\n", intdata);
1155 }
1156
1157 static int lan78xx_ethtool_get_eeprom_len(struct net_device *netdev)
1158 {
1159 return MAX_EEPROM_SIZE;
1160 }
1161
1162 static int lan78xx_ethtool_get_eeprom(struct net_device *netdev,
1163 struct ethtool_eeprom *ee, u8 *data)
1164 {
1165 struct lan78xx_net *dev = netdev_priv(netdev);
1166
1167 ee->magic = LAN78XX_EEPROM_MAGIC;
1168
1169 return lan78xx_read_raw_eeprom(dev, ee->offset, ee->len, data);
1170 }
1171
1172 static int lan78xx_ethtool_set_eeprom(struct net_device *netdev,
1173 struct ethtool_eeprom *ee, u8 *data)
1174 {
1175 struct lan78xx_net *dev = netdev_priv(netdev);
1176
1177 /* Allow entire eeprom update only */
1178 if ((ee->magic == LAN78XX_EEPROM_MAGIC) &&
1179 (ee->offset == 0) &&
1180 (ee->len == 512) &&
1181 (data[0] == EEPROM_INDICATOR))
1182 return lan78xx_write_raw_eeprom(dev, ee->offset, ee->len, data);
1183 else if ((ee->magic == LAN78XX_OTP_MAGIC) &&
1184 (ee->offset == 0) &&
1185 (ee->len == 512) &&
1186 (data[0] == OTP_INDICATOR_1))
1187 return lan78xx_write_raw_eeprom(dev, ee->offset, ee->len, data);
1188
1189 return -EINVAL;
1190 }
1191
1192 static void lan78xx_get_strings(struct net_device *netdev, u32 stringset,
1193 u8 *data)
1194 {
1195 if (stringset == ETH_SS_STATS)
1196 memcpy(data, lan78xx_gstrings, sizeof(lan78xx_gstrings));
1197 }
1198
1199 static int lan78xx_get_sset_count(struct net_device *netdev, int sset)
1200 {
1201 if (sset == ETH_SS_STATS)
1202 return ARRAY_SIZE(lan78xx_gstrings);
1203 else
1204 return -EOPNOTSUPP;
1205 }
1206
1207 static void lan78xx_get_stats(struct net_device *netdev,
1208 struct ethtool_stats *stats, u64 *data)
1209 {
1210 struct lan78xx_net *dev = netdev_priv(netdev);
1211 struct lan78xx_statstage lan78xx_stat;
1212 u32 *p;
1213 int i;
1214
1215 if (usb_autopm_get_interface(dev->intf) < 0)
1216 return;
1217
1218 if (lan78xx_read_stats(dev, &lan78xx_stat) > 0) {
1219 p = (u32 *)&lan78xx_stat;
1220 for (i = 0; i < (sizeof(lan78xx_stat) / (sizeof(u32))); i++)
1221 data[i] = p[i];
1222 }
1223
1224 usb_autopm_put_interface(dev->intf);
1225 }
1226
1227 static void lan78xx_get_wol(struct net_device *netdev,
1228 struct ethtool_wolinfo *wol)
1229 {
1230 struct lan78xx_net *dev = netdev_priv(netdev);
1231 int ret;
1232 u32 buf;
1233 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1234
1235 if (usb_autopm_get_interface(dev->intf) < 0)
1236 return;
1237
1238 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1239 if (unlikely(ret < 0)) {
1240 wol->supported = 0;
1241 wol->wolopts = 0;
1242 } else {
1243 if (buf & USB_CFG_RMT_WKP_) {
1244 wol->supported = WAKE_ALL;
1245 wol->wolopts = pdata->wol;
1246 } else {
1247 wol->supported = 0;
1248 wol->wolopts = 0;
1249 }
1250 }
1251
1252 usb_autopm_put_interface(dev->intf);
1253 }
1254
1255 static int lan78xx_set_wol(struct net_device *netdev,
1256 struct ethtool_wolinfo *wol)
1257 {
1258 struct lan78xx_net *dev = netdev_priv(netdev);
1259 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1260 int ret;
1261
1262 ret = usb_autopm_get_interface(dev->intf);
1263 if (ret < 0)
1264 return ret;
1265
1266 pdata->wol = 0;
1267 if (wol->wolopts & WAKE_UCAST)
1268 pdata->wol |= WAKE_UCAST;
1269 if (wol->wolopts & WAKE_MCAST)
1270 pdata->wol |= WAKE_MCAST;
1271 if (wol->wolopts & WAKE_BCAST)
1272 pdata->wol |= WAKE_BCAST;
1273 if (wol->wolopts & WAKE_MAGIC)
1274 pdata->wol |= WAKE_MAGIC;
1275 if (wol->wolopts & WAKE_PHY)
1276 pdata->wol |= WAKE_PHY;
1277 if (wol->wolopts & WAKE_ARP)
1278 pdata->wol |= WAKE_ARP;
1279
1280 device_set_wakeup_enable(&dev->udev->dev, (bool)wol->wolopts);
1281
1282 usb_autopm_put_interface(dev->intf);
1283
1284 return ret;
1285 }
1286
1287 static int lan78xx_get_eee(struct net_device *net, struct ethtool_eee *edata)
1288 {
1289 struct lan78xx_net *dev = netdev_priv(net);
1290 int ret;
1291 u32 buf;
1292 u32 adv, lpadv;
1293
1294 ret = usb_autopm_get_interface(dev->intf);
1295 if (ret < 0)
1296 return ret;
1297
1298 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1299 if (buf & MAC_CR_EEE_EN_) {
1300 buf = lan78xx_mmd_read(dev->net, dev->mii.phy_id,
1301 PHY_MMD_DEV_7, PHY_EEE_ADVERTISEMENT);
1302 adv = mmd_eee_adv_to_ethtool_adv_t(buf);
1303 buf = lan78xx_mmd_read(dev->net, dev->mii.phy_id,
1304 PHY_MMD_DEV_7, PHY_EEE_LP_ADVERTISEMENT);
1305 lpadv = mmd_eee_adv_to_ethtool_adv_t(buf);
1306
1307 edata->eee_enabled = true;
1308 edata->supported = true;
1309 edata->eee_active = !!(adv & lpadv);
1310 edata->advertised = adv;
1311 edata->lp_advertised = lpadv;
1312 edata->tx_lpi_enabled = true;
1313 /* EEE_TX_LPI_REQ_DLY & tx_lpi_timer are same uSec unit */
1314 ret = lan78xx_read_reg(dev, EEE_TX_LPI_REQ_DLY, &buf);
1315 edata->tx_lpi_timer = buf;
1316 } else {
1317 buf = lan78xx_mmd_read(dev->net, dev->mii.phy_id,
1318 PHY_MMD_DEV_7, PHY_EEE_LP_ADVERTISEMENT);
1319 lpadv = mmd_eee_adv_to_ethtool_adv_t(buf);
1320
1321 edata->eee_enabled = false;
1322 edata->eee_active = false;
1323 edata->supported = false;
1324 edata->advertised = 0;
1325 edata->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(lpadv);
1326 edata->tx_lpi_enabled = false;
1327 edata->tx_lpi_timer = 0;
1328 }
1329
1330 usb_autopm_put_interface(dev->intf);
1331
1332 return 0;
1333 }
1334
1335 static int lan78xx_set_eee(struct net_device *net, struct ethtool_eee *edata)
1336 {
1337 struct lan78xx_net *dev = netdev_priv(net);
1338 int ret;
1339 u32 buf;
1340
1341 ret = usb_autopm_get_interface(dev->intf);
1342 if (ret < 0)
1343 return ret;
1344
1345 if (edata->eee_enabled) {
1346 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1347 buf |= MAC_CR_EEE_EN_;
1348 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1349
1350 buf = ethtool_adv_to_mmd_eee_adv_t(edata->advertised);
1351 lan78xx_mmd_write(dev->net, dev->mii.phy_id,
1352 PHY_MMD_DEV_7, PHY_EEE_ADVERTISEMENT, buf);
1353 } else {
1354 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1355 buf &= ~MAC_CR_EEE_EN_;
1356 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1357 }
1358
1359 usb_autopm_put_interface(dev->intf);
1360
1361 return 0;
1362 }
1363
1364 static u32 lan78xx_get_link(struct net_device *net)
1365 {
1366 struct lan78xx_net *dev = netdev_priv(net);
1367
1368 return mii_link_ok(&dev->mii);
1369 }
1370
1371 int lan78xx_nway_reset(struct net_device *net)
1372 {
1373 struct lan78xx_net *dev = netdev_priv(net);
1374
1375 if ((!dev->mii.mdio_read) || (!dev->mii.mdio_write))
1376 return -EOPNOTSUPP;
1377
1378 return mii_nway_restart(&dev->mii);
1379 }
1380
1381 static void lan78xx_get_drvinfo(struct net_device *net,
1382 struct ethtool_drvinfo *info)
1383 {
1384 struct lan78xx_net *dev = netdev_priv(net);
1385
1386 strncpy(info->driver, DRIVER_NAME, sizeof(info->driver));
1387 strncpy(info->version, DRIVER_VERSION, sizeof(info->version));
1388 usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
1389 }
1390
1391 static u32 lan78xx_get_msglevel(struct net_device *net)
1392 {
1393 struct lan78xx_net *dev = netdev_priv(net);
1394
1395 return dev->msg_enable;
1396 }
1397
1398 static void lan78xx_set_msglevel(struct net_device *net, u32 level)
1399 {
1400 struct lan78xx_net *dev = netdev_priv(net);
1401
1402 dev->msg_enable = level;
1403 }
1404
1405 static int lan78xx_get_settings(struct net_device *net, struct ethtool_cmd *cmd)
1406 {
1407 struct lan78xx_net *dev = netdev_priv(net);
1408 struct mii_if_info *mii = &dev->mii;
1409 int ret;
1410 int buf;
1411
1412 if ((!dev->mii.mdio_read) || (!dev->mii.mdio_write))
1413 return -EOPNOTSUPP;
1414
1415 ret = usb_autopm_get_interface(dev->intf);
1416 if (ret < 0)
1417 return ret;
1418
1419 ret = mii_ethtool_gset(&dev->mii, cmd);
1420
1421 mii->mdio_write(mii->dev, mii->phy_id,
1422 PHY_EXT_GPIO_PAGE, PHY_EXT_GPIO_PAGE_SPACE_1);
1423 buf = mii->mdio_read(mii->dev, mii->phy_id, PHY_EXT_MODE_CTRL);
1424 mii->mdio_write(mii->dev, mii->phy_id,
1425 PHY_EXT_GPIO_PAGE, PHY_EXT_GPIO_PAGE_SPACE_0);
1426
1427 buf &= PHY_EXT_MODE_CTRL_MDIX_MASK_;
1428 if (buf == PHY_EXT_MODE_CTRL_AUTO_MDIX_) {
1429 cmd->eth_tp_mdix = ETH_TP_MDI_AUTO;
1430 cmd->eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;
1431 } else if (buf == PHY_EXT_MODE_CTRL_MDI_) {
1432 cmd->eth_tp_mdix = ETH_TP_MDI;
1433 cmd->eth_tp_mdix_ctrl = ETH_TP_MDI;
1434 } else if (buf == PHY_EXT_MODE_CTRL_MDI_X_) {
1435 cmd->eth_tp_mdix = ETH_TP_MDI_X;
1436 cmd->eth_tp_mdix_ctrl = ETH_TP_MDI_X;
1437 }
1438
1439 usb_autopm_put_interface(dev->intf);
1440
1441 return ret;
1442 }
1443
1444 static int lan78xx_set_settings(struct net_device *net, struct ethtool_cmd *cmd)
1445 {
1446 struct lan78xx_net *dev = netdev_priv(net);
1447 struct mii_if_info *mii = &dev->mii;
1448 int ret = 0;
1449 int temp;
1450
1451 if ((!dev->mii.mdio_read) || (!dev->mii.mdio_write))
1452 return -EOPNOTSUPP;
1453
1454 ret = usb_autopm_get_interface(dev->intf);
1455 if (ret < 0)
1456 return ret;
1457
1458 if (dev->mdix_ctrl != cmd->eth_tp_mdix_ctrl) {
1459 if (cmd->eth_tp_mdix_ctrl == ETH_TP_MDI) {
1460 mii->mdio_write(mii->dev, mii->phy_id,
1461 PHY_EXT_GPIO_PAGE,
1462 PHY_EXT_GPIO_PAGE_SPACE_1);
1463 temp = mii->mdio_read(mii->dev, mii->phy_id,
1464 PHY_EXT_MODE_CTRL);
1465 temp &= ~PHY_EXT_MODE_CTRL_MDIX_MASK_;
1466 mii->mdio_write(mii->dev, mii->phy_id,
1467 PHY_EXT_MODE_CTRL,
1468 temp | PHY_EXT_MODE_CTRL_MDI_);
1469 mii->mdio_write(mii->dev, mii->phy_id,
1470 PHY_EXT_GPIO_PAGE,
1471 PHY_EXT_GPIO_PAGE_SPACE_0);
1472 } else if (cmd->eth_tp_mdix_ctrl == ETH_TP_MDI_X) {
1473 mii->mdio_write(mii->dev, mii->phy_id,
1474 PHY_EXT_GPIO_PAGE,
1475 PHY_EXT_GPIO_PAGE_SPACE_1);
1476 temp = mii->mdio_read(mii->dev, mii->phy_id,
1477 PHY_EXT_MODE_CTRL);
1478 temp &= ~PHY_EXT_MODE_CTRL_MDIX_MASK_;
1479 mii->mdio_write(mii->dev, mii->phy_id,
1480 PHY_EXT_MODE_CTRL,
1481 temp | PHY_EXT_MODE_CTRL_MDI_X_);
1482 mii->mdio_write(mii->dev, mii->phy_id,
1483 PHY_EXT_GPIO_PAGE,
1484 PHY_EXT_GPIO_PAGE_SPACE_0);
1485 } else if (cmd->eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO) {
1486 mii->mdio_write(mii->dev, mii->phy_id,
1487 PHY_EXT_GPIO_PAGE,
1488 PHY_EXT_GPIO_PAGE_SPACE_1);
1489 temp = mii->mdio_read(mii->dev, mii->phy_id,
1490 PHY_EXT_MODE_CTRL);
1491 temp &= ~PHY_EXT_MODE_CTRL_MDIX_MASK_;
1492 mii->mdio_write(mii->dev, mii->phy_id,
1493 PHY_EXT_MODE_CTRL,
1494 temp | PHY_EXT_MODE_CTRL_AUTO_MDIX_);
1495 mii->mdio_write(mii->dev, mii->phy_id,
1496 PHY_EXT_GPIO_PAGE,
1497 PHY_EXT_GPIO_PAGE_SPACE_0);
1498 }
1499 }
1500
1501 /* change speed & duplex */
1502 ret = mii_ethtool_sset(&dev->mii, cmd);
1503
1504 if (!cmd->autoneg) {
1505 /* force link down */
1506 temp = mii->mdio_read(mii->dev, mii->phy_id, MII_BMCR);
1507 mii->mdio_write(mii->dev, mii->phy_id, MII_BMCR,
1508 temp | BMCR_LOOPBACK);
1509 mdelay(1);
1510 mii->mdio_write(mii->dev, mii->phy_id, MII_BMCR, temp);
1511 }
1512
1513 usb_autopm_put_interface(dev->intf);
1514
1515 return ret;
1516 }
1517
1518 static const struct ethtool_ops lan78xx_ethtool_ops = {
1519 .get_link = lan78xx_get_link,
1520 .nway_reset = lan78xx_nway_reset,
1521 .get_drvinfo = lan78xx_get_drvinfo,
1522 .get_msglevel = lan78xx_get_msglevel,
1523 .set_msglevel = lan78xx_set_msglevel,
1524 .get_settings = lan78xx_get_settings,
1525 .set_settings = lan78xx_set_settings,
1526 .get_eeprom_len = lan78xx_ethtool_get_eeprom_len,
1527 .get_eeprom = lan78xx_ethtool_get_eeprom,
1528 .set_eeprom = lan78xx_ethtool_set_eeprom,
1529 .get_ethtool_stats = lan78xx_get_stats,
1530 .get_sset_count = lan78xx_get_sset_count,
1531 .get_strings = lan78xx_get_strings,
1532 .get_wol = lan78xx_get_wol,
1533 .set_wol = lan78xx_set_wol,
1534 .get_eee = lan78xx_get_eee,
1535 .set_eee = lan78xx_set_eee,
1536 };
1537
1538 static int lan78xx_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
1539 {
1540 struct lan78xx_net *dev = netdev_priv(netdev);
1541
1542 if (!netif_running(netdev))
1543 return -EINVAL;
1544
1545 return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
1546 }
1547
1548 static void lan78xx_init_mac_address(struct lan78xx_net *dev)
1549 {
1550 u32 addr_lo, addr_hi;
1551 int ret;
1552 u8 addr[6];
1553
1554 ret = lan78xx_read_reg(dev, RX_ADDRL, &addr_lo);
1555 ret = lan78xx_read_reg(dev, RX_ADDRH, &addr_hi);
1556
1557 addr[0] = addr_lo & 0xFF;
1558 addr[1] = (addr_lo >> 8) & 0xFF;
1559 addr[2] = (addr_lo >> 16) & 0xFF;
1560 addr[3] = (addr_lo >> 24) & 0xFF;
1561 addr[4] = addr_hi & 0xFF;
1562 addr[5] = (addr_hi >> 8) & 0xFF;
1563
1564 if (!is_valid_ether_addr(addr)) {
1565 /* reading mac address from EEPROM or OTP */
1566 if ((lan78xx_read_eeprom(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
1567 addr) == 0) ||
1568 (lan78xx_read_otp(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
1569 addr) == 0)) {
1570 if (is_valid_ether_addr(addr)) {
1571 /* eeprom values are valid so use them */
1572 netif_dbg(dev, ifup, dev->net,
1573 "MAC address read from EEPROM");
1574 } else {
1575 /* generate random MAC */
1576 random_ether_addr(addr);
1577 netif_dbg(dev, ifup, dev->net,
1578 "MAC address set to random addr");
1579 }
1580
1581 addr_lo = addr[0] | (addr[1] << 8) |
1582 (addr[2] << 16) | (addr[3] << 24);
1583 addr_hi = addr[4] | (addr[5] << 8);
1584
1585 ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
1586 ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
1587 } else {
1588 /* generate random MAC */
1589 random_ether_addr(addr);
1590 netif_dbg(dev, ifup, dev->net,
1591 "MAC address set to random addr");
1592 }
1593 }
1594
1595 ret = lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
1596 ret = lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
1597
1598 ether_addr_copy(dev->net->dev_addr, addr);
1599 }
1600
1601 static void lan78xx_mii_init(struct lan78xx_net *dev)
1602 {
1603 /* Initialize MII structure */
1604 dev->mii.dev = dev->net;
1605 dev->mii.mdio_read = lan78xx_mdio_read;
1606 dev->mii.mdio_write = lan78xx_mdio_write;
1607 dev->mii.phy_id_mask = 0x1f;
1608 dev->mii.reg_num_mask = 0x1f;
1609 dev->mii.phy_id = INTERNAL_PHY_ID;
1610 dev->mii.supports_gmii = true;
1611 }
1612
1613 static int lan78xx_phy_init(struct lan78xx_net *dev)
1614 {
1615 int temp;
1616 struct mii_if_info *mii = &dev->mii;
1617
1618 if ((!mii->mdio_write) || (!mii->mdio_read))
1619 return -EOPNOTSUPP;
1620
1621 temp = mii->mdio_read(mii->dev, mii->phy_id, MII_ADVERTISE);
1622 temp |= ADVERTISE_ALL;
1623 mii->mdio_write(mii->dev, mii->phy_id, MII_ADVERTISE,
1624 temp | ADVERTISE_CSMA |
1625 ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM);
1626
1627 /* set to AUTOMDIX */
1628 mii->mdio_write(mii->dev, mii->phy_id,
1629 PHY_EXT_GPIO_PAGE, PHY_EXT_GPIO_PAGE_SPACE_1);
1630 temp = mii->mdio_read(mii->dev, mii->phy_id, PHY_EXT_MODE_CTRL);
1631 temp &= ~PHY_EXT_MODE_CTRL_MDIX_MASK_;
1632 mii->mdio_write(mii->dev, mii->phy_id, PHY_EXT_MODE_CTRL,
1633 temp | PHY_EXT_MODE_CTRL_AUTO_MDIX_);
1634 mii->mdio_write(mii->dev, mii->phy_id,
1635 PHY_EXT_GPIO_PAGE, PHY_EXT_GPIO_PAGE_SPACE_0);
1636 dev->mdix_ctrl = ETH_TP_MDI_AUTO;
1637
1638 /* MAC doesn't support 1000HD */
1639 temp = mii->mdio_read(mii->dev, mii->phy_id, MII_CTRL1000);
1640 mii->mdio_write(mii->dev, mii->phy_id, MII_CTRL1000,
1641 temp & ~ADVERTISE_1000HALF);
1642
1643 /* clear interrupt */
1644 mii->mdio_read(mii->dev, mii->phy_id, PHY_VTSE_INT_STS);
1645 mii->mdio_write(mii->dev, mii->phy_id, PHY_VTSE_INT_MASK,
1646 PHY_VTSE_INT_MASK_MDINTPIN_EN_ |
1647 PHY_VTSE_INT_MASK_LINK_CHANGE_);
1648
1649 netif_dbg(dev, ifup, dev->net, "phy initialised successfully");
1650
1651 return 0;
1652 }
1653
1654 static int lan78xx_set_rx_max_frame_length(struct lan78xx_net *dev, int size)
1655 {
1656 int ret = 0;
1657 u32 buf;
1658 bool rxenabled;
1659
1660 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
1661
1662 rxenabled = ((buf & MAC_RX_RXEN_) != 0);
1663
1664 if (rxenabled) {
1665 buf &= ~MAC_RX_RXEN_;
1666 ret = lan78xx_write_reg(dev, MAC_RX, buf);
1667 }
1668
1669 /* add 4 to size for FCS */
1670 buf &= ~MAC_RX_MAX_SIZE_MASK_;
1671 buf |= (((size + 4) << MAC_RX_MAX_SIZE_SHIFT_) & MAC_RX_MAX_SIZE_MASK_);
1672
1673 ret = lan78xx_write_reg(dev, MAC_RX, buf);
1674
1675 if (rxenabled) {
1676 buf |= MAC_RX_RXEN_;
1677 ret = lan78xx_write_reg(dev, MAC_RX, buf);
1678 }
1679
1680 return 0;
1681 }
1682
1683 static int unlink_urbs(struct lan78xx_net *dev, struct sk_buff_head *q)
1684 {
1685 struct sk_buff *skb;
1686 unsigned long flags;
1687 int count = 0;
1688
1689 spin_lock_irqsave(&q->lock, flags);
1690 while (!skb_queue_empty(q)) {
1691 struct skb_data *entry;
1692 struct urb *urb;
1693 int ret;
1694
1695 skb_queue_walk(q, skb) {
1696 entry = (struct skb_data *)skb->cb;
1697 if (entry->state != unlink_start)
1698 goto found;
1699 }
1700 break;
1701 found:
1702 entry->state = unlink_start;
1703 urb = entry->urb;
1704
1705 /* Get reference count of the URB to avoid it to be
1706 * freed during usb_unlink_urb, which may trigger
1707 * use-after-free problem inside usb_unlink_urb since
1708 * usb_unlink_urb is always racing with .complete
1709 * handler(include defer_bh).
1710 */
1711 usb_get_urb(urb);
1712 spin_unlock_irqrestore(&q->lock, flags);
1713 /* during some PM-driven resume scenarios,
1714 * these (async) unlinks complete immediately
1715 */
1716 ret = usb_unlink_urb(urb);
1717 if (ret != -EINPROGRESS && ret != 0)
1718 netdev_dbg(dev->net, "unlink urb err, %d\n", ret);
1719 else
1720 count++;
1721 usb_put_urb(urb);
1722 spin_lock_irqsave(&q->lock, flags);
1723 }
1724 spin_unlock_irqrestore(&q->lock, flags);
1725 return count;
1726 }
1727
1728 static int lan78xx_change_mtu(struct net_device *netdev, int new_mtu)
1729 {
1730 struct lan78xx_net *dev = netdev_priv(netdev);
1731 int ll_mtu = new_mtu + netdev->hard_header_len;
1732 int old_hard_mtu = dev->hard_mtu;
1733 int old_rx_urb_size = dev->rx_urb_size;
1734 int ret;
1735
1736 if (new_mtu > MAX_SINGLE_PACKET_SIZE)
1737 return -EINVAL;
1738
1739 if (new_mtu <= 0)
1740 return -EINVAL;
1741 /* no second zero-length packet read wanted after mtu-sized packets */
1742 if ((ll_mtu % dev->maxpacket) == 0)
1743 return -EDOM;
1744
1745 ret = lan78xx_set_rx_max_frame_length(dev, new_mtu + ETH_HLEN);
1746
1747 netdev->mtu = new_mtu;
1748
1749 dev->hard_mtu = netdev->mtu + netdev->hard_header_len;
1750 if (dev->rx_urb_size == old_hard_mtu) {
1751 dev->rx_urb_size = dev->hard_mtu;
1752 if (dev->rx_urb_size > old_rx_urb_size) {
1753 if (netif_running(dev->net)) {
1754 unlink_urbs(dev, &dev->rxq);
1755 tasklet_schedule(&dev->bh);
1756 }
1757 }
1758 }
1759
1760 return 0;
1761 }
1762
1763 int lan78xx_set_mac_addr(struct net_device *netdev, void *p)
1764 {
1765 struct lan78xx_net *dev = netdev_priv(netdev);
1766 struct sockaddr *addr = p;
1767 u32 addr_lo, addr_hi;
1768 int ret;
1769
1770 if (netif_running(netdev))
1771 return -EBUSY;
1772
1773 if (!is_valid_ether_addr(addr->sa_data))
1774 return -EADDRNOTAVAIL;
1775
1776 ether_addr_copy(netdev->dev_addr, addr->sa_data);
1777
1778 addr_lo = netdev->dev_addr[0] |
1779 netdev->dev_addr[1] << 8 |
1780 netdev->dev_addr[2] << 16 |
1781 netdev->dev_addr[3] << 24;
1782 addr_hi = netdev->dev_addr[4] |
1783 netdev->dev_addr[5] << 8;
1784
1785 ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
1786 ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
1787
1788 return 0;
1789 }
1790
1791 /* Enable or disable Rx checksum offload engine */
1792 static int lan78xx_set_features(struct net_device *netdev,
1793 netdev_features_t features)
1794 {
1795 struct lan78xx_net *dev = netdev_priv(netdev);
1796 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1797 unsigned long flags;
1798 int ret;
1799
1800 spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
1801
1802 if (features & NETIF_F_RXCSUM) {
1803 pdata->rfe_ctl |= RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_;
1804 pdata->rfe_ctl |= RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_;
1805 } else {
1806 pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_);
1807 pdata->rfe_ctl &= ~(RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_);
1808 }
1809
1810 if (features & NETIF_F_HW_VLAN_CTAG_RX)
1811 pdata->rfe_ctl |= RFE_CTL_VLAN_FILTER_;
1812 else
1813 pdata->rfe_ctl &= ~RFE_CTL_VLAN_FILTER_;
1814
1815 spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
1816
1817 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
1818
1819 return 0;
1820 }
1821
1822 static void lan78xx_deferred_vlan_write(struct work_struct *param)
1823 {
1824 struct lan78xx_priv *pdata =
1825 container_of(param, struct lan78xx_priv, set_vlan);
1826 struct lan78xx_net *dev = pdata->dev;
1827
1828 lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, 0,
1829 DP_SEL_VHF_VLAN_LEN, pdata->vlan_table);
1830 }
1831
1832 static int lan78xx_vlan_rx_add_vid(struct net_device *netdev,
1833 __be16 proto, u16 vid)
1834 {
1835 struct lan78xx_net *dev = netdev_priv(netdev);
1836 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1837 u16 vid_bit_index;
1838 u16 vid_dword_index;
1839
1840 vid_dword_index = (vid >> 5) & 0x7F;
1841 vid_bit_index = vid & 0x1F;
1842
1843 pdata->vlan_table[vid_dword_index] |= (1 << vid_bit_index);
1844
1845 /* defer register writes to a sleepable context */
1846 schedule_work(&pdata->set_vlan);
1847
1848 return 0;
1849 }
1850
1851 static int lan78xx_vlan_rx_kill_vid(struct net_device *netdev,
1852 __be16 proto, u16 vid)
1853 {
1854 struct lan78xx_net *dev = netdev_priv(netdev);
1855 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1856 u16 vid_bit_index;
1857 u16 vid_dword_index;
1858
1859 vid_dword_index = (vid >> 5) & 0x7F;
1860 vid_bit_index = vid & 0x1F;
1861
1862 pdata->vlan_table[vid_dword_index] &= ~(1 << vid_bit_index);
1863
1864 /* defer register writes to a sleepable context */
1865 schedule_work(&pdata->set_vlan);
1866
1867 return 0;
1868 }
1869
1870 static void lan78xx_init_ltm(struct lan78xx_net *dev)
1871 {
1872 int ret;
1873 u32 buf;
1874 u32 regs[6] = { 0 };
1875
1876 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1877 if (buf & USB_CFG1_LTM_ENABLE_) {
1878 u8 temp[2];
1879 /* Get values from EEPROM first */
1880 if (lan78xx_read_eeprom(dev, 0x3F, 2, temp) == 0) {
1881 if (temp[0] == 24) {
1882 ret = lan78xx_read_raw_eeprom(dev,
1883 temp[1] * 2,
1884 24,
1885 (u8 *)regs);
1886 if (ret < 0)
1887 return;
1888 }
1889 } else if (lan78xx_read_otp(dev, 0x3F, 2, temp) == 0) {
1890 if (temp[0] == 24) {
1891 ret = lan78xx_read_raw_otp(dev,
1892 temp[1] * 2,
1893 24,
1894 (u8 *)regs);
1895 if (ret < 0)
1896 return;
1897 }
1898 }
1899 }
1900
1901 lan78xx_write_reg(dev, LTM_BELT_IDLE0, regs[0]);
1902 lan78xx_write_reg(dev, LTM_BELT_IDLE1, regs[1]);
1903 lan78xx_write_reg(dev, LTM_BELT_ACT0, regs[2]);
1904 lan78xx_write_reg(dev, LTM_BELT_ACT1, regs[3]);
1905 lan78xx_write_reg(dev, LTM_INACTIVE0, regs[4]);
1906 lan78xx_write_reg(dev, LTM_INACTIVE1, regs[5]);
1907 }
1908
1909 static int lan78xx_reset(struct lan78xx_net *dev)
1910 {
1911 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1912 u32 buf;
1913 int ret = 0;
1914 unsigned long timeout;
1915
1916 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
1917 buf |= HW_CFG_LRST_;
1918 ret = lan78xx_write_reg(dev, HW_CFG, buf);
1919
1920 timeout = jiffies + HZ;
1921 do {
1922 mdelay(1);
1923 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
1924 if (time_after(jiffies, timeout)) {
1925 netdev_warn(dev->net,
1926 "timeout on completion of LiteReset");
1927 return -EIO;
1928 }
1929 } while (buf & HW_CFG_LRST_);
1930
1931 lan78xx_init_mac_address(dev);
1932
1933 /* Respond to the IN token with a NAK */
1934 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1935 buf |= USB_CFG_BIR_;
1936 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
1937
1938 /* Init LTM */
1939 lan78xx_init_ltm(dev);
1940
1941 dev->net->hard_header_len += TX_OVERHEAD;
1942 dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
1943
1944 if (dev->udev->speed == USB_SPEED_SUPER) {
1945 buf = DEFAULT_BURST_CAP_SIZE / SS_USB_PKT_SIZE;
1946 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
1947 dev->rx_qlen = 4;
1948 dev->tx_qlen = 4;
1949 } else if (dev->udev->speed == USB_SPEED_HIGH) {
1950 buf = DEFAULT_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
1951 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
1952 dev->rx_qlen = RX_MAX_QUEUE_MEMORY / dev->rx_urb_size;
1953 dev->tx_qlen = RX_MAX_QUEUE_MEMORY / dev->hard_mtu;
1954 } else {
1955 buf = DEFAULT_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
1956 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
1957 dev->rx_qlen = 4;
1958 }
1959
1960 ret = lan78xx_write_reg(dev, BURST_CAP, buf);
1961 ret = lan78xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
1962
1963 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
1964 buf |= HW_CFG_MEF_;
1965 ret = lan78xx_write_reg(dev, HW_CFG, buf);
1966
1967 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1968 buf |= USB_CFG_BCE_;
1969 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
1970
1971 /* set FIFO sizes */
1972 buf = (MAX_RX_FIFO_SIZE - 512) / 512;
1973 ret = lan78xx_write_reg(dev, FCT_RX_FIFO_END, buf);
1974
1975 buf = (MAX_TX_FIFO_SIZE - 512) / 512;
1976 ret = lan78xx_write_reg(dev, FCT_TX_FIFO_END, buf);
1977
1978 ret = lan78xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
1979 ret = lan78xx_write_reg(dev, FLOW, 0);
1980 ret = lan78xx_write_reg(dev, FCT_FLOW, 0);
1981
1982 /* Don't need rfe_ctl_lock during initialisation */
1983 ret = lan78xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
1984 pdata->rfe_ctl |= RFE_CTL_BCAST_EN_ | RFE_CTL_DA_PERFECT_;
1985 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
1986
1987 /* Enable or disable checksum offload engines */
1988 lan78xx_set_features(dev->net, dev->net->features);
1989
1990 lan78xx_set_multicast(dev->net);
1991
1992 /* reset PHY */
1993 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
1994 buf |= PMT_CTL_PHY_RST_;
1995 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
1996
1997 timeout = jiffies + HZ;
1998 do {
1999 mdelay(1);
2000 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
2001 if (time_after(jiffies, timeout)) {
2002 netdev_warn(dev->net, "timeout waiting for PHY Reset");
2003 return -EIO;
2004 }
2005 } while (buf & PMT_CTL_PHY_RST_);
2006
2007 lan78xx_mii_init(dev);
2008
2009 ret = lan78xx_phy_init(dev);
2010
2011 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
2012
2013 buf |= MAC_CR_GMII_EN_;
2014 buf |= MAC_CR_AUTO_DUPLEX_ | MAC_CR_AUTO_SPEED_;
2015
2016 ret = lan78xx_write_reg(dev, MAC_CR, buf);
2017
2018 /* enable on PHY */
2019 if (buf & MAC_CR_EEE_EN_)
2020 lan78xx_mmd_write(dev->net, dev->mii.phy_id, 0x07, 0x3C, 0x06);
2021
2022 /* enable PHY interrupts */
2023 ret = lan78xx_read_reg(dev, INT_EP_CTL, &buf);
2024 buf |= INT_ENP_PHY_INT;
2025 ret = lan78xx_write_reg(dev, INT_EP_CTL, buf);
2026
2027 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
2028 buf |= MAC_TX_TXEN_;
2029 ret = lan78xx_write_reg(dev, MAC_TX, buf);
2030
2031 ret = lan78xx_read_reg(dev, FCT_TX_CTL, &buf);
2032 buf |= FCT_TX_CTL_EN_;
2033 ret = lan78xx_write_reg(dev, FCT_TX_CTL, buf);
2034
2035 ret = lan78xx_set_rx_max_frame_length(dev, dev->net->mtu + ETH_HLEN);
2036
2037 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
2038 buf |= MAC_RX_RXEN_;
2039 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2040
2041 ret = lan78xx_read_reg(dev, FCT_RX_CTL, &buf);
2042 buf |= FCT_RX_CTL_EN_;
2043 ret = lan78xx_write_reg(dev, FCT_RX_CTL, buf);
2044
2045 if (!mii_nway_restart(&dev->mii))
2046 netif_dbg(dev, link, dev->net, "autoneg initiated");
2047
2048 return 0;
2049 }
2050
2051 static int lan78xx_open(struct net_device *net)
2052 {
2053 struct lan78xx_net *dev = netdev_priv(net);
2054 int ret;
2055
2056 ret = usb_autopm_get_interface(dev->intf);
2057 if (ret < 0)
2058 goto out;
2059
2060 ret = lan78xx_reset(dev);
2061 if (ret < 0)
2062 goto done;
2063
2064 /* for Link Check */
2065 if (dev->urb_intr) {
2066 ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
2067 if (ret < 0) {
2068 netif_err(dev, ifup, dev->net,
2069 "intr submit %d\n", ret);
2070 goto done;
2071 }
2072 }
2073
2074 set_bit(EVENT_DEV_OPEN, &dev->flags);
2075
2076 netif_start_queue(net);
2077
2078 dev->link_on = false;
2079
2080 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
2081 done:
2082 usb_autopm_put_interface(dev->intf);
2083
2084 out:
2085 return ret;
2086 }
2087
2088 static void lan78xx_terminate_urbs(struct lan78xx_net *dev)
2089 {
2090 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);
2091 DECLARE_WAITQUEUE(wait, current);
2092 int temp;
2093
2094 /* ensure there are no more active urbs */
2095 add_wait_queue(&unlink_wakeup, &wait);
2096 set_current_state(TASK_UNINTERRUPTIBLE);
2097 dev->wait = &unlink_wakeup;
2098 temp = unlink_urbs(dev, &dev->txq) + unlink_urbs(dev, &dev->rxq);
2099
2100 /* maybe wait for deletions to finish. */
2101 while (!skb_queue_empty(&dev->rxq) &&
2102 !skb_queue_empty(&dev->txq) &&
2103 !skb_queue_empty(&dev->done)) {
2104 schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
2105 set_current_state(TASK_UNINTERRUPTIBLE);
2106 netif_dbg(dev, ifdown, dev->net,
2107 "waited for %d urb completions\n", temp);
2108 }
2109 set_current_state(TASK_RUNNING);
2110 dev->wait = NULL;
2111 remove_wait_queue(&unlink_wakeup, &wait);
2112 }
2113
2114 int lan78xx_stop(struct net_device *net)
2115 {
2116 struct lan78xx_net *dev = netdev_priv(net);
2117
2118 clear_bit(EVENT_DEV_OPEN, &dev->flags);
2119 netif_stop_queue(net);
2120
2121 netif_info(dev, ifdown, dev->net,
2122 "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
2123 net->stats.rx_packets, net->stats.tx_packets,
2124 net->stats.rx_errors, net->stats.tx_errors);
2125
2126 lan78xx_terminate_urbs(dev);
2127
2128 usb_kill_urb(dev->urb_intr);
2129
2130 skb_queue_purge(&dev->rxq_pause);
2131
2132 /* deferred work (task, timer, softirq) must also stop.
2133 * can't flush_scheduled_work() until we drop rtnl (later),
2134 * else workers could deadlock; so make workers a NOP.
2135 */
2136 dev->flags = 0;
2137 cancel_delayed_work_sync(&dev->wq);
2138 tasklet_kill(&dev->bh);
2139
2140 usb_autopm_put_interface(dev->intf);
2141
2142 return 0;
2143 }
2144
2145 static int lan78xx_linearize(struct sk_buff *skb)
2146 {
2147 return skb_linearize(skb);
2148 }
2149
2150 static struct sk_buff *lan78xx_tx_prep(struct lan78xx_net *dev,
2151 struct sk_buff *skb, gfp_t flags)
2152 {
2153 u32 tx_cmd_a, tx_cmd_b;
2154
2155 if (skb_headroom(skb) < TX_OVERHEAD) {
2156 struct sk_buff *skb2;
2157
2158 skb2 = skb_copy_expand(skb, TX_OVERHEAD, 0, flags);
2159 dev_kfree_skb_any(skb);
2160 skb = skb2;
2161 if (!skb)
2162 return NULL;
2163 }
2164
2165 if (lan78xx_linearize(skb) < 0)
2166 return NULL;
2167
2168 tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN_MASK_) | TX_CMD_A_FCS_;
2169
2170 if (skb->ip_summed == CHECKSUM_PARTIAL)
2171 tx_cmd_a |= TX_CMD_A_IPE_ | TX_CMD_A_TPE_;
2172
2173 tx_cmd_b = 0;
2174 if (skb_is_gso(skb)) {
2175 u16 mss = max(skb_shinfo(skb)->gso_size, TX_CMD_B_MSS_MIN_);
2176
2177 tx_cmd_b = (mss << TX_CMD_B_MSS_SHIFT_) & TX_CMD_B_MSS_MASK_;
2178
2179 tx_cmd_a |= TX_CMD_A_LSO_;
2180 }
2181
2182 if (skb_vlan_tag_present(skb)) {
2183 tx_cmd_a |= TX_CMD_A_IVTG_;
2184 tx_cmd_b |= skb_vlan_tag_get(skb) & TX_CMD_B_VTAG_MASK_;
2185 }
2186
2187 skb_push(skb, 4);
2188 cpu_to_le32s(&tx_cmd_b);
2189 memcpy(skb->data, &tx_cmd_b, 4);
2190
2191 skb_push(skb, 4);
2192 cpu_to_le32s(&tx_cmd_a);
2193 memcpy(skb->data, &tx_cmd_a, 4);
2194
2195 return skb;
2196 }
2197
2198 static enum skb_state defer_bh(struct lan78xx_net *dev, struct sk_buff *skb,
2199 struct sk_buff_head *list, enum skb_state state)
2200 {
2201 unsigned long flags;
2202 enum skb_state old_state;
2203 struct skb_data *entry = (struct skb_data *)skb->cb;
2204
2205 spin_lock_irqsave(&list->lock, flags);
2206 old_state = entry->state;
2207 entry->state = state;
2208
2209 __skb_unlink(skb, list);
2210 spin_unlock(&list->lock);
2211 spin_lock(&dev->done.lock);
2212
2213 __skb_queue_tail(&dev->done, skb);
2214 if (skb_queue_len(&dev->done) == 1)
2215 tasklet_schedule(&dev->bh);
2216 spin_unlock_irqrestore(&dev->done.lock, flags);
2217
2218 return old_state;
2219 }
2220
2221 static void tx_complete(struct urb *urb)
2222 {
2223 struct sk_buff *skb = (struct sk_buff *)urb->context;
2224 struct skb_data *entry = (struct skb_data *)skb->cb;
2225 struct lan78xx_net *dev = entry->dev;
2226
2227 if (urb->status == 0) {
2228 dev->net->stats.tx_packets++;
2229 dev->net->stats.tx_bytes += entry->length;
2230 } else {
2231 dev->net->stats.tx_errors++;
2232
2233 switch (urb->status) {
2234 case -EPIPE:
2235 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
2236 break;
2237
2238 /* software-driven interface shutdown */
2239 case -ECONNRESET:
2240 case -ESHUTDOWN:
2241 break;
2242
2243 case -EPROTO:
2244 case -ETIME:
2245 case -EILSEQ:
2246 netif_stop_queue(dev->net);
2247 break;
2248 default:
2249 netif_dbg(dev, tx_err, dev->net,
2250 "tx err %d\n", entry->urb->status);
2251 break;
2252 }
2253 }
2254
2255 usb_autopm_put_interface_async(dev->intf);
2256
2257 defer_bh(dev, skb, &dev->txq, tx_done);
2258 }
2259
2260 static void lan78xx_queue_skb(struct sk_buff_head *list,
2261 struct sk_buff *newsk, enum skb_state state)
2262 {
2263 struct skb_data *entry = (struct skb_data *)newsk->cb;
2264
2265 __skb_queue_tail(list, newsk);
2266 entry->state = state;
2267 }
2268
2269 netdev_tx_t lan78xx_start_xmit(struct sk_buff *skb, struct net_device *net)
2270 {
2271 struct lan78xx_net *dev = netdev_priv(net);
2272 struct sk_buff *skb2 = NULL;
2273
2274 if (skb) {
2275 skb_tx_timestamp(skb);
2276 skb2 = lan78xx_tx_prep(dev, skb, GFP_ATOMIC);
2277 }
2278
2279 if (skb2) {
2280 skb_queue_tail(&dev->txq_pend, skb2);
2281
2282 if (skb_queue_len(&dev->txq_pend) > 10)
2283 netif_stop_queue(net);
2284 } else {
2285 netif_dbg(dev, tx_err, dev->net,
2286 "lan78xx_tx_prep return NULL\n");
2287 dev->net->stats.tx_errors++;
2288 dev->net->stats.tx_dropped++;
2289 }
2290
2291 tasklet_schedule(&dev->bh);
2292
2293 return NETDEV_TX_OK;
2294 }
2295
2296 int lan78xx_get_endpoints(struct lan78xx_net *dev, struct usb_interface *intf)
2297 {
2298 int tmp;
2299 struct usb_host_interface *alt = NULL;
2300 struct usb_host_endpoint *in = NULL, *out = NULL;
2301 struct usb_host_endpoint *status = NULL;
2302
2303 for (tmp = 0; tmp < intf->num_altsetting; tmp++) {
2304 unsigned ep;
2305
2306 in = NULL;
2307 out = NULL;
2308 status = NULL;
2309 alt = intf->altsetting + tmp;
2310
2311 for (ep = 0; ep < alt->desc.bNumEndpoints; ep++) {
2312 struct usb_host_endpoint *e;
2313 int intr = 0;
2314
2315 e = alt->endpoint + ep;
2316 switch (e->desc.bmAttributes) {
2317 case USB_ENDPOINT_XFER_INT:
2318 if (!usb_endpoint_dir_in(&e->desc))
2319 continue;
2320 intr = 1;
2321 /* FALLTHROUGH */
2322 case USB_ENDPOINT_XFER_BULK:
2323 break;
2324 default:
2325 continue;
2326 }
2327 if (usb_endpoint_dir_in(&e->desc)) {
2328 if (!intr && !in)
2329 in = e;
2330 else if (intr && !status)
2331 status = e;
2332 } else {
2333 if (!out)
2334 out = e;
2335 }
2336 }
2337 if (in && out)
2338 break;
2339 }
2340 if (!alt || !in || !out)
2341 return -EINVAL;
2342
2343 dev->pipe_in = usb_rcvbulkpipe(dev->udev,
2344 in->desc.bEndpointAddress &
2345 USB_ENDPOINT_NUMBER_MASK);
2346 dev->pipe_out = usb_sndbulkpipe(dev->udev,
2347 out->desc.bEndpointAddress &
2348 USB_ENDPOINT_NUMBER_MASK);
2349 dev->ep_intr = status;
2350
2351 return 0;
2352 }
2353
2354 static int lan78xx_bind(struct lan78xx_net *dev, struct usb_interface *intf)
2355 {
2356 struct lan78xx_priv *pdata = NULL;
2357 int ret;
2358 int i;
2359
2360 ret = lan78xx_get_endpoints(dev, intf);
2361
2362 dev->data[0] = (unsigned long)kzalloc(sizeof(*pdata), GFP_KERNEL);
2363
2364 pdata = (struct lan78xx_priv *)(dev->data[0]);
2365 if (!pdata) {
2366 netdev_warn(dev->net, "Unable to allocate lan78xx_priv");
2367 return -ENOMEM;
2368 }
2369
2370 pdata->dev = dev;
2371
2372 spin_lock_init(&pdata->rfe_ctl_lock);
2373 mutex_init(&pdata->dataport_mutex);
2374
2375 INIT_WORK(&pdata->set_multicast, lan78xx_deferred_multicast_write);
2376
2377 for (i = 0; i < DP_SEL_VHF_VLAN_LEN; i++)
2378 pdata->vlan_table[i] = 0;
2379
2380 INIT_WORK(&pdata->set_vlan, lan78xx_deferred_vlan_write);
2381
2382 dev->net->features = 0;
2383
2384 if (DEFAULT_TX_CSUM_ENABLE)
2385 dev->net->features |= NETIF_F_HW_CSUM;
2386
2387 if (DEFAULT_RX_CSUM_ENABLE)
2388 dev->net->features |= NETIF_F_RXCSUM;
2389
2390 if (DEFAULT_TSO_CSUM_ENABLE)
2391 dev->net->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_SG;
2392
2393 dev->net->hw_features = dev->net->features;
2394
2395 /* Init all registers */
2396 ret = lan78xx_reset(dev);
2397
2398 dev->net->flags |= IFF_MULTICAST;
2399
2400 pdata->wol = WAKE_MAGIC;
2401
2402 return 0;
2403 }
2404
2405 static void lan78xx_unbind(struct lan78xx_net *dev, struct usb_interface *intf)
2406 {
2407 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2408
2409 if (pdata) {
2410 netif_dbg(dev, ifdown, dev->net, "free pdata");
2411 kfree(pdata);
2412 pdata = NULL;
2413 dev->data[0] = 0;
2414 }
2415 }
2416
2417 static void lan78xx_rx_csum_offload(struct lan78xx_net *dev,
2418 struct sk_buff *skb,
2419 u32 rx_cmd_a, u32 rx_cmd_b)
2420 {
2421 if (!(dev->net->features & NETIF_F_RXCSUM) ||
2422 unlikely(rx_cmd_a & RX_CMD_A_ICSM_)) {
2423 skb->ip_summed = CHECKSUM_NONE;
2424 } else {
2425 skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT_));
2426 skb->ip_summed = CHECKSUM_COMPLETE;
2427 }
2428 }
2429
2430 void lan78xx_skb_return(struct lan78xx_net *dev, struct sk_buff *skb)
2431 {
2432 int status;
2433
2434 if (test_bit(EVENT_RX_PAUSED, &dev->flags)) {
2435 skb_queue_tail(&dev->rxq_pause, skb);
2436 return;
2437 }
2438
2439 skb->protocol = eth_type_trans(skb, dev->net);
2440 dev->net->stats.rx_packets++;
2441 dev->net->stats.rx_bytes += skb->len;
2442
2443 netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
2444 skb->len + sizeof(struct ethhdr), skb->protocol);
2445 memset(skb->cb, 0, sizeof(struct skb_data));
2446
2447 if (skb_defer_rx_timestamp(skb))
2448 return;
2449
2450 status = netif_rx(skb);
2451 if (status != NET_RX_SUCCESS)
2452 netif_dbg(dev, rx_err, dev->net,
2453 "netif_rx status %d\n", status);
2454 }
2455
2456 static int lan78xx_rx(struct lan78xx_net *dev, struct sk_buff *skb)
2457 {
2458 if (skb->len < dev->net->hard_header_len)
2459 return 0;
2460
2461 while (skb->len > 0) {
2462 u32 rx_cmd_a, rx_cmd_b, align_count, size;
2463 u16 rx_cmd_c;
2464 struct sk_buff *skb2;
2465 unsigned char *packet;
2466
2467 memcpy(&rx_cmd_a, skb->data, sizeof(rx_cmd_a));
2468 le32_to_cpus(&rx_cmd_a);
2469 skb_pull(skb, sizeof(rx_cmd_a));
2470
2471 memcpy(&rx_cmd_b, skb->data, sizeof(rx_cmd_b));
2472 le32_to_cpus(&rx_cmd_b);
2473 skb_pull(skb, sizeof(rx_cmd_b));
2474
2475 memcpy(&rx_cmd_c, skb->data, sizeof(rx_cmd_c));
2476 le16_to_cpus(&rx_cmd_c);
2477 skb_pull(skb, sizeof(rx_cmd_c));
2478
2479 packet = skb->data;
2480
2481 /* get the packet length */
2482 size = (rx_cmd_a & RX_CMD_A_LEN_MASK_);
2483 align_count = (4 - ((size + RXW_PADDING) % 4)) % 4;
2484
2485 if (unlikely(rx_cmd_a & RX_CMD_A_RED_)) {
2486 netif_dbg(dev, rx_err, dev->net,
2487 "Error rx_cmd_a=0x%08x", rx_cmd_a);
2488 } else {
2489 /* last frame in this batch */
2490 if (skb->len == size) {
2491 lan78xx_rx_csum_offload(dev, skb,
2492 rx_cmd_a, rx_cmd_b);
2493
2494 skb_trim(skb, skb->len - 4); /* remove fcs */
2495 skb->truesize = size + sizeof(struct sk_buff);
2496
2497 return 1;
2498 }
2499
2500 skb2 = skb_clone(skb, GFP_ATOMIC);
2501 if (unlikely(!skb2)) {
2502 netdev_warn(dev->net, "Error allocating skb");
2503 return 0;
2504 }
2505
2506 skb2->len = size;
2507 skb2->data = packet;
2508 skb_set_tail_pointer(skb2, size);
2509
2510 lan78xx_rx_csum_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
2511
2512 skb_trim(skb2, skb2->len - 4); /* remove fcs */
2513 skb2->truesize = size + sizeof(struct sk_buff);
2514
2515 lan78xx_skb_return(dev, skb2);
2516 }
2517
2518 skb_pull(skb, size);
2519
2520 /* padding bytes before the next frame starts */
2521 if (skb->len)
2522 skb_pull(skb, align_count);
2523 }
2524
2525 if (unlikely(skb->len < 0)) {
2526 netdev_warn(dev->net, "invalid rx length<0 %d", skb->len);
2527 return 0;
2528 }
2529
2530 return 1;
2531 }
2532
2533 static inline void rx_process(struct lan78xx_net *dev, struct sk_buff *skb)
2534 {
2535 if (!lan78xx_rx(dev, skb)) {
2536 dev->net->stats.rx_errors++;
2537 goto done;
2538 }
2539
2540 if (skb->len) {
2541 lan78xx_skb_return(dev, skb);
2542 return;
2543 }
2544
2545 netif_dbg(dev, rx_err, dev->net, "drop\n");
2546 dev->net->stats.rx_errors++;
2547 done:
2548 skb_queue_tail(&dev->done, skb);
2549 }
2550
2551 static void rx_complete(struct urb *urb);
2552
2553 static int rx_submit(struct lan78xx_net *dev, struct urb *urb, gfp_t flags)
2554 {
2555 struct sk_buff *skb;
2556 struct skb_data *entry;
2557 unsigned long lockflags;
2558 size_t size = dev->rx_urb_size;
2559 int ret = 0;
2560
2561 skb = netdev_alloc_skb_ip_align(dev->net, size);
2562 if (!skb) {
2563 usb_free_urb(urb);
2564 return -ENOMEM;
2565 }
2566
2567 entry = (struct skb_data *)skb->cb;
2568 entry->urb = urb;
2569 entry->dev = dev;
2570 entry->length = 0;
2571
2572 usb_fill_bulk_urb(urb, dev->udev, dev->pipe_in,
2573 skb->data, size, rx_complete, skb);
2574
2575 spin_lock_irqsave(&dev->rxq.lock, lockflags);
2576
2577 if (netif_device_present(dev->net) &&
2578 netif_running(dev->net) &&
2579 !test_bit(EVENT_RX_HALT, &dev->flags) &&
2580 !test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
2581 ret = usb_submit_urb(urb, GFP_ATOMIC);
2582 switch (ret) {
2583 case 0:
2584 lan78xx_queue_skb(&dev->rxq, skb, rx_start);
2585 break;
2586 case -EPIPE:
2587 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
2588 break;
2589 case -ENODEV:
2590 netif_dbg(dev, ifdown, dev->net, "device gone\n");
2591 netif_device_detach(dev->net);
2592 break;
2593 case -EHOSTUNREACH:
2594 ret = -ENOLINK;
2595 break;
2596 default:
2597 netif_dbg(dev, rx_err, dev->net,
2598 "rx submit, %d\n", ret);
2599 tasklet_schedule(&dev->bh);
2600 }
2601 } else {
2602 netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
2603 ret = -ENOLINK;
2604 }
2605 spin_unlock_irqrestore(&dev->rxq.lock, lockflags);
2606 if (ret) {
2607 dev_kfree_skb_any(skb);
2608 usb_free_urb(urb);
2609 }
2610 return ret;
2611 }
2612
2613 static void rx_complete(struct urb *urb)
2614 {
2615 struct sk_buff *skb = (struct sk_buff *)urb->context;
2616 struct skb_data *entry = (struct skb_data *)skb->cb;
2617 struct lan78xx_net *dev = entry->dev;
2618 int urb_status = urb->status;
2619 enum skb_state state;
2620
2621 skb_put(skb, urb->actual_length);
2622 state = rx_done;
2623 entry->urb = NULL;
2624
2625 switch (urb_status) {
2626 case 0:
2627 if (skb->len < dev->net->hard_header_len) {
2628 state = rx_cleanup;
2629 dev->net->stats.rx_errors++;
2630 dev->net->stats.rx_length_errors++;
2631 netif_dbg(dev, rx_err, dev->net,
2632 "rx length %d\n", skb->len);
2633 }
2634 usb_mark_last_busy(dev->udev);
2635 break;
2636 case -EPIPE:
2637 dev->net->stats.rx_errors++;
2638 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
2639 /* FALLTHROUGH */
2640 case -ECONNRESET: /* async unlink */
2641 case -ESHUTDOWN: /* hardware gone */
2642 netif_dbg(dev, ifdown, dev->net,
2643 "rx shutdown, code %d\n", urb_status);
2644 state = rx_cleanup;
2645 entry->urb = urb;
2646 urb = NULL;
2647 break;
2648 case -EPROTO:
2649 case -ETIME:
2650 case -EILSEQ:
2651 dev->net->stats.rx_errors++;
2652 state = rx_cleanup;
2653 entry->urb = urb;
2654 urb = NULL;
2655 break;
2656
2657 /* data overrun ... flush fifo? */
2658 case -EOVERFLOW:
2659 dev->net->stats.rx_over_errors++;
2660 /* FALLTHROUGH */
2661
2662 default:
2663 state = rx_cleanup;
2664 dev->net->stats.rx_errors++;
2665 netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
2666 break;
2667 }
2668
2669 state = defer_bh(dev, skb, &dev->rxq, state);
2670
2671 if (urb) {
2672 if (netif_running(dev->net) &&
2673 !test_bit(EVENT_RX_HALT, &dev->flags) &&
2674 state != unlink_start) {
2675 rx_submit(dev, urb, GFP_ATOMIC);
2676 return;
2677 }
2678 usb_free_urb(urb);
2679 }
2680 netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n");
2681 }
2682
2683 static void lan78xx_tx_bh(struct lan78xx_net *dev)
2684 {
2685 int length;
2686 struct urb *urb = NULL;
2687 struct skb_data *entry;
2688 unsigned long flags;
2689 struct sk_buff_head *tqp = &dev->txq_pend;
2690 struct sk_buff *skb, *skb2;
2691 int ret;
2692 int count, pos;
2693 int skb_totallen, pkt_cnt;
2694
2695 skb_totallen = 0;
2696 pkt_cnt = 0;
2697 for (skb = tqp->next; pkt_cnt < tqp->qlen; skb = skb->next) {
2698 if (skb_is_gso(skb)) {
2699 if (pkt_cnt) {
2700 /* handle previous packets first */
2701 break;
2702 }
2703 length = skb->len;
2704 skb2 = skb_dequeue(tqp);
2705 goto gso_skb;
2706 }
2707
2708 if ((skb_totallen + skb->len) > MAX_SINGLE_PACKET_SIZE)
2709 break;
2710 skb_totallen = skb->len + roundup(skb_totallen, sizeof(u32));
2711 pkt_cnt++;
2712 }
2713
2714 /* copy to a single skb */
2715 skb = alloc_skb(skb_totallen, GFP_ATOMIC);
2716 if (!skb)
2717 goto drop;
2718
2719 skb_put(skb, skb_totallen);
2720
2721 for (count = pos = 0; count < pkt_cnt; count++) {
2722 skb2 = skb_dequeue(tqp);
2723 if (skb2) {
2724 memcpy(skb->data + pos, skb2->data, skb2->len);
2725 pos += roundup(skb2->len, sizeof(u32));
2726 dev_kfree_skb(skb2);
2727 }
2728 }
2729
2730 length = skb_totallen;
2731
2732 gso_skb:
2733 urb = usb_alloc_urb(0, GFP_ATOMIC);
2734 if (!urb) {
2735 netif_dbg(dev, tx_err, dev->net, "no urb\n");
2736 goto drop;
2737 }
2738
2739 entry = (struct skb_data *)skb->cb;
2740 entry->urb = urb;
2741 entry->dev = dev;
2742 entry->length = length;
2743
2744 spin_lock_irqsave(&dev->txq.lock, flags);
2745 ret = usb_autopm_get_interface_async(dev->intf);
2746 if (ret < 0) {
2747 spin_unlock_irqrestore(&dev->txq.lock, flags);
2748 goto drop;
2749 }
2750
2751 usb_fill_bulk_urb(urb, dev->udev, dev->pipe_out,
2752 skb->data, skb->len, tx_complete, skb);
2753
2754 if (length % dev->maxpacket == 0) {
2755 /* send USB_ZERO_PACKET */
2756 urb->transfer_flags |= URB_ZERO_PACKET;
2757 }
2758
2759 #ifdef CONFIG_PM
2760 /* if this triggers the device is still a sleep */
2761 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
2762 /* transmission will be done in resume */
2763 usb_anchor_urb(urb, &dev->deferred);
2764 /* no use to process more packets */
2765 netif_stop_queue(dev->net);
2766 usb_put_urb(urb);
2767 spin_unlock_irqrestore(&dev->txq.lock, flags);
2768 netdev_dbg(dev->net, "Delaying transmission for resumption\n");
2769 return;
2770 }
2771 #endif
2772
2773 ret = usb_submit_urb(urb, GFP_ATOMIC);
2774 switch (ret) {
2775 case 0:
2776 dev->net->trans_start = jiffies;
2777 lan78xx_queue_skb(&dev->txq, skb, tx_start);
2778 if (skb_queue_len(&dev->txq) >= dev->tx_qlen)
2779 netif_stop_queue(dev->net);
2780 break;
2781 case -EPIPE:
2782 netif_stop_queue(dev->net);
2783 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
2784 usb_autopm_put_interface_async(dev->intf);
2785 break;
2786 default:
2787 usb_autopm_put_interface_async(dev->intf);
2788 netif_dbg(dev, tx_err, dev->net,
2789 "tx: submit urb err %d\n", ret);
2790 break;
2791 }
2792
2793 spin_unlock_irqrestore(&dev->txq.lock, flags);
2794
2795 if (ret) {
2796 netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", ret);
2797 drop:
2798 dev->net->stats.tx_dropped++;
2799 if (skb)
2800 dev_kfree_skb_any(skb);
2801 usb_free_urb(urb);
2802 } else
2803 netif_dbg(dev, tx_queued, dev->net,
2804 "> tx, len %d, type 0x%x\n", length, skb->protocol);
2805 }
2806
2807 static void lan78xx_rx_bh(struct lan78xx_net *dev)
2808 {
2809 struct urb *urb;
2810 int i;
2811
2812 if (skb_queue_len(&dev->rxq) < dev->rx_qlen) {
2813 for (i = 0; i < 10; i++) {
2814 if (skb_queue_len(&dev->rxq) >= dev->rx_qlen)
2815 break;
2816 urb = usb_alloc_urb(0, GFP_ATOMIC);
2817 if (urb)
2818 if (rx_submit(dev, urb, GFP_ATOMIC) == -ENOLINK)
2819 return;
2820 }
2821
2822 if (skb_queue_len(&dev->rxq) < dev->rx_qlen)
2823 tasklet_schedule(&dev->bh);
2824 }
2825 if (skb_queue_len(&dev->txq) < dev->tx_qlen)
2826 netif_wake_queue(dev->net);
2827 }
2828
2829 static void lan78xx_bh(unsigned long param)
2830 {
2831 struct lan78xx_net *dev = (struct lan78xx_net *)param;
2832 struct sk_buff *skb;
2833 struct skb_data *entry;
2834
2835 while ((skb = skb_dequeue(&dev->done))) {
2836 entry = (struct skb_data *)(skb->cb);
2837 switch (entry->state) {
2838 case rx_done:
2839 entry->state = rx_cleanup;
2840 rx_process(dev, skb);
2841 continue;
2842 case tx_done:
2843 usb_free_urb(entry->urb);
2844 dev_kfree_skb(skb);
2845 continue;
2846 case rx_cleanup:
2847 usb_free_urb(entry->urb);
2848 dev_kfree_skb(skb);
2849 continue;
2850 default:
2851 netdev_dbg(dev->net, "skb state %d\n", entry->state);
2852 return;
2853 }
2854 }
2855
2856 if (netif_device_present(dev->net) && netif_running(dev->net)) {
2857 if (!skb_queue_empty(&dev->txq_pend))
2858 lan78xx_tx_bh(dev);
2859
2860 if (!timer_pending(&dev->delay) &&
2861 !test_bit(EVENT_RX_HALT, &dev->flags))
2862 lan78xx_rx_bh(dev);
2863 }
2864 }
2865
2866 static void lan78xx_delayedwork(struct work_struct *work)
2867 {
2868 int status;
2869 struct lan78xx_net *dev;
2870
2871 dev = container_of(work, struct lan78xx_net, wq.work);
2872
2873 if (test_bit(EVENT_TX_HALT, &dev->flags)) {
2874 unlink_urbs(dev, &dev->txq);
2875 status = usb_autopm_get_interface(dev->intf);
2876 if (status < 0)
2877 goto fail_pipe;
2878 status = usb_clear_halt(dev->udev, dev->pipe_out);
2879 usb_autopm_put_interface(dev->intf);
2880 if (status < 0 &&
2881 status != -EPIPE &&
2882 status != -ESHUTDOWN) {
2883 if (netif_msg_tx_err(dev))
2884 fail_pipe:
2885 netdev_err(dev->net,
2886 "can't clear tx halt, status %d\n",
2887 status);
2888 } else {
2889 clear_bit(EVENT_TX_HALT, &dev->flags);
2890 if (status != -ESHUTDOWN)
2891 netif_wake_queue(dev->net);
2892 }
2893 }
2894 if (test_bit(EVENT_RX_HALT, &dev->flags)) {
2895 unlink_urbs(dev, &dev->rxq);
2896 status = usb_autopm_get_interface(dev->intf);
2897 if (status < 0)
2898 goto fail_halt;
2899 status = usb_clear_halt(dev->udev, dev->pipe_in);
2900 usb_autopm_put_interface(dev->intf);
2901 if (status < 0 &&
2902 status != -EPIPE &&
2903 status != -ESHUTDOWN) {
2904 if (netif_msg_rx_err(dev))
2905 fail_halt:
2906 netdev_err(dev->net,
2907 "can't clear rx halt, status %d\n",
2908 status);
2909 } else {
2910 clear_bit(EVENT_RX_HALT, &dev->flags);
2911 tasklet_schedule(&dev->bh);
2912 }
2913 }
2914
2915 if (test_bit(EVENT_LINK_RESET, &dev->flags)) {
2916 int ret = 0;
2917
2918 clear_bit(EVENT_LINK_RESET, &dev->flags);
2919 status = usb_autopm_get_interface(dev->intf);
2920 if (status < 0)
2921 goto skip_reset;
2922 if (lan78xx_link_reset(dev) < 0) {
2923 usb_autopm_put_interface(dev->intf);
2924 skip_reset:
2925 netdev_info(dev->net, "link reset failed (%d)\n",
2926 ret);
2927 } else {
2928 usb_autopm_put_interface(dev->intf);
2929 }
2930 }
2931 }
2932
2933 static void intr_complete(struct urb *urb)
2934 {
2935 struct lan78xx_net *dev = urb->context;
2936 int status = urb->status;
2937
2938 switch (status) {
2939 /* success */
2940 case 0:
2941 lan78xx_status(dev, urb);
2942 break;
2943
2944 /* software-driven interface shutdown */
2945 case -ENOENT: /* urb killed */
2946 case -ESHUTDOWN: /* hardware gone */
2947 netif_dbg(dev, ifdown, dev->net,
2948 "intr shutdown, code %d\n", status);
2949 return;
2950
2951 /* NOTE: not throttling like RX/TX, since this endpoint
2952 * already polls infrequently
2953 */
2954 default:
2955 netdev_dbg(dev->net, "intr status %d\n", status);
2956 break;
2957 }
2958
2959 if (!netif_running(dev->net))
2960 return;
2961
2962 memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
2963 status = usb_submit_urb(urb, GFP_ATOMIC);
2964 if (status != 0)
2965 netif_err(dev, timer, dev->net,
2966 "intr resubmit --> %d\n", status);
2967 }
2968
2969 static void lan78xx_disconnect(struct usb_interface *intf)
2970 {
2971 struct lan78xx_net *dev;
2972 struct usb_device *udev;
2973 struct net_device *net;
2974
2975 dev = usb_get_intfdata(intf);
2976 usb_set_intfdata(intf, NULL);
2977 if (!dev)
2978 return;
2979
2980 udev = interface_to_usbdev(intf);
2981
2982 net = dev->net;
2983 unregister_netdev(net);
2984
2985 cancel_delayed_work_sync(&dev->wq);
2986
2987 usb_scuttle_anchored_urbs(&dev->deferred);
2988
2989 lan78xx_unbind(dev, intf);
2990
2991 usb_kill_urb(dev->urb_intr);
2992 usb_free_urb(dev->urb_intr);
2993
2994 free_netdev(net);
2995 usb_put_dev(udev);
2996 }
2997
2998 void lan78xx_tx_timeout(struct net_device *net)
2999 {
3000 struct lan78xx_net *dev = netdev_priv(net);
3001
3002 unlink_urbs(dev, &dev->txq);
3003 tasklet_schedule(&dev->bh);
3004 }
3005
3006 static const struct net_device_ops lan78xx_netdev_ops = {
3007 .ndo_open = lan78xx_open,
3008 .ndo_stop = lan78xx_stop,
3009 .ndo_start_xmit = lan78xx_start_xmit,
3010 .ndo_tx_timeout = lan78xx_tx_timeout,
3011 .ndo_change_mtu = lan78xx_change_mtu,
3012 .ndo_set_mac_address = lan78xx_set_mac_addr,
3013 .ndo_validate_addr = eth_validate_addr,
3014 .ndo_do_ioctl = lan78xx_ioctl,
3015 .ndo_set_rx_mode = lan78xx_set_multicast,
3016 .ndo_set_features = lan78xx_set_features,
3017 .ndo_vlan_rx_add_vid = lan78xx_vlan_rx_add_vid,
3018 .ndo_vlan_rx_kill_vid = lan78xx_vlan_rx_kill_vid,
3019 };
3020
3021 static int lan78xx_probe(struct usb_interface *intf,
3022 const struct usb_device_id *id)
3023 {
3024 struct lan78xx_net *dev;
3025 struct net_device *netdev;
3026 struct usb_device *udev;
3027 int ret;
3028 unsigned maxp;
3029 unsigned period;
3030 u8 *buf = NULL;
3031
3032 udev = interface_to_usbdev(intf);
3033 udev = usb_get_dev(udev);
3034
3035 ret = -ENOMEM;
3036 netdev = alloc_etherdev(sizeof(struct lan78xx_net));
3037 if (!netdev) {
3038 dev_err(&intf->dev, "Error: OOM\n");
3039 goto out1;
3040 }
3041
3042 /* netdev_printk() needs this */
3043 SET_NETDEV_DEV(netdev, &intf->dev);
3044
3045 dev = netdev_priv(netdev);
3046 dev->udev = udev;
3047 dev->intf = intf;
3048 dev->net = netdev;
3049 dev->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
3050 | NETIF_MSG_PROBE | NETIF_MSG_LINK);
3051
3052 skb_queue_head_init(&dev->rxq);
3053 skb_queue_head_init(&dev->txq);
3054 skb_queue_head_init(&dev->done);
3055 skb_queue_head_init(&dev->rxq_pause);
3056 skb_queue_head_init(&dev->txq_pend);
3057 mutex_init(&dev->phy_mutex);
3058
3059 tasklet_init(&dev->bh, lan78xx_bh, (unsigned long)dev);
3060 INIT_DELAYED_WORK(&dev->wq, lan78xx_delayedwork);
3061 init_usb_anchor(&dev->deferred);
3062
3063 netdev->netdev_ops = &lan78xx_netdev_ops;
3064 netdev->watchdog_timeo = TX_TIMEOUT_JIFFIES;
3065 netdev->ethtool_ops = &lan78xx_ethtool_ops;
3066
3067 ret = lan78xx_bind(dev, intf);
3068 if (ret < 0)
3069 goto out2;
3070 strcpy(netdev->name, "eth%d");
3071
3072 if (netdev->mtu > (dev->hard_mtu - netdev->hard_header_len))
3073 netdev->mtu = dev->hard_mtu - netdev->hard_header_len;
3074
3075 dev->ep_blkin = (intf->cur_altsetting)->endpoint + 0;
3076 dev->ep_blkout = (intf->cur_altsetting)->endpoint + 1;
3077 dev->ep_intr = (intf->cur_altsetting)->endpoint + 2;
3078
3079 dev->pipe_in = usb_rcvbulkpipe(udev, BULK_IN_PIPE);
3080 dev->pipe_out = usb_sndbulkpipe(udev, BULK_OUT_PIPE);
3081
3082 dev->pipe_intr = usb_rcvintpipe(dev->udev,
3083 dev->ep_intr->desc.bEndpointAddress &
3084 USB_ENDPOINT_NUMBER_MASK);
3085 period = dev->ep_intr->desc.bInterval;
3086
3087 maxp = usb_maxpacket(dev->udev, dev->pipe_intr, 0);
3088 buf = kmalloc(maxp, GFP_KERNEL);
3089 if (buf) {
3090 dev->urb_intr = usb_alloc_urb(0, GFP_KERNEL);
3091 if (!dev->urb_intr) {
3092 kfree(buf);
3093 goto out3;
3094 } else {
3095 usb_fill_int_urb(dev->urb_intr, dev->udev,
3096 dev->pipe_intr, buf, maxp,
3097 intr_complete, dev, period);
3098 }
3099 }
3100
3101 dev->maxpacket = usb_maxpacket(dev->udev, dev->pipe_out, 1);
3102
3103 /* driver requires remote-wakeup capability during autosuspend. */
3104 intf->needs_remote_wakeup = 1;
3105
3106 ret = register_netdev(netdev);
3107 if (ret != 0) {
3108 netif_err(dev, probe, netdev, "couldn't register the device\n");
3109 goto out2;
3110 }
3111
3112 usb_set_intfdata(intf, dev);
3113
3114 ret = device_set_wakeup_enable(&udev->dev, true);
3115
3116 /* Default delay of 2sec has more overhead than advantage.
3117 * Set to 10sec as default.
3118 */
3119 pm_runtime_set_autosuspend_delay(&udev->dev,
3120 DEFAULT_AUTOSUSPEND_DELAY);
3121
3122 return 0;
3123
3124 out3:
3125 lan78xx_unbind(dev, intf);
3126 out2:
3127 free_netdev(netdev);
3128 out1:
3129 usb_put_dev(udev);
3130
3131 return ret;
3132 }
3133
3134 static u16 lan78xx_wakeframe_crc16(const u8 *buf, int len)
3135 {
3136 const u16 crc16poly = 0x8005;
3137 int i;
3138 u16 bit, crc, msb;
3139 u8 data;
3140
3141 crc = 0xFFFF;
3142 for (i = 0; i < len; i++) {
3143 data = *buf++;
3144 for (bit = 0; bit < 8; bit++) {
3145 msb = crc >> 15;
3146 crc <<= 1;
3147
3148 if (msb ^ (u16)(data & 1)) {
3149 crc ^= crc16poly;
3150 crc |= (u16)0x0001U;
3151 }
3152 data >>= 1;
3153 }
3154 }
3155
3156 return crc;
3157 }
3158
3159 static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
3160 {
3161 u32 buf;
3162 int ret;
3163 int mask_index;
3164 u16 crc;
3165 u32 temp_wucsr;
3166 u32 temp_pmt_ctl;
3167 const u8 ipv4_multicast[3] = { 0x01, 0x00, 0x5E };
3168 const u8 ipv6_multicast[3] = { 0x33, 0x33 };
3169 const u8 arp_type[2] = { 0x08, 0x06 };
3170
3171 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3172 buf &= ~MAC_TX_TXEN_;
3173 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3174 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3175 buf &= ~MAC_RX_RXEN_;
3176 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3177
3178 ret = lan78xx_write_reg(dev, WUCSR, 0);
3179 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3180 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3181
3182 temp_wucsr = 0;
3183
3184 temp_pmt_ctl = 0;
3185 ret = lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl);
3186 temp_pmt_ctl &= ~PMT_CTL_RES_CLR_WKP_EN_;
3187 temp_pmt_ctl |= PMT_CTL_RES_CLR_WKP_STS_;
3188
3189 for (mask_index = 0; mask_index < NUM_OF_WUF_CFG; mask_index++)
3190 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), 0);
3191
3192 mask_index = 0;
3193 if (wol & WAKE_PHY) {
3194 temp_pmt_ctl |= PMT_CTL_PHY_WAKE_EN_;
3195
3196 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3197 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3198 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3199 }
3200 if (wol & WAKE_MAGIC) {
3201 temp_wucsr |= WUCSR_MPEN_;
3202
3203 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3204 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3205 temp_pmt_ctl |= PMT_CTL_SUS_MODE_3_;
3206 }
3207 if (wol & WAKE_BCAST) {
3208 temp_wucsr |= WUCSR_BCST_EN_;
3209
3210 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3211 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3212 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3213 }
3214 if (wol & WAKE_MCAST) {
3215 temp_wucsr |= WUCSR_WAKE_EN_;
3216
3217 /* set WUF_CFG & WUF_MASK for IPv4 Multicast */
3218 crc = lan78xx_wakeframe_crc16(ipv4_multicast, 3);
3219 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3220 WUF_CFGX_EN_ |
3221 WUF_CFGX_TYPE_MCAST_ |
3222 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3223 (crc & WUF_CFGX_CRC16_MASK_));
3224
3225 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7);
3226 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3227 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3228 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3229 mask_index++;
3230
3231 /* for IPv6 Multicast */
3232 crc = lan78xx_wakeframe_crc16(ipv6_multicast, 2);
3233 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3234 WUF_CFGX_EN_ |
3235 WUF_CFGX_TYPE_MCAST_ |
3236 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3237 (crc & WUF_CFGX_CRC16_MASK_));
3238
3239 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 3);
3240 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3241 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3242 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3243 mask_index++;
3244
3245 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3246 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3247 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3248 }
3249 if (wol & WAKE_UCAST) {
3250 temp_wucsr |= WUCSR_PFDA_EN_;
3251
3252 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3253 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3254 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3255 }
3256 if (wol & WAKE_ARP) {
3257 temp_wucsr |= WUCSR_WAKE_EN_;
3258
3259 /* set WUF_CFG & WUF_MASK
3260 * for packettype (offset 12,13) = ARP (0x0806)
3261 */
3262 crc = lan78xx_wakeframe_crc16(arp_type, 2);
3263 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3264 WUF_CFGX_EN_ |
3265 WUF_CFGX_TYPE_ALL_ |
3266 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3267 (crc & WUF_CFGX_CRC16_MASK_));
3268
3269 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000);
3270 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3271 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3272 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3273 mask_index++;
3274
3275 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3276 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3277 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3278 }
3279
3280 ret = lan78xx_write_reg(dev, WUCSR, temp_wucsr);
3281
3282 /* when multiple WOL bits are set */
3283 if (hweight_long((unsigned long)wol) > 1) {
3284 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3285 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3286 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3287 }
3288 ret = lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl);
3289
3290 /* clear WUPS */
3291 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3292 buf |= PMT_CTL_WUPS_MASK_;
3293 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3294
3295 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3296 buf |= MAC_RX_RXEN_;
3297 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3298
3299 return 0;
3300 }
3301
3302 int lan78xx_suspend(struct usb_interface *intf, pm_message_t message)
3303 {
3304 struct lan78xx_net *dev = usb_get_intfdata(intf);
3305 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
3306 u32 buf;
3307 int ret;
3308 int event;
3309
3310 ret = 0;
3311 event = message.event;
3312
3313 if (!dev->suspend_count++) {
3314 spin_lock_irq(&dev->txq.lock);
3315 /* don't autosuspend while transmitting */
3316 if ((skb_queue_len(&dev->txq) ||
3317 skb_queue_len(&dev->txq_pend)) &&
3318 PMSG_IS_AUTO(message)) {
3319 spin_unlock_irq(&dev->txq.lock);
3320 ret = -EBUSY;
3321 goto out;
3322 } else {
3323 set_bit(EVENT_DEV_ASLEEP, &dev->flags);
3324 spin_unlock_irq(&dev->txq.lock);
3325 }
3326
3327 /* stop TX & RX */
3328 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3329 buf &= ~MAC_TX_TXEN_;
3330 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3331 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3332 buf &= ~MAC_RX_RXEN_;
3333 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3334
3335 /* empty out the rx and queues */
3336 netif_device_detach(dev->net);
3337 lan78xx_terminate_urbs(dev);
3338 usb_kill_urb(dev->urb_intr);
3339
3340 /* reattach */
3341 netif_device_attach(dev->net);
3342 }
3343
3344 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3345 if (PMSG_IS_AUTO(message)) {
3346 /* auto suspend (selective suspend) */
3347 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3348 buf &= ~MAC_TX_TXEN_;
3349 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3350 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3351 buf &= ~MAC_RX_RXEN_;
3352 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3353
3354 ret = lan78xx_write_reg(dev, WUCSR, 0);
3355 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3356 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3357
3358 /* set goodframe wakeup */
3359 ret = lan78xx_read_reg(dev, WUCSR, &buf);
3360
3361 buf |= WUCSR_RFE_WAKE_EN_;
3362 buf |= WUCSR_STORE_WAKE_;
3363
3364 ret = lan78xx_write_reg(dev, WUCSR, buf);
3365
3366 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3367
3368 buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
3369 buf |= PMT_CTL_RES_CLR_WKP_STS_;
3370
3371 buf |= PMT_CTL_PHY_WAKE_EN_;
3372 buf |= PMT_CTL_WOL_EN_;
3373 buf &= ~PMT_CTL_SUS_MODE_MASK_;
3374 buf |= PMT_CTL_SUS_MODE_3_;
3375
3376 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3377
3378 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3379
3380 buf |= PMT_CTL_WUPS_MASK_;
3381
3382 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3383
3384 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3385 buf |= MAC_RX_RXEN_;
3386 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3387 } else {
3388 lan78xx_set_suspend(dev, pdata->wol);
3389 }
3390 }
3391
3392 out:
3393 return ret;
3394 }
3395
3396 int lan78xx_resume(struct usb_interface *intf)
3397 {
3398 struct lan78xx_net *dev = usb_get_intfdata(intf);
3399 struct sk_buff *skb;
3400 struct urb *res;
3401 int ret;
3402 u32 buf;
3403
3404 if (!--dev->suspend_count) {
3405 /* resume interrupt URBs */
3406 if (dev->urb_intr && test_bit(EVENT_DEV_OPEN, &dev->flags))
3407 usb_submit_urb(dev->urb_intr, GFP_NOIO);
3408
3409 spin_lock_irq(&dev->txq.lock);
3410 while ((res = usb_get_from_anchor(&dev->deferred))) {
3411 skb = (struct sk_buff *)res->context;
3412 ret = usb_submit_urb(res, GFP_ATOMIC);
3413 if (ret < 0) {
3414 dev_kfree_skb_any(skb);
3415 usb_free_urb(res);
3416 usb_autopm_put_interface_async(dev->intf);
3417 } else {
3418 dev->net->trans_start = jiffies;
3419 lan78xx_queue_skb(&dev->txq, skb, tx_start);
3420 }
3421 }
3422
3423 clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
3424 spin_unlock_irq(&dev->txq.lock);
3425
3426 if (test_bit(EVENT_DEV_OPEN, &dev->flags)) {
3427 if (!(skb_queue_len(&dev->txq) >= dev->tx_qlen))
3428 netif_start_queue(dev->net);
3429 tasklet_schedule(&dev->bh);
3430 }
3431 }
3432
3433 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3434 ret = lan78xx_write_reg(dev, WUCSR, 0);
3435 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3436
3437 ret = lan78xx_write_reg(dev, WUCSR2, WUCSR2_NS_RCD_ |
3438 WUCSR2_ARP_RCD_ |
3439 WUCSR2_IPV6_TCPSYN_RCD_ |
3440 WUCSR2_IPV4_TCPSYN_RCD_);
3441
3442 ret = lan78xx_write_reg(dev, WUCSR, WUCSR_EEE_TX_WAKE_ |
3443 WUCSR_EEE_RX_WAKE_ |
3444 WUCSR_PFDA_FR_ |
3445 WUCSR_RFE_WAKE_FR_ |
3446 WUCSR_WUFR_ |
3447 WUCSR_MPR_ |
3448 WUCSR_BCST_FR_);
3449
3450 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3451 buf |= MAC_TX_TXEN_;
3452 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3453
3454 return 0;
3455 }
3456
3457 int lan78xx_reset_resume(struct usb_interface *intf)
3458 {
3459 struct lan78xx_net *dev = usb_get_intfdata(intf);
3460
3461 lan78xx_reset(dev);
3462 return lan78xx_resume(intf);
3463 }
3464
3465 static const struct usb_device_id products[] = {
3466 {
3467 /* LAN7800 USB Gigabit Ethernet Device */
3468 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7800_USB_PRODUCT_ID),
3469 },
3470 {
3471 /* LAN7850 USB Gigabit Ethernet Device */
3472 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7850_USB_PRODUCT_ID),
3473 },
3474 {},
3475 };
3476 MODULE_DEVICE_TABLE(usb, products);
3477
3478 static struct usb_driver lan78xx_driver = {
3479 .name = DRIVER_NAME,
3480 .id_table = products,
3481 .probe = lan78xx_probe,
3482 .disconnect = lan78xx_disconnect,
3483 .suspend = lan78xx_suspend,
3484 .resume = lan78xx_resume,
3485 .reset_resume = lan78xx_reset_resume,
3486 .supports_autosuspend = 1,
3487 .disable_hub_initiated_lpm = 1,
3488 };
3489
3490 module_usb_driver(lan78xx_driver);
3491
3492 MODULE_AUTHOR(DRIVER_AUTHOR);
3493 MODULE_DESCRIPTION(DRIVER_DESC);
3494 MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.106176 seconds and 5 git commands to generate.