LCOV - code coverage report
Current view: top level - drivers/net/ethernet/broadcom - tg3.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 1 8873 0.1 %
Date: 2022-03-28 13:20:08 Functions: 1 322 0.3 %
Branches: 0 5661 0.0 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * tg3.c: Broadcom Tigon3 ethernet driver.
       3                 :            :  *
       4                 :            :  * Copyright (C) 2001, 2002, 2003, 2004 David S. Miller (davem@redhat.com)
       5                 :            :  * Copyright (C) 2001, 2002, 2003 Jeff Garzik (jgarzik@pobox.com)
       6                 :            :  * Copyright (C) 2004 Sun Microsystems Inc.
       7                 :            :  * Copyright (C) 2005-2016 Broadcom Corporation.
       8                 :            :  * Copyright (C) 2016-2017 Broadcom Limited.
       9                 :            :  * Copyright (C) 2018 Broadcom. All Rights Reserved. The term "Broadcom"
      10                 :            :  * refers to Broadcom Inc. and/or its subsidiaries.
      11                 :            :  *
      12                 :            :  * Firmware is:
      13                 :            :  *      Derived from proprietary unpublished source code,
      14                 :            :  *      Copyright (C) 2000-2016 Broadcom Corporation.
      15                 :            :  *      Copyright (C) 2016-2017 Broadcom Ltd.
      16                 :            :  *      Copyright (C) 2018 Broadcom. All Rights Reserved. The term "Broadcom"
      17                 :            :  *      refers to Broadcom Inc. and/or its subsidiaries.
      18                 :            :  *
      19                 :            :  *      Permission is hereby granted for the distribution of this firmware
      20                 :            :  *      data in hexadecimal or equivalent format, provided this copyright
      21                 :            :  *      notice is accompanying it.
      22                 :            :  */
      23                 :            : 
      24                 :            : 
      25                 :            : #include <linux/module.h>
      26                 :            : #include <linux/moduleparam.h>
      27                 :            : #include <linux/stringify.h>
      28                 :            : #include <linux/kernel.h>
      29                 :            : #include <linux/sched/signal.h>
      30                 :            : #include <linux/types.h>
      31                 :            : #include <linux/compiler.h>
      32                 :            : #include <linux/slab.h>
      33                 :            : #include <linux/delay.h>
      34                 :            : #include <linux/in.h>
      35                 :            : #include <linux/interrupt.h>
      36                 :            : #include <linux/ioport.h>
      37                 :            : #include <linux/pci.h>
      38                 :            : #include <linux/netdevice.h>
      39                 :            : #include <linux/etherdevice.h>
      40                 :            : #include <linux/skbuff.h>
      41                 :            : #include <linux/ethtool.h>
      42                 :            : #include <linux/mdio.h>
      43                 :            : #include <linux/mii.h>
      44                 :            : #include <linux/phy.h>
      45                 :            : #include <linux/brcmphy.h>
      46                 :            : #include <linux/if.h>
      47                 :            : #include <linux/if_vlan.h>
      48                 :            : #include <linux/ip.h>
      49                 :            : #include <linux/tcp.h>
      50                 :            : #include <linux/workqueue.h>
      51                 :            : #include <linux/prefetch.h>
      52                 :            : #include <linux/dma-mapping.h>
      53                 :            : #include <linux/firmware.h>
      54                 :            : #include <linux/ssb/ssb_driver_gige.h>
      55                 :            : #include <linux/hwmon.h>
      56                 :            : #include <linux/hwmon-sysfs.h>
      57                 :            : #include <linux/crc32poly.h>
      58                 :            : 
      59                 :            : #include <net/checksum.h>
      60                 :            : #include <net/ip.h>
      61                 :            : 
      62                 :            : #include <linux/io.h>
      63                 :            : #include <asm/byteorder.h>
      64                 :            : #include <linux/uaccess.h>
      65                 :            : 
      66                 :            : #include <uapi/linux/net_tstamp.h>
      67                 :            : #include <linux/ptp_clock_kernel.h>
      68                 :            : 
      69                 :            : #define BAR_0   0
      70                 :            : #define BAR_2   2
      71                 :            : 
      72                 :            : #include "tg3.h"
      73                 :            : 
      74                 :            : /* Functions & macros to verify TG3_FLAGS types */
      75                 :            : 
      76                 :          0 : static inline int _tg3_flag(enum TG3_FLAGS flag, unsigned long *bits)
      77                 :            : {
      78                 :          0 :         return test_bit(flag, bits);
      79                 :            : }
      80                 :            : 
      81                 :          0 : static inline void _tg3_flag_set(enum TG3_FLAGS flag, unsigned long *bits)
      82                 :            : {
      83                 :          0 :         set_bit(flag, bits);
      84                 :          0 : }
      85                 :            : 
      86                 :          0 : static inline void _tg3_flag_clear(enum TG3_FLAGS flag, unsigned long *bits)
      87                 :            : {
      88                 :          0 :         clear_bit(flag, bits);
      89                 :          0 : }
      90                 :            : 
      91                 :            : #define tg3_flag(tp, flag)                              \
      92                 :            :         _tg3_flag(TG3_FLAG_##flag, (tp)->tg3_flags)
      93                 :            : #define tg3_flag_set(tp, flag)                          \
      94                 :            :         _tg3_flag_set(TG3_FLAG_##flag, (tp)->tg3_flags)
      95                 :            : #define tg3_flag_clear(tp, flag)                        \
      96                 :            :         _tg3_flag_clear(TG3_FLAG_##flag, (tp)->tg3_flags)
      97                 :            : 
      98                 :            : #define DRV_MODULE_NAME         "tg3"
      99                 :            : #define TG3_MAJ_NUM                     3
     100                 :            : #define TG3_MIN_NUM                     137
     101                 :            : #define DRV_MODULE_VERSION      \
     102                 :            :         __stringify(TG3_MAJ_NUM) "." __stringify(TG3_MIN_NUM)
     103                 :            : #define DRV_MODULE_RELDATE      "May 11, 2014"
     104                 :            : 
     105                 :            : #define RESET_KIND_SHUTDOWN     0
     106                 :            : #define RESET_KIND_INIT         1
     107                 :            : #define RESET_KIND_SUSPEND      2
     108                 :            : 
     109                 :            : #define TG3_DEF_RX_MODE         0
     110                 :            : #define TG3_DEF_TX_MODE         0
     111                 :            : #define TG3_DEF_MSG_ENABLE        \
     112                 :            :         (NETIF_MSG_DRV          | \
     113                 :            :          NETIF_MSG_PROBE        | \
     114                 :            :          NETIF_MSG_LINK         | \
     115                 :            :          NETIF_MSG_TIMER        | \
     116                 :            :          NETIF_MSG_IFDOWN       | \
     117                 :            :          NETIF_MSG_IFUP         | \
     118                 :            :          NETIF_MSG_RX_ERR       | \
     119                 :            :          NETIF_MSG_TX_ERR)
     120                 :            : 
     121                 :            : #define TG3_GRC_LCLCTL_PWRSW_DELAY      100
     122                 :            : 
     123                 :            : /* length of time before we decide the hardware is borked,
     124                 :            :  * and dev->tx_timeout() should be called to fix the problem
     125                 :            :  */
     126                 :            : 
     127                 :            : #define TG3_TX_TIMEOUT                  (5 * HZ)
     128                 :            : 
     129                 :            : /* hardware minimum and maximum for a single frame's data payload */
     130                 :            : #define TG3_MIN_MTU                     ETH_ZLEN
     131                 :            : #define TG3_MAX_MTU(tp) \
     132                 :            :         (tg3_flag(tp, JUMBO_CAPABLE) ? 9000 : 1500)
     133                 :            : 
     134                 :            : /* These numbers seem to be hard coded in the NIC firmware somehow.
     135                 :            :  * You can't change the ring sizes, but you can change where you place
     136                 :            :  * them in the NIC onboard memory.
     137                 :            :  */
     138                 :            : #define TG3_RX_STD_RING_SIZE(tp) \
     139                 :            :         (tg3_flag(tp, LRG_PROD_RING_CAP) ? \
     140                 :            :          TG3_RX_STD_MAX_SIZE_5717 : TG3_RX_STD_MAX_SIZE_5700)
     141                 :            : #define TG3_DEF_RX_RING_PENDING         200
     142                 :            : #define TG3_RX_JMB_RING_SIZE(tp) \
     143                 :            :         (tg3_flag(tp, LRG_PROD_RING_CAP) ? \
     144                 :            :          TG3_RX_JMB_MAX_SIZE_5717 : TG3_RX_JMB_MAX_SIZE_5700)
     145                 :            : #define TG3_DEF_RX_JUMBO_RING_PENDING   100
     146                 :            : 
     147                 :            : /* Do not place this n-ring entries value into the tp struct itself,
     148                 :            :  * we really want to expose these constants to GCC so that modulo et
     149                 :            :  * al.  operations are done with shifts and masks instead of with
     150                 :            :  * hw multiply/modulo instructions.  Another solution would be to
     151                 :            :  * replace things like '% foo' with '& (foo - 1)'.
     152                 :            :  */
     153                 :            : 
     154                 :            : #define TG3_TX_RING_SIZE                512
     155                 :            : #define TG3_DEF_TX_RING_PENDING         (TG3_TX_RING_SIZE - 1)
     156                 :            : 
     157                 :            : #define TG3_RX_STD_RING_BYTES(tp) \
     158                 :            :         (sizeof(struct tg3_rx_buffer_desc) * TG3_RX_STD_RING_SIZE(tp))
     159                 :            : #define TG3_RX_JMB_RING_BYTES(tp) \
     160                 :            :         (sizeof(struct tg3_ext_rx_buffer_desc) * TG3_RX_JMB_RING_SIZE(tp))
     161                 :            : #define TG3_RX_RCB_RING_BYTES(tp) \
     162                 :            :         (sizeof(struct tg3_rx_buffer_desc) * (tp->rx_ret_ring_mask + 1))
     163                 :            : #define TG3_TX_RING_BYTES       (sizeof(struct tg3_tx_buffer_desc) * \
     164                 :            :                                  TG3_TX_RING_SIZE)
     165                 :            : #define NEXT_TX(N)              (((N) + 1) & (TG3_TX_RING_SIZE - 1))
     166                 :            : 
     167                 :            : #define TG3_DMA_BYTE_ENAB               64
     168                 :            : 
     169                 :            : #define TG3_RX_STD_DMA_SZ               1536
     170                 :            : #define TG3_RX_JMB_DMA_SZ               9046
     171                 :            : 
     172                 :            : #define TG3_RX_DMA_TO_MAP_SZ(x)         ((x) + TG3_DMA_BYTE_ENAB)
     173                 :            : 
     174                 :            : #define TG3_RX_STD_MAP_SZ               TG3_RX_DMA_TO_MAP_SZ(TG3_RX_STD_DMA_SZ)
     175                 :            : #define TG3_RX_JMB_MAP_SZ               TG3_RX_DMA_TO_MAP_SZ(TG3_RX_JMB_DMA_SZ)
     176                 :            : 
     177                 :            : #define TG3_RX_STD_BUFF_RING_SIZE(tp) \
     178                 :            :         (sizeof(struct ring_info) * TG3_RX_STD_RING_SIZE(tp))
     179                 :            : 
     180                 :            : #define TG3_RX_JMB_BUFF_RING_SIZE(tp) \
     181                 :            :         (sizeof(struct ring_info) * TG3_RX_JMB_RING_SIZE(tp))
     182                 :            : 
     183                 :            : /* Due to a hardware bug, the 5701 can only DMA to memory addresses
     184                 :            :  * that are at least dword aligned when used in PCIX mode.  The driver
     185                 :            :  * works around this bug by double copying the packet.  This workaround
     186                 :            :  * is built into the normal double copy length check for efficiency.
     187                 :            :  *
     188                 :            :  * However, the double copy is only necessary on those architectures
     189                 :            :  * where unaligned memory accesses are inefficient.  For those architectures
     190                 :            :  * where unaligned memory accesses incur little penalty, we can reintegrate
     191                 :            :  * the 5701 in the normal rx path.  Doing so saves a device structure
     192                 :            :  * dereference by hardcoding the double copy threshold in place.
     193                 :            :  */
     194                 :            : #define TG3_RX_COPY_THRESHOLD           256
     195                 :            : #if NET_IP_ALIGN == 0 || defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
     196                 :            :         #define TG3_RX_COPY_THRESH(tp)  TG3_RX_COPY_THRESHOLD
     197                 :            : #else
     198                 :            :         #define TG3_RX_COPY_THRESH(tp)  ((tp)->rx_copy_thresh)
     199                 :            : #endif
     200                 :            : 
     201                 :            : #if (NET_IP_ALIGN != 0)
     202                 :            : #define TG3_RX_OFFSET(tp)       ((tp)->rx_offset)
     203                 :            : #else
     204                 :            : #define TG3_RX_OFFSET(tp)       (NET_SKB_PAD)
     205                 :            : #endif
     206                 :            : 
     207                 :            : /* minimum number of free TX descriptors required to wake up TX process */
     208                 :            : #define TG3_TX_WAKEUP_THRESH(tnapi)             ((tnapi)->tx_pending / 4)
     209                 :            : #define TG3_TX_BD_DMA_MAX_2K            2048
     210                 :            : #define TG3_TX_BD_DMA_MAX_4K            4096
     211                 :            : 
     212                 :            : #define TG3_RAW_IP_ALIGN 2
     213                 :            : 
     214                 :            : #define TG3_MAX_UCAST_ADDR(tp) (tg3_flag((tp), ENABLE_ASF) ? 2 : 3)
     215                 :            : #define TG3_UCAST_ADDR_IDX(tp) (tg3_flag((tp), ENABLE_ASF) ? 2 : 1)
     216                 :            : 
     217                 :            : #define TG3_FW_UPDATE_TIMEOUT_SEC       5
     218                 :            : #define TG3_FW_UPDATE_FREQ_SEC          (TG3_FW_UPDATE_TIMEOUT_SEC / 2)
     219                 :            : 
     220                 :            : #define FIRMWARE_TG3            "tigon/tg3.bin"
     221                 :            : #define FIRMWARE_TG357766       "tigon/tg357766.bin"
     222                 :            : #define FIRMWARE_TG3TSO         "tigon/tg3_tso.bin"
     223                 :            : #define FIRMWARE_TG3TSO5        "tigon/tg3_tso5.bin"
     224                 :            : 
     225                 :            : static char version[] =
     226                 :            :         DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")";
     227                 :            : 
     228                 :            : MODULE_AUTHOR("David S. Miller (davem@redhat.com) and Jeff Garzik (jgarzik@pobox.com)");
     229                 :            : MODULE_DESCRIPTION("Broadcom Tigon3 ethernet driver");
     230                 :            : MODULE_LICENSE("GPL");
     231                 :            : MODULE_VERSION(DRV_MODULE_VERSION);
     232                 :            : MODULE_FIRMWARE(FIRMWARE_TG3);
     233                 :            : MODULE_FIRMWARE(FIRMWARE_TG3TSO);
     234                 :            : MODULE_FIRMWARE(FIRMWARE_TG3TSO5);
     235                 :            : 
     236                 :            : static int tg3_debug = -1;      /* -1 == use TG3_DEF_MSG_ENABLE as value */
     237                 :            : module_param(tg3_debug, int, 0);
     238                 :            : MODULE_PARM_DESC(tg3_debug, "Tigon3 bitmapped debugging message enable value");
     239                 :            : 
     240                 :            : #define TG3_DRV_DATA_FLAG_10_100_ONLY   0x0001
     241                 :            : #define TG3_DRV_DATA_FLAG_5705_10_100   0x0002
     242                 :            : 
     243                 :            : static const struct pci_device_id tg3_pci_tbl[] = {
     244                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5700)},
     245                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5701)},
     246                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5702)},
     247                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5703)},
     248                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5704)},
     249                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5702FE)},
     250                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5705)},
     251                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5705_2)},
     252                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5705M)},
     253                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5705M_2)},
     254                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5702X)},
     255                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5703X)},
     256                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5704S)},
     257                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5702A3)},
     258                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5703A3)},
     259                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5782)},
     260                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5788)},
     261                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5789)},
     262                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5901),
     263                 :            :          .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY |
     264                 :            :                         TG3_DRV_DATA_FLAG_5705_10_100},
     265                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5901_2),
     266                 :            :          .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY |
     267                 :            :                         TG3_DRV_DATA_FLAG_5705_10_100},
     268                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5704S_2)},
     269                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5705F),
     270                 :            :          .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY |
     271                 :            :                         TG3_DRV_DATA_FLAG_5705_10_100},
     272                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5721)},
     273                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5722)},
     274                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5750)},
     275                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5751)},
     276                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5751M)},
     277                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5751F),
     278                 :            :          .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY},
     279                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5752)},
     280                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5752M)},
     281                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5753)},
     282                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5753M)},
     283                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5753F),
     284                 :            :          .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY},
     285                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5754)},
     286                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5754M)},
     287                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5755)},
     288                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5755M)},
     289                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5756)},
     290                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5786)},
     291                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5787)},
     292                 :            :         {PCI_DEVICE_SUB(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5787M,
     293                 :            :                         PCI_VENDOR_ID_LENOVO,
     294                 :            :                         TG3PCI_SUBDEVICE_ID_LENOVO_5787M),
     295                 :            :          .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY},
     296                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5787M)},
     297                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5787F),
     298                 :            :          .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY},
     299                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5714)},
     300                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5714S)},
     301                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5715)},
     302                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5715S)},
     303                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5780)},
     304                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5780S)},
     305                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5781)},
     306                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5906)},
     307                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5906M)},
     308                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5784)},
     309                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5764)},
     310                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5723)},
     311                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5761)},
     312                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5761E)},
     313                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5761S)},
     314                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5761SE)},
     315                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5785_G)},
     316                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5785_F)},
     317                 :            :         {PCI_DEVICE_SUB(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57780,
     318                 :            :                         PCI_VENDOR_ID_AI, TG3PCI_SUBDEVICE_ID_ACER_57780_A),
     319                 :            :          .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY},
     320                 :            :         {PCI_DEVICE_SUB(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57780,
     321                 :            :                         PCI_VENDOR_ID_AI, TG3PCI_SUBDEVICE_ID_ACER_57780_B),
     322                 :            :          .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY},
     323                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57780)},
     324                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57760)},
     325                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57790),
     326                 :            :          .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY},
     327                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57788)},
     328                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5717)},
     329                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5717_C)},
     330                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5718)},
     331                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57781)},
     332                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57785)},
     333                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57761)},
     334                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57765)},
     335                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57791),
     336                 :            :          .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY},
     337                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57795),
     338                 :            :          .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY},
     339                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5719)},
     340                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5720)},
     341                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57762)},
     342                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57766)},
     343                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5762)},
     344                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5725)},
     345                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5727)},
     346                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57764)},
     347                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57767)},
     348                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57787)},
     349                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57782)},
     350                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57786)},
     351                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_9DXX)},
     352                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_9MXX)},
     353                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_ALTIMA, PCI_DEVICE_ID_ALTIMA_AC1000)},
     354                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_ALTIMA, PCI_DEVICE_ID_ALTIMA_AC1001)},
     355                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_ALTIMA, PCI_DEVICE_ID_ALTIMA_AC1003)},
     356                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_ALTIMA, PCI_DEVICE_ID_ALTIMA_AC9100)},
     357                 :            :         {PCI_DEVICE(PCI_VENDOR_ID_APPLE, PCI_DEVICE_ID_APPLE_TIGON3)},
     358                 :            :         {PCI_DEVICE(0x10cf, 0x11a2)}, /* Fujitsu 1000base-SX with BCM5703SKHB */
     359                 :            :         {}
     360                 :            : };
     361                 :            : 
     362                 :            : MODULE_DEVICE_TABLE(pci, tg3_pci_tbl);
     363                 :            : 
     364                 :            : static const struct {
     365                 :            :         const char string[ETH_GSTRING_LEN];
     366                 :            : } ethtool_stats_keys[] = {
     367                 :            :         { "rx_octets" },
     368                 :            :         { "rx_fragments" },
     369                 :            :         { "rx_ucast_packets" },
     370                 :            :         { "rx_mcast_packets" },
     371                 :            :         { "rx_bcast_packets" },
     372                 :            :         { "rx_fcs_errors" },
     373                 :            :         { "rx_align_errors" },
     374                 :            :         { "rx_xon_pause_rcvd" },
     375                 :            :         { "rx_xoff_pause_rcvd" },
     376                 :            :         { "rx_mac_ctrl_rcvd" },
     377                 :            :         { "rx_xoff_entered" },
     378                 :            :         { "rx_frame_too_long_errors" },
     379                 :            :         { "rx_jabbers" },
     380                 :            :         { "rx_undersize_packets" },
     381                 :            :         { "rx_in_length_errors" },
     382                 :            :         { "rx_out_length_errors" },
     383                 :            :         { "rx_64_or_less_octet_packets" },
     384                 :            :         { "rx_65_to_127_octet_packets" },
     385                 :            :         { "rx_128_to_255_octet_packets" },
     386                 :            :         { "rx_256_to_511_octet_packets" },
     387                 :            :         { "rx_512_to_1023_octet_packets" },
     388                 :            :         { "rx_1024_to_1522_octet_packets" },
     389                 :            :         { "rx_1523_to_2047_octet_packets" },
     390                 :            :         { "rx_2048_to_4095_octet_packets" },
     391                 :            :         { "rx_4096_to_8191_octet_packets" },
     392                 :            :         { "rx_8192_to_9022_octet_packets" },
     393                 :            : 
     394                 :            :         { "tx_octets" },
     395                 :            :         { "tx_collisions" },
     396                 :            : 
     397                 :            :         { "tx_xon_sent" },
     398                 :            :         { "tx_xoff_sent" },
     399                 :            :         { "tx_flow_control" },
     400                 :            :         { "tx_mac_errors" },
     401                 :            :         { "tx_single_collisions" },
     402                 :            :         { "tx_mult_collisions" },
     403                 :            :         { "tx_deferred" },
     404                 :            :         { "tx_excessive_collisions" },
     405                 :            :         { "tx_late_collisions" },
     406                 :            :         { "tx_collide_2times" },
     407                 :            :         { "tx_collide_3times" },
     408                 :            :         { "tx_collide_4times" },
     409                 :            :         { "tx_collide_5times" },
     410                 :            :         { "tx_collide_6times" },
     411                 :            :         { "tx_collide_7times" },
     412                 :            :         { "tx_collide_8times" },
     413                 :            :         { "tx_collide_9times" },
     414                 :            :         { "tx_collide_10times" },
     415                 :            :         { "tx_collide_11times" },
     416                 :            :         { "tx_collide_12times" },
     417                 :            :         { "tx_collide_13times" },
     418                 :            :         { "tx_collide_14times" },
     419                 :            :         { "tx_collide_15times" },
     420                 :            :         { "tx_ucast_packets" },
     421                 :            :         { "tx_mcast_packets" },
     422                 :            :         { "tx_bcast_packets" },
     423                 :            :         { "tx_carrier_sense_errors" },
     424                 :            :         { "tx_discards" },
     425                 :            :         { "tx_errors" },
     426                 :            : 
     427                 :            :         { "dma_writeq_full" },
     428                 :            :         { "dma_write_prioq_full" },
     429                 :            :         { "rxbds_empty" },
     430                 :            :         { "rx_discards" },
     431                 :            :         { "rx_errors" },
     432                 :            :         { "rx_threshold_hit" },
     433                 :            : 
     434                 :            :         { "dma_readq_full" },
     435                 :            :         { "dma_read_prioq_full" },
     436                 :            :         { "tx_comp_queue_full" },
     437                 :            : 
     438                 :            :         { "ring_set_send_prod_index" },
     439                 :            :         { "ring_status_update" },
     440                 :            :         { "nic_irqs" },
     441                 :            :         { "nic_avoided_irqs" },
     442                 :            :         { "nic_tx_threshold_hit" },
     443                 :            : 
     444                 :            :         { "mbuf_lwm_thresh_hit" },
     445                 :            : };
     446                 :            : 
     447                 :            : #define TG3_NUM_STATS   ARRAY_SIZE(ethtool_stats_keys)
     448                 :            : #define TG3_NVRAM_TEST          0
     449                 :            : #define TG3_LINK_TEST           1
     450                 :            : #define TG3_REGISTER_TEST       2
     451                 :            : #define TG3_MEMORY_TEST         3
     452                 :            : #define TG3_MAC_LOOPB_TEST      4
     453                 :            : #define TG3_PHY_LOOPB_TEST      5
     454                 :            : #define TG3_EXT_LOOPB_TEST      6
     455                 :            : #define TG3_INTERRUPT_TEST      7
     456                 :            : 
     457                 :            : 
     458                 :            : static const struct {
     459                 :            :         const char string[ETH_GSTRING_LEN];
     460                 :            : } ethtool_test_keys[] = {
     461                 :            :         [TG3_NVRAM_TEST]        = { "nvram test        (online) " },
     462                 :            :         [TG3_LINK_TEST]         = { "link test         (online) " },
     463                 :            :         [TG3_REGISTER_TEST]     = { "register test     (offline)" },
     464                 :            :         [TG3_MEMORY_TEST]       = { "memory test       (offline)" },
     465                 :            :         [TG3_MAC_LOOPB_TEST]    = { "mac loopback test (offline)" },
     466                 :            :         [TG3_PHY_LOOPB_TEST]    = { "phy loopback test (offline)" },
     467                 :            :         [TG3_EXT_LOOPB_TEST]    = { "ext loopback test (offline)" },
     468                 :            :         [TG3_INTERRUPT_TEST]    = { "interrupt test    (offline)" },
     469                 :            : };
     470                 :            : 
     471                 :            : #define TG3_NUM_TEST    ARRAY_SIZE(ethtool_test_keys)
     472                 :            : 
     473                 :            : 
     474                 :          0 : static void tg3_write32(struct tg3 *tp, u32 off, u32 val)
     475                 :            : {
     476                 :          0 :         writel(val, tp->regs + off);
     477                 :          0 : }
     478                 :            : 
     479                 :          0 : static u32 tg3_read32(struct tg3 *tp, u32 off)
     480                 :            : {
     481                 :          0 :         return readl(tp->regs + off);
     482                 :            : }
     483                 :            : 
     484                 :          0 : static void tg3_ape_write32(struct tg3 *tp, u32 off, u32 val)
     485                 :            : {
     486                 :          0 :         writel(val, tp->aperegs + off);
     487                 :          0 : }
     488                 :            : 
     489                 :          0 : static u32 tg3_ape_read32(struct tg3 *tp, u32 off)
     490                 :            : {
     491                 :          0 :         return readl(tp->aperegs + off);
     492                 :            : }
     493                 :            : 
     494                 :          0 : static void tg3_write_indirect_reg32(struct tg3 *tp, u32 off, u32 val)
     495                 :            : {
     496                 :          0 :         unsigned long flags;
     497                 :            : 
     498                 :          0 :         spin_lock_irqsave(&tp->indirect_lock, flags);
     499                 :          0 :         pci_write_config_dword(tp->pdev, TG3PCI_REG_BASE_ADDR, off);
     500                 :          0 :         pci_write_config_dword(tp->pdev, TG3PCI_REG_DATA, val);
     501                 :          0 :         spin_unlock_irqrestore(&tp->indirect_lock, flags);
     502                 :          0 : }
     503                 :            : 
     504                 :          0 : static void tg3_write_flush_reg32(struct tg3 *tp, u32 off, u32 val)
     505                 :            : {
     506                 :          0 :         writel(val, tp->regs + off);
     507                 :          0 :         readl(tp->regs + off);
     508                 :          0 : }
     509                 :            : 
     510                 :          0 : static u32 tg3_read_indirect_reg32(struct tg3 *tp, u32 off)
     511                 :            : {
     512                 :          0 :         unsigned long flags;
     513                 :          0 :         u32 val;
     514                 :            : 
     515                 :          0 :         spin_lock_irqsave(&tp->indirect_lock, flags);
     516                 :          0 :         pci_write_config_dword(tp->pdev, TG3PCI_REG_BASE_ADDR, off);
     517                 :          0 :         pci_read_config_dword(tp->pdev, TG3PCI_REG_DATA, &val);
     518                 :          0 :         spin_unlock_irqrestore(&tp->indirect_lock, flags);
     519                 :          0 :         return val;
     520                 :            : }
     521                 :            : 
     522                 :          0 : static void tg3_write_indirect_mbox(struct tg3 *tp, u32 off, u32 val)
     523                 :            : {
     524                 :          0 :         unsigned long flags;
     525                 :            : 
     526         [ #  # ]:          0 :         if (off == (MAILBOX_RCVRET_CON_IDX_0 + TG3_64BIT_REG_LOW)) {
     527                 :          0 :                 pci_write_config_dword(tp->pdev, TG3PCI_RCV_RET_RING_CON_IDX +
     528                 :            :                                        TG3_64BIT_REG_LOW, val);
     529                 :          0 :                 return;
     530                 :            :         }
     531         [ #  # ]:          0 :         if (off == TG3_RX_STD_PROD_IDX_REG) {
     532                 :          0 :                 pci_write_config_dword(tp->pdev, TG3PCI_STD_RING_PROD_IDX +
     533                 :            :                                        TG3_64BIT_REG_LOW, val);
     534                 :          0 :                 return;
     535                 :            :         }
     536                 :            : 
     537                 :          0 :         spin_lock_irqsave(&tp->indirect_lock, flags);
     538                 :          0 :         pci_write_config_dword(tp->pdev, TG3PCI_REG_BASE_ADDR, off + 0x5600);
     539                 :          0 :         pci_write_config_dword(tp->pdev, TG3PCI_REG_DATA, val);
     540                 :          0 :         spin_unlock_irqrestore(&tp->indirect_lock, flags);
     541                 :            : 
     542                 :            :         /* In indirect mode when disabling interrupts, we also need
     543                 :            :          * to clear the interrupt bit in the GRC local ctrl register.
     544                 :            :          */
     545                 :          0 :         if ((off == (MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW)) &&
     546         [ #  # ]:          0 :             (val == 0x1)) {
     547                 :          0 :                 pci_write_config_dword(tp->pdev, TG3PCI_MISC_LOCAL_CTRL,
     548                 :          0 :                                        tp->grc_local_ctrl|GRC_LCLCTRL_CLEARINT);
     549                 :            :         }
     550                 :            : }
     551                 :            : 
     552                 :          0 : static u32 tg3_read_indirect_mbox(struct tg3 *tp, u32 off)
     553                 :            : {
     554                 :          0 :         unsigned long flags;
     555                 :          0 :         u32 val;
     556                 :            : 
     557                 :          0 :         spin_lock_irqsave(&tp->indirect_lock, flags);
     558                 :          0 :         pci_write_config_dword(tp->pdev, TG3PCI_REG_BASE_ADDR, off + 0x5600);
     559                 :          0 :         pci_read_config_dword(tp->pdev, TG3PCI_REG_DATA, &val);
     560                 :          0 :         spin_unlock_irqrestore(&tp->indirect_lock, flags);
     561                 :          0 :         return val;
     562                 :            : }
     563                 :            : 
     564                 :            : /* usec_wait specifies the wait time in usec when writing to certain registers
     565                 :            :  * where it is unsafe to read back the register without some delay.
     566                 :            :  * GRC_LOCAL_CTRL is one example if the GPIOs are toggled to switch power.
     567                 :            :  * TG3PCI_CLOCK_CTRL is another example if the clock frequencies are changed.
     568                 :            :  */
     569                 :          0 : static void _tw32_flush(struct tg3 *tp, u32 off, u32 val, u32 usec_wait)
     570                 :            : {
     571   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, PCIX_TARGET_HWBUG) || tg3_flag(tp, ICH_WORKAROUND))
     572                 :            :                 /* Non-posted methods */
     573                 :          0 :                 tp->write32(tp, off, val);
     574                 :            :         else {
     575                 :            :                 /* Posted method */
     576                 :          0 :                 tg3_write32(tp, off, val);
     577         [ #  # ]:          0 :                 if (usec_wait)
     578   [ #  #  #  # ]:          0 :                         udelay(usec_wait);
     579                 :          0 :                 tp->read32(tp, off);
     580                 :            :         }
     581                 :            :         /* Wait again after the read for the posted method to guarantee that
     582                 :            :          * the wait time is met.
     583                 :            :          */
     584         [ #  # ]:          0 :         if (usec_wait)
     585   [ #  #  #  # ]:          0 :                 udelay(usec_wait);
     586                 :          0 : }
     587                 :            : 
     588                 :          0 : static inline void tw32_mailbox_flush(struct tg3 *tp, u32 off, u32 val)
     589                 :            : {
     590                 :          0 :         tp->write32_mbox(tp, off, val);
     591   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, FLUSH_POSTED_WRITES) ||
     592         [ #  # ]:          0 :             (!tg3_flag(tp, MBOX_WRITE_REORDER) &&
     593                 :            :              !tg3_flag(tp, ICH_WORKAROUND)))
     594                 :          0 :                 tp->read32_mbox(tp, off);
     595                 :          0 : }
     596                 :            : 
     597                 :          0 : static void tg3_write32_tx_mbox(struct tg3 *tp, u32 off, u32 val)
     598                 :            : {
     599                 :          0 :         void __iomem *mbox = tp->regs + off;
     600                 :          0 :         writel(val, mbox);
     601         [ #  # ]:          0 :         if (tg3_flag(tp, TXD_MBOX_HWBUG))
     602                 :          0 :                 writel(val, mbox);
     603   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, MBOX_WRITE_REORDER) ||
     604                 :            :             tg3_flag(tp, FLUSH_POSTED_WRITES))
     605                 :          0 :                 readl(mbox);
     606                 :          0 : }
     607                 :            : 
     608                 :          0 : static u32 tg3_read32_mbox_5906(struct tg3 *tp, u32 off)
     609                 :            : {
     610                 :          0 :         return readl(tp->regs + off + GRCMBOX_BASE);
     611                 :            : }
     612                 :            : 
     613                 :          0 : static void tg3_write32_mbox_5906(struct tg3 *tp, u32 off, u32 val)
     614                 :            : {
     615                 :          0 :         writel(val, tp->regs + off + GRCMBOX_BASE);
     616                 :          0 : }
     617                 :            : 
     618                 :            : #define tw32_mailbox(reg, val)          tp->write32_mbox(tp, reg, val)
     619                 :            : #define tw32_mailbox_f(reg, val)        tw32_mailbox_flush(tp, (reg), (val))
     620                 :            : #define tw32_rx_mbox(reg, val)          tp->write32_rx_mbox(tp, reg, val)
     621                 :            : #define tw32_tx_mbox(reg, val)          tp->write32_tx_mbox(tp, reg, val)
     622                 :            : #define tr32_mailbox(reg)               tp->read32_mbox(tp, reg)
     623                 :            : 
     624                 :            : #define tw32(reg, val)                  tp->write32(tp, reg, val)
     625                 :            : #define tw32_f(reg, val)                _tw32_flush(tp, (reg), (val), 0)
     626                 :            : #define tw32_wait_f(reg, val, us)       _tw32_flush(tp, (reg), (val), (us))
     627                 :            : #define tr32(reg)                       tp->read32(tp, reg)
     628                 :            : 
     629                 :          0 : static void tg3_write_mem(struct tg3 *tp, u32 off, u32 val)
     630                 :            : {
     631                 :          0 :         unsigned long flags;
     632                 :            : 
     633         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5906 &&
     634         [ #  # ]:          0 :             (off >= NIC_SRAM_STATS_BLK) && (off < NIC_SRAM_TX_BUFFER_DESC))
     635                 :            :                 return;
     636                 :            : 
     637                 :          0 :         spin_lock_irqsave(&tp->indirect_lock, flags);
     638         [ #  # ]:          0 :         if (tg3_flag(tp, SRAM_USE_CONFIG)) {
     639                 :          0 :                 pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, off);
     640                 :          0 :                 pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_DATA, val);
     641                 :            : 
     642                 :            :                 /* Always leave this as zero. */
     643                 :          0 :                 pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, 0);
     644                 :            :         } else {
     645                 :          0 :                 tw32_f(TG3PCI_MEM_WIN_BASE_ADDR, off);
     646                 :          0 :                 tw32_f(TG3PCI_MEM_WIN_DATA, val);
     647                 :            : 
     648                 :            :                 /* Always leave this as zero. */
     649                 :          0 :                 tw32_f(TG3PCI_MEM_WIN_BASE_ADDR, 0);
     650                 :            :         }
     651                 :          0 :         spin_unlock_irqrestore(&tp->indirect_lock, flags);
     652                 :            : }
     653                 :            : 
     654                 :          0 : static void tg3_read_mem(struct tg3 *tp, u32 off, u32 *val)
     655                 :            : {
     656                 :          0 :         unsigned long flags;
     657                 :            : 
     658         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5906 &&
     659         [ #  # ]:          0 :             (off >= NIC_SRAM_STATS_BLK) && (off < NIC_SRAM_TX_BUFFER_DESC)) {
     660                 :          0 :                 *val = 0;
     661                 :          0 :                 return;
     662                 :            :         }
     663                 :            : 
     664                 :          0 :         spin_lock_irqsave(&tp->indirect_lock, flags);
     665         [ #  # ]:          0 :         if (tg3_flag(tp, SRAM_USE_CONFIG)) {
     666                 :          0 :                 pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, off);
     667                 :          0 :                 pci_read_config_dword(tp->pdev, TG3PCI_MEM_WIN_DATA, val);
     668                 :            : 
     669                 :            :                 /* Always leave this as zero. */
     670                 :          0 :                 pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, 0);
     671                 :            :         } else {
     672                 :          0 :                 tw32_f(TG3PCI_MEM_WIN_BASE_ADDR, off);
     673                 :          0 :                 *val = tr32(TG3PCI_MEM_WIN_DATA);
     674                 :            : 
     675                 :            :                 /* Always leave this as zero. */
     676                 :          0 :                 tw32_f(TG3PCI_MEM_WIN_BASE_ADDR, 0);
     677                 :            :         }
     678                 :          0 :         spin_unlock_irqrestore(&tp->indirect_lock, flags);
     679                 :            : }
     680                 :            : 
     681                 :          0 : static void tg3_ape_lock_init(struct tg3 *tp)
     682                 :            : {
     683                 :          0 :         int i;
     684                 :          0 :         u32 regbase, bit;
     685                 :            : 
     686         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5761)
     687                 :            :                 regbase = TG3_APE_LOCK_GRANT;
     688                 :            :         else
     689                 :          0 :                 regbase = TG3_APE_PER_LOCK_GRANT;
     690                 :            : 
     691                 :            :         /* Make sure the driver hasn't any stale locks. */
     692         [ #  # ]:          0 :         for (i = TG3_APE_LOCK_PHY0; i <= TG3_APE_LOCK_GPIO; i++) {
     693         [ #  # ]:          0 :                 switch (i) {
     694                 :            :                 case TG3_APE_LOCK_PHY0:
     695                 :            :                 case TG3_APE_LOCK_PHY1:
     696                 :            :                 case TG3_APE_LOCK_PHY2:
     697                 :            :                 case TG3_APE_LOCK_PHY3:
     698                 :            :                         bit = APE_LOCK_GRANT_DRIVER;
     699                 :            :                         break;
     700                 :          0 :                 default:
     701         [ #  # ]:          0 :                         if (!tp->pci_fn)
     702                 :            :                                 bit = APE_LOCK_GRANT_DRIVER;
     703                 :            :                         else
     704                 :          0 :                                 bit = 1 << tp->pci_fn;
     705                 :            :                 }
     706                 :          0 :                 tg3_ape_write32(tp, regbase + 4 * i, bit);
     707                 :            :         }
     708                 :            : 
     709                 :          0 : }
     710                 :            : 
     711                 :          0 : static int tg3_ape_lock(struct tg3 *tp, int locknum)
     712                 :            : {
     713                 :          0 :         int i, off;
     714                 :          0 :         int ret = 0;
     715                 :          0 :         u32 status, req, gnt, bit;
     716                 :            : 
     717         [ #  # ]:          0 :         if (!tg3_flag(tp, ENABLE_APE))
     718                 :            :                 return 0;
     719                 :            : 
     720   [ #  #  #  # ]:          0 :         switch (locknum) {
     721                 :          0 :         case TG3_APE_LOCK_GPIO:
     722         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5761)
     723                 :            :                         return 0;
     724                 :            :                 /* fall through */
     725                 :            :         case TG3_APE_LOCK_GRC:
     726                 :            :         case TG3_APE_LOCK_MEM:
     727         [ #  # ]:          0 :                 if (!tp->pci_fn)
     728                 :            :                         bit = APE_LOCK_REQ_DRIVER;
     729                 :            :                 else
     730                 :          0 :                         bit = 1 << tp->pci_fn;
     731                 :            :                 break;
     732                 :            :         case TG3_APE_LOCK_PHY0:
     733                 :            :         case TG3_APE_LOCK_PHY1:
     734                 :            :         case TG3_APE_LOCK_PHY2:
     735                 :            :         case TG3_APE_LOCK_PHY3:
     736                 :            :                 bit = APE_LOCK_REQ_DRIVER;
     737                 :            :                 break;
     738                 :            :         default:
     739                 :            :                 return -EINVAL;
     740                 :            :         }
     741                 :            : 
     742         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5761) {
     743                 :            :                 req = TG3_APE_LOCK_REQ;
     744                 :            :                 gnt = TG3_APE_LOCK_GRANT;
     745                 :            :         } else {
     746                 :          0 :                 req = TG3_APE_PER_LOCK_REQ;
     747                 :          0 :                 gnt = TG3_APE_PER_LOCK_GRANT;
     748                 :            :         }
     749                 :            : 
     750                 :          0 :         off = 4 * locknum;
     751                 :            : 
     752                 :          0 :         tg3_ape_write32(tp, req + off, bit);
     753                 :            : 
     754                 :            :         /* Wait for up to 1 millisecond to acquire lock. */
     755         [ #  # ]:          0 :         for (i = 0; i < 100; i++) {
     756                 :          0 :                 status = tg3_ape_read32(tp, gnt + off);
     757         [ #  # ]:          0 :                 if (status == bit)
     758                 :            :                         break;
     759         [ #  # ]:          0 :                 if (pci_channel_offline(tp->pdev))
     760                 :            :                         break;
     761                 :            : 
     762                 :          0 :                 udelay(10);
     763                 :            :         }
     764                 :            : 
     765         [ #  # ]:          0 :         if (status != bit) {
     766                 :            :                 /* Revoke the lock request. */
     767                 :          0 :                 tg3_ape_write32(tp, gnt + off, bit);
     768                 :          0 :                 ret = -EBUSY;
     769                 :            :         }
     770                 :            : 
     771                 :            :         return ret;
     772                 :            : }
     773                 :            : 
     774                 :          0 : static void tg3_ape_unlock(struct tg3 *tp, int locknum)
     775                 :            : {
     776                 :          0 :         u32 gnt, bit;
     777                 :            : 
     778         [ #  # ]:          0 :         if (!tg3_flag(tp, ENABLE_APE))
     779                 :            :                 return;
     780                 :            : 
     781   [ #  #  #  # ]:          0 :         switch (locknum) {
     782                 :          0 :         case TG3_APE_LOCK_GPIO:
     783         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5761)
     784                 :            :                         return;
     785                 :            :                 /* fall through */
     786                 :            :         case TG3_APE_LOCK_GRC:
     787                 :            :         case TG3_APE_LOCK_MEM:
     788         [ #  # ]:          0 :                 if (!tp->pci_fn)
     789                 :            :                         bit = APE_LOCK_GRANT_DRIVER;
     790                 :            :                 else
     791                 :          0 :                         bit = 1 << tp->pci_fn;
     792                 :            :                 break;
     793                 :            :         case TG3_APE_LOCK_PHY0:
     794                 :            :         case TG3_APE_LOCK_PHY1:
     795                 :            :         case TG3_APE_LOCK_PHY2:
     796                 :            :         case TG3_APE_LOCK_PHY3:
     797                 :            :                 bit = APE_LOCK_GRANT_DRIVER;
     798                 :            :                 break;
     799                 :            :         default:
     800                 :            :                 return;
     801                 :            :         }
     802                 :            : 
     803         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5761)
     804                 :            :                 gnt = TG3_APE_LOCK_GRANT;
     805                 :            :         else
     806                 :          0 :                 gnt = TG3_APE_PER_LOCK_GRANT;
     807                 :            : 
     808                 :          0 :         tg3_ape_write32(tp, gnt + 4 * locknum, bit);
     809                 :            : }
     810                 :            : 
     811                 :          0 : static int tg3_ape_event_lock(struct tg3 *tp, u32 timeout_us)
     812                 :            : {
     813                 :          0 :         u32 apedata;
     814                 :            : 
     815         [ #  # ]:          0 :         while (timeout_us) {
     816         [ #  # ]:          0 :                 if (tg3_ape_lock(tp, TG3_APE_LOCK_MEM))
     817                 :            :                         return -EBUSY;
     818                 :            : 
     819                 :          0 :                 apedata = tg3_ape_read32(tp, TG3_APE_EVENT_STATUS);
     820         [ #  # ]:          0 :                 if (!(apedata & APE_EVENT_STATUS_EVENT_PENDING))
     821                 :            :                         break;
     822                 :            : 
     823                 :          0 :                 tg3_ape_unlock(tp, TG3_APE_LOCK_MEM);
     824                 :            : 
     825                 :          0 :                 udelay(10);
     826                 :          0 :                 timeout_us -= (timeout_us > 10) ? 10 : timeout_us;
     827                 :            :         }
     828                 :            : 
     829         [ #  # ]:          0 :         return timeout_us ? 0 : -EBUSY;
     830                 :            : }
     831                 :            : 
     832                 :            : #ifdef CONFIG_TIGON3_HWMON
     833                 :          0 : static int tg3_ape_wait_for_event(struct tg3 *tp, u32 timeout_us)
     834                 :            : {
     835                 :            :         u32 i, apedata;
     836                 :            : 
     837         [ #  # ]:          0 :         for (i = 0; i < timeout_us / 10; i++) {
     838                 :          0 :                 apedata = tg3_ape_read32(tp, TG3_APE_EVENT_STATUS);
     839                 :            : 
     840         [ #  # ]:          0 :                 if (!(apedata & APE_EVENT_STATUS_EVENT_PENDING))
     841                 :            :                         break;
     842                 :            : 
     843                 :          0 :                 udelay(10);
     844                 :            :         }
     845                 :            : 
     846                 :          0 :         return i == timeout_us / 10;
     847                 :            : }
     848                 :            : 
     849                 :          0 : static int tg3_ape_scratchpad_read(struct tg3 *tp, u32 *data, u32 base_off,
     850                 :            :                                    u32 len)
     851                 :            : {
     852                 :          0 :         int err;
     853                 :          0 :         u32 i, bufoff, msgoff, maxlen, apedata;
     854                 :            : 
     855         [ #  # ]:          0 :         if (!tg3_flag(tp, APE_HAS_NCSI))
     856                 :            :                 return 0;
     857                 :            : 
     858                 :          0 :         apedata = tg3_ape_read32(tp, TG3_APE_SEG_SIG);
     859         [ #  # ]:          0 :         if (apedata != APE_SEG_SIG_MAGIC)
     860                 :            :                 return -ENODEV;
     861                 :            : 
     862                 :          0 :         apedata = tg3_ape_read32(tp, TG3_APE_FW_STATUS);
     863         [ #  # ]:          0 :         if (!(apedata & APE_FW_STATUS_READY))
     864                 :            :                 return -EAGAIN;
     865                 :            : 
     866                 :          0 :         bufoff = tg3_ape_read32(tp, TG3_APE_SEG_MSG_BUF_OFF) +
     867                 :            :                  TG3_APE_SHMEM_BASE;
     868                 :          0 :         msgoff = bufoff + 2 * sizeof(u32);
     869                 :          0 :         maxlen = tg3_ape_read32(tp, TG3_APE_SEG_MSG_BUF_LEN);
     870                 :            : 
     871         [ #  # ]:          0 :         while (len) {
     872                 :          0 :                 u32 length;
     873                 :            : 
     874                 :            :                 /* Cap xfer sizes to scratchpad limits. */
     875                 :          0 :                 length = (len > maxlen) ? maxlen : len;
     876                 :          0 :                 len -= length;
     877                 :            : 
     878                 :          0 :                 apedata = tg3_ape_read32(tp, TG3_APE_FW_STATUS);
     879         [ #  # ]:          0 :                 if (!(apedata & APE_FW_STATUS_READY))
     880                 :            :                         return -EAGAIN;
     881                 :            : 
     882                 :            :                 /* Wait for up to 1 msec for APE to service previous event. */
     883                 :          0 :                 err = tg3_ape_event_lock(tp, 1000);
     884         [ #  # ]:          0 :                 if (err)
     885                 :          0 :                         return err;
     886                 :            : 
     887                 :          0 :                 apedata = APE_EVENT_STATUS_DRIVER_EVNT |
     888                 :            :                           APE_EVENT_STATUS_SCRTCHPD_READ |
     889                 :            :                           APE_EVENT_STATUS_EVENT_PENDING;
     890                 :          0 :                 tg3_ape_write32(tp, TG3_APE_EVENT_STATUS, apedata);
     891                 :            : 
     892                 :          0 :                 tg3_ape_write32(tp, bufoff, base_off);
     893                 :          0 :                 tg3_ape_write32(tp, bufoff + sizeof(u32), length);
     894                 :            : 
     895                 :          0 :                 tg3_ape_unlock(tp, TG3_APE_LOCK_MEM);
     896                 :          0 :                 tg3_ape_write32(tp, TG3_APE_EVENT, APE_EVENT_1);
     897                 :            : 
     898                 :          0 :                 base_off += length;
     899                 :            : 
     900         [ #  # ]:          0 :                 if (tg3_ape_wait_for_event(tp, 30000))
     901                 :            :                         return -EAGAIN;
     902                 :            : 
     903         [ #  # ]:          0 :                 for (i = 0; length; i += 4, length -= 4) {
     904                 :          0 :                         u32 val = tg3_ape_read32(tp, msgoff + i);
     905                 :          0 :                         memcpy(data, &val, sizeof(u32));
     906                 :          0 :                         data++;
     907                 :            :                 }
     908                 :            :         }
     909                 :            : 
     910                 :            :         return 0;
     911                 :            : }
     912                 :            : #endif
     913                 :            : 
     914                 :          0 : static int tg3_ape_send_event(struct tg3 *tp, u32 event)
     915                 :            : {
     916                 :          0 :         int err;
     917                 :          0 :         u32 apedata;
     918                 :            : 
     919                 :          0 :         apedata = tg3_ape_read32(tp, TG3_APE_SEG_SIG);
     920         [ #  # ]:          0 :         if (apedata != APE_SEG_SIG_MAGIC)
     921                 :            :                 return -EAGAIN;
     922                 :            : 
     923                 :          0 :         apedata = tg3_ape_read32(tp, TG3_APE_FW_STATUS);
     924         [ #  # ]:          0 :         if (!(apedata & APE_FW_STATUS_READY))
     925                 :            :                 return -EAGAIN;
     926                 :            : 
     927                 :            :         /* Wait for up to 20 millisecond for APE to service previous event. */
     928                 :          0 :         err = tg3_ape_event_lock(tp, 20000);
     929         [ #  # ]:          0 :         if (err)
     930                 :            :                 return err;
     931                 :            : 
     932                 :          0 :         tg3_ape_write32(tp, TG3_APE_EVENT_STATUS,
     933                 :            :                         event | APE_EVENT_STATUS_EVENT_PENDING);
     934                 :            : 
     935                 :          0 :         tg3_ape_unlock(tp, TG3_APE_LOCK_MEM);
     936                 :          0 :         tg3_ape_write32(tp, TG3_APE_EVENT, APE_EVENT_1);
     937                 :            : 
     938                 :          0 :         return 0;
     939                 :            : }
     940                 :            : 
     941                 :          0 : static void tg3_ape_driver_state_change(struct tg3 *tp, int kind)
     942                 :            : {
     943                 :          0 :         u32 event;
     944                 :          0 :         u32 apedata;
     945                 :            : 
     946         [ #  # ]:          0 :         if (!tg3_flag(tp, ENABLE_APE))
     947                 :            :                 return;
     948                 :            : 
     949      [ #  #  # ]:          0 :         switch (kind) {
     950                 :          0 :         case RESET_KIND_INIT:
     951                 :          0 :                 tg3_ape_write32(tp, TG3_APE_HOST_HEARTBEAT_COUNT, tp->ape_hb++);
     952                 :          0 :                 tg3_ape_write32(tp, TG3_APE_HOST_SEG_SIG,
     953                 :            :                                 APE_HOST_SEG_SIG_MAGIC);
     954                 :          0 :                 tg3_ape_write32(tp, TG3_APE_HOST_SEG_LEN,
     955                 :            :                                 APE_HOST_SEG_LEN_MAGIC);
     956                 :          0 :                 apedata = tg3_ape_read32(tp, TG3_APE_HOST_INIT_COUNT);
     957                 :          0 :                 tg3_ape_write32(tp, TG3_APE_HOST_INIT_COUNT, ++apedata);
     958                 :          0 :                 tg3_ape_write32(tp, TG3_APE_HOST_DRIVER_ID,
     959                 :            :                         APE_HOST_DRIVER_ID_MAGIC(TG3_MAJ_NUM, TG3_MIN_NUM));
     960                 :          0 :                 tg3_ape_write32(tp, TG3_APE_HOST_BEHAVIOR,
     961                 :            :                                 APE_HOST_BEHAV_NO_PHYLOCK);
     962                 :          0 :                 tg3_ape_write32(tp, TG3_APE_HOST_DRVR_STATE,
     963                 :            :                                     TG3_APE_HOST_DRVR_STATE_START);
     964                 :            : 
     965                 :          0 :                 event = APE_EVENT_STATUS_STATE_START;
     966                 :          0 :                 break;
     967                 :          0 :         case RESET_KIND_SHUTDOWN:
     968   [ #  #  #  #  :          0 :                 if (device_may_wakeup(&tp->pdev->dev) &&
                   #  # ]
     969                 :            :                     tg3_flag(tp, WOL_ENABLE)) {
     970                 :          0 :                         tg3_ape_write32(tp, TG3_APE_HOST_WOL_SPEED,
     971                 :            :                                             TG3_APE_HOST_WOL_SPEED_AUTO);
     972                 :          0 :                         apedata = TG3_APE_HOST_DRVR_STATE_WOL;
     973                 :            :                 } else
     974                 :            :                         apedata = TG3_APE_HOST_DRVR_STATE_UNLOAD;
     975                 :            : 
     976                 :          0 :                 tg3_ape_write32(tp, TG3_APE_HOST_DRVR_STATE, apedata);
     977                 :            : 
     978                 :          0 :                 event = APE_EVENT_STATUS_STATE_UNLOAD;
     979                 :          0 :                 break;
     980                 :            :         default:
     981                 :            :                 return;
     982                 :            :         }
     983                 :            : 
     984                 :          0 :         event |= APE_EVENT_STATUS_DRIVER_EVNT | APE_EVENT_STATUS_STATE_CHNGE;
     985                 :            : 
     986                 :          0 :         tg3_ape_send_event(tp, event);
     987                 :            : }
     988                 :            : 
     989                 :          0 : static void tg3_send_ape_heartbeat(struct tg3 *tp,
     990                 :            :                                    unsigned long interval)
     991                 :            : {
     992                 :            :         /* Check if hb interval has exceeded */
     993         [ #  # ]:          0 :         if (!tg3_flag(tp, ENABLE_APE) ||
     994         [ #  # ]:          0 :             time_before(jiffies, tp->ape_hb_jiffies + interval))
     995                 :            :                 return;
     996                 :            : 
     997                 :          0 :         tg3_ape_write32(tp, TG3_APE_HOST_HEARTBEAT_COUNT, tp->ape_hb++);
     998                 :          0 :         tp->ape_hb_jiffies = jiffies;
     999                 :            : }
    1000                 :            : 
    1001                 :          0 : static void tg3_disable_ints(struct tg3 *tp)
    1002                 :            : {
    1003                 :          0 :         int i;
    1004                 :            : 
    1005                 :          0 :         tw32(TG3PCI_MISC_HOST_CTRL,
    1006                 :            :              (tp->misc_host_ctrl | MISC_HOST_CTRL_MASK_PCI_INT));
    1007         [ #  # ]:          0 :         for (i = 0; i < tp->irq_max; i++)
    1008                 :          0 :                 tw32_mailbox_f(tp->napi[i].int_mbox, 0x00000001);
    1009                 :          0 : }
    1010                 :            : 
    1011                 :          0 : static void tg3_enable_ints(struct tg3 *tp)
    1012                 :            : {
    1013                 :          0 :         int i;
    1014                 :            : 
    1015                 :          0 :         tp->irq_sync = 0;
    1016                 :          0 :         wmb();
    1017                 :            : 
    1018                 :          0 :         tw32(TG3PCI_MISC_HOST_CTRL,
    1019                 :            :              (tp->misc_host_ctrl & ~MISC_HOST_CTRL_MASK_PCI_INT));
    1020                 :            : 
    1021                 :          0 :         tp->coal_now = tp->coalesce_mode | HOSTCC_MODE_ENABLE;
    1022         [ #  # ]:          0 :         for (i = 0; i < tp->irq_cnt; i++) {
    1023                 :          0 :                 struct tg3_napi *tnapi = &tp->napi[i];
    1024                 :            : 
    1025                 :          0 :                 tw32_mailbox_f(tnapi->int_mbox, tnapi->last_tag << 24);
    1026         [ #  # ]:          0 :                 if (tg3_flag(tp, 1SHOT_MSI))
    1027                 :          0 :                         tw32_mailbox_f(tnapi->int_mbox, tnapi->last_tag << 24);
    1028                 :            : 
    1029                 :          0 :                 tp->coal_now |= tnapi->coal_now;
    1030                 :            :         }
    1031                 :            : 
    1032                 :            :         /* Force an initial interrupt */
    1033         [ #  # ]:          0 :         if (!tg3_flag(tp, TAGGED_STATUS) &&
    1034         [ #  # ]:          0 :             (tp->napi[0].hw_status->status & SD_STATUS_UPDATED))
    1035                 :          0 :                 tw32(GRC_LOCAL_CTRL, tp->grc_local_ctrl | GRC_LCLCTRL_SETINT);
    1036                 :            :         else
    1037                 :          0 :                 tw32(HOSTCC_MODE, tp->coal_now);
    1038                 :            : 
    1039                 :          0 :         tp->coal_now &= ~(tp->napi[0].coal_now | tp->napi[1].coal_now);
    1040                 :          0 : }
    1041                 :            : 
    1042                 :          0 : static inline unsigned int tg3_has_work(struct tg3_napi *tnapi)
    1043                 :            : {
    1044                 :          0 :         struct tg3 *tp = tnapi->tp;
    1045                 :          0 :         struct tg3_hw_status *sblk = tnapi->hw_status;
    1046                 :          0 :         unsigned int work_exists = 0;
    1047                 :            : 
    1048                 :            :         /* check for phy events */
    1049   [ #  #  #  # ]:          0 :         if (!(tg3_flag(tp, USE_LINKCHG_REG) || tg3_flag(tp, POLL_SERDES))) {
    1050         [ #  # ]:          0 :                 if (sblk->status & SD_STATUS_LINK_CHG)
    1051                 :          0 :                         work_exists = 1;
    1052                 :            :         }
    1053                 :            : 
    1054                 :            :         /* check for TX work to do */
    1055         [ #  # ]:          0 :         if (sblk->idx[0].tx_consumer != tnapi->tx_cons)
    1056                 :          0 :                 work_exists = 1;
    1057                 :            : 
    1058                 :            :         /* check for RX work to do */
    1059         [ #  # ]:          0 :         if (tnapi->rx_rcb_prod_idx &&
    1060         [ #  # ]:          0 :             *(tnapi->rx_rcb_prod_idx) != tnapi->rx_rcb_ptr)
    1061                 :          0 :                 work_exists = 1;
    1062                 :            : 
    1063                 :          0 :         return work_exists;
    1064                 :            : }
    1065                 :            : 
    1066                 :            : /* tg3_int_reenable
    1067                 :            :  *  similar to tg3_enable_ints, but it accurately determines whether there
    1068                 :            :  *  is new work pending and can return without flushing the PIO write
    1069                 :            :  *  which reenables interrupts
    1070                 :            :  */
    1071                 :          0 : static void tg3_int_reenable(struct tg3_napi *tnapi)
    1072                 :            : {
    1073                 :          0 :         struct tg3 *tp = tnapi->tp;
    1074                 :            : 
    1075                 :          0 :         tw32_mailbox(tnapi->int_mbox, tnapi->last_tag << 24);
    1076                 :            : 
    1077                 :            :         /* When doing tagged status, this work check is unnecessary.
    1078                 :            :          * The last_tag we write above tells the chip which piece of
    1079                 :            :          * work we've completed.
    1080                 :            :          */
    1081   [ #  #  #  # ]:          0 :         if (!tg3_flag(tp, TAGGED_STATUS) && tg3_has_work(tnapi))
    1082                 :          0 :                 tw32(HOSTCC_MODE, tp->coalesce_mode |
    1083                 :            :                      HOSTCC_MODE_ENABLE | tnapi->coal_now);
    1084                 :          0 : }
    1085                 :            : 
    1086                 :          0 : static void tg3_switch_clocks(struct tg3 *tp)
    1087                 :            : {
    1088                 :          0 :         u32 clock_ctrl;
    1089                 :          0 :         u32 orig_clock_ctrl;
    1090                 :            : 
    1091   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, CPMU_PRESENT) || tg3_flag(tp, 5780_CLASS))
    1092                 :          0 :                 return;
    1093                 :            : 
    1094                 :          0 :         clock_ctrl = tr32(TG3PCI_CLOCK_CTRL);
    1095                 :            : 
    1096                 :          0 :         orig_clock_ctrl = clock_ctrl;
    1097                 :          0 :         clock_ctrl &= (CLOCK_CTRL_FORCE_CLKRUN |
    1098                 :            :                        CLOCK_CTRL_CLKRUN_OENABLE |
    1099                 :            :                        0x1f);
    1100                 :          0 :         tp->pci_clock_ctrl = clock_ctrl;
    1101                 :            : 
    1102         [ #  # ]:          0 :         if (tg3_flag(tp, 5705_PLUS)) {
    1103         [ #  # ]:          0 :                 if (orig_clock_ctrl & CLOCK_CTRL_625_CORE) {
    1104                 :          0 :                         tw32_wait_f(TG3PCI_CLOCK_CTRL,
    1105                 :            :                                     clock_ctrl | CLOCK_CTRL_625_CORE, 40);
    1106                 :            :                 }
    1107         [ #  # ]:          0 :         } else if ((orig_clock_ctrl & CLOCK_CTRL_44MHZ_CORE) != 0) {
    1108                 :          0 :                 tw32_wait_f(TG3PCI_CLOCK_CTRL,
    1109                 :            :                             clock_ctrl |
    1110                 :            :                             (CLOCK_CTRL_44MHZ_CORE | CLOCK_CTRL_ALTCLK),
    1111                 :            :                             40);
    1112                 :          0 :                 tw32_wait_f(TG3PCI_CLOCK_CTRL,
    1113                 :            :                             clock_ctrl | (CLOCK_CTRL_ALTCLK),
    1114                 :            :                             40);
    1115                 :            :         }
    1116                 :          0 :         tw32_wait_f(TG3PCI_CLOCK_CTRL, clock_ctrl, 40);
    1117                 :            : }
    1118                 :            : 
    1119                 :            : #define PHY_BUSY_LOOPS  5000
    1120                 :            : 
    1121                 :          0 : static int __tg3_readphy(struct tg3 *tp, unsigned int phy_addr, int reg,
    1122                 :            :                          u32 *val)
    1123                 :            : {
    1124                 :          0 :         u32 frame_val;
    1125                 :          0 :         unsigned int loops;
    1126                 :          0 :         int ret;
    1127                 :            : 
    1128         [ #  # ]:          0 :         if ((tp->mi_mode & MAC_MI_MODE_AUTO_POLL) != 0) {
    1129                 :          0 :                 tw32_f(MAC_MI_MODE,
    1130                 :            :                      (tp->mi_mode & ~MAC_MI_MODE_AUTO_POLL));
    1131                 :          0 :                 udelay(80);
    1132                 :            :         }
    1133                 :            : 
    1134                 :          0 :         tg3_ape_lock(tp, tp->phy_ape_lock);
    1135                 :            : 
    1136                 :          0 :         *val = 0x0;
    1137                 :            : 
    1138                 :          0 :         frame_val  = ((phy_addr << MI_COM_PHY_ADDR_SHIFT) &
    1139                 :            :                       MI_COM_PHY_ADDR_MASK);
    1140                 :          0 :         frame_val |= ((reg << MI_COM_REG_ADDR_SHIFT) &
    1141                 :            :                       MI_COM_REG_ADDR_MASK);
    1142                 :          0 :         frame_val |= (MI_COM_CMD_READ | MI_COM_START);
    1143                 :            : 
    1144                 :          0 :         tw32_f(MAC_MI_COM, frame_val);
    1145                 :            : 
    1146                 :          0 :         loops = PHY_BUSY_LOOPS;
    1147         [ #  # ]:          0 :         while (loops != 0) {
    1148                 :          0 :                 udelay(10);
    1149                 :          0 :                 frame_val = tr32(MAC_MI_COM);
    1150                 :            : 
    1151         [ #  # ]:          0 :                 if ((frame_val & MI_COM_BUSY) == 0) {
    1152                 :          0 :                         udelay(5);
    1153                 :          0 :                         frame_val = tr32(MAC_MI_COM);
    1154                 :          0 :                         break;
    1155                 :            :                 }
    1156                 :          0 :                 loops -= 1;
    1157                 :            :         }
    1158                 :            : 
    1159                 :          0 :         ret = -EBUSY;
    1160         [ #  # ]:          0 :         if (loops != 0) {
    1161                 :          0 :                 *val = frame_val & MI_COM_DATA_MASK;
    1162                 :          0 :                 ret = 0;
    1163                 :            :         }
    1164                 :            : 
    1165         [ #  # ]:          0 :         if ((tp->mi_mode & MAC_MI_MODE_AUTO_POLL) != 0) {
    1166                 :          0 :                 tw32_f(MAC_MI_MODE, tp->mi_mode);
    1167                 :          0 :                 udelay(80);
    1168                 :            :         }
    1169                 :            : 
    1170                 :          0 :         tg3_ape_unlock(tp, tp->phy_ape_lock);
    1171                 :            : 
    1172                 :          0 :         return ret;
    1173                 :            : }
    1174                 :            : 
    1175                 :          0 : static int tg3_readphy(struct tg3 *tp, int reg, u32 *val)
    1176                 :            : {
    1177                 :          0 :         return __tg3_readphy(tp, tp->phy_addr, reg, val);
    1178                 :            : }
    1179                 :            : 
    1180                 :          0 : static int __tg3_writephy(struct tg3 *tp, unsigned int phy_addr, int reg,
    1181                 :            :                           u32 val)
    1182                 :            : {
    1183                 :          0 :         u32 frame_val;
    1184                 :          0 :         unsigned int loops;
    1185                 :          0 :         int ret;
    1186                 :            : 
    1187         [ #  # ]:          0 :         if ((tp->phy_flags & TG3_PHYFLG_IS_FET) &&
    1188         [ #  # ]:          0 :             (reg == MII_CTRL1000 || reg == MII_TG3_AUX_CTRL))
    1189                 :            :                 return 0;
    1190                 :            : 
    1191         [ #  # ]:          0 :         if ((tp->mi_mode & MAC_MI_MODE_AUTO_POLL) != 0) {
    1192                 :          0 :                 tw32_f(MAC_MI_MODE,
    1193                 :            :                      (tp->mi_mode & ~MAC_MI_MODE_AUTO_POLL));
    1194                 :          0 :                 udelay(80);
    1195                 :            :         }
    1196                 :            : 
    1197                 :          0 :         tg3_ape_lock(tp, tp->phy_ape_lock);
    1198                 :            : 
    1199                 :          0 :         frame_val  = ((phy_addr << MI_COM_PHY_ADDR_SHIFT) &
    1200                 :            :                       MI_COM_PHY_ADDR_MASK);
    1201                 :          0 :         frame_val |= ((reg << MI_COM_REG_ADDR_SHIFT) &
    1202                 :            :                       MI_COM_REG_ADDR_MASK);
    1203                 :          0 :         frame_val |= (val & MI_COM_DATA_MASK);
    1204                 :          0 :         frame_val |= (MI_COM_CMD_WRITE | MI_COM_START);
    1205                 :            : 
    1206                 :          0 :         tw32_f(MAC_MI_COM, frame_val);
    1207                 :            : 
    1208                 :          0 :         loops = PHY_BUSY_LOOPS;
    1209         [ #  # ]:          0 :         while (loops != 0) {
    1210                 :          0 :                 udelay(10);
    1211                 :          0 :                 frame_val = tr32(MAC_MI_COM);
    1212         [ #  # ]:          0 :                 if ((frame_val & MI_COM_BUSY) == 0) {
    1213                 :          0 :                         udelay(5);
    1214                 :          0 :                         frame_val = tr32(MAC_MI_COM);
    1215                 :          0 :                         break;
    1216                 :            :                 }
    1217                 :          0 :                 loops -= 1;
    1218                 :            :         }
    1219                 :            : 
    1220                 :          0 :         ret = -EBUSY;
    1221         [ #  # ]:          0 :         if (loops != 0)
    1222                 :          0 :                 ret = 0;
    1223                 :            : 
    1224         [ #  # ]:          0 :         if ((tp->mi_mode & MAC_MI_MODE_AUTO_POLL) != 0) {
    1225                 :          0 :                 tw32_f(MAC_MI_MODE, tp->mi_mode);
    1226                 :          0 :                 udelay(80);
    1227                 :            :         }
    1228                 :            : 
    1229                 :          0 :         tg3_ape_unlock(tp, tp->phy_ape_lock);
    1230                 :            : 
    1231                 :          0 :         return ret;
    1232                 :            : }
    1233                 :            : 
    1234                 :          0 : static int tg3_writephy(struct tg3 *tp, int reg, u32 val)
    1235                 :            : {
    1236                 :          0 :         return __tg3_writephy(tp, tp->phy_addr, reg, val);
    1237                 :            : }
    1238                 :            : 
    1239                 :          0 : static int tg3_phy_cl45_write(struct tg3 *tp, u32 devad, u32 addr, u32 val)
    1240                 :            : {
    1241                 :          0 :         int err;
    1242                 :            : 
    1243                 :          0 :         err = tg3_writephy(tp, MII_TG3_MMD_CTRL, devad);
    1244         [ #  # ]:          0 :         if (err)
    1245                 :          0 :                 goto done;
    1246                 :            : 
    1247                 :          0 :         err = tg3_writephy(tp, MII_TG3_MMD_ADDRESS, addr);
    1248         [ #  # ]:          0 :         if (err)
    1249                 :          0 :                 goto done;
    1250                 :            : 
    1251                 :          0 :         err = tg3_writephy(tp, MII_TG3_MMD_CTRL,
    1252                 :            :                            MII_TG3_MMD_CTRL_DATA_NOINC | devad);
    1253         [ #  # ]:          0 :         if (err)
    1254                 :          0 :                 goto done;
    1255                 :            : 
    1256                 :          0 :         err = tg3_writephy(tp, MII_TG3_MMD_ADDRESS, val);
    1257                 :            : 
    1258                 :          0 : done:
    1259                 :          0 :         return err;
    1260                 :            : }
    1261                 :            : 
    1262                 :          0 : static int tg3_phy_cl45_read(struct tg3 *tp, u32 devad, u32 addr, u32 *val)
    1263                 :            : {
    1264                 :          0 :         int err;
    1265                 :            : 
    1266                 :          0 :         err = tg3_writephy(tp, MII_TG3_MMD_CTRL, devad);
    1267         [ #  # ]:          0 :         if (err)
    1268                 :          0 :                 goto done;
    1269                 :            : 
    1270                 :          0 :         err = tg3_writephy(tp, MII_TG3_MMD_ADDRESS, addr);
    1271         [ #  # ]:          0 :         if (err)
    1272                 :          0 :                 goto done;
    1273                 :            : 
    1274                 :          0 :         err = tg3_writephy(tp, MII_TG3_MMD_CTRL,
    1275                 :            :                            MII_TG3_MMD_CTRL_DATA_NOINC | devad);
    1276         [ #  # ]:          0 :         if (err)
    1277                 :          0 :                 goto done;
    1278                 :            : 
    1279                 :          0 :         err = tg3_readphy(tp, MII_TG3_MMD_ADDRESS, val);
    1280                 :            : 
    1281                 :          0 : done:
    1282                 :          0 :         return err;
    1283                 :            : }
    1284                 :            : 
    1285                 :          0 : static int tg3_phydsp_read(struct tg3 *tp, u32 reg, u32 *val)
    1286                 :            : {
    1287                 :          0 :         int err;
    1288                 :            : 
    1289                 :          0 :         err = tg3_writephy(tp, MII_TG3_DSP_ADDRESS, reg);
    1290         [ #  # ]:          0 :         if (!err)
    1291                 :          0 :                 err = tg3_readphy(tp, MII_TG3_DSP_RW_PORT, val);
    1292                 :            : 
    1293                 :          0 :         return err;
    1294                 :            : }
    1295                 :            : 
    1296                 :          0 : static int tg3_phydsp_write(struct tg3 *tp, u32 reg, u32 val)
    1297                 :            : {
    1298                 :          0 :         int err;
    1299                 :            : 
    1300                 :          0 :         err = tg3_writephy(tp, MII_TG3_DSP_ADDRESS, reg);
    1301         [ #  # ]:          0 :         if (!err)
    1302                 :          0 :                 err = tg3_writephy(tp, MII_TG3_DSP_RW_PORT, val);
    1303                 :            : 
    1304                 :          0 :         return err;
    1305                 :            : }
    1306                 :            : 
    1307                 :          0 : static int tg3_phy_auxctl_read(struct tg3 *tp, int reg, u32 *val)
    1308                 :            : {
    1309                 :          0 :         int err;
    1310                 :            : 
    1311                 :          0 :         err = tg3_writephy(tp, MII_TG3_AUX_CTRL,
    1312                 :          0 :                            (reg << MII_TG3_AUXCTL_MISC_RDSEL_SHIFT) |
    1313                 :            :                            MII_TG3_AUXCTL_SHDWSEL_MISC);
    1314         [ #  # ]:          0 :         if (!err)
    1315                 :          0 :                 err = tg3_readphy(tp, MII_TG3_AUX_CTRL, val);
    1316                 :            : 
    1317                 :          0 :         return err;
    1318                 :            : }
    1319                 :            : 
    1320                 :          0 : static int tg3_phy_auxctl_write(struct tg3 *tp, int reg, u32 set)
    1321                 :            : {
    1322                 :          0 :         if (reg == MII_TG3_AUXCTL_SHDWSEL_MISC)
    1323                 :          0 :                 set |= MII_TG3_AUXCTL_MISC_WREN;
    1324                 :            : 
    1325                 :          0 :         return tg3_writephy(tp, MII_TG3_AUX_CTRL, set | reg);
    1326                 :            : }
    1327                 :            : 
    1328                 :          0 : static int tg3_phy_toggle_auxctl_smdsp(struct tg3 *tp, bool enable)
    1329                 :            : {
    1330                 :          0 :         u32 val;
    1331                 :          0 :         int err;
    1332                 :            : 
    1333                 :          0 :         err = tg3_phy_auxctl_read(tp, MII_TG3_AUXCTL_SHDWSEL_AUXCTL, &val);
    1334                 :            : 
    1335         [ #  # ]:          0 :         if (err)
    1336                 :            :                 return err;
    1337                 :            : 
    1338         [ #  # ]:          0 :         if (enable)
    1339                 :          0 :                 val |= MII_TG3_AUXCTL_ACTL_SMDSP_ENA;
    1340                 :            :         else
    1341                 :          0 :                 val &= ~MII_TG3_AUXCTL_ACTL_SMDSP_ENA;
    1342                 :            : 
    1343                 :          0 :         err = tg3_phy_auxctl_write((tp), MII_TG3_AUXCTL_SHDWSEL_AUXCTL,
    1344                 :            :                                    val | MII_TG3_AUXCTL_ACTL_TX_6DB);
    1345                 :            : 
    1346                 :          0 :         return err;
    1347                 :            : }
    1348                 :            : 
    1349                 :          0 : static int tg3_phy_shdw_write(struct tg3 *tp, int reg, u32 val)
    1350                 :            : {
    1351                 :          0 :         return tg3_writephy(tp, MII_TG3_MISC_SHDW,
    1352                 :            :                             reg | val | MII_TG3_MISC_SHDW_WREN);
    1353                 :            : }
    1354                 :            : 
    1355                 :          0 : static int tg3_bmcr_reset(struct tg3 *tp)
    1356                 :            : {
    1357                 :          0 :         u32 phy_control;
    1358                 :          0 :         int limit, err;
    1359                 :            : 
    1360                 :            :         /* OK, reset it, and poll the BMCR_RESET bit until it
    1361                 :            :          * clears or we time out.
    1362                 :            :          */
    1363                 :          0 :         phy_control = BMCR_RESET;
    1364                 :          0 :         err = tg3_writephy(tp, MII_BMCR, phy_control);
    1365         [ #  # ]:          0 :         if (err != 0)
    1366                 :            :                 return -EBUSY;
    1367                 :            : 
    1368                 :            :         limit = 5000;
    1369         [ #  # ]:          0 :         while (limit--) {
    1370                 :          0 :                 err = tg3_readphy(tp, MII_BMCR, &phy_control);
    1371         [ #  # ]:          0 :                 if (err != 0)
    1372                 :            :                         return -EBUSY;
    1373                 :            : 
    1374         [ #  # ]:          0 :                 if ((phy_control & BMCR_RESET) == 0) {
    1375                 :          0 :                         udelay(40);
    1376                 :            :                         break;
    1377                 :            :                 }
    1378                 :          0 :                 udelay(10);
    1379                 :            :         }
    1380         [ #  # ]:          0 :         if (limit < 0)
    1381                 :          0 :                 return -EBUSY;
    1382                 :            : 
    1383                 :            :         return 0;
    1384                 :            : }
    1385                 :            : 
    1386                 :          0 : static int tg3_mdio_read(struct mii_bus *bp, int mii_id, int reg)
    1387                 :            : {
    1388                 :          0 :         struct tg3 *tp = bp->priv;
    1389                 :          0 :         u32 val;
    1390                 :            : 
    1391                 :          0 :         spin_lock_bh(&tp->lock);
    1392                 :            : 
    1393         [ #  # ]:          0 :         if (__tg3_readphy(tp, mii_id, reg, &val))
    1394                 :          0 :                 val = -EIO;
    1395                 :            : 
    1396                 :          0 :         spin_unlock_bh(&tp->lock);
    1397                 :            : 
    1398                 :          0 :         return val;
    1399                 :            : }
    1400                 :            : 
    1401                 :          0 : static int tg3_mdio_write(struct mii_bus *bp, int mii_id, int reg, u16 val)
    1402                 :            : {
    1403                 :          0 :         struct tg3 *tp = bp->priv;
    1404                 :          0 :         u32 ret = 0;
    1405                 :            : 
    1406                 :          0 :         spin_lock_bh(&tp->lock);
    1407                 :            : 
    1408         [ #  # ]:          0 :         if (__tg3_writephy(tp, mii_id, reg, val))
    1409                 :          0 :                 ret = -EIO;
    1410                 :            : 
    1411                 :          0 :         spin_unlock_bh(&tp->lock);
    1412                 :            : 
    1413                 :          0 :         return ret;
    1414                 :            : }
    1415                 :            : 
    1416                 :          0 : static void tg3_mdio_config_5785(struct tg3 *tp)
    1417                 :            : {
    1418                 :          0 :         u32 val;
    1419                 :          0 :         struct phy_device *phydev;
    1420                 :            : 
    1421                 :          0 :         phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr);
    1422   [ #  #  #  #  :          0 :         switch (phydev->drv->phy_id & phydev->drv->phy_id_mask) {
                      # ]
    1423                 :            :         case PHY_ID_BCM50610:
    1424                 :            :         case PHY_ID_BCM50610M:
    1425                 :            :                 val = MAC_PHYCFG2_50610_LED_MODES;
    1426                 :            :                 break;
    1427                 :          0 :         case PHY_ID_BCMAC131:
    1428                 :          0 :                 val = MAC_PHYCFG2_AC131_LED_MODES;
    1429                 :          0 :                 break;
    1430                 :          0 :         case PHY_ID_RTL8211C:
    1431                 :          0 :                 val = MAC_PHYCFG2_RTL8211C_LED_MODES;
    1432                 :          0 :                 break;
    1433                 :          0 :         case PHY_ID_RTL8201E:
    1434                 :          0 :                 val = MAC_PHYCFG2_RTL8201E_LED_MODES;
    1435                 :          0 :                 break;
    1436                 :            :         default:
    1437                 :            :                 return;
    1438                 :            :         }
    1439                 :            : 
    1440         [ #  # ]:          0 :         if (phydev->interface != PHY_INTERFACE_MODE_RGMII) {
    1441                 :          0 :                 tw32(MAC_PHYCFG2, val);
    1442                 :            : 
    1443                 :          0 :                 val = tr32(MAC_PHYCFG1);
    1444                 :          0 :                 val &= ~(MAC_PHYCFG1_RGMII_INT |
    1445                 :            :                          MAC_PHYCFG1_RXCLK_TO_MASK | MAC_PHYCFG1_TXCLK_TO_MASK);
    1446                 :          0 :                 val |= MAC_PHYCFG1_RXCLK_TIMEOUT | MAC_PHYCFG1_TXCLK_TIMEOUT;
    1447                 :          0 :                 tw32(MAC_PHYCFG1, val);
    1448                 :            : 
    1449                 :          0 :                 return;
    1450                 :            :         }
    1451                 :            : 
    1452         [ #  # ]:          0 :         if (!tg3_flag(tp, RGMII_INBAND_DISABLE))
    1453                 :          0 :                 val |= MAC_PHYCFG2_EMODE_MASK_MASK |
    1454                 :            :                        MAC_PHYCFG2_FMODE_MASK_MASK |
    1455                 :            :                        MAC_PHYCFG2_GMODE_MASK_MASK |
    1456                 :            :                        MAC_PHYCFG2_ACT_MASK_MASK   |
    1457                 :            :                        MAC_PHYCFG2_QUAL_MASK_MASK |
    1458                 :            :                        MAC_PHYCFG2_INBAND_ENABLE;
    1459                 :            : 
    1460                 :          0 :         tw32(MAC_PHYCFG2, val);
    1461                 :            : 
    1462                 :          0 :         val = tr32(MAC_PHYCFG1);
    1463                 :          0 :         val &= ~(MAC_PHYCFG1_RXCLK_TO_MASK | MAC_PHYCFG1_TXCLK_TO_MASK |
    1464                 :            :                  MAC_PHYCFG1_RGMII_EXT_RX_DEC | MAC_PHYCFG1_RGMII_SND_STAT_EN);
    1465         [ #  # ]:          0 :         if (!tg3_flag(tp, RGMII_INBAND_DISABLE)) {
    1466         [ #  # ]:          0 :                 if (tg3_flag(tp, RGMII_EXT_IBND_RX_EN))
    1467                 :          0 :                         val |= MAC_PHYCFG1_RGMII_EXT_RX_DEC;
    1468         [ #  # ]:          0 :                 if (tg3_flag(tp, RGMII_EXT_IBND_TX_EN))
    1469                 :          0 :                         val |= MAC_PHYCFG1_RGMII_SND_STAT_EN;
    1470                 :            :         }
    1471                 :          0 :         val |= MAC_PHYCFG1_RXCLK_TIMEOUT | MAC_PHYCFG1_TXCLK_TIMEOUT |
    1472                 :            :                MAC_PHYCFG1_RGMII_INT | MAC_PHYCFG1_TXC_DRV;
    1473                 :          0 :         tw32(MAC_PHYCFG1, val);
    1474                 :            : 
    1475                 :          0 :         val = tr32(MAC_EXT_RGMII_MODE);
    1476                 :          0 :         val &= ~(MAC_RGMII_MODE_RX_INT_B |
    1477                 :            :                  MAC_RGMII_MODE_RX_QUALITY |
    1478                 :            :                  MAC_RGMII_MODE_RX_ACTIVITY |
    1479                 :            :                  MAC_RGMII_MODE_RX_ENG_DET |
    1480                 :            :                  MAC_RGMII_MODE_TX_ENABLE |
    1481                 :            :                  MAC_RGMII_MODE_TX_LOWPWR |
    1482                 :            :                  MAC_RGMII_MODE_TX_RESET);
    1483         [ #  # ]:          0 :         if (!tg3_flag(tp, RGMII_INBAND_DISABLE)) {
    1484         [ #  # ]:          0 :                 if (tg3_flag(tp, RGMII_EXT_IBND_RX_EN))
    1485                 :          0 :                         val |= MAC_RGMII_MODE_RX_INT_B |
    1486                 :            :                                MAC_RGMII_MODE_RX_QUALITY |
    1487                 :            :                                MAC_RGMII_MODE_RX_ACTIVITY |
    1488                 :            :                                MAC_RGMII_MODE_RX_ENG_DET;
    1489         [ #  # ]:          0 :                 if (tg3_flag(tp, RGMII_EXT_IBND_TX_EN))
    1490                 :          0 :                         val |= MAC_RGMII_MODE_TX_ENABLE |
    1491                 :            :                                MAC_RGMII_MODE_TX_LOWPWR |
    1492                 :            :                                MAC_RGMII_MODE_TX_RESET;
    1493                 :            :         }
    1494                 :          0 :         tw32(MAC_EXT_RGMII_MODE, val);
    1495                 :            : }
    1496                 :            : 
    1497                 :          0 : static void tg3_mdio_start(struct tg3 *tp)
    1498                 :            : {
    1499                 :          0 :         tp->mi_mode &= ~MAC_MI_MODE_AUTO_POLL;
    1500                 :          0 :         tw32_f(MAC_MI_MODE, tp->mi_mode);
    1501                 :          0 :         udelay(80);
    1502                 :            : 
    1503         [ #  # ]:          0 :         if (tg3_flag(tp, MDIOBUS_INITED) &&
    1504         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5785)
    1505                 :          0 :                 tg3_mdio_config_5785(tp);
    1506                 :          0 : }
    1507                 :            : 
    1508                 :          0 : static int tg3_mdio_init(struct tg3 *tp)
    1509                 :            : {
    1510                 :          0 :         int i;
    1511                 :          0 :         u32 reg;
    1512                 :          0 :         struct phy_device *phydev;
    1513                 :            : 
    1514         [ #  # ]:          0 :         if (tg3_flag(tp, 5717_PLUS)) {
    1515                 :          0 :                 u32 is_serdes;
    1516                 :            : 
    1517                 :          0 :                 tp->phy_addr = tp->pci_fn + 1;
    1518                 :            : 
    1519         [ #  # ]:          0 :                 if (tg3_chip_rev_id(tp) != CHIPREV_ID_5717_A0)
    1520                 :          0 :                         is_serdes = tr32(SG_DIG_STATUS) & SG_DIG_IS_SERDES;
    1521                 :            :                 else
    1522                 :          0 :                         is_serdes = tr32(TG3_CPMU_PHY_STRAP) &
    1523                 :            :                                     TG3_CPMU_PHY_STRAP_IS_SERDES;
    1524         [ #  # ]:          0 :                 if (is_serdes)
    1525                 :          0 :                         tp->phy_addr += 7;
    1526   [ #  #  #  # ]:          0 :         } else if (tg3_flag(tp, IS_SSB_CORE) && tg3_flag(tp, ROBOSWITCH)) {
    1527                 :            :                 int addr;
    1528                 :            : 
    1529                 :            :                 addr = ssb_gige_get_phyaddr(tp->pdev);
    1530                 :            :                 if (addr < 0)
    1531                 :            :                         return addr;
    1532                 :            :                 tp->phy_addr = addr;
    1533                 :            :         } else
    1534                 :          0 :                 tp->phy_addr = TG3_PHY_MII_ADDR;
    1535                 :            : 
    1536                 :          0 :         tg3_mdio_start(tp);
    1537                 :            : 
    1538   [ #  #  #  # ]:          0 :         if (!tg3_flag(tp, USE_PHYLIB) || tg3_flag(tp, MDIOBUS_INITED))
    1539                 :          0 :                 return 0;
    1540                 :            : 
    1541                 :          0 :         tp->mdio_bus = mdiobus_alloc();
    1542         [ #  # ]:          0 :         if (tp->mdio_bus == NULL)
    1543                 :            :                 return -ENOMEM;
    1544                 :            : 
    1545                 :          0 :         tp->mdio_bus->name     = "tg3 mdio bus";
    1546                 :          0 :         snprintf(tp->mdio_bus->id, MII_BUS_ID_SIZE, "%x",
    1547                 :          0 :                  (tp->pdev->bus->number << 8) | tp->pdev->devfn);
    1548                 :          0 :         tp->mdio_bus->priv     = tp;
    1549                 :          0 :         tp->mdio_bus->parent   = &tp->pdev->dev;
    1550                 :          0 :         tp->mdio_bus->read     = &tg3_mdio_read;
    1551                 :          0 :         tp->mdio_bus->write    = &tg3_mdio_write;
    1552                 :          0 :         tp->mdio_bus->phy_mask = ~(1 << tp->phy_addr);
    1553                 :            : 
    1554                 :            :         /* The bus registration will look for all the PHYs on the mdio bus.
    1555                 :            :          * Unfortunately, it does not ensure the PHY is powered up before
    1556                 :            :          * accessing the PHY ID registers.  A chip reset is the
    1557                 :            :          * quickest way to bring the device back to an operational state..
    1558                 :            :          */
    1559   [ #  #  #  # ]:          0 :         if (tg3_readphy(tp, MII_BMCR, &reg) || (reg & BMCR_PDOWN))
    1560                 :          0 :                 tg3_bmcr_reset(tp);
    1561                 :            : 
    1562                 :          0 :         i = mdiobus_register(tp->mdio_bus);
    1563         [ #  # ]:          0 :         if (i) {
    1564                 :          0 :                 dev_warn(&tp->pdev->dev, "mdiobus_reg failed (0x%x)\n", i);
    1565                 :          0 :                 mdiobus_free(tp->mdio_bus);
    1566                 :          0 :                 return i;
    1567                 :            :         }
    1568                 :            : 
    1569                 :          0 :         phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr);
    1570                 :            : 
    1571   [ #  #  #  # ]:          0 :         if (!phydev || !phydev->drv) {
    1572                 :          0 :                 dev_warn(&tp->pdev->dev, "No PHY devices\n");
    1573                 :          0 :                 mdiobus_unregister(tp->mdio_bus);
    1574                 :          0 :                 mdiobus_free(tp->mdio_bus);
    1575                 :          0 :                 return -ENODEV;
    1576                 :            :         }
    1577                 :            : 
    1578   [ #  #  #  #  :          0 :         switch (phydev->drv->phy_id & phydev->drv->phy_id_mask) {
                      # ]
    1579                 :          0 :         case PHY_ID_BCM57780:
    1580                 :          0 :                 phydev->interface = PHY_INTERFACE_MODE_GMII;
    1581                 :          0 :                 phydev->dev_flags |= PHY_BRCM_AUTO_PWRDWN_ENABLE;
    1582                 :          0 :                 break;
    1583                 :          0 :         case PHY_ID_BCM50610:
    1584                 :            :         case PHY_ID_BCM50610M:
    1585                 :          0 :                 phydev->dev_flags |= PHY_BRCM_CLEAR_RGMII_MODE |
    1586                 :            :                                      PHY_BRCM_RX_REFCLK_UNUSED |
    1587                 :            :                                      PHY_BRCM_DIS_TXCRXC_NOENRGY |
    1588                 :            :                                      PHY_BRCM_AUTO_PWRDWN_ENABLE;
    1589         [ #  # ]:          0 :                 if (tg3_flag(tp, RGMII_INBAND_DISABLE))
    1590                 :          0 :                         phydev->dev_flags |= PHY_BRCM_STD_IBND_DISABLE;
    1591         [ #  # ]:          0 :                 if (tg3_flag(tp, RGMII_EXT_IBND_RX_EN))
    1592                 :          0 :                         phydev->dev_flags |= PHY_BRCM_EXT_IBND_RX_ENABLE;
    1593         [ #  # ]:          0 :                 if (tg3_flag(tp, RGMII_EXT_IBND_TX_EN))
    1594                 :          0 :                         phydev->dev_flags |= PHY_BRCM_EXT_IBND_TX_ENABLE;
    1595                 :            :                 /* fall through */
    1596                 :            :         case PHY_ID_RTL8211C:
    1597                 :          0 :                 phydev->interface = PHY_INTERFACE_MODE_RGMII;
    1598                 :          0 :                 break;
    1599                 :          0 :         case PHY_ID_RTL8201E:
    1600                 :            :         case PHY_ID_BCMAC131:
    1601                 :          0 :                 phydev->interface = PHY_INTERFACE_MODE_MII;
    1602                 :          0 :                 phydev->dev_flags |= PHY_BRCM_AUTO_PWRDWN_ENABLE;
    1603                 :          0 :                 tp->phy_flags |= TG3_PHYFLG_IS_FET;
    1604                 :          0 :                 break;
    1605                 :            :         }
    1606                 :            : 
    1607                 :          0 :         tg3_flag_set(tp, MDIOBUS_INITED);
    1608                 :            : 
    1609         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5785)
    1610                 :          0 :                 tg3_mdio_config_5785(tp);
    1611                 :            : 
    1612                 :            :         return 0;
    1613                 :            : }
    1614                 :            : 
    1615                 :          0 : static void tg3_mdio_fini(struct tg3 *tp)
    1616                 :            : {
    1617         [ #  # ]:          0 :         if (tg3_flag(tp, MDIOBUS_INITED)) {
    1618                 :          0 :                 tg3_flag_clear(tp, MDIOBUS_INITED);
    1619                 :          0 :                 mdiobus_unregister(tp->mdio_bus);
    1620                 :          0 :                 mdiobus_free(tp->mdio_bus);
    1621                 :            :         }
    1622                 :          0 : }
    1623                 :            : 
    1624                 :            : /* tp->lock is held. */
    1625                 :          0 : static inline void tg3_generate_fw_event(struct tg3 *tp)
    1626                 :            : {
    1627                 :          0 :         u32 val;
    1628                 :            : 
    1629                 :          0 :         val = tr32(GRC_RX_CPU_EVENT);
    1630                 :          0 :         val |= GRC_RX_CPU_DRIVER_EVENT;
    1631                 :          0 :         tw32_f(GRC_RX_CPU_EVENT, val);
    1632                 :            : 
    1633                 :          0 :         tp->last_event_jiffies = jiffies;
    1634                 :          0 : }
    1635                 :            : 
    1636                 :            : #define TG3_FW_EVENT_TIMEOUT_USEC 2500
    1637                 :            : 
    1638                 :            : /* tp->lock is held. */
    1639                 :          0 : static void tg3_wait_for_event_ack(struct tg3 *tp)
    1640                 :            : {
    1641                 :          0 :         int i;
    1642                 :          0 :         unsigned int delay_cnt;
    1643                 :          0 :         long time_remain;
    1644                 :            : 
    1645                 :            :         /* If enough time has passed, no wait is necessary. */
    1646                 :          0 :         time_remain = (long)(tp->last_event_jiffies + 1 +
    1647                 :          0 :                       usecs_to_jiffies(TG3_FW_EVENT_TIMEOUT_USEC)) -
    1648                 :            :                       (long)jiffies;
    1649         [ #  # ]:          0 :         if (time_remain < 0)
    1650                 :            :                 return;
    1651                 :            : 
    1652                 :            :         /* Check if we can shorten the wait time. */
    1653                 :          0 :         delay_cnt = jiffies_to_usecs(time_remain);
    1654                 :          0 :         if (delay_cnt > TG3_FW_EVENT_TIMEOUT_USEC)
    1655                 :            :                 delay_cnt = TG3_FW_EVENT_TIMEOUT_USEC;
    1656                 :          0 :         delay_cnt = (delay_cnt >> 3) + 1;
    1657                 :            : 
    1658         [ #  # ]:          0 :         for (i = 0; i < delay_cnt; i++) {
    1659         [ #  # ]:          0 :                 if (!(tr32(GRC_RX_CPU_EVENT) & GRC_RX_CPU_DRIVER_EVENT))
    1660                 :            :                         break;
    1661         [ #  # ]:          0 :                 if (pci_channel_offline(tp->pdev))
    1662                 :            :                         break;
    1663                 :            : 
    1664                 :          0 :                 udelay(8);
    1665                 :            :         }
    1666                 :            : }
    1667                 :            : 
    1668                 :            : /* tp->lock is held. */
    1669                 :          0 : static void tg3_phy_gather_ump_data(struct tg3 *tp, u32 *data)
    1670                 :            : {
    1671                 :          0 :         u32 reg, val;
    1672                 :            : 
    1673                 :          0 :         val = 0;
    1674         [ #  # ]:          0 :         if (!tg3_readphy(tp, MII_BMCR, &reg))
    1675                 :          0 :                 val = reg << 16;
    1676         [ #  # ]:          0 :         if (!tg3_readphy(tp, MII_BMSR, &reg))
    1677                 :          0 :                 val |= (reg & 0xffff);
    1678                 :          0 :         *data++ = val;
    1679                 :            : 
    1680                 :          0 :         val = 0;
    1681         [ #  # ]:          0 :         if (!tg3_readphy(tp, MII_ADVERTISE, &reg))
    1682                 :          0 :                 val = reg << 16;
    1683         [ #  # ]:          0 :         if (!tg3_readphy(tp, MII_LPA, &reg))
    1684                 :          0 :                 val |= (reg & 0xffff);
    1685                 :          0 :         *data++ = val;
    1686                 :            : 
    1687                 :          0 :         val = 0;
    1688         [ #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_MII_SERDES)) {
    1689         [ #  # ]:          0 :                 if (!tg3_readphy(tp, MII_CTRL1000, &reg))
    1690                 :          0 :                         val = reg << 16;
    1691         [ #  # ]:          0 :                 if (!tg3_readphy(tp, MII_STAT1000, &reg))
    1692                 :          0 :                         val |= (reg & 0xffff);
    1693                 :            :         }
    1694                 :          0 :         *data++ = val;
    1695                 :            : 
    1696         [ #  # ]:          0 :         if (!tg3_readphy(tp, MII_PHYADDR, &reg))
    1697                 :          0 :                 val = reg << 16;
    1698                 :            :         else
    1699                 :            :                 val = 0;
    1700                 :          0 :         *data++ = val;
    1701                 :          0 : }
    1702                 :            : 
    1703                 :            : /* tp->lock is held. */
    1704                 :          0 : static void tg3_ump_link_report(struct tg3 *tp)
    1705                 :            : {
    1706                 :          0 :         u32 data[4];
    1707                 :            : 
    1708   [ #  #  #  # ]:          0 :         if (!tg3_flag(tp, 5780_CLASS) || !tg3_flag(tp, ENABLE_ASF))
    1709                 :          0 :                 return;
    1710                 :            : 
    1711                 :          0 :         tg3_phy_gather_ump_data(tp, data);
    1712                 :            : 
    1713                 :          0 :         tg3_wait_for_event_ack(tp);
    1714                 :            : 
    1715                 :          0 :         tg3_write_mem(tp, NIC_SRAM_FW_CMD_MBOX, FWCMD_NICDRV_LINK_UPDATE);
    1716                 :          0 :         tg3_write_mem(tp, NIC_SRAM_FW_CMD_LEN_MBOX, 14);
    1717                 :          0 :         tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0x0, data[0]);
    1718                 :          0 :         tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0x4, data[1]);
    1719                 :          0 :         tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0x8, data[2]);
    1720                 :          0 :         tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0xc, data[3]);
    1721                 :            : 
    1722                 :          0 :         tg3_generate_fw_event(tp);
    1723                 :            : }
    1724                 :            : 
    1725                 :            : /* tp->lock is held. */
    1726                 :          0 : static void tg3_stop_fw(struct tg3 *tp)
    1727                 :            : {
    1728   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, ENABLE_ASF) && !tg3_flag(tp, ENABLE_APE)) {
    1729                 :            :                 /* Wait for RX cpu to ACK the previous event. */
    1730                 :          0 :                 tg3_wait_for_event_ack(tp);
    1731                 :            : 
    1732                 :          0 :                 tg3_write_mem(tp, NIC_SRAM_FW_CMD_MBOX, FWCMD_NICDRV_PAUSE_FW);
    1733                 :            : 
    1734                 :          0 :                 tg3_generate_fw_event(tp);
    1735                 :            : 
    1736                 :            :                 /* Wait for RX cpu to ACK this event. */
    1737                 :          0 :                 tg3_wait_for_event_ack(tp);
    1738                 :            :         }
    1739                 :          0 : }
    1740                 :            : 
    1741                 :            : /* tp->lock is held. */
    1742                 :          0 : static void tg3_write_sig_pre_reset(struct tg3 *tp, int kind)
    1743                 :            : {
    1744                 :          0 :         tg3_write_mem(tp, NIC_SRAM_FIRMWARE_MBOX,
    1745                 :            :                       NIC_SRAM_FIRMWARE_MBOX_MAGIC1);
    1746                 :            : 
    1747         [ #  # ]:          0 :         if (tg3_flag(tp, ASF_NEW_HANDSHAKE)) {
    1748   [ #  #  #  # ]:          0 :                 switch (kind) {
    1749                 :          0 :                 case RESET_KIND_INIT:
    1750                 :          0 :                         tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
    1751                 :            :                                       DRV_STATE_START);
    1752                 :          0 :                         break;
    1753                 :            : 
    1754                 :          0 :                 case RESET_KIND_SHUTDOWN:
    1755                 :          0 :                         tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
    1756                 :            :                                       DRV_STATE_UNLOAD);
    1757                 :          0 :                         break;
    1758                 :            : 
    1759                 :          0 :                 case RESET_KIND_SUSPEND:
    1760                 :          0 :                         tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
    1761                 :            :                                       DRV_STATE_SUSPEND);
    1762                 :          0 :                         break;
    1763                 :            : 
    1764                 :            :                 default:
    1765                 :            :                         break;
    1766                 :            :                 }
    1767                 :          0 :         }
    1768                 :          0 : }
    1769                 :            : 
    1770                 :            : /* tp->lock is held. */
    1771                 :          0 : static void tg3_write_sig_post_reset(struct tg3 *tp, int kind)
    1772                 :            : {
    1773         [ #  # ]:          0 :         if (tg3_flag(tp, ASF_NEW_HANDSHAKE)) {
    1774      [ #  #  # ]:          0 :                 switch (kind) {
    1775                 :          0 :                 case RESET_KIND_INIT:
    1776                 :          0 :                         tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
    1777                 :            :                                       DRV_STATE_START_DONE);
    1778                 :          0 :                         break;
    1779                 :            : 
    1780                 :          0 :                 case RESET_KIND_SHUTDOWN:
    1781                 :          0 :                         tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
    1782                 :            :                                       DRV_STATE_UNLOAD_DONE);
    1783                 :          0 :                         break;
    1784                 :            : 
    1785                 :            :                 default:
    1786                 :            :                         break;
    1787                 :            :                 }
    1788                 :          0 :         }
    1789                 :          0 : }
    1790                 :            : 
    1791                 :            : /* tp->lock is held. */
    1792                 :          0 : static void tg3_write_sig_legacy(struct tg3 *tp, int kind)
    1793                 :            : {
    1794         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_ASF)) {
    1795   [ #  #  #  # ]:          0 :                 switch (kind) {
    1796                 :          0 :                 case RESET_KIND_INIT:
    1797                 :          0 :                         tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
    1798                 :            :                                       DRV_STATE_START);
    1799                 :          0 :                         break;
    1800                 :            : 
    1801                 :          0 :                 case RESET_KIND_SHUTDOWN:
    1802                 :          0 :                         tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
    1803                 :            :                                       DRV_STATE_UNLOAD);
    1804                 :          0 :                         break;
    1805                 :            : 
    1806                 :          0 :                 case RESET_KIND_SUSPEND:
    1807                 :          0 :                         tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
    1808                 :            :                                       DRV_STATE_SUSPEND);
    1809                 :          0 :                         break;
    1810                 :            : 
    1811                 :            :                 default:
    1812                 :            :                         break;
    1813                 :            :                 }
    1814                 :          0 :         }
    1815                 :          0 : }
    1816                 :            : 
    1817                 :          0 : static int tg3_poll_fw(struct tg3 *tp)
    1818                 :            : {
    1819                 :          0 :         int i;
    1820                 :          0 :         u32 val;
    1821                 :            : 
    1822         [ #  # ]:          0 :         if (tg3_flag(tp, NO_FWARE_REPORTED))
    1823                 :            :                 return 0;
    1824                 :            : 
    1825         [ #  # ]:          0 :         if (tg3_flag(tp, IS_SSB_CORE)) {
    1826                 :            :                 /* We don't use firmware. */
    1827                 :            :                 return 0;
    1828                 :            :         }
    1829                 :            : 
    1830         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5906) {
    1831                 :            :                 /* Wait up to 20ms for init done. */
    1832         [ #  # ]:          0 :                 for (i = 0; i < 200; i++) {
    1833         [ #  # ]:          0 :                         if (tr32(VCPU_STATUS) & VCPU_STATUS_INIT_DONE)
    1834                 :            :                                 return 0;
    1835         [ #  # ]:          0 :                         if (pci_channel_offline(tp->pdev))
    1836                 :            :                                 return -ENODEV;
    1837                 :            : 
    1838                 :          0 :                         udelay(100);
    1839                 :            :                 }
    1840                 :            :                 return -ENODEV;
    1841                 :            :         }
    1842                 :            : 
    1843                 :            :         /* Wait for firmware initialization to complete. */
    1844         [ #  # ]:          0 :         for (i = 0; i < 100000; i++) {
    1845                 :          0 :                 tg3_read_mem(tp, NIC_SRAM_FIRMWARE_MBOX, &val);
    1846         [ #  # ]:          0 :                 if (val == ~NIC_SRAM_FIRMWARE_MBOX_MAGIC1)
    1847                 :            :                         break;
    1848         [ #  # ]:          0 :                 if (pci_channel_offline(tp->pdev)) {
    1849         [ #  # ]:          0 :                         if (!tg3_flag(tp, NO_FWARE_REPORTED)) {
    1850                 :          0 :                                 tg3_flag_set(tp, NO_FWARE_REPORTED);
    1851                 :          0 :                                 netdev_info(tp->dev, "No firmware running\n");
    1852                 :            :                         }
    1853                 :            : 
    1854                 :            :                         break;
    1855                 :            :                 }
    1856                 :            : 
    1857                 :          0 :                 udelay(10);
    1858                 :            :         }
    1859                 :            : 
    1860                 :            :         /* Chip might not be fitted with firmware.  Some Sun onboard
    1861                 :            :          * parts are configured like that.  So don't signal the timeout
    1862                 :            :          * of the above loop as an error, but do report the lack of
    1863                 :            :          * running firmware once.
    1864                 :            :          */
    1865   [ #  #  #  # ]:          0 :         if (i >= 100000 && !tg3_flag(tp, NO_FWARE_REPORTED)) {
    1866                 :          0 :                 tg3_flag_set(tp, NO_FWARE_REPORTED);
    1867                 :            : 
    1868                 :          0 :                 netdev_info(tp->dev, "No firmware running\n");
    1869                 :            :         }
    1870                 :            : 
    1871         [ #  # ]:          0 :         if (tg3_chip_rev_id(tp) == CHIPREV_ID_57765_A0) {
    1872                 :            :                 /* The 57765 A0 needs a little more
    1873                 :            :                  * time to do some important work.
    1874                 :            :                  */
    1875         [ #  # ]:          0 :                 mdelay(10);
    1876                 :            :         }
    1877                 :            : 
    1878                 :            :         return 0;
    1879                 :            : }
    1880                 :            : 
    1881                 :          0 : static void tg3_link_report(struct tg3 *tp)
    1882                 :            : {
    1883         [ #  # ]:          0 :         if (!netif_carrier_ok(tp->dev)) {
    1884         [ #  # ]:          0 :                 netif_info(tp, link, tp->dev, "Link is down\n");
    1885                 :          0 :                 tg3_ump_link_report(tp);
    1886         [ #  # ]:          0 :         } else if (netif_msg_link(tp)) {
    1887                 :          0 :                 netdev_info(tp->dev, "Link is up at %d Mbps, %s duplex\n",
    1888         [ #  # ]:          0 :                             (tp->link_config.active_speed == SPEED_1000 ?
    1889                 :            :                              1000 :
    1890                 :            :                              (tp->link_config.active_speed == SPEED_100 ?
    1891         [ #  # ]:          0 :                               100 : 10)),
    1892         [ #  # ]:          0 :                             (tp->link_config.active_duplex == DUPLEX_FULL ?
    1893                 :            :                              "full" : "half"));
    1894                 :            : 
    1895         [ #  # ]:          0 :                 netdev_info(tp->dev, "Flow control is %s for TX and %s for RX\n",
    1896                 :            :                             (tp->link_config.active_flowctrl & FLOW_CTRL_TX) ?
    1897                 :            :                             "on" : "off",
    1898         [ #  # ]:          0 :                             (tp->link_config.active_flowctrl & FLOW_CTRL_RX) ?
    1899                 :            :                             "on" : "off");
    1900                 :            : 
    1901         [ #  # ]:          0 :                 if (tp->phy_flags & TG3_PHYFLG_EEE_CAP)
    1902                 :          0 :                         netdev_info(tp->dev, "EEE is %s\n",
    1903         [ #  # ]:          0 :                                     tp->setlpicnt ? "enabled" : "disabled");
    1904                 :            : 
    1905                 :          0 :                 tg3_ump_link_report(tp);
    1906                 :            :         }
    1907                 :            : 
    1908                 :          0 :         tp->link_up = netif_carrier_ok(tp->dev);
    1909                 :          0 : }
    1910                 :            : 
    1911                 :          0 : static u32 tg3_decode_flowctrl_1000T(u32 adv)
    1912                 :            : {
    1913                 :          0 :         u32 flowctrl = 0;
    1914                 :            : 
    1915                 :          0 :         if (adv & ADVERTISE_PAUSE_CAP) {
    1916                 :          0 :                 flowctrl |= FLOW_CTRL_RX;
    1917         [ #  # ]:          0 :                 if (!(adv & ADVERTISE_PAUSE_ASYM))
    1918                 :          0 :                         flowctrl |= FLOW_CTRL_TX;
    1919         [ #  # ]:          0 :         } else if (adv & ADVERTISE_PAUSE_ASYM)
    1920                 :          0 :                 flowctrl |= FLOW_CTRL_TX;
    1921                 :            : 
    1922                 :          0 :         return flowctrl;
    1923                 :            : }
    1924                 :            : 
    1925                 :          0 : static u16 tg3_advert_flowctrl_1000X(u8 flow_ctrl)
    1926                 :            : {
    1927                 :          0 :         u16 miireg;
    1928                 :            : 
    1929                 :          0 :         if ((flow_ctrl & FLOW_CTRL_TX) && (flow_ctrl & FLOW_CTRL_RX))
    1930                 :            :                 miireg = ADVERTISE_1000XPAUSE;
    1931   [ #  #  #  #  :          0 :         else if (flow_ctrl & FLOW_CTRL_TX)
                   #  # ]
    1932                 :            :                 miireg = ADVERTISE_1000XPSE_ASYM;
    1933   [ #  #  #  #  :          0 :         else if (flow_ctrl & FLOW_CTRL_RX)
                   #  # ]
    1934                 :            :                 miireg = ADVERTISE_1000XPAUSE | ADVERTISE_1000XPSE_ASYM;
    1935                 :            :         else
    1936                 :          0 :                 miireg = 0;
    1937                 :            : 
    1938                 :          0 :         return miireg;
    1939                 :            : }
    1940                 :            : 
    1941                 :          0 : static u32 tg3_decode_flowctrl_1000X(u32 adv)
    1942                 :            : {
    1943                 :          0 :         u32 flowctrl = 0;
    1944                 :            : 
    1945                 :          0 :         if (adv & ADVERTISE_1000XPAUSE) {
    1946                 :          0 :                 flowctrl |= FLOW_CTRL_RX;
    1947         [ #  # ]:          0 :                 if (!(adv & ADVERTISE_1000XPSE_ASYM))
    1948                 :          0 :                         flowctrl |= FLOW_CTRL_TX;
    1949         [ #  # ]:          0 :         } else if (adv & ADVERTISE_1000XPSE_ASYM)
    1950                 :          0 :                 flowctrl |= FLOW_CTRL_TX;
    1951                 :            : 
    1952                 :          0 :         return flowctrl;
    1953                 :            : }
    1954                 :            : 
    1955                 :          0 : static u8 tg3_resolve_flowctrl_1000X(u16 lcladv, u16 rmtadv)
    1956                 :            : {
    1957                 :          0 :         u8 cap = 0;
    1958                 :            : 
    1959                 :          0 :         if (lcladv & rmtadv & ADVERTISE_1000XPAUSE) {
    1960                 :            :                 cap = FLOW_CTRL_TX | FLOW_CTRL_RX;
    1961         [ #  # ]:          0 :         } else if (lcladv & rmtadv & ADVERTISE_1000XPSE_ASYM) {
    1962         [ #  # ]:          0 :                 if (lcladv & ADVERTISE_1000XPAUSE)
    1963                 :          0 :                         cap = FLOW_CTRL_RX;
    1964         [ #  # ]:          0 :                 if (rmtadv & ADVERTISE_1000XPAUSE)
    1965                 :          0 :                         cap = FLOW_CTRL_TX;
    1966                 :            :         }
    1967                 :            : 
    1968                 :            :         return cap;
    1969                 :            : }
    1970                 :            : 
    1971                 :          0 : static void tg3_setup_flow_control(struct tg3 *tp, u32 lcladv, u32 rmtadv)
    1972                 :            : {
    1973                 :          0 :         u8 autoneg;
    1974                 :          0 :         u8 flowctrl = 0;
    1975                 :          0 :         u32 old_rx_mode = tp->rx_mode;
    1976                 :          0 :         u32 old_tx_mode = tp->tx_mode;
    1977                 :            : 
    1978         [ #  # ]:          0 :         if (tg3_flag(tp, USE_PHYLIB))
    1979                 :          0 :                 autoneg = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr)->autoneg;
    1980                 :            :         else
    1981                 :          0 :                 autoneg = tp->link_config.autoneg;
    1982                 :            : 
    1983   [ #  #  #  # ]:          0 :         if (autoneg == AUTONEG_ENABLE && tg3_flag(tp, PAUSE_AUTONEG)) {
    1984         [ #  # ]:          0 :                 if (tp->phy_flags & TG3_PHYFLG_ANY_SERDES)
    1985         [ #  # ]:          0 :                         flowctrl = tg3_resolve_flowctrl_1000X(lcladv, rmtadv);
    1986                 :            :                 else
    1987         [ #  # ]:          0 :                         flowctrl = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
    1988                 :            :         } else
    1989                 :          0 :                 flowctrl = tp->link_config.flowctrl;
    1990                 :            : 
    1991                 :          0 :         tp->link_config.active_flowctrl = flowctrl;
    1992                 :            : 
    1993         [ #  # ]:          0 :         if (flowctrl & FLOW_CTRL_RX)
    1994                 :          0 :                 tp->rx_mode |= RX_MODE_FLOW_CTRL_ENABLE;
    1995                 :            :         else
    1996                 :          0 :                 tp->rx_mode &= ~RX_MODE_FLOW_CTRL_ENABLE;
    1997                 :            : 
    1998         [ #  # ]:          0 :         if (old_rx_mode != tp->rx_mode)
    1999                 :          0 :                 tw32_f(MAC_RX_MODE, tp->rx_mode);
    2000                 :            : 
    2001         [ #  # ]:          0 :         if (flowctrl & FLOW_CTRL_TX)
    2002                 :          0 :                 tp->tx_mode |= TX_MODE_FLOW_CTRL_ENABLE;
    2003                 :            :         else
    2004                 :          0 :                 tp->tx_mode &= ~TX_MODE_FLOW_CTRL_ENABLE;
    2005                 :            : 
    2006         [ #  # ]:          0 :         if (old_tx_mode != tp->tx_mode)
    2007                 :          0 :                 tw32_f(MAC_TX_MODE, tp->tx_mode);
    2008                 :          0 : }
    2009                 :            : 
    2010                 :          0 : static void tg3_adjust_link(struct net_device *dev)
    2011                 :            : {
    2012                 :          0 :         u8 oldflowctrl, linkmesg = 0;
    2013                 :          0 :         u32 mac_mode, lcl_adv, rmt_adv;
    2014                 :          0 :         struct tg3 *tp = netdev_priv(dev);
    2015                 :          0 :         struct phy_device *phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr);
    2016                 :            : 
    2017                 :          0 :         spin_lock_bh(&tp->lock);
    2018                 :            : 
    2019                 :          0 :         mac_mode = tp->mac_mode & ~(MAC_MODE_PORT_MODE_MASK |
    2020                 :            :                                     MAC_MODE_HALF_DUPLEX);
    2021                 :            : 
    2022                 :          0 :         oldflowctrl = tp->link_config.active_flowctrl;
    2023                 :            : 
    2024         [ #  # ]:          0 :         if (phydev->link) {
    2025                 :          0 :                 lcl_adv = 0;
    2026                 :          0 :                 rmt_adv = 0;
    2027                 :            : 
    2028         [ #  # ]:          0 :                 if (phydev->speed == SPEED_100 || phydev->speed == SPEED_10)
    2029                 :          0 :                         mac_mode |= MAC_MODE_PORT_MODE_MII;
    2030         [ #  # ]:          0 :                 else if (phydev->speed == SPEED_1000 ||
    2031         [ #  # ]:          0 :                          tg3_asic_rev(tp) != ASIC_REV_5785)
    2032                 :          0 :                         mac_mode |= MAC_MODE_PORT_MODE_GMII;
    2033                 :            :                 else
    2034                 :          0 :                         mac_mode |= MAC_MODE_PORT_MODE_MII;
    2035                 :            : 
    2036         [ #  # ]:          0 :                 if (phydev->duplex == DUPLEX_HALF)
    2037                 :          0 :                         mac_mode |= MAC_MODE_HALF_DUPLEX;
    2038                 :            :                 else {
    2039                 :          0 :                         lcl_adv = mii_advertise_flowctrl(
    2040         [ #  # ]:          0 :                                   tp->link_config.flowctrl);
    2041                 :            : 
    2042         [ #  # ]:          0 :                         if (phydev->pause)
    2043                 :          0 :                                 rmt_adv = LPA_PAUSE_CAP;
    2044         [ #  # ]:          0 :                         if (phydev->asym_pause)
    2045                 :          0 :                                 rmt_adv |= LPA_PAUSE_ASYM;
    2046                 :            :                 }
    2047                 :            : 
    2048                 :          0 :                 tg3_setup_flow_control(tp, lcl_adv, rmt_adv);
    2049                 :            :         } else
    2050                 :          0 :                 mac_mode |= MAC_MODE_PORT_MODE_GMII;
    2051                 :            : 
    2052         [ #  # ]:          0 :         if (mac_mode != tp->mac_mode) {
    2053                 :          0 :                 tp->mac_mode = mac_mode;
    2054                 :          0 :                 tw32_f(MAC_MODE, tp->mac_mode);
    2055                 :          0 :                 udelay(40);
    2056                 :            :         }
    2057                 :            : 
    2058         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5785) {
    2059         [ #  # ]:          0 :                 if (phydev->speed == SPEED_10)
    2060                 :          0 :                         tw32(MAC_MI_STAT,
    2061                 :            :                              MAC_MI_STAT_10MBPS_MODE |
    2062                 :            :                              MAC_MI_STAT_LNKSTAT_ATTN_ENAB);
    2063                 :            :                 else
    2064                 :          0 :                         tw32(MAC_MI_STAT, MAC_MI_STAT_LNKSTAT_ATTN_ENAB);
    2065                 :            :         }
    2066                 :            : 
    2067         [ #  # ]:          0 :         if (phydev->speed == SPEED_1000 && phydev->duplex == DUPLEX_HALF)
    2068                 :          0 :                 tw32(MAC_TX_LENGTHS,
    2069                 :            :                      ((2 << TX_LENGTHS_IPG_CRS_SHIFT) |
    2070                 :            :                       (6 << TX_LENGTHS_IPG_SHIFT) |
    2071                 :            :                       (0xff << TX_LENGTHS_SLOT_TIME_SHIFT)));
    2072                 :            :         else
    2073                 :          0 :                 tw32(MAC_TX_LENGTHS,
    2074                 :            :                      ((2 << TX_LENGTHS_IPG_CRS_SHIFT) |
    2075                 :            :                       (6 << TX_LENGTHS_IPG_SHIFT) |
    2076                 :            :                       (32 << TX_LENGTHS_SLOT_TIME_SHIFT)));
    2077                 :            : 
    2078         [ #  # ]:          0 :         if (phydev->link != tp->old_link ||
    2079         [ #  # ]:          0 :             phydev->speed != tp->link_config.active_speed ||
    2080         [ #  # ]:          0 :             phydev->duplex != tp->link_config.active_duplex ||
    2081         [ #  # ]:          0 :             oldflowctrl != tp->link_config.active_flowctrl)
    2082                 :          0 :                 linkmesg = 1;
    2083                 :            : 
    2084                 :          0 :         tp->old_link = phydev->link;
    2085                 :          0 :         tp->link_config.active_speed = phydev->speed;
    2086                 :          0 :         tp->link_config.active_duplex = phydev->duplex;
    2087                 :            : 
    2088                 :          0 :         spin_unlock_bh(&tp->lock);
    2089                 :            : 
    2090         [ #  # ]:          0 :         if (linkmesg)
    2091                 :          0 :                 tg3_link_report(tp);
    2092                 :          0 : }
    2093                 :            : 
    2094                 :          0 : static int tg3_phy_init(struct tg3 *tp)
    2095                 :            : {
    2096                 :          0 :         struct phy_device *phydev;
    2097                 :            : 
    2098         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_IS_CONNECTED)
    2099                 :            :                 return 0;
    2100                 :            : 
    2101                 :            :         /* Bring the PHY back to a known state. */
    2102                 :          0 :         tg3_bmcr_reset(tp);
    2103                 :            : 
    2104                 :          0 :         phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr);
    2105                 :            : 
    2106                 :            :         /* Attach the MAC to the PHY. */
    2107         [ #  # ]:          0 :         phydev = phy_connect(tp->dev, phydev_name(phydev),
    2108                 :            :                              tg3_adjust_link, phydev->interface);
    2109         [ #  # ]:          0 :         if (IS_ERR(phydev)) {
    2110                 :          0 :                 dev_err(&tp->pdev->dev, "Could not attach to PHY\n");
    2111                 :          0 :                 return PTR_ERR(phydev);
    2112                 :            :         }
    2113                 :            : 
    2114                 :            :         /* Mask with MAC supported features. */
    2115      [ #  #  # ]:          0 :         switch (phydev->interface) {
    2116                 :          0 :         case PHY_INTERFACE_MODE_GMII:
    2117                 :            :         case PHY_INTERFACE_MODE_RGMII:
    2118         [ #  # ]:          0 :                 if (!(tp->phy_flags & TG3_PHYFLG_10_100_ONLY)) {
    2119                 :          0 :                         phy_set_max_speed(phydev, SPEED_1000);
    2120                 :          0 :                         phy_support_asym_pause(phydev);
    2121                 :          0 :                         break;
    2122                 :            :                 }
    2123                 :            :                 /* fall through */
    2124                 :            :         case PHY_INTERFACE_MODE_MII:
    2125                 :          0 :                 phy_set_max_speed(phydev, SPEED_100);
    2126                 :          0 :                 phy_support_asym_pause(phydev);
    2127                 :          0 :                 break;
    2128                 :          0 :         default:
    2129                 :          0 :                 phy_disconnect(mdiobus_get_phy(tp->mdio_bus, tp->phy_addr));
    2130                 :          0 :                 return -EINVAL;
    2131                 :            :         }
    2132                 :            : 
    2133                 :          0 :         tp->phy_flags |= TG3_PHYFLG_IS_CONNECTED;
    2134                 :            : 
    2135                 :          0 :         phy_attached_info(phydev);
    2136                 :            : 
    2137                 :          0 :         return 0;
    2138                 :            : }
    2139                 :            : 
    2140                 :          0 : static void tg3_phy_start(struct tg3 *tp)
    2141                 :            : {
    2142                 :          0 :         struct phy_device *phydev;
    2143                 :            : 
    2144         [ #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_IS_CONNECTED))
    2145                 :            :                 return;
    2146                 :            : 
    2147                 :          0 :         phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr);
    2148                 :            : 
    2149         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_IS_LOW_POWER) {
    2150                 :          0 :                 tp->phy_flags &= ~TG3_PHYFLG_IS_LOW_POWER;
    2151                 :          0 :                 phydev->speed = tp->link_config.speed;
    2152                 :          0 :                 phydev->duplex = tp->link_config.duplex;
    2153                 :          0 :                 phydev->autoneg = tp->link_config.autoneg;
    2154                 :          0 :                 ethtool_convert_legacy_u32_to_link_mode(
    2155                 :          0 :                         phydev->advertising, tp->link_config.advertising);
    2156                 :            :         }
    2157                 :            : 
    2158                 :          0 :         phy_start(phydev);
    2159                 :            : 
    2160                 :          0 :         phy_start_aneg(phydev);
    2161                 :            : }
    2162                 :            : 
    2163                 :          0 : static void tg3_phy_stop(struct tg3 *tp)
    2164                 :            : {
    2165         [ #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_IS_CONNECTED))
    2166                 :            :                 return;
    2167                 :            : 
    2168                 :          0 :         phy_stop(mdiobus_get_phy(tp->mdio_bus, tp->phy_addr));
    2169                 :            : }
    2170                 :            : 
    2171                 :          0 : static void tg3_phy_fini(struct tg3 *tp)
    2172                 :            : {
    2173         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_IS_CONNECTED) {
    2174                 :          0 :                 phy_disconnect(mdiobus_get_phy(tp->mdio_bus, tp->phy_addr));
    2175                 :          0 :                 tp->phy_flags &= ~TG3_PHYFLG_IS_CONNECTED;
    2176                 :            :         }
    2177                 :          0 : }
    2178                 :            : 
    2179                 :          0 : static int tg3_phy_set_extloopbk(struct tg3 *tp)
    2180                 :            : {
    2181                 :          0 :         int err;
    2182                 :          0 :         u32 val;
    2183                 :            : 
    2184         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_IS_FET)
    2185                 :            :                 return 0;
    2186                 :            : 
    2187         [ #  # ]:          0 :         if ((tp->phy_id & TG3_PHY_ID_MASK) == TG3_PHY_ID_BCM5401) {
    2188                 :            :                 /* Cannot do read-modify-write on 5401 */
    2189                 :          0 :                 err = tg3_phy_auxctl_write(tp,
    2190                 :            :                                            MII_TG3_AUXCTL_SHDWSEL_AUXCTL,
    2191                 :            :                                            MII_TG3_AUXCTL_ACTL_EXTLOOPBK |
    2192                 :            :                                            0x4c20);
    2193                 :          0 :                 goto done;
    2194                 :            :         }
    2195                 :            : 
    2196                 :          0 :         err = tg3_phy_auxctl_read(tp,
    2197                 :            :                                   MII_TG3_AUXCTL_SHDWSEL_AUXCTL, &val);
    2198         [ #  # ]:          0 :         if (err)
    2199                 :            :                 return err;
    2200                 :            : 
    2201                 :          0 :         val |= MII_TG3_AUXCTL_ACTL_EXTLOOPBK;
    2202                 :          0 :         err = tg3_phy_auxctl_write(tp,
    2203                 :            :                                    MII_TG3_AUXCTL_SHDWSEL_AUXCTL, val);
    2204                 :            : 
    2205                 :            : done:
    2206                 :            :         return err;
    2207                 :            : }
    2208                 :            : 
    2209                 :          0 : static void tg3_phy_fet_toggle_apd(struct tg3 *tp, bool enable)
    2210                 :            : {
    2211                 :          0 :         u32 phytest;
    2212                 :            : 
    2213         [ #  # ]:          0 :         if (!tg3_readphy(tp, MII_TG3_FET_TEST, &phytest)) {
    2214                 :          0 :                 u32 phy;
    2215                 :            : 
    2216                 :          0 :                 tg3_writephy(tp, MII_TG3_FET_TEST,
    2217                 :            :                              phytest | MII_TG3_FET_SHADOW_EN);
    2218         [ #  # ]:          0 :                 if (!tg3_readphy(tp, MII_TG3_FET_SHDW_AUXSTAT2, &phy)) {
    2219         [ #  # ]:          0 :                         if (enable)
    2220                 :          0 :                                 phy |= MII_TG3_FET_SHDW_AUXSTAT2_APD;
    2221                 :            :                         else
    2222                 :          0 :                                 phy &= ~MII_TG3_FET_SHDW_AUXSTAT2_APD;
    2223                 :          0 :                         tg3_writephy(tp, MII_TG3_FET_SHDW_AUXSTAT2, phy);
    2224                 :            :                 }
    2225                 :          0 :                 tg3_writephy(tp, MII_TG3_FET_TEST, phytest);
    2226                 :            :         }
    2227                 :          0 : }
    2228                 :            : 
    2229                 :          0 : static void tg3_phy_toggle_apd(struct tg3 *tp, bool enable)
    2230                 :            : {
    2231                 :          0 :         u32 reg;
    2232                 :            : 
    2233   [ #  #  #  # ]:          0 :         if (!tg3_flag(tp, 5705_PLUS) ||
    2234                 :          0 :             (tg3_flag(tp, 5717_PLUS) &&
    2235         [ #  # ]:          0 :              (tp->phy_flags & TG3_PHYFLG_MII_SERDES)))
    2236                 :          0 :                 return;
    2237                 :            : 
    2238         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_IS_FET) {
    2239                 :          0 :                 tg3_phy_fet_toggle_apd(tp, enable);
    2240                 :          0 :                 return;
    2241                 :            :         }
    2242                 :            : 
    2243                 :          0 :         reg = MII_TG3_MISC_SHDW_SCR5_LPED |
    2244                 :            :               MII_TG3_MISC_SHDW_SCR5_DLPTLM |
    2245                 :            :               MII_TG3_MISC_SHDW_SCR5_SDTL |
    2246                 :            :               MII_TG3_MISC_SHDW_SCR5_C125OE;
    2247   [ #  #  #  # ]:          0 :         if (tg3_asic_rev(tp) != ASIC_REV_5784 || !enable)
    2248                 :          0 :                 reg |= MII_TG3_MISC_SHDW_SCR5_DLLAPD;
    2249                 :            : 
    2250                 :          0 :         tg3_phy_shdw_write(tp, MII_TG3_MISC_SHDW_SCR5_SEL, reg);
    2251                 :            : 
    2252                 :            : 
    2253                 :          0 :         reg = MII_TG3_MISC_SHDW_APD_WKTM_84MS;
    2254         [ #  # ]:          0 :         if (enable)
    2255                 :          0 :                 reg |= MII_TG3_MISC_SHDW_APD_ENABLE;
    2256                 :            : 
    2257                 :          0 :         tg3_phy_shdw_write(tp, MII_TG3_MISC_SHDW_APD_SEL, reg);
    2258                 :            : }
    2259                 :            : 
    2260                 :          0 : static void tg3_phy_toggle_automdix(struct tg3 *tp, bool enable)
    2261                 :            : {
    2262                 :          0 :         u32 phy;
    2263                 :            : 
    2264         [ #  # ]:          0 :         if (!tg3_flag(tp, 5705_PLUS) ||
    2265         [ #  # ]:          0 :             (tp->phy_flags & TG3_PHYFLG_ANY_SERDES))
    2266                 :          0 :                 return;
    2267                 :            : 
    2268         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_IS_FET) {
    2269                 :          0 :                 u32 ephy;
    2270                 :            : 
    2271         [ #  # ]:          0 :                 if (!tg3_readphy(tp, MII_TG3_FET_TEST, &ephy)) {
    2272                 :          0 :                         u32 reg = MII_TG3_FET_SHDW_MISCCTRL;
    2273                 :            : 
    2274                 :          0 :                         tg3_writephy(tp, MII_TG3_FET_TEST,
    2275                 :            :                                      ephy | MII_TG3_FET_SHADOW_EN);
    2276         [ #  # ]:          0 :                         if (!tg3_readphy(tp, reg, &phy)) {
    2277         [ #  # ]:          0 :                                 if (enable)
    2278                 :          0 :                                         phy |= MII_TG3_FET_SHDW_MISCCTRL_MDIX;
    2279                 :            :                                 else
    2280                 :          0 :                                         phy &= ~MII_TG3_FET_SHDW_MISCCTRL_MDIX;
    2281                 :          0 :                                 tg3_writephy(tp, reg, phy);
    2282                 :            :                         }
    2283                 :          0 :                         tg3_writephy(tp, MII_TG3_FET_TEST, ephy);
    2284                 :            :                 }
    2285                 :            :         } else {
    2286                 :          0 :                 int ret;
    2287                 :            : 
    2288                 :          0 :                 ret = tg3_phy_auxctl_read(tp,
    2289                 :            :                                           MII_TG3_AUXCTL_SHDWSEL_MISC, &phy);
    2290         [ #  # ]:          0 :                 if (!ret) {
    2291         [ #  # ]:          0 :                         if (enable)
    2292                 :          0 :                                 phy |= MII_TG3_AUXCTL_MISC_FORCE_AMDIX;
    2293                 :            :                         else
    2294                 :          0 :                                 phy &= ~MII_TG3_AUXCTL_MISC_FORCE_AMDIX;
    2295                 :          0 :                         tg3_phy_auxctl_write(tp,
    2296                 :            :                                              MII_TG3_AUXCTL_SHDWSEL_MISC, phy);
    2297                 :            :                 }
    2298                 :            :         }
    2299                 :            : }
    2300                 :            : 
    2301                 :          0 : static void tg3_phy_set_wirespeed(struct tg3 *tp)
    2302                 :            : {
    2303                 :          0 :         int ret;
    2304                 :          0 :         u32 val;
    2305                 :            : 
    2306         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_NO_ETH_WIRE_SPEED)
    2307                 :          0 :                 return;
    2308                 :            : 
    2309                 :          0 :         ret = tg3_phy_auxctl_read(tp, MII_TG3_AUXCTL_SHDWSEL_MISC, &val);
    2310         [ #  # ]:          0 :         if (!ret)
    2311                 :          0 :                 tg3_phy_auxctl_write(tp, MII_TG3_AUXCTL_SHDWSEL_MISC,
    2312                 :            :                                      val | MII_TG3_AUXCTL_MISC_WIRESPD_EN);
    2313                 :            : }
    2314                 :            : 
    2315                 :          0 : static void tg3_phy_apply_otp(struct tg3 *tp)
    2316                 :            : {
    2317                 :          0 :         u32 otp, phy;
    2318                 :            : 
    2319         [ #  # ]:          0 :         if (!tp->phy_otp)
    2320                 :            :                 return;
    2321                 :            : 
    2322                 :          0 :         otp = tp->phy_otp;
    2323                 :            : 
    2324         [ #  # ]:          0 :         if (tg3_phy_toggle_auxctl_smdsp(tp, true))
    2325                 :            :                 return;
    2326                 :            : 
    2327                 :          0 :         phy = ((otp & TG3_OTP_AGCTGT_MASK) >> TG3_OTP_AGCTGT_SHIFT);
    2328                 :          0 :         phy |= MII_TG3_DSP_TAP1_AGCTGT_DFLT;
    2329                 :          0 :         tg3_phydsp_write(tp, MII_TG3_DSP_TAP1, phy);
    2330                 :            : 
    2331                 :          0 :         phy = ((otp & TG3_OTP_HPFFLTR_MASK) >> TG3_OTP_HPFFLTR_SHIFT) |
    2332                 :            :               ((otp & TG3_OTP_HPFOVER_MASK) >> TG3_OTP_HPFOVER_SHIFT);
    2333                 :          0 :         tg3_phydsp_write(tp, MII_TG3_DSP_AADJ1CH0, phy);
    2334                 :            : 
    2335                 :          0 :         phy = ((otp & TG3_OTP_LPFDIS_MASK) >> TG3_OTP_LPFDIS_SHIFT);
    2336                 :          0 :         phy |= MII_TG3_DSP_AADJ1CH3_ADCCKADJ;
    2337                 :          0 :         tg3_phydsp_write(tp, MII_TG3_DSP_AADJ1CH3, phy);
    2338                 :            : 
    2339                 :          0 :         phy = ((otp & TG3_OTP_VDAC_MASK) >> TG3_OTP_VDAC_SHIFT);
    2340                 :          0 :         tg3_phydsp_write(tp, MII_TG3_DSP_EXP75, phy);
    2341                 :            : 
    2342                 :          0 :         phy = ((otp & TG3_OTP_10BTAMP_MASK) >> TG3_OTP_10BTAMP_SHIFT);
    2343                 :          0 :         tg3_phydsp_write(tp, MII_TG3_DSP_EXP96, phy);
    2344                 :            : 
    2345                 :          0 :         phy = ((otp & TG3_OTP_ROFF_MASK) >> TG3_OTP_ROFF_SHIFT) |
    2346                 :          0 :               ((otp & TG3_OTP_RCOFF_MASK) >> TG3_OTP_RCOFF_SHIFT);
    2347                 :          0 :         tg3_phydsp_write(tp, MII_TG3_DSP_EXP97, phy);
    2348                 :            : 
    2349                 :          0 :         tg3_phy_toggle_auxctl_smdsp(tp, false);
    2350                 :            : }
    2351                 :            : 
    2352                 :          0 : static void tg3_eee_pull_config(struct tg3 *tp, struct ethtool_eee *eee)
    2353                 :            : {
    2354                 :          0 :         u32 val;
    2355                 :          0 :         struct ethtool_eee *dest = &tp->eee;
    2356                 :            : 
    2357         [ #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_EEE_CAP))
    2358                 :          0 :                 return;
    2359                 :            : 
    2360         [ #  # ]:          0 :         if (eee)
    2361                 :          0 :                 dest = eee;
    2362                 :            : 
    2363         [ #  # ]:          0 :         if (tg3_phy_cl45_read(tp, MDIO_MMD_AN, TG3_CL45_D7_EEERES_STAT, &val))
    2364                 :            :                 return;
    2365                 :            : 
    2366                 :            :         /* Pull eee_active */
    2367         [ #  # ]:          0 :         if (val == TG3_CL45_D7_EEERES_STAT_LP_1000T ||
    2368                 :            :             val == TG3_CL45_D7_EEERES_STAT_LP_100TX) {
    2369                 :          0 :                 dest->eee_active = 1;
    2370                 :            :         } else
    2371                 :          0 :                 dest->eee_active = 0;
    2372                 :            : 
    2373                 :            :         /* Pull lp advertised settings */
    2374         [ #  # ]:          0 :         if (tg3_phy_cl45_read(tp, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE, &val))
    2375                 :            :                 return;
    2376                 :          0 :         dest->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val);
    2377                 :            : 
    2378                 :            :         /* Pull advertised and eee_enabled settings */
    2379         [ #  # ]:          0 :         if (tg3_phy_cl45_read(tp, MDIO_MMD_AN, MDIO_AN_EEE_ADV, &val))
    2380                 :            :                 return;
    2381                 :          0 :         dest->eee_enabled = !!val;
    2382                 :          0 :         dest->advertised = mmd_eee_adv_to_ethtool_adv_t(val);
    2383                 :            : 
    2384                 :            :         /* Pull tx_lpi_enabled */
    2385                 :          0 :         val = tr32(TG3_CPMU_EEE_MODE);
    2386                 :          0 :         dest->tx_lpi_enabled = !!(val & TG3_CPMU_EEEMD_LPI_IN_TX);
    2387                 :            : 
    2388                 :            :         /* Pull lpi timer value */
    2389                 :          0 :         dest->tx_lpi_timer = tr32(TG3_CPMU_EEE_DBTMR1) & 0xffff;
    2390                 :            : }
    2391                 :            : 
    2392                 :          0 : static void tg3_phy_eee_adjust(struct tg3 *tp, bool current_link_up)
    2393                 :            : {
    2394                 :          0 :         u32 val;
    2395                 :            : 
    2396         [ #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_EEE_CAP))
    2397                 :            :                 return;
    2398                 :            : 
    2399                 :          0 :         tp->setlpicnt = 0;
    2400                 :            : 
    2401   [ #  #  #  # ]:          0 :         if (tp->link_config.autoneg == AUTONEG_ENABLE &&
    2402                 :          0 :             current_link_up &&
    2403         [ #  # ]:          0 :             tp->link_config.active_duplex == DUPLEX_FULL &&
    2404         [ #  # ]:          0 :             (tp->link_config.active_speed == SPEED_100 ||
    2405                 :            :              tp->link_config.active_speed == SPEED_1000)) {
    2406                 :          0 :                 u32 eeectl;
    2407                 :            : 
    2408         [ #  # ]:          0 :                 if (tp->link_config.active_speed == SPEED_1000)
    2409                 :            :                         eeectl = TG3_CPMU_EEE_CTRL_EXIT_16_5_US;
    2410                 :            :                 else
    2411                 :          0 :                         eeectl = TG3_CPMU_EEE_CTRL_EXIT_36_US;
    2412                 :            : 
    2413                 :          0 :                 tw32(TG3_CPMU_EEE_CTRL, eeectl);
    2414                 :            : 
    2415                 :          0 :                 tg3_eee_pull_config(tp, NULL);
    2416         [ #  # ]:          0 :                 if (tp->eee.eee_active)
    2417                 :          0 :                         tp->setlpicnt = 2;
    2418                 :            :         }
    2419                 :            : 
    2420         [ #  # ]:          0 :         if (!tp->setlpicnt) {
    2421   [ #  #  #  # ]:          0 :                 if (current_link_up &&
    2422                 :          0 :                    !tg3_phy_toggle_auxctl_smdsp(tp, true)) {
    2423                 :          0 :                         tg3_phydsp_write(tp, MII_TG3_DSP_TAP26, 0x0000);
    2424                 :          0 :                         tg3_phy_toggle_auxctl_smdsp(tp, false);
    2425                 :            :                 }
    2426                 :            : 
    2427                 :          0 :                 val = tr32(TG3_CPMU_EEE_MODE);
    2428                 :          0 :                 tw32(TG3_CPMU_EEE_MODE, val & ~TG3_CPMU_EEEMD_LPI_ENABLE);
    2429                 :            :         }
    2430                 :            : }
    2431                 :            : 
    2432                 :          0 : static void tg3_phy_eee_enable(struct tg3 *tp)
    2433                 :            : {
    2434                 :          0 :         u32 val;
    2435                 :            : 
    2436         [ #  # ]:          0 :         if (tp->link_config.active_speed == SPEED_1000 &&
    2437         [ #  # ]:          0 :             (tg3_asic_rev(tp) == ASIC_REV_5717 ||
    2438         [ #  # ]:          0 :              tg3_asic_rev(tp) == ASIC_REV_5719 ||
    2439         [ #  # ]:          0 :              tg3_flag(tp, 57765_CLASS)) &&
    2440                 :          0 :             !tg3_phy_toggle_auxctl_smdsp(tp, true)) {
    2441                 :          0 :                 val = MII_TG3_DSP_TAP26_ALNOKO |
    2442                 :            :                       MII_TG3_DSP_TAP26_RMRXSTO;
    2443                 :          0 :                 tg3_phydsp_write(tp, MII_TG3_DSP_TAP26, val);
    2444                 :          0 :                 tg3_phy_toggle_auxctl_smdsp(tp, false);
    2445                 :            :         }
    2446                 :            : 
    2447                 :          0 :         val = tr32(TG3_CPMU_EEE_MODE);
    2448                 :          0 :         tw32(TG3_CPMU_EEE_MODE, val | TG3_CPMU_EEEMD_LPI_ENABLE);
    2449                 :          0 : }
    2450                 :            : 
    2451                 :          0 : static int tg3_wait_macro_done(struct tg3 *tp)
    2452                 :            : {
    2453                 :          0 :         int limit = 100;
    2454                 :            : 
    2455         [ #  # ]:          0 :         while (limit--) {
    2456                 :          0 :                 u32 tmp32;
    2457                 :            : 
    2458         [ #  # ]:          0 :                 if (!tg3_readphy(tp, MII_TG3_DSP_CONTROL, &tmp32)) {
    2459         [ #  # ]:          0 :                         if ((tmp32 & 0x1000) == 0)
    2460                 :            :                                 break;
    2461                 :            :                 }
    2462                 :            :         }
    2463         [ #  # ]:          0 :         if (limit < 0)
    2464                 :          0 :                 return -EBUSY;
    2465                 :            : 
    2466                 :            :         return 0;
    2467                 :            : }
    2468                 :            : 
    2469                 :          0 : static int tg3_phy_write_and_check_testpat(struct tg3 *tp, int *resetp)
    2470                 :            : {
    2471                 :          0 :         static const u32 test_pat[4][6] = {
    2472                 :            :         { 0x00005555, 0x00000005, 0x00002aaa, 0x0000000a, 0x00003456, 0x00000003 },
    2473                 :            :         { 0x00002aaa, 0x0000000a, 0x00003333, 0x00000003, 0x0000789a, 0x00000005 },
    2474                 :            :         { 0x00005a5a, 0x00000005, 0x00002a6a, 0x0000000a, 0x00001bcd, 0x00000003 },
    2475                 :            :         { 0x00002a5a, 0x0000000a, 0x000033c3, 0x00000003, 0x00002ef1, 0x00000005 }
    2476                 :            :         };
    2477                 :          0 :         int chan;
    2478                 :            : 
    2479         [ #  # ]:          0 :         for (chan = 0; chan < 4; chan++) {
    2480                 :          0 :                 int i;
    2481                 :            : 
    2482                 :          0 :                 tg3_writephy(tp, MII_TG3_DSP_ADDRESS,
    2483                 :          0 :                              (chan * 0x2000) | 0x0200);
    2484                 :          0 :                 tg3_writephy(tp, MII_TG3_DSP_CONTROL, 0x0002);
    2485                 :            : 
    2486         [ #  # ]:          0 :                 for (i = 0; i < 6; i++)
    2487                 :          0 :                         tg3_writephy(tp, MII_TG3_DSP_RW_PORT,
    2488                 :            :                                      test_pat[chan][i]);
    2489                 :            : 
    2490                 :          0 :                 tg3_writephy(tp, MII_TG3_DSP_CONTROL, 0x0202);
    2491         [ #  # ]:          0 :                 if (tg3_wait_macro_done(tp)) {
    2492                 :          0 :                         *resetp = 1;
    2493                 :          0 :                         return -EBUSY;
    2494                 :            :                 }
    2495                 :            : 
    2496                 :          0 :                 tg3_writephy(tp, MII_TG3_DSP_ADDRESS,
    2497                 :            :                              (chan * 0x2000) | 0x0200);
    2498                 :          0 :                 tg3_writephy(tp, MII_TG3_DSP_CONTROL, 0x0082);
    2499         [ #  # ]:          0 :                 if (tg3_wait_macro_done(tp)) {
    2500                 :          0 :                         *resetp = 1;
    2501                 :          0 :                         return -EBUSY;
    2502                 :            :                 }
    2503                 :            : 
    2504                 :          0 :                 tg3_writephy(tp, MII_TG3_DSP_CONTROL, 0x0802);
    2505         [ #  # ]:          0 :                 if (tg3_wait_macro_done(tp)) {
    2506                 :          0 :                         *resetp = 1;
    2507                 :          0 :                         return -EBUSY;
    2508                 :            :                 }
    2509                 :            : 
    2510         [ #  # ]:          0 :                 for (i = 0; i < 6; i += 2) {
    2511                 :          0 :                         u32 low, high;
    2512                 :            : 
    2513   [ #  #  #  # ]:          0 :                         if (tg3_readphy(tp, MII_TG3_DSP_RW_PORT, &low) ||
    2514         [ #  # ]:          0 :                             tg3_readphy(tp, MII_TG3_DSP_RW_PORT, &high) ||
    2515                 :          0 :                             tg3_wait_macro_done(tp)) {
    2516                 :          0 :                                 *resetp = 1;
    2517                 :          0 :                                 return -EBUSY;
    2518                 :            :                         }
    2519                 :          0 :                         low &= 0x7fff;
    2520                 :          0 :                         high &= 0x000f;
    2521         [ #  # ]:          0 :                         if (low != test_pat[chan][i] ||
    2522         [ #  # ]:          0 :                             high != test_pat[chan][i+1]) {
    2523                 :          0 :                                 tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x000b);
    2524                 :          0 :                                 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x4001);
    2525                 :          0 :                                 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x4005);
    2526                 :            : 
    2527                 :          0 :                                 return -EBUSY;
    2528                 :            :                         }
    2529                 :            :                 }
    2530                 :            :         }
    2531                 :            : 
    2532                 :            :         return 0;
    2533                 :            : }
    2534                 :            : 
    2535                 :          0 : static int tg3_phy_reset_chanpat(struct tg3 *tp)
    2536                 :            : {
    2537                 :          0 :         int chan;
    2538                 :            : 
    2539         [ #  # ]:          0 :         for (chan = 0; chan < 4; chan++) {
    2540                 :          0 :                 int i;
    2541                 :            : 
    2542                 :          0 :                 tg3_writephy(tp, MII_TG3_DSP_ADDRESS,
    2543                 :          0 :                              (chan * 0x2000) | 0x0200);
    2544                 :          0 :                 tg3_writephy(tp, MII_TG3_DSP_CONTROL, 0x0002);
    2545         [ #  # ]:          0 :                 for (i = 0; i < 6; i++)
    2546                 :          0 :                         tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x000);
    2547                 :          0 :                 tg3_writephy(tp, MII_TG3_DSP_CONTROL, 0x0202);
    2548         [ #  # ]:          0 :                 if (tg3_wait_macro_done(tp))
    2549                 :            :                         return -EBUSY;
    2550                 :            :         }
    2551                 :            : 
    2552                 :            :         return 0;
    2553                 :            : }
    2554                 :            : 
    2555                 :          0 : static int tg3_phy_reset_5703_4_5(struct tg3 *tp)
    2556                 :            : {
    2557                 :          0 :         u32 reg32, phy9_orig;
    2558                 :          0 :         int retries, do_phy_reset, err;
    2559                 :            : 
    2560                 :          0 :         retries = 10;
    2561                 :          0 :         do_phy_reset = 1;
    2562                 :          0 :         do {
    2563         [ #  # ]:          0 :                 if (do_phy_reset) {
    2564                 :          0 :                         err = tg3_bmcr_reset(tp);
    2565         [ #  # ]:          0 :                         if (err)
    2566                 :          0 :                                 return err;
    2567                 :          0 :                         do_phy_reset = 0;
    2568                 :            :                 }
    2569                 :            : 
    2570                 :            :                 /* Disable transmitter and interrupt.  */
    2571         [ #  # ]:          0 :                 if (tg3_readphy(tp, MII_TG3_EXT_CTRL, &reg32))
    2572                 :          0 :                         continue;
    2573                 :            : 
    2574                 :          0 :                 reg32 |= 0x3000;
    2575                 :          0 :                 tg3_writephy(tp, MII_TG3_EXT_CTRL, reg32);
    2576                 :            : 
    2577                 :            :                 /* Set full-duplex, 1000 mbps.  */
    2578                 :          0 :                 tg3_writephy(tp, MII_BMCR,
    2579                 :            :                              BMCR_FULLDPLX | BMCR_SPEED1000);
    2580                 :            : 
    2581                 :            :                 /* Set to master mode.  */
    2582         [ #  # ]:          0 :                 if (tg3_readphy(tp, MII_CTRL1000, &phy9_orig))
    2583                 :          0 :                         continue;
    2584                 :            : 
    2585                 :          0 :                 tg3_writephy(tp, MII_CTRL1000,
    2586                 :            :                              CTL1000_AS_MASTER | CTL1000_ENABLE_MASTER);
    2587                 :            : 
    2588                 :          0 :                 err = tg3_phy_toggle_auxctl_smdsp(tp, true);
    2589         [ #  # ]:          0 :                 if (err)
    2590                 :          0 :                         return err;
    2591                 :            : 
    2592                 :            :                 /* Block the PHY control access.  */
    2593                 :          0 :                 tg3_phydsp_write(tp, 0x8005, 0x0800);
    2594                 :            : 
    2595                 :          0 :                 err = tg3_phy_write_and_check_testpat(tp, &do_phy_reset);
    2596         [ #  # ]:          0 :                 if (!err)
    2597                 :            :                         break;
    2598         [ #  # ]:          0 :         } while (--retries);
    2599                 :            : 
    2600                 :          0 :         err = tg3_phy_reset_chanpat(tp);
    2601         [ #  # ]:          0 :         if (err)
    2602                 :            :                 return err;
    2603                 :            : 
    2604                 :          0 :         tg3_phydsp_write(tp, 0x8005, 0x0000);
    2605                 :            : 
    2606                 :          0 :         tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x8200);
    2607                 :          0 :         tg3_writephy(tp, MII_TG3_DSP_CONTROL, 0x0000);
    2608                 :            : 
    2609                 :          0 :         tg3_phy_toggle_auxctl_smdsp(tp, false);
    2610                 :            : 
    2611                 :          0 :         tg3_writephy(tp, MII_CTRL1000, phy9_orig);
    2612                 :            : 
    2613                 :          0 :         err = tg3_readphy(tp, MII_TG3_EXT_CTRL, &reg32);
    2614         [ #  # ]:          0 :         if (err)
    2615                 :            :                 return err;
    2616                 :            : 
    2617                 :          0 :         reg32 &= ~0x3000;
    2618                 :          0 :         tg3_writephy(tp, MII_TG3_EXT_CTRL, reg32);
    2619                 :            : 
    2620                 :          0 :         return 0;
    2621                 :            : }
    2622                 :            : 
    2623                 :          0 : static void tg3_carrier_off(struct tg3 *tp)
    2624                 :            : {
    2625                 :          0 :         netif_carrier_off(tp->dev);
    2626                 :          0 :         tp->link_up = false;
    2627                 :          0 : }
    2628                 :            : 
    2629                 :          0 : static void tg3_warn_mgmt_link_flap(struct tg3 *tp)
    2630                 :            : {
    2631         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_ASF))
    2632                 :          0 :                 netdev_warn(tp->dev,
    2633                 :            :                             "Management side-band traffic will be interrupted during phy settings change\n");
    2634                 :          0 : }
    2635                 :            : 
    2636                 :            : /* This will reset the tigon3 PHY if there is no valid
    2637                 :            :  * link unless the FORCE argument is non-zero.
    2638                 :            :  */
    2639                 :          0 : static int tg3_phy_reset(struct tg3 *tp)
    2640                 :            : {
    2641                 :          0 :         u32 val, cpmuctrl;
    2642                 :          0 :         int err;
    2643                 :            : 
    2644         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5906) {
    2645                 :          0 :                 val = tr32(GRC_MISC_CFG);
    2646                 :          0 :                 tw32_f(GRC_MISC_CFG, val & ~GRC_MISC_CFG_EPHY_IDDQ);
    2647                 :          0 :                 udelay(40);
    2648                 :            :         }
    2649                 :          0 :         err  = tg3_readphy(tp, MII_BMSR, &val);
    2650                 :          0 :         err |= tg3_readphy(tp, MII_BMSR, &val);
    2651         [ #  # ]:          0 :         if (err != 0)
    2652                 :            :                 return -EBUSY;
    2653                 :            : 
    2654   [ #  #  #  # ]:          0 :         if (netif_running(tp->dev) && tp->link_up) {
    2655                 :          0 :                 netif_carrier_off(tp->dev);
    2656                 :          0 :                 tg3_link_report(tp);
    2657                 :            :         }
    2658                 :            : 
    2659                 :          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5703 ||
    2660         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5704 ||
    2661                 :            :             tg3_asic_rev(tp) == ASIC_REV_5705) {
    2662                 :          0 :                 err = tg3_phy_reset_5703_4_5(tp);
    2663         [ #  # ]:          0 :                 if (err)
    2664                 :            :                         return err;
    2665                 :          0 :                 goto out;
    2666                 :            :         }
    2667                 :            : 
    2668                 :          0 :         cpmuctrl = 0;
    2669         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5784 &&
    2670         [ #  # ]:          0 :             tg3_chip_rev(tp) != CHIPREV_5784_AX) {
    2671                 :          0 :                 cpmuctrl = tr32(TG3_CPMU_CTRL);
    2672         [ #  # ]:          0 :                 if (cpmuctrl & CPMU_CTRL_GPHY_10MB_RXONLY)
    2673                 :          0 :                         tw32(TG3_CPMU_CTRL,
    2674                 :            :                              cpmuctrl & ~CPMU_CTRL_GPHY_10MB_RXONLY);
    2675                 :            :         }
    2676                 :            : 
    2677                 :          0 :         err = tg3_bmcr_reset(tp);
    2678         [ #  # ]:          0 :         if (err)
    2679                 :            :                 return err;
    2680                 :            : 
    2681         [ #  # ]:          0 :         if (cpmuctrl & CPMU_CTRL_GPHY_10MB_RXONLY) {
    2682                 :          0 :                 val = MII_TG3_DSP_EXP8_AEDW | MII_TG3_DSP_EXP8_REJ2MHz;
    2683                 :          0 :                 tg3_phydsp_write(tp, MII_TG3_DSP_EXP8, val);
    2684                 :            : 
    2685                 :          0 :                 tw32(TG3_CPMU_CTRL, cpmuctrl);
    2686                 :            :         }
    2687                 :            : 
    2688         [ #  # ]:          0 :         if (tg3_chip_rev(tp) == CHIPREV_5784_AX ||
    2689                 :            :             tg3_chip_rev(tp) == CHIPREV_5761_AX) {
    2690                 :          0 :                 val = tr32(TG3_CPMU_LSPD_1000MB_CLK);
    2691         [ #  # ]:          0 :                 if ((val & CPMU_LSPD_1000MB_MACCLK_MASK) ==
    2692                 :            :                     CPMU_LSPD_1000MB_MACCLK_12_5) {
    2693                 :          0 :                         val &= ~CPMU_LSPD_1000MB_MACCLK_MASK;
    2694                 :          0 :                         udelay(40);
    2695                 :          0 :                         tw32_f(TG3_CPMU_LSPD_1000MB_CLK, val);
    2696                 :            :                 }
    2697                 :            :         }
    2698                 :            : 
    2699         [ #  # ]:          0 :         if (tg3_flag(tp, 5717_PLUS) &&
    2700         [ #  # ]:          0 :             (tp->phy_flags & TG3_PHYFLG_MII_SERDES))
    2701                 :            :                 return 0;
    2702                 :            : 
    2703                 :          0 :         tg3_phy_apply_otp(tp);
    2704                 :            : 
    2705         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_ENABLE_APD)
    2706                 :          0 :                 tg3_phy_toggle_apd(tp, true);
    2707                 :            :         else
    2708                 :          0 :                 tg3_phy_toggle_apd(tp, false);
    2709                 :            : 
    2710                 :          0 : out:
    2711   [ #  #  #  # ]:          0 :         if ((tp->phy_flags & TG3_PHYFLG_ADC_BUG) &&
    2712                 :          0 :             !tg3_phy_toggle_auxctl_smdsp(tp, true)) {
    2713                 :          0 :                 tg3_phydsp_write(tp, 0x201f, 0x2aaa);
    2714                 :          0 :                 tg3_phydsp_write(tp, 0x000a, 0x0323);
    2715                 :          0 :                 tg3_phy_toggle_auxctl_smdsp(tp, false);
    2716                 :            :         }
    2717                 :            : 
    2718         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_5704_A0_BUG) {
    2719                 :          0 :                 tg3_writephy(tp, MII_TG3_MISC_SHDW, 0x8d68);
    2720                 :          0 :                 tg3_writephy(tp, MII_TG3_MISC_SHDW, 0x8d68);
    2721                 :            :         }
    2722                 :            : 
    2723         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_BER_BUG) {
    2724         [ #  # ]:          0 :                 if (!tg3_phy_toggle_auxctl_smdsp(tp, true)) {
    2725                 :          0 :                         tg3_phydsp_write(tp, 0x000a, 0x310b);
    2726                 :          0 :                         tg3_phydsp_write(tp, 0x201f, 0x9506);
    2727                 :          0 :                         tg3_phydsp_write(tp, 0x401f, 0x14e2);
    2728                 :          0 :                         tg3_phy_toggle_auxctl_smdsp(tp, false);
    2729                 :            :                 }
    2730         [ #  # ]:          0 :         } else if (tp->phy_flags & TG3_PHYFLG_JITTER_BUG) {
    2731         [ #  # ]:          0 :                 if (!tg3_phy_toggle_auxctl_smdsp(tp, true)) {
    2732                 :          0 :                         tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x000a);
    2733         [ #  # ]:          0 :                         if (tp->phy_flags & TG3_PHYFLG_ADJUST_TRIM) {
    2734                 :          0 :                                 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x110b);
    2735                 :          0 :                                 tg3_writephy(tp, MII_TG3_TEST1,
    2736                 :            :                                              MII_TG3_TEST1_TRIM_EN | 0x4);
    2737                 :            :                         } else
    2738                 :          0 :                                 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x010b);
    2739                 :            : 
    2740                 :          0 :                         tg3_phy_toggle_auxctl_smdsp(tp, false);
    2741                 :            :                 }
    2742                 :            :         }
    2743                 :            : 
    2744                 :            :         /* Set Extended packet length bit (bit 14) on all chips that */
    2745                 :            :         /* support jumbo frames */
    2746         [ #  # ]:          0 :         if ((tp->phy_id & TG3_PHY_ID_MASK) == TG3_PHY_ID_BCM5401) {
    2747                 :            :                 /* Cannot do read-modify-write on 5401 */
    2748                 :          0 :                 tg3_phy_auxctl_write(tp, MII_TG3_AUXCTL_SHDWSEL_AUXCTL, 0x4c20);
    2749         [ #  # ]:          0 :         } else if (tg3_flag(tp, JUMBO_CAPABLE)) {
    2750                 :            :                 /* Set bit 14 with read-modify-write to preserve other bits */
    2751                 :          0 :                 err = tg3_phy_auxctl_read(tp,
    2752                 :            :                                           MII_TG3_AUXCTL_SHDWSEL_AUXCTL, &val);
    2753         [ #  # ]:          0 :                 if (!err)
    2754                 :          0 :                         tg3_phy_auxctl_write(tp, MII_TG3_AUXCTL_SHDWSEL_AUXCTL,
    2755                 :            :                                            val | MII_TG3_AUXCTL_ACTL_EXTPKTLEN);
    2756                 :            :         }
    2757                 :            : 
    2758                 :            :         /* Set phy register 0x10 bit 0 to high fifo elasticity to support
    2759                 :            :          * jumbo frames transmission.
    2760                 :            :          */
    2761         [ #  # ]:          0 :         if (tg3_flag(tp, JUMBO_CAPABLE)) {
    2762         [ #  # ]:          0 :                 if (!tg3_readphy(tp, MII_TG3_EXT_CTRL, &val))
    2763                 :          0 :                         tg3_writephy(tp, MII_TG3_EXT_CTRL,
    2764                 :            :                                      val | MII_TG3_EXT_CTRL_FIFO_ELASTIC);
    2765                 :            :         }
    2766                 :            : 
    2767         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5906) {
    2768                 :            :                 /* adjust output voltage */
    2769                 :          0 :                 tg3_writephy(tp, MII_TG3_FET_PTEST, 0x12);
    2770                 :            :         }
    2771                 :            : 
    2772         [ #  # ]:          0 :         if (tg3_chip_rev_id(tp) == CHIPREV_ID_5762_A0)
    2773                 :          0 :                 tg3_phydsp_write(tp, 0xffb, 0x4000);
    2774                 :            : 
    2775                 :          0 :         tg3_phy_toggle_automdix(tp, true);
    2776                 :          0 :         tg3_phy_set_wirespeed(tp);
    2777                 :          0 :         return 0;
    2778                 :            : }
    2779                 :            : 
    2780                 :            : #define TG3_GPIO_MSG_DRVR_PRES           0x00000001
    2781                 :            : #define TG3_GPIO_MSG_NEED_VAUX           0x00000002
    2782                 :            : #define TG3_GPIO_MSG_MASK                (TG3_GPIO_MSG_DRVR_PRES | \
    2783                 :            :                                           TG3_GPIO_MSG_NEED_VAUX)
    2784                 :            : #define TG3_GPIO_MSG_ALL_DRVR_PRES_MASK \
    2785                 :            :         ((TG3_GPIO_MSG_DRVR_PRES << 0) | \
    2786                 :            :          (TG3_GPIO_MSG_DRVR_PRES << 4) | \
    2787                 :            :          (TG3_GPIO_MSG_DRVR_PRES << 8) | \
    2788                 :            :          (TG3_GPIO_MSG_DRVR_PRES << 12))
    2789                 :            : 
    2790                 :            : #define TG3_GPIO_MSG_ALL_NEED_VAUX_MASK \
    2791                 :            :         ((TG3_GPIO_MSG_NEED_VAUX << 0) | \
    2792                 :            :          (TG3_GPIO_MSG_NEED_VAUX << 4) | \
    2793                 :            :          (TG3_GPIO_MSG_NEED_VAUX << 8) | \
    2794                 :            :          (TG3_GPIO_MSG_NEED_VAUX << 12))
    2795                 :            : 
    2796                 :          0 : static inline u32 tg3_set_function_status(struct tg3 *tp, u32 newstat)
    2797                 :            : {
    2798                 :          0 :         u32 status, shift;
    2799                 :            : 
    2800         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5717 ||
    2801                 :            :             tg3_asic_rev(tp) == ASIC_REV_5719)
    2802                 :          0 :                 status = tg3_ape_read32(tp, TG3_APE_GPIO_MSG);
    2803                 :            :         else
    2804                 :          0 :                 status = tr32(TG3_CPMU_DRV_STATUS);
    2805                 :            : 
    2806                 :          0 :         shift = TG3_APE_GPIO_MSG_SHIFT + 4 * tp->pci_fn;
    2807                 :          0 :         status &= ~(TG3_GPIO_MSG_MASK << shift);
    2808                 :          0 :         status |= (newstat << shift);
    2809                 :            : 
    2810         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5717 ||
    2811                 :            :             tg3_asic_rev(tp) == ASIC_REV_5719)
    2812                 :          0 :                 tg3_ape_write32(tp, TG3_APE_GPIO_MSG, status);
    2813                 :            :         else
    2814                 :          0 :                 tw32(TG3_CPMU_DRV_STATUS, status);
    2815                 :            : 
    2816                 :          0 :         return status >> TG3_APE_GPIO_MSG_SHIFT;
    2817                 :            : }
    2818                 :            : 
    2819                 :          0 : static inline int tg3_pwrsrc_switch_to_vmain(struct tg3 *tp)
    2820                 :            : {
    2821         [ #  # ]:          0 :         if (!tg3_flag(tp, IS_NIC))
    2822                 :            :                 return 0;
    2823                 :            : 
    2824         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5717 ||
    2825         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5719 ||
    2826                 :            :             tg3_asic_rev(tp) == ASIC_REV_5720) {
    2827         [ #  # ]:          0 :                 if (tg3_ape_lock(tp, TG3_APE_LOCK_GPIO))
    2828                 :            :                         return -EIO;
    2829                 :            : 
    2830                 :          0 :                 tg3_set_function_status(tp, TG3_GPIO_MSG_DRVR_PRES);
    2831                 :            : 
    2832                 :          0 :                 tw32_wait_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl,
    2833                 :            :                             TG3_GRC_LCLCTL_PWRSW_DELAY);
    2834                 :            : 
    2835                 :          0 :                 tg3_ape_unlock(tp, TG3_APE_LOCK_GPIO);
    2836                 :            :         } else {
    2837                 :          0 :                 tw32_wait_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl,
    2838                 :            :                             TG3_GRC_LCLCTL_PWRSW_DELAY);
    2839                 :            :         }
    2840                 :            : 
    2841                 :            :         return 0;
    2842                 :            : }
    2843                 :            : 
    2844                 :          0 : static void tg3_pwrsrc_die_with_vmain(struct tg3 *tp)
    2845                 :            : {
    2846                 :          0 :         u32 grc_local_ctrl;
    2847                 :            : 
    2848         [ #  # ]:          0 :         if (!tg3_flag(tp, IS_NIC) ||
    2849   [ #  #  #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5700 ||
    2850                 :            :             tg3_asic_rev(tp) == ASIC_REV_5701)
    2851                 :            :                 return;
    2852                 :            : 
    2853                 :          0 :         grc_local_ctrl = tp->grc_local_ctrl | GRC_LCLCTRL_GPIO_OE1;
    2854                 :            : 
    2855                 :          0 :         tw32_wait_f(GRC_LOCAL_CTRL,
    2856                 :            :                     grc_local_ctrl | GRC_LCLCTRL_GPIO_OUTPUT1,
    2857                 :            :                     TG3_GRC_LCLCTL_PWRSW_DELAY);
    2858                 :            : 
    2859                 :          0 :         tw32_wait_f(GRC_LOCAL_CTRL,
    2860                 :            :                     grc_local_ctrl,
    2861                 :            :                     TG3_GRC_LCLCTL_PWRSW_DELAY);
    2862                 :            : 
    2863                 :          0 :         tw32_wait_f(GRC_LOCAL_CTRL,
    2864                 :            :                     grc_local_ctrl | GRC_LCLCTRL_GPIO_OUTPUT1,
    2865                 :            :                     TG3_GRC_LCLCTL_PWRSW_DELAY);
    2866                 :            : }
    2867                 :            : 
    2868                 :          0 : static void tg3_pwrsrc_switch_to_vaux(struct tg3 *tp)
    2869                 :            : {
    2870         [ #  # ]:          0 :         if (!tg3_flag(tp, IS_NIC))
    2871                 :            :                 return;
    2872                 :            : 
    2873         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5700 ||
    2874                 :            :             tg3_asic_rev(tp) == ASIC_REV_5701) {
    2875                 :          0 :                 tw32_wait_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl |
    2876                 :            :                             (GRC_LCLCTRL_GPIO_OE0 |
    2877                 :            :                              GRC_LCLCTRL_GPIO_OE1 |
    2878                 :            :                              GRC_LCLCTRL_GPIO_OE2 |
    2879                 :            :                              GRC_LCLCTRL_GPIO_OUTPUT0 |
    2880                 :            :                              GRC_LCLCTRL_GPIO_OUTPUT1),
    2881                 :            :                             TG3_GRC_LCLCTL_PWRSW_DELAY);
    2882         [ #  # ]:          0 :         } else if (tp->pdev->device == PCI_DEVICE_ID_TIGON3_5761 ||
    2883                 :            :                    tp->pdev->device == TG3PCI_DEVICE_TIGON3_5761S) {
    2884                 :            :                 /* The 5761 non-e device swaps GPIO 0 and GPIO 2. */
    2885                 :          0 :                 u32 grc_local_ctrl = GRC_LCLCTRL_GPIO_OE0 |
    2886                 :            :                                      GRC_LCLCTRL_GPIO_OE1 |
    2887                 :            :                                      GRC_LCLCTRL_GPIO_OE2 |
    2888                 :            :                                      GRC_LCLCTRL_GPIO_OUTPUT0 |
    2889                 :            :                                      GRC_LCLCTRL_GPIO_OUTPUT1 |
    2890                 :          0 :                                      tp->grc_local_ctrl;
    2891                 :          0 :                 tw32_wait_f(GRC_LOCAL_CTRL, grc_local_ctrl,
    2892                 :            :                             TG3_GRC_LCLCTL_PWRSW_DELAY);
    2893                 :            : 
    2894                 :          0 :                 grc_local_ctrl |= GRC_LCLCTRL_GPIO_OUTPUT2;
    2895                 :          0 :                 tw32_wait_f(GRC_LOCAL_CTRL, grc_local_ctrl,
    2896                 :            :                             TG3_GRC_LCLCTL_PWRSW_DELAY);
    2897                 :            : 
    2898                 :          0 :                 grc_local_ctrl &= ~GRC_LCLCTRL_GPIO_OUTPUT0;
    2899                 :          0 :                 tw32_wait_f(GRC_LOCAL_CTRL, grc_local_ctrl,
    2900                 :            :                             TG3_GRC_LCLCTL_PWRSW_DELAY);
    2901                 :            :         } else {
    2902                 :          0 :                 u32 no_gpio2;
    2903                 :          0 :                 u32 grc_local_ctrl = 0;
    2904                 :            : 
    2905                 :            :                 /* Workaround to prevent overdrawing Amps. */
    2906         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5714) {
    2907                 :          0 :                         grc_local_ctrl |= GRC_LCLCTRL_GPIO_OE3;
    2908                 :          0 :                         tw32_wait_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl |
    2909                 :            :                                     grc_local_ctrl,
    2910                 :            :                                     TG3_GRC_LCLCTL_PWRSW_DELAY);
    2911                 :            :                 }
    2912                 :            : 
    2913                 :            :                 /* On 5753 and variants, GPIO2 cannot be used. */
    2914                 :          0 :                 no_gpio2 = tp->nic_sram_data_cfg &
    2915                 :            :                            NIC_SRAM_DATA_CFG_NO_GPIO2;
    2916                 :            : 
    2917                 :          0 :                 grc_local_ctrl |= GRC_LCLCTRL_GPIO_OE0 |
    2918                 :            :                                   GRC_LCLCTRL_GPIO_OE1 |
    2919                 :            :                                   GRC_LCLCTRL_GPIO_OE2 |
    2920                 :            :                                   GRC_LCLCTRL_GPIO_OUTPUT1 |
    2921                 :            :                                   GRC_LCLCTRL_GPIO_OUTPUT2;
    2922         [ #  # ]:          0 :                 if (no_gpio2) {
    2923                 :          0 :                         grc_local_ctrl &= ~(GRC_LCLCTRL_GPIO_OE2 |
    2924                 :            :                                             GRC_LCLCTRL_GPIO_OUTPUT2);
    2925                 :            :                 }
    2926                 :          0 :                 tw32_wait_f(GRC_LOCAL_CTRL,
    2927                 :            :                             tp->grc_local_ctrl | grc_local_ctrl,
    2928                 :            :                             TG3_GRC_LCLCTL_PWRSW_DELAY);
    2929                 :            : 
    2930                 :          0 :                 grc_local_ctrl |= GRC_LCLCTRL_GPIO_OUTPUT0;
    2931                 :            : 
    2932                 :          0 :                 tw32_wait_f(GRC_LOCAL_CTRL,
    2933                 :            :                             tp->grc_local_ctrl | grc_local_ctrl,
    2934                 :            :                             TG3_GRC_LCLCTL_PWRSW_DELAY);
    2935                 :            : 
    2936         [ #  # ]:          0 :                 if (!no_gpio2) {
    2937                 :          0 :                         grc_local_ctrl &= ~GRC_LCLCTRL_GPIO_OUTPUT2;
    2938                 :          0 :                         tw32_wait_f(GRC_LOCAL_CTRL,
    2939                 :            :                                     tp->grc_local_ctrl | grc_local_ctrl,
    2940                 :            :                                     TG3_GRC_LCLCTL_PWRSW_DELAY);
    2941                 :            :                 }
    2942                 :            :         }
    2943                 :            : }
    2944                 :            : 
    2945                 :          0 : static void tg3_frob_aux_power_5717(struct tg3 *tp, bool wol_enable)
    2946                 :            : {
    2947                 :          0 :         u32 msg = 0;
    2948                 :            : 
    2949                 :            :         /* Serialize power state transitions */
    2950         [ #  # ]:          0 :         if (tg3_ape_lock(tp, TG3_APE_LOCK_GPIO))
    2951                 :            :                 return;
    2952                 :            : 
    2953   [ #  #  #  #  :          0 :         if (tg3_flag(tp, ENABLE_ASF) || tg3_flag(tp, ENABLE_APE) || wol_enable)
                   #  # ]
    2954                 :            :                 msg = TG3_GPIO_MSG_NEED_VAUX;
    2955                 :            : 
    2956                 :          0 :         msg = tg3_set_function_status(tp, msg);
    2957                 :            : 
    2958         [ #  # ]:          0 :         if (msg & TG3_GPIO_MSG_ALL_DRVR_PRES_MASK)
    2959                 :          0 :                 goto done;
    2960                 :            : 
    2961         [ #  # ]:          0 :         if (msg & TG3_GPIO_MSG_ALL_NEED_VAUX_MASK)
    2962                 :          0 :                 tg3_pwrsrc_switch_to_vaux(tp);
    2963                 :            :         else
    2964                 :          0 :                 tg3_pwrsrc_die_with_vmain(tp);
    2965                 :            : 
    2966                 :          0 : done:
    2967                 :          0 :         tg3_ape_unlock(tp, TG3_APE_LOCK_GPIO);
    2968                 :            : }
    2969                 :            : 
    2970                 :          0 : static void tg3_frob_aux_power(struct tg3 *tp, bool include_wol)
    2971                 :            : {
    2972                 :          0 :         bool need_vaux = false;
    2973                 :            : 
    2974                 :            :         /* The GPIOs do something completely different on 57765. */
    2975   [ #  #  #  # ]:          0 :         if (!tg3_flag(tp, IS_NIC) || tg3_flag(tp, 57765_CLASS))
    2976                 :          0 :                 return;
    2977                 :            : 
    2978         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5717 ||
    2979         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5719 ||
    2980                 :            :             tg3_asic_rev(tp) == ASIC_REV_5720) {
    2981                 :          0 :                 tg3_frob_aux_power_5717(tp, include_wol ?
    2982   [ #  #  #  # ]:          0 :                                         tg3_flag(tp, WOL_ENABLE) != 0 : 0);
    2983                 :          0 :                 return;
    2984                 :            :         }
    2985                 :            : 
    2986   [ #  #  #  # ]:          0 :         if (tp->pdev_peer && tp->pdev_peer != tp->pdev) {
    2987                 :          0 :                 struct net_device *dev_peer;
    2988                 :            : 
    2989         [ #  # ]:          0 :                 dev_peer = pci_get_drvdata(tp->pdev_peer);
    2990                 :            : 
    2991                 :            :                 /* remove_one() may have been run on the peer. */
    2992         [ #  # ]:          0 :                 if (dev_peer) {
    2993                 :          0 :                         struct tg3 *tp_peer = netdev_priv(dev_peer);
    2994                 :            : 
    2995         [ #  # ]:          0 :                         if (tg3_flag(tp_peer, INIT_COMPLETE))
    2996                 :            :                                 return;
    2997                 :            : 
    2998   [ #  #  #  #  :          0 :                         if ((include_wol && tg3_flag(tp_peer, WOL_ENABLE)) ||
                   #  # ]
    2999                 :            :                             tg3_flag(tp_peer, ENABLE_ASF))
    3000                 :            :                                 need_vaux = true;
    3001                 :            :                 }
    3002                 :            :         }
    3003                 :            : 
    3004   [ #  #  #  #  :          0 :         if ((include_wol && tg3_flag(tp, WOL_ENABLE)) ||
                   #  # ]
    3005                 :            :             tg3_flag(tp, ENABLE_ASF))
    3006                 :            :                 need_vaux = true;
    3007                 :            : 
    3008         [ #  # ]:          0 :         if (need_vaux)
    3009                 :          0 :                 tg3_pwrsrc_switch_to_vaux(tp);
    3010                 :            :         else
    3011                 :          0 :                 tg3_pwrsrc_die_with_vmain(tp);
    3012                 :            : }
    3013                 :            : 
    3014                 :          0 : static int tg3_5700_link_polarity(struct tg3 *tp, u32 speed)
    3015                 :            : {
    3016                 :          0 :         if (tp->led_ctrl == LED_CTRL_MODE_PHY_2)
    3017                 :            :                 return 1;
    3018   [ #  #  #  # ]:          0 :         else if ((tp->phy_id & TG3_PHY_ID_MASK) == TG3_PHY_ID_BCM5411) {
    3019   [ #  #  #  # ]:          0 :                 if (speed != SPEED_10)
    3020                 :            :                         return 1;
    3021   [ #  #  #  # ]:          0 :         } else if (speed == SPEED_10)
    3022                 :            :                 return 1;
    3023                 :            : 
    3024                 :            :         return 0;
    3025                 :            : }
    3026                 :            : 
    3027                 :          0 : static bool tg3_phy_power_bug(struct tg3 *tp)
    3028                 :            : {
    3029   [ #  #  #  #  :          0 :         switch (tg3_asic_rev(tp)) {
                      # ]
    3030                 :            :         case ASIC_REV_5700:
    3031                 :            :         case ASIC_REV_5704:
    3032                 :            :                 return true;
    3033                 :          0 :         case ASIC_REV_5780:
    3034         [ #  # ]:          0 :                 if (tp->phy_flags & TG3_PHYFLG_MII_SERDES)
    3035                 :          0 :                         return true;
    3036                 :            :                 return false;
    3037                 :          0 :         case ASIC_REV_5717:
    3038         [ #  # ]:          0 :                 if (!tp->pci_fn)
    3039                 :          0 :                         return true;
    3040                 :            :                 return false;
    3041                 :          0 :         case ASIC_REV_5719:
    3042                 :            :         case ASIC_REV_5720:
    3043         [ #  # ]:          0 :                 if ((tp->phy_flags & TG3_PHYFLG_PHY_SERDES) &&
    3044         [ #  # ]:          0 :                     !tp->pci_fn)
    3045                 :          0 :                         return true;
    3046                 :            :                 return false;
    3047                 :            :         }
    3048                 :            : 
    3049                 :          0 :         return false;
    3050                 :            : }
    3051                 :            : 
    3052                 :          0 : static bool tg3_phy_led_bug(struct tg3 *tp)
    3053                 :            : {
    3054                 :          0 :         switch (tg3_asic_rev(tp)) {
    3055                 :          0 :         case ASIC_REV_5719:
    3056                 :            :         case ASIC_REV_5720:
    3057         [ #  # ]:          0 :                 if ((tp->phy_flags & TG3_PHYFLG_MII_SERDES) &&
    3058         [ #  # ]:          0 :                     !tp->pci_fn)
    3059                 :            :                         return true;
    3060                 :            :                 return false;
    3061                 :            :         }
    3062                 :            : 
    3063                 :            :         return false;
    3064                 :            : }
    3065                 :            : 
    3066                 :          0 : static void tg3_power_down_phy(struct tg3 *tp, bool do_low_power)
    3067                 :            : {
    3068                 :          0 :         u32 val;
    3069                 :            : 
    3070         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_KEEP_LINK_ON_PWRDN)
    3071                 :            :                 return;
    3072                 :            : 
    3073         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_PHY_SERDES) {
    3074         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5704) {
    3075                 :          0 :                         u32 sg_dig_ctrl = tr32(SG_DIG_CTRL);
    3076                 :          0 :                         u32 serdes_cfg = tr32(MAC_SERDES_CFG);
    3077                 :            : 
    3078                 :          0 :                         sg_dig_ctrl |=
    3079                 :            :                                 SG_DIG_USING_HW_AUTONEG | SG_DIG_SOFT_RESET;
    3080                 :          0 :                         tw32(SG_DIG_CTRL, sg_dig_ctrl);
    3081                 :          0 :                         tw32(MAC_SERDES_CFG, serdes_cfg | (1 << 15));
    3082                 :            :                 }
    3083                 :          0 :                 return;
    3084                 :            :         }
    3085                 :            : 
    3086         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5906) {
    3087                 :          0 :                 tg3_bmcr_reset(tp);
    3088                 :          0 :                 val = tr32(GRC_MISC_CFG);
    3089                 :          0 :                 tw32_f(GRC_MISC_CFG, val | GRC_MISC_CFG_EPHY_IDDQ);
    3090                 :          0 :                 udelay(40);
    3091                 :          0 :                 return;
    3092         [ #  # ]:          0 :         } else if (tp->phy_flags & TG3_PHYFLG_IS_FET) {
    3093                 :          0 :                 u32 phytest;
    3094         [ #  # ]:          0 :                 if (!tg3_readphy(tp, MII_TG3_FET_TEST, &phytest)) {
    3095                 :          0 :                         u32 phy;
    3096                 :            : 
    3097                 :          0 :                         tg3_writephy(tp, MII_ADVERTISE, 0);
    3098                 :          0 :                         tg3_writephy(tp, MII_BMCR,
    3099                 :            :                                      BMCR_ANENABLE | BMCR_ANRESTART);
    3100                 :            : 
    3101                 :          0 :                         tg3_writephy(tp, MII_TG3_FET_TEST,
    3102                 :            :                                      phytest | MII_TG3_FET_SHADOW_EN);
    3103         [ #  # ]:          0 :                         if (!tg3_readphy(tp, MII_TG3_FET_SHDW_AUXMODE4, &phy)) {
    3104                 :          0 :                                 phy |= MII_TG3_FET_SHDW_AUXMODE4_SBPD;
    3105                 :          0 :                                 tg3_writephy(tp,
    3106                 :            :                                              MII_TG3_FET_SHDW_AUXMODE4,
    3107                 :            :                                              phy);
    3108                 :            :                         }
    3109                 :          0 :                         tg3_writephy(tp, MII_TG3_FET_TEST, phytest);
    3110                 :            :                 }
    3111                 :          0 :                 return;
    3112         [ #  # ]:          0 :         } else if (do_low_power) {
    3113         [ #  # ]:          0 :                 if (!tg3_phy_led_bug(tp))
    3114                 :          0 :                         tg3_writephy(tp, MII_TG3_EXT_CTRL,
    3115                 :            :                                      MII_TG3_EXT_CTRL_FORCE_LED_OFF);
    3116                 :            : 
    3117                 :          0 :                 val = MII_TG3_AUXCTL_PCTL_100TX_LPWR |
    3118                 :            :                       MII_TG3_AUXCTL_PCTL_SPR_ISOLATE |
    3119                 :            :                       MII_TG3_AUXCTL_PCTL_VREG_11V;
    3120                 :          0 :                 tg3_phy_auxctl_write(tp, MII_TG3_AUXCTL_SHDWSEL_PWRCTL, val);
    3121                 :            :         }
    3122                 :            : 
    3123                 :            :         /* The PHY should not be powered down on some chips because
    3124                 :            :          * of bugs.
    3125                 :            :          */
    3126         [ #  # ]:          0 :         if (tg3_phy_power_bug(tp))
    3127                 :            :                 return;
    3128                 :            : 
    3129         [ #  # ]:          0 :         if (tg3_chip_rev(tp) == CHIPREV_5784_AX ||
    3130                 :            :             tg3_chip_rev(tp) == CHIPREV_5761_AX) {
    3131                 :          0 :                 val = tr32(TG3_CPMU_LSPD_1000MB_CLK);
    3132                 :          0 :                 val &= ~CPMU_LSPD_1000MB_MACCLK_MASK;
    3133                 :          0 :                 val |= CPMU_LSPD_1000MB_MACCLK_12_5;
    3134                 :          0 :                 tw32_f(TG3_CPMU_LSPD_1000MB_CLK, val);
    3135                 :            :         }
    3136                 :            : 
    3137                 :          0 :         tg3_writephy(tp, MII_BMCR, BMCR_PDOWN);
    3138                 :            : }
    3139                 :            : 
    3140                 :            : /* tp->lock is held. */
    3141                 :          0 : static int tg3_nvram_lock(struct tg3 *tp)
    3142                 :            : {
    3143         [ #  # ]:          0 :         if (tg3_flag(tp, NVRAM)) {
    3144                 :          0 :                 int i;
    3145                 :            : 
    3146         [ #  # ]:          0 :                 if (tp->nvram_lock_cnt == 0) {
    3147                 :          0 :                         tw32(NVRAM_SWARB, SWARB_REQ_SET1);
    3148         [ #  # ]:          0 :                         for (i = 0; i < 8000; i++) {
    3149         [ #  # ]:          0 :                                 if (tr32(NVRAM_SWARB) & SWARB_GNT1)
    3150                 :            :                                         break;
    3151                 :          0 :                                 udelay(20);
    3152                 :            :                         }
    3153         [ #  # ]:          0 :                         if (i == 8000) {
    3154                 :          0 :                                 tw32(NVRAM_SWARB, SWARB_REQ_CLR1);
    3155                 :          0 :                                 return -ENODEV;
    3156                 :            :                         }
    3157                 :            :                 }
    3158                 :          0 :                 tp->nvram_lock_cnt++;
    3159                 :            :         }
    3160                 :            :         return 0;
    3161                 :            : }
    3162                 :            : 
    3163                 :            : /* tp->lock is held. */
    3164                 :          0 : static void tg3_nvram_unlock(struct tg3 *tp)
    3165                 :            : {
    3166         [ #  # ]:          0 :         if (tg3_flag(tp, NVRAM)) {
    3167         [ #  # ]:          0 :                 if (tp->nvram_lock_cnt > 0)
    3168                 :          0 :                         tp->nvram_lock_cnt--;
    3169         [ #  # ]:          0 :                 if (tp->nvram_lock_cnt == 0)
    3170                 :          0 :                         tw32_f(NVRAM_SWARB, SWARB_REQ_CLR1);
    3171                 :            :         }
    3172                 :          0 : }
    3173                 :            : 
    3174                 :            : /* tp->lock is held. */
    3175                 :          0 : static void tg3_enable_nvram_access(struct tg3 *tp)
    3176                 :            : {
    3177   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, 5750_PLUS) && !tg3_flag(tp, PROTECTED_NVRAM)) {
    3178                 :          0 :                 u32 nvaccess = tr32(NVRAM_ACCESS);
    3179                 :            : 
    3180                 :          0 :                 tw32(NVRAM_ACCESS, nvaccess | ACCESS_ENABLE);
    3181                 :            :         }
    3182                 :          0 : }
    3183                 :            : 
    3184                 :            : /* tp->lock is held. */
    3185                 :          0 : static void tg3_disable_nvram_access(struct tg3 *tp)
    3186                 :            : {
    3187   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, 5750_PLUS) && !tg3_flag(tp, PROTECTED_NVRAM)) {
    3188                 :          0 :                 u32 nvaccess = tr32(NVRAM_ACCESS);
    3189                 :            : 
    3190                 :          0 :                 tw32(NVRAM_ACCESS, nvaccess & ~ACCESS_ENABLE);
    3191                 :            :         }
    3192                 :          0 : }
    3193                 :            : 
    3194                 :          0 : static int tg3_nvram_read_using_eeprom(struct tg3 *tp,
    3195                 :            :                                         u32 offset, u32 *val)
    3196                 :            : {
    3197                 :          0 :         u32 tmp;
    3198                 :          0 :         int i;
    3199                 :            : 
    3200   [ #  #  #  # ]:          0 :         if (offset > EEPROM_ADDR_ADDR_MASK || (offset % 4) != 0)
    3201                 :            :                 return -EINVAL;
    3202                 :            : 
    3203                 :          0 :         tmp = tr32(GRC_EEPROM_ADDR) & ~(EEPROM_ADDR_ADDR_MASK |
    3204                 :            :                                         EEPROM_ADDR_DEVID_MASK |
    3205                 :            :                                         EEPROM_ADDR_READ);
    3206                 :          0 :         tw32(GRC_EEPROM_ADDR,
    3207                 :            :              tmp |
    3208                 :            :              (0 << EEPROM_ADDR_DEVID_SHIFT) |
    3209                 :            :              ((offset << EEPROM_ADDR_ADDR_SHIFT) &
    3210                 :            :               EEPROM_ADDR_ADDR_MASK) |
    3211                 :            :              EEPROM_ADDR_READ | EEPROM_ADDR_START);
    3212                 :            : 
    3213         [ #  # ]:          0 :         for (i = 0; i < 1000; i++) {
    3214                 :          0 :                 tmp = tr32(GRC_EEPROM_ADDR);
    3215                 :            : 
    3216         [ #  # ]:          0 :                 if (tmp & EEPROM_ADDR_COMPLETE)
    3217                 :            :                         break;
    3218                 :          0 :                 msleep(1);
    3219                 :            :         }
    3220         [ #  # ]:          0 :         if (!(tmp & EEPROM_ADDR_COMPLETE))
    3221                 :            :                 return -EBUSY;
    3222                 :            : 
    3223                 :          0 :         tmp = tr32(GRC_EEPROM_DATA);
    3224                 :            : 
    3225                 :            :         /*
    3226                 :            :          * The data will always be opposite the native endian
    3227                 :            :          * format.  Perform a blind byteswap to compensate.
    3228                 :            :          */
    3229                 :          0 :         *val = swab32(tmp);
    3230                 :            : 
    3231                 :          0 :         return 0;
    3232                 :            : }
    3233                 :            : 
    3234                 :            : #define NVRAM_CMD_TIMEOUT 10000
    3235                 :            : 
    3236                 :          0 : static int tg3_nvram_exec_cmd(struct tg3 *tp, u32 nvram_cmd)
    3237                 :            : {
    3238                 :          0 :         int i;
    3239                 :            : 
    3240                 :          0 :         tw32(NVRAM_CMD, nvram_cmd);
    3241         [ #  # ]:          0 :         for (i = 0; i < NVRAM_CMD_TIMEOUT; i++) {
    3242                 :          0 :                 usleep_range(10, 40);
    3243         [ #  # ]:          0 :                 if (tr32(NVRAM_CMD) & NVRAM_CMD_DONE) {
    3244                 :          0 :                         udelay(10);
    3245                 :            :                         break;
    3246                 :            :                 }
    3247                 :            :         }
    3248                 :            : 
    3249         [ #  # ]:          0 :         if (i == NVRAM_CMD_TIMEOUT)
    3250                 :          0 :                 return -EBUSY;
    3251                 :            : 
    3252                 :            :         return 0;
    3253                 :            : }
    3254                 :            : 
    3255                 :          0 : static u32 tg3_nvram_phys_addr(struct tg3 *tp, u32 addr)
    3256                 :            : {
    3257   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, NVRAM) &&
    3258         [ #  # ]:          0 :             tg3_flag(tp, NVRAM_BUFFERED) &&
    3259         [ #  # ]:          0 :             tg3_flag(tp, FLASH) &&
    3260                 :          0 :             !tg3_flag(tp, NO_NVRAM_ADDR_TRANS) &&
    3261         [ #  # ]:          0 :             (tp->nvram_jedecnum == JEDEC_ATMEL))
    3262                 :            : 
    3263                 :          0 :                 addr = ((addr / tp->nvram_pagesize) <<
    3264                 :            :                         ATMEL_AT45DB0X1B_PAGE_POS) +
    3265                 :          0 :                        (addr % tp->nvram_pagesize);
    3266                 :            : 
    3267                 :          0 :         return addr;
    3268                 :            : }
    3269                 :            : 
    3270                 :          0 : static u32 tg3_nvram_logical_addr(struct tg3 *tp, u32 addr)
    3271                 :            : {
    3272   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, NVRAM) &&
    3273         [ #  # ]:          0 :             tg3_flag(tp, NVRAM_BUFFERED) &&
    3274         [ #  # ]:          0 :             tg3_flag(tp, FLASH) &&
    3275                 :          0 :             !tg3_flag(tp, NO_NVRAM_ADDR_TRANS) &&
    3276         [ #  # ]:          0 :             (tp->nvram_jedecnum == JEDEC_ATMEL))
    3277                 :            : 
    3278                 :          0 :                 addr = ((addr >> ATMEL_AT45DB0X1B_PAGE_POS) *
    3279                 :          0 :                         tp->nvram_pagesize) +
    3280                 :          0 :                        (addr & ((1 << ATMEL_AT45DB0X1B_PAGE_POS) - 1));
    3281                 :            : 
    3282                 :          0 :         return addr;
    3283                 :            : }
    3284                 :            : 
    3285                 :            : /* NOTE: Data read in from NVRAM is byteswapped according to
    3286                 :            :  * the byteswapping settings for all other register accesses.
    3287                 :            :  * tg3 devices are BE devices, so on a BE machine, the data
    3288                 :            :  * returned will be exactly as it is seen in NVRAM.  On a LE
    3289                 :            :  * machine, the 32-bit value will be byteswapped.
    3290                 :            :  */
    3291                 :          0 : static int tg3_nvram_read(struct tg3 *tp, u32 offset, u32 *val)
    3292                 :            : {
    3293                 :          0 :         int ret;
    3294                 :            : 
    3295         [ #  # ]:          0 :         if (!tg3_flag(tp, NVRAM))
    3296                 :          0 :                 return tg3_nvram_read_using_eeprom(tp, offset, val);
    3297                 :            : 
    3298                 :          0 :         offset = tg3_nvram_phys_addr(tp, offset);
    3299                 :            : 
    3300         [ #  # ]:          0 :         if (offset > NVRAM_ADDR_MSK)
    3301                 :            :                 return -EINVAL;
    3302                 :            : 
    3303                 :          0 :         ret = tg3_nvram_lock(tp);
    3304         [ #  # ]:          0 :         if (ret)
    3305                 :            :                 return ret;
    3306                 :            : 
    3307                 :          0 :         tg3_enable_nvram_access(tp);
    3308                 :            : 
    3309                 :          0 :         tw32(NVRAM_ADDR, offset);
    3310                 :          0 :         ret = tg3_nvram_exec_cmd(tp, NVRAM_CMD_RD | NVRAM_CMD_GO |
    3311                 :            :                 NVRAM_CMD_FIRST | NVRAM_CMD_LAST | NVRAM_CMD_DONE);
    3312                 :            : 
    3313         [ #  # ]:          0 :         if (ret == 0)
    3314                 :          0 :                 *val = tr32(NVRAM_RDDATA);
    3315                 :            : 
    3316                 :          0 :         tg3_disable_nvram_access(tp);
    3317                 :            : 
    3318                 :          0 :         tg3_nvram_unlock(tp);
    3319                 :            : 
    3320                 :          0 :         return ret;
    3321                 :            : }
    3322                 :            : 
    3323                 :            : /* Ensures NVRAM data is in bytestream format. */
    3324                 :          0 : static int tg3_nvram_read_be32(struct tg3 *tp, u32 offset, __be32 *val)
    3325                 :            : {
    3326                 :          0 :         u32 v;
    3327                 :          0 :         int res = tg3_nvram_read(tp, offset, &v);
    3328   [ #  #  #  #  :          0 :         if (!res)
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    3329                 :          0 :                 *val = cpu_to_be32(v);
    3330                 :          0 :         return res;
    3331                 :            : }
    3332                 :            : 
    3333                 :          0 : static int tg3_nvram_write_block_using_eeprom(struct tg3 *tp,
    3334                 :            :                                     u32 offset, u32 len, u8 *buf)
    3335                 :            : {
    3336                 :          0 :         int i, j, rc = 0;
    3337                 :          0 :         u32 val;
    3338                 :            : 
    3339         [ #  # ]:          0 :         for (i = 0; i < len; i += 4) {
    3340                 :          0 :                 u32 addr;
    3341                 :          0 :                 __be32 data;
    3342                 :            : 
    3343                 :          0 :                 addr = offset + i;
    3344                 :            : 
    3345                 :          0 :                 memcpy(&data, buf + i, 4);
    3346                 :            : 
    3347                 :            :                 /*
    3348                 :            :                  * The SEEPROM interface expects the data to always be opposite
    3349                 :            :                  * the native endian format.  We accomplish this by reversing
    3350                 :            :                  * all the operations that would have been performed on the
    3351                 :            :                  * data from a call to tg3_nvram_read_be32().
    3352                 :            :                  */
    3353                 :          0 :                 tw32(GRC_EEPROM_DATA, swab32(be32_to_cpu(data)));
    3354                 :            : 
    3355                 :          0 :                 val = tr32(GRC_EEPROM_ADDR);
    3356                 :          0 :                 tw32(GRC_EEPROM_ADDR, val | EEPROM_ADDR_COMPLETE);
    3357                 :            : 
    3358                 :          0 :                 val &= ~(EEPROM_ADDR_ADDR_MASK | EEPROM_ADDR_DEVID_MASK |
    3359                 :            :                         EEPROM_ADDR_READ);
    3360                 :          0 :                 tw32(GRC_EEPROM_ADDR, val |
    3361                 :            :                         (0 << EEPROM_ADDR_DEVID_SHIFT) |
    3362                 :            :                         (addr & EEPROM_ADDR_ADDR_MASK) |
    3363                 :            :                         EEPROM_ADDR_START |
    3364                 :            :                         EEPROM_ADDR_WRITE);
    3365                 :            : 
    3366         [ #  # ]:          0 :                 for (j = 0; j < 1000; j++) {
    3367                 :          0 :                         val = tr32(GRC_EEPROM_ADDR);
    3368                 :            : 
    3369         [ #  # ]:          0 :                         if (val & EEPROM_ADDR_COMPLETE)
    3370                 :            :                                 break;
    3371                 :          0 :                         msleep(1);
    3372                 :            :                 }
    3373         [ #  # ]:          0 :                 if (!(val & EEPROM_ADDR_COMPLETE)) {
    3374                 :            :                         rc = -EBUSY;
    3375                 :            :                         break;
    3376                 :            :                 }
    3377                 :            :         }
    3378                 :            : 
    3379                 :          0 :         return rc;
    3380                 :            : }
    3381                 :            : 
    3382                 :            : /* offset and length are dword aligned */
    3383                 :          0 : static int tg3_nvram_write_block_unbuffered(struct tg3 *tp, u32 offset, u32 len,
    3384                 :            :                 u8 *buf)
    3385                 :            : {
    3386                 :          0 :         int ret = 0;
    3387                 :          0 :         u32 pagesize = tp->nvram_pagesize;
    3388                 :          0 :         u32 pagemask = pagesize - 1;
    3389                 :          0 :         u32 nvram_cmd;
    3390                 :          0 :         u8 *tmp;
    3391                 :            : 
    3392         [ #  # ]:          0 :         tmp = kmalloc(pagesize, GFP_KERNEL);
    3393         [ #  # ]:          0 :         if (tmp == NULL)
    3394                 :            :                 return -ENOMEM;
    3395                 :            : 
    3396         [ #  # ]:          0 :         while (len) {
    3397                 :          0 :                 int j;
    3398                 :          0 :                 u32 phy_addr, page_off, size;
    3399                 :            : 
    3400                 :          0 :                 phy_addr = offset & ~pagemask;
    3401                 :            : 
    3402         [ #  # ]:          0 :                 for (j = 0; j < pagesize; j += 4) {
    3403                 :          0 :                         ret = tg3_nvram_read_be32(tp, phy_addr + j,
    3404                 :          0 :                                                   (__be32 *) (tmp + j));
    3405         [ #  # ]:          0 :                         if (ret)
    3406                 :            :                                 break;
    3407                 :            :                 }
    3408         [ #  # ]:          0 :                 if (ret)
    3409                 :            :                         break;
    3410                 :            : 
    3411                 :          0 :                 page_off = offset & pagemask;
    3412                 :          0 :                 size = pagesize;
    3413                 :          0 :                 if (len < size)
    3414                 :            :                         size = len;
    3415                 :            : 
    3416                 :          0 :                 len -= size;
    3417                 :            : 
    3418                 :          0 :                 memcpy(tmp + page_off, buf, size);
    3419                 :            : 
    3420                 :          0 :                 offset = offset + (pagesize - page_off);
    3421                 :            : 
    3422                 :          0 :                 tg3_enable_nvram_access(tp);
    3423                 :            : 
    3424                 :            :                 /*
    3425                 :            :                  * Before we can erase the flash page, we need
    3426                 :            :                  * to issue a special "write enable" command.
    3427                 :            :                  */
    3428                 :          0 :                 nvram_cmd = NVRAM_CMD_WREN | NVRAM_CMD_GO | NVRAM_CMD_DONE;
    3429                 :            : 
    3430         [ #  # ]:          0 :                 if (tg3_nvram_exec_cmd(tp, nvram_cmd))
    3431                 :            :                         break;
    3432                 :            : 
    3433                 :            :                 /* Erase the target page */
    3434                 :          0 :                 tw32(NVRAM_ADDR, phy_addr);
    3435                 :            : 
    3436                 :          0 :                 nvram_cmd = NVRAM_CMD_GO | NVRAM_CMD_DONE | NVRAM_CMD_WR |
    3437                 :            :                         NVRAM_CMD_FIRST | NVRAM_CMD_LAST | NVRAM_CMD_ERASE;
    3438                 :            : 
    3439         [ #  # ]:          0 :                 if (tg3_nvram_exec_cmd(tp, nvram_cmd))
    3440                 :            :                         break;
    3441                 :            : 
    3442                 :            :                 /* Issue another write enable to start the write. */
    3443                 :          0 :                 nvram_cmd = NVRAM_CMD_WREN | NVRAM_CMD_GO | NVRAM_CMD_DONE;
    3444                 :            : 
    3445         [ #  # ]:          0 :                 if (tg3_nvram_exec_cmd(tp, nvram_cmd))
    3446                 :            :                         break;
    3447                 :            : 
    3448         [ #  # ]:          0 :                 for (j = 0; j < pagesize; j += 4) {
    3449                 :          0 :                         __be32 data;
    3450                 :            : 
    3451                 :          0 :                         data = *((__be32 *) (tmp + j));
    3452                 :            : 
    3453                 :          0 :                         tw32(NVRAM_WRDATA, be32_to_cpu(data));
    3454                 :            : 
    3455                 :          0 :                         tw32(NVRAM_ADDR, phy_addr + j);
    3456                 :            : 
    3457                 :          0 :                         nvram_cmd = NVRAM_CMD_GO | NVRAM_CMD_DONE |
    3458                 :            :                                 NVRAM_CMD_WR;
    3459                 :            : 
    3460         [ #  # ]:          0 :                         if (j == 0)
    3461                 :            :                                 nvram_cmd |= NVRAM_CMD_FIRST;
    3462         [ #  # ]:          0 :                         else if (j == (pagesize - 4))
    3463                 :          0 :                                 nvram_cmd |= NVRAM_CMD_LAST;
    3464                 :            : 
    3465                 :          0 :                         ret = tg3_nvram_exec_cmd(tp, nvram_cmd);
    3466         [ #  # ]:          0 :                         if (ret)
    3467                 :            :                                 break;
    3468                 :            :                 }
    3469         [ #  # ]:          0 :                 if (ret)
    3470                 :            :                         break;
    3471                 :            :         }
    3472                 :            : 
    3473                 :          0 :         nvram_cmd = NVRAM_CMD_WRDI | NVRAM_CMD_GO | NVRAM_CMD_DONE;
    3474                 :          0 :         tg3_nvram_exec_cmd(tp, nvram_cmd);
    3475                 :            : 
    3476                 :          0 :         kfree(tmp);
    3477                 :            : 
    3478                 :          0 :         return ret;
    3479                 :            : }
    3480                 :            : 
    3481                 :            : /* offset and length are dword aligned */
    3482                 :          0 : static int tg3_nvram_write_block_buffered(struct tg3 *tp, u32 offset, u32 len,
    3483                 :            :                 u8 *buf)
    3484                 :            : {
    3485                 :          0 :         int i, ret = 0;
    3486                 :            : 
    3487         [ #  # ]:          0 :         for (i = 0; i < len; i += 4, offset += 4) {
    3488                 :          0 :                 u32 page_off, phy_addr, nvram_cmd;
    3489                 :          0 :                 __be32 data;
    3490                 :            : 
    3491                 :          0 :                 memcpy(&data, buf + i, 4);
    3492                 :          0 :                 tw32(NVRAM_WRDATA, be32_to_cpu(data));
    3493                 :            : 
    3494                 :          0 :                 page_off = offset % tp->nvram_pagesize;
    3495                 :            : 
    3496                 :          0 :                 phy_addr = tg3_nvram_phys_addr(tp, offset);
    3497                 :            : 
    3498                 :          0 :                 nvram_cmd = NVRAM_CMD_GO | NVRAM_CMD_DONE | NVRAM_CMD_WR;
    3499                 :            : 
    3500         [ #  # ]:          0 :                 if (page_off == 0 || i == 0)
    3501                 :          0 :                         nvram_cmd |= NVRAM_CMD_FIRST;
    3502         [ #  # ]:          0 :                 if (page_off == (tp->nvram_pagesize - 4))
    3503                 :          0 :                         nvram_cmd |= NVRAM_CMD_LAST;
    3504                 :            : 
    3505         [ #  # ]:          0 :                 if (i == (len - 4))
    3506                 :          0 :                         nvram_cmd |= NVRAM_CMD_LAST;
    3507                 :            : 
    3508   [ #  #  #  # ]:          0 :                 if ((nvram_cmd & NVRAM_CMD_FIRST) ||
    3509         [ #  # ]:          0 :                     !tg3_flag(tp, FLASH) ||
    3510                 :            :                     !tg3_flag(tp, 57765_PLUS))
    3511                 :          0 :                         tw32(NVRAM_ADDR, phy_addr);
    3512                 :            : 
    3513   [ #  #  #  # ]:          0 :                 if (tg3_asic_rev(tp) != ASIC_REV_5752 &&
    3514                 :          0 :                     !tg3_flag(tp, 5755_PLUS) &&
    3515   [ #  #  #  # ]:          0 :                     (tp->nvram_jedecnum == JEDEC_ST) &&
    3516                 :            :                     (nvram_cmd & NVRAM_CMD_FIRST)) {
    3517                 :          0 :                         u32 cmd;
    3518                 :            : 
    3519                 :          0 :                         cmd = NVRAM_CMD_WREN | NVRAM_CMD_GO | NVRAM_CMD_DONE;
    3520                 :          0 :                         ret = tg3_nvram_exec_cmd(tp, cmd);
    3521         [ #  # ]:          0 :                         if (ret)
    3522                 :            :                                 break;
    3523                 :            :                 }
    3524         [ #  # ]:          0 :                 if (!tg3_flag(tp, FLASH)) {
    3525                 :            :                         /* We always do complete word writes to eeprom. */
    3526                 :          0 :                         nvram_cmd |= (NVRAM_CMD_FIRST | NVRAM_CMD_LAST);
    3527                 :            :                 }
    3528                 :            : 
    3529                 :          0 :                 ret = tg3_nvram_exec_cmd(tp, nvram_cmd);
    3530         [ #  # ]:          0 :                 if (ret)
    3531                 :            :                         break;
    3532                 :            :         }
    3533                 :          0 :         return ret;
    3534                 :            : }
    3535                 :            : 
    3536                 :            : /* offset and length are dword aligned */
    3537                 :          0 : static int tg3_nvram_write_block(struct tg3 *tp, u32 offset, u32 len, u8 *buf)
    3538                 :            : {
    3539                 :          0 :         int ret;
    3540                 :            : 
    3541         [ #  # ]:          0 :         if (tg3_flag(tp, EEPROM_WRITE_PROT)) {
    3542                 :          0 :                 tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl &
    3543                 :            :                        ~GRC_LCLCTRL_GPIO_OUTPUT1);
    3544                 :          0 :                 udelay(40);
    3545                 :            :         }
    3546                 :            : 
    3547         [ #  # ]:          0 :         if (!tg3_flag(tp, NVRAM)) {
    3548                 :          0 :                 ret = tg3_nvram_write_block_using_eeprom(tp, offset, len, buf);
    3549                 :            :         } else {
    3550                 :          0 :                 u32 grc_mode;
    3551                 :            : 
    3552                 :          0 :                 ret = tg3_nvram_lock(tp);
    3553         [ #  # ]:          0 :                 if (ret)
    3554                 :            :                         return ret;
    3555                 :            : 
    3556                 :          0 :                 tg3_enable_nvram_access(tp);
    3557   [ #  #  #  # ]:          0 :                 if (tg3_flag(tp, 5750_PLUS) && !tg3_flag(tp, PROTECTED_NVRAM))
    3558                 :          0 :                         tw32(NVRAM_WRITE1, 0x406);
    3559                 :            : 
    3560                 :          0 :                 grc_mode = tr32(GRC_MODE);
    3561                 :          0 :                 tw32(GRC_MODE, grc_mode | GRC_MODE_NVRAM_WR_ENABLE);
    3562                 :            : 
    3563   [ #  #  #  # ]:          0 :                 if (tg3_flag(tp, NVRAM_BUFFERED) || !tg3_flag(tp, FLASH)) {
    3564                 :          0 :                         ret = tg3_nvram_write_block_buffered(tp, offset, len,
    3565                 :            :                                 buf);
    3566                 :            :                 } else {
    3567                 :          0 :                         ret = tg3_nvram_write_block_unbuffered(tp, offset, len,
    3568                 :            :                                 buf);
    3569                 :            :                 }
    3570                 :            : 
    3571                 :          0 :                 grc_mode = tr32(GRC_MODE);
    3572                 :          0 :                 tw32(GRC_MODE, grc_mode & ~GRC_MODE_NVRAM_WR_ENABLE);
    3573                 :            : 
    3574                 :          0 :                 tg3_disable_nvram_access(tp);
    3575                 :          0 :                 tg3_nvram_unlock(tp);
    3576                 :            :         }
    3577                 :            : 
    3578         [ #  # ]:          0 :         if (tg3_flag(tp, EEPROM_WRITE_PROT)) {
    3579                 :          0 :                 tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl);
    3580                 :          0 :                 udelay(40);
    3581                 :            :         }
    3582                 :            : 
    3583                 :            :         return ret;
    3584                 :            : }
    3585                 :            : 
    3586                 :            : #define RX_CPU_SCRATCH_BASE     0x30000
    3587                 :            : #define RX_CPU_SCRATCH_SIZE     0x04000
    3588                 :            : #define TX_CPU_SCRATCH_BASE     0x34000
    3589                 :            : #define TX_CPU_SCRATCH_SIZE     0x04000
    3590                 :            : 
    3591                 :            : /* tp->lock is held. */
    3592                 :          0 : static int tg3_pause_cpu(struct tg3 *tp, u32 cpu_base)
    3593                 :            : {
    3594                 :          0 :         int i;
    3595                 :          0 :         const int iters = 10000;
    3596                 :            : 
    3597         [ #  # ]:          0 :         for (i = 0; i < iters; i++) {
    3598                 :          0 :                 tw32(cpu_base + CPU_STATE, 0xffffffff);
    3599                 :          0 :                 tw32(cpu_base + CPU_MODE,  CPU_MODE_HALT);
    3600         [ #  # ]:          0 :                 if (tr32(cpu_base + CPU_MODE) & CPU_MODE_HALT)
    3601                 :            :                         break;
    3602         [ #  # ]:          0 :                 if (pci_channel_offline(tp->pdev))
    3603                 :            :                         return -EBUSY;
    3604                 :            :         }
    3605                 :            : 
    3606         [ #  # ]:          0 :         return (i == iters) ? -EBUSY : 0;
    3607                 :            : }
    3608                 :            : 
    3609                 :            : /* tp->lock is held. */
    3610                 :          0 : static int tg3_rxcpu_pause(struct tg3 *tp)
    3611                 :            : {
    3612                 :          0 :         int rc = tg3_pause_cpu(tp, RX_CPU_BASE);
    3613                 :            : 
    3614                 :          0 :         tw32(RX_CPU_BASE + CPU_STATE, 0xffffffff);
    3615                 :          0 :         tw32_f(RX_CPU_BASE + CPU_MODE,  CPU_MODE_HALT);
    3616                 :          0 :         udelay(10);
    3617                 :            : 
    3618                 :          0 :         return rc;
    3619                 :            : }
    3620                 :            : 
    3621                 :            : /* tp->lock is held. */
    3622                 :          0 : static int tg3_txcpu_pause(struct tg3 *tp)
    3623                 :            : {
    3624                 :          0 :         return tg3_pause_cpu(tp, TX_CPU_BASE);
    3625                 :            : }
    3626                 :            : 
    3627                 :            : /* tp->lock is held. */
    3628                 :          0 : static void tg3_resume_cpu(struct tg3 *tp, u32 cpu_base)
    3629                 :            : {
    3630                 :          0 :         tw32(cpu_base + CPU_STATE, 0xffffffff);
    3631                 :          0 :         tw32_f(cpu_base + CPU_MODE,  0x00000000);
    3632                 :          0 : }
    3633                 :            : 
    3634                 :            : /* tp->lock is held. */
    3635                 :          0 : static void tg3_rxcpu_resume(struct tg3 *tp)
    3636                 :            : {
    3637                 :          0 :         tg3_resume_cpu(tp, RX_CPU_BASE);
    3638                 :          0 : }
    3639                 :            : 
    3640                 :            : /* tp->lock is held. */
    3641                 :          0 : static int tg3_halt_cpu(struct tg3 *tp, u32 cpu_base)
    3642                 :            : {
    3643                 :          0 :         int rc;
    3644                 :            : 
    3645   [ #  #  #  # ]:          0 :         BUG_ON(cpu_base == TX_CPU_BASE && tg3_flag(tp, 5705_PLUS));
    3646                 :            : 
    3647         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5906) {
    3648                 :          0 :                 u32 val = tr32(GRC_VCPU_EXT_CTRL);
    3649                 :            : 
    3650                 :          0 :                 tw32(GRC_VCPU_EXT_CTRL, val | GRC_VCPU_EXT_CTRL_HALT_CPU);
    3651                 :          0 :                 return 0;
    3652                 :            :         }
    3653         [ #  # ]:          0 :         if (cpu_base == RX_CPU_BASE) {
    3654                 :          0 :                 rc = tg3_rxcpu_pause(tp);
    3655                 :            :         } else {
    3656                 :            :                 /*
    3657                 :            :                  * There is only an Rx CPU for the 5750 derivative in the
    3658                 :            :                  * BCM4785.
    3659                 :            :                  */
    3660         [ #  # ]:          0 :                 if (tg3_flag(tp, IS_SSB_CORE))
    3661                 :            :                         return 0;
    3662                 :            : 
    3663                 :          0 :                 rc = tg3_txcpu_pause(tp);
    3664                 :            :         }
    3665                 :            : 
    3666         [ #  # ]:          0 :         if (rc) {
    3667         [ #  # ]:          0 :                 netdev_err(tp->dev, "%s timed out, %s CPU\n",
    3668                 :            :                            __func__, cpu_base == RX_CPU_BASE ? "RX" : "TX");
    3669                 :          0 :                 return -ENODEV;
    3670                 :            :         }
    3671                 :            : 
    3672                 :            :         /* Clear firmware's nvram arbitration. */
    3673         [ #  # ]:          0 :         if (tg3_flag(tp, NVRAM))
    3674                 :          0 :                 tw32(NVRAM_SWARB, SWARB_REQ_CLR0);
    3675                 :            :         return 0;
    3676                 :            : }
    3677                 :            : 
    3678                 :          0 : static int tg3_fw_data_len(struct tg3 *tp,
    3679                 :            :                            const struct tg3_firmware_hdr *fw_hdr)
    3680                 :            : {
    3681                 :          0 :         int fw_len;
    3682                 :            : 
    3683                 :            :         /* Non fragmented firmware have one firmware header followed by a
    3684                 :            :          * contiguous chunk of data to be written. The length field in that
    3685                 :            :          * header is not the length of data to be written but the complete
    3686                 :            :          * length of the bss. The data length is determined based on
    3687                 :            :          * tp->fw->size minus headers.
    3688                 :            :          *
    3689                 :            :          * Fragmented firmware have a main header followed by multiple
    3690                 :            :          * fragments. Each fragment is identical to non fragmented firmware
    3691                 :            :          * with a firmware header followed by a contiguous chunk of data. In
    3692                 :            :          * the main header, the length field is unused and set to 0xffffffff.
    3693                 :            :          * In each fragment header the length is the entire size of that
    3694                 :            :          * fragment i.e. fragment data + header length. Data length is
    3695                 :            :          * therefore length field in the header minus TG3_FW_HDR_LEN.
    3696                 :            :          */
    3697                 :          0 :         if (tp->fw_len == 0xffffffff)
    3698                 :          0 :                 fw_len = be32_to_cpu(fw_hdr->len);
    3699                 :            :         else
    3700                 :          0 :                 fw_len = tp->fw->size;
    3701                 :            : 
    3702                 :          0 :         return (fw_len - TG3_FW_HDR_LEN) / sizeof(u32);
    3703                 :            : }
    3704                 :            : 
    3705                 :            : /* tp->lock is held. */
    3706                 :          0 : static int tg3_load_firmware_cpu(struct tg3 *tp, u32 cpu_base,
    3707                 :            :                                  u32 cpu_scratch_base, int cpu_scratch_size,
    3708                 :            :                                  const struct tg3_firmware_hdr *fw_hdr)
    3709                 :            : {
    3710                 :          0 :         int err, i;
    3711                 :          0 :         void (*write_op)(struct tg3 *, u32, u32);
    3712                 :          0 :         int total_len = tp->fw->size;
    3713                 :            : 
    3714   [ #  #  #  # ]:          0 :         if (cpu_base == TX_CPU_BASE && tg3_flag(tp, 5705_PLUS)) {
    3715                 :          0 :                 netdev_err(tp->dev,
    3716                 :            :                            "%s: Trying to load TX cpu firmware which is 5705\n",
    3717                 :            :                            __func__);
    3718                 :          0 :                 return -EINVAL;
    3719                 :            :         }
    3720                 :            : 
    3721   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, 5705_PLUS) && tg3_asic_rev(tp) != ASIC_REV_57766)
    3722                 :            :                 write_op = tg3_write_mem;
    3723                 :            :         else
    3724                 :          0 :                 write_op = tg3_write_indirect_reg32;
    3725                 :            : 
    3726         [ #  # ]:          0 :         if (tg3_asic_rev(tp) != ASIC_REV_57766) {
    3727                 :            :                 /* It is possible that bootcode is still loading at this point.
    3728                 :            :                  * Get the nvram lock first before halting the cpu.
    3729                 :            :                  */
    3730                 :          0 :                 int lock_err = tg3_nvram_lock(tp);
    3731                 :          0 :                 err = tg3_halt_cpu(tp, cpu_base);
    3732         [ #  # ]:          0 :                 if (!lock_err)
    3733                 :          0 :                         tg3_nvram_unlock(tp);
    3734         [ #  # ]:          0 :                 if (err)
    3735                 :          0 :                         goto out;
    3736                 :            : 
    3737         [ #  # ]:          0 :                 for (i = 0; i < cpu_scratch_size; i += sizeof(u32))
    3738                 :          0 :                         write_op(tp, cpu_scratch_base + i, 0);
    3739                 :          0 :                 tw32(cpu_base + CPU_STATE, 0xffffffff);
    3740                 :          0 :                 tw32(cpu_base + CPU_MODE,
    3741                 :            :                      tr32(cpu_base + CPU_MODE) | CPU_MODE_HALT);
    3742                 :            :         } else {
    3743                 :            :                 /* Subtract additional main header for fragmented firmware and
    3744                 :            :                  * advance to the first fragment
    3745                 :            :                  */
    3746                 :          0 :                 total_len -= TG3_FW_HDR_LEN;
    3747                 :          0 :                 fw_hdr++;
    3748                 :            :         }
    3749                 :            : 
    3750                 :          0 :         do {
    3751                 :          0 :                 u32 *fw_data = (u32 *)(fw_hdr + 1);
    3752   [ #  #  #  # ]:          0 :                 for (i = 0; i < tg3_fw_data_len(tp, fw_hdr); i++)
    3753                 :          0 :                         write_op(tp, cpu_scratch_base +
    3754                 :          0 :                                      (be32_to_cpu(fw_hdr->base_addr) & 0xffff) +
    3755                 :            :                                      (i * sizeof(u32)),
    3756                 :          0 :                                  be32_to_cpu(fw_data[i]));
    3757                 :            : 
    3758                 :          0 :                 total_len -= be32_to_cpu(fw_hdr->len);
    3759                 :            : 
    3760                 :            :                 /* Advance to next fragment */
    3761                 :          0 :                 fw_hdr = (struct tg3_firmware_hdr *)
    3762                 :          0 :                          ((void *)fw_hdr + be32_to_cpu(fw_hdr->len));
    3763         [ #  # ]:          0 :         } while (total_len > 0);
    3764                 :            : 
    3765                 :            :         err = 0;
    3766                 :            : 
    3767                 :            : out:
    3768                 :            :         return err;
    3769                 :            : }
    3770                 :            : 
    3771                 :            : /* tp->lock is held. */
    3772                 :          0 : static int tg3_pause_cpu_and_set_pc(struct tg3 *tp, u32 cpu_base, u32 pc)
    3773                 :            : {
    3774                 :          0 :         int i;
    3775                 :          0 :         const int iters = 5;
    3776                 :            : 
    3777                 :          0 :         tw32(cpu_base + CPU_STATE, 0xffffffff);
    3778                 :          0 :         tw32_f(cpu_base + CPU_PC, pc);
    3779                 :            : 
    3780         [ #  # ]:          0 :         for (i = 0; i < iters; i++) {
    3781         [ #  # ]:          0 :                 if (tr32(cpu_base + CPU_PC) == pc)
    3782                 :            :                         break;
    3783                 :          0 :                 tw32(cpu_base + CPU_STATE, 0xffffffff);
    3784                 :          0 :                 tw32(cpu_base + CPU_MODE,  CPU_MODE_HALT);
    3785                 :          0 :                 tw32_f(cpu_base + CPU_PC, pc);
    3786                 :          0 :                 udelay(1000);
    3787                 :            :         }
    3788                 :            : 
    3789         [ #  # ]:          0 :         return (i == iters) ? -EBUSY : 0;
    3790                 :            : }
    3791                 :            : 
    3792                 :            : /* tp->lock is held. */
    3793                 :          0 : static int tg3_load_5701_a0_firmware_fix(struct tg3 *tp)
    3794                 :            : {
    3795                 :          0 :         const struct tg3_firmware_hdr *fw_hdr;
    3796                 :          0 :         int err;
    3797                 :            : 
    3798                 :          0 :         fw_hdr = (struct tg3_firmware_hdr *)tp->fw->data;
    3799                 :            : 
    3800                 :            :         /* Firmware blob starts with version numbers, followed by
    3801                 :            :            start address and length. We are setting complete length.
    3802                 :            :            length = end_address_of_bss - start_address_of_text.
    3803                 :            :            Remainder is the blob to be loaded contiguously
    3804                 :            :            from start address. */
    3805                 :            : 
    3806                 :          0 :         err = tg3_load_firmware_cpu(tp, RX_CPU_BASE,
    3807                 :            :                                     RX_CPU_SCRATCH_BASE, RX_CPU_SCRATCH_SIZE,
    3808                 :            :                                     fw_hdr);
    3809         [ #  # ]:          0 :         if (err)
    3810                 :            :                 return err;
    3811                 :            : 
    3812                 :          0 :         err = tg3_load_firmware_cpu(tp, TX_CPU_BASE,
    3813                 :            :                                     TX_CPU_SCRATCH_BASE, TX_CPU_SCRATCH_SIZE,
    3814                 :            :                                     fw_hdr);
    3815         [ #  # ]:          0 :         if (err)
    3816                 :            :                 return err;
    3817                 :            : 
    3818                 :            :         /* Now startup only the RX cpu. */
    3819                 :          0 :         err = tg3_pause_cpu_and_set_pc(tp, RX_CPU_BASE,
    3820                 :          0 :                                        be32_to_cpu(fw_hdr->base_addr));
    3821         [ #  # ]:          0 :         if (err) {
    3822                 :          0 :                 netdev_err(tp->dev, "%s fails to set RX CPU PC, is %08x "
    3823                 :            :                            "should be %08x\n", __func__,
    3824                 :          0 :                            tr32(RX_CPU_BASE + CPU_PC),
    3825                 :          0 :                                 be32_to_cpu(fw_hdr->base_addr));
    3826                 :          0 :                 return -ENODEV;
    3827                 :            :         }
    3828                 :            : 
    3829                 :          0 :         tg3_rxcpu_resume(tp);
    3830                 :            : 
    3831                 :          0 :         return 0;
    3832                 :            : }
    3833                 :            : 
    3834                 :          0 : static int tg3_validate_rxcpu_state(struct tg3 *tp)
    3835                 :            : {
    3836                 :          0 :         const int iters = 1000;
    3837                 :          0 :         int i;
    3838                 :          0 :         u32 val;
    3839                 :            : 
    3840                 :            :         /* Wait for boot code to complete initialization and enter service
    3841                 :            :          * loop. It is then safe to download service patches
    3842                 :            :          */
    3843         [ #  # ]:          0 :         for (i = 0; i < iters; i++) {
    3844         [ #  # ]:          0 :                 if (tr32(RX_CPU_HWBKPT) == TG3_SBROM_IN_SERVICE_LOOP)
    3845                 :            :                         break;
    3846                 :            : 
    3847                 :          0 :                 udelay(10);
    3848                 :            :         }
    3849                 :            : 
    3850         [ #  # ]:          0 :         if (i == iters) {
    3851                 :          0 :                 netdev_err(tp->dev, "Boot code not ready for service patches\n");
    3852                 :          0 :                 return -EBUSY;
    3853                 :            :         }
    3854                 :            : 
    3855                 :          0 :         val = tg3_read_indirect_reg32(tp, TG3_57766_FW_HANDSHAKE);
    3856         [ #  # ]:          0 :         if (val & 0xff) {
    3857                 :          0 :                 netdev_warn(tp->dev,
    3858                 :            :                             "Other patches exist. Not downloading EEE patch\n");
    3859                 :          0 :                 return -EEXIST;
    3860                 :            :         }
    3861                 :            : 
    3862                 :            :         return 0;
    3863                 :            : }
    3864                 :            : 
    3865                 :            : /* tp->lock is held. */
    3866                 :          0 : static void tg3_load_57766_firmware(struct tg3 *tp)
    3867                 :            : {
    3868                 :          0 :         struct tg3_firmware_hdr *fw_hdr;
    3869                 :            : 
    3870         [ #  # ]:          0 :         if (!tg3_flag(tp, NO_NVRAM))
    3871                 :            :                 return;
    3872                 :            : 
    3873         [ #  # ]:          0 :         if (tg3_validate_rxcpu_state(tp))
    3874                 :            :                 return;
    3875                 :            : 
    3876         [ #  # ]:          0 :         if (!tp->fw)
    3877                 :            :                 return;
    3878                 :            : 
    3879                 :            :         /* This firmware blob has a different format than older firmware
    3880                 :            :          * releases as given below. The main difference is we have fragmented
    3881                 :            :          * data to be written to non-contiguous locations.
    3882                 :            :          *
    3883                 :            :          * In the beginning we have a firmware header identical to other
    3884                 :            :          * firmware which consists of version, base addr and length. The length
    3885                 :            :          * here is unused and set to 0xffffffff.
    3886                 :            :          *
    3887                 :            :          * This is followed by a series of firmware fragments which are
    3888                 :            :          * individually identical to previous firmware. i.e. they have the
    3889                 :            :          * firmware header and followed by data for that fragment. The version
    3890                 :            :          * field of the individual fragment header is unused.
    3891                 :            :          */
    3892                 :            : 
    3893                 :          0 :         fw_hdr = (struct tg3_firmware_hdr *)tp->fw->data;
    3894         [ #  # ]:          0 :         if (be32_to_cpu(fw_hdr->base_addr) != TG3_57766_FW_BASE_ADDR)
    3895                 :            :                 return;
    3896                 :            : 
    3897         [ #  # ]:          0 :         if (tg3_rxcpu_pause(tp))
    3898                 :            :                 return;
    3899                 :            : 
    3900                 :            :         /* tg3_load_firmware_cpu() will always succeed for the 57766 */
    3901                 :          0 :         tg3_load_firmware_cpu(tp, 0, TG3_57766_FW_BASE_ADDR, 0, fw_hdr);
    3902                 :            : 
    3903                 :          0 :         tg3_rxcpu_resume(tp);
    3904                 :            : }
    3905                 :            : 
    3906                 :            : /* tp->lock is held. */
    3907                 :          0 : static int tg3_load_tso_firmware(struct tg3 *tp)
    3908                 :            : {
    3909                 :          0 :         const struct tg3_firmware_hdr *fw_hdr;
    3910                 :          0 :         unsigned long cpu_base, cpu_scratch_base, cpu_scratch_size;
    3911                 :          0 :         int err;
    3912                 :            : 
    3913         [ #  # ]:          0 :         if (!tg3_flag(tp, FW_TSO))
    3914                 :            :                 return 0;
    3915                 :            : 
    3916                 :          0 :         fw_hdr = (struct tg3_firmware_hdr *)tp->fw->data;
    3917                 :            : 
    3918                 :            :         /* Firmware blob starts with version numbers, followed by
    3919                 :            :            start address and length. We are setting complete length.
    3920                 :            :            length = end_address_of_bss - start_address_of_text.
    3921                 :            :            Remainder is the blob to be loaded contiguously
    3922                 :            :            from start address. */
    3923                 :            : 
    3924                 :          0 :         cpu_scratch_size = tp->fw_len;
    3925                 :            : 
    3926         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5705) {
    3927                 :            :                 cpu_base = RX_CPU_BASE;
    3928                 :            :                 cpu_scratch_base = NIC_SRAM_MBUF_POOL_BASE5705;
    3929                 :            :         } else {
    3930                 :          0 :                 cpu_base = TX_CPU_BASE;
    3931                 :          0 :                 cpu_scratch_base = TX_CPU_SCRATCH_BASE;
    3932                 :          0 :                 cpu_scratch_size = TX_CPU_SCRATCH_SIZE;
    3933                 :            :         }
    3934                 :            : 
    3935                 :          0 :         err = tg3_load_firmware_cpu(tp, cpu_base,
    3936                 :            :                                     cpu_scratch_base, cpu_scratch_size,
    3937                 :            :                                     fw_hdr);
    3938         [ #  # ]:          0 :         if (err)
    3939                 :            :                 return err;
    3940                 :            : 
    3941                 :            :         /* Now startup the cpu. */
    3942                 :          0 :         err = tg3_pause_cpu_and_set_pc(tp, cpu_base,
    3943                 :          0 :                                        be32_to_cpu(fw_hdr->base_addr));
    3944         [ #  # ]:          0 :         if (err) {
    3945                 :          0 :                 netdev_err(tp->dev,
    3946                 :            :                            "%s fails to set CPU PC, is %08x should be %08x\n",
    3947                 :          0 :                            __func__, tr32(cpu_base + CPU_PC),
    3948                 :          0 :                            be32_to_cpu(fw_hdr->base_addr));
    3949                 :          0 :                 return -ENODEV;
    3950                 :            :         }
    3951                 :            : 
    3952                 :          0 :         tg3_resume_cpu(tp, cpu_base);
    3953                 :          0 :         return 0;
    3954                 :            : }
    3955                 :            : 
    3956                 :            : /* tp->lock is held. */
    3957                 :          0 : static void __tg3_set_one_mac_addr(struct tg3 *tp, u8 *mac_addr, int index)
    3958                 :            : {
    3959                 :          0 :         u32 addr_high, addr_low;
    3960                 :            : 
    3961                 :          0 :         addr_high = ((mac_addr[0] << 8) | mac_addr[1]);
    3962                 :          0 :         addr_low = ((mac_addr[2] << 24) | (mac_addr[3] << 16) |
    3963                 :          0 :                     (mac_addr[4] <<  8) | mac_addr[5]);
    3964                 :            : 
    3965         [ #  # ]:          0 :         if (index < 4) {
    3966                 :          0 :                 tw32(MAC_ADDR_0_HIGH + (index * 8), addr_high);
    3967                 :          0 :                 tw32(MAC_ADDR_0_LOW + (index * 8), addr_low);
    3968                 :            :         } else {
    3969                 :          0 :                 index -= 4;
    3970                 :          0 :                 tw32(MAC_EXTADDR_0_HIGH + (index * 8), addr_high);
    3971                 :          0 :                 tw32(MAC_EXTADDR_0_LOW + (index * 8), addr_low);
    3972                 :            :         }
    3973                 :          0 : }
    3974                 :            : 
    3975                 :            : /* tp->lock is held. */
    3976                 :          0 : static void __tg3_set_mac_addr(struct tg3 *tp, bool skip_mac_1)
    3977                 :            : {
    3978                 :          0 :         u32 addr_high;
    3979                 :          0 :         int i;
    3980                 :            : 
    3981         [ #  # ]:          0 :         for (i = 0; i < 4; i++) {
    3982         [ #  # ]:          0 :                 if (i == 1 && skip_mac_1)
    3983                 :          0 :                         continue;
    3984                 :          0 :                 __tg3_set_one_mac_addr(tp, tp->dev->dev_addr, i);
    3985                 :            :         }
    3986                 :            : 
    3987         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5703 ||
    3988                 :            :             tg3_asic_rev(tp) == ASIC_REV_5704) {
    3989         [ #  # ]:          0 :                 for (i = 4; i < 16; i++)
    3990                 :          0 :                         __tg3_set_one_mac_addr(tp, tp->dev->dev_addr, i);
    3991                 :            :         }
    3992                 :            : 
    3993                 :          0 :         addr_high = (tp->dev->dev_addr[0] +
    3994                 :          0 :                      tp->dev->dev_addr[1] +
    3995                 :          0 :                      tp->dev->dev_addr[2] +
    3996                 :          0 :                      tp->dev->dev_addr[3] +
    3997                 :          0 :                      tp->dev->dev_addr[4] +
    3998                 :          0 :                      tp->dev->dev_addr[5]) &
    3999                 :            :                 TX_BACKOFF_SEED_MASK;
    4000                 :          0 :         tw32(MAC_TX_BACKOFF_SEED, addr_high);
    4001                 :          0 : }
    4002                 :            : 
    4003                 :          0 : static void tg3_enable_register_access(struct tg3 *tp)
    4004                 :            : {
    4005                 :            :         /*
    4006                 :            :          * Make sure register accesses (indirect or otherwise) will function
    4007                 :            :          * correctly.
    4008                 :            :          */
    4009                 :          0 :         pci_write_config_dword(tp->pdev,
    4010                 :            :                                TG3PCI_MISC_HOST_CTRL, tp->misc_host_ctrl);
    4011                 :            : }
    4012                 :            : 
    4013                 :          0 : static int tg3_power_up(struct tg3 *tp)
    4014                 :            : {
    4015                 :          0 :         int err;
    4016                 :            : 
    4017                 :          0 :         tg3_enable_register_access(tp);
    4018                 :            : 
    4019                 :          0 :         err = pci_set_power_state(tp->pdev, PCI_D0);
    4020         [ #  # ]:          0 :         if (!err) {
    4021                 :            :                 /* Switch out of Vaux if it is a NIC */
    4022                 :          0 :                 tg3_pwrsrc_switch_to_vmain(tp);
    4023                 :            :         } else {
    4024                 :          0 :                 netdev_err(tp->dev, "Transition to D0 failed\n");
    4025                 :            :         }
    4026                 :            : 
    4027                 :          0 :         return err;
    4028                 :            : }
    4029                 :            : 
    4030                 :            : static int tg3_setup_phy(struct tg3 *, bool);
    4031                 :            : 
    4032                 :          0 : static int tg3_power_down_prepare(struct tg3 *tp)
    4033                 :            : {
    4034                 :          0 :         u32 misc_host_ctrl;
    4035                 :          0 :         bool device_should_wake, do_low_power;
    4036                 :            : 
    4037                 :          0 :         tg3_enable_register_access(tp);
    4038                 :            : 
    4039                 :            :         /* Restore the CLKREQ setting. */
    4040         [ #  # ]:          0 :         if (tg3_flag(tp, CLKREQ_BUG))
    4041                 :          0 :                 pcie_capability_set_word(tp->pdev, PCI_EXP_LNKCTL,
    4042                 :            :                                          PCI_EXP_LNKCTL_CLKREQ_EN);
    4043                 :            : 
    4044                 :          0 :         misc_host_ctrl = tr32(TG3PCI_MISC_HOST_CTRL);
    4045                 :          0 :         tw32(TG3PCI_MISC_HOST_CTRL,
    4046                 :            :              misc_host_ctrl | MISC_HOST_CTRL_MASK_PCI_INT);
    4047                 :            : 
    4048   [ #  #  #  #  :          0 :         device_should_wake = device_may_wakeup(&tp->pdev->dev) &&
                   #  # ]
    4049                 :            :                              tg3_flag(tp, WOL_ENABLE);
    4050                 :            : 
    4051         [ #  # ]:          0 :         if (tg3_flag(tp, USE_PHYLIB)) {
    4052                 :          0 :                 do_low_power = false;
    4053         [ #  # ]:          0 :                 if ((tp->phy_flags & TG3_PHYFLG_IS_CONNECTED) &&
    4054                 :            :                     !(tp->phy_flags & TG3_PHYFLG_IS_LOW_POWER)) {
    4055                 :          0 :                         __ETHTOOL_DECLARE_LINK_MODE_MASK(advertising) = { 0, };
    4056                 :          0 :                         struct phy_device *phydev;
    4057                 :          0 :                         u32 phyid;
    4058                 :            : 
    4059                 :          0 :                         phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr);
    4060                 :            : 
    4061                 :          0 :                         tp->phy_flags |= TG3_PHYFLG_IS_LOW_POWER;
    4062                 :            : 
    4063                 :          0 :                         tp->link_config.speed = phydev->speed;
    4064                 :          0 :                         tp->link_config.duplex = phydev->duplex;
    4065                 :          0 :                         tp->link_config.autoneg = phydev->autoneg;
    4066                 :          0 :                         ethtool_convert_link_mode_to_legacy_u32(
    4067                 :            :                                 &tp->link_config.advertising,
    4068                 :          0 :                                 phydev->advertising);
    4069                 :            : 
    4070                 :          0 :                         linkmode_set_bit(ETHTOOL_LINK_MODE_TP_BIT, advertising);
    4071                 :          0 :                         linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
    4072                 :            :                                          advertising);
    4073                 :          0 :                         linkmode_set_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
    4074                 :            :                                          advertising);
    4075                 :          0 :                         linkmode_set_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT,
    4076                 :            :                                          advertising);
    4077                 :            : 
    4078   [ #  #  #  # ]:          0 :                         if (tg3_flag(tp, ENABLE_ASF) || device_should_wake) {
    4079         [ #  # ]:          0 :                                 if (tg3_flag(tp, WOL_SPEED_100MB)) {
    4080                 :          0 :                                         linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT,
    4081                 :            :                                                          advertising);
    4082                 :          0 :                                         linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT,
    4083                 :            :                                                          advertising);
    4084                 :          0 :                                         linkmode_set_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT,
    4085                 :            :                                                          advertising);
    4086                 :            :                                 } else {
    4087                 :          0 :                                         linkmode_set_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT,
    4088                 :            :                                                          advertising);
    4089                 :            :                                 }
    4090                 :            :                         }
    4091                 :            : 
    4092                 :          0 :                         linkmode_copy(phydev->advertising, advertising);
    4093                 :          0 :                         phy_start_aneg(phydev);
    4094                 :            : 
    4095                 :          0 :                         phyid = phydev->drv->phy_id & phydev->drv->phy_id_mask;
    4096         [ #  # ]:          0 :                         if (phyid != PHY_ID_BCMAC131) {
    4097                 :          0 :                                 phyid &= PHY_BCM_OUI_MASK;
    4098                 :          0 :                                 if (phyid == PHY_BCM_OUI_1 ||
    4099   [ #  #  #  # ]:          0 :                                     phyid == PHY_BCM_OUI_2 ||
    4100                 :            :                                     phyid == PHY_BCM_OUI_3)
    4101                 :          0 :                                         do_low_power = true;
    4102                 :            :                         }
    4103                 :            :                 }
    4104                 :            :         } else {
    4105                 :          0 :                 do_low_power = true;
    4106                 :            : 
    4107         [ #  # ]:          0 :                 if (!(tp->phy_flags & TG3_PHYFLG_IS_LOW_POWER))
    4108                 :          0 :                         tp->phy_flags |= TG3_PHYFLG_IS_LOW_POWER;
    4109                 :            : 
    4110         [ #  # ]:          0 :                 if (!(tp->phy_flags & TG3_PHYFLG_ANY_SERDES))
    4111                 :          0 :                         tg3_setup_phy(tp, false);
    4112                 :            :         }
    4113                 :            : 
    4114         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5906) {
    4115                 :          0 :                 u32 val;
    4116                 :            : 
    4117                 :          0 :                 val = tr32(GRC_VCPU_EXT_CTRL);
    4118                 :          0 :                 tw32(GRC_VCPU_EXT_CTRL, val | GRC_VCPU_EXT_CTRL_DISABLE_WOL);
    4119         [ #  # ]:          0 :         } else if (!tg3_flag(tp, ENABLE_ASF)) {
    4120                 :            :                 int i;
    4121                 :            :                 u32 val;
    4122                 :            : 
    4123         [ #  # ]:          0 :                 for (i = 0; i < 200; i++) {
    4124                 :          0 :                         tg3_read_mem(tp, NIC_SRAM_FW_ASF_STATUS_MBOX, &val);
    4125         [ #  # ]:          0 :                         if (val == ~NIC_SRAM_FIRMWARE_MBOX_MAGIC1)
    4126                 :            :                                 break;
    4127                 :          0 :                         msleep(1);
    4128                 :            :                 }
    4129                 :            :         }
    4130         [ #  # ]:          0 :         if (tg3_flag(tp, WOL_CAP))
    4131                 :          0 :                 tg3_write_mem(tp, NIC_SRAM_WOL_MBOX, WOL_SIGNATURE |
    4132                 :            :                                                      WOL_DRV_STATE_SHUTDOWN |
    4133                 :            :                                                      WOL_DRV_WOL |
    4134                 :            :                                                      WOL_SET_MAGIC_PKT);
    4135                 :            : 
    4136         [ #  # ]:          0 :         if (device_should_wake) {
    4137                 :          0 :                 u32 mac_mode;
    4138                 :            : 
    4139         [ #  # ]:          0 :                 if (!(tp->phy_flags & TG3_PHYFLG_PHY_SERDES)) {
    4140         [ #  # ]:          0 :                         if (do_low_power &&
    4141         [ #  # ]:          0 :                             !(tp->phy_flags & TG3_PHYFLG_IS_FET)) {
    4142                 :          0 :                                 tg3_phy_auxctl_write(tp,
    4143                 :            :                                                MII_TG3_AUXCTL_SHDWSEL_PWRCTL,
    4144                 :            :                                                MII_TG3_AUXCTL_PCTL_WOL_EN |
    4145                 :            :                                                MII_TG3_AUXCTL_PCTL_100TX_LPWR |
    4146                 :            :                                                MII_TG3_AUXCTL_PCTL_CL_AB_TXDAC);
    4147                 :          0 :                                 udelay(40);
    4148                 :            :                         }
    4149                 :            : 
    4150         [ #  # ]:          0 :                         if (tp->phy_flags & TG3_PHYFLG_MII_SERDES)
    4151                 :            :                                 mac_mode = MAC_MODE_PORT_MODE_GMII;
    4152         [ #  # ]:          0 :                         else if (tp->phy_flags &
    4153                 :            :                                  TG3_PHYFLG_KEEP_LINK_ON_PWRDN) {
    4154         [ #  # ]:          0 :                                 if (tp->link_config.active_speed == SPEED_1000)
    4155                 :            :                                         mac_mode = MAC_MODE_PORT_MODE_GMII;
    4156                 :            :                                 else
    4157                 :          0 :                                         mac_mode = MAC_MODE_PORT_MODE_MII;
    4158                 :            :                         } else
    4159                 :            :                                 mac_mode = MAC_MODE_PORT_MODE_MII;
    4160                 :            : 
    4161                 :          0 :                         mac_mode |= tp->mac_mode & MAC_MODE_LINK_POLARITY;
    4162         [ #  # ]:          0 :                         if (tg3_asic_rev(tp) == ASIC_REV_5700) {
    4163                 :          0 :                                 u32 speed = tg3_flag(tp, WOL_SPEED_100MB) ?
    4164         [ #  # ]:          0 :                                              SPEED_100 : SPEED_10;
    4165         [ #  # ]:          0 :                                 if (tg3_5700_link_polarity(tp, speed))
    4166                 :          0 :                                         mac_mode |= MAC_MODE_LINK_POLARITY;
    4167                 :            :                                 else
    4168                 :          0 :                                         mac_mode &= ~MAC_MODE_LINK_POLARITY;
    4169                 :            :                         }
    4170                 :            :                 } else {
    4171                 :            :                         mac_mode = MAC_MODE_PORT_MODE_TBI;
    4172                 :            :                 }
    4173                 :            : 
    4174         [ #  # ]:          0 :                 if (!tg3_flag(tp, 5750_PLUS))
    4175                 :          0 :                         tw32(MAC_LED_CTRL, tp->led_ctrl);
    4176                 :            : 
    4177                 :          0 :                 mac_mode |= MAC_MODE_MAGIC_PKT_ENABLE;
    4178   [ #  #  #  #  :          0 :                 if ((tg3_flag(tp, 5705_PLUS) && !tg3_flag(tp, 5780_CLASS)) &&
                   #  # ]
    4179         [ #  # ]:          0 :                     (tg3_flag(tp, ENABLE_ASF) || tg3_flag(tp, ENABLE_APE)))
    4180                 :          0 :                         mac_mode |= MAC_MODE_KEEP_FRAME_IN_WOL;
    4181                 :            : 
    4182         [ #  # ]:          0 :                 if (tg3_flag(tp, ENABLE_APE))
    4183                 :          0 :                         mac_mode |= MAC_MODE_APE_TX_EN |
    4184                 :            :                                     MAC_MODE_APE_RX_EN |
    4185                 :            :                                     MAC_MODE_TDE_ENABLE;
    4186                 :            : 
    4187                 :          0 :                 tw32_f(MAC_MODE, mac_mode);
    4188                 :          0 :                 udelay(100);
    4189                 :            : 
    4190                 :          0 :                 tw32_f(MAC_RX_MODE, RX_MODE_ENABLE);
    4191                 :          0 :                 udelay(10);
    4192                 :            :         }
    4193                 :            : 
    4194         [ #  # ]:          0 :         if (!tg3_flag(tp, WOL_SPEED_100MB) &&
    4195         [ #  # ]:          0 :             (tg3_asic_rev(tp) == ASIC_REV_5700 ||
    4196                 :          0 :              tg3_asic_rev(tp) == ASIC_REV_5701)) {
    4197                 :          0 :                 u32 base_val;
    4198                 :            : 
    4199                 :          0 :                 base_val = tp->pci_clock_ctrl;
    4200                 :          0 :                 base_val |= (CLOCK_CTRL_RXCLK_DISABLE |
    4201                 :            :                              CLOCK_CTRL_TXCLK_DISABLE);
    4202                 :            : 
    4203                 :          0 :                 tw32_wait_f(TG3PCI_CLOCK_CTRL, base_val | CLOCK_CTRL_ALTCLK |
    4204                 :            :                             CLOCK_CTRL_PWRDOWN_PLL133, 40);
    4205   [ #  #  #  # ]:          0 :         } else if (tg3_flag(tp, 5780_CLASS) ||
    4206                 :          0 :                    tg3_flag(tp, CPMU_PRESENT) ||
    4207         [ #  # ]:          0 :                    tg3_asic_rev(tp) == ASIC_REV_5906) {
    4208                 :            :                 /* do nothing */
    4209   [ #  #  #  # ]:          0 :         } else if (!(tg3_flag(tp, 5750_PLUS) && tg3_flag(tp, ENABLE_ASF))) {
    4210                 :          0 :                 u32 newbits1, newbits2;
    4211                 :            : 
    4212         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5700 ||
    4213                 :            :                     tg3_asic_rev(tp) == ASIC_REV_5701) {
    4214                 :            :                         newbits1 = (CLOCK_CTRL_RXCLK_DISABLE |
    4215                 :            :                                     CLOCK_CTRL_TXCLK_DISABLE |
    4216                 :            :                                     CLOCK_CTRL_ALTCLK);
    4217                 :            :                         newbits2 = newbits1 | CLOCK_CTRL_44MHZ_CORE;
    4218         [ #  # ]:          0 :                 } else if (tg3_flag(tp, 5705_PLUS)) {
    4219                 :            :                         newbits1 = CLOCK_CTRL_625_CORE;
    4220                 :            :                         newbits2 = newbits1 | CLOCK_CTRL_ALTCLK;
    4221                 :            :                 } else {
    4222                 :          0 :                         newbits1 = CLOCK_CTRL_ALTCLK;
    4223                 :          0 :                         newbits2 = newbits1 | CLOCK_CTRL_44MHZ_CORE;
    4224                 :            :                 }
    4225                 :            : 
    4226                 :          0 :                 tw32_wait_f(TG3PCI_CLOCK_CTRL, tp->pci_clock_ctrl | newbits1,
    4227                 :            :                             40);
    4228                 :            : 
    4229                 :          0 :                 tw32_wait_f(TG3PCI_CLOCK_CTRL, tp->pci_clock_ctrl | newbits2,
    4230                 :            :                             40);
    4231                 :            : 
    4232         [ #  # ]:          0 :                 if (!tg3_flag(tp, 5705_PLUS)) {
    4233                 :          0 :                         u32 newbits3;
    4234                 :            : 
    4235         [ #  # ]:          0 :                         if (tg3_asic_rev(tp) == ASIC_REV_5700 ||
    4236                 :            :                             tg3_asic_rev(tp) == ASIC_REV_5701) {
    4237                 :            :                                 newbits3 = (CLOCK_CTRL_RXCLK_DISABLE |
    4238                 :            :                                             CLOCK_CTRL_TXCLK_DISABLE |
    4239                 :            :                                             CLOCK_CTRL_44MHZ_CORE);
    4240                 :            :                         } else {
    4241                 :          0 :                                 newbits3 = CLOCK_CTRL_44MHZ_CORE;
    4242                 :            :                         }
    4243                 :            : 
    4244                 :          0 :                         tw32_wait_f(TG3PCI_CLOCK_CTRL,
    4245                 :            :                                     tp->pci_clock_ctrl | newbits3, 40);
    4246                 :            :                 }
    4247                 :            :         }
    4248                 :            : 
    4249   [ #  #  #  # ]:          0 :         if (!(device_should_wake) && !tg3_flag(tp, ENABLE_ASF))
    4250                 :          0 :                 tg3_power_down_phy(tp, do_low_power);
    4251                 :            : 
    4252                 :          0 :         tg3_frob_aux_power(tp, true);
    4253                 :            : 
    4254                 :            :         /* Workaround for unstable PLL clock */
    4255         [ #  # ]:          0 :         if ((!tg3_flag(tp, IS_SSB_CORE)) &&
    4256         [ #  # ]:          0 :             ((tg3_chip_rev(tp) == CHIPREV_5750_AX) ||
    4257                 :            :              (tg3_chip_rev(tp) == CHIPREV_5750_BX))) {
    4258                 :          0 :                 u32 val = tr32(0x7d00);
    4259                 :            : 
    4260                 :          0 :                 val &= ~((1 << 16) | (1 << 4) | (1 << 2) | (1 << 1) | 1);
    4261                 :          0 :                 tw32(0x7d00, val);
    4262         [ #  # ]:          0 :                 if (!tg3_flag(tp, ENABLE_ASF)) {
    4263                 :          0 :                         int err;
    4264                 :            : 
    4265                 :          0 :                         err = tg3_nvram_lock(tp);
    4266                 :          0 :                         tg3_halt_cpu(tp, RX_CPU_BASE);
    4267         [ #  # ]:          0 :                         if (!err)
    4268                 :          0 :                                 tg3_nvram_unlock(tp);
    4269                 :            :                 }
    4270                 :            :         }
    4271                 :            : 
    4272                 :          0 :         tg3_write_sig_post_reset(tp, RESET_KIND_SHUTDOWN);
    4273                 :            : 
    4274                 :          0 :         tg3_ape_driver_state_change(tp, RESET_KIND_SHUTDOWN);
    4275                 :            : 
    4276                 :          0 :         return 0;
    4277                 :            : }
    4278                 :            : 
    4279                 :          0 : static void tg3_power_down(struct tg3 *tp)
    4280                 :            : {
    4281                 :          0 :         pci_wake_from_d3(tp->pdev, tg3_flag(tp, WOL_ENABLE));
    4282                 :          0 :         pci_set_power_state(tp->pdev, PCI_D3hot);
    4283                 :          0 : }
    4284                 :            : 
    4285                 :            : static void tg3_aux_stat_to_speed_duplex(struct tg3 *tp, u32 val, u32 *speed, u8 *duplex)
    4286                 :            : {
    4287                 :            :         switch (val & MII_TG3_AUX_STAT_SPDMASK) {
    4288                 :            :         case MII_TG3_AUX_STAT_10HALF:
    4289                 :            :                 *speed = SPEED_10;
    4290                 :            :                 *duplex = DUPLEX_HALF;
    4291                 :            :                 break;
    4292                 :            : 
    4293                 :            :         case MII_TG3_AUX_STAT_10FULL:
    4294                 :            :                 *speed = SPEED_10;
    4295                 :            :                 *duplex = DUPLEX_FULL;
    4296                 :            :                 break;
    4297                 :            : 
    4298                 :            :         case MII_TG3_AUX_STAT_100HALF:
    4299                 :            :                 *speed = SPEED_100;
    4300                 :            :                 *duplex = DUPLEX_HALF;
    4301                 :            :                 break;
    4302                 :            : 
    4303                 :            :         case MII_TG3_AUX_STAT_100FULL:
    4304                 :            :                 *speed = SPEED_100;
    4305                 :            :                 *duplex = DUPLEX_FULL;
    4306                 :            :                 break;
    4307                 :            : 
    4308                 :            :         case MII_TG3_AUX_STAT_1000HALF:
    4309                 :            :                 *speed = SPEED_1000;
    4310                 :            :                 *duplex = DUPLEX_HALF;
    4311                 :            :                 break;
    4312                 :            : 
    4313                 :            :         case MII_TG3_AUX_STAT_1000FULL:
    4314                 :            :                 *speed = SPEED_1000;
    4315                 :            :                 *duplex = DUPLEX_FULL;
    4316                 :            :                 break;
    4317                 :            : 
    4318                 :            :         default:
    4319                 :            :                 if (tp->phy_flags & TG3_PHYFLG_IS_FET) {
    4320                 :            :                         *speed = (val & MII_TG3_AUX_STAT_100) ? SPEED_100 :
    4321                 :            :                                  SPEED_10;
    4322                 :            :                         *duplex = (val & MII_TG3_AUX_STAT_FULL) ? DUPLEX_FULL :
    4323                 :            :                                   DUPLEX_HALF;
    4324                 :            :                         break;
    4325                 :            :                 }
    4326                 :            :                 *speed = SPEED_UNKNOWN;
    4327                 :            :                 *duplex = DUPLEX_UNKNOWN;
    4328                 :            :                 break;
    4329                 :            :         }
    4330                 :            : }
    4331                 :            : 
    4332                 :          0 : static int tg3_phy_autoneg_cfg(struct tg3 *tp, u32 advertise, u32 flowctrl)
    4333                 :            : {
    4334                 :          0 :         int err = 0;
    4335                 :          0 :         u32 val, new_adv;
    4336                 :            : 
    4337                 :          0 :         new_adv = ADVERTISE_CSMA;
    4338                 :          0 :         new_adv |= ethtool_adv_to_mii_adv_t(advertise) & ADVERTISE_ALL;
    4339         [ #  # ]:          0 :         new_adv |= mii_advertise_flowctrl(flowctrl);
    4340                 :            : 
    4341                 :          0 :         err = tg3_writephy(tp, MII_ADVERTISE, new_adv);
    4342         [ #  # ]:          0 :         if (err)
    4343                 :          0 :                 goto done;
    4344                 :            : 
    4345         [ #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_10_100_ONLY)) {
    4346         [ #  # ]:          0 :                 new_adv = ethtool_adv_to_mii_ctrl1000_t(advertise);
    4347                 :            : 
    4348         [ #  # ]:          0 :                 if (tg3_chip_rev_id(tp) == CHIPREV_ID_5701_A0 ||
    4349                 :            :                     tg3_chip_rev_id(tp) == CHIPREV_ID_5701_B0)
    4350                 :          0 :                         new_adv |= CTL1000_AS_MASTER | CTL1000_ENABLE_MASTER;
    4351                 :            : 
    4352                 :          0 :                 err = tg3_writephy(tp, MII_CTRL1000, new_adv);
    4353         [ #  # ]:          0 :                 if (err)
    4354                 :          0 :                         goto done;
    4355                 :            :         }
    4356                 :            : 
    4357         [ #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_EEE_CAP))
    4358                 :          0 :                 goto done;
    4359                 :            : 
    4360                 :          0 :         tw32(TG3_CPMU_EEE_MODE,
    4361                 :            :              tr32(TG3_CPMU_EEE_MODE) & ~TG3_CPMU_EEEMD_LPI_ENABLE);
    4362                 :            : 
    4363                 :          0 :         err = tg3_phy_toggle_auxctl_smdsp(tp, true);
    4364         [ #  # ]:          0 :         if (!err) {
    4365                 :          0 :                 u32 err2;
    4366                 :            : 
    4367                 :          0 :                 val = 0;
    4368                 :            :                 /* Advertise 100-BaseTX EEE ability */
    4369         [ #  # ]:          0 :                 if (advertise & ADVERTISED_100baseT_Full)
    4370                 :          0 :                         val |= MDIO_AN_EEE_ADV_100TX;
    4371                 :            :                 /* Advertise 1000-BaseT EEE ability */
    4372         [ #  # ]:          0 :                 if (advertise & ADVERTISED_1000baseT_Full)
    4373                 :          0 :                         val |= MDIO_AN_EEE_ADV_1000T;
    4374                 :            : 
    4375         [ #  # ]:          0 :                 if (!tp->eee.eee_enabled) {
    4376                 :          0 :                         val = 0;
    4377                 :          0 :                         tp->eee.advertised = 0;
    4378                 :            :                 } else {
    4379                 :          0 :                         tp->eee.advertised = advertise &
    4380                 :            :                                              (ADVERTISED_100baseT_Full |
    4381                 :            :                                               ADVERTISED_1000baseT_Full);
    4382                 :            :                 }
    4383                 :            : 
    4384                 :          0 :                 err = tg3_phy_cl45_write(tp, MDIO_MMD_AN, MDIO_AN_EEE_ADV, val);
    4385         [ #  # ]:          0 :                 if (err)
    4386                 :          0 :                         val = 0;
    4387                 :            : 
    4388      [ #  #  # ]:          0 :                 switch (tg3_asic_rev(tp)) {
    4389                 :          0 :                 case ASIC_REV_5717:
    4390                 :            :                 case ASIC_REV_57765:
    4391                 :            :                 case ASIC_REV_57766:
    4392                 :            :                 case ASIC_REV_5719:
    4393                 :            :                         /* If we advertised any eee advertisements above... */
    4394         [ #  # ]:          0 :                         if (val)
    4395                 :          0 :                                 val = MII_TG3_DSP_TAP26_ALNOKO |
    4396                 :            :                                       MII_TG3_DSP_TAP26_RMRXSTO |
    4397                 :            :                                       MII_TG3_DSP_TAP26_OPCSINPT;
    4398                 :          0 :                         tg3_phydsp_write(tp, MII_TG3_DSP_TAP26, val);
    4399                 :            :                         /* Fall through */
    4400                 :          0 :                 case ASIC_REV_5720:
    4401                 :            :                 case ASIC_REV_5762:
    4402         [ #  # ]:          0 :                         if (!tg3_phydsp_read(tp, MII_TG3_DSP_CH34TP2, &val))
    4403                 :          0 :                                 tg3_phydsp_write(tp, MII_TG3_DSP_CH34TP2, val |
    4404                 :            :                                                  MII_TG3_DSP_CH34TP2_HIBW01);
    4405                 :            :                 }
    4406                 :            : 
    4407                 :          0 :                 err2 = tg3_phy_toggle_auxctl_smdsp(tp, false);
    4408         [ #  # ]:          0 :                 if (!err)
    4409                 :          0 :                         err = err2;
    4410                 :            :         }
    4411                 :            : 
    4412                 :          0 : done:
    4413                 :          0 :         return err;
    4414                 :            : }
    4415                 :            : 
    4416                 :          0 : static void tg3_phy_copper_begin(struct tg3 *tp)
    4417                 :            : {
    4418         [ #  # ]:          0 :         if (tp->link_config.autoneg == AUTONEG_ENABLE ||
    4419         [ #  # ]:          0 :             (tp->phy_flags & TG3_PHYFLG_IS_LOW_POWER)) {
    4420                 :          0 :                 u32 adv, fc;
    4421                 :            : 
    4422         [ #  # ]:          0 :                 if ((tp->phy_flags & TG3_PHYFLG_IS_LOW_POWER) &&
    4423                 :            :                     !(tp->phy_flags & TG3_PHYFLG_KEEP_LINK_ON_PWRDN)) {
    4424                 :          0 :                         adv = ADVERTISED_10baseT_Half |
    4425                 :            :                               ADVERTISED_10baseT_Full;
    4426         [ #  # ]:          0 :                         if (tg3_flag(tp, WOL_SPEED_100MB))
    4427                 :          0 :                                 adv |= ADVERTISED_100baseT_Half |
    4428                 :            :                                        ADVERTISED_100baseT_Full;
    4429         [ #  # ]:          0 :                         if (tp->phy_flags & TG3_PHYFLG_1G_ON_VAUX_OK) {
    4430         [ #  # ]:          0 :                                 if (!(tp->phy_flags &
    4431                 :            :                                       TG3_PHYFLG_DISABLE_1G_HD_ADV))
    4432                 :          0 :                                         adv |= ADVERTISED_1000baseT_Half;
    4433                 :          0 :                                 adv |= ADVERTISED_1000baseT_Full;
    4434                 :            :                         }
    4435                 :            : 
    4436                 :            :                         fc = FLOW_CTRL_TX | FLOW_CTRL_RX;
    4437                 :            :                 } else {
    4438                 :          0 :                         adv = tp->link_config.advertising;
    4439         [ #  # ]:          0 :                         if (tp->phy_flags & TG3_PHYFLG_10_100_ONLY)
    4440                 :          0 :                                 adv &= ~(ADVERTISED_1000baseT_Half |
    4441                 :            :                                          ADVERTISED_1000baseT_Full);
    4442                 :            : 
    4443                 :          0 :                         fc = tp->link_config.flowctrl;
    4444                 :            :                 }
    4445                 :            : 
    4446                 :          0 :                 tg3_phy_autoneg_cfg(tp, adv, fc);
    4447                 :            : 
    4448         [ #  # ]:          0 :                 if ((tp->phy_flags & TG3_PHYFLG_IS_LOW_POWER) &&
    4449                 :            :                     (tp->phy_flags & TG3_PHYFLG_KEEP_LINK_ON_PWRDN)) {
    4450                 :            :                         /* Normally during power down we want to autonegotiate
    4451                 :            :                          * the lowest possible speed for WOL. However, to avoid
    4452                 :            :                          * link flap, we leave it untouched.
    4453                 :            :                          */
    4454                 :            :                         return;
    4455                 :            :                 }
    4456                 :            : 
    4457                 :          0 :                 tg3_writephy(tp, MII_BMCR,
    4458                 :            :                              BMCR_ANENABLE | BMCR_ANRESTART);
    4459                 :            :         } else {
    4460                 :          0 :                 int i;
    4461                 :          0 :                 u32 bmcr, orig_bmcr;
    4462                 :            : 
    4463                 :          0 :                 tp->link_config.active_speed = tp->link_config.speed;
    4464                 :          0 :                 tp->link_config.active_duplex = tp->link_config.duplex;
    4465                 :            : 
    4466         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5714) {
    4467                 :            :                         /* With autoneg disabled, 5715 only links up when the
    4468                 :            :                          * advertisement register has the configured speed
    4469                 :            :                          * enabled.
    4470                 :            :                          */
    4471                 :          0 :                         tg3_writephy(tp, MII_ADVERTISE, ADVERTISE_ALL);
    4472                 :            :                 }
    4473                 :            : 
    4474                 :          0 :                 bmcr = 0;
    4475      [ #  #  # ]:          0 :                 switch (tp->link_config.speed) {
    4476                 :            :                 default:
    4477                 :            :                 case SPEED_10:
    4478                 :            :                         break;
    4479                 :            : 
    4480                 :          0 :                 case SPEED_100:
    4481                 :          0 :                         bmcr |= BMCR_SPEED100;
    4482                 :          0 :                         break;
    4483                 :            : 
    4484                 :          0 :                 case SPEED_1000:
    4485                 :          0 :                         bmcr |= BMCR_SPEED1000;
    4486                 :          0 :                         break;
    4487                 :            :                 }
    4488                 :            : 
    4489         [ #  # ]:          0 :                 if (tp->link_config.duplex == DUPLEX_FULL)
    4490                 :          0 :                         bmcr |= BMCR_FULLDPLX;
    4491                 :            : 
    4492         [ #  # ]:          0 :                 if (!tg3_readphy(tp, MII_BMCR, &orig_bmcr) &&
    4493         [ #  # ]:          0 :                     (bmcr != orig_bmcr)) {
    4494                 :          0 :                         tg3_writephy(tp, MII_BMCR, BMCR_LOOPBACK);
    4495         [ #  # ]:          0 :                         for (i = 0; i < 1500; i++) {
    4496                 :          0 :                                 u32 tmp;
    4497                 :            : 
    4498                 :          0 :                                 udelay(10);
    4499   [ #  #  #  # ]:          0 :                                 if (tg3_readphy(tp, MII_BMSR, &tmp) ||
    4500                 :            :                                     tg3_readphy(tp, MII_BMSR, &tmp))
    4501                 :          0 :                                         continue;
    4502         [ #  # ]:          0 :                                 if (!(tmp & BMSR_LSTATUS)) {
    4503                 :          0 :                                         udelay(40);
    4504                 :          0 :                                         break;
    4505                 :            :                                 }
    4506                 :            :                         }
    4507                 :          0 :                         tg3_writephy(tp, MII_BMCR, bmcr);
    4508                 :          0 :                         udelay(40);
    4509                 :            :                 }
    4510                 :            :         }
    4511                 :            : }
    4512                 :            : 
    4513                 :          0 : static int tg3_phy_pull_config(struct tg3 *tp)
    4514                 :            : {
    4515                 :          0 :         int err;
    4516                 :          0 :         u32 val;
    4517                 :            : 
    4518                 :          0 :         err = tg3_readphy(tp, MII_BMCR, &val);
    4519         [ #  # ]:          0 :         if (err)
    4520                 :          0 :                 goto done;
    4521                 :            : 
    4522         [ #  # ]:          0 :         if (!(val & BMCR_ANENABLE)) {
    4523                 :          0 :                 tp->link_config.autoneg = AUTONEG_DISABLE;
    4524                 :          0 :                 tp->link_config.advertising = 0;
    4525                 :          0 :                 tg3_flag_clear(tp, PAUSE_AUTONEG);
    4526                 :            : 
    4527                 :          0 :                 err = -EIO;
    4528                 :            : 
    4529   [ #  #  #  # ]:          0 :                 switch (val & (BMCR_SPEED1000 | BMCR_SPEED100)) {
    4530                 :          0 :                 case 0:
    4531         [ #  # ]:          0 :                         if (tp->phy_flags & TG3_PHYFLG_ANY_SERDES)
    4532                 :          0 :                                 goto done;
    4533                 :            : 
    4534                 :          0 :                         tp->link_config.speed = SPEED_10;
    4535                 :          0 :                         break;
    4536                 :          0 :                 case BMCR_SPEED100:
    4537         [ #  # ]:          0 :                         if (tp->phy_flags & TG3_PHYFLG_ANY_SERDES)
    4538                 :          0 :                                 goto done;
    4539                 :            : 
    4540                 :          0 :                         tp->link_config.speed = SPEED_100;
    4541                 :          0 :                         break;
    4542                 :          0 :                 case BMCR_SPEED1000:
    4543         [ #  # ]:          0 :                         if (!(tp->phy_flags & TG3_PHYFLG_10_100_ONLY)) {
    4544                 :          0 :                                 tp->link_config.speed = SPEED_1000;
    4545                 :          0 :                                 break;
    4546                 :            :                         }
    4547                 :            :                         /* Fall through */
    4548                 :            :                 default:
    4549                 :          0 :                         goto done;
    4550                 :            :                 }
    4551                 :            : 
    4552         [ #  # ]:          0 :                 if (val & BMCR_FULLDPLX)
    4553                 :          0 :                         tp->link_config.duplex = DUPLEX_FULL;
    4554                 :            :                 else
    4555                 :          0 :                         tp->link_config.duplex = DUPLEX_HALF;
    4556                 :            : 
    4557                 :          0 :                 tp->link_config.flowctrl = FLOW_CTRL_RX | FLOW_CTRL_TX;
    4558                 :            : 
    4559                 :          0 :                 err = 0;
    4560                 :          0 :                 goto done;
    4561                 :            :         }
    4562                 :            : 
    4563                 :          0 :         tp->link_config.autoneg = AUTONEG_ENABLE;
    4564                 :          0 :         tp->link_config.advertising = ADVERTISED_Autoneg;
    4565                 :          0 :         tg3_flag_set(tp, PAUSE_AUTONEG);
    4566                 :            : 
    4567         [ #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_ANY_SERDES)) {
    4568                 :          0 :                 u32 adv;
    4569                 :            : 
    4570                 :          0 :                 err = tg3_readphy(tp, MII_ADVERTISE, &val);
    4571         [ #  # ]:          0 :                 if (err)
    4572                 :          0 :                         goto done;
    4573                 :            : 
    4574                 :          0 :                 adv = mii_adv_to_ethtool_adv_t(val & ADVERTISE_ALL);
    4575                 :          0 :                 tp->link_config.advertising |= adv | ADVERTISED_TP;
    4576                 :            : 
    4577         [ #  # ]:          0 :                 tp->link_config.flowctrl = tg3_decode_flowctrl_1000T(val);
    4578                 :            :         } else {
    4579                 :          0 :                 tp->link_config.advertising |= ADVERTISED_FIBRE;
    4580                 :            :         }
    4581                 :            : 
    4582         [ #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_10_100_ONLY)) {
    4583                 :          0 :                 u32 adv;
    4584                 :            : 
    4585         [ #  # ]:          0 :                 if (!(tp->phy_flags & TG3_PHYFLG_ANY_SERDES)) {
    4586                 :          0 :                         err = tg3_readphy(tp, MII_CTRL1000, &val);
    4587         [ #  # ]:          0 :                         if (err)
    4588                 :          0 :                                 goto done;
    4589                 :            : 
    4590         [ #  # ]:          0 :                         adv = mii_ctrl1000_to_ethtool_adv_t(val);
    4591                 :            :                 } else {
    4592                 :          0 :                         err = tg3_readphy(tp, MII_ADVERTISE, &val);
    4593         [ #  # ]:          0 :                         if (err)
    4594                 :          0 :                                 goto done;
    4595                 :            : 
    4596         [ #  # ]:          0 :                         adv = tg3_decode_flowctrl_1000X(val);
    4597                 :          0 :                         tp->link_config.flowctrl = adv;
    4598                 :            : 
    4599                 :          0 :                         val &= (ADVERTISE_1000XHALF | ADVERTISE_1000XFULL);
    4600         [ #  # ]:          0 :                         adv = mii_adv_to_ethtool_adv_x(val);
    4601                 :            :                 }
    4602                 :            : 
    4603                 :          0 :                 tp->link_config.advertising |= adv;
    4604                 :            :         }
    4605                 :            : 
    4606                 :          0 : done:
    4607                 :          0 :         return err;
    4608                 :            : }
    4609                 :            : 
    4610                 :          0 : static int tg3_init_5401phy_dsp(struct tg3 *tp)
    4611                 :            : {
    4612                 :          0 :         int err;
    4613                 :            : 
    4614                 :            :         /* Turn off tap power management. */
    4615                 :            :         /* Set Extended packet length bit */
    4616                 :          0 :         err = tg3_phy_auxctl_write(tp, MII_TG3_AUXCTL_SHDWSEL_AUXCTL, 0x4c20);
    4617                 :            : 
    4618                 :          0 :         err |= tg3_phydsp_write(tp, 0x0012, 0x1804);
    4619                 :          0 :         err |= tg3_phydsp_write(tp, 0x0013, 0x1204);
    4620                 :          0 :         err |= tg3_phydsp_write(tp, 0x8006, 0x0132);
    4621                 :          0 :         err |= tg3_phydsp_write(tp, 0x8006, 0x0232);
    4622                 :          0 :         err |= tg3_phydsp_write(tp, 0x201f, 0x0a20);
    4623                 :            : 
    4624                 :          0 :         udelay(40);
    4625                 :            : 
    4626                 :          0 :         return err;
    4627                 :            : }
    4628                 :            : 
    4629                 :          0 : static bool tg3_phy_eee_config_ok(struct tg3 *tp)
    4630                 :            : {
    4631                 :          0 :         struct ethtool_eee eee;
    4632                 :            : 
    4633         [ #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_EEE_CAP))
    4634                 :            :                 return true;
    4635                 :            : 
    4636                 :          0 :         tg3_eee_pull_config(tp, &eee);
    4637                 :            : 
    4638         [ #  # ]:          0 :         if (tp->eee.eee_enabled) {
    4639         [ #  # ]:          0 :                 if (tp->eee.advertised != eee.advertised ||
    4640         [ #  # ]:          0 :                     tp->eee.tx_lpi_timer != eee.tx_lpi_timer ||
    4641         [ #  # ]:          0 :                     tp->eee.tx_lpi_enabled != eee.tx_lpi_enabled)
    4642                 :          0 :                         return false;
    4643                 :            :         } else {
    4644                 :            :                 /* EEE is disabled but we're advertising */
    4645         [ #  # ]:          0 :                 if (eee.advertised)
    4646                 :          0 :                         return false;
    4647                 :            :         }
    4648                 :            : 
    4649                 :            :         return true;
    4650                 :            : }
    4651                 :            : 
    4652                 :          0 : static bool tg3_phy_copper_an_config_ok(struct tg3 *tp, u32 *lcladv)
    4653                 :            : {
    4654                 :          0 :         u32 advmsk, tgtadv, advertising;
    4655                 :            : 
    4656                 :          0 :         advertising = tp->link_config.advertising;
    4657                 :          0 :         tgtadv = ethtool_adv_to_mii_adv_t(advertising) & ADVERTISE_ALL;
    4658                 :            : 
    4659                 :          0 :         advmsk = ADVERTISE_ALL;
    4660         [ #  # ]:          0 :         if (tp->link_config.active_duplex == DUPLEX_FULL) {
    4661         [ #  # ]:          0 :                 tgtadv |= mii_advertise_flowctrl(tp->link_config.flowctrl);
    4662                 :          0 :                 advmsk |= ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM;
    4663                 :            :         }
    4664                 :            : 
    4665         [ #  # ]:          0 :         if (tg3_readphy(tp, MII_ADVERTISE, lcladv))
    4666                 :            :                 return false;
    4667                 :            : 
    4668         [ #  # ]:          0 :         if ((*lcladv & advmsk) != tgtadv)
    4669                 :            :                 return false;
    4670                 :            : 
    4671         [ #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_10_100_ONLY)) {
    4672                 :          0 :                 u32 tg3_ctrl;
    4673                 :            : 
    4674         [ #  # ]:          0 :                 tgtadv = ethtool_adv_to_mii_ctrl1000_t(advertising);
    4675                 :            : 
    4676         [ #  # ]:          0 :                 if (tg3_readphy(tp, MII_CTRL1000, &tg3_ctrl))
    4677                 :          0 :                         return false;
    4678                 :            : 
    4679         [ #  # ]:          0 :                 if (tgtadv &&
    4680         [ #  # ]:          0 :                     (tg3_chip_rev_id(tp) == CHIPREV_ID_5701_A0 ||
    4681                 :            :                      tg3_chip_rev_id(tp) == CHIPREV_ID_5701_B0)) {
    4682                 :          0 :                         tgtadv |= CTL1000_AS_MASTER | CTL1000_ENABLE_MASTER;
    4683                 :          0 :                         tg3_ctrl &= (ADVERTISE_1000HALF | ADVERTISE_1000FULL |
    4684                 :            :                                      CTL1000_AS_MASTER | CTL1000_ENABLE_MASTER);
    4685                 :            :                 } else {
    4686                 :          0 :                         tg3_ctrl &= (ADVERTISE_1000HALF | ADVERTISE_1000FULL);
    4687                 :            :                 }
    4688                 :            : 
    4689         [ #  # ]:          0 :                 if (tg3_ctrl != tgtadv)
    4690                 :            :                         return false;
    4691                 :            :         }
    4692                 :            : 
    4693                 :            :         return true;
    4694                 :            : }
    4695                 :            : 
    4696                 :          0 : static bool tg3_phy_copper_fetch_rmtadv(struct tg3 *tp, u32 *rmtadv)
    4697                 :            : {
    4698                 :          0 :         u32 lpeth = 0;
    4699                 :            : 
    4700         [ #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_10_100_ONLY)) {
    4701                 :          0 :                 u32 val;
    4702                 :            : 
    4703         [ #  # ]:          0 :                 if (tg3_readphy(tp, MII_STAT1000, &val))
    4704                 :          0 :                         return false;
    4705                 :            : 
    4706         [ #  # ]:          0 :                 lpeth = mii_stat1000_to_ethtool_lpa_t(val);
    4707                 :            :         }
    4708                 :            : 
    4709         [ #  # ]:          0 :         if (tg3_readphy(tp, MII_LPA, rmtadv))
    4710                 :            :                 return false;
    4711                 :            : 
    4712         [ #  # ]:          0 :         lpeth |= mii_lpa_to_ethtool_lpa_t(*rmtadv);
    4713                 :          0 :         tp->link_config.rmt_adv = lpeth;
    4714                 :            : 
    4715                 :          0 :         return true;
    4716                 :            : }
    4717                 :            : 
    4718                 :          0 : static bool tg3_test_and_report_link_chg(struct tg3 *tp, bool curr_link_up)
    4719                 :            : {
    4720         [ #  # ]:          0 :         if (curr_link_up != tp->link_up) {
    4721         [ #  # ]:          0 :                 if (curr_link_up) {
    4722                 :          0 :                         netif_carrier_on(tp->dev);
    4723                 :            :                 } else {
    4724                 :          0 :                         netif_carrier_off(tp->dev);
    4725         [ #  # ]:          0 :                         if (tp->phy_flags & TG3_PHYFLG_MII_SERDES)
    4726                 :          0 :                                 tp->phy_flags &= ~TG3_PHYFLG_PARALLEL_DETECT;
    4727                 :            :                 }
    4728                 :            : 
    4729                 :          0 :                 tg3_link_report(tp);
    4730                 :          0 :                 return true;
    4731                 :            :         }
    4732                 :            : 
    4733                 :            :         return false;
    4734                 :            : }
    4735                 :            : 
    4736                 :          0 : static void tg3_clear_mac_status(struct tg3 *tp)
    4737                 :            : {
    4738                 :          0 :         tw32(MAC_EVENT, 0);
    4739                 :            : 
    4740                 :          0 :         tw32_f(MAC_STATUS,
    4741                 :            :                MAC_STATUS_SYNC_CHANGED |
    4742                 :            :                MAC_STATUS_CFG_CHANGED |
    4743                 :            :                MAC_STATUS_MI_COMPLETION |
    4744                 :            :                MAC_STATUS_LNKSTATE_CHANGED);
    4745                 :          0 :         udelay(40);
    4746                 :          0 : }
    4747                 :            : 
    4748                 :          0 : static void tg3_setup_eee(struct tg3 *tp)
    4749                 :            : {
    4750                 :          0 :         u32 val;
    4751                 :            : 
    4752                 :          0 :         val = TG3_CPMU_EEE_LNKIDL_PCIE_NL0 |
    4753                 :            :               TG3_CPMU_EEE_LNKIDL_UART_IDL;
    4754         [ #  # ]:          0 :         if (tg3_chip_rev_id(tp) == CHIPREV_ID_57765_A0)
    4755                 :          0 :                 val |= TG3_CPMU_EEE_LNKIDL_APE_TX_MT;
    4756                 :            : 
    4757                 :          0 :         tw32_f(TG3_CPMU_EEE_LNKIDL_CTRL, val);
    4758                 :            : 
    4759                 :          0 :         tw32_f(TG3_CPMU_EEE_CTRL,
    4760                 :            :                TG3_CPMU_EEE_CTRL_EXIT_20_1_US);
    4761                 :            : 
    4762                 :          0 :         val = TG3_CPMU_EEEMD_ERLY_L1_XIT_DET |
    4763                 :          0 :               (tp->eee.tx_lpi_enabled ? TG3_CPMU_EEEMD_LPI_IN_TX : 0) |
    4764         [ #  # ]:          0 :               TG3_CPMU_EEEMD_LPI_IN_RX |
    4765                 :            :               TG3_CPMU_EEEMD_EEE_ENABLE;
    4766                 :            : 
    4767         [ #  # ]:          0 :         if (tg3_asic_rev(tp) != ASIC_REV_5717)
    4768                 :          0 :                 val |= TG3_CPMU_EEEMD_SND_IDX_DET_EN;
    4769                 :            : 
    4770         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_APE))
    4771                 :          0 :                 val |= TG3_CPMU_EEEMD_APE_TX_DET_EN;
    4772                 :            : 
    4773         [ #  # ]:          0 :         tw32_f(TG3_CPMU_EEE_MODE, tp->eee.eee_enabled ? val : 0);
    4774                 :            : 
    4775                 :          0 :         tw32_f(TG3_CPMU_EEE_DBTMR1,
    4776                 :            :                TG3_CPMU_DBTMR1_PCIEXIT_2047US |
    4777                 :            :                (tp->eee.tx_lpi_timer & 0xffff));
    4778                 :            : 
    4779                 :          0 :         tw32_f(TG3_CPMU_EEE_DBTMR2,
    4780                 :            :                TG3_CPMU_DBTMR2_APE_TX_2047US |
    4781                 :            :                TG3_CPMU_DBTMR2_TXIDXEQ_2047US);
    4782                 :          0 : }
    4783                 :            : 
    4784                 :          0 : static int tg3_setup_copper_phy(struct tg3 *tp, bool force_reset)
    4785                 :            : {
    4786                 :          0 :         bool current_link_up;
    4787                 :          0 :         u32 bmsr, val;
    4788                 :          0 :         u32 lcl_adv, rmt_adv;
    4789                 :          0 :         u32 current_speed;
    4790                 :          0 :         u8 current_duplex;
    4791                 :          0 :         int i, err;
    4792                 :            : 
    4793                 :          0 :         tg3_clear_mac_status(tp);
    4794                 :            : 
    4795         [ #  # ]:          0 :         if ((tp->mi_mode & MAC_MI_MODE_AUTO_POLL) != 0) {
    4796                 :          0 :                 tw32_f(MAC_MI_MODE,
    4797                 :            :                      (tp->mi_mode & ~MAC_MI_MODE_AUTO_POLL));
    4798                 :          0 :                 udelay(80);
    4799                 :            :         }
    4800                 :            : 
    4801                 :          0 :         tg3_phy_auxctl_write(tp, MII_TG3_AUXCTL_SHDWSEL_PWRCTL, 0);
    4802                 :            : 
    4803                 :            :         /* Some third-party PHYs need to be reset on link going
    4804                 :            :          * down.
    4805                 :            :          */
    4806                 :          0 :         if ((tg3_asic_rev(tp) == ASIC_REV_5703 ||
    4807         [ #  # ]:          0 :              tg3_asic_rev(tp) == ASIC_REV_5704 ||
    4808                 :          0 :              tg3_asic_rev(tp) == ASIC_REV_5705) &&
    4809         [ #  # ]:          0 :             tp->link_up) {
    4810                 :          0 :                 tg3_readphy(tp, MII_BMSR, &bmsr);
    4811         [ #  # ]:          0 :                 if (!tg3_readphy(tp, MII_BMSR, &bmsr) &&
    4812         [ #  # ]:          0 :                     !(bmsr & BMSR_LSTATUS))
    4813                 :            :                         force_reset = true;
    4814                 :            :         }
    4815         [ #  # ]:          0 :         if (force_reset)
    4816                 :          0 :                 tg3_phy_reset(tp);
    4817                 :            : 
    4818         [ #  # ]:          0 :         if ((tp->phy_id & TG3_PHY_ID_MASK) == TG3_PHY_ID_BCM5401) {
    4819                 :          0 :                 tg3_readphy(tp, MII_BMSR, &bmsr);
    4820   [ #  #  #  # ]:          0 :                 if (tg3_readphy(tp, MII_BMSR, &bmsr) ||
    4821                 :          0 :                     !tg3_flag(tp, INIT_COMPLETE))
    4822                 :          0 :                         bmsr = 0;
    4823                 :            : 
    4824         [ #  # ]:          0 :                 if (!(bmsr & BMSR_LSTATUS)) {
    4825                 :          0 :                         err = tg3_init_5401phy_dsp(tp);
    4826         [ #  # ]:          0 :                         if (err)
    4827                 :            :                                 return err;
    4828                 :            : 
    4829                 :          0 :                         tg3_readphy(tp, MII_BMSR, &bmsr);
    4830         [ #  # ]:          0 :                         for (i = 0; i < 1000; i++) {
    4831                 :          0 :                                 udelay(10);
    4832         [ #  # ]:          0 :                                 if (!tg3_readphy(tp, MII_BMSR, &bmsr) &&
    4833         [ #  # ]:          0 :                                     (bmsr & BMSR_LSTATUS)) {
    4834                 :          0 :                                         udelay(40);
    4835                 :            :                                         break;
    4836                 :            :                                 }
    4837                 :            :                         }
    4838                 :            : 
    4839         [ #  # ]:          0 :                         if ((tp->phy_id & TG3_PHY_ID_REV_MASK) ==
    4840                 :          0 :                             TG3_PHY_REV_BCM5401_B0 &&
    4841         [ #  # ]:          0 :                             !(bmsr & BMSR_LSTATUS) &&
    4842         [ #  # ]:          0 :                             tp->link_config.active_speed == SPEED_1000) {
    4843                 :          0 :                                 err = tg3_phy_reset(tp);
    4844         [ #  # ]:          0 :                                 if (!err)
    4845                 :          0 :                                         err = tg3_init_5401phy_dsp(tp);
    4846         [ #  # ]:          0 :                                 if (err)
    4847                 :            :                                         return err;
    4848                 :            :                         }
    4849                 :            :                 }
    4850         [ #  # ]:          0 :         } else if (tg3_chip_rev_id(tp) == CHIPREV_ID_5701_A0 ||
    4851                 :            :                    tg3_chip_rev_id(tp) == CHIPREV_ID_5701_B0) {
    4852                 :            :                 /* 5701 {A0,B0} CRC bug workaround */
    4853                 :          0 :                 tg3_writephy(tp, 0x15, 0x0a75);
    4854                 :          0 :                 tg3_writephy(tp, MII_TG3_MISC_SHDW, 0x8c68);
    4855                 :          0 :                 tg3_writephy(tp, MII_TG3_MISC_SHDW, 0x8d68);
    4856                 :          0 :                 tg3_writephy(tp, MII_TG3_MISC_SHDW, 0x8c68);
    4857                 :            :         }
    4858                 :            : 
    4859                 :            :         /* Clear pending interrupts... */
    4860                 :          0 :         tg3_readphy(tp, MII_TG3_ISTAT, &val);
    4861                 :          0 :         tg3_readphy(tp, MII_TG3_ISTAT, &val);
    4862                 :            : 
    4863         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_USE_MI_INTERRUPT)
    4864                 :          0 :                 tg3_writephy(tp, MII_TG3_IMASK, ~MII_TG3_INT_LINKCHG);
    4865         [ #  # ]:          0 :         else if (!(tp->phy_flags & TG3_PHYFLG_IS_FET))
    4866                 :          0 :                 tg3_writephy(tp, MII_TG3_IMASK, ~0);
    4867                 :            : 
    4868         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5700 ||
    4869                 :            :             tg3_asic_rev(tp) == ASIC_REV_5701) {
    4870         [ #  # ]:          0 :                 if (tp->led_ctrl == LED_CTRL_MODE_PHY_1)
    4871                 :          0 :                         tg3_writephy(tp, MII_TG3_EXT_CTRL,
    4872                 :            :                                      MII_TG3_EXT_CTRL_LNK3_LED_MODE);
    4873                 :            :                 else
    4874                 :          0 :                         tg3_writephy(tp, MII_TG3_EXT_CTRL, 0);
    4875                 :            :         }
    4876                 :            : 
    4877                 :          0 :         current_link_up = false;
    4878                 :          0 :         current_speed = SPEED_UNKNOWN;
    4879                 :          0 :         current_duplex = DUPLEX_UNKNOWN;
    4880                 :          0 :         tp->phy_flags &= ~TG3_PHYFLG_MDIX_STATE;
    4881                 :          0 :         tp->link_config.rmt_adv = 0;
    4882                 :            : 
    4883         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_CAPACITIVE_COUPLING) {
    4884                 :          0 :                 err = tg3_phy_auxctl_read(tp,
    4885                 :            :                                           MII_TG3_AUXCTL_SHDWSEL_MISCTEST,
    4886                 :            :                                           &val);
    4887   [ #  #  #  # ]:          0 :                 if (!err && !(val & (1 << 10))) {
    4888                 :          0 :                         tg3_phy_auxctl_write(tp,
    4889                 :            :                                              MII_TG3_AUXCTL_SHDWSEL_MISCTEST,
    4890                 :            :                                              val | (1 << 10));
    4891                 :          0 :                         goto relink;
    4892                 :            :                 }
    4893                 :            :         }
    4894                 :            : 
    4895                 :          0 :         bmsr = 0;
    4896         [ #  # ]:          0 :         for (i = 0; i < 100; i++) {
    4897                 :          0 :                 tg3_readphy(tp, MII_BMSR, &bmsr);
    4898         [ #  # ]:          0 :                 if (!tg3_readphy(tp, MII_BMSR, &bmsr) &&
    4899         [ #  # ]:          0 :                     (bmsr & BMSR_LSTATUS))
    4900                 :            :                         break;
    4901                 :          0 :                 udelay(40);
    4902                 :            :         }
    4903                 :            : 
    4904         [ #  # ]:          0 :         if (bmsr & BMSR_LSTATUS) {
    4905                 :          0 :                 u32 aux_stat, bmcr;
    4906                 :            : 
    4907                 :          0 :                 tg3_readphy(tp, MII_TG3_AUX_STAT, &aux_stat);
    4908         [ #  # ]:          0 :                 for (i = 0; i < 2000; i++) {
    4909                 :          0 :                         udelay(10);
    4910   [ #  #  #  # ]:          0 :                         if (!tg3_readphy(tp, MII_TG3_AUX_STAT, &aux_stat) &&
    4911                 :            :                             aux_stat)
    4912                 :            :                                 break;
    4913                 :            :                 }
    4914                 :            : 
    4915                 :          0 :                 tg3_aux_stat_to_speed_duplex(tp, aux_stat,
    4916                 :            :                                              &current_speed,
    4917                 :            :                                              &current_duplex);
    4918                 :            : 
    4919                 :          0 :                 bmcr = 0;
    4920         [ #  # ]:          0 :                 for (i = 0; i < 200; i++) {
    4921                 :          0 :                         tg3_readphy(tp, MII_BMCR, &bmcr);
    4922         [ #  # ]:          0 :                         if (tg3_readphy(tp, MII_BMCR, &bmcr))
    4923                 :          0 :                                 continue;
    4924         [ #  # ]:          0 :                         if (bmcr && bmcr != 0x7fff)
    4925                 :            :                                 break;
    4926                 :          0 :                         udelay(10);
    4927                 :            :                 }
    4928                 :            : 
    4929                 :          0 :                 lcl_adv = 0;
    4930                 :          0 :                 rmt_adv = 0;
    4931                 :            : 
    4932                 :          0 :                 tp->link_config.active_speed = current_speed;
    4933                 :          0 :                 tp->link_config.active_duplex = current_duplex;
    4934                 :            : 
    4935         [ #  # ]:          0 :                 if (tp->link_config.autoneg == AUTONEG_ENABLE) {
    4936                 :          0 :                         bool eee_config_ok = tg3_phy_eee_config_ok(tp);
    4937                 :            : 
    4938   [ #  #  #  # ]:          0 :                         if ((bmcr & BMCR_ANENABLE) &&
    4939         [ #  # ]:          0 :                             eee_config_ok &&
    4940         [ #  # ]:          0 :                             tg3_phy_copper_an_config_ok(tp, &lcl_adv) &&
    4941                 :          0 :                             tg3_phy_copper_fetch_rmtadv(tp, &rmt_adv))
    4942                 :          0 :                                 current_link_up = true;
    4943                 :            : 
    4944                 :            :                         /* EEE settings changes take effect only after a phy
    4945                 :            :                          * reset.  If we have skipped a reset due to Link Flap
    4946                 :            :                          * Avoidance being enabled, do it now.
    4947                 :            :                          */
    4948         [ #  # ]:          0 :                         if (!eee_config_ok &&
    4949   [ #  #  #  # ]:          0 :                             (tp->phy_flags & TG3_PHYFLG_KEEP_LINK_ON_PWRDN) &&
    4950                 :            :                             !force_reset) {
    4951                 :          0 :                                 tg3_setup_eee(tp);
    4952                 :          0 :                                 tg3_phy_reset(tp);
    4953                 :            :                         }
    4954                 :            :                 } else {
    4955         [ #  # ]:          0 :                         if (!(bmcr & BMCR_ANENABLE) &&
    4956         [ #  # ]:          0 :                             tp->link_config.speed == current_speed &&
    4957         [ #  # ]:          0 :                             tp->link_config.duplex == current_duplex) {
    4958                 :            :                                 current_link_up = true;
    4959                 :            :                         }
    4960                 :            :                 }
    4961                 :            : 
    4962         [ #  # ]:          0 :                 if (current_link_up &&
    4963         [ #  # ]:          0 :                     tp->link_config.active_duplex == DUPLEX_FULL) {
    4964                 :          0 :                         u32 reg, bit;
    4965                 :            : 
    4966         [ #  # ]:          0 :                         if (tp->phy_flags & TG3_PHYFLG_IS_FET) {
    4967                 :            :                                 reg = MII_TG3_FET_GEN_STAT;
    4968                 :            :                                 bit = MII_TG3_FET_GEN_STAT_MDIXSTAT;
    4969                 :            :                         } else {
    4970                 :          0 :                                 reg = MII_TG3_EXT_STAT;
    4971                 :          0 :                                 bit = MII_TG3_EXT_STAT_MDIX;
    4972                 :            :                         }
    4973                 :            : 
    4974   [ #  #  #  # ]:          0 :                         if (!tg3_readphy(tp, reg, &val) && (val & bit))
    4975                 :          0 :                                 tp->phy_flags |= TG3_PHYFLG_MDIX_STATE;
    4976                 :            : 
    4977                 :          0 :                         tg3_setup_flow_control(tp, lcl_adv, rmt_adv);
    4978                 :            :                 }
    4979                 :            :         }
    4980                 :            : 
    4981                 :          0 : relink:
    4982   [ #  #  #  # ]:          0 :         if (!current_link_up || (tp->phy_flags & TG3_PHYFLG_IS_LOW_POWER)) {
    4983                 :          0 :                 tg3_phy_copper_begin(tp);
    4984                 :            : 
    4985         [ #  # ]:          0 :                 if (tg3_flag(tp, ROBOSWITCH)) {
    4986                 :          0 :                         current_link_up = true;
    4987                 :            :                         /* FIXME: when BCM5325 switch is used use 100 MBit/s */
    4988                 :          0 :                         current_speed = SPEED_1000;
    4989                 :          0 :                         current_duplex = DUPLEX_FULL;
    4990                 :          0 :                         tp->link_config.active_speed = current_speed;
    4991                 :          0 :                         tp->link_config.active_duplex = current_duplex;
    4992                 :            :                 }
    4993                 :            : 
    4994                 :          0 :                 tg3_readphy(tp, MII_BMSR, &bmsr);
    4995   [ #  #  #  # ]:          0 :                 if ((!tg3_readphy(tp, MII_BMSR, &bmsr) && (bmsr & BMSR_LSTATUS)) ||
    4996         [ #  # ]:          0 :                     (tp->mac_mode & MAC_MODE_PORT_INT_LPBACK))
    4997                 :          0 :                         current_link_up = true;
    4998                 :            :         }
    4999                 :            : 
    5000                 :          0 :         tp->mac_mode &= ~MAC_MODE_PORT_MODE_MASK;
    5001         [ #  # ]:          0 :         if (current_link_up) {
    5002         [ #  # ]:          0 :                 if (tp->link_config.active_speed == SPEED_100 ||
    5003                 :            :                     tp->link_config.active_speed == SPEED_10)
    5004                 :          0 :                         tp->mac_mode |= MAC_MODE_PORT_MODE_MII;
    5005                 :            :                 else
    5006                 :          0 :                         tp->mac_mode |= MAC_MODE_PORT_MODE_GMII;
    5007         [ #  # ]:          0 :         } else if (tp->phy_flags & TG3_PHYFLG_IS_FET)
    5008                 :          0 :                 tp->mac_mode |= MAC_MODE_PORT_MODE_MII;
    5009                 :            :         else
    5010                 :          0 :                 tp->mac_mode |= MAC_MODE_PORT_MODE_GMII;
    5011                 :            : 
    5012                 :            :         /* In order for the 5750 core in BCM4785 chip to work properly
    5013                 :            :          * in RGMII mode, the Led Control Register must be set up.
    5014                 :            :          */
    5015         [ #  # ]:          0 :         if (tg3_flag(tp, RGMII_MODE)) {
    5016                 :          0 :                 u32 led_ctrl = tr32(MAC_LED_CTRL);
    5017                 :          0 :                 led_ctrl &= ~(LED_CTRL_1000MBPS_ON | LED_CTRL_100MBPS_ON);
    5018                 :            : 
    5019         [ #  # ]:          0 :                 if (tp->link_config.active_speed == SPEED_10)
    5020                 :          0 :                         led_ctrl |= LED_CTRL_LNKLED_OVERRIDE;
    5021         [ #  # ]:          0 :                 else if (tp->link_config.active_speed == SPEED_100)
    5022                 :          0 :                         led_ctrl |= (LED_CTRL_LNKLED_OVERRIDE |
    5023                 :            :                                      LED_CTRL_100MBPS_ON);
    5024         [ #  # ]:          0 :                 else if (tp->link_config.active_speed == SPEED_1000)
    5025                 :          0 :                         led_ctrl |= (LED_CTRL_LNKLED_OVERRIDE |
    5026                 :            :                                      LED_CTRL_1000MBPS_ON);
    5027                 :            : 
    5028                 :          0 :                 tw32(MAC_LED_CTRL, led_ctrl);
    5029                 :          0 :                 udelay(40);
    5030                 :            :         }
    5031                 :            : 
    5032                 :          0 :         tp->mac_mode &= ~MAC_MODE_HALF_DUPLEX;
    5033         [ #  # ]:          0 :         if (tp->link_config.active_duplex == DUPLEX_HALF)
    5034                 :          0 :                 tp->mac_mode |= MAC_MODE_HALF_DUPLEX;
    5035                 :            : 
    5036         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5700) {
    5037         [ #  # ]:          0 :                 if (current_link_up &&
    5038         [ #  # ]:          0 :                     tg3_5700_link_polarity(tp, tp->link_config.active_speed))
    5039                 :          0 :                         tp->mac_mode |= MAC_MODE_LINK_POLARITY;
    5040                 :            :                 else
    5041                 :          0 :                         tp->mac_mode &= ~MAC_MODE_LINK_POLARITY;
    5042                 :            :         }
    5043                 :            : 
    5044                 :            :         /* ??? Without this setting Netgear GA302T PHY does not
    5045                 :            :          * ??? send/receive packets...
    5046                 :            :          */
    5047   [ #  #  #  # ]:          0 :         if ((tp->phy_id & TG3_PHY_ID_MASK) == TG3_PHY_ID_BCM5411 &&
    5048                 :            :             tg3_chip_rev_id(tp) == CHIPREV_ID_5700_ALTIMA) {
    5049                 :          0 :                 tp->mi_mode |= MAC_MI_MODE_AUTO_POLL;
    5050                 :          0 :                 tw32_f(MAC_MI_MODE, tp->mi_mode);
    5051                 :          0 :                 udelay(80);
    5052                 :            :         }
    5053                 :            : 
    5054                 :          0 :         tw32_f(MAC_MODE, tp->mac_mode);
    5055                 :          0 :         udelay(40);
    5056                 :            : 
    5057                 :          0 :         tg3_phy_eee_adjust(tp, current_link_up);
    5058                 :            : 
    5059         [ #  # ]:          0 :         if (tg3_flag(tp, USE_LINKCHG_REG)) {
    5060                 :            :                 /* Polled via timer. */
    5061                 :          0 :                 tw32_f(MAC_EVENT, 0);
    5062                 :            :         } else {
    5063                 :          0 :                 tw32_f(MAC_EVENT, MAC_EVENT_LNKSTATE_CHANGED);
    5064                 :            :         }
    5065                 :          0 :         udelay(40);
    5066                 :            : 
    5067   [ #  #  #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5700 &&
    5068                 :          0 :             current_link_up &&
    5069   [ #  #  #  # ]:          0 :             tp->link_config.active_speed == SPEED_1000 &&
    5070         [ #  # ]:          0 :             (tg3_flag(tp, PCIX_MODE) || tg3_flag(tp, PCI_HIGH_SPEED))) {
    5071                 :          0 :                 udelay(120);
    5072                 :          0 :                 tw32_f(MAC_STATUS,
    5073                 :            :                      (MAC_STATUS_SYNC_CHANGED |
    5074                 :            :                       MAC_STATUS_CFG_CHANGED));
    5075                 :          0 :                 udelay(40);
    5076                 :          0 :                 tg3_write_mem(tp,
    5077                 :            :                               NIC_SRAM_FIRMWARE_MBOX,
    5078                 :            :                               NIC_SRAM_FIRMWARE_MBOX_MAGIC2);
    5079                 :            :         }
    5080                 :            : 
    5081                 :            :         /* Prevent send BD corruption. */
    5082         [ #  # ]:          0 :         if (tg3_flag(tp, CLKREQ_BUG)) {
    5083         [ #  # ]:          0 :                 if (tp->link_config.active_speed == SPEED_100 ||
    5084                 :            :                     tp->link_config.active_speed == SPEED_10)
    5085                 :          0 :                         pcie_capability_clear_word(tp->pdev, PCI_EXP_LNKCTL,
    5086                 :            :                                                    PCI_EXP_LNKCTL_CLKREQ_EN);
    5087                 :            :                 else
    5088                 :          0 :                         pcie_capability_set_word(tp->pdev, PCI_EXP_LNKCTL,
    5089                 :            :                                                  PCI_EXP_LNKCTL_CLKREQ_EN);
    5090                 :            :         }
    5091                 :            : 
    5092                 :          0 :         tg3_test_and_report_link_chg(tp, current_link_up);
    5093                 :            : 
    5094                 :          0 :         return 0;
    5095                 :            : }
    5096                 :            : 
    5097                 :            : struct tg3_fiber_aneginfo {
    5098                 :            :         int state;
    5099                 :            : #define ANEG_STATE_UNKNOWN              0
    5100                 :            : #define ANEG_STATE_AN_ENABLE            1
    5101                 :            : #define ANEG_STATE_RESTART_INIT         2
    5102                 :            : #define ANEG_STATE_RESTART              3
    5103                 :            : #define ANEG_STATE_DISABLE_LINK_OK      4
    5104                 :            : #define ANEG_STATE_ABILITY_DETECT_INIT  5
    5105                 :            : #define ANEG_STATE_ABILITY_DETECT       6
    5106                 :            : #define ANEG_STATE_ACK_DETECT_INIT      7
    5107                 :            : #define ANEG_STATE_ACK_DETECT           8
    5108                 :            : #define ANEG_STATE_COMPLETE_ACK_INIT    9
    5109                 :            : #define ANEG_STATE_COMPLETE_ACK         10
    5110                 :            : #define ANEG_STATE_IDLE_DETECT_INIT     11
    5111                 :            : #define ANEG_STATE_IDLE_DETECT          12
    5112                 :            : #define ANEG_STATE_LINK_OK              13
    5113                 :            : #define ANEG_STATE_NEXT_PAGE_WAIT_INIT  14
    5114                 :            : #define ANEG_STATE_NEXT_PAGE_WAIT       15
    5115                 :            : 
    5116                 :            :         u32 flags;
    5117                 :            : #define MR_AN_ENABLE            0x00000001
    5118                 :            : #define MR_RESTART_AN           0x00000002
    5119                 :            : #define MR_AN_COMPLETE          0x00000004
    5120                 :            : #define MR_PAGE_RX              0x00000008
    5121                 :            : #define MR_NP_LOADED            0x00000010
    5122                 :            : #define MR_TOGGLE_TX            0x00000020
    5123                 :            : #define MR_LP_ADV_FULL_DUPLEX   0x00000040
    5124                 :            : #define MR_LP_ADV_HALF_DUPLEX   0x00000080
    5125                 :            : #define MR_LP_ADV_SYM_PAUSE     0x00000100
    5126                 :            : #define MR_LP_ADV_ASYM_PAUSE    0x00000200
    5127                 :            : #define MR_LP_ADV_REMOTE_FAULT1 0x00000400
    5128                 :            : #define MR_LP_ADV_REMOTE_FAULT2 0x00000800
    5129                 :            : #define MR_LP_ADV_NEXT_PAGE     0x00001000
    5130                 :            : #define MR_TOGGLE_RX            0x00002000
    5131                 :            : #define MR_NP_RX                0x00004000
    5132                 :            : 
    5133                 :            : #define MR_LINK_OK              0x80000000
    5134                 :            : 
    5135                 :            :         unsigned long link_time, cur_time;
    5136                 :            : 
    5137                 :            :         u32 ability_match_cfg;
    5138                 :            :         int ability_match_count;
    5139                 :            : 
    5140                 :            :         char ability_match, idle_match, ack_match;
    5141                 :            : 
    5142                 :            :         u32 txconfig, rxconfig;
    5143                 :            : #define ANEG_CFG_NP             0x00000080
    5144                 :            : #define ANEG_CFG_ACK            0x00000040
    5145                 :            : #define ANEG_CFG_RF2            0x00000020
    5146                 :            : #define ANEG_CFG_RF1            0x00000010
    5147                 :            : #define ANEG_CFG_PS2            0x00000001
    5148                 :            : #define ANEG_CFG_PS1            0x00008000
    5149                 :            : #define ANEG_CFG_HD             0x00004000
    5150                 :            : #define ANEG_CFG_FD             0x00002000
    5151                 :            : #define ANEG_CFG_INVAL          0x00001f06
    5152                 :            : 
    5153                 :            : };
    5154                 :            : #define ANEG_OK         0
    5155                 :            : #define ANEG_DONE       1
    5156                 :            : #define ANEG_TIMER_ENAB 2
    5157                 :            : #define ANEG_FAILED     -1
    5158                 :            : 
    5159                 :            : #define ANEG_STATE_SETTLE_TIME  10000
    5160                 :            : 
    5161                 :          0 : static int tg3_fiber_aneg_smachine(struct tg3 *tp,
    5162                 :            :                                    struct tg3_fiber_aneginfo *ap)
    5163                 :            : {
    5164                 :          0 :         u16 flowctrl;
    5165                 :          0 :         unsigned long delta;
    5166                 :          0 :         u32 rx_cfg_reg;
    5167                 :          0 :         int ret;
    5168                 :            : 
    5169         [ #  # ]:          0 :         if (ap->state == ANEG_STATE_UNKNOWN) {
    5170                 :          0 :                 ap->rxconfig = 0;
    5171                 :          0 :                 ap->link_time = 0;
    5172                 :          0 :                 ap->cur_time = 0;
    5173                 :          0 :                 ap->ability_match_cfg = 0;
    5174                 :          0 :                 ap->ability_match_count = 0;
    5175                 :          0 :                 ap->ability_match = 0;
    5176                 :          0 :                 ap->idle_match = 0;
    5177                 :          0 :                 ap->ack_match = 0;
    5178                 :            :         }
    5179                 :          0 :         ap->cur_time++;
    5180                 :            : 
    5181         [ #  # ]:          0 :         if (tr32(MAC_STATUS) & MAC_STATUS_RCVD_CFG) {
    5182                 :          0 :                 rx_cfg_reg = tr32(MAC_RX_AUTO_NEG);
    5183                 :            : 
    5184         [ #  # ]:          0 :                 if (rx_cfg_reg != ap->ability_match_cfg) {
    5185                 :          0 :                         ap->ability_match_cfg = rx_cfg_reg;
    5186                 :          0 :                         ap->ability_match = 0;
    5187                 :          0 :                         ap->ability_match_count = 0;
    5188                 :            :                 } else {
    5189         [ #  # ]:          0 :                         if (++ap->ability_match_count > 1) {
    5190                 :          0 :                                 ap->ability_match = 1;
    5191                 :          0 :                                 ap->ability_match_cfg = rx_cfg_reg;
    5192                 :            :                         }
    5193                 :            :                 }
    5194         [ #  # ]:          0 :                 if (rx_cfg_reg & ANEG_CFG_ACK)
    5195                 :          0 :                         ap->ack_match = 1;
    5196                 :            :                 else
    5197                 :          0 :                         ap->ack_match = 0;
    5198                 :            : 
    5199                 :          0 :                 ap->idle_match = 0;
    5200                 :            :         } else {
    5201                 :          0 :                 ap->idle_match = 1;
    5202                 :          0 :                 ap->ability_match_cfg = 0;
    5203                 :          0 :                 ap->ability_match_count = 0;
    5204                 :          0 :                 ap->ability_match = 0;
    5205                 :          0 :                 ap->ack_match = 0;
    5206                 :            : 
    5207                 :          0 :                 rx_cfg_reg = 0;
    5208                 :            :         }
    5209                 :            : 
    5210                 :          0 :         ap->rxconfig = rx_cfg_reg;
    5211                 :          0 :         ret = ANEG_OK;
    5212                 :            : 
    5213   [ #  #  #  #  :          0 :         switch (ap->state) {
          #  #  #  #  #  
          #  #  #  #  #  
                      # ]
    5214                 :            :         case ANEG_STATE_UNKNOWN:
    5215                 :            :                 if (ap->flags & (MR_AN_ENABLE | MR_RESTART_AN))
    5216                 :            :                         ap->state = ANEG_STATE_AN_ENABLE;
    5217                 :            : 
    5218                 :            :                 /* fall through */
    5219                 :            :         case ANEG_STATE_AN_ENABLE:
    5220                 :          0 :                 ap->flags &= ~(MR_AN_COMPLETE | MR_PAGE_RX);
    5221         [ #  # ]:          0 :                 if (ap->flags & MR_AN_ENABLE) {
    5222                 :          0 :                         ap->link_time = 0;
    5223                 :          0 :                         ap->cur_time = 0;
    5224                 :          0 :                         ap->ability_match_cfg = 0;
    5225                 :          0 :                         ap->ability_match_count = 0;
    5226                 :          0 :                         ap->ability_match = 0;
    5227                 :          0 :                         ap->idle_match = 0;
    5228                 :          0 :                         ap->ack_match = 0;
    5229                 :            : 
    5230                 :          0 :                         ap->state = ANEG_STATE_RESTART_INIT;
    5231                 :            :                 } else {
    5232                 :          0 :                         ap->state = ANEG_STATE_DISABLE_LINK_OK;
    5233                 :            :                 }
    5234                 :            :                 break;
    5235                 :            : 
    5236                 :          0 :         case ANEG_STATE_RESTART_INIT:
    5237                 :          0 :                 ap->link_time = ap->cur_time;
    5238                 :          0 :                 ap->flags &= ~(MR_NP_LOADED);
    5239                 :          0 :                 ap->txconfig = 0;
    5240                 :          0 :                 tw32(MAC_TX_AUTO_NEG, 0);
    5241                 :          0 :                 tp->mac_mode |= MAC_MODE_SEND_CONFIGS;
    5242                 :          0 :                 tw32_f(MAC_MODE, tp->mac_mode);
    5243                 :          0 :                 udelay(40);
    5244                 :            : 
    5245                 :          0 :                 ret = ANEG_TIMER_ENAB;
    5246                 :          0 :                 ap->state = ANEG_STATE_RESTART;
    5247                 :            : 
    5248                 :            :                 /* fall through */
    5249                 :          0 :         case ANEG_STATE_RESTART:
    5250                 :          0 :                 delta = ap->cur_time - ap->link_time;
    5251         [ #  # ]:          0 :                 if (delta > ANEG_STATE_SETTLE_TIME)
    5252                 :          0 :                         ap->state = ANEG_STATE_ABILITY_DETECT_INIT;
    5253                 :            :                 else
    5254                 :            :                         ret = ANEG_TIMER_ENAB;
    5255                 :            :                 break;
    5256                 :            : 
    5257                 :          0 :         case ANEG_STATE_DISABLE_LINK_OK:
    5258                 :          0 :                 ret = ANEG_DONE;
    5259                 :          0 :                 break;
    5260                 :            : 
    5261                 :          0 :         case ANEG_STATE_ABILITY_DETECT_INIT:
    5262                 :          0 :                 ap->flags &= ~(MR_TOGGLE_TX);
    5263                 :          0 :                 ap->txconfig = ANEG_CFG_FD;
    5264         [ #  # ]:          0 :                 flowctrl = tg3_advert_flowctrl_1000X(tp->link_config.flowctrl);
    5265         [ #  # ]:          0 :                 if (flowctrl & ADVERTISE_1000XPAUSE)
    5266                 :          0 :                         ap->txconfig |= ANEG_CFG_PS1;
    5267         [ #  # ]:          0 :                 if (flowctrl & ADVERTISE_1000XPSE_ASYM)
    5268                 :          0 :                         ap->txconfig |= ANEG_CFG_PS2;
    5269                 :          0 :                 tw32(MAC_TX_AUTO_NEG, ap->txconfig);
    5270                 :          0 :                 tp->mac_mode |= MAC_MODE_SEND_CONFIGS;
    5271                 :          0 :                 tw32_f(MAC_MODE, tp->mac_mode);
    5272                 :          0 :                 udelay(40);
    5273                 :            : 
    5274                 :          0 :                 ap->state = ANEG_STATE_ABILITY_DETECT;
    5275                 :          0 :                 break;
    5276                 :            : 
    5277                 :          0 :         case ANEG_STATE_ABILITY_DETECT:
    5278   [ #  #  #  # ]:          0 :                 if (ap->ability_match != 0 && ap->rxconfig != 0)
    5279                 :          0 :                         ap->state = ANEG_STATE_ACK_DETECT_INIT;
    5280                 :            :                 break;
    5281                 :            : 
    5282                 :          0 :         case ANEG_STATE_ACK_DETECT_INIT:
    5283                 :          0 :                 ap->txconfig |= ANEG_CFG_ACK;
    5284                 :          0 :                 tw32(MAC_TX_AUTO_NEG, ap->txconfig);
    5285                 :          0 :                 tp->mac_mode |= MAC_MODE_SEND_CONFIGS;
    5286                 :          0 :                 tw32_f(MAC_MODE, tp->mac_mode);
    5287                 :          0 :                 udelay(40);
    5288                 :            : 
    5289                 :          0 :                 ap->state = ANEG_STATE_ACK_DETECT;
    5290                 :            : 
    5291                 :            :                 /* fall through */
    5292                 :          0 :         case ANEG_STATE_ACK_DETECT:
    5293         [ #  # ]:          0 :                 if (ap->ack_match != 0) {
    5294                 :          0 :                         if ((ap->rxconfig & ~ANEG_CFG_ACK) ==
    5295         [ #  # ]:          0 :                             (ap->ability_match_cfg & ~ANEG_CFG_ACK)) {
    5296                 :          0 :                                 ap->state = ANEG_STATE_COMPLETE_ACK_INIT;
    5297                 :            :                         } else {
    5298                 :          0 :                                 ap->state = ANEG_STATE_AN_ENABLE;
    5299                 :            :                         }
    5300         [ #  # ]:          0 :                 } else if (ap->ability_match != 0 &&
    5301         [ #  # ]:          0 :                            ap->rxconfig == 0) {
    5302                 :          0 :                         ap->state = ANEG_STATE_AN_ENABLE;
    5303                 :            :                 }
    5304                 :            :                 break;
    5305                 :            : 
    5306                 :          0 :         case ANEG_STATE_COMPLETE_ACK_INIT:
    5307         [ #  # ]:          0 :                 if (ap->rxconfig & ANEG_CFG_INVAL) {
    5308                 :            :                         ret = ANEG_FAILED;
    5309                 :            :                         break;
    5310                 :            :                 }
    5311                 :          0 :                 ap->flags &= ~(MR_LP_ADV_FULL_DUPLEX |
    5312                 :            :                                MR_LP_ADV_HALF_DUPLEX |
    5313                 :            :                                MR_LP_ADV_SYM_PAUSE |
    5314                 :            :                                MR_LP_ADV_ASYM_PAUSE |
    5315                 :            :                                MR_LP_ADV_REMOTE_FAULT1 |
    5316                 :            :                                MR_LP_ADV_REMOTE_FAULT2 |
    5317                 :            :                                MR_LP_ADV_NEXT_PAGE |
    5318                 :            :                                MR_TOGGLE_RX |
    5319                 :            :                                MR_NP_RX);
    5320         [ #  # ]:          0 :                 if (ap->rxconfig & ANEG_CFG_FD)
    5321                 :          0 :                         ap->flags |= MR_LP_ADV_FULL_DUPLEX;
    5322         [ #  # ]:          0 :                 if (ap->rxconfig & ANEG_CFG_HD)
    5323                 :          0 :                         ap->flags |= MR_LP_ADV_HALF_DUPLEX;
    5324         [ #  # ]:          0 :                 if (ap->rxconfig & ANEG_CFG_PS1)
    5325                 :          0 :                         ap->flags |= MR_LP_ADV_SYM_PAUSE;
    5326         [ #  # ]:          0 :                 if (ap->rxconfig & ANEG_CFG_PS2)
    5327                 :          0 :                         ap->flags |= MR_LP_ADV_ASYM_PAUSE;
    5328         [ #  # ]:          0 :                 if (ap->rxconfig & ANEG_CFG_RF1)
    5329                 :          0 :                         ap->flags |= MR_LP_ADV_REMOTE_FAULT1;
    5330         [ #  # ]:          0 :                 if (ap->rxconfig & ANEG_CFG_RF2)
    5331                 :          0 :                         ap->flags |= MR_LP_ADV_REMOTE_FAULT2;
    5332         [ #  # ]:          0 :                 if (ap->rxconfig & ANEG_CFG_NP)
    5333                 :          0 :                         ap->flags |= MR_LP_ADV_NEXT_PAGE;
    5334                 :            : 
    5335                 :          0 :                 ap->link_time = ap->cur_time;
    5336                 :            : 
    5337                 :          0 :                 ap->flags ^= (MR_TOGGLE_TX);
    5338         [ #  # ]:          0 :                 if (ap->rxconfig & 0x0008)
    5339                 :          0 :                         ap->flags |= MR_TOGGLE_RX;
    5340         [ #  # ]:          0 :                 if (ap->rxconfig & ANEG_CFG_NP)
    5341                 :          0 :                         ap->flags |= MR_NP_RX;
    5342                 :          0 :                 ap->flags |= MR_PAGE_RX;
    5343                 :            : 
    5344                 :          0 :                 ap->state = ANEG_STATE_COMPLETE_ACK;
    5345                 :          0 :                 ret = ANEG_TIMER_ENAB;
    5346                 :          0 :                 break;
    5347                 :            : 
    5348                 :          0 :         case ANEG_STATE_COMPLETE_ACK:
    5349   [ #  #  #  # ]:          0 :                 if (ap->ability_match != 0 &&
    5350                 :            :                     ap->rxconfig == 0) {
    5351                 :          0 :                         ap->state = ANEG_STATE_AN_ENABLE;
    5352                 :          0 :                         break;
    5353                 :            :                 }
    5354                 :          0 :                 delta = ap->cur_time - ap->link_time;
    5355         [ #  # ]:          0 :                 if (delta > ANEG_STATE_SETTLE_TIME) {
    5356         [ #  # ]:          0 :                         if (!(ap->flags & (MR_LP_ADV_NEXT_PAGE))) {
    5357                 :          0 :                                 ap->state = ANEG_STATE_IDLE_DETECT_INIT;
    5358                 :            :                         } else {
    5359         [ #  # ]:          0 :                                 if ((ap->txconfig & ANEG_CFG_NP) == 0 &&
    5360         [ #  # ]:          0 :                                     !(ap->flags & MR_NP_RX)) {
    5361                 :          0 :                                         ap->state = ANEG_STATE_IDLE_DETECT_INIT;
    5362                 :            :                                 } else {
    5363                 :            :                                         ret = ANEG_FAILED;
    5364                 :            :                                 }
    5365                 :            :                         }
    5366                 :            :                 }
    5367                 :            :                 break;
    5368                 :            : 
    5369                 :          0 :         case ANEG_STATE_IDLE_DETECT_INIT:
    5370                 :          0 :                 ap->link_time = ap->cur_time;
    5371                 :          0 :                 tp->mac_mode &= ~MAC_MODE_SEND_CONFIGS;
    5372                 :          0 :                 tw32_f(MAC_MODE, tp->mac_mode);
    5373                 :          0 :                 udelay(40);
    5374                 :            : 
    5375                 :          0 :                 ap->state = ANEG_STATE_IDLE_DETECT;
    5376                 :          0 :                 ret = ANEG_TIMER_ENAB;
    5377                 :          0 :                 break;
    5378                 :            : 
    5379                 :          0 :         case ANEG_STATE_IDLE_DETECT:
    5380   [ #  #  #  # ]:          0 :                 if (ap->ability_match != 0 &&
    5381                 :            :                     ap->rxconfig == 0) {
    5382                 :          0 :                         ap->state = ANEG_STATE_AN_ENABLE;
    5383                 :          0 :                         break;
    5384                 :            :                 }
    5385                 :          0 :                 delta = ap->cur_time - ap->link_time;
    5386         [ #  # ]:          0 :                 if (delta > ANEG_STATE_SETTLE_TIME) {
    5387                 :            :                         /* XXX another gem from the Broadcom driver :( */
    5388                 :          0 :                         ap->state = ANEG_STATE_LINK_OK;
    5389                 :            :                 }
    5390                 :            :                 break;
    5391                 :            : 
    5392                 :          0 :         case ANEG_STATE_LINK_OK:
    5393                 :          0 :                 ap->flags |= (MR_AN_COMPLETE | MR_LINK_OK);
    5394                 :          0 :                 ret = ANEG_DONE;
    5395                 :          0 :                 break;
    5396                 :            : 
    5397                 :            :         case ANEG_STATE_NEXT_PAGE_WAIT_INIT:
    5398                 :            :                 /* ??? unimplemented */
    5399                 :            :                 break;
    5400                 :            : 
    5401                 :            :         case ANEG_STATE_NEXT_PAGE_WAIT:
    5402                 :            :                 /* ??? unimplemented */
    5403                 :            :                 break;
    5404                 :            : 
    5405                 :          0 :         default:
    5406                 :          0 :                 ret = ANEG_FAILED;
    5407                 :          0 :                 break;
    5408                 :            :         }
    5409                 :            : 
    5410                 :          0 :         return ret;
    5411                 :            : }
    5412                 :            : 
    5413                 :          0 : static int fiber_autoneg(struct tg3 *tp, u32 *txflags, u32 *rxflags)
    5414                 :            : {
    5415                 :          0 :         int res = 0;
    5416                 :          0 :         struct tg3_fiber_aneginfo aninfo;
    5417                 :          0 :         int status = ANEG_FAILED;
    5418                 :          0 :         unsigned int tick;
    5419                 :          0 :         u32 tmp;
    5420                 :            : 
    5421                 :          0 :         tw32_f(MAC_TX_AUTO_NEG, 0);
    5422                 :            : 
    5423                 :          0 :         tmp = tp->mac_mode & ~MAC_MODE_PORT_MODE_MASK;
    5424                 :          0 :         tw32_f(MAC_MODE, tmp | MAC_MODE_PORT_MODE_GMII);
    5425                 :          0 :         udelay(40);
    5426                 :            : 
    5427                 :          0 :         tw32_f(MAC_MODE, tp->mac_mode | MAC_MODE_SEND_CONFIGS);
    5428                 :          0 :         udelay(40);
    5429                 :            : 
    5430                 :          0 :         memset(&aninfo, 0, sizeof(aninfo));
    5431                 :          0 :         aninfo.flags |= MR_AN_ENABLE;
    5432                 :          0 :         aninfo.state = ANEG_STATE_UNKNOWN;
    5433                 :          0 :         aninfo.cur_time = 0;
    5434                 :          0 :         tick = 0;
    5435         [ #  # ]:          0 :         while (++tick < 195000) {
    5436                 :          0 :                 status = tg3_fiber_aneg_smachine(tp, &aninfo);
    5437         [ #  # ]:          0 :                 if (status == ANEG_DONE || status == ANEG_FAILED)
    5438                 :            :                         break;
    5439                 :            : 
    5440                 :          0 :                 udelay(1);
    5441                 :            :         }
    5442                 :            : 
    5443                 :          0 :         tp->mac_mode &= ~MAC_MODE_SEND_CONFIGS;
    5444                 :          0 :         tw32_f(MAC_MODE, tp->mac_mode);
    5445                 :          0 :         udelay(40);
    5446                 :            : 
    5447                 :          0 :         *txflags = aninfo.txconfig;
    5448                 :          0 :         *rxflags = aninfo.flags;
    5449                 :            : 
    5450         [ #  # ]:          0 :         if (status == ANEG_DONE &&
    5451         [ #  # ]:          0 :             (aninfo.flags & (MR_AN_COMPLETE | MR_LINK_OK |
    5452                 :            :                              MR_LP_ADV_FULL_DUPLEX)))
    5453                 :          0 :                 res = 1;
    5454                 :            : 
    5455                 :          0 :         return res;
    5456                 :            : }
    5457                 :            : 
    5458                 :          0 : static void tg3_init_bcm8002(struct tg3 *tp)
    5459                 :            : {
    5460                 :          0 :         u32 mac_status = tr32(MAC_STATUS);
    5461                 :          0 :         int i;
    5462                 :            : 
    5463                 :            :         /* Reset when initting first time or we have a link. */
    5464         [ #  # ]:          0 :         if (tg3_flag(tp, INIT_COMPLETE) &&
    5465         [ #  # ]:          0 :             !(mac_status & MAC_STATUS_PCS_SYNCED))
    5466                 :            :                 return;
    5467                 :            : 
    5468                 :            :         /* Set PLL lock range. */
    5469                 :          0 :         tg3_writephy(tp, 0x16, 0x8007);
    5470                 :            : 
    5471                 :            :         /* SW reset */
    5472                 :          0 :         tg3_writephy(tp, MII_BMCR, BMCR_RESET);
    5473                 :            : 
    5474                 :            :         /* Wait for reset to complete. */
    5475                 :            :         /* XXX schedule_timeout() ... */
    5476         [ #  # ]:          0 :         for (i = 0; i < 500; i++)
    5477                 :          0 :                 udelay(10);
    5478                 :            : 
    5479                 :            :         /* Config mode; select PMA/Ch 1 regs. */
    5480                 :          0 :         tg3_writephy(tp, 0x10, 0x8411);
    5481                 :            : 
    5482                 :            :         /* Enable auto-lock and comdet, select txclk for tx. */
    5483                 :          0 :         tg3_writephy(tp, 0x11, 0x0a10);
    5484                 :            : 
    5485                 :          0 :         tg3_writephy(tp, 0x18, 0x00a0);
    5486                 :          0 :         tg3_writephy(tp, 0x16, 0x41ff);
    5487                 :            : 
    5488                 :            :         /* Assert and deassert POR. */
    5489                 :          0 :         tg3_writephy(tp, 0x13, 0x0400);
    5490                 :          0 :         udelay(40);
    5491                 :          0 :         tg3_writephy(tp, 0x13, 0x0000);
    5492                 :            : 
    5493                 :          0 :         tg3_writephy(tp, 0x11, 0x0a50);
    5494                 :          0 :         udelay(40);
    5495                 :          0 :         tg3_writephy(tp, 0x11, 0x0a10);
    5496                 :            : 
    5497                 :            :         /* Wait for signal to stabilize */
    5498                 :            :         /* XXX schedule_timeout() ... */
    5499         [ #  # ]:          0 :         for (i = 0; i < 15000; i++)
    5500                 :          0 :                 udelay(10);
    5501                 :            : 
    5502                 :            :         /* Deselect the channel register so we can read the PHYID
    5503                 :            :          * later.
    5504                 :            :          */
    5505                 :          0 :         tg3_writephy(tp, 0x10, 0x8011);
    5506                 :            : }
    5507                 :            : 
    5508                 :          0 : static bool tg3_setup_fiber_hw_autoneg(struct tg3 *tp, u32 mac_status)
    5509                 :            : {
    5510                 :          0 :         u16 flowctrl;
    5511                 :          0 :         bool current_link_up;
    5512                 :          0 :         u32 sg_dig_ctrl, sg_dig_status;
    5513                 :          0 :         u32 serdes_cfg, expected_sg_dig_ctrl;
    5514                 :          0 :         int workaround, port_a;
    5515                 :            : 
    5516                 :          0 :         serdes_cfg = 0;
    5517                 :          0 :         expected_sg_dig_ctrl = 0;
    5518                 :          0 :         workaround = 0;
    5519                 :          0 :         port_a = 1;
    5520                 :          0 :         current_link_up = false;
    5521                 :            : 
    5522         [ #  # ]:          0 :         if (tg3_chip_rev_id(tp) != CHIPREV_ID_5704_A0 &&
    5523                 :            :             tg3_chip_rev_id(tp) != CHIPREV_ID_5704_A1) {
    5524                 :          0 :                 workaround = 1;
    5525         [ #  # ]:          0 :                 if (tr32(TG3PCI_DUAL_MAC_CTRL) & DUAL_MAC_CTRL_ID)
    5526                 :          0 :                         port_a = 0;
    5527                 :            : 
    5528                 :            :                 /* preserve bits 0-11,13,14 for signal pre-emphasis */
    5529                 :            :                 /* preserve bits 20-23 for voltage regulator */
    5530                 :          0 :                 serdes_cfg = tr32(MAC_SERDES_CFG) & 0x00f06fff;
    5531                 :            :         }
    5532                 :            : 
    5533                 :          0 :         sg_dig_ctrl = tr32(SG_DIG_CTRL);
    5534                 :            : 
    5535         [ #  # ]:          0 :         if (tp->link_config.autoneg != AUTONEG_ENABLE) {
    5536         [ #  # ]:          0 :                 if (sg_dig_ctrl & SG_DIG_USING_HW_AUTONEG) {
    5537         [ #  # ]:          0 :                         if (workaround) {
    5538                 :          0 :                                 u32 val = serdes_cfg;
    5539                 :            : 
    5540         [ #  # ]:          0 :                                 if (port_a)
    5541                 :          0 :                                         val |= 0xc010000;
    5542                 :            :                                 else
    5543                 :          0 :                                         val |= 0x4010000;
    5544                 :          0 :                                 tw32_f(MAC_SERDES_CFG, val);
    5545                 :            :                         }
    5546                 :            : 
    5547                 :          0 :                         tw32_f(SG_DIG_CTRL, SG_DIG_COMMON_SETUP);
    5548                 :            :                 }
    5549         [ #  # ]:          0 :                 if (mac_status & MAC_STATUS_PCS_SYNCED) {
    5550                 :          0 :                         tg3_setup_flow_control(tp, 0, 0);
    5551                 :          0 :                         current_link_up = true;
    5552                 :            :                 }
    5553                 :          0 :                 goto out;
    5554                 :            :         }
    5555                 :            : 
    5556                 :            :         /* Want auto-negotiation.  */
    5557                 :          0 :         expected_sg_dig_ctrl = SG_DIG_USING_HW_AUTONEG | SG_DIG_COMMON_SETUP;
    5558                 :            : 
    5559         [ #  # ]:          0 :         flowctrl = tg3_advert_flowctrl_1000X(tp->link_config.flowctrl);
    5560         [ #  # ]:          0 :         if (flowctrl & ADVERTISE_1000XPAUSE)
    5561                 :          0 :                 expected_sg_dig_ctrl |= SG_DIG_PAUSE_CAP;
    5562         [ #  # ]:          0 :         if (flowctrl & ADVERTISE_1000XPSE_ASYM)
    5563                 :          0 :                 expected_sg_dig_ctrl |= SG_DIG_ASYM_PAUSE;
    5564                 :            : 
    5565         [ #  # ]:          0 :         if (sg_dig_ctrl != expected_sg_dig_ctrl) {
    5566         [ #  # ]:          0 :                 if ((tp->phy_flags & TG3_PHYFLG_PARALLEL_DETECT) &&
    5567         [ #  # ]:          0 :                     tp->serdes_counter &&
    5568         [ #  # ]:          0 :                     ((mac_status & (MAC_STATUS_PCS_SYNCED |
    5569                 :            :                                     MAC_STATUS_RCVD_CFG)) ==
    5570                 :            :                      MAC_STATUS_PCS_SYNCED)) {
    5571                 :          0 :                         tp->serdes_counter--;
    5572                 :          0 :                         current_link_up = true;
    5573                 :          0 :                         goto out;
    5574                 :            :                 }
    5575                 :          0 : restart_autoneg:
    5576         [ #  # ]:          0 :                 if (workaround)
    5577                 :          0 :                         tw32_f(MAC_SERDES_CFG, serdes_cfg | 0xc011000);
    5578                 :          0 :                 tw32_f(SG_DIG_CTRL, expected_sg_dig_ctrl | SG_DIG_SOFT_RESET);
    5579                 :          0 :                 udelay(5);
    5580                 :          0 :                 tw32_f(SG_DIG_CTRL, expected_sg_dig_ctrl);
    5581                 :            : 
    5582                 :          0 :                 tp->serdes_counter = SERDES_AN_TIMEOUT_5704S;
    5583                 :          0 :                 tp->phy_flags &= ~TG3_PHYFLG_PARALLEL_DETECT;
    5584         [ #  # ]:          0 :         } else if (mac_status & (MAC_STATUS_PCS_SYNCED |
    5585                 :            :                                  MAC_STATUS_SIGNAL_DET)) {
    5586                 :          0 :                 sg_dig_status = tr32(SG_DIG_STATUS);
    5587                 :          0 :                 mac_status = tr32(MAC_STATUS);
    5588                 :            : 
    5589         [ #  # ]:          0 :                 if ((sg_dig_status & SG_DIG_AUTONEG_COMPLETE) &&
    5590         [ #  # ]:          0 :                     (mac_status & MAC_STATUS_PCS_SYNCED)) {
    5591                 :          0 :                         u32 local_adv = 0, remote_adv = 0;
    5592                 :            : 
    5593         [ #  # ]:          0 :                         if (sg_dig_ctrl & SG_DIG_PAUSE_CAP)
    5594                 :          0 :                                 local_adv |= ADVERTISE_1000XPAUSE;
    5595         [ #  # ]:          0 :                         if (sg_dig_ctrl & SG_DIG_ASYM_PAUSE)
    5596                 :          0 :                                 local_adv |= ADVERTISE_1000XPSE_ASYM;
    5597                 :            : 
    5598         [ #  # ]:          0 :                         if (sg_dig_status & SG_DIG_PARTNER_PAUSE_CAPABLE)
    5599                 :          0 :                                 remote_adv |= LPA_1000XPAUSE;
    5600         [ #  # ]:          0 :                         if (sg_dig_status & SG_DIG_PARTNER_ASYM_PAUSE)
    5601                 :          0 :                                 remote_adv |= LPA_1000XPAUSE_ASYM;
    5602                 :            : 
    5603         [ #  # ]:          0 :                         tp->link_config.rmt_adv =
    5604                 :            :                                            mii_adv_to_ethtool_adv_x(remote_adv);
    5605                 :            : 
    5606                 :          0 :                         tg3_setup_flow_control(tp, local_adv, remote_adv);
    5607                 :          0 :                         current_link_up = true;
    5608                 :          0 :                         tp->serdes_counter = 0;
    5609                 :          0 :                         tp->phy_flags &= ~TG3_PHYFLG_PARALLEL_DETECT;
    5610         [ #  # ]:          0 :                 } else if (!(sg_dig_status & SG_DIG_AUTONEG_COMPLETE)) {
    5611         [ #  # ]:          0 :                         if (tp->serdes_counter)
    5612                 :          0 :                                 tp->serdes_counter--;
    5613                 :            :                         else {
    5614         [ #  # ]:          0 :                                 if (workaround) {
    5615                 :          0 :                                         u32 val = serdes_cfg;
    5616                 :            : 
    5617         [ #  # ]:          0 :                                         if (port_a)
    5618                 :          0 :                                                 val |= 0xc010000;
    5619                 :            :                                         else
    5620                 :          0 :                                                 val |= 0x4010000;
    5621                 :            : 
    5622                 :          0 :                                         tw32_f(MAC_SERDES_CFG, val);
    5623                 :            :                                 }
    5624                 :            : 
    5625                 :          0 :                                 tw32_f(SG_DIG_CTRL, SG_DIG_COMMON_SETUP);
    5626                 :          0 :                                 udelay(40);
    5627                 :            : 
    5628                 :            :                                 /* Link parallel detection - link is up */
    5629                 :            :                                 /* only if we have PCS_SYNC and not */
    5630                 :            :                                 /* receiving config code words */
    5631                 :          0 :                                 mac_status = tr32(MAC_STATUS);
    5632         [ #  # ]:          0 :                                 if ((mac_status & MAC_STATUS_PCS_SYNCED) &&
    5633                 :            :                                     !(mac_status & MAC_STATUS_RCVD_CFG)) {
    5634                 :          0 :                                         tg3_setup_flow_control(tp, 0, 0);
    5635                 :          0 :                                         current_link_up = true;
    5636                 :          0 :                                         tp->phy_flags |=
    5637                 :            :                                                 TG3_PHYFLG_PARALLEL_DETECT;
    5638                 :          0 :                                         tp->serdes_counter =
    5639                 :            :                                                 SERDES_PARALLEL_DET_TIMEOUT;
    5640                 :            :                                 } else
    5641                 :          0 :                                         goto restart_autoneg;
    5642                 :            :                         }
    5643                 :            :                 }
    5644                 :            :         } else {
    5645                 :          0 :                 tp->serdes_counter = SERDES_AN_TIMEOUT_5704S;
    5646                 :          0 :                 tp->phy_flags &= ~TG3_PHYFLG_PARALLEL_DETECT;
    5647                 :            :         }
    5648                 :            : 
    5649                 :          0 : out:
    5650                 :          0 :         return current_link_up;
    5651                 :            : }
    5652                 :            : 
    5653                 :          0 : static bool tg3_setup_fiber_by_hand(struct tg3 *tp, u32 mac_status)
    5654                 :            : {
    5655                 :          0 :         bool current_link_up = false;
    5656                 :            : 
    5657         [ #  # ]:          0 :         if (!(mac_status & MAC_STATUS_PCS_SYNCED))
    5658                 :          0 :                 goto out;
    5659                 :            : 
    5660         [ #  # ]:          0 :         if (tp->link_config.autoneg == AUTONEG_ENABLE) {
    5661                 :          0 :                 u32 txflags, rxflags;
    5662                 :          0 :                 int i;
    5663                 :            : 
    5664         [ #  # ]:          0 :                 if (fiber_autoneg(tp, &txflags, &rxflags)) {
    5665                 :          0 :                         u32 local_adv = 0, remote_adv = 0;
    5666                 :            : 
    5667         [ #  # ]:          0 :                         if (txflags & ANEG_CFG_PS1)
    5668                 :          0 :                                 local_adv |= ADVERTISE_1000XPAUSE;
    5669         [ #  # ]:          0 :                         if (txflags & ANEG_CFG_PS2)
    5670                 :          0 :                                 local_adv |= ADVERTISE_1000XPSE_ASYM;
    5671                 :            : 
    5672         [ #  # ]:          0 :                         if (rxflags & MR_LP_ADV_SYM_PAUSE)
    5673                 :          0 :                                 remote_adv |= LPA_1000XPAUSE;
    5674         [ #  # ]:          0 :                         if (rxflags & MR_LP_ADV_ASYM_PAUSE)
    5675                 :          0 :                                 remote_adv |= LPA_1000XPAUSE_ASYM;
    5676                 :            : 
    5677         [ #  # ]:          0 :                         tp->link_config.rmt_adv =
    5678                 :            :                                            mii_adv_to_ethtool_adv_x(remote_adv);
    5679                 :            : 
    5680                 :          0 :                         tg3_setup_flow_control(tp, local_adv, remote_adv);
    5681                 :            : 
    5682                 :          0 :                         current_link_up = true;
    5683                 :            :                 }
    5684         [ #  # ]:          0 :                 for (i = 0; i < 30; i++) {
    5685                 :          0 :                         udelay(20);
    5686                 :          0 :                         tw32_f(MAC_STATUS,
    5687                 :            :                                (MAC_STATUS_SYNC_CHANGED |
    5688                 :            :                                 MAC_STATUS_CFG_CHANGED));
    5689                 :          0 :                         udelay(40);
    5690         [ #  # ]:          0 :                         if ((tr32(MAC_STATUS) &
    5691                 :            :                              (MAC_STATUS_SYNC_CHANGED |
    5692                 :            :                               MAC_STATUS_CFG_CHANGED)) == 0)
    5693                 :            :                                 break;
    5694                 :            :                 }
    5695                 :            : 
    5696                 :          0 :                 mac_status = tr32(MAC_STATUS);
    5697         [ #  # ]:          0 :                 if (!current_link_up &&
    5698         [ #  # ]:          0 :                     (mac_status & MAC_STATUS_PCS_SYNCED) &&
    5699                 :            :                     !(mac_status & MAC_STATUS_RCVD_CFG))
    5700                 :          0 :                         current_link_up = true;
    5701                 :            :         } else {
    5702                 :          0 :                 tg3_setup_flow_control(tp, 0, 0);
    5703                 :            : 
    5704                 :            :                 /* Forcing 1000FD link up. */
    5705                 :          0 :                 current_link_up = true;
    5706                 :            : 
    5707                 :          0 :                 tw32_f(MAC_MODE, (tp->mac_mode | MAC_MODE_SEND_CONFIGS));
    5708                 :          0 :                 udelay(40);
    5709                 :            : 
    5710                 :          0 :                 tw32_f(MAC_MODE, tp->mac_mode);
    5711                 :          0 :                 udelay(40);
    5712                 :            :         }
    5713                 :            : 
    5714                 :          0 : out:
    5715                 :          0 :         return current_link_up;
    5716                 :            : }
    5717                 :            : 
    5718                 :          0 : static int tg3_setup_fiber_phy(struct tg3 *tp, bool force_reset)
    5719                 :            : {
    5720                 :          0 :         u32 orig_pause_cfg;
    5721                 :          0 :         u32 orig_active_speed;
    5722                 :          0 :         u8 orig_active_duplex;
    5723                 :          0 :         u32 mac_status;
    5724                 :          0 :         bool current_link_up;
    5725                 :          0 :         int i;
    5726                 :            : 
    5727                 :          0 :         orig_pause_cfg = tp->link_config.active_flowctrl;
    5728                 :          0 :         orig_active_speed = tp->link_config.active_speed;
    5729                 :          0 :         orig_active_duplex = tp->link_config.active_duplex;
    5730                 :            : 
    5731         [ #  # ]:          0 :         if (!tg3_flag(tp, HW_AUTONEG) &&
    5732   [ #  #  #  # ]:          0 :             tp->link_up &&
    5733                 :            :             tg3_flag(tp, INIT_COMPLETE)) {
    5734                 :          0 :                 mac_status = tr32(MAC_STATUS);
    5735                 :          0 :                 mac_status &= (MAC_STATUS_PCS_SYNCED |
    5736                 :            :                                MAC_STATUS_SIGNAL_DET |
    5737                 :            :                                MAC_STATUS_CFG_CHANGED |
    5738                 :            :                                MAC_STATUS_RCVD_CFG);
    5739         [ #  # ]:          0 :                 if (mac_status == (MAC_STATUS_PCS_SYNCED |
    5740                 :            :                                    MAC_STATUS_SIGNAL_DET)) {
    5741                 :          0 :                         tw32_f(MAC_STATUS, (MAC_STATUS_SYNC_CHANGED |
    5742                 :            :                                             MAC_STATUS_CFG_CHANGED));
    5743                 :          0 :                         return 0;
    5744                 :            :                 }
    5745                 :            :         }
    5746                 :            : 
    5747                 :          0 :         tw32_f(MAC_TX_AUTO_NEG, 0);
    5748                 :            : 
    5749                 :          0 :         tp->mac_mode &= ~(MAC_MODE_PORT_MODE_MASK | MAC_MODE_HALF_DUPLEX);
    5750                 :          0 :         tp->mac_mode |= MAC_MODE_PORT_MODE_TBI;
    5751                 :          0 :         tw32_f(MAC_MODE, tp->mac_mode);
    5752                 :          0 :         udelay(40);
    5753                 :            : 
    5754         [ #  # ]:          0 :         if (tp->phy_id == TG3_PHY_ID_BCM8002)
    5755                 :          0 :                 tg3_init_bcm8002(tp);
    5756                 :            : 
    5757                 :            :         /* Enable link change event even when serdes polling.  */
    5758                 :          0 :         tw32_f(MAC_EVENT, MAC_EVENT_LNKSTATE_CHANGED);
    5759                 :          0 :         udelay(40);
    5760                 :            : 
    5761                 :          0 :         current_link_up = false;
    5762                 :          0 :         tp->link_config.rmt_adv = 0;
    5763                 :          0 :         mac_status = tr32(MAC_STATUS);
    5764                 :            : 
    5765         [ #  # ]:          0 :         if (tg3_flag(tp, HW_AUTONEG))
    5766                 :          0 :                 current_link_up = tg3_setup_fiber_hw_autoneg(tp, mac_status);
    5767                 :            :         else
    5768                 :          0 :                 current_link_up = tg3_setup_fiber_by_hand(tp, mac_status);
    5769                 :            : 
    5770                 :          0 :         tp->napi[0].hw_status->status =
    5771                 :          0 :                 (SD_STATUS_UPDATED |
    5772                 :          0 :                  (tp->napi[0].hw_status->status & ~SD_STATUS_LINK_CHG));
    5773                 :            : 
    5774         [ #  # ]:          0 :         for (i = 0; i < 100; i++) {
    5775                 :          0 :                 tw32_f(MAC_STATUS, (MAC_STATUS_SYNC_CHANGED |
    5776                 :            :                                     MAC_STATUS_CFG_CHANGED));
    5777                 :          0 :                 udelay(5);
    5778         [ #  # ]:          0 :                 if ((tr32(MAC_STATUS) & (MAC_STATUS_SYNC_CHANGED |
    5779                 :            :                                          MAC_STATUS_CFG_CHANGED |
    5780                 :            :                                          MAC_STATUS_LNKSTATE_CHANGED)) == 0)
    5781                 :            :                         break;
    5782                 :            :         }
    5783                 :            : 
    5784                 :          0 :         mac_status = tr32(MAC_STATUS);
    5785         [ #  # ]:          0 :         if ((mac_status & MAC_STATUS_PCS_SYNCED) == 0) {
    5786                 :          0 :                 current_link_up = false;
    5787         [ #  # ]:          0 :                 if (tp->link_config.autoneg == AUTONEG_ENABLE &&
    5788         [ #  # ]:          0 :                     tp->serdes_counter == 0) {
    5789                 :          0 :                         tw32_f(MAC_MODE, (tp->mac_mode |
    5790                 :            :                                           MAC_MODE_SEND_CONFIGS));
    5791                 :          0 :                         udelay(1);
    5792                 :          0 :                         tw32_f(MAC_MODE, tp->mac_mode);
    5793                 :            :                 }
    5794                 :            :         }
    5795                 :            : 
    5796         [ #  # ]:          0 :         if (current_link_up) {
    5797                 :          0 :                 tp->link_config.active_speed = SPEED_1000;
    5798                 :          0 :                 tp->link_config.active_duplex = DUPLEX_FULL;
    5799                 :          0 :                 tw32(MAC_LED_CTRL, (tp->led_ctrl |
    5800                 :            :                                     LED_CTRL_LNKLED_OVERRIDE |
    5801                 :            :                                     LED_CTRL_1000MBPS_ON));
    5802                 :            :         } else {
    5803                 :          0 :                 tp->link_config.active_speed = SPEED_UNKNOWN;
    5804                 :          0 :                 tp->link_config.active_duplex = DUPLEX_UNKNOWN;
    5805                 :          0 :                 tw32(MAC_LED_CTRL, (tp->led_ctrl |
    5806                 :            :                                     LED_CTRL_LNKLED_OVERRIDE |
    5807                 :            :                                     LED_CTRL_TRAFFIC_OVERRIDE));
    5808                 :            :         }
    5809                 :            : 
    5810         [ #  # ]:          0 :         if (!tg3_test_and_report_link_chg(tp, current_link_up)) {
    5811                 :          0 :                 u32 now_pause_cfg = tp->link_config.active_flowctrl;
    5812         [ #  # ]:          0 :                 if (orig_pause_cfg != now_pause_cfg ||
    5813         [ #  # ]:          0 :                     orig_active_speed != tp->link_config.active_speed ||
    5814         [ #  # ]:          0 :                     orig_active_duplex != tp->link_config.active_duplex)
    5815                 :          0 :                         tg3_link_report(tp);
    5816                 :            :         }
    5817                 :            : 
    5818                 :            :         return 0;
    5819                 :            : }
    5820                 :            : 
    5821                 :          0 : static int tg3_setup_fiber_mii_phy(struct tg3 *tp, bool force_reset)
    5822                 :            : {
    5823                 :          0 :         int err = 0;
    5824                 :          0 :         u32 bmsr, bmcr;
    5825                 :          0 :         u32 current_speed = SPEED_UNKNOWN;
    5826                 :          0 :         u8 current_duplex = DUPLEX_UNKNOWN;
    5827                 :          0 :         bool current_link_up = false;
    5828                 :          0 :         u32 local_adv, remote_adv, sgsr;
    5829                 :            : 
    5830         [ #  # ]:          0 :         if ((tg3_asic_rev(tp) == ASIC_REV_5719 ||
    5831         [ #  # ]:          0 :              tg3_asic_rev(tp) == ASIC_REV_5720) &&
    5832                 :          0 :              !tg3_readphy(tp, SERDES_TG3_1000X_STATUS, &sgsr) &&
    5833         [ #  # ]:          0 :              (sgsr & SERDES_TG3_SGMII_MODE)) {
    5834                 :            : 
    5835         [ #  # ]:          0 :                 if (force_reset)
    5836                 :          0 :                         tg3_phy_reset(tp);
    5837                 :            : 
    5838                 :          0 :                 tp->mac_mode &= ~MAC_MODE_PORT_MODE_MASK;
    5839                 :            : 
    5840         [ #  # ]:          0 :                 if (!(sgsr & SERDES_TG3_LINK_UP)) {
    5841                 :          0 :                         tp->mac_mode |= MAC_MODE_PORT_MODE_GMII;
    5842                 :            :                 } else {
    5843                 :          0 :                         current_link_up = true;
    5844         [ #  # ]:          0 :                         if (sgsr & SERDES_TG3_SPEED_1000) {
    5845                 :          0 :                                 current_speed = SPEED_1000;
    5846                 :          0 :                                 tp->mac_mode |= MAC_MODE_PORT_MODE_GMII;
    5847         [ #  # ]:          0 :                         } else if (sgsr & SERDES_TG3_SPEED_100) {
    5848                 :          0 :                                 current_speed = SPEED_100;
    5849                 :          0 :                                 tp->mac_mode |= MAC_MODE_PORT_MODE_MII;
    5850                 :            :                         } else {
    5851                 :          0 :                                 current_speed = SPEED_10;
    5852                 :          0 :                                 tp->mac_mode |= MAC_MODE_PORT_MODE_MII;
    5853                 :            :                         }
    5854                 :            : 
    5855         [ #  # ]:          0 :                         if (sgsr & SERDES_TG3_FULL_DUPLEX)
    5856                 :            :                                 current_duplex = DUPLEX_FULL;
    5857                 :            :                         else
    5858                 :          0 :                                 current_duplex = DUPLEX_HALF;
    5859                 :            :                 }
    5860                 :            : 
    5861                 :          0 :                 tw32_f(MAC_MODE, tp->mac_mode);
    5862                 :          0 :                 udelay(40);
    5863                 :            : 
    5864                 :          0 :                 tg3_clear_mac_status(tp);
    5865                 :            : 
    5866                 :          0 :                 goto fiber_setup_done;
    5867                 :            :         }
    5868                 :            : 
    5869                 :          0 :         tp->mac_mode |= MAC_MODE_PORT_MODE_GMII;
    5870                 :          0 :         tw32_f(MAC_MODE, tp->mac_mode);
    5871                 :          0 :         udelay(40);
    5872                 :            : 
    5873                 :          0 :         tg3_clear_mac_status(tp);
    5874                 :            : 
    5875         [ #  # ]:          0 :         if (force_reset)
    5876                 :          0 :                 tg3_phy_reset(tp);
    5877                 :            : 
    5878                 :          0 :         tp->link_config.rmt_adv = 0;
    5879                 :            : 
    5880                 :          0 :         err |= tg3_readphy(tp, MII_BMSR, &bmsr);
    5881                 :          0 :         err |= tg3_readphy(tp, MII_BMSR, &bmsr);
    5882         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5714) {
    5883         [ #  # ]:          0 :                 if (tr32(MAC_TX_STATUS) & TX_STATUS_LINK_UP)
    5884                 :          0 :                         bmsr |= BMSR_LSTATUS;
    5885                 :            :                 else
    5886                 :          0 :                         bmsr &= ~BMSR_LSTATUS;
    5887                 :            :         }
    5888                 :            : 
    5889                 :          0 :         err |= tg3_readphy(tp, MII_BMCR, &bmcr);
    5890                 :            : 
    5891   [ #  #  #  # ]:          0 :         if ((tp->link_config.autoneg == AUTONEG_ENABLE) && !force_reset &&
    5892         [ #  # ]:          0 :             (tp->phy_flags & TG3_PHYFLG_PARALLEL_DETECT)) {
    5893                 :            :                 /* do nothing, just check for link up at the end */
    5894         [ #  # ]:          0 :         } else if (tp->link_config.autoneg == AUTONEG_ENABLE) {
    5895                 :          0 :                 u32 adv, newadv;
    5896                 :            : 
    5897                 :          0 :                 err |= tg3_readphy(tp, MII_ADVERTISE, &adv);
    5898                 :          0 :                 newadv = adv & ~(ADVERTISE_1000XFULL | ADVERTISE_1000XHALF |
    5899                 :            :                                  ADVERTISE_1000XPAUSE |
    5900                 :            :                                  ADVERTISE_1000XPSE_ASYM |
    5901                 :            :                                  ADVERTISE_SLCT);
    5902                 :            : 
    5903         [ #  # ]:          0 :                 newadv |= tg3_advert_flowctrl_1000X(tp->link_config.flowctrl);
    5904         [ #  # ]:          0 :                 newadv |= ethtool_adv_to_mii_adv_x(tp->link_config.advertising);
    5905                 :            : 
    5906   [ #  #  #  # ]:          0 :                 if ((newadv != adv) || !(bmcr & BMCR_ANENABLE)) {
    5907                 :          0 :                         tg3_writephy(tp, MII_ADVERTISE, newadv);
    5908                 :          0 :                         bmcr |= BMCR_ANENABLE | BMCR_ANRESTART;
    5909                 :          0 :                         tg3_writephy(tp, MII_BMCR, bmcr);
    5910                 :            : 
    5911                 :          0 :                         tw32_f(MAC_EVENT, MAC_EVENT_LNKSTATE_CHANGED);
    5912                 :          0 :                         tp->serdes_counter = SERDES_AN_TIMEOUT_5714S;
    5913                 :          0 :                         tp->phy_flags &= ~TG3_PHYFLG_PARALLEL_DETECT;
    5914                 :            : 
    5915                 :          0 :                         return err;
    5916                 :            :                 }
    5917                 :            :         } else {
    5918                 :          0 :                 u32 new_bmcr;
    5919                 :            : 
    5920                 :          0 :                 bmcr &= ~BMCR_SPEED1000;
    5921                 :          0 :                 new_bmcr = bmcr & ~(BMCR_ANENABLE | BMCR_FULLDPLX);
    5922                 :            : 
    5923         [ #  # ]:          0 :                 if (tp->link_config.duplex == DUPLEX_FULL)
    5924                 :          0 :                         new_bmcr |= BMCR_FULLDPLX;
    5925                 :            : 
    5926         [ #  # ]:          0 :                 if (new_bmcr != bmcr) {
    5927                 :            :                         /* BMCR_SPEED1000 is a reserved bit that needs
    5928                 :            :                          * to be set on write.
    5929                 :            :                          */
    5930                 :          0 :                         new_bmcr |= BMCR_SPEED1000;
    5931                 :            : 
    5932                 :            :                         /* Force a linkdown */
    5933         [ #  # ]:          0 :                         if (tp->link_up) {
    5934                 :          0 :                                 u32 adv;
    5935                 :            : 
    5936                 :          0 :                                 err |= tg3_readphy(tp, MII_ADVERTISE, &adv);
    5937                 :          0 :                                 adv &= ~(ADVERTISE_1000XFULL |
    5938                 :            :                                          ADVERTISE_1000XHALF |
    5939                 :            :                                          ADVERTISE_SLCT);
    5940                 :          0 :                                 tg3_writephy(tp, MII_ADVERTISE, adv);
    5941                 :          0 :                                 tg3_writephy(tp, MII_BMCR, bmcr |
    5942                 :            :                                                            BMCR_ANRESTART |
    5943                 :            :                                                            BMCR_ANENABLE);
    5944                 :          0 :                                 udelay(10);
    5945                 :          0 :                                 tg3_carrier_off(tp);
    5946                 :            :                         }
    5947                 :          0 :                         tg3_writephy(tp, MII_BMCR, new_bmcr);
    5948                 :          0 :                         bmcr = new_bmcr;
    5949                 :          0 :                         err |= tg3_readphy(tp, MII_BMSR, &bmsr);
    5950                 :          0 :                         err |= tg3_readphy(tp, MII_BMSR, &bmsr);
    5951         [ #  # ]:          0 :                         if (tg3_asic_rev(tp) == ASIC_REV_5714) {
    5952         [ #  # ]:          0 :                                 if (tr32(MAC_TX_STATUS) & TX_STATUS_LINK_UP)
    5953                 :          0 :                                         bmsr |= BMSR_LSTATUS;
    5954                 :            :                                 else
    5955                 :          0 :                                         bmsr &= ~BMSR_LSTATUS;
    5956                 :            :                         }
    5957                 :          0 :                         tp->phy_flags &= ~TG3_PHYFLG_PARALLEL_DETECT;
    5958                 :            :                 }
    5959                 :            :         }
    5960                 :            : 
    5961         [ #  # ]:          0 :         if (bmsr & BMSR_LSTATUS) {
    5962                 :          0 :                 current_speed = SPEED_1000;
    5963                 :          0 :                 current_link_up = true;
    5964         [ #  # ]:          0 :                 if (bmcr & BMCR_FULLDPLX)
    5965                 :            :                         current_duplex = DUPLEX_FULL;
    5966                 :            :                 else
    5967                 :          0 :                         current_duplex = DUPLEX_HALF;
    5968                 :            : 
    5969                 :          0 :                 local_adv = 0;
    5970                 :          0 :                 remote_adv = 0;
    5971                 :            : 
    5972         [ #  # ]:          0 :                 if (bmcr & BMCR_ANENABLE) {
    5973                 :          0 :                         u32 common;
    5974                 :            : 
    5975                 :          0 :                         err |= tg3_readphy(tp, MII_ADVERTISE, &local_adv);
    5976                 :          0 :                         err |= tg3_readphy(tp, MII_LPA, &remote_adv);
    5977                 :          0 :                         common = local_adv & remote_adv;
    5978         [ #  # ]:          0 :                         if (common & (ADVERTISE_1000XHALF |
    5979                 :            :                                       ADVERTISE_1000XFULL)) {
    5980         [ #  # ]:          0 :                                 if (common & ADVERTISE_1000XFULL)
    5981                 :            :                                         current_duplex = DUPLEX_FULL;
    5982                 :            :                                 else
    5983                 :          0 :                                         current_duplex = DUPLEX_HALF;
    5984                 :            : 
    5985         [ #  # ]:          0 :                                 tp->link_config.rmt_adv =
    5986                 :            :                                            mii_adv_to_ethtool_adv_x(remote_adv);
    5987         [ #  # ]:          0 :                         } else if (!tg3_flag(tp, 5780_CLASS)) {
    5988                 :            :                                 /* Link is up via parallel detect */
    5989                 :            :                         } else {
    5990                 :          0 :                                 current_link_up = false;
    5991                 :            :                         }
    5992                 :            :                 }
    5993                 :            :         }
    5994                 :            : 
    5995                 :          0 : fiber_setup_done:
    5996         [ #  # ]:          0 :         if (current_link_up && current_duplex == DUPLEX_FULL)
    5997                 :          0 :                 tg3_setup_flow_control(tp, local_adv, remote_adv);
    5998                 :            : 
    5999                 :          0 :         tp->mac_mode &= ~MAC_MODE_HALF_DUPLEX;
    6000         [ #  # ]:          0 :         if (tp->link_config.active_duplex == DUPLEX_HALF)
    6001                 :          0 :                 tp->mac_mode |= MAC_MODE_HALF_DUPLEX;
    6002                 :            : 
    6003                 :          0 :         tw32_f(MAC_MODE, tp->mac_mode);
    6004                 :          0 :         udelay(40);
    6005                 :            : 
    6006                 :          0 :         tw32_f(MAC_EVENT, MAC_EVENT_LNKSTATE_CHANGED);
    6007                 :            : 
    6008                 :          0 :         tp->link_config.active_speed = current_speed;
    6009                 :          0 :         tp->link_config.active_duplex = current_duplex;
    6010                 :            : 
    6011                 :          0 :         tg3_test_and_report_link_chg(tp, current_link_up);
    6012                 :          0 :         return err;
    6013                 :            : }
    6014                 :            : 
    6015                 :          0 : static void tg3_serdes_parallel_detect(struct tg3 *tp)
    6016                 :            : {
    6017         [ #  # ]:          0 :         if (tp->serdes_counter) {
    6018                 :            :                 /* Give autoneg time to complete. */
    6019                 :          0 :                 tp->serdes_counter--;
    6020                 :          0 :                 return;
    6021                 :            :         }
    6022                 :            : 
    6023         [ #  # ]:          0 :         if (!tp->link_up &&
    6024         [ #  # ]:          0 :             (tp->link_config.autoneg == AUTONEG_ENABLE)) {
    6025                 :          0 :                 u32 bmcr;
    6026                 :            : 
    6027                 :          0 :                 tg3_readphy(tp, MII_BMCR, &bmcr);
    6028         [ #  # ]:          0 :                 if (bmcr & BMCR_ANENABLE) {
    6029                 :          0 :                         u32 phy1, phy2;
    6030                 :            : 
    6031                 :            :                         /* Select shadow register 0x1f */
    6032                 :          0 :                         tg3_writephy(tp, MII_TG3_MISC_SHDW, 0x7c00);
    6033                 :          0 :                         tg3_readphy(tp, MII_TG3_MISC_SHDW, &phy1);
    6034                 :            : 
    6035                 :            :                         /* Select expansion interrupt status register */
    6036                 :          0 :                         tg3_writephy(tp, MII_TG3_DSP_ADDRESS,
    6037                 :            :                                          MII_TG3_DSP_EXP1_INT_STAT);
    6038                 :          0 :                         tg3_readphy(tp, MII_TG3_DSP_RW_PORT, &phy2);
    6039                 :          0 :                         tg3_readphy(tp, MII_TG3_DSP_RW_PORT, &phy2);
    6040                 :            : 
    6041   [ #  #  #  # ]:          0 :                         if ((phy1 & 0x10) && !(phy2 & 0x20)) {
    6042                 :            :                                 /* We have signal detect and not receiving
    6043                 :            :                                  * config code words, link is up by parallel
    6044                 :            :                                  * detection.
    6045                 :            :                                  */
    6046                 :            : 
    6047                 :          0 :                                 bmcr &= ~BMCR_ANENABLE;
    6048                 :          0 :                                 bmcr |= BMCR_SPEED1000 | BMCR_FULLDPLX;
    6049                 :          0 :                                 tg3_writephy(tp, MII_BMCR, bmcr);
    6050                 :          0 :                                 tp->phy_flags |= TG3_PHYFLG_PARALLEL_DETECT;
    6051                 :            :                         }
    6052                 :            :                 }
    6053         [ #  # ]:          0 :         } else if (tp->link_up &&
    6054         [ #  # ]:          0 :                    (tp->link_config.autoneg == AUTONEG_ENABLE) &&
    6055         [ #  # ]:          0 :                    (tp->phy_flags & TG3_PHYFLG_PARALLEL_DETECT)) {
    6056                 :          0 :                 u32 phy2;
    6057                 :            : 
    6058                 :            :                 /* Select expansion interrupt status register */
    6059                 :          0 :                 tg3_writephy(tp, MII_TG3_DSP_ADDRESS,
    6060                 :            :                                  MII_TG3_DSP_EXP1_INT_STAT);
    6061                 :          0 :                 tg3_readphy(tp, MII_TG3_DSP_RW_PORT, &phy2);
    6062         [ #  # ]:          0 :                 if (phy2 & 0x20) {
    6063                 :          0 :                         u32 bmcr;
    6064                 :            : 
    6065                 :            :                         /* Config code words received, turn on autoneg. */
    6066                 :          0 :                         tg3_readphy(tp, MII_BMCR, &bmcr);
    6067                 :          0 :                         tg3_writephy(tp, MII_BMCR, bmcr | BMCR_ANENABLE);
    6068                 :            : 
    6069                 :          0 :                         tp->phy_flags &= ~TG3_PHYFLG_PARALLEL_DETECT;
    6070                 :            : 
    6071                 :            :                 }
    6072                 :            :         }
    6073                 :            : }
    6074                 :            : 
    6075                 :          0 : static int tg3_setup_phy(struct tg3 *tp, bool force_reset)
    6076                 :            : {
    6077                 :          0 :         u32 val;
    6078                 :          0 :         int err;
    6079                 :            : 
    6080         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_PHY_SERDES)
    6081                 :          0 :                 err = tg3_setup_fiber_phy(tp, force_reset);
    6082         [ #  # ]:          0 :         else if (tp->phy_flags & TG3_PHYFLG_MII_SERDES)
    6083                 :          0 :                 err = tg3_setup_fiber_mii_phy(tp, force_reset);
    6084                 :            :         else
    6085                 :          0 :                 err = tg3_setup_copper_phy(tp, force_reset);
    6086                 :            : 
    6087         [ #  # ]:          0 :         if (tg3_chip_rev(tp) == CHIPREV_5784_AX) {
    6088                 :          0 :                 u32 scale;
    6089                 :            : 
    6090                 :          0 :                 val = tr32(TG3_CPMU_CLCK_STAT) & CPMU_CLCK_STAT_MAC_CLCK_MASK;
    6091         [ #  # ]:          0 :                 if (val == CPMU_CLCK_STAT_MAC_CLCK_62_5)
    6092                 :            :                         scale = 65;
    6093         [ #  # ]:          0 :                 else if (val == CPMU_CLCK_STAT_MAC_CLCK_6_25)
    6094                 :            :                         scale = 6;
    6095                 :            :                 else
    6096                 :          0 :                         scale = 12;
    6097                 :            : 
    6098                 :          0 :                 val = tr32(GRC_MISC_CFG) & ~GRC_MISC_CFG_PRESCALAR_MASK;
    6099                 :          0 :                 val |= (scale << GRC_MISC_CFG_PRESCALAR_SHIFT);
    6100                 :          0 :                 tw32(GRC_MISC_CFG, val);
    6101                 :            :         }
    6102                 :            : 
    6103                 :          0 :         val = (2 << TX_LENGTHS_IPG_CRS_SHIFT) |
    6104                 :            :               (6 << TX_LENGTHS_IPG_SHIFT);
    6105         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5720 ||
    6106                 :            :             tg3_asic_rev(tp) == ASIC_REV_5762)
    6107                 :          0 :                 val |= tr32(MAC_TX_LENGTHS) &
    6108                 :            :                        (TX_LENGTHS_JMB_FRM_LEN_MSK |
    6109                 :            :                         TX_LENGTHS_CNT_DWN_VAL_MSK);
    6110                 :            : 
    6111         [ #  # ]:          0 :         if (tp->link_config.active_speed == SPEED_1000 &&
    6112         [ #  # ]:          0 :             tp->link_config.active_duplex == DUPLEX_HALF)
    6113                 :          0 :                 tw32(MAC_TX_LENGTHS, val |
    6114                 :            :                      (0xff << TX_LENGTHS_SLOT_TIME_SHIFT));
    6115                 :            :         else
    6116                 :          0 :                 tw32(MAC_TX_LENGTHS, val |
    6117                 :            :                      (32 << TX_LENGTHS_SLOT_TIME_SHIFT));
    6118                 :            : 
    6119         [ #  # ]:          0 :         if (!tg3_flag(tp, 5705_PLUS)) {
    6120         [ #  # ]:          0 :                 if (tp->link_up) {
    6121                 :          0 :                         tw32(HOSTCC_STAT_COAL_TICKS,
    6122                 :            :                              tp->coal.stats_block_coalesce_usecs);
    6123                 :            :                 } else {
    6124                 :          0 :                         tw32(HOSTCC_STAT_COAL_TICKS, 0);
    6125                 :            :                 }
    6126                 :            :         }
    6127                 :            : 
    6128         [ #  # ]:          0 :         if (tg3_flag(tp, ASPM_WORKAROUND)) {
    6129                 :          0 :                 val = tr32(PCIE_PWR_MGMT_THRESH);
    6130         [ #  # ]:          0 :                 if (!tp->link_up)
    6131                 :          0 :                         val = (val & ~PCIE_PWR_MGMT_L1_THRESH_MSK) |
    6132                 :          0 :                               tp->pwrmgmt_thresh;
    6133                 :            :                 else
    6134                 :          0 :                         val |= PCIE_PWR_MGMT_L1_THRESH_MSK;
    6135                 :          0 :                 tw32(PCIE_PWR_MGMT_THRESH, val);
    6136                 :            :         }
    6137                 :            : 
    6138                 :          0 :         return err;
    6139                 :            : }
    6140                 :            : 
    6141                 :            : /* tp->lock must be held */
    6142                 :          0 : static u64 tg3_refclk_read(struct tg3 *tp, struct ptp_system_timestamp *sts)
    6143                 :            : {
    6144                 :          0 :         u64 stamp;
    6145                 :            : 
    6146         [ #  # ]:          0 :         ptp_read_system_prets(sts);
    6147                 :          0 :         stamp = tr32(TG3_EAV_REF_CLCK_LSB);
    6148         [ #  # ]:          0 :         ptp_read_system_postts(sts);
    6149                 :          0 :         stamp |= (u64)tr32(TG3_EAV_REF_CLCK_MSB) << 32;
    6150                 :            : 
    6151                 :          0 :         return stamp;
    6152                 :            : }
    6153                 :            : 
    6154                 :            : /* tp->lock must be held */
    6155                 :          0 : static void tg3_refclk_write(struct tg3 *tp, u64 newval)
    6156                 :            : {
    6157                 :          0 :         u32 clock_ctl = tr32(TG3_EAV_REF_CLCK_CTL);
    6158                 :            : 
    6159                 :          0 :         tw32(TG3_EAV_REF_CLCK_CTL, clock_ctl | TG3_EAV_REF_CLCK_CTL_STOP);
    6160                 :          0 :         tw32(TG3_EAV_REF_CLCK_LSB, newval & 0xffffffff);
    6161                 :          0 :         tw32(TG3_EAV_REF_CLCK_MSB, newval >> 32);
    6162                 :          0 :         tw32_f(TG3_EAV_REF_CLCK_CTL, clock_ctl | TG3_EAV_REF_CLCK_CTL_RESUME);
    6163                 :          0 : }
    6164                 :            : 
    6165                 :            : static inline void tg3_full_lock(struct tg3 *tp, int irq_sync);
    6166                 :            : static inline void tg3_full_unlock(struct tg3 *tp);
    6167                 :          0 : static int tg3_get_ts_info(struct net_device *dev, struct ethtool_ts_info *info)
    6168                 :            : {
    6169                 :          0 :         struct tg3 *tp = netdev_priv(dev);
    6170                 :            : 
    6171                 :          0 :         info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE |
    6172                 :            :                                 SOF_TIMESTAMPING_RX_SOFTWARE |
    6173                 :            :                                 SOF_TIMESTAMPING_SOFTWARE;
    6174                 :            : 
    6175         [ #  # ]:          0 :         if (tg3_flag(tp, PTP_CAPABLE)) {
    6176                 :          0 :                 info->so_timestamping |= SOF_TIMESTAMPING_TX_HARDWARE |
    6177                 :            :                                         SOF_TIMESTAMPING_RX_HARDWARE |
    6178                 :            :                                         SOF_TIMESTAMPING_RAW_HARDWARE;
    6179                 :            :         }
    6180                 :            : 
    6181         [ #  # ]:          0 :         if (tp->ptp_clock)
    6182                 :          0 :                 info->phc_index = ptp_clock_index(tp->ptp_clock);
    6183                 :            :         else
    6184                 :          0 :                 info->phc_index = -1;
    6185                 :            : 
    6186                 :          0 :         info->tx_types = (1 << HWTSTAMP_TX_OFF) | (1 << HWTSTAMP_TX_ON);
    6187                 :            : 
    6188                 :          0 :         info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) |
    6189                 :            :                            (1 << HWTSTAMP_FILTER_PTP_V1_L4_EVENT) |
    6190                 :            :                            (1 << HWTSTAMP_FILTER_PTP_V2_L2_EVENT) |
    6191                 :            :                            (1 << HWTSTAMP_FILTER_PTP_V2_L4_EVENT);
    6192                 :          0 :         return 0;
    6193                 :            : }
    6194                 :            : 
    6195                 :          0 : static int tg3_ptp_adjfreq(struct ptp_clock_info *ptp, s32 ppb)
    6196                 :            : {
    6197                 :          0 :         struct tg3 *tp = container_of(ptp, struct tg3, ptp_info);
    6198                 :          0 :         bool neg_adj = false;
    6199                 :          0 :         u32 correction = 0;
    6200                 :            : 
    6201         [ #  # ]:          0 :         if (ppb < 0) {
    6202                 :          0 :                 neg_adj = true;
    6203                 :          0 :                 ppb = -ppb;
    6204                 :            :         }
    6205                 :            : 
    6206                 :            :         /* Frequency adjustment is performed using hardware with a 24 bit
    6207                 :            :          * accumulator and a programmable correction value. On each clk, the
    6208                 :            :          * correction value gets added to the accumulator and when it
    6209                 :            :          * overflows, the time counter is incremented/decremented.
    6210                 :            :          *
    6211                 :            :          * So conversion from ppb to correction value is
    6212                 :            :          *              ppb * (1 << 24) / 1000000000
    6213                 :            :          */
    6214                 :          0 :         correction = div_u64((u64)ppb * (1 << 24), 1000000000ULL) &
    6215                 :            :                      TG3_EAV_REF_CLK_CORRECT_MASK;
    6216                 :            : 
    6217                 :          0 :         tg3_full_lock(tp, 0);
    6218                 :            : 
    6219                 :          0 :         if (correction)
    6220         [ #  # ]:          0 :                 tw32(TG3_EAV_REF_CLK_CORRECT_CTL,
    6221                 :            :                      TG3_EAV_REF_CLK_CORRECT_EN |
    6222                 :            :                      (neg_adj ? TG3_EAV_REF_CLK_CORRECT_NEG : 0) | correction);
    6223                 :            :         else
    6224                 :          0 :                 tw32(TG3_EAV_REF_CLK_CORRECT_CTL, 0);
    6225                 :            : 
    6226                 :          0 :         tg3_full_unlock(tp);
    6227                 :            : 
    6228                 :          0 :         return 0;
    6229                 :            : }
    6230                 :            : 
    6231                 :          0 : static int tg3_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta)
    6232                 :            : {
    6233                 :          0 :         struct tg3 *tp = container_of(ptp, struct tg3, ptp_info);
    6234                 :            : 
    6235                 :          0 :         tg3_full_lock(tp, 0);
    6236                 :          0 :         tp->ptp_adjust += delta;
    6237                 :          0 :         tg3_full_unlock(tp);
    6238                 :            : 
    6239                 :          0 :         return 0;
    6240                 :            : }
    6241                 :            : 
    6242                 :          0 : static int tg3_ptp_gettimex(struct ptp_clock_info *ptp, struct timespec64 *ts,
    6243                 :            :                             struct ptp_system_timestamp *sts)
    6244                 :            : {
    6245                 :          0 :         u64 ns;
    6246                 :          0 :         struct tg3 *tp = container_of(ptp, struct tg3, ptp_info);
    6247                 :            : 
    6248                 :          0 :         tg3_full_lock(tp, 0);
    6249                 :          0 :         ns = tg3_refclk_read(tp, sts);
    6250                 :          0 :         ns += tp->ptp_adjust;
    6251                 :          0 :         tg3_full_unlock(tp);
    6252                 :            : 
    6253                 :          0 :         *ts = ns_to_timespec64(ns);
    6254                 :            : 
    6255                 :          0 :         return 0;
    6256                 :            : }
    6257                 :            : 
    6258                 :          0 : static int tg3_ptp_settime(struct ptp_clock_info *ptp,
    6259                 :            :                            const struct timespec64 *ts)
    6260                 :            : {
    6261                 :          0 :         u64 ns;
    6262                 :          0 :         struct tg3 *tp = container_of(ptp, struct tg3, ptp_info);
    6263                 :            : 
    6264                 :          0 :         ns = timespec64_to_ns(ts);
    6265                 :            : 
    6266                 :          0 :         tg3_full_lock(tp, 0);
    6267                 :          0 :         tg3_refclk_write(tp, ns);
    6268                 :          0 :         tp->ptp_adjust = 0;
    6269                 :          0 :         tg3_full_unlock(tp);
    6270                 :            : 
    6271                 :          0 :         return 0;
    6272                 :            : }
    6273                 :            : 
    6274                 :          0 : static int tg3_ptp_enable(struct ptp_clock_info *ptp,
    6275                 :            :                           struct ptp_clock_request *rq, int on)
    6276                 :            : {
    6277                 :          0 :         struct tg3 *tp = container_of(ptp, struct tg3, ptp_info);
    6278                 :          0 :         u32 clock_ctl;
    6279                 :          0 :         int rval = 0;
    6280                 :            : 
    6281         [ #  # ]:          0 :         switch (rq->type) {
    6282                 :          0 :         case PTP_CLK_REQ_PEROUT:
    6283                 :            :                 /* Reject requests with unsupported flags */
    6284         [ #  # ]:          0 :                 if (rq->perout.flags)
    6285                 :            :                         return -EOPNOTSUPP;
    6286                 :            : 
    6287         [ #  # ]:          0 :                 if (rq->perout.index != 0)
    6288                 :            :                         return -EINVAL;
    6289                 :            : 
    6290                 :          0 :                 tg3_full_lock(tp, 0);
    6291                 :          0 :                 clock_ctl = tr32(TG3_EAV_REF_CLCK_CTL);
    6292                 :          0 :                 clock_ctl &= ~TG3_EAV_CTL_TSYNC_GPIO_MASK;
    6293                 :            : 
    6294         [ #  # ]:          0 :                 if (on) {
    6295                 :          0 :                         u64 nsec;
    6296                 :            : 
    6297                 :          0 :                         nsec = rq->perout.start.sec * 1000000000ULL +
    6298                 :          0 :                                rq->perout.start.nsec;
    6299                 :            : 
    6300   [ #  #  #  # ]:          0 :                         if (rq->perout.period.sec || rq->perout.period.nsec) {
    6301                 :          0 :                                 netdev_warn(tp->dev,
    6302                 :            :                                             "Device supports only a one-shot timesync output, period must be 0\n");
    6303                 :          0 :                                 rval = -EINVAL;
    6304                 :          0 :                                 goto err_out;
    6305                 :            :                         }
    6306                 :            : 
    6307         [ #  # ]:          0 :                         if (nsec & (1ULL << 63)) {
    6308                 :          0 :                                 netdev_warn(tp->dev,
    6309                 :            :                                             "Start value (nsec) is over limit. Maximum size of start is only 63 bits\n");
    6310                 :          0 :                                 rval = -EINVAL;
    6311                 :          0 :                                 goto err_out;
    6312                 :            :                         }
    6313                 :            : 
    6314                 :          0 :                         tw32(TG3_EAV_WATCHDOG0_LSB, (nsec & 0xffffffff));
    6315                 :          0 :                         tw32(TG3_EAV_WATCHDOG0_MSB,
    6316                 :            :                              TG3_EAV_WATCHDOG0_EN |
    6317                 :            :                              ((nsec >> 32) & TG3_EAV_WATCHDOG_MSB_MASK));
    6318                 :            : 
    6319                 :          0 :                         tw32(TG3_EAV_REF_CLCK_CTL,
    6320                 :            :                              clock_ctl | TG3_EAV_CTL_TSYNC_WDOG0);
    6321                 :            :                 } else {
    6322                 :          0 :                         tw32(TG3_EAV_WATCHDOG0_MSB, 0);
    6323                 :          0 :                         tw32(TG3_EAV_REF_CLCK_CTL, clock_ctl);
    6324                 :            :                 }
    6325                 :            : 
    6326                 :          0 : err_out:
    6327                 :          0 :                 tg3_full_unlock(tp);
    6328                 :          0 :                 return rval;
    6329                 :            : 
    6330                 :            :         default:
    6331                 :            :                 break;
    6332                 :            :         }
    6333                 :            : 
    6334                 :            :         return -EOPNOTSUPP;
    6335                 :            : }
    6336                 :            : 
    6337                 :            : static const struct ptp_clock_info tg3_ptp_caps = {
    6338                 :            :         .owner          = THIS_MODULE,
    6339                 :            :         .name           = "tg3 clock",
    6340                 :            :         .max_adj        = 250000000,
    6341                 :            :         .n_alarm        = 0,
    6342                 :            :         .n_ext_ts       = 0,
    6343                 :            :         .n_per_out      = 1,
    6344                 :            :         .n_pins         = 0,
    6345                 :            :         .pps            = 0,
    6346                 :            :         .adjfreq        = tg3_ptp_adjfreq,
    6347                 :            :         .adjtime        = tg3_ptp_adjtime,
    6348                 :            :         .gettimex64     = tg3_ptp_gettimex,
    6349                 :            :         .settime64      = tg3_ptp_settime,
    6350                 :            :         .enable         = tg3_ptp_enable,
    6351                 :            : };
    6352                 :            : 
    6353                 :          0 : static void tg3_hwclock_to_timestamp(struct tg3 *tp, u64 hwclock,
    6354                 :            :                                      struct skb_shared_hwtstamps *timestamp)
    6355                 :            : {
    6356                 :          0 :         memset(timestamp, 0, sizeof(struct skb_shared_hwtstamps));
    6357                 :          0 :         timestamp->hwtstamp  = ns_to_ktime((hwclock & TG3_TSTAMP_MASK) +
    6358                 :          0 :                                            tp->ptp_adjust);
    6359                 :          0 : }
    6360                 :            : 
    6361                 :            : /* tp->lock must be held */
    6362                 :          0 : static void tg3_ptp_init(struct tg3 *tp)
    6363                 :            : {
    6364         [ #  # ]:          0 :         if (!tg3_flag(tp, PTP_CAPABLE))
    6365                 :            :                 return;
    6366                 :            : 
    6367                 :            :         /* Initialize the hardware clock to the system time. */
    6368                 :          0 :         tg3_refclk_write(tp, ktime_to_ns(ktime_get_real()));
    6369                 :          0 :         tp->ptp_adjust = 0;
    6370                 :          0 :         tp->ptp_info = tg3_ptp_caps;
    6371                 :            : }
    6372                 :            : 
    6373                 :            : /* tp->lock must be held */
    6374                 :          0 : static void tg3_ptp_resume(struct tg3 *tp)
    6375                 :            : {
    6376         [ #  # ]:          0 :         if (!tg3_flag(tp, PTP_CAPABLE))
    6377                 :            :                 return;
    6378                 :            : 
    6379                 :          0 :         tg3_refclk_write(tp, ktime_to_ns(ktime_get_real()) + tp->ptp_adjust);
    6380                 :          0 :         tp->ptp_adjust = 0;
    6381                 :            : }
    6382                 :            : 
    6383                 :          0 : static void tg3_ptp_fini(struct tg3 *tp)
    6384                 :            : {
    6385   [ #  #  #  # ]:          0 :         if (!tg3_flag(tp, PTP_CAPABLE) || !tp->ptp_clock)
    6386                 :            :                 return;
    6387                 :            : 
    6388                 :          0 :         ptp_clock_unregister(tp->ptp_clock);
    6389                 :          0 :         tp->ptp_clock = NULL;
    6390                 :          0 :         tp->ptp_adjust = 0;
    6391                 :            : }
    6392                 :            : 
    6393                 :          0 : static inline int tg3_irq_sync(struct tg3 *tp)
    6394                 :            : {
    6395                 :          0 :         return tp->irq_sync;
    6396                 :            : }
    6397                 :            : 
    6398                 :          0 : static inline void tg3_rd32_loop(struct tg3 *tp, u32 *dst, u32 off, u32 len)
    6399                 :            : {
    6400                 :          0 :         int i;
    6401                 :            : 
    6402                 :          0 :         dst = (u32 *)((u8 *)dst + off);
    6403   [ #  #  #  #  :          0 :         for (i = 0; i < len; i += sizeof(u32))
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    6404                 :          0 :                 *dst++ = tr32(off + i);
    6405                 :            : }
    6406                 :            : 
    6407                 :          0 : static void tg3_dump_legacy_regs(struct tg3 *tp, u32 *regs)
    6408                 :            : {
    6409                 :          0 :         tg3_rd32_loop(tp, regs, TG3PCI_VENDOR, 0xb0);
    6410                 :          0 :         tg3_rd32_loop(tp, regs, MAILBOX_INTERRUPT_0, 0x200);
    6411                 :          0 :         tg3_rd32_loop(tp, regs, MAC_MODE, 0x4f0);
    6412                 :          0 :         tg3_rd32_loop(tp, regs, SNDDATAI_MODE, 0xe0);
    6413                 :          0 :         tg3_rd32_loop(tp, regs, SNDDATAC_MODE, 0x04);
    6414                 :          0 :         tg3_rd32_loop(tp, regs, SNDBDS_MODE, 0x80);
    6415                 :          0 :         tg3_rd32_loop(tp, regs, SNDBDI_MODE, 0x48);
    6416                 :          0 :         tg3_rd32_loop(tp, regs, SNDBDC_MODE, 0x04);
    6417                 :          0 :         tg3_rd32_loop(tp, regs, RCVLPC_MODE, 0x20);
    6418                 :          0 :         tg3_rd32_loop(tp, regs, RCVLPC_SELLST_BASE, 0x15c);
    6419                 :          0 :         tg3_rd32_loop(tp, regs, RCVDBDI_MODE, 0x0c);
    6420                 :          0 :         tg3_rd32_loop(tp, regs, RCVDBDI_JUMBO_BD, 0x3c);
    6421                 :          0 :         tg3_rd32_loop(tp, regs, RCVDBDI_BD_PROD_IDX_0, 0x44);
    6422                 :          0 :         tg3_rd32_loop(tp, regs, RCVDCC_MODE, 0x04);
    6423                 :          0 :         tg3_rd32_loop(tp, regs, RCVBDI_MODE, 0x20);
    6424                 :          0 :         tg3_rd32_loop(tp, regs, RCVCC_MODE, 0x14);
    6425                 :          0 :         tg3_rd32_loop(tp, regs, RCVLSC_MODE, 0x08);
    6426                 :          0 :         tg3_rd32_loop(tp, regs, MBFREE_MODE, 0x08);
    6427                 :          0 :         tg3_rd32_loop(tp, regs, HOSTCC_MODE, 0x100);
    6428                 :            : 
    6429         [ #  # ]:          0 :         if (tg3_flag(tp, SUPPORT_MSIX))
    6430                 :          0 :                 tg3_rd32_loop(tp, regs, HOSTCC_RXCOL_TICKS_VEC1, 0x180);
    6431                 :            : 
    6432                 :          0 :         tg3_rd32_loop(tp, regs, MEMARB_MODE, 0x10);
    6433                 :          0 :         tg3_rd32_loop(tp, regs, BUFMGR_MODE, 0x58);
    6434                 :          0 :         tg3_rd32_loop(tp, regs, RDMAC_MODE, 0x08);
    6435                 :          0 :         tg3_rd32_loop(tp, regs, WDMAC_MODE, 0x08);
    6436                 :          0 :         tg3_rd32_loop(tp, regs, RX_CPU_MODE, 0x04);
    6437                 :          0 :         tg3_rd32_loop(tp, regs, RX_CPU_STATE, 0x04);
    6438                 :          0 :         tg3_rd32_loop(tp, regs, RX_CPU_PGMCTR, 0x04);
    6439                 :          0 :         tg3_rd32_loop(tp, regs, RX_CPU_HWBKPT, 0x04);
    6440                 :            : 
    6441         [ #  # ]:          0 :         if (!tg3_flag(tp, 5705_PLUS)) {
    6442                 :          0 :                 tg3_rd32_loop(tp, regs, TX_CPU_MODE, 0x04);
    6443                 :          0 :                 tg3_rd32_loop(tp, regs, TX_CPU_STATE, 0x04);
    6444                 :          0 :                 tg3_rd32_loop(tp, regs, TX_CPU_PGMCTR, 0x04);
    6445                 :            :         }
    6446                 :            : 
    6447                 :          0 :         tg3_rd32_loop(tp, regs, GRCMBOX_INTERRUPT_0, 0x110);
    6448                 :          0 :         tg3_rd32_loop(tp, regs, FTQ_RESET, 0x120);
    6449                 :          0 :         tg3_rd32_loop(tp, regs, MSGINT_MODE, 0x0c);
    6450                 :          0 :         tg3_rd32_loop(tp, regs, DMAC_MODE, 0x04);
    6451                 :          0 :         tg3_rd32_loop(tp, regs, GRC_MODE, 0x4c);
    6452                 :            : 
    6453         [ #  # ]:          0 :         if (tg3_flag(tp, NVRAM))
    6454                 :          0 :                 tg3_rd32_loop(tp, regs, NVRAM_CMD, 0x24);
    6455                 :          0 : }
    6456                 :            : 
    6457                 :          0 : static void tg3_dump_state(struct tg3 *tp)
    6458                 :            : {
    6459                 :          0 :         int i;
    6460                 :          0 :         u32 *regs;
    6461                 :            : 
    6462                 :          0 :         regs = kzalloc(TG3_REG_BLK_SIZE, GFP_ATOMIC);
    6463         [ #  # ]:          0 :         if (!regs)
    6464                 :            :                 return;
    6465                 :            : 
    6466         [ #  # ]:          0 :         if (tg3_flag(tp, PCI_EXPRESS)) {
    6467                 :            :                 /* Read up to but not including private PCI registers */
    6468         [ #  # ]:          0 :                 for (i = 0; i < TG3_PCIE_TLDLPL_PORT; i += sizeof(u32))
    6469                 :          0 :                         regs[i / sizeof(u32)] = tr32(i);
    6470                 :            :         } else
    6471                 :          0 :                 tg3_dump_legacy_regs(tp, regs);
    6472                 :            : 
    6473         [ #  # ]:          0 :         for (i = 0; i < TG3_REG_BLK_SIZE / sizeof(u32); i += 4) {
    6474   [ #  #  #  # ]:          0 :                 if (!regs[i + 0] && !regs[i + 1] &&
    6475   [ #  #  #  # ]:          0 :                     !regs[i + 2] && !regs[i + 3])
    6476                 :          0 :                         continue;
    6477                 :            : 
    6478                 :          0 :                 netdev_err(tp->dev, "0x%08x: 0x%08x, 0x%08x, 0x%08x, 0x%08x\n",
    6479                 :            :                            i * 4,
    6480                 :          0 :                            regs[i + 0], regs[i + 1], regs[i + 2], regs[i + 3]);
    6481                 :            :         }
    6482                 :            : 
    6483                 :          0 :         kfree(regs);
    6484                 :            : 
    6485         [ #  # ]:          0 :         for (i = 0; i < tp->irq_cnt; i++) {
    6486                 :          0 :                 struct tg3_napi *tnapi = &tp->napi[i];
    6487                 :            : 
    6488                 :            :                 /* SW status block */
    6489                 :          0 :                 netdev_err(tp->dev,
    6490                 :            :                          "%d: Host status block [%08x:%08x:(%04x:%04x:%04x):(%04x:%04x)]\n",
    6491                 :            :                            i,
    6492                 :            :                            tnapi->hw_status->status,
    6493                 :            :                            tnapi->hw_status->status_tag,
    6494                 :          0 :                            tnapi->hw_status->rx_jumbo_consumer,
    6495                 :          0 :                            tnapi->hw_status->rx_consumer,
    6496                 :          0 :                            tnapi->hw_status->rx_mini_consumer,
    6497                 :          0 :                            tnapi->hw_status->idx[0].rx_producer,
    6498                 :          0 :                            tnapi->hw_status->idx[0].tx_consumer);
    6499                 :            : 
    6500                 :          0 :                 netdev_err(tp->dev,
    6501                 :            :                 "%d: NAPI info [%08x:%08x:(%04x:%04x:%04x):%04x:(%04x:%04x:%04x:%04x)]\n",
    6502                 :            :                            i,
    6503                 :            :                            tnapi->last_tag, tnapi->last_irq_tag,
    6504                 :            :                            tnapi->tx_prod, tnapi->tx_cons, tnapi->tx_pending,
    6505                 :            :                            tnapi->rx_rcb_ptr,
    6506                 :            :                            tnapi->prodring.rx_std_prod_idx,
    6507                 :            :                            tnapi->prodring.rx_std_cons_idx,
    6508                 :            :                            tnapi->prodring.rx_jmb_prod_idx,
    6509                 :            :                            tnapi->prodring.rx_jmb_cons_idx);
    6510                 :            :         }
    6511                 :            : }
    6512                 :            : 
    6513                 :            : /* This is called whenever we suspect that the system chipset is re-
    6514                 :            :  * ordering the sequence of MMIO to the tx send mailbox. The symptom
    6515                 :            :  * is bogus tx completions. We try to recover by setting the
    6516                 :            :  * TG3_FLAG_MBOX_WRITE_REORDER flag and resetting the chip later
    6517                 :            :  * in the workqueue.
    6518                 :            :  */
    6519                 :          0 : static void tg3_tx_recover(struct tg3 *tp)
    6520                 :            : {
    6521   [ #  #  #  # ]:          0 :         BUG_ON(tg3_flag(tp, MBOX_WRITE_REORDER) ||
    6522                 :            :                tp->write32_tx_mbox == tg3_write_indirect_mbox);
    6523                 :            : 
    6524                 :          0 :         netdev_warn(tp->dev,
    6525                 :            :                     "The system may be re-ordering memory-mapped I/O "
    6526                 :            :                     "cycles to the network device, attempting to recover. "
    6527                 :            :                     "Please report the problem to the driver maintainer "
    6528                 :            :                     "and include system chipset information.\n");
    6529                 :            : 
    6530                 :          0 :         tg3_flag_set(tp, TX_RECOVERY_PENDING);
    6531                 :          0 : }
    6532                 :            : 
    6533                 :          0 : static inline u32 tg3_tx_avail(struct tg3_napi *tnapi)
    6534                 :            : {
    6535                 :            :         /* Tell compiler to fetch tx indices from memory. */
    6536                 :          0 :         barrier();
    6537                 :          0 :         return tnapi->tx_pending -
    6538                 :          0 :                ((tnapi->tx_prod - tnapi->tx_cons) & (TG3_TX_RING_SIZE - 1));
    6539                 :            : }
    6540                 :            : 
    6541                 :            : /* Tigon3 never reports partial packet sends.  So we do not
    6542                 :            :  * need special logic to handle SKBs that have not had all
    6543                 :            :  * of their frags sent yet, like SunGEM does.
    6544                 :            :  */
    6545                 :          0 : static void tg3_tx(struct tg3_napi *tnapi)
    6546                 :            : {
    6547                 :          0 :         struct tg3 *tp = tnapi->tp;
    6548                 :          0 :         u32 hw_idx = tnapi->hw_status->idx[0].tx_consumer;
    6549                 :          0 :         u32 sw_idx = tnapi->tx_cons;
    6550                 :          0 :         struct netdev_queue *txq;
    6551                 :          0 :         int index = tnapi - tp->napi;
    6552                 :          0 :         unsigned int pkts_compl = 0, bytes_compl = 0;
    6553                 :            : 
    6554         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_TSS))
    6555                 :          0 :                 index--;
    6556                 :            : 
    6557                 :          0 :         txq = netdev_get_tx_queue(tp->dev, index);
    6558                 :            : 
    6559         [ #  # ]:          0 :         while (sw_idx != hw_idx) {
    6560                 :          0 :                 struct tg3_tx_ring_info *ri = &tnapi->tx_buffers[sw_idx];
    6561                 :          0 :                 struct sk_buff *skb = ri->skb;
    6562                 :          0 :                 int i, tx_bug = 0;
    6563                 :            : 
    6564         [ #  # ]:          0 :                 if (unlikely(skb == NULL)) {
    6565                 :          0 :                         tg3_tx_recover(tp);
    6566                 :          0 :                         return;
    6567                 :            :                 }
    6568                 :            : 
    6569         [ #  # ]:          0 :                 if (tnapi->tx_ring[sw_idx].len_flags & TXD_FLAG_HWTSTAMP) {
    6570                 :          0 :                         struct skb_shared_hwtstamps timestamp;
    6571                 :          0 :                         u64 hwclock = tr32(TG3_TX_TSTAMP_LSB);
    6572                 :          0 :                         hwclock |= (u64)tr32(TG3_TX_TSTAMP_MSB) << 32;
    6573                 :            : 
    6574                 :          0 :                         tg3_hwclock_to_timestamp(tp, hwclock, &timestamp);
    6575                 :            : 
    6576                 :          0 :                         skb_tstamp_tx(skb, &timestamp);
    6577                 :            :                 }
    6578                 :            : 
    6579                 :          0 :                 pci_unmap_single(tp->pdev,
    6580                 :            :                                  dma_unmap_addr(ri, mapping),
    6581                 :          0 :                                  skb_headlen(skb),
    6582                 :            :                                  PCI_DMA_TODEVICE);
    6583                 :            : 
    6584                 :          0 :                 ri->skb = NULL;
    6585                 :            : 
    6586         [ #  # ]:          0 :                 while (ri->fragmented) {
    6587                 :          0 :                         ri->fragmented = false;
    6588                 :          0 :                         sw_idx = NEXT_TX(sw_idx);
    6589                 :          0 :                         ri = &tnapi->tx_buffers[sw_idx];
    6590                 :            :                 }
    6591                 :            : 
    6592                 :          0 :                 sw_idx = NEXT_TX(sw_idx);
    6593                 :            : 
    6594         [ #  # ]:          0 :                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
    6595                 :          0 :                         ri = &tnapi->tx_buffers[sw_idx];
    6596   [ #  #  #  # ]:          0 :                         if (unlikely(ri->skb != NULL || sw_idx == hw_idx))
    6597                 :          0 :                                 tx_bug = 1;
    6598                 :            : 
    6599                 :          0 :                         pci_unmap_page(tp->pdev,
    6600                 :            :                                        dma_unmap_addr(ri, mapping),
    6601                 :          0 :                                        skb_frag_size(&skb_shinfo(skb)->frags[i]),
    6602                 :            :                                        PCI_DMA_TODEVICE);
    6603                 :            : 
    6604         [ #  # ]:          0 :                         while (ri->fragmented) {
    6605                 :          0 :                                 ri->fragmented = false;
    6606                 :          0 :                                 sw_idx = NEXT_TX(sw_idx);
    6607                 :          0 :                                 ri = &tnapi->tx_buffers[sw_idx];
    6608                 :            :                         }
    6609                 :            : 
    6610                 :          0 :                         sw_idx = NEXT_TX(sw_idx);
    6611                 :            :                 }
    6612                 :            : 
    6613                 :          0 :                 pkts_compl++;
    6614                 :          0 :                 bytes_compl += skb->len;
    6615                 :            : 
    6616                 :          0 :                 dev_consume_skb_any(skb);
    6617                 :            : 
    6618         [ #  # ]:          0 :                 if (unlikely(tx_bug)) {
    6619                 :          0 :                         tg3_tx_recover(tp);
    6620                 :          0 :                         return;
    6621                 :            :                 }
    6622                 :            :         }
    6623                 :            : 
    6624                 :          0 :         netdev_tx_completed_queue(txq, pkts_compl, bytes_compl);
    6625                 :            : 
    6626                 :          0 :         tnapi->tx_cons = sw_idx;
    6627                 :            : 
    6628                 :            :         /* Need to make the tx_cons update visible to tg3_start_xmit()
    6629                 :            :          * before checking for netif_queue_stopped().  Without the
    6630                 :            :          * memory barrier, there is a small possibility that tg3_start_xmit()
    6631                 :            :          * will miss it and cause the queue to be stopped forever.
    6632                 :            :          */
    6633                 :          0 :         smp_mb();
    6634                 :            : 
    6635   [ #  #  #  # ]:          0 :         if (unlikely(netif_tx_queue_stopped(txq) &&
    6636                 :            :                      (tg3_tx_avail(tnapi) > TG3_TX_WAKEUP_THRESH(tnapi)))) {
    6637                 :          0 :                 __netif_tx_lock(txq, smp_processor_id());
    6638         [ #  # ]:          0 :                 if (netif_tx_queue_stopped(txq) &&
    6639         [ #  # ]:          0 :                     (tg3_tx_avail(tnapi) > TG3_TX_WAKEUP_THRESH(tnapi)))
    6640                 :          0 :                         netif_tx_wake_queue(txq);
    6641                 :          0 :                 __netif_tx_unlock(txq);
    6642                 :            :         }
    6643                 :            : }
    6644                 :            : 
    6645                 :          0 : static void tg3_frag_free(bool is_frag, void *data)
    6646                 :            : {
    6647                 :          0 :         if (is_frag)
    6648                 :          0 :                 skb_free_frag(data);
    6649                 :            :         else
    6650                 :          0 :                 kfree(data);
    6651                 :            : }
    6652                 :            : 
    6653                 :            : static void tg3_rx_data_free(struct tg3 *tp, struct ring_info *ri, u32 map_sz)
    6654                 :            : {
    6655                 :            :         unsigned int skb_size = SKB_DATA_ALIGN(map_sz + TG3_RX_OFFSET(tp)) +
    6656                 :            :                    SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
    6657                 :            : 
    6658                 :            :         if (!ri->data)
    6659                 :            :                 return;
    6660                 :            : 
    6661                 :            :         pci_unmap_single(tp->pdev, dma_unmap_addr(ri, mapping),
    6662                 :            :                          map_sz, PCI_DMA_FROMDEVICE);
    6663                 :            :         tg3_frag_free(skb_size <= PAGE_SIZE, ri->data);
    6664                 :            :         ri->data = NULL;
    6665                 :            : }
    6666                 :            : 
    6667                 :            : 
    6668                 :            : /* Returns size of skb allocated or < 0 on error.
    6669                 :            :  *
    6670                 :            :  * We only need to fill in the address because the other members
    6671                 :            :  * of the RX descriptor are invariant, see tg3_init_rings.
    6672                 :            :  *
    6673                 :            :  * Note the purposeful assymetry of cpu vs. chip accesses.  For
    6674                 :            :  * posting buffers we only dirty the first cache line of the RX
    6675                 :            :  * descriptor (containing the address).  Whereas for the RX status
    6676                 :            :  * buffers the cpu only reads the last cacheline of the RX descriptor
    6677                 :            :  * (to fetch the error flags, vlan tag, checksum, and opaque cookie).
    6678                 :            :  */
    6679                 :          0 : static int tg3_alloc_rx_data(struct tg3 *tp, struct tg3_rx_prodring_set *tpr,
    6680                 :            :                              u32 opaque_key, u32 dest_idx_unmasked,
    6681                 :            :                              unsigned int *frag_size)
    6682                 :            : {
    6683                 :          0 :         struct tg3_rx_buffer_desc *desc;
    6684                 :          0 :         struct ring_info *map;
    6685                 :          0 :         u8 *data;
    6686                 :          0 :         dma_addr_t mapping;
    6687                 :          0 :         int skb_size, data_size, dest_idx;
    6688                 :            : 
    6689      [ #  #  # ]:          0 :         switch (opaque_key) {
    6690                 :          0 :         case RXD_OPAQUE_RING_STD:
    6691                 :          0 :                 dest_idx = dest_idx_unmasked & tp->rx_std_ring_mask;
    6692                 :          0 :                 desc = &tpr->rx_std[dest_idx];
    6693                 :          0 :                 map = &tpr->rx_std_buffers[dest_idx];
    6694                 :          0 :                 data_size = tp->rx_pkt_map_sz;
    6695                 :          0 :                 break;
    6696                 :            : 
    6697                 :          0 :         case RXD_OPAQUE_RING_JUMBO:
    6698                 :          0 :                 dest_idx = dest_idx_unmasked & tp->rx_jmb_ring_mask;
    6699                 :          0 :                 desc = &tpr->rx_jmb[dest_idx].std;
    6700                 :          0 :                 map = &tpr->rx_jmb_buffers[dest_idx];
    6701                 :          0 :                 data_size = TG3_RX_JMB_MAP_SZ;
    6702                 :          0 :                 break;
    6703                 :            : 
    6704                 :            :         default:
    6705                 :            :                 return -EINVAL;
    6706                 :            :         }
    6707                 :            : 
    6708                 :            :         /* Do not overwrite any of the map or rp information
    6709                 :            :          * until we are sure we can commit to a new buffer.
    6710                 :            :          *
    6711                 :            :          * Callers depend upon this behavior and assume that
    6712                 :            :          * we leave everything unchanged if we fail.
    6713                 :            :          */
    6714                 :          0 :         skb_size = SKB_DATA_ALIGN(data_size + TG3_RX_OFFSET(tp)) +
    6715                 :            :                    SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
    6716         [ #  # ]:          0 :         if (skb_size <= PAGE_SIZE) {
    6717                 :          0 :                 data = napi_alloc_frag(skb_size);
    6718                 :          0 :                 *frag_size = skb_size;
    6719                 :            :         } else {
    6720         [ #  # ]:          0 :                 data = kmalloc(skb_size, GFP_ATOMIC);
    6721                 :          0 :                 *frag_size = 0;
    6722                 :            :         }
    6723         [ #  # ]:          0 :         if (!data)
    6724                 :            :                 return -ENOMEM;
    6725                 :            : 
    6726                 :          0 :         mapping = pci_map_single(tp->pdev,
    6727                 :          0 :                                  data + TG3_RX_OFFSET(tp),
    6728                 :            :                                  data_size,
    6729                 :            :                                  PCI_DMA_FROMDEVICE);
    6730         [ #  # ]:          0 :         if (unlikely(pci_dma_mapping_error(tp->pdev, mapping))) {
    6731         [ #  # ]:          0 :                 tg3_frag_free(skb_size <= PAGE_SIZE, data);
    6732                 :          0 :                 return -EIO;
    6733                 :            :         }
    6734                 :            : 
    6735                 :          0 :         map->data = data;
    6736                 :          0 :         dma_unmap_addr_set(map, mapping, mapping);
    6737                 :            : 
    6738                 :          0 :         desc->addr_hi = ((u64)mapping >> 32);
    6739                 :          0 :         desc->addr_lo = ((u64)mapping & 0xffffffff);
    6740                 :            : 
    6741                 :          0 :         return data_size;
    6742                 :            : }
    6743                 :            : 
    6744                 :            : /* We only need to move over in the address because the other
    6745                 :            :  * members of the RX descriptor are invariant.  See notes above
    6746                 :            :  * tg3_alloc_rx_data for full details.
    6747                 :            :  */
    6748                 :            : static void tg3_recycle_rx(struct tg3_napi *tnapi,
    6749                 :            :                            struct tg3_rx_prodring_set *dpr,
    6750                 :            :                            u32 opaque_key, int src_idx,
    6751                 :            :                            u32 dest_idx_unmasked)
    6752                 :            : {
    6753                 :            :         struct tg3 *tp = tnapi->tp;
    6754                 :            :         struct tg3_rx_buffer_desc *src_desc, *dest_desc;
    6755                 :            :         struct ring_info *src_map, *dest_map;
    6756                 :            :         struct tg3_rx_prodring_set *spr = &tp->napi[0].prodring;
    6757                 :            :         int dest_idx;
    6758                 :            : 
    6759                 :            :         switch (opaque_key) {
    6760                 :            :         case RXD_OPAQUE_RING_STD:
    6761                 :            :                 dest_idx = dest_idx_unmasked & tp->rx_std_ring_mask;
    6762                 :            :                 dest_desc = &dpr->rx_std[dest_idx];
    6763                 :            :                 dest_map = &dpr->rx_std_buffers[dest_idx];
    6764                 :            :                 src_desc = &spr->rx_std[src_idx];
    6765                 :            :                 src_map = &spr->rx_std_buffers[src_idx];
    6766                 :            :                 break;
    6767                 :            : 
    6768                 :            :         case RXD_OPAQUE_RING_JUMBO:
    6769                 :            :                 dest_idx = dest_idx_unmasked & tp->rx_jmb_ring_mask;
    6770                 :            :                 dest_desc = &dpr->rx_jmb[dest_idx].std;
    6771                 :            :                 dest_map = &dpr->rx_jmb_buffers[dest_idx];
    6772                 :            :                 src_desc = &spr->rx_jmb[src_idx].std;
    6773                 :            :                 src_map = &spr->rx_jmb_buffers[src_idx];
    6774                 :            :                 break;
    6775                 :            : 
    6776                 :            :         default:
    6777                 :            :                 return;
    6778                 :            :         }
    6779                 :            : 
    6780                 :            :         dest_map->data = src_map->data;
    6781                 :            :         dma_unmap_addr_set(dest_map, mapping,
    6782                 :            :                            dma_unmap_addr(src_map, mapping));
    6783                 :            :         dest_desc->addr_hi = src_desc->addr_hi;
    6784                 :            :         dest_desc->addr_lo = src_desc->addr_lo;
    6785                 :            : 
    6786                 :            :         /* Ensure that the update to the skb happens after the physical
    6787                 :            :          * addresses have been transferred to the new BD location.
    6788                 :            :          */
    6789                 :            :         smp_wmb();
    6790                 :            : 
    6791                 :            :         src_map->data = NULL;
    6792                 :            : }
    6793                 :            : 
    6794                 :            : /* The RX ring scheme is composed of multiple rings which post fresh
    6795                 :            :  * buffers to the chip, and one special ring the chip uses to report
    6796                 :            :  * status back to the host.
    6797                 :            :  *
    6798                 :            :  * The special ring reports the status of received packets to the
    6799                 :            :  * host.  The chip does not write into the original descriptor the
    6800                 :            :  * RX buffer was obtained from.  The chip simply takes the original
    6801                 :            :  * descriptor as provided by the host, updates the status and length
    6802                 :            :  * field, then writes this into the next status ring entry.
    6803                 :            :  *
    6804                 :            :  * Each ring the host uses to post buffers to the chip is described
    6805                 :            :  * by a TG3_BDINFO entry in the chips SRAM area.  When a packet arrives,
    6806                 :            :  * it is first placed into the on-chip ram.  When the packet's length
    6807                 :            :  * is known, it walks down the TG3_BDINFO entries to select the ring.
    6808                 :            :  * Each TG3_BDINFO specifies a MAXLEN field and the first TG3_BDINFO
    6809                 :            :  * which is within the range of the new packet's length is chosen.
    6810                 :            :  *
    6811                 :            :  * The "separate ring for rx status" scheme may sound queer, but it makes
    6812                 :            :  * sense from a cache coherency perspective.  If only the host writes
    6813                 :            :  * to the buffer post rings, and only the chip writes to the rx status
    6814                 :            :  * rings, then cache lines never move beyond shared-modified state.
    6815                 :            :  * If both the host and chip were to write into the same ring, cache line
    6816                 :            :  * eviction could occur since both entities want it in an exclusive state.
    6817                 :            :  */
    6818                 :          0 : static int tg3_rx(struct tg3_napi *tnapi, int budget)
    6819                 :            : {
    6820                 :          0 :         struct tg3 *tp = tnapi->tp;
    6821                 :          0 :         u32 work_mask, rx_std_posted = 0;
    6822                 :          0 :         u32 std_prod_idx, jmb_prod_idx;
    6823                 :          0 :         u32 sw_idx = tnapi->rx_rcb_ptr;
    6824                 :          0 :         u16 hw_idx;
    6825                 :          0 :         int received;
    6826                 :          0 :         struct tg3_rx_prodring_set *tpr = &tnapi->prodring;
    6827                 :            : 
    6828                 :          0 :         hw_idx = *(tnapi->rx_rcb_prod_idx);
    6829                 :            :         /*
    6830                 :            :          * We need to order the read of hw_idx and the read of
    6831                 :            :          * the opaque cookie.
    6832                 :            :          */
    6833                 :          0 :         rmb();
    6834                 :          0 :         work_mask = 0;
    6835                 :          0 :         received = 0;
    6836                 :          0 :         std_prod_idx = tpr->rx_std_prod_idx;
    6837                 :          0 :         jmb_prod_idx = tpr->rx_jmb_prod_idx;
    6838   [ #  #  #  # ]:          0 :         while (sw_idx != hw_idx && budget > 0) {
    6839                 :          0 :                 struct ring_info *ri;
    6840                 :          0 :                 struct tg3_rx_buffer_desc *desc = &tnapi->rx_rcb[sw_idx];
    6841                 :          0 :                 unsigned int len;
    6842                 :          0 :                 struct sk_buff *skb;
    6843                 :          0 :                 dma_addr_t dma_addr;
    6844                 :          0 :                 u32 opaque_key, desc_idx, *post_ptr;
    6845                 :          0 :                 u8 *data;
    6846                 :          0 :                 u64 tstamp = 0;
    6847                 :            : 
    6848                 :          0 :                 desc_idx = desc->opaque & RXD_OPAQUE_INDEX_MASK;
    6849                 :          0 :                 opaque_key = desc->opaque & RXD_OPAQUE_RING_MASK;
    6850         [ #  # ]:          0 :                 if (opaque_key == RXD_OPAQUE_RING_STD) {
    6851                 :          0 :                         ri = &tp->napi[0].prodring.rx_std_buffers[desc_idx];
    6852                 :          0 :                         dma_addr = dma_unmap_addr(ri, mapping);
    6853                 :          0 :                         data = ri->data;
    6854                 :          0 :                         post_ptr = &std_prod_idx;
    6855                 :          0 :                         rx_std_posted++;
    6856         [ #  # ]:          0 :                 } else if (opaque_key == RXD_OPAQUE_RING_JUMBO) {
    6857                 :          0 :                         ri = &tp->napi[0].prodring.rx_jmb_buffers[desc_idx];
    6858                 :          0 :                         dma_addr = dma_unmap_addr(ri, mapping);
    6859                 :          0 :                         data = ri->data;
    6860                 :          0 :                         post_ptr = &jmb_prod_idx;
    6861                 :            :                 } else
    6862                 :          0 :                         goto next_pkt_nopost;
    6863                 :            : 
    6864                 :          0 :                 work_mask |= opaque_key;
    6865                 :            : 
    6866         [ #  # ]:          0 :                 if (desc->err_vlan & RXD_ERR_MASK) {
    6867                 :          0 :                 drop_it:
    6868                 :          0 :                         tg3_recycle_rx(tnapi, tpr, opaque_key,
    6869                 :            :                                        desc_idx, *post_ptr);
    6870                 :          0 :                 drop_it_no_recycle:
    6871                 :            :                         /* Other statistics kept track of by card. */
    6872                 :          0 :                         tp->rx_dropped++;
    6873                 :          0 :                         goto next_pkt;
    6874                 :            :                 }
    6875                 :            : 
    6876                 :          0 :                 prefetch(data + TG3_RX_OFFSET(tp));
    6877                 :          0 :                 len = ((desc->idx_len & RXD_LEN_MASK) >> RXD_LEN_SHIFT) -
    6878                 :            :                       ETH_FCS_LEN;
    6879                 :            : 
    6880                 :          0 :                 if ((desc->type_flags & RXD_FLAG_PTPSTAT_MASK) ==
    6881         [ #  # ]:          0 :                      RXD_FLAG_PTPSTAT_PTPV1 ||
    6882                 :            :                     (desc->type_flags & RXD_FLAG_PTPSTAT_MASK) ==
    6883                 :            :                      RXD_FLAG_PTPSTAT_PTPV2) {
    6884                 :          0 :                         tstamp = tr32(TG3_RX_TSTAMP_LSB);
    6885                 :          0 :                         tstamp |= (u64)tr32(TG3_RX_TSTAMP_MSB) << 32;
    6886                 :            :                 }
    6887                 :            : 
    6888         [ #  # ]:          0 :                 if (len > TG3_RX_COPY_THRESH(tp)) {
    6889                 :          0 :                         int skb_size;
    6890                 :          0 :                         unsigned int frag_size;
    6891                 :            : 
    6892                 :          0 :                         skb_size = tg3_alloc_rx_data(tp, tpr, opaque_key,
    6893                 :            :                                                     *post_ptr, &frag_size);
    6894         [ #  # ]:          0 :                         if (skb_size < 0)
    6895                 :          0 :                                 goto drop_it;
    6896                 :            : 
    6897                 :          0 :                         pci_unmap_single(tp->pdev, dma_addr, skb_size,
    6898                 :            :                                          PCI_DMA_FROMDEVICE);
    6899                 :            : 
    6900                 :            :                         /* Ensure that the update to the data happens
    6901                 :            :                          * after the usage of the old DMA mapping.
    6902                 :            :                          */
    6903                 :          0 :                         smp_wmb();
    6904                 :            : 
    6905                 :          0 :                         ri->data = NULL;
    6906                 :            : 
    6907                 :          0 :                         skb = build_skb(data, frag_size);
    6908         [ #  # ]:          0 :                         if (!skb) {
    6909         [ #  # ]:          0 :                                 tg3_frag_free(frag_size != 0, data);
    6910                 :          0 :                                 goto drop_it_no_recycle;
    6911                 :            :                         }
    6912                 :          0 :                         skb_reserve(skb, TG3_RX_OFFSET(tp));
    6913                 :            :                 } else {
    6914                 :          0 :                         tg3_recycle_rx(tnapi, tpr, opaque_key,
    6915                 :            :                                        desc_idx, *post_ptr);
    6916                 :            : 
    6917                 :          0 :                         skb = netdev_alloc_skb(tp->dev,
    6918                 :            :                                                len + TG3_RAW_IP_ALIGN);
    6919         [ #  # ]:          0 :                         if (skb == NULL)
    6920                 :          0 :                                 goto drop_it_no_recycle;
    6921                 :            : 
    6922                 :          0 :                         skb_reserve(skb, TG3_RAW_IP_ALIGN);
    6923                 :          0 :                         pci_dma_sync_single_for_cpu(tp->pdev, dma_addr, len, PCI_DMA_FROMDEVICE);
    6924                 :          0 :                         memcpy(skb->data,
    6925                 :            :                                data + TG3_RX_OFFSET(tp),
    6926                 :            :                                len);
    6927                 :          0 :                         pci_dma_sync_single_for_device(tp->pdev, dma_addr, len, PCI_DMA_FROMDEVICE);
    6928                 :            :                 }
    6929                 :            : 
    6930                 :          0 :                 skb_put(skb, len);
    6931         [ #  # ]:          0 :                 if (tstamp)
    6932                 :          0 :                         tg3_hwclock_to_timestamp(tp, tstamp,
    6933                 :            :                                                  skb_hwtstamps(skb));
    6934                 :            : 
    6935         [ #  # ]:          0 :                 if ((tp->dev->features & NETIF_F_RXCSUM) &&
    6936         [ #  # ]:          0 :                     (desc->type_flags & RXD_FLAG_TCPUDP_CSUM) &&
    6937                 :          0 :                     (((desc->ip_tcp_csum & RXD_TCPCSUM_MASK)
    6938         [ #  # ]:          0 :                       >> RXD_TCPCSUM_SHIFT) == 0xffff))
    6939                 :          0 :                         skb->ip_summed = CHECKSUM_UNNECESSARY;
    6940                 :            :                 else
    6941                 :            :                         skb_checksum_none_assert(skb);
    6942                 :            : 
    6943                 :          0 :                 skb->protocol = eth_type_trans(skb, tp->dev);
    6944                 :            : 
    6945   [ #  #  #  # ]:          0 :                 if (len > (tp->dev->mtu + ETH_HLEN) &&
    6946         [ #  # ]:          0 :                     skb->protocol != htons(ETH_P_8021Q) &&
    6947                 :            :                     skb->protocol != htons(ETH_P_8021AD)) {
    6948                 :          0 :                         dev_kfree_skb_any(skb);
    6949                 :          0 :                         goto drop_it_no_recycle;
    6950                 :            :                 }
    6951                 :            : 
    6952         [ #  # ]:          0 :                 if (desc->type_flags & RXD_FLAG_VLAN &&
    6953         [ #  # ]:          0 :                     !(tp->rx_mode & RX_MODE_KEEP_VLAN_TAG))
    6954                 :          0 :                         __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
    6955                 :          0 :                                                desc->err_vlan & RXD_VLAN_MASK);
    6956                 :            : 
    6957                 :          0 :                 napi_gro_receive(&tnapi->napi, skb);
    6958                 :            : 
    6959                 :          0 :                 received++;
    6960                 :          0 :                 budget--;
    6961                 :            : 
    6962                 :          0 : next_pkt:
    6963                 :          0 :                 (*post_ptr)++;
    6964                 :            : 
    6965         [ #  # ]:          0 :                 if (unlikely(rx_std_posted >= tp->rx_std_max_post)) {
    6966                 :          0 :                         tpr->rx_std_prod_idx = std_prod_idx &
    6967                 :          0 :                                                tp->rx_std_ring_mask;
    6968                 :          0 :                         tw32_rx_mbox(TG3_RX_STD_PROD_IDX_REG,
    6969                 :            :                                      tpr->rx_std_prod_idx);
    6970                 :          0 :                         work_mask &= ~RXD_OPAQUE_RING_STD;
    6971                 :          0 :                         rx_std_posted = 0;
    6972                 :            :                 }
    6973                 :          0 : next_pkt_nopost:
    6974                 :          0 :                 sw_idx++;
    6975                 :          0 :                 sw_idx &= tp->rx_ret_ring_mask;
    6976                 :            : 
    6977                 :            :                 /* Refresh hw_idx to see if there is new work */
    6978         [ #  # ]:          0 :                 if (sw_idx == hw_idx) {
    6979                 :          0 :                         hw_idx = *(tnapi->rx_rcb_prod_idx);
    6980                 :          0 :                         rmb();
    6981                 :            :                 }
    6982                 :            :         }
    6983                 :            : 
    6984                 :            :         /* ACK the status ring. */
    6985                 :          0 :         tnapi->rx_rcb_ptr = sw_idx;
    6986                 :          0 :         tw32_rx_mbox(tnapi->consmbox, sw_idx);
    6987                 :            : 
    6988                 :            :         /* Refill RX ring(s). */
    6989         [ #  # ]:          0 :         if (!tg3_flag(tp, ENABLE_RSS)) {
    6990                 :            :                 /* Sync BD data before updating mailbox */
    6991                 :          0 :                 wmb();
    6992                 :            : 
    6993         [ #  # ]:          0 :                 if (work_mask & RXD_OPAQUE_RING_STD) {
    6994                 :          0 :                         tpr->rx_std_prod_idx = std_prod_idx &
    6995                 :          0 :                                                tp->rx_std_ring_mask;
    6996                 :          0 :                         tw32_rx_mbox(TG3_RX_STD_PROD_IDX_REG,
    6997                 :            :                                      tpr->rx_std_prod_idx);
    6998                 :            :                 }
    6999         [ #  # ]:          0 :                 if (work_mask & RXD_OPAQUE_RING_JUMBO) {
    7000                 :          0 :                         tpr->rx_jmb_prod_idx = jmb_prod_idx &
    7001                 :          0 :                                                tp->rx_jmb_ring_mask;
    7002                 :          0 :                         tw32_rx_mbox(TG3_RX_JMB_PROD_IDX_REG,
    7003                 :            :                                      tpr->rx_jmb_prod_idx);
    7004                 :            :                 }
    7005         [ #  # ]:          0 :         } else if (work_mask) {
    7006                 :            :                 /* rx_std_buffers[] and rx_jmb_buffers[] entries must be
    7007                 :            :                  * updated before the producer indices can be updated.
    7008                 :            :                  */
    7009                 :          0 :                 smp_wmb();
    7010                 :            : 
    7011                 :          0 :                 tpr->rx_std_prod_idx = std_prod_idx & tp->rx_std_ring_mask;
    7012                 :          0 :                 tpr->rx_jmb_prod_idx = jmb_prod_idx & tp->rx_jmb_ring_mask;
    7013                 :            : 
    7014         [ #  # ]:          0 :                 if (tnapi != &tp->napi[1]) {
    7015                 :          0 :                         tp->rx_refill = true;
    7016                 :          0 :                         napi_schedule(&tp->napi[1].napi);
    7017                 :            :                 }
    7018                 :            :         }
    7019                 :            : 
    7020                 :          0 :         return received;
    7021                 :            : }
    7022                 :            : 
    7023                 :          0 : static void tg3_poll_link(struct tg3 *tp)
    7024                 :            : {
    7025                 :            :         /* handle link change and other phy events */
    7026   [ #  #  #  # ]:          0 :         if (!(tg3_flag(tp, USE_LINKCHG_REG) || tg3_flag(tp, POLL_SERDES))) {
    7027                 :          0 :                 struct tg3_hw_status *sblk = tp->napi[0].hw_status;
    7028                 :            : 
    7029         [ #  # ]:          0 :                 if (sblk->status & SD_STATUS_LINK_CHG) {
    7030                 :          0 :                         sblk->status = SD_STATUS_UPDATED |
    7031                 :            :                                        (sblk->status & ~SD_STATUS_LINK_CHG);
    7032                 :          0 :                         spin_lock(&tp->lock);
    7033         [ #  # ]:          0 :                         if (tg3_flag(tp, USE_PHYLIB)) {
    7034                 :          0 :                                 tw32_f(MAC_STATUS,
    7035                 :            :                                      (MAC_STATUS_SYNC_CHANGED |
    7036                 :            :                                       MAC_STATUS_CFG_CHANGED |
    7037                 :            :                                       MAC_STATUS_MI_COMPLETION |
    7038                 :            :                                       MAC_STATUS_LNKSTATE_CHANGED));
    7039                 :          0 :                                 udelay(40);
    7040                 :            :                         } else
    7041                 :          0 :                                 tg3_setup_phy(tp, false);
    7042                 :          0 :                         spin_unlock(&tp->lock);
    7043                 :            :                 }
    7044                 :            :         }
    7045                 :          0 : }
    7046                 :            : 
    7047                 :            : static int tg3_rx_prodring_xfer(struct tg3 *tp,
    7048                 :            :                                 struct tg3_rx_prodring_set *dpr,
    7049                 :            :                                 struct tg3_rx_prodring_set *spr)
    7050                 :            : {
    7051                 :            :         u32 si, di, cpycnt, src_prod_idx;
    7052                 :            :         int i, err = 0;
    7053                 :            : 
    7054                 :            :         while (1) {
    7055                 :            :                 src_prod_idx = spr->rx_std_prod_idx;
    7056                 :            : 
    7057                 :            :                 /* Make sure updates to the rx_std_buffers[] entries and the
    7058                 :            :                  * standard producer index are seen in the correct order.
    7059                 :            :                  */
    7060                 :            :                 smp_rmb();
    7061                 :            : 
    7062                 :            :                 if (spr->rx_std_cons_idx == src_prod_idx)
    7063                 :            :                         break;
    7064                 :            : 
    7065                 :            :                 if (spr->rx_std_cons_idx < src_prod_idx)
    7066                 :            :                         cpycnt = src_prod_idx - spr->rx_std_cons_idx;
    7067                 :            :                 else
    7068                 :            :                         cpycnt = tp->rx_std_ring_mask + 1 -
    7069                 :            :                                  spr->rx_std_cons_idx;
    7070                 :            : 
    7071                 :            :                 cpycnt = min(cpycnt,
    7072                 :            :                              tp->rx_std_ring_mask + 1 - dpr->rx_std_prod_idx);
    7073                 :            : 
    7074                 :            :                 si = spr->rx_std_cons_idx;
    7075                 :            :                 di = dpr->rx_std_prod_idx;
    7076                 :            : 
    7077                 :            :                 for (i = di; i < di + cpycnt; i++) {
    7078                 :            :                         if (dpr->rx_std_buffers[i].data) {
    7079                 :            :                                 cpycnt = i - di;
    7080                 :            :                                 err = -ENOSPC;
    7081                 :            :                                 break;
    7082                 :            :                         }
    7083                 :            :                 }
    7084                 :            : 
    7085                 :            :                 if (!cpycnt)
    7086                 :            :                         break;
    7087                 :            : 
    7088                 :            :                 /* Ensure that updates to the rx_std_buffers ring and the
    7089                 :            :                  * shadowed hardware producer ring from tg3_recycle_skb() are
    7090                 :            :                  * ordered correctly WRT the skb check above.
    7091                 :            :                  */
    7092                 :            :                 smp_rmb();
    7093                 :            : 
    7094                 :            :                 memcpy(&dpr->rx_std_buffers[di],
    7095                 :            :                        &spr->rx_std_buffers[si],
    7096                 :            :                        cpycnt * sizeof(struct ring_info));
    7097                 :            : 
    7098                 :            :                 for (i = 0; i < cpycnt; i++, di++, si++) {
    7099                 :            :                         struct tg3_rx_buffer_desc *sbd, *dbd;
    7100                 :            :                         sbd = &spr->rx_std[si];
    7101                 :            :                         dbd = &dpr->rx_std[di];
    7102                 :            :                         dbd->addr_hi = sbd->addr_hi;
    7103                 :            :                         dbd->addr_lo = sbd->addr_lo;
    7104                 :            :                 }
    7105                 :            : 
    7106                 :            :                 spr->rx_std_cons_idx = (spr->rx_std_cons_idx + cpycnt) &
    7107                 :            :                                        tp->rx_std_ring_mask;
    7108                 :            :                 dpr->rx_std_prod_idx = (dpr->rx_std_prod_idx + cpycnt) &
    7109                 :            :                                        tp->rx_std_ring_mask;
    7110                 :            :         }
    7111                 :            : 
    7112                 :            :         while (1) {
    7113                 :            :                 src_prod_idx = spr->rx_jmb_prod_idx;
    7114                 :            : 
    7115                 :            :                 /* Make sure updates to the rx_jmb_buffers[] entries and
    7116                 :            :                  * the jumbo producer index are seen in the correct order.
    7117                 :            :                  */
    7118                 :            :                 smp_rmb();
    7119                 :            : 
    7120                 :            :                 if (spr->rx_jmb_cons_idx == src_prod_idx)
    7121                 :            :                         break;
    7122                 :            : 
    7123                 :            :                 if (spr->rx_jmb_cons_idx < src_prod_idx)
    7124                 :            :                         cpycnt = src_prod_idx - spr->rx_jmb_cons_idx;
    7125                 :            :                 else
    7126                 :            :                         cpycnt = tp->rx_jmb_ring_mask + 1 -
    7127                 :            :                                  spr->rx_jmb_cons_idx;
    7128                 :            : 
    7129                 :            :                 cpycnt = min(cpycnt,
    7130                 :            :                              tp->rx_jmb_ring_mask + 1 - dpr->rx_jmb_prod_idx);
    7131                 :            : 
    7132                 :            :                 si = spr->rx_jmb_cons_idx;
    7133                 :            :                 di = dpr->rx_jmb_prod_idx;
    7134                 :            : 
    7135                 :            :                 for (i = di; i < di + cpycnt; i++) {
    7136                 :            :                         if (dpr->rx_jmb_buffers[i].data) {
    7137                 :            :                                 cpycnt = i - di;
    7138                 :            :                                 err = -ENOSPC;
    7139                 :            :                                 break;
    7140                 :            :                         }
    7141                 :            :                 }
    7142                 :            : 
    7143                 :            :                 if (!cpycnt)
    7144                 :            :                         break;
    7145                 :            : 
    7146                 :            :                 /* Ensure that updates to the rx_jmb_buffers ring and the
    7147                 :            :                  * shadowed hardware producer ring from tg3_recycle_skb() are
    7148                 :            :                  * ordered correctly WRT the skb check above.
    7149                 :            :                  */
    7150                 :            :                 smp_rmb();
    7151                 :            : 
    7152                 :            :                 memcpy(&dpr->rx_jmb_buffers[di],
    7153                 :            :                        &spr->rx_jmb_buffers[si],
    7154                 :            :                        cpycnt * sizeof(struct ring_info));
    7155                 :            : 
    7156                 :            :                 for (i = 0; i < cpycnt; i++, di++, si++) {
    7157                 :            :                         struct tg3_rx_buffer_desc *sbd, *dbd;
    7158                 :            :                         sbd = &spr->rx_jmb[si].std;
    7159                 :            :                         dbd = &dpr->rx_jmb[di].std;
    7160                 :            :                         dbd->addr_hi = sbd->addr_hi;
    7161                 :            :                         dbd->addr_lo = sbd->addr_lo;
    7162                 :            :                 }
    7163                 :            : 
    7164                 :            :                 spr->rx_jmb_cons_idx = (spr->rx_jmb_cons_idx + cpycnt) &
    7165                 :            :                                        tp->rx_jmb_ring_mask;
    7166                 :            :                 dpr->rx_jmb_prod_idx = (dpr->rx_jmb_prod_idx + cpycnt) &
    7167                 :            :                                        tp->rx_jmb_ring_mask;
    7168                 :            :         }
    7169                 :            : 
    7170                 :            :         return err;
    7171                 :            : }
    7172                 :            : 
    7173                 :          0 : static int tg3_poll_work(struct tg3_napi *tnapi, int work_done, int budget)
    7174                 :            : {
    7175                 :          0 :         struct tg3 *tp = tnapi->tp;
    7176                 :            : 
    7177                 :            :         /* run TX completion thread */
    7178         [ #  # ]:          0 :         if (tnapi->hw_status->idx[0].tx_consumer != tnapi->tx_cons) {
    7179                 :          0 :                 tg3_tx(tnapi);
    7180         [ #  # ]:          0 :                 if (unlikely(tg3_flag(tp, TX_RECOVERY_PENDING)))
    7181                 :            :                         return work_done;
    7182                 :            :         }
    7183                 :            : 
    7184         [ #  # ]:          0 :         if (!tnapi->rx_rcb_prod_idx)
    7185                 :            :                 return work_done;
    7186                 :            : 
    7187                 :            :         /* run RX thread, within the bounds set by NAPI.
    7188                 :            :          * All RX "locking" is done by ensuring outside
    7189                 :            :          * code synchronizes with tg3->napi.poll()
    7190                 :            :          */
    7191         [ #  # ]:          0 :         if (*(tnapi->rx_rcb_prod_idx) != tnapi->rx_rcb_ptr)
    7192                 :          0 :                 work_done += tg3_rx(tnapi, budget - work_done);
    7193                 :            : 
    7194   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, ENABLE_RSS) && tnapi == &tp->napi[1]) {
    7195                 :          0 :                 struct tg3_rx_prodring_set *dpr = &tp->napi[0].prodring;
    7196                 :          0 :                 int i, err = 0;
    7197                 :          0 :                 u32 std_prod_idx = dpr->rx_std_prod_idx;
    7198                 :          0 :                 u32 jmb_prod_idx = dpr->rx_jmb_prod_idx;
    7199                 :            : 
    7200                 :          0 :                 tp->rx_refill = false;
    7201         [ #  # ]:          0 :                 for (i = 1; i <= tp->rxq_cnt; i++)
    7202                 :          0 :                         err |= tg3_rx_prodring_xfer(tp, dpr,
    7203                 :            :                                                     &tp->napi[i].prodring);
    7204                 :            : 
    7205                 :          0 :                 wmb();
    7206                 :            : 
    7207         [ #  # ]:          0 :                 if (std_prod_idx != dpr->rx_std_prod_idx)
    7208                 :          0 :                         tw32_rx_mbox(TG3_RX_STD_PROD_IDX_REG,
    7209                 :            :                                      dpr->rx_std_prod_idx);
    7210                 :            : 
    7211         [ #  # ]:          0 :                 if (jmb_prod_idx != dpr->rx_jmb_prod_idx)
    7212                 :          0 :                         tw32_rx_mbox(TG3_RX_JMB_PROD_IDX_REG,
    7213                 :            :                                      dpr->rx_jmb_prod_idx);
    7214                 :            : 
    7215         [ #  # ]:          0 :                 if (err)
    7216                 :          0 :                         tw32_f(HOSTCC_MODE, tp->coal_now);
    7217                 :            :         }
    7218                 :            : 
    7219                 :            :         return work_done;
    7220                 :            : }
    7221                 :            : 
    7222                 :          0 : static inline void tg3_reset_task_schedule(struct tg3 *tp)
    7223                 :            : {
    7224         [ #  # ]:          0 :         if (!test_and_set_bit(TG3_FLAG_RESET_TASK_PENDING, tp->tg3_flags))
    7225                 :          0 :                 schedule_work(&tp->reset_task);
    7226                 :          0 : }
    7227                 :            : 
    7228                 :          0 : static inline void tg3_reset_task_cancel(struct tg3 *tp)
    7229                 :            : {
    7230                 :          0 :         cancel_work_sync(&tp->reset_task);
    7231                 :          0 :         tg3_flag_clear(tp, RESET_TASK_PENDING);
    7232                 :          0 :         tg3_flag_clear(tp, TX_RECOVERY_PENDING);
    7233                 :          0 : }
    7234                 :            : 
    7235                 :          0 : static int tg3_poll_msix(struct napi_struct *napi, int budget)
    7236                 :            : {
    7237                 :          0 :         struct tg3_napi *tnapi = container_of(napi, struct tg3_napi, napi);
    7238                 :          0 :         struct tg3 *tp = tnapi->tp;
    7239                 :          0 :         int work_done = 0;
    7240                 :          0 :         struct tg3_hw_status *sblk = tnapi->hw_status;
    7241                 :            : 
    7242                 :          0 :         while (1) {
    7243                 :          0 :                 work_done = tg3_poll_work(tnapi, work_done, budget);
    7244                 :            : 
    7245         [ #  # ]:          0 :                 if (unlikely(tg3_flag(tp, TX_RECOVERY_PENDING)))
    7246                 :          0 :                         goto tx_recovery;
    7247                 :            : 
    7248         [ #  # ]:          0 :                 if (unlikely(work_done >= budget))
    7249                 :            :                         break;
    7250                 :            : 
    7251                 :            :                 /* tp->last_tag is used in tg3_int_reenable() below
    7252                 :            :                  * to tell the hw how much work has been processed,
    7253                 :            :                  * so we must read it before checking for more work.
    7254                 :            :                  */
    7255                 :          0 :                 tnapi->last_tag = sblk->status_tag;
    7256                 :          0 :                 tnapi->last_irq_tag = tnapi->last_tag;
    7257                 :          0 :                 rmb();
    7258                 :            : 
    7259                 :            :                 /* check for RX/TX work to do */
    7260   [ #  #  #  # ]:          0 :                 if (likely(sblk->idx[0].tx_consumer == tnapi->tx_cons &&
    7261                 :            :                            *(tnapi->rx_rcb_prod_idx) == tnapi->rx_rcb_ptr)) {
    7262                 :            : 
    7263                 :            :                         /* This test here is not race free, but will reduce
    7264                 :            :                          * the number of interrupts by looping again.
    7265                 :            :                          */
    7266   [ #  #  #  # ]:          0 :                         if (tnapi == &tp->napi[1] && tp->rx_refill)
    7267                 :          0 :                                 continue;
    7268                 :            : 
    7269                 :          0 :                         napi_complete_done(napi, work_done);
    7270                 :            :                         /* Reenable interrupts. */
    7271                 :          0 :                         tw32_mailbox(tnapi->int_mbox, tnapi->last_tag << 24);
    7272                 :            : 
    7273                 :            :                         /* This test here is synchronized by napi_schedule()
    7274                 :            :                          * and napi_complete() to close the race condition.
    7275                 :            :                          */
    7276   [ #  #  #  # ]:          0 :                         if (unlikely(tnapi == &tp->napi[1] && tp->rx_refill)) {
    7277                 :          0 :                                 tw32(HOSTCC_MODE, tp->coalesce_mode |
    7278                 :            :                                                   HOSTCC_MODE_ENABLE |
    7279                 :            :                                                   tnapi->coal_now);
    7280                 :            :                         }
    7281                 :            :                         break;
    7282                 :            :                 }
    7283                 :            :         }
    7284                 :            : 
    7285                 :          0 :         tg3_send_ape_heartbeat(tp, TG3_APE_HB_INTERVAL << 1);
    7286                 :          0 :         return work_done;
    7287                 :            : 
    7288                 :            : tx_recovery:
    7289                 :            :         /* work_done is guaranteed to be less than budget. */
    7290                 :          0 :         napi_complete(napi);
    7291                 :          0 :         tg3_reset_task_schedule(tp);
    7292                 :          0 :         return work_done;
    7293                 :            : }
    7294                 :            : 
    7295                 :          0 : static void tg3_process_error(struct tg3 *tp)
    7296                 :            : {
    7297                 :          0 :         u32 val;
    7298                 :          0 :         bool real_error = false;
    7299                 :            : 
    7300         [ #  # ]:          0 :         if (tg3_flag(tp, ERROR_PROCESSED))
    7301                 :            :                 return;
    7302                 :            : 
    7303                 :            :         /* Check Flow Attention register */
    7304                 :          0 :         val = tr32(HOSTCC_FLOW_ATTN);
    7305         [ #  # ]:          0 :         if (val & ~HOSTCC_FLOW_ATTN_MBUF_LWM) {
    7306                 :          0 :                 netdev_err(tp->dev, "FLOW Attention error.  Resetting chip.\n");
    7307                 :          0 :                 real_error = true;
    7308                 :            :         }
    7309                 :            : 
    7310         [ #  # ]:          0 :         if (tr32(MSGINT_STATUS) & ~MSGINT_STATUS_MSI_REQ) {
    7311                 :          0 :                 netdev_err(tp->dev, "MSI Status error.  Resetting chip.\n");
    7312                 :          0 :                 real_error = true;
    7313                 :            :         }
    7314                 :            : 
    7315   [ #  #  #  # ]:          0 :         if (tr32(RDMAC_STATUS) || tr32(WDMAC_STATUS)) {
    7316                 :          0 :                 netdev_err(tp->dev, "DMA Status error.  Resetting chip.\n");
    7317                 :          0 :                 real_error = true;
    7318                 :            :         }
    7319                 :            : 
    7320         [ #  # ]:          0 :         if (!real_error)
    7321                 :            :                 return;
    7322                 :            : 
    7323                 :          0 :         tg3_dump_state(tp);
    7324                 :            : 
    7325                 :          0 :         tg3_flag_set(tp, ERROR_PROCESSED);
    7326                 :          0 :         tg3_reset_task_schedule(tp);
    7327                 :            : }
    7328                 :            : 
    7329                 :          0 : static int tg3_poll(struct napi_struct *napi, int budget)
    7330                 :            : {
    7331                 :          0 :         struct tg3_napi *tnapi = container_of(napi, struct tg3_napi, napi);
    7332                 :          0 :         struct tg3 *tp = tnapi->tp;
    7333                 :          0 :         int work_done = 0;
    7334                 :          0 :         struct tg3_hw_status *sblk = tnapi->hw_status;
    7335                 :            : 
    7336                 :          0 :         while (1) {
    7337         [ #  # ]:          0 :                 if (sblk->status & SD_STATUS_ERROR)
    7338                 :          0 :                         tg3_process_error(tp);
    7339                 :            : 
    7340                 :          0 :                 tg3_poll_link(tp);
    7341                 :            : 
    7342                 :          0 :                 work_done = tg3_poll_work(tnapi, work_done, budget);
    7343                 :            : 
    7344         [ #  # ]:          0 :                 if (unlikely(tg3_flag(tp, TX_RECOVERY_PENDING)))
    7345                 :          0 :                         goto tx_recovery;
    7346                 :            : 
    7347         [ #  # ]:          0 :                 if (unlikely(work_done >= budget))
    7348                 :            :                         break;
    7349                 :            : 
    7350         [ #  # ]:          0 :                 if (tg3_flag(tp, TAGGED_STATUS)) {
    7351                 :            :                         /* tp->last_tag is used in tg3_int_reenable() below
    7352                 :            :                          * to tell the hw how much work has been processed,
    7353                 :            :                          * so we must read it before checking for more work.
    7354                 :            :                          */
    7355                 :          0 :                         tnapi->last_tag = sblk->status_tag;
    7356                 :          0 :                         tnapi->last_irq_tag = tnapi->last_tag;
    7357                 :          0 :                         rmb();
    7358                 :            :                 } else
    7359                 :          0 :                         sblk->status &= ~SD_STATUS_UPDATED;
    7360                 :            : 
    7361         [ #  # ]:          0 :                 if (likely(!tg3_has_work(tnapi))) {
    7362                 :          0 :                         napi_complete_done(napi, work_done);
    7363                 :          0 :                         tg3_int_reenable(tnapi);
    7364                 :          0 :                         break;
    7365                 :            :                 }
    7366                 :            :         }
    7367                 :            : 
    7368                 :          0 :         tg3_send_ape_heartbeat(tp, TG3_APE_HB_INTERVAL << 1);
    7369                 :          0 :         return work_done;
    7370                 :            : 
    7371                 :            : tx_recovery:
    7372                 :            :         /* work_done is guaranteed to be less than budget. */
    7373                 :          0 :         napi_complete(napi);
    7374                 :          0 :         tg3_reset_task_schedule(tp);
    7375                 :          0 :         return work_done;
    7376                 :            : }
    7377                 :            : 
    7378                 :          0 : static void tg3_napi_disable(struct tg3 *tp)
    7379                 :            : {
    7380                 :          0 :         int i;
    7381                 :            : 
    7382   [ #  #  #  # ]:          0 :         for (i = tp->irq_cnt - 1; i >= 0; i--)
    7383                 :          0 :                 napi_disable(&tp->napi[i].napi);
    7384                 :            : }
    7385                 :            : 
    7386                 :          0 : static void tg3_napi_enable(struct tg3 *tp)
    7387                 :            : {
    7388                 :          0 :         int i;
    7389                 :            : 
    7390   [ #  #  #  #  :          0 :         for (i = 0; i < tp->irq_cnt; i++)
          #  #  #  #  #  
                      # ]
    7391                 :          0 :                 napi_enable(&tp->napi[i].napi);
    7392                 :            : }
    7393                 :            : 
    7394                 :          0 : static void tg3_napi_init(struct tg3 *tp)
    7395                 :            : {
    7396                 :          0 :         int i;
    7397                 :            : 
    7398                 :          0 :         netif_napi_add(tp->dev, &tp->napi[0].napi, tg3_poll, 64);
    7399         [ #  # ]:          0 :         for (i = 1; i < tp->irq_cnt; i++)
    7400                 :          0 :                 netif_napi_add(tp->dev, &tp->napi[i].napi, tg3_poll_msix, 64);
    7401                 :          0 : }
    7402                 :            : 
    7403                 :          0 : static void tg3_napi_fini(struct tg3 *tp)
    7404                 :            : {
    7405                 :          0 :         int i;
    7406                 :            : 
    7407   [ #  #  #  # ]:          0 :         for (i = 0; i < tp->irq_cnt; i++)
    7408                 :          0 :                 netif_napi_del(&tp->napi[i].napi);
    7409                 :            : }
    7410                 :            : 
    7411                 :          0 : static inline void tg3_netif_stop(struct tg3 *tp)
    7412                 :            : {
    7413         [ #  # ]:          0 :         netif_trans_update(tp->dev); /* prevent tx timeout */
    7414                 :          0 :         tg3_napi_disable(tp);
    7415                 :          0 :         netif_carrier_off(tp->dev);
    7416                 :          0 :         netif_tx_disable(tp->dev);
    7417                 :          0 : }
    7418                 :            : 
    7419                 :            : /* tp->lock must be held */
    7420                 :          0 : static inline void tg3_netif_start(struct tg3 *tp)
    7421                 :            : {
    7422                 :          0 :         tg3_ptp_resume(tp);
    7423                 :            : 
    7424                 :            :         /* NOTE: unconditional netif_tx_wake_all_queues is only
    7425                 :            :          * appropriate so long as all callers are assured to
    7426                 :            :          * have free tx slots (such as after tg3_init_hw)
    7427                 :            :          */
    7428                 :          0 :         netif_tx_wake_all_queues(tp->dev);
    7429                 :            : 
    7430         [ #  # ]:          0 :         if (tp->link_up)
    7431                 :          0 :                 netif_carrier_on(tp->dev);
    7432                 :            : 
    7433                 :            :         tg3_napi_enable(tp);
    7434                 :          0 :         tp->napi[0].hw_status->status |= SD_STATUS_UPDATED;
    7435                 :          0 :         tg3_enable_ints(tp);
    7436                 :          0 : }
    7437                 :            : 
    7438                 :          0 : static void tg3_irq_quiesce(struct tg3 *tp)
    7439                 :            :         __releases(tp->lock)
    7440                 :            :         __acquires(tp->lock)
    7441                 :            : {
    7442                 :          0 :         int i;
    7443                 :            : 
    7444         [ #  # ]:          0 :         BUG_ON(tp->irq_sync);
    7445                 :            : 
    7446                 :          0 :         tp->irq_sync = 1;
    7447                 :          0 :         smp_mb();
    7448                 :            : 
    7449                 :          0 :         spin_unlock_bh(&tp->lock);
    7450                 :            : 
    7451         [ #  # ]:          0 :         for (i = 0; i < tp->irq_cnt; i++)
    7452                 :          0 :                 synchronize_irq(tp->napi[i].irq_vec);
    7453                 :            : 
    7454                 :          0 :         spin_lock_bh(&tp->lock);
    7455                 :          0 : }
    7456                 :            : 
    7457                 :            : /* Fully shutdown all tg3 driver activity elsewhere in the system.
    7458                 :            :  * If irq_sync is non-zero, then the IRQ handler must be synchronized
    7459                 :            :  * with as well.  Most of the time, this is not necessary except when
    7460                 :            :  * shutting down the device.
    7461                 :            :  */
    7462                 :          0 : static inline void tg3_full_lock(struct tg3 *tp, int irq_sync)
    7463                 :            : {
    7464                 :          0 :         spin_lock_bh(&tp->lock);
    7465   [ #  #  #  #  :          0 :         if (irq_sync)
             #  #  #  # ]
    7466                 :          0 :                 tg3_irq_quiesce(tp);
    7467                 :            : }
    7468                 :            : 
    7469                 :          0 : static inline void tg3_full_unlock(struct tg3 *tp)
    7470                 :            : {
    7471                 :          0 :         spin_unlock_bh(&tp->lock);
    7472                 :          0 : }
    7473                 :            : 
    7474                 :            : /* One-shot MSI handler - Chip automatically disables interrupt
    7475                 :            :  * after sending MSI so driver doesn't have to do it.
    7476                 :            :  */
    7477                 :          0 : static irqreturn_t tg3_msi_1shot(int irq, void *dev_id)
    7478                 :            : {
    7479                 :          0 :         struct tg3_napi *tnapi = dev_id;
    7480                 :          0 :         struct tg3 *tp = tnapi->tp;
    7481                 :            : 
    7482                 :          0 :         prefetch(tnapi->hw_status);
    7483         [ #  # ]:          0 :         if (tnapi->rx_rcb)
    7484                 :          0 :                 prefetch(&tnapi->rx_rcb[tnapi->rx_rcb_ptr]);
    7485                 :            : 
    7486         [ #  # ]:          0 :         if (likely(!tg3_irq_sync(tp)))
    7487                 :          0 :                 napi_schedule(&tnapi->napi);
    7488                 :            : 
    7489                 :          0 :         return IRQ_HANDLED;
    7490                 :            : }
    7491                 :            : 
    7492                 :            : /* MSI ISR - No need to check for interrupt sharing and no need to
    7493                 :            :  * flush status block and interrupt mailbox. PCI ordering rules
    7494                 :            :  * guarantee that MSI will arrive after the status block.
    7495                 :            :  */
    7496                 :          0 : static irqreturn_t tg3_msi(int irq, void *dev_id)
    7497                 :            : {
    7498                 :          0 :         struct tg3_napi *tnapi = dev_id;
    7499                 :          0 :         struct tg3 *tp = tnapi->tp;
    7500                 :            : 
    7501                 :          0 :         prefetch(tnapi->hw_status);
    7502         [ #  # ]:          0 :         if (tnapi->rx_rcb)
    7503                 :          0 :                 prefetch(&tnapi->rx_rcb[tnapi->rx_rcb_ptr]);
    7504                 :            :         /*
    7505                 :            :          * Writing any value to intr-mbox-0 clears PCI INTA# and
    7506                 :            :          * chip-internal interrupt pending events.
    7507                 :            :          * Writing non-zero to intr-mbox-0 additional tells the
    7508                 :            :          * NIC to stop sending us irqs, engaging "in-intr-handler"
    7509                 :            :          * event coalescing.
    7510                 :            :          */
    7511                 :          0 :         tw32_mailbox(tnapi->int_mbox, 0x00000001);
    7512         [ #  # ]:          0 :         if (likely(!tg3_irq_sync(tp)))
    7513                 :          0 :                 napi_schedule(&tnapi->napi);
    7514                 :            : 
    7515                 :          0 :         return IRQ_RETVAL(1);
    7516                 :            : }
    7517                 :            : 
    7518                 :          0 : static irqreturn_t tg3_interrupt(int irq, void *dev_id)
    7519                 :            : {
    7520                 :          0 :         struct tg3_napi *tnapi = dev_id;
    7521                 :          0 :         struct tg3 *tp = tnapi->tp;
    7522                 :          0 :         struct tg3_hw_status *sblk = tnapi->hw_status;
    7523                 :          0 :         unsigned int handled = 1;
    7524                 :            : 
    7525                 :            :         /* In INTx mode, it is possible for the interrupt to arrive at
    7526                 :            :          * the CPU before the status block posted prior to the interrupt.
    7527                 :            :          * Reading the PCI State register will confirm whether the
    7528                 :            :          * interrupt is ours and will flush the status block.
    7529                 :            :          */
    7530         [ #  # ]:          0 :         if (unlikely(!(sblk->status & SD_STATUS_UPDATED))) {
    7531         [ #  # ]:          0 :                 if (tg3_flag(tp, CHIP_RESETTING) ||
    7532         [ #  # ]:          0 :                     (tr32(TG3PCI_PCISTATE) & PCISTATE_INT_NOT_ACTIVE)) {
    7533                 :          0 :                         handled = 0;
    7534                 :          0 :                         goto out;
    7535                 :            :                 }
    7536                 :            :         }
    7537                 :            : 
    7538                 :            :         /*
    7539                 :            :          * Writing any value to intr-mbox-0 clears PCI INTA# and
    7540                 :            :          * chip-internal interrupt pending events.
    7541                 :            :          * Writing non-zero to intr-mbox-0 additional tells the
    7542                 :            :          * NIC to stop sending us irqs, engaging "in-intr-handler"
    7543                 :            :          * event coalescing.
    7544                 :            :          *
    7545                 :            :          * Flush the mailbox to de-assert the IRQ immediately to prevent
    7546                 :            :          * spurious interrupts.  The flush impacts performance but
    7547                 :            :          * excessive spurious interrupts can be worse in some cases.
    7548                 :            :          */
    7549                 :          0 :         tw32_mailbox_f(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW, 0x00000001);
    7550         [ #  # ]:          0 :         if (tg3_irq_sync(tp))
    7551                 :          0 :                 goto out;
    7552                 :          0 :         sblk->status &= ~SD_STATUS_UPDATED;
    7553         [ #  # ]:          0 :         if (likely(tg3_has_work(tnapi))) {
    7554                 :          0 :                 prefetch(&tnapi->rx_rcb[tnapi->rx_rcb_ptr]);
    7555                 :          0 :                 napi_schedule(&tnapi->napi);
    7556                 :            :         } else {
    7557                 :            :                 /* No work, shared interrupt perhaps?  re-enable
    7558                 :            :                  * interrupts, and flush that PCI write
    7559                 :            :                  */
    7560                 :          0 :                 tw32_mailbox_f(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW,
    7561                 :            :                                0x00000000);
    7562                 :            :         }
    7563                 :          0 : out:
    7564                 :          0 :         return IRQ_RETVAL(handled);
    7565                 :            : }
    7566                 :            : 
    7567                 :          0 : static irqreturn_t tg3_interrupt_tagged(int irq, void *dev_id)
    7568                 :            : {
    7569                 :          0 :         struct tg3_napi *tnapi = dev_id;
    7570                 :          0 :         struct tg3 *tp = tnapi->tp;
    7571                 :          0 :         struct tg3_hw_status *sblk = tnapi->hw_status;
    7572                 :          0 :         unsigned int handled = 1;
    7573                 :            : 
    7574                 :            :         /* In INTx mode, it is possible for the interrupt to arrive at
    7575                 :            :          * the CPU before the status block posted prior to the interrupt.
    7576                 :            :          * Reading the PCI State register will confirm whether the
    7577                 :            :          * interrupt is ours and will flush the status block.
    7578                 :            :          */
    7579         [ #  # ]:          0 :         if (unlikely(sblk->status_tag == tnapi->last_irq_tag)) {
    7580         [ #  # ]:          0 :                 if (tg3_flag(tp, CHIP_RESETTING) ||
    7581         [ #  # ]:          0 :                     (tr32(TG3PCI_PCISTATE) & PCISTATE_INT_NOT_ACTIVE)) {
    7582                 :          0 :                         handled = 0;
    7583                 :          0 :                         goto out;
    7584                 :            :                 }
    7585                 :            :         }
    7586                 :            : 
    7587                 :            :         /*
    7588                 :            :          * writing any value to intr-mbox-0 clears PCI INTA# and
    7589                 :            :          * chip-internal interrupt pending events.
    7590                 :            :          * writing non-zero to intr-mbox-0 additional tells the
    7591                 :            :          * NIC to stop sending us irqs, engaging "in-intr-handler"
    7592                 :            :          * event coalescing.
    7593                 :            :          *
    7594                 :            :          * Flush the mailbox to de-assert the IRQ immediately to prevent
    7595                 :            :          * spurious interrupts.  The flush impacts performance but
    7596                 :            :          * excessive spurious interrupts can be worse in some cases.
    7597                 :            :          */
    7598                 :          0 :         tw32_mailbox_f(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW, 0x00000001);
    7599                 :            : 
    7600                 :            :         /*
    7601                 :            :          * In a shared interrupt configuration, sometimes other devices'
    7602                 :            :          * interrupts will scream.  We record the current status tag here
    7603                 :            :          * so that the above check can report that the screaming interrupts
    7604                 :            :          * are unhandled.  Eventually they will be silenced.
    7605                 :            :          */
    7606                 :          0 :         tnapi->last_irq_tag = sblk->status_tag;
    7607                 :            : 
    7608         [ #  # ]:          0 :         if (tg3_irq_sync(tp))
    7609                 :          0 :                 goto out;
    7610                 :            : 
    7611                 :          0 :         prefetch(&tnapi->rx_rcb[tnapi->rx_rcb_ptr]);
    7612                 :            : 
    7613                 :          0 :         napi_schedule(&tnapi->napi);
    7614                 :            : 
    7615                 :          0 : out:
    7616                 :          0 :         return IRQ_RETVAL(handled);
    7617                 :            : }
    7618                 :            : 
    7619                 :            : /* ISR for interrupt test */
    7620                 :          0 : static irqreturn_t tg3_test_isr(int irq, void *dev_id)
    7621                 :            : {
    7622                 :          0 :         struct tg3_napi *tnapi = dev_id;
    7623                 :          0 :         struct tg3 *tp = tnapi->tp;
    7624                 :          0 :         struct tg3_hw_status *sblk = tnapi->hw_status;
    7625                 :            : 
    7626         [ #  # ]:          0 :         if ((sblk->status & SD_STATUS_UPDATED) ||
    7627         [ #  # ]:          0 :             !(tr32(TG3PCI_PCISTATE) & PCISTATE_INT_NOT_ACTIVE)) {
    7628                 :          0 :                 tg3_disable_ints(tp);
    7629                 :          0 :                 return IRQ_RETVAL(1);
    7630                 :            :         }
    7631                 :            :         return IRQ_RETVAL(0);
    7632                 :            : }
    7633                 :            : 
    7634                 :            : #ifdef CONFIG_NET_POLL_CONTROLLER
    7635                 :          0 : static void tg3_poll_controller(struct net_device *dev)
    7636                 :            : {
    7637                 :          0 :         int i;
    7638         [ #  # ]:          0 :         struct tg3 *tp = netdev_priv(dev);
    7639                 :            : 
    7640         [ #  # ]:          0 :         if (tg3_irq_sync(tp))
    7641                 :            :                 return;
    7642                 :            : 
    7643         [ #  # ]:          0 :         for (i = 0; i < tp->irq_cnt; i++)
    7644                 :          0 :                 tg3_interrupt(tp->napi[i].irq_vec, &tp->napi[i]);
    7645                 :            : }
    7646                 :            : #endif
    7647                 :            : 
    7648                 :          0 : static void tg3_tx_timeout(struct net_device *dev, unsigned int txqueue)
    7649                 :            : {
    7650         [ #  # ]:          0 :         struct tg3 *tp = netdev_priv(dev);
    7651                 :            : 
    7652         [ #  # ]:          0 :         if (netif_msg_tx_err(tp)) {
    7653                 :          0 :                 netdev_err(dev, "transmit timed out, resetting\n");
    7654                 :          0 :                 tg3_dump_state(tp);
    7655                 :            :         }
    7656                 :            : 
    7657                 :          0 :         tg3_reset_task_schedule(tp);
    7658                 :          0 : }
    7659                 :            : 
    7660                 :            : /* Test for DMA buffers crossing any 4GB boundaries: 4G, 8G, etc */
    7661                 :          0 : static inline int tg3_4g_overflow_test(dma_addr_t mapping, int len)
    7662                 :            : {
    7663                 :          0 :         u32 base = (u32) mapping & 0xffffffff;
    7664                 :            : 
    7665                 :          0 :         return base + len + 8 < base;
    7666                 :            : }
    7667                 :            : 
    7668                 :            : /* Test for TSO DMA buffers that cross into regions which are within MSS bytes
    7669                 :            :  * of any 4GB boundaries: 4G, 8G, etc
    7670                 :            :  */
    7671                 :          0 : static inline int tg3_4g_tso_overflow_test(struct tg3 *tp, dma_addr_t mapping,
    7672                 :            :                                            u32 len, u32 mss)
    7673                 :            : {
    7674         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5762 && mss) {
    7675                 :          0 :                 u32 base = (u32) mapping & 0xffffffff;
    7676                 :            : 
    7677                 :          0 :                 return ((base + len + (mss & 0x3fff)) < base);
    7678                 :            :         }
    7679                 :            :         return 0;
    7680                 :            : }
    7681                 :            : 
    7682                 :            : /* Test for DMA addresses > 40-bit */
    7683                 :          0 : static inline int tg3_40bit_overflow_test(struct tg3 *tp, dma_addr_t mapping,
    7684                 :            :                                           int len)
    7685                 :            : {
    7686                 :            : #if defined(CONFIG_HIGHMEM) && (BITS_PER_LONG == 64)
    7687                 :            :         if (tg3_flag(tp, 40BIT_DMA_BUG))
    7688                 :            :                 return ((u64) mapping + len) > DMA_BIT_MASK(40);
    7689                 :            :         return 0;
    7690                 :            : #else
    7691                 :          0 :         return 0;
    7692                 :            : #endif
    7693                 :            : }
    7694                 :            : 
    7695                 :          0 : static inline void tg3_tx_set_bd(struct tg3_tx_buffer_desc *txbd,
    7696                 :            :                                  dma_addr_t mapping, u32 len, u32 flags,
    7697                 :            :                                  u32 mss, u32 vlan)
    7698                 :            : {
    7699                 :          0 :         txbd->addr_hi = ((u64) mapping >> 32);
    7700                 :          0 :         txbd->addr_lo = ((u64) mapping & 0xffffffff);
    7701                 :          0 :         txbd->len_flags = (len << TXD_LEN_SHIFT) | (flags & 0x0000ffff);
    7702                 :          0 :         txbd->vlan_tag = (mss << TXD_MSS_SHIFT) | (vlan << TXD_VLAN_TAG_SHIFT);
    7703                 :            : }
    7704                 :            : 
    7705                 :          0 : static bool tg3_tx_frag_set(struct tg3_napi *tnapi, u32 *entry, u32 *budget,
    7706                 :            :                             dma_addr_t map, u32 len, u32 flags,
    7707                 :            :                             u32 mss, u32 vlan)
    7708                 :            : {
    7709                 :          0 :         struct tg3 *tp = tnapi->tp;
    7710                 :          0 :         bool hwbug = false;
    7711                 :            : 
    7712   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, SHORT_DMA_BUG) && len <= 8)
    7713                 :          0 :                 hwbug = true;
    7714                 :            : 
    7715         [ #  # ]:          0 :         if (tg3_4g_overflow_test(map, len))
    7716                 :          0 :                 hwbug = true;
    7717                 :            : 
    7718   [ #  #  #  # ]:          0 :         if (tg3_4g_tso_overflow_test(tp, map, len, mss))
    7719                 :          0 :                 hwbug = true;
    7720                 :            : 
    7721                 :          0 :         if (tg3_40bit_overflow_test(tp, map, len))
    7722                 :            :                 hwbug = true;
    7723                 :            : 
    7724         [ #  # ]:          0 :         if (tp->dma_limit) {
    7725                 :          0 :                 u32 prvidx = *entry;
    7726                 :          0 :                 u32 tmp_flag = flags & ~TXD_FLAG_END;
    7727   [ #  #  #  # ]:          0 :                 while (len > tp->dma_limit && *budget) {
    7728                 :          0 :                         u32 frag_len = tp->dma_limit;
    7729                 :          0 :                         len -= tp->dma_limit;
    7730                 :            : 
    7731                 :            :                         /* Avoid the 8byte DMA problem */
    7732         [ #  # ]:          0 :                         if (len <= 8) {
    7733                 :          0 :                                 len += tp->dma_limit / 2;
    7734                 :          0 :                                 frag_len = tp->dma_limit / 2;
    7735                 :            :                         }
    7736                 :            : 
    7737                 :          0 :                         tnapi->tx_buffers[*entry].fragmented = true;
    7738                 :            : 
    7739                 :          0 :                         tg3_tx_set_bd(&tnapi->tx_ring[*entry], map,
    7740                 :            :                                       frag_len, tmp_flag, mss, vlan);
    7741                 :          0 :                         *budget -= 1;
    7742                 :          0 :                         prvidx = *entry;
    7743                 :          0 :                         *entry = NEXT_TX(*entry);
    7744                 :            : 
    7745                 :          0 :                         map += frag_len;
    7746                 :            :                 }
    7747                 :            : 
    7748         [ #  # ]:          0 :                 if (len) {
    7749         [ #  # ]:          0 :                         if (*budget) {
    7750                 :          0 :                                 tg3_tx_set_bd(&tnapi->tx_ring[*entry], map,
    7751                 :            :                                               len, flags, mss, vlan);
    7752                 :          0 :                                 *budget -= 1;
    7753                 :          0 :                                 *entry = NEXT_TX(*entry);
    7754                 :            :                         } else {
    7755                 :          0 :                                 hwbug = true;
    7756                 :          0 :                                 tnapi->tx_buffers[prvidx].fragmented = false;
    7757                 :            :                         }
    7758                 :            :                 }
    7759                 :            :         } else {
    7760                 :          0 :                 tg3_tx_set_bd(&tnapi->tx_ring[*entry], map,
    7761                 :            :                               len, flags, mss, vlan);
    7762                 :          0 :                 *entry = NEXT_TX(*entry);
    7763                 :            :         }
    7764                 :            : 
    7765                 :          0 :         return hwbug;
    7766                 :            : }
    7767                 :            : 
    7768                 :            : static void tg3_tx_skb_unmap(struct tg3_napi *tnapi, u32 entry, int last)
    7769                 :            : {
    7770                 :            :         int i;
    7771                 :            :         struct sk_buff *skb;
    7772                 :            :         struct tg3_tx_ring_info *txb = &tnapi->tx_buffers[entry];
    7773                 :            : 
    7774                 :            :         skb = txb->skb;
    7775                 :            :         txb->skb = NULL;
    7776                 :            : 
    7777                 :            :         pci_unmap_single(tnapi->tp->pdev,
    7778                 :            :                          dma_unmap_addr(txb, mapping),
    7779                 :            :                          skb_headlen(skb),
    7780                 :            :                          PCI_DMA_TODEVICE);
    7781                 :            : 
    7782                 :            :         while (txb->fragmented) {
    7783                 :            :                 txb->fragmented = false;
    7784                 :            :                 entry = NEXT_TX(entry);
    7785                 :            :                 txb = &tnapi->tx_buffers[entry];
    7786                 :            :         }
    7787                 :            : 
    7788                 :            :         for (i = 0; i <= last; i++) {
    7789                 :            :                 const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
    7790                 :            : 
    7791                 :            :                 entry = NEXT_TX(entry);
    7792                 :            :                 txb = &tnapi->tx_buffers[entry];
    7793                 :            : 
    7794                 :            :                 pci_unmap_page(tnapi->tp->pdev,
    7795                 :            :                                dma_unmap_addr(txb, mapping),
    7796                 :            :                                skb_frag_size(frag), PCI_DMA_TODEVICE);
    7797                 :            : 
    7798                 :            :                 while (txb->fragmented) {
    7799                 :            :                         txb->fragmented = false;
    7800                 :            :                         entry = NEXT_TX(entry);
    7801                 :            :                         txb = &tnapi->tx_buffers[entry];
    7802                 :            :                 }
    7803                 :            :         }
    7804                 :            : }
    7805                 :            : 
    7806                 :            : /* Workaround 4GB and 40-bit hardware DMA bugs. */
    7807                 :          0 : static int tigon3_dma_hwbug_workaround(struct tg3_napi *tnapi,
    7808                 :            :                                        struct sk_buff **pskb,
    7809                 :            :                                        u32 *entry, u32 *budget,
    7810                 :            :                                        u32 base_flags, u32 mss, u32 vlan)
    7811                 :            : {
    7812                 :          0 :         struct tg3 *tp = tnapi->tp;
    7813                 :          0 :         struct sk_buff *new_skb, *skb = *pskb;
    7814                 :          0 :         dma_addr_t new_addr = 0;
    7815                 :          0 :         int ret = 0;
    7816                 :            : 
    7817         [ #  # ]:          0 :         if (tg3_asic_rev(tp) != ASIC_REV_5701)
    7818                 :          0 :                 new_skb = skb_copy(skb, GFP_ATOMIC);
    7819                 :            :         else {
    7820                 :          0 :                 int more_headroom = 4 - ((unsigned long)skb->data & 3);
    7821                 :            : 
    7822         [ #  # ]:          0 :                 new_skb = skb_copy_expand(skb,
    7823                 :          0 :                                           skb_headroom(skb) + more_headroom,
    7824                 :            :                                           skb_tailroom(skb), GFP_ATOMIC);
    7825                 :            :         }
    7826                 :            : 
    7827         [ #  # ]:          0 :         if (!new_skb) {
    7828                 :            :                 ret = -1;
    7829                 :            :         } else {
    7830                 :            :                 /* New SKB is guaranteed to be linear. */
    7831                 :          0 :                 new_addr = pci_map_single(tp->pdev, new_skb->data, new_skb->len,
    7832                 :            :                                           PCI_DMA_TODEVICE);
    7833                 :            :                 /* Make sure the mapping succeeded */
    7834                 :          0 :                 if (pci_dma_mapping_error(tp->pdev, new_addr)) {
    7835                 :          0 :                         dev_kfree_skb_any(new_skb);
    7836                 :          0 :                         ret = -1;
    7837                 :            :                 } else {
    7838                 :          0 :                         u32 save_entry = *entry;
    7839                 :            : 
    7840                 :          0 :                         base_flags |= TXD_FLAG_END;
    7841                 :            : 
    7842                 :          0 :                         tnapi->tx_buffers[*entry].skb = new_skb;
    7843                 :          0 :                         dma_unmap_addr_set(&tnapi->tx_buffers[*entry],
    7844                 :            :                                            mapping, new_addr);
    7845                 :            : 
    7846         [ #  # ]:          0 :                         if (tg3_tx_frag_set(tnapi, entry, budget, new_addr,
    7847                 :            :                                             new_skb->len, base_flags,
    7848                 :            :                                             mss, vlan)) {
    7849                 :          0 :                                 tg3_tx_skb_unmap(tnapi, save_entry, -1);
    7850                 :          0 :                                 dev_kfree_skb_any(new_skb);
    7851                 :          0 :                                 ret = -1;
    7852                 :            :                         }
    7853                 :            :                 }
    7854                 :            :         }
    7855                 :            : 
    7856                 :          0 :         dev_consume_skb_any(skb);
    7857                 :          0 :         *pskb = new_skb;
    7858                 :          0 :         return ret;
    7859                 :            : }
    7860                 :            : 
    7861                 :          0 : static bool tg3_tso_bug_gso_check(struct tg3_napi *tnapi, struct sk_buff *skb)
    7862                 :            : {
    7863                 :            :         /* Check if we will never have enough descriptors,
    7864                 :            :          * as gso_segs can be more than current ring size
    7865                 :            :          */
    7866                 :          0 :         return skb_shinfo(skb)->gso_segs < tnapi->tx_pending / 3;
    7867                 :            : }
    7868                 :            : 
    7869                 :            : static netdev_tx_t tg3_start_xmit(struct sk_buff *, struct net_device *);
    7870                 :            : 
    7871                 :            : /* Use GSO to workaround all TSO packets that meet HW bug conditions
    7872                 :            :  * indicated in tg3_tx_frag_set()
    7873                 :            :  */
    7874                 :            : static int tg3_tso_bug(struct tg3 *tp, struct tg3_napi *tnapi,
    7875                 :            :                        struct netdev_queue *txq, struct sk_buff *skb)
    7876                 :            : {
    7877                 :            :         u32 frag_cnt_est = skb_shinfo(skb)->gso_segs * 3;
    7878                 :            :         struct sk_buff *segs, *seg, *next;
    7879                 :            : 
    7880                 :            :         /* Estimate the number of fragments in the worst case */
    7881                 :            :         if (unlikely(tg3_tx_avail(tnapi) <= frag_cnt_est)) {
    7882                 :            :                 netif_tx_stop_queue(txq);
    7883                 :            : 
    7884                 :            :                 /* netif_tx_stop_queue() must be done before checking
    7885                 :            :                  * checking tx index in tg3_tx_avail() below, because in
    7886                 :            :                  * tg3_tx(), we update tx index before checking for
    7887                 :            :                  * netif_tx_queue_stopped().
    7888                 :            :                  */
    7889                 :            :                 smp_mb();
    7890                 :            :                 if (tg3_tx_avail(tnapi) <= frag_cnt_est)
    7891                 :            :                         return NETDEV_TX_BUSY;
    7892                 :            : 
    7893                 :            :                 netif_tx_wake_queue(txq);
    7894                 :            :         }
    7895                 :            : 
    7896                 :            :         segs = skb_gso_segment(skb, tp->dev->features &
    7897                 :            :                                     ~(NETIF_F_TSO | NETIF_F_TSO6));
    7898                 :            :         if (IS_ERR(segs) || !segs)
    7899                 :            :                 goto tg3_tso_bug_end;
    7900                 :            : 
    7901                 :            :         skb_list_walk_safe(segs, seg, next) {
    7902                 :            :                 skb_mark_not_on_list(seg);
    7903                 :            :                 tg3_start_xmit(seg, tp->dev);
    7904                 :            :         }
    7905                 :            : 
    7906                 :            : tg3_tso_bug_end:
    7907                 :            :         dev_consume_skb_any(skb);
    7908                 :            : 
    7909                 :            :         return NETDEV_TX_OK;
    7910                 :            : }
    7911                 :            : 
    7912                 :            : /* hard_start_xmit for all devices */
    7913                 :          0 : static netdev_tx_t tg3_start_xmit(struct sk_buff *skb, struct net_device *dev)
    7914                 :            : {
    7915                 :          0 :         struct tg3 *tp = netdev_priv(dev);
    7916                 :          0 :         u32 len, entry, base_flags, mss, vlan = 0;
    7917                 :          0 :         u32 budget;
    7918                 :          0 :         int i = -1, would_hit_hwbug;
    7919                 :          0 :         dma_addr_t mapping;
    7920                 :          0 :         struct tg3_napi *tnapi;
    7921                 :          0 :         struct netdev_queue *txq;
    7922                 :          0 :         unsigned int last;
    7923                 :          0 :         struct iphdr *iph = NULL;
    7924                 :          0 :         struct tcphdr *tcph = NULL;
    7925                 :          0 :         __sum16 tcp_csum = 0, ip_csum = 0;
    7926                 :          0 :         __be16 ip_tot_len = 0;
    7927                 :            : 
    7928                 :          0 :         txq = netdev_get_tx_queue(dev, skb_get_queue_mapping(skb));
    7929                 :          0 :         tnapi = &tp->napi[skb_get_queue_mapping(skb)];
    7930         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_TSS))
    7931                 :          0 :                 tnapi++;
    7932                 :            : 
    7933                 :          0 :         budget = tg3_tx_avail(tnapi);
    7934                 :            : 
    7935                 :            :         /* We are running in BH disabled context with netif_tx_lock
    7936                 :            :          * and TX reclaim runs via tp->napi.poll inside of a software
    7937                 :            :          * interrupt.  Furthermore, IRQ processing runs lockless so we have
    7938                 :            :          * no IRQ context deadlocks to worry about either.  Rejoice!
    7939                 :            :          */
    7940         [ #  # ]:          0 :         if (unlikely(budget <= (skb_shinfo(skb)->nr_frags + 1))) {
    7941         [ #  # ]:          0 :                 if (!netif_tx_queue_stopped(txq)) {
    7942                 :          0 :                         netif_tx_stop_queue(txq);
    7943                 :            : 
    7944                 :            :                         /* This is a hard error, log it. */
    7945                 :          0 :                         netdev_err(dev,
    7946                 :            :                                    "BUG! Tx Ring full when queue awake!\n");
    7947                 :            :                 }
    7948                 :          0 :                 return NETDEV_TX_BUSY;
    7949                 :            :         }
    7950                 :            : 
    7951                 :          0 :         entry = tnapi->tx_prod;
    7952                 :          0 :         base_flags = 0;
    7953                 :            : 
    7954         [ #  # ]:          0 :         mss = skb_shinfo(skb)->gso_size;
    7955         [ #  # ]:          0 :         if (mss) {
    7956                 :          0 :                 u32 tcp_opt_len, hdr_len;
    7957                 :            : 
    7958         [ #  # ]:          0 :                 if (skb_cow_head(skb, 0))
    7959                 :          0 :                         goto drop;
    7960                 :            : 
    7961         [ #  # ]:          0 :                 iph = ip_hdr(skb);
    7962         [ #  # ]:          0 :                 tcp_opt_len = tcp_optlen(skb);
    7963                 :            : 
    7964         [ #  # ]:          0 :                 hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb) - ETH_HLEN;
    7965                 :            : 
    7966                 :            :                 /* HW/FW can not correctly segment packets that have been
    7967                 :            :                  * vlan encapsulated.
    7968                 :            :                  */
    7969         [ #  # ]:          0 :                 if (skb->protocol == htons(ETH_P_8021Q) ||
    7970                 :            :                     skb->protocol == htons(ETH_P_8021AD)) {
    7971         [ #  # ]:          0 :                         if (tg3_tso_bug_gso_check(tnapi, skb))
    7972                 :          0 :                                 return tg3_tso_bug(tp, tnapi, txq, skb);
    7973                 :          0 :                         goto drop;
    7974                 :            :                 }
    7975                 :            : 
    7976         [ #  # ]:          0 :                 if (!skb_is_gso_v6(skb)) {
    7977   [ #  #  #  # ]:          0 :                         if (unlikely((ETH_HLEN + hdr_len) > 80) &&
    7978                 :            :                             tg3_flag(tp, TSO_BUG)) {
    7979         [ #  # ]:          0 :                                 if (tg3_tso_bug_gso_check(tnapi, skb))
    7980                 :          0 :                                         return tg3_tso_bug(tp, tnapi, txq, skb);
    7981                 :          0 :                                 goto drop;
    7982                 :            :                         }
    7983                 :          0 :                         ip_csum = iph->check;
    7984                 :          0 :                         ip_tot_len = iph->tot_len;
    7985                 :          0 :                         iph->check = 0;
    7986                 :          0 :                         iph->tot_len = htons(mss + hdr_len);
    7987                 :            :                 }
    7988                 :            : 
    7989                 :          0 :                 base_flags |= (TXD_FLAG_CPU_PRE_DMA |
    7990                 :            :                                TXD_FLAG_CPU_POST_DMA);
    7991                 :            : 
    7992                 :          0 :                 tcph = tcp_hdr(skb);
    7993                 :          0 :                 tcp_csum = tcph->check;
    7994                 :            : 
    7995   [ #  #  #  # ]:          0 :                 if (tg3_flag(tp, HW_TSO_1) ||
    7996         [ #  # ]:          0 :                     tg3_flag(tp, HW_TSO_2) ||
    7997                 :            :                     tg3_flag(tp, HW_TSO_3)) {
    7998                 :          0 :                         tcph->check = 0;
    7999                 :          0 :                         base_flags &= ~TXD_FLAG_TCPUDP_CSUM;
    8000                 :            :                 } else {
    8001                 :          0 :                         tcph->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr,
    8002                 :            :                                                          0, IPPROTO_TCP, 0);
    8003                 :            :                 }
    8004                 :            : 
    8005         [ #  # ]:          0 :                 if (tg3_flag(tp, HW_TSO_3)) {
    8006                 :          0 :                         mss |= (hdr_len & 0xc) << 12;
    8007         [ #  # ]:          0 :                         if (hdr_len & 0x10)
    8008                 :          0 :                                 base_flags |= 0x00000010;
    8009                 :          0 :                         base_flags |= (hdr_len & 0x3e0) << 5;
    8010         [ #  # ]:          0 :                 } else if (tg3_flag(tp, HW_TSO_2))
    8011                 :          0 :                         mss |= hdr_len << 9;
    8012         [ #  # ]:          0 :                 else if (tg3_flag(tp, HW_TSO_1) ||
    8013         [ #  # ]:          0 :                          tg3_asic_rev(tp) == ASIC_REV_5705) {
    8014   [ #  #  #  # ]:          0 :                         if (tcp_opt_len || iph->ihl > 5) {
    8015                 :          0 :                                 int tsflags;
    8016                 :            : 
    8017                 :          0 :                                 tsflags = (iph->ihl - 5) + (tcp_opt_len >> 2);
    8018                 :          0 :                                 mss |= (tsflags << 11);
    8019                 :            :                         }
    8020                 :            :                 } else {
    8021   [ #  #  #  # ]:          0 :                         if (tcp_opt_len || iph->ihl > 5) {
    8022                 :          0 :                                 int tsflags;
    8023                 :            : 
    8024                 :          0 :                                 tsflags = (iph->ihl - 5) + (tcp_opt_len >> 2);
    8025                 :          0 :                                 base_flags |= tsflags << 12;
    8026                 :            :                         }
    8027                 :            :                 }
    8028         [ #  # ]:          0 :         } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
    8029                 :            :                 /* HW/FW can not correctly checksum packets that have been
    8030                 :            :                  * vlan encapsulated.
    8031                 :            :                  */
    8032         [ #  # ]:          0 :                 if (skb->protocol == htons(ETH_P_8021Q) ||
    8033                 :            :                     skb->protocol == htons(ETH_P_8021AD)) {
    8034         [ #  # ]:          0 :                         if (skb_checksum_help(skb))
    8035                 :          0 :                                 goto drop;
    8036                 :            :                 } else  {
    8037                 :            :                         base_flags |= TXD_FLAG_TCPUDP_CSUM;
    8038                 :            :                 }
    8039                 :            :         }
    8040                 :            : 
    8041   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, USE_JUMBO_BDFLAG) &&
    8042         [ #  # ]:          0 :             !mss && skb->len > VLAN_ETH_FRAME_LEN)
    8043                 :          0 :                 base_flags |= TXD_FLAG_JMB_PKT;
    8044                 :            : 
    8045         [ #  # ]:          0 :         if (skb_vlan_tag_present(skb)) {
    8046                 :          0 :                 base_flags |= TXD_FLAG_VLAN;
    8047                 :          0 :                 vlan = skb_vlan_tag_get(skb);
    8048                 :            :         }
    8049                 :            : 
    8050   [ #  #  #  # ]:          0 :         if ((unlikely(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP)) &&
    8051                 :            :             tg3_flag(tp, TX_TSTAMP_EN)) {
    8052                 :          0 :                 skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
    8053                 :          0 :                 base_flags |= TXD_FLAG_HWTSTAMP;
    8054                 :            :         }
    8055                 :            : 
    8056                 :          0 :         len = skb_headlen(skb);
    8057                 :            : 
    8058                 :          0 :         mapping = pci_map_single(tp->pdev, skb->data, len, PCI_DMA_TODEVICE);
    8059                 :          0 :         if (pci_dma_mapping_error(tp->pdev, mapping))
    8060                 :          0 :                 goto drop;
    8061                 :            : 
    8062                 :            : 
    8063                 :          0 :         tnapi->tx_buffers[entry].skb = skb;
    8064                 :          0 :         dma_unmap_addr_set(&tnapi->tx_buffers[entry], mapping, mapping);
    8065                 :            : 
    8066                 :          0 :         would_hit_hwbug = 0;
    8067                 :            : 
    8068         [ #  # ]:          0 :         if (tg3_flag(tp, 5701_DMA_BUG))
    8069                 :          0 :                 would_hit_hwbug = 1;
    8070                 :            : 
    8071         [ #  # ]:          0 :         if (tg3_tx_frag_set(tnapi, &entry, &budget, mapping, len, base_flags |
    8072         [ #  # ]:          0 :                           ((skb_shinfo(skb)->nr_frags == 0) ? TXD_FLAG_END : 0),
    8073                 :            :                             mss, vlan)) {
    8074                 :            :                 would_hit_hwbug = 1;
    8075         [ #  # ]:          0 :         } else if (skb_shinfo(skb)->nr_frags > 0) {
    8076                 :          0 :                 u32 tmp_mss = mss;
    8077                 :            : 
    8078   [ #  #  #  # ]:          0 :                 if (!tg3_flag(tp, HW_TSO_1) &&
    8079         [ #  # ]:          0 :                     !tg3_flag(tp, HW_TSO_2) &&
    8080                 :            :                     !tg3_flag(tp, HW_TSO_3))
    8081                 :          0 :                         tmp_mss = 0;
    8082                 :            : 
    8083                 :            :                 /* Now loop through additional data
    8084                 :            :                  * fragments, and queue them.
    8085                 :            :                  */
    8086                 :          0 :                 last = skb_shinfo(skb)->nr_frags - 1;
    8087         [ #  # ]:          0 :                 for (i = 0; i <= last; i++) {
    8088                 :          0 :                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
    8089                 :            : 
    8090                 :          0 :                         len = skb_frag_size(frag);
    8091                 :          0 :                         mapping = skb_frag_dma_map(&tp->pdev->dev, frag, 0,
    8092                 :            :                                                    len, DMA_TO_DEVICE);
    8093                 :            : 
    8094                 :          0 :                         tnapi->tx_buffers[entry].skb = NULL;
    8095                 :          0 :                         dma_unmap_addr_set(&tnapi->tx_buffers[entry], mapping,
    8096                 :            :                                            mapping);
    8097                 :          0 :                         if (dma_mapping_error(&tp->pdev->dev, mapping))
    8098                 :          0 :                                 goto dma_error;
    8099                 :            : 
    8100   [ #  #  #  # ]:          0 :                         if (!budget ||
    8101                 :          0 :                             tg3_tx_frag_set(tnapi, &entry, &budget, mapping,
    8102                 :            :                                             len, base_flags |
    8103         [ #  # ]:          0 :                                             ((i == last) ? TXD_FLAG_END : 0),
    8104                 :            :                                             tmp_mss, vlan)) {
    8105                 :            :                                 would_hit_hwbug = 1;
    8106                 :            :                                 break;
    8107                 :            :                         }
    8108                 :            :                 }
    8109                 :            :         }
    8110                 :            : 
    8111         [ #  # ]:          0 :         if (would_hit_hwbug) {
    8112                 :          0 :                 tg3_tx_skb_unmap(tnapi, tnapi->tx_prod, i);
    8113                 :            : 
    8114   [ #  #  #  # ]:          0 :                 if (mss && tg3_tso_bug_gso_check(tnapi, skb)) {
    8115                 :            :                         /* If it's a TSO packet, do GSO instead of
    8116                 :            :                          * allocating and copying to a large linear SKB
    8117                 :            :                          */
    8118         [ #  # ]:          0 :                         if (ip_tot_len) {
    8119                 :          0 :                                 iph->check = ip_csum;
    8120                 :          0 :                                 iph->tot_len = ip_tot_len;
    8121                 :            :                         }
    8122                 :          0 :                         tcph->check = tcp_csum;
    8123                 :          0 :                         return tg3_tso_bug(tp, tnapi, txq, skb);
    8124                 :            :                 }
    8125                 :            : 
    8126                 :            :                 /* If the workaround fails due to memory/mapping
    8127                 :            :                  * failure, silently drop this packet.
    8128                 :            :                  */
    8129                 :          0 :                 entry = tnapi->tx_prod;
    8130                 :          0 :                 budget = tg3_tx_avail(tnapi);
    8131         [ #  # ]:          0 :                 if (tigon3_dma_hwbug_workaround(tnapi, &skb, &entry, &budget,
    8132                 :            :                                                 base_flags, mss, vlan))
    8133                 :          0 :                         goto drop_nofree;
    8134                 :            :         }
    8135                 :            : 
    8136         [ #  # ]:          0 :         skb_tx_timestamp(skb);
    8137                 :          0 :         netdev_tx_sent_queue(txq, skb->len);
    8138                 :            : 
    8139                 :            :         /* Sync BD data before updating mailbox */
    8140                 :          0 :         wmb();
    8141                 :            : 
    8142                 :          0 :         tnapi->tx_prod = entry;
    8143         [ #  # ]:          0 :         if (unlikely(tg3_tx_avail(tnapi) <= (MAX_SKB_FRAGS + 1))) {
    8144                 :          0 :                 netif_tx_stop_queue(txq);
    8145                 :            : 
    8146                 :            :                 /* netif_tx_stop_queue() must be done before checking
    8147                 :            :                  * checking tx index in tg3_tx_avail() below, because in
    8148                 :            :                  * tg3_tx(), we update tx index before checking for
    8149                 :            :                  * netif_tx_queue_stopped().
    8150                 :            :                  */
    8151                 :          0 :                 smp_mb();
    8152         [ #  # ]:          0 :                 if (tg3_tx_avail(tnapi) > TG3_TX_WAKEUP_THRESH(tnapi))
    8153                 :          0 :                         netif_tx_wake_queue(txq);
    8154                 :            :         }
    8155                 :            : 
    8156   [ #  #  #  # ]:          0 :         if (!netdev_xmit_more() || netif_xmit_stopped(txq)) {
    8157                 :            :                 /* Packets are ready, update Tx producer idx on card. */
    8158                 :          0 :                 tw32_tx_mbox(tnapi->prodmbox, entry);
    8159                 :            :         }
    8160                 :            : 
    8161                 :            :         return NETDEV_TX_OK;
    8162                 :            : 
    8163                 :            : dma_error:
    8164                 :          0 :         tg3_tx_skb_unmap(tnapi, tnapi->tx_prod, --i);
    8165                 :          0 :         tnapi->tx_buffers[tnapi->tx_prod].skb = NULL;
    8166                 :          0 : drop:
    8167                 :          0 :         dev_kfree_skb_any(skb);
    8168                 :          0 : drop_nofree:
    8169                 :          0 :         tp->tx_dropped++;
    8170                 :          0 :         return NETDEV_TX_OK;
    8171                 :            : }
    8172                 :            : 
    8173                 :          0 : static void tg3_mac_loopback(struct tg3 *tp, bool enable)
    8174                 :            : {
    8175         [ #  # ]:          0 :         if (enable) {
    8176                 :          0 :                 tp->mac_mode &= ~(MAC_MODE_HALF_DUPLEX |
    8177                 :            :                                   MAC_MODE_PORT_MODE_MASK);
    8178                 :            : 
    8179                 :          0 :                 tp->mac_mode |= MAC_MODE_PORT_INT_LPBACK;
    8180                 :            : 
    8181         [ #  # ]:          0 :                 if (!tg3_flag(tp, 5705_PLUS))
    8182                 :          0 :                         tp->mac_mode |= MAC_MODE_LINK_POLARITY;
    8183                 :            : 
    8184         [ #  # ]:          0 :                 if (tp->phy_flags & TG3_PHYFLG_10_100_ONLY)
    8185                 :          0 :                         tp->mac_mode |= MAC_MODE_PORT_MODE_MII;
    8186                 :            :                 else
    8187                 :          0 :                         tp->mac_mode |= MAC_MODE_PORT_MODE_GMII;
    8188                 :            :         } else {
    8189                 :          0 :                 tp->mac_mode &= ~MAC_MODE_PORT_INT_LPBACK;
    8190                 :            : 
    8191         [ #  # ]:          0 :                 if (tg3_flag(tp, 5705_PLUS) ||
    8192         [ #  # ]:          0 :                     (tp->phy_flags & TG3_PHYFLG_PHY_SERDES) ||
    8193         [ #  # ]:          0 :                     tg3_asic_rev(tp) == ASIC_REV_5700)
    8194                 :          0 :                         tp->mac_mode &= ~MAC_MODE_LINK_POLARITY;
    8195                 :            :         }
    8196                 :            : 
    8197                 :          0 :         tw32(MAC_MODE, tp->mac_mode);
    8198                 :          0 :         udelay(40);
    8199                 :          0 : }
    8200                 :            : 
    8201                 :          0 : static int tg3_phy_lpbk_set(struct tg3 *tp, u32 speed, bool extlpbk)
    8202                 :            : {
    8203                 :          0 :         u32 val, bmcr, mac_mode, ptest = 0;
    8204                 :            : 
    8205                 :          0 :         tg3_phy_toggle_apd(tp, false);
    8206                 :          0 :         tg3_phy_toggle_automdix(tp, false);
    8207                 :            : 
    8208   [ #  #  #  # ]:          0 :         if (extlpbk && tg3_phy_set_extloopbk(tp))
    8209                 :            :                 return -EIO;
    8210                 :            : 
    8211                 :          0 :         bmcr = BMCR_FULLDPLX;
    8212      [ #  #  # ]:          0 :         switch (speed) {
    8213                 :            :         case SPEED_10:
    8214                 :            :                 break;
    8215                 :          0 :         case SPEED_100:
    8216                 :          0 :                 bmcr |= BMCR_SPEED100;
    8217                 :          0 :                 break;
    8218                 :          0 :         case SPEED_1000:
    8219                 :            :         default:
    8220         [ #  # ]:          0 :                 if (tp->phy_flags & TG3_PHYFLG_IS_FET) {
    8221                 :          0 :                         speed = SPEED_100;
    8222                 :          0 :                         bmcr |= BMCR_SPEED100;
    8223                 :            :                 } else {
    8224                 :          0 :                         speed = SPEED_1000;
    8225                 :          0 :                         bmcr |= BMCR_SPEED1000;
    8226                 :            :                 }
    8227                 :            :         }
    8228                 :            : 
    8229         [ #  # ]:          0 :         if (extlpbk) {
    8230         [ #  # ]:          0 :                 if (!(tp->phy_flags & TG3_PHYFLG_IS_FET)) {
    8231                 :          0 :                         tg3_readphy(tp, MII_CTRL1000, &val);
    8232                 :          0 :                         val |= CTL1000_AS_MASTER |
    8233                 :            :                                CTL1000_ENABLE_MASTER;
    8234                 :          0 :                         tg3_writephy(tp, MII_CTRL1000, val);
    8235                 :            :                 } else {
    8236                 :          0 :                         ptest = MII_TG3_FET_PTEST_TRIM_SEL |
    8237                 :            :                                 MII_TG3_FET_PTEST_TRIM_2;
    8238                 :          0 :                         tg3_writephy(tp, MII_TG3_FET_PTEST, ptest);
    8239                 :            :                 }
    8240                 :            :         } else
    8241                 :          0 :                 bmcr |= BMCR_LOOPBACK;
    8242                 :            : 
    8243                 :          0 :         tg3_writephy(tp, MII_BMCR, bmcr);
    8244                 :            : 
    8245                 :            :         /* The write needs to be flushed for the FETs */
    8246         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_IS_FET)
    8247                 :          0 :                 tg3_readphy(tp, MII_BMCR, &bmcr);
    8248                 :            : 
    8249                 :          0 :         udelay(40);
    8250                 :            : 
    8251         [ #  # ]:          0 :         if ((tp->phy_flags & TG3_PHYFLG_IS_FET) &&
    8252         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5785) {
    8253                 :          0 :                 tg3_writephy(tp, MII_TG3_FET_PTEST, ptest |
    8254                 :            :                              MII_TG3_FET_PTEST_FRC_TX_LINK |
    8255                 :            :                              MII_TG3_FET_PTEST_FRC_TX_LOCK);
    8256                 :            : 
    8257                 :            :                 /* The write needs to be flushed for the AC131 */
    8258                 :          0 :                 tg3_readphy(tp, MII_TG3_FET_PTEST, &val);
    8259                 :            :         }
    8260                 :            : 
    8261                 :            :         /* Reset to prevent losing 1st rx packet intermittently */
    8262   [ #  #  #  # ]:          0 :         if ((tp->phy_flags & TG3_PHYFLG_MII_SERDES) &&
    8263                 :          0 :             tg3_flag(tp, 5780_CLASS)) {
    8264                 :          0 :                 tw32_f(MAC_RX_MODE, RX_MODE_RESET);
    8265                 :          0 :                 udelay(10);
    8266                 :          0 :                 tw32_f(MAC_RX_MODE, tp->rx_mode);
    8267                 :            :         }
    8268                 :            : 
    8269                 :          0 :         mac_mode = tp->mac_mode &
    8270                 :            :                    ~(MAC_MODE_PORT_MODE_MASK | MAC_MODE_HALF_DUPLEX);
    8271         [ #  # ]:          0 :         if (speed == SPEED_1000)
    8272                 :          0 :                 mac_mode |= MAC_MODE_PORT_MODE_GMII;
    8273                 :            :         else
    8274                 :          0 :                 mac_mode |= MAC_MODE_PORT_MODE_MII;
    8275                 :            : 
    8276         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5700) {
    8277                 :          0 :                 u32 masked_phy_id = tp->phy_id & TG3_PHY_ID_MASK;
    8278                 :            : 
    8279         [ #  # ]:          0 :                 if (masked_phy_id == TG3_PHY_ID_BCM5401)
    8280                 :          0 :                         mac_mode &= ~MAC_MODE_LINK_POLARITY;
    8281         [ #  # ]:          0 :                 else if (masked_phy_id == TG3_PHY_ID_BCM5411)
    8282                 :          0 :                         mac_mode |= MAC_MODE_LINK_POLARITY;
    8283                 :            : 
    8284                 :          0 :                 tg3_writephy(tp, MII_TG3_EXT_CTRL,
    8285                 :            :                              MII_TG3_EXT_CTRL_LNK3_LED_MODE);
    8286                 :            :         }
    8287                 :            : 
    8288                 :          0 :         tw32(MAC_MODE, mac_mode);
    8289                 :          0 :         udelay(40);
    8290                 :            : 
    8291                 :          0 :         return 0;
    8292                 :            : }
    8293                 :            : 
    8294                 :          0 : static void tg3_set_loopback(struct net_device *dev, netdev_features_t features)
    8295                 :            : {
    8296         [ #  # ]:          0 :         struct tg3 *tp = netdev_priv(dev);
    8297                 :            : 
    8298         [ #  # ]:          0 :         if (features & NETIF_F_LOOPBACK) {
    8299         [ #  # ]:          0 :                 if (tp->mac_mode & MAC_MODE_PORT_INT_LPBACK)
    8300                 :            :                         return;
    8301                 :            : 
    8302                 :          0 :                 spin_lock_bh(&tp->lock);
    8303                 :          0 :                 tg3_mac_loopback(tp, true);
    8304                 :          0 :                 netif_carrier_on(tp->dev);
    8305                 :          0 :                 spin_unlock_bh(&tp->lock);
    8306                 :          0 :                 netdev_info(dev, "Internal MAC loopback mode enabled.\n");
    8307                 :            :         } else {
    8308         [ #  # ]:          0 :                 if (!(tp->mac_mode & MAC_MODE_PORT_INT_LPBACK))
    8309                 :            :                         return;
    8310                 :            : 
    8311                 :          0 :                 spin_lock_bh(&tp->lock);
    8312                 :          0 :                 tg3_mac_loopback(tp, false);
    8313                 :            :                 /* Force link status check */
    8314                 :          0 :                 tg3_setup_phy(tp, true);
    8315                 :          0 :                 spin_unlock_bh(&tp->lock);
    8316                 :          0 :                 netdev_info(dev, "Internal MAC loopback mode disabled.\n");
    8317                 :            :         }
    8318                 :            : }
    8319                 :            : 
    8320                 :          0 : static netdev_features_t tg3_fix_features(struct net_device *dev,
    8321                 :            :         netdev_features_t features)
    8322                 :            : {
    8323         [ #  # ]:          0 :         struct tg3 *tp = netdev_priv(dev);
    8324                 :            : 
    8325   [ #  #  #  # ]:          0 :         if (dev->mtu > ETH_DATA_LEN && tg3_flag(tp, 5780_CLASS))
    8326                 :          0 :                 features &= ~NETIF_F_ALL_TSO;
    8327                 :            : 
    8328                 :          0 :         return features;
    8329                 :            : }
    8330                 :            : 
    8331                 :          0 : static int tg3_set_features(struct net_device *dev, netdev_features_t features)
    8332                 :            : {
    8333                 :          0 :         netdev_features_t changed = dev->features ^ features;
    8334                 :            : 
    8335   [ #  #  #  # ]:          0 :         if ((changed & NETIF_F_LOOPBACK) && netif_running(dev))
    8336                 :          0 :                 tg3_set_loopback(dev, features);
    8337                 :            : 
    8338                 :          0 :         return 0;
    8339                 :            : }
    8340                 :            : 
    8341                 :          0 : static void tg3_rx_prodring_free(struct tg3 *tp,
    8342                 :            :                                  struct tg3_rx_prodring_set *tpr)
    8343                 :            : {
    8344                 :          0 :         int i;
    8345                 :            : 
    8346         [ #  # ]:          0 :         if (tpr != &tp->napi[0].prodring) {
    8347         [ #  # ]:          0 :                 for (i = tpr->rx_std_cons_idx; i != tpr->rx_std_prod_idx;
    8348                 :          0 :                      i = (i + 1) & tp->rx_std_ring_mask)
    8349                 :          0 :                         tg3_rx_data_free(tp, &tpr->rx_std_buffers[i],
    8350                 :            :                                         tp->rx_pkt_map_sz);
    8351                 :            : 
    8352         [ #  # ]:          0 :                 if (tg3_flag(tp, JUMBO_CAPABLE)) {
    8353                 :          0 :                         for (i = tpr->rx_jmb_cons_idx;
    8354         [ #  # ]:          0 :                              i != tpr->rx_jmb_prod_idx;
    8355                 :          0 :                              i = (i + 1) & tp->rx_jmb_ring_mask) {
    8356                 :          0 :                                 tg3_rx_data_free(tp, &tpr->rx_jmb_buffers[i],
    8357                 :            :                                                 TG3_RX_JMB_MAP_SZ);
    8358                 :            :                         }
    8359                 :            :                 }
    8360                 :            : 
    8361                 :          0 :                 return;
    8362                 :            :         }
    8363                 :            : 
    8364         [ #  # ]:          0 :         for (i = 0; i <= tp->rx_std_ring_mask; i++)
    8365                 :          0 :                 tg3_rx_data_free(tp, &tpr->rx_std_buffers[i],
    8366                 :            :                                 tp->rx_pkt_map_sz);
    8367                 :            : 
    8368   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, JUMBO_CAPABLE) && !tg3_flag(tp, 5780_CLASS)) {
    8369         [ #  # ]:          0 :                 for (i = 0; i <= tp->rx_jmb_ring_mask; i++)
    8370                 :          0 :                         tg3_rx_data_free(tp, &tpr->rx_jmb_buffers[i],
    8371                 :            :                                         TG3_RX_JMB_MAP_SZ);
    8372                 :            :         }
    8373                 :            : }
    8374                 :            : 
    8375                 :            : /* Initialize rx rings for packet processing.
    8376                 :            :  *
    8377                 :            :  * The chip has been shut down and the driver detached from
    8378                 :            :  * the networking, so no interrupts or new tx packets will
    8379                 :            :  * end up in the driver.  tp->{tx,}lock are held and thus
    8380                 :            :  * we may not sleep.
    8381                 :            :  */
    8382                 :          0 : static int tg3_rx_prodring_alloc(struct tg3 *tp,
    8383                 :            :                                  struct tg3_rx_prodring_set *tpr)
    8384                 :            : {
    8385                 :          0 :         u32 i, rx_pkt_dma_sz;
    8386                 :            : 
    8387                 :          0 :         tpr->rx_std_cons_idx = 0;
    8388                 :          0 :         tpr->rx_std_prod_idx = 0;
    8389                 :          0 :         tpr->rx_jmb_cons_idx = 0;
    8390                 :          0 :         tpr->rx_jmb_prod_idx = 0;
    8391                 :            : 
    8392         [ #  # ]:          0 :         if (tpr != &tp->napi[0].prodring) {
    8393         [ #  # ]:          0 :                 memset(&tpr->rx_std_buffers[0], 0,
    8394                 :          0 :                        TG3_RX_STD_BUFF_RING_SIZE(tp));
    8395         [ #  # ]:          0 :                 if (tpr->rx_jmb_buffers)
    8396         [ #  # ]:          0 :                         memset(&tpr->rx_jmb_buffers[0], 0,
    8397                 :            :                                TG3_RX_JMB_BUFF_RING_SIZE(tp));
    8398                 :          0 :                 goto done;
    8399                 :            :         }
    8400                 :            : 
    8401                 :            :         /* Zero out all descriptors. */
    8402         [ #  # ]:          0 :         memset(tpr->rx_std, 0, TG3_RX_STD_RING_BYTES(tp));
    8403                 :            : 
    8404                 :          0 :         rx_pkt_dma_sz = TG3_RX_STD_DMA_SZ;
    8405         [ #  # ]:          0 :         if (tg3_flag(tp, 5780_CLASS) &&
    8406         [ #  # ]:          0 :             tp->dev->mtu > ETH_DATA_LEN)
    8407                 :          0 :                 rx_pkt_dma_sz = TG3_RX_JMB_DMA_SZ;
    8408                 :          0 :         tp->rx_pkt_map_sz = TG3_RX_DMA_TO_MAP_SZ(rx_pkt_dma_sz);
    8409                 :            : 
    8410                 :            :         /* Initialize invariants of the rings, we only set this
    8411                 :            :          * stuff once.  This works because the card does not
    8412                 :            :          * write into the rx buffer posting rings.
    8413                 :            :          */
    8414         [ #  # ]:          0 :         for (i = 0; i <= tp->rx_std_ring_mask; i++) {
    8415                 :          0 :                 struct tg3_rx_buffer_desc *rxd;
    8416                 :            : 
    8417                 :          0 :                 rxd = &tpr->rx_std[i];
    8418                 :          0 :                 rxd->idx_len = rx_pkt_dma_sz << RXD_LEN_SHIFT;
    8419                 :          0 :                 rxd->type_flags = (RXD_FLAG_END << RXD_FLAGS_SHIFT);
    8420                 :          0 :                 rxd->opaque = (RXD_OPAQUE_RING_STD |
    8421                 :            :                                (i << RXD_OPAQUE_INDEX_SHIFT));
    8422                 :            :         }
    8423                 :            : 
    8424                 :            :         /* Now allocate fresh SKBs for each rx ring. */
    8425         [ #  # ]:          0 :         for (i = 0; i < tp->rx_pending; i++) {
    8426                 :          0 :                 unsigned int frag_size;
    8427                 :            : 
    8428         [ #  # ]:          0 :                 if (tg3_alloc_rx_data(tp, tpr, RXD_OPAQUE_RING_STD, i,
    8429                 :            :                                       &frag_size) < 0) {
    8430                 :          0 :                         netdev_warn(tp->dev,
    8431                 :            :                                     "Using a smaller RX standard ring. Only "
    8432                 :            :                                     "%d out of %d buffers were allocated "
    8433                 :            :                                     "successfully\n", i, tp->rx_pending);
    8434         [ #  # ]:          0 :                         if (i == 0)
    8435                 :          0 :                                 goto initfail;
    8436                 :          0 :                         tp->rx_pending = i;
    8437                 :          0 :                         break;
    8438                 :            :                 }
    8439                 :            :         }
    8440                 :            : 
    8441   [ #  #  #  # ]:          0 :         if (!tg3_flag(tp, JUMBO_CAPABLE) || tg3_flag(tp, 5780_CLASS))
    8442                 :          0 :                 goto done;
    8443                 :            : 
    8444         [ #  # ]:          0 :         memset(tpr->rx_jmb, 0, TG3_RX_JMB_RING_BYTES(tp));
    8445                 :            : 
    8446         [ #  # ]:          0 :         if (!tg3_flag(tp, JUMBO_RING_ENABLE))
    8447                 :          0 :                 goto done;
    8448                 :            : 
    8449         [ #  # ]:          0 :         for (i = 0; i <= tp->rx_jmb_ring_mask; i++) {
    8450                 :          0 :                 struct tg3_rx_buffer_desc *rxd;
    8451                 :            : 
    8452                 :          0 :                 rxd = &tpr->rx_jmb[i].std;
    8453                 :          0 :                 rxd->idx_len = TG3_RX_JMB_DMA_SZ << RXD_LEN_SHIFT;
    8454                 :          0 :                 rxd->type_flags = (RXD_FLAG_END << RXD_FLAGS_SHIFT) |
    8455                 :            :                                   RXD_FLAG_JUMBO;
    8456                 :          0 :                 rxd->opaque = (RXD_OPAQUE_RING_JUMBO |
    8457                 :            :                        (i << RXD_OPAQUE_INDEX_SHIFT));
    8458                 :            :         }
    8459                 :            : 
    8460         [ #  # ]:          0 :         for (i = 0; i < tp->rx_jumbo_pending; i++) {
    8461                 :          0 :                 unsigned int frag_size;
    8462                 :            : 
    8463         [ #  # ]:          0 :                 if (tg3_alloc_rx_data(tp, tpr, RXD_OPAQUE_RING_JUMBO, i,
    8464                 :            :                                       &frag_size) < 0) {
    8465                 :          0 :                         netdev_warn(tp->dev,
    8466                 :            :                                     "Using a smaller RX jumbo ring. Only %d "
    8467                 :            :                                     "out of %d buffers were allocated "
    8468                 :            :                                     "successfully\n", i, tp->rx_jumbo_pending);
    8469         [ #  # ]:          0 :                         if (i == 0)
    8470                 :          0 :                                 goto initfail;
    8471                 :          0 :                         tp->rx_jumbo_pending = i;
    8472                 :          0 :                         break;
    8473                 :            :                 }
    8474                 :            :         }
    8475                 :            : 
    8476                 :          0 : done:
    8477                 :            :         return 0;
    8478                 :            : 
    8479                 :          0 : initfail:
    8480                 :          0 :         tg3_rx_prodring_free(tp, tpr);
    8481                 :          0 :         return -ENOMEM;
    8482                 :            : }
    8483                 :            : 
    8484                 :          0 : static void tg3_rx_prodring_fini(struct tg3 *tp,
    8485                 :            :                                  struct tg3_rx_prodring_set *tpr)
    8486                 :            : {
    8487                 :          0 :         kfree(tpr->rx_std_buffers);
    8488                 :          0 :         tpr->rx_std_buffers = NULL;
    8489                 :          0 :         kfree(tpr->rx_jmb_buffers);
    8490                 :          0 :         tpr->rx_jmb_buffers = NULL;
    8491         [ #  # ]:          0 :         if (tpr->rx_std) {
    8492         [ #  # ]:          0 :                 dma_free_coherent(&tp->pdev->dev, TG3_RX_STD_RING_BYTES(tp),
    8493                 :            :                                   tpr->rx_std, tpr->rx_std_mapping);
    8494                 :          0 :                 tpr->rx_std = NULL;
    8495                 :            :         }
    8496         [ #  # ]:          0 :         if (tpr->rx_jmb) {
    8497         [ #  # ]:          0 :                 dma_free_coherent(&tp->pdev->dev, TG3_RX_JMB_RING_BYTES(tp),
    8498                 :            :                                   tpr->rx_jmb, tpr->rx_jmb_mapping);
    8499                 :          0 :                 tpr->rx_jmb = NULL;
    8500                 :            :         }
    8501                 :          0 : }
    8502                 :            : 
    8503                 :          0 : static int tg3_rx_prodring_init(struct tg3 *tp,
    8504                 :            :                                 struct tg3_rx_prodring_set *tpr)
    8505                 :            : {
    8506         [ #  # ]:          0 :         tpr->rx_std_buffers = kzalloc(TG3_RX_STD_BUFF_RING_SIZE(tp),
    8507                 :            :                                       GFP_KERNEL);
    8508         [ #  # ]:          0 :         if (!tpr->rx_std_buffers)
    8509                 :            :                 return -ENOMEM;
    8510                 :            : 
    8511         [ #  # ]:          0 :         tpr->rx_std = dma_alloc_coherent(&tp->pdev->dev,
    8512                 :            :                                          TG3_RX_STD_RING_BYTES(tp),
    8513                 :            :                                          &tpr->rx_std_mapping,
    8514                 :            :                                          GFP_KERNEL);
    8515         [ #  # ]:          0 :         if (!tpr->rx_std)
    8516                 :          0 :                 goto err_out;
    8517                 :            : 
    8518   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, JUMBO_CAPABLE) && !tg3_flag(tp, 5780_CLASS)) {
    8519         [ #  # ]:          0 :                 tpr->rx_jmb_buffers = kzalloc(TG3_RX_JMB_BUFF_RING_SIZE(tp),
    8520                 :            :                                               GFP_KERNEL);
    8521         [ #  # ]:          0 :                 if (!tpr->rx_jmb_buffers)
    8522                 :          0 :                         goto err_out;
    8523                 :            : 
    8524         [ #  # ]:          0 :                 tpr->rx_jmb = dma_alloc_coherent(&tp->pdev->dev,
    8525                 :            :                                                  TG3_RX_JMB_RING_BYTES(tp),
    8526                 :            :                                                  &tpr->rx_jmb_mapping,
    8527                 :            :                                                  GFP_KERNEL);
    8528         [ #  # ]:          0 :                 if (!tpr->rx_jmb)
    8529                 :          0 :                         goto err_out;
    8530                 :            :         }
    8531                 :            : 
    8532                 :            :         return 0;
    8533                 :            : 
    8534                 :          0 : err_out:
    8535                 :          0 :         tg3_rx_prodring_fini(tp, tpr);
    8536                 :          0 :         return -ENOMEM;
    8537                 :            : }
    8538                 :            : 
    8539                 :            : /* Free up pending packets in all rx/tx rings.
    8540                 :            :  *
    8541                 :            :  * The chip has been shut down and the driver detached from
    8542                 :            :  * the networking, so no interrupts or new tx packets will
    8543                 :            :  * end up in the driver.  tp->{tx,}lock is not held and we are not
    8544                 :            :  * in an interrupt context and thus may sleep.
    8545                 :            :  */
    8546                 :          0 : static void tg3_free_rings(struct tg3 *tp)
    8547                 :            : {
    8548                 :          0 :         int i, j;
    8549                 :            : 
    8550         [ #  # ]:          0 :         for (j = 0; j < tp->irq_cnt; j++) {
    8551                 :          0 :                 struct tg3_napi *tnapi = &tp->napi[j];
    8552                 :            : 
    8553                 :          0 :                 tg3_rx_prodring_free(tp, &tnapi->prodring);
    8554                 :            : 
    8555         [ #  # ]:          0 :                 if (!tnapi->tx_buffers)
    8556                 :          0 :                         continue;
    8557                 :            : 
    8558         [ #  # ]:          0 :                 for (i = 0; i < TG3_TX_RING_SIZE; i++) {
    8559                 :          0 :                         struct sk_buff *skb = tnapi->tx_buffers[i].skb;
    8560                 :            : 
    8561         [ #  # ]:          0 :                         if (!skb)
    8562                 :          0 :                                 continue;
    8563                 :            : 
    8564                 :          0 :                         tg3_tx_skb_unmap(tnapi, i,
    8565                 :          0 :                                          skb_shinfo(skb)->nr_frags - 1);
    8566                 :            : 
    8567                 :          0 :                         dev_consume_skb_any(skb);
    8568                 :            :                 }
    8569                 :          0 :                 netdev_tx_reset_queue(netdev_get_tx_queue(tp->dev, j));
    8570                 :            :         }
    8571                 :          0 : }
    8572                 :            : 
    8573                 :            : /* Initialize tx/rx rings for packet processing.
    8574                 :            :  *
    8575                 :            :  * The chip has been shut down and the driver detached from
    8576                 :            :  * the networking, so no interrupts or new tx packets will
    8577                 :            :  * end up in the driver.  tp->{tx,}lock are held and thus
    8578                 :            :  * we may not sleep.
    8579                 :            :  */
    8580                 :          0 : static int tg3_init_rings(struct tg3 *tp)
    8581                 :            : {
    8582                 :          0 :         int i;
    8583                 :            : 
    8584                 :            :         /* Free up all the SKBs. */
    8585                 :          0 :         tg3_free_rings(tp);
    8586                 :            : 
    8587         [ #  # ]:          0 :         for (i = 0; i < tp->irq_cnt; i++) {
    8588                 :          0 :                 struct tg3_napi *tnapi = &tp->napi[i];
    8589                 :            : 
    8590                 :          0 :                 tnapi->last_tag = 0;
    8591                 :          0 :                 tnapi->last_irq_tag = 0;
    8592                 :          0 :                 tnapi->hw_status->status = 0;
    8593                 :          0 :                 tnapi->hw_status->status_tag = 0;
    8594                 :          0 :                 memset(tnapi->hw_status, 0, TG3_HW_STATUS_SIZE);
    8595                 :            : 
    8596                 :          0 :                 tnapi->tx_prod = 0;
    8597                 :          0 :                 tnapi->tx_cons = 0;
    8598         [ #  # ]:          0 :                 if (tnapi->tx_ring)
    8599                 :          0 :                         memset(tnapi->tx_ring, 0, TG3_TX_RING_BYTES);
    8600                 :            : 
    8601                 :          0 :                 tnapi->rx_rcb_ptr = 0;
    8602         [ #  # ]:          0 :                 if (tnapi->rx_rcb)
    8603                 :          0 :                         memset(tnapi->rx_rcb, 0, TG3_RX_RCB_RING_BYTES(tp));
    8604                 :            : 
    8605   [ #  #  #  # ]:          0 :                 if (tnapi->prodring.rx_std &&
    8606                 :          0 :                     tg3_rx_prodring_alloc(tp, &tnapi->prodring)) {
    8607                 :          0 :                         tg3_free_rings(tp);
    8608                 :          0 :                         return -ENOMEM;
    8609                 :            :                 }
    8610                 :            :         }
    8611                 :            : 
    8612                 :            :         return 0;
    8613                 :            : }
    8614                 :            : 
    8615                 :          0 : static void tg3_mem_tx_release(struct tg3 *tp)
    8616                 :            : {
    8617                 :          0 :         int i;
    8618                 :            : 
    8619         [ #  # ]:          0 :         for (i = 0; i < tp->irq_max; i++) {
    8620                 :          0 :                 struct tg3_napi *tnapi = &tp->napi[i];
    8621                 :            : 
    8622         [ #  # ]:          0 :                 if (tnapi->tx_ring) {
    8623                 :          0 :                         dma_free_coherent(&tp->pdev->dev, TG3_TX_RING_BYTES,
    8624                 :            :                                 tnapi->tx_ring, tnapi->tx_desc_mapping);
    8625                 :          0 :                         tnapi->tx_ring = NULL;
    8626                 :            :                 }
    8627                 :            : 
    8628                 :          0 :                 kfree(tnapi->tx_buffers);
    8629                 :          0 :                 tnapi->tx_buffers = NULL;
    8630                 :            :         }
    8631                 :          0 : }
    8632                 :            : 
    8633                 :          0 : static int tg3_mem_tx_acquire(struct tg3 *tp)
    8634                 :            : {
    8635                 :          0 :         int i;
    8636                 :          0 :         struct tg3_napi *tnapi = &tp->napi[0];
    8637                 :            : 
    8638                 :            :         /* If multivector TSS is enabled, vector 0 does not handle
    8639                 :            :          * tx interrupts.  Don't allocate any resources for it.
    8640                 :            :          */
    8641         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_TSS))
    8642                 :          0 :                 tnapi++;
    8643                 :            : 
    8644         [ #  # ]:          0 :         for (i = 0; i < tp->txq_cnt; i++, tnapi++) {
    8645                 :          0 :                 tnapi->tx_buffers = kcalloc(TG3_TX_RING_SIZE,
    8646                 :            :                                             sizeof(struct tg3_tx_ring_info),
    8647                 :            :                                             GFP_KERNEL);
    8648         [ #  # ]:          0 :                 if (!tnapi->tx_buffers)
    8649                 :          0 :                         goto err_out;
    8650                 :            : 
    8651                 :          0 :                 tnapi->tx_ring = dma_alloc_coherent(&tp->pdev->dev,
    8652                 :            :                                                     TG3_TX_RING_BYTES,
    8653                 :            :                                                     &tnapi->tx_desc_mapping,
    8654                 :            :                                                     GFP_KERNEL);
    8655         [ #  # ]:          0 :                 if (!tnapi->tx_ring)
    8656                 :          0 :                         goto err_out;
    8657                 :            :         }
    8658                 :            : 
    8659                 :            :         return 0;
    8660                 :            : 
    8661                 :          0 : err_out:
    8662                 :          0 :         tg3_mem_tx_release(tp);
    8663                 :          0 :         return -ENOMEM;
    8664                 :            : }
    8665                 :            : 
    8666                 :          0 : static void tg3_mem_rx_release(struct tg3 *tp)
    8667                 :            : {
    8668                 :          0 :         int i;
    8669                 :            : 
    8670         [ #  # ]:          0 :         for (i = 0; i < tp->irq_max; i++) {
    8671                 :          0 :                 struct tg3_napi *tnapi = &tp->napi[i];
    8672                 :            : 
    8673                 :          0 :                 tg3_rx_prodring_fini(tp, &tnapi->prodring);
    8674                 :            : 
    8675         [ #  # ]:          0 :                 if (!tnapi->rx_rcb)
    8676                 :          0 :                         continue;
    8677                 :            : 
    8678                 :          0 :                 dma_free_coherent(&tp->pdev->dev,
    8679                 :          0 :                                   TG3_RX_RCB_RING_BYTES(tp),
    8680                 :            :                                   tnapi->rx_rcb,
    8681                 :            :                                   tnapi->rx_rcb_mapping);
    8682                 :          0 :                 tnapi->rx_rcb = NULL;
    8683                 :            :         }
    8684                 :          0 : }
    8685                 :            : 
    8686                 :          0 : static int tg3_mem_rx_acquire(struct tg3 *tp)
    8687                 :            : {
    8688                 :          0 :         unsigned int i, limit;
    8689                 :            : 
    8690                 :          0 :         limit = tp->rxq_cnt;
    8691                 :            : 
    8692                 :            :         /* If RSS is enabled, we need a (dummy) producer ring
    8693                 :            :          * set on vector zero.  This is the true hw prodring.
    8694                 :            :          */
    8695         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_RSS))
    8696                 :          0 :                 limit++;
    8697                 :            : 
    8698         [ #  # ]:          0 :         for (i = 0; i < limit; i++) {
    8699                 :          0 :                 struct tg3_napi *tnapi = &tp->napi[i];
    8700                 :            : 
    8701         [ #  # ]:          0 :                 if (tg3_rx_prodring_init(tp, &tnapi->prodring))
    8702                 :          0 :                         goto err_out;
    8703                 :            : 
    8704                 :            :                 /* If multivector RSS is enabled, vector 0
    8705                 :            :                  * does not handle rx or tx interrupts.
    8706                 :            :                  * Don't allocate any resources for it.
    8707                 :            :                  */
    8708   [ #  #  #  # ]:          0 :                 if (!i && tg3_flag(tp, ENABLE_RSS))
    8709                 :          0 :                         continue;
    8710                 :            : 
    8711                 :          0 :                 tnapi->rx_rcb = dma_alloc_coherent(&tp->pdev->dev,
    8712                 :          0 :                                                    TG3_RX_RCB_RING_BYTES(tp),
    8713                 :            :                                                    &tnapi->rx_rcb_mapping,
    8714                 :            :                                                    GFP_KERNEL);
    8715         [ #  # ]:          0 :                 if (!tnapi->rx_rcb)
    8716                 :          0 :                         goto err_out;
    8717                 :            :         }
    8718                 :            : 
    8719                 :            :         return 0;
    8720                 :            : 
    8721                 :          0 : err_out:
    8722                 :          0 :         tg3_mem_rx_release(tp);
    8723                 :          0 :         return -ENOMEM;
    8724                 :            : }
    8725                 :            : 
    8726                 :            : /*
    8727                 :            :  * Must not be invoked with interrupt sources disabled and
    8728                 :            :  * the hardware shutdown down.
    8729                 :            :  */
    8730                 :          0 : static void tg3_free_consistent(struct tg3 *tp)
    8731                 :            : {
    8732                 :          0 :         int i;
    8733                 :            : 
    8734         [ #  # ]:          0 :         for (i = 0; i < tp->irq_cnt; i++) {
    8735                 :          0 :                 struct tg3_napi *tnapi = &tp->napi[i];
    8736                 :            : 
    8737         [ #  # ]:          0 :                 if (tnapi->hw_status) {
    8738                 :          0 :                         dma_free_coherent(&tp->pdev->dev, TG3_HW_STATUS_SIZE,
    8739                 :            :                                           tnapi->hw_status,
    8740                 :            :                                           tnapi->status_mapping);
    8741                 :          0 :                         tnapi->hw_status = NULL;
    8742                 :            :                 }
    8743                 :            :         }
    8744                 :            : 
    8745                 :          0 :         tg3_mem_rx_release(tp);
    8746                 :          0 :         tg3_mem_tx_release(tp);
    8747                 :            : 
    8748                 :            :         /* tp->hw_stats can be referenced safely:
    8749                 :            :          *     1. under rtnl_lock
    8750                 :            :          *     2. or under tp->lock if TG3_FLAG_INIT_COMPLETE is set.
    8751                 :            :          */
    8752         [ #  # ]:          0 :         if (tp->hw_stats) {
    8753                 :          0 :                 dma_free_coherent(&tp->pdev->dev, sizeof(struct tg3_hw_stats),
    8754                 :            :                                   tp->hw_stats, tp->stats_mapping);
    8755                 :          0 :                 tp->hw_stats = NULL;
    8756                 :            :         }
    8757                 :          0 : }
    8758                 :            : 
    8759                 :            : /*
    8760                 :            :  * Must not be invoked with interrupt sources disabled and
    8761                 :            :  * the hardware shutdown down.  Can sleep.
    8762                 :            :  */
    8763                 :          0 : static int tg3_alloc_consistent(struct tg3 *tp)
    8764                 :            : {
    8765                 :          0 :         int i;
    8766                 :            : 
    8767                 :          0 :         tp->hw_stats = dma_alloc_coherent(&tp->pdev->dev,
    8768                 :            :                                           sizeof(struct tg3_hw_stats),
    8769                 :            :                                           &tp->stats_mapping, GFP_KERNEL);
    8770         [ #  # ]:          0 :         if (!tp->hw_stats)
    8771                 :          0 :                 goto err_out;
    8772                 :            : 
    8773         [ #  # ]:          0 :         for (i = 0; i < tp->irq_cnt; i++) {
    8774                 :          0 :                 struct tg3_napi *tnapi = &tp->napi[i];
    8775                 :          0 :                 struct tg3_hw_status *sblk;
    8776                 :            : 
    8777                 :          0 :                 tnapi->hw_status = dma_alloc_coherent(&tp->pdev->dev,
    8778                 :            :                                                       TG3_HW_STATUS_SIZE,
    8779                 :            :                                                       &tnapi->status_mapping,
    8780                 :            :                                                       GFP_KERNEL);
    8781         [ #  # ]:          0 :                 if (!tnapi->hw_status)
    8782                 :          0 :                         goto err_out;
    8783                 :            : 
    8784                 :          0 :                 sblk = tnapi->hw_status;
    8785                 :            : 
    8786         [ #  # ]:          0 :                 if (tg3_flag(tp, ENABLE_RSS)) {
    8787                 :          0 :                         u16 *prodptr = NULL;
    8788                 :            : 
    8789                 :            :                         /*
    8790                 :            :                          * When RSS is enabled, the status block format changes
    8791                 :            :                          * slightly.  The "rx_jumbo_consumer", "reserved",
    8792                 :            :                          * and "rx_mini_consumer" members get mapped to the
    8793                 :            :                          * other three rx return ring producer indexes.
    8794                 :            :                          */
    8795   [ #  #  #  #  :          0 :                         switch (i) {
                      # ]
    8796                 :          0 :                         case 1:
    8797                 :          0 :                                 prodptr = &sblk->idx[0].rx_producer;
    8798                 :          0 :                                 break;
    8799                 :          0 :                         case 2:
    8800                 :          0 :                                 prodptr = &sblk->rx_jumbo_consumer;
    8801                 :          0 :                                 break;
    8802                 :          0 :                         case 3:
    8803                 :          0 :                                 prodptr = &sblk->reserved;
    8804                 :          0 :                                 break;
    8805                 :          0 :                         case 4:
    8806                 :          0 :                                 prodptr = &sblk->rx_mini_consumer;
    8807                 :          0 :                                 break;
    8808                 :            :                         }
    8809                 :          0 :                         tnapi->rx_rcb_prod_idx = prodptr;
    8810                 :            :                 } else {
    8811                 :          0 :                         tnapi->rx_rcb_prod_idx = &sblk->idx[0].rx_producer;
    8812                 :            :                 }
    8813                 :            :         }
    8814                 :            : 
    8815   [ #  #  #  # ]:          0 :         if (tg3_mem_tx_acquire(tp) || tg3_mem_rx_acquire(tp))
    8816                 :          0 :                 goto err_out;
    8817                 :            : 
    8818                 :            :         return 0;
    8819                 :            : 
    8820                 :          0 : err_out:
    8821                 :          0 :         tg3_free_consistent(tp);
    8822                 :          0 :         return -ENOMEM;
    8823                 :            : }
    8824                 :            : 
    8825                 :            : #define MAX_WAIT_CNT 1000
    8826                 :            : 
    8827                 :            : /* To stop a block, clear the enable bit and poll till it
    8828                 :            :  * clears.  tp->lock is held.
    8829                 :            :  */
    8830                 :          0 : static int tg3_stop_block(struct tg3 *tp, unsigned long ofs, u32 enable_bit, bool silent)
    8831                 :            : {
    8832                 :          0 :         unsigned int i;
    8833                 :          0 :         u32 val;
    8834                 :            : 
    8835         [ #  # ]:          0 :         if (tg3_flag(tp, 5705_PLUS)) {
    8836         [ #  # ]:          0 :                 switch (ofs) {
    8837                 :            :                 case RCVLSC_MODE:
    8838                 :            :                 case DMAC_MODE:
    8839                 :            :                 case MBFREE_MODE:
    8840                 :            :                 case BUFMGR_MODE:
    8841                 :            :                 case MEMARB_MODE:
    8842                 :            :                         /* We can't enable/disable these bits of the
    8843                 :            :                          * 5705/5750, just say success.
    8844                 :            :                          */
    8845                 :            :                         return 0;
    8846                 :            : 
    8847                 :            :                 default:
    8848                 :            :                         break;
    8849                 :            :                 }
    8850                 :          0 :         }
    8851                 :            : 
    8852                 :          0 :         val = tr32(ofs);
    8853                 :          0 :         val &= ~enable_bit;
    8854                 :          0 :         tw32_f(ofs, val);
    8855                 :            : 
    8856         [ #  # ]:          0 :         for (i = 0; i < MAX_WAIT_CNT; i++) {
    8857         [ #  # ]:          0 :                 if (pci_channel_offline(tp->pdev)) {
    8858                 :          0 :                         dev_err(&tp->pdev->dev,
    8859                 :            :                                 "tg3_stop_block device offline, "
    8860                 :            :                                 "ofs=%lx enable_bit=%x\n",
    8861                 :            :                                 ofs, enable_bit);
    8862                 :          0 :                         return -ENODEV;
    8863                 :            :                 }
    8864                 :            : 
    8865                 :          0 :                 udelay(100);
    8866                 :          0 :                 val = tr32(ofs);
    8867         [ #  # ]:          0 :                 if ((val & enable_bit) == 0)
    8868                 :            :                         break;
    8869                 :            :         }
    8870                 :            : 
    8871         [ #  # ]:          0 :         if (i == MAX_WAIT_CNT && !silent) {
    8872                 :          0 :                 dev_err(&tp->pdev->dev,
    8873                 :            :                         "tg3_stop_block timed out, ofs=%lx enable_bit=%x\n",
    8874                 :            :                         ofs, enable_bit);
    8875                 :          0 :                 return -ENODEV;
    8876                 :            :         }
    8877                 :            : 
    8878                 :            :         return 0;
    8879                 :            : }
    8880                 :            : 
    8881                 :            : /* tp->lock is held. */
    8882                 :          0 : static int tg3_abort_hw(struct tg3 *tp, bool silent)
    8883                 :            : {
    8884                 :          0 :         int i, err;
    8885                 :            : 
    8886                 :          0 :         tg3_disable_ints(tp);
    8887                 :            : 
    8888         [ #  # ]:          0 :         if (pci_channel_offline(tp->pdev)) {
    8889                 :          0 :                 tp->rx_mode &= ~(RX_MODE_ENABLE | TX_MODE_ENABLE);
    8890                 :          0 :                 tp->mac_mode &= ~MAC_MODE_TDE_ENABLE;
    8891                 :          0 :                 err = -ENODEV;
    8892                 :          0 :                 goto err_no_dev;
    8893                 :            :         }
    8894                 :            : 
    8895                 :          0 :         tp->rx_mode &= ~RX_MODE_ENABLE;
    8896                 :          0 :         tw32_f(MAC_RX_MODE, tp->rx_mode);
    8897                 :          0 :         udelay(10);
    8898                 :            : 
    8899                 :          0 :         err  = tg3_stop_block(tp, RCVBDI_MODE, RCVBDI_MODE_ENABLE, silent);
    8900                 :          0 :         err |= tg3_stop_block(tp, RCVLPC_MODE, RCVLPC_MODE_ENABLE, silent);
    8901                 :          0 :         err |= tg3_stop_block(tp, RCVLSC_MODE, RCVLSC_MODE_ENABLE, silent);
    8902                 :          0 :         err |= tg3_stop_block(tp, RCVDBDI_MODE, RCVDBDI_MODE_ENABLE, silent);
    8903                 :          0 :         err |= tg3_stop_block(tp, RCVDCC_MODE, RCVDCC_MODE_ENABLE, silent);
    8904                 :          0 :         err |= tg3_stop_block(tp, RCVCC_MODE, RCVCC_MODE_ENABLE, silent);
    8905                 :            : 
    8906                 :          0 :         err |= tg3_stop_block(tp, SNDBDS_MODE, SNDBDS_MODE_ENABLE, silent);
    8907                 :          0 :         err |= tg3_stop_block(tp, SNDBDI_MODE, SNDBDI_MODE_ENABLE, silent);
    8908                 :          0 :         err |= tg3_stop_block(tp, SNDDATAI_MODE, SNDDATAI_MODE_ENABLE, silent);
    8909                 :          0 :         err |= tg3_stop_block(tp, RDMAC_MODE, RDMAC_MODE_ENABLE, silent);
    8910                 :          0 :         err |= tg3_stop_block(tp, SNDDATAC_MODE, SNDDATAC_MODE_ENABLE, silent);
    8911                 :          0 :         err |= tg3_stop_block(tp, DMAC_MODE, DMAC_MODE_ENABLE, silent);
    8912                 :          0 :         err |= tg3_stop_block(tp, SNDBDC_MODE, SNDBDC_MODE_ENABLE, silent);
    8913                 :            : 
    8914                 :          0 :         tp->mac_mode &= ~MAC_MODE_TDE_ENABLE;
    8915                 :          0 :         tw32_f(MAC_MODE, tp->mac_mode);
    8916                 :          0 :         udelay(40);
    8917                 :            : 
    8918                 :          0 :         tp->tx_mode &= ~TX_MODE_ENABLE;
    8919                 :          0 :         tw32_f(MAC_TX_MODE, tp->tx_mode);
    8920                 :            : 
    8921         [ #  # ]:          0 :         for (i = 0; i < MAX_WAIT_CNT; i++) {
    8922                 :          0 :                 udelay(100);
    8923         [ #  # ]:          0 :                 if (!(tr32(MAC_TX_MODE) & TX_MODE_ENABLE))
    8924                 :            :                         break;
    8925                 :            :         }
    8926         [ #  # ]:          0 :         if (i >= MAX_WAIT_CNT) {
    8927                 :          0 :                 dev_err(&tp->pdev->dev,
    8928                 :            :                         "%s timed out, TX_MODE_ENABLE will not clear "
    8929                 :            :                         "MAC_TX_MODE=%08x\n", __func__, tr32(MAC_TX_MODE));
    8930                 :          0 :                 err |= -ENODEV;
    8931                 :            :         }
    8932                 :            : 
    8933                 :          0 :         err |= tg3_stop_block(tp, HOSTCC_MODE, HOSTCC_MODE_ENABLE, silent);
    8934                 :          0 :         err |= tg3_stop_block(tp, WDMAC_MODE, WDMAC_MODE_ENABLE, silent);
    8935                 :          0 :         err |= tg3_stop_block(tp, MBFREE_MODE, MBFREE_MODE_ENABLE, silent);
    8936                 :            : 
    8937                 :          0 :         tw32(FTQ_RESET, 0xffffffff);
    8938                 :          0 :         tw32(FTQ_RESET, 0x00000000);
    8939                 :            : 
    8940                 :          0 :         err |= tg3_stop_block(tp, BUFMGR_MODE, BUFMGR_MODE_ENABLE, silent);
    8941                 :          0 :         err |= tg3_stop_block(tp, MEMARB_MODE, MEMARB_MODE_ENABLE, silent);
    8942                 :            : 
    8943                 :          0 : err_no_dev:
    8944         [ #  # ]:          0 :         for (i = 0; i < tp->irq_cnt; i++) {
    8945                 :          0 :                 struct tg3_napi *tnapi = &tp->napi[i];
    8946         [ #  # ]:          0 :                 if (tnapi->hw_status)
    8947                 :          0 :                         memset(tnapi->hw_status, 0, TG3_HW_STATUS_SIZE);
    8948                 :            :         }
    8949                 :            : 
    8950                 :          0 :         return err;
    8951                 :            : }
    8952                 :            : 
    8953                 :            : /* Save PCI command register before chip reset */
    8954                 :          0 : static void tg3_save_pci_state(struct tg3 *tp)
    8955                 :            : {
    8956                 :          0 :         pci_read_config_word(tp->pdev, PCI_COMMAND, &tp->pci_cmd);
    8957                 :            : }
    8958                 :            : 
    8959                 :            : /* Restore PCI state after chip reset */
    8960                 :          0 : static void tg3_restore_pci_state(struct tg3 *tp)
    8961                 :            : {
    8962                 :          0 :         u32 val;
    8963                 :            : 
    8964                 :            :         /* Re-enable indirect register accesses. */
    8965                 :          0 :         pci_write_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
    8966                 :            :                                tp->misc_host_ctrl);
    8967                 :            : 
    8968                 :            :         /* Set MAX PCI retry to zero. */
    8969                 :          0 :         val = (PCISTATE_ROM_ENABLE | PCISTATE_ROM_RETRY_ENABLE);
    8970   [ #  #  #  # ]:          0 :         if (tg3_chip_rev_id(tp) == CHIPREV_ID_5704_A0 &&
    8971                 :          0 :             tg3_flag(tp, PCIX_MODE))
    8972                 :          0 :                 val |= PCISTATE_RETRY_SAME_DMA;
    8973                 :            :         /* Allow reads and writes to the APE register and memory space. */
    8974         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_APE))
    8975                 :          0 :                 val |= PCISTATE_ALLOW_APE_CTLSPC_WR |
    8976                 :            :                        PCISTATE_ALLOW_APE_SHMEM_WR |
    8977                 :            :                        PCISTATE_ALLOW_APE_PSPACE_WR;
    8978                 :          0 :         pci_write_config_dword(tp->pdev, TG3PCI_PCISTATE, val);
    8979                 :            : 
    8980                 :          0 :         pci_write_config_word(tp->pdev, PCI_COMMAND, tp->pci_cmd);
    8981                 :            : 
    8982         [ #  # ]:          0 :         if (!tg3_flag(tp, PCI_EXPRESS)) {
    8983                 :          0 :                 pci_write_config_byte(tp->pdev, PCI_CACHE_LINE_SIZE,
    8984                 :          0 :                                       tp->pci_cacheline_sz);
    8985                 :          0 :                 pci_write_config_byte(tp->pdev, PCI_LATENCY_TIMER,
    8986                 :          0 :                                       tp->pci_lat_timer);
    8987                 :            :         }
    8988                 :            : 
    8989                 :            :         /* Make sure PCI-X relaxed ordering bit is clear. */
    8990         [ #  # ]:          0 :         if (tg3_flag(tp, PCIX_MODE)) {
    8991                 :          0 :                 u16 pcix_cmd;
    8992                 :            : 
    8993                 :          0 :                 pci_read_config_word(tp->pdev, tp->pcix_cap + PCI_X_CMD,
    8994                 :            :                                      &pcix_cmd);
    8995                 :          0 :                 pcix_cmd &= ~PCI_X_CMD_ERO;
    8996                 :          0 :                 pci_write_config_word(tp->pdev, tp->pcix_cap + PCI_X_CMD,
    8997                 :            :                                       pcix_cmd);
    8998                 :            :         }
    8999                 :            : 
    9000         [ #  # ]:          0 :         if (tg3_flag(tp, 5780_CLASS)) {
    9001                 :            : 
    9002                 :            :                 /* Chip reset on 5780 will reset MSI enable bit,
    9003                 :            :                  * so need to restore it.
    9004                 :            :                  */
    9005         [ #  # ]:          0 :                 if (tg3_flag(tp, USING_MSI)) {
    9006                 :          0 :                         u16 ctrl;
    9007                 :            : 
    9008                 :          0 :                         pci_read_config_word(tp->pdev,
    9009                 :          0 :                                              tp->msi_cap + PCI_MSI_FLAGS,
    9010                 :            :                                              &ctrl);
    9011                 :          0 :                         pci_write_config_word(tp->pdev,
    9012                 :          0 :                                               tp->msi_cap + PCI_MSI_FLAGS,
    9013                 :            :                                               ctrl | PCI_MSI_FLAGS_ENABLE);
    9014                 :          0 :                         val = tr32(MSGINT_MODE);
    9015                 :          0 :                         tw32(MSGINT_MODE, val | MSGINT_MODE_ENABLE);
    9016                 :            :                 }
    9017                 :            :         }
    9018                 :          0 : }
    9019                 :            : 
    9020                 :          0 : static void tg3_override_clk(struct tg3 *tp)
    9021                 :            : {
    9022                 :          0 :         u32 val;
    9023                 :            : 
    9024      [ #  #  # ]:          0 :         switch (tg3_asic_rev(tp)) {
    9025                 :          0 :         case ASIC_REV_5717:
    9026                 :          0 :                 val = tr32(TG3_CPMU_CLCK_ORIDE_ENABLE);
    9027                 :          0 :                 tw32(TG3_CPMU_CLCK_ORIDE_ENABLE, val |
    9028                 :            :                      TG3_CPMU_MAC_ORIDE_ENABLE);
    9029                 :          0 :                 break;
    9030                 :            : 
    9031                 :          0 :         case ASIC_REV_5719:
    9032                 :            :         case ASIC_REV_5720:
    9033                 :          0 :                 tw32(TG3_CPMU_CLCK_ORIDE, CPMU_CLCK_ORIDE_MAC_ORIDE_EN);
    9034                 :          0 :                 break;
    9035                 :            : 
    9036                 :            :         default:
    9037                 :            :                 return;
    9038                 :            :         }
    9039                 :            : }
    9040                 :            : 
    9041                 :          0 : static void tg3_restore_clk(struct tg3 *tp)
    9042                 :            : {
    9043                 :          0 :         u32 val;
    9044                 :            : 
    9045      [ #  #  # ]:          0 :         switch (tg3_asic_rev(tp)) {
    9046                 :          0 :         case ASIC_REV_5717:
    9047                 :          0 :                 val = tr32(TG3_CPMU_CLCK_ORIDE_ENABLE);
    9048                 :          0 :                 tw32(TG3_CPMU_CLCK_ORIDE_ENABLE,
    9049                 :            :                      val & ~TG3_CPMU_MAC_ORIDE_ENABLE);
    9050                 :          0 :                 break;
    9051                 :            : 
    9052                 :          0 :         case ASIC_REV_5719:
    9053                 :            :         case ASIC_REV_5720:
    9054                 :          0 :                 val = tr32(TG3_CPMU_CLCK_ORIDE);
    9055                 :          0 :                 tw32(TG3_CPMU_CLCK_ORIDE, val & ~CPMU_CLCK_ORIDE_MAC_ORIDE_EN);
    9056                 :          0 :                 break;
    9057                 :            : 
    9058                 :            :         default:
    9059                 :            :                 return;
    9060                 :            :         }
    9061                 :            : }
    9062                 :            : 
    9063                 :            : /* tp->lock is held. */
    9064                 :          0 : static int tg3_chip_reset(struct tg3 *tp)
    9065                 :            :         __releases(tp->lock)
    9066                 :            :         __acquires(tp->lock)
    9067                 :            : {
    9068                 :          0 :         u32 val;
    9069                 :          0 :         void (*write_op)(struct tg3 *, u32, u32);
    9070                 :          0 :         int i, err;
    9071                 :            : 
    9072         [ #  # ]:          0 :         if (!pci_device_is_present(tp->pdev))
    9073                 :            :                 return -ENODEV;
    9074                 :            : 
    9075                 :          0 :         tg3_nvram_lock(tp);
    9076                 :            : 
    9077                 :          0 :         tg3_ape_lock(tp, TG3_APE_LOCK_GRC);
    9078                 :            : 
    9079                 :            :         /* No matching tg3_nvram_unlock() after this because
    9080                 :            :          * chip reset below will undo the nvram lock.
    9081                 :            :          */
    9082                 :          0 :         tp->nvram_lock_cnt = 0;
    9083                 :            : 
    9084                 :            :         /* GRC_MISC_CFG core clock reset will clear the memory
    9085                 :            :          * enable bit in PCI register 4 and the MSI enable bit
    9086                 :            :          * on some chips, so we save relevant registers here.
    9087                 :            :          */
    9088                 :          0 :         tg3_save_pci_state(tp);
    9089                 :            : 
    9090   [ #  #  #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5752 ||
    9091                 :          0 :             tg3_flag(tp, 5755_PLUS))
    9092                 :          0 :                 tw32(GRC_FASTBOOT_PC, 0);
    9093                 :            : 
    9094                 :            :         /*
    9095                 :            :          * We must avoid the readl() that normally takes place.
    9096                 :            :          * It locks machines, causes machine checks, and other
    9097                 :            :          * fun things.  So, temporarily disable the 5701
    9098                 :            :          * hardware workaround, while we do the reset.
    9099                 :            :          */
    9100                 :          0 :         write_op = tp->write32;
    9101         [ #  # ]:          0 :         if (write_op == tg3_write_flush_reg32)
    9102                 :          0 :                 tp->write32 = tg3_write32;
    9103                 :            : 
    9104                 :            :         /* Prevent the irq handler from reading or writing PCI registers
    9105                 :            :          * during chip reset when the memory enable bit in the PCI command
    9106                 :            :          * register may be cleared.  The chip does not generate interrupt
    9107                 :            :          * at this time, but the irq handler may still be called due to irq
    9108                 :            :          * sharing or irqpoll.
    9109                 :            :          */
    9110                 :          0 :         tg3_flag_set(tp, CHIP_RESETTING);
    9111         [ #  # ]:          0 :         for (i = 0; i < tp->irq_cnt; i++) {
    9112                 :          0 :                 struct tg3_napi *tnapi = &tp->napi[i];
    9113         [ #  # ]:          0 :                 if (tnapi->hw_status) {
    9114                 :          0 :                         tnapi->hw_status->status = 0;
    9115                 :          0 :                         tnapi->hw_status->status_tag = 0;
    9116                 :            :                 }
    9117                 :          0 :                 tnapi->last_tag = 0;
    9118                 :          0 :                 tnapi->last_irq_tag = 0;
    9119                 :            :         }
    9120                 :          0 :         smp_mb();
    9121                 :            : 
    9122                 :          0 :         tg3_full_unlock(tp);
    9123                 :            : 
    9124         [ #  # ]:          0 :         for (i = 0; i < tp->irq_cnt; i++)
    9125                 :          0 :                 synchronize_irq(tp->napi[i].irq_vec);
    9126                 :            : 
    9127                 :          0 :         tg3_full_lock(tp, 0);
    9128                 :            : 
    9129         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_57780) {
    9130                 :          0 :                 val = tr32(TG3_PCIE_LNKCTL) & ~TG3_PCIE_LNKCTL_L1_PLL_PD_EN;
    9131                 :          0 :                 tw32(TG3_PCIE_LNKCTL, val | TG3_PCIE_LNKCTL_L1_PLL_PD_DIS);
    9132                 :            :         }
    9133                 :            : 
    9134                 :            :         /* do the reset */
    9135                 :          0 :         val = GRC_MISC_CFG_CORECLK_RESET;
    9136                 :            : 
    9137         [ #  # ]:          0 :         if (tg3_flag(tp, PCI_EXPRESS)) {
    9138                 :            :                 /* Force PCIe 1.0a mode */
    9139   [ #  #  #  # ]:          0 :                 if (tg3_asic_rev(tp) != ASIC_REV_5785 &&
    9140         [ #  # ]:          0 :                     !tg3_flag(tp, 57765_PLUS) &&
    9141                 :          0 :                     tr32(TG3_PCIE_PHY_TSTCTL) ==
    9142                 :            :                     (TG3_PCIE_PHY_TSTCTL_PCIE10 | TG3_PCIE_PHY_TSTCTL_PSCRAM))
    9143                 :          0 :                         tw32(TG3_PCIE_PHY_TSTCTL, TG3_PCIE_PHY_TSTCTL_PSCRAM);
    9144                 :            : 
    9145         [ #  # ]:          0 :                 if (tg3_chip_rev_id(tp) != CHIPREV_ID_5750_A0) {
    9146                 :          0 :                         tw32(GRC_MISC_CFG, (1 << 29));
    9147                 :          0 :                         val |= (1 << 29);
    9148                 :            :                 }
    9149                 :            :         }
    9150                 :            : 
    9151         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5906) {
    9152                 :          0 :                 tw32(VCPU_STATUS, tr32(VCPU_STATUS) | VCPU_STATUS_DRV_RESET);
    9153                 :          0 :                 tw32(GRC_VCPU_EXT_CTRL,
    9154                 :            :                      tr32(GRC_VCPU_EXT_CTRL) & ~GRC_VCPU_EXT_CTRL_HALT_CPU);
    9155                 :            :         }
    9156                 :            : 
    9157                 :            :         /* Set the clock to the highest frequency to avoid timeouts. With link
    9158                 :            :          * aware mode, the clock speed could be slow and bootcode does not
    9159                 :            :          * complete within the expected time. Override the clock to allow the
    9160                 :            :          * bootcode to finish sooner and then restore it.
    9161                 :            :          */
    9162                 :          0 :         tg3_override_clk(tp);
    9163                 :            : 
    9164                 :            :         /* Manage gphy power for all CPMU absent PCIe devices. */
    9165   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, 5705_PLUS) && !tg3_flag(tp, CPMU_PRESENT))
    9166                 :          0 :                 val |= GRC_MISC_CFG_KEEP_GPHY_POWER;
    9167                 :            : 
    9168                 :          0 :         tw32(GRC_MISC_CFG, val);
    9169                 :            : 
    9170                 :            :         /* restore 5701 hardware bug workaround write method */
    9171                 :          0 :         tp->write32 = write_op;
    9172                 :            : 
    9173                 :            :         /* Unfortunately, we have to delay before the PCI read back.
    9174                 :            :          * Some 575X chips even will not respond to a PCI cfg access
    9175                 :            :          * when the reset command is given to the chip.
    9176                 :            :          *
    9177                 :            :          * How do these hardware designers expect things to work
    9178                 :            :          * properly if the PCI write is posted for a long period
    9179                 :            :          * of time?  It is always necessary to have some method by
    9180                 :            :          * which a register read back can occur to push the write
    9181                 :            :          * out which does the reset.
    9182                 :            :          *
    9183                 :            :          * For most tg3 variants the trick below was working.
    9184                 :            :          * Ho hum...
    9185                 :            :          */
    9186                 :          0 :         udelay(120);
    9187                 :            : 
    9188                 :            :         /* Flush PCI posted writes.  The normal MMIO registers
    9189                 :            :          * are inaccessible at this time so this is the only
    9190                 :            :          * way to make this reliably (actually, this is no longer
    9191                 :            :          * the case, see above).  I tried to use indirect
    9192                 :            :          * register read/write but this upset some 5701 variants.
    9193                 :            :          */
    9194                 :          0 :         pci_read_config_dword(tp->pdev, PCI_COMMAND, &val);
    9195                 :            : 
    9196                 :          0 :         udelay(120);
    9197                 :            : 
    9198   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, PCI_EXPRESS) && pci_is_pcie(tp->pdev)) {
    9199                 :          0 :                 u16 val16;
    9200                 :            : 
    9201         [ #  # ]:          0 :                 if (tg3_chip_rev_id(tp) == CHIPREV_ID_5750_A0) {
    9202                 :            :                         int j;
    9203                 :            :                         u32 cfg_val;
    9204                 :            : 
    9205                 :            :                         /* Wait for link training to complete.  */
    9206         [ #  # ]:          0 :                         for (j = 0; j < 5000; j++)
    9207                 :          0 :                                 udelay(100);
    9208                 :            : 
    9209                 :          0 :                         pci_read_config_dword(tp->pdev, 0xc4, &cfg_val);
    9210                 :          0 :                         pci_write_config_dword(tp->pdev, 0xc4,
    9211                 :            :                                                cfg_val | (1 << 15));
    9212                 :            :                 }
    9213                 :            : 
    9214                 :            :                 /* Clear the "no snoop" and "relaxed ordering" bits. */
    9215                 :          0 :                 val16 = PCI_EXP_DEVCTL_RELAX_EN | PCI_EXP_DEVCTL_NOSNOOP_EN;
    9216                 :            :                 /*
    9217                 :            :                  * Older PCIe devices only support the 128 byte
    9218                 :            :                  * MPS setting.  Enforce the restriction.
    9219                 :            :                  */
    9220         [ #  # ]:          0 :                 if (!tg3_flag(tp, CPMU_PRESENT))
    9221                 :          0 :                         val16 |= PCI_EXP_DEVCTL_PAYLOAD;
    9222                 :          0 :                 pcie_capability_clear_word(tp->pdev, PCI_EXP_DEVCTL, val16);
    9223                 :            : 
    9224                 :            :                 /* Clear error status */
    9225                 :          0 :                 pcie_capability_write_word(tp->pdev, PCI_EXP_DEVSTA,
    9226                 :            :                                       PCI_EXP_DEVSTA_CED |
    9227                 :            :                                       PCI_EXP_DEVSTA_NFED |
    9228                 :            :                                       PCI_EXP_DEVSTA_FED |
    9229                 :            :                                       PCI_EXP_DEVSTA_URD);
    9230                 :            :         }
    9231                 :            : 
    9232                 :          0 :         tg3_restore_pci_state(tp);
    9233                 :            : 
    9234                 :          0 :         tg3_flag_clear(tp, CHIP_RESETTING);
    9235                 :          0 :         tg3_flag_clear(tp, ERROR_PROCESSED);
    9236                 :            : 
    9237                 :          0 :         val = 0;
    9238         [ #  # ]:          0 :         if (tg3_flag(tp, 5780_CLASS))
    9239                 :          0 :                 val = tr32(MEMARB_MODE);
    9240                 :          0 :         tw32(MEMARB_MODE, val | MEMARB_MODE_ENABLE);
    9241                 :            : 
    9242         [ #  # ]:          0 :         if (tg3_chip_rev_id(tp) == CHIPREV_ID_5750_A3) {
    9243                 :          0 :                 tg3_stop_fw(tp);
    9244                 :          0 :                 tw32(0x5000, 0x400);
    9245                 :            :         }
    9246                 :            : 
    9247         [ #  # ]:          0 :         if (tg3_flag(tp, IS_SSB_CORE)) {
    9248                 :            :                 /*
    9249                 :            :                  * BCM4785: In order to avoid repercussions from using
    9250                 :            :                  * potentially defective internal ROM, stop the Rx RISC CPU,
    9251                 :            :                  * which is not required.
    9252                 :            :                  */
    9253                 :          0 :                 tg3_stop_fw(tp);
    9254                 :          0 :                 tg3_halt_cpu(tp, RX_CPU_BASE);
    9255                 :            :         }
    9256                 :            : 
    9257                 :          0 :         err = tg3_poll_fw(tp);
    9258         [ #  # ]:          0 :         if (err)
    9259                 :            :                 return err;
    9260                 :            : 
    9261                 :          0 :         tw32(GRC_MODE, tp->grc_mode);
    9262                 :            : 
    9263         [ #  # ]:          0 :         if (tg3_chip_rev_id(tp) == CHIPREV_ID_5705_A0) {
    9264                 :          0 :                 val = tr32(0xc4);
    9265                 :            : 
    9266                 :          0 :                 tw32(0xc4, val | (1 << 15));
    9267                 :            :         }
    9268                 :            : 
    9269         [ #  # ]:          0 :         if ((tp->nic_sram_data_cfg & NIC_SRAM_DATA_CFG_MINI_PCI) != 0 &&
    9270         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5705) {
    9271                 :          0 :                 tp->pci_clock_ctrl |= CLOCK_CTRL_CLKRUN_OENABLE;
    9272         [ #  # ]:          0 :                 if (tg3_chip_rev_id(tp) == CHIPREV_ID_5705_A0)
    9273                 :          0 :                         tp->pci_clock_ctrl |= CLOCK_CTRL_FORCE_CLKRUN;
    9274                 :          0 :                 tw32(TG3PCI_CLOCK_CTRL, tp->pci_clock_ctrl);
    9275                 :            :         }
    9276                 :            : 
    9277         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_PHY_SERDES) {
    9278                 :          0 :                 tp->mac_mode = MAC_MODE_PORT_MODE_TBI;
    9279                 :          0 :                 val = tp->mac_mode;
    9280         [ #  # ]:          0 :         } else if (tp->phy_flags & TG3_PHYFLG_MII_SERDES) {
    9281                 :          0 :                 tp->mac_mode = MAC_MODE_PORT_MODE_GMII;
    9282                 :          0 :                 val = tp->mac_mode;
    9283                 :            :         } else
    9284                 :          0 :                 val = 0;
    9285                 :            : 
    9286                 :          0 :         tw32_f(MAC_MODE, val);
    9287                 :          0 :         udelay(40);
    9288                 :            : 
    9289                 :          0 :         tg3_ape_unlock(tp, TG3_APE_LOCK_GRC);
    9290                 :            : 
    9291                 :          0 :         tg3_mdio_start(tp);
    9292                 :            : 
    9293         [ #  # ]:          0 :         if (tg3_flag(tp, PCI_EXPRESS) &&
    9294         [ #  # ]:          0 :             tg3_chip_rev_id(tp) != CHIPREV_ID_5750_A0 &&
    9295   [ #  #  #  # ]:          0 :             tg3_asic_rev(tp) != ASIC_REV_5785 &&
    9296                 :            :             !tg3_flag(tp, 57765_PLUS)) {
    9297                 :          0 :                 val = tr32(0x7c00);
    9298                 :            : 
    9299                 :          0 :                 tw32(0x7c00, val | (1 << 25));
    9300                 :            :         }
    9301                 :            : 
    9302                 :          0 :         tg3_restore_clk(tp);
    9303                 :            : 
    9304                 :            :         /* Increase the core clock speed to fix tx timeout issue for 5762
    9305                 :            :          * with 100Mbps link speed.
    9306                 :            :          */
    9307         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5762) {
    9308                 :          0 :                 val = tr32(TG3_CPMU_CLCK_ORIDE_ENABLE);
    9309                 :          0 :                 tw32(TG3_CPMU_CLCK_ORIDE_ENABLE, val |
    9310                 :            :                      TG3_CPMU_MAC_ORIDE_ENABLE);
    9311                 :            :         }
    9312                 :            : 
    9313                 :            :         /* Reprobe ASF enable state.  */
    9314                 :          0 :         tg3_flag_clear(tp, ENABLE_ASF);
    9315                 :          0 :         tp->phy_flags &= ~(TG3_PHYFLG_1G_ON_VAUX_OK |
    9316                 :            :                            TG3_PHYFLG_KEEP_LINK_ON_PWRDN);
    9317                 :            : 
    9318                 :          0 :         tg3_flag_clear(tp, ASF_NEW_HANDSHAKE);
    9319                 :          0 :         tg3_read_mem(tp, NIC_SRAM_DATA_SIG, &val);
    9320         [ #  # ]:          0 :         if (val == NIC_SRAM_DATA_SIG_MAGIC) {
    9321                 :          0 :                 u32 nic_cfg;
    9322                 :            : 
    9323                 :          0 :                 tg3_read_mem(tp, NIC_SRAM_DATA_CFG, &nic_cfg);
    9324         [ #  # ]:          0 :                 if (nic_cfg & NIC_SRAM_DATA_CFG_ASF_ENABLE) {
    9325                 :          0 :                         tg3_flag_set(tp, ENABLE_ASF);
    9326                 :          0 :                         tp->last_event_jiffies = jiffies;
    9327         [ #  # ]:          0 :                         if (tg3_flag(tp, 5750_PLUS))
    9328                 :          0 :                                 tg3_flag_set(tp, ASF_NEW_HANDSHAKE);
    9329                 :            : 
    9330                 :          0 :                         tg3_read_mem(tp, NIC_SRAM_DATA_CFG_3, &nic_cfg);
    9331         [ #  # ]:          0 :                         if (nic_cfg & NIC_SRAM_1G_ON_VAUX_OK)
    9332                 :          0 :                                 tp->phy_flags |= TG3_PHYFLG_1G_ON_VAUX_OK;
    9333         [ #  # ]:          0 :                         if (nic_cfg & NIC_SRAM_LNK_FLAP_AVOID)
    9334                 :          0 :                                 tp->phy_flags |= TG3_PHYFLG_KEEP_LINK_ON_PWRDN;
    9335                 :            :                 }
    9336                 :            :         }
    9337                 :            : 
    9338                 :            :         return 0;
    9339                 :            : }
    9340                 :            : 
    9341                 :            : static void tg3_get_nstats(struct tg3 *, struct rtnl_link_stats64 *);
    9342                 :            : static void tg3_get_estats(struct tg3 *, struct tg3_ethtool_stats *);
    9343                 :            : static void __tg3_set_rx_mode(struct net_device *);
    9344                 :            : 
    9345                 :            : /* tp->lock is held. */
    9346                 :          0 : static int tg3_halt(struct tg3 *tp, int kind, bool silent)
    9347                 :            : {
    9348                 :          0 :         int err;
    9349                 :            : 
    9350                 :          0 :         tg3_stop_fw(tp);
    9351                 :            : 
    9352                 :          0 :         tg3_write_sig_pre_reset(tp, kind);
    9353                 :            : 
    9354                 :          0 :         tg3_abort_hw(tp, silent);
    9355                 :          0 :         err = tg3_chip_reset(tp);
    9356                 :            : 
    9357                 :          0 :         __tg3_set_mac_addr(tp, false);
    9358                 :            : 
    9359                 :          0 :         tg3_write_sig_legacy(tp, kind);
    9360                 :          0 :         tg3_write_sig_post_reset(tp, kind);
    9361                 :            : 
    9362         [ #  # ]:          0 :         if (tp->hw_stats) {
    9363                 :            :                 /* Save the stats across chip resets... */
    9364                 :          0 :                 tg3_get_nstats(tp, &tp->net_stats_prev);
    9365                 :          0 :                 tg3_get_estats(tp, &tp->estats_prev);
    9366                 :            : 
    9367                 :            :                 /* And make sure the next sample is new data */
    9368                 :          0 :                 memset(tp->hw_stats, 0, sizeof(struct tg3_hw_stats));
    9369                 :            :         }
    9370                 :            : 
    9371                 :          0 :         return err;
    9372                 :            : }
    9373                 :            : 
    9374                 :          0 : static int tg3_set_mac_addr(struct net_device *dev, void *p)
    9375                 :            : {
    9376         [ #  # ]:          0 :         struct tg3 *tp = netdev_priv(dev);
    9377                 :          0 :         struct sockaddr *addr = p;
    9378                 :          0 :         int err = 0;
    9379                 :          0 :         bool skip_mac_1 = false;
    9380                 :            : 
    9381   [ #  #  #  # ]:          0 :         if (!is_valid_ether_addr(addr->sa_data))
    9382                 :            :                 return -EADDRNOTAVAIL;
    9383                 :            : 
    9384                 :          0 :         memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
    9385                 :            : 
    9386         [ #  # ]:          0 :         if (!netif_running(dev))
    9387                 :            :                 return 0;
    9388                 :            : 
    9389         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_ASF)) {
    9390                 :          0 :                 u32 addr0_high, addr0_low, addr1_high, addr1_low;
    9391                 :            : 
    9392                 :          0 :                 addr0_high = tr32(MAC_ADDR_0_HIGH);
    9393                 :          0 :                 addr0_low = tr32(MAC_ADDR_0_LOW);
    9394                 :          0 :                 addr1_high = tr32(MAC_ADDR_1_HIGH);
    9395                 :          0 :                 addr1_low = tr32(MAC_ADDR_1_LOW);
    9396                 :            : 
    9397                 :            :                 /* Skip MAC addr 1 if ASF is using it. */
    9398         [ #  # ]:          0 :                 if ((addr0_high != addr1_high || addr0_low != addr1_low) &&
    9399         [ #  # ]:          0 :                     !(addr1_high == 0 && addr1_low == 0))
    9400                 :          0 :                         skip_mac_1 = true;
    9401                 :            :         }
    9402                 :          0 :         spin_lock_bh(&tp->lock);
    9403                 :          0 :         __tg3_set_mac_addr(tp, skip_mac_1);
    9404                 :          0 :         __tg3_set_rx_mode(dev);
    9405                 :          0 :         spin_unlock_bh(&tp->lock);
    9406                 :            : 
    9407                 :          0 :         return err;
    9408                 :            : }
    9409                 :            : 
    9410                 :            : /* tp->lock is held. */
    9411                 :          0 : static void tg3_set_bdinfo(struct tg3 *tp, u32 bdinfo_addr,
    9412                 :            :                            dma_addr_t mapping, u32 maxlen_flags,
    9413                 :            :                            u32 nic_addr)
    9414                 :            : {
    9415                 :          0 :         tg3_write_mem(tp,
    9416                 :            :                       (bdinfo_addr + TG3_BDINFO_HOST_ADDR + TG3_64BIT_REG_HIGH),
    9417                 :          0 :                       ((u64) mapping >> 32));
    9418                 :          0 :         tg3_write_mem(tp,
    9419                 :            :                       (bdinfo_addr + TG3_BDINFO_HOST_ADDR + TG3_64BIT_REG_LOW),
    9420                 :            :                       ((u64) mapping & 0xffffffff));
    9421                 :          0 :         tg3_write_mem(tp,
    9422                 :            :                       (bdinfo_addr + TG3_BDINFO_MAXLEN_FLAGS),
    9423                 :            :                        maxlen_flags);
    9424                 :            : 
    9425         [ #  # ]:          0 :         if (!tg3_flag(tp, 5705_PLUS))
    9426                 :          0 :                 tg3_write_mem(tp,
    9427                 :            :                               (bdinfo_addr + TG3_BDINFO_NIC_ADDR),
    9428                 :            :                               nic_addr);
    9429                 :          0 : }
    9430                 :            : 
    9431                 :            : 
    9432                 :          0 : static void tg3_coal_tx_init(struct tg3 *tp, struct ethtool_coalesce *ec)
    9433                 :            : {
    9434                 :          0 :         int i = 0;
    9435                 :            : 
    9436         [ #  # ]:          0 :         if (!tg3_flag(tp, ENABLE_TSS)) {
    9437                 :          0 :                 tw32(HOSTCC_TXCOL_TICKS, ec->tx_coalesce_usecs);
    9438                 :          0 :                 tw32(HOSTCC_TXMAX_FRAMES, ec->tx_max_coalesced_frames);
    9439                 :          0 :                 tw32(HOSTCC_TXCOAL_MAXF_INT, ec->tx_max_coalesced_frames_irq);
    9440                 :            :         } else {
    9441                 :          0 :                 tw32(HOSTCC_TXCOL_TICKS, 0);
    9442                 :          0 :                 tw32(HOSTCC_TXMAX_FRAMES, 0);
    9443                 :          0 :                 tw32(HOSTCC_TXCOAL_MAXF_INT, 0);
    9444                 :            : 
    9445         [ #  # ]:          0 :                 for (; i < tp->txq_cnt; i++) {
    9446                 :          0 :                         u32 reg;
    9447                 :            : 
    9448                 :          0 :                         reg = HOSTCC_TXCOL_TICKS_VEC1 + i * 0x18;
    9449                 :          0 :                         tw32(reg, ec->tx_coalesce_usecs);
    9450                 :          0 :                         reg = HOSTCC_TXMAX_FRAMES_VEC1 + i * 0x18;
    9451                 :          0 :                         tw32(reg, ec->tx_max_coalesced_frames);
    9452                 :          0 :                         reg = HOSTCC_TXCOAL_MAXF_INT_VEC1 + i * 0x18;
    9453                 :          0 :                         tw32(reg, ec->tx_max_coalesced_frames_irq);
    9454                 :            :                 }
    9455                 :            :         }
    9456                 :            : 
    9457         [ #  # ]:          0 :         for (; i < tp->irq_max - 1; i++) {
    9458                 :          0 :                 tw32(HOSTCC_TXCOL_TICKS_VEC1 + i * 0x18, 0);
    9459                 :          0 :                 tw32(HOSTCC_TXMAX_FRAMES_VEC1 + i * 0x18, 0);
    9460                 :          0 :                 tw32(HOSTCC_TXCOAL_MAXF_INT_VEC1 + i * 0x18, 0);
    9461                 :            :         }
    9462                 :          0 : }
    9463                 :            : 
    9464                 :          0 : static void tg3_coal_rx_init(struct tg3 *tp, struct ethtool_coalesce *ec)
    9465                 :            : {
    9466                 :          0 :         int i = 0;
    9467                 :          0 :         u32 limit = tp->rxq_cnt;
    9468                 :            : 
    9469         [ #  # ]:          0 :         if (!tg3_flag(tp, ENABLE_RSS)) {
    9470                 :          0 :                 tw32(HOSTCC_RXCOL_TICKS, ec->rx_coalesce_usecs);
    9471                 :          0 :                 tw32(HOSTCC_RXMAX_FRAMES, ec->rx_max_coalesced_frames);
    9472                 :          0 :                 tw32(HOSTCC_RXCOAL_MAXF_INT, ec->rx_max_coalesced_frames_irq);
    9473                 :          0 :                 limit--;
    9474                 :            :         } else {
    9475                 :          0 :                 tw32(HOSTCC_RXCOL_TICKS, 0);
    9476                 :          0 :                 tw32(HOSTCC_RXMAX_FRAMES, 0);
    9477                 :          0 :                 tw32(HOSTCC_RXCOAL_MAXF_INT, 0);
    9478                 :            :         }
    9479                 :            : 
    9480         [ #  # ]:          0 :         for (; i < limit; i++) {
    9481                 :          0 :                 u32 reg;
    9482                 :            : 
    9483                 :          0 :                 reg = HOSTCC_RXCOL_TICKS_VEC1 + i * 0x18;
    9484                 :          0 :                 tw32(reg, ec->rx_coalesce_usecs);
    9485                 :          0 :                 reg = HOSTCC_RXMAX_FRAMES_VEC1 + i * 0x18;
    9486                 :          0 :                 tw32(reg, ec->rx_max_coalesced_frames);
    9487                 :          0 :                 reg = HOSTCC_RXCOAL_MAXF_INT_VEC1 + i * 0x18;
    9488                 :          0 :                 tw32(reg, ec->rx_max_coalesced_frames_irq);
    9489                 :            :         }
    9490                 :            : 
    9491         [ #  # ]:          0 :         for (; i < tp->irq_max - 1; i++) {
    9492                 :          0 :                 tw32(HOSTCC_RXCOL_TICKS_VEC1 + i * 0x18, 0);
    9493                 :          0 :                 tw32(HOSTCC_RXMAX_FRAMES_VEC1 + i * 0x18, 0);
    9494                 :          0 :                 tw32(HOSTCC_RXCOAL_MAXF_INT_VEC1 + i * 0x18, 0);
    9495                 :            :         }
    9496                 :          0 : }
    9497                 :            : 
    9498                 :          0 : static void __tg3_set_coalesce(struct tg3 *tp, struct ethtool_coalesce *ec)
    9499                 :            : {
    9500                 :          0 :         tg3_coal_tx_init(tp, ec);
    9501                 :          0 :         tg3_coal_rx_init(tp, ec);
    9502                 :            : 
    9503         [ #  # ]:          0 :         if (!tg3_flag(tp, 5705_PLUS)) {
    9504                 :          0 :                 u32 val = ec->stats_block_coalesce_usecs;
    9505                 :            : 
    9506                 :          0 :                 tw32(HOSTCC_RXCOAL_TICK_INT, ec->rx_coalesce_usecs_irq);
    9507                 :          0 :                 tw32(HOSTCC_TXCOAL_TICK_INT, ec->tx_coalesce_usecs_irq);
    9508                 :            : 
    9509         [ #  # ]:          0 :                 if (!tp->link_up)
    9510                 :          0 :                         val = 0;
    9511                 :            : 
    9512                 :          0 :                 tw32(HOSTCC_STAT_COAL_TICKS, val);
    9513                 :            :         }
    9514                 :          0 : }
    9515                 :            : 
    9516                 :            : /* tp->lock is held. */
    9517                 :          0 : static void tg3_tx_rcbs_disable(struct tg3 *tp)
    9518                 :            : {
    9519                 :          0 :         u32 txrcb, limit;
    9520                 :            : 
    9521                 :            :         /* Disable all transmit rings but the first. */
    9522         [ #  # ]:          0 :         if (!tg3_flag(tp, 5705_PLUS))
    9523                 :            :                 limit = NIC_SRAM_SEND_RCB + TG3_BDINFO_SIZE * 16;
    9524         [ #  # ]:          0 :         else if (tg3_flag(tp, 5717_PLUS))
    9525                 :            :                 limit = NIC_SRAM_SEND_RCB + TG3_BDINFO_SIZE * 4;
    9526         [ #  # ]:          0 :         else if (tg3_flag(tp, 57765_CLASS) ||
    9527         [ #  # ]:          0 :                  tg3_asic_rev(tp) == ASIC_REV_5762)
    9528                 :            :                 limit = NIC_SRAM_SEND_RCB + TG3_BDINFO_SIZE * 2;
    9529                 :            :         else
    9530                 :          0 :                 limit = NIC_SRAM_SEND_RCB + TG3_BDINFO_SIZE;
    9531                 :            : 
    9532                 :          0 :         for (txrcb = NIC_SRAM_SEND_RCB + TG3_BDINFO_SIZE;
    9533         [ #  # ]:          0 :              txrcb < limit; txrcb += TG3_BDINFO_SIZE)
    9534                 :          0 :                 tg3_write_mem(tp, txrcb + TG3_BDINFO_MAXLEN_FLAGS,
    9535                 :            :                               BDINFO_FLAGS_DISABLED);
    9536                 :          0 : }
    9537                 :            : 
    9538                 :            : /* tp->lock is held. */
    9539                 :          0 : static void tg3_tx_rcbs_init(struct tg3 *tp)
    9540                 :            : {
    9541                 :          0 :         int i = 0;
    9542                 :          0 :         u32 txrcb = NIC_SRAM_SEND_RCB;
    9543                 :            : 
    9544         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_TSS))
    9545                 :          0 :                 i++;
    9546                 :            : 
    9547         [ #  # ]:          0 :         for (; i < tp->irq_max; i++, txrcb += TG3_BDINFO_SIZE) {
    9548                 :          0 :                 struct tg3_napi *tnapi = &tp->napi[i];
    9549                 :            : 
    9550         [ #  # ]:          0 :                 if (!tnapi->tx_ring)
    9551                 :          0 :                         continue;
    9552                 :            : 
    9553                 :          0 :                 tg3_set_bdinfo(tp, txrcb, tnapi->tx_desc_mapping,
    9554                 :            :                                (TG3_TX_RING_SIZE << BDINFO_FLAGS_MAXLEN_SHIFT),
    9555                 :            :                                NIC_SRAM_TX_BUFFER_DESC);
    9556                 :            :         }
    9557                 :          0 : }
    9558                 :            : 
    9559                 :            : /* tp->lock is held. */
    9560                 :          0 : static void tg3_rx_ret_rcbs_disable(struct tg3 *tp)
    9561                 :            : {
    9562                 :          0 :         u32 rxrcb, limit;
    9563                 :            : 
    9564                 :            :         /* Disable all receive return rings but the first. */
    9565         [ #  # ]:          0 :         if (tg3_flag(tp, 5717_PLUS))
    9566                 :            :                 limit = NIC_SRAM_RCV_RET_RCB + TG3_BDINFO_SIZE * 17;
    9567         [ #  # ]:          0 :         else if (!tg3_flag(tp, 5705_PLUS))
    9568                 :            :                 limit = NIC_SRAM_RCV_RET_RCB + TG3_BDINFO_SIZE * 16;
    9569         [ #  # ]:          0 :         else if (tg3_asic_rev(tp) == ASIC_REV_5755 ||
    9570         [ #  # ]:          0 :                  tg3_asic_rev(tp) == ASIC_REV_5762 ||
    9571                 :            :                  tg3_flag(tp, 57765_CLASS))
    9572                 :            :                 limit = NIC_SRAM_RCV_RET_RCB + TG3_BDINFO_SIZE * 4;
    9573                 :            :         else
    9574                 :            :                 limit = NIC_SRAM_RCV_RET_RCB + TG3_BDINFO_SIZE;
    9575                 :            : 
    9576                 :          0 :         for (rxrcb = NIC_SRAM_RCV_RET_RCB + TG3_BDINFO_SIZE;
    9577         [ #  # ]:          0 :              rxrcb < limit; rxrcb += TG3_BDINFO_SIZE)
    9578                 :          0 :                 tg3_write_mem(tp, rxrcb + TG3_BDINFO_MAXLEN_FLAGS,
    9579                 :            :                               BDINFO_FLAGS_DISABLED);
    9580                 :          0 : }
    9581                 :            : 
    9582                 :            : /* tp->lock is held. */
    9583                 :          0 : static void tg3_rx_ret_rcbs_init(struct tg3 *tp)
    9584                 :            : {
    9585                 :          0 :         int i = 0;
    9586                 :          0 :         u32 rxrcb = NIC_SRAM_RCV_RET_RCB;
    9587                 :            : 
    9588         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_RSS))
    9589                 :          0 :                 i++;
    9590                 :            : 
    9591         [ #  # ]:          0 :         for (; i < tp->irq_max; i++, rxrcb += TG3_BDINFO_SIZE) {
    9592                 :          0 :                 struct tg3_napi *tnapi = &tp->napi[i];
    9593                 :            : 
    9594         [ #  # ]:          0 :                 if (!tnapi->rx_rcb)
    9595                 :          0 :                         continue;
    9596                 :            : 
    9597                 :          0 :                 tg3_set_bdinfo(tp, rxrcb, tnapi->rx_rcb_mapping,
    9598                 :          0 :                                (tp->rx_ret_ring_mask + 1) <<
    9599                 :            :                                 BDINFO_FLAGS_MAXLEN_SHIFT, 0);
    9600                 :            :         }
    9601                 :          0 : }
    9602                 :            : 
    9603                 :            : /* tp->lock is held. */
    9604                 :          0 : static void tg3_rings_reset(struct tg3 *tp)
    9605                 :            : {
    9606                 :          0 :         int i;
    9607                 :          0 :         u32 stblk;
    9608                 :          0 :         struct tg3_napi *tnapi = &tp->napi[0];
    9609                 :            : 
    9610                 :          0 :         tg3_tx_rcbs_disable(tp);
    9611                 :            : 
    9612                 :          0 :         tg3_rx_ret_rcbs_disable(tp);
    9613                 :            : 
    9614                 :            :         /* Disable interrupts */
    9615                 :          0 :         tw32_mailbox_f(tp->napi[0].int_mbox, 1);
    9616                 :          0 :         tp->napi[0].chk_msi_cnt = 0;
    9617                 :          0 :         tp->napi[0].last_rx_cons = 0;
    9618                 :          0 :         tp->napi[0].last_tx_cons = 0;
    9619                 :            : 
    9620                 :            :         /* Zero mailbox registers. */
    9621         [ #  # ]:          0 :         if (tg3_flag(tp, SUPPORT_MSIX)) {
    9622         [ #  # ]:          0 :                 for (i = 1; i < tp->irq_max; i++) {
    9623                 :          0 :                         tp->napi[i].tx_prod = 0;
    9624                 :          0 :                         tp->napi[i].tx_cons = 0;
    9625         [ #  # ]:          0 :                         if (tg3_flag(tp, ENABLE_TSS))
    9626                 :          0 :                                 tw32_mailbox(tp->napi[i].prodmbox, 0);
    9627                 :          0 :                         tw32_rx_mbox(tp->napi[i].consmbox, 0);
    9628                 :          0 :                         tw32_mailbox_f(tp->napi[i].int_mbox, 1);
    9629                 :          0 :                         tp->napi[i].chk_msi_cnt = 0;
    9630                 :          0 :                         tp->napi[i].last_rx_cons = 0;
    9631                 :          0 :                         tp->napi[i].last_tx_cons = 0;
    9632                 :            :                 }
    9633         [ #  # ]:          0 :                 if (!tg3_flag(tp, ENABLE_TSS))
    9634                 :          0 :                         tw32_mailbox(tp->napi[0].prodmbox, 0);
    9635                 :            :         } else {
    9636                 :          0 :                 tp->napi[0].tx_prod = 0;
    9637                 :          0 :                 tp->napi[0].tx_cons = 0;
    9638                 :          0 :                 tw32_mailbox(tp->napi[0].prodmbox, 0);
    9639                 :          0 :                 tw32_rx_mbox(tp->napi[0].consmbox, 0);
    9640                 :            :         }
    9641                 :            : 
    9642                 :            :         /* Make sure the NIC-based send BD rings are disabled. */
    9643         [ #  # ]:          0 :         if (!tg3_flag(tp, 5705_PLUS)) {
    9644                 :            :                 u32 mbox = MAILBOX_SNDNIC_PROD_IDX_0 + TG3_64BIT_REG_LOW;
    9645         [ #  # ]:          0 :                 for (i = 0; i < 16; i++)
    9646                 :          0 :                         tw32_tx_mbox(mbox + i * 8, 0);
    9647                 :            :         }
    9648                 :            : 
    9649                 :            :         /* Clear status block in ram. */
    9650                 :          0 :         memset(tnapi->hw_status, 0, TG3_HW_STATUS_SIZE);
    9651                 :            : 
    9652                 :            :         /* Set status block DMA address */
    9653                 :          0 :         tw32(HOSTCC_STATUS_BLK_HOST_ADDR + TG3_64BIT_REG_HIGH,
    9654                 :            :              ((u64) tnapi->status_mapping >> 32));
    9655                 :          0 :         tw32(HOSTCC_STATUS_BLK_HOST_ADDR + TG3_64BIT_REG_LOW,
    9656                 :            :              ((u64) tnapi->status_mapping & 0xffffffff));
    9657                 :            : 
    9658                 :          0 :         stblk = HOSTCC_STATBLCK_RING1;
    9659                 :            : 
    9660         [ #  # ]:          0 :         for (i = 1, tnapi++; i < tp->irq_cnt; i++, tnapi++) {
    9661                 :          0 :                 u64 mapping = (u64)tnapi->status_mapping;
    9662                 :          0 :                 tw32(stblk + TG3_64BIT_REG_HIGH, mapping >> 32);
    9663                 :          0 :                 tw32(stblk + TG3_64BIT_REG_LOW, mapping & 0xffffffff);
    9664                 :          0 :                 stblk += 8;
    9665                 :            : 
    9666                 :            :                 /* Clear status block in ram. */
    9667                 :          0 :                 memset(tnapi->hw_status, 0, TG3_HW_STATUS_SIZE);
    9668                 :            :         }
    9669                 :            : 
    9670                 :          0 :         tg3_tx_rcbs_init(tp);
    9671                 :          0 :         tg3_rx_ret_rcbs_init(tp);
    9672                 :          0 : }
    9673                 :            : 
    9674                 :          0 : static void tg3_setup_rxbd_thresholds(struct tg3 *tp)
    9675                 :            : {
    9676                 :          0 :         u32 val, bdcache_maxcnt, host_rep_thresh, nic_rep_thresh;
    9677                 :            : 
    9678   [ #  #  #  # ]:          0 :         if (!tg3_flag(tp, 5750_PLUS) ||
    9679                 :          0 :             tg3_flag(tp, 5780_CLASS) ||
    9680   [ #  #  #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5750 ||
    9681         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5752 ||
    9682                 :            :             tg3_flag(tp, 57765_PLUS))
    9683                 :            :                 bdcache_maxcnt = TG3_SRAM_RX_STD_BDCACHE_SIZE_5700;
    9684         [ #  # ]:          0 :         else if (tg3_asic_rev(tp) == ASIC_REV_5755 ||
    9685                 :            :                  tg3_asic_rev(tp) == ASIC_REV_5787)
    9686                 :            :                 bdcache_maxcnt = TG3_SRAM_RX_STD_BDCACHE_SIZE_5755;
    9687                 :            :         else
    9688                 :          0 :                 bdcache_maxcnt = TG3_SRAM_RX_STD_BDCACHE_SIZE_5906;
    9689                 :            : 
    9690                 :          0 :         nic_rep_thresh = min(bdcache_maxcnt / 2, tp->rx_std_max_post);
    9691                 :          0 :         host_rep_thresh = max_t(u32, tp->rx_pending / 8, 1);
    9692                 :            : 
    9693                 :          0 :         val = min(nic_rep_thresh, host_rep_thresh);
    9694                 :          0 :         tw32(RCVBDI_STD_THRESH, val);
    9695                 :            : 
    9696         [ #  # ]:          0 :         if (tg3_flag(tp, 57765_PLUS))
    9697                 :          0 :                 tw32(STD_REPLENISH_LWM, bdcache_maxcnt);
    9698                 :            : 
    9699   [ #  #  #  # ]:          0 :         if (!tg3_flag(tp, JUMBO_CAPABLE) || tg3_flag(tp, 5780_CLASS))
    9700                 :          0 :                 return;
    9701                 :            : 
    9702                 :          0 :         bdcache_maxcnt = TG3_SRAM_RX_JMB_BDCACHE_SIZE_5700;
    9703                 :            : 
    9704                 :          0 :         host_rep_thresh = max_t(u32, tp->rx_jumbo_pending / 8, 1);
    9705                 :            : 
    9706                 :          0 :         val = min(bdcache_maxcnt / 2, host_rep_thresh);
    9707                 :          0 :         tw32(RCVBDI_JUMBO_THRESH, val);
    9708                 :            : 
    9709         [ #  # ]:          0 :         if (tg3_flag(tp, 57765_PLUS))
    9710                 :          0 :                 tw32(JMB_REPLENISH_LWM, bdcache_maxcnt);
    9711                 :            : }
    9712                 :            : 
    9713                 :          0 : static inline u32 calc_crc(unsigned char *buf, int len)
    9714                 :            : {
    9715                 :          0 :         u32 reg;
    9716                 :          0 :         u32 tmp;
    9717                 :          0 :         int j, k;
    9718                 :            : 
    9719                 :          0 :         reg = 0xffffffff;
    9720                 :            : 
    9721   [ #  #  #  #  :          0 :         for (j = 0; j < len; j++) {
                   #  # ]
    9722                 :          0 :                 reg ^= buf[j];
    9723                 :            : 
    9724   [ #  #  #  #  :          0 :                 for (k = 0; k < 8; k++) {
                   #  # ]
    9725                 :          0 :                         tmp = reg & 0x01;
    9726                 :            : 
    9727                 :          0 :                         reg >>= 1;
    9728                 :            : 
    9729   [ #  #  #  #  :          0 :                         if (tmp)
                   #  # ]
    9730                 :          0 :                                 reg ^= CRC32_POLY_LE;
    9731                 :            :                 }
    9732                 :            :         }
    9733                 :            : 
    9734                 :          0 :         return ~reg;
    9735                 :            : }
    9736                 :            : 
    9737                 :          0 : static void tg3_set_multi(struct tg3 *tp, unsigned int accept_all)
    9738                 :            : {
    9739                 :            :         /* accept or reject all multicast frames */
    9740         [ #  # ]:          0 :         tw32(MAC_HASH_REG_0, accept_all ? 0xffffffff : 0);
    9741                 :          0 :         tw32(MAC_HASH_REG_1, accept_all ? 0xffffffff : 0);
    9742                 :          0 :         tw32(MAC_HASH_REG_2, accept_all ? 0xffffffff : 0);
    9743                 :          0 :         tw32(MAC_HASH_REG_3, accept_all ? 0xffffffff : 0);
    9744                 :          0 : }
    9745                 :            : 
    9746                 :          0 : static void __tg3_set_rx_mode(struct net_device *dev)
    9747                 :            : {
    9748                 :          0 :         struct tg3 *tp = netdev_priv(dev);
    9749                 :          0 :         u32 rx_mode;
    9750                 :            : 
    9751                 :          0 :         rx_mode = tp->rx_mode & ~(RX_MODE_PROMISC |
    9752                 :            :                                   RX_MODE_KEEP_VLAN_TAG);
    9753                 :            : 
    9754                 :            : #if !defined(CONFIG_VLAN_8021Q) && !defined(CONFIG_VLAN_8021Q_MODULE)
    9755                 :            :         /* When ASF is in use, we always keep the RX_MODE_KEEP_VLAN_TAG
    9756                 :            :          * flag clear.
    9757                 :            :          */
    9758         [ #  # ]:          0 :         if (!tg3_flag(tp, ENABLE_ASF))
    9759                 :          0 :                 rx_mode |= RX_MODE_KEEP_VLAN_TAG;
    9760                 :            : #endif
    9761                 :            : 
    9762         [ #  # ]:          0 :         if (dev->flags & IFF_PROMISC) {
    9763                 :            :                 /* Promiscuous mode. */
    9764                 :          0 :                 rx_mode |= RX_MODE_PROMISC;
    9765         [ #  # ]:          0 :         } else if (dev->flags & IFF_ALLMULTI) {
    9766                 :            :                 /* Accept all multicast. */
    9767                 :          0 :                 tg3_set_multi(tp, 1);
    9768         [ #  # ]:          0 :         } else if (netdev_mc_empty(dev)) {
    9769                 :            :                 /* Reject all multicast. */
    9770                 :          0 :                 tg3_set_multi(tp, 0);
    9771                 :            :         } else {
    9772                 :            :                 /* Accept one or more multicast(s). */
    9773                 :          0 :                 struct netdev_hw_addr *ha;
    9774                 :          0 :                 u32 mc_filter[4] = { 0, };
    9775                 :          0 :                 u32 regidx;
    9776                 :          0 :                 u32 bit;
    9777                 :          0 :                 u32 crc;
    9778                 :            : 
    9779         [ #  # ]:          0 :                 netdev_for_each_mc_addr(ha, dev) {
    9780                 :          0 :                         crc = calc_crc(ha->addr, ETH_ALEN);
    9781                 :          0 :                         bit = ~crc & 0x7f;
    9782                 :          0 :                         regidx = (bit & 0x60) >> 5;
    9783                 :          0 :                         bit &= 0x1f;
    9784                 :          0 :                         mc_filter[regidx] |= (1 << bit);
    9785                 :            :                 }
    9786                 :            : 
    9787                 :          0 :                 tw32(MAC_HASH_REG_0, mc_filter[0]);
    9788                 :          0 :                 tw32(MAC_HASH_REG_1, mc_filter[1]);
    9789                 :          0 :                 tw32(MAC_HASH_REG_2, mc_filter[2]);
    9790                 :          0 :                 tw32(MAC_HASH_REG_3, mc_filter[3]);
    9791                 :            :         }
    9792                 :            : 
    9793   [ #  #  #  # ]:          0 :         if (netdev_uc_count(dev) > TG3_MAX_UCAST_ADDR(tp)) {
    9794                 :          0 :                 rx_mode |= RX_MODE_PROMISC;
    9795         [ #  # ]:          0 :         } else if (!(dev->flags & IFF_PROMISC)) {
    9796                 :            :                 /* Add all entries into to the mac addr filter list */
    9797                 :          0 :                 int i = 0;
    9798                 :          0 :                 struct netdev_hw_addr *ha;
    9799                 :            : 
    9800         [ #  # ]:          0 :                 netdev_for_each_uc_addr(ha, dev) {
    9801                 :          0 :                         __tg3_set_one_mac_addr(tp, ha->addr,
    9802         [ #  # ]:          0 :                                                i + TG3_UCAST_ADDR_IDX(tp));
    9803                 :          0 :                         i++;
    9804                 :            :                 }
    9805                 :            :         }
    9806                 :            : 
    9807         [ #  # ]:          0 :         if (rx_mode != tp->rx_mode) {
    9808                 :          0 :                 tp->rx_mode = rx_mode;
    9809                 :          0 :                 tw32_f(MAC_RX_MODE, rx_mode);
    9810                 :          0 :                 udelay(10);
    9811                 :            :         }
    9812                 :          0 : }
    9813                 :            : 
    9814                 :          0 : static void tg3_rss_init_dflt_indir_tbl(struct tg3 *tp, u32 qcnt)
    9815                 :            : {
    9816                 :          0 :         int i;
    9817                 :            : 
    9818   [ #  #  #  # ]:          0 :         for (i = 0; i < TG3_RSS_INDIR_TBL_SIZE; i++)
    9819                 :          0 :                 tp->rss_ind_tbl[i] = ethtool_rxfh_indir_default(i, qcnt);
    9820                 :            : }
    9821                 :            : 
    9822                 :          0 : static void tg3_rss_check_indir_tbl(struct tg3 *tp)
    9823                 :            : {
    9824                 :          0 :         int i;
    9825                 :            : 
    9826         [ #  # ]:          0 :         if (!tg3_flag(tp, SUPPORT_MSIX))
    9827                 :            :                 return;
    9828                 :            : 
    9829         [ #  # ]:          0 :         if (tp->rxq_cnt == 1) {
    9830                 :          0 :                 memset(&tp->rss_ind_tbl[0], 0, sizeof(tp->rss_ind_tbl));
    9831                 :          0 :                 return;
    9832                 :            :         }
    9833                 :            : 
    9834                 :            :         /* Validate table against current IRQ count */
    9835         [ #  # ]:          0 :         for (i = 0; i < TG3_RSS_INDIR_TBL_SIZE; i++) {
    9836         [ #  # ]:          0 :                 if (tp->rss_ind_tbl[i] >= tp->rxq_cnt)
    9837                 :            :                         break;
    9838                 :            :         }
    9839                 :            : 
    9840         [ #  # ]:          0 :         if (i != TG3_RSS_INDIR_TBL_SIZE)
    9841                 :            :                 tg3_rss_init_dflt_indir_tbl(tp, tp->rxq_cnt);
    9842                 :            : }
    9843                 :            : 
    9844                 :          0 : static void tg3_rss_write_indir_tbl(struct tg3 *tp)
    9845                 :            : {
    9846                 :          0 :         int i = 0;
    9847                 :          0 :         u32 reg = MAC_RSS_INDIR_TBL_0;
    9848                 :            : 
    9849         [ #  # ]:          0 :         while (i < TG3_RSS_INDIR_TBL_SIZE) {
    9850                 :          0 :                 u32 val = tp->rss_ind_tbl[i];
    9851                 :          0 :                 i++;
    9852         [ #  # ]:          0 :                 for (; i % 8; i++) {
    9853                 :          0 :                         val <<= 4;
    9854                 :          0 :                         val |= tp->rss_ind_tbl[i];
    9855                 :            :                 }
    9856                 :          0 :                 tw32(reg, val);
    9857                 :          0 :                 reg += 4;
    9858                 :            :         }
    9859                 :          0 : }
    9860                 :            : 
    9861                 :          0 : static inline u32 tg3_lso_rd_dma_workaround_bit(struct tg3 *tp)
    9862                 :            : {
    9863                 :          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5719)
    9864                 :            :                 return TG3_LSO_RD_DMA_TX_LENGTH_WA_5719;
    9865                 :            :         else
    9866                 :          0 :                 return TG3_LSO_RD_DMA_TX_LENGTH_WA_5720;
    9867                 :            : }
    9868                 :            : 
    9869                 :            : /* tp->lock is held. */
    9870                 :          0 : static int tg3_reset_hw(struct tg3 *tp, bool reset_phy)
    9871                 :            : {
    9872                 :          0 :         u32 val, rdmac_mode;
    9873                 :          0 :         int i, err, limit;
    9874                 :          0 :         struct tg3_rx_prodring_set *tpr = &tp->napi[0].prodring;
    9875                 :            : 
    9876                 :          0 :         tg3_disable_ints(tp);
    9877                 :            : 
    9878                 :          0 :         tg3_stop_fw(tp);
    9879                 :            : 
    9880                 :          0 :         tg3_write_sig_pre_reset(tp, RESET_KIND_INIT);
    9881                 :            : 
    9882         [ #  # ]:          0 :         if (tg3_flag(tp, INIT_COMPLETE))
    9883                 :          0 :                 tg3_abort_hw(tp, 1);
    9884                 :            : 
    9885         [ #  # ]:          0 :         if ((tp->phy_flags & TG3_PHYFLG_KEEP_LINK_ON_PWRDN) &&
    9886                 :            :             !(tp->phy_flags & TG3_PHYFLG_USER_CONFIGURED)) {
    9887                 :          0 :                 tg3_phy_pull_config(tp);
    9888                 :          0 :                 tg3_eee_pull_config(tp, NULL);
    9889                 :          0 :                 tp->phy_flags |= TG3_PHYFLG_USER_CONFIGURED;
    9890                 :            :         }
    9891                 :            : 
    9892                 :            :         /* Enable MAC control of LPI */
    9893         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_EEE_CAP)
    9894                 :          0 :                 tg3_setup_eee(tp);
    9895                 :            : 
    9896         [ #  # ]:          0 :         if (reset_phy)
    9897                 :          0 :                 tg3_phy_reset(tp);
    9898                 :            : 
    9899                 :          0 :         err = tg3_chip_reset(tp);
    9900         [ #  # ]:          0 :         if (err)
    9901                 :            :                 return err;
    9902                 :            : 
    9903                 :          0 :         tg3_write_sig_legacy(tp, RESET_KIND_INIT);
    9904                 :            : 
    9905         [ #  # ]:          0 :         if (tg3_chip_rev(tp) == CHIPREV_5784_AX) {
    9906                 :          0 :                 val = tr32(TG3_CPMU_CTRL);
    9907                 :          0 :                 val &= ~(CPMU_CTRL_LINK_AWARE_MODE | CPMU_CTRL_LINK_IDLE_MODE);
    9908                 :          0 :                 tw32(TG3_CPMU_CTRL, val);
    9909                 :            : 
    9910                 :          0 :                 val = tr32(TG3_CPMU_LSPD_10MB_CLK);
    9911                 :          0 :                 val &= ~CPMU_LSPD_10MB_MACCLK_MASK;
    9912                 :          0 :                 val |= CPMU_LSPD_10MB_MACCLK_6_25;
    9913                 :          0 :                 tw32(TG3_CPMU_LSPD_10MB_CLK, val);
    9914                 :            : 
    9915                 :          0 :                 val = tr32(TG3_CPMU_LNK_AWARE_PWRMD);
    9916                 :          0 :                 val &= ~CPMU_LNK_AWARE_MACCLK_MASK;
    9917                 :          0 :                 val |= CPMU_LNK_AWARE_MACCLK_6_25;
    9918                 :          0 :                 tw32(TG3_CPMU_LNK_AWARE_PWRMD, val);
    9919                 :            : 
    9920                 :          0 :                 val = tr32(TG3_CPMU_HST_ACC);
    9921                 :          0 :                 val &= ~CPMU_HST_ACC_MACCLK_MASK;
    9922                 :          0 :                 val |= CPMU_HST_ACC_MACCLK_6_25;
    9923                 :          0 :                 tw32(TG3_CPMU_HST_ACC, val);
    9924                 :            :         }
    9925                 :            : 
    9926         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_57780) {
    9927                 :          0 :                 val = tr32(PCIE_PWR_MGMT_THRESH) & ~PCIE_PWR_MGMT_L1_THRESH_MSK;
    9928                 :          0 :                 val |= PCIE_PWR_MGMT_EXT_ASPM_TMR_EN |
    9929                 :            :                        PCIE_PWR_MGMT_L1_THRESH_4MS;
    9930                 :          0 :                 tw32(PCIE_PWR_MGMT_THRESH, val);
    9931                 :            : 
    9932                 :          0 :                 val = tr32(TG3_PCIE_EIDLE_DELAY) & ~TG3_PCIE_EIDLE_DELAY_MASK;
    9933                 :          0 :                 tw32(TG3_PCIE_EIDLE_DELAY, val | TG3_PCIE_EIDLE_DELAY_13_CLKS);
    9934                 :            : 
    9935                 :          0 :                 tw32(TG3_CORR_ERR_STAT, TG3_CORR_ERR_STAT_CLEAR);
    9936                 :            : 
    9937                 :          0 :                 val = tr32(TG3_PCIE_LNKCTL) & ~TG3_PCIE_LNKCTL_L1_PLL_PD_EN;
    9938                 :          0 :                 tw32(TG3_PCIE_LNKCTL, val | TG3_PCIE_LNKCTL_L1_PLL_PD_DIS);
    9939                 :            :         }
    9940                 :            : 
    9941         [ #  # ]:          0 :         if (tg3_flag(tp, L1PLLPD_EN)) {
    9942                 :          0 :                 u32 grc_mode = tr32(GRC_MODE);
    9943                 :            : 
    9944                 :            :                 /* Access the lower 1K of PL PCIE block registers. */
    9945                 :          0 :                 val = grc_mode & ~GRC_MODE_PCIE_PORT_MASK;
    9946                 :          0 :                 tw32(GRC_MODE, val | GRC_MODE_PCIE_PL_SEL);
    9947                 :            : 
    9948                 :          0 :                 val = tr32(TG3_PCIE_TLDLPL_PORT + TG3_PCIE_PL_LO_PHYCTL1);
    9949                 :          0 :                 tw32(TG3_PCIE_TLDLPL_PORT + TG3_PCIE_PL_LO_PHYCTL1,
    9950                 :            :                      val | TG3_PCIE_PL_LO_PHYCTL1_L1PLLPD_EN);
    9951                 :            : 
    9952                 :          0 :                 tw32(GRC_MODE, grc_mode);
    9953                 :            :         }
    9954                 :            : 
    9955         [ #  # ]:          0 :         if (tg3_flag(tp, 57765_CLASS)) {
    9956         [ #  # ]:          0 :                 if (tg3_chip_rev_id(tp) == CHIPREV_ID_57765_A0) {
    9957                 :          0 :                         u32 grc_mode = tr32(GRC_MODE);
    9958                 :            : 
    9959                 :            :                         /* Access the lower 1K of PL PCIE block registers. */
    9960                 :          0 :                         val = grc_mode & ~GRC_MODE_PCIE_PORT_MASK;
    9961                 :          0 :                         tw32(GRC_MODE, val | GRC_MODE_PCIE_PL_SEL);
    9962                 :            : 
    9963                 :          0 :                         val = tr32(TG3_PCIE_TLDLPL_PORT +
    9964                 :            :                                    TG3_PCIE_PL_LO_PHYCTL5);
    9965                 :          0 :                         tw32(TG3_PCIE_TLDLPL_PORT + TG3_PCIE_PL_LO_PHYCTL5,
    9966                 :            :                              val | TG3_PCIE_PL_LO_PHYCTL5_DIS_L2CLKREQ);
    9967                 :            : 
    9968                 :          0 :                         tw32(GRC_MODE, grc_mode);
    9969                 :            :                 }
    9970                 :            : 
    9971         [ #  # ]:          0 :                 if (tg3_chip_rev(tp) != CHIPREV_57765_AX) {
    9972                 :          0 :                         u32 grc_mode;
    9973                 :            : 
    9974                 :            :                         /* Fix transmit hangs */
    9975                 :          0 :                         val = tr32(TG3_CPMU_PADRNG_CTL);
    9976                 :          0 :                         val |= TG3_CPMU_PADRNG_CTL_RDIV2;
    9977                 :          0 :                         tw32(TG3_CPMU_PADRNG_CTL, val);
    9978                 :            : 
    9979                 :          0 :                         grc_mode = tr32(GRC_MODE);
    9980                 :            : 
    9981                 :            :                         /* Access the lower 1K of DL PCIE block registers. */
    9982                 :          0 :                         val = grc_mode & ~GRC_MODE_PCIE_PORT_MASK;
    9983                 :          0 :                         tw32(GRC_MODE, val | GRC_MODE_PCIE_DL_SEL);
    9984                 :            : 
    9985                 :          0 :                         val = tr32(TG3_PCIE_TLDLPL_PORT +
    9986                 :            :                                    TG3_PCIE_DL_LO_FTSMAX);
    9987                 :          0 :                         val &= ~TG3_PCIE_DL_LO_FTSMAX_MSK;
    9988                 :          0 :                         tw32(TG3_PCIE_TLDLPL_PORT + TG3_PCIE_DL_LO_FTSMAX,
    9989                 :            :                              val | TG3_PCIE_DL_LO_FTSMAX_VAL);
    9990                 :            : 
    9991                 :          0 :                         tw32(GRC_MODE, grc_mode);
    9992                 :            :                 }
    9993                 :            : 
    9994                 :          0 :                 val = tr32(TG3_CPMU_LSPD_10MB_CLK);
    9995                 :          0 :                 val &= ~CPMU_LSPD_10MB_MACCLK_MASK;
    9996                 :          0 :                 val |= CPMU_LSPD_10MB_MACCLK_6_25;
    9997                 :          0 :                 tw32(TG3_CPMU_LSPD_10MB_CLK, val);
    9998                 :            :         }
    9999                 :            : 
   10000                 :            :         /* This works around an issue with Athlon chipsets on
   10001                 :            :          * B3 tigon3 silicon.  This bit has no effect on any
   10002                 :            :          * other revision.  But do not set this on PCI Express
   10003                 :            :          * chips and don't even touch the clocks if the CPMU is present.
   10004                 :            :          */
   10005         [ #  # ]:          0 :         if (!tg3_flag(tp, CPMU_PRESENT)) {
   10006         [ #  # ]:          0 :                 if (!tg3_flag(tp, PCI_EXPRESS))
   10007                 :          0 :                         tp->pci_clock_ctrl |= CLOCK_CTRL_DELAY_PCI_GRANT;
   10008                 :          0 :                 tw32_f(TG3PCI_CLOCK_CTRL, tp->pci_clock_ctrl);
   10009                 :            :         }
   10010                 :            : 
   10011   [ #  #  #  # ]:          0 :         if (tg3_chip_rev_id(tp) == CHIPREV_ID_5704_A0 &&
   10012                 :            :             tg3_flag(tp, PCIX_MODE)) {
   10013                 :          0 :                 val = tr32(TG3PCI_PCISTATE);
   10014                 :          0 :                 val |= PCISTATE_RETRY_SAME_DMA;
   10015                 :          0 :                 tw32(TG3PCI_PCISTATE, val);
   10016                 :            :         }
   10017                 :            : 
   10018         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_APE)) {
   10019                 :            :                 /* Allow reads and writes to the
   10020                 :            :                  * APE register and memory space.
   10021                 :            :                  */
   10022                 :          0 :                 val = tr32(TG3PCI_PCISTATE);
   10023                 :          0 :                 val |= PCISTATE_ALLOW_APE_CTLSPC_WR |
   10024                 :            :                        PCISTATE_ALLOW_APE_SHMEM_WR |
   10025                 :            :                        PCISTATE_ALLOW_APE_PSPACE_WR;
   10026                 :          0 :                 tw32(TG3PCI_PCISTATE, val);
   10027                 :            :         }
   10028                 :            : 
   10029         [ #  # ]:          0 :         if (tg3_chip_rev(tp) == CHIPREV_5704_BX) {
   10030                 :            :                 /* Enable some hw fixes.  */
   10031                 :          0 :                 val = tr32(TG3PCI_MSI_DATA);
   10032                 :          0 :                 val |= (1 << 26) | (1 << 28) | (1 << 29);
   10033                 :          0 :                 tw32(TG3PCI_MSI_DATA, val);
   10034                 :            :         }
   10035                 :            : 
   10036                 :            :         /* Descriptor ring init may make accesses to the
   10037                 :            :          * NIC SRAM area to setup the TX descriptors, so we
   10038                 :            :          * can only do this after the hardware has been
   10039                 :            :          * successfully reset.
   10040                 :            :          */
   10041                 :          0 :         err = tg3_init_rings(tp);
   10042         [ #  # ]:          0 :         if (err)
   10043                 :            :                 return err;
   10044                 :            : 
   10045         [ #  # ]:          0 :         if (tg3_flag(tp, 57765_PLUS)) {
   10046                 :          0 :                 val = tr32(TG3PCI_DMA_RW_CTRL) &
   10047                 :            :                       ~DMA_RWCTRL_DIS_CACHE_ALIGNMENT;
   10048         [ #  # ]:          0 :                 if (tg3_chip_rev_id(tp) == CHIPREV_ID_57765_A0)
   10049                 :          0 :                         val &= ~DMA_RWCTRL_CRDRDR_RDMA_MRRS_MSK;
   10050         [ #  # ]:          0 :                 if (!tg3_flag(tp, 57765_CLASS) &&
   10051   [ #  #  #  # ]:          0 :                     tg3_asic_rev(tp) != ASIC_REV_5717 &&
   10052                 :            :                     tg3_asic_rev(tp) != ASIC_REV_5762)
   10053                 :          0 :                         val |= DMA_RWCTRL_TAGGED_STAT_WA;
   10054                 :          0 :                 tw32(TG3PCI_DMA_RW_CTRL, val | tp->dma_rwctrl);
   10055         [ #  # ]:          0 :         } else if (tg3_asic_rev(tp) != ASIC_REV_5784 &&
   10056                 :            :                    tg3_asic_rev(tp) != ASIC_REV_5761) {
   10057                 :            :                 /* This value is determined during the probe time DMA
   10058                 :            :                  * engine test, tg3_test_dma.
   10059                 :            :                  */
   10060                 :          0 :                 tw32(TG3PCI_DMA_RW_CTRL, tp->dma_rwctrl);
   10061                 :            :         }
   10062                 :            : 
   10063                 :          0 :         tp->grc_mode &= ~(GRC_MODE_HOST_SENDBDS |
   10064                 :            :                           GRC_MODE_4X_NIC_SEND_RINGS |
   10065                 :            :                           GRC_MODE_NO_TX_PHDR_CSUM |
   10066                 :            :                           GRC_MODE_NO_RX_PHDR_CSUM);
   10067                 :          0 :         tp->grc_mode |= GRC_MODE_HOST_SENDBDS;
   10068                 :            : 
   10069                 :            :         /* Pseudo-header checksum is done by hardware logic and not
   10070                 :            :          * the offload processers, so make the chip do the pseudo-
   10071                 :            :          * header checksums on receive.  For transmit it is more
   10072                 :            :          * convenient to do the pseudo-header checksum in software
   10073                 :            :          * as Linux does that on transmit for us in all cases.
   10074                 :            :          */
   10075                 :          0 :         tp->grc_mode |= GRC_MODE_NO_TX_PHDR_CSUM;
   10076                 :            : 
   10077                 :          0 :         val = GRC_MODE_IRQ_ON_MAC_ATTN | GRC_MODE_HOST_STACKUP;
   10078         [ #  # ]:          0 :         if (tp->rxptpctl)
   10079                 :          0 :                 tw32(TG3_RX_PTP_CTL,
   10080                 :            :                      tp->rxptpctl | TG3_RX_PTP_CTL_HWTS_INTERLOCK);
   10081                 :            : 
   10082         [ #  # ]:          0 :         if (tg3_flag(tp, PTP_CAPABLE))
   10083                 :          0 :                 val |= GRC_MODE_TIME_SYNC_ENABLE;
   10084                 :            : 
   10085                 :          0 :         tw32(GRC_MODE, tp->grc_mode | val);
   10086                 :            : 
   10087                 :            :         /* On one of the AMD platform, MRRS is restricted to 4000 because of
   10088                 :            :          * south bridge limitation. As a workaround, Driver is setting MRRS
   10089                 :            :          * to 2048 instead of default 4096.
   10090                 :            :          */
   10091         [ #  # ]:          0 :         if (tp->pdev->subsystem_vendor == PCI_VENDOR_ID_DELL &&
   10092                 :            :             tp->pdev->subsystem_device == TG3PCI_SUBDEVICE_ID_DELL_5762) {
   10093                 :          0 :                 val = tr32(TG3PCI_DEV_STATUS_CTRL) & ~MAX_READ_REQ_MASK;
   10094                 :          0 :                 tw32(TG3PCI_DEV_STATUS_CTRL, val | MAX_READ_REQ_SIZE_2048);
   10095                 :            :         }
   10096                 :            : 
   10097                 :            :         /* Setup the timer prescalar register.  Clock is always 66Mhz. */
   10098                 :          0 :         val = tr32(GRC_MISC_CFG);
   10099                 :          0 :         val &= ~0xff;
   10100                 :          0 :         val |= (65 << GRC_MISC_CFG_PRESCALAR_SHIFT);
   10101                 :          0 :         tw32(GRC_MISC_CFG, val);
   10102                 :            : 
   10103                 :            :         /* Initialize MBUF/DESC pool. */
   10104         [ #  # ]:          0 :         if (tg3_flag(tp, 5750_PLUS)) {
   10105                 :            :                 /* Do nothing.  */
   10106         [ #  # ]:          0 :         } else if (tg3_asic_rev(tp) != ASIC_REV_5705) {
   10107                 :          0 :                 tw32(BUFMGR_MB_POOL_ADDR, NIC_SRAM_MBUF_POOL_BASE);
   10108         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5704)
   10109                 :          0 :                         tw32(BUFMGR_MB_POOL_SIZE, NIC_SRAM_MBUF_POOL_SIZE64);
   10110                 :            :                 else
   10111                 :          0 :                         tw32(BUFMGR_MB_POOL_SIZE, NIC_SRAM_MBUF_POOL_SIZE96);
   10112                 :          0 :                 tw32(BUFMGR_DMA_DESC_POOL_ADDR, NIC_SRAM_DMA_DESC_POOL_BASE);
   10113                 :          0 :                 tw32(BUFMGR_DMA_DESC_POOL_SIZE, NIC_SRAM_DMA_DESC_POOL_SIZE);
   10114         [ #  # ]:          0 :         } else if (tg3_flag(tp, TSO_CAPABLE)) {
   10115                 :          0 :                 int fw_len;
   10116                 :            : 
   10117                 :          0 :                 fw_len = tp->fw_len;
   10118                 :          0 :                 fw_len = (fw_len + (0x80 - 1)) & ~(0x80 - 1);
   10119                 :          0 :                 tw32(BUFMGR_MB_POOL_ADDR,
   10120                 :            :                      NIC_SRAM_MBUF_POOL_BASE5705 + fw_len);
   10121                 :          0 :                 tw32(BUFMGR_MB_POOL_SIZE,
   10122                 :            :                      NIC_SRAM_MBUF_POOL_SIZE5705 - fw_len - 0xa00);
   10123                 :            :         }
   10124                 :            : 
   10125         [ #  # ]:          0 :         if (tp->dev->mtu <= ETH_DATA_LEN) {
   10126                 :          0 :                 tw32(BUFMGR_MB_RDMA_LOW_WATER,
   10127                 :            :                      tp->bufmgr_config.mbuf_read_dma_low_water);
   10128                 :          0 :                 tw32(BUFMGR_MB_MACRX_LOW_WATER,
   10129                 :            :                      tp->bufmgr_config.mbuf_mac_rx_low_water);
   10130                 :          0 :                 tw32(BUFMGR_MB_HIGH_WATER,
   10131                 :            :                      tp->bufmgr_config.mbuf_high_water);
   10132                 :            :         } else {
   10133                 :          0 :                 tw32(BUFMGR_MB_RDMA_LOW_WATER,
   10134                 :            :                      tp->bufmgr_config.mbuf_read_dma_low_water_jumbo);
   10135                 :          0 :                 tw32(BUFMGR_MB_MACRX_LOW_WATER,
   10136                 :            :                      tp->bufmgr_config.mbuf_mac_rx_low_water_jumbo);
   10137                 :          0 :                 tw32(BUFMGR_MB_HIGH_WATER,
   10138                 :            :                      tp->bufmgr_config.mbuf_high_water_jumbo);
   10139                 :            :         }
   10140                 :          0 :         tw32(BUFMGR_DMA_LOW_WATER,
   10141                 :            :              tp->bufmgr_config.dma_low_water);
   10142                 :          0 :         tw32(BUFMGR_DMA_HIGH_WATER,
   10143                 :            :              tp->bufmgr_config.dma_high_water);
   10144                 :            : 
   10145                 :          0 :         val = BUFMGR_MODE_ENABLE | BUFMGR_MODE_ATTN_ENABLE;
   10146         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5719)
   10147                 :          0 :                 val |= BUFMGR_MODE_NO_TX_UNDERRUN;
   10148         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5717 ||
   10149         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5762 ||
   10150         [ #  # ]:          0 :             tg3_chip_rev_id(tp) == CHIPREV_ID_5719_A0 ||
   10151                 :            :             tg3_chip_rev_id(tp) == CHIPREV_ID_5720_A0)
   10152                 :          0 :                 val |= BUFMGR_MODE_MBLOW_ATTN_ENAB;
   10153                 :          0 :         tw32(BUFMGR_MODE, val);
   10154         [ #  # ]:          0 :         for (i = 0; i < 2000; i++) {
   10155         [ #  # ]:          0 :                 if (tr32(BUFMGR_MODE) & BUFMGR_MODE_ENABLE)
   10156                 :            :                         break;
   10157                 :          0 :                 udelay(10);
   10158                 :            :         }
   10159         [ #  # ]:          0 :         if (i >= 2000) {
   10160                 :          0 :                 netdev_err(tp->dev, "%s cannot enable BUFMGR\n", __func__);
   10161                 :          0 :                 return -ENODEV;
   10162                 :            :         }
   10163                 :            : 
   10164         [ #  # ]:          0 :         if (tg3_chip_rev_id(tp) == CHIPREV_ID_5906_A1)
   10165                 :          0 :                 tw32(ISO_PKT_TX, (tr32(ISO_PKT_TX) & ~0x3) | 0x2);
   10166                 :            : 
   10167                 :          0 :         tg3_setup_rxbd_thresholds(tp);
   10168                 :            : 
   10169                 :            :         /* Initialize TG3_BDINFO's at:
   10170                 :            :          *  RCVDBDI_STD_BD:     standard eth size rx ring
   10171                 :            :          *  RCVDBDI_JUMBO_BD:   jumbo frame rx ring
   10172                 :            :          *  RCVDBDI_MINI_BD:    small frame rx ring (??? does not work)
   10173                 :            :          *
   10174                 :            :          * like so:
   10175                 :            :          *  TG3_BDINFO_HOST_ADDR:       high/low parts of DMA address of ring
   10176                 :            :          *  TG3_BDINFO_MAXLEN_FLAGS:    (rx max buffer size << 16) |
   10177                 :            :          *                              ring attribute flags
   10178                 :            :          *  TG3_BDINFO_NIC_ADDR:        location of descriptors in nic SRAM
   10179                 :            :          *
   10180                 :            :          * Standard receive ring @ NIC_SRAM_RX_BUFFER_DESC, 512 entries.
   10181                 :            :          * Jumbo receive ring @ NIC_SRAM_RX_JUMBO_BUFFER_DESC, 256 entries.
   10182                 :            :          *
   10183                 :            :          * The size of each ring is fixed in the firmware, but the location is
   10184                 :            :          * configurable.
   10185                 :            :          */
   10186                 :          0 :         tw32(RCVDBDI_STD_BD + TG3_BDINFO_HOST_ADDR + TG3_64BIT_REG_HIGH,
   10187                 :            :              ((u64) tpr->rx_std_mapping >> 32));
   10188                 :          0 :         tw32(RCVDBDI_STD_BD + TG3_BDINFO_HOST_ADDR + TG3_64BIT_REG_LOW,
   10189                 :            :              ((u64) tpr->rx_std_mapping & 0xffffffff));
   10190         [ #  # ]:          0 :         if (!tg3_flag(tp, 5717_PLUS))
   10191                 :          0 :                 tw32(RCVDBDI_STD_BD + TG3_BDINFO_NIC_ADDR,
   10192                 :            :                      NIC_SRAM_RX_BUFFER_DESC);
   10193                 :            : 
   10194                 :            :         /* Disable the mini ring */
   10195         [ #  # ]:          0 :         if (!tg3_flag(tp, 5705_PLUS))
   10196                 :          0 :                 tw32(RCVDBDI_MINI_BD + TG3_BDINFO_MAXLEN_FLAGS,
   10197                 :            :                      BDINFO_FLAGS_DISABLED);
   10198                 :            : 
   10199                 :            :         /* Program the jumbo buffer descriptor ring control
   10200                 :            :          * blocks on those devices that have them.
   10201                 :            :          */
   10202   [ #  #  #  # ]:          0 :         if (tg3_chip_rev_id(tp) == CHIPREV_ID_5719_A0 ||
   10203         [ #  # ]:          0 :             (tg3_flag(tp, JUMBO_CAPABLE) && !tg3_flag(tp, 5780_CLASS))) {
   10204                 :            : 
   10205         [ #  # ]:          0 :                 if (tg3_flag(tp, JUMBO_RING_ENABLE)) {
   10206                 :          0 :                         tw32(RCVDBDI_JUMBO_BD + TG3_BDINFO_HOST_ADDR + TG3_64BIT_REG_HIGH,
   10207                 :            :                              ((u64) tpr->rx_jmb_mapping >> 32));
   10208                 :          0 :                         tw32(RCVDBDI_JUMBO_BD + TG3_BDINFO_HOST_ADDR + TG3_64BIT_REG_LOW,
   10209                 :            :                              ((u64) tpr->rx_jmb_mapping & 0xffffffff));
   10210         [ #  # ]:          0 :                         val = TG3_RX_JMB_RING_SIZE(tp) <<
   10211                 :            :                               BDINFO_FLAGS_MAXLEN_SHIFT;
   10212                 :          0 :                         tw32(RCVDBDI_JUMBO_BD + TG3_BDINFO_MAXLEN_FLAGS,
   10213                 :            :                              val | BDINFO_FLAGS_USE_EXT_RECV);
   10214   [ #  #  #  # ]:          0 :                         if (!tg3_flag(tp, USE_JUMBO_BDFLAG) ||
   10215                 :          0 :                             tg3_flag(tp, 57765_CLASS) ||
   10216         [ #  # ]:          0 :                             tg3_asic_rev(tp) == ASIC_REV_5762)
   10217                 :          0 :                                 tw32(RCVDBDI_JUMBO_BD + TG3_BDINFO_NIC_ADDR,
   10218                 :            :                                      NIC_SRAM_RX_JUMBO_BUFFER_DESC);
   10219                 :            :                 } else {
   10220                 :          0 :                         tw32(RCVDBDI_JUMBO_BD + TG3_BDINFO_MAXLEN_FLAGS,
   10221                 :            :                              BDINFO_FLAGS_DISABLED);
   10222                 :            :                 }
   10223                 :            : 
   10224         [ #  # ]:          0 :                 if (tg3_flag(tp, 57765_PLUS)) {
   10225         [ #  # ]:          0 :                         val = TG3_RX_STD_RING_SIZE(tp);
   10226                 :          0 :                         val <<= BDINFO_FLAGS_MAXLEN_SHIFT;
   10227                 :          0 :                         val |= (TG3_RX_STD_DMA_SZ << 2);
   10228                 :            :                 } else
   10229                 :            :                         val = TG3_RX_STD_DMA_SZ << BDINFO_FLAGS_MAXLEN_SHIFT;
   10230                 :            :         } else
   10231                 :            :                 val = TG3_RX_STD_MAX_SIZE_5700 << BDINFO_FLAGS_MAXLEN_SHIFT;
   10232                 :            : 
   10233                 :          0 :         tw32(RCVDBDI_STD_BD + TG3_BDINFO_MAXLEN_FLAGS, val);
   10234                 :            : 
   10235                 :          0 :         tpr->rx_std_prod_idx = tp->rx_pending;
   10236                 :          0 :         tw32_rx_mbox(TG3_RX_STD_PROD_IDX_REG, tpr->rx_std_prod_idx);
   10237                 :            : 
   10238                 :          0 :         tpr->rx_jmb_prod_idx =
   10239         [ #  # ]:          0 :                 tg3_flag(tp, JUMBO_RING_ENABLE) ? tp->rx_jumbo_pending : 0;
   10240                 :          0 :         tw32_rx_mbox(TG3_RX_JMB_PROD_IDX_REG, tpr->rx_jmb_prod_idx);
   10241                 :            : 
   10242                 :          0 :         tg3_rings_reset(tp);
   10243                 :            : 
   10244                 :            :         /* Initialize MAC address and backoff seed. */
   10245                 :          0 :         __tg3_set_mac_addr(tp, false);
   10246                 :            : 
   10247                 :            :         /* MTU + ethernet header + FCS + optional VLAN tag */
   10248                 :          0 :         tw32(MAC_RX_MTU_SIZE,
   10249                 :            :              tp->dev->mtu + ETH_HLEN + ETH_FCS_LEN + VLAN_HLEN);
   10250                 :            : 
   10251                 :            :         /* The slot time is changed by tg3_setup_phy if we
   10252                 :            :          * run at gigabit with half duplex.
   10253                 :            :          */
   10254                 :          0 :         val = (2 << TX_LENGTHS_IPG_CRS_SHIFT) |
   10255                 :            :               (6 << TX_LENGTHS_IPG_SHIFT) |
   10256                 :            :               (32 << TX_LENGTHS_SLOT_TIME_SHIFT);
   10257                 :            : 
   10258         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5720 ||
   10259                 :            :             tg3_asic_rev(tp) == ASIC_REV_5762)
   10260                 :          0 :                 val |= tr32(MAC_TX_LENGTHS) &
   10261                 :            :                        (TX_LENGTHS_JMB_FRM_LEN_MSK |
   10262                 :            :                         TX_LENGTHS_CNT_DWN_VAL_MSK);
   10263                 :            : 
   10264                 :          0 :         tw32(MAC_TX_LENGTHS, val);
   10265                 :            : 
   10266                 :            :         /* Receive rules. */
   10267                 :          0 :         tw32(MAC_RCV_RULE_CFG, RCV_RULE_CFG_DEFAULT_CLASS);
   10268                 :          0 :         tw32(RCVLPC_CONFIG, 0x0181);
   10269                 :            : 
   10270                 :            :         /* Calculate RDMAC_MODE setting early, we need it to determine
   10271                 :            :          * the RCVLPC_STATE_ENABLE mask.
   10272                 :            :          */
   10273                 :          0 :         rdmac_mode = (RDMAC_MODE_ENABLE | RDMAC_MODE_TGTABORT_ENAB |
   10274                 :            :                       RDMAC_MODE_MSTABORT_ENAB | RDMAC_MODE_PARITYERR_ENAB |
   10275                 :            :                       RDMAC_MODE_ADDROFLOW_ENAB | RDMAC_MODE_FIFOOFLOW_ENAB |
   10276                 :            :                       RDMAC_MODE_FIFOURUN_ENAB | RDMAC_MODE_FIFOOREAD_ENAB |
   10277                 :            :                       RDMAC_MODE_LNGREAD_ENAB);
   10278                 :            : 
   10279         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5717)
   10280                 :          0 :                 rdmac_mode |= RDMAC_MODE_MULT_DMA_RD_DIS;
   10281                 :            : 
   10282                 :          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5784 ||
   10283         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5785 ||
   10284                 :            :             tg3_asic_rev(tp) == ASIC_REV_57780)
   10285                 :          0 :                 rdmac_mode |= RDMAC_MODE_BD_SBD_CRPT_ENAB |
   10286                 :            :                               RDMAC_MODE_MBUF_RBD_CRPT_ENAB |
   10287                 :            :                               RDMAC_MODE_MBUF_SBD_CRPT_ENAB;
   10288                 :            : 
   10289   [ #  #  #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5705 &&
   10290                 :            :             tg3_chip_rev_id(tp) != CHIPREV_ID_5705_A0) {
   10291         [ #  # ]:          0 :                 if (tg3_flag(tp, TSO_CAPABLE) &&
   10292         [ #  # ]:          0 :                     tg3_asic_rev(tp) == ASIC_REV_5705) {
   10293                 :          0 :                         rdmac_mode |= RDMAC_MODE_FIFO_SIZE_128;
   10294   [ #  #  #  # ]:          0 :                 } else if (!(tr32(TG3PCI_PCISTATE) & PCISTATE_BUS_SPEED_HIGH) &&
   10295                 :            :                            !tg3_flag(tp, IS_5788)) {
   10296                 :          0 :                         rdmac_mode |= RDMAC_MODE_FIFO_LONG_BURST;
   10297                 :            :                 }
   10298                 :            :         }
   10299                 :            : 
   10300         [ #  # ]:          0 :         if (tg3_flag(tp, PCI_EXPRESS))
   10301                 :          0 :                 rdmac_mode |= RDMAC_MODE_FIFO_LONG_BURST;
   10302                 :            : 
   10303         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_57766) {
   10304                 :          0 :                 tp->dma_limit = 0;
   10305         [ #  # ]:          0 :                 if (tp->dev->mtu <= ETH_DATA_LEN) {
   10306                 :          0 :                         rdmac_mode |= RDMAC_MODE_JMB_2K_MMRR;
   10307                 :          0 :                         tp->dma_limit = TG3_TX_BD_DMA_MAX_2K;
   10308                 :            :                 }
   10309                 :            :         }
   10310                 :            : 
   10311   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, HW_TSO_1) ||
   10312         [ #  # ]:          0 :             tg3_flag(tp, HW_TSO_2) ||
   10313                 :            :             tg3_flag(tp, HW_TSO_3))
   10314                 :          0 :                 rdmac_mode |= RDMAC_MODE_IPV4_LSO_EN;
   10315                 :            : 
   10316         [ #  # ]:          0 :         if (tg3_flag(tp, 57765_PLUS) ||
   10317   [ #  #  #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5785 ||
   10318                 :            :             tg3_asic_rev(tp) == ASIC_REV_57780)
   10319                 :          0 :                 rdmac_mode |= RDMAC_MODE_IPV6_LSO_EN;
   10320                 :            : 
   10321         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5720 ||
   10322                 :            :             tg3_asic_rev(tp) == ASIC_REV_5762)
   10323                 :          0 :                 rdmac_mode |= tr32(RDMAC_MODE) & RDMAC_MODE_H2BNC_VLAN_DET;
   10324                 :            : 
   10325         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5761 ||
   10326         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5784 ||
   10327         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5785 ||
   10328         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_57780 ||
   10329                 :            :             tg3_flag(tp, 57765_PLUS)) {
   10330                 :          0 :                 u32 tgtreg;
   10331                 :            : 
   10332         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5762)
   10333                 :            :                         tgtreg = TG3_RDMA_RSRVCTRL_REG2;
   10334                 :            :                 else
   10335                 :          0 :                         tgtreg = TG3_RDMA_RSRVCTRL_REG;
   10336                 :            : 
   10337                 :          0 :                 val = tr32(tgtreg);
   10338         [ #  # ]:          0 :                 if (tg3_chip_rev_id(tp) == CHIPREV_ID_5719_A0 ||
   10339         [ #  # ]:          0 :                     tg3_asic_rev(tp) == ASIC_REV_5762) {
   10340                 :          0 :                         val &= ~(TG3_RDMA_RSRVCTRL_TXMRGN_MASK |
   10341                 :            :                                  TG3_RDMA_RSRVCTRL_FIFO_LWM_MASK |
   10342                 :            :                                  TG3_RDMA_RSRVCTRL_FIFO_HWM_MASK);
   10343                 :          0 :                         val |= TG3_RDMA_RSRVCTRL_TXMRGN_320B |
   10344                 :            :                                TG3_RDMA_RSRVCTRL_FIFO_LWM_1_5K |
   10345                 :            :                                TG3_RDMA_RSRVCTRL_FIFO_HWM_1_5K;
   10346                 :            :                 }
   10347                 :          0 :                 tw32(tgtreg, val | TG3_RDMA_RSRVCTRL_FIFO_OFLW_FIX);
   10348                 :            :         }
   10349                 :            : 
   10350         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5719 ||
   10351         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5720 ||
   10352                 :            :             tg3_asic_rev(tp) == ASIC_REV_5762) {
   10353                 :          0 :                 u32 tgtreg;
   10354                 :            : 
   10355         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5762)
   10356                 :            :                         tgtreg = TG3_LSO_RD_DMA_CRPTEN_CTRL2;
   10357                 :            :                 else
   10358                 :          0 :                         tgtreg = TG3_LSO_RD_DMA_CRPTEN_CTRL;
   10359                 :            : 
   10360                 :          0 :                 val = tr32(tgtreg);
   10361                 :          0 :                 tw32(tgtreg, val |
   10362                 :            :                      TG3_LSO_RD_DMA_CRPTEN_CTRL_BLEN_BD_4K |
   10363                 :            :                      TG3_LSO_RD_DMA_CRPTEN_CTRL_BLEN_LSO_4K);
   10364                 :            :         }
   10365                 :            : 
   10366                 :            :         /* Receive/send statistics. */
   10367         [ #  # ]:          0 :         if (tg3_flag(tp, 5750_PLUS)) {
   10368                 :          0 :                 val = tr32(RCVLPC_STATS_ENABLE);
   10369                 :          0 :                 val &= ~RCVLPC_STATSENAB_DACK_FIX;
   10370                 :          0 :                 tw32(RCVLPC_STATS_ENABLE, val);
   10371   [ #  #  #  # ]:          0 :         } else if ((rdmac_mode & RDMAC_MODE_FIFO_SIZE_128) &&
   10372                 :            :                    tg3_flag(tp, TSO_CAPABLE)) {
   10373                 :          0 :                 val = tr32(RCVLPC_STATS_ENABLE);
   10374                 :          0 :                 val &= ~RCVLPC_STATSENAB_LNGBRST_RFIX;
   10375                 :          0 :                 tw32(RCVLPC_STATS_ENABLE, val);
   10376                 :            :         } else {
   10377                 :          0 :                 tw32(RCVLPC_STATS_ENABLE, 0xffffff);
   10378                 :            :         }
   10379                 :          0 :         tw32(RCVLPC_STATSCTRL, RCVLPC_STATSCTRL_ENABLE);
   10380                 :          0 :         tw32(SNDDATAI_STATSENAB, 0xffffff);
   10381                 :          0 :         tw32(SNDDATAI_STATSCTRL,
   10382                 :            :              (SNDDATAI_SCTRL_ENABLE |
   10383                 :            :               SNDDATAI_SCTRL_FASTUPD));
   10384                 :            : 
   10385                 :            :         /* Setup host coalescing engine. */
   10386                 :          0 :         tw32(HOSTCC_MODE, 0);
   10387         [ #  # ]:          0 :         for (i = 0; i < 2000; i++) {
   10388         [ #  # ]:          0 :                 if (!(tr32(HOSTCC_MODE) & HOSTCC_MODE_ENABLE))
   10389                 :            :                         break;
   10390                 :          0 :                 udelay(10);
   10391                 :            :         }
   10392                 :            : 
   10393                 :          0 :         __tg3_set_coalesce(tp, &tp->coal);
   10394                 :            : 
   10395         [ #  # ]:          0 :         if (!tg3_flag(tp, 5705_PLUS)) {
   10396                 :            :                 /* Status/statistics block address.  See tg3_timer,
   10397                 :            :                  * the tg3_periodic_fetch_stats call there, and
   10398                 :            :                  * tg3_get_stats to see how this works for 5705/5750 chips.
   10399                 :            :                  */
   10400                 :          0 :                 tw32(HOSTCC_STATS_BLK_HOST_ADDR + TG3_64BIT_REG_HIGH,
   10401                 :            :                      ((u64) tp->stats_mapping >> 32));
   10402                 :          0 :                 tw32(HOSTCC_STATS_BLK_HOST_ADDR + TG3_64BIT_REG_LOW,
   10403                 :            :                      ((u64) tp->stats_mapping & 0xffffffff));
   10404                 :          0 :                 tw32(HOSTCC_STATS_BLK_NIC_ADDR, NIC_SRAM_STATS_BLK);
   10405                 :            : 
   10406                 :          0 :                 tw32(HOSTCC_STATUS_BLK_NIC_ADDR, NIC_SRAM_STATUS_BLK);
   10407                 :            : 
   10408                 :            :                 /* Clear statistics and status block memory areas */
   10409                 :          0 :                 for (i = NIC_SRAM_STATS_BLK;
   10410         [ #  # ]:          0 :                      i < NIC_SRAM_STATUS_BLK + TG3_HW_STATUS_SIZE;
   10411                 :          0 :                      i += sizeof(u32)) {
   10412                 :          0 :                         tg3_write_mem(tp, i, 0);
   10413                 :          0 :                         udelay(40);
   10414                 :            :                 }
   10415                 :            :         }
   10416                 :            : 
   10417                 :          0 :         tw32(HOSTCC_MODE, HOSTCC_MODE_ENABLE | tp->coalesce_mode);
   10418                 :            : 
   10419                 :          0 :         tw32(RCVCC_MODE, RCVCC_MODE_ENABLE | RCVCC_MODE_ATTN_ENABLE);
   10420                 :          0 :         tw32(RCVLPC_MODE, RCVLPC_MODE_ENABLE);
   10421         [ #  # ]:          0 :         if (!tg3_flag(tp, 5705_PLUS))
   10422                 :          0 :                 tw32(RCVLSC_MODE, RCVLSC_MODE_ENABLE | RCVLSC_MODE_ATTN_ENABLE);
   10423                 :            : 
   10424         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_MII_SERDES) {
   10425                 :          0 :                 tp->phy_flags &= ~TG3_PHYFLG_PARALLEL_DETECT;
   10426                 :            :                 /* reset to prevent losing 1st rx packet intermittently */
   10427                 :          0 :                 tw32_f(MAC_RX_MODE, RX_MODE_RESET);
   10428                 :          0 :                 udelay(10);
   10429                 :            :         }
   10430                 :            : 
   10431                 :          0 :         tp->mac_mode |= MAC_MODE_TXSTAT_ENABLE | MAC_MODE_RXSTAT_ENABLE |
   10432                 :            :                         MAC_MODE_TDE_ENABLE | MAC_MODE_RDE_ENABLE |
   10433                 :            :                         MAC_MODE_FHDE_ENABLE;
   10434         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_APE))
   10435                 :          0 :                 tp->mac_mode |= MAC_MODE_APE_TX_EN | MAC_MODE_APE_RX_EN;
   10436         [ #  # ]:          0 :         if (!tg3_flag(tp, 5705_PLUS) &&
   10437         [ #  # ]:          0 :             !(tp->phy_flags & TG3_PHYFLG_PHY_SERDES) &&
   10438         [ #  # ]:          0 :             tg3_asic_rev(tp) != ASIC_REV_5700)
   10439                 :          0 :                 tp->mac_mode |= MAC_MODE_LINK_POLARITY;
   10440                 :          0 :         tw32_f(MAC_MODE, tp->mac_mode | MAC_MODE_RXSTAT_CLEAR | MAC_MODE_TXSTAT_CLEAR);
   10441                 :          0 :         udelay(40);
   10442                 :            : 
   10443                 :            :         /* tp->grc_local_ctrl is partially set up during tg3_get_invariants().
   10444                 :            :          * If TG3_FLAG_IS_NIC is zero, we should read the
   10445                 :            :          * register to preserve the GPIO settings for LOMs. The GPIOs,
   10446                 :            :          * whether used as inputs or outputs, are set by boot code after
   10447                 :            :          * reset.
   10448                 :            :          */
   10449         [ #  # ]:          0 :         if (!tg3_flag(tp, IS_NIC)) {
   10450                 :          0 :                 u32 gpio_mask;
   10451                 :            : 
   10452                 :          0 :                 gpio_mask = GRC_LCLCTRL_GPIO_OE0 | GRC_LCLCTRL_GPIO_OE1 |
   10453                 :            :                             GRC_LCLCTRL_GPIO_OE2 | GRC_LCLCTRL_GPIO_OUTPUT0 |
   10454                 :            :                             GRC_LCLCTRL_GPIO_OUTPUT1 | GRC_LCLCTRL_GPIO_OUTPUT2;
   10455                 :            : 
   10456         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5752)
   10457                 :          0 :                         gpio_mask |= GRC_LCLCTRL_GPIO_OE3 |
   10458                 :            :                                      GRC_LCLCTRL_GPIO_OUTPUT3;
   10459                 :            : 
   10460         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5755)
   10461                 :          0 :                         gpio_mask |= GRC_LCLCTRL_GPIO_UART_SEL;
   10462                 :            : 
   10463                 :          0 :                 tp->grc_local_ctrl &= ~gpio_mask;
   10464                 :          0 :                 tp->grc_local_ctrl |= tr32(GRC_LOCAL_CTRL) & gpio_mask;
   10465                 :            : 
   10466                 :            :                 /* GPIO1 must be driven high for eeprom write protect */
   10467         [ #  # ]:          0 :                 if (tg3_flag(tp, EEPROM_WRITE_PROT))
   10468                 :          0 :                         tp->grc_local_ctrl |= (GRC_LCLCTRL_GPIO_OE1 |
   10469                 :            :                                                GRC_LCLCTRL_GPIO_OUTPUT1);
   10470                 :            :         }
   10471                 :          0 :         tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl);
   10472                 :          0 :         udelay(100);
   10473                 :            : 
   10474         [ #  # ]:          0 :         if (tg3_flag(tp, USING_MSIX)) {
   10475                 :          0 :                 val = tr32(MSGINT_MODE);
   10476                 :          0 :                 val |= MSGINT_MODE_ENABLE;
   10477         [ #  # ]:          0 :                 if (tp->irq_cnt > 1)
   10478                 :          0 :                         val |= MSGINT_MODE_MULTIVEC_EN;
   10479         [ #  # ]:          0 :                 if (!tg3_flag(tp, 1SHOT_MSI))
   10480                 :          0 :                         val |= MSGINT_MODE_ONE_SHOT_DISABLE;
   10481                 :          0 :                 tw32(MSGINT_MODE, val);
   10482                 :            :         }
   10483                 :            : 
   10484         [ #  # ]:          0 :         if (!tg3_flag(tp, 5705_PLUS)) {
   10485                 :          0 :                 tw32_f(DMAC_MODE, DMAC_MODE_ENABLE);
   10486                 :          0 :                 udelay(40);
   10487                 :            :         }
   10488                 :            : 
   10489                 :          0 :         val = (WDMAC_MODE_ENABLE | WDMAC_MODE_TGTABORT_ENAB |
   10490                 :            :                WDMAC_MODE_MSTABORT_ENAB | WDMAC_MODE_PARITYERR_ENAB |
   10491                 :            :                WDMAC_MODE_ADDROFLOW_ENAB | WDMAC_MODE_FIFOOFLOW_ENAB |
   10492                 :            :                WDMAC_MODE_FIFOURUN_ENAB | WDMAC_MODE_FIFOOREAD_ENAB |
   10493                 :            :                WDMAC_MODE_LNGREAD_ENAB);
   10494                 :            : 
   10495   [ #  #  #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5705 &&
   10496                 :            :             tg3_chip_rev_id(tp) != CHIPREV_ID_5705_A0) {
   10497         [ #  # ]:          0 :                 if (tg3_flag(tp, TSO_CAPABLE) &&
   10498         [ #  # ]:          0 :                     (tg3_chip_rev_id(tp) == CHIPREV_ID_5705_A1 ||
   10499                 :            :                      tg3_chip_rev_id(tp) == CHIPREV_ID_5705_A2)) {
   10500                 :            :                         /* nothing */
   10501   [ #  #  #  # ]:          0 :                 } else if (!(tr32(TG3PCI_PCISTATE) & PCISTATE_BUS_SPEED_HIGH) &&
   10502                 :            :                            !tg3_flag(tp, IS_5788)) {
   10503                 :          0 :                         val |= WDMAC_MODE_RX_ACCEL;
   10504                 :            :                 }
   10505                 :            :         }
   10506                 :            : 
   10507                 :            :         /* Enable host coalescing bug fix */
   10508         [ #  # ]:          0 :         if (tg3_flag(tp, 5755_PLUS))
   10509                 :          0 :                 val |= WDMAC_MODE_STATUS_TAG_FIX;
   10510                 :            : 
   10511         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5785)
   10512                 :          0 :                 val |= WDMAC_MODE_BURST_ALL_DATA;
   10513                 :            : 
   10514                 :          0 :         tw32_f(WDMAC_MODE, val);
   10515                 :          0 :         udelay(40);
   10516                 :            : 
   10517         [ #  # ]:          0 :         if (tg3_flag(tp, PCIX_MODE)) {
   10518                 :          0 :                 u16 pcix_cmd;
   10519                 :            : 
   10520                 :          0 :                 pci_read_config_word(tp->pdev, tp->pcix_cap + PCI_X_CMD,
   10521                 :            :                                      &pcix_cmd);
   10522         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5703) {
   10523                 :          0 :                         pcix_cmd &= ~PCI_X_CMD_MAX_READ;
   10524                 :          0 :                         pcix_cmd |= PCI_X_CMD_READ_2K;
   10525         [ #  # ]:          0 :                 } else if (tg3_asic_rev(tp) == ASIC_REV_5704) {
   10526                 :          0 :                         pcix_cmd &= ~(PCI_X_CMD_MAX_SPLIT | PCI_X_CMD_MAX_READ);
   10527                 :          0 :                         pcix_cmd |= PCI_X_CMD_READ_2K;
   10528                 :            :                 }
   10529                 :          0 :                 pci_write_config_word(tp->pdev, tp->pcix_cap + PCI_X_CMD,
   10530                 :            :                                       pcix_cmd);
   10531                 :            :         }
   10532                 :            : 
   10533                 :          0 :         tw32_f(RDMAC_MODE, rdmac_mode);
   10534                 :          0 :         udelay(40);
   10535                 :            : 
   10536         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5719 ||
   10537                 :            :             tg3_asic_rev(tp) == ASIC_REV_5720) {
   10538         [ #  # ]:          0 :                 for (i = 0; i < TG3_NUM_RDMA_CHANNELS; i++) {
   10539   [ #  #  #  # ]:          0 :                         if (tr32(TG3_RDMA_LENGTH + (i << 2)) > TG3_MAX_MTU(tp))
   10540                 :            :                                 break;
   10541                 :            :                 }
   10542         [ #  # ]:          0 :                 if (i < TG3_NUM_RDMA_CHANNELS) {
   10543                 :          0 :                         val = tr32(TG3_LSO_RD_DMA_CRPTEN_CTRL);
   10544         [ #  # ]:          0 :                         val |= tg3_lso_rd_dma_workaround_bit(tp);
   10545                 :          0 :                         tw32(TG3_LSO_RD_DMA_CRPTEN_CTRL, val);
   10546                 :          0 :                         tg3_flag_set(tp, 5719_5720_RDMA_BUG);
   10547                 :            :                 }
   10548                 :            :         }
   10549                 :            : 
   10550                 :          0 :         tw32(RCVDCC_MODE, RCVDCC_MODE_ENABLE | RCVDCC_MODE_ATTN_ENABLE);
   10551         [ #  # ]:          0 :         if (!tg3_flag(tp, 5705_PLUS))
   10552                 :          0 :                 tw32(MBFREE_MODE, MBFREE_MODE_ENABLE);
   10553                 :            : 
   10554         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5761)
   10555                 :          0 :                 tw32(SNDDATAC_MODE,
   10556                 :            :                      SNDDATAC_MODE_ENABLE | SNDDATAC_MODE_CDELAY);
   10557                 :            :         else
   10558                 :          0 :                 tw32(SNDDATAC_MODE, SNDDATAC_MODE_ENABLE);
   10559                 :            : 
   10560                 :          0 :         tw32(SNDBDC_MODE, SNDBDC_MODE_ENABLE | SNDBDC_MODE_ATTN_ENABLE);
   10561                 :          0 :         tw32(RCVBDI_MODE, RCVBDI_MODE_ENABLE | RCVBDI_MODE_RCB_ATTN_ENAB);
   10562                 :          0 :         val = RCVDBDI_MODE_ENABLE | RCVDBDI_MODE_INV_RING_SZ;
   10563         [ #  # ]:          0 :         if (tg3_flag(tp, LRG_PROD_RING_CAP))
   10564                 :          0 :                 val |= RCVDBDI_MODE_LRG_RING_SZ;
   10565                 :          0 :         tw32(RCVDBDI_MODE, val);
   10566                 :          0 :         tw32(SNDDATAI_MODE, SNDDATAI_MODE_ENABLE);
   10567   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, HW_TSO_1) ||
   10568         [ #  # ]:          0 :             tg3_flag(tp, HW_TSO_2) ||
   10569                 :            :             tg3_flag(tp, HW_TSO_3))
   10570                 :          0 :                 tw32(SNDDATAI_MODE, SNDDATAI_MODE_ENABLE | 0x8);
   10571                 :          0 :         val = SNDBDI_MODE_ENABLE | SNDBDI_MODE_ATTN_ENABLE;
   10572         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_TSS))
   10573                 :          0 :                 val |= SNDBDI_MODE_MULTI_TXQ_EN;
   10574                 :          0 :         tw32(SNDBDI_MODE, val);
   10575                 :          0 :         tw32(SNDBDS_MODE, SNDBDS_MODE_ENABLE | SNDBDS_MODE_ATTN_ENABLE);
   10576                 :            : 
   10577         [ #  # ]:          0 :         if (tg3_chip_rev_id(tp) == CHIPREV_ID_5701_A0) {
   10578                 :          0 :                 err = tg3_load_5701_a0_firmware_fix(tp);
   10579         [ #  # ]:          0 :                 if (err)
   10580                 :            :                         return err;
   10581                 :            :         }
   10582                 :            : 
   10583         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_57766) {
   10584                 :            :                 /* Ignore any errors for the firmware download. If download
   10585                 :            :                  * fails, the device will operate with EEE disabled
   10586                 :            :                  */
   10587                 :          0 :                 tg3_load_57766_firmware(tp);
   10588                 :            :         }
   10589                 :            : 
   10590         [ #  # ]:          0 :         if (tg3_flag(tp, TSO_CAPABLE)) {
   10591                 :          0 :                 err = tg3_load_tso_firmware(tp);
   10592         [ #  # ]:          0 :                 if (err)
   10593                 :            :                         return err;
   10594                 :            :         }
   10595                 :            : 
   10596                 :          0 :         tp->tx_mode = TX_MODE_ENABLE;
   10597                 :            : 
   10598         [ #  # ]:          0 :         if (tg3_flag(tp, 5755_PLUS) ||
   10599         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5906)
   10600                 :          0 :                 tp->tx_mode |= TX_MODE_MBUF_LOCKUP_FIX;
   10601                 :            : 
   10602         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5720 ||
   10603                 :            :             tg3_asic_rev(tp) == ASIC_REV_5762) {
   10604                 :          0 :                 val = TX_MODE_JMB_FRM_LEN | TX_MODE_CNT_DN_MODE;
   10605                 :          0 :                 tp->tx_mode &= ~val;
   10606                 :          0 :                 tp->tx_mode |= tr32(MAC_TX_MODE) & val;
   10607                 :            :         }
   10608                 :            : 
   10609                 :          0 :         tw32_f(MAC_TX_MODE, tp->tx_mode);
   10610                 :          0 :         udelay(100);
   10611                 :            : 
   10612         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_RSS)) {
   10613                 :          0 :                 u32 rss_key[10];
   10614                 :            : 
   10615                 :          0 :                 tg3_rss_write_indir_tbl(tp);
   10616                 :            : 
   10617                 :          0 :                 netdev_rss_key_fill(rss_key, 10 * sizeof(u32));
   10618                 :            : 
   10619         [ #  # ]:          0 :                 for (i = 0; i < 10 ; i++)
   10620                 :          0 :                         tw32(MAC_RSS_HASH_KEY_0 + i*4, rss_key[i]);
   10621                 :            :         }
   10622                 :            : 
   10623                 :          0 :         tp->rx_mode = RX_MODE_ENABLE;
   10624         [ #  # ]:          0 :         if (tg3_flag(tp, 5755_PLUS))
   10625                 :          0 :                 tp->rx_mode |= RX_MODE_IPV6_CSUM_ENABLE;
   10626                 :            : 
   10627         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5762)
   10628                 :          0 :                 tp->rx_mode |= RX_MODE_IPV4_FRAG_FIX;
   10629                 :            : 
   10630         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_RSS))
   10631                 :          0 :                 tp->rx_mode |= RX_MODE_RSS_ENABLE |
   10632                 :            :                                RX_MODE_RSS_ITBL_HASH_BITS_7 |
   10633                 :            :                                RX_MODE_RSS_IPV6_HASH_EN |
   10634                 :            :                                RX_MODE_RSS_TCP_IPV6_HASH_EN |
   10635                 :            :                                RX_MODE_RSS_IPV4_HASH_EN |
   10636                 :            :                                RX_MODE_RSS_TCP_IPV4_HASH_EN;
   10637                 :            : 
   10638                 :          0 :         tw32_f(MAC_RX_MODE, tp->rx_mode);
   10639                 :          0 :         udelay(10);
   10640                 :            : 
   10641                 :          0 :         tw32(MAC_LED_CTRL, tp->led_ctrl);
   10642                 :            : 
   10643                 :          0 :         tw32(MAC_MI_STAT, MAC_MI_STAT_LNKSTAT_ATTN_ENAB);
   10644         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_PHY_SERDES) {
   10645                 :          0 :                 tw32_f(MAC_RX_MODE, RX_MODE_RESET);
   10646                 :          0 :                 udelay(10);
   10647                 :            :         }
   10648                 :          0 :         tw32_f(MAC_RX_MODE, tp->rx_mode);
   10649                 :          0 :         udelay(10);
   10650                 :            : 
   10651         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_PHY_SERDES) {
   10652         [ #  # ]:          0 :                 if ((tg3_asic_rev(tp) == ASIC_REV_5704) &&
   10653         [ #  # ]:          0 :                     !(tp->phy_flags & TG3_PHYFLG_SERDES_PREEMPHASIS)) {
   10654                 :            :                         /* Set drive transmission level to 1.2V  */
   10655                 :            :                         /* only if the signal pre-emphasis bit is not set  */
   10656                 :          0 :                         val = tr32(MAC_SERDES_CFG);
   10657                 :          0 :                         val &= 0xfffff000;
   10658                 :          0 :                         val |= 0x880;
   10659                 :          0 :                         tw32(MAC_SERDES_CFG, val);
   10660                 :            :                 }
   10661         [ #  # ]:          0 :                 if (tg3_chip_rev_id(tp) == CHIPREV_ID_5703_A1)
   10662                 :          0 :                         tw32(MAC_SERDES_CFG, 0x616000);
   10663                 :            :         }
   10664                 :            : 
   10665                 :            :         /* Prevent chip from dropping frames when flow control
   10666                 :            :          * is enabled.
   10667                 :            :          */
   10668         [ #  # ]:          0 :         if (tg3_flag(tp, 57765_CLASS))
   10669                 :            :                 val = 1;
   10670                 :            :         else
   10671                 :          0 :                 val = 2;
   10672                 :          0 :         tw32_f(MAC_LOW_WMARK_MAX_RX_FRAME, val);
   10673                 :            : 
   10674         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5704 &&
   10675         [ #  # ]:          0 :             (tp->phy_flags & TG3_PHYFLG_PHY_SERDES)) {
   10676                 :            :                 /* Use hardware link auto-negotiation */
   10677                 :          0 :                 tg3_flag_set(tp, HW_AUTONEG);
   10678                 :            :         }
   10679                 :            : 
   10680         [ #  # ]:          0 :         if ((tp->phy_flags & TG3_PHYFLG_MII_SERDES) &&
   10681         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5714) {
   10682                 :          0 :                 u32 tmp;
   10683                 :            : 
   10684                 :          0 :                 tmp = tr32(SERDES_RX_CTRL);
   10685                 :          0 :                 tw32(SERDES_RX_CTRL, tmp | SERDES_RX_SIG_DETECT);
   10686                 :          0 :                 tp->grc_local_ctrl &= ~GRC_LCLCTRL_USE_EXT_SIG_DETECT;
   10687                 :          0 :                 tp->grc_local_ctrl |= GRC_LCLCTRL_USE_SIG_DETECT;
   10688                 :          0 :                 tw32(GRC_LOCAL_CTRL, tp->grc_local_ctrl);
   10689                 :            :         }
   10690                 :            : 
   10691         [ #  # ]:          0 :         if (!tg3_flag(tp, USE_PHYLIB)) {
   10692         [ #  # ]:          0 :                 if (tp->phy_flags & TG3_PHYFLG_IS_LOW_POWER)
   10693                 :          0 :                         tp->phy_flags &= ~TG3_PHYFLG_IS_LOW_POWER;
   10694                 :            : 
   10695                 :          0 :                 err = tg3_setup_phy(tp, false);
   10696         [ #  # ]:          0 :                 if (err)
   10697                 :            :                         return err;
   10698                 :            : 
   10699         [ #  # ]:          0 :                 if (!(tp->phy_flags & TG3_PHYFLG_PHY_SERDES) &&
   10700                 :            :                     !(tp->phy_flags & TG3_PHYFLG_IS_FET)) {
   10701                 :          0 :                         u32 tmp;
   10702                 :            : 
   10703                 :            :                         /* Clear CRC stats. */
   10704         [ #  # ]:          0 :                         if (!tg3_readphy(tp, MII_TG3_TEST1, &tmp)) {
   10705                 :          0 :                                 tg3_writephy(tp, MII_TG3_TEST1,
   10706                 :            :                                              tmp | MII_TG3_TEST1_CRC_EN);
   10707                 :          0 :                                 tg3_readphy(tp, MII_TG3_RXR_COUNTERS, &tmp);
   10708                 :            :                         }
   10709                 :            :                 }
   10710                 :            :         }
   10711                 :            : 
   10712                 :          0 :         __tg3_set_rx_mode(tp->dev);
   10713                 :            : 
   10714                 :            :         /* Initialize receive rules. */
   10715                 :          0 :         tw32(MAC_RCV_RULE_0,  0xc2000000 & RCV_RULE_DISABLE_MASK);
   10716                 :          0 :         tw32(MAC_RCV_VALUE_0, 0xffffffff & RCV_RULE_DISABLE_MASK);
   10717                 :          0 :         tw32(MAC_RCV_RULE_1,  0x86000004 & RCV_RULE_DISABLE_MASK);
   10718                 :          0 :         tw32(MAC_RCV_VALUE_1, 0xffffffff & RCV_RULE_DISABLE_MASK);
   10719                 :            : 
   10720   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, 5705_PLUS) && !tg3_flag(tp, 5780_CLASS))
   10721                 :            :                 limit = 8;
   10722                 :            :         else
   10723                 :            :                 limit = 16;
   10724         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_ASF))
   10725                 :          0 :                 limit -= 4;
   10726   [ #  #  #  #  :          0 :         switch (limit) {
          #  #  #  #  #  
             #  #  #  # ]
   10727                 :          0 :         case 16:
   10728                 :          0 :                 tw32(MAC_RCV_RULE_15,  0); tw32(MAC_RCV_VALUE_15,  0);
   10729                 :            :                 /* fall through */
   10730                 :          0 :         case 15:
   10731                 :          0 :                 tw32(MAC_RCV_RULE_14,  0); tw32(MAC_RCV_VALUE_14,  0);
   10732                 :            :                 /* fall through */
   10733                 :          0 :         case 14:
   10734                 :          0 :                 tw32(MAC_RCV_RULE_13,  0); tw32(MAC_RCV_VALUE_13,  0);
   10735                 :            :                 /* fall through */
   10736                 :          0 :         case 13:
   10737                 :          0 :                 tw32(MAC_RCV_RULE_12,  0); tw32(MAC_RCV_VALUE_12,  0);
   10738                 :            :                 /* fall through */
   10739                 :          0 :         case 12:
   10740                 :          0 :                 tw32(MAC_RCV_RULE_11,  0); tw32(MAC_RCV_VALUE_11,  0);
   10741                 :            :                 /* fall through */
   10742                 :          0 :         case 11:
   10743                 :          0 :                 tw32(MAC_RCV_RULE_10,  0); tw32(MAC_RCV_VALUE_10,  0);
   10744                 :            :                 /* fall through */
   10745                 :          0 :         case 10:
   10746                 :          0 :                 tw32(MAC_RCV_RULE_9,  0); tw32(MAC_RCV_VALUE_9,  0);
   10747                 :            :                 /* fall through */
   10748                 :          0 :         case 9:
   10749                 :          0 :                 tw32(MAC_RCV_RULE_8,  0); tw32(MAC_RCV_VALUE_8,  0);
   10750                 :            :                 /* fall through */
   10751                 :          0 :         case 8:
   10752                 :          0 :                 tw32(MAC_RCV_RULE_7,  0); tw32(MAC_RCV_VALUE_7,  0);
   10753                 :            :                 /* fall through */
   10754                 :          0 :         case 7:
   10755                 :          0 :                 tw32(MAC_RCV_RULE_6,  0); tw32(MAC_RCV_VALUE_6,  0);
   10756                 :            :                 /* fall through */
   10757                 :          0 :         case 6:
   10758                 :          0 :                 tw32(MAC_RCV_RULE_5,  0); tw32(MAC_RCV_VALUE_5,  0);
   10759                 :            :                 /* fall through */
   10760                 :          0 :         case 5:
   10761                 :          0 :                 tw32(MAC_RCV_RULE_4,  0); tw32(MAC_RCV_VALUE_4,  0);
   10762                 :            :                 /* fall through */
   10763                 :            :         case 4:
   10764                 :            :                 /* tw32(MAC_RCV_RULE_3,  0); tw32(MAC_RCV_VALUE_3,  0); */
   10765                 :            :         case 3:
   10766                 :            :                 /* tw32(MAC_RCV_RULE_2,  0); tw32(MAC_RCV_VALUE_2,  0); */
   10767                 :            :         case 2:
   10768                 :            :         case 1:
   10769                 :            : 
   10770                 :            :         default:
   10771                 :          0 :                 break;
   10772                 :            :         }
   10773                 :            : 
   10774         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_APE))
   10775                 :            :                 /* Write our heartbeat update interval to APE. */
   10776                 :          0 :                 tg3_ape_write32(tp, TG3_APE_HOST_HEARTBEAT_INT_MS,
   10777                 :            :                                 APE_HOST_HEARTBEAT_INT_5SEC);
   10778                 :            : 
   10779                 :          0 :         tg3_write_sig_post_reset(tp, RESET_KIND_INIT);
   10780                 :            : 
   10781                 :          0 :         return 0;
   10782                 :            : }
   10783                 :            : 
   10784                 :            : /* Called at device open time to get the chip ready for
   10785                 :            :  * packet processing.  Invoked with tp->lock held.
   10786                 :            :  */
   10787                 :          0 : static int tg3_init_hw(struct tg3 *tp, bool reset_phy)
   10788                 :            : {
   10789                 :            :         /* Chip may have been just powered on. If so, the boot code may still
   10790                 :            :          * be running initialization. Wait for it to finish to avoid races in
   10791                 :            :          * accessing the hardware.
   10792                 :            :          */
   10793                 :          0 :         tg3_enable_register_access(tp);
   10794                 :          0 :         tg3_poll_fw(tp);
   10795                 :            : 
   10796                 :          0 :         tg3_switch_clocks(tp);
   10797                 :            : 
   10798                 :          0 :         tw32(TG3PCI_MEM_WIN_BASE_ADDR, 0);
   10799                 :            : 
   10800                 :          0 :         return tg3_reset_hw(tp, reset_phy);
   10801                 :            : }
   10802                 :            : 
   10803                 :            : #ifdef CONFIG_TIGON3_HWMON
   10804                 :          0 : static void tg3_sd_scan_scratchpad(struct tg3 *tp, struct tg3_ocir *ocir)
   10805                 :            : {
   10806                 :          0 :         int i;
   10807                 :            : 
   10808         [ #  # ]:          0 :         for (i = 0; i < TG3_SD_NUM_RECS; i++, ocir++) {
   10809                 :          0 :                 u32 off = i * TG3_OCIR_LEN, len = TG3_OCIR_LEN;
   10810                 :            : 
   10811                 :          0 :                 tg3_ape_scratchpad_read(tp, (u32 *) ocir, off, len);
   10812                 :          0 :                 off += len;
   10813                 :            : 
   10814         [ #  # ]:          0 :                 if (ocir->signature != TG3_OCIR_SIG_MAGIC ||
   10815         [ #  # ]:          0 :                     !(ocir->version_flags & TG3_OCIR_FLAG_ACTIVE))
   10816                 :          0 :                         memset(ocir, 0, TG3_OCIR_LEN);
   10817                 :            :         }
   10818                 :          0 : }
   10819                 :            : 
   10820                 :            : /* sysfs attributes for hwmon */
   10821                 :          0 : static ssize_t tg3_show_temp(struct device *dev,
   10822                 :            :                              struct device_attribute *devattr, char *buf)
   10823                 :            : {
   10824                 :          0 :         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
   10825                 :          0 :         struct tg3 *tp = dev_get_drvdata(dev);
   10826                 :          0 :         u32 temperature;
   10827                 :            : 
   10828                 :          0 :         spin_lock_bh(&tp->lock);
   10829                 :          0 :         tg3_ape_scratchpad_read(tp, &temperature, attr->index,
   10830                 :            :                                 sizeof(temperature));
   10831                 :          0 :         spin_unlock_bh(&tp->lock);
   10832                 :          0 :         return sprintf(buf, "%u\n", temperature * 1000);
   10833                 :            : }
   10834                 :            : 
   10835                 :            : 
   10836                 :            : static SENSOR_DEVICE_ATTR(temp1_input, 0444, tg3_show_temp, NULL,
   10837                 :            :                           TG3_TEMP_SENSOR_OFFSET);
   10838                 :            : static SENSOR_DEVICE_ATTR(temp1_crit, 0444, tg3_show_temp, NULL,
   10839                 :            :                           TG3_TEMP_CAUTION_OFFSET);
   10840                 :            : static SENSOR_DEVICE_ATTR(temp1_max, 0444, tg3_show_temp, NULL,
   10841                 :            :                           TG3_TEMP_MAX_OFFSET);
   10842                 :            : 
   10843                 :            : static struct attribute *tg3_attrs[] = {
   10844                 :            :         &sensor_dev_attr_temp1_input.dev_attr.attr,
   10845                 :            :         &sensor_dev_attr_temp1_crit.dev_attr.attr,
   10846                 :            :         &sensor_dev_attr_temp1_max.dev_attr.attr,
   10847                 :            :         NULL
   10848                 :            : };
   10849                 :            : ATTRIBUTE_GROUPS(tg3);
   10850                 :            : 
   10851                 :          0 : static void tg3_hwmon_close(struct tg3 *tp)
   10852                 :            : {
   10853                 :          0 :         if (tp->hwmon_dev) {
   10854                 :          0 :                 hwmon_device_unregister(tp->hwmon_dev);
   10855                 :          0 :                 tp->hwmon_dev = NULL;
   10856                 :            :         }
   10857                 :            : }
   10858                 :            : 
   10859                 :          0 : static void tg3_hwmon_open(struct tg3 *tp)
   10860                 :            : {
   10861                 :          0 :         int i;
   10862                 :          0 :         u32 size = 0;
   10863                 :          0 :         struct pci_dev *pdev = tp->pdev;
   10864                 :          0 :         struct tg3_ocir ocirs[TG3_SD_NUM_RECS];
   10865                 :            : 
   10866                 :          0 :         tg3_sd_scan_scratchpad(tp, ocirs);
   10867                 :            : 
   10868         [ #  # ]:          0 :         for (i = 0; i < TG3_SD_NUM_RECS; i++) {
   10869         [ #  # ]:          0 :                 if (!ocirs[i].src_data_length)
   10870                 :          0 :                         continue;
   10871                 :            : 
   10872                 :          0 :                 size += ocirs[i].src_hdr_length;
   10873                 :          0 :                 size += ocirs[i].src_data_length;
   10874                 :            :         }
   10875                 :            : 
   10876         [ #  # ]:          0 :         if (!size)
   10877                 :          0 :                 return;
   10878                 :            : 
   10879                 :          0 :         tp->hwmon_dev = hwmon_device_register_with_groups(&pdev->dev, "tg3",
   10880                 :            :                                                           tp, tg3_groups);
   10881         [ #  # ]:          0 :         if (IS_ERR(tp->hwmon_dev)) {
   10882                 :          0 :                 tp->hwmon_dev = NULL;
   10883                 :          0 :                 dev_err(&pdev->dev, "Cannot register hwmon device, aborting\n");
   10884                 :            :         }
   10885                 :            : }
   10886                 :            : #else
   10887                 :            : static inline void tg3_hwmon_close(struct tg3 *tp) { }
   10888                 :            : static inline void tg3_hwmon_open(struct tg3 *tp) { }
   10889                 :            : #endif /* CONFIG_TIGON3_HWMON */
   10890                 :            : 
   10891                 :            : 
   10892                 :            : #define TG3_STAT_ADD32(PSTAT, REG) \
   10893                 :            : do {    u32 __val = tr32(REG); \
   10894                 :            :         (PSTAT)->low += __val; \
   10895                 :            :         if ((PSTAT)->low < __val) \
   10896                 :            :                 (PSTAT)->high += 1; \
   10897                 :            : } while (0)
   10898                 :            : 
   10899                 :          0 : static void tg3_periodic_fetch_stats(struct tg3 *tp)
   10900                 :            : {
   10901                 :          0 :         struct tg3_hw_stats *sp = tp->hw_stats;
   10902                 :            : 
   10903         [ #  # ]:          0 :         if (!tp->link_up)
   10904                 :            :                 return;
   10905                 :            : 
   10906         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->tx_octets, MAC_TX_STATS_OCTETS);
   10907         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->tx_collisions, MAC_TX_STATS_COLLISIONS);
   10908         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->tx_xon_sent, MAC_TX_STATS_XON_SENT);
   10909         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->tx_xoff_sent, MAC_TX_STATS_XOFF_SENT);
   10910         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->tx_mac_errors, MAC_TX_STATS_MAC_ERRORS);
   10911         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->tx_single_collisions, MAC_TX_STATS_SINGLE_COLLISIONS);
   10912         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->tx_mult_collisions, MAC_TX_STATS_MULT_COLLISIONS);
   10913         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->tx_deferred, MAC_TX_STATS_DEFERRED);
   10914         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->tx_excessive_collisions, MAC_TX_STATS_EXCESSIVE_COL);
   10915         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->tx_late_collisions, MAC_TX_STATS_LATE_COL);
   10916         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->tx_ucast_packets, MAC_TX_STATS_UCAST);
   10917         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->tx_mcast_packets, MAC_TX_STATS_MCAST);
   10918         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->tx_bcast_packets, MAC_TX_STATS_BCAST);
   10919   [ #  #  #  # ]:          0 :         if (unlikely(tg3_flag(tp, 5719_5720_RDMA_BUG) &&
   10920                 :            :                      (sp->tx_ucast_packets.low + sp->tx_mcast_packets.low +
   10921                 :            :                       sp->tx_bcast_packets.low) > TG3_NUM_RDMA_CHANNELS)) {
   10922                 :          0 :                 u32 val;
   10923                 :            : 
   10924                 :          0 :                 val = tr32(TG3_LSO_RD_DMA_CRPTEN_CTRL);
   10925         [ #  # ]:          0 :                 val &= ~tg3_lso_rd_dma_workaround_bit(tp);
   10926                 :          0 :                 tw32(TG3_LSO_RD_DMA_CRPTEN_CTRL, val);
   10927                 :          0 :                 tg3_flag_clear(tp, 5719_5720_RDMA_BUG);
   10928                 :            :         }
   10929                 :            : 
   10930         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->rx_octets, MAC_RX_STATS_OCTETS);
   10931         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->rx_fragments, MAC_RX_STATS_FRAGMENTS);
   10932         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->rx_ucast_packets, MAC_RX_STATS_UCAST);
   10933         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->rx_mcast_packets, MAC_RX_STATS_MCAST);
   10934         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->rx_bcast_packets, MAC_RX_STATS_BCAST);
   10935         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->rx_fcs_errors, MAC_RX_STATS_FCS_ERRORS);
   10936         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->rx_align_errors, MAC_RX_STATS_ALIGN_ERRORS);
   10937         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->rx_xon_pause_rcvd, MAC_RX_STATS_XON_PAUSE_RECVD);
   10938         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->rx_xoff_pause_rcvd, MAC_RX_STATS_XOFF_PAUSE_RECVD);
   10939         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->rx_mac_ctrl_rcvd, MAC_RX_STATS_MAC_CTRL_RECVD);
   10940         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->rx_xoff_entered, MAC_RX_STATS_XOFF_ENTERED);
   10941         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->rx_frame_too_long_errors, MAC_RX_STATS_FRAME_TOO_LONG);
   10942         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->rx_jabbers, MAC_RX_STATS_JABBERS);
   10943         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->rx_undersize_packets, MAC_RX_STATS_UNDERSIZE);
   10944                 :            : 
   10945         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->rxbds_empty, RCVLPC_NO_RCV_BD_CNT);
   10946         [ #  # ]:          0 :         if (tg3_asic_rev(tp) != ASIC_REV_5717 &&
   10947         [ #  # ]:          0 :             tg3_asic_rev(tp) != ASIC_REV_5762 &&
   10948         [ #  # ]:          0 :             tg3_chip_rev_id(tp) != CHIPREV_ID_5719_A0 &&
   10949                 :            :             tg3_chip_rev_id(tp) != CHIPREV_ID_5720_A0) {
   10950         [ #  # ]:          0 :                 TG3_STAT_ADD32(&sp->rx_discards, RCVLPC_IN_DISCARDS_CNT);
   10951                 :            :         } else {
   10952                 :          0 :                 u32 val = tr32(HOSTCC_FLOW_ATTN);
   10953                 :          0 :                 val = (val & HOSTCC_FLOW_ATTN_MBUF_LWM) ? 1 : 0;
   10954         [ #  # ]:          0 :                 if (val) {
   10955                 :          0 :                         tw32(HOSTCC_FLOW_ATTN, HOSTCC_FLOW_ATTN_MBUF_LWM);
   10956                 :          0 :                         sp->rx_discards.low += val;
   10957         [ #  # ]:          0 :                         if (sp->rx_discards.low < val)
   10958                 :          0 :                                 sp->rx_discards.high += 1;
   10959                 :            :                 }
   10960                 :          0 :                 sp->mbuf_lwm_thresh_hit = sp->rx_discards;
   10961                 :            :         }
   10962         [ #  # ]:          0 :         TG3_STAT_ADD32(&sp->rx_errors, RCVLPC_IN_ERRORS_CNT);
   10963                 :            : }
   10964                 :            : 
   10965                 :          0 : static void tg3_chk_missed_msi(struct tg3 *tp)
   10966                 :            : {
   10967                 :          0 :         u32 i;
   10968                 :            : 
   10969         [ #  # ]:          0 :         for (i = 0; i < tp->irq_cnt; i++) {
   10970                 :          0 :                 struct tg3_napi *tnapi = &tp->napi[i];
   10971                 :            : 
   10972         [ #  # ]:          0 :                 if (tg3_has_work(tnapi)) {
   10973         [ #  # ]:          0 :                         if (tnapi->last_rx_cons == tnapi->rx_rcb_ptr &&
   10974         [ #  # ]:          0 :                             tnapi->last_tx_cons == tnapi->tx_cons) {
   10975         [ #  # ]:          0 :                                 if (tnapi->chk_msi_cnt < 1) {
   10976                 :          0 :                                         tnapi->chk_msi_cnt++;
   10977                 :          0 :                                         return;
   10978                 :            :                                 }
   10979                 :          0 :                                 tg3_msi(0, tnapi);
   10980                 :            :                         }
   10981                 :            :                 }
   10982                 :          0 :                 tnapi->chk_msi_cnt = 0;
   10983                 :          0 :                 tnapi->last_rx_cons = tnapi->rx_rcb_ptr;
   10984                 :          0 :                 tnapi->last_tx_cons = tnapi->tx_cons;
   10985                 :            :         }
   10986                 :            : }
   10987                 :            : 
   10988                 :          0 : static void tg3_timer(struct timer_list *t)
   10989                 :            : {
   10990                 :          0 :         struct tg3 *tp = from_timer(tp, t, timer);
   10991                 :            : 
   10992                 :          0 :         spin_lock(&tp->lock);
   10993                 :            : 
   10994   [ #  #  #  # ]:          0 :         if (tp->irq_sync || tg3_flag(tp, RESET_TASK_PENDING)) {
   10995                 :          0 :                 spin_unlock(&tp->lock);
   10996                 :          0 :                 goto restart_timer;
   10997                 :            :         }
   10998                 :            : 
   10999   [ #  #  #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5717 ||
   11000                 :            :             tg3_flag(tp, 57765_CLASS))
   11001                 :          0 :                 tg3_chk_missed_msi(tp);
   11002                 :            : 
   11003         [ #  # ]:          0 :         if (tg3_flag(tp, FLUSH_POSTED_WRITES)) {
   11004                 :            :                 /* BCM4785: Flush posted writes from GbE to host memory. */
   11005                 :          0 :                 tr32(HOSTCC_MODE);
   11006                 :            :         }
   11007                 :            : 
   11008         [ #  # ]:          0 :         if (!tg3_flag(tp, TAGGED_STATUS)) {
   11009                 :            :                 /* All of this garbage is because when using non-tagged
   11010                 :            :                  * IRQ status the mailbox/status_block protocol the chip
   11011                 :            :                  * uses with the cpu is race prone.
   11012                 :            :                  */
   11013         [ #  # ]:          0 :                 if (tp->napi[0].hw_status->status & SD_STATUS_UPDATED) {
   11014                 :          0 :                         tw32(GRC_LOCAL_CTRL,
   11015                 :            :                              tp->grc_local_ctrl | GRC_LCLCTRL_SETINT);
   11016                 :            :                 } else {
   11017                 :          0 :                         tw32(HOSTCC_MODE, tp->coalesce_mode |
   11018                 :            :                              HOSTCC_MODE_ENABLE | HOSTCC_MODE_NOW);
   11019                 :            :                 }
   11020                 :            : 
   11021         [ #  # ]:          0 :                 if (!(tr32(WDMAC_MODE) & WDMAC_MODE_ENABLE)) {
   11022                 :          0 :                         spin_unlock(&tp->lock);
   11023                 :          0 :                         tg3_reset_task_schedule(tp);
   11024                 :          0 :                         goto restart_timer;
   11025                 :            :                 }
   11026                 :            :         }
   11027                 :            : 
   11028                 :            :         /* This part only runs once per second. */
   11029         [ #  # ]:          0 :         if (!--tp->timer_counter) {
   11030         [ #  # ]:          0 :                 if (tg3_flag(tp, 5705_PLUS))
   11031                 :          0 :                         tg3_periodic_fetch_stats(tp);
   11032                 :            : 
   11033   [ #  #  #  # ]:          0 :                 if (tp->setlpicnt && !--tp->setlpicnt)
   11034                 :          0 :                         tg3_phy_eee_enable(tp);
   11035                 :            : 
   11036         [ #  # ]:          0 :                 if (tg3_flag(tp, USE_LINKCHG_REG)) {
   11037                 :          0 :                         u32 mac_stat;
   11038                 :          0 :                         int phy_event;
   11039                 :            : 
   11040                 :          0 :                         mac_stat = tr32(MAC_STATUS);
   11041                 :            : 
   11042                 :          0 :                         phy_event = 0;
   11043         [ #  # ]:          0 :                         if (tp->phy_flags & TG3_PHYFLG_USE_MI_INTERRUPT) {
   11044         [ #  # ]:          0 :                                 if (mac_stat & MAC_STATUS_MI_INTERRUPT)
   11045                 :            :                                         phy_event = 1;
   11046         [ #  # ]:          0 :                         } else if (mac_stat & MAC_STATUS_LNKSTATE_CHANGED)
   11047                 :            :                                 phy_event = 1;
   11048                 :            : 
   11049                 :            :                         if (phy_event)
   11050                 :          0 :                                 tg3_setup_phy(tp, false);
   11051         [ #  # ]:          0 :                 } else if (tg3_flag(tp, POLL_SERDES)) {
   11052                 :          0 :                         u32 mac_stat = tr32(MAC_STATUS);
   11053                 :          0 :                         int need_setup = 0;
   11054                 :            : 
   11055         [ #  # ]:          0 :                         if (tp->link_up &&
   11056         [ #  # ]:          0 :                             (mac_stat & MAC_STATUS_LNKSTATE_CHANGED)) {
   11057                 :          0 :                                 need_setup = 1;
   11058                 :            :                         }
   11059         [ #  # ]:          0 :                         if (!tp->link_up &&
   11060         [ #  # ]:          0 :                             (mac_stat & (MAC_STATUS_PCS_SYNCED |
   11061                 :            :                                          MAC_STATUS_SIGNAL_DET))) {
   11062                 :            :                                 need_setup = 1;
   11063                 :            :                         }
   11064         [ #  # ]:          0 :                         if (need_setup) {
   11065         [ #  # ]:          0 :                                 if (!tp->serdes_counter) {
   11066                 :          0 :                                         tw32_f(MAC_MODE,
   11067                 :            :                                              (tp->mac_mode &
   11068                 :            :                                               ~MAC_MODE_PORT_MODE_MASK));
   11069                 :          0 :                                         udelay(40);
   11070                 :          0 :                                         tw32_f(MAC_MODE, tp->mac_mode);
   11071                 :          0 :                                         udelay(40);
   11072                 :            :                                 }
   11073                 :          0 :                                 tg3_setup_phy(tp, false);
   11074                 :            :                         }
   11075   [ #  #  #  # ]:          0 :                 } else if ((tp->phy_flags & TG3_PHYFLG_MII_SERDES) &&
   11076                 :            :                            tg3_flag(tp, 5780_CLASS)) {
   11077                 :          0 :                         tg3_serdes_parallel_detect(tp);
   11078         [ #  # ]:          0 :                 } else if (tg3_flag(tp, POLL_CPMU_LINK)) {
   11079                 :          0 :                         u32 cpmu = tr32(TG3_CPMU_STATUS);
   11080                 :          0 :                         bool link_up = !((cpmu & TG3_CPMU_STATUS_LINK_MASK) ==
   11081                 :            :                                          TG3_CPMU_STATUS_LINK_MASK);
   11082                 :            : 
   11083         [ #  # ]:          0 :                         if (link_up != tp->link_up)
   11084                 :          0 :                                 tg3_setup_phy(tp, false);
   11085                 :            :                 }
   11086                 :            : 
   11087                 :          0 :                 tp->timer_counter = tp->timer_multiplier;
   11088                 :            :         }
   11089                 :            : 
   11090                 :            :         /* Heartbeat is only sent once every 2 seconds.
   11091                 :            :          *
   11092                 :            :          * The heartbeat is to tell the ASF firmware that the host
   11093                 :            :          * driver is still alive.  In the event that the OS crashes,
   11094                 :            :          * ASF needs to reset the hardware to free up the FIFO space
   11095                 :            :          * that may be filled with rx packets destined for the host.
   11096                 :            :          * If the FIFO is full, ASF will no longer function properly.
   11097                 :            :          *
   11098                 :            :          * Unintended resets have been reported on real time kernels
   11099                 :            :          * where the timer doesn't run on time.  Netpoll will also have
   11100                 :            :          * same problem.
   11101                 :            :          *
   11102                 :            :          * The new FWCMD_NICDRV_ALIVE3 command tells the ASF firmware
   11103                 :            :          * to check the ring condition when the heartbeat is expiring
   11104                 :            :          * before doing the reset.  This will prevent most unintended
   11105                 :            :          * resets.
   11106                 :            :          */
   11107         [ #  # ]:          0 :         if (!--tp->asf_counter) {
   11108   [ #  #  #  # ]:          0 :                 if (tg3_flag(tp, ENABLE_ASF) && !tg3_flag(tp, ENABLE_APE)) {
   11109                 :          0 :                         tg3_wait_for_event_ack(tp);
   11110                 :            : 
   11111                 :          0 :                         tg3_write_mem(tp, NIC_SRAM_FW_CMD_MBOX,
   11112                 :            :                                       FWCMD_NICDRV_ALIVE3);
   11113                 :          0 :                         tg3_write_mem(tp, NIC_SRAM_FW_CMD_LEN_MBOX, 4);
   11114                 :          0 :                         tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX,
   11115                 :            :                                       TG3_FW_UPDATE_TIMEOUT_SEC);
   11116                 :            : 
   11117                 :          0 :                         tg3_generate_fw_event(tp);
   11118                 :            :                 }
   11119                 :          0 :                 tp->asf_counter = tp->asf_multiplier;
   11120                 :            :         }
   11121                 :            : 
   11122                 :            :         /* Update the APE heartbeat every 5 seconds.*/
   11123                 :          0 :         tg3_send_ape_heartbeat(tp, TG3_APE_HB_INTERVAL);
   11124                 :            : 
   11125                 :          0 :         spin_unlock(&tp->lock);
   11126                 :            : 
   11127                 :          0 : restart_timer:
   11128                 :          0 :         tp->timer.expires = jiffies + tp->timer_offset;
   11129                 :          0 :         add_timer(&tp->timer);
   11130                 :          0 : }
   11131                 :            : 
   11132                 :          0 : static void tg3_timer_init(struct tg3 *tp)
   11133                 :            : {
   11134         [ #  # ]:          0 :         if (tg3_flag(tp, TAGGED_STATUS) &&
   11135   [ #  #  #  # ]:          0 :             tg3_asic_rev(tp) != ASIC_REV_5717 &&
   11136                 :            :             !tg3_flag(tp, 57765_CLASS))
   11137                 :          0 :                 tp->timer_offset = HZ;
   11138                 :            :         else
   11139                 :          0 :                 tp->timer_offset = HZ / 10;
   11140                 :            : 
   11141         [ #  # ]:          0 :         BUG_ON(tp->timer_offset > HZ);
   11142                 :            : 
   11143                 :          0 :         tp->timer_multiplier = (HZ / tp->timer_offset);
   11144                 :          0 :         tp->asf_multiplier = (HZ / tp->timer_offset) *
   11145                 :            :                              TG3_FW_UPDATE_FREQ_SEC;
   11146                 :            : 
   11147                 :          0 :         timer_setup(&tp->timer, tg3_timer, 0);
   11148                 :          0 : }
   11149                 :            : 
   11150                 :          0 : static void tg3_timer_start(struct tg3 *tp)
   11151                 :            : {
   11152                 :          0 :         tp->asf_counter   = tp->asf_multiplier;
   11153                 :          0 :         tp->timer_counter = tp->timer_multiplier;
   11154                 :            : 
   11155                 :          0 :         tp->timer.expires = jiffies + tp->timer_offset;
   11156                 :          0 :         add_timer(&tp->timer);
   11157                 :            : }
   11158                 :            : 
   11159                 :          0 : static void tg3_timer_stop(struct tg3 *tp)
   11160                 :            : {
   11161                 :          0 :         del_timer_sync(&tp->timer);
   11162                 :            : }
   11163                 :            : 
   11164                 :            : /* Restart hardware after configuration changes, self-test, etc.
   11165                 :            :  * Invoked with tp->lock held.
   11166                 :            :  */
   11167                 :          0 : static int tg3_restart_hw(struct tg3 *tp, bool reset_phy)
   11168                 :            :         __releases(tp->lock)
   11169                 :            :         __acquires(tp->lock)
   11170                 :            : {
   11171                 :          0 :         int err;
   11172                 :            : 
   11173                 :          0 :         err = tg3_init_hw(tp, reset_phy);
   11174         [ #  # ]:          0 :         if (err) {
   11175                 :          0 :                 netdev_err(tp->dev,
   11176                 :            :                            "Failed to re-initialize device, aborting\n");
   11177                 :          0 :                 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
   11178                 :          0 :                 tg3_full_unlock(tp);
   11179                 :          0 :                 tg3_timer_stop(tp);
   11180                 :          0 :                 tp->irq_sync = 0;
   11181                 :          0 :                 tg3_napi_enable(tp);
   11182                 :          0 :                 dev_close(tp->dev);
   11183                 :          0 :                 tg3_full_lock(tp, 0);
   11184                 :            :         }
   11185                 :          0 :         return err;
   11186                 :            : }
   11187                 :            : 
   11188                 :          0 : static void tg3_reset_task(struct work_struct *work)
   11189                 :            : {
   11190                 :          0 :         struct tg3 *tp = container_of(work, struct tg3, reset_task);
   11191                 :          0 :         int err;
   11192                 :            : 
   11193                 :          0 :         rtnl_lock();
   11194                 :          0 :         tg3_full_lock(tp, 0);
   11195                 :            : 
   11196         [ #  # ]:          0 :         if (!netif_running(tp->dev)) {
   11197                 :          0 :                 tg3_flag_clear(tp, RESET_TASK_PENDING);
   11198                 :          0 :                 tg3_full_unlock(tp);
   11199                 :          0 :                 rtnl_unlock();
   11200                 :          0 :                 return;
   11201                 :            :         }
   11202                 :            : 
   11203                 :          0 :         tg3_full_unlock(tp);
   11204                 :            : 
   11205                 :          0 :         tg3_phy_stop(tp);
   11206                 :            : 
   11207                 :          0 :         tg3_netif_stop(tp);
   11208                 :            : 
   11209                 :          0 :         tg3_full_lock(tp, 1);
   11210                 :            : 
   11211         [ #  # ]:          0 :         if (tg3_flag(tp, TX_RECOVERY_PENDING)) {
   11212                 :          0 :                 tp->write32_tx_mbox = tg3_write32_tx_mbox;
   11213                 :          0 :                 tp->write32_rx_mbox = tg3_write_flush_reg32;
   11214                 :          0 :                 tg3_flag_set(tp, MBOX_WRITE_REORDER);
   11215                 :          0 :                 tg3_flag_clear(tp, TX_RECOVERY_PENDING);
   11216                 :            :         }
   11217                 :            : 
   11218                 :          0 :         tg3_halt(tp, RESET_KIND_SHUTDOWN, 0);
   11219                 :          0 :         err = tg3_init_hw(tp, true);
   11220         [ #  # ]:          0 :         if (err)
   11221                 :          0 :                 goto out;
   11222                 :            : 
   11223                 :          0 :         tg3_netif_start(tp);
   11224                 :            : 
   11225                 :          0 : out:
   11226                 :          0 :         tg3_full_unlock(tp);
   11227                 :            : 
   11228         [ #  # ]:          0 :         if (!err)
   11229                 :          0 :                 tg3_phy_start(tp);
   11230                 :            : 
   11231                 :          0 :         tg3_flag_clear(tp, RESET_TASK_PENDING);
   11232                 :          0 :         rtnl_unlock();
   11233                 :            : }
   11234                 :            : 
   11235                 :          0 : static int tg3_request_irq(struct tg3 *tp, int irq_num)
   11236                 :            : {
   11237                 :          0 :         irq_handler_t fn;
   11238                 :          0 :         unsigned long flags;
   11239                 :          0 :         char *name;
   11240                 :          0 :         struct tg3_napi *tnapi = &tp->napi[irq_num];
   11241                 :            : 
   11242         [ #  # ]:          0 :         if (tp->irq_cnt == 1)
   11243                 :          0 :                 name = tp->dev->name;
   11244                 :            :         else {
   11245                 :          0 :                 name = &tnapi->irq_lbl[0];
   11246   [ #  #  #  # ]:          0 :                 if (tnapi->tx_buffers && tnapi->rx_rcb)
   11247                 :          0 :                         snprintf(name, IFNAMSIZ,
   11248                 :          0 :                                  "%s-txrx-%d", tp->dev->name, irq_num);
   11249         [ #  # ]:          0 :                 else if (tnapi->tx_buffers)
   11250                 :          0 :                         snprintf(name, IFNAMSIZ,
   11251                 :          0 :                                  "%s-tx-%d", tp->dev->name, irq_num);
   11252         [ #  # ]:          0 :                 else if (tnapi->rx_rcb)
   11253                 :          0 :                         snprintf(name, IFNAMSIZ,
   11254                 :          0 :                                  "%s-rx-%d", tp->dev->name, irq_num);
   11255                 :            :                 else
   11256                 :          0 :                         snprintf(name, IFNAMSIZ,
   11257                 :          0 :                                  "%s-%d", tp->dev->name, irq_num);
   11258                 :          0 :                 name[IFNAMSIZ-1] = 0;
   11259                 :            :         }
   11260                 :            : 
   11261   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, USING_MSI) || tg3_flag(tp, USING_MSIX)) {
   11262                 :          0 :                 fn = tg3_msi;
   11263         [ #  # ]:          0 :                 if (tg3_flag(tp, 1SHOT_MSI))
   11264                 :          0 :                         fn = tg3_msi_1shot;
   11265                 :            :                 flags = 0;
   11266                 :            :         } else {
   11267                 :          0 :                 fn = tg3_interrupt;
   11268         [ #  # ]:          0 :                 if (tg3_flag(tp, TAGGED_STATUS))
   11269                 :          0 :                         fn = tg3_interrupt_tagged;
   11270                 :            :                 flags = IRQF_SHARED;
   11271                 :            :         }
   11272                 :            : 
   11273                 :          0 :         return request_irq(tnapi->irq_vec, fn, flags, name, tnapi);
   11274                 :            : }
   11275                 :            : 
   11276                 :          0 : static int tg3_test_interrupt(struct tg3 *tp)
   11277                 :            : {
   11278                 :          0 :         struct tg3_napi *tnapi = &tp->napi[0];
   11279                 :          0 :         struct net_device *dev = tp->dev;
   11280                 :          0 :         int err, i, intr_ok = 0;
   11281                 :          0 :         u32 val;
   11282                 :            : 
   11283         [ #  # ]:          0 :         if (!netif_running(dev))
   11284                 :            :                 return -ENODEV;
   11285                 :            : 
   11286                 :          0 :         tg3_disable_ints(tp);
   11287                 :            : 
   11288                 :          0 :         free_irq(tnapi->irq_vec, tnapi);
   11289                 :            : 
   11290                 :            :         /*
   11291                 :            :          * Turn off MSI one shot mode.  Otherwise this test has no
   11292                 :            :          * observable way to know whether the interrupt was delivered.
   11293                 :            :          */
   11294         [ #  # ]:          0 :         if (tg3_flag(tp, 57765_PLUS)) {
   11295                 :          0 :                 val = tr32(MSGINT_MODE) | MSGINT_MODE_ONE_SHOT_DISABLE;
   11296                 :          0 :                 tw32(MSGINT_MODE, val);
   11297                 :            :         }
   11298                 :            : 
   11299                 :          0 :         err = request_irq(tnapi->irq_vec, tg3_test_isr,
   11300                 :          0 :                           IRQF_SHARED, dev->name, tnapi);
   11301         [ #  # ]:          0 :         if (err)
   11302                 :            :                 return err;
   11303                 :            : 
   11304                 :          0 :         tnapi->hw_status->status &= ~SD_STATUS_UPDATED;
   11305                 :          0 :         tg3_enable_ints(tp);
   11306                 :            : 
   11307                 :          0 :         tw32_f(HOSTCC_MODE, tp->coalesce_mode | HOSTCC_MODE_ENABLE |
   11308                 :            :                tnapi->coal_now);
   11309                 :            : 
   11310         [ #  # ]:          0 :         for (i = 0; i < 5; i++) {
   11311                 :          0 :                 u32 int_mbox, misc_host_ctrl;
   11312                 :            : 
   11313                 :          0 :                 int_mbox = tr32_mailbox(tnapi->int_mbox);
   11314                 :          0 :                 misc_host_ctrl = tr32(TG3PCI_MISC_HOST_CTRL);
   11315                 :            : 
   11316         [ #  # ]:          0 :                 if ((int_mbox != 0) ||
   11317         [ #  # ]:          0 :                     (misc_host_ctrl & MISC_HOST_CTRL_MASK_PCI_INT)) {
   11318                 :            :                         intr_ok = 1;
   11319                 :            :                         break;
   11320                 :            :                 }
   11321                 :            : 
   11322         [ #  # ]:          0 :                 if (tg3_flag(tp, 57765_PLUS) &&
   11323         [ #  # ]:          0 :                     tnapi->hw_status->status_tag != tnapi->last_tag)
   11324                 :          0 :                         tw32_mailbox_f(tnapi->int_mbox, tnapi->last_tag << 24);
   11325                 :            : 
   11326                 :          0 :                 msleep(10);
   11327                 :            :         }
   11328                 :            : 
   11329                 :          0 :         tg3_disable_ints(tp);
   11330                 :            : 
   11331                 :          0 :         free_irq(tnapi->irq_vec, tnapi);
   11332                 :            : 
   11333                 :          0 :         err = tg3_request_irq(tp, 0);
   11334                 :            : 
   11335         [ #  # ]:          0 :         if (err)
   11336                 :            :                 return err;
   11337                 :            : 
   11338         [ #  # ]:          0 :         if (intr_ok) {
   11339                 :            :                 /* Reenable MSI one shot mode. */
   11340   [ #  #  #  # ]:          0 :                 if (tg3_flag(tp, 57765_PLUS) && tg3_flag(tp, 1SHOT_MSI)) {
   11341                 :          0 :                         val = tr32(MSGINT_MODE) & ~MSGINT_MODE_ONE_SHOT_DISABLE;
   11342                 :          0 :                         tw32(MSGINT_MODE, val);
   11343                 :            :                 }
   11344                 :          0 :                 return 0;
   11345                 :            :         }
   11346                 :            : 
   11347                 :            :         return -EIO;
   11348                 :            : }
   11349                 :            : 
   11350                 :            : /* Returns 0 if MSI test succeeds or MSI test fails and INTx mode is
   11351                 :            :  * successfully restored
   11352                 :            :  */
   11353                 :          0 : static int tg3_test_msi(struct tg3 *tp)
   11354                 :            : {
   11355                 :          0 :         int err;
   11356                 :          0 :         u16 pci_cmd;
   11357                 :            : 
   11358         [ #  # ]:          0 :         if (!tg3_flag(tp, USING_MSI))
   11359                 :            :                 return 0;
   11360                 :            : 
   11361                 :            :         /* Turn off SERR reporting in case MSI terminates with Master
   11362                 :            :          * Abort.
   11363                 :            :          */
   11364                 :          0 :         pci_read_config_word(tp->pdev, PCI_COMMAND, &pci_cmd);
   11365                 :          0 :         pci_write_config_word(tp->pdev, PCI_COMMAND,
   11366                 :          0 :                               pci_cmd & ~PCI_COMMAND_SERR);
   11367                 :            : 
   11368                 :          0 :         err = tg3_test_interrupt(tp);
   11369                 :            : 
   11370                 :          0 :         pci_write_config_word(tp->pdev, PCI_COMMAND, pci_cmd);
   11371                 :            : 
   11372         [ #  # ]:          0 :         if (!err)
   11373                 :            :                 return 0;
   11374                 :            : 
   11375                 :            :         /* other failures */
   11376         [ #  # ]:          0 :         if (err != -EIO)
   11377                 :            :                 return err;
   11378                 :            : 
   11379                 :            :         /* MSI test failed, go back to INTx mode */
   11380                 :          0 :         netdev_warn(tp->dev, "No interrupt was generated using MSI. Switching "
   11381                 :            :                     "to INTx mode. Please report this failure to the PCI "
   11382                 :            :                     "maintainer and include system chipset information\n");
   11383                 :            : 
   11384                 :          0 :         free_irq(tp->napi[0].irq_vec, &tp->napi[0]);
   11385                 :            : 
   11386                 :          0 :         pci_disable_msi(tp->pdev);
   11387                 :            : 
   11388                 :          0 :         tg3_flag_clear(tp, USING_MSI);
   11389                 :          0 :         tp->napi[0].irq_vec = tp->pdev->irq;
   11390                 :            : 
   11391                 :          0 :         err = tg3_request_irq(tp, 0);
   11392         [ #  # ]:          0 :         if (err)
   11393                 :            :                 return err;
   11394                 :            : 
   11395                 :            :         /* Need to reset the chip because the MSI cycle may have terminated
   11396                 :            :          * with Master Abort.
   11397                 :            :          */
   11398                 :          0 :         tg3_full_lock(tp, 1);
   11399                 :            : 
   11400                 :          0 :         tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
   11401                 :          0 :         err = tg3_init_hw(tp, true);
   11402                 :            : 
   11403                 :          0 :         tg3_full_unlock(tp);
   11404                 :            : 
   11405         [ #  # ]:          0 :         if (err)
   11406                 :          0 :                 free_irq(tp->napi[0].irq_vec, &tp->napi[0]);
   11407                 :            : 
   11408                 :            :         return err;
   11409                 :            : }
   11410                 :            : 
   11411                 :          0 : static int tg3_request_firmware(struct tg3 *tp)
   11412                 :            : {
   11413                 :          0 :         const struct tg3_firmware_hdr *fw_hdr;
   11414                 :            : 
   11415         [ #  # ]:          0 :         if (request_firmware(&tp->fw, tp->fw_needed, &tp->pdev->dev)) {
   11416                 :          0 :                 netdev_err(tp->dev, "Failed to load firmware \"%s\"\n",
   11417                 :            :                            tp->fw_needed);
   11418                 :          0 :                 return -ENOENT;
   11419                 :            :         }
   11420                 :            : 
   11421                 :          0 :         fw_hdr = (struct tg3_firmware_hdr *)tp->fw->data;
   11422                 :            : 
   11423                 :            :         /* Firmware blob starts with version numbers, followed by
   11424                 :            :          * start address and _full_ length including BSS sections
   11425                 :            :          * (which must be longer than the actual data, of course
   11426                 :            :          */
   11427                 :            : 
   11428                 :          0 :         tp->fw_len = be32_to_cpu(fw_hdr->len);    /* includes bss */
   11429         [ #  # ]:          0 :         if (tp->fw_len < (tp->fw->size - TG3_FW_HDR_LEN)) {
   11430                 :          0 :                 netdev_err(tp->dev, "bogus length %d in \"%s\"\n",
   11431                 :            :                            tp->fw_len, tp->fw_needed);
   11432                 :          0 :                 release_firmware(tp->fw);
   11433                 :          0 :                 tp->fw = NULL;
   11434                 :          0 :                 return -EINVAL;
   11435                 :            :         }
   11436                 :            : 
   11437                 :            :         /* We no longer need firmware; we have it. */
   11438                 :          0 :         tp->fw_needed = NULL;
   11439                 :          0 :         return 0;
   11440                 :            : }
   11441                 :            : 
   11442                 :          0 : static u32 tg3_irq_count(struct tg3 *tp)
   11443                 :            : {
   11444                 :          0 :         u32 irq_cnt = max(tp->rxq_cnt, tp->txq_cnt);
   11445                 :            : 
   11446                 :          0 :         if (irq_cnt > 1) {
   11447                 :            :                 /* We want as many rx rings enabled as there are cpus.
   11448                 :            :                  * In multiqueue MSI-X mode, the first MSI-X vector
   11449                 :            :                  * only deals with link interrupts, etc, so we add
   11450                 :            :                  * one to the number of vectors we are requesting.
   11451                 :            :                  */
   11452                 :          0 :                 irq_cnt = min_t(unsigned, irq_cnt + 1, tp->irq_max);
   11453                 :            :         }
   11454                 :            : 
   11455                 :          0 :         return irq_cnt;
   11456                 :            : }
   11457                 :            : 
   11458                 :          0 : static bool tg3_enable_msix(struct tg3 *tp)
   11459                 :            : {
   11460                 :          0 :         int i, rc;
   11461                 :          0 :         struct msix_entry msix_ent[TG3_IRQ_MAX_VECS];
   11462                 :            : 
   11463                 :          0 :         tp->txq_cnt = tp->txq_req;
   11464                 :          0 :         tp->rxq_cnt = tp->rxq_req;
   11465         [ #  # ]:          0 :         if (!tp->rxq_cnt)
   11466                 :          0 :                 tp->rxq_cnt = netif_get_num_default_rss_queues();
   11467         [ #  # ]:          0 :         if (tp->rxq_cnt > tp->rxq_max)
   11468                 :          0 :                 tp->rxq_cnt = tp->rxq_max;
   11469                 :            : 
   11470                 :            :         /* Disable multiple TX rings by default.  Simple round-robin hardware
   11471                 :            :          * scheduling of the TX rings can cause starvation of rings with
   11472                 :            :          * small packets when other rings have TSO or jumbo packets.
   11473                 :            :          */
   11474         [ #  # ]:          0 :         if (!tp->txq_req)
   11475                 :          0 :                 tp->txq_cnt = 1;
   11476                 :            : 
   11477         [ #  # ]:          0 :         tp->irq_cnt = tg3_irq_count(tp);
   11478                 :            : 
   11479         [ #  # ]:          0 :         for (i = 0; i < tp->irq_max; i++) {
   11480                 :          0 :                 msix_ent[i].entry  = i;
   11481                 :          0 :                 msix_ent[i].vector = 0;
   11482                 :            :         }
   11483                 :            : 
   11484                 :          0 :         rc = pci_enable_msix_range(tp->pdev, msix_ent, 1, tp->irq_cnt);
   11485         [ #  # ]:          0 :         if (rc < 0) {
   11486                 :            :                 return false;
   11487         [ #  # ]:          0 :         } else if (rc < tp->irq_cnt) {
   11488                 :          0 :                 netdev_notice(tp->dev, "Requested %d MSI-X vectors, received %d\n",
   11489                 :            :                               tp->irq_cnt, rc);
   11490                 :          0 :                 tp->irq_cnt = rc;
   11491                 :          0 :                 tp->rxq_cnt = max(rc - 1, 1);
   11492         [ #  # ]:          0 :                 if (tp->txq_cnt)
   11493                 :          0 :                         tp->txq_cnt = min(tp->rxq_cnt, tp->txq_max);
   11494                 :            :         }
   11495                 :            : 
   11496         [ #  # ]:          0 :         for (i = 0; i < tp->irq_max; i++)
   11497                 :          0 :                 tp->napi[i].irq_vec = msix_ent[i].vector;
   11498                 :            : 
   11499         [ #  # ]:          0 :         if (netif_set_real_num_rx_queues(tp->dev, tp->rxq_cnt)) {
   11500                 :          0 :                 pci_disable_msix(tp->pdev);
   11501                 :          0 :                 return false;
   11502                 :            :         }
   11503                 :            : 
   11504         [ #  # ]:          0 :         if (tp->irq_cnt == 1)
   11505                 :            :                 return true;
   11506                 :            : 
   11507                 :          0 :         tg3_flag_set(tp, ENABLE_RSS);
   11508                 :            : 
   11509         [ #  # ]:          0 :         if (tp->txq_cnt > 1)
   11510                 :          0 :                 tg3_flag_set(tp, ENABLE_TSS);
   11511                 :            : 
   11512                 :          0 :         netif_set_real_num_tx_queues(tp->dev, tp->txq_cnt);
   11513                 :            : 
   11514                 :          0 :         return true;
   11515                 :            : }
   11516                 :            : 
   11517                 :          0 : static void tg3_ints_init(struct tg3 *tp)
   11518                 :            : {
   11519   [ #  #  #  #  :          0 :         if ((tg3_flag(tp, SUPPORT_MSI) || tg3_flag(tp, SUPPORT_MSIX)) &&
                   #  # ]
   11520                 :            :             !tg3_flag(tp, TAGGED_STATUS)) {
   11521                 :            :                 /* All MSI supporting chips should support tagged
   11522                 :            :                  * status.  Assert that this is the case.
   11523                 :            :                  */
   11524                 :          0 :                 netdev_warn(tp->dev,
   11525                 :            :                             "MSI without TAGGED_STATUS? Not using MSI\n");
   11526                 :          0 :                 goto defcfg;
   11527                 :            :         }
   11528                 :            : 
   11529   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, SUPPORT_MSIX) && tg3_enable_msix(tp))
   11530                 :          0 :                 tg3_flag_set(tp, USING_MSIX);
   11531   [ #  #  #  # ]:          0 :         else if (tg3_flag(tp, SUPPORT_MSI) && pci_enable_msi(tp->pdev) == 0)
   11532                 :          0 :                 tg3_flag_set(tp, USING_MSI);
   11533                 :            : 
   11534   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, USING_MSI) || tg3_flag(tp, USING_MSIX)) {
   11535                 :          0 :                 u32 msi_mode = tr32(MSGINT_MODE);
   11536   [ #  #  #  # ]:          0 :                 if (tg3_flag(tp, USING_MSIX) && tp->irq_cnt > 1)
   11537                 :          0 :                         msi_mode |= MSGINT_MODE_MULTIVEC_EN;
   11538         [ #  # ]:          0 :                 if (!tg3_flag(tp, 1SHOT_MSI))
   11539                 :          0 :                         msi_mode |= MSGINT_MODE_ONE_SHOT_DISABLE;
   11540                 :          0 :                 tw32(MSGINT_MODE, msi_mode | MSGINT_MODE_ENABLE);
   11541                 :            :         }
   11542                 :          0 : defcfg:
   11543         [ #  # ]:          0 :         if (!tg3_flag(tp, USING_MSIX)) {
   11544                 :          0 :                 tp->irq_cnt = 1;
   11545                 :          0 :                 tp->napi[0].irq_vec = tp->pdev->irq;
   11546                 :            :         }
   11547                 :            : 
   11548         [ #  # ]:          0 :         if (tp->irq_cnt == 1) {
   11549                 :          0 :                 tp->txq_cnt = 1;
   11550                 :          0 :                 tp->rxq_cnt = 1;
   11551                 :          0 :                 netif_set_real_num_tx_queues(tp->dev, 1);
   11552                 :          0 :                 netif_set_real_num_rx_queues(tp->dev, 1);
   11553                 :            :         }
   11554                 :          0 : }
   11555                 :            : 
   11556                 :          0 : static void tg3_ints_fini(struct tg3 *tp)
   11557                 :            : {
   11558         [ #  # ]:          0 :         if (tg3_flag(tp, USING_MSIX))
   11559                 :          0 :                 pci_disable_msix(tp->pdev);
   11560         [ #  # ]:          0 :         else if (tg3_flag(tp, USING_MSI))
   11561                 :          0 :                 pci_disable_msi(tp->pdev);
   11562                 :          0 :         tg3_flag_clear(tp, USING_MSI);
   11563                 :          0 :         tg3_flag_clear(tp, USING_MSIX);
   11564                 :          0 :         tg3_flag_clear(tp, ENABLE_RSS);
   11565                 :          0 :         tg3_flag_clear(tp, ENABLE_TSS);
   11566                 :          0 : }
   11567                 :            : 
   11568                 :          0 : static int tg3_start(struct tg3 *tp, bool reset_phy, bool test_irq,
   11569                 :            :                      bool init)
   11570                 :            : {
   11571                 :          0 :         struct net_device *dev = tp->dev;
   11572                 :          0 :         int i, err;
   11573                 :            : 
   11574                 :            :         /*
   11575                 :            :          * Setup interrupts first so we know how
   11576                 :            :          * many NAPI resources to allocate
   11577                 :            :          */
   11578                 :          0 :         tg3_ints_init(tp);
   11579                 :            : 
   11580                 :          0 :         tg3_rss_check_indir_tbl(tp);
   11581                 :            : 
   11582                 :            :         /* The placement of this call is tied
   11583                 :            :          * to the setup and use of Host TX descriptors.
   11584                 :            :          */
   11585                 :          0 :         err = tg3_alloc_consistent(tp);
   11586         [ #  # ]:          0 :         if (err)
   11587                 :          0 :                 goto out_ints_fini;
   11588                 :            : 
   11589                 :          0 :         tg3_napi_init(tp);
   11590                 :            : 
   11591                 :          0 :         tg3_napi_enable(tp);
   11592                 :            : 
   11593         [ #  # ]:          0 :         for (i = 0; i < tp->irq_cnt; i++) {
   11594                 :          0 :                 err = tg3_request_irq(tp, i);
   11595         [ #  # ]:          0 :                 if (err) {
   11596         [ #  # ]:          0 :                         for (i--; i >= 0; i--) {
   11597                 :          0 :                                 struct tg3_napi *tnapi = &tp->napi[i];
   11598                 :            : 
   11599                 :          0 :                                 free_irq(tnapi->irq_vec, tnapi);
   11600                 :            :                         }
   11601                 :          0 :                         goto out_napi_fini;
   11602                 :            :                 }
   11603                 :            :         }
   11604                 :            : 
   11605                 :          0 :         tg3_full_lock(tp, 0);
   11606                 :            : 
   11607         [ #  # ]:          0 :         if (init)
   11608                 :          0 :                 tg3_ape_driver_state_change(tp, RESET_KIND_INIT);
   11609                 :            : 
   11610                 :          0 :         err = tg3_init_hw(tp, reset_phy);
   11611         [ #  # ]:          0 :         if (err) {
   11612                 :          0 :                 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
   11613                 :          0 :                 tg3_free_rings(tp);
   11614                 :            :         }
   11615                 :            : 
   11616                 :          0 :         tg3_full_unlock(tp);
   11617                 :            : 
   11618         [ #  # ]:          0 :         if (err)
   11619                 :          0 :                 goto out_free_irq;
   11620                 :            : 
   11621   [ #  #  #  # ]:          0 :         if (test_irq && tg3_flag(tp, USING_MSI)) {
   11622                 :          0 :                 err = tg3_test_msi(tp);
   11623                 :            : 
   11624         [ #  # ]:          0 :                 if (err) {
   11625                 :          0 :                         tg3_full_lock(tp, 0);
   11626                 :          0 :                         tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
   11627                 :          0 :                         tg3_free_rings(tp);
   11628                 :          0 :                         tg3_full_unlock(tp);
   11629                 :            : 
   11630                 :          0 :                         goto out_napi_fini;
   11631                 :            :                 }
   11632                 :            : 
   11633   [ #  #  #  # ]:          0 :                 if (!tg3_flag(tp, 57765_PLUS) && tg3_flag(tp, USING_MSI)) {
   11634                 :          0 :                         u32 val = tr32(PCIE_TRANSACTION_CFG);
   11635                 :            : 
   11636                 :          0 :                         tw32(PCIE_TRANSACTION_CFG,
   11637                 :            :                              val | PCIE_TRANS_CFG_1SHOT_MSI);
   11638                 :            :                 }
   11639                 :            :         }
   11640                 :            : 
   11641                 :          0 :         tg3_phy_start(tp);
   11642                 :            : 
   11643                 :          0 :         tg3_hwmon_open(tp);
   11644                 :            : 
   11645                 :          0 :         tg3_full_lock(tp, 0);
   11646                 :            : 
   11647                 :          0 :         tg3_timer_start(tp);
   11648                 :          0 :         tg3_flag_set(tp, INIT_COMPLETE);
   11649                 :          0 :         tg3_enable_ints(tp);
   11650                 :            : 
   11651                 :          0 :         tg3_ptp_resume(tp);
   11652                 :            : 
   11653                 :          0 :         tg3_full_unlock(tp);
   11654                 :            : 
   11655                 :            :         netif_tx_start_all_queues(dev);
   11656                 :            : 
   11657                 :            :         /*
   11658                 :            :          * Reset loopback feature if it was turned on while the device was down
   11659                 :            :          * make sure that it's installed properly now.
   11660                 :            :          */
   11661         [ #  # ]:          0 :         if (dev->features & NETIF_F_LOOPBACK)
   11662                 :          0 :                 tg3_set_loopback(dev, dev->features);
   11663                 :            : 
   11664                 :            :         return 0;
   11665                 :            : 
   11666                 :            : out_free_irq:
   11667         [ #  # ]:          0 :         for (i = tp->irq_cnt - 1; i >= 0; i--) {
   11668                 :          0 :                 struct tg3_napi *tnapi = &tp->napi[i];
   11669                 :          0 :                 free_irq(tnapi->irq_vec, tnapi);
   11670                 :            :         }
   11671                 :            : 
   11672                 :          0 : out_napi_fini:
   11673                 :          0 :         tg3_napi_disable(tp);
   11674                 :            :         tg3_napi_fini(tp);
   11675                 :          0 :         tg3_free_consistent(tp);
   11676                 :            : 
   11677                 :          0 : out_ints_fini:
   11678                 :          0 :         tg3_ints_fini(tp);
   11679                 :            : 
   11680                 :          0 :         return err;
   11681                 :            : }
   11682                 :            : 
   11683                 :          0 : static void tg3_stop(struct tg3 *tp)
   11684                 :            : {
   11685                 :          0 :         int i;
   11686                 :            : 
   11687                 :          0 :         tg3_reset_task_cancel(tp);
   11688                 :          0 :         tg3_netif_stop(tp);
   11689                 :            : 
   11690                 :          0 :         tg3_timer_stop(tp);
   11691                 :            : 
   11692         [ #  # ]:          0 :         tg3_hwmon_close(tp);
   11693                 :            : 
   11694                 :          0 :         tg3_phy_stop(tp);
   11695                 :            : 
   11696                 :          0 :         tg3_full_lock(tp, 1);
   11697                 :            : 
   11698                 :          0 :         tg3_disable_ints(tp);
   11699                 :            : 
   11700                 :          0 :         tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
   11701                 :          0 :         tg3_free_rings(tp);
   11702                 :          0 :         tg3_flag_clear(tp, INIT_COMPLETE);
   11703                 :            : 
   11704                 :          0 :         tg3_full_unlock(tp);
   11705                 :            : 
   11706         [ #  # ]:          0 :         for (i = tp->irq_cnt - 1; i >= 0; i--) {
   11707                 :          0 :                 struct tg3_napi *tnapi = &tp->napi[i];
   11708                 :          0 :                 free_irq(tnapi->irq_vec, tnapi);
   11709                 :            :         }
   11710                 :            : 
   11711                 :          0 :         tg3_ints_fini(tp);
   11712                 :            : 
   11713                 :          0 :         tg3_napi_fini(tp);
   11714                 :            : 
   11715                 :          0 :         tg3_free_consistent(tp);
   11716                 :          0 : }
   11717                 :            : 
   11718                 :          0 : static int tg3_open(struct net_device *dev)
   11719                 :            : {
   11720         [ #  # ]:          0 :         struct tg3 *tp = netdev_priv(dev);
   11721                 :          0 :         int err;
   11722                 :            : 
   11723         [ #  # ]:          0 :         if (tp->pcierr_recovery) {
   11724                 :          0 :                 netdev_err(dev, "Failed to open device. PCI error recovery "
   11725                 :            :                            "in progress\n");
   11726                 :          0 :                 return -EAGAIN;
   11727                 :            :         }
   11728                 :            : 
   11729         [ #  # ]:          0 :         if (tp->fw_needed) {
   11730                 :          0 :                 err = tg3_request_firmware(tp);
   11731         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_57766) {
   11732         [ #  # ]:          0 :                         if (err) {
   11733                 :          0 :                                 netdev_warn(tp->dev, "EEE capability disabled\n");
   11734                 :          0 :                                 tp->phy_flags &= ~TG3_PHYFLG_EEE_CAP;
   11735         [ #  # ]:          0 :                         } else if (!(tp->phy_flags & TG3_PHYFLG_EEE_CAP)) {
   11736                 :          0 :                                 netdev_warn(tp->dev, "EEE capability restored\n");
   11737                 :          0 :                                 tp->phy_flags |= TG3_PHYFLG_EEE_CAP;
   11738                 :            :                         }
   11739         [ #  # ]:          0 :                 } else if (tg3_chip_rev_id(tp) == CHIPREV_ID_5701_A0) {
   11740         [ #  # ]:          0 :                         if (err)
   11741                 :            :                                 return err;
   11742         [ #  # ]:          0 :                 } else if (err) {
   11743                 :          0 :                         netdev_warn(tp->dev, "TSO capability disabled\n");
   11744                 :          0 :                         tg3_flag_clear(tp, TSO_CAPABLE);
   11745         [ #  # ]:          0 :                 } else if (!tg3_flag(tp, TSO_CAPABLE)) {
   11746                 :          0 :                         netdev_notice(tp->dev, "TSO capability restored\n");
   11747                 :          0 :                         tg3_flag_set(tp, TSO_CAPABLE);
   11748                 :            :                 }
   11749                 :            :         }
   11750                 :            : 
   11751                 :          0 :         tg3_carrier_off(tp);
   11752                 :            : 
   11753                 :          0 :         err = tg3_power_up(tp);
   11754         [ #  # ]:          0 :         if (err)
   11755                 :            :                 return err;
   11756                 :            : 
   11757                 :          0 :         tg3_full_lock(tp, 0);
   11758                 :            : 
   11759                 :          0 :         tg3_disable_ints(tp);
   11760                 :          0 :         tg3_flag_clear(tp, INIT_COMPLETE);
   11761                 :            : 
   11762                 :          0 :         tg3_full_unlock(tp);
   11763                 :            : 
   11764                 :          0 :         err = tg3_start(tp,
   11765                 :          0 :                         !(tp->phy_flags & TG3_PHYFLG_KEEP_LINK_ON_PWRDN),
   11766                 :            :                         true, true);
   11767         [ #  # ]:          0 :         if (err) {
   11768                 :          0 :                 tg3_frob_aux_power(tp, false);
   11769                 :          0 :                 pci_set_power_state(tp->pdev, PCI_D3hot);
   11770                 :            :         }
   11771                 :            : 
   11772                 :            :         return err;
   11773                 :            : }
   11774                 :            : 
   11775                 :          0 : static int tg3_close(struct net_device *dev)
   11776                 :            : {
   11777         [ #  # ]:          0 :         struct tg3 *tp = netdev_priv(dev);
   11778                 :            : 
   11779         [ #  # ]:          0 :         if (tp->pcierr_recovery) {
   11780                 :          0 :                 netdev_err(dev, "Failed to close device. PCI error recovery "
   11781                 :            :                            "in progress\n");
   11782                 :          0 :                 return -EAGAIN;
   11783                 :            :         }
   11784                 :            : 
   11785                 :          0 :         tg3_stop(tp);
   11786                 :            : 
   11787         [ #  # ]:          0 :         if (pci_device_is_present(tp->pdev)) {
   11788                 :          0 :                 tg3_power_down_prepare(tp);
   11789                 :            : 
   11790                 :          0 :                 tg3_carrier_off(tp);
   11791                 :            :         }
   11792                 :            :         return 0;
   11793                 :            : }
   11794                 :            : 
   11795                 :          0 : static inline u64 get_stat64(tg3_stat64_t *val)
   11796                 :            : {
   11797                 :          0 :        return ((u64)val->high << 32) | ((u64)val->low);
   11798                 :            : }
   11799                 :            : 
   11800                 :          0 : static u64 tg3_calc_crc_errors(struct tg3 *tp)
   11801                 :            : {
   11802                 :          0 :         struct tg3_hw_stats *hw_stats = tp->hw_stats;
   11803                 :            : 
   11804         [ #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_PHY_SERDES) &&
   11805         [ #  # ]:          0 :             (tg3_asic_rev(tp) == ASIC_REV_5700 ||
   11806                 :            :              tg3_asic_rev(tp) == ASIC_REV_5701)) {
   11807                 :          0 :                 u32 val;
   11808                 :            : 
   11809         [ #  # ]:          0 :                 if (!tg3_readphy(tp, MII_TG3_TEST1, &val)) {
   11810                 :          0 :                         tg3_writephy(tp, MII_TG3_TEST1,
   11811                 :            :                                      val | MII_TG3_TEST1_CRC_EN);
   11812                 :          0 :                         tg3_readphy(tp, MII_TG3_RXR_COUNTERS, &val);
   11813                 :            :                 } else
   11814                 :          0 :                         val = 0;
   11815                 :            : 
   11816                 :          0 :                 tp->phy_crc_errors += val;
   11817                 :            : 
   11818                 :          0 :                 return tp->phy_crc_errors;
   11819                 :            :         }
   11820                 :            : 
   11821                 :          0 :         return get_stat64(&hw_stats->rx_fcs_errors);
   11822                 :            : }
   11823                 :            : 
   11824                 :            : #define ESTAT_ADD(member) \
   11825                 :            :         estats->member =     old_estats->member + \
   11826                 :            :                                 get_stat64(&hw_stats->member)
   11827                 :            : 
   11828                 :          0 : static void tg3_get_estats(struct tg3 *tp, struct tg3_ethtool_stats *estats)
   11829                 :            : {
   11830                 :          0 :         struct tg3_ethtool_stats *old_estats = &tp->estats_prev;
   11831                 :          0 :         struct tg3_hw_stats *hw_stats = tp->hw_stats;
   11832                 :            : 
   11833                 :          0 :         ESTAT_ADD(rx_octets);
   11834                 :          0 :         ESTAT_ADD(rx_fragments);
   11835                 :          0 :         ESTAT_ADD(rx_ucast_packets);
   11836                 :          0 :         ESTAT_ADD(rx_mcast_packets);
   11837                 :          0 :         ESTAT_ADD(rx_bcast_packets);
   11838                 :          0 :         ESTAT_ADD(rx_fcs_errors);
   11839                 :          0 :         ESTAT_ADD(rx_align_errors);
   11840                 :          0 :         ESTAT_ADD(rx_xon_pause_rcvd);
   11841                 :          0 :         ESTAT_ADD(rx_xoff_pause_rcvd);
   11842                 :          0 :         ESTAT_ADD(rx_mac_ctrl_rcvd);
   11843                 :          0 :         ESTAT_ADD(rx_xoff_entered);
   11844                 :          0 :         ESTAT_ADD(rx_frame_too_long_errors);
   11845                 :          0 :         ESTAT_ADD(rx_jabbers);
   11846                 :          0 :         ESTAT_ADD(rx_undersize_packets);
   11847                 :          0 :         ESTAT_ADD(rx_in_length_errors);
   11848                 :          0 :         ESTAT_ADD(rx_out_length_errors);
   11849                 :          0 :         ESTAT_ADD(rx_64_or_less_octet_packets);
   11850                 :          0 :         ESTAT_ADD(rx_65_to_127_octet_packets);
   11851                 :          0 :         ESTAT_ADD(rx_128_to_255_octet_packets);
   11852                 :          0 :         ESTAT_ADD(rx_256_to_511_octet_packets);
   11853                 :          0 :         ESTAT_ADD(rx_512_to_1023_octet_packets);
   11854                 :          0 :         ESTAT_ADD(rx_1024_to_1522_octet_packets);
   11855                 :          0 :         ESTAT_ADD(rx_1523_to_2047_octet_packets);
   11856                 :          0 :         ESTAT_ADD(rx_2048_to_4095_octet_packets);
   11857                 :          0 :         ESTAT_ADD(rx_4096_to_8191_octet_packets);
   11858                 :          0 :         ESTAT_ADD(rx_8192_to_9022_octet_packets);
   11859                 :            : 
   11860                 :          0 :         ESTAT_ADD(tx_octets);
   11861                 :          0 :         ESTAT_ADD(tx_collisions);
   11862                 :          0 :         ESTAT_ADD(tx_xon_sent);
   11863                 :          0 :         ESTAT_ADD(tx_xoff_sent);
   11864                 :          0 :         ESTAT_ADD(tx_flow_control);
   11865                 :          0 :         ESTAT_ADD(tx_mac_errors);
   11866                 :          0 :         ESTAT_ADD(tx_single_collisions);
   11867                 :          0 :         ESTAT_ADD(tx_mult_collisions);
   11868                 :          0 :         ESTAT_ADD(tx_deferred);
   11869                 :          0 :         ESTAT_ADD(tx_excessive_collisions);
   11870                 :          0 :         ESTAT_ADD(tx_late_collisions);
   11871                 :          0 :         ESTAT_ADD(tx_collide_2times);
   11872                 :          0 :         ESTAT_ADD(tx_collide_3times);
   11873                 :          0 :         ESTAT_ADD(tx_collide_4times);
   11874                 :          0 :         ESTAT_ADD(tx_collide_5times);
   11875                 :          0 :         ESTAT_ADD(tx_collide_6times);
   11876                 :          0 :         ESTAT_ADD(tx_collide_7times);
   11877                 :          0 :         ESTAT_ADD(tx_collide_8times);
   11878                 :          0 :         ESTAT_ADD(tx_collide_9times);
   11879                 :          0 :         ESTAT_ADD(tx_collide_10times);
   11880                 :          0 :         ESTAT_ADD(tx_collide_11times);
   11881                 :          0 :         ESTAT_ADD(tx_collide_12times);
   11882                 :          0 :         ESTAT_ADD(tx_collide_13times);
   11883                 :          0 :         ESTAT_ADD(tx_collide_14times);
   11884                 :          0 :         ESTAT_ADD(tx_collide_15times);
   11885                 :          0 :         ESTAT_ADD(tx_ucast_packets);
   11886                 :          0 :         ESTAT_ADD(tx_mcast_packets);
   11887                 :          0 :         ESTAT_ADD(tx_bcast_packets);
   11888                 :          0 :         ESTAT_ADD(tx_carrier_sense_errors);
   11889                 :          0 :         ESTAT_ADD(tx_discards);
   11890                 :          0 :         ESTAT_ADD(tx_errors);
   11891                 :            : 
   11892                 :          0 :         ESTAT_ADD(dma_writeq_full);
   11893                 :          0 :         ESTAT_ADD(dma_write_prioq_full);
   11894                 :          0 :         ESTAT_ADD(rxbds_empty);
   11895                 :          0 :         ESTAT_ADD(rx_discards);
   11896                 :          0 :         ESTAT_ADD(rx_errors);
   11897                 :          0 :         ESTAT_ADD(rx_threshold_hit);
   11898                 :            : 
   11899                 :          0 :         ESTAT_ADD(dma_readq_full);
   11900                 :          0 :         ESTAT_ADD(dma_read_prioq_full);
   11901                 :          0 :         ESTAT_ADD(tx_comp_queue_full);
   11902                 :            : 
   11903                 :          0 :         ESTAT_ADD(ring_set_send_prod_index);
   11904                 :          0 :         ESTAT_ADD(ring_status_update);
   11905                 :          0 :         ESTAT_ADD(nic_irqs);
   11906                 :          0 :         ESTAT_ADD(nic_avoided_irqs);
   11907                 :          0 :         ESTAT_ADD(nic_tx_threshold_hit);
   11908                 :            : 
   11909                 :          0 :         ESTAT_ADD(mbuf_lwm_thresh_hit);
   11910                 :          0 : }
   11911                 :            : 
   11912                 :          0 : static void tg3_get_nstats(struct tg3 *tp, struct rtnl_link_stats64 *stats)
   11913                 :            : {
   11914                 :          0 :         struct rtnl_link_stats64 *old_stats = &tp->net_stats_prev;
   11915                 :          0 :         struct tg3_hw_stats *hw_stats = tp->hw_stats;
   11916                 :            : 
   11917                 :          0 :         stats->rx_packets = old_stats->rx_packets +
   11918                 :          0 :                 get_stat64(&hw_stats->rx_ucast_packets) +
   11919                 :          0 :                 get_stat64(&hw_stats->rx_mcast_packets) +
   11920                 :          0 :                 get_stat64(&hw_stats->rx_bcast_packets);
   11921                 :            : 
   11922                 :          0 :         stats->tx_packets = old_stats->tx_packets +
   11923                 :          0 :                 get_stat64(&hw_stats->tx_ucast_packets) +
   11924                 :          0 :                 get_stat64(&hw_stats->tx_mcast_packets) +
   11925                 :          0 :                 get_stat64(&hw_stats->tx_bcast_packets);
   11926                 :            : 
   11927                 :          0 :         stats->rx_bytes = old_stats->rx_bytes +
   11928                 :          0 :                 get_stat64(&hw_stats->rx_octets);
   11929                 :          0 :         stats->tx_bytes = old_stats->tx_bytes +
   11930                 :          0 :                 get_stat64(&hw_stats->tx_octets);
   11931                 :            : 
   11932                 :          0 :         stats->rx_errors = old_stats->rx_errors +
   11933                 :          0 :                 get_stat64(&hw_stats->rx_errors);
   11934                 :          0 :         stats->tx_errors = old_stats->tx_errors +
   11935                 :          0 :                 get_stat64(&hw_stats->tx_errors) +
   11936                 :          0 :                 get_stat64(&hw_stats->tx_mac_errors) +
   11937                 :          0 :                 get_stat64(&hw_stats->tx_carrier_sense_errors) +
   11938                 :          0 :                 get_stat64(&hw_stats->tx_discards);
   11939                 :            : 
   11940                 :          0 :         stats->multicast = old_stats->multicast +
   11941                 :          0 :                 get_stat64(&hw_stats->rx_mcast_packets);
   11942                 :          0 :         stats->collisions = old_stats->collisions +
   11943                 :          0 :                 get_stat64(&hw_stats->tx_collisions);
   11944                 :            : 
   11945                 :          0 :         stats->rx_length_errors = old_stats->rx_length_errors +
   11946                 :          0 :                 get_stat64(&hw_stats->rx_frame_too_long_errors) +
   11947                 :          0 :                 get_stat64(&hw_stats->rx_undersize_packets);
   11948                 :            : 
   11949                 :          0 :         stats->rx_frame_errors = old_stats->rx_frame_errors +
   11950                 :          0 :                 get_stat64(&hw_stats->rx_align_errors);
   11951                 :          0 :         stats->tx_aborted_errors = old_stats->tx_aborted_errors +
   11952                 :          0 :                 get_stat64(&hw_stats->tx_discards);
   11953                 :          0 :         stats->tx_carrier_errors = old_stats->tx_carrier_errors +
   11954                 :          0 :                 get_stat64(&hw_stats->tx_carrier_sense_errors);
   11955                 :            : 
   11956                 :          0 :         stats->rx_crc_errors = old_stats->rx_crc_errors +
   11957                 :          0 :                 tg3_calc_crc_errors(tp);
   11958                 :            : 
   11959                 :          0 :         stats->rx_missed_errors = old_stats->rx_missed_errors +
   11960                 :          0 :                 get_stat64(&hw_stats->rx_discards);
   11961                 :            : 
   11962                 :          0 :         stats->rx_dropped = tp->rx_dropped;
   11963                 :          0 :         stats->tx_dropped = tp->tx_dropped;
   11964                 :          0 : }
   11965                 :            : 
   11966                 :          0 : static int tg3_get_regs_len(struct net_device *dev)
   11967                 :            : {
   11968                 :          0 :         return TG3_REG_BLK_SIZE;
   11969                 :            : }
   11970                 :            : 
   11971                 :          0 : static void tg3_get_regs(struct net_device *dev,
   11972                 :            :                 struct ethtool_regs *regs, void *_p)
   11973                 :            : {
   11974         [ #  # ]:          0 :         struct tg3 *tp = netdev_priv(dev);
   11975                 :            : 
   11976                 :          0 :         regs->version = 0;
   11977                 :            : 
   11978                 :          0 :         memset(_p, 0, TG3_REG_BLK_SIZE);
   11979                 :            : 
   11980         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_IS_LOW_POWER)
   11981                 :            :                 return;
   11982                 :            : 
   11983                 :          0 :         tg3_full_lock(tp, 0);
   11984                 :            : 
   11985                 :          0 :         tg3_dump_legacy_regs(tp, (u32 *)_p);
   11986                 :            : 
   11987                 :          0 :         tg3_full_unlock(tp);
   11988                 :            : }
   11989                 :            : 
   11990                 :          0 : static int tg3_get_eeprom_len(struct net_device *dev)
   11991                 :            : {
   11992                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   11993                 :            : 
   11994                 :          0 :         return tp->nvram_size;
   11995                 :            : }
   11996                 :            : 
   11997                 :          0 : static int tg3_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom, u8 *data)
   11998                 :            : {
   11999                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   12000                 :          0 :         int ret, cpmu_restore = 0;
   12001                 :          0 :         u8  *pd;
   12002                 :          0 :         u32 i, offset, len, b_offset, b_count, cpmu_val = 0;
   12003                 :          0 :         __be32 val;
   12004                 :            : 
   12005         [ #  # ]:          0 :         if (tg3_flag(tp, NO_NVRAM))
   12006                 :            :                 return -EINVAL;
   12007                 :            : 
   12008                 :          0 :         offset = eeprom->offset;
   12009                 :          0 :         len = eeprom->len;
   12010                 :          0 :         eeprom->len = 0;
   12011                 :            : 
   12012                 :          0 :         eeprom->magic = TG3_EEPROM_MAGIC;
   12013                 :            : 
   12014                 :            :         /* Override clock, link aware and link idle modes */
   12015         [ #  # ]:          0 :         if (tg3_flag(tp, CPMU_PRESENT)) {
   12016                 :          0 :                 cpmu_val = tr32(TG3_CPMU_CTRL);
   12017         [ #  # ]:          0 :                 if (cpmu_val & (CPMU_CTRL_LINK_AWARE_MODE |
   12018                 :            :                                 CPMU_CTRL_LINK_IDLE_MODE)) {
   12019                 :          0 :                         tw32(TG3_CPMU_CTRL, cpmu_val &
   12020                 :            :                                             ~(CPMU_CTRL_LINK_AWARE_MODE |
   12021                 :            :                                              CPMU_CTRL_LINK_IDLE_MODE));
   12022                 :          0 :                         cpmu_restore = 1;
   12023                 :            :                 }
   12024                 :            :         }
   12025                 :          0 :         tg3_override_clk(tp);
   12026                 :            : 
   12027         [ #  # ]:          0 :         if (offset & 3) {
   12028                 :            :                 /* adjustments to start on required 4 byte boundary */
   12029                 :          0 :                 b_offset = offset & 3;
   12030                 :          0 :                 b_count = 4 - b_offset;
   12031                 :          0 :                 if (b_count > len) {
   12032                 :            :                         /* i.e. offset=1 len=2 */
   12033                 :            :                         b_count = len;
   12034                 :            :                 }
   12035                 :          0 :                 ret = tg3_nvram_read_be32(tp, offset-b_offset, &val);
   12036         [ #  # ]:          0 :                 if (ret)
   12037                 :          0 :                         goto eeprom_done;
   12038                 :          0 :                 memcpy(data, ((char *)&val) + b_offset, b_count);
   12039                 :          0 :                 len -= b_count;
   12040                 :          0 :                 offset += b_count;
   12041                 :          0 :                 eeprom->len += b_count;
   12042                 :            :         }
   12043                 :            : 
   12044                 :            :         /* read bytes up to the last 4 byte boundary */
   12045                 :          0 :         pd = &data[eeprom->len];
   12046         [ #  # ]:          0 :         for (i = 0; i < (len - (len & 3)); i += 4) {
   12047                 :          0 :                 ret = tg3_nvram_read_be32(tp, offset + i, &val);
   12048         [ #  # ]:          0 :                 if (ret) {
   12049         [ #  # ]:          0 :                         if (i)
   12050                 :          0 :                                 i -= 4;
   12051                 :          0 :                         eeprom->len += i;
   12052                 :          0 :                         goto eeprom_done;
   12053                 :            :                 }
   12054                 :          0 :                 memcpy(pd + i, &val, 4);
   12055         [ #  # ]:          0 :                 if (need_resched()) {
   12056         [ #  # ]:          0 :                         if (signal_pending(current)) {
   12057                 :          0 :                                 eeprom->len += i;
   12058                 :          0 :                                 ret = -EINTR;
   12059                 :          0 :                                 goto eeprom_done;
   12060                 :            :                         }
   12061                 :          0 :                         cond_resched();
   12062                 :            :                 }
   12063                 :            :         }
   12064                 :          0 :         eeprom->len += i;
   12065                 :            : 
   12066         [ #  # ]:          0 :         if (len & 3) {
   12067                 :            :                 /* read last bytes not ending on 4 byte boundary */
   12068                 :          0 :                 pd = &data[eeprom->len];
   12069                 :          0 :                 b_count = len & 3;
   12070                 :          0 :                 b_offset = offset + len - b_count;
   12071                 :          0 :                 ret = tg3_nvram_read_be32(tp, b_offset, &val);
   12072         [ #  # ]:          0 :                 if (ret)
   12073                 :          0 :                         goto eeprom_done;
   12074                 :          0 :                 memcpy(pd, &val, b_count);
   12075                 :          0 :                 eeprom->len += b_count;
   12076                 :            :         }
   12077                 :            :         ret = 0;
   12078                 :            : 
   12079                 :          0 : eeprom_done:
   12080                 :            :         /* Restore clock, link aware and link idle modes */
   12081                 :          0 :         tg3_restore_clk(tp);
   12082         [ #  # ]:          0 :         if (cpmu_restore)
   12083                 :          0 :                 tw32(TG3_CPMU_CTRL, cpmu_val);
   12084                 :            : 
   12085                 :            :         return ret;
   12086                 :            : }
   12087                 :            : 
   12088                 :          0 : static int tg3_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom, u8 *data)
   12089                 :            : {
   12090                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   12091                 :          0 :         int ret;
   12092                 :          0 :         u32 offset, len, b_offset, odd_len;
   12093                 :          0 :         u8 *buf;
   12094                 :          0 :         __be32 start = 0, end;
   12095                 :            : 
   12096         [ #  # ]:          0 :         if (tg3_flag(tp, NO_NVRAM) ||
   12097         [ #  # ]:          0 :             eeprom->magic != TG3_EEPROM_MAGIC)
   12098                 :            :                 return -EINVAL;
   12099                 :            : 
   12100                 :          0 :         offset = eeprom->offset;
   12101                 :          0 :         len = eeprom->len;
   12102                 :            : 
   12103         [ #  # ]:          0 :         if ((b_offset = (offset & 3))) {
   12104                 :            :                 /* adjustments to start on required 4 byte boundary */
   12105                 :          0 :                 ret = tg3_nvram_read_be32(tp, offset-b_offset, &start);
   12106         [ #  # ]:          0 :                 if (ret)
   12107                 :            :                         return ret;
   12108                 :          0 :                 len += b_offset;
   12109                 :          0 :                 offset &= ~3;
   12110                 :          0 :                 if (len < 4)
   12111                 :            :                         len = 4;
   12112                 :            :         }
   12113                 :            : 
   12114                 :          0 :         odd_len = 0;
   12115         [ #  # ]:          0 :         if (len & 3) {
   12116                 :            :                 /* adjustments to end on required 4 byte boundary */
   12117                 :          0 :                 odd_len = 1;
   12118                 :          0 :                 len = (len + 3) & ~3;
   12119                 :          0 :                 ret = tg3_nvram_read_be32(tp, offset+len-4, &end);
   12120         [ #  # ]:          0 :                 if (ret)
   12121                 :            :                         return ret;
   12122                 :            :         }
   12123                 :            : 
   12124                 :          0 :         buf = data;
   12125         [ #  # ]:          0 :         if (b_offset || odd_len) {
   12126         [ #  # ]:          0 :                 buf = kmalloc(len, GFP_KERNEL);
   12127         [ #  # ]:          0 :                 if (!buf)
   12128                 :            :                         return -ENOMEM;
   12129         [ #  # ]:          0 :                 if (b_offset)
   12130                 :          0 :                         memcpy(buf, &start, 4);
   12131         [ #  # ]:          0 :                 if (odd_len)
   12132                 :          0 :                         memcpy(buf+len-4, &end, 4);
   12133                 :          0 :                 memcpy(buf + b_offset, data, eeprom->len);
   12134                 :            :         }
   12135                 :            : 
   12136                 :          0 :         ret = tg3_nvram_write_block(tp, offset, len, buf);
   12137                 :            : 
   12138         [ #  # ]:          0 :         if (buf != data)
   12139                 :          0 :                 kfree(buf);
   12140                 :            : 
   12141                 :            :         return ret;
   12142                 :            : }
   12143                 :            : 
   12144                 :          0 : static int tg3_get_link_ksettings(struct net_device *dev,
   12145                 :            :                                   struct ethtool_link_ksettings *cmd)
   12146                 :            : {
   12147                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   12148                 :          0 :         u32 supported, advertising;
   12149                 :            : 
   12150         [ #  # ]:          0 :         if (tg3_flag(tp, USE_PHYLIB)) {
   12151                 :          0 :                 struct phy_device *phydev;
   12152         [ #  # ]:          0 :                 if (!(tp->phy_flags & TG3_PHYFLG_IS_CONNECTED))
   12153                 :            :                         return -EAGAIN;
   12154                 :          0 :                 phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr);
   12155                 :          0 :                 phy_ethtool_ksettings_get(phydev, cmd);
   12156                 :            : 
   12157                 :          0 :                 return 0;
   12158                 :            :         }
   12159                 :            : 
   12160                 :          0 :         supported = (SUPPORTED_Autoneg);
   12161                 :            : 
   12162         [ #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_10_100_ONLY))
   12163                 :          0 :                 supported |= (SUPPORTED_1000baseT_Half |
   12164                 :            :                               SUPPORTED_1000baseT_Full);
   12165                 :            : 
   12166         [ #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_ANY_SERDES)) {
   12167                 :          0 :                 supported |= (SUPPORTED_100baseT_Half |
   12168                 :            :                               SUPPORTED_100baseT_Full |
   12169                 :            :                               SUPPORTED_10baseT_Half |
   12170                 :            :                               SUPPORTED_10baseT_Full |
   12171                 :            :                               SUPPORTED_TP);
   12172                 :          0 :                 cmd->base.port = PORT_TP;
   12173                 :            :         } else {
   12174                 :          0 :                 supported |= SUPPORTED_FIBRE;
   12175                 :          0 :                 cmd->base.port = PORT_FIBRE;
   12176                 :            :         }
   12177                 :          0 :         ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
   12178                 :            :                                                 supported);
   12179                 :            : 
   12180                 :          0 :         advertising = tp->link_config.advertising;
   12181         [ #  # ]:          0 :         if (tg3_flag(tp, PAUSE_AUTONEG)) {
   12182         [ #  # ]:          0 :                 if (tp->link_config.flowctrl & FLOW_CTRL_RX) {
   12183         [ #  # ]:          0 :                         if (tp->link_config.flowctrl & FLOW_CTRL_TX) {
   12184                 :          0 :                                 advertising |= ADVERTISED_Pause;
   12185                 :            :                         } else {
   12186                 :          0 :                                 advertising |= ADVERTISED_Pause |
   12187                 :            :                                         ADVERTISED_Asym_Pause;
   12188                 :            :                         }
   12189         [ #  # ]:          0 :                 } else if (tp->link_config.flowctrl & FLOW_CTRL_TX) {
   12190                 :          0 :                         advertising |= ADVERTISED_Asym_Pause;
   12191                 :            :                 }
   12192                 :            :         }
   12193                 :          0 :         ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
   12194                 :            :                                                 advertising);
   12195                 :            : 
   12196   [ #  #  #  # ]:          0 :         if (netif_running(dev) && tp->link_up) {
   12197                 :          0 :                 cmd->base.speed = tp->link_config.active_speed;
   12198                 :          0 :                 cmd->base.duplex = tp->link_config.active_duplex;
   12199                 :          0 :                 ethtool_convert_legacy_u32_to_link_mode(
   12200                 :          0 :                         cmd->link_modes.lp_advertising,
   12201                 :            :                         tp->link_config.rmt_adv);
   12202                 :            : 
   12203         [ #  # ]:          0 :                 if (!(tp->phy_flags & TG3_PHYFLG_ANY_SERDES)) {
   12204         [ #  # ]:          0 :                         if (tp->phy_flags & TG3_PHYFLG_MDIX_STATE)
   12205                 :          0 :                                 cmd->base.eth_tp_mdix = ETH_TP_MDI_X;
   12206                 :            :                         else
   12207                 :          0 :                                 cmd->base.eth_tp_mdix = ETH_TP_MDI;
   12208                 :            :                 }
   12209                 :            :         } else {
   12210                 :          0 :                 cmd->base.speed = SPEED_UNKNOWN;
   12211                 :          0 :                 cmd->base.duplex = DUPLEX_UNKNOWN;
   12212                 :          0 :                 cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID;
   12213                 :            :         }
   12214                 :          0 :         cmd->base.phy_address = tp->phy_addr;
   12215                 :          0 :         cmd->base.autoneg = tp->link_config.autoneg;
   12216                 :          0 :         return 0;
   12217                 :            : }
   12218                 :            : 
   12219                 :          0 : static int tg3_set_link_ksettings(struct net_device *dev,
   12220                 :            :                                   const struct ethtool_link_ksettings *cmd)
   12221                 :            : {
   12222                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   12223                 :          0 :         u32 speed = cmd->base.speed;
   12224                 :          0 :         u32 advertising;
   12225                 :            : 
   12226         [ #  # ]:          0 :         if (tg3_flag(tp, USE_PHYLIB)) {
   12227                 :          0 :                 struct phy_device *phydev;
   12228         [ #  # ]:          0 :                 if (!(tp->phy_flags & TG3_PHYFLG_IS_CONNECTED))
   12229                 :            :                         return -EAGAIN;
   12230                 :          0 :                 phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr);
   12231                 :          0 :                 return phy_ethtool_ksettings_set(phydev, cmd);
   12232                 :            :         }
   12233                 :            : 
   12234         [ #  # ]:          0 :         if (cmd->base.autoneg != AUTONEG_ENABLE &&
   12235                 :            :             cmd->base.autoneg != AUTONEG_DISABLE)
   12236                 :            :                 return -EINVAL;
   12237                 :            : 
   12238         [ #  # ]:          0 :         if (cmd->base.autoneg == AUTONEG_DISABLE &&
   12239   [ #  #  #  # ]:          0 :             cmd->base.duplex != DUPLEX_FULL &&
   12240                 :            :             cmd->base.duplex != DUPLEX_HALF)
   12241                 :            :                 return -EINVAL;
   12242                 :            : 
   12243                 :          0 :         ethtool_convert_link_mode_to_legacy_u32(&advertising,
   12244                 :          0 :                                                 cmd->link_modes.advertising);
   12245                 :            : 
   12246         [ #  # ]:          0 :         if (cmd->base.autoneg == AUTONEG_ENABLE) {
   12247                 :          0 :                 u32 mask = ADVERTISED_Autoneg |
   12248                 :            :                            ADVERTISED_Pause |
   12249                 :            :                            ADVERTISED_Asym_Pause;
   12250                 :            : 
   12251         [ #  # ]:          0 :                 if (!(tp->phy_flags & TG3_PHYFLG_10_100_ONLY))
   12252                 :          0 :                         mask |= ADVERTISED_1000baseT_Half |
   12253                 :            :                                 ADVERTISED_1000baseT_Full;
   12254                 :            : 
   12255         [ #  # ]:          0 :                 if (!(tp->phy_flags & TG3_PHYFLG_ANY_SERDES))
   12256                 :          0 :                         mask |= ADVERTISED_100baseT_Half |
   12257                 :            :                                 ADVERTISED_100baseT_Full |
   12258                 :            :                                 ADVERTISED_10baseT_Half |
   12259                 :            :                                 ADVERTISED_10baseT_Full |
   12260                 :            :                                 ADVERTISED_TP;
   12261                 :            :                 else
   12262                 :          0 :                         mask |= ADVERTISED_FIBRE;
   12263                 :            : 
   12264         [ #  # ]:          0 :                 if (advertising & ~mask)
   12265                 :            :                         return -EINVAL;
   12266                 :            : 
   12267                 :          0 :                 mask &= (ADVERTISED_1000baseT_Half |
   12268                 :            :                          ADVERTISED_1000baseT_Full |
   12269                 :            :                          ADVERTISED_100baseT_Half |
   12270                 :            :                          ADVERTISED_100baseT_Full |
   12271                 :            :                          ADVERTISED_10baseT_Half |
   12272                 :            :                          ADVERTISED_10baseT_Full);
   12273                 :            : 
   12274                 :          0 :                 advertising &= mask;
   12275                 :            :         } else {
   12276         [ #  # ]:          0 :                 if (tp->phy_flags & TG3_PHYFLG_ANY_SERDES) {
   12277         [ #  # ]:          0 :                         if (speed != SPEED_1000)
   12278                 :            :                                 return -EINVAL;
   12279                 :            : 
   12280         [ #  # ]:          0 :                         if (cmd->base.duplex != DUPLEX_FULL)
   12281                 :            :                                 return -EINVAL;
   12282                 :            :                 } else {
   12283                 :          0 :                         if (speed != SPEED_100 &&
   12284         [ #  # ]:          0 :                             speed != SPEED_10)
   12285                 :            :                                 return -EINVAL;
   12286                 :            :                 }
   12287                 :            :         }
   12288                 :            : 
   12289                 :          0 :         tg3_full_lock(tp, 0);
   12290                 :            : 
   12291                 :          0 :         tp->link_config.autoneg = cmd->base.autoneg;
   12292         [ #  # ]:          0 :         if (cmd->base.autoneg == AUTONEG_ENABLE) {
   12293                 :          0 :                 tp->link_config.advertising = (advertising |
   12294                 :            :                                               ADVERTISED_Autoneg);
   12295                 :          0 :                 tp->link_config.speed = SPEED_UNKNOWN;
   12296                 :          0 :                 tp->link_config.duplex = DUPLEX_UNKNOWN;
   12297                 :            :         } else {
   12298                 :          0 :                 tp->link_config.advertising = 0;
   12299                 :          0 :                 tp->link_config.speed = speed;
   12300                 :          0 :                 tp->link_config.duplex = cmd->base.duplex;
   12301                 :            :         }
   12302                 :            : 
   12303                 :          0 :         tp->phy_flags |= TG3_PHYFLG_USER_CONFIGURED;
   12304                 :            : 
   12305                 :          0 :         tg3_warn_mgmt_link_flap(tp);
   12306                 :            : 
   12307         [ #  # ]:          0 :         if (netif_running(dev))
   12308                 :          0 :                 tg3_setup_phy(tp, true);
   12309                 :            : 
   12310                 :          0 :         tg3_full_unlock(tp);
   12311                 :            : 
   12312                 :          0 :         return 0;
   12313                 :            : }
   12314                 :            : 
   12315                 :          0 : static void tg3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
   12316                 :            : {
   12317                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   12318                 :            : 
   12319                 :          0 :         strlcpy(info->driver, DRV_MODULE_NAME, sizeof(info->driver));
   12320                 :          0 :         strlcpy(info->version, DRV_MODULE_VERSION, sizeof(info->version));
   12321                 :          0 :         strlcpy(info->fw_version, tp->fw_ver, sizeof(info->fw_version));
   12322         [ #  # ]:          0 :         strlcpy(info->bus_info, pci_name(tp->pdev), sizeof(info->bus_info));
   12323                 :          0 : }
   12324                 :            : 
   12325                 :          0 : static void tg3_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
   12326                 :            : {
   12327                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   12328                 :            : 
   12329   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, WOL_CAP) && device_can_wakeup(&tp->pdev->dev))
   12330                 :          0 :                 wol->supported = WAKE_MAGIC;
   12331                 :            :         else
   12332                 :          0 :                 wol->supported = 0;
   12333                 :          0 :         wol->wolopts = 0;
   12334   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, WOL_ENABLE) && device_can_wakeup(&tp->pdev->dev))
   12335                 :          0 :                 wol->wolopts = WAKE_MAGIC;
   12336                 :          0 :         memset(&wol->sopass, 0, sizeof(wol->sopass));
   12337                 :          0 : }
   12338                 :            : 
   12339                 :          0 : static int tg3_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
   12340                 :            : {
   12341         [ #  # ]:          0 :         struct tg3 *tp = netdev_priv(dev);
   12342                 :          0 :         struct device *dp = &tp->pdev->dev;
   12343                 :            : 
   12344         [ #  # ]:          0 :         if (wol->wolopts & ~WAKE_MAGIC)
   12345                 :            :                 return -EINVAL;
   12346   [ #  #  #  # ]:          0 :         if ((wol->wolopts & WAKE_MAGIC) &&
   12347         [ #  # ]:          0 :             !(tg3_flag(tp, WOL_CAP) && device_can_wakeup(dp)))
   12348                 :            :                 return -EINVAL;
   12349                 :            : 
   12350                 :          0 :         device_set_wakeup_enable(dp, wol->wolopts & WAKE_MAGIC);
   12351                 :            : 
   12352   [ #  #  #  # ]:          0 :         if (device_may_wakeup(dp))
   12353                 :          0 :                 tg3_flag_set(tp, WOL_ENABLE);
   12354                 :            :         else
   12355                 :          0 :                 tg3_flag_clear(tp, WOL_ENABLE);
   12356                 :            : 
   12357                 :            :         return 0;
   12358                 :            : }
   12359                 :            : 
   12360                 :          0 : static u32 tg3_get_msglevel(struct net_device *dev)
   12361                 :            : {
   12362                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   12363                 :          0 :         return tp->msg_enable;
   12364                 :            : }
   12365                 :            : 
   12366                 :          0 : static void tg3_set_msglevel(struct net_device *dev, u32 value)
   12367                 :            : {
   12368                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   12369                 :          0 :         tp->msg_enable = value;
   12370                 :          0 : }
   12371                 :            : 
   12372                 :          0 : static int tg3_nway_reset(struct net_device *dev)
   12373                 :            : {
   12374                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   12375                 :          0 :         int r;
   12376                 :            : 
   12377         [ #  # ]:          0 :         if (!netif_running(dev))
   12378                 :            :                 return -EAGAIN;
   12379                 :            : 
   12380         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_PHY_SERDES)
   12381                 :            :                 return -EINVAL;
   12382                 :            : 
   12383                 :          0 :         tg3_warn_mgmt_link_flap(tp);
   12384                 :            : 
   12385         [ #  # ]:          0 :         if (tg3_flag(tp, USE_PHYLIB)) {
   12386         [ #  # ]:          0 :                 if (!(tp->phy_flags & TG3_PHYFLG_IS_CONNECTED))
   12387                 :            :                         return -EAGAIN;
   12388                 :          0 :                 r = phy_start_aneg(mdiobus_get_phy(tp->mdio_bus, tp->phy_addr));
   12389                 :            :         } else {
   12390                 :          0 :                 u32 bmcr;
   12391                 :            : 
   12392                 :          0 :                 spin_lock_bh(&tp->lock);
   12393                 :          0 :                 r = -EINVAL;
   12394                 :          0 :                 tg3_readphy(tp, MII_BMCR, &bmcr);
   12395         [ #  # ]:          0 :                 if (!tg3_readphy(tp, MII_BMCR, &bmcr) &&
   12396         [ #  # ]:          0 :                     ((bmcr & BMCR_ANENABLE) ||
   12397         [ #  # ]:          0 :                      (tp->phy_flags & TG3_PHYFLG_PARALLEL_DETECT))) {
   12398                 :          0 :                         tg3_writephy(tp, MII_BMCR, bmcr | BMCR_ANRESTART |
   12399                 :            :                                                    BMCR_ANENABLE);
   12400                 :          0 :                         r = 0;
   12401                 :            :                 }
   12402                 :          0 :                 spin_unlock_bh(&tp->lock);
   12403                 :            :         }
   12404                 :            : 
   12405                 :            :         return r;
   12406                 :            : }
   12407                 :            : 
   12408                 :          0 : static void tg3_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ering)
   12409                 :            : {
   12410                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   12411                 :            : 
   12412                 :          0 :         ering->rx_max_pending = tp->rx_std_ring_mask;
   12413         [ #  # ]:          0 :         if (tg3_flag(tp, JUMBO_RING_ENABLE))
   12414                 :          0 :                 ering->rx_jumbo_max_pending = tp->rx_jmb_ring_mask;
   12415                 :            :         else
   12416                 :          0 :                 ering->rx_jumbo_max_pending = 0;
   12417                 :            : 
   12418                 :          0 :         ering->tx_max_pending = TG3_TX_RING_SIZE - 1;
   12419                 :            : 
   12420                 :          0 :         ering->rx_pending = tp->rx_pending;
   12421         [ #  # ]:          0 :         if (tg3_flag(tp, JUMBO_RING_ENABLE))
   12422                 :          0 :                 ering->rx_jumbo_pending = tp->rx_jumbo_pending;
   12423                 :            :         else
   12424                 :          0 :                 ering->rx_jumbo_pending = 0;
   12425                 :            : 
   12426                 :          0 :         ering->tx_pending = tp->napi[0].tx_pending;
   12427                 :          0 : }
   12428                 :            : 
   12429                 :          0 : static int tg3_set_ringparam(struct net_device *dev, struct ethtool_ringparam *ering)
   12430                 :            : {
   12431         [ #  # ]:          0 :         struct tg3 *tp = netdev_priv(dev);
   12432                 :          0 :         int i, irq_sync = 0, err = 0;
   12433                 :          0 :         bool reset_phy = false;
   12434                 :            : 
   12435         [ #  # ]:          0 :         if ((ering->rx_pending > tp->rx_std_ring_mask) ||
   12436         [ #  # ]:          0 :             (ering->rx_jumbo_pending > tp->rx_jmb_ring_mask) ||
   12437   [ #  #  #  # ]:          0 :             (ering->tx_pending > TG3_TX_RING_SIZE - 1) ||
   12438         [ #  # ]:          0 :             (ering->tx_pending <= MAX_SKB_FRAGS) ||
   12439                 :          0 :             (tg3_flag(tp, TSO_BUG) &&
   12440         [ #  # ]:          0 :              (ering->tx_pending <= (MAX_SKB_FRAGS * 3))))
   12441                 :          0 :                 return -EINVAL;
   12442                 :            : 
   12443         [ #  # ]:          0 :         if (netif_running(dev)) {
   12444                 :          0 :                 tg3_phy_stop(tp);
   12445                 :          0 :                 tg3_netif_stop(tp);
   12446                 :          0 :                 irq_sync = 1;
   12447                 :            :         }
   12448                 :            : 
   12449                 :          0 :         tg3_full_lock(tp, irq_sync);
   12450                 :            : 
   12451                 :          0 :         tp->rx_pending = ering->rx_pending;
   12452                 :            : 
   12453         [ #  # ]:          0 :         if (tg3_flag(tp, MAX_RXPEND_64) &&
   12454         [ #  # ]:          0 :             tp->rx_pending > 63)
   12455                 :          0 :                 tp->rx_pending = 63;
   12456                 :            : 
   12457         [ #  # ]:          0 :         if (tg3_flag(tp, JUMBO_RING_ENABLE))
   12458                 :          0 :                 tp->rx_jumbo_pending = ering->rx_jumbo_pending;
   12459                 :            : 
   12460         [ #  # ]:          0 :         for (i = 0; i < tp->irq_max; i++)
   12461                 :          0 :                 tp->napi[i].tx_pending = ering->tx_pending;
   12462                 :            : 
   12463         [ #  # ]:          0 :         if (netif_running(dev)) {
   12464                 :          0 :                 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
   12465                 :            :                 /* Reset PHY to avoid PHY lock up */
   12466         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5717 ||
   12467         [ #  # ]:          0 :                     tg3_asic_rev(tp) == ASIC_REV_5719 ||
   12468                 :            :                     tg3_asic_rev(tp) == ASIC_REV_5720)
   12469                 :          0 :                         reset_phy = true;
   12470                 :            : 
   12471                 :          0 :                 err = tg3_restart_hw(tp, reset_phy);
   12472         [ #  # ]:          0 :                 if (!err)
   12473                 :          0 :                         tg3_netif_start(tp);
   12474                 :            :         }
   12475                 :            : 
   12476                 :          0 :         tg3_full_unlock(tp);
   12477                 :            : 
   12478         [ #  # ]:          0 :         if (irq_sync && !err)
   12479                 :          0 :                 tg3_phy_start(tp);
   12480                 :            : 
   12481                 :            :         return err;
   12482                 :            : }
   12483                 :            : 
   12484                 :          0 : static void tg3_get_pauseparam(struct net_device *dev, struct ethtool_pauseparam *epause)
   12485                 :            : {
   12486                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   12487                 :            : 
   12488                 :          0 :         epause->autoneg = !!tg3_flag(tp, PAUSE_AUTONEG);
   12489                 :            : 
   12490         [ #  # ]:          0 :         if (tp->link_config.flowctrl & FLOW_CTRL_RX)
   12491                 :          0 :                 epause->rx_pause = 1;
   12492                 :            :         else
   12493                 :          0 :                 epause->rx_pause = 0;
   12494                 :            : 
   12495         [ #  # ]:          0 :         if (tp->link_config.flowctrl & FLOW_CTRL_TX)
   12496                 :          0 :                 epause->tx_pause = 1;
   12497                 :            :         else
   12498                 :          0 :                 epause->tx_pause = 0;
   12499                 :          0 : }
   12500                 :            : 
   12501                 :          0 : static int tg3_set_pauseparam(struct net_device *dev, struct ethtool_pauseparam *epause)
   12502                 :            : {
   12503         [ #  # ]:          0 :         struct tg3 *tp = netdev_priv(dev);
   12504                 :          0 :         int err = 0;
   12505                 :          0 :         bool reset_phy = false;
   12506                 :            : 
   12507         [ #  # ]:          0 :         if (tp->link_config.autoneg == AUTONEG_ENABLE)
   12508                 :          0 :                 tg3_warn_mgmt_link_flap(tp);
   12509                 :            : 
   12510         [ #  # ]:          0 :         if (tg3_flag(tp, USE_PHYLIB)) {
   12511                 :          0 :                 struct phy_device *phydev;
   12512                 :            : 
   12513                 :          0 :                 phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr);
   12514                 :            : 
   12515         [ #  # ]:          0 :                 if (!phy_validate_pause(phydev, epause))
   12516                 :            :                         return -EINVAL;
   12517                 :            : 
   12518                 :          0 :                 tp->link_config.flowctrl = 0;
   12519                 :          0 :                 phy_set_asym_pause(phydev, epause->rx_pause, epause->tx_pause);
   12520         [ #  # ]:          0 :                 if (epause->rx_pause) {
   12521                 :          0 :                         tp->link_config.flowctrl |= FLOW_CTRL_RX;
   12522                 :            : 
   12523         [ #  # ]:          0 :                         if (epause->tx_pause) {
   12524                 :          0 :                                 tp->link_config.flowctrl |= FLOW_CTRL_TX;
   12525                 :            :                         }
   12526         [ #  # ]:          0 :                 } else if (epause->tx_pause) {
   12527                 :          0 :                         tp->link_config.flowctrl |= FLOW_CTRL_TX;
   12528                 :            :                 }
   12529                 :            : 
   12530         [ #  # ]:          0 :                 if (epause->autoneg)
   12531                 :          0 :                         tg3_flag_set(tp, PAUSE_AUTONEG);
   12532                 :            :                 else
   12533                 :          0 :                         tg3_flag_clear(tp, PAUSE_AUTONEG);
   12534                 :            : 
   12535         [ #  # ]:          0 :                 if (tp->phy_flags & TG3_PHYFLG_IS_CONNECTED) {
   12536         [ #  # ]:          0 :                         if (phydev->autoneg) {
   12537                 :            :                                 /* phy_set_asym_pause() will
   12538                 :            :                                  * renegotiate the link to inform our
   12539                 :            :                                  * link partner of our flow control
   12540                 :            :                                  * settings, even if the flow control
   12541                 :            :                                  * is forced.  Let tg3_adjust_link()
   12542                 :            :                                  * do the final flow control setup.
   12543                 :            :                                  */
   12544                 :            :                                 return 0;
   12545                 :            :                         }
   12546                 :            : 
   12547         [ #  # ]:          0 :                         if (!epause->autoneg)
   12548                 :          0 :                                 tg3_setup_flow_control(tp, 0, 0);
   12549                 :            :                 }
   12550                 :            :         } else {
   12551                 :          0 :                 int irq_sync = 0;
   12552                 :            : 
   12553         [ #  # ]:          0 :                 if (netif_running(dev)) {
   12554                 :          0 :                         tg3_netif_stop(tp);
   12555                 :          0 :                         irq_sync = 1;
   12556                 :            :                 }
   12557                 :            : 
   12558                 :          0 :                 tg3_full_lock(tp, irq_sync);
   12559                 :            : 
   12560         [ #  # ]:          0 :                 if (epause->autoneg)
   12561                 :          0 :                         tg3_flag_set(tp, PAUSE_AUTONEG);
   12562                 :            :                 else
   12563                 :          0 :                         tg3_flag_clear(tp, PAUSE_AUTONEG);
   12564         [ #  # ]:          0 :                 if (epause->rx_pause)
   12565                 :          0 :                         tp->link_config.flowctrl |= FLOW_CTRL_RX;
   12566                 :            :                 else
   12567                 :          0 :                         tp->link_config.flowctrl &= ~FLOW_CTRL_RX;
   12568         [ #  # ]:          0 :                 if (epause->tx_pause)
   12569                 :          0 :                         tp->link_config.flowctrl |= FLOW_CTRL_TX;
   12570                 :            :                 else
   12571                 :          0 :                         tp->link_config.flowctrl &= ~FLOW_CTRL_TX;
   12572                 :            : 
   12573         [ #  # ]:          0 :                 if (netif_running(dev)) {
   12574                 :          0 :                         tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
   12575                 :            :                         /* Reset PHY to avoid PHY lock up */
   12576         [ #  # ]:          0 :                         if (tg3_asic_rev(tp) == ASIC_REV_5717 ||
   12577         [ #  # ]:          0 :                             tg3_asic_rev(tp) == ASIC_REV_5719 ||
   12578                 :            :                             tg3_asic_rev(tp) == ASIC_REV_5720)
   12579                 :          0 :                                 reset_phy = true;
   12580                 :            : 
   12581                 :          0 :                         err = tg3_restart_hw(tp, reset_phy);
   12582         [ #  # ]:          0 :                         if (!err)
   12583                 :          0 :                                 tg3_netif_start(tp);
   12584                 :            :                 }
   12585                 :            : 
   12586                 :          0 :                 tg3_full_unlock(tp);
   12587                 :            :         }
   12588                 :            : 
   12589                 :          0 :         tp->phy_flags |= TG3_PHYFLG_USER_CONFIGURED;
   12590                 :            : 
   12591                 :          0 :         return err;
   12592                 :            : }
   12593                 :            : 
   12594                 :          0 : static int tg3_get_sset_count(struct net_device *dev, int sset)
   12595                 :            : {
   12596      [ #  #  # ]:          0 :         switch (sset) {
   12597                 :            :         case ETH_SS_TEST:
   12598                 :            :                 return TG3_NUM_TEST;
   12599                 :          0 :         case ETH_SS_STATS:
   12600                 :          0 :                 return TG3_NUM_STATS;
   12601                 :          0 :         default:
   12602                 :          0 :                 return -EOPNOTSUPP;
   12603                 :            :         }
   12604                 :            : }
   12605                 :            : 
   12606                 :          0 : static int tg3_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info,
   12607                 :            :                          u32 *rules __always_unused)
   12608                 :            : {
   12609                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   12610                 :            : 
   12611         [ #  # ]:          0 :         if (!tg3_flag(tp, SUPPORT_MSIX))
   12612                 :            :                 return -EOPNOTSUPP;
   12613                 :            : 
   12614         [ #  # ]:          0 :         switch (info->cmd) {
   12615                 :          0 :         case ETHTOOL_GRXRINGS:
   12616         [ #  # ]:          0 :                 if (netif_running(tp->dev))
   12617                 :          0 :                         info->data = tp->rxq_cnt;
   12618                 :            :                 else {
   12619                 :          0 :                         info->data = num_online_cpus();
   12620         [ #  # ]:          0 :                         if (info->data > TG3_RSS_MAX_NUM_QS)
   12621                 :          0 :                                 info->data = TG3_RSS_MAX_NUM_QS;
   12622                 :            :                 }
   12623                 :            : 
   12624                 :            :                 return 0;
   12625                 :            : 
   12626                 :            :         default:
   12627                 :            :                 return -EOPNOTSUPP;
   12628                 :            :         }
   12629                 :            : }
   12630                 :            : 
   12631                 :          0 : static u32 tg3_get_rxfh_indir_size(struct net_device *dev)
   12632                 :            : {
   12633                 :          0 :         u32 size = 0;
   12634                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   12635                 :            : 
   12636         [ #  # ]:          0 :         if (tg3_flag(tp, SUPPORT_MSIX))
   12637                 :          0 :                 size = TG3_RSS_INDIR_TBL_SIZE;
   12638                 :            : 
   12639                 :          0 :         return size;
   12640                 :            : }
   12641                 :            : 
   12642                 :          0 : static int tg3_get_rxfh(struct net_device *dev, u32 *indir, u8 *key, u8 *hfunc)
   12643                 :            : {
   12644         [ #  # ]:          0 :         struct tg3 *tp = netdev_priv(dev);
   12645                 :          0 :         int i;
   12646                 :            : 
   12647         [ #  # ]:          0 :         if (hfunc)
   12648                 :          0 :                 *hfunc = ETH_RSS_HASH_TOP;
   12649         [ #  # ]:          0 :         if (!indir)
   12650                 :            :                 return 0;
   12651                 :            : 
   12652         [ #  # ]:          0 :         for (i = 0; i < TG3_RSS_INDIR_TBL_SIZE; i++)
   12653                 :          0 :                 indir[i] = tp->rss_ind_tbl[i];
   12654                 :            : 
   12655                 :            :         return 0;
   12656                 :            : }
   12657                 :            : 
   12658                 :          0 : static int tg3_set_rxfh(struct net_device *dev, const u32 *indir, const u8 *key,
   12659                 :            :                         const u8 hfunc)
   12660                 :            : {
   12661         [ #  # ]:          0 :         struct tg3 *tp = netdev_priv(dev);
   12662                 :          0 :         size_t i;
   12663                 :            : 
   12664                 :            :         /* We require at least one supported parameter to be changed and no
   12665                 :            :          * change in any of the unsupported parameters
   12666                 :            :          */
   12667                 :          0 :         if (key ||
   12668         [ #  # ]:          0 :             (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP))
   12669                 :            :                 return -EOPNOTSUPP;
   12670                 :            : 
   12671         [ #  # ]:          0 :         if (!indir)
   12672                 :            :                 return 0;
   12673                 :            : 
   12674         [ #  # ]:          0 :         for (i = 0; i < TG3_RSS_INDIR_TBL_SIZE; i++)
   12675                 :          0 :                 tp->rss_ind_tbl[i] = indir[i];
   12676                 :            : 
   12677   [ #  #  #  # ]:          0 :         if (!netif_running(dev) || !tg3_flag(tp, ENABLE_RSS))
   12678                 :          0 :                 return 0;
   12679                 :            : 
   12680                 :            :         /* It is legal to write the indirection
   12681                 :            :          * table while the device is running.
   12682                 :            :          */
   12683                 :          0 :         tg3_full_lock(tp, 0);
   12684                 :          0 :         tg3_rss_write_indir_tbl(tp);
   12685                 :          0 :         tg3_full_unlock(tp);
   12686                 :            : 
   12687                 :          0 :         return 0;
   12688                 :            : }
   12689                 :            : 
   12690                 :          0 : static void tg3_get_channels(struct net_device *dev,
   12691                 :            :                              struct ethtool_channels *channel)
   12692                 :            : {
   12693                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   12694                 :          0 :         u32 deflt_qs = netif_get_num_default_rss_queues();
   12695                 :            : 
   12696                 :          0 :         channel->max_rx = tp->rxq_max;
   12697                 :          0 :         channel->max_tx = tp->txq_max;
   12698                 :            : 
   12699         [ #  # ]:          0 :         if (netif_running(dev)) {
   12700                 :          0 :                 channel->rx_count = tp->rxq_cnt;
   12701                 :          0 :                 channel->tx_count = tp->txq_cnt;
   12702                 :            :         } else {
   12703         [ #  # ]:          0 :                 if (tp->rxq_req)
   12704                 :          0 :                         channel->rx_count = tp->rxq_req;
   12705                 :            :                 else
   12706                 :          0 :                         channel->rx_count = min(deflt_qs, tp->rxq_max);
   12707                 :            : 
   12708         [ #  # ]:          0 :                 if (tp->txq_req)
   12709                 :          0 :                         channel->tx_count = tp->txq_req;
   12710                 :            :                 else
   12711                 :          0 :                         channel->tx_count = min(deflt_qs, tp->txq_max);
   12712                 :            :         }
   12713                 :          0 : }
   12714                 :            : 
   12715                 :          0 : static int tg3_set_channels(struct net_device *dev,
   12716                 :            :                             struct ethtool_channels *channel)
   12717                 :            : {
   12718                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   12719                 :            : 
   12720         [ #  # ]:          0 :         if (!tg3_flag(tp, SUPPORT_MSIX))
   12721                 :            :                 return -EOPNOTSUPP;
   12722                 :            : 
   12723         [ #  # ]:          0 :         if (channel->rx_count > tp->rxq_max ||
   12724         [ #  # ]:          0 :             channel->tx_count > tp->txq_max)
   12725                 :            :                 return -EINVAL;
   12726                 :            : 
   12727                 :          0 :         tp->rxq_req = channel->rx_count;
   12728                 :          0 :         tp->txq_req = channel->tx_count;
   12729                 :            : 
   12730         [ #  # ]:          0 :         if (!netif_running(dev))
   12731                 :            :                 return 0;
   12732                 :            : 
   12733                 :          0 :         tg3_stop(tp);
   12734                 :            : 
   12735                 :          0 :         tg3_carrier_off(tp);
   12736                 :            : 
   12737                 :          0 :         tg3_start(tp, true, false, false);
   12738                 :            : 
   12739                 :          0 :         return 0;
   12740                 :            : }
   12741                 :            : 
   12742                 :          0 : static void tg3_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
   12743                 :            : {
   12744      [ #  #  # ]:          0 :         switch (stringset) {
   12745                 :          0 :         case ETH_SS_STATS:
   12746                 :          0 :                 memcpy(buf, &ethtool_stats_keys, sizeof(ethtool_stats_keys));
   12747                 :          0 :                 break;
   12748                 :          0 :         case ETH_SS_TEST:
   12749                 :          0 :                 memcpy(buf, &ethtool_test_keys, sizeof(ethtool_test_keys));
   12750                 :          0 :                 break;
   12751                 :            :         default:
   12752                 :          0 :                 WARN_ON(1);     /* we need a WARN() */
   12753                 :          0 :                 break;
   12754                 :            :         }
   12755                 :          0 : }
   12756                 :            : 
   12757                 :          0 : static int tg3_set_phys_id(struct net_device *dev,
   12758                 :            :                             enum ethtool_phys_id_state state)
   12759                 :            : {
   12760   [ #  #  #  #  :          0 :         struct tg3 *tp = netdev_priv(dev);
                      # ]
   12761                 :            : 
   12762   [ #  #  #  #  :          0 :         switch (state) {
                      # ]
   12763                 :            :         case ETHTOOL_ID_ACTIVE:
   12764                 :            :                 return 1;       /* cycle on/off once per second */
   12765                 :            : 
   12766                 :          0 :         case ETHTOOL_ID_ON:
   12767                 :          0 :                 tw32(MAC_LED_CTRL, LED_CTRL_LNKLED_OVERRIDE |
   12768                 :            :                      LED_CTRL_1000MBPS_ON |
   12769                 :            :                      LED_CTRL_100MBPS_ON |
   12770                 :            :                      LED_CTRL_10MBPS_ON |
   12771                 :            :                      LED_CTRL_TRAFFIC_OVERRIDE |
   12772                 :            :                      LED_CTRL_TRAFFIC_BLINK |
   12773                 :            :                      LED_CTRL_TRAFFIC_LED);
   12774                 :          0 :                 break;
   12775                 :            : 
   12776                 :          0 :         case ETHTOOL_ID_OFF:
   12777                 :          0 :                 tw32(MAC_LED_CTRL, LED_CTRL_LNKLED_OVERRIDE |
   12778                 :            :                      LED_CTRL_TRAFFIC_OVERRIDE);
   12779                 :          0 :                 break;
   12780                 :            : 
   12781                 :          0 :         case ETHTOOL_ID_INACTIVE:
   12782                 :          0 :                 tw32(MAC_LED_CTRL, tp->led_ctrl);
   12783                 :          0 :                 break;
   12784                 :            :         }
   12785                 :            : 
   12786                 :            :         return 0;
   12787                 :            : }
   12788                 :            : 
   12789                 :          0 : static void tg3_get_ethtool_stats(struct net_device *dev,
   12790                 :            :                                    struct ethtool_stats *estats, u64 *tmp_stats)
   12791                 :            : {
   12792         [ #  # ]:          0 :         struct tg3 *tp = netdev_priv(dev);
   12793                 :            : 
   12794         [ #  # ]:          0 :         if (tp->hw_stats)
   12795                 :          0 :                 tg3_get_estats(tp, (struct tg3_ethtool_stats *)tmp_stats);
   12796                 :            :         else
   12797                 :          0 :                 memset(tmp_stats, 0, sizeof(struct tg3_ethtool_stats));
   12798                 :          0 : }
   12799                 :            : 
   12800                 :          0 : static __be32 *tg3_vpd_readblock(struct tg3 *tp, u32 *vpdlen)
   12801                 :            : {
   12802                 :          0 :         int i;
   12803                 :          0 :         __be32 *buf;
   12804                 :          0 :         u32 offset = 0, len = 0;
   12805                 :          0 :         u32 magic, val;
   12806                 :            : 
   12807   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, NO_NVRAM) || tg3_nvram_read(tp, 0, &magic))
   12808                 :          0 :                 return NULL;
   12809                 :            : 
   12810         [ #  # ]:          0 :         if (magic == TG3_EEPROM_MAGIC) {
   12811                 :          0 :                 for (offset = TG3_NVM_DIR_START;
   12812         [ #  # ]:          0 :                      offset < TG3_NVM_DIR_END;
   12813                 :          0 :                      offset += TG3_NVM_DIRENT_SIZE) {
   12814         [ #  # ]:          0 :                         if (tg3_nvram_read(tp, offset, &val))
   12815                 :            :                                 return NULL;
   12816                 :            : 
   12817         [ #  # ]:          0 :                         if ((val >> TG3_NVM_DIRTYPE_SHIFT) ==
   12818                 :            :                             TG3_NVM_DIRTYPE_EXTVPD)
   12819                 :            :                                 break;
   12820                 :            :                 }
   12821                 :            : 
   12822         [ #  # ]:          0 :                 if (offset != TG3_NVM_DIR_END) {
   12823                 :          0 :                         len = (val & TG3_NVM_DIRTYPE_LENMSK) * 4;
   12824         [ #  # ]:          0 :                         if (tg3_nvram_read(tp, offset + 4, &offset))
   12825                 :            :                                 return NULL;
   12826                 :            : 
   12827                 :          0 :                         offset = tg3_nvram_logical_addr(tp, offset);
   12828                 :            :                 }
   12829                 :            :         }
   12830                 :            : 
   12831   [ #  #  #  # ]:          0 :         if (!offset || !len) {
   12832                 :          0 :                 offset = TG3_NVM_VPD_OFF;
   12833                 :          0 :                 len = TG3_NVM_VPD_LEN;
   12834                 :            :         }
   12835                 :            : 
   12836         [ #  # ]:          0 :         buf = kmalloc(len, GFP_KERNEL);
   12837         [ #  # ]:          0 :         if (buf == NULL)
   12838                 :            :                 return NULL;
   12839                 :            : 
   12840         [ #  # ]:          0 :         if (magic == TG3_EEPROM_MAGIC) {
   12841         [ #  # ]:          0 :                 for (i = 0; i < len; i += 4) {
   12842                 :            :                         /* The data is in little-endian format in NVRAM.
   12843                 :            :                          * Use the big-endian read routines to preserve
   12844                 :            :                          * the byte order as it exists in NVRAM.
   12845                 :            :                          */
   12846         [ #  # ]:          0 :                         if (tg3_nvram_read_be32(tp, offset + i, &buf[i/4]))
   12847                 :          0 :                                 goto error;
   12848                 :            :                 }
   12849                 :            :         } else {
   12850                 :            :                 u8 *ptr;
   12851                 :            :                 ssize_t cnt;
   12852                 :            :                 unsigned int pos = 0;
   12853                 :            : 
   12854                 :            :                 ptr = (u8 *)&buf[0];
   12855         [ #  # ]:          0 :                 for (i = 0; pos < len && i < 3; i++, pos += cnt, ptr += cnt) {
   12856                 :          0 :                         cnt = pci_read_vpd(tp->pdev, pos,
   12857                 :          0 :                                            len - pos, ptr);
   12858         [ #  # ]:          0 :                         if (cnt == -ETIMEDOUT || cnt == -EINTR)
   12859                 :            :                                 cnt = 0;
   12860         [ #  # ]:          0 :                         else if (cnt < 0)
   12861                 :          0 :                                 goto error;
   12862                 :            :                 }
   12863         [ #  # ]:          0 :                 if (pos != len)
   12864                 :          0 :                         goto error;
   12865                 :            :         }
   12866                 :            : 
   12867                 :          0 :         *vpdlen = len;
   12868                 :            : 
   12869                 :          0 :         return buf;
   12870                 :            : 
   12871                 :          0 : error:
   12872                 :          0 :         kfree(buf);
   12873                 :          0 :         return NULL;
   12874                 :            : }
   12875                 :            : 
   12876                 :            : #define NVRAM_TEST_SIZE 0x100
   12877                 :            : #define NVRAM_SELFBOOT_FORMAT1_0_SIZE   0x14
   12878                 :            : #define NVRAM_SELFBOOT_FORMAT1_2_SIZE   0x18
   12879                 :            : #define NVRAM_SELFBOOT_FORMAT1_3_SIZE   0x1c
   12880                 :            : #define NVRAM_SELFBOOT_FORMAT1_4_SIZE   0x20
   12881                 :            : #define NVRAM_SELFBOOT_FORMAT1_5_SIZE   0x24
   12882                 :            : #define NVRAM_SELFBOOT_FORMAT1_6_SIZE   0x50
   12883                 :            : #define NVRAM_SELFBOOT_HW_SIZE 0x20
   12884                 :            : #define NVRAM_SELFBOOT_DATA_SIZE 0x1c
   12885                 :            : 
   12886                 :          0 : static int tg3_test_nvram(struct tg3 *tp)
   12887                 :            : {
   12888                 :          0 :         u32 csum, magic, len;
   12889                 :          0 :         __be32 *buf;
   12890                 :          0 :         int i, j, k, err = 0, size;
   12891                 :            : 
   12892         [ #  # ]:          0 :         if (tg3_flag(tp, NO_NVRAM))
   12893                 :            :                 return 0;
   12894                 :            : 
   12895         [ #  # ]:          0 :         if (tg3_nvram_read(tp, 0, &magic) != 0)
   12896                 :            :                 return -EIO;
   12897                 :            : 
   12898         [ #  # ]:          0 :         if (magic == TG3_EEPROM_MAGIC)
   12899                 :            :                 size = NVRAM_TEST_SIZE;
   12900         [ #  # ]:          0 :         else if ((magic & TG3_EEPROM_MAGIC_FW_MSK) == TG3_EEPROM_MAGIC_FW) {
   12901         [ #  # ]:          0 :                 if ((magic & TG3_EEPROM_SB_FORMAT_MASK) ==
   12902                 :            :                     TG3_EEPROM_SB_FORMAT_1) {
   12903   [ #  #  #  #  :          0 :                         switch (magic & TG3_EEPROM_SB_REVISION_MASK) {
                #  #  # ]
   12904                 :            :                         case TG3_EEPROM_SB_REVISION_0:
   12905                 :            :                                 size = NVRAM_SELFBOOT_FORMAT1_0_SIZE;
   12906                 :            :                                 break;
   12907                 :          0 :                         case TG3_EEPROM_SB_REVISION_2:
   12908                 :          0 :                                 size = NVRAM_SELFBOOT_FORMAT1_2_SIZE;
   12909                 :          0 :                                 break;
   12910                 :          0 :                         case TG3_EEPROM_SB_REVISION_3:
   12911                 :          0 :                                 size = NVRAM_SELFBOOT_FORMAT1_3_SIZE;
   12912                 :          0 :                                 break;
   12913                 :          0 :                         case TG3_EEPROM_SB_REVISION_4:
   12914                 :          0 :                                 size = NVRAM_SELFBOOT_FORMAT1_4_SIZE;
   12915                 :          0 :                                 break;
   12916                 :          0 :                         case TG3_EEPROM_SB_REVISION_5:
   12917                 :          0 :                                 size = NVRAM_SELFBOOT_FORMAT1_5_SIZE;
   12918                 :          0 :                                 break;
   12919                 :          0 :                         case TG3_EEPROM_SB_REVISION_6:
   12920                 :          0 :                                 size = NVRAM_SELFBOOT_FORMAT1_6_SIZE;
   12921                 :          0 :                                 break;
   12922                 :            :                         default:
   12923                 :            :                                 return -EIO;
   12924                 :            :                         }
   12925                 :            :                 } else
   12926                 :            :                         return 0;
   12927         [ #  # ]:          0 :         } else if ((magic & TG3_EEPROM_MAGIC_HW_MSK) == TG3_EEPROM_MAGIC_HW)
   12928                 :            :                 size = NVRAM_SELFBOOT_HW_SIZE;
   12929                 :            :         else
   12930                 :            :                 return -EIO;
   12931                 :            : 
   12932         [ #  # ]:          0 :         buf = kmalloc(size, GFP_KERNEL);
   12933         [ #  # ]:          0 :         if (buf == NULL)
   12934                 :            :                 return -ENOMEM;
   12935                 :            : 
   12936                 :            :         err = -EIO;
   12937         [ #  # ]:          0 :         for (i = 0, j = 0; i < size; i += 4, j++) {
   12938                 :          0 :                 err = tg3_nvram_read_be32(tp, i, &buf[j]);
   12939         [ #  # ]:          0 :                 if (err)
   12940                 :            :                         break;
   12941                 :            :         }
   12942         [ #  # ]:          0 :         if (i < size)
   12943                 :          0 :                 goto out;
   12944                 :            : 
   12945                 :            :         /* Selfboot format */
   12946                 :          0 :         magic = be32_to_cpu(buf[0]);
   12947         [ #  # ]:          0 :         if ((magic & TG3_EEPROM_MAGIC_FW_MSK) ==
   12948                 :            :             TG3_EEPROM_MAGIC_FW) {
   12949                 :          0 :                 u8 *buf8 = (u8 *) buf, csum8 = 0;
   12950                 :            : 
   12951         [ #  # ]:          0 :                 if ((magic & TG3_EEPROM_SB_REVISION_MASK) ==
   12952                 :            :                     TG3_EEPROM_SB_REVISION_2) {
   12953                 :            :                         /* For rev 2, the csum doesn't include the MBA. */
   12954         [ #  # ]:          0 :                         for (i = 0; i < TG3_EEPROM_SB_F1R2_MBA_OFF; i++)
   12955                 :          0 :                                 csum8 += buf8[i];
   12956         [ #  # ]:          0 :                         for (i = TG3_EEPROM_SB_F1R2_MBA_OFF + 4; i < size; i++)
   12957                 :          0 :                                 csum8 += buf8[i];
   12958                 :            :                 } else {
   12959         [ #  # ]:          0 :                         for (i = 0; i < size; i++)
   12960                 :          0 :                                 csum8 += buf8[i];
   12961                 :            :                 }
   12962                 :            : 
   12963         [ #  # ]:          0 :                 if (csum8 == 0) {
   12964                 :          0 :                         err = 0;
   12965                 :          0 :                         goto out;
   12966                 :            :                 }
   12967                 :            : 
   12968                 :          0 :                 err = -EIO;
   12969                 :          0 :                 goto out;
   12970                 :            :         }
   12971                 :            : 
   12972         [ #  # ]:          0 :         if ((magic & TG3_EEPROM_MAGIC_HW_MSK) ==
   12973                 :            :             TG3_EEPROM_MAGIC_HW) {
   12974                 :            :                 u8 data[NVRAM_SELFBOOT_DATA_SIZE];
   12975                 :            :                 u8 parity[NVRAM_SELFBOOT_DATA_SIZE];
   12976                 :            :                 u8 *buf8 = (u8 *) buf;
   12977                 :            : 
   12978                 :            :                 /* Separate the parity bits and the data bytes.  */
   12979         [ #  # ]:          0 :                 for (i = 0, j = 0, k = 0; i < NVRAM_SELFBOOT_HW_SIZE; i++) {
   12980         [ #  # ]:          0 :                         if ((i == 0) || (i == 8)) {
   12981                 :            :                                 int l;
   12982                 :            :                                 u8 msk;
   12983                 :            : 
   12984         [ #  # ]:          0 :                                 for (l = 0, msk = 0x80; l < 7; l++, msk >>= 1)
   12985                 :          0 :                                         parity[k++] = buf8[i] & msk;
   12986                 :          0 :                                 i++;
   12987         [ #  # ]:          0 :                         } else if (i == 16) {
   12988                 :            :                                 int l;
   12989                 :            :                                 u8 msk;
   12990                 :            : 
   12991         [ #  # ]:          0 :                                 for (l = 0, msk = 0x20; l < 6; l++, msk >>= 1)
   12992                 :          0 :                                         parity[k++] = buf8[i] & msk;
   12993                 :            :                                 i++;
   12994                 :            : 
   12995         [ #  # ]:          0 :                                 for (l = 0, msk = 0x80; l < 8; l++, msk >>= 1)
   12996                 :          0 :                                         parity[k++] = buf8[i] & msk;
   12997                 :            :                                 i++;
   12998                 :            :                         }
   12999                 :          0 :                         data[j++] = buf8[i];
   13000                 :            :                 }
   13001                 :            : 
   13002                 :            :                 err = -EIO;
   13003         [ #  # ]:          0 :                 for (i = 0; i < NVRAM_SELFBOOT_DATA_SIZE; i++) {
   13004         [ #  # ]:          0 :                         u8 hw8 = hweight8(data[i]);
   13005                 :            : 
   13006   [ #  #  #  # ]:          0 :                         if ((hw8 & 0x1) && parity[i])
   13007                 :          0 :                                 goto out;
   13008   [ #  #  #  # ]:          0 :                         else if (!(hw8 & 0x1) && !parity[i])
   13009                 :          0 :                                 goto out;
   13010                 :            :                 }
   13011                 :          0 :                 err = 0;
   13012                 :          0 :                 goto out;
   13013                 :            :         }
   13014                 :            : 
   13015                 :            :         err = -EIO;
   13016                 :            : 
   13017                 :            :         /* Bootstrap checksum at offset 0x10 */
   13018                 :            :         csum = calc_crc((unsigned char *) buf, 0x10);
   13019         [ #  # ]:          0 :         if (csum != le32_to_cpu(buf[0x10/4]))
   13020                 :          0 :                 goto out;
   13021                 :            : 
   13022                 :            :         /* Manufacturing block starts at offset 0x74, checksum at 0xfc */
   13023                 :            :         csum = calc_crc((unsigned char *) &buf[0x74/4], 0x88);
   13024         [ #  # ]:          0 :         if (csum != le32_to_cpu(buf[0xfc/4]))
   13025                 :          0 :                 goto out;
   13026                 :            : 
   13027                 :          0 :         kfree(buf);
   13028                 :            : 
   13029                 :          0 :         buf = tg3_vpd_readblock(tp, &len);
   13030         [ #  # ]:          0 :         if (!buf)
   13031                 :            :                 return -ENOMEM;
   13032                 :            : 
   13033                 :          0 :         i = pci_vpd_find_tag((u8 *)buf, 0, len, PCI_VPD_LRDT_RO_DATA);
   13034         [ #  # ]:          0 :         if (i > 0) {
   13035         [ #  # ]:          0 :                 j = pci_vpd_lrdt_size(&((u8 *)buf)[i]);
   13036                 :          0 :                 if (j < 0)
   13037                 :            :                         goto out;
   13038                 :            : 
   13039         [ #  # ]:          0 :                 if (i + PCI_VPD_LRDT_TAG_SIZE + j > len)
   13040                 :          0 :                         goto out;
   13041                 :            : 
   13042                 :          0 :                 i += PCI_VPD_LRDT_TAG_SIZE;
   13043                 :          0 :                 j = pci_vpd_find_info_keyword((u8 *)buf, i, j,
   13044                 :            :                                               PCI_VPD_RO_KEYWORD_CHKSUM);
   13045         [ #  # ]:          0 :                 if (j > 0) {
   13046                 :          0 :                         u8 csum8 = 0;
   13047                 :            : 
   13048                 :          0 :                         j += PCI_VPD_INFO_FLD_HDR_SIZE;
   13049                 :            : 
   13050         [ #  # ]:          0 :                         for (i = 0; i <= j; i++)
   13051                 :          0 :                                 csum8 += ((u8 *)buf)[i];
   13052                 :            : 
   13053         [ #  # ]:          0 :                         if (csum8)
   13054                 :          0 :                                 goto out;
   13055                 :            :                 }
   13056                 :            :         }
   13057                 :            : 
   13058                 :            :         err = 0;
   13059                 :            : 
   13060                 :          0 : out:
   13061                 :          0 :         kfree(buf);
   13062                 :          0 :         return err;
   13063                 :            : }
   13064                 :            : 
   13065                 :            : #define TG3_SERDES_TIMEOUT_SEC  2
   13066                 :            : #define TG3_COPPER_TIMEOUT_SEC  6
   13067                 :            : 
   13068                 :          0 : static int tg3_test_link(struct tg3 *tp)
   13069                 :            : {
   13070                 :          0 :         int i, max;
   13071                 :            : 
   13072         [ #  # ]:          0 :         if (!netif_running(tp->dev))
   13073                 :            :                 return -ENODEV;
   13074                 :            : 
   13075         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_ANY_SERDES)
   13076                 :            :                 max = TG3_SERDES_TIMEOUT_SEC;
   13077                 :            :         else
   13078                 :          0 :                 max = TG3_COPPER_TIMEOUT_SEC;
   13079                 :            : 
   13080         [ #  # ]:          0 :         for (i = 0; i < max; i++) {
   13081         [ #  # ]:          0 :                 if (tp->link_up)
   13082                 :            :                         return 0;
   13083                 :            : 
   13084         [ #  # ]:          0 :                 if (msleep_interruptible(1000))
   13085                 :            :                         break;
   13086                 :            :         }
   13087                 :            : 
   13088                 :            :         return -EIO;
   13089                 :            : }
   13090                 :            : 
   13091                 :            : /* Only test the commonly used registers */
   13092                 :          0 : static int tg3_test_registers(struct tg3 *tp)
   13093                 :            : {
   13094                 :          0 :         int i, is_5705, is_5750;
   13095                 :          0 :         u32 offset, read_mask, write_mask, val, save_val, read_val;
   13096                 :          0 :         static struct {
   13097                 :            :                 u16 offset;
   13098                 :            :                 u16 flags;
   13099                 :            : #define TG3_FL_5705     0x1
   13100                 :            : #define TG3_FL_NOT_5705 0x2
   13101                 :            : #define TG3_FL_NOT_5788 0x4
   13102                 :            : #define TG3_FL_NOT_5750 0x8
   13103                 :            :                 u32 read_mask;
   13104                 :            :                 u32 write_mask;
   13105                 :            :         } reg_tbl[] = {
   13106                 :            :                 /* MAC Control Registers */
   13107                 :            :                 { MAC_MODE, TG3_FL_NOT_5705,
   13108                 :            :                         0x00000000, 0x00ef6f8c },
   13109                 :            :                 { MAC_MODE, TG3_FL_5705,
   13110                 :            :                         0x00000000, 0x01ef6b8c },
   13111                 :            :                 { MAC_STATUS, TG3_FL_NOT_5705,
   13112                 :            :                         0x03800107, 0x00000000 },
   13113                 :            :                 { MAC_STATUS, TG3_FL_5705,
   13114                 :            :                         0x03800100, 0x00000000 },
   13115                 :            :                 { MAC_ADDR_0_HIGH, 0x0000,
   13116                 :            :                         0x00000000, 0x0000ffff },
   13117                 :            :                 { MAC_ADDR_0_LOW, 0x0000,
   13118                 :            :                         0x00000000, 0xffffffff },
   13119                 :            :                 { MAC_RX_MTU_SIZE, 0x0000,
   13120                 :            :                         0x00000000, 0x0000ffff },
   13121                 :            :                 { MAC_TX_MODE, 0x0000,
   13122                 :            :                         0x00000000, 0x00000070 },
   13123                 :            :                 { MAC_TX_LENGTHS, 0x0000,
   13124                 :            :                         0x00000000, 0x00003fff },
   13125                 :            :                 { MAC_RX_MODE, TG3_FL_NOT_5705,
   13126                 :            :                         0x00000000, 0x000007fc },
   13127                 :            :                 { MAC_RX_MODE, TG3_FL_5705,
   13128                 :            :                         0x00000000, 0x000007dc },
   13129                 :            :                 { MAC_HASH_REG_0, 0x0000,
   13130                 :            :                         0x00000000, 0xffffffff },
   13131                 :            :                 { MAC_HASH_REG_1, 0x0000,
   13132                 :            :                         0x00000000, 0xffffffff },
   13133                 :            :                 { MAC_HASH_REG_2, 0x0000,
   13134                 :            :                         0x00000000, 0xffffffff },
   13135                 :            :                 { MAC_HASH_REG_3, 0x0000,
   13136                 :            :                         0x00000000, 0xffffffff },
   13137                 :            : 
   13138                 :            :                 /* Receive Data and Receive BD Initiator Control Registers. */
   13139                 :            :                 { RCVDBDI_JUMBO_BD+0, TG3_FL_NOT_5705,
   13140                 :            :                         0x00000000, 0xffffffff },
   13141                 :            :                 { RCVDBDI_JUMBO_BD+4, TG3_FL_NOT_5705,
   13142                 :            :                         0x00000000, 0xffffffff },
   13143                 :            :                 { RCVDBDI_JUMBO_BD+8, TG3_FL_NOT_5705,
   13144                 :            :                         0x00000000, 0x00000003 },
   13145                 :            :                 { RCVDBDI_JUMBO_BD+0xc, TG3_FL_NOT_5705,
   13146                 :            :                         0x00000000, 0xffffffff },
   13147                 :            :                 { RCVDBDI_STD_BD+0, 0x0000,
   13148                 :            :                         0x00000000, 0xffffffff },
   13149                 :            :                 { RCVDBDI_STD_BD+4, 0x0000,
   13150                 :            :                         0x00000000, 0xffffffff },
   13151                 :            :                 { RCVDBDI_STD_BD+8, 0x0000,
   13152                 :            :                         0x00000000, 0xffff0002 },
   13153                 :            :                 { RCVDBDI_STD_BD+0xc, 0x0000,
   13154                 :            :                         0x00000000, 0xffffffff },
   13155                 :            : 
   13156                 :            :                 /* Receive BD Initiator Control Registers. */
   13157                 :            :                 { RCVBDI_STD_THRESH, TG3_FL_NOT_5705,
   13158                 :            :                         0x00000000, 0xffffffff },
   13159                 :            :                 { RCVBDI_STD_THRESH, TG3_FL_5705,
   13160                 :            :                         0x00000000, 0x000003ff },
   13161                 :            :                 { RCVBDI_JUMBO_THRESH, TG3_FL_NOT_5705,
   13162                 :            :                         0x00000000, 0xffffffff },
   13163                 :            : 
   13164                 :            :                 /* Host Coalescing Control Registers. */
   13165                 :            :                 { HOSTCC_MODE, TG3_FL_NOT_5705,
   13166                 :            :                         0x00000000, 0x00000004 },
   13167                 :            :                 { HOSTCC_MODE, TG3_FL_5705,
   13168                 :            :                         0x00000000, 0x000000f6 },
   13169                 :            :                 { HOSTCC_RXCOL_TICKS, TG3_FL_NOT_5705,
   13170                 :            :                         0x00000000, 0xffffffff },
   13171                 :            :                 { HOSTCC_RXCOL_TICKS, TG3_FL_5705,
   13172                 :            :                         0x00000000, 0x000003ff },
   13173                 :            :                 { HOSTCC_TXCOL_TICKS, TG3_FL_NOT_5705,
   13174                 :            :                         0x00000000, 0xffffffff },
   13175                 :            :                 { HOSTCC_TXCOL_TICKS, TG3_FL_5705,
   13176                 :            :                         0x00000000, 0x000003ff },
   13177                 :            :                 { HOSTCC_RXMAX_FRAMES, TG3_FL_NOT_5705,
   13178                 :            :                         0x00000000, 0xffffffff },
   13179                 :            :                 { HOSTCC_RXMAX_FRAMES, TG3_FL_5705 | TG3_FL_NOT_5788,
   13180                 :            :                         0x00000000, 0x000000ff },
   13181                 :            :                 { HOSTCC_TXMAX_FRAMES, TG3_FL_NOT_5705,
   13182                 :            :                         0x00000000, 0xffffffff },
   13183                 :            :                 { HOSTCC_TXMAX_FRAMES, TG3_FL_5705 | TG3_FL_NOT_5788,
   13184                 :            :                         0x00000000, 0x000000ff },
   13185                 :            :                 { HOSTCC_RXCOAL_TICK_INT, TG3_FL_NOT_5705,
   13186                 :            :                         0x00000000, 0xffffffff },
   13187                 :            :                 { HOSTCC_TXCOAL_TICK_INT, TG3_FL_NOT_5705,
   13188                 :            :                         0x00000000, 0xffffffff },
   13189                 :            :                 { HOSTCC_RXCOAL_MAXF_INT, TG3_FL_NOT_5705,
   13190                 :            :                         0x00000000, 0xffffffff },
   13191                 :            :                 { HOSTCC_RXCOAL_MAXF_INT, TG3_FL_5705 | TG3_FL_NOT_5788,
   13192                 :            :                         0x00000000, 0x000000ff },
   13193                 :            :                 { HOSTCC_TXCOAL_MAXF_INT, TG3_FL_NOT_5705,
   13194                 :            :                         0x00000000, 0xffffffff },
   13195                 :            :                 { HOSTCC_TXCOAL_MAXF_INT, TG3_FL_5705 | TG3_FL_NOT_5788,
   13196                 :            :                         0x00000000, 0x000000ff },
   13197                 :            :                 { HOSTCC_STAT_COAL_TICKS, TG3_FL_NOT_5705,
   13198                 :            :                         0x00000000, 0xffffffff },
   13199                 :            :                 { HOSTCC_STATS_BLK_HOST_ADDR, TG3_FL_NOT_5705,
   13200                 :            :                         0x00000000, 0xffffffff },
   13201                 :            :                 { HOSTCC_STATS_BLK_HOST_ADDR+4, TG3_FL_NOT_5705,
   13202                 :            :                         0x00000000, 0xffffffff },
   13203                 :            :                 { HOSTCC_STATUS_BLK_HOST_ADDR, 0x0000,
   13204                 :            :                         0x00000000, 0xffffffff },
   13205                 :            :                 { HOSTCC_STATUS_BLK_HOST_ADDR+4, 0x0000,
   13206                 :            :                         0x00000000, 0xffffffff },
   13207                 :            :                 { HOSTCC_STATS_BLK_NIC_ADDR, 0x0000,
   13208                 :            :                         0xffffffff, 0x00000000 },
   13209                 :            :                 { HOSTCC_STATUS_BLK_NIC_ADDR, 0x0000,
   13210                 :            :                         0xffffffff, 0x00000000 },
   13211                 :            : 
   13212                 :            :                 /* Buffer Manager Control Registers. */
   13213                 :            :                 { BUFMGR_MB_POOL_ADDR, TG3_FL_NOT_5750,
   13214                 :            :                         0x00000000, 0x007fff80 },
   13215                 :            :                 { BUFMGR_MB_POOL_SIZE, TG3_FL_NOT_5750,
   13216                 :            :                         0x00000000, 0x007fffff },
   13217                 :            :                 { BUFMGR_MB_RDMA_LOW_WATER, 0x0000,
   13218                 :            :                         0x00000000, 0x0000003f },
   13219                 :            :                 { BUFMGR_MB_MACRX_LOW_WATER, 0x0000,
   13220                 :            :                         0x00000000, 0x000001ff },
   13221                 :            :                 { BUFMGR_MB_HIGH_WATER, 0x0000,
   13222                 :            :                         0x00000000, 0x000001ff },
   13223                 :            :                 { BUFMGR_DMA_DESC_POOL_ADDR, TG3_FL_NOT_5705,
   13224                 :            :                         0xffffffff, 0x00000000 },
   13225                 :            :                 { BUFMGR_DMA_DESC_POOL_SIZE, TG3_FL_NOT_5705,
   13226                 :            :                         0xffffffff, 0x00000000 },
   13227                 :            : 
   13228                 :            :                 /* Mailbox Registers */
   13229                 :            :                 { GRCMBOX_RCVSTD_PROD_IDX+4, 0x0000,
   13230                 :            :                         0x00000000, 0x000001ff },
   13231                 :            :                 { GRCMBOX_RCVJUMBO_PROD_IDX+4, TG3_FL_NOT_5705,
   13232                 :            :                         0x00000000, 0x000001ff },
   13233                 :            :                 { GRCMBOX_RCVRET_CON_IDX_0+4, 0x0000,
   13234                 :            :                         0x00000000, 0x000007ff },
   13235                 :            :                 { GRCMBOX_SNDHOST_PROD_IDX_0+4, 0x0000,
   13236                 :            :                         0x00000000, 0x000001ff },
   13237                 :            : 
   13238                 :            :                 { 0xffff, 0x0000, 0x00000000, 0x00000000 },
   13239                 :            :         };
   13240                 :            : 
   13241                 :          0 :         is_5705 = is_5750 = 0;
   13242         [ #  # ]:          0 :         if (tg3_flag(tp, 5705_PLUS)) {
   13243                 :          0 :                 is_5705 = 1;
   13244         [ #  # ]:          0 :                 if (tg3_flag(tp, 5750_PLUS))
   13245                 :          0 :                         is_5750 = 1;
   13246                 :            :         }
   13247                 :            : 
   13248         [ #  # ]:          0 :         for (i = 0; reg_tbl[i].offset != 0xffff; i++) {
   13249   [ #  #  #  # ]:          0 :                 if (is_5705 && (reg_tbl[i].flags & TG3_FL_NOT_5705))
   13250                 :          0 :                         continue;
   13251                 :            : 
   13252   [ #  #  #  # ]:          0 :                 if (!is_5705 && (reg_tbl[i].flags & TG3_FL_5705))
   13253                 :          0 :                         continue;
   13254                 :            : 
   13255         [ #  # ]:          0 :                 if (tg3_flag(tp, IS_5788) &&
   13256         [ #  # ]:          0 :                     (reg_tbl[i].flags & TG3_FL_NOT_5788))
   13257                 :          0 :                         continue;
   13258                 :            : 
   13259   [ #  #  #  # ]:          0 :                 if (is_5750 && (reg_tbl[i].flags & TG3_FL_NOT_5750))
   13260                 :          0 :                         continue;
   13261                 :            : 
   13262                 :          0 :                 offset = (u32) reg_tbl[i].offset;
   13263                 :          0 :                 read_mask = reg_tbl[i].read_mask;
   13264                 :          0 :                 write_mask = reg_tbl[i].write_mask;
   13265                 :            : 
   13266                 :            :                 /* Save the original register content */
   13267                 :          0 :                 save_val = tr32(offset);
   13268                 :            : 
   13269                 :            :                 /* Determine the read-only value. */
   13270                 :          0 :                 read_val = save_val & read_mask;
   13271                 :            : 
   13272                 :            :                 /* Write zero to the register, then make sure the read-only bits
   13273                 :            :                  * are not changed and the read/write bits are all zeros.
   13274                 :            :                  */
   13275                 :          0 :                 tw32(offset, 0);
   13276                 :            : 
   13277                 :          0 :                 val = tr32(offset);
   13278                 :            : 
   13279                 :            :                 /* Test the read-only and read/write bits. */
   13280   [ #  #  #  # ]:          0 :                 if (((val & read_mask) != read_val) || (val & write_mask))
   13281                 :          0 :                         goto out;
   13282                 :            : 
   13283                 :            :                 /* Write ones to all the bits defined by RdMask and WrMask, then
   13284                 :            :                  * make sure the read-only bits are not changed and the
   13285                 :            :                  * read/write bits are all ones.
   13286                 :            :                  */
   13287                 :          0 :                 tw32(offset, read_mask | write_mask);
   13288                 :            : 
   13289                 :          0 :                 val = tr32(offset);
   13290                 :            : 
   13291                 :            :                 /* Test the read-only bits. */
   13292         [ #  # ]:          0 :                 if ((val & read_mask) != read_val)
   13293                 :          0 :                         goto out;
   13294                 :            : 
   13295                 :            :                 /* Test the read/write bits. */
   13296         [ #  # ]:          0 :                 if ((val & write_mask) != write_mask)
   13297                 :          0 :                         goto out;
   13298                 :            : 
   13299                 :          0 :                 tw32(offset, save_val);
   13300                 :            :         }
   13301                 :            : 
   13302                 :            :         return 0;
   13303                 :            : 
   13304                 :          0 : out:
   13305         [ #  # ]:          0 :         if (netif_msg_hw(tp))
   13306                 :          0 :                 netdev_err(tp->dev,
   13307                 :            :                            "Register test failed at offset %x\n", offset);
   13308                 :          0 :         tw32(offset, save_val);
   13309                 :          0 :         return -EIO;
   13310                 :            : }
   13311                 :            : 
   13312                 :          0 : static int tg3_do_mem_test(struct tg3 *tp, u32 offset, u32 len)
   13313                 :            : {
   13314                 :          0 :         static const u32 test_pattern[] = { 0x00000000, 0xffffffff, 0xaa55a55a };
   13315                 :          0 :         int i;
   13316                 :          0 :         u32 j;
   13317                 :            : 
   13318         [ #  # ]:          0 :         for (i = 0; i < ARRAY_SIZE(test_pattern); i++) {
   13319         [ #  # ]:          0 :                 for (j = 0; j < len; j += 4) {
   13320                 :          0 :                         u32 val;
   13321                 :            : 
   13322                 :          0 :                         tg3_write_mem(tp, offset + j, test_pattern[i]);
   13323                 :          0 :                         tg3_read_mem(tp, offset + j, &val);
   13324         [ #  # ]:          0 :                         if (val != test_pattern[i])
   13325                 :          0 :                                 return -EIO;
   13326                 :            :                 }
   13327                 :            :         }
   13328                 :            :         return 0;
   13329                 :            : }
   13330                 :            : 
   13331                 :          0 : static int tg3_test_memory(struct tg3 *tp)
   13332                 :            : {
   13333                 :          0 :         static struct mem_entry {
   13334                 :            :                 u32 offset;
   13335                 :            :                 u32 len;
   13336                 :            :         } mem_tbl_570x[] = {
   13337                 :            :                 { 0x00000000, 0x00b50},
   13338                 :            :                 { 0x00002000, 0x1c000},
   13339                 :            :                 { 0xffffffff, 0x00000}
   13340                 :            :         }, mem_tbl_5705[] = {
   13341                 :            :                 { 0x00000100, 0x0000c},
   13342                 :            :                 { 0x00000200, 0x00008},
   13343                 :            :                 { 0x00004000, 0x00800},
   13344                 :            :                 { 0x00006000, 0x01000},
   13345                 :            :                 { 0x00008000, 0x02000},
   13346                 :            :                 { 0x00010000, 0x0e000},
   13347                 :            :                 { 0xffffffff, 0x00000}
   13348                 :            :         }, mem_tbl_5755[] = {
   13349                 :            :                 { 0x00000200, 0x00008},
   13350                 :            :                 { 0x00004000, 0x00800},
   13351                 :            :                 { 0x00006000, 0x00800},
   13352                 :            :                 { 0x00008000, 0x02000},
   13353                 :            :                 { 0x00010000, 0x0c000},
   13354                 :            :                 { 0xffffffff, 0x00000}
   13355                 :            :         }, mem_tbl_5906[] = {
   13356                 :            :                 { 0x00000200, 0x00008},
   13357                 :            :                 { 0x00004000, 0x00400},
   13358                 :            :                 { 0x00006000, 0x00400},
   13359                 :            :                 { 0x00008000, 0x01000},
   13360                 :            :                 { 0x00010000, 0x01000},
   13361                 :            :                 { 0xffffffff, 0x00000}
   13362                 :            :         }, mem_tbl_5717[] = {
   13363                 :            :                 { 0x00000200, 0x00008},
   13364                 :            :                 { 0x00010000, 0x0a000},
   13365                 :            :                 { 0x00020000, 0x13c00},
   13366                 :            :                 { 0xffffffff, 0x00000}
   13367                 :            :         }, mem_tbl_57765[] = {
   13368                 :            :                 { 0x00000200, 0x00008},
   13369                 :            :                 { 0x00004000, 0x00800},
   13370                 :            :                 { 0x00006000, 0x09800},
   13371                 :            :                 { 0x00010000, 0x0a000},
   13372                 :            :                 { 0xffffffff, 0x00000}
   13373                 :            :         };
   13374                 :          0 :         struct mem_entry *mem_tbl;
   13375                 :          0 :         int err = 0;
   13376                 :          0 :         int i;
   13377                 :            : 
   13378         [ #  # ]:          0 :         if (tg3_flag(tp, 5717_PLUS))
   13379                 :            :                 mem_tbl = mem_tbl_5717;
   13380         [ #  # ]:          0 :         else if (tg3_flag(tp, 57765_CLASS) ||
   13381         [ #  # ]:          0 :                  tg3_asic_rev(tp) == ASIC_REV_5762)
   13382                 :            :                 mem_tbl = mem_tbl_57765;
   13383         [ #  # ]:          0 :         else if (tg3_flag(tp, 5755_PLUS))
   13384                 :            :                 mem_tbl = mem_tbl_5755;
   13385         [ #  # ]:          0 :         else if (tg3_asic_rev(tp) == ASIC_REV_5906)
   13386                 :            :                 mem_tbl = mem_tbl_5906;
   13387         [ #  # ]:          0 :         else if (tg3_flag(tp, 5705_PLUS))
   13388                 :            :                 mem_tbl = mem_tbl_5705;
   13389                 :            :         else
   13390                 :          0 :                 mem_tbl = mem_tbl_570x;
   13391                 :            : 
   13392         [ #  # ]:          0 :         for (i = 0; mem_tbl[i].offset != 0xffffffff; i++) {
   13393                 :          0 :                 err = tg3_do_mem_test(tp, mem_tbl[i].offset, mem_tbl[i].len);
   13394         [ #  # ]:          0 :                 if (err)
   13395                 :            :                         break;
   13396                 :            :         }
   13397                 :            : 
   13398                 :          0 :         return err;
   13399                 :            : }
   13400                 :            : 
   13401                 :            : #define TG3_TSO_MSS             500
   13402                 :            : 
   13403                 :            : #define TG3_TSO_IP_HDR_LEN      20
   13404                 :            : #define TG3_TSO_TCP_HDR_LEN     20
   13405                 :            : #define TG3_TSO_TCP_OPT_LEN     12
   13406                 :            : 
   13407                 :            : static const u8 tg3_tso_header[] = {
   13408                 :            : 0x08, 0x00,
   13409                 :            : 0x45, 0x00, 0x00, 0x00,
   13410                 :            : 0x00, 0x00, 0x40, 0x00,
   13411                 :            : 0x40, 0x06, 0x00, 0x00,
   13412                 :            : 0x0a, 0x00, 0x00, 0x01,
   13413                 :            : 0x0a, 0x00, 0x00, 0x02,
   13414                 :            : 0x0d, 0x00, 0xe0, 0x00,
   13415                 :            : 0x00, 0x00, 0x01, 0x00,
   13416                 :            : 0x00, 0x00, 0x02, 0x00,
   13417                 :            : 0x80, 0x10, 0x10, 0x00,
   13418                 :            : 0x14, 0x09, 0x00, 0x00,
   13419                 :            : 0x01, 0x01, 0x08, 0x0a,
   13420                 :            : 0x11, 0x11, 0x11, 0x11,
   13421                 :            : 0x11, 0x11, 0x11, 0x11,
   13422                 :            : };
   13423                 :            : 
   13424                 :          0 : static int tg3_run_loopback(struct tg3 *tp, u32 pktsz, bool tso_loopback)
   13425                 :            : {
   13426                 :          0 :         u32 rx_start_idx, rx_idx, tx_idx, opaque_key;
   13427                 :          0 :         u32 base_flags = 0, mss = 0, desc_idx, coal_now, data_off, val;
   13428                 :          0 :         u32 budget;
   13429                 :          0 :         struct sk_buff *skb;
   13430                 :          0 :         u8 *tx_data, *rx_data;
   13431                 :          0 :         dma_addr_t map;
   13432                 :          0 :         int num_pkts, tx_len, rx_len, i, err;
   13433                 :          0 :         struct tg3_rx_buffer_desc *desc;
   13434                 :          0 :         struct tg3_napi *tnapi, *rnapi;
   13435                 :          0 :         struct tg3_rx_prodring_set *tpr = &tp->napi[0].prodring;
   13436                 :            : 
   13437                 :          0 :         tnapi = &tp->napi[0];
   13438                 :          0 :         rnapi = &tp->napi[0];
   13439         [ #  # ]:          0 :         if (tp->irq_cnt > 1) {
   13440         [ #  # ]:          0 :                 if (tg3_flag(tp, ENABLE_RSS))
   13441                 :          0 :                         rnapi = &tp->napi[1];
   13442         [ #  # ]:          0 :                 if (tg3_flag(tp, ENABLE_TSS))
   13443                 :          0 :                         tnapi = &tp->napi[1];
   13444                 :            :         }
   13445                 :          0 :         coal_now = tnapi->coal_now | rnapi->coal_now;
   13446                 :            : 
   13447                 :          0 :         err = -EIO;
   13448                 :            : 
   13449                 :          0 :         tx_len = pktsz;
   13450                 :          0 :         skb = netdev_alloc_skb(tp->dev, tx_len);
   13451         [ #  # ]:          0 :         if (!skb)
   13452                 :            :                 return -ENOMEM;
   13453                 :            : 
   13454                 :          0 :         tx_data = skb_put(skb, tx_len);
   13455                 :          0 :         memcpy(tx_data, tp->dev->dev_addr, ETH_ALEN);
   13456                 :          0 :         memset(tx_data + ETH_ALEN, 0x0, 8);
   13457                 :            : 
   13458                 :          0 :         tw32(MAC_RX_MTU_SIZE, tx_len + ETH_FCS_LEN);
   13459                 :            : 
   13460         [ #  # ]:          0 :         if (tso_loopback) {
   13461                 :          0 :                 struct iphdr *iph = (struct iphdr *)&tx_data[ETH_HLEN];
   13462                 :            : 
   13463                 :          0 :                 u32 hdr_len = TG3_TSO_IP_HDR_LEN + TG3_TSO_TCP_HDR_LEN +
   13464                 :            :                               TG3_TSO_TCP_OPT_LEN;
   13465                 :            : 
   13466                 :          0 :                 memcpy(tx_data + ETH_ALEN * 2, tg3_tso_header,
   13467                 :            :                        sizeof(tg3_tso_header));
   13468                 :          0 :                 mss = TG3_TSO_MSS;
   13469                 :            : 
   13470                 :          0 :                 val = tx_len - ETH_ALEN * 2 - sizeof(tg3_tso_header);
   13471                 :          0 :                 num_pkts = DIV_ROUND_UP(val, TG3_TSO_MSS);
   13472                 :            : 
   13473                 :            :                 /* Set the total length field in the IP header */
   13474                 :          0 :                 iph->tot_len = htons((u16)(mss + hdr_len));
   13475                 :            : 
   13476                 :          0 :                 base_flags = (TXD_FLAG_CPU_PRE_DMA |
   13477                 :            :                               TXD_FLAG_CPU_POST_DMA);
   13478                 :            : 
   13479   [ #  #  #  # ]:          0 :                 if (tg3_flag(tp, HW_TSO_1) ||
   13480         [ #  # ]:          0 :                     tg3_flag(tp, HW_TSO_2) ||
   13481                 :          0 :                     tg3_flag(tp, HW_TSO_3)) {
   13482                 :          0 :                         struct tcphdr *th;
   13483                 :          0 :                         val = ETH_HLEN + TG3_TSO_IP_HDR_LEN;
   13484                 :          0 :                         th = (struct tcphdr *)&tx_data[val];
   13485                 :          0 :                         th->check = 0;
   13486                 :            :                 } else
   13487                 :            :                         base_flags |= TXD_FLAG_TCPUDP_CSUM;
   13488                 :            : 
   13489         [ #  # ]:          0 :                 if (tg3_flag(tp, HW_TSO_3)) {
   13490                 :          0 :                         mss |= (hdr_len & 0xc) << 12;
   13491                 :          0 :                         if (hdr_len & 0x10)
   13492                 :          0 :                                 base_flags |= 0x00000010;
   13493                 :          0 :                         base_flags |= (hdr_len & 0x3e0) << 5;
   13494         [ #  # ]:          0 :                 } else if (tg3_flag(tp, HW_TSO_2))
   13495                 :            :                         mss |= hdr_len << 9;
   13496         [ #  # ]:          0 :                 else if (tg3_flag(tp, HW_TSO_1) ||
   13497         [ #  # ]:          0 :                          tg3_asic_rev(tp) == ASIC_REV_5705) {
   13498                 :            :                         mss |= (TG3_TSO_TCP_OPT_LEN << 9);
   13499                 :            :                 } else {
   13500                 :          0 :                         base_flags |= (TG3_TSO_TCP_OPT_LEN << 10);
   13501                 :            :                 }
   13502                 :            : 
   13503                 :            :                 data_off = ETH_ALEN * 2 + sizeof(tg3_tso_header);
   13504                 :            :         } else {
   13505                 :          0 :                 num_pkts = 1;
   13506                 :          0 :                 data_off = ETH_HLEN;
   13507                 :            : 
   13508   [ #  #  #  # ]:          0 :                 if (tg3_flag(tp, USE_JUMBO_BDFLAG) &&
   13509                 :            :                     tx_len > VLAN_ETH_FRAME_LEN)
   13510                 :          0 :                         base_flags |= TXD_FLAG_JMB_PKT;
   13511                 :            :         }
   13512                 :            : 
   13513         [ #  # ]:          0 :         for (i = data_off; i < tx_len; i++)
   13514                 :          0 :                 tx_data[i] = (u8) (i & 0xff);
   13515                 :            : 
   13516                 :          0 :         map = pci_map_single(tp->pdev, skb->data, tx_len, PCI_DMA_TODEVICE);
   13517                 :          0 :         if (pci_dma_mapping_error(tp->pdev, map)) {
   13518                 :          0 :                 dev_kfree_skb(skb);
   13519                 :          0 :                 return -EIO;
   13520                 :            :         }
   13521                 :            : 
   13522                 :          0 :         val = tnapi->tx_prod;
   13523                 :          0 :         tnapi->tx_buffers[val].skb = skb;
   13524                 :          0 :         dma_unmap_addr_set(&tnapi->tx_buffers[val], mapping, map);
   13525                 :            : 
   13526                 :          0 :         tw32_f(HOSTCC_MODE, tp->coalesce_mode | HOSTCC_MODE_ENABLE |
   13527                 :            :                rnapi->coal_now);
   13528                 :            : 
   13529                 :          0 :         udelay(10);
   13530                 :            : 
   13531                 :          0 :         rx_start_idx = rnapi->hw_status->idx[0].rx_producer;
   13532                 :            : 
   13533                 :          0 :         budget = tg3_tx_avail(tnapi);
   13534         [ #  # ]:          0 :         if (tg3_tx_frag_set(tnapi, &val, &budget, map, tx_len,
   13535                 :            :                             base_flags | TXD_FLAG_END, mss, 0)) {
   13536                 :          0 :                 tnapi->tx_buffers[val].skb = NULL;
   13537                 :          0 :                 dev_kfree_skb(skb);
   13538                 :          0 :                 return -EIO;
   13539                 :            :         }
   13540                 :            : 
   13541                 :          0 :         tnapi->tx_prod++;
   13542                 :            : 
   13543                 :            :         /* Sync BD data before updating mailbox */
   13544                 :          0 :         wmb();
   13545                 :            : 
   13546                 :          0 :         tw32_tx_mbox(tnapi->prodmbox, tnapi->tx_prod);
   13547                 :          0 :         tr32_mailbox(tnapi->prodmbox);
   13548                 :            : 
   13549                 :          0 :         udelay(10);
   13550                 :            : 
   13551                 :            :         /* 350 usec to allow enough time on some 10/100 Mbps devices.  */
   13552         [ #  # ]:          0 :         for (i = 0; i < 35; i++) {
   13553                 :          0 :                 tw32_f(HOSTCC_MODE, tp->coalesce_mode | HOSTCC_MODE_ENABLE |
   13554                 :            :                        coal_now);
   13555                 :            : 
   13556                 :          0 :                 udelay(10);
   13557                 :            : 
   13558                 :          0 :                 tx_idx = tnapi->hw_status->idx[0].tx_consumer;
   13559                 :          0 :                 rx_idx = rnapi->hw_status->idx[0].rx_producer;
   13560         [ #  # ]:          0 :                 if ((tx_idx == tnapi->tx_prod) &&
   13561         [ #  # ]:          0 :                     (rx_idx == (rx_start_idx + num_pkts)))
   13562                 :            :                         break;
   13563                 :            :         }
   13564                 :            : 
   13565                 :          0 :         tg3_tx_skb_unmap(tnapi, tnapi->tx_prod - 1, -1);
   13566                 :          0 :         dev_kfree_skb(skb);
   13567                 :            : 
   13568         [ #  # ]:          0 :         if (tx_idx != tnapi->tx_prod)
   13569                 :          0 :                 goto out;
   13570                 :            : 
   13571         [ #  # ]:          0 :         if (rx_idx != rx_start_idx + num_pkts)
   13572                 :          0 :                 goto out;
   13573                 :            : 
   13574                 :          0 :         val = data_off;
   13575         [ #  # ]:          0 :         while (rx_idx != rx_start_idx) {
   13576                 :          0 :                 desc = &rnapi->rx_rcb[rx_start_idx++];
   13577                 :          0 :                 desc_idx = desc->opaque & RXD_OPAQUE_INDEX_MASK;
   13578                 :          0 :                 opaque_key = desc->opaque & RXD_OPAQUE_RING_MASK;
   13579                 :            : 
   13580   [ #  #  #  # ]:          0 :                 if ((desc->err_vlan & RXD_ERR_MASK) != 0 &&
   13581                 :            :                     (desc->err_vlan != RXD_ERR_ODD_NIBBLE_RCVD_MII))
   13582                 :          0 :                         goto out;
   13583                 :            : 
   13584                 :          0 :                 rx_len = ((desc->idx_len & RXD_LEN_MASK) >> RXD_LEN_SHIFT)
   13585                 :          0 :                          - ETH_FCS_LEN;
   13586                 :            : 
   13587         [ #  # ]:          0 :                 if (!tso_loopback) {
   13588         [ #  # ]:          0 :                         if (rx_len != tx_len)
   13589                 :          0 :                                 goto out;
   13590                 :            : 
   13591         [ #  # ]:          0 :                         if (pktsz <= TG3_RX_STD_DMA_SZ - ETH_FCS_LEN) {
   13592         [ #  # ]:          0 :                                 if (opaque_key != RXD_OPAQUE_RING_STD)
   13593                 :          0 :                                         goto out;
   13594                 :            :                         } else {
   13595         [ #  # ]:          0 :                                 if (opaque_key != RXD_OPAQUE_RING_JUMBO)
   13596                 :          0 :                                         goto out;
   13597                 :            :                         }
   13598         [ #  # ]:          0 :                 } else if ((desc->type_flags & RXD_FLAG_TCPUDP_CSUM) &&
   13599                 :          0 :                            (desc->ip_tcp_csum & RXD_TCPCSUM_MASK)
   13600         [ #  # ]:          0 :                             >> RXD_TCPCSUM_SHIFT != 0xffff) {
   13601                 :          0 :                         goto out;
   13602                 :            :                 }
   13603                 :            : 
   13604         [ #  # ]:          0 :                 if (opaque_key == RXD_OPAQUE_RING_STD) {
   13605                 :          0 :                         rx_data = tpr->rx_std_buffers[desc_idx].data;
   13606                 :          0 :                         map = dma_unmap_addr(&tpr->rx_std_buffers[desc_idx],
   13607                 :            :                                              mapping);
   13608         [ #  # ]:          0 :                 } else if (opaque_key == RXD_OPAQUE_RING_JUMBO) {
   13609                 :          0 :                         rx_data = tpr->rx_jmb_buffers[desc_idx].data;
   13610                 :          0 :                         map = dma_unmap_addr(&tpr->rx_jmb_buffers[desc_idx],
   13611                 :            :                                              mapping);
   13612                 :            :                 } else
   13613                 :          0 :                         goto out;
   13614                 :            : 
   13615                 :          0 :                 pci_dma_sync_single_for_cpu(tp->pdev, map, rx_len,
   13616                 :            :                                             PCI_DMA_FROMDEVICE);
   13617                 :            : 
   13618                 :          0 :                 rx_data += TG3_RX_OFFSET(tp);
   13619         [ #  # ]:          0 :                 for (i = data_off; i < rx_len; i++, val++) {
   13620         [ #  # ]:          0 :                         if (*(rx_data + i) != (u8) (val & 0xff))
   13621                 :          0 :                                 goto out;
   13622                 :            :                 }
   13623                 :            :         }
   13624                 :            : 
   13625                 :            :         err = 0;
   13626                 :            : 
   13627                 :            :         /* tg3_free_rings will unmap and free the rx_data */
   13628                 :            : out:
   13629                 :            :         return err;
   13630                 :            : }
   13631                 :            : 
   13632                 :            : #define TG3_STD_LOOPBACK_FAILED         1
   13633                 :            : #define TG3_JMB_LOOPBACK_FAILED         2
   13634                 :            : #define TG3_TSO_LOOPBACK_FAILED         4
   13635                 :            : #define TG3_LOOPBACK_FAILED \
   13636                 :            :         (TG3_STD_LOOPBACK_FAILED | \
   13637                 :            :          TG3_JMB_LOOPBACK_FAILED | \
   13638                 :            :          TG3_TSO_LOOPBACK_FAILED)
   13639                 :            : 
   13640                 :          0 : static int tg3_test_loopback(struct tg3 *tp, u64 *data, bool do_extlpbk)
   13641                 :            : {
   13642                 :          0 :         int err = -EIO;
   13643                 :          0 :         u32 eee_cap;
   13644                 :          0 :         u32 jmb_pkt_sz = 9000;
   13645                 :            : 
   13646         [ #  # ]:          0 :         if (tp->dma_limit)
   13647                 :          0 :                 jmb_pkt_sz = tp->dma_limit - ETH_HLEN;
   13648                 :            : 
   13649                 :          0 :         eee_cap = tp->phy_flags & TG3_PHYFLG_EEE_CAP;
   13650                 :          0 :         tp->phy_flags &= ~TG3_PHYFLG_EEE_CAP;
   13651                 :            : 
   13652         [ #  # ]:          0 :         if (!netif_running(tp->dev)) {
   13653                 :          0 :                 data[TG3_MAC_LOOPB_TEST] = TG3_LOOPBACK_FAILED;
   13654                 :          0 :                 data[TG3_PHY_LOOPB_TEST] = TG3_LOOPBACK_FAILED;
   13655         [ #  # ]:          0 :                 if (do_extlpbk)
   13656                 :          0 :                         data[TG3_EXT_LOOPB_TEST] = TG3_LOOPBACK_FAILED;
   13657                 :          0 :                 goto done;
   13658                 :            :         }
   13659                 :            : 
   13660                 :          0 :         err = tg3_reset_hw(tp, true);
   13661         [ #  # ]:          0 :         if (err) {
   13662                 :          0 :                 data[TG3_MAC_LOOPB_TEST] = TG3_LOOPBACK_FAILED;
   13663                 :          0 :                 data[TG3_PHY_LOOPB_TEST] = TG3_LOOPBACK_FAILED;
   13664         [ #  # ]:          0 :                 if (do_extlpbk)
   13665                 :          0 :                         data[TG3_EXT_LOOPB_TEST] = TG3_LOOPBACK_FAILED;
   13666                 :          0 :                 goto done;
   13667                 :            :         }
   13668                 :            : 
   13669         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_RSS)) {
   13670                 :            :                 int i;
   13671                 :            : 
   13672                 :            :                 /* Reroute all rx packets to the 1st queue */
   13673                 :          0 :                 for (i = MAC_RSS_INDIR_TBL_0;
   13674         [ #  # ]:          0 :                      i < MAC_RSS_INDIR_TBL_0 + TG3_RSS_INDIR_TBL_SIZE; i += 4)
   13675                 :          0 :                         tw32(i, 0x0);
   13676                 :            :         }
   13677                 :            : 
   13678                 :            :         /* HW errata - mac loopback fails in some cases on 5780.
   13679                 :            :          * Normal traffic and PHY loopback are not affected by
   13680                 :            :          * errata.  Also, the MAC loopback test is deprecated for
   13681                 :            :          * all newer ASIC revisions.
   13682                 :            :          */
   13683   [ #  #  #  # ]:          0 :         if (tg3_asic_rev(tp) != ASIC_REV_5780 &&
   13684                 :            :             !tg3_flag(tp, CPMU_PRESENT)) {
   13685                 :          0 :                 tg3_mac_loopback(tp, true);
   13686                 :            : 
   13687         [ #  # ]:          0 :                 if (tg3_run_loopback(tp, ETH_FRAME_LEN, false))
   13688                 :          0 :                         data[TG3_MAC_LOOPB_TEST] |= TG3_STD_LOOPBACK_FAILED;
   13689                 :            : 
   13690   [ #  #  #  # ]:          0 :                 if (tg3_flag(tp, JUMBO_RING_ENABLE) &&
   13691                 :          0 :                     tg3_run_loopback(tp, jmb_pkt_sz + ETH_HLEN, false))
   13692                 :          0 :                         data[TG3_MAC_LOOPB_TEST] |= TG3_JMB_LOOPBACK_FAILED;
   13693                 :            : 
   13694                 :          0 :                 tg3_mac_loopback(tp, false);
   13695                 :            :         }
   13696                 :            : 
   13697   [ #  #  #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_PHY_SERDES) &&
   13698                 :            :             !tg3_flag(tp, USE_PHYLIB)) {
   13699                 :          0 :                 int i;
   13700                 :            : 
   13701                 :          0 :                 tg3_phy_lpbk_set(tp, 0, false);
   13702                 :            : 
   13703                 :            :                 /* Wait for link */
   13704         [ #  # ]:          0 :                 for (i = 0; i < 100; i++) {
   13705         [ #  # ]:          0 :                         if (tr32(MAC_TX_STATUS) & TX_STATUS_LINK_UP)
   13706                 :            :                                 break;
   13707                 :          0 :                         mdelay(1);
   13708                 :            :                 }
   13709                 :            : 
   13710         [ #  # ]:          0 :                 if (tg3_run_loopback(tp, ETH_FRAME_LEN, false))
   13711                 :          0 :                         data[TG3_PHY_LOOPB_TEST] |= TG3_STD_LOOPBACK_FAILED;
   13712   [ #  #  #  # ]:          0 :                 if (tg3_flag(tp, TSO_CAPABLE) &&
   13713                 :          0 :                     tg3_run_loopback(tp, ETH_FRAME_LEN, true))
   13714                 :          0 :                         data[TG3_PHY_LOOPB_TEST] |= TG3_TSO_LOOPBACK_FAILED;
   13715   [ #  #  #  # ]:          0 :                 if (tg3_flag(tp, JUMBO_RING_ENABLE) &&
   13716                 :          0 :                     tg3_run_loopback(tp, jmb_pkt_sz + ETH_HLEN, false))
   13717                 :          0 :                         data[TG3_PHY_LOOPB_TEST] |= TG3_JMB_LOOPBACK_FAILED;
   13718                 :            : 
   13719         [ #  # ]:          0 :                 if (do_extlpbk) {
   13720                 :          0 :                         tg3_phy_lpbk_set(tp, 0, true);
   13721                 :            : 
   13722                 :            :                         /* All link indications report up, but the hardware
   13723                 :            :                          * isn't really ready for about 20 msec.  Double it
   13724                 :            :                          * to be sure.
   13725                 :            :                          */
   13726         [ #  # ]:          0 :                         mdelay(40);
   13727                 :            : 
   13728         [ #  # ]:          0 :                         if (tg3_run_loopback(tp, ETH_FRAME_LEN, false))
   13729                 :          0 :                                 data[TG3_EXT_LOOPB_TEST] |=
   13730                 :            :                                                         TG3_STD_LOOPBACK_FAILED;
   13731   [ #  #  #  # ]:          0 :                         if (tg3_flag(tp, TSO_CAPABLE) &&
   13732                 :          0 :                             tg3_run_loopback(tp, ETH_FRAME_LEN, true))
   13733                 :          0 :                                 data[TG3_EXT_LOOPB_TEST] |=
   13734                 :            :                                                         TG3_TSO_LOOPBACK_FAILED;
   13735   [ #  #  #  # ]:          0 :                         if (tg3_flag(tp, JUMBO_RING_ENABLE) &&
   13736                 :          0 :                             tg3_run_loopback(tp, jmb_pkt_sz + ETH_HLEN, false))
   13737                 :          0 :                                 data[TG3_EXT_LOOPB_TEST] |=
   13738                 :            :                                                         TG3_JMB_LOOPBACK_FAILED;
   13739                 :            :                 }
   13740                 :            : 
   13741                 :            :                 /* Re-enable gphy autopowerdown. */
   13742         [ #  # ]:          0 :                 if (tp->phy_flags & TG3_PHYFLG_ENABLE_APD)
   13743                 :          0 :                         tg3_phy_toggle_apd(tp, true);
   13744                 :            :         }
   13745                 :            : 
   13746                 :          0 :         err = (data[TG3_MAC_LOOPB_TEST] | data[TG3_PHY_LOOPB_TEST] |
   13747         [ #  # ]:          0 :                data[TG3_EXT_LOOPB_TEST]) ? -EIO : 0;
   13748                 :            : 
   13749                 :          0 : done:
   13750                 :          0 :         tp->phy_flags |= eee_cap;
   13751                 :            : 
   13752                 :          0 :         return err;
   13753                 :            : }
   13754                 :            : 
   13755                 :          0 : static void tg3_self_test(struct net_device *dev, struct ethtool_test *etest,
   13756                 :            :                           u64 *data)
   13757                 :            : {
   13758         [ #  # ]:          0 :         struct tg3 *tp = netdev_priv(dev);
   13759                 :          0 :         bool doextlpbk = etest->flags & ETH_TEST_FL_EXTERNAL_LB;
   13760                 :            : 
   13761         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_IS_LOW_POWER) {
   13762         [ #  # ]:          0 :                 if (tg3_power_up(tp)) {
   13763                 :          0 :                         etest->flags |= ETH_TEST_FL_FAILED;
   13764                 :          0 :                         memset(data, 1, sizeof(u64) * TG3_NUM_TEST);
   13765                 :          0 :                         return;
   13766                 :            :                 }
   13767                 :          0 :                 tg3_ape_driver_state_change(tp, RESET_KIND_INIT);
   13768                 :            :         }
   13769                 :            : 
   13770                 :          0 :         memset(data, 0, sizeof(u64) * TG3_NUM_TEST);
   13771                 :            : 
   13772         [ #  # ]:          0 :         if (tg3_test_nvram(tp) != 0) {
   13773                 :          0 :                 etest->flags |= ETH_TEST_FL_FAILED;
   13774                 :          0 :                 data[TG3_NVRAM_TEST] = 1;
   13775                 :            :         }
   13776   [ #  #  #  # ]:          0 :         if (!doextlpbk && tg3_test_link(tp)) {
   13777                 :          0 :                 etest->flags |= ETH_TEST_FL_FAILED;
   13778                 :          0 :                 data[TG3_LINK_TEST] = 1;
   13779                 :            :         }
   13780         [ #  # ]:          0 :         if (etest->flags & ETH_TEST_FL_OFFLINE) {
   13781                 :          0 :                 int err, err2 = 0, irq_sync = 0;
   13782                 :            : 
   13783         [ #  # ]:          0 :                 if (netif_running(dev)) {
   13784                 :          0 :                         tg3_phy_stop(tp);
   13785                 :          0 :                         tg3_netif_stop(tp);
   13786                 :          0 :                         irq_sync = 1;
   13787                 :            :                 }
   13788                 :            : 
   13789                 :          0 :                 tg3_full_lock(tp, irq_sync);
   13790                 :          0 :                 tg3_halt(tp, RESET_KIND_SUSPEND, 1);
   13791                 :          0 :                 err = tg3_nvram_lock(tp);
   13792                 :          0 :                 tg3_halt_cpu(tp, RX_CPU_BASE);
   13793         [ #  # ]:          0 :                 if (!tg3_flag(tp, 5705_PLUS))
   13794                 :          0 :                         tg3_halt_cpu(tp, TX_CPU_BASE);
   13795         [ #  # ]:          0 :                 if (!err)
   13796                 :          0 :                         tg3_nvram_unlock(tp);
   13797                 :            : 
   13798         [ #  # ]:          0 :                 if (tp->phy_flags & TG3_PHYFLG_MII_SERDES)
   13799                 :          0 :                         tg3_phy_reset(tp);
   13800                 :            : 
   13801         [ #  # ]:          0 :                 if (tg3_test_registers(tp) != 0) {
   13802                 :          0 :                         etest->flags |= ETH_TEST_FL_FAILED;
   13803                 :          0 :                         data[TG3_REGISTER_TEST] = 1;
   13804                 :            :                 }
   13805                 :            : 
   13806         [ #  # ]:          0 :                 if (tg3_test_memory(tp) != 0) {
   13807                 :          0 :                         etest->flags |= ETH_TEST_FL_FAILED;
   13808                 :          0 :                         data[TG3_MEMORY_TEST] = 1;
   13809                 :            :                 }
   13810                 :            : 
   13811         [ #  # ]:          0 :                 if (doextlpbk)
   13812                 :          0 :                         etest->flags |= ETH_TEST_FL_EXTERNAL_LB_DONE;
   13813                 :            : 
   13814         [ #  # ]:          0 :                 if (tg3_test_loopback(tp, data, doextlpbk))
   13815                 :          0 :                         etest->flags |= ETH_TEST_FL_FAILED;
   13816                 :            : 
   13817                 :          0 :                 tg3_full_unlock(tp);
   13818                 :            : 
   13819         [ #  # ]:          0 :                 if (tg3_test_interrupt(tp) != 0) {
   13820                 :          0 :                         etest->flags |= ETH_TEST_FL_FAILED;
   13821                 :          0 :                         data[TG3_INTERRUPT_TEST] = 1;
   13822                 :            :                 }
   13823                 :            : 
   13824                 :          0 :                 tg3_full_lock(tp, 0);
   13825                 :            : 
   13826                 :          0 :                 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
   13827         [ #  # ]:          0 :                 if (netif_running(dev)) {
   13828                 :          0 :                         tg3_flag_set(tp, INIT_COMPLETE);
   13829                 :          0 :                         err2 = tg3_restart_hw(tp, true);
   13830         [ #  # ]:          0 :                         if (!err2)
   13831                 :          0 :                                 tg3_netif_start(tp);
   13832                 :            :                 }
   13833                 :            : 
   13834                 :          0 :                 tg3_full_unlock(tp);
   13835                 :            : 
   13836         [ #  # ]:          0 :                 if (irq_sync && !err2)
   13837                 :          0 :                         tg3_phy_start(tp);
   13838                 :            :         }
   13839         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_IS_LOW_POWER)
   13840                 :          0 :                 tg3_power_down_prepare(tp);
   13841                 :            : 
   13842                 :            : }
   13843                 :            : 
   13844                 :            : static int tg3_hwtstamp_set(struct net_device *dev, struct ifreq *ifr)
   13845                 :            : {
   13846                 :            :         struct tg3 *tp = netdev_priv(dev);
   13847                 :            :         struct hwtstamp_config stmpconf;
   13848                 :            : 
   13849                 :            :         if (!tg3_flag(tp, PTP_CAPABLE))
   13850                 :            :                 return -EOPNOTSUPP;
   13851                 :            : 
   13852                 :            :         if (copy_from_user(&stmpconf, ifr->ifr_data, sizeof(stmpconf)))
   13853                 :            :                 return -EFAULT;
   13854                 :            : 
   13855                 :            :         if (stmpconf.flags)
   13856                 :            :                 return -EINVAL;
   13857                 :            : 
   13858                 :            :         if (stmpconf.tx_type != HWTSTAMP_TX_ON &&
   13859                 :            :             stmpconf.tx_type != HWTSTAMP_TX_OFF)
   13860                 :            :                 return -ERANGE;
   13861                 :            : 
   13862                 :            :         switch (stmpconf.rx_filter) {
   13863                 :            :         case HWTSTAMP_FILTER_NONE:
   13864                 :            :                 tp->rxptpctl = 0;
   13865                 :            :                 break;
   13866                 :            :         case HWTSTAMP_FILTER_PTP_V1_L4_EVENT:
   13867                 :            :                 tp->rxptpctl = TG3_RX_PTP_CTL_RX_PTP_V1_EN |
   13868                 :            :                                TG3_RX_PTP_CTL_ALL_V1_EVENTS;
   13869                 :            :                 break;
   13870                 :            :         case HWTSTAMP_FILTER_PTP_V1_L4_SYNC:
   13871                 :            :                 tp->rxptpctl = TG3_RX_PTP_CTL_RX_PTP_V1_EN |
   13872                 :            :                                TG3_RX_PTP_CTL_SYNC_EVNT;
   13873                 :            :                 break;
   13874                 :            :         case HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ:
   13875                 :            :                 tp->rxptpctl = TG3_RX_PTP_CTL_RX_PTP_V1_EN |
   13876                 :            :                                TG3_RX_PTP_CTL_DELAY_REQ;
   13877                 :            :                 break;
   13878                 :            :         case HWTSTAMP_FILTER_PTP_V2_EVENT:
   13879                 :            :                 tp->rxptpctl = TG3_RX_PTP_CTL_RX_PTP_V2_EN |
   13880                 :            :                                TG3_RX_PTP_CTL_ALL_V2_EVENTS;
   13881                 :            :                 break;
   13882                 :            :         case HWTSTAMP_FILTER_PTP_V2_L2_EVENT:
   13883                 :            :                 tp->rxptpctl = TG3_RX_PTP_CTL_RX_PTP_V2_L2_EN |
   13884                 :            :                                TG3_RX_PTP_CTL_ALL_V2_EVENTS;
   13885                 :            :                 break;
   13886                 :            :         case HWTSTAMP_FILTER_PTP_V2_L4_EVENT:
   13887                 :            :                 tp->rxptpctl = TG3_RX_PTP_CTL_RX_PTP_V2_L4_EN |
   13888                 :            :                                TG3_RX_PTP_CTL_ALL_V2_EVENTS;
   13889                 :            :                 break;
   13890                 :            :         case HWTSTAMP_FILTER_PTP_V2_SYNC:
   13891                 :            :                 tp->rxptpctl = TG3_RX_PTP_CTL_RX_PTP_V2_EN |
   13892                 :            :                                TG3_RX_PTP_CTL_SYNC_EVNT;
   13893                 :            :                 break;
   13894                 :            :         case HWTSTAMP_FILTER_PTP_V2_L2_SYNC:
   13895                 :            :                 tp->rxptpctl = TG3_RX_PTP_CTL_RX_PTP_V2_L2_EN |
   13896                 :            :                                TG3_RX_PTP_CTL_SYNC_EVNT;
   13897                 :            :                 break;
   13898                 :            :         case HWTSTAMP_FILTER_PTP_V2_L4_SYNC:
   13899                 :            :                 tp->rxptpctl = TG3_RX_PTP_CTL_RX_PTP_V2_L4_EN |
   13900                 :            :                                TG3_RX_PTP_CTL_SYNC_EVNT;
   13901                 :            :                 break;
   13902                 :            :         case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ:
   13903                 :            :                 tp->rxptpctl = TG3_RX_PTP_CTL_RX_PTP_V2_EN |
   13904                 :            :                                TG3_RX_PTP_CTL_DELAY_REQ;
   13905                 :            :                 break;
   13906                 :            :         case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ:
   13907                 :            :                 tp->rxptpctl = TG3_RX_PTP_CTL_RX_PTP_V2_L2_EN |
   13908                 :            :                                TG3_RX_PTP_CTL_DELAY_REQ;
   13909                 :            :                 break;
   13910                 :            :         case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ:
   13911                 :            :                 tp->rxptpctl = TG3_RX_PTP_CTL_RX_PTP_V2_L4_EN |
   13912                 :            :                                TG3_RX_PTP_CTL_DELAY_REQ;
   13913                 :            :                 break;
   13914                 :            :         default:
   13915                 :            :                 return -ERANGE;
   13916                 :            :         }
   13917                 :            : 
   13918                 :            :         if (netif_running(dev) && tp->rxptpctl)
   13919                 :            :                 tw32(TG3_RX_PTP_CTL,
   13920                 :            :                      tp->rxptpctl | TG3_RX_PTP_CTL_HWTS_INTERLOCK);
   13921                 :            : 
   13922                 :            :         if (stmpconf.tx_type == HWTSTAMP_TX_ON)
   13923                 :            :                 tg3_flag_set(tp, TX_TSTAMP_EN);
   13924                 :            :         else
   13925                 :            :                 tg3_flag_clear(tp, TX_TSTAMP_EN);
   13926                 :            : 
   13927                 :            :         return copy_to_user(ifr->ifr_data, &stmpconf, sizeof(stmpconf)) ?
   13928                 :            :                 -EFAULT : 0;
   13929                 :            : }
   13930                 :            : 
   13931                 :            : static int tg3_hwtstamp_get(struct net_device *dev, struct ifreq *ifr)
   13932                 :            : {
   13933                 :            :         struct tg3 *tp = netdev_priv(dev);
   13934                 :            :         struct hwtstamp_config stmpconf;
   13935                 :            : 
   13936                 :            :         if (!tg3_flag(tp, PTP_CAPABLE))
   13937                 :            :                 return -EOPNOTSUPP;
   13938                 :            : 
   13939                 :            :         stmpconf.flags = 0;
   13940                 :            :         stmpconf.tx_type = (tg3_flag(tp, TX_TSTAMP_EN) ?
   13941                 :            :                             HWTSTAMP_TX_ON : HWTSTAMP_TX_OFF);
   13942                 :            : 
   13943                 :            :         switch (tp->rxptpctl) {
   13944                 :            :         case 0:
   13945                 :            :                 stmpconf.rx_filter = HWTSTAMP_FILTER_NONE;
   13946                 :            :                 break;
   13947                 :            :         case TG3_RX_PTP_CTL_RX_PTP_V1_EN | TG3_RX_PTP_CTL_ALL_V1_EVENTS:
   13948                 :            :                 stmpconf.rx_filter = HWTSTAMP_FILTER_PTP_V1_L4_EVENT;
   13949                 :            :                 break;
   13950                 :            :         case TG3_RX_PTP_CTL_RX_PTP_V1_EN | TG3_RX_PTP_CTL_SYNC_EVNT:
   13951                 :            :                 stmpconf.rx_filter = HWTSTAMP_FILTER_PTP_V1_L4_SYNC;
   13952                 :            :                 break;
   13953                 :            :         case TG3_RX_PTP_CTL_RX_PTP_V1_EN | TG3_RX_PTP_CTL_DELAY_REQ:
   13954                 :            :                 stmpconf.rx_filter = HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ;
   13955                 :            :                 break;
   13956                 :            :         case TG3_RX_PTP_CTL_RX_PTP_V2_EN | TG3_RX_PTP_CTL_ALL_V2_EVENTS:
   13957                 :            :                 stmpconf.rx_filter = HWTSTAMP_FILTER_PTP_V2_EVENT;
   13958                 :            :                 break;
   13959                 :            :         case TG3_RX_PTP_CTL_RX_PTP_V2_L2_EN | TG3_RX_PTP_CTL_ALL_V2_EVENTS:
   13960                 :            :                 stmpconf.rx_filter = HWTSTAMP_FILTER_PTP_V2_L2_EVENT;
   13961                 :            :                 break;
   13962                 :            :         case TG3_RX_PTP_CTL_RX_PTP_V2_L4_EN | TG3_RX_PTP_CTL_ALL_V2_EVENTS:
   13963                 :            :                 stmpconf.rx_filter = HWTSTAMP_FILTER_PTP_V2_L4_EVENT;
   13964                 :            :                 break;
   13965                 :            :         case TG3_RX_PTP_CTL_RX_PTP_V2_EN | TG3_RX_PTP_CTL_SYNC_EVNT:
   13966                 :            :                 stmpconf.rx_filter = HWTSTAMP_FILTER_PTP_V2_SYNC;
   13967                 :            :                 break;
   13968                 :            :         case TG3_RX_PTP_CTL_RX_PTP_V2_L2_EN | TG3_RX_PTP_CTL_SYNC_EVNT:
   13969                 :            :                 stmpconf.rx_filter = HWTSTAMP_FILTER_PTP_V2_L2_SYNC;
   13970                 :            :                 break;
   13971                 :            :         case TG3_RX_PTP_CTL_RX_PTP_V2_L4_EN | TG3_RX_PTP_CTL_SYNC_EVNT:
   13972                 :            :                 stmpconf.rx_filter = HWTSTAMP_FILTER_PTP_V2_L4_SYNC;
   13973                 :            :                 break;
   13974                 :            :         case TG3_RX_PTP_CTL_RX_PTP_V2_EN | TG3_RX_PTP_CTL_DELAY_REQ:
   13975                 :            :                 stmpconf.rx_filter = HWTSTAMP_FILTER_PTP_V2_DELAY_REQ;
   13976                 :            :                 break;
   13977                 :            :         case TG3_RX_PTP_CTL_RX_PTP_V2_L2_EN | TG3_RX_PTP_CTL_DELAY_REQ:
   13978                 :            :                 stmpconf.rx_filter = HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ;
   13979                 :            :                 break;
   13980                 :            :         case TG3_RX_PTP_CTL_RX_PTP_V2_L4_EN | TG3_RX_PTP_CTL_DELAY_REQ:
   13981                 :            :                 stmpconf.rx_filter = HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ;
   13982                 :            :                 break;
   13983                 :            :         default:
   13984                 :            :                 WARN_ON_ONCE(1);
   13985                 :            :                 return -ERANGE;
   13986                 :            :         }
   13987                 :            : 
   13988                 :            :         return copy_to_user(ifr->ifr_data, &stmpconf, sizeof(stmpconf)) ?
   13989                 :            :                 -EFAULT : 0;
   13990                 :            : }
   13991                 :            : 
   13992                 :          0 : static int tg3_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
   13993                 :            : {
   13994                 :          0 :         struct mii_ioctl_data *data = if_mii(ifr);
   13995                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   13996                 :          0 :         int err;
   13997                 :            : 
   13998         [ #  # ]:          0 :         if (tg3_flag(tp, USE_PHYLIB)) {
   13999                 :          0 :                 struct phy_device *phydev;
   14000         [ #  # ]:          0 :                 if (!(tp->phy_flags & TG3_PHYFLG_IS_CONNECTED))
   14001                 :            :                         return -EAGAIN;
   14002                 :          0 :                 phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr);
   14003                 :          0 :                 return phy_mii_ioctl(phydev, ifr, cmd);
   14004                 :            :         }
   14005                 :            : 
   14006   [ #  #  #  #  :          0 :         switch (cmd) {
                   #  # ]
   14007                 :          0 :         case SIOCGMIIPHY:
   14008                 :          0 :                 data->phy_id = tp->phy_addr;
   14009                 :            : 
   14010                 :            :                 /* fall through */
   14011                 :          0 :         case SIOCGMIIREG: {
   14012                 :          0 :                 u32 mii_regval;
   14013                 :            : 
   14014         [ #  # ]:          0 :                 if (tp->phy_flags & TG3_PHYFLG_PHY_SERDES)
   14015                 :            :                         break;                  /* We have no PHY */
   14016                 :            : 
   14017         [ #  # ]:          0 :                 if (!netif_running(dev))
   14018                 :          0 :                         return -EAGAIN;
   14019                 :            : 
   14020                 :          0 :                 spin_lock_bh(&tp->lock);
   14021                 :          0 :                 err = __tg3_readphy(tp, data->phy_id & 0x1f,
   14022                 :          0 :                                     data->reg_num & 0x1f, &mii_regval);
   14023                 :          0 :                 spin_unlock_bh(&tp->lock);
   14024                 :            : 
   14025                 :          0 :                 data->val_out = mii_regval;
   14026                 :            : 
   14027                 :          0 :                 return err;
   14028                 :            :         }
   14029                 :            : 
   14030                 :          0 :         case SIOCSMIIREG:
   14031         [ #  # ]:          0 :                 if (tp->phy_flags & TG3_PHYFLG_PHY_SERDES)
   14032                 :            :                         break;                  /* We have no PHY */
   14033                 :            : 
   14034         [ #  # ]:          0 :                 if (!netif_running(dev))
   14035                 :            :                         return -EAGAIN;
   14036                 :            : 
   14037                 :          0 :                 spin_lock_bh(&tp->lock);
   14038                 :          0 :                 err = __tg3_writephy(tp, data->phy_id & 0x1f,
   14039                 :          0 :                                      data->reg_num & 0x1f, data->val_in);
   14040                 :          0 :                 spin_unlock_bh(&tp->lock);
   14041                 :            : 
   14042                 :          0 :                 return err;
   14043                 :            : 
   14044                 :          0 :         case SIOCSHWTSTAMP:
   14045                 :          0 :                 return tg3_hwtstamp_set(dev, ifr);
   14046                 :            : 
   14047                 :          0 :         case SIOCGHWTSTAMP:
   14048                 :          0 :                 return tg3_hwtstamp_get(dev, ifr);
   14049                 :            : 
   14050                 :            :         default:
   14051                 :            :                 /* do nothing */
   14052                 :            :                 break;
   14053                 :            :         }
   14054                 :          0 :         return -EOPNOTSUPP;
   14055                 :            : }
   14056                 :            : 
   14057                 :          0 : static int tg3_get_coalesce(struct net_device *dev, struct ethtool_coalesce *ec)
   14058                 :            : {
   14059                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   14060                 :            : 
   14061                 :          0 :         memcpy(ec, &tp->coal, sizeof(*ec));
   14062                 :          0 :         return 0;
   14063                 :            : }
   14064                 :            : 
   14065                 :          0 : static int tg3_set_coalesce(struct net_device *dev, struct ethtool_coalesce *ec)
   14066                 :            : {
   14067                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   14068                 :          0 :         u32 max_rxcoal_tick_int = 0, max_txcoal_tick_int = 0;
   14069                 :          0 :         u32 max_stat_coal_ticks = 0, min_stat_coal_ticks = 0;
   14070                 :            : 
   14071         [ #  # ]:          0 :         if (!tg3_flag(tp, 5705_PLUS)) {
   14072                 :          0 :                 max_rxcoal_tick_int = MAX_RXCOAL_TICK_INT;
   14073                 :          0 :                 max_txcoal_tick_int = MAX_TXCOAL_TICK_INT;
   14074                 :          0 :                 max_stat_coal_ticks = MAX_STAT_COAL_TICKS;
   14075                 :          0 :                 min_stat_coal_ticks = MIN_STAT_COAL_TICKS;
   14076                 :            :         }
   14077                 :            : 
   14078         [ #  # ]:          0 :         if ((ec->rx_coalesce_usecs > MAX_RXCOL_TICKS) ||
   14079                 :          0 :             (!ec->rx_coalesce_usecs) ||
   14080   [ #  #  #  # ]:          0 :             (ec->tx_coalesce_usecs > MAX_TXCOL_TICKS) ||
   14081                 :          0 :             (!ec->tx_coalesce_usecs) ||
   14082         [ #  # ]:          0 :             (ec->rx_max_coalesced_frames > MAX_RXMAX_FRAMES) ||
   14083         [ #  # ]:          0 :             (ec->tx_max_coalesced_frames > MAX_TXMAX_FRAMES) ||
   14084         [ #  # ]:          0 :             (ec->rx_coalesce_usecs_irq > max_rxcoal_tick_int) ||
   14085         [ #  # ]:          0 :             (ec->tx_coalesce_usecs_irq > max_txcoal_tick_int) ||
   14086         [ #  # ]:          0 :             (ec->rx_max_coalesced_frames_irq > MAX_RXCOAL_MAXF_INT) ||
   14087         [ #  # ]:          0 :             (ec->tx_max_coalesced_frames_irq > MAX_TXCOAL_MAXF_INT) ||
   14088   [ #  #  #  # ]:          0 :             (ec->stats_block_coalesce_usecs > max_stat_coal_ticks) ||
   14089                 :            :             (ec->stats_block_coalesce_usecs < min_stat_coal_ticks))
   14090                 :            :                 return -EINVAL;
   14091                 :            : 
   14092                 :            :         /* Only copy relevant parameters, ignore all others. */
   14093                 :          0 :         tp->coal.rx_coalesce_usecs = ec->rx_coalesce_usecs;
   14094                 :          0 :         tp->coal.tx_coalesce_usecs = ec->tx_coalesce_usecs;
   14095                 :          0 :         tp->coal.rx_max_coalesced_frames = ec->rx_max_coalesced_frames;
   14096                 :          0 :         tp->coal.tx_max_coalesced_frames = ec->tx_max_coalesced_frames;
   14097                 :          0 :         tp->coal.rx_coalesce_usecs_irq = ec->rx_coalesce_usecs_irq;
   14098                 :          0 :         tp->coal.tx_coalesce_usecs_irq = ec->tx_coalesce_usecs_irq;
   14099                 :          0 :         tp->coal.rx_max_coalesced_frames_irq = ec->rx_max_coalesced_frames_irq;
   14100                 :          0 :         tp->coal.tx_max_coalesced_frames_irq = ec->tx_max_coalesced_frames_irq;
   14101                 :          0 :         tp->coal.stats_block_coalesce_usecs = ec->stats_block_coalesce_usecs;
   14102                 :            : 
   14103         [ #  # ]:          0 :         if (netif_running(dev)) {
   14104                 :          0 :                 tg3_full_lock(tp, 0);
   14105                 :          0 :                 __tg3_set_coalesce(tp, &tp->coal);
   14106                 :          0 :                 tg3_full_unlock(tp);
   14107                 :            :         }
   14108                 :            :         return 0;
   14109                 :            : }
   14110                 :            : 
   14111                 :          0 : static int tg3_set_eee(struct net_device *dev, struct ethtool_eee *edata)
   14112                 :            : {
   14113         [ #  # ]:          0 :         struct tg3 *tp = netdev_priv(dev);
   14114                 :            : 
   14115         [ #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_EEE_CAP)) {
   14116                 :          0 :                 netdev_warn(tp->dev, "Board does not support EEE!\n");
   14117                 :          0 :                 return -EOPNOTSUPP;
   14118                 :            :         }
   14119                 :            : 
   14120         [ #  # ]:          0 :         if (edata->advertised != tp->eee.advertised) {
   14121                 :          0 :                 netdev_warn(tp->dev,
   14122                 :            :                             "Direct manipulation of EEE advertisement is not supported\n");
   14123                 :          0 :                 return -EINVAL;
   14124                 :            :         }
   14125                 :            : 
   14126         [ #  # ]:          0 :         if (edata->tx_lpi_timer > TG3_CPMU_DBTMR1_LNKIDLE_MAX) {
   14127                 :          0 :                 netdev_warn(tp->dev,
   14128                 :            :                             "Maximal Tx Lpi timer supported is %#x(u)\n",
   14129                 :            :                             TG3_CPMU_DBTMR1_LNKIDLE_MAX);
   14130                 :          0 :                 return -EINVAL;
   14131                 :            :         }
   14132                 :            : 
   14133                 :          0 :         tp->eee = *edata;
   14134                 :            : 
   14135                 :          0 :         tp->phy_flags |= TG3_PHYFLG_USER_CONFIGURED;
   14136                 :          0 :         tg3_warn_mgmt_link_flap(tp);
   14137                 :            : 
   14138         [ #  # ]:          0 :         if (netif_running(tp->dev)) {
   14139                 :          0 :                 tg3_full_lock(tp, 0);
   14140                 :          0 :                 tg3_setup_eee(tp);
   14141                 :          0 :                 tg3_phy_reset(tp);
   14142                 :          0 :                 tg3_full_unlock(tp);
   14143                 :            :         }
   14144                 :            : 
   14145                 :            :         return 0;
   14146                 :            : }
   14147                 :            : 
   14148                 :          0 : static int tg3_get_eee(struct net_device *dev, struct ethtool_eee *edata)
   14149                 :            : {
   14150         [ #  # ]:          0 :         struct tg3 *tp = netdev_priv(dev);
   14151                 :            : 
   14152         [ #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_EEE_CAP)) {
   14153                 :          0 :                 netdev_warn(tp->dev,
   14154                 :            :                             "Board does not support EEE!\n");
   14155                 :          0 :                 return -EOPNOTSUPP;
   14156                 :            :         }
   14157                 :            : 
   14158                 :          0 :         *edata = tp->eee;
   14159                 :          0 :         return 0;
   14160                 :            : }
   14161                 :            : 
   14162                 :            : static const struct ethtool_ops tg3_ethtool_ops = {
   14163                 :            :         .get_drvinfo            = tg3_get_drvinfo,
   14164                 :            :         .get_regs_len           = tg3_get_regs_len,
   14165                 :            :         .get_regs               = tg3_get_regs,
   14166                 :            :         .get_wol                = tg3_get_wol,
   14167                 :            :         .set_wol                = tg3_set_wol,
   14168                 :            :         .get_msglevel           = tg3_get_msglevel,
   14169                 :            :         .set_msglevel           = tg3_set_msglevel,
   14170                 :            :         .nway_reset             = tg3_nway_reset,
   14171                 :            :         .get_link               = ethtool_op_get_link,
   14172                 :            :         .get_eeprom_len         = tg3_get_eeprom_len,
   14173                 :            :         .get_eeprom             = tg3_get_eeprom,
   14174                 :            :         .set_eeprom             = tg3_set_eeprom,
   14175                 :            :         .get_ringparam          = tg3_get_ringparam,
   14176                 :            :         .set_ringparam          = tg3_set_ringparam,
   14177                 :            :         .get_pauseparam         = tg3_get_pauseparam,
   14178                 :            :         .set_pauseparam         = tg3_set_pauseparam,
   14179                 :            :         .self_test              = tg3_self_test,
   14180                 :            :         .get_strings            = tg3_get_strings,
   14181                 :            :         .set_phys_id            = tg3_set_phys_id,
   14182                 :            :         .get_ethtool_stats      = tg3_get_ethtool_stats,
   14183                 :            :         .get_coalesce           = tg3_get_coalesce,
   14184                 :            :         .set_coalesce           = tg3_set_coalesce,
   14185                 :            :         .get_sset_count         = tg3_get_sset_count,
   14186                 :            :         .get_rxnfc              = tg3_get_rxnfc,
   14187                 :            :         .get_rxfh_indir_size    = tg3_get_rxfh_indir_size,
   14188                 :            :         .get_rxfh               = tg3_get_rxfh,
   14189                 :            :         .set_rxfh               = tg3_set_rxfh,
   14190                 :            :         .get_channels           = tg3_get_channels,
   14191                 :            :         .set_channels           = tg3_set_channels,
   14192                 :            :         .get_ts_info            = tg3_get_ts_info,
   14193                 :            :         .get_eee                = tg3_get_eee,
   14194                 :            :         .set_eee                = tg3_set_eee,
   14195                 :            :         .get_link_ksettings     = tg3_get_link_ksettings,
   14196                 :            :         .set_link_ksettings     = tg3_set_link_ksettings,
   14197                 :            : };
   14198                 :            : 
   14199                 :          0 : static void tg3_get_stats64(struct net_device *dev,
   14200                 :            :                             struct rtnl_link_stats64 *stats)
   14201                 :            : {
   14202                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   14203                 :            : 
   14204                 :          0 :         spin_lock_bh(&tp->lock);
   14205   [ #  #  #  # ]:          0 :         if (!tp->hw_stats || !tg3_flag(tp, INIT_COMPLETE)) {
   14206                 :          0 :                 *stats = tp->net_stats_prev;
   14207                 :          0 :                 spin_unlock_bh(&tp->lock);
   14208                 :          0 :                 return;
   14209                 :            :         }
   14210                 :            : 
   14211                 :          0 :         tg3_get_nstats(tp, stats);
   14212                 :          0 :         spin_unlock_bh(&tp->lock);
   14213                 :            : }
   14214                 :            : 
   14215                 :          0 : static void tg3_set_rx_mode(struct net_device *dev)
   14216                 :            : {
   14217                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   14218                 :            : 
   14219         [ #  # ]:          0 :         if (!netif_running(dev))
   14220                 :            :                 return;
   14221                 :            : 
   14222                 :          0 :         tg3_full_lock(tp, 0);
   14223                 :          0 :         __tg3_set_rx_mode(dev);
   14224                 :          0 :         tg3_full_unlock(tp);
   14225                 :            : }
   14226                 :            : 
   14227                 :          0 : static inline void tg3_set_mtu(struct net_device *dev, struct tg3 *tp,
   14228                 :            :                                int new_mtu)
   14229                 :            : {
   14230                 :          0 :         dev->mtu = new_mtu;
   14231                 :            : 
   14232         [ #  # ]:          0 :         if (new_mtu > ETH_DATA_LEN) {
   14233         [ #  # ]:          0 :                 if (tg3_flag(tp, 5780_CLASS)) {
   14234                 :          0 :                         netdev_update_features(dev);
   14235                 :          0 :                         tg3_flag_clear(tp, TSO_CAPABLE);
   14236                 :            :                 } else {
   14237                 :          0 :                         tg3_flag_set(tp, JUMBO_RING_ENABLE);
   14238                 :            :                 }
   14239                 :            :         } else {
   14240         [ #  # ]:          0 :                 if (tg3_flag(tp, 5780_CLASS)) {
   14241                 :          0 :                         tg3_flag_set(tp, TSO_CAPABLE);
   14242                 :          0 :                         netdev_update_features(dev);
   14243                 :            :                 }
   14244                 :          0 :                 tg3_flag_clear(tp, JUMBO_RING_ENABLE);
   14245                 :            :         }
   14246                 :          0 : }
   14247                 :            : 
   14248                 :          0 : static int tg3_change_mtu(struct net_device *dev, int new_mtu)
   14249                 :            : {
   14250                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   14251                 :          0 :         int err;
   14252                 :          0 :         bool reset_phy = false;
   14253                 :            : 
   14254         [ #  # ]:          0 :         if (!netif_running(dev)) {
   14255                 :            :                 /* We'll just catch it later when the
   14256                 :            :                  * device is up'd.
   14257                 :            :                  */
   14258                 :          0 :                 tg3_set_mtu(dev, tp, new_mtu);
   14259                 :          0 :                 return 0;
   14260                 :            :         }
   14261                 :            : 
   14262                 :          0 :         tg3_phy_stop(tp);
   14263                 :            : 
   14264                 :          0 :         tg3_netif_stop(tp);
   14265                 :            : 
   14266                 :          0 :         tg3_set_mtu(dev, tp, new_mtu);
   14267                 :            : 
   14268                 :          0 :         tg3_full_lock(tp, 1);
   14269                 :            : 
   14270                 :          0 :         tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
   14271                 :            : 
   14272                 :            :         /* Reset PHY, otherwise the read DMA engine will be in a mode that
   14273                 :            :          * breaks all requests to 256 bytes.
   14274                 :            :          */
   14275         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_57766 ||
   14276         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5717 ||
   14277         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5719 ||
   14278                 :            :             tg3_asic_rev(tp) == ASIC_REV_5720)
   14279                 :          0 :                 reset_phy = true;
   14280                 :            : 
   14281                 :          0 :         err = tg3_restart_hw(tp, reset_phy);
   14282                 :            : 
   14283         [ #  # ]:          0 :         if (!err)
   14284                 :          0 :                 tg3_netif_start(tp);
   14285                 :            : 
   14286                 :          0 :         tg3_full_unlock(tp);
   14287                 :            : 
   14288         [ #  # ]:          0 :         if (!err)
   14289                 :          0 :                 tg3_phy_start(tp);
   14290                 :            : 
   14291                 :            :         return err;
   14292                 :            : }
   14293                 :            : 
   14294                 :            : static const struct net_device_ops tg3_netdev_ops = {
   14295                 :            :         .ndo_open               = tg3_open,
   14296                 :            :         .ndo_stop               = tg3_close,
   14297                 :            :         .ndo_start_xmit         = tg3_start_xmit,
   14298                 :            :         .ndo_get_stats64        = tg3_get_stats64,
   14299                 :            :         .ndo_validate_addr      = eth_validate_addr,
   14300                 :            :         .ndo_set_rx_mode        = tg3_set_rx_mode,
   14301                 :            :         .ndo_set_mac_address    = tg3_set_mac_addr,
   14302                 :            :         .ndo_do_ioctl           = tg3_ioctl,
   14303                 :            :         .ndo_tx_timeout         = tg3_tx_timeout,
   14304                 :            :         .ndo_change_mtu         = tg3_change_mtu,
   14305                 :            :         .ndo_fix_features       = tg3_fix_features,
   14306                 :            :         .ndo_set_features       = tg3_set_features,
   14307                 :            : #ifdef CONFIG_NET_POLL_CONTROLLER
   14308                 :            :         .ndo_poll_controller    = tg3_poll_controller,
   14309                 :            : #endif
   14310                 :            : };
   14311                 :            : 
   14312                 :          0 : static void tg3_get_eeprom_size(struct tg3 *tp)
   14313                 :            : {
   14314                 :          0 :         u32 cursize, val, magic;
   14315                 :            : 
   14316                 :          0 :         tp->nvram_size = EEPROM_CHIP_SIZE;
   14317                 :            : 
   14318         [ #  # ]:          0 :         if (tg3_nvram_read(tp, 0, &magic) != 0)
   14319                 :          0 :                 return;
   14320                 :            : 
   14321         [ #  # ]:          0 :         if ((magic != TG3_EEPROM_MAGIC) &&
   14322         [ #  # ]:          0 :             ((magic & TG3_EEPROM_MAGIC_FW_MSK) != TG3_EEPROM_MAGIC_FW) &&
   14323         [ #  # ]:          0 :             ((magic & TG3_EEPROM_MAGIC_HW_MSK) != TG3_EEPROM_MAGIC_HW))
   14324                 :            :                 return;
   14325                 :            : 
   14326                 :            :         /*
   14327                 :            :          * Size the chip by reading offsets at increasing powers of two.
   14328                 :            :          * When we encounter our validation signature, we know the addressing
   14329                 :            :          * has wrapped around, and thus have our chip size.
   14330                 :            :          */
   14331                 :            :         cursize = 0x10;
   14332                 :            : 
   14333         [ #  # ]:          0 :         while (cursize < tp->nvram_size) {
   14334         [ #  # ]:          0 :                 if (tg3_nvram_read(tp, cursize, &val) != 0)
   14335                 :            :                         return;
   14336                 :            : 
   14337         [ #  # ]:          0 :                 if (val == magic)
   14338                 :            :                         break;
   14339                 :            : 
   14340                 :          0 :                 cursize <<= 1;
   14341                 :            :         }
   14342                 :            : 
   14343                 :          0 :         tp->nvram_size = cursize;
   14344                 :            : }
   14345                 :            : 
   14346                 :          0 : static void tg3_get_nvram_size(struct tg3 *tp)
   14347                 :            : {
   14348                 :          0 :         u32 val;
   14349                 :            : 
   14350   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, NO_NVRAM) || tg3_nvram_read(tp, 0, &val) != 0)
   14351                 :          0 :                 return;
   14352                 :            : 
   14353                 :            :         /* Selfboot format */
   14354         [ #  # ]:          0 :         if (val != TG3_EEPROM_MAGIC) {
   14355                 :          0 :                 tg3_get_eeprom_size(tp);
   14356                 :          0 :                 return;
   14357                 :            :         }
   14358                 :            : 
   14359         [ #  # ]:          0 :         if (tg3_nvram_read(tp, 0xf0, &val) == 0) {
   14360         [ #  # ]:          0 :                 if (val != 0) {
   14361                 :            :                         /* This is confusing.  We want to operate on the
   14362                 :            :                          * 16-bit value at offset 0xf2.  The tg3_nvram_read()
   14363                 :            :                          * call will read from NVRAM and byteswap the data
   14364                 :            :                          * according to the byteswapping settings for all
   14365                 :            :                          * other register accesses.  This ensures the data we
   14366                 :            :                          * want will always reside in the lower 16-bits.
   14367                 :            :                          * However, the data in NVRAM is in LE format, which
   14368                 :            :                          * means the data from the NVRAM read will always be
   14369                 :            :                          * opposite the endianness of the CPU.  The 16-bit
   14370                 :            :                          * byteswap then brings the data to CPU endianness.
   14371                 :            :                          */
   14372                 :          0 :                         tp->nvram_size = swab16((u16)(val & 0x0000ffff)) * 1024;
   14373                 :          0 :                         return;
   14374                 :            :                 }
   14375                 :            :         }
   14376                 :          0 :         tp->nvram_size = TG3_NVRAM_SIZE_512KB;
   14377                 :            : }
   14378                 :            : 
   14379                 :          0 : static void tg3_get_nvram_info(struct tg3 *tp)
   14380                 :            : {
   14381                 :          0 :         u32 nvcfg1;
   14382                 :            : 
   14383                 :          0 :         nvcfg1 = tr32(NVRAM_CFG1);
   14384         [ #  # ]:          0 :         if (nvcfg1 & NVRAM_CFG1_FLASHIF_ENAB) {
   14385                 :          0 :                 tg3_flag_set(tp, FLASH);
   14386                 :            :         } else {
   14387                 :          0 :                 nvcfg1 &= ~NVRAM_CFG1_COMPAT_BYPASS;
   14388                 :          0 :                 tw32(NVRAM_CFG1, nvcfg1);
   14389                 :            :         }
   14390                 :            : 
   14391   [ #  #  #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5750 ||
   14392                 :          0 :             tg3_flag(tp, 5780_CLASS)) {
   14393   [ #  #  #  #  :          0 :                 switch (nvcfg1 & NVRAM_CFG1_VENDOR_MASK) {
                #  #  # ]
   14394                 :          0 :                 case FLASH_VENDOR_ATMEL_FLASH_BUFFERED:
   14395                 :          0 :                         tp->nvram_jedecnum = JEDEC_ATMEL;
   14396                 :          0 :                         tp->nvram_pagesize = ATMEL_AT45DB0X1B_PAGE_SIZE;
   14397                 :          0 :                         tg3_flag_set(tp, NVRAM_BUFFERED);
   14398                 :            :                         break;
   14399                 :          0 :                 case FLASH_VENDOR_ATMEL_FLASH_UNBUFFERED:
   14400                 :          0 :                         tp->nvram_jedecnum = JEDEC_ATMEL;
   14401                 :          0 :                         tp->nvram_pagesize = ATMEL_AT25F512_PAGE_SIZE;
   14402                 :          0 :                         break;
   14403                 :          0 :                 case FLASH_VENDOR_ATMEL_EEPROM:
   14404                 :          0 :                         tp->nvram_jedecnum = JEDEC_ATMEL;
   14405                 :          0 :                         tp->nvram_pagesize = ATMEL_AT24C512_CHIP_SIZE;
   14406                 :          0 :                         tg3_flag_set(tp, NVRAM_BUFFERED);
   14407                 :            :                         break;
   14408                 :          0 :                 case FLASH_VENDOR_ST:
   14409                 :          0 :                         tp->nvram_jedecnum = JEDEC_ST;
   14410                 :          0 :                         tp->nvram_pagesize = ST_M45PEX0_PAGE_SIZE;
   14411                 :          0 :                         tg3_flag_set(tp, NVRAM_BUFFERED);
   14412                 :            :                         break;
   14413                 :          0 :                 case FLASH_VENDOR_SAIFUN:
   14414                 :          0 :                         tp->nvram_jedecnum = JEDEC_SAIFUN;
   14415                 :          0 :                         tp->nvram_pagesize = SAIFUN_SA25F0XX_PAGE_SIZE;
   14416                 :          0 :                         break;
   14417                 :          0 :                 case FLASH_VENDOR_SST_SMALL:
   14418                 :            :                 case FLASH_VENDOR_SST_LARGE:
   14419                 :          0 :                         tp->nvram_jedecnum = JEDEC_SST;
   14420                 :          0 :                         tp->nvram_pagesize = SST_25VF0X0_PAGE_SIZE;
   14421                 :          0 :                         break;
   14422                 :            :                 }
   14423                 :            :         } else {
   14424                 :          0 :                 tp->nvram_jedecnum = JEDEC_ATMEL;
   14425                 :          0 :                 tp->nvram_pagesize = ATMEL_AT45DB0X1B_PAGE_SIZE;
   14426                 :          0 :                 tg3_flag_set(tp, NVRAM_BUFFERED);
   14427                 :            :         }
   14428                 :          0 : }
   14429                 :            : 
   14430                 :            : static void tg3_nvram_get_pagesize(struct tg3 *tp, u32 nvmcfg1)
   14431                 :            : {
   14432                 :            :         switch (nvmcfg1 & NVRAM_CFG1_5752PAGE_SIZE_MASK) {
   14433                 :            :         case FLASH_5752PAGE_SIZE_256:
   14434                 :            :                 tp->nvram_pagesize = 256;
   14435                 :            :                 break;
   14436                 :            :         case FLASH_5752PAGE_SIZE_512:
   14437                 :            :                 tp->nvram_pagesize = 512;
   14438                 :            :                 break;
   14439                 :            :         case FLASH_5752PAGE_SIZE_1K:
   14440                 :            :                 tp->nvram_pagesize = 1024;
   14441                 :            :                 break;
   14442                 :            :         case FLASH_5752PAGE_SIZE_2K:
   14443                 :            :                 tp->nvram_pagesize = 2048;
   14444                 :            :                 break;
   14445                 :            :         case FLASH_5752PAGE_SIZE_4K:
   14446                 :            :                 tp->nvram_pagesize = 4096;
   14447                 :            :                 break;
   14448                 :            :         case FLASH_5752PAGE_SIZE_264:
   14449                 :            :                 tp->nvram_pagesize = 264;
   14450                 :            :                 break;
   14451                 :            :         case FLASH_5752PAGE_SIZE_528:
   14452                 :            :                 tp->nvram_pagesize = 528;
   14453                 :            :                 break;
   14454                 :            :         }
   14455                 :            : }
   14456                 :            : 
   14457                 :          0 : static void tg3_get_5752_nvram_info(struct tg3 *tp)
   14458                 :            : {
   14459                 :          0 :         u32 nvcfg1;
   14460                 :            : 
   14461                 :          0 :         nvcfg1 = tr32(NVRAM_CFG1);
   14462                 :            : 
   14463                 :            :         /* NVRAM protection for TPM */
   14464         [ #  # ]:          0 :         if (nvcfg1 & (1 << 27))
   14465                 :          0 :                 tg3_flag_set(tp, PROTECTED_NVRAM);
   14466                 :            : 
   14467   [ #  #  #  # ]:          0 :         switch (nvcfg1 & NVRAM_CFG1_5752VENDOR_MASK) {
   14468                 :          0 :         case FLASH_5752VENDOR_ATMEL_EEPROM_64KHZ:
   14469                 :            :         case FLASH_5752VENDOR_ATMEL_EEPROM_376KHZ:
   14470                 :          0 :                 tp->nvram_jedecnum = JEDEC_ATMEL;
   14471                 :          0 :                 tg3_flag_set(tp, NVRAM_BUFFERED);
   14472                 :            :                 break;
   14473                 :          0 :         case FLASH_5752VENDOR_ATMEL_FLASH_BUFFERED:
   14474                 :          0 :                 tp->nvram_jedecnum = JEDEC_ATMEL;
   14475                 :          0 :                 tg3_flag_set(tp, NVRAM_BUFFERED);
   14476                 :          0 :                 tg3_flag_set(tp, FLASH);
   14477                 :            :                 break;
   14478                 :          0 :         case FLASH_5752VENDOR_ST_M45PE10:
   14479                 :            :         case FLASH_5752VENDOR_ST_M45PE20:
   14480                 :            :         case FLASH_5752VENDOR_ST_M45PE40:
   14481                 :          0 :                 tp->nvram_jedecnum = JEDEC_ST;
   14482                 :          0 :                 tg3_flag_set(tp, NVRAM_BUFFERED);
   14483                 :          0 :                 tg3_flag_set(tp, FLASH);
   14484                 :            :                 break;
   14485                 :            :         }
   14486                 :            : 
   14487         [ #  # ]:          0 :         if (tg3_flag(tp, FLASH)) {
   14488                 :          0 :                 tg3_nvram_get_pagesize(tp, nvcfg1);
   14489                 :            :         } else {
   14490                 :            :                 /* For eeprom, set pagesize to maximum eeprom size */
   14491                 :          0 :                 tp->nvram_pagesize = ATMEL_AT24C512_CHIP_SIZE;
   14492                 :            : 
   14493                 :          0 :                 nvcfg1 &= ~NVRAM_CFG1_COMPAT_BYPASS;
   14494                 :          0 :                 tw32(NVRAM_CFG1, nvcfg1);
   14495                 :            :         }
   14496                 :          0 : }
   14497                 :            : 
   14498                 :          0 : static void tg3_get_5755_nvram_info(struct tg3 *tp)
   14499                 :            : {
   14500                 :          0 :         u32 nvcfg1, protect = 0;
   14501                 :            : 
   14502                 :          0 :         nvcfg1 = tr32(NVRAM_CFG1);
   14503                 :            : 
   14504                 :            :         /* NVRAM protection for TPM */
   14505         [ #  # ]:          0 :         if (nvcfg1 & (1 << 27)) {
   14506                 :          0 :                 tg3_flag_set(tp, PROTECTED_NVRAM);
   14507                 :          0 :                 protect = 1;
   14508                 :            :         }
   14509                 :            : 
   14510                 :          0 :         nvcfg1 &= NVRAM_CFG1_5752VENDOR_MASK;
   14511      [ #  #  # ]:          0 :         switch (nvcfg1) {
   14512                 :          0 :         case FLASH_5755VENDOR_ATMEL_FLASH_1:
   14513                 :            :         case FLASH_5755VENDOR_ATMEL_FLASH_2:
   14514                 :            :         case FLASH_5755VENDOR_ATMEL_FLASH_3:
   14515                 :            :         case FLASH_5755VENDOR_ATMEL_FLASH_5:
   14516                 :          0 :                 tp->nvram_jedecnum = JEDEC_ATMEL;
   14517                 :          0 :                 tg3_flag_set(tp, NVRAM_BUFFERED);
   14518                 :          0 :                 tg3_flag_set(tp, FLASH);
   14519                 :          0 :                 tp->nvram_pagesize = 264;
   14520                 :          0 :                 if (nvcfg1 == FLASH_5755VENDOR_ATMEL_FLASH_1 ||
   14521         [ #  # ]:          0 :                     nvcfg1 == FLASH_5755VENDOR_ATMEL_FLASH_5)
   14522         [ #  # ]:          0 :                         tp->nvram_size = (protect ? 0x3e200 :
   14523                 :            :                                           TG3_NVRAM_SIZE_512KB);
   14524         [ #  # ]:          0 :                 else if (nvcfg1 == FLASH_5755VENDOR_ATMEL_FLASH_2)
   14525         [ #  # ]:          0 :                         tp->nvram_size = (protect ? 0x1f200 :
   14526                 :            :                                           TG3_NVRAM_SIZE_256KB);
   14527                 :            :                 else
   14528         [ #  # ]:          0 :                         tp->nvram_size = (protect ? 0x1f200 :
   14529                 :            :                                           TG3_NVRAM_SIZE_128KB);
   14530                 :            :                 break;
   14531                 :          0 :         case FLASH_5752VENDOR_ST_M45PE10:
   14532                 :            :         case FLASH_5752VENDOR_ST_M45PE20:
   14533                 :            :         case FLASH_5752VENDOR_ST_M45PE40:
   14534                 :          0 :                 tp->nvram_jedecnum = JEDEC_ST;
   14535                 :          0 :                 tg3_flag_set(tp, NVRAM_BUFFERED);
   14536                 :          0 :                 tg3_flag_set(tp, FLASH);
   14537                 :          0 :                 tp->nvram_pagesize = 256;
   14538         [ #  # ]:          0 :                 if (nvcfg1 == FLASH_5752VENDOR_ST_M45PE10)
   14539                 :          0 :                         tp->nvram_size = (protect ?
   14540         [ #  # ]:          0 :                                           TG3_NVRAM_SIZE_64KB :
   14541                 :            :                                           TG3_NVRAM_SIZE_128KB);
   14542         [ #  # ]:          0 :                 else if (nvcfg1 == FLASH_5752VENDOR_ST_M45PE20)
   14543                 :          0 :                         tp->nvram_size = (protect ?
   14544         [ #  # ]:          0 :                                           TG3_NVRAM_SIZE_64KB :
   14545                 :            :                                           TG3_NVRAM_SIZE_256KB);
   14546                 :            :                 else
   14547                 :          0 :                         tp->nvram_size = (protect ?
   14548         [ #  # ]:          0 :                                           TG3_NVRAM_SIZE_128KB :
   14549                 :            :                                           TG3_NVRAM_SIZE_512KB);
   14550                 :            :                 break;
   14551                 :            :         }
   14552                 :          0 : }
   14553                 :            : 
   14554                 :          0 : static void tg3_get_5787_nvram_info(struct tg3 *tp)
   14555                 :            : {
   14556                 :          0 :         u32 nvcfg1;
   14557                 :            : 
   14558                 :          0 :         nvcfg1 = tr32(NVRAM_CFG1);
   14559                 :            : 
   14560   [ #  #  #  # ]:          0 :         switch (nvcfg1 & NVRAM_CFG1_5752VENDOR_MASK) {
   14561                 :          0 :         case FLASH_5787VENDOR_ATMEL_EEPROM_64KHZ:
   14562                 :            :         case FLASH_5787VENDOR_ATMEL_EEPROM_376KHZ:
   14563                 :            :         case FLASH_5787VENDOR_MICRO_EEPROM_64KHZ:
   14564                 :            :         case FLASH_5787VENDOR_MICRO_EEPROM_376KHZ:
   14565                 :          0 :                 tp->nvram_jedecnum = JEDEC_ATMEL;
   14566                 :          0 :                 tg3_flag_set(tp, NVRAM_BUFFERED);
   14567                 :          0 :                 tp->nvram_pagesize = ATMEL_AT24C512_CHIP_SIZE;
   14568                 :            : 
   14569                 :          0 :                 nvcfg1 &= ~NVRAM_CFG1_COMPAT_BYPASS;
   14570                 :          0 :                 tw32(NVRAM_CFG1, nvcfg1);
   14571                 :          0 :                 break;
   14572                 :          0 :         case FLASH_5752VENDOR_ATMEL_FLASH_BUFFERED:
   14573                 :            :         case FLASH_5755VENDOR_ATMEL_FLASH_1:
   14574                 :            :         case FLASH_5755VENDOR_ATMEL_FLASH_2:
   14575                 :            :         case FLASH_5755VENDOR_ATMEL_FLASH_3:
   14576                 :          0 :                 tp->nvram_jedecnum = JEDEC_ATMEL;
   14577                 :          0 :                 tg3_flag_set(tp, NVRAM_BUFFERED);
   14578                 :          0 :                 tg3_flag_set(tp, FLASH);
   14579                 :          0 :                 tp->nvram_pagesize = 264;
   14580                 :          0 :                 break;
   14581                 :          0 :         case FLASH_5752VENDOR_ST_M45PE10:
   14582                 :            :         case FLASH_5752VENDOR_ST_M45PE20:
   14583                 :            :         case FLASH_5752VENDOR_ST_M45PE40:
   14584                 :          0 :                 tp->nvram_jedecnum = JEDEC_ST;
   14585                 :          0 :                 tg3_flag_set(tp, NVRAM_BUFFERED);
   14586                 :          0 :                 tg3_flag_set(tp, FLASH);
   14587                 :          0 :                 tp->nvram_pagesize = 256;
   14588                 :          0 :                 break;
   14589                 :            :         }
   14590                 :          0 : }
   14591                 :            : 
   14592                 :          0 : static void tg3_get_5761_nvram_info(struct tg3 *tp)
   14593                 :            : {
   14594                 :          0 :         u32 nvcfg1, protect = 0;
   14595                 :            : 
   14596                 :          0 :         nvcfg1 = tr32(NVRAM_CFG1);
   14597                 :            : 
   14598                 :            :         /* NVRAM protection for TPM */
   14599         [ #  # ]:          0 :         if (nvcfg1 & (1 << 27)) {
   14600                 :          0 :                 tg3_flag_set(tp, PROTECTED_NVRAM);
   14601                 :          0 :                 protect = 1;
   14602                 :            :         }
   14603                 :            : 
   14604                 :          0 :         nvcfg1 &= NVRAM_CFG1_5752VENDOR_MASK;
   14605      [ #  #  # ]:          0 :         switch (nvcfg1) {
   14606                 :          0 :         case FLASH_5761VENDOR_ATMEL_ADB021D:
   14607                 :            :         case FLASH_5761VENDOR_ATMEL_ADB041D:
   14608                 :            :         case FLASH_5761VENDOR_ATMEL_ADB081D:
   14609                 :            :         case FLASH_5761VENDOR_ATMEL_ADB161D:
   14610                 :            :         case FLASH_5761VENDOR_ATMEL_MDB021D:
   14611                 :            :         case FLASH_5761VENDOR_ATMEL_MDB041D:
   14612                 :            :         case FLASH_5761VENDOR_ATMEL_MDB081D:
   14613                 :            :         case FLASH_5761VENDOR_ATMEL_MDB161D:
   14614                 :          0 :                 tp->nvram_jedecnum = JEDEC_ATMEL;
   14615                 :          0 :                 tg3_flag_set(tp, NVRAM_BUFFERED);
   14616                 :          0 :                 tg3_flag_set(tp, FLASH);
   14617                 :          0 :                 tg3_flag_set(tp, NO_NVRAM_ADDR_TRANS);
   14618                 :          0 :                 tp->nvram_pagesize = 256;
   14619                 :          0 :                 break;
   14620                 :          0 :         case FLASH_5761VENDOR_ST_A_M45PE20:
   14621                 :            :         case FLASH_5761VENDOR_ST_A_M45PE40:
   14622                 :            :         case FLASH_5761VENDOR_ST_A_M45PE80:
   14623                 :            :         case FLASH_5761VENDOR_ST_A_M45PE16:
   14624                 :            :         case FLASH_5761VENDOR_ST_M_M45PE20:
   14625                 :            :         case FLASH_5761VENDOR_ST_M_M45PE40:
   14626                 :            :         case FLASH_5761VENDOR_ST_M_M45PE80:
   14627                 :            :         case FLASH_5761VENDOR_ST_M_M45PE16:
   14628                 :          0 :                 tp->nvram_jedecnum = JEDEC_ST;
   14629                 :          0 :                 tg3_flag_set(tp, NVRAM_BUFFERED);
   14630                 :          0 :                 tg3_flag_set(tp, FLASH);
   14631                 :          0 :                 tp->nvram_pagesize = 256;
   14632                 :          0 :                 break;
   14633                 :            :         }
   14634                 :            : 
   14635         [ #  # ]:          0 :         if (protect) {
   14636                 :          0 :                 tp->nvram_size = tr32(NVRAM_ADDR_LOCKOUT);
   14637                 :            :         } else {
   14638   [ #  #  #  #  :          0 :                 switch (nvcfg1) {
                      # ]
   14639                 :          0 :                 case FLASH_5761VENDOR_ATMEL_ADB161D:
   14640                 :            :                 case FLASH_5761VENDOR_ATMEL_MDB161D:
   14641                 :            :                 case FLASH_5761VENDOR_ST_A_M45PE16:
   14642                 :            :                 case FLASH_5761VENDOR_ST_M_M45PE16:
   14643                 :          0 :                         tp->nvram_size = TG3_NVRAM_SIZE_2MB;
   14644                 :          0 :                         break;
   14645                 :          0 :                 case FLASH_5761VENDOR_ATMEL_ADB081D:
   14646                 :            :                 case FLASH_5761VENDOR_ATMEL_MDB081D:
   14647                 :            :                 case FLASH_5761VENDOR_ST_A_M45PE80:
   14648                 :            :                 case FLASH_5761VENDOR_ST_M_M45PE80:
   14649                 :          0 :                         tp->nvram_size = TG3_NVRAM_SIZE_1MB;
   14650                 :          0 :                         break;
   14651                 :          0 :                 case FLASH_5761VENDOR_ATMEL_ADB041D:
   14652                 :            :                 case FLASH_5761VENDOR_ATMEL_MDB041D:
   14653                 :            :                 case FLASH_5761VENDOR_ST_A_M45PE40:
   14654                 :            :                 case FLASH_5761VENDOR_ST_M_M45PE40:
   14655                 :          0 :                         tp->nvram_size = TG3_NVRAM_SIZE_512KB;
   14656                 :          0 :                         break;
   14657                 :          0 :                 case FLASH_5761VENDOR_ATMEL_ADB021D:
   14658                 :            :                 case FLASH_5761VENDOR_ATMEL_MDB021D:
   14659                 :            :                 case FLASH_5761VENDOR_ST_A_M45PE20:
   14660                 :            :                 case FLASH_5761VENDOR_ST_M_M45PE20:
   14661                 :          0 :                         tp->nvram_size = TG3_NVRAM_SIZE_256KB;
   14662                 :          0 :                         break;
   14663                 :            :                 }
   14664                 :          0 :         }
   14665                 :          0 : }
   14666                 :            : 
   14667                 :          0 : static void tg3_get_5906_nvram_info(struct tg3 *tp)
   14668                 :            : {
   14669                 :          0 :         tp->nvram_jedecnum = JEDEC_ATMEL;
   14670                 :          0 :         tg3_flag_set(tp, NVRAM_BUFFERED);
   14671                 :          0 :         tp->nvram_pagesize = ATMEL_AT24C512_CHIP_SIZE;
   14672                 :          0 : }
   14673                 :            : 
   14674                 :          0 : static void tg3_get_57780_nvram_info(struct tg3 *tp)
   14675                 :            : {
   14676                 :          0 :         u32 nvcfg1;
   14677                 :            : 
   14678                 :          0 :         nvcfg1 = tr32(NVRAM_CFG1);
   14679                 :            : 
   14680   [ #  #  #  # ]:          0 :         switch (nvcfg1 & NVRAM_CFG1_5752VENDOR_MASK) {
   14681                 :          0 :         case FLASH_5787VENDOR_ATMEL_EEPROM_376KHZ:
   14682                 :            :         case FLASH_5787VENDOR_MICRO_EEPROM_376KHZ:
   14683                 :          0 :                 tp->nvram_jedecnum = JEDEC_ATMEL;
   14684                 :          0 :                 tg3_flag_set(tp, NVRAM_BUFFERED);
   14685                 :          0 :                 tp->nvram_pagesize = ATMEL_AT24C512_CHIP_SIZE;
   14686                 :            : 
   14687                 :          0 :                 nvcfg1 &= ~NVRAM_CFG1_COMPAT_BYPASS;
   14688                 :          0 :                 tw32(NVRAM_CFG1, nvcfg1);
   14689                 :          0 :                 return;
   14690                 :          0 :         case FLASH_5752VENDOR_ATMEL_FLASH_BUFFERED:
   14691                 :            :         case FLASH_57780VENDOR_ATMEL_AT45DB011D:
   14692                 :            :         case FLASH_57780VENDOR_ATMEL_AT45DB011B:
   14693                 :            :         case FLASH_57780VENDOR_ATMEL_AT45DB021D:
   14694                 :            :         case FLASH_57780VENDOR_ATMEL_AT45DB021B:
   14695                 :            :         case FLASH_57780VENDOR_ATMEL_AT45DB041D:
   14696                 :            :         case FLASH_57780VENDOR_ATMEL_AT45DB041B:
   14697                 :          0 :                 tp->nvram_jedecnum = JEDEC_ATMEL;
   14698                 :          0 :                 tg3_flag_set(tp, NVRAM_BUFFERED);
   14699                 :          0 :                 tg3_flag_set(tp, FLASH);
   14700                 :            : 
   14701   [ #  #  #  # ]:          0 :                 switch (nvcfg1 & NVRAM_CFG1_5752VENDOR_MASK) {
   14702                 :          0 :                 case FLASH_5752VENDOR_ATMEL_FLASH_BUFFERED:
   14703                 :            :                 case FLASH_57780VENDOR_ATMEL_AT45DB011D:
   14704                 :            :                 case FLASH_57780VENDOR_ATMEL_AT45DB011B:
   14705                 :          0 :                         tp->nvram_size = TG3_NVRAM_SIZE_128KB;
   14706                 :          0 :                         break;
   14707                 :          0 :                 case FLASH_57780VENDOR_ATMEL_AT45DB021D:
   14708                 :            :                 case FLASH_57780VENDOR_ATMEL_AT45DB021B:
   14709                 :          0 :                         tp->nvram_size = TG3_NVRAM_SIZE_256KB;
   14710                 :          0 :                         break;
   14711                 :          0 :                 case FLASH_57780VENDOR_ATMEL_AT45DB041D:
   14712                 :            :                 case FLASH_57780VENDOR_ATMEL_AT45DB041B:
   14713                 :          0 :                         tp->nvram_size = TG3_NVRAM_SIZE_512KB;
   14714                 :          0 :                         break;
   14715                 :            :                 }
   14716                 :            :                 break;
   14717                 :          0 :         case FLASH_5752VENDOR_ST_M45PE10:
   14718                 :            :         case FLASH_5752VENDOR_ST_M45PE20:
   14719                 :            :         case FLASH_5752VENDOR_ST_M45PE40:
   14720                 :          0 :                 tp->nvram_jedecnum = JEDEC_ST;
   14721                 :          0 :                 tg3_flag_set(tp, NVRAM_BUFFERED);
   14722                 :          0 :                 tg3_flag_set(tp, FLASH);
   14723                 :            : 
   14724   [ #  #  #  # ]:          0 :                 switch (nvcfg1 & NVRAM_CFG1_5752VENDOR_MASK) {
   14725                 :          0 :                 case FLASH_5752VENDOR_ST_M45PE10:
   14726                 :          0 :                         tp->nvram_size = TG3_NVRAM_SIZE_128KB;
   14727                 :          0 :                         break;
   14728                 :          0 :                 case FLASH_5752VENDOR_ST_M45PE20:
   14729                 :          0 :                         tp->nvram_size = TG3_NVRAM_SIZE_256KB;
   14730                 :          0 :                         break;
   14731                 :          0 :                 case FLASH_5752VENDOR_ST_M45PE40:
   14732                 :          0 :                         tp->nvram_size = TG3_NVRAM_SIZE_512KB;
   14733                 :          0 :                         break;
   14734                 :            :                 }
   14735                 :            :                 break;
   14736                 :          0 :         default:
   14737                 :          0 :                 tg3_flag_set(tp, NO_NVRAM);
   14738                 :            :                 return;
   14739                 :            :         }
   14740                 :            : 
   14741                 :          0 :         tg3_nvram_get_pagesize(tp, nvcfg1);
   14742         [ #  # ]:          0 :         if (tp->nvram_pagesize != 264 && tp->nvram_pagesize != 528)
   14743                 :          0 :                 tg3_flag_set(tp, NO_NVRAM_ADDR_TRANS);
   14744                 :            : }
   14745                 :            : 
   14746                 :            : 
   14747                 :          0 : static void tg3_get_5717_nvram_info(struct tg3 *tp)
   14748                 :            : {
   14749                 :          0 :         u32 nvcfg1;
   14750                 :            : 
   14751                 :          0 :         nvcfg1 = tr32(NVRAM_CFG1);
   14752                 :            : 
   14753   [ #  #  #  # ]:          0 :         switch (nvcfg1 & NVRAM_CFG1_5752VENDOR_MASK) {
   14754                 :          0 :         case FLASH_5717VENDOR_ATMEL_EEPROM:
   14755                 :            :         case FLASH_5717VENDOR_MICRO_EEPROM:
   14756                 :          0 :                 tp->nvram_jedecnum = JEDEC_ATMEL;
   14757                 :          0 :                 tg3_flag_set(tp, NVRAM_BUFFERED);
   14758                 :          0 :                 tp->nvram_pagesize = ATMEL_AT24C512_CHIP_SIZE;
   14759                 :            : 
   14760                 :          0 :                 nvcfg1 &= ~NVRAM_CFG1_COMPAT_BYPASS;
   14761                 :          0 :                 tw32(NVRAM_CFG1, nvcfg1);
   14762                 :          0 :                 return;
   14763                 :          0 :         case FLASH_5717VENDOR_ATMEL_MDB011D:
   14764                 :            :         case FLASH_5717VENDOR_ATMEL_ADB011B:
   14765                 :            :         case FLASH_5717VENDOR_ATMEL_ADB011D:
   14766                 :            :         case FLASH_5717VENDOR_ATMEL_MDB021D:
   14767                 :            :         case FLASH_5717VENDOR_ATMEL_ADB021B:
   14768                 :            :         case FLASH_5717VENDOR_ATMEL_ADB021D:
   14769                 :            :         case FLASH_5717VENDOR_ATMEL_45USPT:
   14770                 :          0 :                 tp->nvram_jedecnum = JEDEC_ATMEL;
   14771                 :          0 :                 tg3_flag_set(tp, NVRAM_BUFFERED);
   14772                 :          0 :                 tg3_flag_set(tp, FLASH);
   14773                 :            : 
   14774      [ #  #  # ]:          0 :                 switch (nvcfg1 & NVRAM_CFG1_5752VENDOR_MASK) {
   14775                 :            :                 case FLASH_5717VENDOR_ATMEL_MDB021D:
   14776                 :            :                         /* Detect size with tg3_nvram_get_size() */
   14777                 :            :                         break;
   14778                 :          0 :                 case FLASH_5717VENDOR_ATMEL_ADB021B:
   14779                 :            :                 case FLASH_5717VENDOR_ATMEL_ADB021D:
   14780                 :          0 :                         tp->nvram_size = TG3_NVRAM_SIZE_256KB;
   14781                 :          0 :                         break;
   14782                 :          0 :                 default:
   14783                 :          0 :                         tp->nvram_size = TG3_NVRAM_SIZE_128KB;
   14784                 :          0 :                         break;
   14785                 :            :                 }
   14786                 :            :                 break;
   14787                 :          0 :         case FLASH_5717VENDOR_ST_M_M25PE10:
   14788                 :            :         case FLASH_5717VENDOR_ST_A_M25PE10:
   14789                 :            :         case FLASH_5717VENDOR_ST_M_M45PE10:
   14790                 :            :         case FLASH_5717VENDOR_ST_A_M45PE10:
   14791                 :            :         case FLASH_5717VENDOR_ST_M_M25PE20:
   14792                 :            :         case FLASH_5717VENDOR_ST_A_M25PE20:
   14793                 :            :         case FLASH_5717VENDOR_ST_M_M45PE20:
   14794                 :            :         case FLASH_5717VENDOR_ST_A_M45PE20:
   14795                 :            :         case FLASH_5717VENDOR_ST_25USPT:
   14796                 :            :         case FLASH_5717VENDOR_ST_45USPT:
   14797                 :          0 :                 tp->nvram_jedecnum = JEDEC_ST;
   14798                 :          0 :                 tg3_flag_set(tp, NVRAM_BUFFERED);
   14799                 :          0 :                 tg3_flag_set(tp, FLASH);
   14800                 :            : 
   14801      [ #  #  # ]:          0 :                 switch (nvcfg1 & NVRAM_CFG1_5752VENDOR_MASK) {
   14802                 :            :                 case FLASH_5717VENDOR_ST_M_M25PE20:
   14803                 :            :                 case FLASH_5717VENDOR_ST_M_M45PE20:
   14804                 :            :                         /* Detect size with tg3_nvram_get_size() */
   14805                 :            :                         break;
   14806                 :          0 :                 case FLASH_5717VENDOR_ST_A_M25PE20:
   14807                 :            :                 case FLASH_5717VENDOR_ST_A_M45PE20:
   14808                 :          0 :                         tp->nvram_size = TG3_NVRAM_SIZE_256KB;
   14809                 :          0 :                         break;
   14810                 :          0 :                 default:
   14811                 :          0 :                         tp->nvram_size = TG3_NVRAM_SIZE_128KB;
   14812                 :          0 :                         break;
   14813                 :            :                 }
   14814                 :            :                 break;
   14815                 :          0 :         default:
   14816                 :          0 :                 tg3_flag_set(tp, NO_NVRAM);
   14817                 :            :                 return;
   14818                 :            :         }
   14819                 :            : 
   14820                 :          0 :         tg3_nvram_get_pagesize(tp, nvcfg1);
   14821         [ #  # ]:          0 :         if (tp->nvram_pagesize != 264 && tp->nvram_pagesize != 528)
   14822                 :          0 :                 tg3_flag_set(tp, NO_NVRAM_ADDR_TRANS);
   14823                 :            : }
   14824                 :            : 
   14825                 :          0 : static void tg3_get_5720_nvram_info(struct tg3 *tp)
   14826                 :            : {
   14827                 :          0 :         u32 nvcfg1, nvmpinstrp, nv_status;
   14828                 :            : 
   14829                 :          0 :         nvcfg1 = tr32(NVRAM_CFG1);
   14830                 :          0 :         nvmpinstrp = nvcfg1 & NVRAM_CFG1_5752VENDOR_MASK;
   14831                 :            : 
   14832         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5762) {
   14833         [ #  # ]:          0 :                 if (!(nvcfg1 & NVRAM_CFG1_5762VENDOR_MASK)) {
   14834                 :          0 :                         tg3_flag_set(tp, NO_NVRAM);
   14835                 :          0 :                         return;
   14836                 :            :                 }
   14837                 :            : 
   14838   [ #  #  #  #  :          0 :                 switch (nvmpinstrp) {
                      # ]
   14839                 :          0 :                 case FLASH_5762_MX25L_100:
   14840                 :            :                 case FLASH_5762_MX25L_200:
   14841                 :            :                 case FLASH_5762_MX25L_400:
   14842                 :            :                 case FLASH_5762_MX25L_800:
   14843                 :            :                 case FLASH_5762_MX25L_160_320:
   14844                 :          0 :                         tp->nvram_pagesize = 4096;
   14845                 :          0 :                         tp->nvram_jedecnum = JEDEC_MACRONIX;
   14846                 :          0 :                         tg3_flag_set(tp, NVRAM_BUFFERED);
   14847                 :          0 :                         tg3_flag_set(tp, NO_NVRAM_ADDR_TRANS);
   14848                 :          0 :                         tg3_flag_set(tp, FLASH);
   14849                 :          0 :                         nv_status = tr32(NVRAM_AUTOSENSE_STATUS);
   14850                 :          0 :                         tp->nvram_size =
   14851                 :          0 :                                 (1 << (nv_status >> AUTOSENSE_DEVID &
   14852                 :            :                                                 AUTOSENSE_DEVID_MASK)
   14853                 :          0 :                                         << AUTOSENSE_SIZE_IN_MB);
   14854                 :          0 :                         return;
   14855                 :            : 
   14856                 :            :                 case FLASH_5762_EEPROM_HD:
   14857                 :            :                         nvmpinstrp = FLASH_5720_EEPROM_HD;
   14858                 :            :                         break;
   14859                 :            :                 case FLASH_5762_EEPROM_LD:
   14860                 :          0 :                         nvmpinstrp = FLASH_5720_EEPROM_LD;
   14861                 :          0 :                         break;
   14862                 :            :                 case FLASH_5720VENDOR_M_ST_M45PE20:
   14863                 :            :                         /* This pinstrap supports multiple sizes, so force it
   14864                 :            :                          * to read the actual size from location 0xf0.
   14865                 :            :                          */
   14866                 :            :                         nvmpinstrp = FLASH_5720VENDOR_ST_45USPT;
   14867                 :            :                         break;
   14868                 :            :                 }
   14869                 :          0 :         }
   14870                 :            : 
   14871   [ #  #  #  # ]:          0 :         switch (nvmpinstrp) {
   14872                 :          0 :         case FLASH_5720_EEPROM_HD:
   14873                 :            :         case FLASH_5720_EEPROM_LD:
   14874                 :          0 :                 tp->nvram_jedecnum = JEDEC_ATMEL;
   14875                 :          0 :                 tg3_flag_set(tp, NVRAM_BUFFERED);
   14876                 :            : 
   14877                 :          0 :                 nvcfg1 &= ~NVRAM_CFG1_COMPAT_BYPASS;
   14878                 :          0 :                 tw32(NVRAM_CFG1, nvcfg1);
   14879         [ #  # ]:          0 :                 if (nvmpinstrp == FLASH_5720_EEPROM_HD)
   14880                 :          0 :                         tp->nvram_pagesize = ATMEL_AT24C512_CHIP_SIZE;
   14881                 :            :                 else
   14882                 :          0 :                         tp->nvram_pagesize = ATMEL_AT24C02_CHIP_SIZE;
   14883                 :            :                 return;
   14884                 :          0 :         case FLASH_5720VENDOR_M_ATMEL_DB011D:
   14885                 :            :         case FLASH_5720VENDOR_A_ATMEL_DB011B:
   14886                 :            :         case FLASH_5720VENDOR_A_ATMEL_DB011D:
   14887                 :            :         case FLASH_5720VENDOR_M_ATMEL_DB021D:
   14888                 :            :         case FLASH_5720VENDOR_A_ATMEL_DB021B:
   14889                 :            :         case FLASH_5720VENDOR_A_ATMEL_DB021D:
   14890                 :            :         case FLASH_5720VENDOR_M_ATMEL_DB041D:
   14891                 :            :         case FLASH_5720VENDOR_A_ATMEL_DB041B:
   14892                 :            :         case FLASH_5720VENDOR_A_ATMEL_DB041D:
   14893                 :            :         case FLASH_5720VENDOR_M_ATMEL_DB081D:
   14894                 :            :         case FLASH_5720VENDOR_A_ATMEL_DB081D:
   14895                 :            :         case FLASH_5720VENDOR_ATMEL_45USPT:
   14896                 :          0 :                 tp->nvram_jedecnum = JEDEC_ATMEL;
   14897                 :          0 :                 tg3_flag_set(tp, NVRAM_BUFFERED);
   14898                 :          0 :                 tg3_flag_set(tp, FLASH);
   14899                 :            : 
   14900   [ #  #  #  # ]:          0 :                 switch (nvmpinstrp) {
   14901                 :          0 :                 case FLASH_5720VENDOR_M_ATMEL_DB021D:
   14902                 :            :                 case FLASH_5720VENDOR_A_ATMEL_DB021B:
   14903                 :            :                 case FLASH_5720VENDOR_A_ATMEL_DB021D:
   14904                 :          0 :                         tp->nvram_size = TG3_NVRAM_SIZE_256KB;
   14905                 :          0 :                         break;
   14906                 :          0 :                 case FLASH_5720VENDOR_M_ATMEL_DB041D:
   14907                 :            :                 case FLASH_5720VENDOR_A_ATMEL_DB041B:
   14908                 :            :                 case FLASH_5720VENDOR_A_ATMEL_DB041D:
   14909                 :          0 :                         tp->nvram_size = TG3_NVRAM_SIZE_512KB;
   14910                 :          0 :                         break;
   14911                 :          0 :                 case FLASH_5720VENDOR_M_ATMEL_DB081D:
   14912                 :            :                 case FLASH_5720VENDOR_A_ATMEL_DB081D:
   14913                 :          0 :                         tp->nvram_size = TG3_NVRAM_SIZE_1MB;
   14914                 :          0 :                         break;
   14915                 :          0 :                 default:
   14916         [ #  # ]:          0 :                         if (tg3_asic_rev(tp) != ASIC_REV_5762)
   14917                 :          0 :                                 tp->nvram_size = TG3_NVRAM_SIZE_128KB;
   14918                 :            :                         break;
   14919                 :            :                 }
   14920                 :            :                 break;
   14921                 :          0 :         case FLASH_5720VENDOR_M_ST_M25PE10:
   14922                 :            :         case FLASH_5720VENDOR_M_ST_M45PE10:
   14923                 :            :         case FLASH_5720VENDOR_A_ST_M25PE10:
   14924                 :            :         case FLASH_5720VENDOR_A_ST_M45PE10:
   14925                 :            :         case FLASH_5720VENDOR_M_ST_M25PE20:
   14926                 :            :         case FLASH_5720VENDOR_M_ST_M45PE20:
   14927                 :            :         case FLASH_5720VENDOR_A_ST_M25PE20:
   14928                 :            :         case FLASH_5720VENDOR_A_ST_M45PE20:
   14929                 :            :         case FLASH_5720VENDOR_M_ST_M25PE40:
   14930                 :            :         case FLASH_5720VENDOR_M_ST_M45PE40:
   14931                 :            :         case FLASH_5720VENDOR_A_ST_M25PE40:
   14932                 :            :         case FLASH_5720VENDOR_A_ST_M45PE40:
   14933                 :            :         case FLASH_5720VENDOR_M_ST_M25PE80:
   14934                 :            :         case FLASH_5720VENDOR_M_ST_M45PE80:
   14935                 :            :         case FLASH_5720VENDOR_A_ST_M25PE80:
   14936                 :            :         case FLASH_5720VENDOR_A_ST_M45PE80:
   14937                 :            :         case FLASH_5720VENDOR_ST_25USPT:
   14938                 :            :         case FLASH_5720VENDOR_ST_45USPT:
   14939                 :          0 :                 tp->nvram_jedecnum = JEDEC_ST;
   14940                 :          0 :                 tg3_flag_set(tp, NVRAM_BUFFERED);
   14941                 :          0 :                 tg3_flag_set(tp, FLASH);
   14942                 :            : 
   14943   [ #  #  #  # ]:          0 :                 switch (nvmpinstrp) {
   14944                 :          0 :                 case FLASH_5720VENDOR_M_ST_M25PE20:
   14945                 :            :                 case FLASH_5720VENDOR_M_ST_M45PE20:
   14946                 :            :                 case FLASH_5720VENDOR_A_ST_M25PE20:
   14947                 :            :                 case FLASH_5720VENDOR_A_ST_M45PE20:
   14948                 :          0 :                         tp->nvram_size = TG3_NVRAM_SIZE_256KB;
   14949                 :          0 :                         break;
   14950                 :          0 :                 case FLASH_5720VENDOR_M_ST_M25PE40:
   14951                 :            :                 case FLASH_5720VENDOR_M_ST_M45PE40:
   14952                 :            :                 case FLASH_5720VENDOR_A_ST_M25PE40:
   14953                 :            :                 case FLASH_5720VENDOR_A_ST_M45PE40:
   14954                 :          0 :                         tp->nvram_size = TG3_NVRAM_SIZE_512KB;
   14955                 :          0 :                         break;
   14956                 :          0 :                 case FLASH_5720VENDOR_M_ST_M25PE80:
   14957                 :            :                 case FLASH_5720VENDOR_M_ST_M45PE80:
   14958                 :            :                 case FLASH_5720VENDOR_A_ST_M25PE80:
   14959                 :            :                 case FLASH_5720VENDOR_A_ST_M45PE80:
   14960                 :          0 :                         tp->nvram_size = TG3_NVRAM_SIZE_1MB;
   14961                 :          0 :                         break;
   14962                 :          0 :                 default:
   14963         [ #  # ]:          0 :                         if (tg3_asic_rev(tp) != ASIC_REV_5762)
   14964                 :          0 :                                 tp->nvram_size = TG3_NVRAM_SIZE_128KB;
   14965                 :            :                         break;
   14966                 :            :                 }
   14967                 :            :                 break;
   14968                 :          0 :         default:
   14969                 :          0 :                 tg3_flag_set(tp, NO_NVRAM);
   14970                 :            :                 return;
   14971                 :            :         }
   14972                 :            : 
   14973                 :          0 :         tg3_nvram_get_pagesize(tp, nvcfg1);
   14974         [ #  # ]:          0 :         if (tp->nvram_pagesize != 264 && tp->nvram_pagesize != 528)
   14975                 :          0 :                 tg3_flag_set(tp, NO_NVRAM_ADDR_TRANS);
   14976                 :            : 
   14977         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5762) {
   14978                 :          0 :                 u32 val;
   14979                 :            : 
   14980         [ #  # ]:          0 :                 if (tg3_nvram_read(tp, 0, &val))
   14981                 :          0 :                         return;
   14982                 :            : 
   14983         [ #  # ]:          0 :                 if (val != TG3_EEPROM_MAGIC &&
   14984         [ #  # ]:          0 :                     (val & TG3_EEPROM_MAGIC_FW_MSK) != TG3_EEPROM_MAGIC_FW)
   14985                 :          0 :                         tg3_flag_set(tp, NO_NVRAM);
   14986                 :            :         }
   14987                 :            : }
   14988                 :            : 
   14989                 :            : /* Chips other than 5700/5701 use the NVRAM for fetching info. */
   14990                 :          0 : static void tg3_nvram_init(struct tg3 *tp)
   14991                 :            : {
   14992         [ #  # ]:          0 :         if (tg3_flag(tp, IS_SSB_CORE)) {
   14993                 :            :                 /* No NVRAM and EEPROM on the SSB Broadcom GigE core. */
   14994                 :          0 :                 tg3_flag_clear(tp, NVRAM);
   14995                 :          0 :                 tg3_flag_clear(tp, NVRAM_BUFFERED);
   14996                 :          0 :                 tg3_flag_set(tp, NO_NVRAM);
   14997                 :          0 :                 return;
   14998                 :            :         }
   14999                 :            : 
   15000                 :          0 :         tw32_f(GRC_EEPROM_ADDR,
   15001                 :            :              (EEPROM_ADDR_FSM_RESET |
   15002                 :            :               (EEPROM_DEFAULT_CLOCK_PERIOD <<
   15003                 :            :                EEPROM_ADDR_CLKPERD_SHIFT)));
   15004                 :            : 
   15005                 :          0 :         msleep(1);
   15006                 :            : 
   15007                 :            :         /* Enable seeprom accesses. */
   15008                 :          0 :         tw32_f(GRC_LOCAL_CTRL,
   15009                 :            :              tr32(GRC_LOCAL_CTRL) | GRC_LCLCTRL_AUTO_SEEPROM);
   15010                 :          0 :         udelay(100);
   15011                 :            : 
   15012         [ #  # ]:          0 :         if (tg3_asic_rev(tp) != ASIC_REV_5700 &&
   15013                 :            :             tg3_asic_rev(tp) != ASIC_REV_5701) {
   15014                 :          0 :                 tg3_flag_set(tp, NVRAM);
   15015                 :            : 
   15016         [ #  # ]:          0 :                 if (tg3_nvram_lock(tp)) {
   15017                 :          0 :                         netdev_warn(tp->dev,
   15018                 :            :                                     "Cannot get nvram lock, %s failed\n",
   15019                 :            :                                     __func__);
   15020                 :          0 :                         return;
   15021                 :            :                 }
   15022                 :          0 :                 tg3_enable_nvram_access(tp);
   15023                 :            : 
   15024                 :          0 :                 tp->nvram_size = 0;
   15025                 :            : 
   15026         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5752)
   15027                 :          0 :                         tg3_get_5752_nvram_info(tp);
   15028         [ #  # ]:          0 :                 else if (tg3_asic_rev(tp) == ASIC_REV_5755)
   15029                 :          0 :                         tg3_get_5755_nvram_info(tp);
   15030         [ #  # ]:          0 :                 else if (tg3_asic_rev(tp) == ASIC_REV_5787 ||
   15031         [ #  # ]:          0 :                          tg3_asic_rev(tp) == ASIC_REV_5784 ||
   15032                 :            :                          tg3_asic_rev(tp) == ASIC_REV_5785)
   15033                 :          0 :                         tg3_get_5787_nvram_info(tp);
   15034         [ #  # ]:          0 :                 else if (tg3_asic_rev(tp) == ASIC_REV_5761)
   15035                 :          0 :                         tg3_get_5761_nvram_info(tp);
   15036         [ #  # ]:          0 :                 else if (tg3_asic_rev(tp) == ASIC_REV_5906)
   15037                 :          0 :                         tg3_get_5906_nvram_info(tp);
   15038   [ #  #  #  # ]:          0 :                 else if (tg3_asic_rev(tp) == ASIC_REV_57780 ||
   15039                 :            :                          tg3_flag(tp, 57765_CLASS))
   15040                 :          0 :                         tg3_get_57780_nvram_info(tp);
   15041         [ #  # ]:          0 :                 else if (tg3_asic_rev(tp) == ASIC_REV_5717 ||
   15042                 :            :                          tg3_asic_rev(tp) == ASIC_REV_5719)
   15043                 :          0 :                         tg3_get_5717_nvram_info(tp);
   15044         [ #  # ]:          0 :                 else if (tg3_asic_rev(tp) == ASIC_REV_5720 ||
   15045                 :            :                          tg3_asic_rev(tp) == ASIC_REV_5762)
   15046                 :          0 :                         tg3_get_5720_nvram_info(tp);
   15047                 :            :                 else
   15048                 :          0 :                         tg3_get_nvram_info(tp);
   15049                 :            : 
   15050         [ #  # ]:          0 :                 if (tp->nvram_size == 0)
   15051                 :          0 :                         tg3_get_nvram_size(tp);
   15052                 :            : 
   15053                 :          0 :                 tg3_disable_nvram_access(tp);
   15054                 :          0 :                 tg3_nvram_unlock(tp);
   15055                 :            : 
   15056                 :            :         } else {
   15057                 :          0 :                 tg3_flag_clear(tp, NVRAM);
   15058                 :          0 :                 tg3_flag_clear(tp, NVRAM_BUFFERED);
   15059                 :            : 
   15060                 :          0 :                 tg3_get_eeprom_size(tp);
   15061                 :            :         }
   15062                 :            : }
   15063                 :            : 
   15064                 :            : struct subsys_tbl_ent {
   15065                 :            :         u16 subsys_vendor, subsys_devid;
   15066                 :            :         u32 phy_id;
   15067                 :            : };
   15068                 :            : 
   15069                 :            : static struct subsys_tbl_ent subsys_id_to_phy_id[] = {
   15070                 :            :         /* Broadcom boards. */
   15071                 :            :         { TG3PCI_SUBVENDOR_ID_BROADCOM,
   15072                 :            :           TG3PCI_SUBDEVICE_ID_BROADCOM_95700A6, TG3_PHY_ID_BCM5401 },
   15073                 :            :         { TG3PCI_SUBVENDOR_ID_BROADCOM,
   15074                 :            :           TG3PCI_SUBDEVICE_ID_BROADCOM_95701A5, TG3_PHY_ID_BCM5701 },
   15075                 :            :         { TG3PCI_SUBVENDOR_ID_BROADCOM,
   15076                 :            :           TG3PCI_SUBDEVICE_ID_BROADCOM_95700T6, TG3_PHY_ID_BCM8002 },
   15077                 :            :         { TG3PCI_SUBVENDOR_ID_BROADCOM,
   15078                 :            :           TG3PCI_SUBDEVICE_ID_BROADCOM_95700A9, 0 },
   15079                 :            :         { TG3PCI_SUBVENDOR_ID_BROADCOM,
   15080                 :            :           TG3PCI_SUBDEVICE_ID_BROADCOM_95701T1, TG3_PHY_ID_BCM5701 },
   15081                 :            :         { TG3PCI_SUBVENDOR_ID_BROADCOM,
   15082                 :            :           TG3PCI_SUBDEVICE_ID_BROADCOM_95701T8, TG3_PHY_ID_BCM5701 },
   15083                 :            :         { TG3PCI_SUBVENDOR_ID_BROADCOM,
   15084                 :            :           TG3PCI_SUBDEVICE_ID_BROADCOM_95701A7, 0 },
   15085                 :            :         { TG3PCI_SUBVENDOR_ID_BROADCOM,
   15086                 :            :           TG3PCI_SUBDEVICE_ID_BROADCOM_95701A10, TG3_PHY_ID_BCM5701 },
   15087                 :            :         { TG3PCI_SUBVENDOR_ID_BROADCOM,
   15088                 :            :           TG3PCI_SUBDEVICE_ID_BROADCOM_95701A12, TG3_PHY_ID_BCM5701 },
   15089                 :            :         { TG3PCI_SUBVENDOR_ID_BROADCOM,
   15090                 :            :           TG3PCI_SUBDEVICE_ID_BROADCOM_95703AX1, TG3_PHY_ID_BCM5703 },
   15091                 :            :         { TG3PCI_SUBVENDOR_ID_BROADCOM,
   15092                 :            :           TG3PCI_SUBDEVICE_ID_BROADCOM_95703AX2, TG3_PHY_ID_BCM5703 },
   15093                 :            : 
   15094                 :            :         /* 3com boards. */
   15095                 :            :         { TG3PCI_SUBVENDOR_ID_3COM,
   15096                 :            :           TG3PCI_SUBDEVICE_ID_3COM_3C996T, TG3_PHY_ID_BCM5401 },
   15097                 :            :         { TG3PCI_SUBVENDOR_ID_3COM,
   15098                 :            :           TG3PCI_SUBDEVICE_ID_3COM_3C996BT, TG3_PHY_ID_BCM5701 },
   15099                 :            :         { TG3PCI_SUBVENDOR_ID_3COM,
   15100                 :            :           TG3PCI_SUBDEVICE_ID_3COM_3C996SX, 0 },
   15101                 :            :         { TG3PCI_SUBVENDOR_ID_3COM,
   15102                 :            :           TG3PCI_SUBDEVICE_ID_3COM_3C1000T, TG3_PHY_ID_BCM5701 },
   15103                 :            :         { TG3PCI_SUBVENDOR_ID_3COM,
   15104                 :            :           TG3PCI_SUBDEVICE_ID_3COM_3C940BR01, TG3_PHY_ID_BCM5701 },
   15105                 :            : 
   15106                 :            :         /* DELL boards. */
   15107                 :            :         { TG3PCI_SUBVENDOR_ID_DELL,
   15108                 :            :           TG3PCI_SUBDEVICE_ID_DELL_VIPER, TG3_PHY_ID_BCM5401 },
   15109                 :            :         { TG3PCI_SUBVENDOR_ID_DELL,
   15110                 :            :           TG3PCI_SUBDEVICE_ID_DELL_JAGUAR, TG3_PHY_ID_BCM5401 },
   15111                 :            :         { TG3PCI_SUBVENDOR_ID_DELL,
   15112                 :            :           TG3PCI_SUBDEVICE_ID_DELL_MERLOT, TG3_PHY_ID_BCM5411 },
   15113                 :            :         { TG3PCI_SUBVENDOR_ID_DELL,
   15114                 :            :           TG3PCI_SUBDEVICE_ID_DELL_SLIM_MERLOT, TG3_PHY_ID_BCM5411 },
   15115                 :            : 
   15116                 :            :         /* Compaq boards. */
   15117                 :            :         { TG3PCI_SUBVENDOR_ID_COMPAQ,
   15118                 :            :           TG3PCI_SUBDEVICE_ID_COMPAQ_BANSHEE, TG3_PHY_ID_BCM5701 },
   15119                 :            :         { TG3PCI_SUBVENDOR_ID_COMPAQ,
   15120                 :            :           TG3PCI_SUBDEVICE_ID_COMPAQ_BANSHEE_2, TG3_PHY_ID_BCM5701 },
   15121                 :            :         { TG3PCI_SUBVENDOR_ID_COMPAQ,
   15122                 :            :           TG3PCI_SUBDEVICE_ID_COMPAQ_CHANGELING, 0 },
   15123                 :            :         { TG3PCI_SUBVENDOR_ID_COMPAQ,
   15124                 :            :           TG3PCI_SUBDEVICE_ID_COMPAQ_NC7780, TG3_PHY_ID_BCM5701 },
   15125                 :            :         { TG3PCI_SUBVENDOR_ID_COMPAQ,
   15126                 :            :           TG3PCI_SUBDEVICE_ID_COMPAQ_NC7780_2, TG3_PHY_ID_BCM5701 },
   15127                 :            : 
   15128                 :            :         /* IBM boards. */
   15129                 :            :         { TG3PCI_SUBVENDOR_ID_IBM,
   15130                 :            :           TG3PCI_SUBDEVICE_ID_IBM_5703SAX2, 0 }
   15131                 :            : };
   15132                 :            : 
   15133                 :            : static struct subsys_tbl_ent *tg3_lookup_by_subsys(struct tg3 *tp)
   15134                 :            : {
   15135                 :            :         int i;
   15136                 :            : 
   15137         [ #  # ]:          0 :         for (i = 0; i < ARRAY_SIZE(subsys_id_to_phy_id); i++) {
   15138                 :          0 :                 if ((subsys_id_to_phy_id[i].subsys_vendor ==
   15139         [ #  # ]:          0 :                      tp->pdev->subsystem_vendor) &&
   15140                 :          0 :                     (subsys_id_to_phy_id[i].subsys_devid ==
   15141         [ #  # ]:          0 :                      tp->pdev->subsystem_device))
   15142                 :          0 :                         return &subsys_id_to_phy_id[i];
   15143                 :            :         }
   15144                 :            :         return NULL;
   15145                 :            : }
   15146                 :            : 
   15147                 :          0 : static void tg3_get_eeprom_hw_cfg(struct tg3 *tp)
   15148                 :            : {
   15149                 :          0 :         u32 val;
   15150                 :            : 
   15151                 :          0 :         tp->phy_id = TG3_PHY_ID_INVALID;
   15152                 :          0 :         tp->led_ctrl = LED_CTRL_MODE_PHY_1;
   15153                 :            : 
   15154                 :            :         /* Assume an onboard device and WOL capable by default.  */
   15155                 :          0 :         tg3_flag_set(tp, EEPROM_WRITE_PROT);
   15156                 :          0 :         tg3_flag_set(tp, WOL_CAP);
   15157                 :            : 
   15158         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5906) {
   15159         [ #  # ]:          0 :                 if (!(tr32(PCIE_TRANSACTION_CFG) & PCIE_TRANS_CFG_LOM)) {
   15160                 :          0 :                         tg3_flag_clear(tp, EEPROM_WRITE_PROT);
   15161                 :          0 :                         tg3_flag_set(tp, IS_NIC);
   15162                 :            :                 }
   15163                 :          0 :                 val = tr32(VCPU_CFGSHDW);
   15164         [ #  # ]:          0 :                 if (val & VCPU_CFGSHDW_ASPM_DBNC)
   15165                 :          0 :                         tg3_flag_set(tp, ASPM_WORKAROUND);
   15166         [ #  # ]:          0 :                 if ((val & VCPU_CFGSHDW_WOL_ENABLE) &&
   15167                 :            :                     (val & VCPU_CFGSHDW_WOL_MAGPKT)) {
   15168                 :          0 :                         tg3_flag_set(tp, WOL_ENABLE);
   15169                 :          0 :                         device_set_wakeup_enable(&tp->pdev->dev, true);
   15170                 :            :                 }
   15171                 :          0 :                 goto done;
   15172                 :            :         }
   15173                 :            : 
   15174                 :          0 :         tg3_read_mem(tp, NIC_SRAM_DATA_SIG, &val);
   15175         [ #  # ]:          0 :         if (val == NIC_SRAM_DATA_SIG_MAGIC) {
   15176                 :          0 :                 u32 nic_cfg, led_cfg;
   15177                 :          0 :                 u32 cfg2 = 0, cfg4 = 0, cfg5 = 0;
   15178                 :          0 :                 u32 nic_phy_id, ver, eeprom_phy_id;
   15179                 :          0 :                 int eeprom_phy_serdes = 0;
   15180                 :            : 
   15181                 :          0 :                 tg3_read_mem(tp, NIC_SRAM_DATA_CFG, &nic_cfg);
   15182                 :          0 :                 tp->nic_sram_data_cfg = nic_cfg;
   15183                 :            : 
   15184                 :          0 :                 tg3_read_mem(tp, NIC_SRAM_DATA_VER, &ver);
   15185                 :          0 :                 ver >>= NIC_SRAM_DATA_VER_SHIFT;
   15186         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) != ASIC_REV_5700 &&
   15187         [ #  # ]:          0 :                     tg3_asic_rev(tp) != ASIC_REV_5701 &&
   15188         [ #  # ]:          0 :                     tg3_asic_rev(tp) != ASIC_REV_5703 &&
   15189         [ #  # ]:          0 :                     (ver > 0) && (ver < 0x100))
   15190                 :          0 :                         tg3_read_mem(tp, NIC_SRAM_DATA_CFG_2, &cfg2);
   15191                 :            : 
   15192         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5785)
   15193                 :          0 :                         tg3_read_mem(tp, NIC_SRAM_DATA_CFG_4, &cfg4);
   15194                 :            : 
   15195         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5717 ||
   15196         [ #  # ]:          0 :                     tg3_asic_rev(tp) == ASIC_REV_5719 ||
   15197                 :            :                     tg3_asic_rev(tp) == ASIC_REV_5720)
   15198                 :          0 :                         tg3_read_mem(tp, NIC_SRAM_DATA_CFG_5, &cfg5);
   15199                 :            : 
   15200         [ #  # ]:          0 :                 if ((nic_cfg & NIC_SRAM_DATA_CFG_PHY_TYPE_MASK) ==
   15201                 :            :                     NIC_SRAM_DATA_CFG_PHY_TYPE_FIBER)
   15202                 :          0 :                         eeprom_phy_serdes = 1;
   15203                 :            : 
   15204                 :          0 :                 tg3_read_mem(tp, NIC_SRAM_DATA_PHY_ID, &nic_phy_id);
   15205         [ #  # ]:          0 :                 if (nic_phy_id != 0) {
   15206                 :          0 :                         u32 id1 = nic_phy_id & NIC_SRAM_DATA_PHY_ID1_MASK;
   15207                 :          0 :                         u32 id2 = nic_phy_id & NIC_SRAM_DATA_PHY_ID2_MASK;
   15208                 :            : 
   15209                 :          0 :                         eeprom_phy_id  = (id1 >> 16) << 10;
   15210                 :          0 :                         eeprom_phy_id |= (id2 & 0xfc00) << 16;
   15211                 :          0 :                         eeprom_phy_id |= (id2 & 0x03ff) <<  0;
   15212                 :            :                 } else
   15213                 :            :                         eeprom_phy_id = 0;
   15214                 :            : 
   15215                 :          0 :                 tp->phy_id = eeprom_phy_id;
   15216         [ #  # ]:          0 :                 if (eeprom_phy_serdes) {
   15217         [ #  # ]:          0 :                         if (!tg3_flag(tp, 5705_PLUS))
   15218                 :          0 :                                 tp->phy_flags |= TG3_PHYFLG_PHY_SERDES;
   15219                 :            :                         else
   15220                 :          0 :                                 tp->phy_flags |= TG3_PHYFLG_MII_SERDES;
   15221                 :            :                 }
   15222                 :            : 
   15223         [ #  # ]:          0 :                 if (tg3_flag(tp, 5750_PLUS))
   15224                 :          0 :                         led_cfg = cfg2 & (NIC_SRAM_DATA_CFG_LED_MODE_MASK |
   15225                 :            :                                     SHASTA_EXT_LED_MODE_MASK);
   15226                 :            :                 else
   15227                 :          0 :                         led_cfg = nic_cfg & NIC_SRAM_DATA_CFG_LED_MODE_MASK;
   15228                 :            : 
   15229   [ #  #  #  #  :          0 :                 switch (led_cfg) {
                   #  # ]
   15230                 :          0 :                 default:
   15231                 :            :                 case NIC_SRAM_DATA_CFG_LED_MODE_PHY_1:
   15232                 :          0 :                         tp->led_ctrl = LED_CTRL_MODE_PHY_1;
   15233                 :          0 :                         break;
   15234                 :            : 
   15235                 :          0 :                 case NIC_SRAM_DATA_CFG_LED_MODE_PHY_2:
   15236                 :          0 :                         tp->led_ctrl = LED_CTRL_MODE_PHY_2;
   15237                 :          0 :                         break;
   15238                 :            : 
   15239                 :          0 :                 case NIC_SRAM_DATA_CFG_LED_MODE_MAC:
   15240                 :          0 :                         tp->led_ctrl = LED_CTRL_MODE_MAC;
   15241                 :            : 
   15242                 :            :                         /* Default to PHY_1_MODE if 0 (MAC_MODE) is
   15243                 :            :                          * read on some older 5700/5701 bootcode.
   15244                 :            :                          */
   15245         [ #  # ]:          0 :                         if (tg3_asic_rev(tp) == ASIC_REV_5700 ||
   15246                 :            :                             tg3_asic_rev(tp) == ASIC_REV_5701)
   15247                 :          0 :                                 tp->led_ctrl = LED_CTRL_MODE_PHY_1;
   15248                 :            : 
   15249                 :            :                         break;
   15250                 :            : 
   15251                 :          0 :                 case SHASTA_EXT_LED_SHARED:
   15252                 :          0 :                         tp->led_ctrl = LED_CTRL_MODE_SHARED;
   15253         [ #  # ]:          0 :                         if (tg3_chip_rev_id(tp) != CHIPREV_ID_5750_A0 &&
   15254                 :            :                             tg3_chip_rev_id(tp) != CHIPREV_ID_5750_A1)
   15255                 :          0 :                                 tp->led_ctrl |= (LED_CTRL_MODE_PHY_1 |
   15256                 :            :                                                  LED_CTRL_MODE_PHY_2);
   15257                 :            : 
   15258         [ #  # ]:          0 :                         if (tg3_flag(tp, 5717_PLUS) ||
   15259         [ #  # ]:          0 :                             tg3_asic_rev(tp) == ASIC_REV_5762)
   15260                 :          0 :                                 tp->led_ctrl |= LED_CTRL_BLINK_RATE_OVERRIDE |
   15261                 :            :                                                 LED_CTRL_BLINK_RATE_MASK;
   15262                 :            : 
   15263                 :            :                         break;
   15264                 :            : 
   15265                 :          0 :                 case SHASTA_EXT_LED_MAC:
   15266                 :          0 :                         tp->led_ctrl = LED_CTRL_MODE_SHASTA_MAC;
   15267                 :          0 :                         break;
   15268                 :            : 
   15269                 :          0 :                 case SHASTA_EXT_LED_COMBO:
   15270                 :          0 :                         tp->led_ctrl = LED_CTRL_MODE_COMBO;
   15271         [ #  # ]:          0 :                         if (tg3_chip_rev_id(tp) != CHIPREV_ID_5750_A0)
   15272                 :          0 :                                 tp->led_ctrl |= (LED_CTRL_MODE_PHY_1 |
   15273                 :            :                                                  LED_CTRL_MODE_PHY_2);
   15274                 :            :                         break;
   15275                 :            : 
   15276                 :            :                 }
   15277                 :            : 
   15278         [ #  # ]:          0 :                 if ((tg3_asic_rev(tp) == ASIC_REV_5700 ||
   15279                 :          0 :                      tg3_asic_rev(tp) == ASIC_REV_5701) &&
   15280         [ #  # ]:          0 :                     tp->pdev->subsystem_vendor == PCI_VENDOR_ID_DELL)
   15281                 :          0 :                         tp->led_ctrl = LED_CTRL_MODE_PHY_2;
   15282                 :            : 
   15283         [ #  # ]:          0 :                 if (tg3_chip_rev(tp) == CHIPREV_5784_AX)
   15284                 :          0 :                         tp->led_ctrl = LED_CTRL_MODE_PHY_1;
   15285                 :            : 
   15286         [ #  # ]:          0 :                 if (nic_cfg & NIC_SRAM_DATA_CFG_EEPROM_WP) {
   15287                 :          0 :                         tg3_flag_set(tp, EEPROM_WRITE_PROT);
   15288         [ #  # ]:          0 :                         if ((tp->pdev->subsystem_vendor ==
   15289                 :          0 :                              PCI_VENDOR_ID_ARIMA) &&
   15290         [ #  # ]:          0 :                             (tp->pdev->subsystem_device == 0x205a ||
   15291                 :            :                              tp->pdev->subsystem_device == 0x2063))
   15292                 :          0 :                                 tg3_flag_clear(tp, EEPROM_WRITE_PROT);
   15293                 :            :                 } else {
   15294                 :          0 :                         tg3_flag_clear(tp, EEPROM_WRITE_PROT);
   15295                 :          0 :                         tg3_flag_set(tp, IS_NIC);
   15296                 :            :                 }
   15297                 :            : 
   15298         [ #  # ]:          0 :                 if (nic_cfg & NIC_SRAM_DATA_CFG_ASF_ENABLE) {
   15299                 :          0 :                         tg3_flag_set(tp, ENABLE_ASF);
   15300         [ #  # ]:          0 :                         if (tg3_flag(tp, 5750_PLUS))
   15301                 :          0 :                                 tg3_flag_set(tp, ASF_NEW_HANDSHAKE);
   15302                 :            :                 }
   15303                 :            : 
   15304   [ #  #  #  # ]:          0 :                 if ((nic_cfg & NIC_SRAM_DATA_CFG_APE_ENABLE) &&
   15305                 :            :                     tg3_flag(tp, 5750_PLUS))
   15306                 :          0 :                         tg3_flag_set(tp, ENABLE_APE);
   15307                 :            : 
   15308         [ #  # ]:          0 :                 if (tp->phy_flags & TG3_PHYFLG_ANY_SERDES &&
   15309         [ #  # ]:          0 :                     !(nic_cfg & NIC_SRAM_DATA_CFG_FIBER_WOL))
   15310                 :          0 :                         tg3_flag_clear(tp, WOL_CAP);
   15311                 :            : 
   15312         [ #  # ]:          0 :                 if (tg3_flag(tp, WOL_CAP) &&
   15313         [ #  # ]:          0 :                     (nic_cfg & NIC_SRAM_DATA_CFG_WOL_ENABLE)) {
   15314                 :          0 :                         tg3_flag_set(tp, WOL_ENABLE);
   15315                 :          0 :                         device_set_wakeup_enable(&tp->pdev->dev, true);
   15316                 :            :                 }
   15317                 :            : 
   15318         [ #  # ]:          0 :                 if (cfg2 & (1 << 17))
   15319                 :          0 :                         tp->phy_flags |= TG3_PHYFLG_CAPACITIVE_COUPLING;
   15320                 :            : 
   15321                 :            :                 /* serdes signal pre-emphasis in register 0x590 set by */
   15322                 :            :                 /* bootcode if bit 18 is set */
   15323         [ #  # ]:          0 :                 if (cfg2 & (1 << 18))
   15324                 :          0 :                         tp->phy_flags |= TG3_PHYFLG_SERDES_PREEMPHASIS;
   15325                 :            : 
   15326         [ #  # ]:          0 :                 if ((tg3_flag(tp, 57765_PLUS) ||
   15327         [ #  # ]:          0 :                      (tg3_asic_rev(tp) == ASIC_REV_5784 &&
   15328         [ #  # ]:          0 :                       tg3_chip_rev(tp) != CHIPREV_5784_AX)) &&
   15329         [ #  # ]:          0 :                     (cfg2 & NIC_SRAM_DATA_CFG_2_APD_EN))
   15330                 :          0 :                         tp->phy_flags |= TG3_PHYFLG_ENABLE_APD;
   15331                 :            : 
   15332         [ #  # ]:          0 :                 if (tg3_flag(tp, PCI_EXPRESS)) {
   15333                 :          0 :                         u32 cfg3;
   15334                 :            : 
   15335                 :          0 :                         tg3_read_mem(tp, NIC_SRAM_DATA_CFG_3, &cfg3);
   15336   [ #  #  #  # ]:          0 :                         if (tg3_asic_rev(tp) != ASIC_REV_5785 &&
   15337                 :          0 :                             !tg3_flag(tp, 57765_PLUS) &&
   15338         [ #  # ]:          0 :                             (cfg3 & NIC_SRAM_ASPM_DEBOUNCE))
   15339                 :          0 :                                 tg3_flag_set(tp, ASPM_WORKAROUND);
   15340         [ #  # ]:          0 :                         if (cfg3 & NIC_SRAM_LNK_FLAP_AVOID)
   15341                 :          0 :                                 tp->phy_flags |= TG3_PHYFLG_KEEP_LINK_ON_PWRDN;
   15342         [ #  # ]:          0 :                         if (cfg3 & NIC_SRAM_1G_ON_VAUX_OK)
   15343                 :          0 :                                 tp->phy_flags |= TG3_PHYFLG_1G_ON_VAUX_OK;
   15344                 :            :                 }
   15345                 :            : 
   15346         [ #  # ]:          0 :                 if (cfg4 & NIC_SRAM_RGMII_INBAND_DISABLE)
   15347                 :          0 :                         tg3_flag_set(tp, RGMII_INBAND_DISABLE);
   15348         [ #  # ]:          0 :                 if (cfg4 & NIC_SRAM_RGMII_EXT_IBND_RX_EN)
   15349                 :          0 :                         tg3_flag_set(tp, RGMII_EXT_IBND_RX_EN);
   15350         [ #  # ]:          0 :                 if (cfg4 & NIC_SRAM_RGMII_EXT_IBND_TX_EN)
   15351                 :          0 :                         tg3_flag_set(tp, RGMII_EXT_IBND_TX_EN);
   15352                 :            : 
   15353         [ #  # ]:          0 :                 if (cfg5 & NIC_SRAM_DISABLE_1G_HALF_ADV)
   15354                 :          0 :                         tp->phy_flags |= TG3_PHYFLG_DISABLE_1G_HD_ADV;
   15355                 :            :         }
   15356                 :          0 : done:
   15357         [ #  # ]:          0 :         if (tg3_flag(tp, WOL_CAP))
   15358                 :          0 :                 device_set_wakeup_enable(&tp->pdev->dev,
   15359                 :            :                                          tg3_flag(tp, WOL_ENABLE));
   15360                 :            :         else
   15361                 :          0 :                 device_set_wakeup_capable(&tp->pdev->dev, false);
   15362                 :          0 : }
   15363                 :            : 
   15364                 :          0 : static int tg3_ape_otp_read(struct tg3 *tp, u32 offset, u32 *val)
   15365                 :            : {
   15366                 :          0 :         int i, err;
   15367                 :          0 :         u32 val2, off = offset * 8;
   15368                 :            : 
   15369                 :          0 :         err = tg3_nvram_lock(tp);
   15370         [ #  # ]:          0 :         if (err)
   15371                 :            :                 return err;
   15372                 :            : 
   15373                 :          0 :         tg3_ape_write32(tp, TG3_APE_OTP_ADDR, off | APE_OTP_ADDR_CPU_ENABLE);
   15374                 :          0 :         tg3_ape_write32(tp, TG3_APE_OTP_CTRL, APE_OTP_CTRL_PROG_EN |
   15375                 :            :                         APE_OTP_CTRL_CMD_RD | APE_OTP_CTRL_START);
   15376                 :          0 :         tg3_ape_read32(tp, TG3_APE_OTP_CTRL);
   15377                 :          0 :         udelay(10);
   15378                 :            : 
   15379         [ #  # ]:          0 :         for (i = 0; i < 100; i++) {
   15380                 :          0 :                 val2 = tg3_ape_read32(tp, TG3_APE_OTP_STATUS);
   15381         [ #  # ]:          0 :                 if (val2 & APE_OTP_STATUS_CMD_DONE) {
   15382                 :          0 :                         *val = tg3_ape_read32(tp, TG3_APE_OTP_RD_DATA);
   15383                 :          0 :                         break;
   15384                 :            :                 }
   15385                 :          0 :                 udelay(10);
   15386                 :            :         }
   15387                 :            : 
   15388                 :          0 :         tg3_ape_write32(tp, TG3_APE_OTP_CTRL, 0);
   15389                 :            : 
   15390                 :          0 :         tg3_nvram_unlock(tp);
   15391         [ #  # ]:          0 :         if (val2 & APE_OTP_STATUS_CMD_DONE)
   15392                 :          0 :                 return 0;
   15393                 :            : 
   15394                 :            :         return -EBUSY;
   15395                 :            : }
   15396                 :            : 
   15397                 :          0 : static int tg3_issue_otp_command(struct tg3 *tp, u32 cmd)
   15398                 :            : {
   15399                 :          0 :         int i;
   15400                 :          0 :         u32 val;
   15401                 :            : 
   15402                 :          0 :         tw32(OTP_CTRL, cmd | OTP_CTRL_OTP_CMD_START);
   15403                 :          0 :         tw32(OTP_CTRL, cmd);
   15404                 :            : 
   15405                 :            :         /* Wait for up to 1 ms for command to execute. */
   15406         [ #  # ]:          0 :         for (i = 0; i < 100; i++) {
   15407                 :          0 :                 val = tr32(OTP_STATUS);
   15408         [ #  # ]:          0 :                 if (val & OTP_STATUS_CMD_DONE)
   15409                 :            :                         break;
   15410                 :          0 :                 udelay(10);
   15411                 :            :         }
   15412                 :            : 
   15413         [ #  # ]:          0 :         return (val & OTP_STATUS_CMD_DONE) ? 0 : -EBUSY;
   15414                 :            : }
   15415                 :            : 
   15416                 :            : /* Read the gphy configuration from the OTP region of the chip.  The gphy
   15417                 :            :  * configuration is a 32-bit value that straddles the alignment boundary.
   15418                 :            :  * We do two 32-bit reads and then shift and merge the results.
   15419                 :            :  */
   15420                 :          0 : static u32 tg3_read_otp_phycfg(struct tg3 *tp)
   15421                 :            : {
   15422                 :          0 :         u32 bhalf_otp, thalf_otp;
   15423                 :            : 
   15424                 :          0 :         tw32(OTP_MODE, OTP_MODE_OTP_THRU_GRC);
   15425                 :            : 
   15426         [ #  # ]:          0 :         if (tg3_issue_otp_command(tp, OTP_CTRL_OTP_CMD_INIT))
   15427                 :            :                 return 0;
   15428                 :            : 
   15429                 :          0 :         tw32(OTP_ADDRESS, OTP_ADDRESS_MAGIC1);
   15430                 :            : 
   15431         [ #  # ]:          0 :         if (tg3_issue_otp_command(tp, OTP_CTRL_OTP_CMD_READ))
   15432                 :            :                 return 0;
   15433                 :            : 
   15434                 :          0 :         thalf_otp = tr32(OTP_READ_DATA);
   15435                 :            : 
   15436                 :          0 :         tw32(OTP_ADDRESS, OTP_ADDRESS_MAGIC2);
   15437                 :            : 
   15438         [ #  # ]:          0 :         if (tg3_issue_otp_command(tp, OTP_CTRL_OTP_CMD_READ))
   15439                 :            :                 return 0;
   15440                 :            : 
   15441                 :          0 :         bhalf_otp = tr32(OTP_READ_DATA);
   15442                 :            : 
   15443                 :          0 :         return ((thalf_otp & 0x0000ffff) << 16) | (bhalf_otp >> 16);
   15444                 :            : }
   15445                 :            : 
   15446                 :          0 : static void tg3_phy_init_link_config(struct tg3 *tp)
   15447                 :            : {
   15448                 :          0 :         u32 adv = ADVERTISED_Autoneg;
   15449                 :            : 
   15450                 :          0 :         if (!(tp->phy_flags & TG3_PHYFLG_10_100_ONLY)) {
   15451         [ #  # ]:          0 :                 if (!(tp->phy_flags & TG3_PHYFLG_DISABLE_1G_HD_ADV))
   15452                 :          0 :                         adv |= ADVERTISED_1000baseT_Half;
   15453                 :          0 :                 adv |= ADVERTISED_1000baseT_Full;
   15454                 :            :         }
   15455                 :            : 
   15456         [ #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_ANY_SERDES))
   15457                 :          0 :                 adv |= ADVERTISED_100baseT_Half |
   15458                 :            :                        ADVERTISED_100baseT_Full |
   15459                 :            :                        ADVERTISED_10baseT_Half |
   15460                 :            :                        ADVERTISED_10baseT_Full |
   15461                 :            :                        ADVERTISED_TP;
   15462                 :            :         else
   15463                 :          0 :                 adv |= ADVERTISED_FIBRE;
   15464                 :            : 
   15465                 :          0 :         tp->link_config.advertising = adv;
   15466                 :          0 :         tp->link_config.speed = SPEED_UNKNOWN;
   15467                 :          0 :         tp->link_config.duplex = DUPLEX_UNKNOWN;
   15468                 :          0 :         tp->link_config.autoneg = AUTONEG_ENABLE;
   15469                 :          0 :         tp->link_config.active_speed = SPEED_UNKNOWN;
   15470                 :          0 :         tp->link_config.active_duplex = DUPLEX_UNKNOWN;
   15471                 :            : 
   15472                 :          0 :         tp->old_link = -1;
   15473                 :            : }
   15474                 :            : 
   15475                 :          0 : static int tg3_phy_probe(struct tg3 *tp)
   15476                 :            : {
   15477                 :          0 :         u32 hw_phy_id_1, hw_phy_id_2;
   15478                 :          0 :         u32 hw_phy_id, hw_phy_id_masked;
   15479                 :          0 :         int err;
   15480                 :            : 
   15481                 :            :         /* flow control autonegotiation is default behavior */
   15482                 :          0 :         tg3_flag_set(tp, PAUSE_AUTONEG);
   15483                 :          0 :         tp->link_config.flowctrl = FLOW_CTRL_TX | FLOW_CTRL_RX;
   15484                 :            : 
   15485         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_APE)) {
   15486   [ #  #  #  #  :          0 :                 switch (tp->pci_fn) {
                      # ]
   15487                 :          0 :                 case 0:
   15488                 :          0 :                         tp->phy_ape_lock = TG3_APE_LOCK_PHY0;
   15489                 :          0 :                         break;
   15490                 :          0 :                 case 1:
   15491                 :          0 :                         tp->phy_ape_lock = TG3_APE_LOCK_PHY1;
   15492                 :          0 :                         break;
   15493                 :          0 :                 case 2:
   15494                 :          0 :                         tp->phy_ape_lock = TG3_APE_LOCK_PHY2;
   15495                 :          0 :                         break;
   15496                 :          0 :                 case 3:
   15497                 :          0 :                         tp->phy_ape_lock = TG3_APE_LOCK_PHY3;
   15498                 :          0 :                         break;
   15499                 :            :                 }
   15500                 :          0 :         }
   15501                 :            : 
   15502         [ #  # ]:          0 :         if (!tg3_flag(tp, ENABLE_ASF) &&
   15503         [ #  # ]:          0 :             !(tp->phy_flags & TG3_PHYFLG_ANY_SERDES) &&
   15504                 :            :             !(tp->phy_flags & TG3_PHYFLG_10_100_ONLY))
   15505                 :          0 :                 tp->phy_flags &= ~(TG3_PHYFLG_1G_ON_VAUX_OK |
   15506                 :            :                                    TG3_PHYFLG_KEEP_LINK_ON_PWRDN);
   15507                 :            : 
   15508         [ #  # ]:          0 :         if (tg3_flag(tp, USE_PHYLIB))
   15509                 :          0 :                 return tg3_phy_init(tp);
   15510                 :            : 
   15511                 :            :         /* Reading the PHY ID register can conflict with ASF
   15512                 :            :          * firmware access to the PHY hardware.
   15513                 :            :          */
   15514                 :          0 :         err = 0;
   15515   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, ENABLE_ASF) || tg3_flag(tp, ENABLE_APE)) {
   15516                 :            :                 hw_phy_id = hw_phy_id_masked = TG3_PHY_ID_INVALID;
   15517                 :            :         } else {
   15518                 :            :                 /* Now read the physical PHY_ID from the chip and verify
   15519                 :            :                  * that it is sane.  If it doesn't look good, we fall back
   15520                 :            :                  * to either the hard-coded table based PHY_ID and failing
   15521                 :            :                  * that the value found in the eeprom area.
   15522                 :            :                  */
   15523                 :          0 :                 err |= tg3_readphy(tp, MII_PHYSID1, &hw_phy_id_1);
   15524                 :          0 :                 err |= tg3_readphy(tp, MII_PHYSID2, &hw_phy_id_2);
   15525                 :            : 
   15526                 :          0 :                 hw_phy_id  = (hw_phy_id_1 & 0xffff) << 10;
   15527                 :          0 :                 hw_phy_id |= (hw_phy_id_2 & 0xfc00) << 16;
   15528                 :          0 :                 hw_phy_id |= (hw_phy_id_2 & 0x03ff) <<  0;
   15529                 :            : 
   15530                 :          0 :                 hw_phy_id_masked = hw_phy_id & TG3_PHY_ID_MASK;
   15531                 :            :         }
   15532                 :            : 
   15533   [ #  #  #  #  :          0 :         if (!err && TG3_KNOWN_PHY_ID(hw_phy_id_masked)) {
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
   15534                 :          0 :                 tp->phy_id = hw_phy_id;
   15535         [ #  # ]:          0 :                 if (hw_phy_id_masked == TG3_PHY_ID_BCM8002)
   15536                 :          0 :                         tp->phy_flags |= TG3_PHYFLG_PHY_SERDES;
   15537                 :            :                 else
   15538                 :          0 :                         tp->phy_flags &= ~TG3_PHYFLG_PHY_SERDES;
   15539                 :            :         } else {
   15540         [ #  # ]:          0 :                 if (tp->phy_id != TG3_PHY_ID_INVALID) {
   15541                 :            :                         /* Do nothing, phy ID already set up in
   15542                 :            :                          * tg3_get_eeprom_hw_cfg().
   15543                 :            :                          */
   15544                 :            :                 } else {
   15545                 :            :                         struct subsys_tbl_ent *p;
   15546                 :            : 
   15547                 :            :                         /* No eeprom signature?  Try the hardcoded
   15548                 :            :                          * subsys device table.
   15549                 :            :                          */
   15550                 :            :                         p = tg3_lookup_by_subsys(tp);
   15551         [ #  # ]:          0 :                         if (p) {
   15552                 :          0 :                                 tp->phy_id = p->phy_id;
   15553         [ #  # ]:          0 :                         } else if (!tg3_flag(tp, IS_SSB_CORE)) {
   15554                 :            :                                 /* For now we saw the IDs 0xbc050cd0,
   15555                 :            :                                  * 0xbc050f80 and 0xbc050c30 on devices
   15556                 :            :                                  * connected to an BCM4785 and there are
   15557                 :            :                                  * probably more. Just assume that the phy is
   15558                 :            :                                  * supported when it is connected to a SSB core
   15559                 :            :                                  * for now.
   15560                 :            :                                  */
   15561                 :            :                                 return -ENODEV;
   15562                 :            :                         }
   15563                 :            : 
   15564         [ #  # ]:          0 :                         if (!tp->phy_id ||
   15565                 :            :                             tp->phy_id == TG3_PHY_ID_BCM8002)
   15566                 :          0 :                                 tp->phy_flags |= TG3_PHYFLG_PHY_SERDES;
   15567                 :            :                 }
   15568                 :            :         }
   15569                 :            : 
   15570         [ #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_ANY_SERDES) &&
   15571         [ #  # ]:          0 :             (tg3_asic_rev(tp) == ASIC_REV_5719 ||
   15572         [ #  # ]:          0 :              tg3_asic_rev(tp) == ASIC_REV_5720 ||
   15573         [ #  # ]:          0 :              tg3_asic_rev(tp) == ASIC_REV_57766 ||
   15574         [ #  # ]:          0 :              tg3_asic_rev(tp) == ASIC_REV_5762 ||
   15575         [ #  # ]:          0 :              (tg3_asic_rev(tp) == ASIC_REV_5717 &&
   15576         [ #  # ]:          0 :               tg3_chip_rev_id(tp) != CHIPREV_ID_5717_A0) ||
   15577         [ #  # ]:          0 :              (tg3_asic_rev(tp) == ASIC_REV_57765 &&
   15578                 :            :               tg3_chip_rev_id(tp) != CHIPREV_ID_57765_A0))) {
   15579                 :          0 :                 tp->phy_flags |= TG3_PHYFLG_EEE_CAP;
   15580                 :            : 
   15581                 :          0 :                 tp->eee.supported = SUPPORTED_100baseT_Full |
   15582                 :            :                                     SUPPORTED_1000baseT_Full;
   15583                 :          0 :                 tp->eee.advertised = ADVERTISED_100baseT_Full |
   15584                 :            :                                      ADVERTISED_1000baseT_Full;
   15585                 :          0 :                 tp->eee.eee_enabled = 1;
   15586                 :          0 :                 tp->eee.tx_lpi_enabled = 1;
   15587                 :          0 :                 tp->eee.tx_lpi_timer = TG3_CPMU_DBTMR1_LNKIDLE_2047US;
   15588                 :            :         }
   15589                 :            : 
   15590         [ #  # ]:          0 :         tg3_phy_init_link_config(tp);
   15591                 :            : 
   15592         [ #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_KEEP_LINK_ON_PWRDN) &&
   15593         [ #  # ]:          0 :             !(tp->phy_flags & TG3_PHYFLG_ANY_SERDES) &&
   15594         [ #  # ]:          0 :             !tg3_flag(tp, ENABLE_APE) &&
   15595                 :            :             !tg3_flag(tp, ENABLE_ASF)) {
   15596                 :          0 :                 u32 bmsr, dummy;
   15597                 :            : 
   15598                 :          0 :                 tg3_readphy(tp, MII_BMSR, &bmsr);
   15599         [ #  # ]:          0 :                 if (!tg3_readphy(tp, MII_BMSR, &bmsr) &&
   15600         [ #  # ]:          0 :                     (bmsr & BMSR_LSTATUS))
   15601                 :          0 :                         goto skip_phy_reset;
   15602                 :            : 
   15603                 :          0 :                 err = tg3_phy_reset(tp);
   15604         [ #  # ]:          0 :                 if (err)
   15605                 :          0 :                         return err;
   15606                 :            : 
   15607                 :          0 :                 tg3_phy_set_wirespeed(tp);
   15608                 :            : 
   15609         [ #  # ]:          0 :                 if (!tg3_phy_copper_an_config_ok(tp, &dummy)) {
   15610                 :          0 :                         tg3_phy_autoneg_cfg(tp, tp->link_config.advertising,
   15611                 :          0 :                                             tp->link_config.flowctrl);
   15612                 :            : 
   15613                 :          0 :                         tg3_writephy(tp, MII_BMCR,
   15614                 :            :                                      BMCR_ANENABLE | BMCR_ANRESTART);
   15615                 :            :                 }
   15616                 :            :         }
   15617                 :            : 
   15618                 :          0 : skip_phy_reset:
   15619         [ #  # ]:          0 :         if ((tp->phy_id & TG3_PHY_ID_MASK) == TG3_PHY_ID_BCM5401) {
   15620                 :          0 :                 err = tg3_init_5401phy_dsp(tp);
   15621         [ #  # ]:          0 :                 if (err)
   15622                 :            :                         return err;
   15623                 :            : 
   15624                 :          0 :                 err = tg3_init_5401phy_dsp(tp);
   15625                 :            :         }
   15626                 :            : 
   15627                 :            :         return err;
   15628                 :            : }
   15629                 :            : 
   15630                 :          0 : static void tg3_read_vpd(struct tg3 *tp)
   15631                 :            : {
   15632                 :          0 :         u8 *vpd_data;
   15633                 :          0 :         unsigned int block_end, rosize, len;
   15634                 :          0 :         u32 vpdlen;
   15635                 :          0 :         int j, i = 0;
   15636                 :            : 
   15637                 :          0 :         vpd_data = (u8 *)tg3_vpd_readblock(tp, &vpdlen);
   15638         [ #  # ]:          0 :         if (!vpd_data)
   15639                 :          0 :                 goto out_no_vpd;
   15640                 :            : 
   15641                 :          0 :         i = pci_vpd_find_tag(vpd_data, 0, vpdlen, PCI_VPD_LRDT_RO_DATA);
   15642         [ #  # ]:          0 :         if (i < 0)
   15643                 :          0 :                 goto out_not_found;
   15644                 :            : 
   15645         [ #  # ]:          0 :         rosize = pci_vpd_lrdt_size(&vpd_data[i]);
   15646                 :          0 :         block_end = i + PCI_VPD_LRDT_TAG_SIZE + rosize;
   15647                 :          0 :         i += PCI_VPD_LRDT_TAG_SIZE;
   15648                 :            : 
   15649         [ #  # ]:          0 :         if (block_end > vpdlen)
   15650                 :          0 :                 goto out_not_found;
   15651                 :            : 
   15652                 :          0 :         j = pci_vpd_find_info_keyword(vpd_data, i, rosize,
   15653                 :            :                                       PCI_VPD_RO_KEYWORD_MFR_ID);
   15654         [ #  # ]:          0 :         if (j > 0) {
   15655         [ #  # ]:          0 :                 len = pci_vpd_info_field_size(&vpd_data[j]);
   15656                 :            : 
   15657                 :          0 :                 j += PCI_VPD_INFO_FLD_HDR_SIZE;
   15658   [ #  #  #  # ]:          0 :                 if (j + len > block_end || len != 4 ||
   15659         [ #  # ]:          0 :                     memcmp(&vpd_data[j], "1028", 4))
   15660                 :          0 :                         goto partno;
   15661                 :            : 
   15662                 :          0 :                 j = pci_vpd_find_info_keyword(vpd_data, i, rosize,
   15663                 :            :                                               PCI_VPD_RO_KEYWORD_VENDOR0);
   15664         [ #  # ]:          0 :                 if (j < 0)
   15665                 :          0 :                         goto partno;
   15666                 :            : 
   15667         [ #  # ]:          0 :                 len = pci_vpd_info_field_size(&vpd_data[j]);
   15668                 :            : 
   15669                 :          0 :                 j += PCI_VPD_INFO_FLD_HDR_SIZE;
   15670         [ #  # ]:          0 :                 if (j + len > block_end)
   15671                 :          0 :                         goto partno;
   15672                 :            : 
   15673                 :          0 :                 if (len >= sizeof(tp->fw_ver))
   15674                 :            :                         len = sizeof(tp->fw_ver) - 1;
   15675                 :          0 :                 memset(tp->fw_ver, 0, sizeof(tp->fw_ver));
   15676                 :          0 :                 snprintf(tp->fw_ver, sizeof(tp->fw_ver), "%.*s bc ", len,
   15677                 :            :                          &vpd_data[j]);
   15678                 :            :         }
   15679                 :            : 
   15680                 :          0 : partno:
   15681                 :          0 :         i = pci_vpd_find_info_keyword(vpd_data, i, rosize,
   15682                 :            :                                       PCI_VPD_RO_KEYWORD_PARTNO);
   15683         [ #  # ]:          0 :         if (i < 0)
   15684                 :          0 :                 goto out_not_found;
   15685                 :            : 
   15686         [ #  # ]:          0 :         len = pci_vpd_info_field_size(&vpd_data[i]);
   15687                 :            : 
   15688                 :          0 :         i += PCI_VPD_INFO_FLD_HDR_SIZE;
   15689         [ #  # ]:          0 :         if (len > TG3_BPN_SIZE ||
   15690         [ #  # ]:          0 :             (len + i) > vpdlen)
   15691                 :          0 :                 goto out_not_found;
   15692                 :            : 
   15693                 :          0 :         memcpy(tp->board_part_number, &vpd_data[i], len);
   15694                 :            : 
   15695                 :          0 : out_not_found:
   15696                 :          0 :         kfree(vpd_data);
   15697         [ #  # ]:          0 :         if (tp->board_part_number[0])
   15698                 :          0 :                 return;
   15699                 :            : 
   15700                 :          0 : out_no_vpd:
   15701         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5717) {
   15702         [ #  # ]:          0 :                 if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_5717 ||
   15703                 :            :                     tp->pdev->device == TG3PCI_DEVICE_TIGON3_5717_C)
   15704                 :          0 :                         strcpy(tp->board_part_number, "BCM5717");
   15705         [ #  # ]:          0 :                 else if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_5718)
   15706                 :          0 :                         strcpy(tp->board_part_number, "BCM5718");
   15707                 :            :                 else
   15708                 :          0 :                         goto nomatch;
   15709         [ #  # ]:          0 :         } else if (tg3_asic_rev(tp) == ASIC_REV_57780) {
   15710         [ #  # ]:          0 :                 if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_57780)
   15711                 :          0 :                         strcpy(tp->board_part_number, "BCM57780");
   15712         [ #  # ]:          0 :                 else if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_57760)
   15713                 :          0 :                         strcpy(tp->board_part_number, "BCM57760");
   15714         [ #  # ]:          0 :                 else if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_57790)
   15715                 :          0 :                         strcpy(tp->board_part_number, "BCM57790");
   15716         [ #  # ]:          0 :                 else if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_57788)
   15717                 :          0 :                         strcpy(tp->board_part_number, "BCM57788");
   15718                 :            :                 else
   15719                 :          0 :                         goto nomatch;
   15720         [ #  # ]:          0 :         } else if (tg3_asic_rev(tp) == ASIC_REV_57765) {
   15721         [ #  # ]:          0 :                 if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_57761)
   15722                 :          0 :                         strcpy(tp->board_part_number, "BCM57761");
   15723         [ #  # ]:          0 :                 else if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_57765)
   15724                 :          0 :                         strcpy(tp->board_part_number, "BCM57765");
   15725         [ #  # ]:          0 :                 else if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_57781)
   15726                 :          0 :                         strcpy(tp->board_part_number, "BCM57781");
   15727         [ #  # ]:          0 :                 else if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_57785)
   15728                 :          0 :                         strcpy(tp->board_part_number, "BCM57785");
   15729         [ #  # ]:          0 :                 else if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_57791)
   15730                 :          0 :                         strcpy(tp->board_part_number, "BCM57791");
   15731         [ #  # ]:          0 :                 else if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_57795)
   15732                 :          0 :                         strcpy(tp->board_part_number, "BCM57795");
   15733                 :            :                 else
   15734                 :          0 :                         goto nomatch;
   15735         [ #  # ]:          0 :         } else if (tg3_asic_rev(tp) == ASIC_REV_57766) {
   15736         [ #  # ]:          0 :                 if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_57762)
   15737                 :          0 :                         strcpy(tp->board_part_number, "BCM57762");
   15738         [ #  # ]:          0 :                 else if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_57766)
   15739                 :          0 :                         strcpy(tp->board_part_number, "BCM57766");
   15740         [ #  # ]:          0 :                 else if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_57782)
   15741                 :          0 :                         strcpy(tp->board_part_number, "BCM57782");
   15742         [ #  # ]:          0 :                 else if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_57786)
   15743                 :          0 :                         strcpy(tp->board_part_number, "BCM57786");
   15744                 :            :                 else
   15745                 :          0 :                         goto nomatch;
   15746         [ #  # ]:          0 :         } else if (tg3_asic_rev(tp) == ASIC_REV_5906) {
   15747                 :          0 :                 strcpy(tp->board_part_number, "BCM95906");
   15748                 :            :         } else {
   15749                 :          0 : nomatch:
   15750                 :          0 :                 strcpy(tp->board_part_number, "none");
   15751                 :            :         }
   15752                 :            : }
   15753                 :            : 
   15754                 :          0 : static int tg3_fw_img_is_valid(struct tg3 *tp, u32 offset)
   15755                 :            : {
   15756                 :          0 :         u32 val;
   15757                 :            : 
   15758         [ #  # ]:          0 :         if (tg3_nvram_read(tp, offset, &val) ||
   15759   [ #  #  #  # ]:          0 :             (val & 0xfc000000) != 0x0c000000 ||
   15760                 :          0 :             tg3_nvram_read(tp, offset + 4, &val) ||
   15761         [ #  # ]:          0 :             val != 0)
   15762                 :          0 :                 return 0;
   15763                 :            : 
   15764                 :            :         return 1;
   15765                 :            : }
   15766                 :            : 
   15767                 :          0 : static void tg3_read_bc_ver(struct tg3 *tp)
   15768                 :            : {
   15769                 :          0 :         u32 val, offset, start, ver_offset;
   15770                 :          0 :         int i, dst_off;
   15771                 :          0 :         bool newver = false;
   15772                 :            : 
   15773   [ #  #  #  # ]:          0 :         if (tg3_nvram_read(tp, 0xc, &offset) ||
   15774                 :          0 :             tg3_nvram_read(tp, 0x4, &start))
   15775                 :          0 :                 return;
   15776                 :            : 
   15777                 :          0 :         offset = tg3_nvram_logical_addr(tp, offset);
   15778                 :            : 
   15779         [ #  # ]:          0 :         if (tg3_nvram_read(tp, offset, &val))
   15780                 :            :                 return;
   15781                 :            : 
   15782         [ #  # ]:          0 :         if ((val & 0xfc000000) == 0x0c000000) {
   15783         [ #  # ]:          0 :                 if (tg3_nvram_read(tp, offset + 4, &val))
   15784                 :            :                         return;
   15785                 :            : 
   15786         [ #  # ]:          0 :                 if (val == 0)
   15787                 :          0 :                         newver = true;
   15788                 :            :         }
   15789                 :            : 
   15790                 :          0 :         dst_off = strlen(tp->fw_ver);
   15791                 :            : 
   15792         [ #  # ]:          0 :         if (newver) {
   15793   [ #  #  #  # ]:          0 :                 if (TG3_VER_SIZE - dst_off < 16 ||
   15794                 :          0 :                     tg3_nvram_read(tp, offset + 8, &ver_offset))
   15795                 :          0 :                         return;
   15796                 :            : 
   15797                 :          0 :                 offset = offset + ver_offset - start;
   15798         [ #  # ]:          0 :                 for (i = 0; i < 16; i += 4) {
   15799                 :          0 :                         __be32 v;
   15800         [ #  # ]:          0 :                         if (tg3_nvram_read_be32(tp, offset + i, &v))
   15801                 :            :                                 return;
   15802                 :            : 
   15803                 :          0 :                         memcpy(tp->fw_ver + dst_off + i, &v, sizeof(v));
   15804                 :            :                 }
   15805                 :            :         } else {
   15806                 :          0 :                 u32 major, minor;
   15807                 :            : 
   15808         [ #  # ]:          0 :                 if (tg3_nvram_read(tp, TG3_NVM_PTREV_BCVER, &ver_offset))
   15809                 :            :                         return;
   15810                 :            : 
   15811                 :          0 :                 major = (ver_offset & TG3_NVM_BCVER_MAJMSK) >>
   15812                 :            :                         TG3_NVM_BCVER_MAJSFT;
   15813                 :          0 :                 minor = ver_offset & TG3_NVM_BCVER_MINMSK;
   15814                 :          0 :                 snprintf(&tp->fw_ver[dst_off], TG3_VER_SIZE - dst_off,
   15815                 :            :                          "v%d.%02d", major, minor);
   15816                 :            :         }
   15817                 :            : }
   15818                 :            : 
   15819                 :          0 : static void tg3_read_hwsb_ver(struct tg3 *tp)
   15820                 :            : {
   15821                 :          0 :         u32 val, major, minor;
   15822                 :            : 
   15823                 :            :         /* Use native endian representation */
   15824         [ #  # ]:          0 :         if (tg3_nvram_read(tp, TG3_NVM_HWSB_CFG1, &val))
   15825                 :          0 :                 return;
   15826                 :            : 
   15827                 :          0 :         major = (val & TG3_NVM_HWSB_CFG1_MAJMSK) >>
   15828                 :            :                 TG3_NVM_HWSB_CFG1_MAJSFT;
   15829                 :          0 :         minor = (val & TG3_NVM_HWSB_CFG1_MINMSK) >>
   15830                 :            :                 TG3_NVM_HWSB_CFG1_MINSFT;
   15831                 :            : 
   15832                 :          0 :         snprintf(&tp->fw_ver[0], 32, "sb v%d.%02d", major, minor);
   15833                 :            : }
   15834                 :            : 
   15835                 :          0 : static void tg3_read_sb_ver(struct tg3 *tp, u32 val)
   15836                 :            : {
   15837                 :          0 :         u32 offset, major, minor, build;
   15838                 :            : 
   15839                 :          0 :         strncat(tp->fw_ver, "sb", TG3_VER_SIZE - strlen(tp->fw_ver) - 1);
   15840                 :            : 
   15841         [ #  # ]:          0 :         if ((val & TG3_EEPROM_SB_FORMAT_MASK) != TG3_EEPROM_SB_FORMAT_1)
   15842                 :            :                 return;
   15843                 :            : 
   15844   [ #  #  #  #  :          0 :         switch (val & TG3_EEPROM_SB_REVISION_MASK) {
                #  #  # ]
   15845                 :            :         case TG3_EEPROM_SB_REVISION_0:
   15846                 :            :                 offset = TG3_EEPROM_SB_F1R0_EDH_OFF;
   15847                 :            :                 break;
   15848                 :          0 :         case TG3_EEPROM_SB_REVISION_2:
   15849                 :          0 :                 offset = TG3_EEPROM_SB_F1R2_EDH_OFF;
   15850                 :          0 :                 break;
   15851                 :          0 :         case TG3_EEPROM_SB_REVISION_3:
   15852                 :          0 :                 offset = TG3_EEPROM_SB_F1R3_EDH_OFF;
   15853                 :          0 :                 break;
   15854                 :          0 :         case TG3_EEPROM_SB_REVISION_4:
   15855                 :          0 :                 offset = TG3_EEPROM_SB_F1R4_EDH_OFF;
   15856                 :          0 :                 break;
   15857                 :          0 :         case TG3_EEPROM_SB_REVISION_5:
   15858                 :          0 :                 offset = TG3_EEPROM_SB_F1R5_EDH_OFF;
   15859                 :          0 :                 break;
   15860                 :          0 :         case TG3_EEPROM_SB_REVISION_6:
   15861                 :          0 :                 offset = TG3_EEPROM_SB_F1R6_EDH_OFF;
   15862                 :          0 :                 break;
   15863                 :            :         default:
   15864                 :            :                 return;
   15865                 :            :         }
   15866                 :            : 
   15867         [ #  # ]:          0 :         if (tg3_nvram_read(tp, offset, &val))
   15868                 :            :                 return;
   15869                 :            : 
   15870                 :          0 :         build = (val & TG3_EEPROM_SB_EDH_BLD_MASK) >>
   15871                 :            :                 TG3_EEPROM_SB_EDH_BLD_SHFT;
   15872                 :          0 :         major = (val & TG3_EEPROM_SB_EDH_MAJ_MASK) >>
   15873                 :            :                 TG3_EEPROM_SB_EDH_MAJ_SHFT;
   15874                 :          0 :         minor =  val & TG3_EEPROM_SB_EDH_MIN_MASK;
   15875                 :            : 
   15876         [ #  # ]:          0 :         if (minor > 99 || build > 26)
   15877                 :            :                 return;
   15878                 :            : 
   15879                 :          0 :         offset = strlen(tp->fw_ver);
   15880                 :          0 :         snprintf(&tp->fw_ver[offset], TG3_VER_SIZE - offset,
   15881                 :            :                  " v%d.%02d", major, minor);
   15882                 :            : 
   15883         [ #  # ]:          0 :         if (build > 0) {
   15884                 :          0 :                 offset = strlen(tp->fw_ver);
   15885         [ #  # ]:          0 :                 if (offset < TG3_VER_SIZE - 1)
   15886                 :          0 :                         tp->fw_ver[offset] = 'a' + build - 1;
   15887                 :            :         }
   15888                 :            : }
   15889                 :            : 
   15890                 :          0 : static void tg3_read_mgmtfw_ver(struct tg3 *tp)
   15891                 :            : {
   15892                 :          0 :         u32 val, offset, start;
   15893                 :          0 :         int i, vlen;
   15894                 :            : 
   15895                 :          0 :         for (offset = TG3_NVM_DIR_START;
   15896         [ #  # ]:          0 :              offset < TG3_NVM_DIR_END;
   15897                 :          0 :              offset += TG3_NVM_DIRENT_SIZE) {
   15898         [ #  # ]:          0 :                 if (tg3_nvram_read(tp, offset, &val))
   15899                 :          0 :                         return;
   15900                 :            : 
   15901         [ #  # ]:          0 :                 if ((val >> TG3_NVM_DIRTYPE_SHIFT) == TG3_NVM_DIRTYPE_ASFINI)
   15902                 :            :                         break;
   15903                 :            :         }
   15904                 :            : 
   15905         [ #  # ]:          0 :         if (offset == TG3_NVM_DIR_END)
   15906                 :            :                 return;
   15907                 :            : 
   15908         [ #  # ]:          0 :         if (!tg3_flag(tp, 5705_PLUS))
   15909                 :          0 :                 start = 0x08000000;
   15910         [ #  # ]:          0 :         else if (tg3_nvram_read(tp, offset - 4, &start))
   15911                 :            :                 return;
   15912                 :            : 
   15913   [ #  #  #  # ]:          0 :         if (tg3_nvram_read(tp, offset + 4, &offset) ||
   15914         [ #  # ]:          0 :             !tg3_fw_img_is_valid(tp, offset) ||
   15915                 :          0 :             tg3_nvram_read(tp, offset + 8, &val))
   15916                 :          0 :                 return;
   15917                 :            : 
   15918                 :          0 :         offset += val - start;
   15919                 :            : 
   15920                 :          0 :         vlen = strlen(tp->fw_ver);
   15921                 :            : 
   15922                 :          0 :         tp->fw_ver[vlen++] = ',';
   15923                 :          0 :         tp->fw_ver[vlen++] = ' ';
   15924                 :            : 
   15925         [ #  # ]:          0 :         for (i = 0; i < 4; i++) {
   15926                 :          0 :                 __be32 v;
   15927         [ #  # ]:          0 :                 if (tg3_nvram_read_be32(tp, offset, &v))
   15928                 :          0 :                         return;
   15929                 :            : 
   15930                 :          0 :                 offset += sizeof(v);
   15931                 :            : 
   15932         [ #  # ]:          0 :                 if (vlen > TG3_VER_SIZE - sizeof(v)) {
   15933                 :          0 :                         memcpy(&tp->fw_ver[vlen], &v, TG3_VER_SIZE - vlen);
   15934                 :          0 :                         break;
   15935                 :            :                 }
   15936                 :            : 
   15937                 :          0 :                 memcpy(&tp->fw_ver[vlen], &v, sizeof(v));
   15938                 :          0 :                 vlen += sizeof(v);
   15939                 :            :         }
   15940                 :            : }
   15941                 :            : 
   15942                 :          0 : static void tg3_probe_ncsi(struct tg3 *tp)
   15943                 :            : {
   15944                 :          0 :         u32 apedata;
   15945                 :            : 
   15946                 :          0 :         apedata = tg3_ape_read32(tp, TG3_APE_SEG_SIG);
   15947         [ #  # ]:          0 :         if (apedata != APE_SEG_SIG_MAGIC)
   15948                 :            :                 return;
   15949                 :            : 
   15950                 :          0 :         apedata = tg3_ape_read32(tp, TG3_APE_FW_STATUS);
   15951         [ #  # ]:          0 :         if (!(apedata & APE_FW_STATUS_READY))
   15952                 :            :                 return;
   15953                 :            : 
   15954         [ #  # ]:          0 :         if (tg3_ape_read32(tp, TG3_APE_FW_FEATURES) & TG3_APE_FW_FEATURE_NCSI)
   15955                 :          0 :                 tg3_flag_set(tp, APE_HAS_NCSI);
   15956                 :            : }
   15957                 :            : 
   15958                 :          0 : static void tg3_read_dash_ver(struct tg3 *tp)
   15959                 :            : {
   15960                 :          0 :         int vlen;
   15961                 :          0 :         u32 apedata;
   15962                 :          0 :         char *fwtype;
   15963                 :            : 
   15964                 :          0 :         apedata = tg3_ape_read32(tp, TG3_APE_FW_VERSION);
   15965                 :            : 
   15966         [ #  # ]:          0 :         if (tg3_flag(tp, APE_HAS_NCSI))
   15967                 :            :                 fwtype = "NCSI";
   15968         [ #  # ]:          0 :         else if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_5725)
   15969                 :            :                 fwtype = "SMASH";
   15970                 :            :         else
   15971                 :          0 :                 fwtype = "DASH";
   15972                 :            : 
   15973                 :          0 :         vlen = strlen(tp->fw_ver);
   15974                 :            : 
   15975                 :          0 :         snprintf(&tp->fw_ver[vlen], TG3_VER_SIZE - vlen, " %s v%d.%d.%d.%d",
   15976                 :            :                  fwtype,
   15977                 :            :                  (apedata & APE_FW_VERSION_MAJMSK) >> APE_FW_VERSION_MAJSFT,
   15978                 :          0 :                  (apedata & APE_FW_VERSION_MINMSK) >> APE_FW_VERSION_MINSFT,
   15979                 :          0 :                  (apedata & APE_FW_VERSION_REVMSK) >> APE_FW_VERSION_REVSFT,
   15980                 :            :                  (apedata & APE_FW_VERSION_BLDMSK));
   15981                 :          0 : }
   15982                 :            : 
   15983                 :          0 : static void tg3_read_otp_ver(struct tg3 *tp)
   15984                 :            : {
   15985                 :          0 :         u32 val, val2;
   15986                 :            : 
   15987         [ #  # ]:          0 :         if (tg3_asic_rev(tp) != ASIC_REV_5762)
   15988                 :          0 :                 return;
   15989                 :            : 
   15990   [ #  #  #  # ]:          0 :         if (!tg3_ape_otp_read(tp, OTP_ADDRESS_MAGIC0, &val) &&
   15991                 :          0 :             !tg3_ape_otp_read(tp, OTP_ADDRESS_MAGIC0 + 4, &val2) &&
   15992   [ #  #  #  # ]:          0 :             TG3_OTP_MAGIC0_VALID(val)) {
   15993                 :          0 :                 u64 val64 = (u64) val << 32 | val2;
   15994                 :          0 :                 u32 ver = 0;
   15995                 :          0 :                 int i, vlen;
   15996                 :            : 
   15997         [ #  # ]:          0 :                 for (i = 0; i < 7; i++) {
   15998         [ #  # ]:          0 :                         if ((val64 & 0xff) == 0)
   15999                 :            :                                 break;
   16000                 :          0 :                         ver = val64 & 0xff;
   16001                 :          0 :                         val64 >>= 8;
   16002                 :            :                 }
   16003                 :          0 :                 vlen = strlen(tp->fw_ver);
   16004                 :          0 :                 snprintf(&tp->fw_ver[vlen], TG3_VER_SIZE - vlen, " .%02d", ver);
   16005                 :            :         }
   16006                 :            : }
   16007                 :            : 
   16008                 :          0 : static void tg3_read_fw_ver(struct tg3 *tp)
   16009                 :            : {
   16010                 :          0 :         u32 val;
   16011                 :          0 :         bool vpd_vers = false;
   16012                 :            : 
   16013         [ #  # ]:          0 :         if (tp->fw_ver[0] != 0)
   16014                 :          0 :                 vpd_vers = true;
   16015                 :            : 
   16016         [ #  # ]:          0 :         if (tg3_flag(tp, NO_NVRAM)) {
   16017                 :          0 :                 strcat(tp->fw_ver, "sb");
   16018                 :          0 :                 tg3_read_otp_ver(tp);
   16019                 :          0 :                 return;
   16020                 :            :         }
   16021                 :            : 
   16022         [ #  # ]:          0 :         if (tg3_nvram_read(tp, 0, &val))
   16023                 :            :                 return;
   16024                 :            : 
   16025         [ #  # ]:          0 :         if (val == TG3_EEPROM_MAGIC)
   16026                 :          0 :                 tg3_read_bc_ver(tp);
   16027         [ #  # ]:          0 :         else if ((val & TG3_EEPROM_MAGIC_FW_MSK) == TG3_EEPROM_MAGIC_FW)
   16028                 :          0 :                 tg3_read_sb_ver(tp, val);
   16029         [ #  # ]:          0 :         else if ((val & TG3_EEPROM_MAGIC_HW_MSK) == TG3_EEPROM_MAGIC_HW)
   16030                 :          0 :                 tg3_read_hwsb_ver(tp);
   16031                 :            : 
   16032         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_ASF)) {
   16033         [ #  # ]:          0 :                 if (tg3_flag(tp, ENABLE_APE)) {
   16034                 :          0 :                         tg3_probe_ncsi(tp);
   16035         [ #  # ]:          0 :                         if (!vpd_vers)
   16036                 :          0 :                                 tg3_read_dash_ver(tp);
   16037         [ #  # ]:          0 :                 } else if (!vpd_vers) {
   16038                 :          0 :                         tg3_read_mgmtfw_ver(tp);
   16039                 :            :                 }
   16040                 :            :         }
   16041                 :            : 
   16042                 :          0 :         tp->fw_ver[TG3_VER_SIZE - 1] = 0;
   16043                 :            : }
   16044                 :            : 
   16045                 :          0 : static inline u32 tg3_rx_ret_ring_size(struct tg3 *tp)
   16046                 :            : {
   16047         [ #  # ]:          0 :         if (tg3_flag(tp, LRG_PROD_RING_CAP))
   16048                 :            :                 return TG3_RX_RET_MAX_SIZE_5717;
   16049   [ #  #  #  # ]:          0 :         else if (tg3_flag(tp, JUMBO_CAPABLE) && !tg3_flag(tp, 5780_CLASS))
   16050                 :            :                 return TG3_RX_RET_MAX_SIZE_5700;
   16051                 :            :         else
   16052                 :          0 :                 return TG3_RX_RET_MAX_SIZE_5705;
   16053                 :            : }
   16054                 :            : 
   16055                 :            : static const struct pci_device_id tg3_write_reorder_chipsets[] = {
   16056                 :            :         { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_FE_GATE_700C) },
   16057                 :            :         { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8131_BRIDGE) },
   16058                 :            :         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8385_0) },
   16059                 :            :         { },
   16060                 :            : };
   16061                 :            : 
   16062                 :            : static struct pci_dev *tg3_find_peer(struct tg3 *tp)
   16063                 :            : {
   16064                 :            :         struct pci_dev *peer;
   16065                 :            :         unsigned int func, devnr = tp->pdev->devfn & ~7;
   16066                 :            : 
   16067                 :            :         for (func = 0; func < 8; func++) {
   16068                 :            :                 peer = pci_get_slot(tp->pdev->bus, devnr | func);
   16069                 :            :                 if (peer && peer != tp->pdev)
   16070                 :            :                         break;
   16071                 :            :                 pci_dev_put(peer);
   16072                 :            :         }
   16073                 :            :         /* 5704 can be configured in single-port mode, set peer to
   16074                 :            :          * tp->pdev in that case.
   16075                 :            :          */
   16076                 :            :         if (!peer) {
   16077                 :            :                 peer = tp->pdev;
   16078                 :            :                 return peer;
   16079                 :            :         }
   16080                 :            : 
   16081                 :            :         /*
   16082                 :            :          * We don't need to keep the refcount elevated; there's no way
   16083                 :            :          * to remove one half of this device without removing the other
   16084                 :            :          */
   16085                 :            :         pci_dev_put(peer);
   16086                 :            : 
   16087                 :            :         return peer;
   16088                 :            : }
   16089                 :            : 
   16090                 :          0 : static void tg3_detect_asic_rev(struct tg3 *tp, u32 misc_ctrl_reg)
   16091                 :            : {
   16092                 :          0 :         tp->pci_chip_rev_id = misc_ctrl_reg >> MISC_HOST_CTRL_CHIPREV_SHIFT;
   16093         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_USE_PROD_ID_REG) {
   16094                 :          0 :                 u32 reg;
   16095                 :            : 
   16096                 :            :                 /* All devices that use the alternate
   16097                 :            :                  * ASIC REV location have a CPMU.
   16098                 :            :                  */
   16099                 :          0 :                 tg3_flag_set(tp, CPMU_PRESENT);
   16100                 :            : 
   16101         [ #  # ]:          0 :                 if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_5717 ||
   16102         [ #  # ]:          0 :                     tp->pdev->device == TG3PCI_DEVICE_TIGON3_5717_C ||
   16103         [ #  # ]:          0 :                     tp->pdev->device == TG3PCI_DEVICE_TIGON3_5718 ||
   16104         [ #  # ]:          0 :                     tp->pdev->device == TG3PCI_DEVICE_TIGON3_5719 ||
   16105         [ #  # ]:          0 :                     tp->pdev->device == TG3PCI_DEVICE_TIGON3_5720 ||
   16106         [ #  # ]:          0 :                     tp->pdev->device == TG3PCI_DEVICE_TIGON3_57767 ||
   16107         [ #  # ]:          0 :                     tp->pdev->device == TG3PCI_DEVICE_TIGON3_57764 ||
   16108         [ #  # ]:          0 :                     tp->pdev->device == TG3PCI_DEVICE_TIGON3_5762 ||
   16109         [ #  # ]:          0 :                     tp->pdev->device == TG3PCI_DEVICE_TIGON3_5725 ||
   16110         [ #  # ]:          0 :                     tp->pdev->device == TG3PCI_DEVICE_TIGON3_5727 ||
   16111                 :            :                     tp->pdev->device == TG3PCI_DEVICE_TIGON3_57787)
   16112                 :            :                         reg = TG3PCI_GEN2_PRODID_ASICREV;
   16113         [ #  # ]:          0 :                 else if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_57781 ||
   16114         [ #  # ]:          0 :                          tp->pdev->device == TG3PCI_DEVICE_TIGON3_57785 ||
   16115         [ #  # ]:          0 :                          tp->pdev->device == TG3PCI_DEVICE_TIGON3_57761 ||
   16116         [ #  # ]:          0 :                          tp->pdev->device == TG3PCI_DEVICE_TIGON3_57765 ||
   16117         [ #  # ]:          0 :                          tp->pdev->device == TG3PCI_DEVICE_TIGON3_57791 ||
   16118         [ #  # ]:          0 :                          tp->pdev->device == TG3PCI_DEVICE_TIGON3_57795 ||
   16119         [ #  # ]:          0 :                          tp->pdev->device == TG3PCI_DEVICE_TIGON3_57762 ||
   16120         [ #  # ]:          0 :                          tp->pdev->device == TG3PCI_DEVICE_TIGON3_57766 ||
   16121         [ #  # ]:          0 :                          tp->pdev->device == TG3PCI_DEVICE_TIGON3_57782 ||
   16122                 :            :                          tp->pdev->device == TG3PCI_DEVICE_TIGON3_57786)
   16123                 :            :                         reg = TG3PCI_GEN15_PRODID_ASICREV;
   16124                 :            :                 else
   16125                 :          0 :                         reg = TG3PCI_PRODID_ASICREV;
   16126                 :            : 
   16127                 :          0 :                 pci_read_config_dword(tp->pdev, reg, &tp->pci_chip_rev_id);
   16128                 :            :         }
   16129                 :            : 
   16130                 :            :         /* Wrong chip ID in 5752 A0. This code can be removed later
   16131                 :            :          * as A0 is not in production.
   16132                 :            :          */
   16133         [ #  # ]:          0 :         if (tg3_chip_rev_id(tp) == CHIPREV_ID_5752_A0_HW)
   16134                 :          0 :                 tp->pci_chip_rev_id = CHIPREV_ID_5752_A0;
   16135                 :            : 
   16136         [ #  # ]:          0 :         if (tg3_chip_rev_id(tp) == CHIPREV_ID_5717_C0)
   16137                 :          0 :                 tp->pci_chip_rev_id = CHIPREV_ID_5720_A0;
   16138                 :            : 
   16139         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5717 ||
   16140         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5719 ||
   16141                 :            :             tg3_asic_rev(tp) == ASIC_REV_5720)
   16142                 :          0 :                 tg3_flag_set(tp, 5717_PLUS);
   16143                 :            : 
   16144         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_57765 ||
   16145                 :            :             tg3_asic_rev(tp) == ASIC_REV_57766)
   16146                 :          0 :                 tg3_flag_set(tp, 57765_CLASS);
   16147                 :            : 
   16148   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, 57765_CLASS) || tg3_flag(tp, 5717_PLUS) ||
   16149         [ #  # ]:          0 :              tg3_asic_rev(tp) == ASIC_REV_5762)
   16150                 :          0 :                 tg3_flag_set(tp, 57765_PLUS);
   16151                 :            : 
   16152                 :            :         /* Intentionally exclude ASIC_REV_5906 */
   16153                 :          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5755 ||
   16154         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5787 ||
   16155         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5784 ||
   16156         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5761 ||
   16157         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5785 ||
   16158         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_57780 ||
   16159                 :            :             tg3_flag(tp, 57765_PLUS))
   16160                 :          0 :                 tg3_flag_set(tp, 5755_PLUS);
   16161                 :            : 
   16162         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5780 ||
   16163                 :            :             tg3_asic_rev(tp) == ASIC_REV_5714)
   16164                 :          0 :                 tg3_flag_set(tp, 5780_CLASS);
   16165                 :            : 
   16166         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5750 ||
   16167         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5752 ||
   16168         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5906 ||
   16169         [ #  # ]:          0 :             tg3_flag(tp, 5755_PLUS) ||
   16170                 :            :             tg3_flag(tp, 5780_CLASS))
   16171                 :          0 :                 tg3_flag_set(tp, 5750_PLUS);
   16172                 :            : 
   16173   [ #  #  #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5705 ||
   16174                 :            :             tg3_flag(tp, 5750_PLUS))
   16175                 :          0 :                 tg3_flag_set(tp, 5705_PLUS);
   16176                 :          0 : }
   16177                 :            : 
   16178                 :            : static bool tg3_10_100_only_device(struct tg3 *tp,
   16179                 :            :                                    const struct pci_device_id *ent)
   16180                 :            : {
   16181                 :            :         u32 grc_misc_cfg = tr32(GRC_MISC_CFG) & GRC_MISC_CFG_BOARD_ID_MASK;
   16182                 :            : 
   16183                 :            :         if ((tg3_asic_rev(tp) == ASIC_REV_5703 &&
   16184                 :            :              (grc_misc_cfg == 0x8000 || grc_misc_cfg == 0x4000)) ||
   16185                 :            :             (tp->phy_flags & TG3_PHYFLG_IS_FET))
   16186                 :            :                 return true;
   16187                 :            : 
   16188                 :            :         if (ent->driver_data & TG3_DRV_DATA_FLAG_10_100_ONLY) {
   16189                 :            :                 if (tg3_asic_rev(tp) == ASIC_REV_5705) {
   16190                 :            :                         if (ent->driver_data & TG3_DRV_DATA_FLAG_5705_10_100)
   16191                 :            :                                 return true;
   16192                 :            :                 } else {
   16193                 :            :                         return true;
   16194                 :            :                 }
   16195                 :            :         }
   16196                 :            : 
   16197                 :            :         return false;
   16198                 :            : }
   16199                 :            : 
   16200                 :          0 : static int tg3_get_invariants(struct tg3 *tp, const struct pci_device_id *ent)
   16201                 :            : {
   16202                 :          0 :         u32 misc_ctrl_reg;
   16203                 :          0 :         u32 pci_state_reg, grc_misc_cfg;
   16204                 :          0 :         u32 val;
   16205                 :          0 :         u16 pci_cmd;
   16206                 :          0 :         int err;
   16207                 :            : 
   16208                 :            :         /* Force memory write invalidate off.  If we leave it on,
   16209                 :            :          * then on 5700_BX chips we have to enable a workaround.
   16210                 :            :          * The workaround is to set the TG3PCI_DMA_RW_CTRL boundary
   16211                 :            :          * to match the cacheline size.  The Broadcom driver have this
   16212                 :            :          * workaround but turns MWI off all the times so never uses
   16213                 :            :          * it.  This seems to suggest that the workaround is insufficient.
   16214                 :            :          */
   16215                 :          0 :         pci_read_config_word(tp->pdev, PCI_COMMAND, &pci_cmd);
   16216                 :          0 :         pci_cmd &= ~PCI_COMMAND_INVALIDATE;
   16217                 :          0 :         pci_write_config_word(tp->pdev, PCI_COMMAND, pci_cmd);
   16218                 :            : 
   16219                 :            :         /* Important! -- Make sure register accesses are byteswapped
   16220                 :            :          * correctly.  Also, for those chips that require it, make
   16221                 :            :          * sure that indirect register accesses are enabled before
   16222                 :            :          * the first operation.
   16223                 :            :          */
   16224                 :          0 :         pci_read_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
   16225                 :            :                               &misc_ctrl_reg);
   16226                 :          0 :         tp->misc_host_ctrl |= (misc_ctrl_reg &
   16227                 :            :                                MISC_HOST_CTRL_CHIPREV);
   16228                 :          0 :         pci_write_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
   16229                 :            :                                tp->misc_host_ctrl);
   16230                 :            : 
   16231                 :          0 :         tg3_detect_asic_rev(tp, misc_ctrl_reg);
   16232                 :            : 
   16233                 :            :         /* If we have 5702/03 A1 or A2 on certain ICH chipsets,
   16234                 :            :          * we need to disable memory and use config. cycles
   16235                 :            :          * only to access all registers. The 5702/03 chips
   16236                 :            :          * can mistakenly decode the special cycles from the
   16237                 :            :          * ICH chipsets as memory write cycles, causing corruption
   16238                 :            :          * of register and memory space. Only certain ICH bridges
   16239                 :            :          * will drive special cycles with non-zero data during the
   16240                 :            :          * address phase which can fall within the 5703's address
   16241                 :            :          * range. This is not an ICH bug as the PCI spec allows
   16242                 :            :          * non-zero address during special cycles. However, only
   16243                 :            :          * these ICH bridges are known to drive non-zero addresses
   16244                 :            :          * during special cycles.
   16245                 :            :          *
   16246                 :            :          * Since special cycles do not cross PCI bridges, we only
   16247                 :            :          * enable this workaround if the 5703 is on the secondary
   16248                 :            :          * bus of these ICH bridges.
   16249                 :            :          */
   16250         [ #  # ]:          0 :         if ((tg3_chip_rev_id(tp) == CHIPREV_ID_5703_A1) ||
   16251                 :            :             (tg3_chip_rev_id(tp) == CHIPREV_ID_5703_A2)) {
   16252                 :            :                 static struct tg3_dev_id {
   16253                 :            :                         u32     vendor;
   16254                 :            :                         u32     device;
   16255                 :            :                         u32     rev;
   16256                 :            :                 } ich_chipsets[] = {
   16257                 :            :                         { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AA_8,
   16258                 :            :                           PCI_ANY_ID },
   16259                 :            :                         { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AB_8,
   16260                 :            :                           PCI_ANY_ID },
   16261                 :            :                         { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_11,
   16262                 :            :                           0xa },
   16263                 :            :                         { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_6,
   16264                 :            :                           PCI_ANY_ID },
   16265                 :            :                         { },
   16266                 :            :                 };
   16267                 :            :                 struct tg3_dev_id *pci_id = &ich_chipsets[0];
   16268                 :            :                 struct pci_dev *bridge = NULL;
   16269                 :            : 
   16270         [ #  # ]:          0 :                 while (pci_id->vendor != 0) {
   16271                 :          0 :                         bridge = pci_get_device(pci_id->vendor, pci_id->device,
   16272                 :            :                                                 bridge);
   16273         [ #  # ]:          0 :                         if (!bridge) {
   16274                 :          0 :                                 pci_id++;
   16275                 :          0 :                                 continue;
   16276                 :            :                         }
   16277         [ #  # ]:          0 :                         if (pci_id->rev != PCI_ANY_ID) {
   16278         [ #  # ]:          0 :                                 if (bridge->revision > pci_id->rev)
   16279                 :          0 :                                         continue;
   16280                 :            :                         }
   16281         [ #  # ]:          0 :                         if (bridge->subordinate &&
   16282                 :          0 :                             (bridge->subordinate->number ==
   16283         [ #  # ]:          0 :                              tp->pdev->bus->number)) {
   16284                 :          0 :                                 tg3_flag_set(tp, ICH_WORKAROUND);
   16285                 :          0 :                                 pci_dev_put(bridge);
   16286                 :          0 :                                 break;
   16287                 :            :                         }
   16288                 :            :                 }
   16289                 :            :         }
   16290                 :            : 
   16291         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5701) {
   16292                 :            :                 static struct tg3_dev_id {
   16293                 :            :                         u32     vendor;
   16294                 :            :                         u32     device;
   16295                 :            :                 } bridge_chipsets[] = {
   16296                 :            :                         { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PXH_0 },
   16297                 :            :                         { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PXH_1 },
   16298                 :            :                         { },
   16299                 :            :                 };
   16300                 :            :                 struct tg3_dev_id *pci_id = &bridge_chipsets[0];
   16301                 :            :                 struct pci_dev *bridge = NULL;
   16302                 :            : 
   16303         [ #  # ]:          0 :                 while (pci_id->vendor != 0) {
   16304                 :          0 :                         bridge = pci_get_device(pci_id->vendor,
   16305                 :            :                                                 pci_id->device,
   16306                 :            :                                                 bridge);
   16307         [ #  # ]:          0 :                         if (!bridge) {
   16308                 :          0 :                                 pci_id++;
   16309                 :          0 :                                 continue;
   16310                 :            :                         }
   16311         [ #  # ]:          0 :                         if (bridge->subordinate &&
   16312                 :          0 :                             (bridge->subordinate->number <=
   16313         [ #  # ]:          0 :                              tp->pdev->bus->number) &&
   16314                 :          0 :                             (bridge->subordinate->busn_res.end >=
   16315         [ #  # ]:          0 :                              tp->pdev->bus->number)) {
   16316                 :          0 :                                 tg3_flag_set(tp, 5701_DMA_BUG);
   16317                 :          0 :                                 pci_dev_put(bridge);
   16318                 :          0 :                                 break;
   16319                 :            :                         }
   16320                 :            :                 }
   16321                 :            :         }
   16322                 :            : 
   16323                 :            :         /* The EPB bridge inside 5714, 5715, and 5780 cannot support
   16324                 :            :          * DMA addresses > 40-bit. This bridge may have other additional
   16325                 :            :          * 57xx devices behind it in some 4-port NIC designs for example.
   16326                 :            :          * Any tg3 device found behind the bridge will also need the 40-bit
   16327                 :            :          * DMA workaround.
   16328                 :            :          */
   16329         [ #  # ]:          0 :         if (tg3_flag(tp, 5780_CLASS)) {
   16330                 :          0 :                 tg3_flag_set(tp, 40BIT_DMA_BUG);
   16331                 :          0 :                 tp->msi_cap = tp->pdev->msi_cap;
   16332                 :            :         } else {
   16333                 :            :                 struct pci_dev *bridge = NULL;
   16334                 :            : 
   16335                 :          0 :                 do {
   16336                 :          0 :                         bridge = pci_get_device(PCI_VENDOR_ID_SERVERWORKS,
   16337                 :            :                                                 PCI_DEVICE_ID_SERVERWORKS_EPB,
   16338                 :            :                                                 bridge);
   16339   [ #  #  #  # ]:          0 :                         if (bridge && bridge->subordinate &&
   16340                 :          0 :                             (bridge->subordinate->number <=
   16341         [ #  # ]:          0 :                              tp->pdev->bus->number) &&
   16342                 :          0 :                             (bridge->subordinate->busn_res.end >=
   16343         [ #  # ]:          0 :                              tp->pdev->bus->number)) {
   16344                 :          0 :                                 tg3_flag_set(tp, 40BIT_DMA_BUG);
   16345                 :          0 :                                 pci_dev_put(bridge);
   16346                 :          0 :                                 break;
   16347                 :            :                         }
   16348         [ #  # ]:          0 :                 } while (bridge);
   16349                 :            :         }
   16350                 :            : 
   16351         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5704 ||
   16352                 :            :             tg3_asic_rev(tp) == ASIC_REV_5714)
   16353                 :          0 :                 tp->pdev_peer = tg3_find_peer(tp);
   16354                 :            : 
   16355                 :            :         /* Determine TSO capabilities */
   16356         [ #  # ]:          0 :         if (tg3_chip_rev_id(tp) == CHIPREV_ID_5719_A0)
   16357                 :            :                 ; /* Do nothing. HW bug. */
   16358         [ #  # ]:          0 :         else if (tg3_flag(tp, 57765_PLUS))
   16359                 :          0 :                 tg3_flag_set(tp, HW_TSO_3);
   16360         [ #  # ]:          0 :         else if (tg3_flag(tp, 5755_PLUS) ||
   16361         [ #  # ]:          0 :                  tg3_asic_rev(tp) == ASIC_REV_5906)
   16362                 :          0 :                 tg3_flag_set(tp, HW_TSO_2);
   16363         [ #  # ]:          0 :         else if (tg3_flag(tp, 5750_PLUS)) {
   16364                 :          0 :                 tg3_flag_set(tp, HW_TSO_1);
   16365                 :          0 :                 tg3_flag_set(tp, TSO_BUG);
   16366   [ #  #  #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5750 &&
   16367                 :            :                     tg3_chip_rev_id(tp) >= CHIPREV_ID_5750_C2)
   16368                 :          0 :                         tg3_flag_clear(tp, TSO_BUG);
   16369         [ #  # ]:          0 :         } else if (tg3_asic_rev(tp) != ASIC_REV_5700 &&
   16370         [ #  # ]:          0 :                    tg3_asic_rev(tp) != ASIC_REV_5701 &&
   16371                 :            :                    tg3_chip_rev_id(tp) != CHIPREV_ID_5705_A0) {
   16372                 :          0 :                 tg3_flag_set(tp, FW_TSO);
   16373                 :          0 :                 tg3_flag_set(tp, TSO_BUG);
   16374         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5705)
   16375                 :          0 :                         tp->fw_needed = FIRMWARE_TG3TSO5;
   16376                 :            :                 else
   16377                 :          0 :                         tp->fw_needed = FIRMWARE_TG3TSO;
   16378                 :            :         }
   16379                 :            : 
   16380                 :            :         /* Selectively allow TSO based on operating conditions */
   16381   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, HW_TSO_1) ||
   16382         [ #  # ]:          0 :             tg3_flag(tp, HW_TSO_2) ||
   16383         [ #  # ]:          0 :             tg3_flag(tp, HW_TSO_3) ||
   16384                 :            :             tg3_flag(tp, FW_TSO)) {
   16385                 :            :                 /* For firmware TSO, assume ASF is disabled.
   16386                 :            :                  * We'll disable TSO later if we discover ASF
   16387                 :            :                  * is enabled in tg3_get_eeprom_hw_cfg().
   16388                 :            :                  */
   16389                 :          0 :                 tg3_flag_set(tp, TSO_CAPABLE);
   16390                 :            :         } else {
   16391                 :          0 :                 tg3_flag_clear(tp, TSO_CAPABLE);
   16392                 :          0 :                 tg3_flag_clear(tp, TSO_BUG);
   16393                 :          0 :                 tp->fw_needed = NULL;
   16394                 :            :         }
   16395                 :            : 
   16396         [ #  # ]:          0 :         if (tg3_chip_rev_id(tp) == CHIPREV_ID_5701_A0)
   16397                 :          0 :                 tp->fw_needed = FIRMWARE_TG3;
   16398                 :            : 
   16399         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_57766)
   16400                 :          0 :                 tp->fw_needed = FIRMWARE_TG357766;
   16401                 :            : 
   16402                 :          0 :         tp->irq_max = 1;
   16403                 :            : 
   16404         [ #  # ]:          0 :         if (tg3_flag(tp, 5750_PLUS)) {
   16405                 :          0 :                 tg3_flag_set(tp, SUPPORT_MSI);
   16406         [ #  # ]:          0 :                 if (tg3_chip_rev(tp) == CHIPREV_5750_AX ||
   16407                 :          0 :                     tg3_chip_rev(tp) == CHIPREV_5750_BX ||
   16408   [ #  #  #  # ]:          0 :                     (tg3_asic_rev(tp) == ASIC_REV_5714 &&
   16409                 :          0 :                      tg3_chip_rev_id(tp) <= CHIPREV_ID_5714_A2 &&
   16410         [ #  # ]:          0 :                      tp->pdev_peer == tp->pdev))
   16411                 :          0 :                         tg3_flag_clear(tp, SUPPORT_MSI);
   16412                 :            : 
   16413         [ #  # ]:          0 :                 if (tg3_flag(tp, 5755_PLUS) ||
   16414         [ #  # ]:          0 :                     tg3_asic_rev(tp) == ASIC_REV_5906) {
   16415                 :          0 :                         tg3_flag_set(tp, 1SHOT_MSI);
   16416                 :            :                 }
   16417                 :            : 
   16418         [ #  # ]:          0 :                 if (tg3_flag(tp, 57765_PLUS)) {
   16419                 :          0 :                         tg3_flag_set(tp, SUPPORT_MSIX);
   16420                 :          0 :                         tp->irq_max = TG3_IRQ_MAX_VECS;
   16421                 :            :                 }
   16422                 :            :         }
   16423                 :            : 
   16424                 :          0 :         tp->txq_max = 1;
   16425                 :          0 :         tp->rxq_max = 1;
   16426         [ #  # ]:          0 :         if (tp->irq_max > 1) {
   16427                 :          0 :                 tp->rxq_max = TG3_RSS_MAX_NUM_QS;
   16428                 :          0 :                 tg3_rss_init_dflt_indir_tbl(tp, TG3_RSS_MAX_NUM_QS);
   16429                 :            : 
   16430         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5719 ||
   16431                 :            :                     tg3_asic_rev(tp) == ASIC_REV_5720)
   16432                 :          0 :                         tp->txq_max = tp->irq_max - 1;
   16433                 :            :         }
   16434                 :            : 
   16435         [ #  # ]:          0 :         if (tg3_flag(tp, 5755_PLUS) ||
   16436         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5906)
   16437                 :          0 :                 tg3_flag_set(tp, SHORT_DMA_BUG);
   16438                 :            : 
   16439         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5719)
   16440                 :          0 :                 tp->dma_limit = TG3_TX_BD_DMA_MAX_4K;
   16441                 :            : 
   16442         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5717 ||
   16443         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5719 ||
   16444         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5720 ||
   16445                 :            :             tg3_asic_rev(tp) == ASIC_REV_5762)
   16446                 :          0 :                 tg3_flag_set(tp, LRG_PROD_RING_CAP);
   16447                 :            : 
   16448         [ #  # ]:          0 :         if (tg3_flag(tp, 57765_PLUS) &&
   16449         [ #  # ]:          0 :             tg3_chip_rev_id(tp) != CHIPREV_ID_5719_A0)
   16450                 :          0 :                 tg3_flag_set(tp, USE_JUMBO_BDFLAG);
   16451                 :            : 
   16452   [ #  #  #  # ]:          0 :         if (!tg3_flag(tp, 5705_PLUS) ||
   16453         [ #  # ]:          0 :             tg3_flag(tp, 5780_CLASS) ||
   16454                 :            :             tg3_flag(tp, USE_JUMBO_BDFLAG))
   16455                 :          0 :                 tg3_flag_set(tp, JUMBO_CAPABLE);
   16456                 :            : 
   16457                 :          0 :         pci_read_config_dword(tp->pdev, TG3PCI_PCISTATE,
   16458                 :            :                               &pci_state_reg);
   16459                 :            : 
   16460         [ #  # ]:          0 :         if (pci_is_pcie(tp->pdev)) {
   16461                 :          0 :                 u16 lnkctl;
   16462                 :            : 
   16463                 :          0 :                 tg3_flag_set(tp, PCI_EXPRESS);
   16464                 :            : 
   16465                 :          0 :                 pcie_capability_read_word(tp->pdev, PCI_EXP_LNKCTL, &lnkctl);
   16466         [ #  # ]:          0 :                 if (lnkctl & PCI_EXP_LNKCTL_CLKREQ_EN) {
   16467         [ #  # ]:          0 :                         if (tg3_asic_rev(tp) == ASIC_REV_5906) {
   16468                 :          0 :                                 tg3_flag_clear(tp, HW_TSO_2);
   16469                 :          0 :                                 tg3_flag_clear(tp, TSO_CAPABLE);
   16470                 :            :                         }
   16471         [ #  # ]:          0 :                         if (tg3_asic_rev(tp) == ASIC_REV_5784 ||
   16472         [ #  # ]:          0 :                             tg3_asic_rev(tp) == ASIC_REV_5761 ||
   16473         [ #  # ]:          0 :                             tg3_chip_rev_id(tp) == CHIPREV_ID_57780_A0 ||
   16474                 :            :                             tg3_chip_rev_id(tp) == CHIPREV_ID_57780_A1)
   16475                 :          0 :                                 tg3_flag_set(tp, CLKREQ_BUG);
   16476         [ #  # ]:          0 :                 } else if (tg3_chip_rev_id(tp) == CHIPREV_ID_5717_A0) {
   16477                 :          0 :                         tg3_flag_set(tp, L1PLLPD_EN);
   16478                 :            :                 }
   16479         [ #  # ]:          0 :         } else if (tg3_asic_rev(tp) == ASIC_REV_5785) {
   16480                 :            :                 /* BCM5785 devices are effectively PCIe devices, and should
   16481                 :            :                  * follow PCIe codepaths, but do not have a PCIe capabilities
   16482                 :            :                  * section.
   16483                 :            :                  */
   16484                 :          0 :                 tg3_flag_set(tp, PCI_EXPRESS);
   16485   [ #  #  #  # ]:          0 :         } else if (!tg3_flag(tp, 5705_PLUS) ||
   16486                 :            :                    tg3_flag(tp, 5780_CLASS)) {
   16487                 :          0 :                 tp->pcix_cap = pci_find_capability(tp->pdev, PCI_CAP_ID_PCIX);
   16488         [ #  # ]:          0 :                 if (!tp->pcix_cap) {
   16489                 :          0 :                         dev_err(&tp->pdev->dev,
   16490                 :            :                                 "Cannot find PCI-X capability, aborting\n");
   16491                 :          0 :                         return -EIO;
   16492                 :            :                 }
   16493                 :            : 
   16494         [ #  # ]:          0 :                 if (!(pci_state_reg & PCISTATE_CONV_PCI_MODE))
   16495                 :          0 :                         tg3_flag_set(tp, PCIX_MODE);
   16496                 :            :         }
   16497                 :            : 
   16498                 :            :         /* If we have an AMD 762 or VIA K8T800 chipset, write
   16499                 :            :          * reordering to the mailbox registers done by the host
   16500                 :            :          * controller can cause major troubles.  We read back from
   16501                 :            :          * every mailbox register write to force the writes to be
   16502                 :            :          * posted to the chip in order.
   16503                 :            :          */
   16504   [ #  #  #  # ]:          0 :         if (pci_dev_present(tg3_write_reorder_chipsets) &&
   16505                 :            :             !tg3_flag(tp, PCI_EXPRESS))
   16506                 :          0 :                 tg3_flag_set(tp, MBOX_WRITE_REORDER);
   16507                 :            : 
   16508                 :          0 :         pci_read_config_byte(tp->pdev, PCI_CACHE_LINE_SIZE,
   16509                 :            :                              &tp->pci_cacheline_sz);
   16510                 :          0 :         pci_read_config_byte(tp->pdev, PCI_LATENCY_TIMER,
   16511                 :            :                              &tp->pci_lat_timer);
   16512         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5703 &&
   16513         [ #  # ]:          0 :             tp->pci_lat_timer < 64) {
   16514                 :          0 :                 tp->pci_lat_timer = 64;
   16515                 :          0 :                 pci_write_config_byte(tp->pdev, PCI_LATENCY_TIMER,
   16516                 :            :                                       tp->pci_lat_timer);
   16517                 :            :         }
   16518                 :            : 
   16519                 :            :         /* Important! -- It is critical that the PCI-X hw workaround
   16520                 :            :          * situation is decided before the first MMIO register access.
   16521                 :            :          */
   16522         [ #  # ]:          0 :         if (tg3_chip_rev(tp) == CHIPREV_5700_BX) {
   16523                 :            :                 /* 5700 BX chips need to have their TX producer index
   16524                 :            :                  * mailboxes written twice to workaround a bug.
   16525                 :            :                  */
   16526                 :          0 :                 tg3_flag_set(tp, TXD_MBOX_HWBUG);
   16527                 :            : 
   16528                 :            :                 /* If we are in PCI-X mode, enable register write workaround.
   16529                 :            :                  *
   16530                 :            :                  * The workaround is to use indirect register accesses
   16531                 :            :                  * for all chip writes not to mailbox registers.
   16532                 :            :                  */
   16533         [ #  # ]:          0 :                 if (tg3_flag(tp, PCIX_MODE)) {
   16534                 :          0 :                         u32 pm_reg;
   16535                 :            : 
   16536                 :          0 :                         tg3_flag_set(tp, PCIX_TARGET_HWBUG);
   16537                 :            : 
   16538                 :            :                         /* The chip can have it's power management PCI config
   16539                 :            :                          * space registers clobbered due to this bug.
   16540                 :            :                          * So explicitly force the chip into D0 here.
   16541                 :            :                          */
   16542                 :          0 :                         pci_read_config_dword(tp->pdev,
   16543                 :          0 :                                               tp->pdev->pm_cap + PCI_PM_CTRL,
   16544                 :            :                                               &pm_reg);
   16545                 :          0 :                         pm_reg &= ~PCI_PM_CTRL_STATE_MASK;
   16546                 :          0 :                         pm_reg |= PCI_PM_CTRL_PME_ENABLE | 0 /* D0 */;
   16547                 :          0 :                         pci_write_config_dword(tp->pdev,
   16548                 :          0 :                                                tp->pdev->pm_cap + PCI_PM_CTRL,
   16549                 :            :                                                pm_reg);
   16550                 :            : 
   16551                 :            :                         /* Also, force SERR#/PERR# in PCI command. */
   16552                 :          0 :                         pci_read_config_word(tp->pdev, PCI_COMMAND, &pci_cmd);
   16553                 :          0 :                         pci_cmd |= PCI_COMMAND_PARITY | PCI_COMMAND_SERR;
   16554                 :          0 :                         pci_write_config_word(tp->pdev, PCI_COMMAND, pci_cmd);
   16555                 :            :                 }
   16556                 :            :         }
   16557                 :            : 
   16558         [ #  # ]:          0 :         if ((pci_state_reg & PCISTATE_BUS_SPEED_HIGH) != 0)
   16559                 :          0 :                 tg3_flag_set(tp, PCI_HIGH_SPEED);
   16560         [ #  # ]:          0 :         if ((pci_state_reg & PCISTATE_BUS_32BIT) != 0)
   16561                 :          0 :                 tg3_flag_set(tp, PCI_32BIT);
   16562                 :            : 
   16563                 :            :         /* Chip-specific fixup from Broadcom driver */
   16564         [ #  # ]:          0 :         if ((tg3_chip_rev_id(tp) == CHIPREV_ID_5704_A0) &&
   16565         [ #  # ]:          0 :             (!(pci_state_reg & PCISTATE_RETRY_SAME_DMA))) {
   16566                 :          0 :                 pci_state_reg |= PCISTATE_RETRY_SAME_DMA;
   16567                 :          0 :                 pci_write_config_dword(tp->pdev, TG3PCI_PCISTATE, pci_state_reg);
   16568                 :            :         }
   16569                 :            : 
   16570                 :            :         /* Default fast path register access methods */
   16571                 :          0 :         tp->read32 = tg3_read32;
   16572                 :          0 :         tp->write32 = tg3_write32;
   16573                 :          0 :         tp->read32_mbox = tg3_read32;
   16574                 :          0 :         tp->write32_mbox = tg3_write32;
   16575                 :          0 :         tp->write32_tx_mbox = tg3_write32;
   16576                 :          0 :         tp->write32_rx_mbox = tg3_write32;
   16577                 :            : 
   16578                 :            :         /* Various workaround register access methods */
   16579         [ #  # ]:          0 :         if (tg3_flag(tp, PCIX_TARGET_HWBUG))
   16580                 :          0 :                 tp->write32 = tg3_write_indirect_reg32;
   16581   [ #  #  #  # ]:          0 :         else if (tg3_asic_rev(tp) == ASIC_REV_5701 ||
   16582                 :          0 :                  (tg3_flag(tp, PCI_EXPRESS) &&
   16583         [ #  # ]:          0 :                   tg3_chip_rev_id(tp) == CHIPREV_ID_5750_A0)) {
   16584                 :            :                 /*
   16585                 :            :                  * Back to back register writes can cause problems on these
   16586                 :            :                  * chips, the workaround is to read back all reg writes
   16587                 :            :                  * except those to mailbox regs.
   16588                 :            :                  *
   16589                 :            :                  * See tg3_write_indirect_reg32().
   16590                 :            :                  */
   16591                 :          0 :                 tp->write32 = tg3_write_flush_reg32;
   16592                 :            :         }
   16593                 :            : 
   16594   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, TXD_MBOX_HWBUG) || tg3_flag(tp, MBOX_WRITE_REORDER)) {
   16595                 :          0 :                 tp->write32_tx_mbox = tg3_write32_tx_mbox;
   16596         [ #  # ]:          0 :                 if (tg3_flag(tp, MBOX_WRITE_REORDER))
   16597                 :          0 :                         tp->write32_rx_mbox = tg3_write_flush_reg32;
   16598                 :            :         }
   16599                 :            : 
   16600         [ #  # ]:          0 :         if (tg3_flag(tp, ICH_WORKAROUND)) {
   16601                 :          0 :                 tp->read32 = tg3_read_indirect_reg32;
   16602                 :          0 :                 tp->write32 = tg3_write_indirect_reg32;
   16603                 :          0 :                 tp->read32_mbox = tg3_read_indirect_mbox;
   16604                 :          0 :                 tp->write32_mbox = tg3_write_indirect_mbox;
   16605                 :          0 :                 tp->write32_tx_mbox = tg3_write_indirect_mbox;
   16606                 :          0 :                 tp->write32_rx_mbox = tg3_write_indirect_mbox;
   16607                 :            : 
   16608                 :          0 :                 iounmap(tp->regs);
   16609                 :          0 :                 tp->regs = NULL;
   16610                 :            : 
   16611                 :          0 :                 pci_read_config_word(tp->pdev, PCI_COMMAND, &pci_cmd);
   16612                 :          0 :                 pci_cmd &= ~PCI_COMMAND_MEMORY;
   16613                 :          0 :                 pci_write_config_word(tp->pdev, PCI_COMMAND, pci_cmd);
   16614                 :            :         }
   16615         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5906) {
   16616                 :          0 :                 tp->read32_mbox = tg3_read32_mbox_5906;
   16617                 :          0 :                 tp->write32_mbox = tg3_write32_mbox_5906;
   16618                 :          0 :                 tp->write32_tx_mbox = tg3_write32_mbox_5906;
   16619                 :          0 :                 tp->write32_rx_mbox = tg3_write32_mbox_5906;
   16620                 :            :         }
   16621                 :            : 
   16622   [ #  #  #  # ]:          0 :         if (tp->write32 == tg3_write_indirect_reg32 ||
   16623                 :          0 :             (tg3_flag(tp, PCIX_MODE) &&
   16624         [ #  # ]:          0 :              (tg3_asic_rev(tp) == ASIC_REV_5700 ||
   16625                 :            :               tg3_asic_rev(tp) == ASIC_REV_5701)))
   16626                 :          0 :                 tg3_flag_set(tp, SRAM_USE_CONFIG);
   16627                 :            : 
   16628                 :            :         /* The memory arbiter has to be enabled in order for SRAM accesses
   16629                 :            :          * to succeed.  Normally on powerup the tg3 chip firmware will make
   16630                 :            :          * sure it is enabled, but other entities such as system netboot
   16631                 :            :          * code might disable it.
   16632                 :            :          */
   16633                 :          0 :         val = tr32(MEMARB_MODE);
   16634                 :          0 :         tw32(MEMARB_MODE, val | MEMARB_MODE_ENABLE);
   16635                 :            : 
   16636                 :          0 :         tp->pci_fn = PCI_FUNC(tp->pdev->devfn) & 3;
   16637   [ #  #  #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5704 ||
   16638                 :            :             tg3_flag(tp, 5780_CLASS)) {
   16639         [ #  # ]:          0 :                 if (tg3_flag(tp, PCIX_MODE)) {
   16640                 :          0 :                         pci_read_config_dword(tp->pdev,
   16641                 :          0 :                                               tp->pcix_cap + PCI_X_STATUS,
   16642                 :            :                                               &val);
   16643                 :          0 :                         tp->pci_fn = val & 0x7;
   16644                 :            :                 }
   16645         [ #  # ]:          0 :         } else if (tg3_asic_rev(tp) == ASIC_REV_5717 ||
   16646         [ #  # ]:          0 :                    tg3_asic_rev(tp) == ASIC_REV_5719 ||
   16647                 :            :                    tg3_asic_rev(tp) == ASIC_REV_5720) {
   16648                 :          0 :                 tg3_read_mem(tp, NIC_SRAM_CPMU_STATUS, &val);
   16649         [ #  # ]:          0 :                 if ((val & NIC_SRAM_CPMUSTAT_SIG_MSK) != NIC_SRAM_CPMUSTAT_SIG)
   16650                 :          0 :                         val = tr32(TG3_CPMU_STATUS);
   16651                 :            : 
   16652         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5717)
   16653                 :          0 :                         tp->pci_fn = (val & TG3_CPMU_STATUS_FMSK_5717) ? 1 : 0;
   16654                 :            :                 else
   16655                 :          0 :                         tp->pci_fn = (val & TG3_CPMU_STATUS_FMSK_5719) >>
   16656                 :            :                                      TG3_CPMU_STATUS_FSHFT_5719;
   16657                 :            :         }
   16658                 :            : 
   16659         [ #  # ]:          0 :         if (tg3_flag(tp, FLUSH_POSTED_WRITES)) {
   16660                 :          0 :                 tp->write32_tx_mbox = tg3_write_flush_reg32;
   16661                 :          0 :                 tp->write32_rx_mbox = tg3_write_flush_reg32;
   16662                 :            :         }
   16663                 :            : 
   16664                 :            :         /* Get eeprom hw config before calling tg3_set_power_state().
   16665                 :            :          * In particular, the TG3_FLAG_IS_NIC flag must be
   16666                 :            :          * determined before calling tg3_set_power_state() so that
   16667                 :            :          * we know whether or not to switch out of Vaux power.
   16668                 :            :          * When the flag is set, it means that GPIO1 is used for eeprom
   16669                 :            :          * write protect and also implies that it is a LOM where GPIOs
   16670                 :            :          * are not used to switch power.
   16671                 :            :          */
   16672                 :          0 :         tg3_get_eeprom_hw_cfg(tp);
   16673                 :            : 
   16674   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, FW_TSO) && tg3_flag(tp, ENABLE_ASF)) {
   16675                 :          0 :                 tg3_flag_clear(tp, TSO_CAPABLE);
   16676                 :          0 :                 tg3_flag_clear(tp, TSO_BUG);
   16677                 :          0 :                 tp->fw_needed = NULL;
   16678                 :            :         }
   16679                 :            : 
   16680         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_APE)) {
   16681                 :            :                 /* Allow reads and writes to the
   16682                 :            :                  * APE register and memory space.
   16683                 :            :                  */
   16684                 :          0 :                 pci_state_reg |= PCISTATE_ALLOW_APE_CTLSPC_WR |
   16685                 :            :                                  PCISTATE_ALLOW_APE_SHMEM_WR |
   16686                 :            :                                  PCISTATE_ALLOW_APE_PSPACE_WR;
   16687                 :          0 :                 pci_write_config_dword(tp->pdev, TG3PCI_PCISTATE,
   16688                 :            :                                        pci_state_reg);
   16689                 :            : 
   16690                 :          0 :                 tg3_ape_lock_init(tp);
   16691                 :          0 :                 tp->ape_hb_interval =
   16692                 :            :                         msecs_to_jiffies(APE_HOST_HEARTBEAT_INT_5SEC);
   16693                 :            :         }
   16694                 :            : 
   16695                 :            :         /* Set up tp->grc_local_ctrl before calling
   16696                 :            :          * tg3_pwrsrc_switch_to_vmain().  GPIO1 driven high
   16697                 :            :          * will bring 5700's external PHY out of reset.
   16698                 :            :          * It is also used as eeprom write protect on LOMs.
   16699                 :            :          */
   16700                 :          0 :         tp->grc_local_ctrl = GRC_LCLCTRL_INT_ON_ATTN | GRC_LCLCTRL_AUTO_SEEPROM;
   16701   [ #  #  #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5700 ||
   16702                 :            :             tg3_flag(tp, EEPROM_WRITE_PROT))
   16703                 :          0 :                 tp->grc_local_ctrl |= (GRC_LCLCTRL_GPIO_OE1 |
   16704                 :            :                                        GRC_LCLCTRL_GPIO_OUTPUT1);
   16705                 :            :         /* Unused GPIO3 must be driven as output on 5752 because there
   16706                 :            :          * are no pull-up resistors on unused GPIO pins.
   16707                 :            :          */
   16708         [ #  # ]:          0 :         else if (tg3_asic_rev(tp) == ASIC_REV_5752)
   16709                 :          0 :                 tp->grc_local_ctrl |= GRC_LCLCTRL_GPIO_OE3;
   16710                 :            : 
   16711         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5755 ||
   16712         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_57780 ||
   16713                 :            :             tg3_flag(tp, 57765_CLASS))
   16714                 :          0 :                 tp->grc_local_ctrl |= GRC_LCLCTRL_GPIO_UART_SEL;
   16715                 :            : 
   16716         [ #  # ]:          0 :         if (tp->pdev->device == PCI_DEVICE_ID_TIGON3_5761 ||
   16717                 :            :             tp->pdev->device == TG3PCI_DEVICE_TIGON3_5761S) {
   16718                 :            :                 /* Turn off the debug UART. */
   16719                 :          0 :                 tp->grc_local_ctrl |= GRC_LCLCTRL_GPIO_UART_SEL;
   16720         [ #  # ]:          0 :                 if (tg3_flag(tp, IS_NIC))
   16721                 :            :                         /* Keep VMain power. */
   16722                 :          0 :                         tp->grc_local_ctrl |= GRC_LCLCTRL_GPIO_OE0 |
   16723                 :            :                                               GRC_LCLCTRL_GPIO_OUTPUT0;
   16724                 :            :         }
   16725                 :            : 
   16726         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5762)
   16727                 :          0 :                 tp->grc_local_ctrl |=
   16728                 :          0 :                         tr32(GRC_LOCAL_CTRL) & GRC_LCLCTRL_GPIO_UART_SEL;
   16729                 :            : 
   16730                 :            :         /* Switch out of Vaux if it is a NIC */
   16731                 :          0 :         tg3_pwrsrc_switch_to_vmain(tp);
   16732                 :            : 
   16733                 :            :         /* Derive initial jumbo mode from MTU assigned in
   16734                 :            :          * ether_setup() via the alloc_etherdev() call
   16735                 :            :          */
   16736   [ #  #  #  # ]:          0 :         if (tp->dev->mtu > ETH_DATA_LEN && !tg3_flag(tp, 5780_CLASS))
   16737                 :          0 :                 tg3_flag_set(tp, JUMBO_RING_ENABLE);
   16738                 :            : 
   16739                 :            :         /* Determine WakeOnLan speed to use. */
   16740   [ #  #  #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5700 ||
   16741         [ #  # ]:          0 :             tg3_chip_rev_id(tp) == CHIPREV_ID_5701_A0 ||
   16742         [ #  # ]:          0 :             tg3_chip_rev_id(tp) == CHIPREV_ID_5701_B0 ||
   16743                 :            :             tg3_chip_rev_id(tp) == CHIPREV_ID_5701_B2) {
   16744                 :          0 :                 tg3_flag_clear(tp, WOL_SPEED_100MB);
   16745                 :            :         } else {
   16746                 :          0 :                 tg3_flag_set(tp, WOL_SPEED_100MB);
   16747                 :            :         }
   16748                 :            : 
   16749         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5906)
   16750                 :          0 :                 tp->phy_flags |= TG3_PHYFLG_IS_FET;
   16751                 :            : 
   16752                 :            :         /* A few boards don't want Ethernet@WireSpeed phy feature */
   16753   [ #  #  #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5700 ||
   16754         [ #  # ]:          0 :             (tg3_asic_rev(tp) == ASIC_REV_5705 &&
   16755         [ #  # ]:          0 :              (tg3_chip_rev_id(tp) != CHIPREV_ID_5705_A0) &&
   16756                 :            :              (tg3_chip_rev_id(tp) != CHIPREV_ID_5705_A1)) ||
   16757         [ #  # ]:          0 :             (tp->phy_flags & TG3_PHYFLG_IS_FET) ||
   16758                 :            :             (tp->phy_flags & TG3_PHYFLG_ANY_SERDES))
   16759                 :          0 :                 tp->phy_flags |= TG3_PHYFLG_NO_ETH_WIRE_SPEED;
   16760                 :            : 
   16761         [ #  # ]:          0 :         if (tg3_chip_rev(tp) == CHIPREV_5703_AX ||
   16762                 :            :             tg3_chip_rev(tp) == CHIPREV_5704_AX)
   16763                 :          0 :                 tp->phy_flags |= TG3_PHYFLG_ADC_BUG;
   16764         [ #  # ]:          0 :         if (tg3_chip_rev_id(tp) == CHIPREV_ID_5704_A0)
   16765                 :          0 :                 tp->phy_flags |= TG3_PHYFLG_5704_A0_BUG;
   16766                 :            : 
   16767         [ #  # ]:          0 :         if (tg3_flag(tp, 5705_PLUS) &&
   16768         [ #  # ]:          0 :             !(tp->phy_flags & TG3_PHYFLG_IS_FET) &&
   16769   [ #  #  #  # ]:          0 :             tg3_asic_rev(tp) != ASIC_REV_5785 &&
   16770         [ #  # ]:          0 :             tg3_asic_rev(tp) != ASIC_REV_57780 &&
   16771                 :            :             !tg3_flag(tp, 57765_PLUS)) {
   16772                 :          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5755 ||
   16773         [ #  # ]:          0 :                     tg3_asic_rev(tp) == ASIC_REV_5787 ||
   16774         [ #  # ]:          0 :                     tg3_asic_rev(tp) == ASIC_REV_5784 ||
   16775                 :            :                     tg3_asic_rev(tp) == ASIC_REV_5761) {
   16776         [ #  # ]:          0 :                         if (tp->pdev->device != PCI_DEVICE_ID_TIGON3_5756 &&
   16777                 :            :                             tp->pdev->device != PCI_DEVICE_ID_TIGON3_5722)
   16778                 :          0 :                                 tp->phy_flags |= TG3_PHYFLG_JITTER_BUG;
   16779         [ #  # ]:          0 :                         if (tp->pdev->device == PCI_DEVICE_ID_TIGON3_5755M)
   16780                 :          0 :                                 tp->phy_flags |= TG3_PHYFLG_ADJUST_TRIM;
   16781                 :            :                 } else
   16782                 :          0 :                         tp->phy_flags |= TG3_PHYFLG_BER_BUG;
   16783                 :            :         }
   16784                 :            : 
   16785         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5784 &&
   16786         [ #  # ]:          0 :             tg3_chip_rev(tp) != CHIPREV_5784_AX) {
   16787                 :          0 :                 tp->phy_otp = tg3_read_otp_phycfg(tp);
   16788         [ #  # ]:          0 :                 if (tp->phy_otp == 0)
   16789                 :          0 :                         tp->phy_otp = TG3_OTP_DEFAULT;
   16790                 :            :         }
   16791                 :            : 
   16792         [ #  # ]:          0 :         if (tg3_flag(tp, CPMU_PRESENT))
   16793                 :          0 :                 tp->mi_mode = MAC_MI_MODE_500KHZ_CONST;
   16794                 :            :         else
   16795                 :          0 :                 tp->mi_mode = MAC_MI_MODE_BASE;
   16796                 :            : 
   16797                 :          0 :         tp->coalesce_mode = 0;
   16798         [ #  # ]:          0 :         if (tg3_chip_rev(tp) != CHIPREV_5700_AX &&
   16799                 :            :             tg3_chip_rev(tp) != CHIPREV_5700_BX)
   16800                 :          0 :                 tp->coalesce_mode |= HOSTCC_MODE_32BYTE;
   16801                 :            : 
   16802                 :            :         /* Set these bits to enable statistics workaround. */
   16803         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5717 ||
   16804         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5762 ||
   16805         [ #  # ]:          0 :             tg3_chip_rev_id(tp) == CHIPREV_ID_5719_A0 ||
   16806                 :            :             tg3_chip_rev_id(tp) == CHIPREV_ID_5720_A0) {
   16807                 :          0 :                 tp->coalesce_mode |= HOSTCC_MODE_ATTN;
   16808                 :          0 :                 tp->grc_mode |= GRC_MODE_IRQ_ON_FLOW_ATTN;
   16809                 :            :         }
   16810                 :            : 
   16811         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5785 ||
   16812                 :            :             tg3_asic_rev(tp) == ASIC_REV_57780)
   16813                 :          0 :                 tg3_flag_set(tp, USE_PHYLIB);
   16814                 :            : 
   16815                 :          0 :         err = tg3_mdio_init(tp);
   16816         [ #  # ]:          0 :         if (err)
   16817                 :            :                 return err;
   16818                 :            : 
   16819                 :            :         /* Initialize data/descriptor byte/word swapping. */
   16820                 :          0 :         val = tr32(GRC_MODE);
   16821         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5720 ||
   16822                 :            :             tg3_asic_rev(tp) == ASIC_REV_5762)
   16823                 :          0 :                 val &= (GRC_MODE_BYTE_SWAP_B2HRX_DATA |
   16824                 :            :                         GRC_MODE_WORD_SWAP_B2HRX_DATA |
   16825                 :            :                         GRC_MODE_B2HRX_ENABLE |
   16826                 :            :                         GRC_MODE_HTX2B_ENABLE |
   16827                 :            :                         GRC_MODE_HOST_STACKUP);
   16828                 :            :         else
   16829                 :          0 :                 val &= GRC_MODE_HOST_STACKUP;
   16830                 :            : 
   16831                 :          0 :         tw32(GRC_MODE, val | tp->grc_mode);
   16832                 :            : 
   16833                 :          0 :         tg3_switch_clocks(tp);
   16834                 :            : 
   16835                 :            :         /* Clear this out for sanity. */
   16836                 :          0 :         tw32(TG3PCI_MEM_WIN_BASE_ADDR, 0);
   16837                 :            : 
   16838                 :            :         /* Clear TG3PCI_REG_BASE_ADDR to prevent hangs. */
   16839                 :          0 :         tw32(TG3PCI_REG_BASE_ADDR, 0);
   16840                 :            : 
   16841                 :          0 :         pci_read_config_dword(tp->pdev, TG3PCI_PCISTATE,
   16842                 :            :                               &pci_state_reg);
   16843   [ #  #  #  # ]:          0 :         if ((pci_state_reg & PCISTATE_CONV_PCI_MODE) == 0 &&
   16844                 :            :             !tg3_flag(tp, PCIX_TARGET_HWBUG)) {
   16845         [ #  # ]:          0 :                 if (tg3_chip_rev_id(tp) == CHIPREV_ID_5701_A0 ||
   16846         [ #  # ]:          0 :                     tg3_chip_rev_id(tp) == CHIPREV_ID_5701_B0 ||
   16847         [ #  # ]:          0 :                     tg3_chip_rev_id(tp) == CHIPREV_ID_5701_B2 ||
   16848                 :            :                     tg3_chip_rev_id(tp) == CHIPREV_ID_5701_B5) {
   16849                 :          0 :                         void __iomem *sram_base;
   16850                 :            : 
   16851                 :            :                         /* Write some dummy words into the SRAM status block
   16852                 :            :                          * area, see if it reads back correctly.  If the return
   16853                 :            :                          * value is bad, force enable the PCIX workaround.
   16854                 :            :                          */
   16855                 :          0 :                         sram_base = tp->regs + NIC_SRAM_WIN_BASE + NIC_SRAM_STATS_BLK;
   16856                 :            : 
   16857                 :          0 :                         writel(0x00000000, sram_base);
   16858                 :          0 :                         writel(0x00000000, sram_base + 4);
   16859                 :          0 :                         writel(0xffffffff, sram_base + 4);
   16860         [ #  # ]:          0 :                         if (readl(sram_base) != 0x00000000)
   16861                 :          0 :                                 tg3_flag_set(tp, PCIX_TARGET_HWBUG);
   16862                 :            :                 }
   16863                 :            :         }
   16864                 :            : 
   16865                 :          0 :         udelay(50);
   16866                 :          0 :         tg3_nvram_init(tp);
   16867                 :            : 
   16868                 :            :         /* If the device has an NVRAM, no need to load patch firmware */
   16869   [ #  #  #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_57766 &&
   16870                 :            :             !tg3_flag(tp, NO_NVRAM))
   16871                 :          0 :                 tp->fw_needed = NULL;
   16872                 :            : 
   16873                 :          0 :         grc_misc_cfg = tr32(GRC_MISC_CFG);
   16874                 :          0 :         grc_misc_cfg &= GRC_MISC_CFG_BOARD_ID_MASK;
   16875                 :            : 
   16876         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5705 &&
   16877                 :          0 :             (grc_misc_cfg == GRC_MISC_CFG_BOARD_ID_5788 ||
   16878         [ #  # ]:          0 :              grc_misc_cfg == GRC_MISC_CFG_BOARD_ID_5788M))
   16879                 :          0 :                 tg3_flag_set(tp, IS_5788);
   16880                 :            : 
   16881         [ #  # ]:          0 :         if (!tg3_flag(tp, IS_5788) &&
   16882         [ #  # ]:          0 :             tg3_asic_rev(tp) != ASIC_REV_5700)
   16883                 :          0 :                 tg3_flag_set(tp, TAGGED_STATUS);
   16884         [ #  # ]:          0 :         if (tg3_flag(tp, TAGGED_STATUS)) {
   16885                 :          0 :                 tp->coalesce_mode |= (HOSTCC_MODE_CLRTICK_RXBD |
   16886                 :            :                                       HOSTCC_MODE_CLRTICK_TXBD);
   16887                 :            : 
   16888                 :          0 :                 tp->misc_host_ctrl |= MISC_HOST_CTRL_TAGGED_STATUS;
   16889                 :          0 :                 pci_write_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
   16890                 :            :                                        tp->misc_host_ctrl);
   16891                 :            :         }
   16892                 :            : 
   16893                 :            :         /* Preserve the APE MAC_MODE bits */
   16894         [ #  # ]:          0 :         if (tg3_flag(tp, ENABLE_APE))
   16895                 :          0 :                 tp->mac_mode = MAC_MODE_APE_TX_EN | MAC_MODE_APE_RX_EN;
   16896                 :            :         else
   16897                 :          0 :                 tp->mac_mode = 0;
   16898                 :            : 
   16899         [ #  # ]:          0 :         if (tg3_10_100_only_device(tp, ent))
   16900                 :          0 :                 tp->phy_flags |= TG3_PHYFLG_10_100_ONLY;
   16901                 :            : 
   16902                 :          0 :         err = tg3_phy_probe(tp);
   16903         [ #  # ]:          0 :         if (err) {
   16904                 :          0 :                 dev_err(&tp->pdev->dev, "phy probe failed, err %d\n", err);
   16905                 :            :                 /* ... but do not return immediately ... */
   16906                 :          0 :                 tg3_mdio_fini(tp);
   16907                 :            :         }
   16908                 :            : 
   16909                 :          0 :         tg3_read_vpd(tp);
   16910                 :          0 :         tg3_read_fw_ver(tp);
   16911                 :            : 
   16912         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_PHY_SERDES) {
   16913                 :          0 :                 tp->phy_flags &= ~TG3_PHYFLG_USE_MI_INTERRUPT;
   16914                 :            :         } else {
   16915         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5700)
   16916                 :          0 :                         tp->phy_flags |= TG3_PHYFLG_USE_MI_INTERRUPT;
   16917                 :            :                 else
   16918                 :          0 :                         tp->phy_flags &= ~TG3_PHYFLG_USE_MI_INTERRUPT;
   16919                 :            :         }
   16920                 :            : 
   16921                 :            :         /* 5700 {AX,BX} chips have a broken status block link
   16922                 :            :          * change bit implementation, so we must use the
   16923                 :            :          * status register in those cases.
   16924                 :            :          */
   16925         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5700)
   16926                 :          0 :                 tg3_flag_set(tp, USE_LINKCHG_REG);
   16927                 :            :         else
   16928                 :          0 :                 tg3_flag_clear(tp, USE_LINKCHG_REG);
   16929                 :            : 
   16930                 :            :         /* The led_ctrl is set during tg3_phy_probe, here we might
   16931                 :            :          * have to force the link status polling mechanism based
   16932                 :            :          * upon subsystem IDs.
   16933                 :            :          */
   16934         [ #  # ]:          0 :         if (tp->pdev->subsystem_vendor == PCI_VENDOR_ID_DELL &&
   16935         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5701 &&
   16936         [ #  # ]:          0 :             !(tp->phy_flags & TG3_PHYFLG_PHY_SERDES)) {
   16937                 :          0 :                 tp->phy_flags |= TG3_PHYFLG_USE_MI_INTERRUPT;
   16938                 :          0 :                 tg3_flag_set(tp, USE_LINKCHG_REG);
   16939                 :            :         }
   16940                 :            : 
   16941                 :            :         /* For all SERDES we poll the MAC status register. */
   16942         [ #  # ]:          0 :         if (tp->phy_flags & TG3_PHYFLG_PHY_SERDES)
   16943                 :          0 :                 tg3_flag_set(tp, POLL_SERDES);
   16944                 :            :         else
   16945                 :          0 :                 tg3_flag_clear(tp, POLL_SERDES);
   16946                 :            : 
   16947   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, ENABLE_APE) && tg3_flag(tp, ENABLE_ASF))
   16948                 :          0 :                 tg3_flag_set(tp, POLL_CPMU_LINK);
   16949                 :            : 
   16950                 :          0 :         tp->rx_offset = NET_SKB_PAD + NET_IP_ALIGN;
   16951                 :          0 :         tp->rx_copy_thresh = TG3_RX_COPY_THRESHOLD;
   16952   [ #  #  #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5701 &&
   16953                 :            :             tg3_flag(tp, PCIX_MODE)) {
   16954                 :          0 :                 tp->rx_offset = NET_SKB_PAD;
   16955                 :            : #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
   16956                 :            :                 tp->rx_copy_thresh = ~(u16)0;
   16957                 :            : #endif
   16958                 :            :         }
   16959                 :            : 
   16960         [ #  # ]:          0 :         tp->rx_std_ring_mask = TG3_RX_STD_RING_SIZE(tp) - 1;
   16961         [ #  # ]:          0 :         tp->rx_jmb_ring_mask = TG3_RX_JMB_RING_SIZE(tp) - 1;
   16962                 :          0 :         tp->rx_ret_ring_mask = tg3_rx_ret_ring_size(tp) - 1;
   16963                 :            : 
   16964                 :          0 :         tp->rx_std_max_post = tp->rx_std_ring_mask + 1;
   16965                 :            : 
   16966                 :            :         /* Increment the rx prod index on the rx std ring by at most
   16967                 :            :          * 8 for these chips to workaround hw errata.
   16968                 :            :          */
   16969         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5750 ||
   16970         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5752 ||
   16971                 :            :             tg3_asic_rev(tp) == ASIC_REV_5755)
   16972                 :          0 :                 tp->rx_std_max_post = 8;
   16973                 :            : 
   16974         [ #  # ]:          0 :         if (tg3_flag(tp, ASPM_WORKAROUND))
   16975                 :          0 :                 tp->pwrmgmt_thresh = tr32(PCIE_PWR_MGMT_THRESH) &
   16976                 :            :                                      PCIE_PWR_MGMT_L1_THRESH_MSK;
   16977                 :            : 
   16978                 :            :         return err;
   16979                 :            : }
   16980                 :            : 
   16981                 :          0 : static int tg3_get_device_address(struct tg3 *tp)
   16982                 :            : {
   16983                 :          0 :         struct net_device *dev = tp->dev;
   16984                 :          0 :         u32 hi, lo, mac_offset;
   16985                 :          0 :         int addr_ok = 0;
   16986                 :          0 :         int err;
   16987                 :            : 
   16988         [ #  # ]:          0 :         if (!eth_platform_get_mac_address(&tp->pdev->dev, dev->dev_addr))
   16989                 :            :                 return 0;
   16990                 :            : 
   16991                 :          0 :         if (tg3_flag(tp, IS_SSB_CORE)) {
   16992                 :            :                 err = ssb_gige_get_macaddr(tp->pdev, &dev->dev_addr[0]);
   16993                 :            :                 if (!err && is_valid_ether_addr(&dev->dev_addr[0]))
   16994                 :            :                         return 0;
   16995                 :            :         }
   16996                 :            : 
   16997                 :          0 :         mac_offset = 0x7c;
   16998   [ #  #  #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5704 ||
   16999                 :            :             tg3_flag(tp, 5780_CLASS)) {
   17000         [ #  # ]:          0 :                 if (tr32(TG3PCI_DUAL_MAC_CTRL) & DUAL_MAC_CTRL_ID)
   17001                 :          0 :                         mac_offset = 0xcc;
   17002         [ #  # ]:          0 :                 if (tg3_nvram_lock(tp))
   17003                 :          0 :                         tw32_f(NVRAM_CMD, NVRAM_CMD_RESET);
   17004                 :            :                 else
   17005                 :          0 :                         tg3_nvram_unlock(tp);
   17006         [ #  # ]:          0 :         } else if (tg3_flag(tp, 5717_PLUS)) {
   17007         [ #  # ]:          0 :                 if (tp->pci_fn & 1)
   17008                 :          0 :                         mac_offset = 0xcc;
   17009         [ #  # ]:          0 :                 if (tp->pci_fn > 1)
   17010                 :          0 :                         mac_offset += 0x18c;
   17011         [ #  # ]:          0 :         } else if (tg3_asic_rev(tp) == ASIC_REV_5906)
   17012                 :          0 :                 mac_offset = 0x10;
   17013                 :            : 
   17014                 :            :         /* First try to get it from MAC address mailbox. */
   17015                 :          0 :         tg3_read_mem(tp, NIC_SRAM_MAC_ADDR_HIGH_MBOX, &hi);
   17016         [ #  # ]:          0 :         if ((hi >> 16) == 0x484b) {
   17017                 :          0 :                 dev->dev_addr[0] = (hi >>  8) & 0xff;
   17018                 :          0 :                 dev->dev_addr[1] = (hi >>  0) & 0xff;
   17019                 :            : 
   17020                 :          0 :                 tg3_read_mem(tp, NIC_SRAM_MAC_ADDR_LOW_MBOX, &lo);
   17021                 :          0 :                 dev->dev_addr[2] = (lo >> 24) & 0xff;
   17022                 :          0 :                 dev->dev_addr[3] = (lo >> 16) & 0xff;
   17023                 :          0 :                 dev->dev_addr[4] = (lo >>  8) & 0xff;
   17024                 :          0 :                 dev->dev_addr[5] = (lo >>  0) & 0xff;
   17025                 :            : 
   17026                 :            :                 /* Some old bootcode may report a 0 MAC address in SRAM */
   17027         [ #  # ]:          0 :                 addr_ok = is_valid_ether_addr(&dev->dev_addr[0]);
   17028                 :            :         }
   17029                 :            :         if (!addr_ok) {
   17030                 :            :                 /* Next, try NVRAM. */
   17031   [ #  #  #  # ]:          0 :                 if (!tg3_flag(tp, NO_NVRAM) &&
   17032         [ #  # ]:          0 :                     !tg3_nvram_read_be32(tp, mac_offset + 0, &hi) &&
   17033                 :          0 :                     !tg3_nvram_read_be32(tp, mac_offset + 4, &lo)) {
   17034                 :          0 :                         memcpy(&dev->dev_addr[0], ((char *)&hi) + 2, 2);
   17035                 :          0 :                         memcpy(&dev->dev_addr[2], (char *)&lo, sizeof(lo));
   17036                 :            :                 }
   17037                 :            :                 /* Finally just fetch it out of the MAC control regs. */
   17038                 :            :                 else {
   17039                 :          0 :                         hi = tr32(MAC_ADDR_0_HIGH);
   17040                 :          0 :                         lo = tr32(MAC_ADDR_0_LOW);
   17041                 :            : 
   17042                 :          0 :                         dev->dev_addr[5] = lo & 0xff;
   17043                 :          0 :                         dev->dev_addr[4] = (lo >> 8) & 0xff;
   17044                 :          0 :                         dev->dev_addr[3] = (lo >> 16) & 0xff;
   17045                 :          0 :                         dev->dev_addr[2] = (lo >> 24) & 0xff;
   17046                 :          0 :                         dev->dev_addr[1] = hi & 0xff;
   17047                 :          0 :                         dev->dev_addr[0] = (hi >> 8) & 0xff;
   17048                 :            :                 }
   17049                 :            :         }
   17050                 :            : 
   17051   [ #  #  #  # ]:          0 :         if (!is_valid_ether_addr(&dev->dev_addr[0]))
   17052                 :          0 :                 return -EINVAL;
   17053                 :            :         return 0;
   17054                 :            : }
   17055                 :            : 
   17056                 :            : #define BOUNDARY_SINGLE_CACHELINE       1
   17057                 :            : #define BOUNDARY_MULTI_CACHELINE        2
   17058                 :            : 
   17059                 :          0 : static u32 tg3_calc_dma_bndry(struct tg3 *tp, u32 val)
   17060                 :            : {
   17061                 :          0 :         int cacheline_size;
   17062                 :          0 :         u8 byte;
   17063                 :          0 :         int goal;
   17064                 :            : 
   17065                 :          0 :         pci_read_config_byte(tp->pdev, PCI_CACHE_LINE_SIZE, &byte);
   17066                 :          0 :         if (byte == 0)
   17067                 :            :                 cacheline_size = 1024;
   17068                 :            :         else
   17069                 :            :                 cacheline_size = (int) byte * 4;
   17070                 :            : 
   17071                 :            :         /* On 5703 and later chips, the boundary bits have no
   17072                 :            :          * effect.
   17073                 :            :          */
   17074         [ #  # ]:          0 :         if (tg3_asic_rev(tp) != ASIC_REV_5700 &&
   17075         [ #  # ]:          0 :             tg3_asic_rev(tp) != ASIC_REV_5701 &&
   17076                 :          0 :             !tg3_flag(tp, PCI_EXPRESS))
   17077                 :          0 :                 goto out;
   17078                 :            : 
   17079                 :            : #if defined(CONFIG_PPC64) || defined(CONFIG_IA64) || defined(CONFIG_PARISC)
   17080                 :            :         goal = BOUNDARY_MULTI_CACHELINE;
   17081                 :            : #else
   17082                 :            : #if defined(CONFIG_SPARC64) || defined(CONFIG_ALPHA)
   17083                 :            :         goal = BOUNDARY_SINGLE_CACHELINE;
   17084                 :            : #else
   17085                 :          0 :         goal = 0;
   17086                 :            : #endif
   17087                 :            : #endif
   17088                 :            : 
   17089         [ #  # ]:          0 :         if (tg3_flag(tp, 57765_PLUS)) {
   17090                 :          0 :                 val = goal ? 0 : DMA_RWCTRL_DIS_CACHE_ALIGNMENT;
   17091                 :          0 :                 goto out;
   17092                 :            :         }
   17093                 :            : 
   17094                 :          0 :         if (!goal)
   17095                 :          0 :                 goto out;
   17096                 :            : 
   17097                 :            :         /* PCI controllers on most RISC systems tend to disconnect
   17098                 :            :          * when a device tries to burst across a cache-line boundary.
   17099                 :            :          * Therefore, letting tg3 do so just wastes PCI bandwidth.
   17100                 :            :          *
   17101                 :            :          * Unfortunately, for PCI-E there are only limited
   17102                 :            :          * write-side controls for this, and thus for reads
   17103                 :            :          * we will still get the disconnects.  We'll also waste
   17104                 :            :          * these PCI cycles for both read and write for chips
   17105                 :            :          * other than 5700 and 5701 which do not implement the
   17106                 :            :          * boundary bits.
   17107                 :            :          */
   17108                 :            :         if (tg3_flag(tp, PCIX_MODE) && !tg3_flag(tp, PCI_EXPRESS)) {
   17109                 :            :                 switch (cacheline_size) {
   17110                 :            :                 case 16:
   17111                 :            :                 case 32:
   17112                 :            :                 case 64:
   17113                 :            :                 case 128:
   17114                 :            :                         if (goal == BOUNDARY_SINGLE_CACHELINE) {
   17115                 :            :                                 val |= (DMA_RWCTRL_READ_BNDRY_128_PCIX |
   17116                 :            :                                         DMA_RWCTRL_WRITE_BNDRY_128_PCIX);
   17117                 :            :                         } else {
   17118                 :            :                                 val |= (DMA_RWCTRL_READ_BNDRY_384_PCIX |
   17119                 :            :                                         DMA_RWCTRL_WRITE_BNDRY_384_PCIX);
   17120                 :            :                         }
   17121                 :            :                         break;
   17122                 :            : 
   17123                 :            :                 case 256:
   17124                 :            :                         val |= (DMA_RWCTRL_READ_BNDRY_256_PCIX |
   17125                 :            :                                 DMA_RWCTRL_WRITE_BNDRY_256_PCIX);
   17126                 :            :                         break;
   17127                 :            : 
   17128                 :            :                 default:
   17129                 :            :                         val |= (DMA_RWCTRL_READ_BNDRY_384_PCIX |
   17130                 :            :                                 DMA_RWCTRL_WRITE_BNDRY_384_PCIX);
   17131                 :            :                         break;
   17132                 :            :                 }
   17133                 :            :         } else if (tg3_flag(tp, PCI_EXPRESS)) {
   17134                 :            :                 switch (cacheline_size) {
   17135                 :            :                 case 16:
   17136                 :            :                 case 32:
   17137                 :            :                 case 64:
   17138                 :            :                         if (goal == BOUNDARY_SINGLE_CACHELINE) {
   17139                 :            :                                 val &= ~DMA_RWCTRL_WRITE_BNDRY_DISAB_PCIE;
   17140                 :            :                                 val |= DMA_RWCTRL_WRITE_BNDRY_64_PCIE;
   17141                 :            :                                 break;
   17142                 :            :                         }
   17143                 :            :                         /* fallthrough */
   17144                 :            :                 case 128:
   17145                 :            :                 default:
   17146                 :            :                         val &= ~DMA_RWCTRL_WRITE_BNDRY_DISAB_PCIE;
   17147                 :            :                         val |= DMA_RWCTRL_WRITE_BNDRY_128_PCIE;
   17148                 :            :                         break;
   17149                 :            :                 }
   17150                 :            :         } else {
   17151                 :            :                 switch (cacheline_size) {
   17152                 :            :                 case 16:
   17153                 :            :                         if (goal == BOUNDARY_SINGLE_CACHELINE) {
   17154                 :            :                                 val |= (DMA_RWCTRL_READ_BNDRY_16 |
   17155                 :            :                                         DMA_RWCTRL_WRITE_BNDRY_16);
   17156                 :            :                                 break;
   17157                 :            :                         }
   17158                 :            :                         /* fallthrough */
   17159                 :            :                 case 32:
   17160                 :            :                         if (goal == BOUNDARY_SINGLE_CACHELINE) {
   17161                 :            :                                 val |= (DMA_RWCTRL_READ_BNDRY_32 |
   17162                 :            :                                         DMA_RWCTRL_WRITE_BNDRY_32);
   17163                 :            :                                 break;
   17164                 :            :                         }
   17165                 :            :                         /* fallthrough */
   17166                 :            :                 case 64:
   17167                 :            :                         if (goal == BOUNDARY_SINGLE_CACHELINE) {
   17168                 :            :                                 val |= (DMA_RWCTRL_READ_BNDRY_64 |
   17169                 :            :                                         DMA_RWCTRL_WRITE_BNDRY_64);
   17170                 :            :                                 break;
   17171                 :            :                         }
   17172                 :            :                         /* fallthrough */
   17173                 :            :                 case 128:
   17174                 :            :                         if (goal == BOUNDARY_SINGLE_CACHELINE) {
   17175                 :            :                                 val |= (DMA_RWCTRL_READ_BNDRY_128 |
   17176                 :            :                                         DMA_RWCTRL_WRITE_BNDRY_128);
   17177                 :            :                                 break;
   17178                 :            :                         }
   17179                 :            :                         /* fallthrough */
   17180                 :            :                 case 256:
   17181                 :            :                         val |= (DMA_RWCTRL_READ_BNDRY_256 |
   17182                 :            :                                 DMA_RWCTRL_WRITE_BNDRY_256);
   17183                 :            :                         break;
   17184                 :            :                 case 512:
   17185                 :            :                         val |= (DMA_RWCTRL_READ_BNDRY_512 |
   17186                 :            :                                 DMA_RWCTRL_WRITE_BNDRY_512);
   17187                 :            :                         break;
   17188                 :            :                 case 1024:
   17189                 :            :                 default:
   17190                 :            :                         val |= (DMA_RWCTRL_READ_BNDRY_1024 |
   17191                 :            :                                 DMA_RWCTRL_WRITE_BNDRY_1024);
   17192                 :            :                         break;
   17193                 :            :                 }
   17194                 :            :         }
   17195                 :            : 
   17196                 :          0 : out:
   17197                 :          0 :         return val;
   17198                 :            : }
   17199                 :            : 
   17200                 :          0 : static int tg3_do_test_dma(struct tg3 *tp, u32 *buf, dma_addr_t buf_dma,
   17201                 :            :                            int size, bool to_device)
   17202                 :            : {
   17203                 :          0 :         struct tg3_internal_buffer_desc test_desc;
   17204                 :          0 :         u32 sram_dma_descs;
   17205                 :          0 :         int i, ret;
   17206                 :            : 
   17207                 :          0 :         sram_dma_descs = NIC_SRAM_DMA_DESC_POOL_BASE;
   17208                 :            : 
   17209                 :          0 :         tw32(FTQ_RCVBD_COMP_FIFO_ENQDEQ, 0);
   17210                 :          0 :         tw32(FTQ_RCVDATA_COMP_FIFO_ENQDEQ, 0);
   17211                 :          0 :         tw32(RDMAC_STATUS, 0);
   17212                 :          0 :         tw32(WDMAC_STATUS, 0);
   17213                 :            : 
   17214                 :          0 :         tw32(BUFMGR_MODE, 0);
   17215                 :          0 :         tw32(FTQ_RESET, 0);
   17216                 :            : 
   17217                 :          0 :         test_desc.addr_hi = ((u64) buf_dma) >> 32;
   17218                 :          0 :         test_desc.addr_lo = buf_dma & 0xffffffff;
   17219                 :          0 :         test_desc.nic_mbuf = 0x00002100;
   17220                 :          0 :         test_desc.len = size;
   17221                 :            : 
   17222                 :            :         /*
   17223                 :            :          * HP ZX1 was seeing test failures for 5701 cards running at 33Mhz
   17224                 :            :          * the *second* time the tg3 driver was getting loaded after an
   17225                 :            :          * initial scan.
   17226                 :            :          *
   17227                 :            :          * Broadcom tells me:
   17228                 :            :          *   ...the DMA engine is connected to the GRC block and a DMA
   17229                 :            :          *   reset may affect the GRC block in some unpredictable way...
   17230                 :            :          *   The behavior of resets to individual blocks has not been tested.
   17231                 :            :          *
   17232                 :            :          * Broadcom noted the GRC reset will also reset all sub-components.
   17233                 :            :          */
   17234         [ #  # ]:          0 :         if (to_device) {
   17235                 :          0 :                 test_desc.cqid_sqid = (13 << 8) | 2;
   17236                 :            : 
   17237                 :          0 :                 tw32_f(RDMAC_MODE, RDMAC_MODE_ENABLE);
   17238                 :          0 :                 udelay(40);
   17239                 :            :         } else {
   17240                 :          0 :                 test_desc.cqid_sqid = (16 << 8) | 7;
   17241                 :            : 
   17242                 :          0 :                 tw32_f(WDMAC_MODE, WDMAC_MODE_ENABLE);
   17243                 :          0 :                 udelay(40);
   17244                 :            :         }
   17245                 :          0 :         test_desc.flags = 0x00000005;
   17246                 :            : 
   17247         [ #  # ]:          0 :         for (i = 0; i < (sizeof(test_desc) / sizeof(u32)); i++) {
   17248                 :          0 :                 u32 val;
   17249                 :            : 
   17250                 :          0 :                 val = *(((u32 *)&test_desc) + i);
   17251                 :          0 :                 pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR,
   17252                 :            :                                        sram_dma_descs + (i * sizeof(u32)));
   17253                 :          0 :                 pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_DATA, val);
   17254                 :            :         }
   17255                 :          0 :         pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, 0);
   17256                 :            : 
   17257         [ #  # ]:          0 :         if (to_device)
   17258                 :          0 :                 tw32(FTQ_DMA_HIGH_READ_FIFO_ENQDEQ, sram_dma_descs);
   17259                 :            :         else
   17260                 :          0 :                 tw32(FTQ_DMA_HIGH_WRITE_FIFO_ENQDEQ, sram_dma_descs);
   17261                 :            : 
   17262                 :            :         ret = -ENODEV;
   17263         [ #  # ]:          0 :         for (i = 0; i < 40; i++) {
   17264                 :          0 :                 u32 val;
   17265                 :            : 
   17266         [ #  # ]:          0 :                 if (to_device)
   17267                 :          0 :                         val = tr32(FTQ_RCVBD_COMP_FIFO_ENQDEQ);
   17268                 :            :                 else
   17269                 :          0 :                         val = tr32(FTQ_RCVDATA_COMP_FIFO_ENQDEQ);
   17270         [ #  # ]:          0 :                 if ((val & 0xffff) == sram_dma_descs) {
   17271                 :            :                         ret = 0;
   17272                 :            :                         break;
   17273                 :            :                 }
   17274                 :            : 
   17275                 :          0 :                 udelay(100);
   17276                 :            :         }
   17277                 :            : 
   17278                 :          0 :         return ret;
   17279                 :            : }
   17280                 :            : 
   17281                 :            : #define TEST_BUFFER_SIZE        0x2000
   17282                 :            : 
   17283                 :            : static const struct pci_device_id tg3_dma_wait_state_chipsets[] = {
   17284                 :            :         { PCI_DEVICE(PCI_VENDOR_ID_APPLE, PCI_DEVICE_ID_APPLE_UNI_N_PCI15) },
   17285                 :            :         { },
   17286                 :            : };
   17287                 :            : 
   17288                 :          0 : static int tg3_test_dma(struct tg3 *tp)
   17289                 :            : {
   17290                 :          0 :         dma_addr_t buf_dma;
   17291                 :          0 :         u32 *buf, saved_dma_rwctrl;
   17292                 :          0 :         int ret = 0;
   17293                 :            : 
   17294                 :          0 :         buf = dma_alloc_coherent(&tp->pdev->dev, TEST_BUFFER_SIZE,
   17295                 :            :                                  &buf_dma, GFP_KERNEL);
   17296         [ #  # ]:          0 :         if (!buf) {
   17297                 :          0 :                 ret = -ENOMEM;
   17298                 :          0 :                 goto out_nofree;
   17299                 :            :         }
   17300                 :            : 
   17301                 :          0 :         tp->dma_rwctrl = ((0x7 << DMA_RWCTRL_PCI_WRITE_CMD_SHIFT) |
   17302                 :            :                           (0x6 << DMA_RWCTRL_PCI_READ_CMD_SHIFT));
   17303                 :            : 
   17304                 :          0 :         tp->dma_rwctrl = tg3_calc_dma_bndry(tp, tp->dma_rwctrl);
   17305                 :            : 
   17306         [ #  # ]:          0 :         if (tg3_flag(tp, 57765_PLUS))
   17307                 :          0 :                 goto out;
   17308                 :            : 
   17309         [ #  # ]:          0 :         if (tg3_flag(tp, PCI_EXPRESS)) {
   17310                 :            :                 /* DMA read watermark not used on PCIE */
   17311                 :          0 :                 tp->dma_rwctrl |= 0x00180000;
   17312         [ #  # ]:          0 :         } else if (!tg3_flag(tp, PCIX_MODE)) {
   17313         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5705 ||
   17314                 :            :                     tg3_asic_rev(tp) == ASIC_REV_5750)
   17315                 :          0 :                         tp->dma_rwctrl |= 0x003f0000;
   17316                 :            :                 else
   17317                 :          0 :                         tp->dma_rwctrl |= 0x003f000f;
   17318                 :            :         } else {
   17319         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5703 ||
   17320                 :            :                     tg3_asic_rev(tp) == ASIC_REV_5704) {
   17321                 :          0 :                         u32 ccval = (tr32(TG3PCI_CLOCK_CTRL) & 0x1f);
   17322                 :          0 :                         u32 read_water = 0x7;
   17323                 :            : 
   17324                 :            :                         /* If the 5704 is behind the EPB bridge, we can
   17325                 :            :                          * do the less restrictive ONE_DMA workaround for
   17326                 :            :                          * better performance.
   17327                 :            :                          */
   17328         [ #  # ]:          0 :                         if (tg3_flag(tp, 40BIT_DMA_BUG) &&
   17329         [ #  # ]:          0 :                             tg3_asic_rev(tp) == ASIC_REV_5704)
   17330                 :          0 :                                 tp->dma_rwctrl |= 0x8000;
   17331         [ #  # ]:          0 :                         else if (ccval == 0x6 || ccval == 0x7)
   17332                 :          0 :                                 tp->dma_rwctrl |= DMA_RWCTRL_ONE_DMA;
   17333                 :            : 
   17334         [ #  # ]:          0 :                         if (tg3_asic_rev(tp) == ASIC_REV_5703)
   17335                 :          0 :                                 read_water = 4;
   17336                 :            :                         /* Set bit 23 to enable PCIX hw bug fix */
   17337                 :          0 :                         tp->dma_rwctrl |=
   17338                 :          0 :                                 (read_water << DMA_RWCTRL_READ_WATER_SHIFT) |
   17339                 :            :                                 (0x3 << DMA_RWCTRL_WRITE_WATER_SHIFT) |
   17340                 :            :                                 (1 << 23);
   17341         [ #  # ]:          0 :                 } else if (tg3_asic_rev(tp) == ASIC_REV_5780) {
   17342                 :            :                         /* 5780 always in PCIX mode */
   17343                 :          0 :                         tp->dma_rwctrl |= 0x00144000;
   17344         [ #  # ]:          0 :                 } else if (tg3_asic_rev(tp) == ASIC_REV_5714) {
   17345                 :            :                         /* 5714 always in PCIX mode */
   17346                 :          0 :                         tp->dma_rwctrl |= 0x00148000;
   17347                 :            :                 } else {
   17348                 :          0 :                         tp->dma_rwctrl |= 0x001b000f;
   17349                 :            :                 }
   17350                 :            :         }
   17351         [ #  # ]:          0 :         if (tg3_flag(tp, ONE_DMA_AT_ONCE))
   17352                 :          0 :                 tp->dma_rwctrl |= DMA_RWCTRL_ONE_DMA;
   17353                 :            : 
   17354         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5703 ||
   17355                 :            :             tg3_asic_rev(tp) == ASIC_REV_5704)
   17356                 :          0 :                 tp->dma_rwctrl &= 0xfffffff0;
   17357                 :            : 
   17358         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5700 ||
   17359                 :            :             tg3_asic_rev(tp) == ASIC_REV_5701) {
   17360                 :            :                 /* Remove this if it causes problems for some boards. */
   17361                 :          0 :                 tp->dma_rwctrl |= DMA_RWCTRL_USE_MEM_READ_MULT;
   17362                 :            : 
   17363                 :            :                 /* On 5700/5701 chips, we need to set this bit.
   17364                 :            :                  * Otherwise the chip will issue cacheline transactions
   17365                 :            :                  * to streamable DMA memory with not all the byte
   17366                 :            :                  * enables turned on.  This is an error on several
   17367                 :            :                  * RISC PCI controllers, in particular sparc64.
   17368                 :            :                  *
   17369                 :            :                  * On 5703/5704 chips, this bit has been reassigned
   17370                 :            :                  * a different meaning.  In particular, it is used
   17371                 :            :                  * on those chips to enable a PCI-X workaround.
   17372                 :            :                  */
   17373                 :          0 :                 tp->dma_rwctrl |= DMA_RWCTRL_ASSERT_ALL_BE;
   17374                 :            :         }
   17375                 :            : 
   17376                 :          0 :         tw32(TG3PCI_DMA_RW_CTRL, tp->dma_rwctrl);
   17377                 :            : 
   17378                 :            : 
   17379         [ #  # ]:          0 :         if (tg3_asic_rev(tp) != ASIC_REV_5700 &&
   17380                 :            :             tg3_asic_rev(tp) != ASIC_REV_5701)
   17381                 :          0 :                 goto out;
   17382                 :            : 
   17383                 :            :         /* It is best to perform DMA test with maximum write burst size
   17384                 :            :          * to expose the 5700/5701 write DMA bug.
   17385                 :            :          */
   17386                 :          0 :         saved_dma_rwctrl = tp->dma_rwctrl;
   17387                 :          0 :         tp->dma_rwctrl &= ~DMA_RWCTRL_WRITE_BNDRY_MASK;
   17388                 :          0 :         tw32(TG3PCI_DMA_RW_CTRL, tp->dma_rwctrl);
   17389                 :            : 
   17390                 :          0 :         while (1) {
   17391                 :          0 :                 u32 *p = buf, i;
   17392                 :            : 
   17393         [ #  # ]:          0 :                 for (i = 0; i < TEST_BUFFER_SIZE / sizeof(u32); i++)
   17394                 :          0 :                         p[i] = i;
   17395                 :            : 
   17396                 :            :                 /* Send the buffer to the chip. */
   17397                 :          0 :                 ret = tg3_do_test_dma(tp, buf, buf_dma, TEST_BUFFER_SIZE, true);
   17398         [ #  # ]:          0 :                 if (ret) {
   17399                 :          0 :                         dev_err(&tp->pdev->dev,
   17400                 :            :                                 "%s: Buffer write failed. err = %d\n",
   17401                 :            :                                 __func__, ret);
   17402                 :          0 :                         break;
   17403                 :            :                 }
   17404                 :            : 
   17405                 :            :                 /* Now read it back. */
   17406                 :          0 :                 ret = tg3_do_test_dma(tp, buf, buf_dma, TEST_BUFFER_SIZE, false);
   17407         [ #  # ]:          0 :                 if (ret) {
   17408                 :          0 :                         dev_err(&tp->pdev->dev, "%s: Buffer read failed. "
   17409                 :            :                                 "err = %d\n", __func__, ret);
   17410                 :          0 :                         break;
   17411                 :            :                 }
   17412                 :            : 
   17413                 :            :                 /* Verify it. */
   17414         [ #  # ]:          0 :                 for (i = 0; i < TEST_BUFFER_SIZE / sizeof(u32); i++) {
   17415         [ #  # ]:          0 :                         if (p[i] == i)
   17416                 :          0 :                                 continue;
   17417                 :            : 
   17418         [ #  # ]:          0 :                         if ((tp->dma_rwctrl & DMA_RWCTRL_WRITE_BNDRY_MASK) !=
   17419                 :            :                             DMA_RWCTRL_WRITE_BNDRY_16) {
   17420                 :          0 :                                 tp->dma_rwctrl &= ~DMA_RWCTRL_WRITE_BNDRY_MASK;
   17421                 :          0 :                                 tp->dma_rwctrl |= DMA_RWCTRL_WRITE_BNDRY_16;
   17422                 :          0 :                                 tw32(TG3PCI_DMA_RW_CTRL, tp->dma_rwctrl);
   17423                 :          0 :                                 break;
   17424                 :            :                         } else {
   17425                 :          0 :                                 dev_err(&tp->pdev->dev,
   17426                 :            :                                         "%s: Buffer corrupted on read back! "
   17427                 :            :                                         "(%d != %d)\n", __func__, p[i], i);
   17428                 :          0 :                                 ret = -ENODEV;
   17429                 :          0 :                                 goto out;
   17430                 :            :                         }
   17431                 :            :                 }
   17432                 :            : 
   17433         [ #  # ]:          0 :                 if (i == (TEST_BUFFER_SIZE / sizeof(u32))) {
   17434                 :            :                         /* Success. */
   17435                 :            :                         ret = 0;
   17436                 :            :                         break;
   17437                 :            :                 }
   17438                 :            :         }
   17439         [ #  # ]:          0 :         if ((tp->dma_rwctrl & DMA_RWCTRL_WRITE_BNDRY_MASK) !=
   17440                 :            :             DMA_RWCTRL_WRITE_BNDRY_16) {
   17441                 :            :                 /* DMA test passed without adjusting DMA boundary,
   17442                 :            :                  * now look for chipsets that are known to expose the
   17443                 :            :                  * DMA bug without failing the test.
   17444                 :            :                  */
   17445         [ #  # ]:          0 :                 if (pci_dev_present(tg3_dma_wait_state_chipsets)) {
   17446                 :          0 :                         tp->dma_rwctrl &= ~DMA_RWCTRL_WRITE_BNDRY_MASK;
   17447                 :          0 :                         tp->dma_rwctrl |= DMA_RWCTRL_WRITE_BNDRY_16;
   17448                 :            :                 } else {
   17449                 :            :                         /* Safe to use the calculated DMA boundary. */
   17450                 :          0 :                         tp->dma_rwctrl = saved_dma_rwctrl;
   17451                 :            :                 }
   17452                 :            : 
   17453                 :          0 :                 tw32(TG3PCI_DMA_RW_CTRL, tp->dma_rwctrl);
   17454                 :            :         }
   17455                 :            : 
   17456                 :          0 : out:
   17457                 :          0 :         dma_free_coherent(&tp->pdev->dev, TEST_BUFFER_SIZE, buf, buf_dma);
   17458                 :          0 : out_nofree:
   17459                 :          0 :         return ret;
   17460                 :            : }
   17461                 :            : 
   17462                 :          0 : static void tg3_init_bufmgr_config(struct tg3 *tp)
   17463                 :            : {
   17464         [ #  # ]:          0 :         if (tg3_flag(tp, 57765_PLUS)) {
   17465                 :          0 :                 tp->bufmgr_config.mbuf_read_dma_low_water =
   17466                 :            :                         DEFAULT_MB_RDMA_LOW_WATER_5705;
   17467                 :          0 :                 tp->bufmgr_config.mbuf_mac_rx_low_water =
   17468                 :            :                         DEFAULT_MB_MACRX_LOW_WATER_57765;
   17469                 :          0 :                 tp->bufmgr_config.mbuf_high_water =
   17470                 :            :                         DEFAULT_MB_HIGH_WATER_57765;
   17471                 :            : 
   17472                 :          0 :                 tp->bufmgr_config.mbuf_read_dma_low_water_jumbo =
   17473                 :            :                         DEFAULT_MB_RDMA_LOW_WATER_5705;
   17474                 :          0 :                 tp->bufmgr_config.mbuf_mac_rx_low_water_jumbo =
   17475                 :            :                         DEFAULT_MB_MACRX_LOW_WATER_JUMBO_57765;
   17476                 :          0 :                 tp->bufmgr_config.mbuf_high_water_jumbo =
   17477                 :            :                         DEFAULT_MB_HIGH_WATER_JUMBO_57765;
   17478         [ #  # ]:          0 :         } else if (tg3_flag(tp, 5705_PLUS)) {
   17479                 :          0 :                 tp->bufmgr_config.mbuf_read_dma_low_water =
   17480                 :            :                         DEFAULT_MB_RDMA_LOW_WATER_5705;
   17481                 :          0 :                 tp->bufmgr_config.mbuf_mac_rx_low_water =
   17482                 :            :                         DEFAULT_MB_MACRX_LOW_WATER_5705;
   17483                 :          0 :                 tp->bufmgr_config.mbuf_high_water =
   17484                 :            :                         DEFAULT_MB_HIGH_WATER_5705;
   17485         [ #  # ]:          0 :                 if (tg3_asic_rev(tp) == ASIC_REV_5906) {
   17486                 :          0 :                         tp->bufmgr_config.mbuf_mac_rx_low_water =
   17487                 :            :                                 DEFAULT_MB_MACRX_LOW_WATER_5906;
   17488                 :          0 :                         tp->bufmgr_config.mbuf_high_water =
   17489                 :            :                                 DEFAULT_MB_HIGH_WATER_5906;
   17490                 :            :                 }
   17491                 :            : 
   17492                 :          0 :                 tp->bufmgr_config.mbuf_read_dma_low_water_jumbo =
   17493                 :            :                         DEFAULT_MB_RDMA_LOW_WATER_JUMBO_5780;
   17494                 :          0 :                 tp->bufmgr_config.mbuf_mac_rx_low_water_jumbo =
   17495                 :            :                         DEFAULT_MB_MACRX_LOW_WATER_JUMBO_5780;
   17496                 :          0 :                 tp->bufmgr_config.mbuf_high_water_jumbo =
   17497                 :            :                         DEFAULT_MB_HIGH_WATER_JUMBO_5780;
   17498                 :            :         } else {
   17499                 :          0 :                 tp->bufmgr_config.mbuf_read_dma_low_water =
   17500                 :            :                         DEFAULT_MB_RDMA_LOW_WATER;
   17501                 :          0 :                 tp->bufmgr_config.mbuf_mac_rx_low_water =
   17502                 :            :                         DEFAULT_MB_MACRX_LOW_WATER;
   17503                 :          0 :                 tp->bufmgr_config.mbuf_high_water =
   17504                 :            :                         DEFAULT_MB_HIGH_WATER;
   17505                 :            : 
   17506                 :          0 :                 tp->bufmgr_config.mbuf_read_dma_low_water_jumbo =
   17507                 :            :                         DEFAULT_MB_RDMA_LOW_WATER_JUMBO;
   17508                 :          0 :                 tp->bufmgr_config.mbuf_mac_rx_low_water_jumbo =
   17509                 :            :                         DEFAULT_MB_MACRX_LOW_WATER_JUMBO;
   17510                 :          0 :                 tp->bufmgr_config.mbuf_high_water_jumbo =
   17511                 :            :                         DEFAULT_MB_HIGH_WATER_JUMBO;
   17512                 :            :         }
   17513                 :            : 
   17514                 :          0 :         tp->bufmgr_config.dma_low_water = DEFAULT_DMA_LOW_WATER;
   17515                 :          0 :         tp->bufmgr_config.dma_high_water = DEFAULT_DMA_HIGH_WATER;
   17516                 :          0 : }
   17517                 :            : 
   17518                 :            : static char *tg3_phy_string(struct tg3 *tp)
   17519                 :            : {
   17520                 :            :         switch (tp->phy_id & TG3_PHY_ID_MASK) {
   17521                 :            :         case TG3_PHY_ID_BCM5400:        return "5400";
   17522                 :            :         case TG3_PHY_ID_BCM5401:        return "5401";
   17523                 :            :         case TG3_PHY_ID_BCM5411:        return "5411";
   17524                 :            :         case TG3_PHY_ID_BCM5701:        return "5701";
   17525                 :            :         case TG3_PHY_ID_BCM5703:        return "5703";
   17526                 :            :         case TG3_PHY_ID_BCM5704:        return "5704";
   17527                 :            :         case TG3_PHY_ID_BCM5705:        return "5705";
   17528                 :            :         case TG3_PHY_ID_BCM5750:        return "5750";
   17529                 :            :         case TG3_PHY_ID_BCM5752:        return "5752";
   17530                 :            :         case TG3_PHY_ID_BCM5714:        return "5714";
   17531                 :            :         case TG3_PHY_ID_BCM5780:        return "5780";
   17532                 :            :         case TG3_PHY_ID_BCM5755:        return "5755";
   17533                 :            :         case TG3_PHY_ID_BCM5787:        return "5787";
   17534                 :            :         case TG3_PHY_ID_BCM5784:        return "5784";
   17535                 :            :         case TG3_PHY_ID_BCM5756:        return "5722/5756";
   17536                 :            :         case TG3_PHY_ID_BCM5906:        return "5906";
   17537                 :            :         case TG3_PHY_ID_BCM5761:        return "5761";
   17538                 :            :         case TG3_PHY_ID_BCM5718C:       return "5718C";
   17539                 :            :         case TG3_PHY_ID_BCM5718S:       return "5718S";
   17540                 :            :         case TG3_PHY_ID_BCM57765:       return "57765";
   17541                 :            :         case TG3_PHY_ID_BCM5719C:       return "5719C";
   17542                 :            :         case TG3_PHY_ID_BCM5720C:       return "5720C";
   17543                 :            :         case TG3_PHY_ID_BCM5762:        return "5762C";
   17544                 :            :         case TG3_PHY_ID_BCM8002:        return "8002/serdes";
   17545                 :            :         case 0:                 return "serdes";
   17546                 :            :         default:                return "unknown";
   17547                 :            :         }
   17548                 :            : }
   17549                 :            : 
   17550                 :          0 : static char *tg3_bus_string(struct tg3 *tp, char *str)
   17551                 :            : {
   17552         [ #  # ]:          0 :         if (tg3_flag(tp, PCI_EXPRESS)) {
   17553                 :          0 :                 strcpy(str, "PCI Express");
   17554                 :          0 :                 return str;
   17555         [ #  # ]:          0 :         } else if (tg3_flag(tp, PCIX_MODE)) {
   17556                 :          0 :                 u32 clock_ctrl = tr32(TG3PCI_CLOCK_CTRL) & 0x1f;
   17557                 :            : 
   17558                 :          0 :                 strcpy(str, "PCIX:");
   17559                 :            : 
   17560         [ #  # ]:          0 :                 if ((clock_ctrl == 7) ||
   17561         [ #  # ]:          0 :                     ((tr32(GRC_MISC_CFG) & GRC_MISC_CFG_BOARD_ID_MASK) ==
   17562                 :            :                      GRC_MISC_CFG_BOARD_ID_5704CIOBE))
   17563                 :          0 :                         strcat(str, "133MHz");
   17564         [ #  # ]:          0 :                 else if (clock_ctrl == 0)
   17565                 :          0 :                         strcat(str, "33MHz");
   17566         [ #  # ]:          0 :                 else if (clock_ctrl == 2)
   17567                 :          0 :                         strcat(str, "50MHz");
   17568         [ #  # ]:          0 :                 else if (clock_ctrl == 4)
   17569                 :          0 :                         strcat(str, "66MHz");
   17570         [ #  # ]:          0 :                 else if (clock_ctrl == 6)
   17571                 :          0 :                         strcat(str, "100MHz");
   17572                 :            :         } else {
   17573                 :          0 :                 strcpy(str, "PCI:");
   17574         [ #  # ]:          0 :                 if (tg3_flag(tp, PCI_HIGH_SPEED))
   17575                 :          0 :                         strcat(str, "66MHz");
   17576                 :            :                 else
   17577                 :          0 :                         strcat(str, "33MHz");
   17578                 :            :         }
   17579         [ #  # ]:          0 :         if (tg3_flag(tp, PCI_32BIT))
   17580                 :          0 :                 strcat(str, ":32-bit");
   17581                 :            :         else
   17582                 :          0 :                 strcat(str, ":64-bit");
   17583                 :            :         return str;
   17584                 :            : }
   17585                 :            : 
   17586                 :          0 : static void tg3_init_coal(struct tg3 *tp)
   17587                 :            : {
   17588                 :          0 :         struct ethtool_coalesce *ec = &tp->coal;
   17589                 :            : 
   17590                 :          0 :         memset(ec, 0, sizeof(*ec));
   17591                 :          0 :         ec->cmd = ETHTOOL_GCOALESCE;
   17592                 :          0 :         ec->rx_coalesce_usecs = LOW_RXCOL_TICKS;
   17593                 :          0 :         ec->tx_coalesce_usecs = LOW_TXCOL_TICKS;
   17594                 :          0 :         ec->rx_max_coalesced_frames = LOW_RXMAX_FRAMES;
   17595                 :          0 :         ec->tx_max_coalesced_frames = LOW_TXMAX_FRAMES;
   17596                 :          0 :         ec->rx_coalesce_usecs_irq = DEFAULT_RXCOAL_TICK_INT;
   17597                 :          0 :         ec->tx_coalesce_usecs_irq = DEFAULT_TXCOAL_TICK_INT;
   17598                 :          0 :         ec->rx_max_coalesced_frames_irq = DEFAULT_RXCOAL_MAXF_INT;
   17599                 :          0 :         ec->tx_max_coalesced_frames_irq = DEFAULT_TXCOAL_MAXF_INT;
   17600                 :          0 :         ec->stats_block_coalesce_usecs = DEFAULT_STAT_COAL_TICKS;
   17601                 :            : 
   17602         [ #  # ]:          0 :         if (tp->coalesce_mode & (HOSTCC_MODE_CLRTICK_RXBD |
   17603                 :            :                                  HOSTCC_MODE_CLRTICK_TXBD)) {
   17604                 :          0 :                 ec->rx_coalesce_usecs = LOW_RXCOL_TICKS_CLRTCKS;
   17605                 :          0 :                 ec->rx_coalesce_usecs_irq = DEFAULT_RXCOAL_TICK_INT_CLRTCKS;
   17606                 :          0 :                 ec->tx_coalesce_usecs = LOW_TXCOL_TICKS_CLRTCKS;
   17607                 :          0 :                 ec->tx_coalesce_usecs_irq = DEFAULT_TXCOAL_TICK_INT_CLRTCKS;
   17608                 :            :         }
   17609                 :            : 
   17610         [ #  # ]:          0 :         if (tg3_flag(tp, 5705_PLUS)) {
   17611                 :          0 :                 ec->rx_coalesce_usecs_irq = 0;
   17612                 :          0 :                 ec->tx_coalesce_usecs_irq = 0;
   17613                 :          0 :                 ec->stats_block_coalesce_usecs = 0;
   17614                 :            :         }
   17615                 :          0 : }
   17616                 :            : 
   17617                 :          0 : static int tg3_init_one(struct pci_dev *pdev,
   17618                 :            :                                   const struct pci_device_id *ent)
   17619                 :            : {
   17620                 :          0 :         struct net_device *dev;
   17621                 :          0 :         struct tg3 *tp;
   17622                 :          0 :         int i, err;
   17623                 :          0 :         u32 sndmbx, rcvmbx, intmbx;
   17624                 :          0 :         char str[40];
   17625                 :          0 :         u64 dma_mask, persist_dma_mask;
   17626                 :          0 :         netdev_features_t features = 0;
   17627                 :            : 
   17628         [ #  # ]:          0 :         printk_once(KERN_INFO "%s\n", version);
   17629                 :            : 
   17630                 :          0 :         err = pci_enable_device(pdev);
   17631         [ #  # ]:          0 :         if (err) {
   17632                 :          0 :                 dev_err(&pdev->dev, "Cannot enable PCI device, aborting\n");
   17633                 :          0 :                 return err;
   17634                 :            :         }
   17635                 :            : 
   17636                 :          0 :         err = pci_request_regions(pdev, DRV_MODULE_NAME);
   17637         [ #  # ]:          0 :         if (err) {
   17638                 :          0 :                 dev_err(&pdev->dev, "Cannot obtain PCI resources, aborting\n");
   17639                 :          0 :                 goto err_out_disable_pdev;
   17640                 :            :         }
   17641                 :            : 
   17642                 :          0 :         pci_set_master(pdev);
   17643                 :            : 
   17644                 :          0 :         dev = alloc_etherdev_mq(sizeof(*tp), TG3_IRQ_MAX_VECS);
   17645         [ #  # ]:          0 :         if (!dev) {
   17646                 :          0 :                 err = -ENOMEM;
   17647                 :          0 :                 goto err_out_free_res;
   17648                 :            :         }
   17649                 :            : 
   17650                 :          0 :         SET_NETDEV_DEV(dev, &pdev->dev);
   17651                 :            : 
   17652         [ #  # ]:          0 :         tp = netdev_priv(dev);
   17653                 :          0 :         tp->pdev = pdev;
   17654                 :          0 :         tp->dev = dev;
   17655                 :          0 :         tp->rx_mode = TG3_DEF_RX_MODE;
   17656                 :          0 :         tp->tx_mode = TG3_DEF_TX_MODE;
   17657                 :          0 :         tp->irq_sync = 1;
   17658                 :          0 :         tp->pcierr_recovery = false;
   17659                 :            : 
   17660         [ #  # ]:          0 :         if (tg3_debug > 0)
   17661                 :          0 :                 tp->msg_enable = tg3_debug;
   17662                 :            :         else
   17663                 :          0 :                 tp->msg_enable = TG3_DEF_MSG_ENABLE;
   17664                 :            : 
   17665                 :          0 :         if (pdev_is_ssb_gige_core(pdev)) {
   17666                 :            :                 tg3_flag_set(tp, IS_SSB_CORE);
   17667                 :            :                 if (ssb_gige_must_flush_posted_writes(pdev))
   17668                 :            :                         tg3_flag_set(tp, FLUSH_POSTED_WRITES);
   17669                 :            :                 if (ssb_gige_one_dma_at_once(pdev))
   17670                 :            :                         tg3_flag_set(tp, ONE_DMA_AT_ONCE);
   17671                 :            :                 if (ssb_gige_have_roboswitch(pdev)) {
   17672                 :            :                         tg3_flag_set(tp, USE_PHYLIB);
   17673                 :            :                         tg3_flag_set(tp, ROBOSWITCH);
   17674                 :            :                 }
   17675                 :            :                 if (ssb_gige_is_rgmii(pdev))
   17676                 :            :                         tg3_flag_set(tp, RGMII_MODE);
   17677                 :            :         }
   17678                 :            : 
   17679                 :            :         /* The word/byte swap controls here control register access byte
   17680                 :            :          * swapping.  DMA data byte swapping is controlled in the GRC_MODE
   17681                 :            :          * setting below.
   17682                 :            :          */
   17683                 :          0 :         tp->misc_host_ctrl =
   17684                 :            :                 MISC_HOST_CTRL_MASK_PCI_INT |
   17685                 :            :                 MISC_HOST_CTRL_WORD_SWAP |
   17686                 :            :                 MISC_HOST_CTRL_INDIR_ACCESS |
   17687                 :            :                 MISC_HOST_CTRL_PCISTATE_RW;
   17688                 :            : 
   17689                 :            :         /* The NONFRM (non-frame) byte/word swap controls take effect
   17690                 :            :          * on descriptor entries, anything which isn't packet data.
   17691                 :            :          *
   17692                 :            :          * The StrongARM chips on the board (one for tx, one for rx)
   17693                 :            :          * are running in big-endian mode.
   17694                 :            :          */
   17695                 :          0 :         tp->grc_mode = (GRC_MODE_WSWAP_DATA | GRC_MODE_BSWAP_DATA |
   17696                 :            :                         GRC_MODE_WSWAP_NONFRM_DATA);
   17697                 :            : #ifdef __BIG_ENDIAN
   17698                 :            :         tp->grc_mode |= GRC_MODE_BSWAP_NONFRM_DATA;
   17699                 :            : #endif
   17700                 :          0 :         spin_lock_init(&tp->lock);
   17701                 :          0 :         spin_lock_init(&tp->indirect_lock);
   17702                 :          0 :         INIT_WORK(&tp->reset_task, tg3_reset_task);
   17703                 :            : 
   17704                 :          0 :         tp->regs = pci_ioremap_bar(pdev, BAR_0);
   17705         [ #  # ]:          0 :         if (!tp->regs) {
   17706                 :          0 :                 dev_err(&pdev->dev, "Cannot map device registers, aborting\n");
   17707                 :          0 :                 err = -ENOMEM;
   17708                 :          0 :                 goto err_out_free_dev;
   17709                 :            :         }
   17710                 :            : 
   17711                 :          0 :         if (tp->pdev->device == PCI_DEVICE_ID_TIGON3_5761 ||
   17712         [ #  # ]:          0 :             tp->pdev->device == PCI_DEVICE_ID_TIGON3_5761E ||
   17713         [ #  # ]:          0 :             tp->pdev->device == TG3PCI_DEVICE_TIGON3_5761S ||
   17714         [ #  # ]:          0 :             tp->pdev->device == TG3PCI_DEVICE_TIGON3_5761SE ||
   17715         [ #  # ]:          0 :             tp->pdev->device == TG3PCI_DEVICE_TIGON3_5717 ||
   17716         [ #  # ]:          0 :             tp->pdev->device == TG3PCI_DEVICE_TIGON3_5717_C ||
   17717         [ #  # ]:          0 :             tp->pdev->device == TG3PCI_DEVICE_TIGON3_5718 ||
   17718         [ #  # ]:          0 :             tp->pdev->device == TG3PCI_DEVICE_TIGON3_5719 ||
   17719         [ #  # ]:          0 :             tp->pdev->device == TG3PCI_DEVICE_TIGON3_5720 ||
   17720         [ #  # ]:          0 :             tp->pdev->device == TG3PCI_DEVICE_TIGON3_57767 ||
   17721         [ #  # ]:          0 :             tp->pdev->device == TG3PCI_DEVICE_TIGON3_57764 ||
   17722         [ #  # ]:          0 :             tp->pdev->device == TG3PCI_DEVICE_TIGON3_5762 ||
   17723         [ #  # ]:          0 :             tp->pdev->device == TG3PCI_DEVICE_TIGON3_5725 ||
   17724         [ #  # ]:          0 :             tp->pdev->device == TG3PCI_DEVICE_TIGON3_5727 ||
   17725                 :            :             tp->pdev->device == TG3PCI_DEVICE_TIGON3_57787) {
   17726                 :          0 :                 tg3_flag_set(tp, ENABLE_APE);
   17727                 :          0 :                 tp->aperegs = pci_ioremap_bar(pdev, BAR_2);
   17728         [ #  # ]:          0 :                 if (!tp->aperegs) {
   17729                 :          0 :                         dev_err(&pdev->dev,
   17730                 :            :                                 "Cannot map APE registers, aborting\n");
   17731                 :          0 :                         err = -ENOMEM;
   17732                 :          0 :                         goto err_out_iounmap;
   17733                 :            :                 }
   17734                 :            :         }
   17735                 :            : 
   17736                 :          0 :         tp->rx_pending = TG3_DEF_RX_RING_PENDING;
   17737                 :          0 :         tp->rx_jumbo_pending = TG3_DEF_RX_JUMBO_RING_PENDING;
   17738                 :            : 
   17739                 :          0 :         dev->ethtool_ops = &tg3_ethtool_ops;
   17740                 :          0 :         dev->watchdog_timeo = TG3_TX_TIMEOUT;
   17741                 :          0 :         dev->netdev_ops = &tg3_netdev_ops;
   17742                 :          0 :         dev->irq = pdev->irq;
   17743                 :            : 
   17744                 :          0 :         err = tg3_get_invariants(tp, ent);
   17745         [ #  # ]:          0 :         if (err) {
   17746                 :          0 :                 dev_err(&pdev->dev,
   17747                 :            :                         "Problem fetching invariants of chip, aborting\n");
   17748                 :          0 :                 goto err_out_apeunmap;
   17749                 :            :         }
   17750                 :            : 
   17751                 :            :         /* The EPB bridge inside 5714, 5715, and 5780 and any
   17752                 :            :          * device behind the EPB cannot support DMA addresses > 40-bit.
   17753                 :            :          * On 64-bit systems with IOMMU, use 40-bit dma_mask.
   17754                 :            :          * On 64-bit systems without IOMMU, use 64-bit dma_mask and
   17755                 :            :          * do DMA address check in tg3_start_xmit().
   17756                 :            :          */
   17757         [ #  # ]:          0 :         if (tg3_flag(tp, IS_5788))
   17758                 :            :                 persist_dma_mask = dma_mask = DMA_BIT_MASK(32);
   17759         [ #  # ]:          0 :         else if (tg3_flag(tp, 40BIT_DMA_BUG)) {
   17760                 :            :                 persist_dma_mask = dma_mask = DMA_BIT_MASK(40);
   17761                 :            : #ifdef CONFIG_HIGHMEM
   17762                 :            :                 dma_mask = DMA_BIT_MASK(64);
   17763                 :            : #endif
   17764                 :            :         } else
   17765                 :            :                 persist_dma_mask = dma_mask = DMA_BIT_MASK(64);
   17766                 :            : 
   17767                 :            :         /* Configure DMA attributes. */
   17768                 :            :         if (dma_mask > DMA_BIT_MASK(32)) {
   17769                 :          0 :                 err = pci_set_dma_mask(pdev, dma_mask);
   17770         [ #  # ]:          0 :                 if (!err) {
   17771                 :          0 :                         features |= NETIF_F_HIGHDMA;
   17772                 :          0 :                         err = pci_set_consistent_dma_mask(pdev,
   17773                 :            :                                                           persist_dma_mask);
   17774         [ #  # ]:          0 :                         if (err < 0) {
   17775                 :          0 :                                 dev_err(&pdev->dev, "Unable to obtain 64 bit "
   17776                 :            :                                         "DMA for consistent allocations\n");
   17777                 :          0 :                                 goto err_out_apeunmap;
   17778                 :            :                         }
   17779                 :            :                 }
   17780                 :            :         }
   17781         [ #  # ]:          0 :         if (err || dma_mask == DMA_BIT_MASK(32)) {
   17782                 :          0 :                 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
   17783         [ #  # ]:          0 :                 if (err) {
   17784                 :          0 :                         dev_err(&pdev->dev,
   17785                 :            :                                 "No usable DMA configuration, aborting\n");
   17786                 :          0 :                         goto err_out_apeunmap;
   17787                 :            :                 }
   17788                 :            :         }
   17789                 :            : 
   17790                 :          0 :         tg3_init_bufmgr_config(tp);
   17791                 :            : 
   17792                 :            :         /* 5700 B0 chips do not support checksumming correctly due
   17793                 :            :          * to hardware bugs.
   17794                 :            :          */
   17795         [ #  # ]:          0 :         if (tg3_chip_rev_id(tp) != CHIPREV_ID_5700_B0) {
   17796                 :          0 :                 features |= NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_RXCSUM;
   17797                 :            : 
   17798         [ #  # ]:          0 :                 if (tg3_flag(tp, 5755_PLUS))
   17799                 :          0 :                         features |= NETIF_F_IPV6_CSUM;
   17800                 :            :         }
   17801                 :            : 
   17802                 :            :         /* TSO is on by default on chips that support hardware TSO.
   17803                 :            :          * Firmware TSO on older chips gives lower performance, so it
   17804                 :            :          * is off by default, but can be enabled using ethtool.
   17805                 :            :          */
   17806   [ #  #  #  # ]:          0 :         if ((tg3_flag(tp, HW_TSO_1) ||
   17807         [ #  # ]:          0 :              tg3_flag(tp, HW_TSO_2) ||
   17808                 :          0 :              tg3_flag(tp, HW_TSO_3)) &&
   17809         [ #  # ]:          0 :             (features & NETIF_F_IP_CSUM))
   17810                 :          0 :                 features |= NETIF_F_TSO;
   17811   [ #  #  #  # ]:          0 :         if (tg3_flag(tp, HW_TSO_2) || tg3_flag(tp, HW_TSO_3)) {
   17812         [ #  # ]:          0 :                 if (features & NETIF_F_IPV6_CSUM)
   17813                 :          0 :                         features |= NETIF_F_TSO6;
   17814         [ #  # ]:          0 :                 if (tg3_flag(tp, HW_TSO_3) ||
   17815   [ #  #  #  # ]:          0 :                     tg3_asic_rev(tp) == ASIC_REV_5761 ||
   17816                 :          0 :                     (tg3_asic_rev(tp) == ASIC_REV_5784 &&
   17817   [ #  #  #  # ]:          0 :                      tg3_chip_rev(tp) != CHIPREV_5784_AX) ||
   17818         [ #  # ]:          0 :                     tg3_asic_rev(tp) == ASIC_REV_5785 ||
   17819                 :            :                     tg3_asic_rev(tp) == ASIC_REV_57780)
   17820                 :          0 :                         features |= NETIF_F_TSO_ECN;
   17821                 :            :         }
   17822                 :            : 
   17823                 :          0 :         dev->features |= features | NETIF_F_HW_VLAN_CTAG_TX |
   17824                 :            :                          NETIF_F_HW_VLAN_CTAG_RX;
   17825                 :          0 :         dev->vlan_features |= features;
   17826                 :            : 
   17827                 :            :         /*
   17828                 :            :          * Add loopback capability only for a subset of devices that support
   17829                 :            :          * MAC-LOOPBACK. Eventually this need to be enhanced to allow INT-PHY
   17830                 :            :          * loopback for the remaining devices.
   17831                 :            :          */
   17832   [ #  #  #  # ]:          0 :         if (tg3_asic_rev(tp) != ASIC_REV_5780 &&
   17833                 :            :             !tg3_flag(tp, CPMU_PRESENT))
   17834                 :            :                 /* Add the loopback capability */
   17835                 :          0 :                 features |= NETIF_F_LOOPBACK;
   17836                 :            : 
   17837                 :          0 :         dev->hw_features |= features;
   17838                 :          0 :         dev->priv_flags |= IFF_UNICAST_FLT;
   17839                 :            : 
   17840                 :            :         /* MTU range: 60 - 9000 or 1500, depending on hardware */
   17841                 :          0 :         dev->min_mtu = TG3_MIN_MTU;
   17842         [ #  # ]:          0 :         dev->max_mtu = TG3_MAX_MTU(tp);
   17843                 :            : 
   17844   [ #  #  #  # ]:          0 :         if (tg3_chip_rev_id(tp) == CHIPREV_ID_5705_A1 &&
   17845                 :          0 :             !tg3_flag(tp, TSO_CAPABLE) &&
   17846         [ #  # ]:          0 :             !(tr32(TG3PCI_PCISTATE) & PCISTATE_BUS_SPEED_HIGH)) {
   17847                 :          0 :                 tg3_flag_set(tp, MAX_RXPEND_64);
   17848                 :          0 :                 tp->rx_pending = 63;
   17849                 :            :         }
   17850                 :            : 
   17851                 :          0 :         err = tg3_get_device_address(tp);
   17852         [ #  # ]:          0 :         if (err) {
   17853                 :          0 :                 dev_err(&pdev->dev,
   17854                 :            :                         "Could not obtain valid ethernet address, aborting\n");
   17855                 :          0 :                 goto err_out_apeunmap;
   17856                 :            :         }
   17857                 :            : 
   17858                 :            :         intmbx = MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW;
   17859                 :            :         rcvmbx = MAILBOX_RCVRET_CON_IDX_0 + TG3_64BIT_REG_LOW;
   17860                 :            :         sndmbx = MAILBOX_SNDHOST_PROD_IDX_0 + TG3_64BIT_REG_LOW;
   17861         [ #  # ]:          0 :         for (i = 0; i < tp->irq_max; i++) {
   17862                 :          0 :                 struct tg3_napi *tnapi = &tp->napi[i];
   17863                 :            : 
   17864                 :          0 :                 tnapi->tp = tp;
   17865                 :          0 :                 tnapi->tx_pending = TG3_DEF_TX_RING_PENDING;
   17866                 :            : 
   17867                 :          0 :                 tnapi->int_mbox = intmbx;
   17868         [ #  # ]:          0 :                 if (i <= 4)
   17869                 :          0 :                         intmbx += 0x8;
   17870                 :            :                 else
   17871                 :          0 :                         intmbx += 0x4;
   17872                 :            : 
   17873                 :          0 :                 tnapi->consmbox = rcvmbx;
   17874                 :          0 :                 tnapi->prodmbox = sndmbx;
   17875                 :            : 
   17876         [ #  # ]:          0 :                 if (i)
   17877                 :          0 :                         tnapi->coal_now = HOSTCC_MODE_COAL_VEC1_NOW << (i - 1);
   17878                 :            :                 else
   17879                 :          0 :                         tnapi->coal_now = HOSTCC_MODE_NOW;
   17880                 :            : 
   17881         [ #  # ]:          0 :                 if (!tg3_flag(tp, SUPPORT_MSIX))
   17882                 :            :                         break;
   17883                 :            : 
   17884                 :            :                 /*
   17885                 :            :                  * If we support MSIX, we'll be using RSS.  If we're using
   17886                 :            :                  * RSS, the first vector only handles link interrupts and the
   17887                 :            :                  * remaining vectors handle rx and tx interrupts.  Reuse the
   17888                 :            :                  * mailbox values for the next iteration.  The values we setup
   17889                 :            :                  * above are still useful for the single vectored mode.
   17890                 :            :                  */
   17891         [ #  # ]:          0 :                 if (!i)
   17892                 :          0 :                         continue;
   17893                 :            : 
   17894                 :          0 :                 rcvmbx += 0x8;
   17895                 :            : 
   17896         [ #  # ]:          0 :                 if (sndmbx & 0x4)
   17897                 :          0 :                         sndmbx -= 0x4;
   17898                 :            :                 else
   17899                 :          0 :                         sndmbx += 0xc;
   17900                 :            :         }
   17901                 :            : 
   17902                 :            :         /*
   17903                 :            :          * Reset chip in case UNDI or EFI driver did not shutdown
   17904                 :            :          * DMA self test will enable WDMAC and we'll see (spurious)
   17905                 :            :          * pending DMA on the PCI bus at that point.
   17906                 :            :          */
   17907         [ #  # ]:          0 :         if ((tr32(HOSTCC_MODE) & HOSTCC_MODE_ENABLE) ||
   17908         [ #  # ]:          0 :             (tr32(WDMAC_MODE) & WDMAC_MODE_ENABLE)) {
   17909                 :          0 :                 tg3_full_lock(tp, 0);
   17910                 :          0 :                 tw32(MEMARB_MODE, MEMARB_MODE_ENABLE);
   17911                 :          0 :                 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
   17912                 :          0 :                 tg3_full_unlock(tp);
   17913                 :            :         }
   17914                 :            : 
   17915                 :          0 :         err = tg3_test_dma(tp);
   17916         [ #  # ]:          0 :         if (err) {
   17917                 :          0 :                 dev_err(&pdev->dev, "DMA engine test failed, aborting\n");
   17918                 :          0 :                 goto err_out_apeunmap;
   17919                 :            :         }
   17920                 :            : 
   17921                 :          0 :         tg3_init_coal(tp);
   17922                 :            : 
   17923         [ #  # ]:          0 :         pci_set_drvdata(pdev, dev);
   17924                 :            : 
   17925         [ #  # ]:          0 :         if (tg3_asic_rev(tp) == ASIC_REV_5719 ||
   17926         [ #  # ]:          0 :             tg3_asic_rev(tp) == ASIC_REV_5720 ||
   17927                 :            :             tg3_asic_rev(tp) == ASIC_REV_5762)
   17928                 :          0 :                 tg3_flag_set(tp, PTP_CAPABLE);
   17929                 :            : 
   17930                 :          0 :         tg3_timer_init(tp);
   17931                 :            : 
   17932                 :          0 :         tg3_carrier_off(tp);
   17933                 :            : 
   17934                 :          0 :         err = register_netdev(dev);
   17935         [ #  # ]:          0 :         if (err) {
   17936                 :          0 :                 dev_err(&pdev->dev, "Cannot register net device, aborting\n");
   17937                 :          0 :                 goto err_out_apeunmap;
   17938                 :            :         }
   17939                 :            : 
   17940         [ #  # ]:          0 :         if (tg3_flag(tp, PTP_CAPABLE)) {
   17941                 :          0 :                 tg3_ptp_init(tp);
   17942                 :          0 :                 tp->ptp_clock = ptp_clock_register(&tp->ptp_info,
   17943                 :          0 :                                                    &tp->pdev->dev);
   17944         [ #  # ]:          0 :                 if (IS_ERR(tp->ptp_clock))
   17945                 :          0 :                         tp->ptp_clock = NULL;
   17946                 :            :         }
   17947                 :            : 
   17948                 :          0 :         netdev_info(dev, "Tigon3 [partno(%s) rev %04x] (%s) MAC address %pM\n",
   17949                 :          0 :                     tp->board_part_number,
   17950                 :            :                     tg3_chip_rev_id(tp),
   17951                 :            :                     tg3_bus_string(tp, str),
   17952                 :            :                     dev->dev_addr);
   17953                 :            : 
   17954         [ #  # ]:          0 :         if (!(tp->phy_flags & TG3_PHYFLG_IS_CONNECTED)) {
   17955                 :          0 :                 char *ethtype;
   17956                 :            : 
   17957         [ #  # ]:          0 :                 if (tp->phy_flags & TG3_PHYFLG_10_100_ONLY)
   17958                 :            :                         ethtype = "10/100Base-TX";
   17959         [ #  # ]:          0 :                 else if (tp->phy_flags & TG3_PHYFLG_ANY_SERDES)
   17960                 :            :                         ethtype = "1000Base-SX";
   17961                 :            :                 else
   17962                 :          0 :                         ethtype = "10/100/1000Base-T";
   17963                 :            : 
   17964                 :          0 :                 netdev_info(dev, "attached PHY is %s (%s Ethernet) "
   17965                 :            :                             "(WireSpeed[%d], EEE[%d])\n",
   17966                 :            :                             tg3_phy_string(tp), ethtype,
   17967                 :          0 :                             (tp->phy_flags & TG3_PHYFLG_NO_ETH_WIRE_SPEED) == 0,
   17968                 :          0 :                             (tp->phy_flags & TG3_PHYFLG_EEE_CAP) != 0);
   17969                 :            :         }
   17970                 :            : 
   17971                 :          0 :         netdev_info(dev, "RXcsums[%d] LinkChgREG[%d] MIirq[%d] ASF[%d] TSOcap[%d]\n",
   17972                 :          0 :                     (dev->features & NETIF_F_RXCSUM) != 0,
   17973                 :            :                     tg3_flag(tp, USE_LINKCHG_REG) != 0,
   17974                 :          0 :                     (tp->phy_flags & TG3_PHYFLG_USE_MI_INTERRUPT) != 0,
   17975                 :            :                     tg3_flag(tp, ENABLE_ASF) != 0,
   17976                 :            :                     tg3_flag(tp, TSO_CAPABLE) != 0);
   17977                 :          0 :         netdev_info(dev, "dma_rwctrl[%08x] dma_mask[%d-bit]\n",
   17978                 :            :                     tp->dma_rwctrl,
   17979         [ #  # ]:          0 :                     pdev->dma_mask == DMA_BIT_MASK(32) ? 32 :
   17980         [ #  # ]:          0 :                     ((u64)pdev->dma_mask) == DMA_BIT_MASK(40) ? 40 : 64);
   17981                 :            : 
   17982                 :          0 :         pci_save_state(pdev);
   17983                 :            : 
   17984                 :          0 :         return 0;
   17985                 :            : 
   17986                 :          0 : err_out_apeunmap:
   17987         [ #  # ]:          0 :         if (tp->aperegs) {
   17988                 :          0 :                 iounmap(tp->aperegs);
   17989                 :          0 :                 tp->aperegs = NULL;
   17990                 :            :         }
   17991                 :            : 
   17992                 :          0 : err_out_iounmap:
   17993         [ #  # ]:          0 :         if (tp->regs) {
   17994                 :          0 :                 iounmap(tp->regs);
   17995                 :          0 :                 tp->regs = NULL;
   17996                 :            :         }
   17997                 :            : 
   17998                 :          0 : err_out_free_dev:
   17999                 :          0 :         free_netdev(dev);
   18000                 :            : 
   18001                 :          0 : err_out_free_res:
   18002                 :          0 :         pci_release_regions(pdev);
   18003                 :            : 
   18004                 :          0 : err_out_disable_pdev:
   18005         [ #  # ]:          0 :         if (pci_is_enabled(pdev))
   18006                 :          0 :                 pci_disable_device(pdev);
   18007                 :            :         return err;
   18008                 :            : }
   18009                 :            : 
   18010                 :          0 : static void tg3_remove_one(struct pci_dev *pdev)
   18011                 :            : {
   18012         [ #  # ]:          0 :         struct net_device *dev = pci_get_drvdata(pdev);
   18013                 :            : 
   18014         [ #  # ]:          0 :         if (dev) {
   18015                 :          0 :                 struct tg3 *tp = netdev_priv(dev);
   18016                 :            : 
   18017                 :          0 :                 tg3_ptp_fini(tp);
   18018                 :            : 
   18019                 :          0 :                 release_firmware(tp->fw);
   18020                 :            : 
   18021                 :          0 :                 tg3_reset_task_cancel(tp);
   18022                 :            : 
   18023         [ #  # ]:          0 :                 if (tg3_flag(tp, USE_PHYLIB)) {
   18024                 :          0 :                         tg3_phy_fini(tp);
   18025                 :          0 :                         tg3_mdio_fini(tp);
   18026                 :            :                 }
   18027                 :            : 
   18028                 :          0 :                 unregister_netdev(dev);
   18029         [ #  # ]:          0 :                 if (tp->aperegs) {
   18030                 :          0 :                         iounmap(tp->aperegs);
   18031                 :          0 :                         tp->aperegs = NULL;
   18032                 :            :                 }
   18033         [ #  # ]:          0 :                 if (tp->regs) {
   18034                 :          0 :                         iounmap(tp->regs);
   18035                 :          0 :                         tp->regs = NULL;
   18036                 :            :                 }
   18037                 :          0 :                 free_netdev(dev);
   18038                 :          0 :                 pci_release_regions(pdev);
   18039                 :          0 :                 pci_disable_device(pdev);
   18040                 :            :         }
   18041                 :          0 : }
   18042                 :            : 
   18043                 :            : #ifdef CONFIG_PM_SLEEP
   18044                 :          0 : static int tg3_suspend(struct device *device)
   18045                 :            : {
   18046                 :          0 :         struct net_device *dev = dev_get_drvdata(device);
   18047                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   18048                 :          0 :         int err = 0;
   18049                 :            : 
   18050                 :          0 :         rtnl_lock();
   18051                 :            : 
   18052         [ #  # ]:          0 :         if (!netif_running(dev))
   18053                 :          0 :                 goto unlock;
   18054                 :            : 
   18055                 :          0 :         tg3_reset_task_cancel(tp);
   18056                 :          0 :         tg3_phy_stop(tp);
   18057                 :          0 :         tg3_netif_stop(tp);
   18058                 :            : 
   18059                 :          0 :         tg3_timer_stop(tp);
   18060                 :            : 
   18061                 :          0 :         tg3_full_lock(tp, 1);
   18062                 :          0 :         tg3_disable_ints(tp);
   18063                 :          0 :         tg3_full_unlock(tp);
   18064                 :            : 
   18065                 :          0 :         netif_device_detach(dev);
   18066                 :            : 
   18067                 :          0 :         tg3_full_lock(tp, 0);
   18068                 :          0 :         tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
   18069                 :          0 :         tg3_flag_clear(tp, INIT_COMPLETE);
   18070                 :          0 :         tg3_full_unlock(tp);
   18071                 :            : 
   18072                 :          0 :         err = tg3_power_down_prepare(tp);
   18073         [ #  # ]:          0 :         if (err) {
   18074                 :          0 :                 int err2;
   18075                 :            : 
   18076                 :          0 :                 tg3_full_lock(tp, 0);
   18077                 :            : 
   18078                 :          0 :                 tg3_flag_set(tp, INIT_COMPLETE);
   18079                 :          0 :                 err2 = tg3_restart_hw(tp, true);
   18080         [ #  # ]:          0 :                 if (err2)
   18081                 :          0 :                         goto out;
   18082                 :            : 
   18083                 :          0 :                 tg3_timer_start(tp);
   18084                 :            : 
   18085                 :          0 :                 netif_device_attach(dev);
   18086                 :          0 :                 tg3_netif_start(tp);
   18087                 :            : 
   18088                 :          0 : out:
   18089                 :          0 :                 tg3_full_unlock(tp);
   18090                 :            : 
   18091         [ #  # ]:          0 :                 if (!err2)
   18092                 :          0 :                         tg3_phy_start(tp);
   18093                 :            :         }
   18094                 :            : 
   18095                 :          0 : unlock:
   18096                 :          0 :         rtnl_unlock();
   18097                 :          0 :         return err;
   18098                 :            : }
   18099                 :            : 
   18100                 :          0 : static int tg3_resume(struct device *device)
   18101                 :            : {
   18102                 :          0 :         struct net_device *dev = dev_get_drvdata(device);
   18103                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   18104                 :          0 :         int err = 0;
   18105                 :            : 
   18106                 :          0 :         rtnl_lock();
   18107                 :            : 
   18108         [ #  # ]:          0 :         if (!netif_running(dev))
   18109                 :          0 :                 goto unlock;
   18110                 :            : 
   18111                 :          0 :         netif_device_attach(dev);
   18112                 :            : 
   18113                 :          0 :         tg3_full_lock(tp, 0);
   18114                 :            : 
   18115                 :          0 :         tg3_ape_driver_state_change(tp, RESET_KIND_INIT);
   18116                 :            : 
   18117                 :          0 :         tg3_flag_set(tp, INIT_COMPLETE);
   18118                 :          0 :         err = tg3_restart_hw(tp,
   18119                 :          0 :                              !(tp->phy_flags & TG3_PHYFLG_KEEP_LINK_ON_PWRDN));
   18120         [ #  # ]:          0 :         if (err)
   18121                 :          0 :                 goto out;
   18122                 :            : 
   18123                 :          0 :         tg3_timer_start(tp);
   18124                 :            : 
   18125                 :          0 :         tg3_netif_start(tp);
   18126                 :            : 
   18127                 :          0 : out:
   18128                 :          0 :         tg3_full_unlock(tp);
   18129                 :            : 
   18130         [ #  # ]:          0 :         if (!err)
   18131                 :          0 :                 tg3_phy_start(tp);
   18132                 :            : 
   18133                 :          0 : unlock:
   18134                 :          0 :         rtnl_unlock();
   18135                 :          0 :         return err;
   18136                 :            : }
   18137                 :            : #endif /* CONFIG_PM_SLEEP */
   18138                 :            : 
   18139                 :            : static SIMPLE_DEV_PM_OPS(tg3_pm_ops, tg3_suspend, tg3_resume);
   18140                 :            : 
   18141                 :          0 : static void tg3_shutdown(struct pci_dev *pdev)
   18142                 :            : {
   18143                 :          0 :         struct net_device *dev = pci_get_drvdata(pdev);
   18144                 :          0 :         struct tg3 *tp = netdev_priv(dev);
   18145                 :            : 
   18146                 :          0 :         rtnl_lock();
   18147                 :          0 :         netif_device_detach(dev);
   18148                 :            : 
   18149         [ #  # ]:          0 :         if (netif_running(dev))
   18150                 :          0 :                 dev_close(dev);
   18151                 :            : 
   18152         [ #  # ]:          0 :         if (system_state == SYSTEM_POWER_OFF)
   18153                 :          0 :                 tg3_power_down(tp);
   18154                 :            : 
   18155                 :          0 :         rtnl_unlock();
   18156                 :          0 : }
   18157                 :            : 
   18158                 :            : /**
   18159                 :            :  * tg3_io_error_detected - called when PCI error is detected
   18160                 :            :  * @pdev: Pointer to PCI device
   18161                 :            :  * @state: The current pci connection state
   18162                 :            :  *
   18163                 :            :  * This function is called after a PCI bus error affecting
   18164                 :            :  * this device has been detected.
   18165                 :            :  */
   18166                 :          0 : static pci_ers_result_t tg3_io_error_detected(struct pci_dev *pdev,
   18167                 :            :                                               pci_channel_state_t state)
   18168                 :            : {
   18169                 :          0 :         struct net_device *netdev = pci_get_drvdata(pdev);
   18170                 :          0 :         struct tg3 *tp = netdev_priv(netdev);
   18171                 :          0 :         pci_ers_result_t err = PCI_ERS_RESULT_NEED_RESET;
   18172                 :            : 
   18173                 :          0 :         netdev_info(netdev, "PCI I/O error detected\n");
   18174                 :            : 
   18175                 :          0 :         rtnl_lock();
   18176                 :            : 
   18177                 :            :         /* We probably don't have netdev yet */
   18178   [ #  #  #  # ]:          0 :         if (!netdev || !netif_running(netdev))
   18179                 :          0 :                 goto done;
   18180                 :            : 
   18181                 :            :         /* We needn't recover from permanent error */
   18182         [ #  # ]:          0 :         if (state == pci_channel_io_frozen)
   18183                 :          0 :                 tp->pcierr_recovery = true;
   18184                 :            : 
   18185                 :          0 :         tg3_phy_stop(tp);
   18186                 :            : 
   18187                 :          0 :         tg3_netif_stop(tp);
   18188                 :            : 
   18189                 :          0 :         tg3_timer_stop(tp);
   18190                 :            : 
   18191                 :            :         /* Want to make sure that the reset task doesn't run */
   18192                 :          0 :         tg3_reset_task_cancel(tp);
   18193                 :            : 
   18194                 :          0 :         netif_device_detach(netdev);
   18195                 :            : 
   18196                 :            :         /* Clean up software state, even if MMIO is blocked */
   18197                 :          0 :         tg3_full_lock(tp, 0);
   18198                 :          0 :         tg3_halt(tp, RESET_KIND_SHUTDOWN, 0);
   18199                 :          0 :         tg3_full_unlock(tp);
   18200                 :            : 
   18201                 :          0 : done:
   18202         [ #  # ]:          0 :         if (state == pci_channel_io_perm_failure) {
   18203         [ #  # ]:          0 :                 if (netdev) {
   18204                 :            :                         tg3_napi_enable(tp);
   18205                 :          0 :                         dev_close(netdev);
   18206                 :            :                 }
   18207                 :            :                 err = PCI_ERS_RESULT_DISCONNECT;
   18208                 :            :         } else {
   18209                 :          0 :                 pci_disable_device(pdev);
   18210                 :            :         }
   18211                 :            : 
   18212                 :          0 :         rtnl_unlock();
   18213                 :            : 
   18214                 :          0 :         return err;
   18215                 :            : }
   18216                 :            : 
   18217                 :            : /**
   18218                 :            :  * tg3_io_slot_reset - called after the pci bus has been reset.
   18219                 :            :  * @pdev: Pointer to PCI device
   18220                 :            :  *
   18221                 :            :  * Restart the card from scratch, as if from a cold-boot.
   18222                 :            :  * At this point, the card has exprienced a hard reset,
   18223                 :            :  * followed by fixups by BIOS, and has its config space
   18224                 :            :  * set up identically to what it was at cold boot.
   18225                 :            :  */
   18226                 :          0 : static pci_ers_result_t tg3_io_slot_reset(struct pci_dev *pdev)
   18227                 :            : {
   18228                 :          0 :         struct net_device *netdev = pci_get_drvdata(pdev);
   18229                 :          0 :         struct tg3 *tp = netdev_priv(netdev);
   18230                 :          0 :         pci_ers_result_t rc = PCI_ERS_RESULT_DISCONNECT;
   18231                 :          0 :         int err;
   18232                 :            : 
   18233                 :          0 :         rtnl_lock();
   18234                 :            : 
   18235         [ #  # ]:          0 :         if (pci_enable_device(pdev)) {
   18236                 :          0 :                 dev_err(&pdev->dev,
   18237                 :            :                         "Cannot re-enable PCI device after reset.\n");
   18238                 :          0 :                 goto done;
   18239                 :            :         }
   18240                 :            : 
   18241                 :          0 :         pci_set_master(pdev);
   18242                 :          0 :         pci_restore_state(pdev);
   18243                 :          0 :         pci_save_state(pdev);
   18244                 :            : 
   18245   [ #  #  #  # ]:          0 :         if (!netdev || !netif_running(netdev)) {
   18246                 :          0 :                 rc = PCI_ERS_RESULT_RECOVERED;
   18247                 :          0 :                 goto done;
   18248                 :            :         }
   18249                 :            : 
   18250                 :          0 :         err = tg3_power_up(tp);
   18251         [ #  # ]:          0 :         if (err)
   18252                 :          0 :                 goto done;
   18253                 :            : 
   18254                 :            :         rc = PCI_ERS_RESULT_RECOVERED;
   18255                 :            : 
   18256                 :          0 : done:
   18257   [ #  #  #  # ]:          0 :         if (rc != PCI_ERS_RESULT_RECOVERED && netdev && netif_running(netdev)) {
   18258                 :            :                 tg3_napi_enable(tp);
   18259                 :          0 :                 dev_close(netdev);
   18260                 :            :         }
   18261                 :          0 :         rtnl_unlock();
   18262                 :            : 
   18263                 :          0 :         return rc;
   18264                 :            : }
   18265                 :            : 
   18266                 :            : /**
   18267                 :            :  * tg3_io_resume - called when traffic can start flowing again.
   18268                 :            :  * @pdev: Pointer to PCI device
   18269                 :            :  *
   18270                 :            :  * This callback is called when the error recovery driver tells
   18271                 :            :  * us that its OK to resume normal operation.
   18272                 :            :  */
   18273                 :          0 : static void tg3_io_resume(struct pci_dev *pdev)
   18274                 :            : {
   18275                 :          0 :         struct net_device *netdev = pci_get_drvdata(pdev);
   18276                 :          0 :         struct tg3 *tp = netdev_priv(netdev);
   18277                 :          0 :         int err;
   18278                 :            : 
   18279                 :          0 :         rtnl_lock();
   18280                 :            : 
   18281   [ #  #  #  # ]:          0 :         if (!netdev || !netif_running(netdev))
   18282                 :          0 :                 goto done;
   18283                 :            : 
   18284                 :          0 :         tg3_full_lock(tp, 0);
   18285                 :          0 :         tg3_ape_driver_state_change(tp, RESET_KIND_INIT);
   18286                 :          0 :         tg3_flag_set(tp, INIT_COMPLETE);
   18287                 :          0 :         err = tg3_restart_hw(tp, true);
   18288         [ #  # ]:          0 :         if (err) {
   18289                 :          0 :                 tg3_full_unlock(tp);
   18290                 :          0 :                 netdev_err(netdev, "Cannot restart hardware after reset.\n");
   18291                 :          0 :                 goto done;
   18292                 :            :         }
   18293                 :            : 
   18294                 :          0 :         netif_device_attach(netdev);
   18295                 :            : 
   18296                 :          0 :         tg3_timer_start(tp);
   18297                 :            : 
   18298                 :          0 :         tg3_netif_start(tp);
   18299                 :            : 
   18300                 :          0 :         tg3_full_unlock(tp);
   18301                 :            : 
   18302                 :          0 :         tg3_phy_start(tp);
   18303                 :            : 
   18304                 :          0 : done:
   18305                 :          0 :         tp->pcierr_recovery = false;
   18306                 :          0 :         rtnl_unlock();
   18307                 :          0 : }
   18308                 :            : 
   18309                 :            : static const struct pci_error_handlers tg3_err_handler = {
   18310                 :            :         .error_detected = tg3_io_error_detected,
   18311                 :            :         .slot_reset     = tg3_io_slot_reset,
   18312                 :            :         .resume         = tg3_io_resume
   18313                 :            : };
   18314                 :            : 
   18315                 :            : static struct pci_driver tg3_driver = {
   18316                 :            :         .name           = DRV_MODULE_NAME,
   18317                 :            :         .id_table       = tg3_pci_tbl,
   18318                 :            :         .probe          = tg3_init_one,
   18319                 :            :         .remove         = tg3_remove_one,
   18320                 :            :         .err_handler    = &tg3_err_handler,
   18321                 :            :         .driver.pm      = &tg3_pm_ops,
   18322                 :            :         .shutdown       = tg3_shutdown,
   18323                 :            : };
   18324                 :            : 
   18325                 :         30 : module_pci_driver(tg3_driver);

Generated by: LCOV version 1.14