smsc95xx.c (de65d816aa44f9ddd79861ae21d75010cc1fd003) smsc95xx.c (38673c8218a6bcaac97b0243089e33617e28f43f)
1 /***************************************************************************
2 *
3 * Copyright (C) 2007-2008 SMSC
4 *
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.

--- 41 unchanged lines hidden (view full) ---

50#define SMSC95XX_TX_OVERHEAD_CSUM (12)
51#define SUPPORTED_WAKE (WAKE_PHY | WAKE_UCAST | WAKE_BCAST | \
52 WAKE_MCAST | WAKE_ARP | WAKE_MAGIC)
53
54#define FEATURE_8_WAKEUP_FILTERS (0x01)
55#define FEATURE_PHY_NLP_CROSSOVER (0x02)
56#define FEATURE_AUTOSUSPEND (0x04)
57
1 /***************************************************************************
2 *
3 * Copyright (C) 2007-2008 SMSC
4 *
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.

--- 41 unchanged lines hidden (view full) ---

50#define SMSC95XX_TX_OVERHEAD_CSUM (12)
51#define SUPPORTED_WAKE (WAKE_PHY | WAKE_UCAST | WAKE_BCAST | \
52 WAKE_MCAST | WAKE_ARP | WAKE_MAGIC)
53
54#define FEATURE_8_WAKEUP_FILTERS (0x01)
55#define FEATURE_PHY_NLP_CROSSOVER (0x02)
56#define FEATURE_AUTOSUSPEND (0x04)
57
58#define SUSPEND_SUSPEND0 (0x01)
59#define SUSPEND_SUSPEND1 (0x02)
60#define SUSPEND_SUSPEND2 (0x04)
61#define SUSPEND_SUSPEND3 (0x08)
62#define SUSPEND_ALLMODES (SUSPEND_SUSPEND0 | SUSPEND_SUSPEND1 | \
63 SUSPEND_SUSPEND2 | SUSPEND_SUSPEND3)
64
58struct smsc95xx_priv {
59 u32 mac_cr;
60 u32 hash_hi;
61 u32 hash_lo;
62 u32 wolopts;
63 spinlock_t mac_cr_lock;
64 u8 features;
65struct smsc95xx_priv {
66 u32 mac_cr;
67 u32 hash_hi;
68 u32 hash_lo;
69 u32 wolopts;
70 spinlock_t mac_cr_lock;
71 u8 features;
72 u8 suspend_flags;
65};
66
67static bool turbo_mode = true;
68module_param(turbo_mode, bool, 0644);
69MODULE_PARM_DESC(turbo_mode, "Enable multiple frames per Rx transaction");
70
71static int __must_check __smsc95xx_read_reg(struct usbnet *dev, u32 index,
72 u32 *data, int in_pm)

--- 435 unchanged lines hidden (view full) ---

508}
509
510static int smsc95xx_phy_update_flowcontrol(struct usbnet *dev, u8 duplex,
511 u16 lcladv, u16 rmtadv)
512{
513 u32 flow, afc_cfg = 0;
514
515 int ret = smsc95xx_read_reg(dev, AFC_CFG, &afc_cfg);
73};
74
75static bool turbo_mode = true;
76module_param(turbo_mode, bool, 0644);
77MODULE_PARM_DESC(turbo_mode, "Enable multiple frames per Rx transaction");
78
79static int __must_check __smsc95xx_read_reg(struct usbnet *dev, u32 index,
80 u32 *data, int in_pm)

--- 435 unchanged lines hidden (view full) ---

516}
517
518static int smsc95xx_phy_update_flowcontrol(struct usbnet *dev, u8 duplex,
519 u16 lcladv, u16 rmtadv)
520{
521 u32 flow, afc_cfg = 0;
522
523 int ret = smsc95xx_read_reg(dev, AFC_CFG, &afc_cfg);
516 if (ret < 0) {
517 netdev_warn(dev->net, "Error reading AFC_CFG\n");
524 if (ret < 0)
518 return ret;
525 return ret;
519 }
520
521 if (duplex == DUPLEX_FULL) {
522 u8 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
523
524 if (cap & FLOW_CTRL_RX)
525 flow = 0xFFFF0002;
526 else
527 flow = 0;

--- 8 unchanged lines hidden (view full) ---

536 cap & FLOW_CTRL_TX ? "enabled" : "disabled");
537 } else {
538 netif_dbg(dev, link, dev->net, "half duplex\n");
539 flow = 0;
540 afc_cfg |= 0xF;
541 }
542
543 ret = smsc95xx_write_reg(dev, FLOW, flow);
526
527 if (duplex == DUPLEX_FULL) {
528 u8 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
529
530 if (cap & FLOW_CTRL_RX)
531 flow = 0xFFFF0002;
532 else
533 flow = 0;

--- 8 unchanged lines hidden (view full) ---

542 cap & FLOW_CTRL_TX ? "enabled" : "disabled");
543 } else {
544 netif_dbg(dev, link, dev->net, "half duplex\n");
545 flow = 0;
546 afc_cfg |= 0xF;
547 }
548
549 ret = smsc95xx_write_reg(dev, FLOW, flow);
544 if (ret < 0) {
545 netdev_warn(dev->net, "Error writing FLOW\n");
550 if (ret < 0)
546 return ret;
551 return ret;
547 }
548
552
549 ret = smsc95xx_write_reg(dev, AFC_CFG, afc_cfg);
550 if (ret < 0)
551 netdev_warn(dev->net, "Error writing AFC_CFG\n");
552
553 return ret;
553 return smsc95xx_write_reg(dev, AFC_CFG, afc_cfg);
554}
555
556static int smsc95xx_link_reset(struct usbnet *dev)
557{
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 };
561 unsigned long flags;
562 u16 lcladv, rmtadv;
563 int ret;
564
565 /* clear interrupt status */
566 ret = smsc95xx_mdio_read(dev->net, mii->phy_id, PHY_INT_SRC);
554}
555
556static int smsc95xx_link_reset(struct usbnet *dev)
557{
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 };
561 unsigned long flags;
562 u16 lcladv, rmtadv;
563 int ret;
564
565 /* clear interrupt status */
566 ret = smsc95xx_mdio_read(dev->net, mii->phy_id, PHY_INT_SRC);
567 if (ret < 0) {
568 netdev_warn(dev->net, "Error reading PHY_INT_SRC\n");
567 if (ret < 0)
569 return ret;
568 return ret;
570 }
571
572 ret = smsc95xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
569
570 ret = smsc95xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
573 if (ret < 0) {
574 netdev_warn(dev->net, "Error writing INT_STS\n");
571 if (ret < 0)
575 return ret;
572 return ret;
576 }
577
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);
582
583 netif_dbg(dev, link, dev->net,
584 "speed: %u duplex: %d lcladv: %04x rmtadv: %04x\n",

--- 5 unchanged lines hidden (view full) ---

590 pdata->mac_cr |= MAC_CR_RCVOWN_;
591 } else {
592 pdata->mac_cr &= ~MAC_CR_RCVOWN_;
593 pdata->mac_cr |= MAC_CR_FDPX_;
594 }
595 spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);
596
597 ret = smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr);
573
574 mii_check_media(mii, 1, 1);
575 mii_ethtool_gset(&dev->mii, &ecmd);
576 lcladv = smsc95xx_mdio_read(dev->net, mii->phy_id, MII_ADVERTISE);
577 rmtadv = smsc95xx_mdio_read(dev->net, mii->phy_id, MII_LPA);
578
579 netif_dbg(dev, link, dev->net,
580 "speed: %u duplex: %d lcladv: %04x rmtadv: %04x\n",

--- 5 unchanged lines hidden (view full) ---

586 pdata->mac_cr |= MAC_CR_RCVOWN_;
587 } else {
588 pdata->mac_cr &= ~MAC_CR_RCVOWN_;
589 pdata->mac_cr |= MAC_CR_FDPX_;
590 }
591 spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);
592
593 ret = smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr);
598 if (ret < 0) {
599 netdev_warn(dev->net, "Error writing MAC_CR\n");
594 if (ret < 0)
600 return ret;
595 return ret;
601 }
602
603 ret = smsc95xx_phy_update_flowcontrol(dev, ecmd.duplex, lcladv, rmtadv);
604 if (ret < 0)
605 netdev_warn(dev->net, "Error updating PHY flow control\n");
606
607 return ret;
608}
609

