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