1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /*************************************************************************** 3 * 4 * Copyright (C) 2007-2008 SMSC 5 * 6 *****************************************************************************/ 7 8 #include <linux/module.h> 9 #include <linux/kmod.h> 10 #include <linux/netdevice.h> 11 #include <linux/etherdevice.h> 12 #include <linux/ethtool.h> 13 #include <linux/mii.h> 14 #include <linux/usb.h> 15 #include <linux/bitrev.h> 16 #include <linux/crc16.h> 17 #include <linux/crc32.h> 18 #include <linux/usb/usbnet.h> 19 #include <linux/slab.h> 20 #include <linux/of_net.h> 21 #include "smsc95xx.h" 22 23 #define SMSC_CHIPNAME "smsc95xx" 24 #define SMSC_DRIVER_VERSION "1.0.6" 25 #define HS_USB_PKT_SIZE (512) 26 #define FS_USB_PKT_SIZE (64) 27 #define DEFAULT_HS_BURST_CAP_SIZE (16 * 1024 + 5 * HS_USB_PKT_SIZE) 28 #define DEFAULT_FS_BURST_CAP_SIZE (6 * 1024 + 33 * FS_USB_PKT_SIZE) 29 #define DEFAULT_BULK_IN_DELAY (0x00002000) 30 #define MAX_SINGLE_PACKET_SIZE (2048) 31 #define LAN95XX_EEPROM_MAGIC (0x9500) 32 #define EEPROM_MAC_OFFSET (0x01) 33 #define DEFAULT_TX_CSUM_ENABLE (true) 34 #define DEFAULT_RX_CSUM_ENABLE (true) 35 #define SMSC95XX_INTERNAL_PHY_ID (1) 36 #define SMSC95XX_TX_OVERHEAD (8) 37 #define SMSC95XX_TX_OVERHEAD_CSUM (12) 38 #define SUPPORTED_WAKE (WAKE_PHY | WAKE_UCAST | WAKE_BCAST | \ 39 WAKE_MCAST | WAKE_ARP | WAKE_MAGIC) 40 41 #define FEATURE_8_WAKEUP_FILTERS (0x01) 42 #define FEATURE_PHY_NLP_CROSSOVER (0x02) 43 #define FEATURE_REMOTE_WAKEUP (0x04) 44 45 #define SUSPEND_SUSPEND0 (0x01) 46 #define SUSPEND_SUSPEND1 (0x02) 47 #define SUSPEND_SUSPEND2 (0x04) 48 #define SUSPEND_SUSPEND3 (0x08) 49 #define SUSPEND_ALLMODES (SUSPEND_SUSPEND0 | SUSPEND_SUSPEND1 | \ 50 SUSPEND_SUSPEND2 | SUSPEND_SUSPEND3) 51 52 #define CARRIER_CHECK_DELAY (2 * HZ) 53 54 struct smsc95xx_priv { 55 u32 chip_id; 56 u32 mac_cr; 57 u32 hash_hi; 58 u32 hash_lo; 59 u32 wolopts; 60 spinlock_t mac_cr_lock; 61 u8 features; 62 u8 suspend_flags; 63 u8 mdix_ctrl; 64 bool link_ok; 65 struct delayed_work carrier_check; 66 struct usbnet *dev; 67 }; 68 69 static bool turbo_mode = true; 70 module_param(turbo_mode, bool, 0644); 71 MODULE_PARM_DESC(turbo_mode, "Enable multiple frames per Rx transaction"); 72 73 static int __must_check __smsc95xx_read_reg(struct usbnet *dev, u32 index, 74 u32 *data, int in_pm) 75 { 76 u32 buf; 77 int ret; 78 int (*fn)(struct usbnet *, u8, u8, u16, u16, void *, u16); 79 80 BUG_ON(!dev); 81 82 if (!in_pm) 83 fn = usbnet_read_cmd; 84 else 85 fn = usbnet_read_cmd_nopm; 86 87 ret = fn(dev, USB_VENDOR_REQUEST_READ_REGISTER, USB_DIR_IN 88 | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 89 0, index, &buf, 4); 90 if (unlikely(ret < 0)) { 91 netdev_warn(dev->net, "Failed to read reg index 0x%08x: %d\n", 92 index, ret); 93 return ret; 94 } 95 96 le32_to_cpus(&buf); 97 *data = buf; 98 99 return ret; 100 } 101 102 static int __must_check __smsc95xx_write_reg(struct usbnet *dev, u32 index, 103 u32 data, int in_pm) 104 { 105 u32 buf; 106 int ret; 107 int (*fn)(struct usbnet *, u8, u8, u16, u16, const void *, u16); 108 109 BUG_ON(!dev); 110 111 if (!in_pm) 112 fn = usbnet_write_cmd; 113 else 114 fn = usbnet_write_cmd_nopm; 115 116 buf = data; 117 cpu_to_le32s(&buf); 118 119 ret = fn(dev, USB_VENDOR_REQUEST_WRITE_REGISTER, USB_DIR_OUT 120 | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 121 0, index, &buf, 4); 122 if (unlikely(ret < 0)) 123 netdev_warn(dev->net, "Failed to write reg index 0x%08x: %d\n", 124 index, ret); 125 126 return ret; 127 } 128 129 static int __must_check smsc95xx_read_reg_nopm(struct usbnet *dev, u32 index, 130 u32 *data) 131 { 132 return __smsc95xx_read_reg(dev, index, data, 1); 133 } 134 135 static int __must_check smsc95xx_write_reg_nopm(struct usbnet *dev, u32 index, 136 u32 data) 137 { 138 return __smsc95xx_write_reg(dev, index, data, 1); 139 } 140 141 static int __must_check smsc95xx_read_reg(struct usbnet *dev, u32 index, 142 u32 *data) 143 { 144 return __smsc95xx_read_reg(dev, index, data, 0); 145 } 146 147 static int __must_check smsc95xx_write_reg(struct usbnet *dev, u32 index, 148 u32 data) 149 { 150 return __smsc95xx_write_reg(dev, index, data, 0); 151 } 152 153 /* Loop until the read is completed with timeout 154 * called with phy_mutex held */ 155 static int __must_check __smsc95xx_phy_wait_not_busy(struct usbnet *dev, 156 int in_pm) 157 { 158 unsigned long start_time = jiffies; 159 u32 val; 160 int ret; 161 162 do { 163 ret = __smsc95xx_read_reg(dev, MII_ADDR, &val, in_pm); 164 if (ret < 0) { 165 netdev_warn(dev->net, "Error reading MII_ACCESS\n"); 166 return ret; 167 } 168 169 if (!(val & MII_BUSY_)) 170 return 0; 171 } while (!time_after(jiffies, start_time + HZ)); 172 173 return -EIO; 174 } 175 176 static int __smsc95xx_mdio_read(struct net_device *netdev, int phy_id, int idx, 177 int in_pm) 178 { 179 struct usbnet *dev = netdev_priv(netdev); 180 u32 val, addr; 181 int ret; 182 183 mutex_lock(&dev->phy_mutex); 184 185 /* confirm MII not busy */ 186 ret = __smsc95xx_phy_wait_not_busy(dev, in_pm); 187 if (ret < 0) { 188 netdev_warn(dev->net, "MII is busy in smsc95xx_mdio_read\n"); 189 goto done; 190 } 191 192 /* set the address, index & direction (read from PHY) */ 193 phy_id &= dev->mii.phy_id_mask; 194 idx &= dev->mii.reg_num_mask; 195 addr = (phy_id << 11) | (idx << 6) | MII_READ_ | MII_BUSY_; 196 ret = __smsc95xx_write_reg(dev, MII_ADDR, addr, in_pm); 197 if (ret < 0) { 198 netdev_warn(dev->net, "Error writing MII_ADDR\n"); 199 goto done; 200 } 201 202 ret = __smsc95xx_phy_wait_not_busy(dev, in_pm); 203 if (ret < 0) { 204 netdev_warn(dev->net, "Timed out reading MII reg %02X\n", idx); 205 goto done; 206 } 207 208 ret = __smsc95xx_read_reg(dev, MII_DATA, &val, in_pm); 209 if (ret < 0) { 210 netdev_warn(dev->net, "Error reading MII_DATA\n"); 211 goto done; 212 } 213 214 ret = (u16)(val & 0xFFFF); 215 216 done: 217 mutex_unlock(&dev->phy_mutex); 218 return ret; 219 } 220 221 static void __smsc95xx_mdio_write(struct net_device *netdev, int phy_id, 222 int idx, int regval, int in_pm) 223 { 224 struct usbnet *dev = netdev_priv(netdev); 225 u32 val, addr; 226 int ret; 227 228 mutex_lock(&dev->phy_mutex); 229 230 /* confirm MII not busy */ 231 ret = __smsc95xx_phy_wait_not_busy(dev, in_pm); 232 if (ret < 0) { 233 netdev_warn(dev->net, "MII is busy in smsc95xx_mdio_write\n"); 234 goto done; 235 } 236 237 val = regval; 238 ret = __smsc95xx_write_reg(dev, MII_DATA, val, in_pm); 239 if (ret < 0) { 240 netdev_warn(dev->net, "Error writing MII_DATA\n"); 241 goto done; 242 } 243 244 /* set the address, index & direction (write to PHY) */ 245 phy_id &= dev->mii.phy_id_mask; 246 idx &= dev->mii.reg_num_mask; 247 addr = (phy_id << 11) | (idx << 6) | MII_WRITE_ | MII_BUSY_; 248 ret = __smsc95xx_write_reg(dev, MII_ADDR, addr, in_pm); 249 if (ret < 0) { 250 netdev_warn(dev->net, "Error writing MII_ADDR\n"); 251 goto done; 252 } 253 254 ret = __smsc95xx_phy_wait_not_busy(dev, in_pm); 255 if (ret < 0) { 256 netdev_warn(dev->net, "Timed out writing MII reg %02X\n", idx); 257 goto done; 258 } 259 260 done: 261 mutex_unlock(&dev->phy_mutex); 262 } 263 264 static int smsc95xx_mdio_read_nopm(struct net_device *netdev, int phy_id, 265 int idx) 266 { 267 return __smsc95xx_mdio_read(netdev, phy_id, idx, 1); 268 } 269 270 static void smsc95xx_mdio_write_nopm(struct net_device *netdev, int phy_id, 271 int idx, int regval) 272 { 273 __smsc95xx_mdio_write(netdev, phy_id, idx, regval, 1); 274 } 275 276 static int smsc95xx_mdio_read(struct net_device *netdev, int phy_id, int idx) 277 { 278 return __smsc95xx_mdio_read(netdev, phy_id, idx, 0); 279 } 280 281 static void smsc95xx_mdio_write(struct net_device *netdev, int phy_id, int idx, 282 int regval) 283 { 284 __smsc95xx_mdio_write(netdev, phy_id, idx, regval, 0); 285 } 286 287 static int __must_check smsc95xx_wait_eeprom(struct usbnet *dev) 288 { 289 unsigned long start_time = jiffies; 290 u32 val; 291 int ret; 292 293 do { 294 ret = smsc95xx_read_reg(dev, E2P_CMD, &val); 295 if (ret < 0) { 296 netdev_warn(dev->net, "Error reading E2P_CMD\n"); 297 return ret; 298 } 299 300 if (!(val & E2P_CMD_BUSY_) || (val & E2P_CMD_TIMEOUT_)) 301 break; 302 udelay(40); 303 } while (!time_after(jiffies, start_time + HZ)); 304 305 if (val & (E2P_CMD_TIMEOUT_ | E2P_CMD_BUSY_)) { 306 netdev_warn(dev->net, "EEPROM read operation timeout\n"); 307 return -EIO; 308 } 309 310 return 0; 311 } 312 313 static int __must_check smsc95xx_eeprom_confirm_not_busy(struct usbnet *dev) 314 { 315 unsigned long start_time = jiffies; 316 u32 val; 317 int ret; 318 319 do { 320 ret = smsc95xx_read_reg(dev, E2P_CMD, &val); 321 if (ret < 0) { 322 netdev_warn(dev->net, "Error reading E2P_CMD\n"); 323 return ret; 324 } 325 326 if (!(val & E2P_CMD_BUSY_)) 327 return 0; 328 329 udelay(40); 330 } while (!time_after(jiffies, start_time + HZ)); 331 332 netdev_warn(dev->net, "EEPROM is busy\n"); 333 return -EIO; 334 } 335 336 static int smsc95xx_read_eeprom(struct usbnet *dev, u32 offset, u32 length, 337 u8 *data) 338 { 339 u32 val; 340 int i, ret; 341 342 BUG_ON(!dev); 343 BUG_ON(!data); 344 345 ret = smsc95xx_eeprom_confirm_not_busy(dev); 346 if (ret) 347 return ret; 348 349 for (i = 0; i < length; i++) { 350 val = E2P_CMD_BUSY_ | E2P_CMD_READ_ | (offset & E2P_CMD_ADDR_); 351 ret = smsc95xx_write_reg(dev, E2P_CMD, val); 352 if (ret < 0) { 353 netdev_warn(dev->net, "Error writing E2P_CMD\n"); 354 return ret; 355 } 356 357 ret = smsc95xx_wait_eeprom(dev); 358 if (ret < 0) 359 return ret; 360 361 ret = smsc95xx_read_reg(dev, E2P_DATA, &val); 362 if (ret < 0) { 363 netdev_warn(dev->net, "Error reading E2P_DATA\n"); 364 return ret; 365 } 366 367 data[i] = val & 0xFF; 368 offset++; 369 } 370 371 return 0; 372 } 373 374 static int smsc95xx_write_eeprom(struct usbnet *dev, u32 offset, u32 length, 375 u8 *data) 376 { 377 u32 val; 378 int i, ret; 379 380 BUG_ON(!dev); 381 BUG_ON(!data); 382 383 ret = smsc95xx_eeprom_confirm_not_busy(dev); 384 if (ret) 385 return ret; 386 387 /* Issue write/erase enable command */ 388 val = E2P_CMD_BUSY_ | E2P_CMD_EWEN_; 389 ret = smsc95xx_write_reg(dev, E2P_CMD, val); 390 if (ret < 0) { 391 netdev_warn(dev->net, "Error writing E2P_DATA\n"); 392 return ret; 393 } 394 395 ret = smsc95xx_wait_eeprom(dev); 396 if (ret < 0) 397 return ret; 398 399 for (i = 0; i < length; i++) { 400 401 /* Fill data register */ 402 val = data[i]; 403 ret = smsc95xx_write_reg(dev, E2P_DATA, val); 404 if (ret < 0) { 405 netdev_warn(dev->net, "Error writing E2P_DATA\n"); 406 return ret; 407 } 408 409 /* Send "write" command */ 410 val = E2P_CMD_BUSY_ | E2P_CMD_WRITE_ | (offset & E2P_CMD_ADDR_); 411 ret = smsc95xx_write_reg(dev, E2P_CMD, val); 412 if (ret < 0) { 413 netdev_warn(dev->net, "Error writing E2P_CMD\n"); 414 return ret; 415 } 416 417 ret = smsc95xx_wait_eeprom(dev); 418 if (ret < 0) 419 return ret; 420 421 offset++; 422 } 423 424 return 0; 425 } 426 427 static int __must_check smsc95xx_write_reg_async(struct usbnet *dev, u16 index, 428 u32 data) 429 { 430 const u16 size = 4; 431 u32 buf; 432 int ret; 433 434 buf = data; 435 cpu_to_le32s(&buf); 436 437 ret = usbnet_write_cmd_async(dev, USB_VENDOR_REQUEST_WRITE_REGISTER, 438 USB_DIR_OUT | USB_TYPE_VENDOR | 439 USB_RECIP_DEVICE, 440 0, index, &buf, size); 441 if (ret < 0) 442 netdev_warn(dev->net, "Error write async cmd, sts=%d\n", 443 ret); 444 return ret; 445 } 446 447 /* returns hash bit number for given MAC address 448 * example: 449 * 01 00 5E 00 00 01 -> returns bit number 31 */ 450 static unsigned int smsc95xx_hash(char addr[ETH_ALEN]) 451 { 452 return (ether_crc(ETH_ALEN, addr) >> 26) & 0x3f; 453 } 454 455 static void smsc95xx_set_multicast(struct net_device *netdev) 456 { 457 struct usbnet *dev = netdev_priv(netdev); 458 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]); 459 unsigned long flags; 460 int ret; 461 462 pdata->hash_hi = 0; 463 pdata->hash_lo = 0; 464 465 spin_lock_irqsave(&pdata->mac_cr_lock, flags); 466 467 if (dev->net->flags & IFF_PROMISC) { 468 netif_dbg(dev, drv, dev->net, "promiscuous mode enabled\n"); 469 pdata->mac_cr |= MAC_CR_PRMS_; 470 pdata->mac_cr &= ~(MAC_CR_MCPAS_ | MAC_CR_HPFILT_); 471 } else if (dev->net->flags & IFF_ALLMULTI) { 472 netif_dbg(dev, drv, dev->net, "receive all multicast enabled\n"); 473 pdata->mac_cr |= MAC_CR_MCPAS_; 474 pdata->mac_cr &= ~(MAC_CR_PRMS_ | MAC_CR_HPFILT_); 475 } else if (!netdev_mc_empty(dev->net)) { 476 struct netdev_hw_addr *ha; 477 478 pdata->mac_cr |= MAC_CR_HPFILT_; 479 pdata->mac_cr &= ~(MAC_CR_PRMS_ | MAC_CR_MCPAS_); 480 481 netdev_for_each_mc_addr(ha, netdev) { 482 u32 bitnum = smsc95xx_hash(ha->addr); 483 u32 mask = 0x01 << (bitnum & 0x1F); 484 if (bitnum & 0x20) 485 pdata->hash_hi |= mask; 486 else 487 pdata->hash_lo |= mask; 488 } 489 490 netif_dbg(dev, drv, dev->net, "HASHH=0x%08X, HASHL=0x%08X\n", 491 pdata->hash_hi, pdata->hash_lo); 492 } else { 493 netif_dbg(dev, drv, dev->net, "receive own packets only\n"); 494 pdata->mac_cr &= 495 ~(MAC_CR_PRMS_ | MAC_CR_MCPAS_ | MAC_CR_HPFILT_); 496 } 497 498 spin_unlock_irqrestore(&pdata->mac_cr_lock, flags); 499 500 /* Initiate async writes, as we can't wait for completion here */ 501 ret = smsc95xx_write_reg_async(dev, HASHH, pdata->hash_hi); 502 if (ret < 0) 503 netdev_warn(dev->net, "failed to initiate async write to HASHH\n"); 504 505 ret = smsc95xx_write_reg_async(dev, HASHL, pdata->hash_lo); 506 if (ret < 0) 507 netdev_warn(dev->net, "failed to initiate async write to HASHL\n"); 508 509 ret = smsc95xx_write_reg_async(dev, MAC_CR, pdata->mac_cr); 510 if (ret < 0) 511 netdev_warn(dev->net, "failed to initiate async write to MAC_CR\n"); 512 } 513 514 static int smsc95xx_phy_update_flowcontrol(struct usbnet *dev, u8 duplex, 515 u16 lcladv, u16 rmtadv) 516 { 517 u32 flow = 0, afc_cfg; 518 519 int ret = smsc95xx_read_reg(dev, AFC_CFG, &afc_cfg); 520 if (ret < 0) 521 return ret; 522 523 if (duplex == DUPLEX_FULL) { 524 u8 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv); 525 526 if (cap & FLOW_CTRL_RX) 527 flow = 0xFFFF0002; 528 529 if (cap & FLOW_CTRL_TX) { 530 afc_cfg |= 0xF; 531 flow |= 0xFFFF0000; 532 } else { 533 afc_cfg &= ~0xF; 534 } 535 536 netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s\n", 537 cap & FLOW_CTRL_RX ? "enabled" : "disabled", 538 cap & FLOW_CTRL_TX ? "enabled" : "disabled"); 539 } else { 540 netif_dbg(dev, link, dev->net, "half duplex\n"); 541 afc_cfg |= 0xF; 542 } 543 544 ret = smsc95xx_write_reg(dev, FLOW, flow); 545 if (ret < 0) 546 return ret; 547 548 return smsc95xx_write_reg(dev, AFC_CFG, afc_cfg); 549 } 550 551 static int smsc95xx_link_reset(struct usbnet *dev) 552 { 553 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]); 554 struct mii_if_info *mii = &dev->mii; 555 struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET }; 556 unsigned long flags; 557 u16 lcladv, rmtadv; 558 int ret; 559 560 /* clear interrupt status */ 561 ret = smsc95xx_mdio_read(dev->net, mii->phy_id, PHY_INT_SRC); 562 if (ret < 0) 563 return ret; 564 565 ret = smsc95xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_); 566 if (ret < 0) 567 return ret; 568 569 mii_check_media(mii, 1, 1); 570 mii_ethtool_gset(&dev->mii, &ecmd); 571 lcladv = smsc95xx_mdio_read(dev->net, mii->phy_id, MII_ADVERTISE); 572 rmtadv = smsc95xx_mdio_read(dev->net, mii->phy_id, MII_LPA); 573 574 netif_dbg(dev, link, dev->net, 575 "speed: %u duplex: %d lcladv: %04x rmtadv: %04x\n", 576 ethtool_cmd_speed(&ecmd), ecmd.duplex, lcladv, rmtadv); 577 578 spin_lock_irqsave(&pdata->mac_cr_lock, flags); 579 if (ecmd.duplex != DUPLEX_FULL) { 580 pdata->mac_cr &= ~MAC_CR_FDPX_; 581 pdata->mac_cr |= MAC_CR_RCVOWN_; 582 } else { 583 pdata->mac_cr &= ~MAC_CR_RCVOWN_; 584 pdata->mac_cr |= MAC_CR_FDPX_; 585 } 586 spin_unlock_irqrestore(&pdata->mac_cr_lock, flags); 587 588 ret = smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr); 589 if (ret < 0) 590 return ret; 591 592 ret = smsc95xx_phy_update_flowcontrol(dev, ecmd.duplex, lcladv, rmtadv); 593 if (ret < 0) 594 netdev_warn(dev->net, "Error updating PHY flow control\n"); 595 596 return ret; 597 } 598 599 static void smsc95xx_status(struct usbnet *dev, struct urb *urb) 600 { 601 u32 intdata; 602 603 if (urb->actual_length != 4) { 604 netdev_warn(dev->net, "unexpected urb length %d\n", 605 urb->actual_length); 606 return; 607 } 608 609 intdata = get_unaligned_le32(urb->transfer_buffer); 610 netif_dbg(dev, link, dev->net, "intdata: 0x%08X\n", intdata); 611 612 if (intdata & INT_ENP_PHY_INT_) 613 usbnet_defer_kevent(dev, EVENT_LINK_RESET); 614 else 615 netdev_warn(dev->net, "unexpected interrupt, intdata=0x%08X\n", 616 intdata); 617 } 618 619 static void set_carrier(struct usbnet *dev, bool link) 620 { 621 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]); 622 623 if (pdata->link_ok == link) 624 return; 625 626 pdata->link_ok = link; 627 628 if (link) 629 usbnet_link_change(dev, 1, 0); 630 else 631 usbnet_link_change(dev, 0, 0); 632 } 633 634 static void check_carrier(struct work_struct *work) 635 { 636 struct smsc95xx_priv *pdata = container_of(work, struct smsc95xx_priv, 637 carrier_check.work); 638 struct usbnet *dev = pdata->dev; 639 int ret; 640 641 if (pdata->suspend_flags != 0) 642 return; 643 644 ret = smsc95xx_mdio_read(dev->net, dev->mii.phy_id, MII_BMSR); 645 if (ret < 0) { 646 netdev_warn(dev->net, "Failed to read MII_BMSR\n"); 647 return; 648 } 649 if (ret & BMSR_LSTATUS) 650 set_carrier(dev, 1); 651 else 652 set_carrier(dev, 0); 653 654 schedule_delayed_work(&pdata->carrier_check, CARRIER_CHECK_DELAY); 655 } 656 657 /* Enable or disable Tx & Rx checksum offload engines */ 658 static int smsc95xx_set_features(struct net_device *netdev, 659 netdev_features_t features) 660 { 661 struct usbnet *dev = netdev_priv(netdev); 662 u32 read_buf; 663 int ret; 664 665 ret = smsc95xx_read_reg(dev, COE_CR, &read_buf); 666 if (ret < 0) 667 return ret; 668 669 if (features & NETIF_F_IP_CSUM) 670 read_buf |= Tx_COE_EN_; 671 else 672 read_buf &= ~Tx_COE_EN_; 673 674 if (features & NETIF_F_RXCSUM) 675 read_buf |= Rx_COE_EN_; 676 else 677 read_buf &= ~Rx_COE_EN_; 678 679 ret = smsc95xx_write_reg(dev, COE_CR, read_buf); 680 if (ret < 0) 681 return ret; 682 683 netif_dbg(dev, hw, dev->net, "COE_CR = 0x%08x\n", read_buf); 684 return 0; 685 } 686 687 static int smsc95xx_ethtool_get_eeprom_len(struct net_device *net) 688 { 689 return MAX_EEPROM_SIZE; 690 } 691 692 static int smsc95xx_ethtool_get_eeprom(struct net_device *netdev, 693 struct ethtool_eeprom *ee, u8 *data) 694 { 695 struct usbnet *dev = netdev_priv(netdev); 696 697 ee->magic = LAN95XX_EEPROM_MAGIC; 698 699 return smsc95xx_read_eeprom(dev, ee->offset, ee->len, data); 700 } 701 702 static int smsc95xx_ethtool_set_eeprom(struct net_device *netdev, 703 struct ethtool_eeprom *ee, u8 *data) 704 { 705 struct usbnet *dev = netdev_priv(netdev); 706 707 if (ee->magic != LAN95XX_EEPROM_MAGIC) { 708 netdev_warn(dev->net, "EEPROM: magic value mismatch, magic = 0x%x\n", 709 ee->magic); 710 return -EINVAL; 711 } 712 713 return smsc95xx_write_eeprom(dev, ee->offset, ee->len, data); 714 } 715 716 static int smsc95xx_ethtool_getregslen(struct net_device *netdev) 717 { 718 /* all smsc95xx registers */ 719 return COE_CR - ID_REV + sizeof(u32); 720 } 721 722 static void 723 smsc95xx_ethtool_getregs(struct net_device *netdev, struct ethtool_regs *regs, 724 void *buf) 725 { 726 struct usbnet *dev = netdev_priv(netdev); 727 unsigned int i, j; 728 int retval; 729 u32 *data = buf; 730 731 retval = smsc95xx_read_reg(dev, ID_REV, ®s->version); 732 if (retval < 0) { 733 netdev_warn(netdev, "REGS: cannot read ID_REV\n"); 734 return; 735 } 736 737 for (i = ID_REV, j = 0; i <= COE_CR; i += (sizeof(u32)), j++) { 738 retval = smsc95xx_read_reg(dev, i, &data[j]); 739 if (retval < 0) { 740 netdev_warn(netdev, "REGS: cannot read reg[%x]\n", i); 741 return; 742 } 743 } 744 } 745 746 static void smsc95xx_ethtool_get_wol(struct net_device *net, 747 struct ethtool_wolinfo *wolinfo) 748 { 749 struct usbnet *dev = netdev_priv(net); 750 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]); 751 752 wolinfo->supported = SUPPORTED_WAKE; 753 wolinfo->wolopts = pdata->wolopts; 754 } 755 756 static int smsc95xx_ethtool_set_wol(struct net_device *net, 757 struct ethtool_wolinfo *wolinfo) 758 { 759 struct usbnet *dev = netdev_priv(net); 760 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]); 761 int ret; 762 763 if (wolinfo->wolopts & ~SUPPORTED_WAKE) 764 return -EINVAL; 765 766 pdata->wolopts = wolinfo->wolopts & SUPPORTED_WAKE; 767 768 ret = device_set_wakeup_enable(&dev->udev->dev, pdata->wolopts); 769 if (ret < 0) 770 netdev_warn(dev->net, "device_set_wakeup_enable error %d\n", ret); 771 772 return ret; 773 } 774 775 static int get_mdix_status(struct net_device *net) 776 { 777 struct usbnet *dev = netdev_priv(net); 778 u32 val; 779 int buf; 780 781 buf = smsc95xx_mdio_read(dev->net, dev->mii.phy_id, SPECIAL_CTRL_STS); 782 if (buf & SPECIAL_CTRL_STS_OVRRD_AMDIX_) { 783 if (buf & SPECIAL_CTRL_STS_AMDIX_ENABLE_) 784 return ETH_TP_MDI_AUTO; 785 else if (buf & SPECIAL_CTRL_STS_AMDIX_STATE_) 786 return ETH_TP_MDI_X; 787 } else { 788 buf = smsc95xx_read_reg(dev, STRAP_STATUS, &val); 789 if (val & STRAP_STATUS_AMDIX_EN_) 790 return ETH_TP_MDI_AUTO; 791 } 792 793 return ETH_TP_MDI; 794 } 795 796 static void set_mdix_status(struct net_device *net, __u8 mdix_ctrl) 797 { 798 struct usbnet *dev = netdev_priv(net); 799 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]); 800 int buf; 801 802 if ((pdata->chip_id == ID_REV_CHIP_ID_9500A_) || 803 (pdata->chip_id == ID_REV_CHIP_ID_9530_) || 804 (pdata->chip_id == ID_REV_CHIP_ID_89530_) || 805 (pdata->chip_id == ID_REV_CHIP_ID_9730_)) { 806 /* Extend Manual AutoMDIX timer for 9500A/9500Ai */ 807 buf = smsc95xx_mdio_read(dev->net, dev->mii.phy_id, 808 PHY_EDPD_CONFIG); 809 buf |= PHY_EDPD_CONFIG_EXT_CROSSOVER_; 810 smsc95xx_mdio_write(dev->net, dev->mii.phy_id, 811 PHY_EDPD_CONFIG, buf); 812 } 813 814 if (mdix_ctrl == ETH_TP_MDI) { 815 buf = smsc95xx_mdio_read(dev->net, dev->mii.phy_id, 816 SPECIAL_CTRL_STS); 817 buf |= SPECIAL_CTRL_STS_OVRRD_AMDIX_; 818 buf &= ~(SPECIAL_CTRL_STS_AMDIX_ENABLE_ | 819 SPECIAL_CTRL_STS_AMDIX_STATE_); 820 smsc95xx_mdio_write(dev->net, dev->mii.phy_id, 821 SPECIAL_CTRL_STS, buf); 822 } else if (mdix_ctrl == ETH_TP_MDI_X) { 823 buf = smsc95xx_mdio_read(dev->net, dev->mii.phy_id, 824 SPECIAL_CTRL_STS); 825 buf |= SPECIAL_CTRL_STS_OVRRD_AMDIX_; 826 buf &= ~(SPECIAL_CTRL_STS_AMDIX_ENABLE_ | 827 SPECIAL_CTRL_STS_AMDIX_STATE_); 828 buf |= SPECIAL_CTRL_STS_AMDIX_STATE_; 829 smsc95xx_mdio_write(dev->net, dev->mii.phy_id, 830 SPECIAL_CTRL_STS, buf); 831 } else if (mdix_ctrl == ETH_TP_MDI_AUTO) { 832 buf = smsc95xx_mdio_read(dev->net, dev->mii.phy_id, 833 SPECIAL_CTRL_STS); 834 buf &= ~SPECIAL_CTRL_STS_OVRRD_AMDIX_; 835 buf &= ~(SPECIAL_CTRL_STS_AMDIX_ENABLE_ | 836 SPECIAL_CTRL_STS_AMDIX_STATE_); 837 buf |= SPECIAL_CTRL_STS_AMDIX_ENABLE_; 838 smsc95xx_mdio_write(dev->net, dev->mii.phy_id, 839 SPECIAL_CTRL_STS, buf); 840 } 841 pdata->mdix_ctrl = mdix_ctrl; 842 } 843 844 static int smsc95xx_get_link_ksettings(struct net_device *net, 845 struct ethtool_link_ksettings *cmd) 846 { 847 struct usbnet *dev = netdev_priv(net); 848 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]); 849 int retval; 850 851 retval = usbnet_get_link_ksettings(net, cmd); 852 853 cmd->base.eth_tp_mdix = pdata->mdix_ctrl; 854 cmd->base.eth_tp_mdix_ctrl = pdata->mdix_ctrl; 855 856 return retval; 857 } 858 859 static int smsc95xx_set_link_ksettings(struct net_device *net, 860 const struct ethtool_link_ksettings *cmd) 861 { 862 struct usbnet *dev = netdev_priv(net); 863 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]); 864 int retval; 865 866 if (pdata->mdix_ctrl != cmd->base.eth_tp_mdix_ctrl) 867 set_mdix_status(net, cmd->base.eth_tp_mdix_ctrl); 868 869 retval = usbnet_set_link_ksettings(net, cmd); 870 871 return retval; 872 } 873 874 static const struct ethtool_ops smsc95xx_ethtool_ops = { 875 .get_link = usbnet_get_link, 876 .nway_reset = usbnet_nway_reset, 877 .get_drvinfo = usbnet_get_drvinfo, 878 .get_msglevel = usbnet_get_msglevel, 879 .set_msglevel = usbnet_set_msglevel, 880 .get_eeprom_len = smsc95xx_ethtool_get_eeprom_len, 881 .get_eeprom = smsc95xx_ethtool_get_eeprom, 882 .set_eeprom = smsc95xx_ethtool_set_eeprom, 883 .get_regs_len = smsc95xx_ethtool_getregslen, 884 .get_regs = smsc95xx_ethtool_getregs, 885 .get_wol = smsc95xx_ethtool_get_wol, 886 .set_wol = smsc95xx_ethtool_set_wol, 887 .get_link_ksettings = smsc95xx_get_link_ksettings, 888 .set_link_ksettings = smsc95xx_set_link_ksettings, 889 .get_ts_info = ethtool_op_get_ts_info, 890 }; 891 892 static int smsc95xx_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd) 893 { 894 struct usbnet *dev = netdev_priv(netdev); 895 896 if (!netif_running(netdev)) 897 return -EINVAL; 898 899 return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL); 900 } 901 902 static void smsc95xx_init_mac_address(struct usbnet *dev) 903 { 904 const u8 *mac_addr; 905 906 /* maybe the boot loader passed the MAC address in devicetree */ 907 mac_addr = of_get_mac_address(dev->udev->dev.of_node); 908 if (!IS_ERR(mac_addr)) { 909 ether_addr_copy(dev->net->dev_addr, mac_addr); 910 return; 911 } 912 913 /* try reading mac address from EEPROM */ 914 if (smsc95xx_read_eeprom(dev, EEPROM_MAC_OFFSET, ETH_ALEN, 915 dev->net->dev_addr) == 0) { 916 if (is_valid_ether_addr(dev->net->dev_addr)) { 917 /* eeprom values are valid so use them */ 918 netif_dbg(dev, ifup, dev->net, "MAC address read from EEPROM\n"); 919 return; 920 } 921 } 922 923 /* no useful static MAC address found. generate a random one */ 924 eth_hw_addr_random(dev->net); 925 netif_dbg(dev, ifup, dev->net, "MAC address set to eth_random_addr\n"); 926 } 927 928 static int smsc95xx_set_mac_address(struct usbnet *dev) 929 { 930 u32 addr_lo = dev->net->dev_addr[0] | dev->net->dev_addr[1] << 8 | 931 dev->net->dev_addr[2] << 16 | dev->net->dev_addr[3] << 24; 932 u32 addr_hi = dev->net->dev_addr[4] | dev->net->dev_addr[5] << 8; 933 int ret; 934 935 ret = smsc95xx_write_reg(dev, ADDRL, addr_lo); 936 if (ret < 0) 937 return ret; 938 939 return smsc95xx_write_reg(dev, ADDRH, addr_hi); 940 } 941 942 /* starts the TX path */ 943 static int smsc95xx_start_tx_path(struct usbnet *dev) 944 { 945 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]); 946 unsigned long flags; 947 int ret; 948 949 /* Enable Tx at MAC */ 950 spin_lock_irqsave(&pdata->mac_cr_lock, flags); 951 pdata->mac_cr |= MAC_CR_TXEN_; 952 spin_unlock_irqrestore(&pdata->mac_cr_lock, flags); 953 954 ret = smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr); 955 if (ret < 0) 956 return ret; 957 958 /* Enable Tx at SCSRs */ 959 return smsc95xx_write_reg(dev, TX_CFG, TX_CFG_ON_); 960 } 961 962 /* Starts the Receive path */ 963 static int smsc95xx_start_rx_path(struct usbnet *dev, int in_pm) 964 { 965 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]); 966 unsigned long flags; 967 968 spin_lock_irqsave(&pdata->mac_cr_lock, flags); 969 pdata->mac_cr |= MAC_CR_RXEN_; 970 spin_unlock_irqrestore(&pdata->mac_cr_lock, flags); 971 972 return __smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr, in_pm); 973 } 974 975 static int smsc95xx_phy_initialize(struct usbnet *dev) 976 { 977 int bmcr, ret, timeout = 0; 978 979 /* Initialize MII structure */ 980 dev->mii.dev = dev->net; 981 dev->mii.mdio_read = smsc95xx_mdio_read; 982 dev->mii.mdio_write = smsc95xx_mdio_write; 983 dev->mii.phy_id_mask = 0x1f; 984 dev->mii.reg_num_mask = 0x1f; 985 dev->mii.phy_id = SMSC95XX_INTERNAL_PHY_ID; 986 987 /* reset phy and wait for reset to complete */ 988 smsc95xx_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET); 989 990 do { 991 msleep(10); 992 bmcr = smsc95xx_mdio_read(dev->net, dev->mii.phy_id, MII_BMCR); 993 timeout++; 994 } while ((bmcr & BMCR_RESET) && (timeout < 100)); 995 996 if (timeout >= 100) { 997 netdev_warn(dev->net, "timeout on PHY Reset"); 998 return -EIO; 999 } 1000 1001 smsc95xx_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE, 1002 ADVERTISE_ALL | ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP | 1003 ADVERTISE_PAUSE_ASYM); 1004 1005 /* read to clear */ 1006 ret = smsc95xx_mdio_read(dev->net, dev->mii.phy_id, PHY_INT_SRC); 1007 if (ret < 0) { 1008 netdev_warn(dev->net, "Failed to read PHY_INT_SRC during init\n"); 1009 return ret; 1010 } 1011 1012 smsc95xx_mdio_write(dev->net, dev->mii.phy_id, PHY_INT_MASK, 1013 PHY_INT_MASK_DEFAULT_); 1014 mii_nway_restart(&dev->mii); 1015 1016 netif_dbg(dev, ifup, dev->net, "phy initialised successfully\n"); 1017 return 0; 1018 } 1019 1020 static int smsc95xx_reset(struct usbnet *dev) 1021 { 1022 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]); 1023 u32 read_buf, write_buf, burst_cap; 1024 int ret = 0, timeout; 1025 1026 netif_dbg(dev, ifup, dev->net, "entering smsc95xx_reset\n"); 1027 1028 ret = smsc95xx_write_reg(dev, HW_CFG, HW_CFG_LRST_); 1029 if (ret < 0) 1030 return ret; 1031 1032 timeout = 0; 1033 do { 1034 msleep(10); 1035 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf); 1036 if (ret < 0) 1037 return ret; 1038 timeout++; 1039 } while ((read_buf & HW_CFG_LRST_) && (timeout < 100)); 1040 1041 if (timeout >= 100) { 1042 netdev_warn(dev->net, "timeout waiting for completion of Lite Reset\n"); 1043 return ret; 1044 } 1045 1046 ret = smsc95xx_write_reg(dev, PM_CTRL, PM_CTL_PHY_RST_); 1047 if (ret < 0) 1048 return ret; 1049 1050 timeout = 0; 1051 do { 1052 msleep(10); 1053 ret = smsc95xx_read_reg(dev, PM_CTRL, &read_buf); 1054 if (ret < 0) 1055 return ret; 1056 timeout++; 1057 } while ((read_buf & PM_CTL_PHY_RST_) && (timeout < 100)); 1058 1059 if (timeout >= 100) { 1060 netdev_warn(dev->net, "timeout waiting for PHY Reset\n"); 1061 return ret; 1062 } 1063 1064 ret = smsc95xx_set_mac_address(dev); 1065 if (ret < 0) 1066 return ret; 1067 1068 netif_dbg(dev, ifup, dev->net, "MAC Address: %pM\n", 1069 dev->net->dev_addr); 1070 1071 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf); 1072 if (ret < 0) 1073 return ret; 1074 1075 netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG : 0x%08x\n", 1076 read_buf); 1077 1078 read_buf |= HW_CFG_BIR_; 1079 1080 ret = smsc95xx_write_reg(dev, HW_CFG, read_buf); 1081 if (ret < 0) 1082 return ret; 1083 1084 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf); 1085 if (ret < 0) 1086 return ret; 1087 1088 netif_dbg(dev, ifup, dev->net, 1089 "Read Value from HW_CFG after writing HW_CFG_BIR_: 0x%08x\n", 1090 read_buf); 1091 1092 if (!turbo_mode) { 1093 burst_cap = 0; 1094 dev->rx_urb_size = MAX_SINGLE_PACKET_SIZE; 1095 } else if (dev->udev->speed == USB_SPEED_HIGH) { 1096 burst_cap = DEFAULT_HS_BURST_CAP_SIZE / HS_USB_PKT_SIZE; 1097 dev->rx_urb_size = DEFAULT_HS_BURST_CAP_SIZE; 1098 } else { 1099 burst_cap = DEFAULT_FS_BURST_CAP_SIZE / FS_USB_PKT_SIZE; 1100 dev->rx_urb_size = DEFAULT_FS_BURST_CAP_SIZE; 1101 } 1102 1103 netif_dbg(dev, ifup, dev->net, "rx_urb_size=%ld\n", 1104 (ulong)dev->rx_urb_size); 1105 1106 ret = smsc95xx_write_reg(dev, BURST_CAP, burst_cap); 1107 if (ret < 0) 1108 return ret; 1109 1110 ret = smsc95xx_read_reg(dev, BURST_CAP, &read_buf); 1111 if (ret < 0) 1112 return ret; 1113 1114 netif_dbg(dev, ifup, dev->net, 1115 "Read Value from BURST_CAP after writing: 0x%08x\n", 1116 read_buf); 1117 1118 ret = smsc95xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY); 1119 if (ret < 0) 1120 return ret; 1121 1122 ret = smsc95xx_read_reg(dev, BULK_IN_DLY, &read_buf); 1123 if (ret < 0) 1124 return ret; 1125 1126 netif_dbg(dev, ifup, dev->net, 1127 "Read Value from BULK_IN_DLY after writing: 0x%08x\n", 1128 read_buf); 1129 1130 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf); 1131 if (ret < 0) 1132 return ret; 1133 1134 netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG: 0x%08x\n", 1135 read_buf); 1136 1137 if (turbo_mode) 1138 read_buf |= (HW_CFG_MEF_ | HW_CFG_BCE_); 1139 1140 read_buf &= ~HW_CFG_RXDOFF_; 1141 1142 /* set Rx data offset=2, Make IP header aligns on word boundary. */ 1143 read_buf |= NET_IP_ALIGN << 9; 1144 1145 ret = smsc95xx_write_reg(dev, HW_CFG, read_buf); 1146 if (ret < 0) 1147 return ret; 1148 1149 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf); 1150 if (ret < 0) 1151 return ret; 1152 1153 netif_dbg(dev, ifup, dev->net, 1154 "Read Value from HW_CFG after writing: 0x%08x\n", read_buf); 1155 1156 ret = smsc95xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_); 1157 if (ret < 0) 1158 return ret; 1159 1160 ret = smsc95xx_read_reg(dev, ID_REV, &read_buf); 1161 if (ret < 0) 1162 return ret; 1163 netif_dbg(dev, ifup, dev->net, "ID_REV = 0x%08x\n", read_buf); 1164 1165 /* Configure GPIO pins as LED outputs */ 1166 write_buf = LED_GPIO_CFG_SPD_LED | LED_GPIO_CFG_LNK_LED | 1167 LED_GPIO_CFG_FDX_LED; 1168 ret = smsc95xx_write_reg(dev, LED_GPIO_CFG, write_buf); 1169 if (ret < 0) 1170 return ret; 1171 1172 /* Init Tx */ 1173 ret = smsc95xx_write_reg(dev, FLOW, 0); 1174 if (ret < 0) 1175 return ret; 1176 1177 ret = smsc95xx_write_reg(dev, AFC_CFG, AFC_CFG_DEFAULT); 1178 if (ret < 0) 1179 return ret; 1180 1181 /* Don't need mac_cr_lock during initialisation */ 1182 ret = smsc95xx_read_reg(dev, MAC_CR, &pdata->mac_cr); 1183 if (ret < 0) 1184 return ret; 1185 1186 /* Init Rx */ 1187 /* Set Vlan */ 1188 ret = smsc95xx_write_reg(dev, VLAN1, (u32)ETH_P_8021Q); 1189 if (ret < 0) 1190 return ret; 1191 1192 /* Enable or disable checksum offload engines */ 1193 ret = smsc95xx_set_features(dev->net, dev->net->features); 1194 if (ret < 0) { 1195 netdev_warn(dev->net, "Failed to set checksum offload features\n"); 1196 return ret; 1197 } 1198 1199 smsc95xx_set_multicast(dev->net); 1200 1201 ret = smsc95xx_phy_initialize(dev); 1202 if (ret < 0) { 1203 netdev_warn(dev->net, "Failed to init PHY\n"); 1204 return ret; 1205 } 1206 1207 ret = smsc95xx_read_reg(dev, INT_EP_CTL, &read_buf); 1208 if (ret < 0) 1209 return ret; 1210 1211 /* enable PHY interrupts */ 1212 read_buf |= INT_EP_CTL_PHY_INT_; 1213 1214 ret = smsc95xx_write_reg(dev, INT_EP_CTL, read_buf); 1215 if (ret < 0) 1216 return ret; 1217 1218 ret = smsc95xx_start_tx_path(dev); 1219 if (ret < 0) { 1220 netdev_warn(dev->net, "Failed to start TX path\n"); 1221 return ret; 1222 } 1223 1224 ret = smsc95xx_start_rx_path(dev, 0); 1225 if (ret < 0) { 1226 netdev_warn(dev->net, "Failed to start RX path\n"); 1227 return ret; 1228 } 1229 1230 netif_dbg(dev, ifup, dev->net, "smsc95xx_reset, return 0\n"); 1231 return 0; 1232 } 1233 1234 static const struct net_device_ops smsc95xx_netdev_ops = { 1235 .ndo_open = usbnet_open, 1236 .ndo_stop = usbnet_stop, 1237 .ndo_start_xmit = usbnet_start_xmit, 1238 .ndo_tx_timeout = usbnet_tx_timeout, 1239 .ndo_change_mtu = usbnet_change_mtu, 1240 .ndo_get_stats64 = usbnet_get_stats64, 1241 .ndo_set_mac_address = eth_mac_addr, 1242 .ndo_validate_addr = eth_validate_addr, 1243 .ndo_do_ioctl = smsc95xx_ioctl, 1244 .ndo_set_rx_mode = smsc95xx_set_multicast, 1245 .ndo_set_features = smsc95xx_set_features, 1246 }; 1247 1248 static int smsc95xx_bind(struct usbnet *dev, struct usb_interface *intf) 1249 { 1250 struct smsc95xx_priv *pdata = NULL; 1251 u32 val; 1252 int ret; 1253 1254 printk(KERN_INFO SMSC_CHIPNAME " v" SMSC_DRIVER_VERSION "\n"); 1255 1256 ret = usbnet_get_endpoints(dev, intf); 1257 if (ret < 0) { 1258 netdev_warn(dev->net, "usbnet_get_endpoints failed: %d\n", ret); 1259 return ret; 1260 } 1261 1262 dev->data[0] = (unsigned long)kzalloc(sizeof(struct smsc95xx_priv), 1263 GFP_KERNEL); 1264 1265 pdata = (struct smsc95xx_priv *)(dev->data[0]); 1266 if (!pdata) 1267 return -ENOMEM; 1268 1269 spin_lock_init(&pdata->mac_cr_lock); 1270 1271 /* LAN95xx devices do not alter the computed checksum of 0 to 0xffff. 1272 * RFC 2460, ipv6 UDP calculated checksum yields a result of zero must 1273 * be changed to 0xffff. RFC 768, ipv4 UDP computed checksum is zero, 1274 * it is transmitted as all ones. The zero transmitted checksum means 1275 * transmitter generated no checksum. Hence, enable csum offload only 1276 * for ipv4 packets. 1277 */ 1278 if (DEFAULT_TX_CSUM_ENABLE) 1279 dev->net->features |= NETIF_F_IP_CSUM; 1280 if (DEFAULT_RX_CSUM_ENABLE) 1281 dev->net->features |= NETIF_F_RXCSUM; 1282 1283 dev->net->hw_features = NETIF_F_IP_CSUM | NETIF_F_RXCSUM; 1284 set_bit(EVENT_NO_IP_ALIGN, &dev->flags); 1285 1286 smsc95xx_init_mac_address(dev); 1287 1288 /* Init all registers */ 1289 ret = smsc95xx_reset(dev); 1290 if (ret) 1291 goto free_pdata; 1292 1293 /* detect device revision as different features may be available */ 1294 ret = smsc95xx_read_reg(dev, ID_REV, &val); 1295 if (ret < 0) 1296 goto free_pdata; 1297 1298 val >>= 16; 1299 pdata->chip_id = val; 1300 pdata->mdix_ctrl = get_mdix_status(dev->net); 1301 1302 if ((val == ID_REV_CHIP_ID_9500A_) || (val == ID_REV_CHIP_ID_9530_) || 1303 (val == ID_REV_CHIP_ID_89530_) || (val == ID_REV_CHIP_ID_9730_)) 1304 pdata->features = (FEATURE_8_WAKEUP_FILTERS | 1305 FEATURE_PHY_NLP_CROSSOVER | 1306 FEATURE_REMOTE_WAKEUP); 1307 else if (val == ID_REV_CHIP_ID_9512_) 1308 pdata->features = FEATURE_8_WAKEUP_FILTERS; 1309 1310 dev->net->netdev_ops = &smsc95xx_netdev_ops; 1311 dev->net->ethtool_ops = &smsc95xx_ethtool_ops; 1312 dev->net->flags |= IFF_MULTICAST; 1313 dev->net->hard_header_len += SMSC95XX_TX_OVERHEAD_CSUM; 1314 dev->net->min_mtu = ETH_MIN_MTU; 1315 dev->net->max_mtu = ETH_DATA_LEN; 1316 dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len; 1317 1318 pdata->dev = dev; 1319 INIT_DELAYED_WORK(&pdata->carrier_check, check_carrier); 1320 schedule_delayed_work(&pdata->carrier_check, CARRIER_CHECK_DELAY); 1321 1322 return 0; 1323 1324 free_pdata: 1325 kfree(pdata); 1326 return ret; 1327 } 1328 1329 static void smsc95xx_unbind(struct usbnet *dev, struct usb_interface *intf) 1330 { 1331 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]); 1332 1333 if (pdata) { 1334 cancel_delayed_work_sync(&pdata->carrier_check); 1335 netif_dbg(dev, ifdown, dev->net, "free pdata\n"); 1336 kfree(pdata); 1337 pdata = NULL; 1338 dev->data[0] = 0; 1339 } 1340 } 1341 1342 static u32 smsc_crc(const u8 *buffer, size_t len, int filter) 1343 { 1344 u32 crc = bitrev16(crc16(0xFFFF, buffer, len)); 1345 return crc << ((filter % 2) * 16); 1346 } 1347 1348 static int smsc95xx_enable_phy_wakeup_interrupts(struct usbnet *dev, u16 mask) 1349 { 1350 struct mii_if_info *mii = &dev->mii; 1351 int ret; 1352 1353 netdev_dbg(dev->net, "enabling PHY wakeup interrupts\n"); 1354 1355 /* read to clear */ 1356 ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_SRC); 1357 if (ret < 0) 1358 return ret; 1359 1360 /* enable interrupt source */ 1361 ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_MASK); 1362 if (ret < 0) 1363 return ret; 1364 1365 ret |= mask; 1366 1367 smsc95xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_INT_MASK, ret); 1368 1369 return 0; 1370 } 1371 1372 static int smsc95xx_link_ok_nopm(struct usbnet *dev) 1373 { 1374 struct mii_if_info *mii = &dev->mii; 1375 int ret; 1376 1377 /* first, a dummy read, needed to latch some MII phys */ 1378 ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR); 1379 if (ret < 0) 1380 return ret; 1381 1382 ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR); 1383 if (ret < 0) 1384 return ret; 1385 1386 return !!(ret & BMSR_LSTATUS); 1387 } 1388 1389 static int smsc95xx_enter_suspend0(struct usbnet *dev) 1390 { 1391 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]); 1392 u32 val; 1393 int ret; 1394 1395 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val); 1396 if (ret < 0) 1397 return ret; 1398 1399 val &= (~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_)); 1400 val |= PM_CTL_SUS_MODE_0; 1401 1402 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val); 1403 if (ret < 0) 1404 return ret; 1405 1406 /* clear wol status */ 1407 val &= ~PM_CTL_WUPS_; 1408 val |= PM_CTL_WUPS_WOL_; 1409 1410 /* enable energy detection */ 1411 if (pdata->wolopts & WAKE_PHY) 1412 val |= PM_CTL_WUPS_ED_; 1413 1414 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val); 1415 if (ret < 0) 1416 return ret; 1417 1418 /* read back PM_CTRL */ 1419 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val); 1420 if (ret < 0) 1421 return ret; 1422 1423 pdata->suspend_flags |= SUSPEND_SUSPEND0; 1424 1425 return 0; 1426 } 1427 1428 static int smsc95xx_enter_suspend1(struct usbnet *dev) 1429 { 1430 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]); 1431 struct mii_if_info *mii = &dev->mii; 1432 u32 val; 1433 int ret; 1434 1435 /* reconfigure link pulse detection timing for 1436 * compatibility with non-standard link partners 1437 */ 1438 if (pdata->features & FEATURE_PHY_NLP_CROSSOVER) 1439 smsc95xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_EDPD_CONFIG, 1440 PHY_EDPD_CONFIG_DEFAULT); 1441 1442 /* enable energy detect power-down mode */ 1443 ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_MODE_CTRL_STS); 1444 if (ret < 0) 1445 return ret; 1446 1447 ret |= MODE_CTRL_STS_EDPWRDOWN_; 1448 1449 smsc95xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_MODE_CTRL_STS, ret); 1450 1451 /* enter SUSPEND1 mode */ 1452 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val); 1453 if (ret < 0) 1454 return ret; 1455 1456 val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_); 1457 val |= PM_CTL_SUS_MODE_1; 1458 1459 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val); 1460 if (ret < 0) 1461 return ret; 1462 1463 /* clear wol status, enable energy detection */ 1464 val &= ~PM_CTL_WUPS_; 1465 val |= (PM_CTL_WUPS_ED_ | PM_CTL_ED_EN_); 1466 1467 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val); 1468 if (ret < 0) 1469 return ret; 1470 1471 pdata->suspend_flags |= SUSPEND_SUSPEND1; 1472 1473 return 0; 1474 } 1475 1476 static int smsc95xx_enter_suspend2(struct usbnet *dev) 1477 { 1478 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]); 1479 u32 val; 1480 int ret; 1481 1482 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val); 1483 if (ret < 0) 1484 return ret; 1485 1486 val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_); 1487 val |= PM_CTL_SUS_MODE_2; 1488 1489 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val); 1490 if (ret < 0) 1491 return ret; 1492 1493 pdata->suspend_flags |= SUSPEND_SUSPEND2; 1494 1495 return 0; 1496 } 1497 1498 static int smsc95xx_enter_suspend3(struct usbnet *dev) 1499 { 1500 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]); 1501 u32 val; 1502 int ret; 1503 1504 ret = smsc95xx_read_reg_nopm(dev, RX_FIFO_INF, &val); 1505 if (ret < 0) 1506 return ret; 1507 1508 if (val & RX_FIFO_INF_USED_) { 1509 netdev_info(dev->net, "rx fifo not empty in autosuspend\n"); 1510 return -EBUSY; 1511 } 1512 1513 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val); 1514 if (ret < 0) 1515 return ret; 1516 1517 val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_); 1518 val |= PM_CTL_SUS_MODE_3 | PM_CTL_RES_CLR_WKP_STS; 1519 1520 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val); 1521 if (ret < 0) 1522 return ret; 1523 1524 /* clear wol status */ 1525 val &= ~PM_CTL_WUPS_; 1526 val |= PM_CTL_WUPS_WOL_; 1527 1528 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val); 1529 if (ret < 0) 1530 return ret; 1531 1532 pdata->suspend_flags |= SUSPEND_SUSPEND3; 1533 1534 return 0; 1535 } 1536 1537 static int smsc95xx_autosuspend(struct usbnet *dev, u32 link_up) 1538 { 1539 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]); 1540 int ret; 1541 1542 if (!netif_running(dev->net)) { 1543 /* interface is ifconfig down so fully power down hw */ 1544 netdev_dbg(dev->net, "autosuspend entering SUSPEND2\n"); 1545 return smsc95xx_enter_suspend2(dev); 1546 } 1547 1548 if (!link_up) { 1549 /* link is down so enter EDPD mode, but only if device can 1550 * reliably resume from it. This check should be redundant 1551 * as current FEATURE_REMOTE_WAKEUP parts also support 1552 * FEATURE_PHY_NLP_CROSSOVER but it's included for clarity */ 1553 if (!(pdata->features & FEATURE_PHY_NLP_CROSSOVER)) { 1554 netdev_warn(dev->net, "EDPD not supported\n"); 1555 return -EBUSY; 1556 } 1557 1558 netdev_dbg(dev->net, "autosuspend entering SUSPEND1\n"); 1559 1560 /* enable PHY wakeup events for if cable is attached */ 1561 ret = smsc95xx_enable_phy_wakeup_interrupts(dev, 1562 PHY_INT_MASK_ANEG_COMP_); 1563 if (ret < 0) { 1564 netdev_warn(dev->net, "error enabling PHY wakeup ints\n"); 1565 return ret; 1566 } 1567 1568 netdev_info(dev->net, "entering SUSPEND1 mode\n"); 1569 return smsc95xx_enter_suspend1(dev); 1570 } 1571 1572 /* enable PHY wakeup events so we remote wakeup if cable is pulled */ 1573 ret = smsc95xx_enable_phy_wakeup_interrupts(dev, 1574 PHY_INT_MASK_LINK_DOWN_); 1575 if (ret < 0) { 1576 netdev_warn(dev->net, "error enabling PHY wakeup ints\n"); 1577 return ret; 1578 } 1579 1580 netdev_dbg(dev->net, "autosuspend entering SUSPEND3\n"); 1581 return smsc95xx_enter_suspend3(dev); 1582 } 1583 1584 static int smsc95xx_suspend(struct usb_interface *intf, pm_message_t message) 1585 { 1586 struct usbnet *dev = usb_get_intfdata(intf); 1587 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]); 1588 u32 val, link_up; 1589 int ret; 1590 1591 ret = usbnet_suspend(intf, message); 1592 if (ret < 0) { 1593 netdev_warn(dev->net, "usbnet_suspend error\n"); 1594 return ret; 1595 } 1596 1597 cancel_delayed_work_sync(&pdata->carrier_check); 1598 1599 if (pdata->suspend_flags) { 1600 netdev_warn(dev->net, "error during last resume\n"); 1601 pdata->suspend_flags = 0; 1602 } 1603 1604 /* determine if link is up using only _nopm functions */ 1605 link_up = smsc95xx_link_ok_nopm(dev); 1606 1607 if (message.event == PM_EVENT_AUTO_SUSPEND && 1608 (pdata->features & FEATURE_REMOTE_WAKEUP)) { 1609 ret = smsc95xx_autosuspend(dev, link_up); 1610 goto done; 1611 } 1612 1613 /* if we get this far we're not autosuspending */ 1614 /* if no wol options set, or if link is down and we're not waking on 1615 * PHY activity, enter lowest power SUSPEND2 mode 1616 */ 1617 if (!(pdata->wolopts & SUPPORTED_WAKE) || 1618 !(link_up || (pdata->wolopts & WAKE_PHY))) { 1619 netdev_info(dev->net, "entering SUSPEND2 mode\n"); 1620 1621 /* disable energy detect (link up) & wake up events */ 1622 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val); 1623 if (ret < 0) 1624 goto done; 1625 1626 val &= ~(WUCSR_MPEN_ | WUCSR_WAKE_EN_); 1627 1628 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val); 1629 if (ret < 0) 1630 goto done; 1631 1632 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val); 1633 if (ret < 0) 1634 goto done; 1635 1636 val &= ~(PM_CTL_ED_EN_ | PM_CTL_WOL_EN_); 1637 1638 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val); 1639 if (ret < 0) 1640 goto done; 1641 1642 ret = smsc95xx_enter_suspend2(dev); 1643 goto done; 1644 } 1645 1646 if (pdata->wolopts & WAKE_PHY) { 1647 ret = smsc95xx_enable_phy_wakeup_interrupts(dev, 1648 (PHY_INT_MASK_ANEG_COMP_ | PHY_INT_MASK_LINK_DOWN_)); 1649 if (ret < 0) { 1650 netdev_warn(dev->net, "error enabling PHY wakeup ints\n"); 1651 goto done; 1652 } 1653 1654 /* if link is down then configure EDPD and enter SUSPEND1, 1655 * otherwise enter SUSPEND0 below 1656 */ 1657 if (!link_up) { 1658 netdev_info(dev->net, "entering SUSPEND1 mode\n"); 1659 ret = smsc95xx_enter_suspend1(dev); 1660 goto done; 1661 } 1662 } 1663 1664 if (pdata->wolopts & (WAKE_BCAST | WAKE_MCAST | WAKE_ARP | WAKE_UCAST)) { 1665 u32 *filter_mask = kcalloc(32, sizeof(u32), GFP_KERNEL); 1666 u32 command[2]; 1667 u32 offset[2]; 1668 u32 crc[4]; 1669 int wuff_filter_count = 1670 (pdata->features & FEATURE_8_WAKEUP_FILTERS) ? 1671 LAN9500A_WUFF_NUM : LAN9500_WUFF_NUM; 1672 int i, filter = 0; 1673 1674 if (!filter_mask) { 1675 netdev_warn(dev->net, "Unable to allocate filter_mask\n"); 1676 ret = -ENOMEM; 1677 goto done; 1678 } 1679 1680 memset(command, 0, sizeof(command)); 1681 memset(offset, 0, sizeof(offset)); 1682 memset(crc, 0, sizeof(crc)); 1683 1684 if (pdata->wolopts & WAKE_BCAST) { 1685 const u8 bcast[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; 1686 netdev_info(dev->net, "enabling broadcast detection\n"); 1687 filter_mask[filter * 4] = 0x003F; 1688 filter_mask[filter * 4 + 1] = 0x00; 1689 filter_mask[filter * 4 + 2] = 0x00; 1690 filter_mask[filter * 4 + 3] = 0x00; 1691 command[filter/4] |= 0x05UL << ((filter % 4) * 8); 1692 offset[filter/4] |= 0x00 << ((filter % 4) * 8); 1693 crc[filter/2] |= smsc_crc(bcast, 6, filter); 1694 filter++; 1695 } 1696 1697 if (pdata->wolopts & WAKE_MCAST) { 1698 const u8 mcast[] = {0x01, 0x00, 0x5E}; 1699 netdev_info(dev->net, "enabling multicast detection\n"); 1700 filter_mask[filter * 4] = 0x0007; 1701 filter_mask[filter * 4 + 1] = 0x00; 1702 filter_mask[filter * 4 + 2] = 0x00; 1703 filter_mask[filter * 4 + 3] = 0x00; 1704 command[filter/4] |= 0x09UL << ((filter % 4) * 8); 1705 offset[filter/4] |= 0x00 << ((filter % 4) * 8); 1706 crc[filter/2] |= smsc_crc(mcast, 3, filter); 1707 filter++; 1708 } 1709 1710 if (pdata->wolopts & WAKE_ARP) { 1711 const u8 arp[] = {0x08, 0x06}; 1712 netdev_info(dev->net, "enabling ARP detection\n"); 1713 filter_mask[filter * 4] = 0x0003; 1714 filter_mask[filter * 4 + 1] = 0x00; 1715 filter_mask[filter * 4 + 2] = 0x00; 1716 filter_mask[filter * 4 + 3] = 0x00; 1717 command[filter/4] |= 0x05UL << ((filter % 4) * 8); 1718 offset[filter/4] |= 0x0C << ((filter % 4) * 8); 1719 crc[filter/2] |= smsc_crc(arp, 2, filter); 1720 filter++; 1721 } 1722 1723 if (pdata->wolopts & WAKE_UCAST) { 1724 netdev_info(dev->net, "enabling unicast detection\n"); 1725 filter_mask[filter * 4] = 0x003F; 1726 filter_mask[filter * 4 + 1] = 0x00; 1727 filter_mask[filter * 4 + 2] = 0x00; 1728 filter_mask[filter * 4 + 3] = 0x00; 1729 command[filter/4] |= 0x01UL << ((filter % 4) * 8); 1730 offset[filter/4] |= 0x00 << ((filter % 4) * 8); 1731 crc[filter/2] |= smsc_crc(dev->net->dev_addr, ETH_ALEN, filter); 1732 filter++; 1733 } 1734 1735 for (i = 0; i < (wuff_filter_count * 4); i++) { 1736 ret = smsc95xx_write_reg_nopm(dev, WUFF, filter_mask[i]); 1737 if (ret < 0) { 1738 kfree(filter_mask); 1739 goto done; 1740 } 1741 } 1742 kfree(filter_mask); 1743 1744 for (i = 0; i < (wuff_filter_count / 4); i++) { 1745 ret = smsc95xx_write_reg_nopm(dev, WUFF, command[i]); 1746 if (ret < 0) 1747 goto done; 1748 } 1749 1750 for (i = 0; i < (wuff_filter_count / 4); i++) { 1751 ret = smsc95xx_write_reg_nopm(dev, WUFF, offset[i]); 1752 if (ret < 0) 1753 goto done; 1754 } 1755 1756 for (i = 0; i < (wuff_filter_count / 2); i++) { 1757 ret = smsc95xx_write_reg_nopm(dev, WUFF, crc[i]); 1758 if (ret < 0) 1759 goto done; 1760 } 1761 1762 /* clear any pending pattern match packet status */ 1763 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val); 1764 if (ret < 0) 1765 goto done; 1766 1767 val |= WUCSR_WUFR_; 1768 1769 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val); 1770 if (ret < 0) 1771 goto done; 1772 } 1773 1774 if (pdata->wolopts & WAKE_MAGIC) { 1775 /* clear any pending magic packet status */ 1776 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val); 1777 if (ret < 0) 1778 goto done; 1779 1780 val |= WUCSR_MPR_; 1781 1782 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val); 1783 if (ret < 0) 1784 goto done; 1785 } 1786 1787 /* enable/disable wakeup sources */ 1788 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val); 1789 if (ret < 0) 1790 goto done; 1791 1792 if (pdata->wolopts & (WAKE_BCAST | WAKE_MCAST | WAKE_ARP | WAKE_UCAST)) { 1793 netdev_info(dev->net, "enabling pattern match wakeup\n"); 1794 val |= WUCSR_WAKE_EN_; 1795 } else { 1796 netdev_info(dev->net, "disabling pattern match wakeup\n"); 1797 val &= ~WUCSR_WAKE_EN_; 1798 } 1799 1800 if (pdata->wolopts & WAKE_MAGIC) { 1801 netdev_info(dev->net, "enabling magic packet wakeup\n"); 1802 val |= WUCSR_MPEN_; 1803 } else { 1804 netdev_info(dev->net, "disabling magic packet wakeup\n"); 1805 val &= ~WUCSR_MPEN_; 1806 } 1807 1808 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val); 1809 if (ret < 0) 1810 goto done; 1811 1812 /* enable wol wakeup source */ 1813 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val); 1814 if (ret < 0) 1815 goto done; 1816 1817 val |= PM_CTL_WOL_EN_; 1818 1819 /* phy energy detect wakeup source */ 1820 if (pdata->wolopts & WAKE_PHY) 1821 val |= PM_CTL_ED_EN_; 1822 1823 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val); 1824 if (ret < 0) 1825 goto done; 1826 1827 /* enable receiver to enable frame reception */ 1828 smsc95xx_start_rx_path(dev, 1); 1829 1830 /* some wol options are enabled, so enter SUSPEND0 */ 1831 netdev_info(dev->net, "entering SUSPEND0 mode\n"); 1832 ret = smsc95xx_enter_suspend0(dev); 1833 1834 done: 1835 /* 1836 * TODO: resume() might need to handle the suspend failure 1837 * in system sleep 1838 */ 1839 if (ret && PMSG_IS_AUTO(message)) 1840 usbnet_resume(intf); 1841 1842 if (ret) 1843 schedule_delayed_work(&pdata->carrier_check, 1844 CARRIER_CHECK_DELAY); 1845 1846 return ret; 1847 } 1848 1849 static int smsc95xx_resume(struct usb_interface *intf) 1850 { 1851 struct usbnet *dev = usb_get_intfdata(intf); 1852 struct smsc95xx_priv *pdata; 1853 u8 suspend_flags; 1854 int ret; 1855 u32 val; 1856 1857 BUG_ON(!dev); 1858 pdata = (struct smsc95xx_priv *)(dev->data[0]); 1859 suspend_flags = pdata->suspend_flags; 1860 1861 netdev_dbg(dev->net, "resume suspend_flags=0x%02x\n", suspend_flags); 1862 1863 /* do this first to ensure it's cleared even in error case */ 1864 pdata->suspend_flags = 0; 1865 schedule_delayed_work(&pdata->carrier_check, CARRIER_CHECK_DELAY); 1866 1867 if (suspend_flags & SUSPEND_ALLMODES) { 1868 /* clear wake-up sources */ 1869 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val); 1870 if (ret < 0) 1871 return ret; 1872 1873 val &= ~(WUCSR_WAKE_EN_ | WUCSR_MPEN_); 1874 1875 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val); 1876 if (ret < 0) 1877 return ret; 1878 1879 /* clear wake-up status */ 1880 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val); 1881 if (ret < 0) 1882 return ret; 1883 1884 val &= ~PM_CTL_WOL_EN_; 1885 val |= PM_CTL_WUPS_; 1886 1887 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val); 1888 if (ret < 0) 1889 return ret; 1890 } 1891 1892 ret = usbnet_resume(intf); 1893 if (ret < 0) 1894 netdev_warn(dev->net, "usbnet_resume error\n"); 1895 1896 return ret; 1897 } 1898 1899 static int smsc95xx_reset_resume(struct usb_interface *intf) 1900 { 1901 struct usbnet *dev = usb_get_intfdata(intf); 1902 int ret; 1903 1904 ret = smsc95xx_reset(dev); 1905 if (ret < 0) 1906 return ret; 1907 1908 return smsc95xx_resume(intf); 1909 } 1910 1911 static void smsc95xx_rx_csum_offload(struct sk_buff *skb) 1912 { 1913 skb->csum = *(u16 *)(skb_tail_pointer(skb) - 2); 1914 skb->ip_summed = CHECKSUM_COMPLETE; 1915 skb_trim(skb, skb->len - 2); 1916 } 1917 1918 static int smsc95xx_rx_fixup(struct usbnet *dev, struct sk_buff *skb) 1919 { 1920 /* This check is no longer done by usbnet */ 1921 if (skb->len < dev->net->hard_header_len) 1922 return 0; 1923 1924 while (skb->len > 0) { 1925 u32 header, align_count; 1926 struct sk_buff *ax_skb; 1927 unsigned char *packet; 1928 u16 size; 1929 1930 header = get_unaligned_le32(skb->data); 1931 skb_pull(skb, 4 + NET_IP_ALIGN); 1932 packet = skb->data; 1933 1934 /* get the packet length */ 1935 size = (u16)((header & RX_STS_FL_) >> 16); 1936 align_count = (4 - ((size + NET_IP_ALIGN) % 4)) % 4; 1937 1938 if (unlikely(header & RX_STS_ES_)) { 1939 netif_dbg(dev, rx_err, dev->net, 1940 "Error header=0x%08x\n", header); 1941 dev->net->stats.rx_errors++; 1942 dev->net->stats.rx_dropped++; 1943 1944 if (header & RX_STS_CRC_) { 1945 dev->net->stats.rx_crc_errors++; 1946 } else { 1947 if (header & (RX_STS_TL_ | RX_STS_RF_)) 1948 dev->net->stats.rx_frame_errors++; 1949 1950 if ((header & RX_STS_LE_) && 1951 (!(header & RX_STS_FT_))) 1952 dev->net->stats.rx_length_errors++; 1953 } 1954 } else { 1955 /* ETH_FRAME_LEN + 4(CRC) + 2(COE) + 4(Vlan) */ 1956 if (unlikely(size > (ETH_FRAME_LEN + 12))) { 1957 netif_dbg(dev, rx_err, dev->net, 1958 "size err header=0x%08x\n", header); 1959 return 0; 1960 } 1961 1962 /* last frame in this batch */ 1963 if (skb->len == size) { 1964 if (dev->net->features & NETIF_F_RXCSUM) 1965 smsc95xx_rx_csum_offload(skb); 1966 skb_trim(skb, skb->len - 4); /* remove fcs */ 1967 skb->truesize = size + sizeof(struct sk_buff); 1968 1969 return 1; 1970 } 1971 1972 ax_skb = skb_clone(skb, GFP_ATOMIC); 1973 if (unlikely(!ax_skb)) { 1974 netdev_warn(dev->net, "Error allocating skb\n"); 1975 return 0; 1976 } 1977 1978 ax_skb->len = size; 1979 ax_skb->data = packet; 1980 skb_set_tail_pointer(ax_skb, size); 1981 1982 if (dev->net->features & NETIF_F_RXCSUM) 1983 smsc95xx_rx_csum_offload(ax_skb); 1984 skb_trim(ax_skb, ax_skb->len - 4); /* remove fcs */ 1985 ax_skb->truesize = size + sizeof(struct sk_buff); 1986 1987 usbnet_skb_return(dev, ax_skb); 1988 } 1989 1990 skb_pull(skb, size); 1991 1992 /* padding bytes before the next frame starts */ 1993 if (skb->len) 1994 skb_pull(skb, align_count); 1995 } 1996 1997 return 1; 1998 } 1999 2000 static u32 smsc95xx_calc_csum_preamble(struct sk_buff *skb) 2001 { 2002 u16 low_16 = (u16)skb_checksum_start_offset(skb); 2003 u16 high_16 = low_16 + skb->csum_offset; 2004 return (high_16 << 16) | low_16; 2005 } 2006 2007 /* The TX CSUM won't work if the checksum lies in the last 4 bytes of the 2008 * transmission. This is fairly unlikely, only seems to trigger with some 2009 * short TCP ACK packets sent. 2010 * 2011 * Note, this calculation should probably check for the alignment of the 2012 * data as well, but a straight check for csum being in the last four bytes 2013 * of the packet should be ok for now. 2014 */ 2015 static bool smsc95xx_can_tx_checksum(struct sk_buff *skb) 2016 { 2017 unsigned int len = skb->len - skb_checksum_start_offset(skb); 2018 2019 if (skb->len <= 45) 2020 return false; 2021 return skb->csum_offset < (len - (4 + 1)); 2022 } 2023 2024 static struct sk_buff *smsc95xx_tx_fixup(struct usbnet *dev, 2025 struct sk_buff *skb, gfp_t flags) 2026 { 2027 bool csum = skb->ip_summed == CHECKSUM_PARTIAL; 2028 int overhead = csum ? SMSC95XX_TX_OVERHEAD_CSUM : SMSC95XX_TX_OVERHEAD; 2029 u32 tx_cmd_a, tx_cmd_b; 2030 void *ptr; 2031 2032 /* We do not advertise SG, so skbs should be already linearized */ 2033 BUG_ON(skb_shinfo(skb)->nr_frags); 2034 2035 /* Make writable and expand header space by overhead if required */ 2036 if (skb_cow_head(skb, overhead)) { 2037 /* Must deallocate here as returning NULL to indicate error 2038 * means the skb won't be deallocated in the caller. 2039 */ 2040 dev_kfree_skb_any(skb); 2041 return NULL; 2042 } 2043 2044 tx_cmd_b = (u32)skb->len; 2045 tx_cmd_a = tx_cmd_b | TX_CMD_A_FIRST_SEG_ | TX_CMD_A_LAST_SEG_; 2046 2047 if (csum) { 2048 if (!smsc95xx_can_tx_checksum(skb)) { 2049 /* workaround - hardware tx checksum does not work 2050 * properly with extremely small packets */ 2051 long csstart = skb_checksum_start_offset(skb); 2052 __wsum calc = csum_partial(skb->data + csstart, 2053 skb->len - csstart, 0); 2054 *((__sum16 *)(skb->data + csstart 2055 + skb->csum_offset)) = csum_fold(calc); 2056 2057 csum = false; 2058 } else { 2059 u32 csum_preamble = smsc95xx_calc_csum_preamble(skb); 2060 ptr = skb_push(skb, 4); 2061 put_unaligned_le32(csum_preamble, ptr); 2062 2063 tx_cmd_a += 4; 2064 tx_cmd_b += 4; 2065 tx_cmd_b |= TX_CMD_B_CSUM_ENABLE; 2066 } 2067 } 2068 2069 ptr = skb_push(skb, 8); 2070 put_unaligned_le32(tx_cmd_a, ptr); 2071 put_unaligned_le32(tx_cmd_b, ptr+4); 2072 2073 return skb; 2074 } 2075 2076 static int smsc95xx_manage_power(struct usbnet *dev, int on) 2077 { 2078 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]); 2079 2080 dev->intf->needs_remote_wakeup = on; 2081 2082 if (pdata->features & FEATURE_REMOTE_WAKEUP) 2083 return 0; 2084 2085 /* this chip revision isn't capable of remote wakeup */ 2086 netdev_info(dev->net, "hardware isn't capable of remote wakeup\n"); 2087 2088 if (on) 2089 usb_autopm_get_interface_no_resume(dev->intf); 2090 else 2091 usb_autopm_put_interface(dev->intf); 2092 2093 return 0; 2094 } 2095 2096 static const struct driver_info smsc95xx_info = { 2097 .description = "smsc95xx USB 2.0 Ethernet", 2098 .bind = smsc95xx_bind, 2099 .unbind = smsc95xx_unbind, 2100 .link_reset = smsc95xx_link_reset, 2101 .reset = smsc95xx_reset, 2102 .rx_fixup = smsc95xx_rx_fixup, 2103 .tx_fixup = smsc95xx_tx_fixup, 2104 .status = smsc95xx_status, 2105 .manage_power = smsc95xx_manage_power, 2106 .flags = FLAG_ETHER | FLAG_SEND_ZLP | FLAG_LINK_INTR, 2107 }; 2108 2109 static const struct usb_device_id products[] = { 2110 { 2111 /* SMSC9500 USB Ethernet Device */ 2112 USB_DEVICE(0x0424, 0x9500), 2113 .driver_info = (unsigned long) &smsc95xx_info, 2114 }, 2115 { 2116 /* SMSC9505 USB Ethernet Device */ 2117 USB_DEVICE(0x0424, 0x9505), 2118 .driver_info = (unsigned long) &smsc95xx_info, 2119 }, 2120 { 2121 /* SMSC9500A USB Ethernet Device */ 2122 USB_DEVICE(0x0424, 0x9E00), 2123 .driver_info = (unsigned long) &smsc95xx_info, 2124 }, 2125 { 2126 /* SMSC9505A USB Ethernet Device */ 2127 USB_DEVICE(0x0424, 0x9E01), 2128 .driver_info = (unsigned long) &smsc95xx_info, 2129 }, 2130 { 2131 /* SMSC9512/9514 USB Hub & Ethernet Device */ 2132 USB_DEVICE(0x0424, 0xec00), 2133 .driver_info = (unsigned long) &smsc95xx_info, 2134 }, 2135 { 2136 /* SMSC9500 USB Ethernet Device (SAL10) */ 2137 USB_DEVICE(0x0424, 0x9900), 2138 .driver_info = (unsigned long) &smsc95xx_info, 2139 }, 2140 { 2141 /* SMSC9505 USB Ethernet Device (SAL10) */ 2142 USB_DEVICE(0x0424, 0x9901), 2143 .driver_info = (unsigned long) &smsc95xx_info, 2144 }, 2145 { 2146 /* SMSC9500A USB Ethernet Device (SAL10) */ 2147 USB_DEVICE(0x0424, 0x9902), 2148 .driver_info = (unsigned long) &smsc95xx_info, 2149 }, 2150 { 2151 /* SMSC9505A USB Ethernet Device (SAL10) */ 2152 USB_DEVICE(0x0424, 0x9903), 2153 .driver_info = (unsigned long) &smsc95xx_info, 2154 }, 2155 { 2156 /* SMSC9512/9514 USB Hub & Ethernet Device (SAL10) */ 2157 USB_DEVICE(0x0424, 0x9904), 2158 .driver_info = (unsigned long) &smsc95xx_info, 2159 }, 2160 { 2161 /* SMSC9500A USB Ethernet Device (HAL) */ 2162 USB_DEVICE(0x0424, 0x9905), 2163 .driver_info = (unsigned long) &smsc95xx_info, 2164 }, 2165 { 2166 /* SMSC9505A USB Ethernet Device (HAL) */ 2167 USB_DEVICE(0x0424, 0x9906), 2168 .driver_info = (unsigned long) &smsc95xx_info, 2169 }, 2170 { 2171 /* SMSC9500 USB Ethernet Device (Alternate ID) */ 2172 USB_DEVICE(0x0424, 0x9907), 2173 .driver_info = (unsigned long) &smsc95xx_info, 2174 }, 2175 { 2176 /* SMSC9500A USB Ethernet Device (Alternate ID) */ 2177 USB_DEVICE(0x0424, 0x9908), 2178 .driver_info = (unsigned long) &smsc95xx_info, 2179 }, 2180 { 2181 /* SMSC9512/9514 USB Hub & Ethernet Device (Alternate ID) */ 2182 USB_DEVICE(0x0424, 0x9909), 2183 .driver_info = (unsigned long) &smsc95xx_info, 2184 }, 2185 { 2186 /* SMSC LAN9530 USB Ethernet Device */ 2187 USB_DEVICE(0x0424, 0x9530), 2188 .driver_info = (unsigned long) &smsc95xx_info, 2189 }, 2190 { 2191 /* SMSC LAN9730 USB Ethernet Device */ 2192 USB_DEVICE(0x0424, 0x9730), 2193 .driver_info = (unsigned long) &smsc95xx_info, 2194 }, 2195 { 2196 /* SMSC LAN89530 USB Ethernet Device */ 2197 USB_DEVICE(0x0424, 0x9E08), 2198 .driver_info = (unsigned long) &smsc95xx_info, 2199 }, 2200 { }, /* END */ 2201 }; 2202 MODULE_DEVICE_TABLE(usb, products); 2203 2204 static struct usb_driver smsc95xx_driver = { 2205 .name = "smsc95xx", 2206 .id_table = products, 2207 .probe = usbnet_probe, 2208 .suspend = smsc95xx_suspend, 2209 .resume = smsc95xx_resume, 2210 .reset_resume = smsc95xx_reset_resume, 2211 .disconnect = usbnet_disconnect, 2212 .disable_hub_initiated_lpm = 1, 2213 .supports_autosuspend = 1, 2214 }; 2215 2216 module_usb_driver(smsc95xx_driver); 2217 2218 MODULE_AUTHOR("Nancy Lin"); 2219 MODULE_AUTHOR("Steve Glendinning <steve.glendinning@shawell.net>"); 2220 MODULE_DESCRIPTION("SMSC95XX USB 2.0 Ethernet Devices"); 2221 MODULE_LICENSE("GPL"); 2222