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