LCOV - code coverage report
Current view: top level - drivers/net/usb - lan78xx.c (source / functions) Hit Total Coverage
Test: Real Lines: 1 1667 0.1 %
Date: 2020-10-17 15:46:43 Functions: 0 105 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14