--- 23 unchanged lines hidden (view full) ---

633static int smsc95xx_set_features(struct net_device *netdev,
634 netdev_features_t features)
635{
636 struct usbnet *dev = netdev_priv(netdev);
637 u32 read_buf;
638 int ret;
639
640 ret = smsc95xx_read_reg(dev, COE_CR, &read_buf);
596
597 ret = smsc95xx_phy_update_flowcontrol(dev, ecmd.duplex, lcladv, rmtadv);
598 if (ret < 0)
599 netdev_warn(dev->net, "Error updating PHY flow control\n");
600
601 return ret;
602}
603

--- 23 unchanged lines hidden (view full) ---

627static int smsc95xx_set_features(struct net_device *netdev,
628 netdev_features_t features)
629{
630 struct usbnet *dev = netdev_priv(netdev);
631 u32 read_buf;
632 int ret;
633
634 ret = smsc95xx_read_reg(dev, COE_CR, &read_buf);
641 if (ret < 0) {
642 netdev_warn(dev->net, "Failed to read COE_CR: %d\n", ret);
635 if (ret < 0)
643 return ret;
636 return ret;
644 }
645
646 if (features & NETIF_F_HW_CSUM)
647 read_buf |= Tx_COE_EN_;
648 else
649 read_buf &= ~Tx_COE_EN_;
650
651 if (features & NETIF_F_RXCSUM)
652 read_buf |= Rx_COE_EN_;
653 else
654 read_buf &= ~Rx_COE_EN_;
655
656 ret = smsc95xx_write_reg(dev, COE_CR, read_buf);
637
638 if (features & NETIF_F_HW_CSUM)
639 read_buf |= Tx_COE_EN_;
640 else
641 read_buf &= ~Tx_COE_EN_;
642
643 if (features & NETIF_F_RXCSUM)
644 read_buf |= Rx_COE_EN_;
645 else
646 read_buf &= ~Rx_COE_EN_;
647
648 ret = smsc95xx_write_reg(dev, COE_CR, read_buf);
657 if (ret < 0) {
658 netdev_warn(dev->net, "Failed to write COE_CR: %d\n", ret);
649 if (ret < 0)
659 return ret;
650 return ret;
660 }
661
662 netif_dbg(dev, hw, dev->net, "COE_CR = 0x%08x\n", read_buf);
663 return 0;
664}
665
666static int smsc95xx_ethtool_get_eeprom_len(struct net_device *net)
667{
668 return MAX_EEPROM_SIZE;

--- 126 unchanged lines hidden (view full) ---

795static int smsc95xx_set_mac_address(struct usbnet *dev)
796{
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;
800 int ret;
801
802 ret = smsc95xx_write_reg(dev, ADDRL, addr_lo);
651
652 netif_dbg(dev, hw, dev->net, "COE_CR = 0x%08x\n", read_buf);
653 return 0;
654}
655
656static int smsc95xx_ethtool_get_eeprom_len(struct net_device *net)
657{
658 return MAX_EEPROM_SIZE;

--- 126 unchanged lines hidden (view full) ---

785static int smsc95xx_set_mac_address(struct usbnet *dev)
786{
787 u32 addr_lo = dev->net->dev_addr[0] | dev->net->dev_addr[1] << 8 |
788 dev->net->dev_addr[2] << 16 | dev->net->dev_addr[3] << 24;
789 u32 addr_hi = dev->net->dev_addr[4] | dev->net->dev_addr[5] << 8;
790 int ret;
791
792 ret = smsc95xx_write_reg(dev, ADDRL, addr_lo);
803 if (ret < 0) {
804 netdev_warn(dev->net, "Failed to write ADDRL: %d\n", ret);
793 if (ret < 0)
805 return ret;
794 return ret;
806 }
807
795
808 ret = smsc95xx_write_reg(dev, ADDRH, addr_hi);
809 if (ret < 0)
810 netdev_warn(dev->net, "Failed to write ADDRH: %d\n", ret);
811
812 return ret;
796 return smsc95xx_write_reg(dev, ADDRH, addr_hi);
813}
814
815/* starts the TX path */
816static int smsc95xx_start_tx_path(struct usbnet *dev)
817{
818 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
819 unsigned long flags;
820 int ret;
821
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);
826
827 ret = smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr);
797}
798
799/* starts the TX path */
800static int smsc95xx_start_tx_path(struct usbnet *dev)
801{
802 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
803 unsigned long flags;
804 int ret;
805
806 /* Enable Tx at MAC */
807 spin_lock_irqsave(&pdata->mac_cr_lock, flags);
808 pdata->mac_cr |= MAC_CR_TXEN_;
809 spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);
810
811 ret = smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr);
828 if (ret < 0) {
829 netdev_warn(dev->net, "Failed to write MAC_CR: %d\n", ret);
812 if (ret < 0)
830 return ret;
813 return ret;
831 }
832
833 /* Enable Tx at SCSRs */
814
815 /* Enable Tx at SCSRs */
834 ret = smsc95xx_write_reg(dev, TX_CFG, TX_CFG_ON_);
835 if (ret < 0)
836 netdev_warn(dev->net, "Failed to write TX_CFG: %d\n", ret);
837
838 return ret;
816 return smsc95xx_write_reg(dev, TX_CFG, TX_CFG_ON_);
839}
840
841/* Starts the Receive path */
842static int smsc95xx_start_rx_path(struct usbnet *dev, int in_pm)
843{
844 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
845 unsigned long flags;
817}
818
819/* Starts the Receive path */
820static int smsc95xx_start_rx_path(struct usbnet *dev, int in_pm)
821{
822 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
823 unsigned long flags;
846 int ret;
847
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);
851
824
825 spin_lock_irqsave(&pdata->mac_cr_lock, flags);
826 pdata->mac_cr |= MAC_CR_RXEN_;
827 spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);
828
852 ret = __smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr, in_pm);
853 if (ret < 0)
854 netdev_warn(dev->net, "Failed to write MAC_CR: %d\n", ret);
855
856 return ret;
829 return __smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr, in_pm);
857}
858
859static int smsc95xx_phy_initialize(struct usbnet *dev)
860{
861 int bmcr, ret, timeout = 0;
862
863 /* Initialize MII structure */
864 dev->mii.dev = dev->net;

--- 40 unchanged lines hidden (view full) ---

905{
906 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
907 u32 read_buf, write_buf, burst_cap;
908 int ret = 0, timeout;
909
910 netif_dbg(dev, ifup, dev->net, "entering smsc95xx_reset\n");
911
912 ret = smsc95xx_write_reg(dev, HW_CFG, HW_CFG_LRST_);
830}
831
832static int smsc95xx_phy_initialize(struct usbnet *dev)
833{
834 int bmcr, ret, timeout = 0;
835
836 /* Initialize MII structure */
837 dev->mii.dev = dev->net;

--- 40 unchanged lines hidden (view full) ---

878{
879 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
880 u32 read_buf, write_buf, burst_cap;
881 int ret = 0, timeout;
882
883 netif_dbg(dev, ifup, dev->net, "entering smsc95xx_reset\n");
884
885 ret = smsc95xx_write_reg(dev, HW_CFG, HW_CFG_LRST_);
913 if (ret < 0) {
914 netdev_warn(dev->net, "Failed to write HW_CFG_LRST_ bit in HW_CFG\n");
886 if (ret < 0)
915 return ret;
887 return ret;
916 }
917
918 timeout = 0;
919 do {
920 msleep(10);
921 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
888
889 timeout = 0;
890 do {
891 msleep(10);
892 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
922 if (ret < 0) {
923 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
893 if (ret < 0)
924 return ret;
894 return ret;
925 }
926 timeout++;
927 } while ((read_buf & HW_CFG_LRST_) && (timeout < 100));
928
929 if (timeout >= 100) {
930 netdev_warn(dev->net, "timeout waiting for completion of Lite Reset\n");
931 return ret;
932 }
933
934 ret = smsc95xx_write_reg(dev, PM_CTRL, PM_CTL_PHY_RST_);
895 timeout++;
896 } while ((read_buf & HW_CFG_LRST_) && (timeout < 100));
897
898 if (timeout >= 100) {
899 netdev_warn(dev->net, "timeout waiting for completion of Lite Reset\n");
900 return ret;
901 }
902
903 ret = smsc95xx_write_reg(dev, PM_CTRL, PM_CTL_PHY_RST_);
935 if (ret < 0) {
936 netdev_warn(dev->net, "Failed to write PM_CTRL: %d\n", ret);
904 if (ret < 0)
937 return ret;
905 return ret;
938 }
939
940 timeout = 0;
941 do {
942 msleep(10);
943 ret = smsc95xx_read_reg(dev, PM_CTRL, &read_buf);
906
907 timeout = 0;
908 do {
909 msleep(10);
910 ret = smsc95xx_read_reg(dev, PM_CTRL, &read_buf);
944 if (ret < 0) {
945 netdev_warn(dev->net, "Failed to read PM_CTRL: %d\n", ret);
911 if (ret < 0)
946 return ret;
912 return ret;
947 }
948 timeout++;
949 } while ((read_buf & PM_CTL_PHY_RST_) && (timeout < 100));
950
951 if (timeout >= 100) {
952 netdev_warn(dev->net, "timeout waiting for PHY Reset\n");
953 return ret;
954 }
955
956 ret = smsc95xx_set_mac_address(dev);
957 if (ret < 0)
958 return ret;
959
960 netif_dbg(dev, ifup, dev->net, "MAC Address: %pM\n",
961 dev->net->dev_addr);
962
963 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
913 timeout++;
914 } while ((read_buf & PM_CTL_PHY_RST_) && (timeout < 100));
915
916 if (timeout >= 100) {
917 netdev_warn(dev->net, "timeout waiting for PHY Reset\n");
918 return ret;
919 }
920
921 ret = smsc95xx_set_mac_address(dev);
922 if (ret < 0)
923 return ret;
924
925 netif_dbg(dev, ifup, dev->net, "MAC Address: %pM\n",
926 dev->net->dev_addr);
927
928 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
964 if (ret < 0) {
965 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
929 if (ret < 0)
966 return ret;
930 return ret;
967 }
968
969 netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG : 0x%08x\n",
970 read_buf);
971
972 read_buf |= HW_CFG_BIR_;
973
974 ret = smsc95xx_write_reg(dev, HW_CFG, read_buf);
931
932 netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG : 0x%08x\n",
933 read_buf);
934
935 read_buf |= HW_CFG_BIR_;
936
937 ret = smsc95xx_write_reg(dev, HW_CFG, read_buf);
975 if (ret < 0) {
976 netdev_warn(dev->net, "Failed to write HW_CFG_BIR_ bit in HW_CFG\n");
938 if (ret < 0)
977 return ret;
939 return ret;
978 }
979
980 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
940
941 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
981 if (ret < 0) {
982 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
942 if (ret < 0)
983 return ret;
943 return ret;
984 }
985
986 netif_dbg(dev, ifup, dev->net,
987 "Read Value from HW_CFG after writing HW_CFG_BIR_: 0x%08x\n",
988 read_buf);
989
990 if (!turbo_mode) {
991 burst_cap = 0;
992 dev->rx_urb_size = MAX_SINGLE_PACKET_SIZE;

--- 4 unchanged lines hidden (view full) ---

997 burst_cap = DEFAULT_FS_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
998 dev->rx_urb_size = DEFAULT_FS_BURST_CAP_SIZE;
999 }
1000
1001 netif_dbg(dev, ifup, dev->net, "rx_urb_size=%ld\n",
1002 (ulong)dev->rx_urb_size);
1003
1004 ret = smsc95xx_write_reg(dev, BURST_CAP, burst_cap);
944
945 netif_dbg(dev, ifup, dev->net,
946 "Read Value from HW_CFG after writing HW_CFG_BIR_: 0x%08x\n",
947 read_buf);
948
949 if (!turbo_mode) {
950 burst_cap = 0;
951 dev->rx_urb_size = MAX_SINGLE_PACKET_SIZE;

--- 4 unchanged lines hidden (view full) ---

956 burst_cap = DEFAULT_FS_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
957 dev->rx_urb_size = DEFAULT_FS_BURST_CAP_SIZE;
958 }
959
960 netif_dbg(dev, ifup, dev->net, "rx_urb_size=%ld\n",
961 (ulong)dev->rx_urb_size);
962
963 ret = smsc95xx_write_reg(dev, BURST_CAP, burst_cap);
1005 if (ret < 0) {
1006 netdev_warn(dev->net, "Failed to write BURST_CAP: %d\n", ret);
964 if (ret < 0)
1007 return ret;
965 return ret;
1008 }
1009
1010 ret = smsc95xx_read_reg(dev, BURST_CAP, &read_buf);
966
967 ret = smsc95xx_read_reg(dev, BURST_CAP, &read_buf);
1011 if (ret < 0) {
1012 netdev_warn(dev->net, "Failed to read BURST_CAP: %d\n", ret);
968 if (ret < 0)
1013 return ret;
969 return ret;
1014 }
1015
1016 netif_dbg(dev, ifup, dev->net,
1017 "Read Value from BURST_CAP after writing: 0x%08x\n",
1018 read_buf);
1019
1020 ret = smsc95xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
970
971 netif_dbg(dev, ifup, dev->net,
972 "Read Value from BURST_CAP after writing: 0x%08x\n",
973 read_buf);
974
975 ret = smsc95xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
1021 if (ret < 0) {
1022 netdev_warn(dev->net, "Failed to write BULK_IN_DLY: %d\n", ret);
976 if (ret < 0)
1023 return ret;
977 return ret;
1024 }
1025
1026 ret = smsc95xx_read_reg(dev, BULK_IN_DLY, &read_buf);
978
979 ret = smsc95xx_read_reg(dev, BULK_IN_DLY, &read_buf);
1027 if (ret < 0) {
1028 netdev_warn(dev->net, "Failed to read BULK_IN_DLY: %d\n", ret);
980 if (ret < 0)
1029 return ret;
981 return ret;
1030 }
1031
1032 netif_dbg(dev, ifup, dev->net,
1033 "Read Value from BULK_IN_DLY after writing: 0x%08x\n",
1034 read_buf);
1035
1036 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
982
983 netif_dbg(dev, ifup, dev->net,
984 "Read Value from BULK_IN_DLY after writing: 0x%08x\n",
985 read_buf);
986
987 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
1037 if (ret < 0) {
1038 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
988 if (ret < 0)
1039 return ret;
989 return ret;
1040 }
1041
1042 netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG: 0x%08x\n",
1043 read_buf);
1044
1045 if (turbo_mode)
1046 read_buf |= (HW_CFG_MEF_ | HW_CFG_BCE_);
1047
1048 read_buf &= ~HW_CFG_RXDOFF_;
1049
1050 /* set Rx data offset=2, Make IP header aligns on word boundary. */
1051 read_buf |= NET_IP_ALIGN << 9;
1052
1053 ret = smsc95xx_write_reg(dev, HW_CFG, read_buf);
990
991 netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG: 0x%08x\n",
992 read_buf);
993
994 if (turbo_mode)
995 read_buf |= (HW_CFG_MEF_ | HW_CFG_BCE_);
996
997 read_buf &= ~HW_CFG_RXDOFF_;
998
999 /* set Rx data offset=2, Make IP header aligns on word boundary. */
1000 read_buf |= NET_IP_ALIGN << 9;
1001
1002 ret = smsc95xx_write_reg(dev, HW_CFG, read_buf);
1054 if (ret < 0) {
1055 netdev_warn(dev->net, "Failed to write HW_CFG: %d\n", ret);
1003 if (ret < 0)
1056 return ret;
1004 return ret;
1057 }
1058
1059 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
1005
1006 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
1060 if (ret < 0) {
1061 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
1007 if (ret < 0)
1062 return ret;
1008 return ret;
1063 }
1064
1065 netif_dbg(dev, ifup, dev->net,
1066 "Read Value from HW_CFG after writing: 0x%08x\n", read_buf);
1067
1068 ret = smsc95xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
1009
1010 netif_dbg(dev, ifup, dev->net,
1011 "Read Value from HW_CFG after writing: 0x%08x\n", read_buf);
1012
1013 ret = smsc95xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
1069 if (ret < 0) {
1070 netdev_warn(dev->net, "Failed to write INT_STS: %d\n", ret);
1014 if (ret < 0)
1071 return ret;
1015 return ret;
1072 }
1073
1074 ret = smsc95xx_read_reg(dev, ID_REV, &read_buf);
1016
1017 ret = smsc95xx_read_reg(dev, ID_REV, &read_buf);
1075 if (ret < 0) {
1076 netdev_warn(dev->net, "Failed to read ID_REV: %d\n", ret);
1018 if (ret < 0)
1077 return ret;
1019 return ret;
1078 }
1079 netif_dbg(dev, ifup, dev->net, "ID_REV = 0x%08x\n", read_buf);
1080
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);
1020 netif_dbg(dev, ifup, dev->net, "ID_REV = 0x%08x\n", read_buf);
1021
1022 /* Configure GPIO pins as LED outputs */
1023 write_buf = LED_GPIO_CFG_SPD_LED | LED_GPIO_CFG_LNK_LED |
1024 LED_GPIO_CFG_FDX_LED;
1025 ret = smsc95xx_write_reg(dev, LED_GPIO_CFG, write_buf);
1085 if (ret < 0) {
1086 netdev_warn(dev->net, "Failed to write LED_GPIO_CFG: %d\n", ret);
1026 if (ret < 0)
1087 return ret;
1027 return ret;
1088 }
1089
1090 /* Init Tx */
1091 ret = smsc95xx_write_reg(dev, FLOW, 0);
1028
1029 /* Init Tx */
1030 ret = smsc95xx_write_reg(dev, FLOW, 0);
1092 if (ret < 0) {
1093 netdev_warn(dev->net, "Failed to write FLOW: %d\n", ret);
1031 if (ret < 0)
1094 return ret;
1032 return ret;
1095 }
1096
1097 ret = smsc95xx_write_reg(dev, AFC_CFG, AFC_CFG_DEFAULT);
1033
1034 ret = smsc95xx_write_reg(dev, AFC_CFG, AFC_CFG_DEFAULT);
1098 if (ret < 0) {
1099 netdev_warn(dev->net, "Failed to write AFC_CFG: %d\n", ret);
1035 if (ret < 0)
1100 return ret;
1036 return ret;
1101 }
1102
1103 /* Don't need mac_cr_lock during initialisation */
1104 ret = smsc95xx_read_reg(dev, MAC_CR, &pdata->mac_cr);
1037
1038 /* Don't need mac_cr_lock during initialisation */
1039 ret = smsc95xx_read_reg(dev, MAC_CR, &pdata->mac_cr);
1105 if (ret < 0) {
1106 netdev_warn(dev->net, "Failed to read MAC_CR: %d\n", ret);
1040 if (ret < 0)
1107 return ret;
1041 return ret;
1108 }
1109
1110 /* Init Rx */
1111 /* Set Vlan */
1112 ret = smsc95xx_write_reg(dev, VLAN1, (u32)ETH_P_8021Q);
1042
1043 /* Init Rx */
1044 /* Set Vlan */
1045 ret = smsc95xx_write_reg(dev, VLAN1, (u32)ETH_P_8021Q);
1113 if (ret < 0) {
1114 netdev_warn(dev->net, "Failed to write VLAN1: %d\n", ret);
1046 if (ret < 0)
1115 return ret;
1047 return ret;
1116 }
1117
1118 /* Enable or disable checksum offload engines */
1119 ret = smsc95xx_set_features(dev->net, dev->net->features);
1120 if (ret < 0) {
1121 netdev_warn(dev->net, "Failed to set checksum offload features\n");
1122 return ret;
1123 }
1124
1125 smsc95xx_set_multicast(dev->net);
1126
1127 ret = smsc95xx_phy_initialize(dev);
1128 if (ret < 0) {
1129 netdev_warn(dev->net, "Failed to init PHY\n");
1130 return ret;
1131 }
1132
1133 ret = smsc95xx_read_reg(dev, INT_EP_CTL, &read_buf);
1048
1049 /* Enable or disable checksum offload engines */
1050 ret = smsc95xx_set_features(dev->net, dev->net->features);
1051 if (ret < 0) {
1052 netdev_warn(dev->net, "Failed to set checksum offload features\n");
1053 return ret;
1054 }
1055
1056 smsc95xx_set_multicast(dev->net);
1057
1058 ret = smsc95xx_phy_initialize(dev);
1059 if (ret < 0) {
1060 netdev_warn(dev->net, "Failed to init PHY\n");
1061 return ret;
1062 }
1063
1064 ret = smsc95xx_read_reg(dev, INT_EP_CTL, &read_buf);
1134 if (ret < 0) {
1135 netdev_warn(dev->net, "Failed to read INT_EP_CTL: %d\n", ret);
1065 if (ret < 0)
1136 return ret;
1066 return ret;
1137 }
1138
1139 /* enable PHY interrupts */
1140 read_buf |= INT_EP_CTL_PHY_INT_;
1141
1142 ret = smsc95xx_write_reg(dev, INT_EP_CTL, read_buf);
1067
1068 /* enable PHY interrupts */
1069 read_buf |= INT_EP_CTL_PHY_INT_;
1070
1071 ret = smsc95xx_write_reg(dev, INT_EP_CTL, read_buf);
1143 if (ret < 0) {
1144 netdev_warn(dev->net, "Failed to write INT_EP_CTL: %d\n", ret);
1072 if (ret < 0)
1145 return ret;
1073 return ret;
1146 }
1147
1148 ret = smsc95xx_start_tx_path(dev);
1149 if (ret < 0) {
1150 netdev_warn(dev->net, "Failed to start TX path\n");
1151 return ret;
1152 }
1153
1154 ret = smsc95xx_start_rx_path(dev, 0);

