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