]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/net/usb/lan78xx.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:


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