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