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