--- 29 unchanged lines hidden (view full) ---

1184
1185 ret = usbnet_get_endpoints(dev, intf);
1186 if (ret < 0) {
1187 netdev_warn(dev->net, "usbnet_get_endpoints failed: %d\n", ret);
1188 return ret;
1189 }
1190
1191 dev->data[0] = (unsigned long)kzalloc(sizeof(struct smsc95xx_priv),
1074
1075 ret = smsc95xx_start_tx_path(dev);
1076 if (ret < 0) {
1077 netdev_warn(dev->net, "Failed to start TX path\n");
1078 return ret;
1079 }
1080
1081 ret = smsc95xx_start_rx_path(dev, 0);

--- 29 unchanged lines hidden (view full) ---

1111
1112 ret = usbnet_get_endpoints(dev, intf);
1113 if (ret < 0) {
1114 netdev_warn(dev->net, "usbnet_get_endpoints failed: %d\n", ret);
1115 return ret;
1116 }
1117
1118 dev->data[0] = (unsigned long)kzalloc(sizeof(struct smsc95xx_priv),
1192 GFP_KERNEL);
1119 GFP_KERNEL);
1193
1194 pdata = (struct smsc95xx_priv *)(dev->data[0]);
1120
1121 pdata = (struct smsc95xx_priv *)(dev->data[0]);
1195 if (!pdata) {
1196 netdev_warn(dev->net, "Unable to allocate struct smsc95xx_priv\n");
1122 if (!pdata)
1197 return -ENOMEM;
1123 return -ENOMEM;
1198 }
1199
1200 spin_lock_init(&pdata->mac_cr_lock);
1201
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;
1206
1207 dev->net->hw_features = NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
1208
1209 smsc95xx_init_mac_address(dev);
1210
1211 /* Init all registers */
1212 ret = smsc95xx_reset(dev);
1213
1214 /* detect device revision as different features may be available */
1215 ret = smsc95xx_read_reg(dev, ID_REV, &val);
1124
1125 spin_lock_init(&pdata->mac_cr_lock);
1126
1127 if (DEFAULT_TX_CSUM_ENABLE)
1128 dev->net->features |= NETIF_F_HW_CSUM;
1129 if (DEFAULT_RX_CSUM_ENABLE)
1130 dev->net->features |= NETIF_F_RXCSUM;
1131
1132 dev->net->hw_features = NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
1133
1134 smsc95xx_init_mac_address(dev);
1135
1136 /* Init all registers */
1137 ret = smsc95xx_reset(dev);
1138
1139 /* detect device revision as different features may be available */
1140 ret = smsc95xx_read_reg(dev, ID_REV, &val);
1216 if (ret < 0) {
1217 netdev_warn(dev->net, "Failed to read ID_REV: %d\n", ret);
1141 if (ret < 0)
1218 return ret;
1142 return ret;
1219 }
1220 val >>= 16;
1221
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_)

