1 /***************************************************************************
3 * Copyright (C) 2007-2008 SMSC
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 *****************************************************************************/
21 #include <linux/module.h>
22 #include <linux/kmod.h>
23 #include <linux/init.h>
24 #include <linux/netdevice.h>
25 #include <linux/etherdevice.h>
26 #include <linux/ethtool.h>
27 #include <linux/mii.h>
28 #include <linux/usb.h>
29 #include <linux/bitrev.h>
30 #include <linux/crc16.h>
31 #include <linux/crc32.h>
32 #include <linux/usb/usbnet.h>
33 #include <linux/slab.h>
36 #define SMSC_CHIPNAME "smsc95xx"
37 #define SMSC_DRIVER_VERSION "1.0.4"
38 #define HS_USB_PKT_SIZE (512)
39 #define FS_USB_PKT_SIZE (64)
40 #define DEFAULT_HS_BURST_CAP_SIZE (16 * 1024 + 5 * HS_USB_PKT_SIZE)
41 #define DEFAULT_FS_BURST_CAP_SIZE (6 * 1024 + 33 * FS_USB_PKT_SIZE)
42 #define DEFAULT_BULK_IN_DELAY (0x00002000)
43 #define MAX_SINGLE_PACKET_SIZE (2048)
44 #define LAN95XX_EEPROM_MAGIC (0x9500)
45 #define EEPROM_MAC_OFFSET (0x01)
46 #define DEFAULT_TX_CSUM_ENABLE (true)
47 #define DEFAULT_RX_CSUM_ENABLE (true)
48 #define SMSC95XX_INTERNAL_PHY_ID (1)
49 #define SMSC95XX_TX_OVERHEAD (8)
50 #define SMSC95XX_TX_OVERHEAD_CSUM (12)
51 #define SUPPORTED_WAKE (WAKE_PHY | WAKE_UCAST | WAKE_BCAST | \
52 WAKE_MCAST | WAKE_ARP | WAKE_MAGIC)
54 #define FEATURE_8_WAKEUP_FILTERS (0x01)
55 #define FEATURE_PHY_NLP_CROSSOVER (0x02)
56 #define FEATURE_AUTOSUSPEND (0x04)
58 struct smsc95xx_priv {
63 spinlock_t mac_cr_lock;
67 static bool turbo_mode = true;
68 module_param(turbo_mode, bool, 0644);
69 MODULE_PARM_DESC(turbo_mode, "Enable multiple frames per Rx transaction");
71 static int __must_check __smsc95xx_read_reg(struct usbnet *dev, u32 index,
76 int (*fn)(struct usbnet *, u8, u8, u16, u16, void *, u16);
83 fn = usbnet_read_cmd_nopm;
85 ret = fn(dev, USB_VENDOR_REQUEST_READ_REGISTER, USB_DIR_IN
86 | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
88 if (unlikely(ret < 0))
89 netdev_warn(dev->net, "Failed to read reg index 0x%08x: %d\n",
98 static int __must_check __smsc95xx_write_reg(struct usbnet *dev, u32 index,
103 int (*fn)(struct usbnet *, u8, u8, u16, u16, const void *, u16);
108 fn = usbnet_write_cmd;
110 fn = usbnet_write_cmd_nopm;
115 ret = fn(dev, USB_VENDOR_REQUEST_WRITE_REGISTER, USB_DIR_OUT
116 | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
118 if (unlikely(ret < 0))
119 netdev_warn(dev->net, "Failed to write reg index 0x%08x: %d\n",
125 static int __must_check smsc95xx_read_reg_nopm(struct usbnet *dev, u32 index,
128 return __smsc95xx_read_reg(dev, index, data, 1);
131 static int __must_check smsc95xx_write_reg_nopm(struct usbnet *dev, u32 index,
134 return __smsc95xx_write_reg(dev, index, data, 1);
137 static int __must_check smsc95xx_read_reg(struct usbnet *dev, u32 index,
140 return __smsc95xx_read_reg(dev, index, data, 0);
143 static int __must_check smsc95xx_write_reg(struct usbnet *dev, u32 index,
146 return __smsc95xx_write_reg(dev, index, data, 0);
149 /* Loop until the read is completed with timeout
150 * called with phy_mutex held */
151 static int __must_check __smsc95xx_phy_wait_not_busy(struct usbnet *dev,
154 unsigned long start_time = jiffies;
159 ret = __smsc95xx_read_reg(dev, MII_ADDR, &val, in_pm);
161 netdev_warn(dev->net, "Error reading MII_ACCESS\n");
165 if (!(val & MII_BUSY_))
167 } while (!time_after(jiffies, start_time + HZ));
172 static int __smsc95xx_mdio_read(struct net_device *netdev, int phy_id, int idx,
175 struct usbnet *dev = netdev_priv(netdev);
179 mutex_lock(&dev->phy_mutex);
181 /* confirm MII not busy */
182 ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
184 netdev_warn(dev->net, "MII is busy in smsc95xx_mdio_read\n");
188 /* set the address, index & direction (read from PHY) */
189 phy_id &= dev->mii.phy_id_mask;
190 idx &= dev->mii.reg_num_mask;
191 addr = (phy_id << 11) | (idx << 6) | MII_READ_ | MII_BUSY_;
192 ret = __smsc95xx_write_reg(dev, MII_ADDR, addr, in_pm);
194 netdev_warn(dev->net, "Error writing MII_ADDR\n");
198 ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
200 netdev_warn(dev->net, "Timed out reading MII reg %02X\n", idx);
204 ret = __smsc95xx_read_reg(dev, MII_DATA, &val, in_pm);
206 netdev_warn(dev->net, "Error reading MII_DATA\n");
210 ret = (u16)(val & 0xFFFF);
213 mutex_unlock(&dev->phy_mutex);
217 static void __smsc95xx_mdio_write(struct net_device *netdev, int phy_id,
218 int idx, int regval, int in_pm)
220 struct usbnet *dev = netdev_priv(netdev);
224 mutex_lock(&dev->phy_mutex);
226 /* confirm MII not busy */
227 ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
229 netdev_warn(dev->net, "MII is busy in smsc95xx_mdio_write\n");
234 ret = __smsc95xx_write_reg(dev, MII_DATA, val, in_pm);
236 netdev_warn(dev->net, "Error writing MII_DATA\n");
240 /* set the address, index & direction (write to PHY) */
241 phy_id &= dev->mii.phy_id_mask;
242 idx &= dev->mii.reg_num_mask;
243 addr = (phy_id << 11) | (idx << 6) | MII_WRITE_ | MII_BUSY_;
244 ret = __smsc95xx_write_reg(dev, MII_ADDR, addr, in_pm);
246 netdev_warn(dev->net, "Error writing MII_ADDR\n");
250 ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
252 netdev_warn(dev->net, "Timed out writing MII reg %02X\n", idx);
257 mutex_unlock(&dev->phy_mutex);
260 static int smsc95xx_mdio_read_nopm(struct net_device *netdev, int phy_id,
263 return __smsc95xx_mdio_read(netdev, phy_id, idx, 1);
266 static void smsc95xx_mdio_write_nopm(struct net_device *netdev, int phy_id,
269 __smsc95xx_mdio_write(netdev, phy_id, idx, regval, 1);
272 static int smsc95xx_mdio_read(struct net_device *netdev, int phy_id, int idx)
274 return __smsc95xx_mdio_read(netdev, phy_id, idx, 0);
277 static void smsc95xx_mdio_write(struct net_device *netdev, int phy_id, int idx,
280 __smsc95xx_mdio_write(netdev, phy_id, idx, regval, 0);
283 static int __must_check smsc95xx_wait_eeprom(struct usbnet *dev)
285 unsigned long start_time = jiffies;
290 ret = smsc95xx_read_reg(dev, E2P_CMD, &val);
292 netdev_warn(dev->net, "Error reading E2P_CMD\n");
296 if (!(val & E2P_CMD_BUSY_) || (val & E2P_CMD_TIMEOUT_))
299 } while (!time_after(jiffies, start_time + HZ));
301 if (val & (E2P_CMD_TIMEOUT_ | E2P_CMD_BUSY_)) {
302 netdev_warn(dev->net, "EEPROM read operation timeout\n");
309 static int __must_check smsc95xx_eeprom_confirm_not_busy(struct usbnet *dev)
311 unsigned long start_time = jiffies;
316 ret = smsc95xx_read_reg(dev, E2P_CMD, &val);
318 netdev_warn(dev->net, "Error reading E2P_CMD\n");
322 if (!(val & E2P_CMD_BUSY_))
326 } while (!time_after(jiffies, start_time + HZ));
328 netdev_warn(dev->net, "EEPROM is busy\n");
332 static int smsc95xx_read_eeprom(struct usbnet *dev, u32 offset, u32 length,
341 ret = smsc95xx_eeprom_confirm_not_busy(dev);
345 for (i = 0; i < length; i++) {
346 val = E2P_CMD_BUSY_ | E2P_CMD_READ_ | (offset & E2P_CMD_ADDR_);
347 ret = smsc95xx_write_reg(dev, E2P_CMD, val);
349 netdev_warn(dev->net, "Error writing E2P_CMD\n");
353 ret = smsc95xx_wait_eeprom(dev);
357 ret = smsc95xx_read_reg(dev, E2P_DATA, &val);
359 netdev_warn(dev->net, "Error reading E2P_DATA\n");
363 data[i] = val & 0xFF;
370 static int smsc95xx_write_eeprom(struct usbnet *dev, u32 offset, u32 length,
379 ret = smsc95xx_eeprom_confirm_not_busy(dev);
383 /* Issue write/erase enable command */
384 val = E2P_CMD_BUSY_ | E2P_CMD_EWEN_;
385 ret = smsc95xx_write_reg(dev, E2P_CMD, val);
387 netdev_warn(dev->net, "Error writing E2P_DATA\n");
391 ret = smsc95xx_wait_eeprom(dev);
395 for (i = 0; i < length; i++) {
397 /* Fill data register */
399 ret = smsc95xx_write_reg(dev, E2P_DATA, val);
401 netdev_warn(dev->net, "Error writing E2P_DATA\n");
405 /* Send "write" command */
406 val = E2P_CMD_BUSY_ | E2P_CMD_WRITE_ | (offset & E2P_CMD_ADDR_);
407 ret = smsc95xx_write_reg(dev, E2P_CMD, val);
409 netdev_warn(dev->net, "Error writing E2P_CMD\n");
413 ret = smsc95xx_wait_eeprom(dev);
423 static int __must_check smsc95xx_write_reg_async(struct usbnet *dev, u16 index,
433 ret = usbnet_write_cmd_async(dev, USB_VENDOR_REQUEST_WRITE_REGISTER,
434 USB_DIR_OUT | USB_TYPE_VENDOR |
436 0, index, &buf, size);
438 netdev_warn(dev->net, "Error write async cmd, sts=%d\n",
443 /* returns hash bit number for given MAC address
445 * 01 00 5E 00 00 01 -> returns bit number 31 */
446 static unsigned int smsc95xx_hash(char addr[ETH_ALEN])
448 return (ether_crc(ETH_ALEN, addr) >> 26) & 0x3f;
451 static void smsc95xx_set_multicast(struct net_device *netdev)
453 struct usbnet *dev = netdev_priv(netdev);
454 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
461 spin_lock_irqsave(&pdata->mac_cr_lock, flags);
463 if (dev->net->flags & IFF_PROMISC) {
464 netif_dbg(dev, drv, dev->net, "promiscuous mode enabled\n");
465 pdata->mac_cr |= MAC_CR_PRMS_;
466 pdata->mac_cr &= ~(MAC_CR_MCPAS_ | MAC_CR_HPFILT_);
467 } else if (dev->net->flags & IFF_ALLMULTI) {
468 netif_dbg(dev, drv, dev->net, "receive all multicast enabled\n");
469 pdata->mac_cr |= MAC_CR_MCPAS_;
470 pdata->mac_cr &= ~(MAC_CR_PRMS_ | MAC_CR_HPFILT_);
471 } else if (!netdev_mc_empty(dev->net)) {
472 struct netdev_hw_addr *ha;
474 pdata->mac_cr |= MAC_CR_HPFILT_;
475 pdata->mac_cr &= ~(MAC_CR_PRMS_ | MAC_CR_MCPAS_);
477 netdev_for_each_mc_addr(ha, netdev) {
478 u32 bitnum = smsc95xx_hash(ha->addr);
479 u32 mask = 0x01 << (bitnum & 0x1F);
481 pdata->hash_hi |= mask;
483 pdata->hash_lo |= mask;
486 netif_dbg(dev, drv, dev->net, "HASHH=0x%08X, HASHL=0x%08X\n",
487 pdata->hash_hi, pdata->hash_lo);
489 netif_dbg(dev, drv, dev->net, "receive own packets only\n");
491 ~(MAC_CR_PRMS_ | MAC_CR_MCPAS_ | MAC_CR_HPFILT_);
494 spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);
496 /* Initiate async writes, as we can't wait for completion here */
497 ret = smsc95xx_write_reg_async(dev, HASHH, pdata->hash_hi);
499 netdev_warn(dev->net, "failed to initiate async write to HASHH\n");
501 ret = smsc95xx_write_reg_async(dev, HASHL, pdata->hash_lo);
503 netdev_warn(dev->net, "failed to initiate async write to HASHL\n");
505 ret = smsc95xx_write_reg_async(dev, MAC_CR, pdata->mac_cr);
507 netdev_warn(dev->net, "failed to initiate async write to MAC_CR\n");
510 static int smsc95xx_phy_update_flowcontrol(struct usbnet *dev, u8 duplex,
511 u16 lcladv, u16 rmtadv)
513 u32 flow, afc_cfg = 0;
515 int ret = smsc95xx_read_reg(dev, AFC_CFG, &afc_cfg);
517 netdev_warn(dev->net, "Error reading AFC_CFG\n");
521 if (duplex == DUPLEX_FULL) {
522 u8 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
524 if (cap & FLOW_CTRL_RX)
529 if (cap & FLOW_CTRL_TX)
534 netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s\n",
535 cap & FLOW_CTRL_RX ? "enabled" : "disabled",
536 cap & FLOW_CTRL_TX ? "enabled" : "disabled");
538 netif_dbg(dev, link, dev->net, "half duplex\n");
543 ret = smsc95xx_write_reg(dev, FLOW, flow);
545 netdev_warn(dev->net, "Error writing FLOW\n");
549 ret = smsc95xx_write_reg(dev, AFC_CFG, afc_cfg);
551 netdev_warn(dev->net, "Error writing AFC_CFG\n");
556 static int smsc95xx_link_reset(struct usbnet *dev)
558 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
559 struct mii_if_info *mii = &dev->mii;
560 struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET };
565 /* clear interrupt status */
566 ret = smsc95xx_mdio_read(dev->net, mii->phy_id, PHY_INT_SRC);
568 netdev_warn(dev->net, "Error reading PHY_INT_SRC\n");
572 ret = smsc95xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
574 netdev_warn(dev->net, "Error writing INT_STS\n");
578 mii_check_media(mii, 1, 1);
579 mii_ethtool_gset(&dev->mii, &ecmd);
580 lcladv = smsc95xx_mdio_read(dev->net, mii->phy_id, MII_ADVERTISE);
581 rmtadv = smsc95xx_mdio_read(dev->net, mii->phy_id, MII_LPA);
583 netif_dbg(dev, link, dev->net,
584 "speed: %u duplex: %d lcladv: %04x rmtadv: %04x\n",
585 ethtool_cmd_speed(&ecmd), ecmd.duplex, lcladv, rmtadv);
587 spin_lock_irqsave(&pdata->mac_cr_lock, flags);
588 if (ecmd.duplex != DUPLEX_FULL) {
589 pdata->mac_cr &= ~MAC_CR_FDPX_;
590 pdata->mac_cr |= MAC_CR_RCVOWN_;
592 pdata->mac_cr &= ~MAC_CR_RCVOWN_;
593 pdata->mac_cr |= MAC_CR_FDPX_;
595 spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);
597 ret = smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr);
599 netdev_warn(dev->net, "Error writing MAC_CR\n");
603 ret = smsc95xx_phy_update_flowcontrol(dev, ecmd.duplex, lcladv, rmtadv);
605 netdev_warn(dev->net, "Error updating PHY flow control\n");
610 static void smsc95xx_status(struct usbnet *dev, struct urb *urb)
614 if (urb->actual_length != 4) {
615 netdev_warn(dev->net, "unexpected urb length %d\n",
620 memcpy(&intdata, urb->transfer_buffer, 4);
621 le32_to_cpus(&intdata);
623 netif_dbg(dev, link, dev->net, "intdata: 0x%08X\n", intdata);
625 if (intdata & INT_ENP_PHY_INT_)
626 usbnet_defer_kevent(dev, EVENT_LINK_RESET);
628 netdev_warn(dev->net, "unexpected interrupt, intdata=0x%08X\n",
632 /* Enable or disable Tx & Rx checksum offload engines */
633 static int smsc95xx_set_features(struct net_device *netdev,
634 netdev_features_t features)
636 struct usbnet *dev = netdev_priv(netdev);
640 ret = smsc95xx_read_reg(dev, COE_CR, &read_buf);
642 netdev_warn(dev->net, "Failed to read COE_CR: %d\n", ret);
646 if (features & NETIF_F_HW_CSUM)
647 read_buf |= Tx_COE_EN_;
649 read_buf &= ~Tx_COE_EN_;
651 if (features & NETIF_F_RXCSUM)
652 read_buf |= Rx_COE_EN_;
654 read_buf &= ~Rx_COE_EN_;
656 ret = smsc95xx_write_reg(dev, COE_CR, read_buf);
658 netdev_warn(dev->net, "Failed to write COE_CR: %d\n", ret);
662 netif_dbg(dev, hw, dev->net, "COE_CR = 0x%08x\n", read_buf);
666 static int smsc95xx_ethtool_get_eeprom_len(struct net_device *net)
668 return MAX_EEPROM_SIZE;
671 static int smsc95xx_ethtool_get_eeprom(struct net_device *netdev,
672 struct ethtool_eeprom *ee, u8 *data)
674 struct usbnet *dev = netdev_priv(netdev);
676 ee->magic = LAN95XX_EEPROM_MAGIC;
678 return smsc95xx_read_eeprom(dev, ee->offset, ee->len, data);
681 static int smsc95xx_ethtool_set_eeprom(struct net_device *netdev,
682 struct ethtool_eeprom *ee, u8 *data)
684 struct usbnet *dev = netdev_priv(netdev);
686 if (ee->magic != LAN95XX_EEPROM_MAGIC) {
687 netdev_warn(dev->net, "EEPROM: magic value mismatch, magic = 0x%x\n",
692 return smsc95xx_write_eeprom(dev, ee->offset, ee->len, data);
695 static int smsc95xx_ethtool_getregslen(struct net_device *netdev)
697 /* all smsc95xx registers */
698 return COE_CR - ID_REV + sizeof(u32);
702 smsc95xx_ethtool_getregs(struct net_device *netdev, struct ethtool_regs *regs,
705 struct usbnet *dev = netdev_priv(netdev);
710 retval = smsc95xx_read_reg(dev, ID_REV, ®s->version);
712 netdev_warn(netdev, "REGS: cannot read ID_REV\n");
716 for (i = ID_REV, j = 0; i <= COE_CR; i += (sizeof(u32)), j++) {
717 retval = smsc95xx_read_reg(dev, i, &data[j]);
719 netdev_warn(netdev, "REGS: cannot read reg[%x]\n", i);
725 static void smsc95xx_ethtool_get_wol(struct net_device *net,
726 struct ethtool_wolinfo *wolinfo)
728 struct usbnet *dev = netdev_priv(net);
729 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
731 wolinfo->supported = SUPPORTED_WAKE;
732 wolinfo->wolopts = pdata->wolopts;
735 static int smsc95xx_ethtool_set_wol(struct net_device *net,
736 struct ethtool_wolinfo *wolinfo)
738 struct usbnet *dev = netdev_priv(net);
739 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
742 pdata->wolopts = wolinfo->wolopts & SUPPORTED_WAKE;
744 ret = device_set_wakeup_enable(&dev->udev->dev, pdata->wolopts);
746 netdev_warn(dev->net, "device_set_wakeup_enable error %d\n", ret);
751 static const struct ethtool_ops smsc95xx_ethtool_ops = {
752 .get_link = usbnet_get_link,
753 .nway_reset = usbnet_nway_reset,
754 .get_drvinfo = usbnet_get_drvinfo,
755 .get_msglevel = usbnet_get_msglevel,
756 .set_msglevel = usbnet_set_msglevel,
757 .get_settings = usbnet_get_settings,
758 .set_settings = usbnet_set_settings,
759 .get_eeprom_len = smsc95xx_ethtool_get_eeprom_len,
760 .get_eeprom = smsc95xx_ethtool_get_eeprom,
761 .set_eeprom = smsc95xx_ethtool_set_eeprom,
762 .get_regs_len = smsc95xx_ethtool_getregslen,
763 .get_regs = smsc95xx_ethtool_getregs,
764 .get_wol = smsc95xx_ethtool_get_wol,
765 .set_wol = smsc95xx_ethtool_set_wol,
768 static int smsc95xx_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
770 struct usbnet *dev = netdev_priv(netdev);
772 if (!netif_running(netdev))
775 return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
778 static void smsc95xx_init_mac_address(struct usbnet *dev)
780 /* try reading mac address from EEPROM */
781 if (smsc95xx_read_eeprom(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
782 dev->net->dev_addr) == 0) {
783 if (is_valid_ether_addr(dev->net->dev_addr)) {
784 /* eeprom values are valid so use them */
785 netif_dbg(dev, ifup, dev->net, "MAC address read from EEPROM\n");
790 /* no eeprom, or eeprom values are invalid. generate random MAC */
791 eth_hw_addr_random(dev->net);
792 netif_dbg(dev, ifup, dev->net, "MAC address set to eth_random_addr\n");
795 static int smsc95xx_set_mac_address(struct usbnet *dev)
797 u32 addr_lo = dev->net->dev_addr[0] | dev->net->dev_addr[1] << 8 |
798 dev->net->dev_addr[2] << 16 | dev->net->dev_addr[3] << 24;
799 u32 addr_hi = dev->net->dev_addr[4] | dev->net->dev_addr[5] << 8;
802 ret = smsc95xx_write_reg(dev, ADDRL, addr_lo);
804 netdev_warn(dev->net, "Failed to write ADDRL: %d\n", ret);
808 ret = smsc95xx_write_reg(dev, ADDRH, addr_hi);
810 netdev_warn(dev->net, "Failed to write ADDRH: %d\n", ret);
815 /* starts the TX path */
816 static int smsc95xx_start_tx_path(struct usbnet *dev)
818 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
822 /* Enable Tx at MAC */
823 spin_lock_irqsave(&pdata->mac_cr_lock, flags);
824 pdata->mac_cr |= MAC_CR_TXEN_;
825 spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);
827 ret = smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr);
829 netdev_warn(dev->net, "Failed to write MAC_CR: %d\n", ret);
833 /* Enable Tx at SCSRs */
834 ret = smsc95xx_write_reg(dev, TX_CFG, TX_CFG_ON_);
836 netdev_warn(dev->net, "Failed to write TX_CFG: %d\n", ret);
841 /* Starts the Receive path */
842 static int smsc95xx_start_rx_path(struct usbnet *dev, int in_pm)
844 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
848 spin_lock_irqsave(&pdata->mac_cr_lock, flags);
849 pdata->mac_cr |= MAC_CR_RXEN_;
850 spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);
852 ret = __smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr, in_pm);
854 netdev_warn(dev->net, "Failed to write MAC_CR: %d\n", ret);
859 static int smsc95xx_phy_initialize(struct usbnet *dev)
861 int bmcr, ret, timeout = 0;
863 /* Initialize MII structure */
864 dev->mii.dev = dev->net;
865 dev->mii.mdio_read = smsc95xx_mdio_read;
866 dev->mii.mdio_write = smsc95xx_mdio_write;
867 dev->mii.phy_id_mask = 0x1f;
868 dev->mii.reg_num_mask = 0x1f;
869 dev->mii.phy_id = SMSC95XX_INTERNAL_PHY_ID;
871 /* reset phy and wait for reset to complete */
872 smsc95xx_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET);
876 bmcr = smsc95xx_mdio_read(dev->net, dev->mii.phy_id, MII_BMCR);
878 } while ((bmcr & BMCR_RESET) && (timeout < 100));
880 if (timeout >= 100) {
881 netdev_warn(dev->net, "timeout on PHY Reset");
885 smsc95xx_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,
886 ADVERTISE_ALL | ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP |
887 ADVERTISE_PAUSE_ASYM);
890 ret = smsc95xx_mdio_read(dev->net, dev->mii.phy_id, PHY_INT_SRC);
892 netdev_warn(dev->net, "Failed to read PHY_INT_SRC during init\n");
896 smsc95xx_mdio_write(dev->net, dev->mii.phy_id, PHY_INT_MASK,
897 PHY_INT_MASK_DEFAULT_);
898 mii_nway_restart(&dev->mii);
900 netif_dbg(dev, ifup, dev->net, "phy initialised successfully\n");
904 static int smsc95xx_reset(struct usbnet *dev)
906 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
907 u32 read_buf, write_buf, burst_cap;
908 int ret = 0, timeout;
910 netif_dbg(dev, ifup, dev->net, "entering smsc95xx_reset\n");
912 ret = smsc95xx_write_reg(dev, HW_CFG, HW_CFG_LRST_);
914 netdev_warn(dev->net, "Failed to write HW_CFG_LRST_ bit in HW_CFG\n");
921 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
923 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
927 } while ((read_buf & HW_CFG_LRST_) && (timeout < 100));
929 if (timeout >= 100) {
930 netdev_warn(dev->net, "timeout waiting for completion of Lite Reset\n");
934 ret = smsc95xx_write_reg(dev, PM_CTRL, PM_CTL_PHY_RST_);
936 netdev_warn(dev->net, "Failed to write PM_CTRL: %d\n", ret);
943 ret = smsc95xx_read_reg(dev, PM_CTRL, &read_buf);
945 netdev_warn(dev->net, "Failed to read PM_CTRL: %d\n", ret);
949 } while ((read_buf & PM_CTL_PHY_RST_) && (timeout < 100));
951 if (timeout >= 100) {
952 netdev_warn(dev->net, "timeout waiting for PHY Reset\n");
956 ret = smsc95xx_set_mac_address(dev);
960 netif_dbg(dev, ifup, dev->net, "MAC Address: %pM\n",
963 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
965 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
969 netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG : 0x%08x\n",
972 read_buf |= HW_CFG_BIR_;
974 ret = smsc95xx_write_reg(dev, HW_CFG, read_buf);
976 netdev_warn(dev->net, "Failed to write HW_CFG_BIR_ bit in HW_CFG\n");
980 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
982 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
986 netif_dbg(dev, ifup, dev->net,
987 "Read Value from HW_CFG after writing HW_CFG_BIR_: 0x%08x\n",
992 dev->rx_urb_size = MAX_SINGLE_PACKET_SIZE;
993 } else if (dev->udev->speed == USB_SPEED_HIGH) {
994 burst_cap = DEFAULT_HS_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
995 dev->rx_urb_size = DEFAULT_HS_BURST_CAP_SIZE;
997 burst_cap = DEFAULT_FS_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
998 dev->rx_urb_size = DEFAULT_FS_BURST_CAP_SIZE;
1001 netif_dbg(dev, ifup, dev->net, "rx_urb_size=%ld\n",
1002 (ulong)dev->rx_urb_size);
1004 ret = smsc95xx_write_reg(dev, BURST_CAP, burst_cap);
1006 netdev_warn(dev->net, "Failed to write BURST_CAP: %d\n", ret);
1010 ret = smsc95xx_read_reg(dev, BURST_CAP, &read_buf);
1012 netdev_warn(dev->net, "Failed to read BURST_CAP: %d\n", ret);
1016 netif_dbg(dev, ifup, dev->net,
1017 "Read Value from BURST_CAP after writing: 0x%08x\n",
1020 ret = smsc95xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
1022 netdev_warn(dev->net, "Failed to write BULK_IN_DLY: %d\n", ret);
1026 ret = smsc95xx_read_reg(dev, BULK_IN_DLY, &read_buf);
1028 netdev_warn(dev->net, "Failed to read BULK_IN_DLY: %d\n", ret);
1032 netif_dbg(dev, ifup, dev->net,
1033 "Read Value from BULK_IN_DLY after writing: 0x%08x\n",
1036 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
1038 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
1042 netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG: 0x%08x\n",
1046 read_buf |= (HW_CFG_MEF_ | HW_CFG_BCE_);
1048 read_buf &= ~HW_CFG_RXDOFF_;
1050 /* set Rx data offset=2, Make IP header aligns on word boundary. */
1051 read_buf |= NET_IP_ALIGN << 9;
1053 ret = smsc95xx_write_reg(dev, HW_CFG, read_buf);
1055 netdev_warn(dev->net, "Failed to write HW_CFG: %d\n", ret);
1059 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
1061 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
1065 netif_dbg(dev, ifup, dev->net,
1066 "Read Value from HW_CFG after writing: 0x%08x\n", read_buf);
1068 ret = smsc95xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
1070 netdev_warn(dev->net, "Failed to write INT_STS: %d\n", ret);
1074 ret = smsc95xx_read_reg(dev, ID_REV, &read_buf);
1076 netdev_warn(dev->net, "Failed to read ID_REV: %d\n", ret);
1079 netif_dbg(dev, ifup, dev->net, "ID_REV = 0x%08x\n", read_buf);
1081 /* Configure GPIO pins as LED outputs */
1082 write_buf = LED_GPIO_CFG_SPD_LED | LED_GPIO_CFG_LNK_LED |
1083 LED_GPIO_CFG_FDX_LED;
1084 ret = smsc95xx_write_reg(dev, LED_GPIO_CFG, write_buf);
1086 netdev_warn(dev->net, "Failed to write LED_GPIO_CFG: %d\n", ret);
1091 ret = smsc95xx_write_reg(dev, FLOW, 0);
1093 netdev_warn(dev->net, "Failed to write FLOW: %d\n", ret);
1097 ret = smsc95xx_write_reg(dev, AFC_CFG, AFC_CFG_DEFAULT);
1099 netdev_warn(dev->net, "Failed to write AFC_CFG: %d\n", ret);
1103 /* Don't need mac_cr_lock during initialisation */
1104 ret = smsc95xx_read_reg(dev, MAC_CR, &pdata->mac_cr);
1106 netdev_warn(dev->net, "Failed to read MAC_CR: %d\n", ret);
1112 ret = smsc95xx_write_reg(dev, VLAN1, (u32)ETH_P_8021Q);
1114 netdev_warn(dev->net, "Failed to write VLAN1: %d\n", ret);
1118 /* Enable or disable checksum offload engines */
1119 ret = smsc95xx_set_features(dev->net, dev->net->features);
1121 netdev_warn(dev->net, "Failed to set checksum offload features\n");
1125 smsc95xx_set_multicast(dev->net);
1127 ret = smsc95xx_phy_initialize(dev);
1129 netdev_warn(dev->net, "Failed to init PHY\n");
1133 ret = smsc95xx_read_reg(dev, INT_EP_CTL, &read_buf);
1135 netdev_warn(dev->net, "Failed to read INT_EP_CTL: %d\n", ret);
1139 /* enable PHY interrupts */
1140 read_buf |= INT_EP_CTL_PHY_INT_;
1142 ret = smsc95xx_write_reg(dev, INT_EP_CTL, read_buf);
1144 netdev_warn(dev->net, "Failed to write INT_EP_CTL: %d\n", ret);
1148 ret = smsc95xx_start_tx_path(dev);
1150 netdev_warn(dev->net, "Failed to start TX path\n");
1154 ret = smsc95xx_start_rx_path(dev, 0);
1156 netdev_warn(dev->net, "Failed to start RX path\n");
1160 netif_dbg(dev, ifup, dev->net, "smsc95xx_reset, return 0\n");
1164 static const struct net_device_ops smsc95xx_netdev_ops = {
1165 .ndo_open = usbnet_open,
1166 .ndo_stop = usbnet_stop,
1167 .ndo_start_xmit = usbnet_start_xmit,
1168 .ndo_tx_timeout = usbnet_tx_timeout,
1169 .ndo_change_mtu = usbnet_change_mtu,
1170 .ndo_set_mac_address = eth_mac_addr,
1171 .ndo_validate_addr = eth_validate_addr,
1172 .ndo_do_ioctl = smsc95xx_ioctl,
1173 .ndo_set_rx_mode = smsc95xx_set_multicast,
1174 .ndo_set_features = smsc95xx_set_features,
1177 static int smsc95xx_bind(struct usbnet *dev, struct usb_interface *intf)
1179 struct smsc95xx_priv *pdata = NULL;
1183 printk(KERN_INFO SMSC_CHIPNAME " v" SMSC_DRIVER_VERSION "\n");
1185 ret = usbnet_get_endpoints(dev, intf);
1187 netdev_warn(dev->net, "usbnet_get_endpoints failed: %d\n", ret);
1191 dev->data[0] = (unsigned long)kzalloc(sizeof(struct smsc95xx_priv),
1194 pdata = (struct smsc95xx_priv *)(dev->data[0]);
1196 netdev_warn(dev->net, "Unable to allocate struct smsc95xx_priv\n");
1200 spin_lock_init(&pdata->mac_cr_lock);
1202 if (DEFAULT_TX_CSUM_ENABLE)
1203 dev->net->features |= NETIF_F_HW_CSUM;
1204 if (DEFAULT_RX_CSUM_ENABLE)
1205 dev->net->features |= NETIF_F_RXCSUM;
1207 dev->net->hw_features = NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
1209 smsc95xx_init_mac_address(dev);
1211 /* Init all registers */
1212 ret = smsc95xx_reset(dev);
1214 /* detect device revision as different features may be available */
1215 ret = smsc95xx_read_reg(dev, ID_REV, &val);
1217 netdev_warn(dev->net, "Failed to read ID_REV: %d\n", ret);
1222 if ((val == ID_REV_CHIP_ID_9500A_) || (val == ID_REV_CHIP_ID_9530_) ||
1223 (val == ID_REV_CHIP_ID_89530_) || (val == ID_REV_CHIP_ID_9730_))
1224 pdata->features = (FEATURE_8_WAKEUP_FILTERS |
1225 FEATURE_PHY_NLP_CROSSOVER |
1226 FEATURE_AUTOSUSPEND);
1227 else if (val == ID_REV_CHIP_ID_9512_)
1228 pdata->features = FEATURE_8_WAKEUP_FILTERS;
1230 dev->net->netdev_ops = &smsc95xx_netdev_ops;
1231 dev->net->ethtool_ops = &smsc95xx_ethtool_ops;
1232 dev->net->flags |= IFF_MULTICAST;
1233 dev->net->hard_header_len += SMSC95XX_TX_OVERHEAD_CSUM;
1234 dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
1238 static void smsc95xx_unbind(struct usbnet *dev, struct usb_interface *intf)
1240 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1242 netif_dbg(dev, ifdown, dev->net, "free pdata\n");
1249 static u32 smsc_crc(const u8 *buffer, size_t len, int filter)
1251 u32 crc = bitrev16(crc16(0xFFFF, buffer, len));
1252 return crc << ((filter % 2) * 16);
1255 static int smsc95xx_enable_phy_wakeup_interrupts(struct usbnet *dev, u16 mask)
1257 struct mii_if_info *mii = &dev->mii;
1260 netdev_dbg(dev->net, "enabling PHY wakeup interrupts\n");
1263 ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_SRC);
1265 netdev_warn(dev->net, "Error reading PHY_INT_SRC\n");
1269 /* enable interrupt source */
1270 ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_MASK);
1272 netdev_warn(dev->net, "Error reading PHY_INT_MASK\n");
1278 smsc95xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_INT_MASK, ret);
1283 static int smsc95xx_link_ok_nopm(struct usbnet *dev)
1285 struct mii_if_info *mii = &dev->mii;
1288 /* first, a dummy read, needed to latch some MII phys */
1289 ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR);
1291 netdev_warn(dev->net, "Error reading MII_BMSR\n");
1295 ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR);
1297 netdev_warn(dev->net, "Error reading MII_BMSR\n");
1301 return !!(ret & BMSR_LSTATUS);
1304 static int smsc95xx_enter_suspend0(struct usbnet *dev)
1306 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1310 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1312 netdev_warn(dev->net, "Error reading PM_CTRL\n");
1316 val &= (~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_));
1317 val |= PM_CTL_SUS_MODE_0;
1319 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1321 netdev_warn(dev->net, "Error writing PM_CTRL\n");
1325 /* clear wol status */
1326 val &= ~PM_CTL_WUPS_;
1327 val |= PM_CTL_WUPS_WOL_;
1329 /* enable energy detection */
1330 if (pdata->wolopts & WAKE_PHY)
1331 val |= PM_CTL_WUPS_ED_;
1333 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1335 netdev_warn(dev->net, "Error writing PM_CTRL\n");
1339 /* read back PM_CTRL */
1340 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1342 netdev_warn(dev->net, "Error reading PM_CTRL\n");
1347 static int smsc95xx_enter_suspend1(struct usbnet *dev)
1349 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1350 struct mii_if_info *mii = &dev->mii;
1354 /* reconfigure link pulse detection timing for
1355 * compatibility with non-standard link partners
1357 if (pdata->features & FEATURE_PHY_NLP_CROSSOVER)
1358 smsc95xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_EDPD_CONFIG,
1359 PHY_EDPD_CONFIG_DEFAULT);
1361 /* enable energy detect power-down mode */
1362 ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_MODE_CTRL_STS);
1364 netdev_warn(dev->net, "Error reading PHY_MODE_CTRL_STS\n");
1368 ret |= MODE_CTRL_STS_EDPWRDOWN_;
1370 smsc95xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_MODE_CTRL_STS, ret);
1372 /* enter SUSPEND1 mode */
1373 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1375 netdev_warn(dev->net, "Error reading PM_CTRL\n");
1379 val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
1380 val |= PM_CTL_SUS_MODE_1;
1382 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1384 netdev_warn(dev->net, "Error writing PM_CTRL\n");
1388 /* clear wol status, enable energy detection */
1389 val &= ~PM_CTL_WUPS_;
1390 val |= (PM_CTL_WUPS_ED_ | PM_CTL_ED_EN_);
1392 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1394 netdev_warn(dev->net, "Error writing PM_CTRL\n");
1399 static int smsc95xx_enter_suspend2(struct usbnet *dev)
1404 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1406 netdev_warn(dev->net, "Error reading PM_CTRL\n");
1410 val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
1411 val |= PM_CTL_SUS_MODE_2;
1413 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1415 netdev_warn(dev->net, "Error writing PM_CTRL\n");
1420 static int smsc95xx_suspend(struct usb_interface *intf, pm_message_t message)
1422 struct usbnet *dev = usb_get_intfdata(intf);
1423 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1427 ret = usbnet_suspend(intf, message);
1429 netdev_warn(dev->net, "usbnet_suspend error\n");
1433 /* determine if link is up using only _nopm functions */
1434 link_up = smsc95xx_link_ok_nopm(dev);
1436 /* if no wol options set, or if link is down and we're not waking on
1437 * PHY activity, enter lowest power SUSPEND2 mode
1439 if (!(pdata->wolopts & SUPPORTED_WAKE) ||
1440 !(link_up || (pdata->wolopts & WAKE_PHY))) {
1441 netdev_info(dev->net, "entering SUSPEND2 mode\n");
1443 /* disable energy detect (link up) & wake up events */
1444 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1446 netdev_warn(dev->net, "Error reading WUCSR\n");
1450 val &= ~(WUCSR_MPEN_ | WUCSR_WAKE_EN_);
1452 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1454 netdev_warn(dev->net, "Error writing WUCSR\n");
1458 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1460 netdev_warn(dev->net, "Error reading PM_CTRL\n");
1464 val &= ~(PM_CTL_ED_EN_ | PM_CTL_WOL_EN_);
1466 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1468 netdev_warn(dev->net, "Error writing PM_CTRL\n");
1472 ret = smsc95xx_enter_suspend2(dev);
1476 if (pdata->wolopts & WAKE_PHY) {
1477 ret = smsc95xx_enable_phy_wakeup_interrupts(dev,
1478 (PHY_INT_MASK_ANEG_COMP_ | PHY_INT_MASK_LINK_DOWN_));
1480 netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
1484 /* if link is down then configure EDPD and enter SUSPEND1,
1485 * otherwise enter SUSPEND0 below
1488 netdev_info(dev->net, "entering SUSPEND1 mode\n");
1489 ret = smsc95xx_enter_suspend1(dev);
1494 if (pdata->wolopts & (WAKE_BCAST | WAKE_MCAST | WAKE_ARP | WAKE_UCAST)) {
1495 u32 *filter_mask = kzalloc(sizeof(u32) * 32, GFP_KERNEL);
1499 int wuff_filter_count =
1500 (pdata->features & FEATURE_8_WAKEUP_FILTERS) ?
1501 LAN9500A_WUFF_NUM : LAN9500_WUFF_NUM;
1505 netdev_warn(dev->net, "Unable to allocate filter_mask\n");
1510 memset(command, 0, sizeof(command));
1511 memset(offset, 0, sizeof(offset));
1512 memset(crc, 0, sizeof(crc));
1514 if (pdata->wolopts & WAKE_BCAST) {
1515 const u8 bcast[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
1516 netdev_info(dev->net, "enabling broadcast detection\n");
1517 filter_mask[filter * 4] = 0x003F;
1518 filter_mask[filter * 4 + 1] = 0x00;
1519 filter_mask[filter * 4 + 2] = 0x00;
1520 filter_mask[filter * 4 + 3] = 0x00;
1521 command[filter/4] |= 0x05UL << ((filter % 4) * 8);
1522 offset[filter/4] |= 0x00 << ((filter % 4) * 8);
1523 crc[filter/2] |= smsc_crc(bcast, 6, filter);
1527 if (pdata->wolopts & WAKE_MCAST) {
1528 const u8 mcast[] = {0x01, 0x00, 0x5E};
1529 netdev_info(dev->net, "enabling multicast detection\n");
1530 filter_mask[filter * 4] = 0x0007;
1531 filter_mask[filter * 4 + 1] = 0x00;
1532 filter_mask[filter * 4 + 2] = 0x00;
1533 filter_mask[filter * 4 + 3] = 0x00;
1534 command[filter/4] |= 0x09UL << ((filter % 4) * 8);
1535 offset[filter/4] |= 0x00 << ((filter % 4) * 8);
1536 crc[filter/2] |= smsc_crc(mcast, 3, filter);
1540 if (pdata->wolopts & WAKE_ARP) {
1541 const u8 arp[] = {0x08, 0x06};
1542 netdev_info(dev->net, "enabling ARP detection\n");
1543 filter_mask[filter * 4] = 0x0003;
1544 filter_mask[filter * 4 + 1] = 0x00;
1545 filter_mask[filter * 4 + 2] = 0x00;
1546 filter_mask[filter * 4 + 3] = 0x00;
1547 command[filter/4] |= 0x05UL << ((filter % 4) * 8);
1548 offset[filter/4] |= 0x0C << ((filter % 4) * 8);
1549 crc[filter/2] |= smsc_crc(arp, 2, filter);
1553 if (pdata->wolopts & WAKE_UCAST) {
1554 netdev_info(dev->net, "enabling unicast detection\n");
1555 filter_mask[filter * 4] = 0x003F;
1556 filter_mask[filter * 4 + 1] = 0x00;
1557 filter_mask[filter * 4 + 2] = 0x00;
1558 filter_mask[filter * 4 + 3] = 0x00;
1559 command[filter/4] |= 0x01UL << ((filter % 4) * 8);
1560 offset[filter/4] |= 0x00 << ((filter % 4) * 8);
1561 crc[filter/2] |= smsc_crc(dev->net->dev_addr, ETH_ALEN, filter);
1565 for (i = 0; i < (wuff_filter_count * 4); i++) {
1566 ret = smsc95xx_write_reg_nopm(dev, WUFF, filter_mask[i]);
1568 netdev_warn(dev->net, "Error writing WUFF\n");
1575 for (i = 0; i < (wuff_filter_count / 4); i++) {
1576 ret = smsc95xx_write_reg_nopm(dev, WUFF, command[i]);
1578 netdev_warn(dev->net, "Error writing WUFF\n");
1583 for (i = 0; i < (wuff_filter_count / 4); i++) {
1584 ret = smsc95xx_write_reg_nopm(dev, WUFF, offset[i]);
1586 netdev_warn(dev->net, "Error writing WUFF\n");
1591 for (i = 0; i < (wuff_filter_count / 2); i++) {
1592 ret = smsc95xx_write_reg_nopm(dev, WUFF, crc[i]);
1594 netdev_warn(dev->net, "Error writing WUFF\n");
1599 /* clear any pending pattern match packet status */
1600 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1602 netdev_warn(dev->net, "Error reading WUCSR\n");
1608 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1610 netdev_warn(dev->net, "Error writing WUCSR\n");
1615 if (pdata->wolopts & WAKE_MAGIC) {
1616 /* clear any pending magic packet status */
1617 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1619 netdev_warn(dev->net, "Error reading WUCSR\n");
1625 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1627 netdev_warn(dev->net, "Error writing WUCSR\n");
1632 /* enable/disable wakeup sources */
1633 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1635 netdev_warn(dev->net, "Error reading WUCSR\n");
1639 if (pdata->wolopts & (WAKE_BCAST | WAKE_MCAST | WAKE_ARP | WAKE_UCAST)) {
1640 netdev_info(dev->net, "enabling pattern match wakeup\n");
1641 val |= WUCSR_WAKE_EN_;
1643 netdev_info(dev->net, "disabling pattern match wakeup\n");
1644 val &= ~WUCSR_WAKE_EN_;
1647 if (pdata->wolopts & WAKE_MAGIC) {
1648 netdev_info(dev->net, "enabling magic packet wakeup\n");
1651 netdev_info(dev->net, "disabling magic packet wakeup\n");
1652 val &= ~WUCSR_MPEN_;
1655 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1657 netdev_warn(dev->net, "Error writing WUCSR\n");
1661 /* enable wol wakeup source */
1662 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1664 netdev_warn(dev->net, "Error reading PM_CTRL\n");
1668 val |= PM_CTL_WOL_EN_;
1670 /* phy energy detect wakeup source */
1671 if (pdata->wolopts & WAKE_PHY)
1672 val |= PM_CTL_ED_EN_;
1674 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1676 netdev_warn(dev->net, "Error writing PM_CTRL\n");
1680 /* enable receiver to enable frame reception */
1681 smsc95xx_start_rx_path(dev, 1);
1683 /* some wol options are enabled, so enter SUSPEND0 */
1684 netdev_info(dev->net, "entering SUSPEND0 mode\n");
1685 ret = smsc95xx_enter_suspend0(dev);
1689 usbnet_resume(intf);
1693 static int smsc95xx_resume(struct usb_interface *intf)
1695 struct usbnet *dev = usb_get_intfdata(intf);
1696 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1702 if (pdata->wolopts) {
1703 /* clear wake-up sources */
1704 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1706 netdev_warn(dev->net, "Error reading WUCSR\n");
1710 val &= ~(WUCSR_WAKE_EN_ | WUCSR_MPEN_);
1712 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1714 netdev_warn(dev->net, "Error writing WUCSR\n");
1718 /* clear wake-up status */
1719 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1721 netdev_warn(dev->net, "Error reading PM_CTRL\n");
1725 val &= ~PM_CTL_WOL_EN_;
1726 val |= PM_CTL_WUPS_;
1728 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1730 netdev_warn(dev->net, "Error writing PM_CTRL\n");
1735 ret = usbnet_resume(intf);
1737 netdev_warn(dev->net, "usbnet_resume error\n");
1742 static void smsc95xx_rx_csum_offload(struct sk_buff *skb)
1744 skb->csum = *(u16 *)(skb_tail_pointer(skb) - 2);
1745 skb->ip_summed = CHECKSUM_COMPLETE;
1746 skb_trim(skb, skb->len - 2);
1749 static int smsc95xx_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
1751 while (skb->len > 0) {
1752 u32 header, align_count;
1753 struct sk_buff *ax_skb;
1754 unsigned char *packet;
1757 memcpy(&header, skb->data, sizeof(header));
1758 le32_to_cpus(&header);
1759 skb_pull(skb, 4 + NET_IP_ALIGN);
1762 /* get the packet length */
1763 size = (u16)((header & RX_STS_FL_) >> 16);
1764 align_count = (4 - ((size + NET_IP_ALIGN) % 4)) % 4;
1766 if (unlikely(header & RX_STS_ES_)) {
1767 netif_dbg(dev, rx_err, dev->net,
1768 "Error header=0x%08x\n", header);
1769 dev->net->stats.rx_errors++;
1770 dev->net->stats.rx_dropped++;
1772 if (header & RX_STS_CRC_) {
1773 dev->net->stats.rx_crc_errors++;
1775 if (header & (RX_STS_TL_ | RX_STS_RF_))
1776 dev->net->stats.rx_frame_errors++;
1778 if ((header & RX_STS_LE_) &&
1779 (!(header & RX_STS_FT_)))
1780 dev->net->stats.rx_length_errors++;
1783 /* ETH_FRAME_LEN + 4(CRC) + 2(COE) + 4(Vlan) */
1784 if (unlikely(size > (ETH_FRAME_LEN + 12))) {
1785 netif_dbg(dev, rx_err, dev->net,
1786 "size err header=0x%08x\n", header);
1790 /* last frame in this batch */
1791 if (skb->len == size) {
1792 if (dev->net->features & NETIF_F_RXCSUM)
1793 smsc95xx_rx_csum_offload(skb);
1794 skb_trim(skb, skb->len - 4); /* remove fcs */
1795 skb->truesize = size + sizeof(struct sk_buff);
1800 ax_skb = skb_clone(skb, GFP_ATOMIC);
1801 if (unlikely(!ax_skb)) {
1802 netdev_warn(dev->net, "Error allocating skb\n");
1807 ax_skb->data = packet;
1808 skb_set_tail_pointer(ax_skb, size);
1810 if (dev->net->features & NETIF_F_RXCSUM)
1811 smsc95xx_rx_csum_offload(ax_skb);
1812 skb_trim(ax_skb, ax_skb->len - 4); /* remove fcs */
1813 ax_skb->truesize = size + sizeof(struct sk_buff);
1815 usbnet_skb_return(dev, ax_skb);
1818 skb_pull(skb, size);
1820 /* padding bytes before the next frame starts */
1822 skb_pull(skb, align_count);
1825 if (unlikely(skb->len < 0)) {
1826 netdev_warn(dev->net, "invalid rx length<0 %d\n", skb->len);
1833 static u32 smsc95xx_calc_csum_preamble(struct sk_buff *skb)
1835 u16 low_16 = (u16)skb_checksum_start_offset(skb);
1836 u16 high_16 = low_16 + skb->csum_offset;
1837 return (high_16 << 16) | low_16;
1840 static struct sk_buff *smsc95xx_tx_fixup(struct usbnet *dev,
1841 struct sk_buff *skb, gfp_t flags)
1843 bool csum = skb->ip_summed == CHECKSUM_PARTIAL;
1844 int overhead = csum ? SMSC95XX_TX_OVERHEAD_CSUM : SMSC95XX_TX_OVERHEAD;
1845 u32 tx_cmd_a, tx_cmd_b;
1847 /* We do not advertise SG, so skbs should be already linearized */
1848 BUG_ON(skb_shinfo(skb)->nr_frags);
1850 if (skb_headroom(skb) < overhead) {
1851 struct sk_buff *skb2 = skb_copy_expand(skb,
1852 overhead, 0, flags);
1853 dev_kfree_skb_any(skb);
1860 if (skb->len <= 45) {
1861 /* workaround - hardware tx checksum does not work
1862 * properly with extremely small packets */
1863 long csstart = skb_checksum_start_offset(skb);
1864 __wsum calc = csum_partial(skb->data + csstart,
1865 skb->len - csstart, 0);
1866 *((__sum16 *)(skb->data + csstart
1867 + skb->csum_offset)) = csum_fold(calc);
1871 u32 csum_preamble = smsc95xx_calc_csum_preamble(skb);
1873 cpu_to_le32s(&csum_preamble);
1874 memcpy(skb->data, &csum_preamble, 4);
1879 tx_cmd_b = (u32)(skb->len - 4);
1881 tx_cmd_b |= TX_CMD_B_CSUM_ENABLE;
1882 cpu_to_le32s(&tx_cmd_b);
1883 memcpy(skb->data, &tx_cmd_b, 4);
1886 tx_cmd_a = (u32)(skb->len - 8) | TX_CMD_A_FIRST_SEG_ |
1888 cpu_to_le32s(&tx_cmd_a);
1889 memcpy(skb->data, &tx_cmd_a, 4);
1894 static const struct driver_info smsc95xx_info = {
1895 .description = "smsc95xx USB 2.0 Ethernet",
1896 .bind = smsc95xx_bind,
1897 .unbind = smsc95xx_unbind,
1898 .link_reset = smsc95xx_link_reset,
1899 .reset = smsc95xx_reset,
1900 .rx_fixup = smsc95xx_rx_fixup,
1901 .tx_fixup = smsc95xx_tx_fixup,
1902 .status = smsc95xx_status,
1903 .flags = FLAG_ETHER | FLAG_SEND_ZLP | FLAG_LINK_INTR,
1906 static const struct usb_device_id products[] = {
1908 /* SMSC9500 USB Ethernet Device */
1909 USB_DEVICE(0x0424, 0x9500),
1910 .driver_info = (unsigned long) &smsc95xx_info,
1913 /* SMSC9505 USB Ethernet Device */
1914 USB_DEVICE(0x0424, 0x9505),
1915 .driver_info = (unsigned long) &smsc95xx_info,
1918 /* SMSC9500A USB Ethernet Device */
1919 USB_DEVICE(0x0424, 0x9E00),
1920 .driver_info = (unsigned long) &smsc95xx_info,
1923 /* SMSC9505A USB Ethernet Device */
1924 USB_DEVICE(0x0424, 0x9E01),
1925 .driver_info = (unsigned long) &smsc95xx_info,
1928 /* SMSC9512/9514 USB Hub & Ethernet Device */
1929 USB_DEVICE(0x0424, 0xec00),
1930 .driver_info = (unsigned long) &smsc95xx_info,
1933 /* SMSC9500 USB Ethernet Device (SAL10) */
1934 USB_DEVICE(0x0424, 0x9900),
1935 .driver_info = (unsigned long) &smsc95xx_info,
1938 /* SMSC9505 USB Ethernet Device (SAL10) */
1939 USB_DEVICE(0x0424, 0x9901),
1940 .driver_info = (unsigned long) &smsc95xx_info,
1943 /* SMSC9500A USB Ethernet Device (SAL10) */
1944 USB_DEVICE(0x0424, 0x9902),
1945 .driver_info = (unsigned long) &smsc95xx_info,
1948 /* SMSC9505A USB Ethernet Device (SAL10) */
1949 USB_DEVICE(0x0424, 0x9903),
1950 .driver_info = (unsigned long) &smsc95xx_info,
1953 /* SMSC9512/9514 USB Hub & Ethernet Device (SAL10) */
1954 USB_DEVICE(0x0424, 0x9904),
1955 .driver_info = (unsigned long) &smsc95xx_info,
1958 /* SMSC9500A USB Ethernet Device (HAL) */
1959 USB_DEVICE(0x0424, 0x9905),
1960 .driver_info = (unsigned long) &smsc95xx_info,
1963 /* SMSC9505A USB Ethernet Device (HAL) */
1964 USB_DEVICE(0x0424, 0x9906),
1965 .driver_info = (unsigned long) &smsc95xx_info,
1968 /* SMSC9500 USB Ethernet Device (Alternate ID) */
1969 USB_DEVICE(0x0424, 0x9907),
1970 .driver_info = (unsigned long) &smsc95xx_info,
1973 /* SMSC9500A USB Ethernet Device (Alternate ID) */
1974 USB_DEVICE(0x0424, 0x9908),
1975 .driver_info = (unsigned long) &smsc95xx_info,
1978 /* SMSC9512/9514 USB Hub & Ethernet Device (Alternate ID) */
1979 USB_DEVICE(0x0424, 0x9909),
1980 .driver_info = (unsigned long) &smsc95xx_info,
1983 /* SMSC LAN9530 USB Ethernet Device */
1984 USB_DEVICE(0x0424, 0x9530),
1985 .driver_info = (unsigned long) &smsc95xx_info,
1988 /* SMSC LAN9730 USB Ethernet Device */
1989 USB_DEVICE(0x0424, 0x9730),
1990 .driver_info = (unsigned long) &smsc95xx_info,
1993 /* SMSC LAN89530 USB Ethernet Device */
1994 USB_DEVICE(0x0424, 0x9E08),
1995 .driver_info = (unsigned long) &smsc95xx_info,
1999 MODULE_DEVICE_TABLE(usb, products);
2001 static struct usb_driver smsc95xx_driver = {
2003 .id_table = products,
2004 .probe = usbnet_probe,
2005 .suspend = smsc95xx_suspend,
2006 .resume = smsc95xx_resume,
2007 .reset_resume = smsc95xx_resume,
2008 .disconnect = usbnet_disconnect,
2009 .disable_hub_initiated_lpm = 1,
2012 module_usb_driver(smsc95xx_driver);
2014 MODULE_AUTHOR("Nancy Lin");
2015 MODULE_AUTHOR("Steve Glendinning <steve.glendinning@shawell.net>");
2016 MODULE_DESCRIPTION("SMSC95XX USB 2.0 Ethernet Devices");
2017 MODULE_LICENSE("GPL");