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