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