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