--- 28 unchanged lines hidden (view full) ---

1256{
1257 struct mii_if_info *mii = &dev->mii;
1258 int ret;
1259
1260 netdev_dbg(dev->net, "enabling PHY wakeup interrupts\n");
1261
1262 /* read to clear */
1263 ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_SRC);
1143 val >>= 16;
1144
1145 if ((val == ID_REV_CHIP_ID_9500A_) || (val == ID_REV_CHIP_ID_9530_) ||
1146 (val == ID_REV_CHIP_ID_89530_) || (val == ID_REV_CHIP_ID_9730_))
1147 pdata->features = (FEATURE_8_WAKEUP_FILTERS |
1148 FEATURE_PHY_NLP_CROSSOVER |
1149 FEATURE_AUTOSUSPEND);
1150 else if (val == ID_REV_CHIP_ID_9512_)

--- 28 unchanged lines hidden (view full) ---

1179{
1180 struct mii_if_info *mii = &dev->mii;
1181 int ret;
1182
1183 netdev_dbg(dev->net, "enabling PHY wakeup interrupts\n");
1184
1185 /* read to clear */
1186 ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_SRC);
1264 if (ret < 0) {
1265 netdev_warn(dev->net, "Error reading PHY_INT_SRC\n");
1187 if (ret < 0)
1266 return ret;
1188 return ret;
1267 }
1268
1269 /* enable interrupt source */
1270 ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_MASK);
1189
1190 /* enable interrupt source */
1191 ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_MASK);
1271 if (ret < 0) {
1272 netdev_warn(dev->net, "Error reading PHY_INT_MASK\n");
1192 if (ret < 0)
1273 return ret;
1193 return ret;
1274 }
1275
1276 ret |= mask;
1277
1278 smsc95xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_INT_MASK, ret);
1279
1280 return 0;
1281}
1282
1283static int smsc95xx_link_ok_nopm(struct usbnet *dev)
1284{
1285 struct mii_if_info *mii = &dev->mii;
1286 int ret;
1287
1288 /* first, a dummy read, needed to latch some MII phys */
1289 ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR);
1194
1195 ret |= mask;
1196
1197 smsc95xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_INT_MASK, ret);
1198
1199 return 0;
1200}
1201
1202static int smsc95xx_link_ok_nopm(struct usbnet *dev)
1203{
1204 struct mii_if_info *mii = &dev->mii;
1205 int ret;
1206
1207 /* first, a dummy read, needed to latch some MII phys */
1208 ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR);
1290 if (ret < 0) {
1291 netdev_warn(dev->net, "Error reading MII_BMSR\n");
1209 if (ret < 0)
1292 return ret;
1210 return ret;
1293 }
1294
1295 ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR);
1211
1212 ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR);
1296 if (ret < 0) {
1297 netdev_warn(dev->net, "Error reading MII_BMSR\n");
1213 if (ret < 0)
1298 return ret;
1214 return ret;
1299 }
1300
1301 return !!(ret & BMSR_LSTATUS);
1302}
1303
1304static int smsc95xx_enter_suspend0(struct usbnet *dev)
1305{
1306 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1307 u32 val;
1308 int ret;
1309
1310 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1215
1216 return !!(ret & BMSR_LSTATUS);
1217}
1218
1219static int smsc95xx_enter_suspend0(struct usbnet *dev)
1220{
1221 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1222 u32 val;
1223 int ret;
1224
1225 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1311 if (ret < 0) {
1312 netdev_warn(dev->net, "Error reading PM_CTRL\n");
1226 if (ret < 0)
1313 return ret;
1227 return ret;
1314 }
1315
1316 val &= (~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_));
1317 val |= PM_CTL_SUS_MODE_0;
1318
1319 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1228
1229 val &= (~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_));
1230 val |= PM_CTL_SUS_MODE_0;
1231
1232 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1320 if (ret < 0) {
1321 netdev_warn(dev->net, "Error writing PM_CTRL\n");
1233 if (ret < 0)
1322 return ret;
1234 return ret;
1323 }
1324
1325 /* clear wol status */
1326 val &= ~PM_CTL_WUPS_;
1327 val |= PM_CTL_WUPS_WOL_;
1328
1329 /* enable energy detection */
1330 if (pdata->wolopts & WAKE_PHY)
1331 val |= PM_CTL_WUPS_ED_;
1332
1333 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1235
1236 /* clear wol status */
1237 val &= ~PM_CTL_WUPS_;
1238 val |= PM_CTL_WUPS_WOL_;
1239
1240 /* enable energy detection */
1241 if (pdata->wolopts & WAKE_PHY)
1242 val |= PM_CTL_WUPS_ED_;
1243
1244 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1334 if (ret < 0) {
1335 netdev_warn(dev->net, "Error writing PM_CTRL\n");
1245 if (ret < 0)
1336 return ret;
1246 return ret;
1337 }
1338
1339 /* read back PM_CTRL */
1340 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1247
1248 /* read back PM_CTRL */
1249 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1341 if (ret < 0)
1342 netdev_warn(dev->net, "Error reading PM_CTRL\n");
1343
1250
1251 pdata->suspend_flags |= SUSPEND_SUSPEND0;
1252
1344 return ret;
1345}
1346
1347static int smsc95xx_enter_suspend1(struct usbnet *dev)
1348{
1349 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1350 struct mii_if_info *mii = &dev->mii;
1351 u32 val;
1352 int ret;
1353
1354 /* reconfigure link pulse detection timing for
1355 * compatibility with non-standard link partners
1356 */
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);
1360
1361 /* enable energy detect power-down mode */
1362 ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_MODE_CTRL_STS);
1253 return ret;
1254}
1255
1256static int smsc95xx_enter_suspend1(struct usbnet *dev)
1257{
1258 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1259 struct mii_if_info *mii = &dev->mii;
1260 u32 val;
1261 int ret;
1262
1263 /* reconfigure link pulse detection timing for
1264 * compatibility with non-standard link partners
1265 */
1266 if (pdata->features & FEATURE_PHY_NLP_CROSSOVER)
1267 smsc95xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_EDPD_CONFIG,
1268 PHY_EDPD_CONFIG_DEFAULT);
1269
1270 /* enable energy detect power-down mode */
1271 ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_MODE_CTRL_STS);
1363 if (ret < 0) {
1364 netdev_warn(dev->net, "Error reading PHY_MODE_CTRL_STS\n");
1272 if (ret < 0)
1365 return ret;
1273 return ret;
1366 }
1367
1368 ret |= MODE_CTRL_STS_EDPWRDOWN_;
1369
1370 smsc95xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_MODE_CTRL_STS, ret);
1371
1372 /* enter SUSPEND1 mode */
1373 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1274
1275 ret |= MODE_CTRL_STS_EDPWRDOWN_;
1276
1277 smsc95xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_MODE_CTRL_STS, ret);
1278
1279 /* enter SUSPEND1 mode */
1280 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1374 if (ret < 0) {
1375 netdev_warn(dev->net, "Error reading PM_CTRL\n");
1281 if (ret < 0)
1376 return ret;
1282 return ret;
1377 }
1378
1379 val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
1380 val |= PM_CTL_SUS_MODE_1;
1381
1382 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1283
1284 val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
1285 val |= PM_CTL_SUS_MODE_1;
1286
1287 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1383 if (ret < 0) {
1384 netdev_warn(dev->net, "Error writing PM_CTRL\n");
1288 if (ret < 0)
1385 return ret;
1289 return ret;
1386 }
1387
1388 /* clear wol status, enable energy detection */
1389 val &= ~PM_CTL_WUPS_;
1390 val |= (PM_CTL_WUPS_ED_ | PM_CTL_ED_EN_);
1391
1392 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1290
1291 /* clear wol status, enable energy detection */
1292 val &= ~PM_CTL_WUPS_;
1293 val |= (PM_CTL_WUPS_ED_ | PM_CTL_ED_EN_);
1294
1295 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1393 if (ret < 0)
1394 netdev_warn(dev->net, "Error writing PM_CTRL\n");
1395
1296
1297 pdata->suspend_flags |= SUSPEND_SUSPEND1;
1298
1396 return ret;
1397}
1398
1399static int smsc95xx_enter_suspend2(struct usbnet *dev)
1400{
1299 return ret;
1300}
1301
1302static int smsc95xx_enter_suspend2(struct usbnet *dev)
1303{
1304 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1401 u32 val;
1402 int ret;
1403
1404 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1305 u32 val;
1306 int ret;
1307
1308 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1405 if (ret < 0) {
1406 netdev_warn(dev->net, "Error reading PM_CTRL\n");
1309 if (ret < 0)
1407 return ret;
1310 return ret;
1408 }
1409
1410 val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
1411 val |= PM_CTL_SUS_MODE_2;
1412
1413 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1311
1312 val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
1313 val |= PM_CTL_SUS_MODE_2;
1314
1315 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1414 if (ret < 0)
1415 netdev_warn(dev->net, "Error writing PM_CTRL\n");
1416
1316
1317 pdata->suspend_flags |= SUSPEND_SUSPEND2;
1318
1417 return ret;
1418}
1419
1319 return ret;
1320}
1321
1322static int smsc95xx_enter_suspend3(struct usbnet *dev)
1323{
1324 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1325 u32 val;
1326 int ret;
1327
1328 ret = smsc95xx_read_reg_nopm(dev, RX_FIFO_INF, &val);
1329 if (ret < 0)
1330 return ret;
1331
1332 if (val & 0xFFFF) {
1333 netdev_info(dev->net, "rx fifo not empty in autosuspend\n");
1334 return -EBUSY;
1335 }
1336
1337 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1338 if (ret < 0)
1339 return ret;
1340
1341 val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
1342 val |= PM_CTL_SUS_MODE_3 | PM_CTL_RES_CLR_WKP_STS;
1343
1344 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1345 if (ret < 0)
1346 return ret;
1347
1348 /* clear wol status */
1349 val &= ~PM_CTL_WUPS_;
1350 val |= PM_CTL_WUPS_WOL_;
1351
1352 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1353 if (ret < 0)
1354 return ret;
1355
1356 pdata->suspend_flags |= SUSPEND_SUSPEND3;
1357
1358 return 0;
1359}
1360
1361static int smsc95xx_autosuspend(struct usbnet *dev, u32 link_up)
1362{
1363 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1364 int ret;
1365
1366 if (!netif_running(dev->net)) {
1367 /* interface is ifconfig down so fully power down hw */
1368 netdev_dbg(dev->net, "autosuspend entering SUSPEND2\n");
1369 return smsc95xx_enter_suspend2(dev);
1370 }
1371
1372 if (!link_up) {
1373 /* link is down so enter EDPD mode, but only if device can
1374 * reliably resume from it. This check should be redundant
1375 * as current FEATURE_AUTOSUSPEND parts also support
1376 * FEATURE_PHY_NLP_CROSSOVER but it's included for clarity */
1377 if (!(pdata->features & FEATURE_PHY_NLP_CROSSOVER)) {
1378 netdev_warn(dev->net, "EDPD not supported\n");
1379 return -EBUSY;
1380 }
1381
1382 netdev_dbg(dev->net, "autosuspend entering SUSPEND1\n");
1383
1384 /* enable PHY wakeup events for if cable is attached */
1385 ret = smsc95xx_enable_phy_wakeup_interrupts(dev,
1386 PHY_INT_MASK_ANEG_COMP_);
1387 if (ret < 0) {
1388 netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
1389 return ret;
1390 }
1391
1392 netdev_info(dev->net, "entering SUSPEND1 mode\n");
1393 return smsc95xx_enter_suspend1(dev);
1394 }
1395
1396 /* enable PHY wakeup events so we remote wakeup if cable is pulled */
1397 ret = smsc95xx_enable_phy_wakeup_interrupts(dev,
1398 PHY_INT_MASK_LINK_DOWN_);
1399 if (ret < 0) {
1400 netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
1401 return ret;
1402 }
1403
1404 netdev_dbg(dev->net, "autosuspend entering SUSPEND3\n");
1405 return smsc95xx_enter_suspend3(dev);
1406}
1407
1420static int smsc95xx_suspend(struct usb_interface *intf, pm_message_t message)
1421{
1422 struct usbnet *dev = usb_get_intfdata(intf);
1423 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1424 u32 val, link_up;
1425 int ret;
1426
1408static int smsc95xx_suspend(struct usb_interface *intf, pm_message_t message)
1409{
1410 struct usbnet *dev = usb_get_intfdata(intf);
1411 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1412 u32 val, link_up;
1413 int ret;
1414
1415 /* TODO: don't indicate this feature to usb framework if
1416 * our current hardware doesn't have the capability
1417 */
1418 if ((message.event == PM_EVENT_AUTO_SUSPEND) &&
1419 (!(pdata->features & FEATURE_AUTOSUSPEND))) {
1420 netdev_warn(dev->net, "autosuspend not supported\n");
1421 return -EBUSY;
1422 }
1423
1427 ret = usbnet_suspend(intf, message);
1428 if (ret < 0) {
1429 netdev_warn(dev->net, "usbnet_suspend error\n");
1430 return ret;
1431 }
1432
1424 ret = usbnet_suspend(intf, message);
1425 if (ret < 0) {
1426 netdev_warn(dev->net, "usbnet_suspend error\n");
1427 return ret;
1428 }
1429
1430 if (pdata->suspend_flags) {
1431 netdev_warn(dev->net, "error during last resume\n");
1432 pdata->suspend_flags = 0;
1433 }
1434
1433 /* determine if link is up using only _nopm functions */
1434 link_up = smsc95xx_link_ok_nopm(dev);
1435
1435 /* determine if link is up using only _nopm functions */
1436 link_up = smsc95xx_link_ok_nopm(dev);
1437
1438 if (message.event == PM_EVENT_AUTO_SUSPEND) {
1439 ret = smsc95xx_autosuspend(dev, link_up);
1440 goto done;
1441 }
1442
1443 /* if we get this far we're not autosuspending */
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
1438 */
1439 if (!(pdata->wolopts & SUPPORTED_WAKE) ||
1440 !(link_up || (pdata->wolopts & WAKE_PHY))) {
1441 netdev_info(dev->net, "entering SUSPEND2 mode\n");
1442
1443 /* disable energy detect (link up) & wake up events */
1444 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1444 /* if no wol options set, or if link is down and we're not waking on
1445 * PHY activity, enter lowest power SUSPEND2 mode
1446 */
1447 if (!(pdata->wolopts & SUPPORTED_WAKE) ||
1448 !(link_up || (pdata->wolopts & WAKE_PHY))) {
1449 netdev_info(dev->net, "entering SUSPEND2 mode\n");
1450
1451 /* disable energy detect (link up) & wake up events */
1452 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1445 if (ret < 0) {
1446 netdev_warn(dev->net, "Error reading WUCSR\n");
1453 if (ret < 0)
1447 goto done;
1454 goto done;
1448 }
1449
1450 val &= ~(WUCSR_MPEN_ | WUCSR_WAKE_EN_);
1451
1452 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1455
1456 val &= ~(WUCSR_MPEN_ | WUCSR_WAKE_EN_);
1457
1458 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1453 if (ret < 0) {
1454 netdev_warn(dev->net, "Error writing WUCSR\n");
1459 if (ret < 0)
1455 goto done;
1460 goto done;
1456 }
1457
1458 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1461
1462 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1459 if (ret < 0) {
1460 netdev_warn(dev->net, "Error reading PM_CTRL\n");
1463 if (ret < 0)
1461 goto done;
1464 goto done;
1462 }
1463
1464 val &= ~(PM_CTL_ED_EN_ | PM_CTL_WOL_EN_);
1465
1466 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1465
1466 val &= ~(PM_CTL_ED_EN_ | PM_CTL_WOL_EN_);
1467
1468 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1467 if (ret < 0) {
1468 netdev_warn(dev->net, "Error writing PM_CTRL\n");
1469 if (ret < 0)
1469 goto done;
1470 goto done;
1470 }
1471
1472 ret = smsc95xx_enter_suspend2(dev);
1473 goto done;
1474 }
1475
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_));

--- 81 unchanged lines hidden (view full) ---

1560 offset[filter/4] |= 0x00 << ((filter % 4) * 8);
1561 crc[filter/2] |= smsc_crc(dev->net->dev_addr, ETH_ALEN, filter);
1562 filter++;
1563 }
1564
1565 for (i = 0; i < (wuff_filter_count * 4); i++) {
1566 ret = smsc95xx_write_reg_nopm(dev, WUFF, filter_mask[i]);
1567 if (ret < 0) {
1471
1472 ret = smsc95xx_enter_suspend2(dev);
1473 goto done;
1474 }
1475
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_));

