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