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