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