--- 81 unchanged lines hidden (view full) ---

1560 offset[filter/4] |= 0x00 << ((filter % 4) * 8);
1561 crc[filter/2] |= smsc_crc(dev->net->dev_addr, ETH_ALEN, filter);
1562 filter++;
1563 }
1564
1565 for (i = 0; i < (wuff_filter_count * 4); i++) {
1566 ret = smsc95xx_write_reg_nopm(dev, WUFF, filter_mask[i]);
1567 if (ret < 0) {
1568 netdev_warn(dev->net, "Error writing WUFF\n");
1569 kfree(filter_mask);
1570 goto done;
1571 }
1572 }
1573 kfree(filter_mask);
1574
1575 for (i = 0; i < (wuff_filter_count / 4); i++) {
1576 ret = smsc95xx_write_reg_nopm(dev, WUFF, command[i]);
1568 kfree(filter_mask);
1569 goto done;
1570 }
1571 }
1572 kfree(filter_mask);
1573
1574 for (i = 0; i < (wuff_filter_count / 4); i++) {
1575 ret = smsc95xx_write_reg_nopm(dev, WUFF, command[i]);
1577 if (ret < 0) {
1578 netdev_warn(dev->net, "Error writing WUFF\n");
1576 if (ret < 0)
1579 goto done;
1577 goto done;
1580 }
1581 }
1582
1583 for (i = 0; i < (wuff_filter_count / 4); i++) {
1584 ret = smsc95xx_write_reg_nopm(dev, WUFF, offset[i]);
1578 }
1579
1580 for (i = 0; i < (wuff_filter_count / 4); i++) {
1581 ret = smsc95xx_write_reg_nopm(dev, WUFF, offset[i]);
1585 if (ret < 0) {
1586 netdev_warn(dev->net, "Error writing WUFF\n");
1582 if (ret < 0)
1587 goto done;
1583 goto done;
1588 }
1589 }
1590
1591 for (i = 0; i < (wuff_filter_count / 2); i++) {
1592 ret = smsc95xx_write_reg_nopm(dev, WUFF, crc[i]);
1584 }
1585
1586 for (i = 0; i < (wuff_filter_count / 2); i++) {
1587 ret = smsc95xx_write_reg_nopm(dev, WUFF, crc[i]);
1593 if (ret < 0) {
1594 netdev_warn(dev->net, "Error writing WUFF\n");
1588 if (ret < 0)
1595 goto done;
1589 goto done;
1596 }
1597 }
1598
1599 /* clear any pending pattern match packet status */
1600 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1590 }
1591
1592 /* clear any pending pattern match packet status */
1593 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1601 if (ret < 0) {
1602 netdev_warn(dev->net, "Error reading WUCSR\n");
1594 if (ret < 0)
1603 goto done;
1595 goto done;
1604 }
1605
1606 val |= WUCSR_WUFR_;
1607
1608 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1596
1597 val |= WUCSR_WUFR_;
1598
1599 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1609 if (ret < 0) {
1610 netdev_warn(dev->net, "Error writing WUCSR\n");
1600 if (ret < 0)
1611 goto done;
1601 goto done;
1612 }
1613 }
1614
1615 if (pdata->wolopts & WAKE_MAGIC) {
1616 /* clear any pending magic packet status */
1617 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1602 }
1603
1604 if (pdata->wolopts & WAKE_MAGIC) {
1605 /* clear any pending magic packet status */
1606 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1618 if (ret < 0) {
1619 netdev_warn(dev->net, "Error reading WUCSR\n");
1607 if (ret < 0)
1620 goto done;
1608 goto done;
1621 }
1622
1623 val |= WUCSR_MPR_;
1624
1625 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1609
1610 val |= WUCSR_MPR_;
1611
1612 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1626 if (ret < 0) {
1627 netdev_warn(dev->net, "Error writing WUCSR\n");
1613 if (ret < 0)
1628 goto done;
1614 goto done;
1629 }
1630 }
1631
1632 /* enable/disable wakeup sources */
1633 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1615 }
1616
1617 /* enable/disable wakeup sources */
1618 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1634 if (ret < 0) {
1635 netdev_warn(dev->net, "Error reading WUCSR\n");
1619 if (ret < 0)
1636 goto done;
1620 goto done;
1637 }
1638
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_;
1642 } else {
1643 netdev_info(dev->net, "disabling pattern match wakeup\n");
1644 val &= ~WUCSR_WAKE_EN_;
1645 }
1646
1647 if (pdata->wolopts & WAKE_MAGIC) {
1648 netdev_info(dev->net, "enabling magic packet wakeup\n");
1649 val |= WUCSR_MPEN_;
1650 } else {
1651 netdev_info(dev->net, "disabling magic packet wakeup\n");
1652 val &= ~WUCSR_MPEN_;
1653 }
1654
1655 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1621
1622 if (pdata->wolopts & (WAKE_BCAST | WAKE_MCAST | WAKE_ARP | WAKE_UCAST)) {
1623 netdev_info(dev->net, "enabling pattern match wakeup\n");
1624 val |= WUCSR_WAKE_EN_;
1625 } else {
1626 netdev_info(dev->net, "disabling pattern match wakeup\n");
1627 val &= ~WUCSR_WAKE_EN_;
1628 }
1629
1630 if (pdata->wolopts & WAKE_MAGIC) {
1631 netdev_info(dev->net, "enabling magic packet wakeup\n");
1632 val |= WUCSR_MPEN_;
1633 } else {
1634 netdev_info(dev->net, "disabling magic packet wakeup\n");
1635 val &= ~WUCSR_MPEN_;
1636 }
1637
1638 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1656 if (ret < 0) {
1657 netdev_warn(dev->net, "Error writing WUCSR\n");
1639 if (ret < 0)
1658 goto done;
1640 goto done;
1659 }
1660
1661 /* enable wol wakeup source */
1662 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1641
1642 /* enable wol wakeup source */
1643 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1663 if (ret < 0) {
1664 netdev_warn(dev->net, "Error reading PM_CTRL\n");
1644 if (ret < 0)
1665 goto done;
1645 goto done;
1666 }
1667
1668 val |= PM_CTL_WOL_EN_;
1669
1670 /* phy energy detect wakeup source */
1671 if (pdata->wolopts & WAKE_PHY)
1672 val |= PM_CTL_ED_EN_;
1673
1674 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1646
1647 val |= PM_CTL_WOL_EN_;
1648
1649 /* phy energy detect wakeup source */
1650 if (pdata->wolopts & WAKE_PHY)
1651 val |= PM_CTL_ED_EN_;
1652
1653 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1675 if (ret < 0) {
1676 netdev_warn(dev->net, "Error writing PM_CTRL\n");
1654 if (ret < 0)
1677 goto done;
1655 goto done;
1678 }
1679
1680 /* enable receiver to enable frame reception */
1681 smsc95xx_start_rx_path(dev, 1);
1682
1683 /* some wol options are enabled, so enter SUSPEND0 */
1684 netdev_info(dev->net, "entering SUSPEND0 mode\n");
1685 ret = smsc95xx_enter_suspend0(dev);
1686
1687done:
1688 if (ret)
1689 usbnet_resume(intf);
1690 return ret;
1691}
1692
1693static int smsc95xx_resume(struct usb_interface *intf)
1694{
1695 struct usbnet *dev = usb_get_intfdata(intf);
1696 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1656
1657 /* enable receiver to enable frame reception */
1658 smsc95xx_start_rx_path(dev, 1);
1659
1660 /* some wol options are enabled, so enter SUSPEND0 */
1661 netdev_info(dev->net, "entering SUSPEND0 mode\n");
1662 ret = smsc95xx_enter_suspend0(dev);
1663
1664done:
1665 if (ret)
1666 usbnet_resume(intf);
1667 return ret;
1668}
1669
1670static int smsc95xx_resume(struct usb_interface *intf)
1671{
1672 struct usbnet *dev = usb_get_intfdata(intf);
1673 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1674 u8 suspend_flags = pdata->suspend_flags;
1697 int ret;
1698 u32 val;
1699
1700 BUG_ON(!dev);
1701
1675 int ret;
1676 u32 val;
1677
1678 BUG_ON(!dev);
1679
1702 if (pdata->wolopts) {
1680 netdev_dbg(dev->net, "resume suspend_flags=0x%02x\n", suspend_flags);
1681
1682 /* do this first to ensure it's cleared even in error case */
1683 pdata->suspend_flags = 0;
1684
1685 if (suspend_flags & SUSPEND_ALLMODES) {
1703 /* clear wake-up sources */
1704 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1686 /* clear wake-up sources */
1687 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1705 if (ret < 0) {
1706 netdev_warn(dev->net, "Error reading WUCSR\n");
1688 if (ret < 0)
1707 return ret;
1689 return ret;
1708 }
1709
1710 val &= ~(WUCSR_WAKE_EN_ | WUCSR_MPEN_);
1711
1712 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1690
1691 val &= ~(WUCSR_WAKE_EN_ | WUCSR_MPEN_);
1692
1693 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1713 if (ret < 0) {
1714 netdev_warn(dev->net, "Error writing WUCSR\n");
1694 if (ret < 0)
1715 return ret;
1695 return ret;
1716 }
1717
1718 /* clear wake-up status */
1719 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1696
1697 /* clear wake-up status */
1698 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1720 if (ret < 0) {
1721 netdev_warn(dev->net, "Error reading PM_CTRL\n");
1699 if (ret < 0)
1722 return ret;
1700 return ret;
1723 }
1724
1725 val &= ~PM_CTL_WOL_EN_;
1726 val |= PM_CTL_WUPS_;
1727
1728 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1701
1702 val &= ~PM_CTL_WOL_EN_;
1703 val |= PM_CTL_WUPS_;
1704
1705 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1729 if (ret < 0) {
1730 netdev_warn(dev->net, "Error writing PM_CTRL\n");
1706 if (ret < 0)
1731 return ret;
1707 return ret;
1732 }
1733 }
1734
1735 ret = usbnet_resume(intf);
1736 if (ret < 0)
1737 netdev_warn(dev->net, "usbnet_resume error\n");
1738
1739 return ret;
1740}

--- 145 unchanged lines hidden (view full) ---

1886 tx_cmd_a = (u32)(skb->len - 8) | TX_CMD_A_FIRST_SEG_ |
1887 TX_CMD_A_LAST_SEG_;
1888 cpu_to_le32s(&tx_cmd_a);
1889 memcpy(skb->data, &tx_cmd_a, 4);
1890
1891 return skb;
1892}
1893
1708 }
1709
1710 ret = usbnet_resume(intf);
1711 if (ret < 0)
1712 netdev_warn(dev->net, "usbnet_resume error\n");
1713
1714 return ret;
1715}

