projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
RDS: rds_conn_lookup() should factor in the struct net for a match
[deliverable/linux.git] / drivers / net / usb / lan78xx.c
CommitLineData
55d7de9d
WH		 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
90static 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
140struct 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
190struct lan78xx_net;
191
192struct 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
205enum 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
215struct 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
222struct 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
237struct 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 */
285static int msg_level = -1;
286module_param(msg_level, int, 0);
287MODULE_PARM_DESC(msg_level, "Override default message level");
288
289static 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
55d7de9d
WH		 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
315static 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
55d7de9d
WH		 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
341static 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
55d7de9d
WH		 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 */
381static 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
399static 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
414static 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
445done:
446 mutex_unlock(&dev->phy_mutex);
447 usb_autopm_put_interface(dev->intf);
448 return ret;
449}
450
451static 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
481done:
482 mutex_unlock(&dev->phy_mutex);
483 usb_autopm_put_interface(dev->intf);
484}
485
486static 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
552done:
553 mutex_unlock(&dev->phy_mutex);
554 usb_autopm_put_interface(dev->intf);
555}
556
557static 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
624done:
625 mutex_unlock(&dev->phy_mutex);
626 usb_autopm_put_interface(dev->intf);
627 return ret;
628}
629
630static 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
655static 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
676static 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
55d7de9d
WH		 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
708static 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
723static 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
55d7de9d
WH		 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
767static 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
821static 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
842static 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
864static 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
898done:
899 mutex_unlock(&pdata->dataport_mutex);
900 usb_autopm_put_interface(dev->intf);
901
902 return ret;
903}
904
905static 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 */
924static inline u32 lan78xx_hash(char addr[ETH_ALEN])
925{
926 return (ether_crc(ETH_ALEN, addr) >> 23) & 0x1ff;
927}
928
929static 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
954static 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
1017static 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
1048static 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 u16 ladv, radv;
1053 int ret;
1054 u32 buf;
1055
1056 /* clear PHY interrupt status */
1057 /* VTSE PHY */
1058 ret = lan78xx_mdio_read(dev->net, mii->phy_id, PHY_VTSE_INT_STS);
1059 if (unlikely(ret < 0))
1060 return -EIO;
1061
1062 /* clear LAN78xx interrupt status */
1063 ret = lan78xx_write_reg(dev, INT_STS, INT_STS_PHY_INT_);
1064 if (unlikely(ret < 0))
1065 return -EIO;
1066
1067 if (!mii_link_ok(mii) && dev->link_on) {
1068 dev->link_on = false;
1069 netif_carrier_off(dev->net);
1070
1071 /* reset MAC */
1072 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1073 if (unlikely(ret < 0))
1074 return -EIO;
1075 buf |= MAC_CR_RST_;
1076 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1077 if (unlikely(ret < 0))
1078 return -EIO;
1079 } else if (mii_link_ok(mii) && !dev->link_on) {
1080 dev->link_on = true;
1081
1082 mii_check_media(mii, 1, 1);
1083 mii_ethtool_gset(&dev->mii, &ecmd);
1084
1085 mii->mdio_read(mii->dev, mii->phy_id, PHY_VTSE_INT_STS);
1086
1087 if (dev->udev->speed == USB_SPEED_SUPER) {
1088 if (ethtool_cmd_speed(&ecmd) == 1000) {
1089 /* disable U2 */
1090 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1091 buf &= ~USB_CFG1_DEV_U2_INIT_EN_;
1092 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1093 /* enable U1 */
1094 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1095 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1096 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1097 } else {
1098 /* enable U1 & U2 */
1099 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1100 buf |= USB_CFG1_DEV_U2_INIT_EN_;
1101 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1102 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1103 }
1104 }
1105
1106 ladv = lan78xx_mdio_read(dev->net, mii->phy_id, MII_ADVERTISE);
1107 if (unlikely(ladv < 0))
1108 return -EIO;
1109
1110 radv = lan78xx_mdio_read(dev->net, mii->phy_id, MII_LPA);
1111 if (unlikely(radv < 0))
1112 return -EIO;
1113
1114 netif_dbg(dev, link, dev->net,
1115 "speed: %u duplex: %d anadv: 0x%04x anlpa: 0x%04x",
1116 ethtool_cmd_speed(&ecmd), ecmd.duplex, ladv, radv);
1117
1118 ret = lan78xx_update_flowcontrol(dev, ecmd.duplex, ladv, radv);
1119 netif_carrier_on(dev->net);
1120 }
1121
1122 return ret;
1123}
1124
1125/* some work can't be done in tasklets, so we use keventd
1126 *
1127 * NOTE: annoying asymmetry: if it's active, schedule_work() fails,
1128 * but tasklet_schedule() doesn't. hope the failure is rare.
1129 */
1130void lan78xx_defer_kevent(struct lan78xx_net *dev, int work)
1131{
1132 set_bit(work, &dev->flags);
1133 if (!schedule_delayed_work(&dev->wq, 0))
1134 netdev_err(dev->net, "kevent %d may have been dropped\n", work);
1135}
1136
1137static void lan78xx_status(struct lan78xx_net *dev, struct urb *urb)
1138{
1139 u32 intdata;
1140
1141 if (urb->actual_length != 4) {
1142 netdev_warn(dev->net,
1143 "unexpected urb length %d", urb->actual_length);
1144 return;
1145 }
1146
1147 memcpy(&intdata, urb->transfer_buffer, 4);
1148 le32_to_cpus(&intdata);
1149
1150 if (intdata & INT_ENP_PHY_INT) {
1151 netif_dbg(dev, link, dev->net, "PHY INTR: 0x%08x\n", intdata);
1152 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
1153 } else
1154 netdev_warn(dev->net,
1155 "unexpected interrupt: 0x%08x\n", intdata);
1156}
1157
1158static int lan78xx_ethtool_get_eeprom_len(struct net_device *netdev)
1159{
1160 return MAX_EEPROM_SIZE;
1161}
1162
1163static int lan78xx_ethtool_get_eeprom(struct net_device *netdev,
1164 struct ethtool_eeprom *ee, u8 *data)
1165{
1166 struct lan78xx_net *dev = netdev_priv(netdev);
1167
1168 ee->magic = LAN78XX_EEPROM_MAGIC;
1169
1170 return lan78xx_read_raw_eeprom(dev, ee->offset, ee->len, data);
1171}
1172
1173static int lan78xx_ethtool_set_eeprom(struct net_device *netdev,
1174 struct ethtool_eeprom *ee, u8 *data)
1175{
1176 struct lan78xx_net *dev = netdev_priv(netdev);
1177
1178 /* Allow entire eeprom update only */
1179 if ((ee->magic == LAN78XX_EEPROM_MAGIC) &&
1180 (ee->offset == 0) &&
1181 (ee->len == 512) &&
1182 (data[0] == EEPROM_INDICATOR))
1183 return lan78xx_write_raw_eeprom(dev, ee->offset, ee->len, data);
1184 else if ((ee->magic == LAN78XX_OTP_MAGIC) &&
1185 (ee->offset == 0) &&
1186 (ee->len == 512) &&
1187 (data[0] == OTP_INDICATOR_1))
1188 return lan78xx_write_raw_eeprom(dev, ee->offset, ee->len, data);
1189
1190 return -EINVAL;
1191}
1192
1193static void lan78xx_get_strings(struct net_device *netdev, u32 stringset,
1194 u8 *data)
1195{
1196 if (stringset == ETH_SS_STATS)
1197 memcpy(data, lan78xx_gstrings, sizeof(lan78xx_gstrings));
1198}
1199
1200static int lan78xx_get_sset_count(struct net_device *netdev, int sset)
1201{
1202 if (sset == ETH_SS_STATS)
1203 return ARRAY_SIZE(lan78xx_gstrings);
1204 else
1205 return -EOPNOTSUPP;
1206}
1207
1208static void lan78xx_get_stats(struct net_device *netdev,
1209 struct ethtool_stats *stats, u64 *data)
1210{
1211 struct lan78xx_net *dev = netdev_priv(netdev);
1212 struct lan78xx_statstage lan78xx_stat;
1213 u32 *p;
1214 int i;
1215
1216 if (usb_autopm_get_interface(dev->intf) < 0)
1217 return;
1218
1219 if (lan78xx_read_stats(dev, &lan78xx_stat) > 0) {
1220 p = (u32 *)&lan78xx_stat;
1221 for (i = 0; i < (sizeof(lan78xx_stat) / (sizeof(u32))); i++)
1222 data[i] = p[i];
1223 }
1224
1225 usb_autopm_put_interface(dev->intf);
1226}
1227
1228static void lan78xx_get_wol(struct net_device *netdev,
1229 struct ethtool_wolinfo *wol)
1230{
1231 struct lan78xx_net *dev = netdev_priv(netdev);
1232 int ret;
1233 u32 buf;
1234 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1235
1236 if (usb_autopm_get_interface(dev->intf) < 0)
1237 return;
1238
1239 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1240 if (unlikely(ret < 0)) {
1241 wol->supported = 0;
1242 wol->wolopts = 0;
1243 } else {
1244 if (buf & USB_CFG_RMT_WKP_) {
1245 wol->supported = WAKE_ALL;
1246 wol->wolopts = pdata->wol;
1247 } else {
1248 wol->supported = 0;
1249 wol->wolopts = 0;
1250 }
1251 }
1252
1253 usb_autopm_put_interface(dev->intf);
1254}
1255
1256static int lan78xx_set_wol(struct net_device *netdev,
1257 struct ethtool_wolinfo *wol)
1258{
1259 struct lan78xx_net *dev = netdev_priv(netdev);
1260 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1261 int ret;
1262
1263 ret = usb_autopm_get_interface(dev->intf);
1264 if (ret < 0)
1265 return ret;
1266
1267 pdata->wol = 0;
1268 if (wol->wolopts & WAKE_UCAST)
1269 pdata->wol |= WAKE_UCAST;
1270 if (wol->wolopts & WAKE_MCAST)
1271 pdata->wol |= WAKE_MCAST;
1272 if (wol->wolopts & WAKE_BCAST)
1273 pdata->wol |= WAKE_BCAST;
1274 if (wol->wolopts & WAKE_MAGIC)
1275 pdata->wol |= WAKE_MAGIC;
1276 if (wol->wolopts & WAKE_PHY)
1277 pdata->wol |= WAKE_PHY;
1278 if (wol->wolopts & WAKE_ARP)
1279 pdata->wol |= WAKE_ARP;
1280
1281 device_set_wakeup_enable(&dev->udev->dev, (bool)wol->wolopts);
1282
1283 usb_autopm_put_interface(dev->intf);
1284
1285 return ret;
1286}
1287
1288static int lan78xx_get_eee(struct net_device *net, struct ethtool_eee *edata)
1289{
1290 struct lan78xx_net *dev = netdev_priv(net);
1291 int ret;
1292 u32 buf;
1293 u32 adv, lpadv;
1294
1295 ret = usb_autopm_get_interface(dev->intf);
1296 if (ret < 0)
1297 return ret;
1298
1299 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1300 if (buf & MAC_CR_EEE_EN_) {
1301 buf = lan78xx_mmd_read(dev->net, dev->mii.phy_id,
1302 PHY_MMD_DEV_7, PHY_EEE_ADVERTISEMENT);
1303 adv = mmd_eee_adv_to_ethtool_adv_t(buf);
1304 buf = lan78xx_mmd_read(dev->net, dev->mii.phy_id,
1305 PHY_MMD_DEV_7, PHY_EEE_LP_ADVERTISEMENT);
1306 lpadv = mmd_eee_adv_to_ethtool_adv_t(buf);
1307
1308 edata->eee_enabled = true;
1309 edata->supported = true;
1310 edata->eee_active = !!(adv & lpadv);
1311 edata->advertised = adv;
1312 edata->lp_advertised = lpadv;
1313 edata->tx_lpi_enabled = true;
1314 /* EEE_TX_LPI_REQ_DLY & tx_lpi_timer are same uSec unit */
1315 ret = lan78xx_read_reg(dev, EEE_TX_LPI_REQ_DLY, &buf);
1316 edata->tx_lpi_timer = buf;
1317 } else {
1318 buf = lan78xx_mmd_read(dev->net, dev->mii.phy_id,
1319 PHY_MMD_DEV_7, PHY_EEE_LP_ADVERTISEMENT);
1320 lpadv = mmd_eee_adv_to_ethtool_adv_t(buf);
1321
1322 edata->eee_enabled = false;
1323 edata->eee_active = false;
1324 edata->supported = false;
1325 edata->advertised = 0;
1326 edata->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(lpadv);
1327 edata->tx_lpi_enabled = false;
1328 edata->tx_lpi_timer = 0;
1329 }
1330
1331 usb_autopm_put_interface(dev->intf);
1332
1333 return 0;
1334}
1335
1336static int lan78xx_set_eee(struct net_device *net, struct ethtool_eee *edata)
1337{
1338 struct lan78xx_net *dev = netdev_priv(net);
1339 int ret;
1340 u32 buf;
1341
1342 ret = usb_autopm_get_interface(dev->intf);
1343 if (ret < 0)
1344 return ret;
1345
1346 if (edata->eee_enabled) {
1347 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1348 buf |= MAC_CR_EEE_EN_;
1349 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1350
1351 buf = ethtool_adv_to_mmd_eee_adv_t(edata->advertised);
1352 lan78xx_mmd_write(dev->net, dev->mii.phy_id,
1353 PHY_MMD_DEV_7, PHY_EEE_ADVERTISEMENT, buf);
1354 } else {
1355 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1356 buf &= ~MAC_CR_EEE_EN_;
1357 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1358 }
1359
1360 usb_autopm_put_interface(dev->intf);
1361
1362 return 0;
1363}
1364
1365static u32 lan78xx_get_link(struct net_device *net)
1366{
1367 struct lan78xx_net *dev = netdev_priv(net);
1368
1369 return mii_link_ok(&dev->mii);
1370}
1371
1372int lan78xx_nway_reset(struct net_device *net)
1373{
1374 struct lan78xx_net *dev = netdev_priv(net);
1375
1376 if ((!dev->mii.mdio_read) || (!dev->mii.mdio_write))
1377 return -EOPNOTSUPP;
1378
1379 return mii_nway_restart(&dev->mii);
1380}
1381
1382static void lan78xx_get_drvinfo(struct net_device *net,
1383 struct ethtool_drvinfo *info)
1384{
1385 struct lan78xx_net *dev = netdev_priv(net);
1386
1387 strncpy(info->driver, DRIVER_NAME, sizeof(info->driver));
1388 strncpy(info->version, DRIVER_VERSION, sizeof(info->version));
1389 usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
1390}
1391
1392static u32 lan78xx_get_msglevel(struct net_device *net)
1393{
1394 struct lan78xx_net *dev = netdev_priv(net);
1395
1396 return dev->msg_enable;
1397}
1398
1399static void lan78xx_set_msglevel(struct net_device *net, u32 level)
1400{
1401 struct lan78xx_net *dev = netdev_priv(net);
1402
1403 dev->msg_enable = level;
1404}
1405
1406static int lan78xx_get_settings(struct net_device *net, struct ethtool_cmd *cmd)
1407{
1408 struct lan78xx_net *dev = netdev_priv(net);
1409 struct mii_if_info *mii = &dev->mii;
1410 int ret;
1411 int buf;
1412
1413 if ((!dev->mii.mdio_read) || (!dev->mii.mdio_write))
1414 return -EOPNOTSUPP;
1415
1416 ret = usb_autopm_get_interface(dev->intf);
1417 if (ret < 0)
1418 return ret;
1419
1420 ret = mii_ethtool_gset(&dev->mii, cmd);
1421
1422 mii->mdio_write(mii->dev, mii->phy_id,
1423 PHY_EXT_GPIO_PAGE, PHY_EXT_GPIO_PAGE_SPACE_1);
1424 buf = mii->mdio_read(mii->dev, mii->phy_id, PHY_EXT_MODE_CTRL);
1425 mii->mdio_write(mii->dev, mii->phy_id,
1426 PHY_EXT_GPIO_PAGE, PHY_EXT_GPIO_PAGE_SPACE_0);
1427
1428 buf &= PHY_EXT_MODE_CTRL_MDIX_MASK_;
1429 if (buf == PHY_EXT_MODE_CTRL_AUTO_MDIX_) {
1430 cmd->eth_tp_mdix = ETH_TP_MDI_AUTO;
1431 cmd->eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;
1432 } else if (buf == PHY_EXT_MODE_CTRL_MDI_) {
1433 cmd->eth_tp_mdix = ETH_TP_MDI;
1434 cmd->eth_tp_mdix_ctrl = ETH_TP_MDI;
1435 } else if (buf == PHY_EXT_MODE_CTRL_MDI_X_) {
1436 cmd->eth_tp_mdix = ETH_TP_MDI_X;
1437 cmd->eth_tp_mdix_ctrl = ETH_TP_MDI_X;
1438 }
1439
1440 usb_autopm_put_interface(dev->intf);
1441
1442 return ret;
1443}
1444
1445static int lan78xx_set_settings(struct net_device *net, struct ethtool_cmd *cmd)
1446{
1447 struct lan78xx_net *dev = netdev_priv(net);
1448 struct mii_if_info *mii = &dev->mii;
1449 int ret = 0;
1450 int temp;
1451
1452 if ((!dev->mii.mdio_read) || (!dev->mii.mdio_write))
1453 return -EOPNOTSUPP;
1454
1455 ret = usb_autopm_get_interface(dev->intf);
1456 if (ret < 0)
1457 return ret;
1458
1459 if (dev->mdix_ctrl != cmd->eth_tp_mdix_ctrl) {
1460 if (cmd->eth_tp_mdix_ctrl == ETH_TP_MDI) {
1461 mii->mdio_write(mii->dev, mii->phy_id,
1462 PHY_EXT_GPIO_PAGE,
1463 PHY_EXT_GPIO_PAGE_SPACE_1);
1464 temp = mii->mdio_read(mii->dev, mii->phy_id,
1465 PHY_EXT_MODE_CTRL);
1466 temp &= ~PHY_EXT_MODE_CTRL_MDIX_MASK_;
1467 mii->mdio_write(mii->dev, mii->phy_id,
1468 PHY_EXT_MODE_CTRL,
1469 temp | PHY_EXT_MODE_CTRL_MDI_);
1470 mii->mdio_write(mii->dev, mii->phy_id,
1471 PHY_EXT_GPIO_PAGE,
1472 PHY_EXT_GPIO_PAGE_SPACE_0);
1473 } else if (cmd->eth_tp_mdix_ctrl == ETH_TP_MDI_X) {
1474 mii->mdio_write(mii->dev, mii->phy_id,
1475 PHY_EXT_GPIO_PAGE,
1476 PHY_EXT_GPIO_PAGE_SPACE_1);
1477 temp = mii->mdio_read(mii->dev, mii->phy_id,
1478 PHY_EXT_MODE_CTRL);
1479 temp &= ~PHY_EXT_MODE_CTRL_MDIX_MASK_;
1480 mii->mdio_write(mii->dev, mii->phy_id,
1481 PHY_EXT_MODE_CTRL,
1482 temp | PHY_EXT_MODE_CTRL_MDI_X_);
1483 mii->mdio_write(mii->dev, mii->phy_id,
1484 PHY_EXT_GPIO_PAGE,
1485 PHY_EXT_GPIO_PAGE_SPACE_0);
1486 } else if (cmd->eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO) {
1487 mii->mdio_write(mii->dev, mii->phy_id,
1488 PHY_EXT_GPIO_PAGE,
1489 PHY_EXT_GPIO_PAGE_SPACE_1);
1490 temp = mii->mdio_read(mii->dev, mii->phy_id,
1491 PHY_EXT_MODE_CTRL);
1492 temp &= ~PHY_EXT_MODE_CTRL_MDIX_MASK_;
1493 mii->mdio_write(mii->dev, mii->phy_id,
1494 PHY_EXT_MODE_CTRL,
1495 temp | PHY_EXT_MODE_CTRL_AUTO_MDIX_);
1496 mii->mdio_write(mii->dev, mii->phy_id,
1497 PHY_EXT_GPIO_PAGE,
1498 PHY_EXT_GPIO_PAGE_SPACE_0);
1499 }
1500 }
1501
1502 /* change speed & duplex */
1503 ret = mii_ethtool_sset(&dev->mii, cmd);
1504
1505 if (!cmd->autoneg) {
1506 /* force link down */
1507 temp = mii->mdio_read(mii->dev, mii->phy_id, MII_BMCR);
1508 mii->mdio_write(mii->dev, mii->phy_id, MII_BMCR,
1509 temp | BMCR_LOOPBACK);
1510 mdelay(1);
1511 mii->mdio_write(mii->dev, mii->phy_id, MII_BMCR, temp);
1512 }
1513
1514 usb_autopm_put_interface(dev->intf);
1515
1516 return ret;
1517}
1518
1519static const struct ethtool_ops lan78xx_ethtool_ops = {
1520 .get_link = lan78xx_get_link,
1521 .nway_reset = lan78xx_nway_reset,
1522 .get_drvinfo = lan78xx_get_drvinfo,
1523 .get_msglevel = lan78xx_get_msglevel,
1524 .set_msglevel = lan78xx_set_msglevel,
1525 .get_settings = lan78xx_get_settings,
1526 .set_settings = lan78xx_set_settings,
1527 .get_eeprom_len = lan78xx_ethtool_get_eeprom_len,
1528 .get_eeprom = lan78xx_ethtool_get_eeprom,
1529 .set_eeprom = lan78xx_ethtool_set_eeprom,
1530 .get_ethtool_stats = lan78xx_get_stats,
1531 .get_sset_count = lan78xx_get_sset_count,
1532 .get_strings = lan78xx_get_strings,
1533 .get_wol = lan78xx_get_wol,
1534 .set_wol = lan78xx_set_wol,
1535 .get_eee = lan78xx_get_eee,
1536 .set_eee = lan78xx_set_eee,
1537};
1538
1539static int lan78xx_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
1540{
1541 struct lan78xx_net *dev = netdev_priv(netdev);
1542
1543 if (!netif_running(netdev))
1544 return -EINVAL;
1545
1546 return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
1547}
1548
1549static void lan78xx_init_mac_address(struct lan78xx_net *dev)
1550{
1551 u32 addr_lo, addr_hi;
1552 int ret;
1553 u8 addr[6];
1554
1555 ret = lan78xx_read_reg(dev, RX_ADDRL, &addr_lo);
1556 ret = lan78xx_read_reg(dev, RX_ADDRH, &addr_hi);
1557
1558 addr[0] = addr_lo & 0xFF;
1559 addr[1] = (addr_lo >> 8) & 0xFF;
1560 addr[2] = (addr_lo >> 16) & 0xFF;
1561 addr[3] = (addr_lo >> 24) & 0xFF;
1562 addr[4] = addr_hi & 0xFF;
1563 addr[5] = (addr_hi >> 8) & 0xFF;
1564
1565 if (!is_valid_ether_addr(addr)) {
1566 /* reading mac address from EEPROM or OTP */
1567 if ((lan78xx_read_eeprom(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
1568 addr) == 0) ||
1569 (lan78xx_read_otp(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
1570 addr) == 0)) {
1571 if (is_valid_ether_addr(addr)) {
1572 /* eeprom values are valid so use them */
1573 netif_dbg(dev, ifup, dev->net,
1574 "MAC address read from EEPROM");
1575 } else {
1576 /* generate random MAC */
1577 random_ether_addr(addr);
1578 netif_dbg(dev, ifup, dev->net,
1579 "MAC address set to random addr");
1580 }
1581
1582 addr_lo = addr[0] | (addr[1] << 8) |
1583 (addr[2] << 16) | (addr[3] << 24);
1584 addr_hi = addr[4] | (addr[5] << 8);
1585
1586 ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
1587 ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
1588 } else {
1589 /* generate random MAC */
1590 random_ether_addr(addr);
1591 netif_dbg(dev, ifup, dev->net,
1592 "MAC address set to random addr");
1593 }
1594 }
1595
1596 ret = lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
1597 ret = lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
1598
1599 ether_addr_copy(dev->net->dev_addr, addr);
1600}
1601
1602static void lan78xx_mii_init(struct lan78xx_net *dev)
1603{
1604 /* Initialize MII structure */
1605 dev->mii.dev = dev->net;
1606 dev->mii.mdio_read = lan78xx_mdio_read;
1607 dev->mii.mdio_write = lan78xx_mdio_write;
1608 dev->mii.phy_id_mask = 0x1f;
1609 dev->mii.reg_num_mask = 0x1f;
1610 dev->mii.phy_id = INTERNAL_PHY_ID;
1611 dev->mii.supports_gmii = true;
1612}
1613
1614static int lan78xx_phy_init(struct lan78xx_net *dev)
1615{
1616 int temp;
1617 struct mii_if_info *mii = &dev->mii;
1618
1619 if ((!mii->mdio_write) || (!mii->mdio_read))
1620 return -EOPNOTSUPP;
1621
1622 temp = mii->mdio_read(mii->dev, mii->phy_id, MII_ADVERTISE);
1623 temp |= ADVERTISE_ALL;
1624 mii->mdio_write(mii->dev, mii->phy_id, MII_ADVERTISE,
1625 temp | ADVERTISE_CSMA |
1626 ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM);
1627
1628 /* set to AUTOMDIX */
1629 mii->mdio_write(mii->dev, mii->phy_id,
1630 PHY_EXT_GPIO_PAGE, PHY_EXT_GPIO_PAGE_SPACE_1);
1631 temp = mii->mdio_read(mii->dev, mii->phy_id, PHY_EXT_MODE_CTRL);
1632 temp &= ~PHY_EXT_MODE_CTRL_MDIX_MASK_;
1633 mii->mdio_write(mii->dev, mii->phy_id, PHY_EXT_MODE_CTRL,
1634 temp | PHY_EXT_MODE_CTRL_AUTO_MDIX_);
1635 mii->mdio_write(mii->dev, mii->phy_id,
1636 PHY_EXT_GPIO_PAGE, PHY_EXT_GPIO_PAGE_SPACE_0);
1637 dev->mdix_ctrl = ETH_TP_MDI_AUTO;
1638
1639 /* MAC doesn't support 1000HD */
1640 temp = mii->mdio_read(mii->dev, mii->phy_id, MII_CTRL1000);
1641 mii->mdio_write(mii->dev, mii->phy_id, MII_CTRL1000,
1642 temp & ~ADVERTISE_1000HALF);
1643
1644 /* clear interrupt */
1645 mii->mdio_read(mii->dev, mii->phy_id, PHY_VTSE_INT_STS);
1646 mii->mdio_write(mii->dev, mii->phy_id, PHY_VTSE_INT_MASK,
1647 PHY_VTSE_INT_MASK_MDINTPIN_EN_ |
1648 PHY_VTSE_INT_MASK_LINK_CHANGE_);
1649
1650 netif_dbg(dev, ifup, dev->net, "phy initialised successfully");
1651
1652 return 0;
1653}
1654
1655static int lan78xx_set_rx_max_frame_length(struct lan78xx_net *dev, int size)
1656{
1657 int ret = 0;
1658 u32 buf;
1659 bool rxenabled;
1660
1661 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
1662
1663 rxenabled = ((buf & MAC_RX_RXEN_) != 0);
1664
1665 if (rxenabled) {
1666 buf &= ~MAC_RX_RXEN_;
1667 ret = lan78xx_write_reg(dev, MAC_RX, buf);
1668 }
1669
1670 /* add 4 to size for FCS */
1671 buf &= ~MAC_RX_MAX_SIZE_MASK_;
1672 buf |= (((size + 4) << MAC_RX_MAX_SIZE_SHIFT_) & MAC_RX_MAX_SIZE_MASK_);
1673
1674 ret = lan78xx_write_reg(dev, MAC_RX, buf);
1675
1676 if (rxenabled) {
1677 buf |= MAC_RX_RXEN_;
1678 ret = lan78xx_write_reg(dev, MAC_RX, buf);
1679 }
1680
1681 return 0;
1682}
1683
1684static int unlink_urbs(struct lan78xx_net *dev, struct sk_buff_head *q)
1685{
1686 struct sk_buff *skb;
1687 unsigned long flags;
1688 int count = 0;
1689
1690 spin_lock_irqsave(&q->lock, flags);
1691 while (!skb_queue_empty(q)) {
1692 struct skb_data *entry;
1693 struct urb *urb;
1694 int ret;
1695
1696 skb_queue_walk(q, skb) {
1697 entry = (struct skb_data *)skb->cb;
1698 if (entry->state != unlink_start)
1699 goto found;
1700 }
1701 break;
1702found:
1703 entry->state = unlink_start;
1704 urb = entry->urb;
1705
1706 /* Get reference count of the URB to avoid it to be
1707 * freed during usb_unlink_urb, which may trigger
1708 * use-after-free problem inside usb_unlink_urb since
1709 * usb_unlink_urb is always racing with .complete
1710 * handler(include defer_bh).
1711 */
1712 usb_get_urb(urb);
1713 spin_unlock_irqrestore(&q->lock, flags);
1714 /* during some PM-driven resume scenarios,
1715 * these (async) unlinks complete immediately
1716 */
1717 ret = usb_unlink_urb(urb);
1718 if (ret != -EINPROGRESS && ret != 0)
1719 netdev_dbg(dev->net, "unlink urb err, %d\n", ret);
1720 else
1721 count++;
1722 usb_put_urb(urb);
1723 spin_lock_irqsave(&q->lock, flags);
1724 }
1725 spin_unlock_irqrestore(&q->lock, flags);
1726 return count;
1727}
1728
1729static int lan78xx_change_mtu(struct net_device *netdev, int new_mtu)
1730{
1731 struct lan78xx_net *dev = netdev_priv(netdev);
1732 int ll_mtu = new_mtu + netdev->hard_header_len;
1733 int old_hard_mtu = dev->hard_mtu;
1734 int old_rx_urb_size = dev->rx_urb_size;
1735 int ret;
1736
1737 if (new_mtu > MAX_SINGLE_PACKET_SIZE)
1738 return -EINVAL;
1739
1740 if (new_mtu <= 0)
1741 return -EINVAL;
1742 /* no second zero-length packet read wanted after mtu-sized packets */
1743 if ((ll_mtu % dev->maxpacket) == 0)
1744 return -EDOM;
1745
1746 ret = lan78xx_set_rx_max_frame_length(dev, new_mtu + ETH_HLEN);
1747
1748 netdev->mtu = new_mtu;
1749
1750 dev->hard_mtu = netdev->mtu + netdev->hard_header_len;
1751 if (dev->rx_urb_size == old_hard_mtu) {
1752 dev->rx_urb_size = dev->hard_mtu;
1753 if (dev->rx_urb_size > old_rx_urb_size) {
1754 if (netif_running(dev->net)) {
1755 unlink_urbs(dev, &dev->rxq);
1756 tasklet_schedule(&dev->bh);
1757 }
1758 }
1759 }
1760
1761 return 0;
1762}
1763
1764int lan78xx_set_mac_addr(struct net_device *netdev, void *p)
1765{
1766 struct lan78xx_net *dev = netdev_priv(netdev);
1767 struct sockaddr *addr = p;
1768 u32 addr_lo, addr_hi;
1769 int ret;
1770
1771 if (netif_running(netdev))
1772 return -EBUSY;
1773
1774 if (!is_valid_ether_addr(addr->sa_data))
1775 return -EADDRNOTAVAIL;
1776
1777 ether_addr_copy(netdev->dev_addr, addr->sa_data);
1778
1779 addr_lo = netdev->dev_addr[0] |
1780 netdev->dev_addr[1] << 8 |
1781 netdev->dev_addr[2] << 16 |
1782 netdev->dev_addr[3] << 24;
1783 addr_hi = netdev->dev_addr[4] |
1784 netdev->dev_addr[5] << 8;
1785
1786 ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
1787 ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
1788
1789 return 0;
1790}
1791
1792/* Enable or disable Rx checksum offload engine */
1793static int lan78xx_set_features(struct net_device *netdev,
1794 netdev_features_t features)
1795{
1796 struct lan78xx_net *dev = netdev_priv(netdev);
1797 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1798 unsigned long flags;
1799 int ret;
1800
1801 spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
1802
1803 if (features & NETIF_F_RXCSUM) {
1804 pdata->rfe_ctl |= RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_;
1805 pdata->rfe_ctl |= RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_;
1806 } else {
1807 pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_);
1808 pdata->rfe_ctl &= ~(RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_);
1809 }
1810
1811 if (features & NETIF_F_HW_VLAN_CTAG_RX)
1812 pdata->rfe_ctl |= RFE_CTL_VLAN_FILTER_;
1813 else
1814 pdata->rfe_ctl &= ~RFE_CTL_VLAN_FILTER_;
1815
1816 spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
1817
1818 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
1819
1820 return 0;
1821}
1822
1823static void lan78xx_deferred_vlan_write(struct work_struct *param)
1824{
1825 struct lan78xx_priv *pdata =
1826 container_of(param, struct lan78xx_priv, set_vlan);
1827 struct lan78xx_net *dev = pdata->dev;
1828
1829 lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, 0,
1830 DP_SEL_VHF_VLAN_LEN, pdata->vlan_table);
1831}
1832
1833static int lan78xx_vlan_rx_add_vid(struct net_device *netdev,
1834 __be16 proto, u16 vid)
1835{
1836 struct lan78xx_net *dev = netdev_priv(netdev);
1837 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1838 u16 vid_bit_index;
1839 u16 vid_dword_index;
1840
1841 vid_dword_index = (vid >> 5) & 0x7F;
1842 vid_bit_index = vid & 0x1F;
1843
1844 pdata->vlan_table[vid_dword_index] |= (1 << vid_bit_index);
1845
1846 /* defer register writes to a sleepable context */
1847 schedule_work(&pdata->set_vlan);
1848
1849 return 0;
1850}
1851
1852static int lan78xx_vlan_rx_kill_vid(struct net_device *netdev,
1853 __be16 proto, u16 vid)
1854{
1855 struct lan78xx_net *dev = netdev_priv(netdev);
1856 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1857 u16 vid_bit_index;
1858 u16 vid_dword_index;
1859
1860 vid_dword_index = (vid >> 5) & 0x7F;
1861 vid_bit_index = vid & 0x1F;
1862
1863 pdata->vlan_table[vid_dword_index] &= ~(1 << vid_bit_index);
1864
1865 /* defer register writes to a sleepable context */
1866 schedule_work(&pdata->set_vlan);
1867
1868 return 0;
1869}
1870
1871static void lan78xx_init_ltm(struct lan78xx_net *dev)
1872{
1873 int ret;
1874 u32 buf;
1875 u32 regs[6] = { 0 };
1876
1877 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1878 if (buf & USB_CFG1_LTM_ENABLE_) {
1879 u8 temp[2];
1880 /* Get values from EEPROM first */
1881 if (lan78xx_read_eeprom(dev, 0x3F, 2, temp) == 0) {
1882 if (temp[0] == 24) {
1883 ret = lan78xx_read_raw_eeprom(dev,
1884 temp[1] * 2,
1885 24,
1886 (u8 *)regs);
1887 if (ret < 0)
1888 return;
1889 }
1890 } else if (lan78xx_read_otp(dev, 0x3F, 2, temp) == 0) {
1891 if (temp[0] == 24) {
1892 ret = lan78xx_read_raw_otp(dev,
1893 temp[1] * 2,
1894 24,
1895 (u8 *)regs);
1896 if (ret < 0)
1897 return;
1898 }
1899 }
1900 }
1901
1902 lan78xx_write_reg(dev, LTM_BELT_IDLE0, regs[0]);
1903 lan78xx_write_reg(dev, LTM_BELT_IDLE1, regs[1]);
1904 lan78xx_write_reg(dev, LTM_BELT_ACT0, regs[2]);
1905 lan78xx_write_reg(dev, LTM_BELT_ACT1, regs[3]);
1906 lan78xx_write_reg(dev, LTM_INACTIVE0, regs[4]);
1907 lan78xx_write_reg(dev, LTM_INACTIVE1, regs[5]);
1908}
1909
1910static int lan78xx_reset(struct lan78xx_net *dev)
1911{
1912 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1913 u32 buf;
1914 int ret = 0;
1915 unsigned long timeout;
1916
1917 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
1918 buf |= HW_CFG_LRST_;
1919 ret = lan78xx_write_reg(dev, HW_CFG, buf);
1920
1921 timeout = jiffies + HZ;
1922 do {
1923 mdelay(1);
1924 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
1925 if (time_after(jiffies, timeout)) {
1926 netdev_warn(dev->net,
1927 "timeout on completion of LiteReset");
1928 return -EIO;
1929 }
1930 } while (buf & HW_CFG_LRST_);
1931
1932 lan78xx_init_mac_address(dev);
1933
1934 /* Respond to the IN token with a NAK */
1935 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1936 buf |= USB_CFG_BIR_;
1937 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
1938
1939 /* Init LTM */
1940 lan78xx_init_ltm(dev);
1941
1942 dev->net->hard_header_len += TX_OVERHEAD;
1943 dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
1944
1945 if (dev->udev->speed == USB_SPEED_SUPER) {
1946 buf = DEFAULT_BURST_CAP_SIZE / SS_USB_PKT_SIZE;
1947 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
1948 dev->rx_qlen = 4;
1949 dev->tx_qlen = 4;
1950 } else if (dev->udev->speed == USB_SPEED_HIGH) {
1951 buf = DEFAULT_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
1952 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
1953 dev->rx_qlen = RX_MAX_QUEUE_MEMORY / dev->rx_urb_size;
1954 dev->tx_qlen = RX_MAX_QUEUE_MEMORY / dev->hard_mtu;
1955 } else {
1956 buf = DEFAULT_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
1957 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
1958 dev->rx_qlen = 4;
1959 }
1960
1961 ret = lan78xx_write_reg(dev, BURST_CAP, buf);
1962 ret = lan78xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
1963
1964 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
1965 buf |= HW_CFG_MEF_;
1966 ret = lan78xx_write_reg(dev, HW_CFG, buf);
1967
1968 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1969 buf |= USB_CFG_BCE_;
1970 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
1971
1972 /* set FIFO sizes */
1973 buf = (MAX_RX_FIFO_SIZE - 512) / 512;
1974 ret = lan78xx_write_reg(dev, FCT_RX_FIFO_END, buf);
1975
1976 buf = (MAX_TX_FIFO_SIZE - 512) / 512;
1977 ret = lan78xx_write_reg(dev, FCT_TX_FIFO_END, buf);
1978
1979 ret = lan78xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
1980 ret = lan78xx_write_reg(dev, FLOW, 0);
1981 ret = lan78xx_write_reg(dev, FCT_FLOW, 0);
1982
1983 /* Don't need rfe_ctl_lock during initialisation */
1984 ret = lan78xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
1985 pdata->rfe_ctl |= RFE_CTL_BCAST_EN_ | RFE_CTL_DA_PERFECT_;
1986 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
1987
1988 /* Enable or disable checksum offload engines */
1989 lan78xx_set_features(dev->net, dev->net->features);
1990
1991 lan78xx_set_multicast(dev->net);
1992
1993 /* reset PHY */
1994 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
1995 buf |= PMT_CTL_PHY_RST_;
1996 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
1997
1998 timeout = jiffies + HZ;
1999 do {
2000 mdelay(1);
2001 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
2002 if (time_after(jiffies, timeout)) {
2003 netdev_warn(dev->net, "timeout waiting for PHY Reset");
2004 return -EIO;
2005 }
2006 } while (buf & PMT_CTL_PHY_RST_);
2007
2008 lan78xx_mii_init(dev);
2009
2010 ret = lan78xx_phy_init(dev);
2011
2012 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
2013
2014 buf |= MAC_CR_GMII_EN_;
2015 buf |= MAC_CR_AUTO_DUPLEX_ | MAC_CR_AUTO_SPEED_;
2016
2017 ret = lan78xx_write_reg(dev, MAC_CR, buf);
2018
2019 /* enable on PHY */
2020 if (buf & MAC_CR_EEE_EN_)
2021 lan78xx_mmd_write(dev->net, dev->mii.phy_id, 0x07, 0x3C, 0x06);
2022
2023 /* enable PHY interrupts */
2024 ret = lan78xx_read_reg(dev, INT_EP_CTL, &buf);
2025 buf |= INT_ENP_PHY_INT;
2026 ret = lan78xx_write_reg(dev, INT_EP_CTL, buf);
2027
2028 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
2029 buf |= MAC_TX_TXEN_;
2030 ret = lan78xx_write_reg(dev, MAC_TX, buf);
2031
2032 ret = lan78xx_read_reg(dev, FCT_TX_CTL, &buf);
2033 buf |= FCT_TX_CTL_EN_;
2034 ret = lan78xx_write_reg(dev, FCT_TX_CTL, buf);
2035
2036 ret = lan78xx_set_rx_max_frame_length(dev, dev->net->mtu + ETH_HLEN);
2037
2038 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
2039 buf |= MAC_RX_RXEN_;
2040 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2041
2042 ret = lan78xx_read_reg(dev, FCT_RX_CTL, &buf);
2043 buf |= FCT_RX_CTL_EN_;
2044 ret = lan78xx_write_reg(dev, FCT_RX_CTL, buf);
2045
2046 if (!mii_nway_restart(&dev->mii))
2047 netif_dbg(dev, link, dev->net, "autoneg initiated");
2048
2049 return 0;
2050}
2051
2052static int lan78xx_open(struct net_device *net)
2053{
2054 struct lan78xx_net *dev = netdev_priv(net);
2055 int ret;
2056
2057 ret = usb_autopm_get_interface(dev->intf);
2058 if (ret < 0)
2059 goto out;
2060
2061 ret = lan78xx_reset(dev);
2062 if (ret < 0)
2063 goto done;
2064
2065 /* for Link Check */
2066 if (dev->urb_intr) {
2067 ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
2068 if (ret < 0) {
2069 netif_err(dev, ifup, dev->net,
2070 "intr submit %d\n", ret);
2071 goto done;
2072 }
2073 }
2074
2075 set_bit(EVENT_DEV_OPEN, &dev->flags);
2076
2077 netif_start_queue(net);
2078
2079 dev->link_on = false;
2080
2081 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
2082done:
2083 usb_autopm_put_interface(dev->intf);
2084
2085out:
2086 return ret;
2087}
2088
2089static void lan78xx_terminate_urbs(struct lan78xx_net *dev)
2090{
2091 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);
2092 DECLARE_WAITQUEUE(wait, current);
2093 int temp;
2094
2095 /* ensure there are no more active urbs */
2096 add_wait_queue(&unlink_wakeup, &wait);
2097 set_current_state(TASK_UNINTERRUPTIBLE);
2098 dev->wait = &unlink_wakeup;
2099 temp = unlink_urbs(dev, &dev->txq) + unlink_urbs(dev, &dev->rxq);
2100
2101 /* maybe wait for deletions to finish. */
2102 while (!skb_queue_empty(&dev->rxq) &&
2103 !skb_queue_empty(&dev->txq) &&
2104 !skb_queue_empty(&dev->done)) {
2105 schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
2106 set_current_state(TASK_UNINTERRUPTIBLE);
2107 netif_dbg(dev, ifdown, dev->net,
2108 "waited for %d urb completions\n", temp);
2109 }
2110 set_current_state(TASK_RUNNING);
2111 dev->wait = NULL;
2112 remove_wait_queue(&unlink_wakeup, &wait);
2113}
2114
2115int lan78xx_stop(struct net_device *net)
2116{
2117 struct lan78xx_net *dev = netdev_priv(net);
2118
2119 clear_bit(EVENT_DEV_OPEN, &dev->flags);
2120 netif_stop_queue(net);
2121
2122 netif_info(dev, ifdown, dev->net,
2123 "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
2124 net->stats.rx_packets, net->stats.tx_packets,
2125 net->stats.rx_errors, net->stats.tx_errors);
2126
2127 lan78xx_terminate_urbs(dev);
2128
2129 usb_kill_urb(dev->urb_intr);
2130
2131 skb_queue_purge(&dev->rxq_pause);
2132
2133 /* deferred work (task, timer, softirq) must also stop.
2134 * can't flush_scheduled_work() until we drop rtnl (later),
2135 * else workers could deadlock; so make workers a NOP.
2136 */
2137 dev->flags = 0;
2138 cancel_delayed_work_sync(&dev->wq);
2139 tasklet_kill(&dev->bh);
2140
2141 usb_autopm_put_interface(dev->intf);
2142
2143 return 0;
2144}
2145
2146static int lan78xx_linearize(struct sk_buff *skb)
2147{
2148 return skb_linearize(skb);
2149}
2150
2151static struct sk_buff *lan78xx_tx_prep(struct lan78xx_net *dev,
2152 struct sk_buff *skb, gfp_t flags)
2153{
2154 u32 tx_cmd_a, tx_cmd_b;
2155
2156 if (skb_headroom(skb) < TX_OVERHEAD) {
2157 struct sk_buff *skb2;
2158
2159 skb2 = skb_copy_expand(skb, TX_OVERHEAD, 0, flags);
2160 dev_kfree_skb_any(skb);
2161 skb = skb2;
2162 if (!skb)
2163 return NULL;
2164 }
2165
2166 if (lan78xx_linearize(skb) < 0)
2167 return NULL;
2168
2169 tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN_MASK_) | TX_CMD_A_FCS_;
2170
2171 if (skb->ip_summed == CHECKSUM_PARTIAL)
2172 tx_cmd_a |= TX_CMD_A_IPE_ | TX_CMD_A_TPE_;
2173
2174 tx_cmd_b = 0;
2175 if (skb_is_gso(skb)) {
2176 u16 mss = max(skb_shinfo(skb)->gso_size, TX_CMD_B_MSS_MIN_);
2177
2178 tx_cmd_b = (mss << TX_CMD_B_MSS_SHIFT_) & TX_CMD_B_MSS_MASK_;
2179
2180 tx_cmd_a |= TX_CMD_A_LSO_;
2181 }
2182
2183 if (skb_vlan_tag_present(skb)) {
2184 tx_cmd_a |= TX_CMD_A_IVTG_;
2185 tx_cmd_b |= skb_vlan_tag_get(skb) & TX_CMD_B_VTAG_MASK_;
2186 }
2187
2188 skb_push(skb, 4);
2189 cpu_to_le32s(&tx_cmd_b);
2190 memcpy(skb->data, &tx_cmd_b, 4);
2191
2192 skb_push(skb, 4);
2193 cpu_to_le32s(&tx_cmd_a);
2194 memcpy(skb->data, &tx_cmd_a, 4);
2195
2196 return skb;
2197}
2198
2199static enum skb_state defer_bh(struct lan78xx_net *dev, struct sk_buff *skb,
2200 struct sk_buff_head *list, enum skb_state state)
2201{
2202 unsigned long flags;
2203 enum skb_state old_state;
2204 struct skb_data *entry = (struct skb_data *)skb->cb;
2205
2206 spin_lock_irqsave(&list->lock, flags);
2207 old_state = entry->state;
2208 entry->state = state;
55d7de9d
WH		 2209
2210 __skb_unlink(skb, list);
2211 spin_unlock(&list->lock);
2212 spin_lock(&dev->done.lock);
55d7de9d
WH		 2213
2214 __skb_queue_tail(&dev->done, skb);
2215 if (skb_queue_len(&dev->done) == 1)
2216 tasklet_schedule(&dev->bh);
2217 spin_unlock_irqrestore(&dev->done.lock, flags);
2218
2219 return old_state;
2220}
2221
2222static void tx_complete(struct urb *urb)
2223{
2224 struct sk_buff *skb = (struct sk_buff *)urb->context;
2225 struct skb_data *entry = (struct skb_data *)skb->cb;
2226 struct lan78xx_net *dev = entry->dev;
2227
2228 if (urb->status == 0) {
2229 dev->net->stats.tx_packets++;
2230 dev->net->stats.tx_bytes += entry->length;
2231 } else {
2232 dev->net->stats.tx_errors++;
2233
2234 switch (urb->status) {
2235 case -EPIPE:
2236 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
2237 break;
2238
2239 /* software-driven interface shutdown */
2240 case -ECONNRESET:
2241 case -ESHUTDOWN:
2242 break;
2243
2244 case -EPROTO:
2245 case -ETIME:
2246 case -EILSEQ:
2247 netif_stop_queue(dev->net);
2248 break;
2249 default:
2250 netif_dbg(dev, tx_err, dev->net,
2251 "tx err %d\n", entry->urb->status);
2252 break;
2253 }
2254 }
2255
2256 usb_autopm_put_interface_async(dev->intf);
2257
81c38e81 2258 defer_bh(dev, skb, &dev->txq, tx_done);
55d7de9d
WH		 2259}
2260
2261static void lan78xx_queue_skb(struct sk_buff_head *list,
2262 struct sk_buff *newsk, enum skb_state state)
2263{
2264 struct skb_data *entry = (struct skb_data *)newsk->cb;
2265
2266 __skb_queue_tail(list, newsk);
2267 entry->state = state;
2268}
2269
2270netdev_tx_t lan78xx_start_xmit(struct sk_buff *skb, struct net_device *net)
2271{
2272 struct lan78xx_net *dev = netdev_priv(net);
81c38e81 2273 struct sk_buff *skb2 = NULL;
55d7de9d 2274
81c38e81 2275 if (skb) {
55d7de9d 2276 skb_tx_timestamp(skb);
81c38e81
WH		 2277 skb2 = lan78xx_tx_prep(dev, skb, GFP_ATOMIC);
2278 }
55d7de9d 2279
81c38e81
WH		 2280 if (skb2) {
2281 skb_queue_tail(&dev->txq_pend, skb2);
55d7de9d
WH		 2282
2283 if (skb_queue_len(&dev->txq_pend) > 10)
2284 netif_stop_queue(net);
2285 } else {
2286 netif_dbg(dev, tx_err, dev->net,
2287 "lan78xx_tx_prep return NULL\n");
2288 dev->net->stats.tx_errors++;
2289 dev->net->stats.tx_dropped++;
2290 }
2291
2292 tasklet_schedule(&dev->bh);
2293
2294 return NETDEV_TX_OK;
2295}
2296
2297int lan78xx_get_endpoints(struct lan78xx_net *dev, struct usb_interface *intf)
2298{
2299 int tmp;
2300 struct usb_host_interface *alt = NULL;
2301 struct usb_host_endpoint *in = NULL, *out = NULL;
2302 struct usb_host_endpoint *status = NULL;
2303
2304 for (tmp = 0; tmp < intf->num_altsetting; tmp++) {
2305 unsigned ep;
2306
2307 in = NULL;
2308 out = NULL;
2309 status = NULL;
2310 alt = intf->altsetting + tmp;
2311
2312 for (ep = 0; ep < alt->desc.bNumEndpoints; ep++) {
2313 struct usb_host_endpoint *e;
2314 int intr = 0;
2315
2316 e = alt->endpoint + ep;
2317 switch (e->desc.bmAttributes) {
2318 case USB_ENDPOINT_XFER_INT:
2319 if (!usb_endpoint_dir_in(&e->desc))
2320 continue;
2321 intr = 1;
2322 /* FALLTHROUGH */
2323 case USB_ENDPOINT_XFER_BULK:
2324 break;
2325 default:
2326 continue;
2327 }
2328 if (usb_endpoint_dir_in(&e->desc)) {
2329 if (!intr && !in)
2330 in = e;
2331 else if (intr && !status)
2332 status = e;
2333 } else {
2334 if (!out)
2335 out = e;
2336 }
2337 }
2338 if (in && out)
2339 break;
2340 }
2341 if (!alt || !in || !out)
2342 return -EINVAL;
2343
2344 dev->pipe_in = usb_rcvbulkpipe(dev->udev,
2345 in->desc.bEndpointAddress &
2346 USB_ENDPOINT_NUMBER_MASK);
2347 dev->pipe_out = usb_sndbulkpipe(dev->udev,
2348 out->desc.bEndpointAddress &
2349 USB_ENDPOINT_NUMBER_MASK);
2350 dev->ep_intr = status;
2351
2352 return 0;
2353}
2354
2355static int lan78xx_bind(struct lan78xx_net *dev, struct usb_interface *intf)
2356{
2357 struct lan78xx_priv *pdata = NULL;
2358 int ret;
2359 int i;
2360
2361 ret = lan78xx_get_endpoints(dev, intf);
2362
2363 dev->data[0] = (unsigned long)kzalloc(sizeof(*pdata), GFP_KERNEL);
2364
2365 pdata = (struct lan78xx_priv *)(dev->data[0]);
2366 if (!pdata) {
2367 netdev_warn(dev->net, "Unable to allocate lan78xx_priv");
2368 return -ENOMEM;
2369 }
2370
2371 pdata->dev = dev;
2372
2373 spin_lock_init(&pdata->rfe_ctl_lock);
2374 mutex_init(&pdata->dataport_mutex);
2375
2376 INIT_WORK(&pdata->set_multicast, lan78xx_deferred_multicast_write);
2377
2378 for (i = 0; i < DP_SEL_VHF_VLAN_LEN; i++)
2379 pdata->vlan_table[i] = 0;
2380
2381 INIT_WORK(&pdata->set_vlan, lan78xx_deferred_vlan_write);
2382
2383 dev->net->features = 0;
2384
2385 if (DEFAULT_TX_CSUM_ENABLE)
2386 dev->net->features |= NETIF_F_HW_CSUM;
2387
2388 if (DEFAULT_RX_CSUM_ENABLE)
2389 dev->net->features |= NETIF_F_RXCSUM;
2390
2391 if (DEFAULT_TSO_CSUM_ENABLE)
2392 dev->net->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_SG;
2393
2394 dev->net->hw_features = dev->net->features;
2395
2396 /* Init all registers */
2397 ret = lan78xx_reset(dev);
2398
2399 dev->net->flags |= IFF_MULTICAST;
2400
2401 pdata->wol = WAKE_MAGIC;
2402
2403 return 0;
2404}
2405
2406static void lan78xx_unbind(struct lan78xx_net *dev, struct usb_interface *intf)
2407{
2408 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2409
2410 if (pdata) {
2411 netif_dbg(dev, ifdown, dev->net, "free pdata");
2412 kfree(pdata);
2413 pdata = NULL;
2414 dev->data[0] = 0;
2415 }
2416}
2417
2418static void lan78xx_rx_csum_offload(struct lan78xx_net *dev,
2419 struct sk_buff *skb,
2420 u32 rx_cmd_a, u32 rx_cmd_b)
2421{
2422 if (!(dev->net->features & NETIF_F_RXCSUM) ||
2423 unlikely(rx_cmd_a & RX_CMD_A_ICSM_)) {
2424 skb->ip_summed = CHECKSUM_NONE;
2425 } else {
2426 skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT_));
2427 skb->ip_summed = CHECKSUM_COMPLETE;
2428 }
2429}
2430
2431void lan78xx_skb_return(struct lan78xx_net *dev, struct sk_buff *skb)
2432{
2433 int status;
2434
2435 if (test_bit(EVENT_RX_PAUSED, &dev->flags)) {
2436 skb_queue_tail(&dev->rxq_pause, skb);
2437 return;
2438 }
2439
2440 skb->protocol = eth_type_trans(skb, dev->net);
2441 dev->net->stats.rx_packets++;
2442 dev->net->stats.rx_bytes += skb->len;
2443
2444 netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
2445 skb->len + sizeof(struct ethhdr), skb->protocol);
2446 memset(skb->cb, 0, sizeof(struct skb_data));
2447
2448 if (skb_defer_rx_timestamp(skb))
2449 return;
2450
2451 status = netif_rx(skb);
2452 if (status != NET_RX_SUCCESS)
2453 netif_dbg(dev, rx_err, dev->net,
2454 "netif_rx status %d\n", status);
2455}
2456
2457static int lan78xx_rx(struct lan78xx_net *dev, struct sk_buff *skb)
2458{
2459 if (skb->len < dev->net->hard_header_len)
2460 return 0;
2461
2462 while (skb->len > 0) {
2463 u32 rx_cmd_a, rx_cmd_b, align_count, size;
2464 u16 rx_cmd_c;
2465 struct sk_buff *skb2;
2466 unsigned char *packet;
2467
2468 memcpy(&rx_cmd_a, skb->data, sizeof(rx_cmd_a));
2469 le32_to_cpus(&rx_cmd_a);
2470 skb_pull(skb, sizeof(rx_cmd_a));
2471
2472 memcpy(&rx_cmd_b, skb->data, sizeof(rx_cmd_b));
2473 le32_to_cpus(&rx_cmd_b);
2474 skb_pull(skb, sizeof(rx_cmd_b));
2475
2476 memcpy(&rx_cmd_c, skb->data, sizeof(rx_cmd_c));
2477 le16_to_cpus(&rx_cmd_c);
2478 skb_pull(skb, sizeof(rx_cmd_c));
2479
2480 packet = skb->data;
2481
2482 /* get the packet length */
2483 size = (rx_cmd_a & RX_CMD_A_LEN_MASK_);
2484 align_count = (4 - ((size + RXW_PADDING) % 4)) % 4;
2485
2486 if (unlikely(rx_cmd_a & RX_CMD_A_RED_)) {
2487 netif_dbg(dev, rx_err, dev->net,
2488 "Error rx_cmd_a=0x%08x", rx_cmd_a);
2489 } else {
2490 /* last frame in this batch */
2491 if (skb->len == size) {
2492 lan78xx_rx_csum_offload(dev, skb,
2493 rx_cmd_a, rx_cmd_b);
2494
2495 skb_trim(skb, skb->len - 4); /* remove fcs */
2496 skb->truesize = size + sizeof(struct sk_buff);
2497
2498 return 1;
2499 }
2500
2501 skb2 = skb_clone(skb, GFP_ATOMIC);
2502 if (unlikely(!skb2)) {
2503 netdev_warn(dev->net, "Error allocating skb");
2504 return 0;
2505 }
2506
2507 skb2->len = size;
2508 skb2->data = packet;
2509 skb_set_tail_pointer(skb2, size);
2510
2511 lan78xx_rx_csum_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
2512
2513 skb_trim(skb2, skb2->len - 4); /* remove fcs */
2514 skb2->truesize = size + sizeof(struct sk_buff);
2515
2516 lan78xx_skb_return(dev, skb2);
2517 }
2518
2519 skb_pull(skb, size);
2520
2521 /* padding bytes before the next frame starts */
2522 if (skb->len)
2523 skb_pull(skb, align_count);
2524 }
2525
2526 if (unlikely(skb->len < 0)) {
2527 netdev_warn(dev->net, "invalid rx length<0 %d", skb->len);
2528 return 0;
2529 }
2530
2531 return 1;
2532}
2533
2534static inline void rx_process(struct lan78xx_net *dev, struct sk_buff *skb)
2535{
2536 if (!lan78xx_rx(dev, skb)) {
2537 dev->net->stats.rx_errors++;
2538 goto done;
2539 }
2540
2541 if (skb->len) {
2542 lan78xx_skb_return(dev, skb);
2543 return;
2544 }
2545
2546 netif_dbg(dev, rx_err, dev->net, "drop\n");
2547 dev->net->stats.rx_errors++;
2548done:
2549 skb_queue_tail(&dev->done, skb);
2550}
2551
2552static void rx_complete(struct urb *urb);
2553
2554static int rx_submit(struct lan78xx_net *dev, struct urb *urb, gfp_t flags)
2555{
2556 struct sk_buff *skb;
2557 struct skb_data *entry;
2558 unsigned long lockflags;
2559 size_t size = dev->rx_urb_size;
2560 int ret = 0;
2561
2562 skb = netdev_alloc_skb_ip_align(dev->net, size);
2563 if (!skb) {
2564 usb_free_urb(urb);
2565 return -ENOMEM;
2566 }
2567
2568 entry = (struct skb_data *)skb->cb;
2569 entry->urb = urb;
2570 entry->dev = dev;
2571 entry->length = 0;
2572
2573 usb_fill_bulk_urb(urb, dev->udev, dev->pipe_in,
2574 skb->data, size, rx_complete, skb);
2575
2576 spin_lock_irqsave(&dev->rxq.lock, lockflags);
2577
2578 if (netif_device_present(dev->net) &&
2579 netif_running(dev->net) &&
2580 !test_bit(EVENT_RX_HALT, &dev->flags) &&
2581 !test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
2582 ret = usb_submit_urb(urb, GFP_ATOMIC);
2583 switch (ret) {
2584 case 0:
2585 lan78xx_queue_skb(&dev->rxq, skb, rx_start);
2586 break;
2587 case -EPIPE:
2588 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
2589 break;
2590 case -ENODEV:
2591 netif_dbg(dev, ifdown, dev->net, "device gone\n");
2592 netif_device_detach(dev->net);
2593 break;
2594 case -EHOSTUNREACH:
2595 ret = -ENOLINK;
2596 break;
2597 default:
2598 netif_dbg(dev, rx_err, dev->net,
2599 "rx submit, %d\n", ret);
2600 tasklet_schedule(&dev->bh);
2601 }
2602 } else {
2603 netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
2604 ret = -ENOLINK;
2605 }
2606 spin_unlock_irqrestore(&dev->rxq.lock, lockflags);
2607 if (ret) {
2608 dev_kfree_skb_any(skb);
2609 usb_free_urb(urb);
2610 }
2611 return ret;
2612}
2613
2614static void rx_complete(struct urb *urb)
2615{
2616 struct sk_buff *skb = (struct sk_buff *)urb->context;
2617 struct skb_data *entry = (struct skb_data *)skb->cb;
2618 struct lan78xx_net *dev = entry->dev;
2619 int urb_status = urb->status;
2620 enum skb_state state;
2621
2622 skb_put(skb, urb->actual_length);
2623 state = rx_done;
2624 entry->urb = NULL;
2625
2626 switch (urb_status) {
2627 case 0:
2628 if (skb->len < dev->net->hard_header_len) {
2629 state = rx_cleanup;
2630 dev->net->stats.rx_errors++;
2631 dev->net->stats.rx_length_errors++;
2632 netif_dbg(dev, rx_err, dev->net,
2633 "rx length %d\n", skb->len);
2634 }
2635 usb_mark_last_busy(dev->udev);
2636 break;
2637 case -EPIPE:
2638 dev->net->stats.rx_errors++;
2639 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
2640 /* FALLTHROUGH */
2641 case -ECONNRESET: /* async unlink */
2642 case -ESHUTDOWN: /* hardware gone */
2643 netif_dbg(dev, ifdown, dev->net,
2644 "rx shutdown, code %d\n", urb_status);
2645 state = rx_cleanup;
2646 entry->urb = urb;
2647 urb = NULL;
2648 break;
2649 case -EPROTO:
2650 case -ETIME:
2651 case -EILSEQ:
2652 dev->net->stats.rx_errors++;
2653 state = rx_cleanup;
2654 entry->urb = urb;
2655 urb = NULL;
2656 break;
2657
2658 /* data overrun ... flush fifo? */
2659 case -EOVERFLOW:
2660 dev->net->stats.rx_over_errors++;
2661 /* FALLTHROUGH */
2662
2663 default:
2664 state = rx_cleanup;
2665 dev->net->stats.rx_errors++;
2666 netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
2667 break;
2668 }
2669
2670 state = defer_bh(dev, skb, &dev->rxq, state);
2671
2672 if (urb) {
2673 if (netif_running(dev->net) &&
2674 !test_bit(EVENT_RX_HALT, &dev->flags) &&
2675 state != unlink_start) {
2676 rx_submit(dev, urb, GFP_ATOMIC);
2677 return;
2678 }
2679 usb_free_urb(urb);
2680 }
2681 netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n");
2682}
2683
2684static void lan78xx_tx_bh(struct lan78xx_net *dev)
2685{
2686 int length;
2687 struct urb *urb = NULL;
2688 struct skb_data *entry;
2689 unsigned long flags;
2690 struct sk_buff_head *tqp = &dev->txq_pend;
2691 struct sk_buff *skb, *skb2;
2692 int ret;
2693 int count, pos;
2694 int skb_totallen, pkt_cnt;
2695
2696 skb_totallen = 0;
2697 pkt_cnt = 0;
2698 for (skb = tqp->next; pkt_cnt < tqp->qlen; skb = skb->next) {
2699 if (skb_is_gso(skb)) {
2700 if (pkt_cnt) {
2701 /* handle previous packets first */
2702 break;
2703 }
2704 length = skb->len;
2705 skb2 = skb_dequeue(tqp);
2706 goto gso_skb;
2707 }
2708
2709 if ((skb_totallen + skb->len) > MAX_SINGLE_PACKET_SIZE)
2710 break;
2711 skb_totallen = skb->len + roundup(skb_totallen, sizeof(u32));
2712 pkt_cnt++;
2713 }
2714
2715 /* copy to a single skb */
2716 skb = alloc_skb(skb_totallen, GFP_ATOMIC);
2717 if (!skb)
2718 goto drop;
2719
2720 skb_put(skb, skb_totallen);
2721
2722 for (count = pos = 0; count < pkt_cnt; count++) {
2723 skb2 = skb_dequeue(tqp);
2724 if (skb2) {
2725 memcpy(skb->data + pos, skb2->data, skb2->len);
2726 pos += roundup(skb2->len, sizeof(u32));
2727 dev_kfree_skb(skb2);
55d7de9d
WH		 2728 }
2729 }
2730
2731 length = skb_totallen;
2732
2733gso_skb:
2734 urb = usb_alloc_urb(0, GFP_ATOMIC);
2735 if (!urb) {
2736 netif_dbg(dev, tx_err, dev->net, "no urb\n");
2737 goto drop;
2738 }
2739
2740 entry = (struct skb_data *)skb->cb;
2741 entry->urb = urb;
2742 entry->dev = dev;
2743 entry->length = length;
2744
2745 spin_lock_irqsave(&dev->txq.lock, flags);
2746 ret = usb_autopm_get_interface_async(dev->intf);
2747 if (ret < 0) {
2748 spin_unlock_irqrestore(&dev->txq.lock, flags);
2749 goto drop;
2750 }
2751
2752 usb_fill_bulk_urb(urb, dev->udev, dev->pipe_out,
2753 skb->data, skb->len, tx_complete, skb);
2754
2755 if (length % dev->maxpacket == 0) {
2756 /* send USB_ZERO_PACKET */
2757 urb->transfer_flags |= URB_ZERO_PACKET;
2758 }
2759
2760#ifdef CONFIG_PM
2761 /* if this triggers the device is still a sleep */
2762 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
2763 /* transmission will be done in resume */
2764 usb_anchor_urb(urb, &dev->deferred);
2765 /* no use to process more packets */
2766 netif_stop_queue(dev->net);
2767 usb_put_urb(urb);
2768 spin_unlock_irqrestore(&dev->txq.lock, flags);
2769 netdev_dbg(dev->net, "Delaying transmission for resumption\n");
2770 return;
2771 }
2772#endif
2773
2774 ret = usb_submit_urb(urb, GFP_ATOMIC);
2775 switch (ret) {
2776 case 0:
2777 dev->net->trans_start = jiffies;
2778 lan78xx_queue_skb(&dev->txq, skb, tx_start);
2779 if (skb_queue_len(&dev->txq) >= dev->tx_qlen)
2780 netif_stop_queue(dev->net);
2781 break;
2782 case -EPIPE:
2783 netif_stop_queue(dev->net);
2784 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
2785 usb_autopm_put_interface_async(dev->intf);
2786 break;
2787 default:
2788 usb_autopm_put_interface_async(dev->intf);
2789 netif_dbg(dev, tx_err, dev->net,
2790 "tx: submit urb err %d\n", ret);
2791 break;
2792 }
2793
2794 spin_unlock_irqrestore(&dev->txq.lock, flags);
2795
2796 if (ret) {
2797 netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", ret);
2798drop:
2799 dev->net->stats.tx_dropped++;
2800 if (skb)
2801 dev_kfree_skb_any(skb);
2802 usb_free_urb(urb);
2803 } else
2804 netif_dbg(dev, tx_queued, dev->net,
2805 "> tx, len %d, type 0x%x\n", length, skb->protocol);
2806}
2807
2808static void lan78xx_rx_bh(struct lan78xx_net *dev)
2809{
2810 struct urb *urb;
2811 int i;
2812
2813 if (skb_queue_len(&dev->rxq) < dev->rx_qlen) {
2814 for (i = 0; i < 10; i++) {
2815 if (skb_queue_len(&dev->rxq) >= dev->rx_qlen)
2816 break;
2817 urb = usb_alloc_urb(0, GFP_ATOMIC);
2818 if (urb)
2819 if (rx_submit(dev, urb, GFP_ATOMIC) == -ENOLINK)
2820 return;
2821 }
2822
2823 if (skb_queue_len(&dev->rxq) < dev->rx_qlen)
2824 tasklet_schedule(&dev->bh);
2825 }
2826 if (skb_queue_len(&dev->txq) < dev->tx_qlen)
2827 netif_wake_queue(dev->net);
2828}
2829
2830static void lan78xx_bh(unsigned long param)
2831{
2832 struct lan78xx_net *dev = (struct lan78xx_net *)param;
2833 struct sk_buff *skb;
2834 struct skb_data *entry;
2835
55d7de9d
WH		 2836 while ((skb = skb_dequeue(&dev->done))) {
2837 entry = (struct skb_data *)(skb->cb);
2838 switch (entry->state) {
2839 case rx_done:
2840 entry->state = rx_cleanup;
2841 rx_process(dev, skb);
2842 continue;
2843 case tx_done:
2844 usb_free_urb(entry->urb);
2845 dev_kfree_skb(skb);
2846 continue;
2847 case rx_cleanup:
2848 usb_free_urb(entry->urb);
2849 dev_kfree_skb(skb);
2850 continue;
2851 default:
2852 netdev_dbg(dev->net, "skb state %d\n", entry->state);
2853 return;
2854 }
55d7de9d
WH		 2855 }
2856
2857 if (netif_device_present(dev->net) && netif_running(dev->net)) {
2858 if (!skb_queue_empty(&dev->txq_pend))
2859 lan78xx_tx_bh(dev);
2860
2861 if (!timer_pending(&dev->delay) &&
2862 !test_bit(EVENT_RX_HALT, &dev->flags))
2863 lan78xx_rx_bh(dev);
2864 }
2865}
2866
2867static void lan78xx_delayedwork(struct work_struct *work)
2868{
2869 int status;
2870 struct lan78xx_net *dev;
2871
2872 dev = container_of(work, struct lan78xx_net, wq.work);
2873
2874 if (test_bit(EVENT_TX_HALT, &dev->flags)) {
2875 unlink_urbs(dev, &dev->txq);
2876 status = usb_autopm_get_interface(dev->intf);
2877 if (status < 0)
2878 goto fail_pipe;
2879 status = usb_clear_halt(dev->udev, dev->pipe_out);
2880 usb_autopm_put_interface(dev->intf);
2881 if (status < 0 &&
2882 status != -EPIPE &&
2883 status != -ESHUTDOWN) {
2884 if (netif_msg_tx_err(dev))
2885fail_pipe:
2886 netdev_err(dev->net,
2887 "can't clear tx halt, status %d\n",
2888 status);
2889 } else {
2890 clear_bit(EVENT_TX_HALT, &dev->flags);
2891 if (status != -ESHUTDOWN)
2892 netif_wake_queue(dev->net);
2893 }
2894 }
2895 if (test_bit(EVENT_RX_HALT, &dev->flags)) {
2896 unlink_urbs(dev, &dev->rxq);
2897 status = usb_autopm_get_interface(dev->intf);
2898 if (status < 0)
2899 goto fail_halt;
2900 status = usb_clear_halt(dev->udev, dev->pipe_in);
2901 usb_autopm_put_interface(dev->intf);
2902 if (status < 0 &&
2903 status != -EPIPE &&
2904 status != -ESHUTDOWN) {
2905 if (netif_msg_rx_err(dev))
2906fail_halt:
2907 netdev_err(dev->net,
2908 "can't clear rx halt, status %d\n",
2909 status);
2910 } else {
2911 clear_bit(EVENT_RX_HALT, &dev->flags);
2912 tasklet_schedule(&dev->bh);
2913 }
2914 }
2915
2916 if (test_bit(EVENT_LINK_RESET, &dev->flags)) {
2917 int ret = 0;
2918
2919 clear_bit(EVENT_LINK_RESET, &dev->flags);
2920 status = usb_autopm_get_interface(dev->intf);
2921 if (status < 0)
2922 goto skip_reset;
2923 if (lan78xx_link_reset(dev) < 0) {
2924 usb_autopm_put_interface(dev->intf);
2925skip_reset:
2926 netdev_info(dev->net, "link reset failed (%d)\n",
2927 ret);
2928 } else {
2929 usb_autopm_put_interface(dev->intf);
2930 }
2931 }
2932}
2933
2934static void intr_complete(struct urb *urb)
2935{
2936 struct lan78xx_net *dev = urb->context;
2937 int status = urb->status;
2938
2939 switch (status) {
2940 /* success */
2941 case 0:
2942 lan78xx_status(dev, urb);
2943 break;
2944
2945 /* software-driven interface shutdown */
2946 case -ENOENT: /* urb killed */
2947 case -ESHUTDOWN: /* hardware gone */
2948 netif_dbg(dev, ifdown, dev->net,
2949 "intr shutdown, code %d\n", status);
2950 return;
2951
2952 /* NOTE: not throttling like RX/TX, since this endpoint
2953 * already polls infrequently
2954 */
2955 default:
2956 netdev_dbg(dev->net, "intr status %d\n", status);
2957 break;
2958 }
2959
2960 if (!netif_running(dev->net))
2961 return;
2962
2963 memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
2964 status = usb_submit_urb(urb, GFP_ATOMIC);
2965 if (status != 0)
2966 netif_err(dev, timer, dev->net,
2967 "intr resubmit --> %d\n", status);
2968}
2969
2970static void lan78xx_disconnect(struct usb_interface *intf)
2971{
2972 struct lan78xx_net *dev;
2973 struct usb_device *udev;
2974 struct net_device *net;
2975
2976 dev = usb_get_intfdata(intf);
2977 usb_set_intfdata(intf, NULL);
2978 if (!dev)
2979 return;
2980
2981 udev = interface_to_usbdev(intf);
2982
2983 net = dev->net;
2984 unregister_netdev(net);
2985
2986 cancel_delayed_work_sync(&dev->wq);
2987
2988 usb_scuttle_anchored_urbs(&dev->deferred);
2989
2990 lan78xx_unbind(dev, intf);
2991
2992 usb_kill_urb(dev->urb_intr);
2993 usb_free_urb(dev->urb_intr);
2994
2995 free_netdev(net);
2996 usb_put_dev(udev);
2997}
2998
2999void lan78xx_tx_timeout(struct net_device *net)
3000{
3001 struct lan78xx_net *dev = netdev_priv(net);
3002
3003 unlink_urbs(dev, &dev->txq);
3004 tasklet_schedule(&dev->bh);
3005}
3006
3007static const struct net_device_ops lan78xx_netdev_ops = {
3008 .ndo_open = lan78xx_open,
3009 .ndo_stop = lan78xx_stop,
3010 .ndo_start_xmit = lan78xx_start_xmit,
3011 .ndo_tx_timeout = lan78xx_tx_timeout,
3012 .ndo_change_mtu = lan78xx_change_mtu,
3013 .ndo_set_mac_address = lan78xx_set_mac_addr,
3014 .ndo_validate_addr = eth_validate_addr,
3015 .ndo_do_ioctl = lan78xx_ioctl,
3016 .ndo_set_rx_mode = lan78xx_set_multicast,
3017 .ndo_set_features = lan78xx_set_features,
3018 .ndo_vlan_rx_add_vid = lan78xx_vlan_rx_add_vid,
3019 .ndo_vlan_rx_kill_vid = lan78xx_vlan_rx_kill_vid,
3020};
3021
3022static int lan78xx_probe(struct usb_interface *intf,
3023 const struct usb_device_id *id)
3024{
3025 struct lan78xx_net *dev;
3026 struct net_device *netdev;
3027 struct usb_device *udev;
3028 int ret;
3029 unsigned maxp;
3030 unsigned period;
3031 u8 *buf = NULL;
3032
3033 udev = interface_to_usbdev(intf);
3034 udev = usb_get_dev(udev);
3035
3036 ret = -ENOMEM;
3037 netdev = alloc_etherdev(sizeof(struct lan78xx_net));
3038 if (!netdev) {
3039 dev_err(&intf->dev, "Error: OOM\n");
3040 goto out1;
3041 }
3042
3043 /* netdev_printk() needs this */
3044 SET_NETDEV_DEV(netdev, &intf->dev);
3045
3046 dev = netdev_priv(netdev);
3047 dev->udev = udev;
3048 dev->intf = intf;
3049 dev->net = netdev;
3050 dev->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
3051 | NETIF_MSG_PROBE | NETIF_MSG_LINK);
3052
3053 skb_queue_head_init(&dev->rxq);
3054 skb_queue_head_init(&dev->txq);
3055 skb_queue_head_init(&dev->done);
3056 skb_queue_head_init(&dev->rxq_pause);
3057 skb_queue_head_init(&dev->txq_pend);
3058 mutex_init(&dev->phy_mutex);
3059
3060 tasklet_init(&dev->bh, lan78xx_bh, (unsigned long)dev);
3061 INIT_DELAYED_WORK(&dev->wq, lan78xx_delayedwork);
3062 init_usb_anchor(&dev->deferred);
3063
3064 netdev->netdev_ops = &lan78xx_netdev_ops;
3065 netdev->watchdog_timeo = TX_TIMEOUT_JIFFIES;
3066 netdev->ethtool_ops = &lan78xx_ethtool_ops;
3067
3068 ret = lan78xx_bind(dev, intf);
3069 if (ret < 0)
3070 goto out2;
3071 strcpy(netdev->name, "eth%d");
3072
3073 if (netdev->mtu > (dev->hard_mtu - netdev->hard_header_len))
3074 netdev->mtu = dev->hard_mtu - netdev->hard_header_len;
3075
3076 dev->ep_blkin = (intf->cur_altsetting)->endpoint + 0;
3077 dev->ep_blkout = (intf->cur_altsetting)->endpoint + 1;
3078 dev->ep_intr = (intf->cur_altsetting)->endpoint + 2;
3079
3080 dev->pipe_in = usb_rcvbulkpipe(udev, BULK_IN_PIPE);
3081 dev->pipe_out = usb_sndbulkpipe(udev, BULK_OUT_PIPE);
3082
3083 dev->pipe_intr = usb_rcvintpipe(dev->udev,
3084 dev->ep_intr->desc.bEndpointAddress &
3085 USB_ENDPOINT_NUMBER_MASK);
3086 period = dev->ep_intr->desc.bInterval;
3087
3088 maxp = usb_maxpacket(dev->udev, dev->pipe_intr, 0);
3089 buf = kmalloc(maxp, GFP_KERNEL);
3090 if (buf) {
3091 dev->urb_intr = usb_alloc_urb(0, GFP_KERNEL);
3092 if (!dev->urb_intr) {
3093 kfree(buf);
3094 goto out3;
3095 } else {
3096 usb_fill_int_urb(dev->urb_intr, dev->udev,
3097 dev->pipe_intr, buf, maxp,
3098 intr_complete, dev, period);
3099 }
3100 }
3101
3102 dev->maxpacket = usb_maxpacket(dev->udev, dev->pipe_out, 1);
3103
3104 /* driver requires remote-wakeup capability during autosuspend. */
3105 intf->needs_remote_wakeup = 1;
3106
3107 ret = register_netdev(netdev);
3108 if (ret != 0) {
3109 netif_err(dev, probe, netdev, "couldn't register the device\n");
3110 goto out2;
3111 }
3112
3113 usb_set_intfdata(intf, dev);
3114
3115 ret = device_set_wakeup_enable(&udev->dev, true);
3116
3117 /* Default delay of 2sec has more overhead than advantage.
3118 * Set to 10sec as default.
3119 */
3120 pm_runtime_set_autosuspend_delay(&udev->dev,
3121 DEFAULT_AUTOSUSPEND_DELAY);
3122
3123 return 0;
3124
55d7de9d
WH		 3125out3:
3126 lan78xx_unbind(dev, intf);
3127out2:
3128 free_netdev(netdev);
3129out1:
3130 usb_put_dev(udev);
3131
3132 return ret;
3133}
3134
3135static u16 lan78xx_wakeframe_crc16(const u8 *buf, int len)
3136{
3137 const u16 crc16poly = 0x8005;
3138 int i;
3139 u16 bit, crc, msb;
3140 u8 data;
3141
3142 crc = 0xFFFF;
3143 for (i = 0; i < len; i++) {
3144 data = *buf++;
3145 for (bit = 0; bit < 8; bit++) {
3146 msb = crc >> 15;
3147 crc <<= 1;
3148
3149 if (msb ^ (u16)(data & 1)) {
3150 crc ^= crc16poly;
3151 crc |= (u16)0x0001U;
3152 }
3153 data >>= 1;
3154 }
3155 }
3156
3157 return crc;
3158}
3159
3160static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
3161{
3162 u32 buf;
3163 int ret;
3164 int mask_index;
3165 u16 crc;
3166 u32 temp_wucsr;
3167 u32 temp_pmt_ctl;
3168 const u8 ipv4_multicast[3] = { 0x01, 0x00, 0x5E };
3169 const u8 ipv6_multicast[3] = { 0x33, 0x33 };
3170 const u8 arp_type[2] = { 0x08, 0x06 };
3171
3172 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3173 buf &= ~MAC_TX_TXEN_;
3174 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3175 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3176 buf &= ~MAC_RX_RXEN_;
3177 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3178
3179 ret = lan78xx_write_reg(dev, WUCSR, 0);
3180 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3181 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3182
3183 temp_wucsr = 0;
3184
3185 temp_pmt_ctl = 0;
3186 ret = lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl);
3187 temp_pmt_ctl &= ~PMT_CTL_RES_CLR_WKP_EN_;
3188 temp_pmt_ctl |= PMT_CTL_RES_CLR_WKP_STS_;
3189
3190 for (mask_index = 0; mask_index < NUM_OF_WUF_CFG; mask_index++)
3191 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), 0);
3192
3193 mask_index = 0;
3194 if (wol & WAKE_PHY) {
3195 temp_pmt_ctl |= PMT_CTL_PHY_WAKE_EN_;
3196
3197 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3198 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3199 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3200 }
3201 if (wol & WAKE_MAGIC) {
3202 temp_wucsr |= WUCSR_MPEN_;
3203
3204 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3205 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3206 temp_pmt_ctl |= PMT_CTL_SUS_MODE_3_;
3207 }
3208 if (wol & WAKE_BCAST) {
3209 temp_wucsr |= WUCSR_BCST_EN_;
3210
3211 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3212 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3213 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3214 }
3215 if (wol & WAKE_MCAST) {
3216 temp_wucsr |= WUCSR_WAKE_EN_;
3217
3218 /* set WUF_CFG & WUF_MASK for IPv4 Multicast */
3219 crc = lan78xx_wakeframe_crc16(ipv4_multicast, 3);
3220 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3221 WUF_CFGX_EN_ |
3222 WUF_CFGX_TYPE_MCAST_ |
3223 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3224 (crc & WUF_CFGX_CRC16_MASK_));
3225
3226 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7);
3227 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3228 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3229 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3230 mask_index++;
3231
3232 /* for IPv6 Multicast */
3233 crc = lan78xx_wakeframe_crc16(ipv6_multicast, 2);
3234 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3235 WUF_CFGX_EN_ |
3236 WUF_CFGX_TYPE_MCAST_ |
3237 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3238 (crc & WUF_CFGX_CRC16_MASK_));
3239
3240 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 3);
3241 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3242 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3243 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3244 mask_index++;
3245
3246 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3247 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3248 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3249 }
3250 if (wol & WAKE_UCAST) {
3251 temp_wucsr |= WUCSR_PFDA_EN_;
3252
3253 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3254 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3255 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3256 }
3257 if (wol & WAKE_ARP) {
3258 temp_wucsr |= WUCSR_WAKE_EN_;
3259
3260 /* set WUF_CFG & WUF_MASK
3261 * for packettype (offset 12,13) = ARP (0x0806)
3262 */
3263 crc = lan78xx_wakeframe_crc16(arp_type, 2);
3264 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3265 WUF_CFGX_EN_ |
3266 WUF_CFGX_TYPE_ALL_ |
3267 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3268 (crc & WUF_CFGX_CRC16_MASK_));
3269
3270 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000);
3271 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3272 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3273 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3274 mask_index++;
3275
3276 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3277 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3278 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3279 }
3280
3281 ret = lan78xx_write_reg(dev, WUCSR, temp_wucsr);
3282
3283 /* when multiple WOL bits are set */
3284 if (hweight_long((unsigned long)wol) > 1) {
3285 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3286 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3287 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3288 }
3289 ret = lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl);
3290
3291 /* clear WUPS */
3292 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3293 buf |= PMT_CTL_WUPS_MASK_;
3294 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3295
3296 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3297 buf |= MAC_RX_RXEN_;
3298 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3299
3300 return 0;
3301}
3302
3303int lan78xx_suspend(struct usb_interface *intf, pm_message_t message)
3304{
3305 struct lan78xx_net *dev = usb_get_intfdata(intf);
3306 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
3307 u32 buf;
3308 int ret;
3309 int event;
3310
3311 ret = 0;
3312 event = message.event;
3313
3314 if (!dev->suspend_count++) {
3315 spin_lock_irq(&dev->txq.lock);
3316 /* don't autosuspend while transmitting */
3317 if ((skb_queue_len(&dev->txq) ||
3318 skb_queue_len(&dev->txq_pend)) &&
3319 PMSG_IS_AUTO(message)) {
3320 spin_unlock_irq(&dev->txq.lock);
3321 ret = -EBUSY;
3322 goto out;
3323 } else {
3324 set_bit(EVENT_DEV_ASLEEP, &dev->flags);
3325 spin_unlock_irq(&dev->txq.lock);
3326 }
3327
3328 /* stop TX & RX */
3329 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3330 buf &= ~MAC_TX_TXEN_;
3331 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3332 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3333 buf &= ~MAC_RX_RXEN_;
3334 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3335
3336 /* empty out the rx and queues */
3337 netif_device_detach(dev->net);
3338 lan78xx_terminate_urbs(dev);
3339 usb_kill_urb(dev->urb_intr);
3340
3341 /* reattach */
3342 netif_device_attach(dev->net);
3343 }
3344
3345 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3346 if (PMSG_IS_AUTO(message)) {
3347 /* auto suspend (selective suspend) */
3348 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3349 buf &= ~MAC_TX_TXEN_;
3350 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3351 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3352 buf &= ~MAC_RX_RXEN_;
3353 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3354
3355 ret = lan78xx_write_reg(dev, WUCSR, 0);
3356 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3357 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3358
3359 /* set goodframe wakeup */
3360 ret = lan78xx_read_reg(dev, WUCSR, &buf);
3361
3362 buf |= WUCSR_RFE_WAKE_EN_;
3363 buf |= WUCSR_STORE_WAKE_;
3364
3365 ret = lan78xx_write_reg(dev, WUCSR, buf);
3366
3367 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3368
3369 buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
3370 buf |= PMT_CTL_RES_CLR_WKP_STS_;
3371
3372 buf |= PMT_CTL_PHY_WAKE_EN_;
3373 buf |= PMT_CTL_WOL_EN_;
3374 buf &= ~PMT_CTL_SUS_MODE_MASK_;
3375 buf |= PMT_CTL_SUS_MODE_3_;
3376
3377 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3378
3379 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3380
3381 buf |= PMT_CTL_WUPS_MASK_;
3382
3383 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3384
3385 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3386 buf |= MAC_RX_RXEN_;
3387 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3388 } else {
3389 lan78xx_set_suspend(dev, pdata->wol);
3390 }
3391 }
3392
3393out:
3394 return ret;
3395}
3396
3397int lan78xx_resume(struct usb_interface *intf)
3398{
3399 struct lan78xx_net *dev = usb_get_intfdata(intf);
3400 struct sk_buff *skb;
3401 struct urb *res;
3402 int ret;
3403 u32 buf;
3404
3405 if (!--dev->suspend_count) {
3406 /* resume interrupt URBs */
3407 if (dev->urb_intr && test_bit(EVENT_DEV_OPEN, &dev->flags))
3408 usb_submit_urb(dev->urb_intr, GFP_NOIO);
3409
3410 spin_lock_irq(&dev->txq.lock);
3411 while ((res = usb_get_from_anchor(&dev->deferred))) {
3412 skb = (struct sk_buff *)res->context;
3413 ret = usb_submit_urb(res, GFP_ATOMIC);
3414 if (ret < 0) {
3415 dev_kfree_skb_any(skb);
3416 usb_free_urb(res);
3417 usb_autopm_put_interface_async(dev->intf);
3418 } else {
3419 dev->net->trans_start = jiffies;
3420 lan78xx_queue_skb(&dev->txq, skb, tx_start);
3421 }
3422 }
3423
3424 clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
3425 spin_unlock_irq(&dev->txq.lock);
3426
3427 if (test_bit(EVENT_DEV_OPEN, &dev->flags)) {
3428 if (!(skb_queue_len(&dev->txq) >= dev->tx_qlen))
3429 netif_start_queue(dev->net);
3430 tasklet_schedule(&dev->bh);
3431 }
3432 }
3433
3434 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3435 ret = lan78xx_write_reg(dev, WUCSR, 0);
3436 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3437
3438 ret = lan78xx_write_reg(dev, WUCSR2, WUCSR2_NS_RCD_ |
3439 WUCSR2_ARP_RCD_ |
3440 WUCSR2_IPV6_TCPSYN_RCD_ |
3441 WUCSR2_IPV4_TCPSYN_RCD_);
3442
3443 ret = lan78xx_write_reg(dev, WUCSR, WUCSR_EEE_TX_WAKE_ |
3444 WUCSR_EEE_RX_WAKE_ |
3445 WUCSR_PFDA_FR_ |
3446 WUCSR_RFE_WAKE_FR_ |
3447 WUCSR_WUFR_ |
3448 WUCSR_MPR_ |
3449 WUCSR_BCST_FR_);
3450
3451 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3452 buf |= MAC_TX_TXEN_;
3453 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3454
3455 return 0;
3456}
3457
3458int lan78xx_reset_resume(struct usb_interface *intf)
3459{
3460 struct lan78xx_net *dev = usb_get_intfdata(intf);
3461
3462 lan78xx_reset(dev);
3463 return lan78xx_resume(intf);
3464}
3465
3466static const struct usb_device_id products[] = {
3467 {
3468 /* LAN7800 USB Gigabit Ethernet Device */
3469 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7800_USB_PRODUCT_ID),
3470 },
3471 {
3472 /* LAN7850 USB Gigabit Ethernet Device */
3473 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7850_USB_PRODUCT_ID),
3474 },
3475 {},
3476};
3477MODULE_DEVICE_TABLE(usb, products);
3478
3479static struct usb_driver lan78xx_driver = {
3480 .name = DRIVER_NAME,
3481 .id_table = products,
3482 .probe = lan78xx_probe,
3483 .disconnect = lan78xx_disconnect,
3484 .suspend = lan78xx_suspend,
3485 .resume = lan78xx_resume,
3486 .reset_resume = lan78xx_reset_resume,
3487 .supports_autosuspend = 1,
3488 .disable_hub_initiated_lpm = 1,
3489};
3490
3491module_usb_driver(lan78xx_driver);
3492
3493MODULE_AUTHOR(DRIVER_AUTHOR);
3494MODULE_DESCRIPTION(DRIVER_DESC);
3495MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.242903 seconds and 5 git commands to generate.