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