--- 145 unchanged lines hidden (view full) ---

1861 tx_cmd_a = (u32)(skb->len - 8) | TX_CMD_A_FIRST_SEG_ |
1862 TX_CMD_A_LAST_SEG_;
1863 cpu_to_le32s(&tx_cmd_a);
1864 memcpy(skb->data, &tx_cmd_a, 4);
1865
1866 return skb;
1867}
1868
1869static int smsc95xx_manage_power(struct usbnet *dev, int on)
1870{
1871 struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1872
1873 dev->intf->needs_remote_wakeup = on;
1874
1875 if (pdata->features & FEATURE_AUTOSUSPEND)
1876 return 0;
1877
1878 /* this chip revision doesn't support autosuspend */
1879 netdev_info(dev->net, "hardware doesn't support USB autosuspend\n");
1880
1881 if (on)
1882 usb_autopm_get_interface_no_resume(dev->intf);
1883 else
1884 usb_autopm_put_interface(dev->intf);
1885
1886 return 0;
1887}
1888
1894static 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,
1889static const struct driver_info smsc95xx_info = {
1890 .description = "smsc95xx USB 2.0 Ethernet",
1891 .bind = smsc95xx_bind,
1892 .unbind = smsc95xx_unbind,
1893 .link_reset = smsc95xx_link_reset,
1894 .reset = smsc95xx_reset,
1895 .rx_fixup = smsc95xx_rx_fixup,
1896 .tx_fixup = smsc95xx_tx_fixup,
1897 .status = smsc95xx_status,
1898 .manage_power = smsc95xx_manage_power,
1903 .flags = FLAG_ETHER | FLAG_SEND_ZLP | FLAG_LINK_INTR,
1904};
1905
1906static const struct usb_device_id products[] = {
1907 {
1908 /* SMSC9500 USB Ethernet Device */
1909 USB_DEVICE(0x0424, 0x9500),
1910 .driver_info = (unsigned long) &smsc95xx_info,

--- 91 unchanged lines hidden (view full) ---

2002 .name = "smsc95xx",
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,
1899 .flags = FLAG_ETHER | FLAG_SEND_ZLP | FLAG_LINK_INTR,
1900};
1901
1902static const struct usb_device_id products[] = {
1903 {
1904 /* SMSC9500 USB Ethernet Device */
1905 USB_DEVICE(0x0424, 0x9500),
1906 .driver_info = (unsigned long) &smsc95xx_info,

--- 91 unchanged lines hidden (view full) ---

1998 .name = "smsc95xx",
1999 .id_table = products,
2000 .probe = usbnet_probe,
2001 .suspend = smsc95xx_suspend,
2002 .resume = smsc95xx_resume,
2003 .reset_resume = smsc95xx_resume,
2004 .disconnect = usbnet_disconnect,
2005 .disable_hub_initiated_lpm = 1,
2006 .supports_autosuspend = 1,
2010};
2011
2012module_usb_driver(smsc95xx_driver);
2013
2014MODULE_AUTHOR("Nancy Lin");
2015MODULE_AUTHOR("Steve Glendinning <steve.glendinning@shawell.net>");
2016MODULE_DESCRIPTION("SMSC95XX USB 2.0 Ethernet Devices");
2017MODULE_LICENSE("GPL");
2007};
2008
2009module_usb_driver(smsc95xx_driver);
2010
2011MODULE_AUTHOR("Nancy Lin");
2012MODULE_AUTHOR("Steve Glendinning <steve.glendinning@shawell.net>");
2013MODULE_DESCRIPTION("SMSC95XX USB 2.0 Ethernet Devices");
2014MODULE_LICENSE("GPL");