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