125e992a4SHeiner Kallweit // SPDX-License-Identifier: GPL-2.0-only 225e992a4SHeiner Kallweit /* 325e992a4SHeiner Kallweit * r8169.c: RealTek 8169/8168/8101 ethernet driver. 425e992a4SHeiner Kallweit * 525e992a4SHeiner Kallweit * Copyright (c) 2002 ShuChen <shuchen@realtek.com.tw> 625e992a4SHeiner Kallweit * Copyright (c) 2003 - 2007 Francois Romieu <romieu@fr.zoreil.com> 725e992a4SHeiner Kallweit * Copyright (c) a lot of people too. Please respect their work. 825e992a4SHeiner Kallweit * 925e992a4SHeiner Kallweit * See MAINTAINERS file for support contact information. 1025e992a4SHeiner Kallweit */ 1125e992a4SHeiner Kallweit 1225e992a4SHeiner Kallweit #include <linux/module.h> 1325e992a4SHeiner Kallweit #include <linux/moduleparam.h> 1425e992a4SHeiner Kallweit #include <linux/pci.h> 1525e992a4SHeiner Kallweit #include <linux/netdevice.h> 1625e992a4SHeiner Kallweit #include <linux/etherdevice.h> 1725e992a4SHeiner Kallweit #include <linux/clk.h> 1825e992a4SHeiner Kallweit #include <linux/delay.h> 1925e992a4SHeiner Kallweit #include <linux/ethtool.h> 2025e992a4SHeiner Kallweit #include <linux/phy.h> 2125e992a4SHeiner Kallweit #include <linux/if_vlan.h> 2225e992a4SHeiner Kallweit #include <linux/crc32.h> 2325e992a4SHeiner Kallweit #include <linux/in.h> 2425e992a4SHeiner Kallweit #include <linux/io.h> 2525e992a4SHeiner Kallweit #include <linux/ip.h> 2625e992a4SHeiner Kallweit #include <linux/tcp.h> 2725e992a4SHeiner Kallweit #include <linux/interrupt.h> 2825e992a4SHeiner Kallweit #include <linux/dma-mapping.h> 2925e992a4SHeiner Kallweit #include <linux/pm_runtime.h> 3025e992a4SHeiner Kallweit #include <linux/prefetch.h> 3125e992a4SHeiner Kallweit #include <linux/pci-aspm.h> 3225e992a4SHeiner Kallweit #include <linux/ipv6.h> 3325e992a4SHeiner Kallweit #include <net/ip6_checksum.h> 3425e992a4SHeiner Kallweit 358197f9d2SHeiner Kallweit #include "r8169_firmware.h" 368197f9d2SHeiner Kallweit 3725e992a4SHeiner Kallweit #define MODULENAME "r8169" 3825e992a4SHeiner Kallweit 3925e992a4SHeiner Kallweit #define FIRMWARE_8168D_1 "rtl_nic/rtl8168d-1.fw" 4025e992a4SHeiner Kallweit #define FIRMWARE_8168D_2 "rtl_nic/rtl8168d-2.fw" 4125e992a4SHeiner Kallweit #define FIRMWARE_8168E_1 "rtl_nic/rtl8168e-1.fw" 4225e992a4SHeiner Kallweit #define FIRMWARE_8168E_2 "rtl_nic/rtl8168e-2.fw" 4325e992a4SHeiner Kallweit #define FIRMWARE_8168E_3 "rtl_nic/rtl8168e-3.fw" 4425e992a4SHeiner Kallweit #define FIRMWARE_8168F_1 "rtl_nic/rtl8168f-1.fw" 4525e992a4SHeiner Kallweit #define FIRMWARE_8168F_2 "rtl_nic/rtl8168f-2.fw" 4625e992a4SHeiner Kallweit #define FIRMWARE_8105E_1 "rtl_nic/rtl8105e-1.fw" 4725e992a4SHeiner Kallweit #define FIRMWARE_8402_1 "rtl_nic/rtl8402-1.fw" 4825e992a4SHeiner Kallweit #define FIRMWARE_8411_1 "rtl_nic/rtl8411-1.fw" 4925e992a4SHeiner Kallweit #define FIRMWARE_8411_2 "rtl_nic/rtl8411-2.fw" 5025e992a4SHeiner Kallweit #define FIRMWARE_8106E_1 "rtl_nic/rtl8106e-1.fw" 5125e992a4SHeiner Kallweit #define FIRMWARE_8106E_2 "rtl_nic/rtl8106e-2.fw" 5225e992a4SHeiner Kallweit #define FIRMWARE_8168G_2 "rtl_nic/rtl8168g-2.fw" 5325e992a4SHeiner Kallweit #define FIRMWARE_8168G_3 "rtl_nic/rtl8168g-3.fw" 5425e992a4SHeiner Kallweit #define FIRMWARE_8168H_1 "rtl_nic/rtl8168h-1.fw" 5525e992a4SHeiner Kallweit #define FIRMWARE_8168H_2 "rtl_nic/rtl8168h-2.fw" 5625e992a4SHeiner Kallweit #define FIRMWARE_8107E_1 "rtl_nic/rtl8107e-1.fw" 5725e992a4SHeiner Kallweit #define FIRMWARE_8107E_2 "rtl_nic/rtl8107e-2.fw" 5825e992a4SHeiner Kallweit 5925e992a4SHeiner Kallweit #define R8169_MSG_DEFAULT \ 6025e992a4SHeiner Kallweit (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_IFUP | NETIF_MSG_IFDOWN) 6125e992a4SHeiner Kallweit 6225e992a4SHeiner Kallweit /* Maximum number of multicast addresses to filter (vs. Rx-all-multicast). 6325e992a4SHeiner Kallweit The RTL chips use a 64 element hash table based on the Ethernet CRC. */ 6425e992a4SHeiner Kallweit static const int multicast_filter_limit = 32; 6525e992a4SHeiner Kallweit 6625e992a4SHeiner Kallweit #define TX_DMA_BURST 7 /* Maximum PCI burst, '7' is unlimited */ 6725e992a4SHeiner Kallweit #define InterFrameGap 0x03 /* 3 means InterFrameGap = the shortest one */ 6825e992a4SHeiner Kallweit 6925e992a4SHeiner Kallweit #define R8169_REGS_SIZE 256 7025e992a4SHeiner Kallweit #define R8169_RX_BUF_SIZE (SZ_16K - 1) 7125e992a4SHeiner Kallweit #define NUM_TX_DESC 64 /* Number of Tx descriptor registers */ 7225e992a4SHeiner Kallweit #define NUM_RX_DESC 256U /* Number of Rx descriptor registers */ 7325e992a4SHeiner Kallweit #define R8169_TX_RING_BYTES (NUM_TX_DESC * sizeof(struct TxDesc)) 7425e992a4SHeiner Kallweit #define R8169_RX_RING_BYTES (NUM_RX_DESC * sizeof(struct RxDesc)) 7525e992a4SHeiner Kallweit 76145a40e8SHeiner Kallweit #define RTL_CFG_NO_GBIT 1 77145a40e8SHeiner Kallweit 7825e992a4SHeiner Kallweit /* write/read MMIO register */ 7925e992a4SHeiner Kallweit #define RTL_W8(tp, reg, val8) writeb((val8), tp->mmio_addr + (reg)) 8025e992a4SHeiner Kallweit #define RTL_W16(tp, reg, val16) writew((val16), tp->mmio_addr + (reg)) 8125e992a4SHeiner Kallweit #define RTL_W32(tp, reg, val32) writel((val32), tp->mmio_addr + (reg)) 8225e992a4SHeiner Kallweit #define RTL_R8(tp, reg) readb(tp->mmio_addr + (reg)) 8325e992a4SHeiner Kallweit #define RTL_R16(tp, reg) readw(tp->mmio_addr + (reg)) 8425e992a4SHeiner Kallweit #define RTL_R32(tp, reg) readl(tp->mmio_addr + (reg)) 8525e992a4SHeiner Kallweit 8625e992a4SHeiner Kallweit enum mac_version { 8725e992a4SHeiner Kallweit /* support for ancient RTL_GIGA_MAC_VER_01 has been removed */ 8825e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_02, 8925e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_03, 9025e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_04, 9125e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_05, 9225e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_06, 9325e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_07, 9425e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_08, 9525e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_09, 9625e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_10, 9725e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_11, 9825e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_12, 9925e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_13, 10025e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_14, 10125e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_15, 10225e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_16, 10325e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_17, 10425e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_18, 10525e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_19, 10625e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_20, 10725e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_21, 10825e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_22, 10925e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_23, 11025e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_24, 11125e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_25, 11225e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_26, 11325e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_27, 11425e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_28, 11525e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_29, 11625e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_30, 11725e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_31, 11825e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_32, 11925e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_33, 12025e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_34, 12125e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_35, 12225e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_36, 12325e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_37, 12425e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_38, 12525e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_39, 12625e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_40, 12725e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_41, 12825e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_42, 12925e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_43, 13025e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_44, 13125e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_45, 13225e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_46, 13325e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_47, 13425e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_48, 13525e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_49, 13625e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_50, 13725e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_51, 13825e992a4SHeiner Kallweit RTL_GIGA_MAC_NONE 13925e992a4SHeiner Kallweit }; 14025e992a4SHeiner Kallweit 14125e992a4SHeiner Kallweit #define JUMBO_1K ETH_DATA_LEN 14225e992a4SHeiner Kallweit #define JUMBO_4K (4*1024 - ETH_HLEN - 2) 14325e992a4SHeiner Kallweit #define JUMBO_6K (6*1024 - ETH_HLEN - 2) 14425e992a4SHeiner Kallweit #define JUMBO_7K (7*1024 - ETH_HLEN - 2) 14525e992a4SHeiner Kallweit #define JUMBO_9K (9*1024 - ETH_HLEN - 2) 14625e992a4SHeiner Kallweit 14725e992a4SHeiner Kallweit static const struct { 14825e992a4SHeiner Kallweit const char *name; 14925e992a4SHeiner Kallweit const char *fw_name; 15025e992a4SHeiner Kallweit } rtl_chip_infos[] = { 15125e992a4SHeiner Kallweit /* PCI devices. */ 15225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_02] = {"RTL8169s" }, 15325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_03] = {"RTL8110s" }, 15425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_04] = {"RTL8169sb/8110sb" }, 15525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_05] = {"RTL8169sc/8110sc" }, 15625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_06] = {"RTL8169sc/8110sc" }, 15725e992a4SHeiner Kallweit /* PCI-E devices. */ 15825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_07] = {"RTL8102e" }, 15925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_08] = {"RTL8102e" }, 16025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_09] = {"RTL8102e" }, 16125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_10] = {"RTL8101e" }, 16225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_11] = {"RTL8168b/8111b" }, 16325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_12] = {"RTL8168b/8111b" }, 16425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_13] = {"RTL8101e" }, 16525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_14] = {"RTL8100e" }, 16625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_15] = {"RTL8100e" }, 16725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_16] = {"RTL8101e" }, 16825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_17] = {"RTL8168b/8111b" }, 16925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_18] = {"RTL8168cp/8111cp" }, 17025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_19] = {"RTL8168c/8111c" }, 17125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_20] = {"RTL8168c/8111c" }, 17225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_21] = {"RTL8168c/8111c" }, 17325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_22] = {"RTL8168c/8111c" }, 17425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_23] = {"RTL8168cp/8111cp" }, 17525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_24] = {"RTL8168cp/8111cp" }, 17625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_25] = {"RTL8168d/8111d", FIRMWARE_8168D_1}, 17725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_26] = {"RTL8168d/8111d", FIRMWARE_8168D_2}, 17825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_27] = {"RTL8168dp/8111dp" }, 17925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_28] = {"RTL8168dp/8111dp" }, 18025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_29] = {"RTL8105e", FIRMWARE_8105E_1}, 18125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_30] = {"RTL8105e", FIRMWARE_8105E_1}, 18225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_31] = {"RTL8168dp/8111dp" }, 18325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_32] = {"RTL8168e/8111e", FIRMWARE_8168E_1}, 18425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_33] = {"RTL8168e/8111e", FIRMWARE_8168E_2}, 18525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_34] = {"RTL8168evl/8111evl", FIRMWARE_8168E_3}, 18625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_35] = {"RTL8168f/8111f", FIRMWARE_8168F_1}, 18725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_36] = {"RTL8168f/8111f", FIRMWARE_8168F_2}, 18825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_37] = {"RTL8402", FIRMWARE_8402_1 }, 18925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_38] = {"RTL8411", FIRMWARE_8411_1 }, 19025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_39] = {"RTL8106e", FIRMWARE_8106E_1}, 19125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_40] = {"RTL8168g/8111g", FIRMWARE_8168G_2}, 19225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_41] = {"RTL8168g/8111g" }, 19325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_42] = {"RTL8168g/8111g", FIRMWARE_8168G_3}, 19425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_43] = {"RTL8106e", FIRMWARE_8106E_2}, 19525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_44] = {"RTL8411", FIRMWARE_8411_2 }, 19625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_45] = {"RTL8168h/8111h", FIRMWARE_8168H_1}, 19725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_46] = {"RTL8168h/8111h", FIRMWARE_8168H_2}, 19825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_47] = {"RTL8107e", FIRMWARE_8107E_1}, 19925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_48] = {"RTL8107e", FIRMWARE_8107E_2}, 20025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_49] = {"RTL8168ep/8111ep" }, 20125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_50] = {"RTL8168ep/8111ep" }, 20225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_51] = {"RTL8168ep/8111ep" }, 20325e992a4SHeiner Kallweit }; 20425e992a4SHeiner Kallweit 20525e992a4SHeiner Kallweit static const struct pci_device_id rtl8169_pci_tbl[] = { 206145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x2502) }, 207145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x2600) }, 208145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x8129) }, 209145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x8136), RTL_CFG_NO_GBIT }, 210145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x8161) }, 211145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x8167) }, 212145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x8168) }, 213145a40e8SHeiner Kallweit { PCI_VDEVICE(NCUBE, 0x8168) }, 214145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x8169) }, 21525e992a4SHeiner Kallweit { PCI_VENDOR_ID_DLINK, 0x4300, 216145a40e8SHeiner Kallweit PCI_VENDOR_ID_DLINK, 0x4b10, 0, 0 }, 2179d9f3fbaSHeiner Kallweit { PCI_VDEVICE(DLINK, 0x4300) }, 2189d9f3fbaSHeiner Kallweit { PCI_VDEVICE(DLINK, 0x4302) }, 2199d9f3fbaSHeiner Kallweit { PCI_VDEVICE(AT, 0xc107) }, 2209d9f3fbaSHeiner Kallweit { PCI_VDEVICE(USR, 0x0116) }, 2219d9f3fbaSHeiner Kallweit { PCI_VENDOR_ID_LINKSYS, 0x1032, PCI_ANY_ID, 0x0024 }, 2229d9f3fbaSHeiner Kallweit { 0x0001, 0x8168, PCI_ANY_ID, 0x2410 }, 22325e992a4SHeiner Kallweit {} 22425e992a4SHeiner Kallweit }; 22525e992a4SHeiner Kallweit 22625e992a4SHeiner Kallweit MODULE_DEVICE_TABLE(pci, rtl8169_pci_tbl); 22725e992a4SHeiner Kallweit 22825e992a4SHeiner Kallweit static struct { 22925e992a4SHeiner Kallweit u32 msg_enable; 23025e992a4SHeiner Kallweit } debug = { -1 }; 23125e992a4SHeiner Kallweit 23225e992a4SHeiner Kallweit enum rtl_registers { 23325e992a4SHeiner Kallweit MAC0 = 0, /* Ethernet hardware address. */ 23425e992a4SHeiner Kallweit MAC4 = 4, 23525e992a4SHeiner Kallweit MAR0 = 8, /* Multicast filter. */ 23625e992a4SHeiner Kallweit CounterAddrLow = 0x10, 23725e992a4SHeiner Kallweit CounterAddrHigh = 0x14, 23825e992a4SHeiner Kallweit TxDescStartAddrLow = 0x20, 23925e992a4SHeiner Kallweit TxDescStartAddrHigh = 0x24, 24025e992a4SHeiner Kallweit TxHDescStartAddrLow = 0x28, 24125e992a4SHeiner Kallweit TxHDescStartAddrHigh = 0x2c, 24225e992a4SHeiner Kallweit FLASH = 0x30, 24325e992a4SHeiner Kallweit ERSR = 0x36, 24425e992a4SHeiner Kallweit ChipCmd = 0x37, 24525e992a4SHeiner Kallweit TxPoll = 0x38, 24625e992a4SHeiner Kallweit IntrMask = 0x3c, 24725e992a4SHeiner Kallweit IntrStatus = 0x3e, 24825e992a4SHeiner Kallweit 24925e992a4SHeiner Kallweit TxConfig = 0x40, 25025e992a4SHeiner Kallweit #define TXCFG_AUTO_FIFO (1 << 7) /* 8111e-vl */ 25125e992a4SHeiner Kallweit #define TXCFG_EMPTY (1 << 11) /* 8111e-vl */ 25225e992a4SHeiner Kallweit 25325e992a4SHeiner Kallweit RxConfig = 0x44, 25425e992a4SHeiner Kallweit #define RX128_INT_EN (1 << 15) /* 8111c and later */ 25525e992a4SHeiner Kallweit #define RX_MULTI_EN (1 << 14) /* 8111c only */ 25625e992a4SHeiner Kallweit #define RXCFG_FIFO_SHIFT 13 25725e992a4SHeiner Kallweit /* No threshold before first PCI xfer */ 25825e992a4SHeiner Kallweit #define RX_FIFO_THRESH (7 << RXCFG_FIFO_SHIFT) 25925e992a4SHeiner Kallweit #define RX_EARLY_OFF (1 << 11) 26025e992a4SHeiner Kallweit #define RXCFG_DMA_SHIFT 8 26125e992a4SHeiner Kallweit /* Unlimited maximum PCI burst. */ 26225e992a4SHeiner Kallweit #define RX_DMA_BURST (7 << RXCFG_DMA_SHIFT) 26325e992a4SHeiner Kallweit 26425e992a4SHeiner Kallweit RxMissed = 0x4c, 26525e992a4SHeiner Kallweit Cfg9346 = 0x50, 26625e992a4SHeiner Kallweit Config0 = 0x51, 26725e992a4SHeiner Kallweit Config1 = 0x52, 26825e992a4SHeiner Kallweit Config2 = 0x53, 26925e992a4SHeiner Kallweit #define PME_SIGNAL (1 << 5) /* 8168c and later */ 27025e992a4SHeiner Kallweit 27125e992a4SHeiner Kallweit Config3 = 0x54, 27225e992a4SHeiner Kallweit Config4 = 0x55, 27325e992a4SHeiner Kallweit Config5 = 0x56, 27425e992a4SHeiner Kallweit MultiIntr = 0x5c, 27525e992a4SHeiner Kallweit PHYAR = 0x60, 27625e992a4SHeiner Kallweit PHYstatus = 0x6c, 27725e992a4SHeiner Kallweit RxMaxSize = 0xda, 27825e992a4SHeiner Kallweit CPlusCmd = 0xe0, 27925e992a4SHeiner Kallweit IntrMitigate = 0xe2, 28025e992a4SHeiner Kallweit 28125e992a4SHeiner Kallweit #define RTL_COALESCE_MASK 0x0f 28225e992a4SHeiner Kallweit #define RTL_COALESCE_SHIFT 4 28325e992a4SHeiner Kallweit #define RTL_COALESCE_T_MAX (RTL_COALESCE_MASK) 28425e992a4SHeiner Kallweit #define RTL_COALESCE_FRAME_MAX (RTL_COALESCE_MASK << 2) 28525e992a4SHeiner Kallweit 28625e992a4SHeiner Kallweit RxDescAddrLow = 0xe4, 28725e992a4SHeiner Kallweit RxDescAddrHigh = 0xe8, 28825e992a4SHeiner Kallweit EarlyTxThres = 0xec, /* 8169. Unit of 32 bytes. */ 28925e992a4SHeiner Kallweit 29025e992a4SHeiner Kallweit #define NoEarlyTx 0x3f /* Max value : no early transmit. */ 29125e992a4SHeiner Kallweit 29225e992a4SHeiner Kallweit MaxTxPacketSize = 0xec, /* 8101/8168. Unit of 128 bytes. */ 29325e992a4SHeiner Kallweit 29425e992a4SHeiner Kallweit #define TxPacketMax (8064 >> 7) 29525e992a4SHeiner Kallweit #define EarlySize 0x27 29625e992a4SHeiner Kallweit 29725e992a4SHeiner Kallweit FuncEvent = 0xf0, 29825e992a4SHeiner Kallweit FuncEventMask = 0xf4, 29925e992a4SHeiner Kallweit FuncPresetState = 0xf8, 30025e992a4SHeiner Kallweit IBCR0 = 0xf8, 30125e992a4SHeiner Kallweit IBCR2 = 0xf9, 30225e992a4SHeiner Kallweit IBIMR0 = 0xfa, 30325e992a4SHeiner Kallweit IBISR0 = 0xfb, 30425e992a4SHeiner Kallweit FuncForceEvent = 0xfc, 30525e992a4SHeiner Kallweit }; 30625e992a4SHeiner Kallweit 30725e992a4SHeiner Kallweit enum rtl8168_8101_registers { 30825e992a4SHeiner Kallweit CSIDR = 0x64, 30925e992a4SHeiner Kallweit CSIAR = 0x68, 31025e992a4SHeiner Kallweit #define CSIAR_FLAG 0x80000000 31125e992a4SHeiner Kallweit #define CSIAR_WRITE_CMD 0x80000000 31225e992a4SHeiner Kallweit #define CSIAR_BYTE_ENABLE 0x0000f000 31325e992a4SHeiner Kallweit #define CSIAR_ADDR_MASK 0x00000fff 31425e992a4SHeiner Kallweit PMCH = 0x6f, 31525e992a4SHeiner Kallweit EPHYAR = 0x80, 31625e992a4SHeiner Kallweit #define EPHYAR_FLAG 0x80000000 31725e992a4SHeiner Kallweit #define EPHYAR_WRITE_CMD 0x80000000 31825e992a4SHeiner Kallweit #define EPHYAR_REG_MASK 0x1f 31925e992a4SHeiner Kallweit #define EPHYAR_REG_SHIFT 16 32025e992a4SHeiner Kallweit #define EPHYAR_DATA_MASK 0xffff 32125e992a4SHeiner Kallweit DLLPR = 0xd0, 32225e992a4SHeiner Kallweit #define PFM_EN (1 << 6) 32325e992a4SHeiner Kallweit #define TX_10M_PS_EN (1 << 7) 32425e992a4SHeiner Kallweit DBG_REG = 0xd1, 32525e992a4SHeiner Kallweit #define FIX_NAK_1 (1 << 4) 32625e992a4SHeiner Kallweit #define FIX_NAK_2 (1 << 3) 32725e992a4SHeiner Kallweit TWSI = 0xd2, 32825e992a4SHeiner Kallweit MCU = 0xd3, 32925e992a4SHeiner Kallweit #define NOW_IS_OOB (1 << 7) 33025e992a4SHeiner Kallweit #define TX_EMPTY (1 << 5) 33125e992a4SHeiner Kallweit #define RX_EMPTY (1 << 4) 33225e992a4SHeiner Kallweit #define RXTX_EMPTY (TX_EMPTY | RX_EMPTY) 33325e992a4SHeiner Kallweit #define EN_NDP (1 << 3) 33425e992a4SHeiner Kallweit #define EN_OOB_RESET (1 << 2) 33525e992a4SHeiner Kallweit #define LINK_LIST_RDY (1 << 1) 33625e992a4SHeiner Kallweit EFUSEAR = 0xdc, 33725e992a4SHeiner Kallweit #define EFUSEAR_FLAG 0x80000000 33825e992a4SHeiner Kallweit #define EFUSEAR_WRITE_CMD 0x80000000 33925e992a4SHeiner Kallweit #define EFUSEAR_READ_CMD 0x00000000 34025e992a4SHeiner Kallweit #define EFUSEAR_REG_MASK 0x03ff 34125e992a4SHeiner Kallweit #define EFUSEAR_REG_SHIFT 8 34225e992a4SHeiner Kallweit #define EFUSEAR_DATA_MASK 0xff 34325e992a4SHeiner Kallweit MISC_1 = 0xf2, 34425e992a4SHeiner Kallweit #define PFM_D3COLD_EN (1 << 6) 34525e992a4SHeiner Kallweit }; 34625e992a4SHeiner Kallweit 34725e992a4SHeiner Kallweit enum rtl8168_registers { 34825e992a4SHeiner Kallweit LED_FREQ = 0x1a, 34925e992a4SHeiner Kallweit EEE_LED = 0x1b, 35025e992a4SHeiner Kallweit ERIDR = 0x70, 35125e992a4SHeiner Kallweit ERIAR = 0x74, 35225e992a4SHeiner Kallweit #define ERIAR_FLAG 0x80000000 35325e992a4SHeiner Kallweit #define ERIAR_WRITE_CMD 0x80000000 35425e992a4SHeiner Kallweit #define ERIAR_READ_CMD 0x00000000 35525e992a4SHeiner Kallweit #define ERIAR_ADDR_BYTE_ALIGN 4 35625e992a4SHeiner Kallweit #define ERIAR_TYPE_SHIFT 16 35725e992a4SHeiner Kallweit #define ERIAR_EXGMAC (0x00 << ERIAR_TYPE_SHIFT) 35825e992a4SHeiner Kallweit #define ERIAR_MSIX (0x01 << ERIAR_TYPE_SHIFT) 35925e992a4SHeiner Kallweit #define ERIAR_ASF (0x02 << ERIAR_TYPE_SHIFT) 36025e992a4SHeiner Kallweit #define ERIAR_OOB (0x02 << ERIAR_TYPE_SHIFT) 36125e992a4SHeiner Kallweit #define ERIAR_MASK_SHIFT 12 36225e992a4SHeiner Kallweit #define ERIAR_MASK_0001 (0x1 << ERIAR_MASK_SHIFT) 36325e992a4SHeiner Kallweit #define ERIAR_MASK_0011 (0x3 << ERIAR_MASK_SHIFT) 36425e992a4SHeiner Kallweit #define ERIAR_MASK_0100 (0x4 << ERIAR_MASK_SHIFT) 36525e992a4SHeiner Kallweit #define ERIAR_MASK_0101 (0x5 << ERIAR_MASK_SHIFT) 36625e992a4SHeiner Kallweit #define ERIAR_MASK_1111 (0xf << ERIAR_MASK_SHIFT) 36725e992a4SHeiner Kallweit EPHY_RXER_NUM = 0x7c, 36825e992a4SHeiner Kallweit OCPDR = 0xb0, /* OCP GPHY access */ 36925e992a4SHeiner Kallweit #define OCPDR_WRITE_CMD 0x80000000 37025e992a4SHeiner Kallweit #define OCPDR_READ_CMD 0x00000000 37125e992a4SHeiner Kallweit #define OCPDR_REG_MASK 0x7f 37225e992a4SHeiner Kallweit #define OCPDR_GPHY_REG_SHIFT 16 37325e992a4SHeiner Kallweit #define OCPDR_DATA_MASK 0xffff 37425e992a4SHeiner Kallweit OCPAR = 0xb4, 37525e992a4SHeiner Kallweit #define OCPAR_FLAG 0x80000000 37625e992a4SHeiner Kallweit #define OCPAR_GPHY_WRITE_CMD 0x8000f060 37725e992a4SHeiner Kallweit #define OCPAR_GPHY_READ_CMD 0x0000f060 37825e992a4SHeiner Kallweit GPHY_OCP = 0xb8, 37925e992a4SHeiner Kallweit RDSAR1 = 0xd0, /* 8168c only. Undocumented on 8168dp */ 38025e992a4SHeiner Kallweit MISC = 0xf0, /* 8168e only. */ 38125e992a4SHeiner Kallweit #define TXPLA_RST (1 << 29) 38225e992a4SHeiner Kallweit #define DISABLE_LAN_EN (1 << 23) /* Enable GPIO pin */ 38325e992a4SHeiner Kallweit #define PWM_EN (1 << 22) 38425e992a4SHeiner Kallweit #define RXDV_GATED_EN (1 << 19) 38525e992a4SHeiner Kallweit #define EARLY_TALLY_EN (1 << 16) 38625e992a4SHeiner Kallweit }; 38725e992a4SHeiner Kallweit 38825e992a4SHeiner Kallweit enum rtl_register_content { 38925e992a4SHeiner Kallweit /* InterruptStatusBits */ 39025e992a4SHeiner Kallweit SYSErr = 0x8000, 39125e992a4SHeiner Kallweit PCSTimeout = 0x4000, 39225e992a4SHeiner Kallweit SWInt = 0x0100, 39325e992a4SHeiner Kallweit TxDescUnavail = 0x0080, 39425e992a4SHeiner Kallweit RxFIFOOver = 0x0040, 39525e992a4SHeiner Kallweit LinkChg = 0x0020, 39625e992a4SHeiner Kallweit RxOverflow = 0x0010, 39725e992a4SHeiner Kallweit TxErr = 0x0008, 39825e992a4SHeiner Kallweit TxOK = 0x0004, 39925e992a4SHeiner Kallweit RxErr = 0x0002, 40025e992a4SHeiner Kallweit RxOK = 0x0001, 40125e992a4SHeiner Kallweit 40225e992a4SHeiner Kallweit /* RxStatusDesc */ 40325e992a4SHeiner Kallweit RxRWT = (1 << 22), 40425e992a4SHeiner Kallweit RxRES = (1 << 21), 40525e992a4SHeiner Kallweit RxRUNT = (1 << 20), 40625e992a4SHeiner Kallweit RxCRC = (1 << 19), 40725e992a4SHeiner Kallweit 40825e992a4SHeiner Kallweit /* ChipCmdBits */ 40925e992a4SHeiner Kallweit StopReq = 0x80, 41025e992a4SHeiner Kallweit CmdReset = 0x10, 41125e992a4SHeiner Kallweit CmdRxEnb = 0x08, 41225e992a4SHeiner Kallweit CmdTxEnb = 0x04, 41325e992a4SHeiner Kallweit RxBufEmpty = 0x01, 41425e992a4SHeiner Kallweit 41525e992a4SHeiner Kallweit /* TXPoll register p.5 */ 41625e992a4SHeiner Kallweit HPQ = 0x80, /* Poll cmd on the high prio queue */ 41725e992a4SHeiner Kallweit NPQ = 0x40, /* Poll cmd on the low prio queue */ 41825e992a4SHeiner Kallweit FSWInt = 0x01, /* Forced software interrupt */ 41925e992a4SHeiner Kallweit 42025e992a4SHeiner Kallweit /* Cfg9346Bits */ 42125e992a4SHeiner Kallweit Cfg9346_Lock = 0x00, 42225e992a4SHeiner Kallweit Cfg9346_Unlock = 0xc0, 42325e992a4SHeiner Kallweit 42425e992a4SHeiner Kallweit /* rx_mode_bits */ 42525e992a4SHeiner Kallweit AcceptErr = 0x20, 42625e992a4SHeiner Kallweit AcceptRunt = 0x10, 42725e992a4SHeiner Kallweit AcceptBroadcast = 0x08, 42825e992a4SHeiner Kallweit AcceptMulticast = 0x04, 42925e992a4SHeiner Kallweit AcceptMyPhys = 0x02, 43025e992a4SHeiner Kallweit AcceptAllPhys = 0x01, 43125e992a4SHeiner Kallweit #define RX_CONFIG_ACCEPT_MASK 0x3f 43225e992a4SHeiner Kallweit 43325e992a4SHeiner Kallweit /* TxConfigBits */ 43425e992a4SHeiner Kallweit TxInterFrameGapShift = 24, 43525e992a4SHeiner Kallweit TxDMAShift = 8, /* DMA burst value (0-7) is shift this many bits */ 43625e992a4SHeiner Kallweit 43725e992a4SHeiner Kallweit /* Config1 register p.24 */ 43825e992a4SHeiner Kallweit LEDS1 = (1 << 7), 43925e992a4SHeiner Kallweit LEDS0 = (1 << 6), 44025e992a4SHeiner Kallweit Speed_down = (1 << 4), 44125e992a4SHeiner Kallweit MEMMAP = (1 << 3), 44225e992a4SHeiner Kallweit IOMAP = (1 << 2), 44325e992a4SHeiner Kallweit VPD = (1 << 1), 44425e992a4SHeiner Kallweit PMEnable = (1 << 0), /* Power Management Enable */ 44525e992a4SHeiner Kallweit 44625e992a4SHeiner Kallweit /* Config2 register p. 25 */ 44725e992a4SHeiner Kallweit ClkReqEn = (1 << 7), /* Clock Request Enable */ 44825e992a4SHeiner Kallweit MSIEnable = (1 << 5), /* 8169 only. Reserved in the 8168. */ 44925e992a4SHeiner Kallweit PCI_Clock_66MHz = 0x01, 45025e992a4SHeiner Kallweit PCI_Clock_33MHz = 0x00, 45125e992a4SHeiner Kallweit 45225e992a4SHeiner Kallweit /* Config3 register p.25 */ 45325e992a4SHeiner Kallweit MagicPacket = (1 << 5), /* Wake up when receives a Magic Packet */ 45425e992a4SHeiner Kallweit LinkUp = (1 << 4), /* Wake up when the cable connection is re-established */ 45525e992a4SHeiner Kallweit Jumbo_En0 = (1 << 2), /* 8168 only. Reserved in the 8168b */ 45625e992a4SHeiner Kallweit Rdy_to_L23 = (1 << 1), /* L23 Enable */ 45725e992a4SHeiner Kallweit Beacon_en = (1 << 0), /* 8168 only. Reserved in the 8168b */ 45825e992a4SHeiner Kallweit 45925e992a4SHeiner Kallweit /* Config4 register */ 46025e992a4SHeiner Kallweit Jumbo_En1 = (1 << 1), /* 8168 only. Reserved in the 8168b */ 46125e992a4SHeiner Kallweit 46225e992a4SHeiner Kallweit /* Config5 register p.27 */ 46325e992a4SHeiner Kallweit BWF = (1 << 6), /* Accept Broadcast wakeup frame */ 46425e992a4SHeiner Kallweit MWF = (1 << 5), /* Accept Multicast wakeup frame */ 46525e992a4SHeiner Kallweit UWF = (1 << 4), /* Accept Unicast wakeup frame */ 46625e992a4SHeiner Kallweit Spi_en = (1 << 3), 46725e992a4SHeiner Kallweit LanWake = (1 << 1), /* LanWake enable/disable */ 46825e992a4SHeiner Kallweit PMEStatus = (1 << 0), /* PME status can be reset by PCI RST# */ 46925e992a4SHeiner Kallweit ASPM_en = (1 << 0), /* ASPM enable */ 47025e992a4SHeiner Kallweit 47125e992a4SHeiner Kallweit /* CPlusCmd p.31 */ 47225e992a4SHeiner Kallweit EnableBist = (1 << 15), // 8168 8101 47325e992a4SHeiner Kallweit Mac_dbgo_oe = (1 << 14), // 8168 8101 47425e992a4SHeiner Kallweit Normal_mode = (1 << 13), // unused 47525e992a4SHeiner Kallweit Force_half_dup = (1 << 12), // 8168 8101 47625e992a4SHeiner Kallweit Force_rxflow_en = (1 << 11), // 8168 8101 47725e992a4SHeiner Kallweit Force_txflow_en = (1 << 10), // 8168 8101 47825e992a4SHeiner Kallweit Cxpl_dbg_sel = (1 << 9), // 8168 8101 47925e992a4SHeiner Kallweit ASF = (1 << 8), // 8168 8101 48025e992a4SHeiner Kallweit PktCntrDisable = (1 << 7), // 8168 8101 48125e992a4SHeiner Kallweit Mac_dbgo_sel = 0x001c, // 8168 48225e992a4SHeiner Kallweit RxVlan = (1 << 6), 48325e992a4SHeiner Kallweit RxChkSum = (1 << 5), 48425e992a4SHeiner Kallweit PCIDAC = (1 << 4), 48525e992a4SHeiner Kallweit PCIMulRW = (1 << 3), 48625e992a4SHeiner Kallweit #define INTT_MASK GENMASK(1, 0) 487bc73241eSHeiner Kallweit #define CPCMD_MASK (Normal_mode | RxVlan | RxChkSum | INTT_MASK) 48825e992a4SHeiner Kallweit 48925e992a4SHeiner Kallweit /* rtl8169_PHYstatus */ 49025e992a4SHeiner Kallweit TBI_Enable = 0x80, 49125e992a4SHeiner Kallweit TxFlowCtrl = 0x40, 49225e992a4SHeiner Kallweit RxFlowCtrl = 0x20, 49325e992a4SHeiner Kallweit _1000bpsF = 0x10, 49425e992a4SHeiner Kallweit _100bps = 0x08, 49525e992a4SHeiner Kallweit _10bps = 0x04, 49625e992a4SHeiner Kallweit LinkStatus = 0x02, 49725e992a4SHeiner Kallweit FullDup = 0x01, 49825e992a4SHeiner Kallweit 49925e992a4SHeiner Kallweit /* ResetCounterCommand */ 50025e992a4SHeiner Kallweit CounterReset = 0x1, 50125e992a4SHeiner Kallweit 50225e992a4SHeiner Kallweit /* DumpCounterCommand */ 50325e992a4SHeiner Kallweit CounterDump = 0x8, 50425e992a4SHeiner Kallweit 50525e992a4SHeiner Kallweit /* magic enable v2 */ 50625e992a4SHeiner Kallweit MagicPacket_v2 = (1 << 16), /* Wake up when receives a Magic Packet */ 50725e992a4SHeiner Kallweit }; 50825e992a4SHeiner Kallweit 50925e992a4SHeiner Kallweit enum rtl_desc_bit { 51025e992a4SHeiner Kallweit /* First doubleword. */ 51125e992a4SHeiner Kallweit DescOwn = (1 << 31), /* Descriptor is owned by NIC */ 51225e992a4SHeiner Kallweit RingEnd = (1 << 30), /* End of descriptor ring */ 51325e992a4SHeiner Kallweit FirstFrag = (1 << 29), /* First segment of a packet */ 51425e992a4SHeiner Kallweit LastFrag = (1 << 28), /* Final segment of a packet */ 51525e992a4SHeiner Kallweit }; 51625e992a4SHeiner Kallweit 51725e992a4SHeiner Kallweit /* Generic case. */ 51825e992a4SHeiner Kallweit enum rtl_tx_desc_bit { 51925e992a4SHeiner Kallweit /* First doubleword. */ 52025e992a4SHeiner Kallweit TD_LSO = (1 << 27), /* Large Send Offload */ 52125e992a4SHeiner Kallweit #define TD_MSS_MAX 0x07ffu /* MSS value */ 52225e992a4SHeiner Kallweit 52325e992a4SHeiner Kallweit /* Second doubleword. */ 52425e992a4SHeiner Kallweit TxVlanTag = (1 << 17), /* Add VLAN tag */ 52525e992a4SHeiner Kallweit }; 52625e992a4SHeiner Kallweit 52725e992a4SHeiner Kallweit /* 8169, 8168b and 810x except 8102e. */ 52825e992a4SHeiner Kallweit enum rtl_tx_desc_bit_0 { 52925e992a4SHeiner Kallweit /* First doubleword. */ 53025e992a4SHeiner Kallweit #define TD0_MSS_SHIFT 16 /* MSS position (11 bits) */ 53125e992a4SHeiner Kallweit TD0_TCP_CS = (1 << 16), /* Calculate TCP/IP checksum */ 53225e992a4SHeiner Kallweit TD0_UDP_CS = (1 << 17), /* Calculate UDP/IP checksum */ 53325e992a4SHeiner Kallweit TD0_IP_CS = (1 << 18), /* Calculate IP checksum */ 53425e992a4SHeiner Kallweit }; 53525e992a4SHeiner Kallweit 53625e992a4SHeiner Kallweit /* 8102e, 8168c and beyond. */ 53725e992a4SHeiner Kallweit enum rtl_tx_desc_bit_1 { 53825e992a4SHeiner Kallweit /* First doubleword. */ 53925e992a4SHeiner Kallweit TD1_GTSENV4 = (1 << 26), /* Giant Send for IPv4 */ 54025e992a4SHeiner Kallweit TD1_GTSENV6 = (1 << 25), /* Giant Send for IPv6 */ 54125e992a4SHeiner Kallweit #define GTTCPHO_SHIFT 18 54225e992a4SHeiner Kallweit #define GTTCPHO_MAX 0x7fU 54325e992a4SHeiner Kallweit 54425e992a4SHeiner Kallweit /* Second doubleword. */ 54525e992a4SHeiner Kallweit #define TCPHO_SHIFT 18 54625e992a4SHeiner Kallweit #define TCPHO_MAX 0x3ffU 54725e992a4SHeiner Kallweit #define TD1_MSS_SHIFT 18 /* MSS position (11 bits) */ 54825e992a4SHeiner Kallweit TD1_IPv6_CS = (1 << 28), /* Calculate IPv6 checksum */ 54925e992a4SHeiner Kallweit TD1_IPv4_CS = (1 << 29), /* Calculate IPv4 checksum */ 55025e992a4SHeiner Kallweit TD1_TCP_CS = (1 << 30), /* Calculate TCP/IP checksum */ 55125e992a4SHeiner Kallweit TD1_UDP_CS = (1 << 31), /* Calculate UDP/IP checksum */ 55225e992a4SHeiner Kallweit }; 55325e992a4SHeiner Kallweit 55425e992a4SHeiner Kallweit enum rtl_rx_desc_bit { 55525e992a4SHeiner Kallweit /* Rx private */ 55625e992a4SHeiner Kallweit PID1 = (1 << 18), /* Protocol ID bit 1/2 */ 55725e992a4SHeiner Kallweit PID0 = (1 << 17), /* Protocol ID bit 0/2 */ 55825e992a4SHeiner Kallweit 55925e992a4SHeiner Kallweit #define RxProtoUDP (PID1) 56025e992a4SHeiner Kallweit #define RxProtoTCP (PID0) 56125e992a4SHeiner Kallweit #define RxProtoIP (PID1 | PID0) 56225e992a4SHeiner Kallweit #define RxProtoMask RxProtoIP 56325e992a4SHeiner Kallweit 56425e992a4SHeiner Kallweit IPFail = (1 << 16), /* IP checksum failed */ 56525e992a4SHeiner Kallweit UDPFail = (1 << 15), /* UDP/IP checksum failed */ 56625e992a4SHeiner Kallweit TCPFail = (1 << 14), /* TCP/IP checksum failed */ 56725e992a4SHeiner Kallweit RxVlanTag = (1 << 16), /* VLAN tag available */ 56825e992a4SHeiner Kallweit }; 56925e992a4SHeiner Kallweit 57025e992a4SHeiner Kallweit #define RsvdMask 0x3fffc000 57125e992a4SHeiner Kallweit 57225e992a4SHeiner Kallweit struct TxDesc { 57325e992a4SHeiner Kallweit __le32 opts1; 57425e992a4SHeiner Kallweit __le32 opts2; 57525e992a4SHeiner Kallweit __le64 addr; 57625e992a4SHeiner Kallweit }; 57725e992a4SHeiner Kallweit 57825e992a4SHeiner Kallweit struct RxDesc { 57925e992a4SHeiner Kallweit __le32 opts1; 58025e992a4SHeiner Kallweit __le32 opts2; 58125e992a4SHeiner Kallweit __le64 addr; 58225e992a4SHeiner Kallweit }; 58325e992a4SHeiner Kallweit 58425e992a4SHeiner Kallweit struct ring_info { 58525e992a4SHeiner Kallweit struct sk_buff *skb; 58625e992a4SHeiner Kallweit u32 len; 58725e992a4SHeiner Kallweit }; 58825e992a4SHeiner Kallweit 58925e992a4SHeiner Kallweit struct rtl8169_counters { 59025e992a4SHeiner Kallweit __le64 tx_packets; 59125e992a4SHeiner Kallweit __le64 rx_packets; 59225e992a4SHeiner Kallweit __le64 tx_errors; 59325e992a4SHeiner Kallweit __le32 rx_errors; 59425e992a4SHeiner Kallweit __le16 rx_missed; 59525e992a4SHeiner Kallweit __le16 align_errors; 59625e992a4SHeiner Kallweit __le32 tx_one_collision; 59725e992a4SHeiner Kallweit __le32 tx_multi_collision; 59825e992a4SHeiner Kallweit __le64 rx_unicast; 59925e992a4SHeiner Kallweit __le64 rx_broadcast; 60025e992a4SHeiner Kallweit __le32 rx_multicast; 60125e992a4SHeiner Kallweit __le16 tx_aborted; 60225e992a4SHeiner Kallweit __le16 tx_underun; 60325e992a4SHeiner Kallweit }; 60425e992a4SHeiner Kallweit 60525e992a4SHeiner Kallweit struct rtl8169_tc_offsets { 60625e992a4SHeiner Kallweit bool inited; 60725e992a4SHeiner Kallweit __le64 tx_errors; 60825e992a4SHeiner Kallweit __le32 tx_multi_collision; 60925e992a4SHeiner Kallweit __le16 tx_aborted; 61025e992a4SHeiner Kallweit }; 61125e992a4SHeiner Kallweit 61225e992a4SHeiner Kallweit enum rtl_flag { 61325e992a4SHeiner Kallweit RTL_FLAG_TASK_ENABLED = 0, 61425e992a4SHeiner Kallweit RTL_FLAG_TASK_RESET_PENDING, 61525e992a4SHeiner Kallweit RTL_FLAG_MAX 61625e992a4SHeiner Kallweit }; 61725e992a4SHeiner Kallweit 61825e992a4SHeiner Kallweit struct rtl8169_stats { 61925e992a4SHeiner Kallweit u64 packets; 62025e992a4SHeiner Kallweit u64 bytes; 62125e992a4SHeiner Kallweit struct u64_stats_sync syncp; 62225e992a4SHeiner Kallweit }; 62325e992a4SHeiner Kallweit 62425e992a4SHeiner Kallweit struct rtl8169_private { 62525e992a4SHeiner Kallweit void __iomem *mmio_addr; /* memory map physical address */ 62625e992a4SHeiner Kallweit struct pci_dev *pci_dev; 62725e992a4SHeiner Kallweit struct net_device *dev; 62825e992a4SHeiner Kallweit struct phy_device *phydev; 62925e992a4SHeiner Kallweit struct napi_struct napi; 63025e992a4SHeiner Kallweit u32 msg_enable; 63125e992a4SHeiner Kallweit enum mac_version mac_version; 63225e992a4SHeiner Kallweit u32 cur_rx; /* Index into the Rx descriptor buffer of next Rx pkt. */ 63325e992a4SHeiner Kallweit u32 cur_tx; /* Index into the Tx descriptor buffer of next Rx pkt. */ 63425e992a4SHeiner Kallweit u32 dirty_tx; 63525e992a4SHeiner Kallweit struct rtl8169_stats rx_stats; 63625e992a4SHeiner Kallweit struct rtl8169_stats tx_stats; 63725e992a4SHeiner Kallweit struct TxDesc *TxDescArray; /* 256-aligned Tx descriptor ring */ 63825e992a4SHeiner Kallweit struct RxDesc *RxDescArray; /* 256-aligned Rx descriptor ring */ 63925e992a4SHeiner Kallweit dma_addr_t TxPhyAddr; 64025e992a4SHeiner Kallweit dma_addr_t RxPhyAddr; 64125e992a4SHeiner Kallweit void *Rx_databuff[NUM_RX_DESC]; /* Rx data buffers */ 64225e992a4SHeiner Kallweit struct ring_info tx_skb[NUM_TX_DESC]; /* Tx data buffers */ 64325e992a4SHeiner Kallweit u16 cp_cmd; 64425e992a4SHeiner Kallweit u16 irq_mask; 64525e992a4SHeiner Kallweit struct clk *clk; 64625e992a4SHeiner Kallweit 64725e992a4SHeiner Kallweit struct { 64825e992a4SHeiner Kallweit DECLARE_BITMAP(flags, RTL_FLAG_MAX); 64925e992a4SHeiner Kallweit struct mutex mutex; 65025e992a4SHeiner Kallweit struct work_struct work; 65125e992a4SHeiner Kallweit } wk; 65225e992a4SHeiner Kallweit 65325e992a4SHeiner Kallweit unsigned irq_enabled:1; 65425e992a4SHeiner Kallweit unsigned supports_gmii:1; 65562b1b3b3SHeiner Kallweit unsigned aspm_manageable:1; 65625e992a4SHeiner Kallweit dma_addr_t counters_phys_addr; 65725e992a4SHeiner Kallweit struct rtl8169_counters *counters; 65825e992a4SHeiner Kallweit struct rtl8169_tc_offsets tc_offset; 65925e992a4SHeiner Kallweit u32 saved_wolopts; 66025e992a4SHeiner Kallweit 66125e992a4SHeiner Kallweit const char *fw_name; 6628197f9d2SHeiner Kallweit struct rtl_fw *rtl_fw; 66325e992a4SHeiner Kallweit 66425e992a4SHeiner Kallweit u32 ocp_base; 66525e992a4SHeiner Kallweit }; 66625e992a4SHeiner Kallweit 66725e992a4SHeiner Kallweit typedef void (*rtl_generic_fct)(struct rtl8169_private *tp); 66825e992a4SHeiner Kallweit 66925e992a4SHeiner Kallweit MODULE_AUTHOR("Realtek and the Linux r8169 crew <netdev@vger.kernel.org>"); 67025e992a4SHeiner Kallweit MODULE_DESCRIPTION("RealTek RTL-8169 Gigabit Ethernet driver"); 67125e992a4SHeiner Kallweit module_param_named(debug, debug.msg_enable, int, 0); 67225e992a4SHeiner Kallweit MODULE_PARM_DESC(debug, "Debug verbosity level (0=none, ..., 16=all)"); 67325e992a4SHeiner Kallweit MODULE_SOFTDEP("pre: realtek"); 67425e992a4SHeiner Kallweit MODULE_LICENSE("GPL"); 67525e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168D_1); 67625e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168D_2); 67725e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168E_1); 67825e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168E_2); 67925e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168E_3); 68025e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8105E_1); 68125e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168F_1); 68225e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168F_2); 68325e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8402_1); 68425e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8411_1); 68525e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8411_2); 68625e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8106E_1); 68725e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8106E_2); 68825e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168G_2); 68925e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168G_3); 69025e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168H_1); 69125e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168H_2); 69225e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8107E_1); 69325e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8107E_2); 69425e992a4SHeiner Kallweit 69525e992a4SHeiner Kallweit static inline struct device *tp_to_dev(struct rtl8169_private *tp) 69625e992a4SHeiner Kallweit { 69725e992a4SHeiner Kallweit return &tp->pci_dev->dev; 69825e992a4SHeiner Kallweit } 69925e992a4SHeiner Kallweit 70025e992a4SHeiner Kallweit static void rtl_lock_work(struct rtl8169_private *tp) 70125e992a4SHeiner Kallweit { 70225e992a4SHeiner Kallweit mutex_lock(&tp->wk.mutex); 70325e992a4SHeiner Kallweit } 70425e992a4SHeiner Kallweit 70525e992a4SHeiner Kallweit static void rtl_unlock_work(struct rtl8169_private *tp) 70625e992a4SHeiner Kallweit { 70725e992a4SHeiner Kallweit mutex_unlock(&tp->wk.mutex); 70825e992a4SHeiner Kallweit } 70925e992a4SHeiner Kallweit 71025e992a4SHeiner Kallweit static void rtl_lock_config_regs(struct rtl8169_private *tp) 71125e992a4SHeiner Kallweit { 71225e992a4SHeiner Kallweit RTL_W8(tp, Cfg9346, Cfg9346_Lock); 71325e992a4SHeiner Kallweit } 71425e992a4SHeiner Kallweit 71525e992a4SHeiner Kallweit static void rtl_unlock_config_regs(struct rtl8169_private *tp) 71625e992a4SHeiner Kallweit { 71725e992a4SHeiner Kallweit RTL_W8(tp, Cfg9346, Cfg9346_Unlock); 71825e992a4SHeiner Kallweit } 71925e992a4SHeiner Kallweit 72025e992a4SHeiner Kallweit static void rtl_tx_performance_tweak(struct rtl8169_private *tp, u16 force) 72125e992a4SHeiner Kallweit { 72225e992a4SHeiner Kallweit pcie_capability_clear_and_set_word(tp->pci_dev, PCI_EXP_DEVCTL, 72325e992a4SHeiner Kallweit PCI_EXP_DEVCTL_READRQ, force); 72425e992a4SHeiner Kallweit } 72525e992a4SHeiner Kallweit 7269e9f33baSHeiner Kallweit static bool rtl_is_8168evl_up(struct rtl8169_private *tp) 7279e9f33baSHeiner Kallweit { 7289e9f33baSHeiner Kallweit return tp->mac_version >= RTL_GIGA_MAC_VER_34 && 7299e9f33baSHeiner Kallweit tp->mac_version != RTL_GIGA_MAC_VER_39; 7309e9f33baSHeiner Kallweit } 7319e9f33baSHeiner Kallweit 73225e992a4SHeiner Kallweit struct rtl_cond { 73325e992a4SHeiner Kallweit bool (*check)(struct rtl8169_private *); 73425e992a4SHeiner Kallweit const char *msg; 73525e992a4SHeiner Kallweit }; 73625e992a4SHeiner Kallweit 73725e992a4SHeiner Kallweit static void rtl_udelay(unsigned int d) 73825e992a4SHeiner Kallweit { 73925e992a4SHeiner Kallweit udelay(d); 74025e992a4SHeiner Kallweit } 74125e992a4SHeiner Kallweit 74225e992a4SHeiner Kallweit static bool rtl_loop_wait(struct rtl8169_private *tp, const struct rtl_cond *c, 74325e992a4SHeiner Kallweit void (*delay)(unsigned int), unsigned int d, int n, 74425e992a4SHeiner Kallweit bool high) 74525e992a4SHeiner Kallweit { 74625e992a4SHeiner Kallweit int i; 74725e992a4SHeiner Kallweit 74825e992a4SHeiner Kallweit for (i = 0; i < n; i++) { 74925e992a4SHeiner Kallweit if (c->check(tp) == high) 75025e992a4SHeiner Kallweit return true; 75125e992a4SHeiner Kallweit delay(d); 75225e992a4SHeiner Kallweit } 75325e992a4SHeiner Kallweit netif_err(tp, drv, tp->dev, "%s == %d (loop: %d, delay: %d).\n", 75425e992a4SHeiner Kallweit c->msg, !high, n, d); 75525e992a4SHeiner Kallweit return false; 75625e992a4SHeiner Kallweit } 75725e992a4SHeiner Kallweit 75825e992a4SHeiner Kallweit static bool rtl_udelay_loop_wait_high(struct rtl8169_private *tp, 75925e992a4SHeiner Kallweit const struct rtl_cond *c, 76025e992a4SHeiner Kallweit unsigned int d, int n) 76125e992a4SHeiner Kallweit { 76225e992a4SHeiner Kallweit return rtl_loop_wait(tp, c, rtl_udelay, d, n, true); 76325e992a4SHeiner Kallweit } 76425e992a4SHeiner Kallweit 76525e992a4SHeiner Kallweit static bool rtl_udelay_loop_wait_low(struct rtl8169_private *tp, 76625e992a4SHeiner Kallweit const struct rtl_cond *c, 76725e992a4SHeiner Kallweit unsigned int d, int n) 76825e992a4SHeiner Kallweit { 76925e992a4SHeiner Kallweit return rtl_loop_wait(tp, c, rtl_udelay, d, n, false); 77025e992a4SHeiner Kallweit } 77125e992a4SHeiner Kallweit 77225e992a4SHeiner Kallweit static bool rtl_msleep_loop_wait_high(struct rtl8169_private *tp, 77325e992a4SHeiner Kallweit const struct rtl_cond *c, 77425e992a4SHeiner Kallweit unsigned int d, int n) 77525e992a4SHeiner Kallweit { 77625e992a4SHeiner Kallweit return rtl_loop_wait(tp, c, msleep, d, n, true); 77725e992a4SHeiner Kallweit } 77825e992a4SHeiner Kallweit 77925e992a4SHeiner Kallweit static bool rtl_msleep_loop_wait_low(struct rtl8169_private *tp, 78025e992a4SHeiner Kallweit const struct rtl_cond *c, 78125e992a4SHeiner Kallweit unsigned int d, int n) 78225e992a4SHeiner Kallweit { 78325e992a4SHeiner Kallweit return rtl_loop_wait(tp, c, msleep, d, n, false); 78425e992a4SHeiner Kallweit } 78525e992a4SHeiner Kallweit 78625e992a4SHeiner Kallweit #define DECLARE_RTL_COND(name) \ 78725e992a4SHeiner Kallweit static bool name ## _check(struct rtl8169_private *); \ 78825e992a4SHeiner Kallweit \ 78925e992a4SHeiner Kallweit static const struct rtl_cond name = { \ 79025e992a4SHeiner Kallweit .check = name ## _check, \ 79125e992a4SHeiner Kallweit .msg = #name \ 79225e992a4SHeiner Kallweit }; \ 79325e992a4SHeiner Kallweit \ 79425e992a4SHeiner Kallweit static bool name ## _check(struct rtl8169_private *tp) 79525e992a4SHeiner Kallweit 79625e992a4SHeiner Kallweit static bool rtl_ocp_reg_failure(struct rtl8169_private *tp, u32 reg) 79725e992a4SHeiner Kallweit { 79825e992a4SHeiner Kallweit if (reg & 0xffff0001) { 79925e992a4SHeiner Kallweit netif_err(tp, drv, tp->dev, "Invalid ocp reg %x!\n", reg); 80025e992a4SHeiner Kallweit return true; 80125e992a4SHeiner Kallweit } 80225e992a4SHeiner Kallweit return false; 80325e992a4SHeiner Kallweit } 80425e992a4SHeiner Kallweit 80525e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_ocp_gphy_cond) 80625e992a4SHeiner Kallweit { 80725e992a4SHeiner Kallweit return RTL_R32(tp, GPHY_OCP) & OCPAR_FLAG; 80825e992a4SHeiner Kallweit } 80925e992a4SHeiner Kallweit 81025e992a4SHeiner Kallweit static void r8168_phy_ocp_write(struct rtl8169_private *tp, u32 reg, u32 data) 81125e992a4SHeiner Kallweit { 81225e992a4SHeiner Kallweit if (rtl_ocp_reg_failure(tp, reg)) 81325e992a4SHeiner Kallweit return; 81425e992a4SHeiner Kallweit 81525e992a4SHeiner Kallweit RTL_W32(tp, GPHY_OCP, OCPAR_FLAG | (reg << 15) | data); 81625e992a4SHeiner Kallweit 81725e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_ocp_gphy_cond, 25, 10); 81825e992a4SHeiner Kallweit } 81925e992a4SHeiner Kallweit 8209b994b4aSHeiner Kallweit static int r8168_phy_ocp_read(struct rtl8169_private *tp, u32 reg) 82125e992a4SHeiner Kallweit { 82225e992a4SHeiner Kallweit if (rtl_ocp_reg_failure(tp, reg)) 82325e992a4SHeiner Kallweit return 0; 82425e992a4SHeiner Kallweit 82525e992a4SHeiner Kallweit RTL_W32(tp, GPHY_OCP, reg << 15); 82625e992a4SHeiner Kallweit 82725e992a4SHeiner Kallweit return rtl_udelay_loop_wait_high(tp, &rtl_ocp_gphy_cond, 25, 10) ? 8289b994b4aSHeiner Kallweit (RTL_R32(tp, GPHY_OCP) & 0xffff) : -ETIMEDOUT; 82925e992a4SHeiner Kallweit } 83025e992a4SHeiner Kallweit 83125e992a4SHeiner Kallweit static void r8168_mac_ocp_write(struct rtl8169_private *tp, u32 reg, u32 data) 83225e992a4SHeiner Kallweit { 83325e992a4SHeiner Kallweit if (rtl_ocp_reg_failure(tp, reg)) 83425e992a4SHeiner Kallweit return; 83525e992a4SHeiner Kallweit 83625e992a4SHeiner Kallweit RTL_W32(tp, OCPDR, OCPAR_FLAG | (reg << 15) | data); 83725e992a4SHeiner Kallweit } 83825e992a4SHeiner Kallweit 83925e992a4SHeiner Kallweit static u16 r8168_mac_ocp_read(struct rtl8169_private *tp, u32 reg) 84025e992a4SHeiner Kallweit { 84125e992a4SHeiner Kallweit if (rtl_ocp_reg_failure(tp, reg)) 84225e992a4SHeiner Kallweit return 0; 84325e992a4SHeiner Kallweit 84425e992a4SHeiner Kallweit RTL_W32(tp, OCPDR, reg << 15); 84525e992a4SHeiner Kallweit 84625e992a4SHeiner Kallweit return RTL_R32(tp, OCPDR); 84725e992a4SHeiner Kallweit } 84825e992a4SHeiner Kallweit 84925e992a4SHeiner Kallweit #define OCP_STD_PHY_BASE 0xa400 85025e992a4SHeiner Kallweit 85125e992a4SHeiner Kallweit static void r8168g_mdio_write(struct rtl8169_private *tp, int reg, int value) 85225e992a4SHeiner Kallweit { 85325e992a4SHeiner Kallweit if (reg == 0x1f) { 85425e992a4SHeiner Kallweit tp->ocp_base = value ? value << 4 : OCP_STD_PHY_BASE; 85525e992a4SHeiner Kallweit return; 85625e992a4SHeiner Kallweit } 85725e992a4SHeiner Kallweit 85825e992a4SHeiner Kallweit if (tp->ocp_base != OCP_STD_PHY_BASE) 85925e992a4SHeiner Kallweit reg -= 0x10; 86025e992a4SHeiner Kallweit 86125e992a4SHeiner Kallweit r8168_phy_ocp_write(tp, tp->ocp_base + reg * 2, value); 86225e992a4SHeiner Kallweit } 86325e992a4SHeiner Kallweit 86425e992a4SHeiner Kallweit static int r8168g_mdio_read(struct rtl8169_private *tp, int reg) 86525e992a4SHeiner Kallweit { 86625e992a4SHeiner Kallweit if (tp->ocp_base != OCP_STD_PHY_BASE) 86725e992a4SHeiner Kallweit reg -= 0x10; 86825e992a4SHeiner Kallweit 86925e992a4SHeiner Kallweit return r8168_phy_ocp_read(tp, tp->ocp_base + reg * 2); 87025e992a4SHeiner Kallweit } 87125e992a4SHeiner Kallweit 87225e992a4SHeiner Kallweit static void mac_mcu_write(struct rtl8169_private *tp, int reg, int value) 87325e992a4SHeiner Kallweit { 87425e992a4SHeiner Kallweit if (reg == 0x1f) { 87525e992a4SHeiner Kallweit tp->ocp_base = value << 4; 87625e992a4SHeiner Kallweit return; 87725e992a4SHeiner Kallweit } 87825e992a4SHeiner Kallweit 87925e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, tp->ocp_base + reg, value); 88025e992a4SHeiner Kallweit } 88125e992a4SHeiner Kallweit 88225e992a4SHeiner Kallweit static int mac_mcu_read(struct rtl8169_private *tp, int reg) 88325e992a4SHeiner Kallweit { 88425e992a4SHeiner Kallweit return r8168_mac_ocp_read(tp, tp->ocp_base + reg); 88525e992a4SHeiner Kallweit } 88625e992a4SHeiner Kallweit 88725e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_phyar_cond) 88825e992a4SHeiner Kallweit { 88925e992a4SHeiner Kallweit return RTL_R32(tp, PHYAR) & 0x80000000; 89025e992a4SHeiner Kallweit } 89125e992a4SHeiner Kallweit 89225e992a4SHeiner Kallweit static void r8169_mdio_write(struct rtl8169_private *tp, int reg, int value) 89325e992a4SHeiner Kallweit { 89425e992a4SHeiner Kallweit RTL_W32(tp, PHYAR, 0x80000000 | (reg & 0x1f) << 16 | (value & 0xffff)); 89525e992a4SHeiner Kallweit 89625e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_phyar_cond, 25, 20); 89725e992a4SHeiner Kallweit /* 89825e992a4SHeiner Kallweit * According to hardware specs a 20us delay is required after write 89925e992a4SHeiner Kallweit * complete indication, but before sending next command. 90025e992a4SHeiner Kallweit */ 90125e992a4SHeiner Kallweit udelay(20); 90225e992a4SHeiner Kallweit } 90325e992a4SHeiner Kallweit 90425e992a4SHeiner Kallweit static int r8169_mdio_read(struct rtl8169_private *tp, int reg) 90525e992a4SHeiner Kallweit { 90625e992a4SHeiner Kallweit int value; 90725e992a4SHeiner Kallweit 90825e992a4SHeiner Kallweit RTL_W32(tp, PHYAR, 0x0 | (reg & 0x1f) << 16); 90925e992a4SHeiner Kallweit 91025e992a4SHeiner Kallweit value = rtl_udelay_loop_wait_high(tp, &rtl_phyar_cond, 25, 20) ? 9119b994b4aSHeiner Kallweit RTL_R32(tp, PHYAR) & 0xffff : -ETIMEDOUT; 91225e992a4SHeiner Kallweit 91325e992a4SHeiner Kallweit /* 91425e992a4SHeiner Kallweit * According to hardware specs a 20us delay is required after read 91525e992a4SHeiner Kallweit * complete indication, but before sending next command. 91625e992a4SHeiner Kallweit */ 91725e992a4SHeiner Kallweit udelay(20); 91825e992a4SHeiner Kallweit 91925e992a4SHeiner Kallweit return value; 92025e992a4SHeiner Kallweit } 92125e992a4SHeiner Kallweit 92225e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_ocpar_cond) 92325e992a4SHeiner Kallweit { 92425e992a4SHeiner Kallweit return RTL_R32(tp, OCPAR) & OCPAR_FLAG; 92525e992a4SHeiner Kallweit } 92625e992a4SHeiner Kallweit 92725e992a4SHeiner Kallweit static void r8168dp_1_mdio_access(struct rtl8169_private *tp, int reg, u32 data) 92825e992a4SHeiner Kallweit { 92925e992a4SHeiner Kallweit RTL_W32(tp, OCPDR, data | ((reg & OCPDR_REG_MASK) << OCPDR_GPHY_REG_SHIFT)); 93025e992a4SHeiner Kallweit RTL_W32(tp, OCPAR, OCPAR_GPHY_WRITE_CMD); 93125e992a4SHeiner Kallweit RTL_W32(tp, EPHY_RXER_NUM, 0); 93225e992a4SHeiner Kallweit 93325e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_ocpar_cond, 1000, 100); 93425e992a4SHeiner Kallweit } 93525e992a4SHeiner Kallweit 93625e992a4SHeiner Kallweit static void r8168dp_1_mdio_write(struct rtl8169_private *tp, int reg, int value) 93725e992a4SHeiner Kallweit { 93825e992a4SHeiner Kallweit r8168dp_1_mdio_access(tp, reg, 93925e992a4SHeiner Kallweit OCPDR_WRITE_CMD | (value & OCPDR_DATA_MASK)); 94025e992a4SHeiner Kallweit } 94125e992a4SHeiner Kallweit 94225e992a4SHeiner Kallweit static int r8168dp_1_mdio_read(struct rtl8169_private *tp, int reg) 94325e992a4SHeiner Kallweit { 94425e992a4SHeiner Kallweit r8168dp_1_mdio_access(tp, reg, OCPDR_READ_CMD); 94525e992a4SHeiner Kallweit 94625e992a4SHeiner Kallweit mdelay(1); 94725e992a4SHeiner Kallweit RTL_W32(tp, OCPAR, OCPAR_GPHY_READ_CMD); 94825e992a4SHeiner Kallweit RTL_W32(tp, EPHY_RXER_NUM, 0); 94925e992a4SHeiner Kallweit 95025e992a4SHeiner Kallweit return rtl_udelay_loop_wait_high(tp, &rtl_ocpar_cond, 1000, 100) ? 9519b994b4aSHeiner Kallweit RTL_R32(tp, OCPDR) & OCPDR_DATA_MASK : -ETIMEDOUT; 95225e992a4SHeiner Kallweit } 95325e992a4SHeiner Kallweit 95425e992a4SHeiner Kallweit #define R8168DP_1_MDIO_ACCESS_BIT 0x00020000 95525e992a4SHeiner Kallweit 95625e992a4SHeiner Kallweit static void r8168dp_2_mdio_start(struct rtl8169_private *tp) 95725e992a4SHeiner Kallweit { 95825e992a4SHeiner Kallweit RTL_W32(tp, 0xd0, RTL_R32(tp, 0xd0) & ~R8168DP_1_MDIO_ACCESS_BIT); 95925e992a4SHeiner Kallweit } 96025e992a4SHeiner Kallweit 96125e992a4SHeiner Kallweit static void r8168dp_2_mdio_stop(struct rtl8169_private *tp) 96225e992a4SHeiner Kallweit { 96325e992a4SHeiner Kallweit RTL_W32(tp, 0xd0, RTL_R32(tp, 0xd0) | R8168DP_1_MDIO_ACCESS_BIT); 96425e992a4SHeiner Kallweit } 96525e992a4SHeiner Kallweit 96625e992a4SHeiner Kallweit static void r8168dp_2_mdio_write(struct rtl8169_private *tp, int reg, int value) 96725e992a4SHeiner Kallweit { 96825e992a4SHeiner Kallweit r8168dp_2_mdio_start(tp); 96925e992a4SHeiner Kallweit 97025e992a4SHeiner Kallweit r8169_mdio_write(tp, reg, value); 97125e992a4SHeiner Kallweit 97225e992a4SHeiner Kallweit r8168dp_2_mdio_stop(tp); 97325e992a4SHeiner Kallweit } 97425e992a4SHeiner Kallweit 97525e992a4SHeiner Kallweit static int r8168dp_2_mdio_read(struct rtl8169_private *tp, int reg) 97625e992a4SHeiner Kallweit { 97725e992a4SHeiner Kallweit int value; 97825e992a4SHeiner Kallweit 97925e992a4SHeiner Kallweit r8168dp_2_mdio_start(tp); 98025e992a4SHeiner Kallweit 98125e992a4SHeiner Kallweit value = r8169_mdio_read(tp, reg); 98225e992a4SHeiner Kallweit 98325e992a4SHeiner Kallweit r8168dp_2_mdio_stop(tp); 98425e992a4SHeiner Kallweit 98525e992a4SHeiner Kallweit return value; 98625e992a4SHeiner Kallweit } 98725e992a4SHeiner Kallweit 98825e992a4SHeiner Kallweit static void rtl_writephy(struct rtl8169_private *tp, int location, int val) 98925e992a4SHeiner Kallweit { 99025e992a4SHeiner Kallweit switch (tp->mac_version) { 99125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27: 99225e992a4SHeiner Kallweit r8168dp_1_mdio_write(tp, location, val); 99325e992a4SHeiner Kallweit break; 99425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_28: 99525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31: 99625e992a4SHeiner Kallweit r8168dp_2_mdio_write(tp, location, val); 99725e992a4SHeiner Kallweit break; 99825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_40 ... RTL_GIGA_MAC_VER_51: 99925e992a4SHeiner Kallweit r8168g_mdio_write(tp, location, val); 100025e992a4SHeiner Kallweit break; 100125e992a4SHeiner Kallweit default: 100225e992a4SHeiner Kallweit r8169_mdio_write(tp, location, val); 100325e992a4SHeiner Kallweit break; 100425e992a4SHeiner Kallweit } 100525e992a4SHeiner Kallweit } 100625e992a4SHeiner Kallweit 100725e992a4SHeiner Kallweit static int rtl_readphy(struct rtl8169_private *tp, int location) 100825e992a4SHeiner Kallweit { 100925e992a4SHeiner Kallweit switch (tp->mac_version) { 101025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27: 101125e992a4SHeiner Kallweit return r8168dp_1_mdio_read(tp, location); 101225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_28: 101325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31: 101425e992a4SHeiner Kallweit return r8168dp_2_mdio_read(tp, location); 101525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_40 ... RTL_GIGA_MAC_VER_51: 101625e992a4SHeiner Kallweit return r8168g_mdio_read(tp, location); 101725e992a4SHeiner Kallweit default: 101825e992a4SHeiner Kallweit return r8169_mdio_read(tp, location); 101925e992a4SHeiner Kallweit } 102025e992a4SHeiner Kallweit } 102125e992a4SHeiner Kallweit 102225e992a4SHeiner Kallweit static void rtl_patchphy(struct rtl8169_private *tp, int reg_addr, int value) 102325e992a4SHeiner Kallweit { 102425e992a4SHeiner Kallweit rtl_writephy(tp, reg_addr, rtl_readphy(tp, reg_addr) | value); 102525e992a4SHeiner Kallweit } 102625e992a4SHeiner Kallweit 102725e992a4SHeiner Kallweit static void rtl_w0w1_phy(struct rtl8169_private *tp, int reg_addr, int p, int m) 102825e992a4SHeiner Kallweit { 102925e992a4SHeiner Kallweit int val; 103025e992a4SHeiner Kallweit 103125e992a4SHeiner Kallweit val = rtl_readphy(tp, reg_addr); 103225e992a4SHeiner Kallweit rtl_writephy(tp, reg_addr, (val & ~m) | p); 103325e992a4SHeiner Kallweit } 103425e992a4SHeiner Kallweit 103525e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_ephyar_cond) 103625e992a4SHeiner Kallweit { 103725e992a4SHeiner Kallweit return RTL_R32(tp, EPHYAR) & EPHYAR_FLAG; 103825e992a4SHeiner Kallweit } 103925e992a4SHeiner Kallweit 104025e992a4SHeiner Kallweit static void rtl_ephy_write(struct rtl8169_private *tp, int reg_addr, int value) 104125e992a4SHeiner Kallweit { 104225e992a4SHeiner Kallweit RTL_W32(tp, EPHYAR, EPHYAR_WRITE_CMD | (value & EPHYAR_DATA_MASK) | 104325e992a4SHeiner Kallweit (reg_addr & EPHYAR_REG_MASK) << EPHYAR_REG_SHIFT); 104425e992a4SHeiner Kallweit 104525e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_ephyar_cond, 10, 100); 104625e992a4SHeiner Kallweit 104725e992a4SHeiner Kallweit udelay(10); 104825e992a4SHeiner Kallweit } 104925e992a4SHeiner Kallweit 105025e992a4SHeiner Kallweit static u16 rtl_ephy_read(struct rtl8169_private *tp, int reg_addr) 105125e992a4SHeiner Kallweit { 105225e992a4SHeiner Kallweit RTL_W32(tp, EPHYAR, (reg_addr & EPHYAR_REG_MASK) << EPHYAR_REG_SHIFT); 105325e992a4SHeiner Kallweit 105425e992a4SHeiner Kallweit return rtl_udelay_loop_wait_high(tp, &rtl_ephyar_cond, 10, 100) ? 105525e992a4SHeiner Kallweit RTL_R32(tp, EPHYAR) & EPHYAR_DATA_MASK : ~0; 105625e992a4SHeiner Kallweit } 105725e992a4SHeiner Kallweit 105825e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_eriar_cond) 105925e992a4SHeiner Kallweit { 106025e992a4SHeiner Kallweit return RTL_R32(tp, ERIAR) & ERIAR_FLAG; 106125e992a4SHeiner Kallweit } 106225e992a4SHeiner Kallweit 106325e992a4SHeiner Kallweit static void _rtl_eri_write(struct rtl8169_private *tp, int addr, u32 mask, 106425e992a4SHeiner Kallweit u32 val, int type) 106525e992a4SHeiner Kallweit { 106625e992a4SHeiner Kallweit BUG_ON((addr & 3) || (mask == 0)); 106725e992a4SHeiner Kallweit RTL_W32(tp, ERIDR, val); 106825e992a4SHeiner Kallweit RTL_W32(tp, ERIAR, ERIAR_WRITE_CMD | type | mask | addr); 106925e992a4SHeiner Kallweit 107025e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_eriar_cond, 100, 100); 107125e992a4SHeiner Kallweit } 107225e992a4SHeiner Kallweit 107325e992a4SHeiner Kallweit static void rtl_eri_write(struct rtl8169_private *tp, int addr, u32 mask, 107425e992a4SHeiner Kallweit u32 val) 107525e992a4SHeiner Kallweit { 107625e992a4SHeiner Kallweit _rtl_eri_write(tp, addr, mask, val, ERIAR_EXGMAC); 107725e992a4SHeiner Kallweit } 107825e992a4SHeiner Kallweit 107925e992a4SHeiner Kallweit static u32 _rtl_eri_read(struct rtl8169_private *tp, int addr, int type) 108025e992a4SHeiner Kallweit { 108125e992a4SHeiner Kallweit RTL_W32(tp, ERIAR, ERIAR_READ_CMD | type | ERIAR_MASK_1111 | addr); 108225e992a4SHeiner Kallweit 108325e992a4SHeiner Kallweit return rtl_udelay_loop_wait_high(tp, &rtl_eriar_cond, 100, 100) ? 108425e992a4SHeiner Kallweit RTL_R32(tp, ERIDR) : ~0; 108525e992a4SHeiner Kallweit } 108625e992a4SHeiner Kallweit 108725e992a4SHeiner Kallweit static u32 rtl_eri_read(struct rtl8169_private *tp, int addr) 108825e992a4SHeiner Kallweit { 108925e992a4SHeiner Kallweit return _rtl_eri_read(tp, addr, ERIAR_EXGMAC); 109025e992a4SHeiner Kallweit } 109125e992a4SHeiner Kallweit 109225e992a4SHeiner Kallweit static void rtl_w0w1_eri(struct rtl8169_private *tp, int addr, u32 mask, u32 p, 109325e992a4SHeiner Kallweit u32 m) 109425e992a4SHeiner Kallweit { 109525e992a4SHeiner Kallweit u32 val; 109625e992a4SHeiner Kallweit 109725e992a4SHeiner Kallweit val = rtl_eri_read(tp, addr); 109825e992a4SHeiner Kallweit rtl_eri_write(tp, addr, mask, (val & ~m) | p); 109925e992a4SHeiner Kallweit } 110025e992a4SHeiner Kallweit 110125e992a4SHeiner Kallweit static void rtl_eri_set_bits(struct rtl8169_private *tp, int addr, u32 mask, 110225e992a4SHeiner Kallweit u32 p) 110325e992a4SHeiner Kallweit { 110425e992a4SHeiner Kallweit rtl_w0w1_eri(tp, addr, mask, p, 0); 110525e992a4SHeiner Kallweit } 110625e992a4SHeiner Kallweit 110725e992a4SHeiner Kallweit static void rtl_eri_clear_bits(struct rtl8169_private *tp, int addr, u32 mask, 110825e992a4SHeiner Kallweit u32 m) 110925e992a4SHeiner Kallweit { 111025e992a4SHeiner Kallweit rtl_w0w1_eri(tp, addr, mask, 0, m); 111125e992a4SHeiner Kallweit } 111225e992a4SHeiner Kallweit 111325e992a4SHeiner Kallweit static u32 r8168dp_ocp_read(struct rtl8169_private *tp, u8 mask, u16 reg) 111425e992a4SHeiner Kallweit { 111525e992a4SHeiner Kallweit RTL_W32(tp, OCPAR, ((u32)mask & 0x0f) << 12 | (reg & 0x0fff)); 111625e992a4SHeiner Kallweit return rtl_udelay_loop_wait_high(tp, &rtl_ocpar_cond, 100, 20) ? 111725e992a4SHeiner Kallweit RTL_R32(tp, OCPDR) : ~0; 111825e992a4SHeiner Kallweit } 111925e992a4SHeiner Kallweit 112025e992a4SHeiner Kallweit static u32 r8168ep_ocp_read(struct rtl8169_private *tp, u8 mask, u16 reg) 112125e992a4SHeiner Kallweit { 112225e992a4SHeiner Kallweit return _rtl_eri_read(tp, reg, ERIAR_OOB); 112325e992a4SHeiner Kallweit } 112425e992a4SHeiner Kallweit 112525e992a4SHeiner Kallweit static void r8168dp_ocp_write(struct rtl8169_private *tp, u8 mask, u16 reg, 112625e992a4SHeiner Kallweit u32 data) 112725e992a4SHeiner Kallweit { 112825e992a4SHeiner Kallweit RTL_W32(tp, OCPDR, data); 112925e992a4SHeiner Kallweit RTL_W32(tp, OCPAR, OCPAR_FLAG | ((u32)mask & 0x0f) << 12 | (reg & 0x0fff)); 113025e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_ocpar_cond, 100, 20); 113125e992a4SHeiner Kallweit } 113225e992a4SHeiner Kallweit 113325e992a4SHeiner Kallweit static void r8168ep_ocp_write(struct rtl8169_private *tp, u8 mask, u16 reg, 113425e992a4SHeiner Kallweit u32 data) 113525e992a4SHeiner Kallweit { 113625e992a4SHeiner Kallweit _rtl_eri_write(tp, reg, ((u32)mask & 0x0f) << ERIAR_MASK_SHIFT, 113725e992a4SHeiner Kallweit data, ERIAR_OOB); 113825e992a4SHeiner Kallweit } 113925e992a4SHeiner Kallweit 114025e992a4SHeiner Kallweit static void r8168dp_oob_notify(struct rtl8169_private *tp, u8 cmd) 114125e992a4SHeiner Kallweit { 114225e992a4SHeiner Kallweit rtl_eri_write(tp, 0xe8, ERIAR_MASK_0001, cmd); 114325e992a4SHeiner Kallweit 114425e992a4SHeiner Kallweit r8168dp_ocp_write(tp, 0x1, 0x30, 0x00000001); 114525e992a4SHeiner Kallweit } 114625e992a4SHeiner Kallweit 114725e992a4SHeiner Kallweit #define OOB_CMD_RESET 0x00 114825e992a4SHeiner Kallweit #define OOB_CMD_DRIVER_START 0x05 114925e992a4SHeiner Kallweit #define OOB_CMD_DRIVER_STOP 0x06 115025e992a4SHeiner Kallweit 115125e992a4SHeiner Kallweit static u16 rtl8168_get_ocp_reg(struct rtl8169_private *tp) 115225e992a4SHeiner Kallweit { 115325e992a4SHeiner Kallweit return (tp->mac_version == RTL_GIGA_MAC_VER_31) ? 0xb8 : 0x10; 115425e992a4SHeiner Kallweit } 115525e992a4SHeiner Kallweit 115625e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_dp_ocp_read_cond) 115725e992a4SHeiner Kallweit { 115825e992a4SHeiner Kallweit u16 reg; 115925e992a4SHeiner Kallweit 116025e992a4SHeiner Kallweit reg = rtl8168_get_ocp_reg(tp); 116125e992a4SHeiner Kallweit 116225e992a4SHeiner Kallweit return r8168dp_ocp_read(tp, 0x0f, reg) & 0x00000800; 116325e992a4SHeiner Kallweit } 116425e992a4SHeiner Kallweit 116525e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_ep_ocp_read_cond) 116625e992a4SHeiner Kallweit { 116725e992a4SHeiner Kallweit return r8168ep_ocp_read(tp, 0x0f, 0x124) & 0x00000001; 116825e992a4SHeiner Kallweit } 116925e992a4SHeiner Kallweit 117025e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_ocp_tx_cond) 117125e992a4SHeiner Kallweit { 117225e992a4SHeiner Kallweit return RTL_R8(tp, IBISR0) & 0x20; 117325e992a4SHeiner Kallweit } 117425e992a4SHeiner Kallweit 117525e992a4SHeiner Kallweit static void rtl8168ep_stop_cmac(struct rtl8169_private *tp) 117625e992a4SHeiner Kallweit { 117725e992a4SHeiner Kallweit RTL_W8(tp, IBCR2, RTL_R8(tp, IBCR2) & ~0x01); 117825e992a4SHeiner Kallweit rtl_msleep_loop_wait_high(tp, &rtl_ocp_tx_cond, 50, 2000); 117925e992a4SHeiner Kallweit RTL_W8(tp, IBISR0, RTL_R8(tp, IBISR0) | 0x20); 118025e992a4SHeiner Kallweit RTL_W8(tp, IBCR0, RTL_R8(tp, IBCR0) & ~0x01); 118125e992a4SHeiner Kallweit } 118225e992a4SHeiner Kallweit 118325e992a4SHeiner Kallweit static void rtl8168dp_driver_start(struct rtl8169_private *tp) 118425e992a4SHeiner Kallweit { 118525e992a4SHeiner Kallweit r8168dp_oob_notify(tp, OOB_CMD_DRIVER_START); 118625e992a4SHeiner Kallweit rtl_msleep_loop_wait_high(tp, &rtl_dp_ocp_read_cond, 10, 10); 118725e992a4SHeiner Kallweit } 118825e992a4SHeiner Kallweit 118925e992a4SHeiner Kallweit static void rtl8168ep_driver_start(struct rtl8169_private *tp) 119025e992a4SHeiner Kallweit { 119125e992a4SHeiner Kallweit r8168ep_ocp_write(tp, 0x01, 0x180, OOB_CMD_DRIVER_START); 119225e992a4SHeiner Kallweit r8168ep_ocp_write(tp, 0x01, 0x30, 119325e992a4SHeiner Kallweit r8168ep_ocp_read(tp, 0x01, 0x30) | 0x01); 119425e992a4SHeiner Kallweit rtl_msleep_loop_wait_high(tp, &rtl_ep_ocp_read_cond, 10, 10); 119525e992a4SHeiner Kallweit } 119625e992a4SHeiner Kallweit 119725e992a4SHeiner Kallweit static void rtl8168_driver_start(struct rtl8169_private *tp) 119825e992a4SHeiner Kallweit { 119925e992a4SHeiner Kallweit switch (tp->mac_version) { 120025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27: 120125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_28: 120225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31: 120325e992a4SHeiner Kallweit rtl8168dp_driver_start(tp); 120425e992a4SHeiner Kallweit break; 120525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_49: 120625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_50: 120725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_51: 120825e992a4SHeiner Kallweit rtl8168ep_driver_start(tp); 120925e992a4SHeiner Kallweit break; 121025e992a4SHeiner Kallweit default: 121125e992a4SHeiner Kallweit BUG(); 121225e992a4SHeiner Kallweit break; 121325e992a4SHeiner Kallweit } 121425e992a4SHeiner Kallweit } 121525e992a4SHeiner Kallweit 121625e992a4SHeiner Kallweit static void rtl8168dp_driver_stop(struct rtl8169_private *tp) 121725e992a4SHeiner Kallweit { 121825e992a4SHeiner Kallweit r8168dp_oob_notify(tp, OOB_CMD_DRIVER_STOP); 121925e992a4SHeiner Kallweit rtl_msleep_loop_wait_low(tp, &rtl_dp_ocp_read_cond, 10, 10); 122025e992a4SHeiner Kallweit } 122125e992a4SHeiner Kallweit 122225e992a4SHeiner Kallweit static void rtl8168ep_driver_stop(struct rtl8169_private *tp) 122325e992a4SHeiner Kallweit { 122425e992a4SHeiner Kallweit rtl8168ep_stop_cmac(tp); 122525e992a4SHeiner Kallweit r8168ep_ocp_write(tp, 0x01, 0x180, OOB_CMD_DRIVER_STOP); 122625e992a4SHeiner Kallweit r8168ep_ocp_write(tp, 0x01, 0x30, 122725e992a4SHeiner Kallweit r8168ep_ocp_read(tp, 0x01, 0x30) | 0x01); 122825e992a4SHeiner Kallweit rtl_msleep_loop_wait_low(tp, &rtl_ep_ocp_read_cond, 10, 10); 122925e992a4SHeiner Kallweit } 123025e992a4SHeiner Kallweit 123125e992a4SHeiner Kallweit static void rtl8168_driver_stop(struct rtl8169_private *tp) 123225e992a4SHeiner Kallweit { 123325e992a4SHeiner Kallweit switch (tp->mac_version) { 123425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27: 123525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_28: 123625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31: 123725e992a4SHeiner Kallweit rtl8168dp_driver_stop(tp); 123825e992a4SHeiner Kallweit break; 123925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_49: 124025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_50: 124125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_51: 124225e992a4SHeiner Kallweit rtl8168ep_driver_stop(tp); 124325e992a4SHeiner Kallweit break; 124425e992a4SHeiner Kallweit default: 124525e992a4SHeiner Kallweit BUG(); 124625e992a4SHeiner Kallweit break; 124725e992a4SHeiner Kallweit } 124825e992a4SHeiner Kallweit } 124925e992a4SHeiner Kallweit 125025e992a4SHeiner Kallweit static bool r8168dp_check_dash(struct rtl8169_private *tp) 125125e992a4SHeiner Kallweit { 125225e992a4SHeiner Kallweit u16 reg = rtl8168_get_ocp_reg(tp); 125325e992a4SHeiner Kallweit 125425e992a4SHeiner Kallweit return !!(r8168dp_ocp_read(tp, 0x0f, reg) & 0x00008000); 125525e992a4SHeiner Kallweit } 125625e992a4SHeiner Kallweit 125725e992a4SHeiner Kallweit static bool r8168ep_check_dash(struct rtl8169_private *tp) 125825e992a4SHeiner Kallweit { 125925e992a4SHeiner Kallweit return !!(r8168ep_ocp_read(tp, 0x0f, 0x128) & 0x00000001); 126025e992a4SHeiner Kallweit } 126125e992a4SHeiner Kallweit 126225e992a4SHeiner Kallweit static bool r8168_check_dash(struct rtl8169_private *tp) 126325e992a4SHeiner Kallweit { 126425e992a4SHeiner Kallweit switch (tp->mac_version) { 126525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27: 126625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_28: 126725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31: 126825e992a4SHeiner Kallweit return r8168dp_check_dash(tp); 126925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_49: 127025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_50: 127125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_51: 127225e992a4SHeiner Kallweit return r8168ep_check_dash(tp); 127325e992a4SHeiner Kallweit default: 127425e992a4SHeiner Kallweit return false; 127525e992a4SHeiner Kallweit } 127625e992a4SHeiner Kallweit } 127725e992a4SHeiner Kallweit 127825e992a4SHeiner Kallweit static void rtl_reset_packet_filter(struct rtl8169_private *tp) 127925e992a4SHeiner Kallweit { 128025e992a4SHeiner Kallweit rtl_eri_clear_bits(tp, 0xdc, ERIAR_MASK_0001, BIT(0)); 128125e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0xdc, ERIAR_MASK_0001, BIT(0)); 128225e992a4SHeiner Kallweit } 128325e992a4SHeiner Kallweit 128425e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_efusear_cond) 128525e992a4SHeiner Kallweit { 128625e992a4SHeiner Kallweit return RTL_R32(tp, EFUSEAR) & EFUSEAR_FLAG; 128725e992a4SHeiner Kallweit } 128825e992a4SHeiner Kallweit 128925e992a4SHeiner Kallweit static u8 rtl8168d_efuse_read(struct rtl8169_private *tp, int reg_addr) 129025e992a4SHeiner Kallweit { 129125e992a4SHeiner Kallweit RTL_W32(tp, EFUSEAR, (reg_addr & EFUSEAR_REG_MASK) << EFUSEAR_REG_SHIFT); 129225e992a4SHeiner Kallweit 129325e992a4SHeiner Kallweit return rtl_udelay_loop_wait_high(tp, &rtl_efusear_cond, 100, 300) ? 129425e992a4SHeiner Kallweit RTL_R32(tp, EFUSEAR) & EFUSEAR_DATA_MASK : ~0; 129525e992a4SHeiner Kallweit } 129625e992a4SHeiner Kallweit 129725e992a4SHeiner Kallweit static void rtl_ack_events(struct rtl8169_private *tp, u16 bits) 129825e992a4SHeiner Kallweit { 129925e992a4SHeiner Kallweit RTL_W16(tp, IntrStatus, bits); 130025e992a4SHeiner Kallweit } 130125e992a4SHeiner Kallweit 130225e992a4SHeiner Kallweit static void rtl_irq_disable(struct rtl8169_private *tp) 130325e992a4SHeiner Kallweit { 130425e992a4SHeiner Kallweit RTL_W16(tp, IntrMask, 0); 130525e992a4SHeiner Kallweit tp->irq_enabled = 0; 130625e992a4SHeiner Kallweit } 130725e992a4SHeiner Kallweit 130825e992a4SHeiner Kallweit #define RTL_EVENT_NAPI_RX (RxOK | RxErr) 130925e992a4SHeiner Kallweit #define RTL_EVENT_NAPI_TX (TxOK | TxErr) 131025e992a4SHeiner Kallweit #define RTL_EVENT_NAPI (RTL_EVENT_NAPI_RX | RTL_EVENT_NAPI_TX) 131125e992a4SHeiner Kallweit 131225e992a4SHeiner Kallweit static void rtl_irq_enable(struct rtl8169_private *tp) 131325e992a4SHeiner Kallweit { 131425e992a4SHeiner Kallweit tp->irq_enabled = 1; 131525e992a4SHeiner Kallweit RTL_W16(tp, IntrMask, tp->irq_mask); 131625e992a4SHeiner Kallweit } 131725e992a4SHeiner Kallweit 131825e992a4SHeiner Kallweit static void rtl8169_irq_mask_and_ack(struct rtl8169_private *tp) 131925e992a4SHeiner Kallweit { 132025e992a4SHeiner Kallweit rtl_irq_disable(tp); 132125e992a4SHeiner Kallweit rtl_ack_events(tp, 0xffff); 132225e992a4SHeiner Kallweit /* PCI commit */ 132325e992a4SHeiner Kallweit RTL_R8(tp, ChipCmd); 132425e992a4SHeiner Kallweit } 132525e992a4SHeiner Kallweit 132625e992a4SHeiner Kallweit static void rtl_link_chg_patch(struct rtl8169_private *tp) 132725e992a4SHeiner Kallweit { 132825e992a4SHeiner Kallweit struct net_device *dev = tp->dev; 132925e992a4SHeiner Kallweit struct phy_device *phydev = tp->phydev; 133025e992a4SHeiner Kallweit 133125e992a4SHeiner Kallweit if (!netif_running(dev)) 133225e992a4SHeiner Kallweit return; 133325e992a4SHeiner Kallweit 133425e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_34 || 133525e992a4SHeiner Kallweit tp->mac_version == RTL_GIGA_MAC_VER_38) { 133625e992a4SHeiner Kallweit if (phydev->speed == SPEED_1000) { 133725e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1bc, ERIAR_MASK_1111, 0x00000011); 133825e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1dc, ERIAR_MASK_1111, 0x00000005); 133925e992a4SHeiner Kallweit } else if (phydev->speed == SPEED_100) { 134025e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1bc, ERIAR_MASK_1111, 0x0000001f); 134125e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1dc, ERIAR_MASK_1111, 0x00000005); 134225e992a4SHeiner Kallweit } else { 134325e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1bc, ERIAR_MASK_1111, 0x0000001f); 134425e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1dc, ERIAR_MASK_1111, 0x0000003f); 134525e992a4SHeiner Kallweit } 134625e992a4SHeiner Kallweit rtl_reset_packet_filter(tp); 134725e992a4SHeiner Kallweit } else if (tp->mac_version == RTL_GIGA_MAC_VER_35 || 134825e992a4SHeiner Kallweit tp->mac_version == RTL_GIGA_MAC_VER_36) { 134925e992a4SHeiner Kallweit if (phydev->speed == SPEED_1000) { 135025e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1bc, ERIAR_MASK_1111, 0x00000011); 135125e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1dc, ERIAR_MASK_1111, 0x00000005); 135225e992a4SHeiner Kallweit } else { 135325e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1bc, ERIAR_MASK_1111, 0x0000001f); 135425e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1dc, ERIAR_MASK_1111, 0x0000003f); 135525e992a4SHeiner Kallweit } 135625e992a4SHeiner Kallweit } else if (tp->mac_version == RTL_GIGA_MAC_VER_37) { 135725e992a4SHeiner Kallweit if (phydev->speed == SPEED_10) { 135825e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1d0, ERIAR_MASK_0011, 0x4d02); 135925e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1dc, ERIAR_MASK_0011, 0x0060a); 136025e992a4SHeiner Kallweit } else { 136125e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1d0, ERIAR_MASK_0011, 0x0000); 136225e992a4SHeiner Kallweit } 136325e992a4SHeiner Kallweit } 136425e992a4SHeiner Kallweit } 136525e992a4SHeiner Kallweit 136625e992a4SHeiner Kallweit #define WAKE_ANY (WAKE_PHY | WAKE_MAGIC | WAKE_UCAST | WAKE_BCAST | WAKE_MCAST) 136725e992a4SHeiner Kallweit 136825e992a4SHeiner Kallweit static void rtl8169_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol) 136925e992a4SHeiner Kallweit { 137025e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 137125e992a4SHeiner Kallweit 137225e992a4SHeiner Kallweit rtl_lock_work(tp); 137325e992a4SHeiner Kallweit wol->supported = WAKE_ANY; 137425e992a4SHeiner Kallweit wol->wolopts = tp->saved_wolopts; 137525e992a4SHeiner Kallweit rtl_unlock_work(tp); 137625e992a4SHeiner Kallweit } 137725e992a4SHeiner Kallweit 137825e992a4SHeiner Kallweit static void __rtl8169_set_wol(struct rtl8169_private *tp, u32 wolopts) 137925e992a4SHeiner Kallweit { 138025e992a4SHeiner Kallweit unsigned int i, tmp; 138125e992a4SHeiner Kallweit static const struct { 138225e992a4SHeiner Kallweit u32 opt; 138325e992a4SHeiner Kallweit u16 reg; 138425e992a4SHeiner Kallweit u8 mask; 138525e992a4SHeiner Kallweit } cfg[] = { 138625e992a4SHeiner Kallweit { WAKE_PHY, Config3, LinkUp }, 138725e992a4SHeiner Kallweit { WAKE_UCAST, Config5, UWF }, 138825e992a4SHeiner Kallweit { WAKE_BCAST, Config5, BWF }, 138925e992a4SHeiner Kallweit { WAKE_MCAST, Config5, MWF }, 139025e992a4SHeiner Kallweit { WAKE_ANY, Config5, LanWake }, 139125e992a4SHeiner Kallweit { WAKE_MAGIC, Config3, MagicPacket } 139225e992a4SHeiner Kallweit }; 139325e992a4SHeiner Kallweit u8 options; 139425e992a4SHeiner Kallweit 139525e992a4SHeiner Kallweit rtl_unlock_config_regs(tp); 139625e992a4SHeiner Kallweit 13979e9f33baSHeiner Kallweit if (rtl_is_8168evl_up(tp)) { 139825e992a4SHeiner Kallweit tmp = ARRAY_SIZE(cfg) - 1; 139925e992a4SHeiner Kallweit if (wolopts & WAKE_MAGIC) 140025e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0x0dc, ERIAR_MASK_0100, 140125e992a4SHeiner Kallweit MagicPacket_v2); 140225e992a4SHeiner Kallweit else 140325e992a4SHeiner Kallweit rtl_eri_clear_bits(tp, 0x0dc, ERIAR_MASK_0100, 140425e992a4SHeiner Kallweit MagicPacket_v2); 14059e9f33baSHeiner Kallweit } else { 140625e992a4SHeiner Kallweit tmp = ARRAY_SIZE(cfg); 140725e992a4SHeiner Kallweit } 140825e992a4SHeiner Kallweit 140925e992a4SHeiner Kallweit for (i = 0; i < tmp; i++) { 141025e992a4SHeiner Kallweit options = RTL_R8(tp, cfg[i].reg) & ~cfg[i].mask; 141125e992a4SHeiner Kallweit if (wolopts & cfg[i].opt) 141225e992a4SHeiner Kallweit options |= cfg[i].mask; 141325e992a4SHeiner Kallweit RTL_W8(tp, cfg[i].reg, options); 141425e992a4SHeiner Kallweit } 141525e992a4SHeiner Kallweit 141625e992a4SHeiner Kallweit switch (tp->mac_version) { 141725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_02 ... RTL_GIGA_MAC_VER_17: 141825e992a4SHeiner Kallweit options = RTL_R8(tp, Config1) & ~PMEnable; 141925e992a4SHeiner Kallweit if (wolopts) 142025e992a4SHeiner Kallweit options |= PMEnable; 142125e992a4SHeiner Kallweit RTL_W8(tp, Config1, options); 142225e992a4SHeiner Kallweit break; 142325e992a4SHeiner Kallweit default: 142425e992a4SHeiner Kallweit options = RTL_R8(tp, Config2) & ~PME_SIGNAL; 142525e992a4SHeiner Kallweit if (wolopts) 142625e992a4SHeiner Kallweit options |= PME_SIGNAL; 142725e992a4SHeiner Kallweit RTL_W8(tp, Config2, options); 142825e992a4SHeiner Kallweit break; 142925e992a4SHeiner Kallweit } 143025e992a4SHeiner Kallweit 143125e992a4SHeiner Kallweit rtl_lock_config_regs(tp); 143225e992a4SHeiner Kallweit 143325e992a4SHeiner Kallweit device_set_wakeup_enable(tp_to_dev(tp), wolopts); 143425e992a4SHeiner Kallweit } 143525e992a4SHeiner Kallweit 143625e992a4SHeiner Kallweit static int rtl8169_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol) 143725e992a4SHeiner Kallweit { 143825e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 143925e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 144025e992a4SHeiner Kallweit 144125e992a4SHeiner Kallweit if (wol->wolopts & ~WAKE_ANY) 144225e992a4SHeiner Kallweit return -EINVAL; 144325e992a4SHeiner Kallweit 144425e992a4SHeiner Kallweit pm_runtime_get_noresume(d); 144525e992a4SHeiner Kallweit 144625e992a4SHeiner Kallweit rtl_lock_work(tp); 144725e992a4SHeiner Kallweit 144825e992a4SHeiner Kallweit tp->saved_wolopts = wol->wolopts; 144925e992a4SHeiner Kallweit 145025e992a4SHeiner Kallweit if (pm_runtime_active(d)) 145125e992a4SHeiner Kallweit __rtl8169_set_wol(tp, tp->saved_wolopts); 145225e992a4SHeiner Kallweit 145325e992a4SHeiner Kallweit rtl_unlock_work(tp); 145425e992a4SHeiner Kallweit 145525e992a4SHeiner Kallweit pm_runtime_put_noidle(d); 145625e992a4SHeiner Kallweit 145725e992a4SHeiner Kallweit return 0; 145825e992a4SHeiner Kallweit } 145925e992a4SHeiner Kallweit 146025e992a4SHeiner Kallweit static void rtl8169_get_drvinfo(struct net_device *dev, 146125e992a4SHeiner Kallweit struct ethtool_drvinfo *info) 146225e992a4SHeiner Kallweit { 146325e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 146425e992a4SHeiner Kallweit struct rtl_fw *rtl_fw = tp->rtl_fw; 146525e992a4SHeiner Kallweit 146625e992a4SHeiner Kallweit strlcpy(info->driver, MODULENAME, sizeof(info->driver)); 146725e992a4SHeiner Kallweit strlcpy(info->bus_info, pci_name(tp->pci_dev), sizeof(info->bus_info)); 146825e992a4SHeiner Kallweit BUILD_BUG_ON(sizeof(info->fw_version) < sizeof(rtl_fw->version)); 146925e992a4SHeiner Kallweit if (rtl_fw) 147025e992a4SHeiner Kallweit strlcpy(info->fw_version, rtl_fw->version, 147125e992a4SHeiner Kallweit sizeof(info->fw_version)); 147225e992a4SHeiner Kallweit } 147325e992a4SHeiner Kallweit 147425e992a4SHeiner Kallweit static int rtl8169_get_regs_len(struct net_device *dev) 147525e992a4SHeiner Kallweit { 147625e992a4SHeiner Kallweit return R8169_REGS_SIZE; 147725e992a4SHeiner Kallweit } 147825e992a4SHeiner Kallweit 147925e992a4SHeiner Kallweit static netdev_features_t rtl8169_fix_features(struct net_device *dev, 148025e992a4SHeiner Kallweit netdev_features_t features) 148125e992a4SHeiner Kallweit { 148225e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 148325e992a4SHeiner Kallweit 148425e992a4SHeiner Kallweit if (dev->mtu > TD_MSS_MAX) 148525e992a4SHeiner Kallweit features &= ~NETIF_F_ALL_TSO; 148625e992a4SHeiner Kallweit 148725e992a4SHeiner Kallweit if (dev->mtu > JUMBO_1K && 148825e992a4SHeiner Kallweit tp->mac_version > RTL_GIGA_MAC_VER_06) 148925e992a4SHeiner Kallweit features &= ~NETIF_F_IP_CSUM; 149025e992a4SHeiner Kallweit 149125e992a4SHeiner Kallweit return features; 149225e992a4SHeiner Kallweit } 149325e992a4SHeiner Kallweit 149425e992a4SHeiner Kallweit static int rtl8169_set_features(struct net_device *dev, 149525e992a4SHeiner Kallweit netdev_features_t features) 149625e992a4SHeiner Kallweit { 149725e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 149825e992a4SHeiner Kallweit u32 rx_config; 149925e992a4SHeiner Kallweit 150025e992a4SHeiner Kallweit rtl_lock_work(tp); 150125e992a4SHeiner Kallweit 150225e992a4SHeiner Kallweit rx_config = RTL_R32(tp, RxConfig); 150325e992a4SHeiner Kallweit if (features & NETIF_F_RXALL) 150425e992a4SHeiner Kallweit rx_config |= (AcceptErr | AcceptRunt); 150525e992a4SHeiner Kallweit else 150625e992a4SHeiner Kallweit rx_config &= ~(AcceptErr | AcceptRunt); 150725e992a4SHeiner Kallweit 150825e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, rx_config); 150925e992a4SHeiner Kallweit 151025e992a4SHeiner Kallweit if (features & NETIF_F_RXCSUM) 151125e992a4SHeiner Kallweit tp->cp_cmd |= RxChkSum; 151225e992a4SHeiner Kallweit else 151325e992a4SHeiner Kallweit tp->cp_cmd &= ~RxChkSum; 151425e992a4SHeiner Kallweit 151525e992a4SHeiner Kallweit if (features & NETIF_F_HW_VLAN_CTAG_RX) 151625e992a4SHeiner Kallweit tp->cp_cmd |= RxVlan; 151725e992a4SHeiner Kallweit else 151825e992a4SHeiner Kallweit tp->cp_cmd &= ~RxVlan; 151925e992a4SHeiner Kallweit 152025e992a4SHeiner Kallweit RTL_W16(tp, CPlusCmd, tp->cp_cmd); 152125e992a4SHeiner Kallweit RTL_R16(tp, CPlusCmd); 152225e992a4SHeiner Kallweit 152325e992a4SHeiner Kallweit rtl_unlock_work(tp); 152425e992a4SHeiner Kallweit 152525e992a4SHeiner Kallweit return 0; 152625e992a4SHeiner Kallweit } 152725e992a4SHeiner Kallweit 152825e992a4SHeiner Kallweit static inline u32 rtl8169_tx_vlan_tag(struct sk_buff *skb) 152925e992a4SHeiner Kallweit { 153025e992a4SHeiner Kallweit return (skb_vlan_tag_present(skb)) ? 1531759d0957SHeiner Kallweit TxVlanTag | htons(skb_vlan_tag_get(skb)) : 0x00; 153225e992a4SHeiner Kallweit } 153325e992a4SHeiner Kallweit 153425e992a4SHeiner Kallweit static void rtl8169_rx_vlan_tag(struct RxDesc *desc, struct sk_buff *skb) 153525e992a4SHeiner Kallweit { 153625e992a4SHeiner Kallweit u32 opts2 = le32_to_cpu(desc->opts2); 153725e992a4SHeiner Kallweit 153825e992a4SHeiner Kallweit if (opts2 & RxVlanTag) 1539759d0957SHeiner Kallweit __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), 1540759d0957SHeiner Kallweit ntohs(opts2 & 0xffff)); 154125e992a4SHeiner Kallweit } 154225e992a4SHeiner Kallweit 154325e992a4SHeiner Kallweit static void rtl8169_get_regs(struct net_device *dev, struct ethtool_regs *regs, 154425e992a4SHeiner Kallweit void *p) 154525e992a4SHeiner Kallweit { 154625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 154725e992a4SHeiner Kallweit u32 __iomem *data = tp->mmio_addr; 154825e992a4SHeiner Kallweit u32 *dw = p; 154925e992a4SHeiner Kallweit int i; 155025e992a4SHeiner Kallweit 155125e992a4SHeiner Kallweit rtl_lock_work(tp); 155225e992a4SHeiner Kallweit for (i = 0; i < R8169_REGS_SIZE; i += 4) 155325e992a4SHeiner Kallweit memcpy_fromio(dw++, data++, 4); 155425e992a4SHeiner Kallweit rtl_unlock_work(tp); 155525e992a4SHeiner Kallweit } 155625e992a4SHeiner Kallweit 155725e992a4SHeiner Kallweit static u32 rtl8169_get_msglevel(struct net_device *dev) 155825e992a4SHeiner Kallweit { 155925e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 156025e992a4SHeiner Kallweit 156125e992a4SHeiner Kallweit return tp->msg_enable; 156225e992a4SHeiner Kallweit } 156325e992a4SHeiner Kallweit 156425e992a4SHeiner Kallweit static void rtl8169_set_msglevel(struct net_device *dev, u32 value) 156525e992a4SHeiner Kallweit { 156625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 156725e992a4SHeiner Kallweit 156825e992a4SHeiner Kallweit tp->msg_enable = value; 156925e992a4SHeiner Kallweit } 157025e992a4SHeiner Kallweit 157125e992a4SHeiner Kallweit static const char rtl8169_gstrings[][ETH_GSTRING_LEN] = { 157225e992a4SHeiner Kallweit "tx_packets", 157325e992a4SHeiner Kallweit "rx_packets", 157425e992a4SHeiner Kallweit "tx_errors", 157525e992a4SHeiner Kallweit "rx_errors", 157625e992a4SHeiner Kallweit "rx_missed", 157725e992a4SHeiner Kallweit "align_errors", 157825e992a4SHeiner Kallweit "tx_single_collisions", 157925e992a4SHeiner Kallweit "tx_multi_collisions", 158025e992a4SHeiner Kallweit "unicast", 158125e992a4SHeiner Kallweit "broadcast", 158225e992a4SHeiner Kallweit "multicast", 158325e992a4SHeiner Kallweit "tx_aborted", 158425e992a4SHeiner Kallweit "tx_underrun", 158525e992a4SHeiner Kallweit }; 158625e992a4SHeiner Kallweit 158725e992a4SHeiner Kallweit static int rtl8169_get_sset_count(struct net_device *dev, int sset) 158825e992a4SHeiner Kallweit { 158925e992a4SHeiner Kallweit switch (sset) { 159025e992a4SHeiner Kallweit case ETH_SS_STATS: 159125e992a4SHeiner Kallweit return ARRAY_SIZE(rtl8169_gstrings); 159225e992a4SHeiner Kallweit default: 159325e992a4SHeiner Kallweit return -EOPNOTSUPP; 159425e992a4SHeiner Kallweit } 159525e992a4SHeiner Kallweit } 159625e992a4SHeiner Kallweit 159725e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_counters_cond) 159825e992a4SHeiner Kallweit { 159925e992a4SHeiner Kallweit return RTL_R32(tp, CounterAddrLow) & (CounterReset | CounterDump); 160025e992a4SHeiner Kallweit } 160125e992a4SHeiner Kallweit 160225e992a4SHeiner Kallweit static bool rtl8169_do_counters(struct rtl8169_private *tp, u32 counter_cmd) 160325e992a4SHeiner Kallweit { 160425e992a4SHeiner Kallweit dma_addr_t paddr = tp->counters_phys_addr; 160525e992a4SHeiner Kallweit u32 cmd; 160625e992a4SHeiner Kallweit 160725e992a4SHeiner Kallweit RTL_W32(tp, CounterAddrHigh, (u64)paddr >> 32); 160825e992a4SHeiner Kallweit RTL_R32(tp, CounterAddrHigh); 160925e992a4SHeiner Kallweit cmd = (u64)paddr & DMA_BIT_MASK(32); 161025e992a4SHeiner Kallweit RTL_W32(tp, CounterAddrLow, cmd); 161125e992a4SHeiner Kallweit RTL_W32(tp, CounterAddrLow, cmd | counter_cmd); 161225e992a4SHeiner Kallweit 161325e992a4SHeiner Kallweit return rtl_udelay_loop_wait_low(tp, &rtl_counters_cond, 10, 1000); 161425e992a4SHeiner Kallweit } 161525e992a4SHeiner Kallweit 161625e992a4SHeiner Kallweit static bool rtl8169_reset_counters(struct rtl8169_private *tp) 161725e992a4SHeiner Kallweit { 161825e992a4SHeiner Kallweit /* 161925e992a4SHeiner Kallweit * Versions prior to RTL_GIGA_MAC_VER_19 don't support resetting the 162025e992a4SHeiner Kallweit * tally counters. 162125e992a4SHeiner Kallweit */ 162225e992a4SHeiner Kallweit if (tp->mac_version < RTL_GIGA_MAC_VER_19) 162325e992a4SHeiner Kallweit return true; 162425e992a4SHeiner Kallweit 162525e992a4SHeiner Kallweit return rtl8169_do_counters(tp, CounterReset); 162625e992a4SHeiner Kallweit } 162725e992a4SHeiner Kallweit 162825e992a4SHeiner Kallweit static bool rtl8169_update_counters(struct rtl8169_private *tp) 162925e992a4SHeiner Kallweit { 163025e992a4SHeiner Kallweit u8 val = RTL_R8(tp, ChipCmd); 163125e992a4SHeiner Kallweit 163225e992a4SHeiner Kallweit /* 163325e992a4SHeiner Kallweit * Some chips are unable to dump tally counters when the receiver 163425e992a4SHeiner Kallweit * is disabled. If 0xff chip may be in a PCI power-save state. 163525e992a4SHeiner Kallweit */ 163625e992a4SHeiner Kallweit if (!(val & CmdRxEnb) || val == 0xff) 163725e992a4SHeiner Kallweit return true; 163825e992a4SHeiner Kallweit 163925e992a4SHeiner Kallweit return rtl8169_do_counters(tp, CounterDump); 164025e992a4SHeiner Kallweit } 164125e992a4SHeiner Kallweit 164225e992a4SHeiner Kallweit static bool rtl8169_init_counter_offsets(struct rtl8169_private *tp) 164325e992a4SHeiner Kallweit { 164425e992a4SHeiner Kallweit struct rtl8169_counters *counters = tp->counters; 164525e992a4SHeiner Kallweit bool ret = false; 164625e992a4SHeiner Kallweit 164725e992a4SHeiner Kallweit /* 164825e992a4SHeiner Kallweit * rtl8169_init_counter_offsets is called from rtl_open. On chip 164925e992a4SHeiner Kallweit * versions prior to RTL_GIGA_MAC_VER_19 the tally counters are only 165025e992a4SHeiner Kallweit * reset by a power cycle, while the counter values collected by the 165125e992a4SHeiner Kallweit * driver are reset at every driver unload/load cycle. 165225e992a4SHeiner Kallweit * 165325e992a4SHeiner Kallweit * To make sure the HW values returned by @get_stats64 match the SW 165425e992a4SHeiner Kallweit * values, we collect the initial values at first open(*) and use them 165525e992a4SHeiner Kallweit * as offsets to normalize the values returned by @get_stats64. 165625e992a4SHeiner Kallweit * 165725e992a4SHeiner Kallweit * (*) We can't call rtl8169_init_counter_offsets from rtl_init_one 165825e992a4SHeiner Kallweit * for the reason stated in rtl8169_update_counters; CmdRxEnb is only 165925e992a4SHeiner Kallweit * set at open time by rtl_hw_start. 166025e992a4SHeiner Kallweit */ 166125e992a4SHeiner Kallweit 166225e992a4SHeiner Kallweit if (tp->tc_offset.inited) 166325e992a4SHeiner Kallweit return true; 166425e992a4SHeiner Kallweit 166525e992a4SHeiner Kallweit /* If both, reset and update fail, propagate to caller. */ 166625e992a4SHeiner Kallweit if (rtl8169_reset_counters(tp)) 166725e992a4SHeiner Kallweit ret = true; 166825e992a4SHeiner Kallweit 166925e992a4SHeiner Kallweit if (rtl8169_update_counters(tp)) 167025e992a4SHeiner Kallweit ret = true; 167125e992a4SHeiner Kallweit 167225e992a4SHeiner Kallweit tp->tc_offset.tx_errors = counters->tx_errors; 167325e992a4SHeiner Kallweit tp->tc_offset.tx_multi_collision = counters->tx_multi_collision; 167425e992a4SHeiner Kallweit tp->tc_offset.tx_aborted = counters->tx_aborted; 167525e992a4SHeiner Kallweit tp->tc_offset.inited = true; 167625e992a4SHeiner Kallweit 167725e992a4SHeiner Kallweit return ret; 167825e992a4SHeiner Kallweit } 167925e992a4SHeiner Kallweit 168025e992a4SHeiner Kallweit static void rtl8169_get_ethtool_stats(struct net_device *dev, 168125e992a4SHeiner Kallweit struct ethtool_stats *stats, u64 *data) 168225e992a4SHeiner Kallweit { 168325e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 168425e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 168525e992a4SHeiner Kallweit struct rtl8169_counters *counters = tp->counters; 168625e992a4SHeiner Kallweit 168725e992a4SHeiner Kallweit ASSERT_RTNL(); 168825e992a4SHeiner Kallweit 168925e992a4SHeiner Kallweit pm_runtime_get_noresume(d); 169025e992a4SHeiner Kallweit 169125e992a4SHeiner Kallweit if (pm_runtime_active(d)) 169225e992a4SHeiner Kallweit rtl8169_update_counters(tp); 169325e992a4SHeiner Kallweit 169425e992a4SHeiner Kallweit pm_runtime_put_noidle(d); 169525e992a4SHeiner Kallweit 169625e992a4SHeiner Kallweit data[0] = le64_to_cpu(counters->tx_packets); 169725e992a4SHeiner Kallweit data[1] = le64_to_cpu(counters->rx_packets); 169825e992a4SHeiner Kallweit data[2] = le64_to_cpu(counters->tx_errors); 169925e992a4SHeiner Kallweit data[3] = le32_to_cpu(counters->rx_errors); 170025e992a4SHeiner Kallweit data[4] = le16_to_cpu(counters->rx_missed); 170125e992a4SHeiner Kallweit data[5] = le16_to_cpu(counters->align_errors); 170225e992a4SHeiner Kallweit data[6] = le32_to_cpu(counters->tx_one_collision); 170325e992a4SHeiner Kallweit data[7] = le32_to_cpu(counters->tx_multi_collision); 170425e992a4SHeiner Kallweit data[8] = le64_to_cpu(counters->rx_unicast); 170525e992a4SHeiner Kallweit data[9] = le64_to_cpu(counters->rx_broadcast); 170625e992a4SHeiner Kallweit data[10] = le32_to_cpu(counters->rx_multicast); 170725e992a4SHeiner Kallweit data[11] = le16_to_cpu(counters->tx_aborted); 170825e992a4SHeiner Kallweit data[12] = le16_to_cpu(counters->tx_underun); 170925e992a4SHeiner Kallweit } 171025e992a4SHeiner Kallweit 171125e992a4SHeiner Kallweit static void rtl8169_get_strings(struct net_device *dev, u32 stringset, u8 *data) 171225e992a4SHeiner Kallweit { 171325e992a4SHeiner Kallweit switch(stringset) { 171425e992a4SHeiner Kallweit case ETH_SS_STATS: 171525e992a4SHeiner Kallweit memcpy(data, *rtl8169_gstrings, sizeof(rtl8169_gstrings)); 171625e992a4SHeiner Kallweit break; 171725e992a4SHeiner Kallweit } 171825e992a4SHeiner Kallweit } 171925e992a4SHeiner Kallweit 172025e992a4SHeiner Kallweit /* 172125e992a4SHeiner Kallweit * Interrupt coalescing 172225e992a4SHeiner Kallweit * 172325e992a4SHeiner Kallweit * > 1 - the availability of the IntrMitigate (0xe2) register through the 172425e992a4SHeiner Kallweit * > 8169, 8168 and 810x line of chipsets 172525e992a4SHeiner Kallweit * 172625e992a4SHeiner Kallweit * 8169, 8168, and 8136(810x) serial chipsets support it. 172725e992a4SHeiner Kallweit * 172825e992a4SHeiner Kallweit * > 2 - the Tx timer unit at gigabit speed 172925e992a4SHeiner Kallweit * 173025e992a4SHeiner Kallweit * The unit of the timer depends on both the speed and the setting of CPlusCmd 173125e992a4SHeiner Kallweit * (0xe0) bit 1 and bit 0. 173225e992a4SHeiner Kallweit * 173325e992a4SHeiner Kallweit * For 8169 173425e992a4SHeiner Kallweit * bit[1:0] \ speed 1000M 100M 10M 173525e992a4SHeiner Kallweit * 0 0 320ns 2.56us 40.96us 173625e992a4SHeiner Kallweit * 0 1 2.56us 20.48us 327.7us 173725e992a4SHeiner Kallweit * 1 0 5.12us 40.96us 655.4us 173825e992a4SHeiner Kallweit * 1 1 10.24us 81.92us 1.31ms 173925e992a4SHeiner Kallweit * 174025e992a4SHeiner Kallweit * For the other 174125e992a4SHeiner Kallweit * bit[1:0] \ speed 1000M 100M 10M 174225e992a4SHeiner Kallweit * 0 0 5us 2.56us 40.96us 174325e992a4SHeiner Kallweit * 0 1 40us 20.48us 327.7us 174425e992a4SHeiner Kallweit * 1 0 80us 40.96us 655.4us 174525e992a4SHeiner Kallweit * 1 1 160us 81.92us 1.31ms 174625e992a4SHeiner Kallweit */ 174725e992a4SHeiner Kallweit 174825e992a4SHeiner Kallweit /* rx/tx scale factors for one particular CPlusCmd[0:1] value */ 174925e992a4SHeiner Kallweit struct rtl_coalesce_scale { 175025e992a4SHeiner Kallweit /* Rx / Tx */ 175125e992a4SHeiner Kallweit u32 nsecs[2]; 175225e992a4SHeiner Kallweit }; 175325e992a4SHeiner Kallweit 175425e992a4SHeiner Kallweit /* rx/tx scale factors for all CPlusCmd[0:1] cases */ 175525e992a4SHeiner Kallweit struct rtl_coalesce_info { 175625e992a4SHeiner Kallweit u32 speed; 175725e992a4SHeiner Kallweit struct rtl_coalesce_scale scalev[4]; /* each CPlusCmd[0:1] case */ 175825e992a4SHeiner Kallweit }; 175925e992a4SHeiner Kallweit 176025e992a4SHeiner Kallweit /* produce (r,t) pairs with each being in series of *1, *8, *8*2, *8*2*2 */ 176125e992a4SHeiner Kallweit #define rxtx_x1822(r, t) { \ 176225e992a4SHeiner Kallweit {{(r), (t)}}, \ 176325e992a4SHeiner Kallweit {{(r)*8, (t)*8}}, \ 176425e992a4SHeiner Kallweit {{(r)*8*2, (t)*8*2}}, \ 176525e992a4SHeiner Kallweit {{(r)*8*2*2, (t)*8*2*2}}, \ 176625e992a4SHeiner Kallweit } 176725e992a4SHeiner Kallweit static const struct rtl_coalesce_info rtl_coalesce_info_8169[] = { 176825e992a4SHeiner Kallweit /* speed delays: rx00 tx00 */ 176925e992a4SHeiner Kallweit { SPEED_10, rxtx_x1822(40960, 40960) }, 177025e992a4SHeiner Kallweit { SPEED_100, rxtx_x1822( 2560, 2560) }, 177125e992a4SHeiner Kallweit { SPEED_1000, rxtx_x1822( 320, 320) }, 177225e992a4SHeiner Kallweit { 0 }, 177325e992a4SHeiner Kallweit }; 177425e992a4SHeiner Kallweit 177525e992a4SHeiner Kallweit static const struct rtl_coalesce_info rtl_coalesce_info_8168_8136[] = { 177625e992a4SHeiner Kallweit /* speed delays: rx00 tx00 */ 177725e992a4SHeiner Kallweit { SPEED_10, rxtx_x1822(40960, 40960) }, 177825e992a4SHeiner Kallweit { SPEED_100, rxtx_x1822( 2560, 2560) }, 177925e992a4SHeiner Kallweit { SPEED_1000, rxtx_x1822( 5000, 5000) }, 178025e992a4SHeiner Kallweit { 0 }, 178125e992a4SHeiner Kallweit }; 178225e992a4SHeiner Kallweit #undef rxtx_x1822 178325e992a4SHeiner Kallweit 178425e992a4SHeiner Kallweit /* get rx/tx scale vector corresponding to current speed */ 178525e992a4SHeiner Kallweit static const struct rtl_coalesce_info *rtl_coalesce_info(struct net_device *dev) 178625e992a4SHeiner Kallweit { 178725e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 178825e992a4SHeiner Kallweit const struct rtl_coalesce_info *ci; 178925e992a4SHeiner Kallweit 179020023d3eSHeiner Kallweit if (tp->mac_version <= RTL_GIGA_MAC_VER_06) 179120023d3eSHeiner Kallweit ci = rtl_coalesce_info_8169; 179220023d3eSHeiner Kallweit else 179320023d3eSHeiner Kallweit ci = rtl_coalesce_info_8168_8136; 179425e992a4SHeiner Kallweit 179520023d3eSHeiner Kallweit for (; ci->speed; ci++) { 179620023d3eSHeiner Kallweit if (tp->phydev->speed == ci->speed) 179725e992a4SHeiner Kallweit return ci; 179825e992a4SHeiner Kallweit } 179925e992a4SHeiner Kallweit 180025e992a4SHeiner Kallweit return ERR_PTR(-ELNRNG); 180125e992a4SHeiner Kallweit } 180225e992a4SHeiner Kallweit 180325e992a4SHeiner Kallweit static int rtl_get_coalesce(struct net_device *dev, struct ethtool_coalesce *ec) 180425e992a4SHeiner Kallweit { 180525e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 180625e992a4SHeiner Kallweit const struct rtl_coalesce_info *ci; 180725e992a4SHeiner Kallweit const struct rtl_coalesce_scale *scale; 180825e992a4SHeiner Kallweit struct { 180925e992a4SHeiner Kallweit u32 *max_frames; 181025e992a4SHeiner Kallweit u32 *usecs; 181125e992a4SHeiner Kallweit } coal_settings [] = { 181225e992a4SHeiner Kallweit { &ec->rx_max_coalesced_frames, &ec->rx_coalesce_usecs }, 181325e992a4SHeiner Kallweit { &ec->tx_max_coalesced_frames, &ec->tx_coalesce_usecs } 181425e992a4SHeiner Kallweit }, *p = coal_settings; 181525e992a4SHeiner Kallweit int i; 181625e992a4SHeiner Kallweit u16 w; 181725e992a4SHeiner Kallweit 181825e992a4SHeiner Kallweit memset(ec, 0, sizeof(*ec)); 181925e992a4SHeiner Kallweit 182025e992a4SHeiner Kallweit /* get rx/tx scale corresponding to current speed and CPlusCmd[0:1] */ 182125e992a4SHeiner Kallweit ci = rtl_coalesce_info(dev); 182225e992a4SHeiner Kallweit if (IS_ERR(ci)) 182325e992a4SHeiner Kallweit return PTR_ERR(ci); 182425e992a4SHeiner Kallweit 182525e992a4SHeiner Kallweit scale = &ci->scalev[tp->cp_cmd & INTT_MASK]; 182625e992a4SHeiner Kallweit 182725e992a4SHeiner Kallweit /* read IntrMitigate and adjust according to scale */ 182825e992a4SHeiner Kallweit for (w = RTL_R16(tp, IntrMitigate); w; w >>= RTL_COALESCE_SHIFT, p++) { 182925e992a4SHeiner Kallweit *p->max_frames = (w & RTL_COALESCE_MASK) << 2; 183025e992a4SHeiner Kallweit w >>= RTL_COALESCE_SHIFT; 183125e992a4SHeiner Kallweit *p->usecs = w & RTL_COALESCE_MASK; 183225e992a4SHeiner Kallweit } 183325e992a4SHeiner Kallweit 183425e992a4SHeiner Kallweit for (i = 0; i < 2; i++) { 183525e992a4SHeiner Kallweit p = coal_settings + i; 183625e992a4SHeiner Kallweit *p->usecs = (*p->usecs * scale->nsecs[i]) / 1000; 183725e992a4SHeiner Kallweit 183825e992a4SHeiner Kallweit /* 183925e992a4SHeiner Kallweit * ethtool_coalesce says it is illegal to set both usecs and 184025e992a4SHeiner Kallweit * max_frames to 0. 184125e992a4SHeiner Kallweit */ 184225e992a4SHeiner Kallweit if (!*p->usecs && !*p->max_frames) 184325e992a4SHeiner Kallweit *p->max_frames = 1; 184425e992a4SHeiner Kallweit } 184525e992a4SHeiner Kallweit 184625e992a4SHeiner Kallweit return 0; 184725e992a4SHeiner Kallweit } 184825e992a4SHeiner Kallweit 184925e992a4SHeiner Kallweit /* choose appropriate scale factor and CPlusCmd[0:1] for (speed, nsec) */ 185025e992a4SHeiner Kallweit static const struct rtl_coalesce_scale *rtl_coalesce_choose_scale( 185125e992a4SHeiner Kallweit struct net_device *dev, u32 nsec, u16 *cp01) 185225e992a4SHeiner Kallweit { 185325e992a4SHeiner Kallweit const struct rtl_coalesce_info *ci; 185425e992a4SHeiner Kallweit u16 i; 185525e992a4SHeiner Kallweit 185625e992a4SHeiner Kallweit ci = rtl_coalesce_info(dev); 185725e992a4SHeiner Kallweit if (IS_ERR(ci)) 185825e992a4SHeiner Kallweit return ERR_CAST(ci); 185925e992a4SHeiner Kallweit 186025e992a4SHeiner Kallweit for (i = 0; i < 4; i++) { 186125e992a4SHeiner Kallweit u32 rxtx_maxscale = max(ci->scalev[i].nsecs[0], 186225e992a4SHeiner Kallweit ci->scalev[i].nsecs[1]); 186325e992a4SHeiner Kallweit if (nsec <= rxtx_maxscale * RTL_COALESCE_T_MAX) { 186425e992a4SHeiner Kallweit *cp01 = i; 186525e992a4SHeiner Kallweit return &ci->scalev[i]; 186625e992a4SHeiner Kallweit } 186725e992a4SHeiner Kallweit } 186825e992a4SHeiner Kallweit 186925e992a4SHeiner Kallweit return ERR_PTR(-EINVAL); 187025e992a4SHeiner Kallweit } 187125e992a4SHeiner Kallweit 187225e992a4SHeiner Kallweit static int rtl_set_coalesce(struct net_device *dev, struct ethtool_coalesce *ec) 187325e992a4SHeiner Kallweit { 187425e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 187525e992a4SHeiner Kallweit const struct rtl_coalesce_scale *scale; 187625e992a4SHeiner Kallweit struct { 187725e992a4SHeiner Kallweit u32 frames; 187825e992a4SHeiner Kallweit u32 usecs; 187925e992a4SHeiner Kallweit } coal_settings [] = { 188025e992a4SHeiner Kallweit { ec->rx_max_coalesced_frames, ec->rx_coalesce_usecs }, 188125e992a4SHeiner Kallweit { ec->tx_max_coalesced_frames, ec->tx_coalesce_usecs } 188225e992a4SHeiner Kallweit }, *p = coal_settings; 188325e992a4SHeiner Kallweit u16 w = 0, cp01; 188425e992a4SHeiner Kallweit int i; 188525e992a4SHeiner Kallweit 188625e992a4SHeiner Kallweit scale = rtl_coalesce_choose_scale(dev, 188725e992a4SHeiner Kallweit max(p[0].usecs, p[1].usecs) * 1000, &cp01); 188825e992a4SHeiner Kallweit if (IS_ERR(scale)) 188925e992a4SHeiner Kallweit return PTR_ERR(scale); 189025e992a4SHeiner Kallweit 189125e992a4SHeiner Kallweit for (i = 0; i < 2; i++, p++) { 189225e992a4SHeiner Kallweit u32 units; 189325e992a4SHeiner Kallweit 189425e992a4SHeiner Kallweit /* 189525e992a4SHeiner Kallweit * accept max_frames=1 we returned in rtl_get_coalesce. 189625e992a4SHeiner Kallweit * accept it not only when usecs=0 because of e.g. the following scenario: 189725e992a4SHeiner Kallweit * 189825e992a4SHeiner Kallweit * - both rx_usecs=0 & rx_frames=0 in hardware (no delay on RX) 189925e992a4SHeiner Kallweit * - rtl_get_coalesce returns rx_usecs=0, rx_frames=1 190025e992a4SHeiner Kallweit * - then user does `ethtool -C eth0 rx-usecs 100` 190125e992a4SHeiner Kallweit * 190225e992a4SHeiner Kallweit * since ethtool sends to kernel whole ethtool_coalesce 190325e992a4SHeiner Kallweit * settings, if we do not handle rx_usecs=!0, rx_frames=1 190425e992a4SHeiner Kallweit * we'll reject it below in `frames % 4 != 0`. 190525e992a4SHeiner Kallweit */ 190625e992a4SHeiner Kallweit if (p->frames == 1) { 190725e992a4SHeiner Kallweit p->frames = 0; 190825e992a4SHeiner Kallweit } 190925e992a4SHeiner Kallweit 191025e992a4SHeiner Kallweit units = p->usecs * 1000 / scale->nsecs[i]; 191125e992a4SHeiner Kallweit if (p->frames > RTL_COALESCE_FRAME_MAX || p->frames % 4) 191225e992a4SHeiner Kallweit return -EINVAL; 191325e992a4SHeiner Kallweit 191425e992a4SHeiner Kallweit w <<= RTL_COALESCE_SHIFT; 191525e992a4SHeiner Kallweit w |= units; 191625e992a4SHeiner Kallweit w <<= RTL_COALESCE_SHIFT; 191725e992a4SHeiner Kallweit w |= p->frames >> 2; 191825e992a4SHeiner Kallweit } 191925e992a4SHeiner Kallweit 192025e992a4SHeiner Kallweit rtl_lock_work(tp); 192125e992a4SHeiner Kallweit 192225e992a4SHeiner Kallweit RTL_W16(tp, IntrMitigate, swab16(w)); 192325e992a4SHeiner Kallweit 192425e992a4SHeiner Kallweit tp->cp_cmd = (tp->cp_cmd & ~INTT_MASK) | cp01; 192525e992a4SHeiner Kallweit RTL_W16(tp, CPlusCmd, tp->cp_cmd); 192625e992a4SHeiner Kallweit RTL_R16(tp, CPlusCmd); 192725e992a4SHeiner Kallweit 192825e992a4SHeiner Kallweit rtl_unlock_work(tp); 192925e992a4SHeiner Kallweit 193025e992a4SHeiner Kallweit return 0; 193125e992a4SHeiner Kallweit } 193225e992a4SHeiner Kallweit 193325e992a4SHeiner Kallweit static int rtl_get_eee_supp(struct rtl8169_private *tp) 193425e992a4SHeiner Kallweit { 193525e992a4SHeiner Kallweit struct phy_device *phydev = tp->phydev; 193625e992a4SHeiner Kallweit int ret; 193725e992a4SHeiner Kallweit 193825e992a4SHeiner Kallweit switch (tp->mac_version) { 193925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_34: 194025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_35: 194125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_36: 194225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_38: 194325e992a4SHeiner Kallweit ret = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE); 194425e992a4SHeiner Kallweit break; 194525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_40 ... RTL_GIGA_MAC_VER_51: 194625e992a4SHeiner Kallweit ret = phy_read_paged(phydev, 0x0a5c, 0x12); 194725e992a4SHeiner Kallweit break; 194825e992a4SHeiner Kallweit default: 194925e992a4SHeiner Kallweit ret = -EPROTONOSUPPORT; 195025e992a4SHeiner Kallweit break; 195125e992a4SHeiner Kallweit } 195225e992a4SHeiner Kallweit 195325e992a4SHeiner Kallweit return ret; 195425e992a4SHeiner Kallweit } 195525e992a4SHeiner Kallweit 195625e992a4SHeiner Kallweit static int rtl_get_eee_lpadv(struct rtl8169_private *tp) 195725e992a4SHeiner Kallweit { 195825e992a4SHeiner Kallweit struct phy_device *phydev = tp->phydev; 195925e992a4SHeiner Kallweit int ret; 196025e992a4SHeiner Kallweit 196125e992a4SHeiner Kallweit switch (tp->mac_version) { 196225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_34: 196325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_35: 196425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_36: 196525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_38: 196625e992a4SHeiner Kallweit ret = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE); 196725e992a4SHeiner Kallweit break; 196825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_40 ... RTL_GIGA_MAC_VER_51: 196925e992a4SHeiner Kallweit ret = phy_read_paged(phydev, 0x0a5d, 0x11); 197025e992a4SHeiner Kallweit break; 197125e992a4SHeiner Kallweit default: 197225e992a4SHeiner Kallweit ret = -EPROTONOSUPPORT; 197325e992a4SHeiner Kallweit break; 197425e992a4SHeiner Kallweit } 197525e992a4SHeiner Kallweit 197625e992a4SHeiner Kallweit return ret; 197725e992a4SHeiner Kallweit } 197825e992a4SHeiner Kallweit 197925e992a4SHeiner Kallweit static int rtl_get_eee_adv(struct rtl8169_private *tp) 198025e992a4SHeiner Kallweit { 198125e992a4SHeiner Kallweit struct phy_device *phydev = tp->phydev; 198225e992a4SHeiner Kallweit int ret; 198325e992a4SHeiner Kallweit 198425e992a4SHeiner Kallweit switch (tp->mac_version) { 198525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_34: 198625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_35: 198725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_36: 198825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_38: 198925e992a4SHeiner Kallweit ret = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV); 199025e992a4SHeiner Kallweit break; 199125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_40 ... RTL_GIGA_MAC_VER_51: 199225e992a4SHeiner Kallweit ret = phy_read_paged(phydev, 0x0a5d, 0x10); 199325e992a4SHeiner Kallweit break; 199425e992a4SHeiner Kallweit default: 199525e992a4SHeiner Kallweit ret = -EPROTONOSUPPORT; 199625e992a4SHeiner Kallweit break; 199725e992a4SHeiner Kallweit } 199825e992a4SHeiner Kallweit 199925e992a4SHeiner Kallweit return ret; 200025e992a4SHeiner Kallweit } 200125e992a4SHeiner Kallweit 200225e992a4SHeiner Kallweit static int rtl_set_eee_adv(struct rtl8169_private *tp, int val) 200325e992a4SHeiner Kallweit { 200425e992a4SHeiner Kallweit struct phy_device *phydev = tp->phydev; 200525e992a4SHeiner Kallweit int ret = 0; 200625e992a4SHeiner Kallweit 200725e992a4SHeiner Kallweit switch (tp->mac_version) { 200825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_34: 200925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_35: 201025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_36: 201125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_38: 201225e992a4SHeiner Kallweit ret = phy_write_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV, val); 201325e992a4SHeiner Kallweit break; 201425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_40 ... RTL_GIGA_MAC_VER_51: 201525e992a4SHeiner Kallweit phy_write_paged(phydev, 0x0a5d, 0x10, val); 201625e992a4SHeiner Kallweit break; 201725e992a4SHeiner Kallweit default: 201825e992a4SHeiner Kallweit ret = -EPROTONOSUPPORT; 201925e992a4SHeiner Kallweit break; 202025e992a4SHeiner Kallweit } 202125e992a4SHeiner Kallweit 202225e992a4SHeiner Kallweit return ret; 202325e992a4SHeiner Kallweit } 202425e992a4SHeiner Kallweit 202525e992a4SHeiner Kallweit static int rtl8169_get_eee(struct net_device *dev, struct ethtool_eee *data) 202625e992a4SHeiner Kallweit { 202725e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 202825e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 202925e992a4SHeiner Kallweit int ret; 203025e992a4SHeiner Kallweit 203125e992a4SHeiner Kallweit pm_runtime_get_noresume(d); 203225e992a4SHeiner Kallweit 203325e992a4SHeiner Kallweit if (!pm_runtime_active(d)) { 203425e992a4SHeiner Kallweit ret = -EOPNOTSUPP; 203525e992a4SHeiner Kallweit goto out; 203625e992a4SHeiner Kallweit } 203725e992a4SHeiner Kallweit 203825e992a4SHeiner Kallweit /* Get Supported EEE */ 203925e992a4SHeiner Kallweit ret = rtl_get_eee_supp(tp); 204025e992a4SHeiner Kallweit if (ret < 0) 204125e992a4SHeiner Kallweit goto out; 204225e992a4SHeiner Kallweit data->supported = mmd_eee_cap_to_ethtool_sup_t(ret); 204325e992a4SHeiner Kallweit 204425e992a4SHeiner Kallweit /* Get advertisement EEE */ 204525e992a4SHeiner Kallweit ret = rtl_get_eee_adv(tp); 204625e992a4SHeiner Kallweit if (ret < 0) 204725e992a4SHeiner Kallweit goto out; 204825e992a4SHeiner Kallweit data->advertised = mmd_eee_adv_to_ethtool_adv_t(ret); 204925e992a4SHeiner Kallweit data->eee_enabled = !!data->advertised; 205025e992a4SHeiner Kallweit 205125e992a4SHeiner Kallweit /* Get LP advertisement EEE */ 205225e992a4SHeiner Kallweit ret = rtl_get_eee_lpadv(tp); 205325e992a4SHeiner Kallweit if (ret < 0) 205425e992a4SHeiner Kallweit goto out; 205525e992a4SHeiner Kallweit data->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(ret); 205625e992a4SHeiner Kallweit data->eee_active = !!(data->advertised & data->lp_advertised); 205725e992a4SHeiner Kallweit out: 205825e992a4SHeiner Kallweit pm_runtime_put_noidle(d); 205925e992a4SHeiner Kallweit return ret < 0 ? ret : 0; 206025e992a4SHeiner Kallweit } 206125e992a4SHeiner Kallweit 206225e992a4SHeiner Kallweit static int rtl8169_set_eee(struct net_device *dev, struct ethtool_eee *data) 206325e992a4SHeiner Kallweit { 206425e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 206525e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 206625e992a4SHeiner Kallweit int old_adv, adv = 0, cap, ret; 206725e992a4SHeiner Kallweit 206825e992a4SHeiner Kallweit pm_runtime_get_noresume(d); 206925e992a4SHeiner Kallweit 207025e992a4SHeiner Kallweit if (!dev->phydev || !pm_runtime_active(d)) { 207125e992a4SHeiner Kallweit ret = -EOPNOTSUPP; 207225e992a4SHeiner Kallweit goto out; 207325e992a4SHeiner Kallweit } 207425e992a4SHeiner Kallweit 207525e992a4SHeiner Kallweit if (dev->phydev->autoneg == AUTONEG_DISABLE || 207625e992a4SHeiner Kallweit dev->phydev->duplex != DUPLEX_FULL) { 207725e992a4SHeiner Kallweit ret = -EPROTONOSUPPORT; 207825e992a4SHeiner Kallweit goto out; 207925e992a4SHeiner Kallweit } 208025e992a4SHeiner Kallweit 208125e992a4SHeiner Kallweit /* Get Supported EEE */ 208225e992a4SHeiner Kallweit ret = rtl_get_eee_supp(tp); 208325e992a4SHeiner Kallweit if (ret < 0) 208425e992a4SHeiner Kallweit goto out; 208525e992a4SHeiner Kallweit cap = ret; 208625e992a4SHeiner Kallweit 208725e992a4SHeiner Kallweit ret = rtl_get_eee_adv(tp); 208825e992a4SHeiner Kallweit if (ret < 0) 208925e992a4SHeiner Kallweit goto out; 209025e992a4SHeiner Kallweit old_adv = ret; 209125e992a4SHeiner Kallweit 209225e992a4SHeiner Kallweit if (data->eee_enabled) { 209325e992a4SHeiner Kallweit adv = !data->advertised ? cap : 209425e992a4SHeiner Kallweit ethtool_adv_to_mmd_eee_adv_t(data->advertised) & cap; 209525e992a4SHeiner Kallweit /* Mask prohibited EEE modes */ 209625e992a4SHeiner Kallweit adv &= ~dev->phydev->eee_broken_modes; 209725e992a4SHeiner Kallweit } 209825e992a4SHeiner Kallweit 209925e992a4SHeiner Kallweit if (old_adv != adv) { 210025e992a4SHeiner Kallweit ret = rtl_set_eee_adv(tp, adv); 210125e992a4SHeiner Kallweit if (ret < 0) 210225e992a4SHeiner Kallweit goto out; 210325e992a4SHeiner Kallweit 210425e992a4SHeiner Kallweit /* Restart autonegotiation so the new modes get sent to the 210525e992a4SHeiner Kallweit * link partner. 210625e992a4SHeiner Kallweit */ 210725e992a4SHeiner Kallweit ret = phy_restart_aneg(dev->phydev); 210825e992a4SHeiner Kallweit } 210925e992a4SHeiner Kallweit 211025e992a4SHeiner Kallweit out: 211125e992a4SHeiner Kallweit pm_runtime_put_noidle(d); 211225e992a4SHeiner Kallweit return ret < 0 ? ret : 0; 211325e992a4SHeiner Kallweit } 211425e992a4SHeiner Kallweit 211525e992a4SHeiner Kallweit static const struct ethtool_ops rtl8169_ethtool_ops = { 211625e992a4SHeiner Kallweit .get_drvinfo = rtl8169_get_drvinfo, 211725e992a4SHeiner Kallweit .get_regs_len = rtl8169_get_regs_len, 211825e992a4SHeiner Kallweit .get_link = ethtool_op_get_link, 211925e992a4SHeiner Kallweit .get_coalesce = rtl_get_coalesce, 212025e992a4SHeiner Kallweit .set_coalesce = rtl_set_coalesce, 212125e992a4SHeiner Kallweit .get_msglevel = rtl8169_get_msglevel, 212225e992a4SHeiner Kallweit .set_msglevel = rtl8169_set_msglevel, 212325e992a4SHeiner Kallweit .get_regs = rtl8169_get_regs, 212425e992a4SHeiner Kallweit .get_wol = rtl8169_get_wol, 212525e992a4SHeiner Kallweit .set_wol = rtl8169_set_wol, 212625e992a4SHeiner Kallweit .get_strings = rtl8169_get_strings, 212725e992a4SHeiner Kallweit .get_sset_count = rtl8169_get_sset_count, 212825e992a4SHeiner Kallweit .get_ethtool_stats = rtl8169_get_ethtool_stats, 212925e992a4SHeiner Kallweit .get_ts_info = ethtool_op_get_ts_info, 213025e992a4SHeiner Kallweit .nway_reset = phy_ethtool_nway_reset, 213125e992a4SHeiner Kallweit .get_eee = rtl8169_get_eee, 213225e992a4SHeiner Kallweit .set_eee = rtl8169_set_eee, 213325e992a4SHeiner Kallweit .get_link_ksettings = phy_ethtool_get_link_ksettings, 213425e992a4SHeiner Kallweit .set_link_ksettings = phy_ethtool_set_link_ksettings, 213525e992a4SHeiner Kallweit }; 213625e992a4SHeiner Kallweit 213725e992a4SHeiner Kallweit static void rtl_enable_eee(struct rtl8169_private *tp) 213825e992a4SHeiner Kallweit { 213925e992a4SHeiner Kallweit int supported = rtl_get_eee_supp(tp); 214025e992a4SHeiner Kallweit 214125e992a4SHeiner Kallweit if (supported > 0) 214225e992a4SHeiner Kallweit rtl_set_eee_adv(tp, supported); 214325e992a4SHeiner Kallweit } 214425e992a4SHeiner Kallweit 214525e992a4SHeiner Kallweit static void rtl8169_get_mac_version(struct rtl8169_private *tp) 214625e992a4SHeiner Kallweit { 214725e992a4SHeiner Kallweit /* 214825e992a4SHeiner Kallweit * The driver currently handles the 8168Bf and the 8168Be identically 214925e992a4SHeiner Kallweit * but they can be identified more specifically through the test below 215025e992a4SHeiner Kallweit * if needed: 215125e992a4SHeiner Kallweit * 215225e992a4SHeiner Kallweit * (RTL_R32(tp, TxConfig) & 0x700000) == 0x500000 ? 8168Bf : 8168Be 215325e992a4SHeiner Kallweit * 215425e992a4SHeiner Kallweit * Same thing for the 8101Eb and the 8101Ec: 215525e992a4SHeiner Kallweit * 215625e992a4SHeiner Kallweit * (RTL_R32(tp, TxConfig) & 0x700000) == 0x200000 ? 8101Eb : 8101Ec 215725e992a4SHeiner Kallweit */ 215825e992a4SHeiner Kallweit static const struct rtl_mac_info { 215925e992a4SHeiner Kallweit u16 mask; 216025e992a4SHeiner Kallweit u16 val; 216125e992a4SHeiner Kallweit u16 mac_version; 216225e992a4SHeiner Kallweit } mac_info[] = { 216325e992a4SHeiner Kallweit /* 8168EP family. */ 216425e992a4SHeiner Kallweit { 0x7cf, 0x502, RTL_GIGA_MAC_VER_51 }, 216525e992a4SHeiner Kallweit { 0x7cf, 0x501, RTL_GIGA_MAC_VER_50 }, 216625e992a4SHeiner Kallweit { 0x7cf, 0x500, RTL_GIGA_MAC_VER_49 }, 216725e992a4SHeiner Kallweit 216825e992a4SHeiner Kallweit /* 8168H family. */ 216925e992a4SHeiner Kallweit { 0x7cf, 0x541, RTL_GIGA_MAC_VER_46 }, 217025e992a4SHeiner Kallweit { 0x7cf, 0x540, RTL_GIGA_MAC_VER_45 }, 217125e992a4SHeiner Kallweit 217225e992a4SHeiner Kallweit /* 8168G family. */ 217325e992a4SHeiner Kallweit { 0x7cf, 0x5c8, RTL_GIGA_MAC_VER_44 }, 217425e992a4SHeiner Kallweit { 0x7cf, 0x509, RTL_GIGA_MAC_VER_42 }, 217525e992a4SHeiner Kallweit { 0x7cf, 0x4c1, RTL_GIGA_MAC_VER_41 }, 217625e992a4SHeiner Kallweit { 0x7cf, 0x4c0, RTL_GIGA_MAC_VER_40 }, 217725e992a4SHeiner Kallweit 217825e992a4SHeiner Kallweit /* 8168F family. */ 217925e992a4SHeiner Kallweit { 0x7c8, 0x488, RTL_GIGA_MAC_VER_38 }, 218025e992a4SHeiner Kallweit { 0x7cf, 0x481, RTL_GIGA_MAC_VER_36 }, 218125e992a4SHeiner Kallweit { 0x7cf, 0x480, RTL_GIGA_MAC_VER_35 }, 218225e992a4SHeiner Kallweit 218325e992a4SHeiner Kallweit /* 8168E family. */ 218425e992a4SHeiner Kallweit { 0x7c8, 0x2c8, RTL_GIGA_MAC_VER_34 }, 218525e992a4SHeiner Kallweit { 0x7cf, 0x2c1, RTL_GIGA_MAC_VER_32 }, 218625e992a4SHeiner Kallweit { 0x7c8, 0x2c0, RTL_GIGA_MAC_VER_33 }, 218725e992a4SHeiner Kallweit 218825e992a4SHeiner Kallweit /* 8168D family. */ 218925e992a4SHeiner Kallweit { 0x7cf, 0x281, RTL_GIGA_MAC_VER_25 }, 219025e992a4SHeiner Kallweit { 0x7c8, 0x280, RTL_GIGA_MAC_VER_26 }, 219125e992a4SHeiner Kallweit 219225e992a4SHeiner Kallweit /* 8168DP family. */ 219325e992a4SHeiner Kallweit { 0x7cf, 0x288, RTL_GIGA_MAC_VER_27 }, 219425e992a4SHeiner Kallweit { 0x7cf, 0x28a, RTL_GIGA_MAC_VER_28 }, 219525e992a4SHeiner Kallweit { 0x7cf, 0x28b, RTL_GIGA_MAC_VER_31 }, 219625e992a4SHeiner Kallweit 219725e992a4SHeiner Kallweit /* 8168C family. */ 219825e992a4SHeiner Kallweit { 0x7cf, 0x3c9, RTL_GIGA_MAC_VER_23 }, 219925e992a4SHeiner Kallweit { 0x7cf, 0x3c8, RTL_GIGA_MAC_VER_18 }, 220025e992a4SHeiner Kallweit { 0x7c8, 0x3c8, RTL_GIGA_MAC_VER_24 }, 220125e992a4SHeiner Kallweit { 0x7cf, 0x3c0, RTL_GIGA_MAC_VER_19 }, 220225e992a4SHeiner Kallweit { 0x7cf, 0x3c2, RTL_GIGA_MAC_VER_20 }, 220325e992a4SHeiner Kallweit { 0x7cf, 0x3c3, RTL_GIGA_MAC_VER_21 }, 220425e992a4SHeiner Kallweit { 0x7c8, 0x3c0, RTL_GIGA_MAC_VER_22 }, 220525e992a4SHeiner Kallweit 220625e992a4SHeiner Kallweit /* 8168B family. */ 220725e992a4SHeiner Kallweit { 0x7cf, 0x380, RTL_GIGA_MAC_VER_12 }, 220825e992a4SHeiner Kallweit { 0x7c8, 0x380, RTL_GIGA_MAC_VER_17 }, 220925e992a4SHeiner Kallweit { 0x7c8, 0x300, RTL_GIGA_MAC_VER_11 }, 221025e992a4SHeiner Kallweit 221125e992a4SHeiner Kallweit /* 8101 family. */ 221225e992a4SHeiner Kallweit { 0x7c8, 0x448, RTL_GIGA_MAC_VER_39 }, 221325e992a4SHeiner Kallweit { 0x7c8, 0x440, RTL_GIGA_MAC_VER_37 }, 221425e992a4SHeiner Kallweit { 0x7cf, 0x409, RTL_GIGA_MAC_VER_29 }, 221525e992a4SHeiner Kallweit { 0x7c8, 0x408, RTL_GIGA_MAC_VER_30 }, 221625e992a4SHeiner Kallweit { 0x7cf, 0x349, RTL_GIGA_MAC_VER_08 }, 221725e992a4SHeiner Kallweit { 0x7cf, 0x249, RTL_GIGA_MAC_VER_08 }, 221825e992a4SHeiner Kallweit { 0x7cf, 0x348, RTL_GIGA_MAC_VER_07 }, 221925e992a4SHeiner Kallweit { 0x7cf, 0x248, RTL_GIGA_MAC_VER_07 }, 222025e992a4SHeiner Kallweit { 0x7cf, 0x340, RTL_GIGA_MAC_VER_13 }, 222125e992a4SHeiner Kallweit { 0x7cf, 0x343, RTL_GIGA_MAC_VER_10 }, 222225e992a4SHeiner Kallweit { 0x7cf, 0x342, RTL_GIGA_MAC_VER_16 }, 222325e992a4SHeiner Kallweit { 0x7c8, 0x348, RTL_GIGA_MAC_VER_09 }, 222425e992a4SHeiner Kallweit { 0x7c8, 0x248, RTL_GIGA_MAC_VER_09 }, 222525e992a4SHeiner Kallweit { 0x7c8, 0x340, RTL_GIGA_MAC_VER_16 }, 222625e992a4SHeiner Kallweit /* FIXME: where did these entries come from ? -- FR */ 222725e992a4SHeiner Kallweit { 0xfc8, 0x388, RTL_GIGA_MAC_VER_15 }, 222825e992a4SHeiner Kallweit { 0xfc8, 0x308, RTL_GIGA_MAC_VER_14 }, 222925e992a4SHeiner Kallweit 223025e992a4SHeiner Kallweit /* 8110 family. */ 223125e992a4SHeiner Kallweit { 0xfc8, 0x980, RTL_GIGA_MAC_VER_06 }, 223225e992a4SHeiner Kallweit { 0xfc8, 0x180, RTL_GIGA_MAC_VER_05 }, 223325e992a4SHeiner Kallweit { 0xfc8, 0x100, RTL_GIGA_MAC_VER_04 }, 223425e992a4SHeiner Kallweit { 0xfc8, 0x040, RTL_GIGA_MAC_VER_03 }, 223525e992a4SHeiner Kallweit { 0xfc8, 0x008, RTL_GIGA_MAC_VER_02 }, 223625e992a4SHeiner Kallweit 223725e992a4SHeiner Kallweit /* Catch-all */ 223825e992a4SHeiner Kallweit { 0x000, 0x000, RTL_GIGA_MAC_NONE } 223925e992a4SHeiner Kallweit }; 224025e992a4SHeiner Kallweit const struct rtl_mac_info *p = mac_info; 224125e992a4SHeiner Kallweit u16 reg = RTL_R32(tp, TxConfig) >> 20; 224225e992a4SHeiner Kallweit 224325e992a4SHeiner Kallweit while ((reg & p->mask) != p->val) 224425e992a4SHeiner Kallweit p++; 224525e992a4SHeiner Kallweit tp->mac_version = p->mac_version; 224625e992a4SHeiner Kallweit 224725e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_NONE) { 224825e992a4SHeiner Kallweit dev_err(tp_to_dev(tp), "unknown chip XID %03x\n", reg & 0xfcf); 224925e992a4SHeiner Kallweit } else if (!tp->supports_gmii) { 225025e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_42) 225125e992a4SHeiner Kallweit tp->mac_version = RTL_GIGA_MAC_VER_43; 225225e992a4SHeiner Kallweit else if (tp->mac_version == RTL_GIGA_MAC_VER_45) 225325e992a4SHeiner Kallweit tp->mac_version = RTL_GIGA_MAC_VER_47; 225425e992a4SHeiner Kallweit else if (tp->mac_version == RTL_GIGA_MAC_VER_46) 225525e992a4SHeiner Kallweit tp->mac_version = RTL_GIGA_MAC_VER_48; 225625e992a4SHeiner Kallweit } 225725e992a4SHeiner Kallweit } 225825e992a4SHeiner Kallweit 225925e992a4SHeiner Kallweit struct phy_reg { 226025e992a4SHeiner Kallweit u16 reg; 226125e992a4SHeiner Kallweit u16 val; 226225e992a4SHeiner Kallweit }; 226325e992a4SHeiner Kallweit 226425e992a4SHeiner Kallweit static void __rtl_writephy_batch(struct rtl8169_private *tp, 226525e992a4SHeiner Kallweit const struct phy_reg *regs, int len) 226625e992a4SHeiner Kallweit { 226725e992a4SHeiner Kallweit while (len-- > 0) { 226825e992a4SHeiner Kallweit rtl_writephy(tp, regs->reg, regs->val); 226925e992a4SHeiner Kallweit regs++; 227025e992a4SHeiner Kallweit } 227125e992a4SHeiner Kallweit } 227225e992a4SHeiner Kallweit 227325e992a4SHeiner Kallweit #define rtl_writephy_batch(tp, a) __rtl_writephy_batch(tp, a, ARRAY_SIZE(a)) 227425e992a4SHeiner Kallweit 227525e992a4SHeiner Kallweit static void rtl_release_firmware(struct rtl8169_private *tp) 227625e992a4SHeiner Kallweit { 227725e992a4SHeiner Kallweit if (tp->rtl_fw) { 227825e992a4SHeiner Kallweit rtl_fw_release_firmware(tp->rtl_fw); 227925e992a4SHeiner Kallweit kfree(tp->rtl_fw); 228025e992a4SHeiner Kallweit tp->rtl_fw = NULL; 228125e992a4SHeiner Kallweit } 228225e992a4SHeiner Kallweit } 228325e992a4SHeiner Kallweit 228425e992a4SHeiner Kallweit static void rtl_apply_firmware(struct rtl8169_private *tp) 228525e992a4SHeiner Kallweit { 228625e992a4SHeiner Kallweit /* TODO: release firmware if rtl_fw_write_firmware signals failure. */ 228725e992a4SHeiner Kallweit if (tp->rtl_fw) 228825e992a4SHeiner Kallweit rtl_fw_write_firmware(tp, tp->rtl_fw); 228925e992a4SHeiner Kallweit } 229025e992a4SHeiner Kallweit 229125e992a4SHeiner Kallweit static void rtl_apply_firmware_cond(struct rtl8169_private *tp, u8 reg, u16 val) 229225e992a4SHeiner Kallweit { 229325e992a4SHeiner Kallweit if (rtl_readphy(tp, reg) != val) 229425e992a4SHeiner Kallweit netif_warn(tp, hw, tp->dev, "chipset not ready for firmware\n"); 229525e992a4SHeiner Kallweit else 229625e992a4SHeiner Kallweit rtl_apply_firmware(tp); 229725e992a4SHeiner Kallweit } 229825e992a4SHeiner Kallweit 229925e992a4SHeiner Kallweit static void rtl8168_config_eee_mac(struct rtl8169_private *tp) 230025e992a4SHeiner Kallweit { 230125e992a4SHeiner Kallweit /* Adjust EEE LED frequency */ 230225e992a4SHeiner Kallweit if (tp->mac_version != RTL_GIGA_MAC_VER_38) 230325e992a4SHeiner Kallweit RTL_W8(tp, EEE_LED, RTL_R8(tp, EEE_LED) & ~0x07); 230425e992a4SHeiner Kallweit 230525e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0x1b0, ERIAR_MASK_1111, 0x0003); 230625e992a4SHeiner Kallweit } 230725e992a4SHeiner Kallweit 230825e992a4SHeiner Kallweit static void rtl8168f_config_eee_phy(struct rtl8169_private *tp) 230925e992a4SHeiner Kallweit { 231025e992a4SHeiner Kallweit struct phy_device *phydev = tp->phydev; 231125e992a4SHeiner Kallweit 231225e992a4SHeiner Kallweit phy_write(phydev, 0x1f, 0x0007); 231325e992a4SHeiner Kallweit phy_write(phydev, 0x1e, 0x0020); 231425e992a4SHeiner Kallweit phy_set_bits(phydev, 0x15, BIT(8)); 231525e992a4SHeiner Kallweit 231625e992a4SHeiner Kallweit phy_write(phydev, 0x1f, 0x0005); 231725e992a4SHeiner Kallweit phy_write(phydev, 0x05, 0x8b85); 231825e992a4SHeiner Kallweit phy_set_bits(phydev, 0x06, BIT(13)); 231925e992a4SHeiner Kallweit 232025e992a4SHeiner Kallweit phy_write(phydev, 0x1f, 0x0000); 232125e992a4SHeiner Kallweit } 232225e992a4SHeiner Kallweit 232325e992a4SHeiner Kallweit static void rtl8168g_config_eee_phy(struct rtl8169_private *tp) 232425e992a4SHeiner Kallweit { 232525e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0a43, 0x11, 0, BIT(4)); 232625e992a4SHeiner Kallweit } 232725e992a4SHeiner Kallweit 232825e992a4SHeiner Kallweit static void rtl8169s_hw_phy_config(struct rtl8169_private *tp) 232925e992a4SHeiner Kallweit { 233025e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 233125e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 233225e992a4SHeiner Kallweit { 0x06, 0x006e }, 233325e992a4SHeiner Kallweit { 0x08, 0x0708 }, 233425e992a4SHeiner Kallweit { 0x15, 0x4000 }, 233525e992a4SHeiner Kallweit { 0x18, 0x65c7 }, 233625e992a4SHeiner Kallweit 233725e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 233825e992a4SHeiner Kallweit { 0x03, 0x00a1 }, 233925e992a4SHeiner Kallweit { 0x02, 0x0008 }, 234025e992a4SHeiner Kallweit { 0x01, 0x0120 }, 234125e992a4SHeiner Kallweit { 0x00, 0x1000 }, 234225e992a4SHeiner Kallweit { 0x04, 0x0800 }, 234325e992a4SHeiner Kallweit { 0x04, 0x0000 }, 234425e992a4SHeiner Kallweit 234525e992a4SHeiner Kallweit { 0x03, 0xff41 }, 234625e992a4SHeiner Kallweit { 0x02, 0xdf60 }, 234725e992a4SHeiner Kallweit { 0x01, 0x0140 }, 234825e992a4SHeiner Kallweit { 0x00, 0x0077 }, 234925e992a4SHeiner Kallweit { 0x04, 0x7800 }, 235025e992a4SHeiner Kallweit { 0x04, 0x7000 }, 235125e992a4SHeiner Kallweit 235225e992a4SHeiner Kallweit { 0x03, 0x802f }, 235325e992a4SHeiner Kallweit { 0x02, 0x4f02 }, 235425e992a4SHeiner Kallweit { 0x01, 0x0409 }, 235525e992a4SHeiner Kallweit { 0x00, 0xf0f9 }, 235625e992a4SHeiner Kallweit { 0x04, 0x9800 }, 235725e992a4SHeiner Kallweit { 0x04, 0x9000 }, 235825e992a4SHeiner Kallweit 235925e992a4SHeiner Kallweit { 0x03, 0xdf01 }, 236025e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 236125e992a4SHeiner Kallweit { 0x01, 0xff95 }, 236225e992a4SHeiner Kallweit { 0x00, 0xba00 }, 236325e992a4SHeiner Kallweit { 0x04, 0xa800 }, 236425e992a4SHeiner Kallweit { 0x04, 0xa000 }, 236525e992a4SHeiner Kallweit 236625e992a4SHeiner Kallweit { 0x03, 0xff41 }, 236725e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 236825e992a4SHeiner Kallweit { 0x01, 0x0140 }, 236925e992a4SHeiner Kallweit { 0x00, 0x00bb }, 237025e992a4SHeiner Kallweit { 0x04, 0xb800 }, 237125e992a4SHeiner Kallweit { 0x04, 0xb000 }, 237225e992a4SHeiner Kallweit 237325e992a4SHeiner Kallweit { 0x03, 0xdf41 }, 237425e992a4SHeiner Kallweit { 0x02, 0xdc60 }, 237525e992a4SHeiner Kallweit { 0x01, 0x6340 }, 237625e992a4SHeiner Kallweit { 0x00, 0x007d }, 237725e992a4SHeiner Kallweit { 0x04, 0xd800 }, 237825e992a4SHeiner Kallweit { 0x04, 0xd000 }, 237925e992a4SHeiner Kallweit 238025e992a4SHeiner Kallweit { 0x03, 0xdf01 }, 238125e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 238225e992a4SHeiner Kallweit { 0x01, 0x100a }, 238325e992a4SHeiner Kallweit { 0x00, 0xa0ff }, 238425e992a4SHeiner Kallweit { 0x04, 0xf800 }, 238525e992a4SHeiner Kallweit { 0x04, 0xf000 }, 238625e992a4SHeiner Kallweit 238725e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 238825e992a4SHeiner Kallweit { 0x0b, 0x0000 }, 238925e992a4SHeiner Kallweit { 0x00, 0x9200 } 239025e992a4SHeiner Kallweit }; 239125e992a4SHeiner Kallweit 239225e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 239325e992a4SHeiner Kallweit } 239425e992a4SHeiner Kallweit 239525e992a4SHeiner Kallweit static void rtl8169sb_hw_phy_config(struct rtl8169_private *tp) 239625e992a4SHeiner Kallweit { 239725e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 239825e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 239925e992a4SHeiner Kallweit { 0x01, 0x90d0 }, 240025e992a4SHeiner Kallweit { 0x1f, 0x0000 } 240125e992a4SHeiner Kallweit }; 240225e992a4SHeiner Kallweit 240325e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 240425e992a4SHeiner Kallweit } 240525e992a4SHeiner Kallweit 240625e992a4SHeiner Kallweit static void rtl8169scd_hw_phy_config_quirk(struct rtl8169_private *tp) 240725e992a4SHeiner Kallweit { 240825e992a4SHeiner Kallweit struct pci_dev *pdev = tp->pci_dev; 240925e992a4SHeiner Kallweit 241025e992a4SHeiner Kallweit if ((pdev->subsystem_vendor != PCI_VENDOR_ID_GIGABYTE) || 241125e992a4SHeiner Kallweit (pdev->subsystem_device != 0xe000)) 241225e992a4SHeiner Kallweit return; 241325e992a4SHeiner Kallweit 241425e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0001); 241525e992a4SHeiner Kallweit rtl_writephy(tp, 0x10, 0xf01b); 241625e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 241725e992a4SHeiner Kallweit } 241825e992a4SHeiner Kallweit 241925e992a4SHeiner Kallweit static void rtl8169scd_hw_phy_config(struct rtl8169_private *tp) 242025e992a4SHeiner Kallweit { 242125e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 242225e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 242325e992a4SHeiner Kallweit { 0x04, 0x0000 }, 242425e992a4SHeiner Kallweit { 0x03, 0x00a1 }, 242525e992a4SHeiner Kallweit { 0x02, 0x0008 }, 242625e992a4SHeiner Kallweit { 0x01, 0x0120 }, 242725e992a4SHeiner Kallweit { 0x00, 0x1000 }, 242825e992a4SHeiner Kallweit { 0x04, 0x0800 }, 242925e992a4SHeiner Kallweit { 0x04, 0x9000 }, 243025e992a4SHeiner Kallweit { 0x03, 0x802f }, 243125e992a4SHeiner Kallweit { 0x02, 0x4f02 }, 243225e992a4SHeiner Kallweit { 0x01, 0x0409 }, 243325e992a4SHeiner Kallweit { 0x00, 0xf099 }, 243425e992a4SHeiner Kallweit { 0x04, 0x9800 }, 243525e992a4SHeiner Kallweit { 0x04, 0xa000 }, 243625e992a4SHeiner Kallweit { 0x03, 0xdf01 }, 243725e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 243825e992a4SHeiner Kallweit { 0x01, 0xff95 }, 243925e992a4SHeiner Kallweit { 0x00, 0xba00 }, 244025e992a4SHeiner Kallweit { 0x04, 0xa800 }, 244125e992a4SHeiner Kallweit { 0x04, 0xf000 }, 244225e992a4SHeiner Kallweit { 0x03, 0xdf01 }, 244325e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 244425e992a4SHeiner Kallweit { 0x01, 0x101a }, 244525e992a4SHeiner Kallweit { 0x00, 0xa0ff }, 244625e992a4SHeiner Kallweit { 0x04, 0xf800 }, 244725e992a4SHeiner Kallweit { 0x04, 0x0000 }, 244825e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 244925e992a4SHeiner Kallweit 245025e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 245125e992a4SHeiner Kallweit { 0x10, 0xf41b }, 245225e992a4SHeiner Kallweit { 0x14, 0xfb54 }, 245325e992a4SHeiner Kallweit { 0x18, 0xf5c7 }, 245425e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 245525e992a4SHeiner Kallweit 245625e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 245725e992a4SHeiner Kallweit { 0x17, 0x0cc0 }, 245825e992a4SHeiner Kallweit { 0x1f, 0x0000 } 245925e992a4SHeiner Kallweit }; 246025e992a4SHeiner Kallweit 246125e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 246225e992a4SHeiner Kallweit 246325e992a4SHeiner Kallweit rtl8169scd_hw_phy_config_quirk(tp); 246425e992a4SHeiner Kallweit } 246525e992a4SHeiner Kallweit 246625e992a4SHeiner Kallweit static void rtl8169sce_hw_phy_config(struct rtl8169_private *tp) 246725e992a4SHeiner Kallweit { 246825e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 246925e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 247025e992a4SHeiner Kallweit { 0x04, 0x0000 }, 247125e992a4SHeiner Kallweit { 0x03, 0x00a1 }, 247225e992a4SHeiner Kallweit { 0x02, 0x0008 }, 247325e992a4SHeiner Kallweit { 0x01, 0x0120 }, 247425e992a4SHeiner Kallweit { 0x00, 0x1000 }, 247525e992a4SHeiner Kallweit { 0x04, 0x0800 }, 247625e992a4SHeiner Kallweit { 0x04, 0x9000 }, 247725e992a4SHeiner Kallweit { 0x03, 0x802f }, 247825e992a4SHeiner Kallweit { 0x02, 0x4f02 }, 247925e992a4SHeiner Kallweit { 0x01, 0x0409 }, 248025e992a4SHeiner Kallweit { 0x00, 0xf099 }, 248125e992a4SHeiner Kallweit { 0x04, 0x9800 }, 248225e992a4SHeiner Kallweit { 0x04, 0xa000 }, 248325e992a4SHeiner Kallweit { 0x03, 0xdf01 }, 248425e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 248525e992a4SHeiner Kallweit { 0x01, 0xff95 }, 248625e992a4SHeiner Kallweit { 0x00, 0xba00 }, 248725e992a4SHeiner Kallweit { 0x04, 0xa800 }, 248825e992a4SHeiner Kallweit { 0x04, 0xf000 }, 248925e992a4SHeiner Kallweit { 0x03, 0xdf01 }, 249025e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 249125e992a4SHeiner Kallweit { 0x01, 0x101a }, 249225e992a4SHeiner Kallweit { 0x00, 0xa0ff }, 249325e992a4SHeiner Kallweit { 0x04, 0xf800 }, 249425e992a4SHeiner Kallweit { 0x04, 0x0000 }, 249525e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 249625e992a4SHeiner Kallweit 249725e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 249825e992a4SHeiner Kallweit { 0x0b, 0x8480 }, 249925e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 250025e992a4SHeiner Kallweit 250125e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 250225e992a4SHeiner Kallweit { 0x18, 0x67c7 }, 250325e992a4SHeiner Kallweit { 0x04, 0x2000 }, 250425e992a4SHeiner Kallweit { 0x03, 0x002f }, 250525e992a4SHeiner Kallweit { 0x02, 0x4360 }, 250625e992a4SHeiner Kallweit { 0x01, 0x0109 }, 250725e992a4SHeiner Kallweit { 0x00, 0x3022 }, 250825e992a4SHeiner Kallweit { 0x04, 0x2800 }, 250925e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 251025e992a4SHeiner Kallweit 251125e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 251225e992a4SHeiner Kallweit { 0x17, 0x0cc0 }, 251325e992a4SHeiner Kallweit { 0x1f, 0x0000 } 251425e992a4SHeiner Kallweit }; 251525e992a4SHeiner Kallweit 251625e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 251725e992a4SHeiner Kallweit } 251825e992a4SHeiner Kallweit 251925e992a4SHeiner Kallweit static void rtl8168bb_hw_phy_config(struct rtl8169_private *tp) 252025e992a4SHeiner Kallweit { 252125e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 252225e992a4SHeiner Kallweit { 0x10, 0xf41b }, 252325e992a4SHeiner Kallweit { 0x1f, 0x0000 } 252425e992a4SHeiner Kallweit }; 252525e992a4SHeiner Kallweit 252625e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0001); 252725e992a4SHeiner Kallweit rtl_patchphy(tp, 0x16, 1 << 0); 252825e992a4SHeiner Kallweit 252925e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 253025e992a4SHeiner Kallweit } 253125e992a4SHeiner Kallweit 253225e992a4SHeiner Kallweit static void rtl8168bef_hw_phy_config(struct rtl8169_private *tp) 253325e992a4SHeiner Kallweit { 253425e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 253525e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 253625e992a4SHeiner Kallweit { 0x10, 0xf41b }, 253725e992a4SHeiner Kallweit { 0x1f, 0x0000 } 253825e992a4SHeiner Kallweit }; 253925e992a4SHeiner Kallweit 254025e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 254125e992a4SHeiner Kallweit } 254225e992a4SHeiner Kallweit 254325e992a4SHeiner Kallweit static void rtl8168cp_1_hw_phy_config(struct rtl8169_private *tp) 254425e992a4SHeiner Kallweit { 254525e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 254625e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 254725e992a4SHeiner Kallweit { 0x1d, 0x0f00 }, 254825e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 254925e992a4SHeiner Kallweit { 0x0c, 0x1ec8 }, 255025e992a4SHeiner Kallweit { 0x1f, 0x0000 } 255125e992a4SHeiner Kallweit }; 255225e992a4SHeiner Kallweit 255325e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 255425e992a4SHeiner Kallweit } 255525e992a4SHeiner Kallweit 255625e992a4SHeiner Kallweit static void rtl8168cp_2_hw_phy_config(struct rtl8169_private *tp) 255725e992a4SHeiner Kallweit { 255825e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 255925e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 256025e992a4SHeiner Kallweit { 0x1d, 0x3d98 }, 256125e992a4SHeiner Kallweit { 0x1f, 0x0000 } 256225e992a4SHeiner Kallweit }; 256325e992a4SHeiner Kallweit 256425e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 256525e992a4SHeiner Kallweit rtl_patchphy(tp, 0x14, 1 << 5); 256625e992a4SHeiner Kallweit rtl_patchphy(tp, 0x0d, 1 << 5); 256725e992a4SHeiner Kallweit 256825e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 256925e992a4SHeiner Kallweit } 257025e992a4SHeiner Kallweit 257125e992a4SHeiner Kallweit static void rtl8168c_1_hw_phy_config(struct rtl8169_private *tp) 257225e992a4SHeiner Kallweit { 257325e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 257425e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 257525e992a4SHeiner Kallweit { 0x12, 0x2300 }, 257625e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 257725e992a4SHeiner Kallweit { 0x00, 0x88d4 }, 257825e992a4SHeiner Kallweit { 0x01, 0x82b1 }, 257925e992a4SHeiner Kallweit { 0x03, 0x7002 }, 258025e992a4SHeiner Kallweit { 0x08, 0x9e30 }, 258125e992a4SHeiner Kallweit { 0x09, 0x01f0 }, 258225e992a4SHeiner Kallweit { 0x0a, 0x5500 }, 258325e992a4SHeiner Kallweit { 0x0c, 0x00c8 }, 258425e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 258525e992a4SHeiner Kallweit { 0x12, 0xc096 }, 258625e992a4SHeiner Kallweit { 0x16, 0x000a }, 258725e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 258825e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 258925e992a4SHeiner Kallweit { 0x09, 0x2000 }, 259025e992a4SHeiner Kallweit { 0x09, 0x0000 } 259125e992a4SHeiner Kallweit }; 259225e992a4SHeiner Kallweit 259325e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 259425e992a4SHeiner Kallweit 259525e992a4SHeiner Kallweit rtl_patchphy(tp, 0x14, 1 << 5); 259625e992a4SHeiner Kallweit rtl_patchphy(tp, 0x0d, 1 << 5); 259725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 259825e992a4SHeiner Kallweit } 259925e992a4SHeiner Kallweit 260025e992a4SHeiner Kallweit static void rtl8168c_2_hw_phy_config(struct rtl8169_private *tp) 260125e992a4SHeiner Kallweit { 260225e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 260325e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 260425e992a4SHeiner Kallweit { 0x12, 0x2300 }, 260525e992a4SHeiner Kallweit { 0x03, 0x802f }, 260625e992a4SHeiner Kallweit { 0x02, 0x4f02 }, 260725e992a4SHeiner Kallweit { 0x01, 0x0409 }, 260825e992a4SHeiner Kallweit { 0x00, 0xf099 }, 260925e992a4SHeiner Kallweit { 0x04, 0x9800 }, 261025e992a4SHeiner Kallweit { 0x04, 0x9000 }, 261125e992a4SHeiner Kallweit { 0x1d, 0x3d98 }, 261225e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 261325e992a4SHeiner Kallweit { 0x0c, 0x7eb8 }, 261425e992a4SHeiner Kallweit { 0x06, 0x0761 }, 261525e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 261625e992a4SHeiner Kallweit { 0x16, 0x0f0a }, 261725e992a4SHeiner Kallweit { 0x1f, 0x0000 } 261825e992a4SHeiner Kallweit }; 261925e992a4SHeiner Kallweit 262025e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 262125e992a4SHeiner Kallweit 262225e992a4SHeiner Kallweit rtl_patchphy(tp, 0x16, 1 << 0); 262325e992a4SHeiner Kallweit rtl_patchphy(tp, 0x14, 1 << 5); 262425e992a4SHeiner Kallweit rtl_patchphy(tp, 0x0d, 1 << 5); 262525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 262625e992a4SHeiner Kallweit } 262725e992a4SHeiner Kallweit 262825e992a4SHeiner Kallweit static void rtl8168c_3_hw_phy_config(struct rtl8169_private *tp) 262925e992a4SHeiner Kallweit { 263025e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 263125e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 263225e992a4SHeiner Kallweit { 0x12, 0x2300 }, 263325e992a4SHeiner Kallweit { 0x1d, 0x3d98 }, 263425e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 263525e992a4SHeiner Kallweit { 0x0c, 0x7eb8 }, 263625e992a4SHeiner Kallweit { 0x06, 0x5461 }, 263725e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 263825e992a4SHeiner Kallweit { 0x16, 0x0f0a }, 263925e992a4SHeiner Kallweit { 0x1f, 0x0000 } 264025e992a4SHeiner Kallweit }; 264125e992a4SHeiner Kallweit 264225e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 264325e992a4SHeiner Kallweit 264425e992a4SHeiner Kallweit rtl_patchphy(tp, 0x16, 1 << 0); 264525e992a4SHeiner Kallweit rtl_patchphy(tp, 0x14, 1 << 5); 264625e992a4SHeiner Kallweit rtl_patchphy(tp, 0x0d, 1 << 5); 264725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 264825e992a4SHeiner Kallweit } 264925e992a4SHeiner Kallweit 265025e992a4SHeiner Kallweit static void rtl8168c_4_hw_phy_config(struct rtl8169_private *tp) 265125e992a4SHeiner Kallweit { 265225e992a4SHeiner Kallweit rtl8168c_3_hw_phy_config(tp); 265325e992a4SHeiner Kallweit } 265425e992a4SHeiner Kallweit 265525e992a4SHeiner Kallweit static const struct phy_reg rtl8168d_1_phy_reg_init_0[] = { 265625e992a4SHeiner Kallweit /* Channel Estimation */ 265725e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 265825e992a4SHeiner Kallweit { 0x06, 0x4064 }, 265925e992a4SHeiner Kallweit { 0x07, 0x2863 }, 266025e992a4SHeiner Kallweit { 0x08, 0x059c }, 266125e992a4SHeiner Kallweit { 0x09, 0x26b4 }, 266225e992a4SHeiner Kallweit { 0x0a, 0x6a19 }, 266325e992a4SHeiner Kallweit { 0x0b, 0xdcc8 }, 266425e992a4SHeiner Kallweit { 0x10, 0xf06d }, 266525e992a4SHeiner Kallweit { 0x14, 0x7f68 }, 266625e992a4SHeiner Kallweit { 0x18, 0x7fd9 }, 266725e992a4SHeiner Kallweit { 0x1c, 0xf0ff }, 266825e992a4SHeiner Kallweit { 0x1d, 0x3d9c }, 266925e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 267025e992a4SHeiner Kallweit { 0x12, 0xf49f }, 267125e992a4SHeiner Kallweit { 0x13, 0x070b }, 267225e992a4SHeiner Kallweit { 0x1a, 0x05ad }, 267325e992a4SHeiner Kallweit { 0x14, 0x94c0 }, 267425e992a4SHeiner Kallweit 267525e992a4SHeiner Kallweit /* 267625e992a4SHeiner Kallweit * Tx Error Issue 267725e992a4SHeiner Kallweit * Enhance line driver power 267825e992a4SHeiner Kallweit */ 267925e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 268025e992a4SHeiner Kallweit { 0x06, 0x5561 }, 268125e992a4SHeiner Kallweit { 0x1f, 0x0005 }, 268225e992a4SHeiner Kallweit { 0x05, 0x8332 }, 268325e992a4SHeiner Kallweit { 0x06, 0x5561 }, 268425e992a4SHeiner Kallweit 268525e992a4SHeiner Kallweit /* 268625e992a4SHeiner Kallweit * Can not link to 1Gbps with bad cable 268725e992a4SHeiner Kallweit * Decrease SNR threshold form 21.07dB to 19.04dB 268825e992a4SHeiner Kallweit */ 268925e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 269025e992a4SHeiner Kallweit { 0x17, 0x0cc0 }, 269125e992a4SHeiner Kallweit 269225e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 269325e992a4SHeiner Kallweit { 0x0d, 0xf880 } 269425e992a4SHeiner Kallweit }; 269525e992a4SHeiner Kallweit 269625e992a4SHeiner Kallweit static const struct phy_reg rtl8168d_1_phy_reg_init_1[] = { 269725e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 269825e992a4SHeiner Kallweit { 0x05, 0x669a }, 269925e992a4SHeiner Kallweit { 0x1f, 0x0005 }, 270025e992a4SHeiner Kallweit { 0x05, 0x8330 }, 270125e992a4SHeiner Kallweit { 0x06, 0x669a }, 270225e992a4SHeiner Kallweit { 0x1f, 0x0002 } 270325e992a4SHeiner Kallweit }; 270425e992a4SHeiner Kallweit 270525e992a4SHeiner Kallweit static void rtl8168d_1_hw_phy_config(struct rtl8169_private *tp) 270625e992a4SHeiner Kallweit { 270725e992a4SHeiner Kallweit rtl_writephy_batch(tp, rtl8168d_1_phy_reg_init_0); 270825e992a4SHeiner Kallweit 270925e992a4SHeiner Kallweit /* 271025e992a4SHeiner Kallweit * Rx Error Issue 271125e992a4SHeiner Kallweit * Fine Tune Switching regulator parameter 271225e992a4SHeiner Kallweit */ 271325e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 271425e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x0b, 0x0010, 0x00ef); 271525e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x0c, 0xa200, 0x5d00); 271625e992a4SHeiner Kallweit 271725e992a4SHeiner Kallweit if (rtl8168d_efuse_read(tp, 0x01) == 0xb1) { 271825e992a4SHeiner Kallweit int val; 271925e992a4SHeiner Kallweit 272025e992a4SHeiner Kallweit rtl_writephy_batch(tp, rtl8168d_1_phy_reg_init_1); 272125e992a4SHeiner Kallweit 272225e992a4SHeiner Kallweit val = rtl_readphy(tp, 0x0d); 272325e992a4SHeiner Kallweit 272425e992a4SHeiner Kallweit if ((val & 0x00ff) != 0x006c) { 272525e992a4SHeiner Kallweit static const u32 set[] = { 272625e992a4SHeiner Kallweit 0x0065, 0x0066, 0x0067, 0x0068, 272725e992a4SHeiner Kallweit 0x0069, 0x006a, 0x006b, 0x006c 272825e992a4SHeiner Kallweit }; 272925e992a4SHeiner Kallweit int i; 273025e992a4SHeiner Kallweit 273125e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 273225e992a4SHeiner Kallweit 273325e992a4SHeiner Kallweit val &= 0xff00; 273425e992a4SHeiner Kallweit for (i = 0; i < ARRAY_SIZE(set); i++) 273525e992a4SHeiner Kallweit rtl_writephy(tp, 0x0d, val | set[i]); 273625e992a4SHeiner Kallweit } 273725e992a4SHeiner Kallweit } else { 273825e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 273925e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 274025e992a4SHeiner Kallweit { 0x05, 0x6662 }, 274125e992a4SHeiner Kallweit { 0x1f, 0x0005 }, 274225e992a4SHeiner Kallweit { 0x05, 0x8330 }, 274325e992a4SHeiner Kallweit { 0x06, 0x6662 } 274425e992a4SHeiner Kallweit }; 274525e992a4SHeiner Kallweit 274625e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 274725e992a4SHeiner Kallweit } 274825e992a4SHeiner Kallweit 274925e992a4SHeiner Kallweit /* RSET couple improve */ 275025e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 275125e992a4SHeiner Kallweit rtl_patchphy(tp, 0x0d, 0x0300); 275225e992a4SHeiner Kallweit rtl_patchphy(tp, 0x0f, 0x0010); 275325e992a4SHeiner Kallweit 275425e992a4SHeiner Kallweit /* Fine tune PLL performance */ 275525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 275625e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x02, 0x0100, 0x0600); 275725e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x03, 0x0000, 0xe000); 275825e992a4SHeiner Kallweit 275925e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0005); 276025e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x001b); 276125e992a4SHeiner Kallweit 276225e992a4SHeiner Kallweit rtl_apply_firmware_cond(tp, MII_EXPANSION, 0xbf00); 276325e992a4SHeiner Kallweit 276425e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 276525e992a4SHeiner Kallweit } 276625e992a4SHeiner Kallweit 276725e992a4SHeiner Kallweit static void rtl8168d_2_hw_phy_config(struct rtl8169_private *tp) 276825e992a4SHeiner Kallweit { 276925e992a4SHeiner Kallweit rtl_writephy_batch(tp, rtl8168d_1_phy_reg_init_0); 277025e992a4SHeiner Kallweit 277125e992a4SHeiner Kallweit if (rtl8168d_efuse_read(tp, 0x01) == 0xb1) { 277225e992a4SHeiner Kallweit int val; 277325e992a4SHeiner Kallweit 277425e992a4SHeiner Kallweit rtl_writephy_batch(tp, rtl8168d_1_phy_reg_init_1); 277525e992a4SHeiner Kallweit 277625e992a4SHeiner Kallweit val = rtl_readphy(tp, 0x0d); 277725e992a4SHeiner Kallweit if ((val & 0x00ff) != 0x006c) { 277825e992a4SHeiner Kallweit static const u32 set[] = { 277925e992a4SHeiner Kallweit 0x0065, 0x0066, 0x0067, 0x0068, 278025e992a4SHeiner Kallweit 0x0069, 0x006a, 0x006b, 0x006c 278125e992a4SHeiner Kallweit }; 278225e992a4SHeiner Kallweit int i; 278325e992a4SHeiner Kallweit 278425e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 278525e992a4SHeiner Kallweit 278625e992a4SHeiner Kallweit val &= 0xff00; 278725e992a4SHeiner Kallweit for (i = 0; i < ARRAY_SIZE(set); i++) 278825e992a4SHeiner Kallweit rtl_writephy(tp, 0x0d, val | set[i]); 278925e992a4SHeiner Kallweit } 279025e992a4SHeiner Kallweit } else { 279125e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 279225e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 279325e992a4SHeiner Kallweit { 0x05, 0x2642 }, 279425e992a4SHeiner Kallweit { 0x1f, 0x0005 }, 279525e992a4SHeiner Kallweit { 0x05, 0x8330 }, 279625e992a4SHeiner Kallweit { 0x06, 0x2642 } 279725e992a4SHeiner Kallweit }; 279825e992a4SHeiner Kallweit 279925e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 280025e992a4SHeiner Kallweit } 280125e992a4SHeiner Kallweit 280225e992a4SHeiner Kallweit /* Fine tune PLL performance */ 280325e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 280425e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x02, 0x0100, 0x0600); 280525e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x03, 0x0000, 0xe000); 280625e992a4SHeiner Kallweit 280725e992a4SHeiner Kallweit /* Switching regulator Slew rate */ 280825e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 280925e992a4SHeiner Kallweit rtl_patchphy(tp, 0x0f, 0x0017); 281025e992a4SHeiner Kallweit 281125e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0005); 281225e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x001b); 281325e992a4SHeiner Kallweit 281425e992a4SHeiner Kallweit rtl_apply_firmware_cond(tp, MII_EXPANSION, 0xb300); 281525e992a4SHeiner Kallweit 281625e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 281725e992a4SHeiner Kallweit } 281825e992a4SHeiner Kallweit 281925e992a4SHeiner Kallweit static void rtl8168d_3_hw_phy_config(struct rtl8169_private *tp) 282025e992a4SHeiner Kallweit { 282125e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 282225e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 282325e992a4SHeiner Kallweit { 0x10, 0x0008 }, 282425e992a4SHeiner Kallweit { 0x0d, 0x006c }, 282525e992a4SHeiner Kallweit 282625e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 282725e992a4SHeiner Kallweit { 0x0d, 0xf880 }, 282825e992a4SHeiner Kallweit 282925e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 283025e992a4SHeiner Kallweit { 0x17, 0x0cc0 }, 283125e992a4SHeiner Kallweit 283225e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 283325e992a4SHeiner Kallweit { 0x0b, 0xa4d8 }, 283425e992a4SHeiner Kallweit { 0x09, 0x281c }, 283525e992a4SHeiner Kallweit { 0x07, 0x2883 }, 283625e992a4SHeiner Kallweit { 0x0a, 0x6b35 }, 283725e992a4SHeiner Kallweit { 0x1d, 0x3da4 }, 283825e992a4SHeiner Kallweit { 0x1c, 0xeffd }, 283925e992a4SHeiner Kallweit { 0x14, 0x7f52 }, 284025e992a4SHeiner Kallweit { 0x18, 0x7fc6 }, 284125e992a4SHeiner Kallweit { 0x08, 0x0601 }, 284225e992a4SHeiner Kallweit { 0x06, 0x4063 }, 284325e992a4SHeiner Kallweit { 0x10, 0xf074 }, 284425e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 284525e992a4SHeiner Kallweit { 0x13, 0x0789 }, 284625e992a4SHeiner Kallweit { 0x12, 0xf4bd }, 284725e992a4SHeiner Kallweit { 0x1a, 0x04fd }, 284825e992a4SHeiner Kallweit { 0x14, 0x84b0 }, 284925e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 285025e992a4SHeiner Kallweit { 0x00, 0x9200 }, 285125e992a4SHeiner Kallweit 285225e992a4SHeiner Kallweit { 0x1f, 0x0005 }, 285325e992a4SHeiner Kallweit { 0x01, 0x0340 }, 285425e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 285525e992a4SHeiner Kallweit { 0x04, 0x4000 }, 285625e992a4SHeiner Kallweit { 0x03, 0x1d21 }, 285725e992a4SHeiner Kallweit { 0x02, 0x0c32 }, 285825e992a4SHeiner Kallweit { 0x01, 0x0200 }, 285925e992a4SHeiner Kallweit { 0x00, 0x5554 }, 286025e992a4SHeiner Kallweit { 0x04, 0x4800 }, 286125e992a4SHeiner Kallweit { 0x04, 0x4000 }, 286225e992a4SHeiner Kallweit { 0x04, 0xf000 }, 286325e992a4SHeiner Kallweit { 0x03, 0xdf01 }, 286425e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 286525e992a4SHeiner Kallweit { 0x01, 0x101a }, 286625e992a4SHeiner Kallweit { 0x00, 0xa0ff }, 286725e992a4SHeiner Kallweit { 0x04, 0xf800 }, 286825e992a4SHeiner Kallweit { 0x04, 0xf000 }, 286925e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 287025e992a4SHeiner Kallweit 287125e992a4SHeiner Kallweit { 0x1f, 0x0007 }, 287225e992a4SHeiner Kallweit { 0x1e, 0x0023 }, 287325e992a4SHeiner Kallweit { 0x16, 0x0000 }, 287425e992a4SHeiner Kallweit { 0x1f, 0x0000 } 287525e992a4SHeiner Kallweit }; 287625e992a4SHeiner Kallweit 287725e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 287825e992a4SHeiner Kallweit } 287925e992a4SHeiner Kallweit 288025e992a4SHeiner Kallweit static void rtl8168d_4_hw_phy_config(struct rtl8169_private *tp) 288125e992a4SHeiner Kallweit { 288225e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 288325e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 288425e992a4SHeiner Kallweit { 0x17, 0x0cc0 }, 288525e992a4SHeiner Kallweit 288625e992a4SHeiner Kallweit { 0x1f, 0x0007 }, 288725e992a4SHeiner Kallweit { 0x1e, 0x002d }, 288825e992a4SHeiner Kallweit { 0x18, 0x0040 }, 288925e992a4SHeiner Kallweit { 0x1f, 0x0000 } 289025e992a4SHeiner Kallweit }; 289125e992a4SHeiner Kallweit 289225e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 289325e992a4SHeiner Kallweit rtl_patchphy(tp, 0x0d, 1 << 5); 289425e992a4SHeiner Kallweit } 289525e992a4SHeiner Kallweit 289625e992a4SHeiner Kallweit static void rtl8168e_1_hw_phy_config(struct rtl8169_private *tp) 289725e992a4SHeiner Kallweit { 289825e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 289925e992a4SHeiner Kallweit /* Enable Delay cap */ 290025e992a4SHeiner Kallweit { 0x1f, 0x0005 }, 290125e992a4SHeiner Kallweit { 0x05, 0x8b80 }, 290225e992a4SHeiner Kallweit { 0x06, 0xc896 }, 290325e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 290425e992a4SHeiner Kallweit 290525e992a4SHeiner Kallweit /* Channel estimation fine tune */ 290625e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 290725e992a4SHeiner Kallweit { 0x0b, 0x6c20 }, 290825e992a4SHeiner Kallweit { 0x07, 0x2872 }, 290925e992a4SHeiner Kallweit { 0x1c, 0xefff }, 291025e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 291125e992a4SHeiner Kallweit { 0x14, 0x6420 }, 291225e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 291325e992a4SHeiner Kallweit 291425e992a4SHeiner Kallweit /* Update PFM & 10M TX idle timer */ 291525e992a4SHeiner Kallweit { 0x1f, 0x0007 }, 291625e992a4SHeiner Kallweit { 0x1e, 0x002f }, 291725e992a4SHeiner Kallweit { 0x15, 0x1919 }, 291825e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 291925e992a4SHeiner Kallweit 292025e992a4SHeiner Kallweit { 0x1f, 0x0007 }, 292125e992a4SHeiner Kallweit { 0x1e, 0x00ac }, 292225e992a4SHeiner Kallweit { 0x18, 0x0006 }, 292325e992a4SHeiner Kallweit { 0x1f, 0x0000 } 292425e992a4SHeiner Kallweit }; 292525e992a4SHeiner Kallweit 292625e992a4SHeiner Kallweit rtl_apply_firmware(tp); 292725e992a4SHeiner Kallweit 292825e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 292925e992a4SHeiner Kallweit 293025e992a4SHeiner Kallweit /* DCO enable for 10M IDLE Power */ 293125e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0007); 293225e992a4SHeiner Kallweit rtl_writephy(tp, 0x1e, 0x0023); 293325e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x17, 0x0006, 0x0000); 293425e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 293525e992a4SHeiner Kallweit 293625e992a4SHeiner Kallweit /* For impedance matching */ 293725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 293825e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x08, 0x8000, 0x7f00); 293925e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 294025e992a4SHeiner Kallweit 294125e992a4SHeiner Kallweit /* PHY auto speed down */ 294225e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0007); 294325e992a4SHeiner Kallweit rtl_writephy(tp, 0x1e, 0x002d); 294425e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x18, 0x0050, 0x0000); 294525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 294625e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x8000, 0x0000); 294725e992a4SHeiner Kallweit 294825e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0005); 294925e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x8b86); 295025e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x06, 0x0001, 0x0000); 295125e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 295225e992a4SHeiner Kallweit 295325e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0005); 295425e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x8b85); 295525e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x06, 0x0000, 0x2000); 295625e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0007); 295725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1e, 0x0020); 295825e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x15, 0x0000, 0x1100); 295925e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0006); 296025e992a4SHeiner Kallweit rtl_writephy(tp, 0x00, 0x5a00); 296125e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 296225e992a4SHeiner Kallweit rtl_writephy(tp, 0x0d, 0x0007); 296325e992a4SHeiner Kallweit rtl_writephy(tp, 0x0e, 0x003c); 296425e992a4SHeiner Kallweit rtl_writephy(tp, 0x0d, 0x4007); 296525e992a4SHeiner Kallweit rtl_writephy(tp, 0x0e, 0x0000); 296625e992a4SHeiner Kallweit rtl_writephy(tp, 0x0d, 0x0000); 296725e992a4SHeiner Kallweit } 296825e992a4SHeiner Kallweit 296925e992a4SHeiner Kallweit static void rtl_rar_exgmac_set(struct rtl8169_private *tp, u8 *addr) 297025e992a4SHeiner Kallweit { 297125e992a4SHeiner Kallweit const u16 w[] = { 297225e992a4SHeiner Kallweit addr[0] | (addr[1] << 8), 297325e992a4SHeiner Kallweit addr[2] | (addr[3] << 8), 297425e992a4SHeiner Kallweit addr[4] | (addr[5] << 8) 297525e992a4SHeiner Kallweit }; 297625e992a4SHeiner Kallweit 297725e992a4SHeiner Kallweit rtl_eri_write(tp, 0xe0, ERIAR_MASK_1111, w[0] | (w[1] << 16)); 297825e992a4SHeiner Kallweit rtl_eri_write(tp, 0xe4, ERIAR_MASK_1111, w[2]); 297925e992a4SHeiner Kallweit rtl_eri_write(tp, 0xf0, ERIAR_MASK_1111, w[0] << 16); 298025e992a4SHeiner Kallweit rtl_eri_write(tp, 0xf4, ERIAR_MASK_1111, w[1] | (w[2] << 16)); 298125e992a4SHeiner Kallweit } 298225e992a4SHeiner Kallweit 298325e992a4SHeiner Kallweit static void rtl8168e_2_hw_phy_config(struct rtl8169_private *tp) 298425e992a4SHeiner Kallweit { 298525e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 298625e992a4SHeiner Kallweit /* Enable Delay cap */ 298725e992a4SHeiner Kallweit { 0x1f, 0x0004 }, 298825e992a4SHeiner Kallweit { 0x1f, 0x0007 }, 298925e992a4SHeiner Kallweit { 0x1e, 0x00ac }, 299025e992a4SHeiner Kallweit { 0x18, 0x0006 }, 299125e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 299225e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 299325e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 299425e992a4SHeiner Kallweit 299525e992a4SHeiner Kallweit /* Channel estimation fine tune */ 299625e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 299725e992a4SHeiner Kallweit { 0x09, 0xa20f }, 299825e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 299925e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 300025e992a4SHeiner Kallweit 300125e992a4SHeiner Kallweit /* Green Setting */ 300225e992a4SHeiner Kallweit { 0x1f, 0x0005 }, 300325e992a4SHeiner Kallweit { 0x05, 0x8b5b }, 300425e992a4SHeiner Kallweit { 0x06, 0x9222 }, 300525e992a4SHeiner Kallweit { 0x05, 0x8b6d }, 300625e992a4SHeiner Kallweit { 0x06, 0x8000 }, 300725e992a4SHeiner Kallweit { 0x05, 0x8b76 }, 300825e992a4SHeiner Kallweit { 0x06, 0x8000 }, 300925e992a4SHeiner Kallweit { 0x1f, 0x0000 } 301025e992a4SHeiner Kallweit }; 301125e992a4SHeiner Kallweit 301225e992a4SHeiner Kallweit rtl_apply_firmware(tp); 301325e992a4SHeiner Kallweit 301425e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 301525e992a4SHeiner Kallweit 301625e992a4SHeiner Kallweit /* For 4-corner performance improve */ 301725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0005); 301825e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x8b80); 301925e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x17, 0x0006, 0x0000); 302025e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 302125e992a4SHeiner Kallweit 302225e992a4SHeiner Kallweit /* PHY auto speed down */ 302325e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0004); 302425e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0007); 302525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1e, 0x002d); 302625e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x18, 0x0010, 0x0000); 302725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 302825e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 302925e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x8000, 0x0000); 303025e992a4SHeiner Kallweit 303125e992a4SHeiner Kallweit /* improve 10M EEE waveform */ 303225e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0005); 303325e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x8b86); 303425e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x06, 0x0001, 0x0000); 303525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 303625e992a4SHeiner Kallweit 303725e992a4SHeiner Kallweit /* Improve 2-pair detection performance */ 303825e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0005); 303925e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x8b85); 304025e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x06, 0x4000, 0x0000); 304125e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 304225e992a4SHeiner Kallweit 304325e992a4SHeiner Kallweit rtl8168f_config_eee_phy(tp); 304425e992a4SHeiner Kallweit rtl_enable_eee(tp); 304525e992a4SHeiner Kallweit 304625e992a4SHeiner Kallweit /* Green feature */ 304725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0003); 304825e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x19, 0x0001, 0x0000); 304925e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x10, 0x0400, 0x0000); 305025e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 305125e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0005); 305225e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x01, 0x0100, 0x0000); 305325e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 305425e992a4SHeiner Kallweit 305525e992a4SHeiner Kallweit /* Broken BIOS workaround: feed GigaMAC registers with MAC address. */ 305625e992a4SHeiner Kallweit rtl_rar_exgmac_set(tp, tp->dev->dev_addr); 305725e992a4SHeiner Kallweit } 305825e992a4SHeiner Kallweit 305925e992a4SHeiner Kallweit static void rtl8168f_hw_phy_config(struct rtl8169_private *tp) 306025e992a4SHeiner Kallweit { 306125e992a4SHeiner Kallweit /* For 4-corner performance improve */ 306225e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0005); 306325e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x8b80); 306425e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x06, 0x0006, 0x0000); 306525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 306625e992a4SHeiner Kallweit 306725e992a4SHeiner Kallweit /* PHY auto speed down */ 306825e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0007); 306925e992a4SHeiner Kallweit rtl_writephy(tp, 0x1e, 0x002d); 307025e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x18, 0x0010, 0x0000); 307125e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 307225e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x8000, 0x0000); 307325e992a4SHeiner Kallweit 307425e992a4SHeiner Kallweit /* Improve 10M EEE waveform */ 307525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0005); 307625e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x8b86); 307725e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x06, 0x0001, 0x0000); 307825e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 307925e992a4SHeiner Kallweit 308025e992a4SHeiner Kallweit rtl8168f_config_eee_phy(tp); 308125e992a4SHeiner Kallweit rtl_enable_eee(tp); 308225e992a4SHeiner Kallweit } 308325e992a4SHeiner Kallweit 308425e992a4SHeiner Kallweit static void rtl8168f_1_hw_phy_config(struct rtl8169_private *tp) 308525e992a4SHeiner Kallweit { 308625e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 308725e992a4SHeiner Kallweit /* Channel estimation fine tune */ 308825e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 308925e992a4SHeiner Kallweit { 0x09, 0xa20f }, 309025e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 309125e992a4SHeiner Kallweit 309225e992a4SHeiner Kallweit /* Modify green table for giga & fnet */ 309325e992a4SHeiner Kallweit { 0x1f, 0x0005 }, 309425e992a4SHeiner Kallweit { 0x05, 0x8b55 }, 309525e992a4SHeiner Kallweit { 0x06, 0x0000 }, 309625e992a4SHeiner Kallweit { 0x05, 0x8b5e }, 309725e992a4SHeiner Kallweit { 0x06, 0x0000 }, 309825e992a4SHeiner Kallweit { 0x05, 0x8b67 }, 309925e992a4SHeiner Kallweit { 0x06, 0x0000 }, 310025e992a4SHeiner Kallweit { 0x05, 0x8b70 }, 310125e992a4SHeiner Kallweit { 0x06, 0x0000 }, 310225e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 310325e992a4SHeiner Kallweit { 0x1f, 0x0007 }, 310425e992a4SHeiner Kallweit { 0x1e, 0x0078 }, 310525e992a4SHeiner Kallweit { 0x17, 0x0000 }, 310625e992a4SHeiner Kallweit { 0x19, 0x00fb }, 310725e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 310825e992a4SHeiner Kallweit 310925e992a4SHeiner Kallweit /* Modify green table for 10M */ 311025e992a4SHeiner Kallweit { 0x1f, 0x0005 }, 311125e992a4SHeiner Kallweit { 0x05, 0x8b79 }, 311225e992a4SHeiner Kallweit { 0x06, 0xaa00 }, 311325e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 311425e992a4SHeiner Kallweit 311525e992a4SHeiner Kallweit /* Disable hiimpedance detection (RTCT) */ 311625e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 311725e992a4SHeiner Kallweit { 0x01, 0x328a }, 311825e992a4SHeiner Kallweit { 0x1f, 0x0000 } 311925e992a4SHeiner Kallweit }; 312025e992a4SHeiner Kallweit 312125e992a4SHeiner Kallweit rtl_apply_firmware(tp); 312225e992a4SHeiner Kallweit 312325e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 312425e992a4SHeiner Kallweit 312525e992a4SHeiner Kallweit rtl8168f_hw_phy_config(tp); 312625e992a4SHeiner Kallweit 312725e992a4SHeiner Kallweit /* Improve 2-pair detection performance */ 312825e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0005); 312925e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x8b85); 313025e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x06, 0x4000, 0x0000); 313125e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 313225e992a4SHeiner Kallweit } 313325e992a4SHeiner Kallweit 313425e992a4SHeiner Kallweit static void rtl8168f_2_hw_phy_config(struct rtl8169_private *tp) 313525e992a4SHeiner Kallweit { 313625e992a4SHeiner Kallweit rtl_apply_firmware(tp); 313725e992a4SHeiner Kallweit 313825e992a4SHeiner Kallweit rtl8168f_hw_phy_config(tp); 313925e992a4SHeiner Kallweit } 314025e992a4SHeiner Kallweit 314125e992a4SHeiner Kallweit static void rtl8411_hw_phy_config(struct rtl8169_private *tp) 314225e992a4SHeiner Kallweit { 314325e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 314425e992a4SHeiner Kallweit /* Channel estimation fine tune */ 314525e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 314625e992a4SHeiner Kallweit { 0x09, 0xa20f }, 314725e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 314825e992a4SHeiner Kallweit 314925e992a4SHeiner Kallweit /* Modify green table for giga & fnet */ 315025e992a4SHeiner Kallweit { 0x1f, 0x0005 }, 315125e992a4SHeiner Kallweit { 0x05, 0x8b55 }, 315225e992a4SHeiner Kallweit { 0x06, 0x0000 }, 315325e992a4SHeiner Kallweit { 0x05, 0x8b5e }, 315425e992a4SHeiner Kallweit { 0x06, 0x0000 }, 315525e992a4SHeiner Kallweit { 0x05, 0x8b67 }, 315625e992a4SHeiner Kallweit { 0x06, 0x0000 }, 315725e992a4SHeiner Kallweit { 0x05, 0x8b70 }, 315825e992a4SHeiner Kallweit { 0x06, 0x0000 }, 315925e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 316025e992a4SHeiner Kallweit { 0x1f, 0x0007 }, 316125e992a4SHeiner Kallweit { 0x1e, 0x0078 }, 316225e992a4SHeiner Kallweit { 0x17, 0x0000 }, 316325e992a4SHeiner Kallweit { 0x19, 0x00aa }, 316425e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 316525e992a4SHeiner Kallweit 316625e992a4SHeiner Kallweit /* Modify green table for 10M */ 316725e992a4SHeiner Kallweit { 0x1f, 0x0005 }, 316825e992a4SHeiner Kallweit { 0x05, 0x8b79 }, 316925e992a4SHeiner Kallweit { 0x06, 0xaa00 }, 317025e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 317125e992a4SHeiner Kallweit 317225e992a4SHeiner Kallweit /* Disable hiimpedance detection (RTCT) */ 317325e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 317425e992a4SHeiner Kallweit { 0x01, 0x328a }, 317525e992a4SHeiner Kallweit { 0x1f, 0x0000 } 317625e992a4SHeiner Kallweit }; 317725e992a4SHeiner Kallweit 317825e992a4SHeiner Kallweit 317925e992a4SHeiner Kallweit rtl_apply_firmware(tp); 318025e992a4SHeiner Kallweit 318125e992a4SHeiner Kallweit rtl8168f_hw_phy_config(tp); 318225e992a4SHeiner Kallweit 318325e992a4SHeiner Kallweit /* Improve 2-pair detection performance */ 318425e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0005); 318525e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x8b85); 318625e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x06, 0x4000, 0x0000); 318725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 318825e992a4SHeiner Kallweit 318925e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 319025e992a4SHeiner Kallweit 319125e992a4SHeiner Kallweit /* Modify green table for giga */ 319225e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0005); 319325e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x8b54); 319425e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x06, 0x0000, 0x0800); 319525e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x8b5d); 319625e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x06, 0x0000, 0x0800); 319725e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x8a7c); 319825e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x06, 0x0000, 0x0100); 319925e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x8a7f); 320025e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x06, 0x0100, 0x0000); 320125e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x8a82); 320225e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x06, 0x0000, 0x0100); 320325e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x8a85); 320425e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x06, 0x0000, 0x0100); 320525e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x8a88); 320625e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x06, 0x0000, 0x0100); 320725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 320825e992a4SHeiner Kallweit 320925e992a4SHeiner Kallweit /* uc same-seed solution */ 321025e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0005); 321125e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x8b85); 321225e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x06, 0x8000, 0x0000); 321325e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 321425e992a4SHeiner Kallweit 321525e992a4SHeiner Kallweit /* Green feature */ 321625e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0003); 321725e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x19, 0x0000, 0x0001); 321825e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x10, 0x0000, 0x0400); 321925e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 322025e992a4SHeiner Kallweit } 322125e992a4SHeiner Kallweit 322225e992a4SHeiner Kallweit static void rtl8168g_disable_aldps(struct rtl8169_private *tp) 322325e992a4SHeiner Kallweit { 322425e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0a43, 0x10, BIT(2), 0); 322525e992a4SHeiner Kallweit } 322625e992a4SHeiner Kallweit 322725e992a4SHeiner Kallweit static void rtl8168g_phy_adjust_10m_aldps(struct rtl8169_private *tp) 322825e992a4SHeiner Kallweit { 322925e992a4SHeiner Kallweit struct phy_device *phydev = tp->phydev; 323025e992a4SHeiner Kallweit 323125e992a4SHeiner Kallweit phy_modify_paged(phydev, 0x0bcc, 0x14, BIT(8), 0); 323225e992a4SHeiner Kallweit phy_modify_paged(phydev, 0x0a44, 0x11, 0, BIT(7) | BIT(6)); 323325e992a4SHeiner Kallweit phy_write(phydev, 0x1f, 0x0a43); 323425e992a4SHeiner Kallweit phy_write(phydev, 0x13, 0x8084); 323525e992a4SHeiner Kallweit phy_clear_bits(phydev, 0x14, BIT(14) | BIT(13)); 323625e992a4SHeiner Kallweit phy_set_bits(phydev, 0x10, BIT(12) | BIT(1) | BIT(0)); 323725e992a4SHeiner Kallweit 323825e992a4SHeiner Kallweit phy_write(phydev, 0x1f, 0x0000); 323925e992a4SHeiner Kallweit } 324025e992a4SHeiner Kallweit 324125e992a4SHeiner Kallweit static void rtl8168g_1_hw_phy_config(struct rtl8169_private *tp) 324225e992a4SHeiner Kallweit { 324325e992a4SHeiner Kallweit int ret; 324425e992a4SHeiner Kallweit 324525e992a4SHeiner Kallweit rtl_apply_firmware(tp); 324625e992a4SHeiner Kallweit 324725e992a4SHeiner Kallweit ret = phy_read_paged(tp->phydev, 0x0a46, 0x10); 324825e992a4SHeiner Kallweit if (ret & BIT(8)) 324925e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0bcc, 0x12, BIT(15), 0); 325025e992a4SHeiner Kallweit else 325125e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0bcc, 0x12, 0, BIT(15)); 325225e992a4SHeiner Kallweit 325325e992a4SHeiner Kallweit ret = phy_read_paged(tp->phydev, 0x0a46, 0x13); 325425e992a4SHeiner Kallweit if (ret & BIT(8)) 325525e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0c41, 0x12, 0, BIT(1)); 325625e992a4SHeiner Kallweit else 325725e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0c41, 0x12, BIT(1), 0); 325825e992a4SHeiner Kallweit 325925e992a4SHeiner Kallweit /* Enable PHY auto speed down */ 326025e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0a44, 0x11, 0, BIT(3) | BIT(2)); 326125e992a4SHeiner Kallweit 326225e992a4SHeiner Kallweit rtl8168g_phy_adjust_10m_aldps(tp); 326325e992a4SHeiner Kallweit 326425e992a4SHeiner Kallweit /* EEE auto-fallback function */ 326525e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0a4b, 0x11, 0, BIT(2)); 326625e992a4SHeiner Kallweit 326725e992a4SHeiner Kallweit /* Enable UC LPF tune function */ 326825e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0a43); 326925e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x8012); 327025e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x8000, 0x0000); 327125e992a4SHeiner Kallweit 327225e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0c42, 0x11, BIT(13), BIT(14)); 327325e992a4SHeiner Kallweit 327425e992a4SHeiner Kallweit /* Improve SWR Efficiency */ 327525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0bcd); 327625e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x5065); 327725e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0xd065); 327825e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0bc8); 327925e992a4SHeiner Kallweit rtl_writephy(tp, 0x11, 0x5655); 328025e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0bcd); 328125e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x1065); 328225e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x9065); 328325e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x1065); 328425e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 328525e992a4SHeiner Kallweit 328625e992a4SHeiner Kallweit rtl8168g_disable_aldps(tp); 328725e992a4SHeiner Kallweit rtl8168g_config_eee_phy(tp); 328825e992a4SHeiner Kallweit rtl_enable_eee(tp); 328925e992a4SHeiner Kallweit } 329025e992a4SHeiner Kallweit 329125e992a4SHeiner Kallweit static void rtl8168g_2_hw_phy_config(struct rtl8169_private *tp) 329225e992a4SHeiner Kallweit { 329325e992a4SHeiner Kallweit rtl_apply_firmware(tp); 329425e992a4SHeiner Kallweit rtl8168g_config_eee_phy(tp); 329525e992a4SHeiner Kallweit rtl_enable_eee(tp); 329625e992a4SHeiner Kallweit } 329725e992a4SHeiner Kallweit 329825e992a4SHeiner Kallweit static void rtl8168h_1_hw_phy_config(struct rtl8169_private *tp) 329925e992a4SHeiner Kallweit { 330025e992a4SHeiner Kallweit u16 dout_tapbin; 330125e992a4SHeiner Kallweit u32 data; 330225e992a4SHeiner Kallweit 330325e992a4SHeiner Kallweit rtl_apply_firmware(tp); 330425e992a4SHeiner Kallweit 330525e992a4SHeiner Kallweit /* CHN EST parameters adjust - giga master */ 330625e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0a43); 330725e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x809b); 330825e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x8000, 0xf800); 330925e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x80a2); 331025e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x8000, 0xff00); 331125e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x80a4); 331225e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x8500, 0xff00); 331325e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x809c); 331425e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0xbd00, 0xff00); 331525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 331625e992a4SHeiner Kallweit 331725e992a4SHeiner Kallweit /* CHN EST parameters adjust - giga slave */ 331825e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0a43); 331925e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x80ad); 332025e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x7000, 0xf800); 332125e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x80b4); 332225e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x5000, 0xff00); 332325e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x80ac); 332425e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x4000, 0xff00); 332525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 332625e992a4SHeiner Kallweit 332725e992a4SHeiner Kallweit /* CHN EST parameters adjust - fnet */ 332825e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0a43); 332925e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x808e); 333025e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x1200, 0xff00); 333125e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x8090); 333225e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0xe500, 0xff00); 333325e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x8092); 333425e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x9f00, 0xff00); 333525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 333625e992a4SHeiner Kallweit 333725e992a4SHeiner Kallweit /* enable R-tune & PGA-retune function */ 333825e992a4SHeiner Kallweit dout_tapbin = 0; 333925e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0a46); 334025e992a4SHeiner Kallweit data = rtl_readphy(tp, 0x13); 334125e992a4SHeiner Kallweit data &= 3; 334225e992a4SHeiner Kallweit data <<= 2; 334325e992a4SHeiner Kallweit dout_tapbin |= data; 334425e992a4SHeiner Kallweit data = rtl_readphy(tp, 0x12); 334525e992a4SHeiner Kallweit data &= 0xc000; 334625e992a4SHeiner Kallweit data >>= 14; 334725e992a4SHeiner Kallweit dout_tapbin |= data; 334825e992a4SHeiner Kallweit dout_tapbin = ~(dout_tapbin^0x08); 334925e992a4SHeiner Kallweit dout_tapbin <<= 12; 335025e992a4SHeiner Kallweit dout_tapbin &= 0xf000; 335125e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0a43); 335225e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x827a); 335325e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, dout_tapbin, 0xf000); 335425e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x827b); 335525e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, dout_tapbin, 0xf000); 335625e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x827c); 335725e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, dout_tapbin, 0xf000); 335825e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x827d); 335925e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, dout_tapbin, 0xf000); 336025e992a4SHeiner Kallweit 336125e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0a43); 336225e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x0811); 336325e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x0800, 0x0000); 336425e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0a42); 336525e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x16, 0x0002, 0x0000); 336625e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 336725e992a4SHeiner Kallweit 336825e992a4SHeiner Kallweit /* enable GPHY 10M */ 336925e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0a44, 0x11, 0, BIT(11)); 337025e992a4SHeiner Kallweit 337125e992a4SHeiner Kallweit /* SAR ADC performance */ 337225e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0bca, 0x17, BIT(12) | BIT(13), BIT(14)); 337325e992a4SHeiner Kallweit 337425e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0a43); 337525e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x803f); 337625e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x0000, 0x3000); 337725e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x8047); 337825e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x0000, 0x3000); 337925e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x804f); 338025e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x0000, 0x3000); 338125e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x8057); 338225e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x0000, 0x3000); 338325e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x805f); 338425e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x0000, 0x3000); 338525e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x8067); 338625e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x0000, 0x3000); 338725e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x806f); 338825e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x0000, 0x3000); 338925e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 339025e992a4SHeiner Kallweit 339125e992a4SHeiner Kallweit /* disable phy pfm mode */ 339225e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0a44, 0x11, BIT(7), 0); 339325e992a4SHeiner Kallweit 339425e992a4SHeiner Kallweit rtl8168g_disable_aldps(tp); 339525e992a4SHeiner Kallweit rtl8168g_config_eee_phy(tp); 339625e992a4SHeiner Kallweit rtl_enable_eee(tp); 339725e992a4SHeiner Kallweit } 339825e992a4SHeiner Kallweit 339925e992a4SHeiner Kallweit static void rtl8168h_2_hw_phy_config(struct rtl8169_private *tp) 340025e992a4SHeiner Kallweit { 340125e992a4SHeiner Kallweit u16 ioffset_p3, ioffset_p2, ioffset_p1, ioffset_p0; 340225e992a4SHeiner Kallweit u16 rlen; 340325e992a4SHeiner Kallweit u32 data; 340425e992a4SHeiner Kallweit 340525e992a4SHeiner Kallweit rtl_apply_firmware(tp); 340625e992a4SHeiner Kallweit 340725e992a4SHeiner Kallweit /* CHIN EST parameter update */ 340825e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0a43); 340925e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x808a); 341025e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x000a, 0x003f); 341125e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 341225e992a4SHeiner Kallweit 341325e992a4SHeiner Kallweit /* enable R-tune & PGA-retune function */ 341425e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0a43); 341525e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x0811); 341625e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x0800, 0x0000); 341725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0a42); 341825e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x16, 0x0002, 0x0000); 341925e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 342025e992a4SHeiner Kallweit 342125e992a4SHeiner Kallweit /* enable GPHY 10M */ 342225e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0a44, 0x11, 0, BIT(11)); 342325e992a4SHeiner Kallweit 342425e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xdd02, 0x807d); 342525e992a4SHeiner Kallweit data = r8168_mac_ocp_read(tp, 0xdd02); 342625e992a4SHeiner Kallweit ioffset_p3 = ((data & 0x80)>>7); 342725e992a4SHeiner Kallweit ioffset_p3 <<= 3; 342825e992a4SHeiner Kallweit 342925e992a4SHeiner Kallweit data = r8168_mac_ocp_read(tp, 0xdd00); 343025e992a4SHeiner Kallweit ioffset_p3 |= ((data & (0xe000))>>13); 343125e992a4SHeiner Kallweit ioffset_p2 = ((data & (0x1e00))>>9); 343225e992a4SHeiner Kallweit ioffset_p1 = ((data & (0x01e0))>>5); 343325e992a4SHeiner Kallweit ioffset_p0 = ((data & 0x0010)>>4); 343425e992a4SHeiner Kallweit ioffset_p0 <<= 3; 343525e992a4SHeiner Kallweit ioffset_p0 |= (data & (0x07)); 343625e992a4SHeiner Kallweit data = (ioffset_p3<<12)|(ioffset_p2<<8)|(ioffset_p1<<4)|(ioffset_p0); 343725e992a4SHeiner Kallweit 343825e992a4SHeiner Kallweit if ((ioffset_p3 != 0x0f) || (ioffset_p2 != 0x0f) || 343925e992a4SHeiner Kallweit (ioffset_p1 != 0x0f) || (ioffset_p0 != 0x0f)) { 344025e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0bcf); 344125e992a4SHeiner Kallweit rtl_writephy(tp, 0x16, data); 344225e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 344325e992a4SHeiner Kallweit } 344425e992a4SHeiner Kallweit 344525e992a4SHeiner Kallweit /* Modify rlen (TX LPF corner frequency) level */ 344625e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0bcd); 344725e992a4SHeiner Kallweit data = rtl_readphy(tp, 0x16); 344825e992a4SHeiner Kallweit data &= 0x000f; 344925e992a4SHeiner Kallweit rlen = 0; 345025e992a4SHeiner Kallweit if (data > 3) 345125e992a4SHeiner Kallweit rlen = data - 3; 345225e992a4SHeiner Kallweit data = rlen | (rlen<<4) | (rlen<<8) | (rlen<<12); 345325e992a4SHeiner Kallweit rtl_writephy(tp, 0x17, data); 345425e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0bcd); 345525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 345625e992a4SHeiner Kallweit 345725e992a4SHeiner Kallweit /* disable phy pfm mode */ 345825e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0a44, 0x11, BIT(7), 0); 345925e992a4SHeiner Kallweit 346025e992a4SHeiner Kallweit rtl8168g_disable_aldps(tp); 346125e992a4SHeiner Kallweit rtl8168g_config_eee_phy(tp); 346225e992a4SHeiner Kallweit rtl_enable_eee(tp); 346325e992a4SHeiner Kallweit } 346425e992a4SHeiner Kallweit 346525e992a4SHeiner Kallweit static void rtl8168ep_1_hw_phy_config(struct rtl8169_private *tp) 346625e992a4SHeiner Kallweit { 346725e992a4SHeiner Kallweit /* Enable PHY auto speed down */ 346825e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0a44, 0x11, 0, BIT(3) | BIT(2)); 346925e992a4SHeiner Kallweit 347025e992a4SHeiner Kallweit rtl8168g_phy_adjust_10m_aldps(tp); 347125e992a4SHeiner Kallweit 347225e992a4SHeiner Kallweit /* Enable EEE auto-fallback function */ 347325e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0a4b, 0x11, 0, BIT(2)); 347425e992a4SHeiner Kallweit 347525e992a4SHeiner Kallweit /* Enable UC LPF tune function */ 347625e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0a43); 347725e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x8012); 347825e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x8000, 0x0000); 347925e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 348025e992a4SHeiner Kallweit 348125e992a4SHeiner Kallweit /* set rg_sel_sdm_rate */ 348225e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0c42, 0x11, BIT(13), BIT(14)); 348325e992a4SHeiner Kallweit 348425e992a4SHeiner Kallweit rtl8168g_disable_aldps(tp); 348525e992a4SHeiner Kallweit rtl8168g_config_eee_phy(tp); 348625e992a4SHeiner Kallweit rtl_enable_eee(tp); 348725e992a4SHeiner Kallweit } 348825e992a4SHeiner Kallweit 348925e992a4SHeiner Kallweit static void rtl8168ep_2_hw_phy_config(struct rtl8169_private *tp) 349025e992a4SHeiner Kallweit { 349125e992a4SHeiner Kallweit rtl8168g_phy_adjust_10m_aldps(tp); 349225e992a4SHeiner Kallweit 349325e992a4SHeiner Kallweit /* Enable UC LPF tune function */ 349425e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0a43); 349525e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x8012); 349625e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x8000, 0x0000); 349725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 349825e992a4SHeiner Kallweit 349925e992a4SHeiner Kallweit /* Set rg_sel_sdm_rate */ 350025e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0c42, 0x11, BIT(13), BIT(14)); 350125e992a4SHeiner Kallweit 350225e992a4SHeiner Kallweit /* Channel estimation parameters */ 350325e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0a43); 350425e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x80f3); 350525e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x8b00, ~0x8bff); 350625e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x80f0); 350725e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x3a00, ~0x3aff); 350825e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x80ef); 350925e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x0500, ~0x05ff); 351025e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x80f6); 351125e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x6e00, ~0x6eff); 351225e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x80ec); 351325e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x6800, ~0x68ff); 351425e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x80ed); 351525e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x7c00, ~0x7cff); 351625e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x80f2); 351725e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0xf400, ~0xf4ff); 351825e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x80f4); 351925e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x8500, ~0x85ff); 352025e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0a43); 352125e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x8110); 352225e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0xa800, ~0xa8ff); 352325e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x810f); 352425e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x1d00, ~0x1dff); 352525e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x8111); 352625e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0xf500, ~0xf5ff); 352725e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x8113); 352825e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x6100, ~0x61ff); 352925e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x8115); 353025e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x9200, ~0x92ff); 353125e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x810e); 353225e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x0400, ~0x04ff); 353325e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x810c); 353425e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x7c00, ~0x7cff); 353525e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x810b); 353625e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x5a00, ~0x5aff); 353725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0a43); 353825e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x80d1); 353925e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0xff00, ~0xffff); 354025e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x80cd); 354125e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x9e00, ~0x9eff); 354225e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x80d3); 354325e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x0e00, ~0x0eff); 354425e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x80d5); 354525e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0xca00, ~0xcaff); 354625e992a4SHeiner Kallweit rtl_writephy(tp, 0x13, 0x80d7); 354725e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x14, 0x8400, ~0x84ff); 354825e992a4SHeiner Kallweit 354925e992a4SHeiner Kallweit /* Force PWM-mode */ 355025e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0bcd); 355125e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x5065); 355225e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0xd065); 355325e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0bc8); 355425e992a4SHeiner Kallweit rtl_writephy(tp, 0x12, 0x00ed); 355525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0bcd); 355625e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x1065); 355725e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x9065); 355825e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x1065); 355925e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 356025e992a4SHeiner Kallweit 356125e992a4SHeiner Kallweit rtl8168g_disable_aldps(tp); 356225e992a4SHeiner Kallweit rtl8168g_config_eee_phy(tp); 356325e992a4SHeiner Kallweit rtl_enable_eee(tp); 356425e992a4SHeiner Kallweit } 356525e992a4SHeiner Kallweit 356625e992a4SHeiner Kallweit static void rtl8102e_hw_phy_config(struct rtl8169_private *tp) 356725e992a4SHeiner Kallweit { 356825e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 356925e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 357025e992a4SHeiner Kallweit { 0x08, 0x441d }, 357125e992a4SHeiner Kallweit { 0x01, 0x9100 }, 357225e992a4SHeiner Kallweit { 0x1f, 0x0000 } 357325e992a4SHeiner Kallweit }; 357425e992a4SHeiner Kallweit 357525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 357625e992a4SHeiner Kallweit rtl_patchphy(tp, 0x11, 1 << 12); 357725e992a4SHeiner Kallweit rtl_patchphy(tp, 0x19, 1 << 13); 357825e992a4SHeiner Kallweit rtl_patchphy(tp, 0x10, 1 << 15); 357925e992a4SHeiner Kallweit 358025e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 358125e992a4SHeiner Kallweit } 358225e992a4SHeiner Kallweit 358325e992a4SHeiner Kallweit static void rtl8105e_hw_phy_config(struct rtl8169_private *tp) 358425e992a4SHeiner Kallweit { 358525e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 358625e992a4SHeiner Kallweit { 0x1f, 0x0005 }, 358725e992a4SHeiner Kallweit { 0x1a, 0x0000 }, 358825e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 358925e992a4SHeiner Kallweit 359025e992a4SHeiner Kallweit { 0x1f, 0x0004 }, 359125e992a4SHeiner Kallweit { 0x1c, 0x0000 }, 359225e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 359325e992a4SHeiner Kallweit 359425e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 359525e992a4SHeiner Kallweit { 0x15, 0x7701 }, 359625e992a4SHeiner Kallweit { 0x1f, 0x0000 } 359725e992a4SHeiner Kallweit }; 359825e992a4SHeiner Kallweit 359925e992a4SHeiner Kallweit /* Disable ALDPS before ram code */ 360025e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 360125e992a4SHeiner Kallweit rtl_writephy(tp, 0x18, 0x0310); 360225e992a4SHeiner Kallweit msleep(100); 360325e992a4SHeiner Kallweit 360425e992a4SHeiner Kallweit rtl_apply_firmware(tp); 360525e992a4SHeiner Kallweit 360625e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 360725e992a4SHeiner Kallweit } 360825e992a4SHeiner Kallweit 360925e992a4SHeiner Kallweit static void rtl8402_hw_phy_config(struct rtl8169_private *tp) 361025e992a4SHeiner Kallweit { 361125e992a4SHeiner Kallweit /* Disable ALDPS before setting firmware */ 361225e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 361325e992a4SHeiner Kallweit rtl_writephy(tp, 0x18, 0x0310); 361425e992a4SHeiner Kallweit msleep(20); 361525e992a4SHeiner Kallweit 361625e992a4SHeiner Kallweit rtl_apply_firmware(tp); 361725e992a4SHeiner Kallweit 361825e992a4SHeiner Kallweit /* EEE setting */ 361925e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1b0, ERIAR_MASK_0011, 0x0000); 362025e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0004); 362125e992a4SHeiner Kallweit rtl_writephy(tp, 0x10, 0x401f); 362225e992a4SHeiner Kallweit rtl_writephy(tp, 0x19, 0x7030); 362325e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 362425e992a4SHeiner Kallweit } 362525e992a4SHeiner Kallweit 362625e992a4SHeiner Kallweit static void rtl8106e_hw_phy_config(struct rtl8169_private *tp) 362725e992a4SHeiner Kallweit { 362825e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 362925e992a4SHeiner Kallweit { 0x1f, 0x0004 }, 363025e992a4SHeiner Kallweit { 0x10, 0xc07f }, 363125e992a4SHeiner Kallweit { 0x19, 0x7030 }, 363225e992a4SHeiner Kallweit { 0x1f, 0x0000 } 363325e992a4SHeiner Kallweit }; 363425e992a4SHeiner Kallweit 363525e992a4SHeiner Kallweit /* Disable ALDPS before ram code */ 363625e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 363725e992a4SHeiner Kallweit rtl_writephy(tp, 0x18, 0x0310); 363825e992a4SHeiner Kallweit msleep(100); 363925e992a4SHeiner Kallweit 364025e992a4SHeiner Kallweit rtl_apply_firmware(tp); 364125e992a4SHeiner Kallweit 364225e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1b0, ERIAR_MASK_0011, 0x0000); 364325e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 364425e992a4SHeiner Kallweit 364525e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1d0, ERIAR_MASK_0011, 0x0000); 364625e992a4SHeiner Kallweit } 364725e992a4SHeiner Kallweit 364825e992a4SHeiner Kallweit static void rtl_hw_phy_config(struct net_device *dev) 364925e992a4SHeiner Kallweit { 365025e992a4SHeiner Kallweit static const rtl_generic_fct phy_configs[] = { 365125e992a4SHeiner Kallweit /* PCI devices. */ 365225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_02] = rtl8169s_hw_phy_config, 365325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_03] = rtl8169s_hw_phy_config, 365425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_04] = rtl8169sb_hw_phy_config, 365525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_05] = rtl8169scd_hw_phy_config, 365625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_06] = rtl8169sce_hw_phy_config, 365725e992a4SHeiner Kallweit /* PCI-E devices. */ 365825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_07] = rtl8102e_hw_phy_config, 365925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_08] = rtl8102e_hw_phy_config, 366025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_09] = rtl8102e_hw_phy_config, 366125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_10] = NULL, 366225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_11] = rtl8168bb_hw_phy_config, 366325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_12] = rtl8168bef_hw_phy_config, 366425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_13] = NULL, 366525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_14] = NULL, 366625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_15] = NULL, 366725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_16] = NULL, 366825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_17] = rtl8168bef_hw_phy_config, 366925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_18] = rtl8168cp_1_hw_phy_config, 367025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_19] = rtl8168c_1_hw_phy_config, 367125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_20] = rtl8168c_2_hw_phy_config, 367225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_21] = rtl8168c_3_hw_phy_config, 367325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_22] = rtl8168c_4_hw_phy_config, 367425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_23] = rtl8168cp_2_hw_phy_config, 367525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_24] = rtl8168cp_2_hw_phy_config, 367625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_25] = rtl8168d_1_hw_phy_config, 367725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_26] = rtl8168d_2_hw_phy_config, 367825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_27] = rtl8168d_3_hw_phy_config, 367925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_28] = rtl8168d_4_hw_phy_config, 368025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_29] = rtl8105e_hw_phy_config, 368125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_30] = rtl8105e_hw_phy_config, 368225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_31] = NULL, 368325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_32] = rtl8168e_1_hw_phy_config, 368425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_33] = rtl8168e_1_hw_phy_config, 368525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_34] = rtl8168e_2_hw_phy_config, 368625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_35] = rtl8168f_1_hw_phy_config, 368725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_36] = rtl8168f_2_hw_phy_config, 368825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_37] = rtl8402_hw_phy_config, 368925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_38] = rtl8411_hw_phy_config, 369025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_39] = rtl8106e_hw_phy_config, 369125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_40] = rtl8168g_1_hw_phy_config, 369225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_41] = NULL, 369325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_42] = rtl8168g_2_hw_phy_config, 369425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_43] = rtl8168g_2_hw_phy_config, 369525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_44] = rtl8168g_2_hw_phy_config, 369625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_45] = rtl8168h_1_hw_phy_config, 369725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_46] = rtl8168h_2_hw_phy_config, 369825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_47] = rtl8168h_1_hw_phy_config, 369925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_48] = rtl8168h_2_hw_phy_config, 370025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_49] = rtl8168ep_1_hw_phy_config, 370125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_50] = rtl8168ep_2_hw_phy_config, 370225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_51] = rtl8168ep_2_hw_phy_config, 370325e992a4SHeiner Kallweit }; 370425e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 370525e992a4SHeiner Kallweit 370625e992a4SHeiner Kallweit if (phy_configs[tp->mac_version]) 370725e992a4SHeiner Kallweit phy_configs[tp->mac_version](tp); 370825e992a4SHeiner Kallweit } 370925e992a4SHeiner Kallweit 371025e992a4SHeiner Kallweit static void rtl_schedule_task(struct rtl8169_private *tp, enum rtl_flag flag) 371125e992a4SHeiner Kallweit { 371225e992a4SHeiner Kallweit if (!test_and_set_bit(flag, tp->wk.flags)) 371325e992a4SHeiner Kallweit schedule_work(&tp->wk.work); 371425e992a4SHeiner Kallweit } 371525e992a4SHeiner Kallweit 371625e992a4SHeiner Kallweit static void rtl8169_init_phy(struct net_device *dev, struct rtl8169_private *tp) 371725e992a4SHeiner Kallweit { 371825e992a4SHeiner Kallweit rtl_hw_phy_config(dev); 371925e992a4SHeiner Kallweit 372025e992a4SHeiner Kallweit if (tp->mac_version <= RTL_GIGA_MAC_VER_06) { 372125e992a4SHeiner Kallweit pci_write_config_byte(tp->pci_dev, PCI_LATENCY_TIMER, 0x40); 372225e992a4SHeiner Kallweit pci_write_config_byte(tp->pci_dev, PCI_CACHE_LINE_SIZE, 0x08); 372325e992a4SHeiner Kallweit netif_dbg(tp, drv, dev, 372425e992a4SHeiner Kallweit "Set MAC Reg C+CR Offset 0x82h = 0x01h\n"); 372525e992a4SHeiner Kallweit RTL_W8(tp, 0x82, 0x01); 372625e992a4SHeiner Kallweit } 372725e992a4SHeiner Kallweit 372825e992a4SHeiner Kallweit /* We may have called phy_speed_down before */ 372925e992a4SHeiner Kallweit phy_speed_up(tp->phydev); 373025e992a4SHeiner Kallweit 373125e992a4SHeiner Kallweit genphy_soft_reset(tp->phydev); 373225e992a4SHeiner Kallweit } 373325e992a4SHeiner Kallweit 373425e992a4SHeiner Kallweit static void rtl_rar_set(struct rtl8169_private *tp, u8 *addr) 373525e992a4SHeiner Kallweit { 373625e992a4SHeiner Kallweit rtl_lock_work(tp); 373725e992a4SHeiner Kallweit 373825e992a4SHeiner Kallweit rtl_unlock_config_regs(tp); 373925e992a4SHeiner Kallweit 374025e992a4SHeiner Kallweit RTL_W32(tp, MAC4, addr[4] | addr[5] << 8); 374125e992a4SHeiner Kallweit RTL_R32(tp, MAC4); 374225e992a4SHeiner Kallweit 374325e992a4SHeiner Kallweit RTL_W32(tp, MAC0, addr[0] | addr[1] << 8 | addr[2] << 16 | addr[3] << 24); 374425e992a4SHeiner Kallweit RTL_R32(tp, MAC0); 374525e992a4SHeiner Kallweit 374625e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_34) 374725e992a4SHeiner Kallweit rtl_rar_exgmac_set(tp, addr); 374825e992a4SHeiner Kallweit 374925e992a4SHeiner Kallweit rtl_lock_config_regs(tp); 375025e992a4SHeiner Kallweit 375125e992a4SHeiner Kallweit rtl_unlock_work(tp); 375225e992a4SHeiner Kallweit } 375325e992a4SHeiner Kallweit 375425e992a4SHeiner Kallweit static int rtl_set_mac_address(struct net_device *dev, void *p) 375525e992a4SHeiner Kallweit { 375625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 375725e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 375825e992a4SHeiner Kallweit int ret; 375925e992a4SHeiner Kallweit 376025e992a4SHeiner Kallweit ret = eth_mac_addr(dev, p); 376125e992a4SHeiner Kallweit if (ret) 376225e992a4SHeiner Kallweit return ret; 376325e992a4SHeiner Kallweit 376425e992a4SHeiner Kallweit pm_runtime_get_noresume(d); 376525e992a4SHeiner Kallweit 376625e992a4SHeiner Kallweit if (pm_runtime_active(d)) 376725e992a4SHeiner Kallweit rtl_rar_set(tp, dev->dev_addr); 376825e992a4SHeiner Kallweit 376925e992a4SHeiner Kallweit pm_runtime_put_noidle(d); 377025e992a4SHeiner Kallweit 377125e992a4SHeiner Kallweit return 0; 377225e992a4SHeiner Kallweit } 377325e992a4SHeiner Kallweit 377425e992a4SHeiner Kallweit static int rtl8169_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 377525e992a4SHeiner Kallweit { 377625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 377725e992a4SHeiner Kallweit 377825e992a4SHeiner Kallweit if (!netif_running(dev)) 377925e992a4SHeiner Kallweit return -ENODEV; 378025e992a4SHeiner Kallweit 378125e992a4SHeiner Kallweit return phy_mii_ioctl(tp->phydev, ifr, cmd); 378225e992a4SHeiner Kallweit } 378325e992a4SHeiner Kallweit 378425e992a4SHeiner Kallweit static void rtl_wol_suspend_quirk(struct rtl8169_private *tp) 378525e992a4SHeiner Kallweit { 378625e992a4SHeiner Kallweit switch (tp->mac_version) { 378725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_25: 378825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_26: 378925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_29: 379025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_30: 379125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_32: 379225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_33: 379325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_34: 379425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_37 ... RTL_GIGA_MAC_VER_51: 379525e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, RTL_R32(tp, RxConfig) | 379625e992a4SHeiner Kallweit AcceptBroadcast | AcceptMulticast | AcceptMyPhys); 379725e992a4SHeiner Kallweit break; 379825e992a4SHeiner Kallweit default: 379925e992a4SHeiner Kallweit break; 380025e992a4SHeiner Kallweit } 380125e992a4SHeiner Kallweit } 380225e992a4SHeiner Kallweit 380325e992a4SHeiner Kallweit static void rtl_pll_power_down(struct rtl8169_private *tp) 380425e992a4SHeiner Kallweit { 380525e992a4SHeiner Kallweit if (r8168_check_dash(tp)) 380625e992a4SHeiner Kallweit return; 380725e992a4SHeiner Kallweit 380825e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_32 || 380925e992a4SHeiner Kallweit tp->mac_version == RTL_GIGA_MAC_VER_33) 381025e992a4SHeiner Kallweit rtl_ephy_write(tp, 0x19, 0xff64); 381125e992a4SHeiner Kallweit 381225e992a4SHeiner Kallweit if (device_may_wakeup(tp_to_dev(tp))) { 381325e992a4SHeiner Kallweit phy_speed_down(tp->phydev, false); 381425e992a4SHeiner Kallweit rtl_wol_suspend_quirk(tp); 381525e992a4SHeiner Kallweit return; 381625e992a4SHeiner Kallweit } 381725e992a4SHeiner Kallweit 381825e992a4SHeiner Kallweit switch (tp->mac_version) { 381925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_25 ... RTL_GIGA_MAC_VER_33: 382025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_37: 382125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_39: 382225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_43: 382325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_44: 382425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_45: 382525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_46: 382625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_47: 382725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_48: 382825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_50: 382925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_51: 383025e992a4SHeiner Kallweit RTL_W8(tp, PMCH, RTL_R8(tp, PMCH) & ~0x80); 383125e992a4SHeiner Kallweit break; 383225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_40: 383325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_41: 383425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_49: 383525e992a4SHeiner Kallweit rtl_eri_clear_bits(tp, 0x1a8, ERIAR_MASK_1111, 0xfc000000); 383625e992a4SHeiner Kallweit RTL_W8(tp, PMCH, RTL_R8(tp, PMCH) & ~0x80); 383725e992a4SHeiner Kallweit break; 383825e992a4SHeiner Kallweit default: 383925e992a4SHeiner Kallweit break; 384025e992a4SHeiner Kallweit } 384125e992a4SHeiner Kallweit } 384225e992a4SHeiner Kallweit 384325e992a4SHeiner Kallweit static void rtl_pll_power_up(struct rtl8169_private *tp) 384425e992a4SHeiner Kallweit { 384525e992a4SHeiner Kallweit switch (tp->mac_version) { 384625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_25 ... RTL_GIGA_MAC_VER_33: 384725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_37: 384825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_39: 384925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_43: 385025e992a4SHeiner Kallweit RTL_W8(tp, PMCH, RTL_R8(tp, PMCH) | 0x80); 385125e992a4SHeiner Kallweit break; 385225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_44: 385325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_45: 385425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_46: 385525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_47: 385625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_48: 385725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_50: 385825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_51: 385925e992a4SHeiner Kallweit RTL_W8(tp, PMCH, RTL_R8(tp, PMCH) | 0xc0); 386025e992a4SHeiner Kallweit break; 386125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_40: 386225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_41: 386325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_49: 386425e992a4SHeiner Kallweit RTL_W8(tp, PMCH, RTL_R8(tp, PMCH) | 0xc0); 386525e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0x1a8, ERIAR_MASK_1111, 0xfc000000); 386625e992a4SHeiner Kallweit break; 386725e992a4SHeiner Kallweit default: 386825e992a4SHeiner Kallweit break; 386925e992a4SHeiner Kallweit } 387025e992a4SHeiner Kallweit 387125e992a4SHeiner Kallweit phy_resume(tp->phydev); 387225e992a4SHeiner Kallweit /* give MAC/PHY some time to resume */ 387325e992a4SHeiner Kallweit msleep(20); 387425e992a4SHeiner Kallweit } 387525e992a4SHeiner Kallweit 387625e992a4SHeiner Kallweit static void rtl_init_rxcfg(struct rtl8169_private *tp) 387725e992a4SHeiner Kallweit { 387825e992a4SHeiner Kallweit switch (tp->mac_version) { 387925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_02 ... RTL_GIGA_MAC_VER_06: 388025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_10 ... RTL_GIGA_MAC_VER_17: 388125e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, RX_FIFO_THRESH | RX_DMA_BURST); 388225e992a4SHeiner Kallweit break; 388325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_18 ... RTL_GIGA_MAC_VER_24: 388425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_34 ... RTL_GIGA_MAC_VER_36: 388525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_38: 388625e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, RX128_INT_EN | RX_MULTI_EN | RX_DMA_BURST); 388725e992a4SHeiner Kallweit break; 388825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_40 ... RTL_GIGA_MAC_VER_51: 388925e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, RX128_INT_EN | RX_MULTI_EN | RX_DMA_BURST | RX_EARLY_OFF); 389025e992a4SHeiner Kallweit break; 389125e992a4SHeiner Kallweit default: 389225e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, RX128_INT_EN | RX_DMA_BURST); 389325e992a4SHeiner Kallweit break; 389425e992a4SHeiner Kallweit } 389525e992a4SHeiner Kallweit } 389625e992a4SHeiner Kallweit 389725e992a4SHeiner Kallweit static void rtl8169_init_ring_indexes(struct rtl8169_private *tp) 389825e992a4SHeiner Kallweit { 389925e992a4SHeiner Kallweit tp->dirty_tx = tp->cur_tx = tp->cur_rx = 0; 390025e992a4SHeiner Kallweit } 390125e992a4SHeiner Kallweit 390225e992a4SHeiner Kallweit static void r8168c_hw_jumbo_enable(struct rtl8169_private *tp) 390325e992a4SHeiner Kallweit { 390425e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) | Jumbo_En0); 390525e992a4SHeiner Kallweit RTL_W8(tp, Config4, RTL_R8(tp, Config4) | Jumbo_En1); 390625e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_512B); 390725e992a4SHeiner Kallweit } 390825e992a4SHeiner Kallweit 390925e992a4SHeiner Kallweit static void r8168c_hw_jumbo_disable(struct rtl8169_private *tp) 391025e992a4SHeiner Kallweit { 391125e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Jumbo_En0); 391225e992a4SHeiner Kallweit RTL_W8(tp, Config4, RTL_R8(tp, Config4) & ~Jumbo_En1); 391325e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B); 391425e992a4SHeiner Kallweit } 391525e992a4SHeiner Kallweit 391625e992a4SHeiner Kallweit static void r8168dp_hw_jumbo_enable(struct rtl8169_private *tp) 391725e992a4SHeiner Kallweit { 391825e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) | Jumbo_En0); 391925e992a4SHeiner Kallweit } 392025e992a4SHeiner Kallweit 392125e992a4SHeiner Kallweit static void r8168dp_hw_jumbo_disable(struct rtl8169_private *tp) 392225e992a4SHeiner Kallweit { 392325e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Jumbo_En0); 392425e992a4SHeiner Kallweit } 392525e992a4SHeiner Kallweit 392625e992a4SHeiner Kallweit static void r8168e_hw_jumbo_enable(struct rtl8169_private *tp) 392725e992a4SHeiner Kallweit { 392825e992a4SHeiner Kallweit RTL_W8(tp, MaxTxPacketSize, 0x3f); 392925e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) | Jumbo_En0); 393025e992a4SHeiner Kallweit RTL_W8(tp, Config4, RTL_R8(tp, Config4) | 0x01); 393125e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_512B); 393225e992a4SHeiner Kallweit } 393325e992a4SHeiner Kallweit 393425e992a4SHeiner Kallweit static void r8168e_hw_jumbo_disable(struct rtl8169_private *tp) 393525e992a4SHeiner Kallweit { 393625e992a4SHeiner Kallweit RTL_W8(tp, MaxTxPacketSize, 0x0c); 393725e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Jumbo_En0); 393825e992a4SHeiner Kallweit RTL_W8(tp, Config4, RTL_R8(tp, Config4) & ~0x01); 393925e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B); 394025e992a4SHeiner Kallweit } 394125e992a4SHeiner Kallweit 394225e992a4SHeiner Kallweit static void r8168b_0_hw_jumbo_enable(struct rtl8169_private *tp) 394325e992a4SHeiner Kallweit { 394425e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, 394525e992a4SHeiner Kallweit PCI_EXP_DEVCTL_READRQ_512B | PCI_EXP_DEVCTL_NOSNOOP_EN); 394625e992a4SHeiner Kallweit } 394725e992a4SHeiner Kallweit 394825e992a4SHeiner Kallweit static void r8168b_0_hw_jumbo_disable(struct rtl8169_private *tp) 394925e992a4SHeiner Kallweit { 395025e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, 395125e992a4SHeiner Kallweit PCI_EXP_DEVCTL_READRQ_4096B | PCI_EXP_DEVCTL_NOSNOOP_EN); 395225e992a4SHeiner Kallweit } 395325e992a4SHeiner Kallweit 395425e992a4SHeiner Kallweit static void r8168b_1_hw_jumbo_enable(struct rtl8169_private *tp) 395525e992a4SHeiner Kallweit { 395625e992a4SHeiner Kallweit r8168b_0_hw_jumbo_enable(tp); 395725e992a4SHeiner Kallweit 395825e992a4SHeiner Kallweit RTL_W8(tp, Config4, RTL_R8(tp, Config4) | (1 << 0)); 395925e992a4SHeiner Kallweit } 396025e992a4SHeiner Kallweit 396125e992a4SHeiner Kallweit static void r8168b_1_hw_jumbo_disable(struct rtl8169_private *tp) 396225e992a4SHeiner Kallweit { 396325e992a4SHeiner Kallweit r8168b_0_hw_jumbo_disable(tp); 396425e992a4SHeiner Kallweit 396525e992a4SHeiner Kallweit RTL_W8(tp, Config4, RTL_R8(tp, Config4) & ~(1 << 0)); 396625e992a4SHeiner Kallweit } 396725e992a4SHeiner Kallweit 396825e992a4SHeiner Kallweit static void rtl_hw_jumbo_enable(struct rtl8169_private *tp) 396925e992a4SHeiner Kallweit { 397025e992a4SHeiner Kallweit rtl_unlock_config_regs(tp); 397125e992a4SHeiner Kallweit switch (tp->mac_version) { 397225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_11: 397325e992a4SHeiner Kallweit r8168b_0_hw_jumbo_enable(tp); 397425e992a4SHeiner Kallweit break; 397525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_12: 397625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_17: 397725e992a4SHeiner Kallweit r8168b_1_hw_jumbo_enable(tp); 397825e992a4SHeiner Kallweit break; 397925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_18 ... RTL_GIGA_MAC_VER_26: 398025e992a4SHeiner Kallweit r8168c_hw_jumbo_enable(tp); 398125e992a4SHeiner Kallweit break; 398225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27 ... RTL_GIGA_MAC_VER_28: 398325e992a4SHeiner Kallweit r8168dp_hw_jumbo_enable(tp); 398425e992a4SHeiner Kallweit break; 398525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31 ... RTL_GIGA_MAC_VER_34: 398625e992a4SHeiner Kallweit r8168e_hw_jumbo_enable(tp); 398725e992a4SHeiner Kallweit break; 398825e992a4SHeiner Kallweit default: 398925e992a4SHeiner Kallweit break; 399025e992a4SHeiner Kallweit } 399125e992a4SHeiner Kallweit rtl_lock_config_regs(tp); 399225e992a4SHeiner Kallweit } 399325e992a4SHeiner Kallweit 399425e992a4SHeiner Kallweit static void rtl_hw_jumbo_disable(struct rtl8169_private *tp) 399525e992a4SHeiner Kallweit { 399625e992a4SHeiner Kallweit rtl_unlock_config_regs(tp); 399725e992a4SHeiner Kallweit switch (tp->mac_version) { 399825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_11: 399925e992a4SHeiner Kallweit r8168b_0_hw_jumbo_disable(tp); 400025e992a4SHeiner Kallweit break; 400125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_12: 400225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_17: 400325e992a4SHeiner Kallweit r8168b_1_hw_jumbo_disable(tp); 400425e992a4SHeiner Kallweit break; 400525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_18 ... RTL_GIGA_MAC_VER_26: 400625e992a4SHeiner Kallweit r8168c_hw_jumbo_disable(tp); 400725e992a4SHeiner Kallweit break; 400825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27 ... RTL_GIGA_MAC_VER_28: 400925e992a4SHeiner Kallweit r8168dp_hw_jumbo_disable(tp); 401025e992a4SHeiner Kallweit break; 401125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31 ... RTL_GIGA_MAC_VER_34: 401225e992a4SHeiner Kallweit r8168e_hw_jumbo_disable(tp); 401325e992a4SHeiner Kallweit break; 401425e992a4SHeiner Kallweit default: 401525e992a4SHeiner Kallweit break; 401625e992a4SHeiner Kallweit } 401725e992a4SHeiner Kallweit rtl_lock_config_regs(tp); 401825e992a4SHeiner Kallweit } 401925e992a4SHeiner Kallweit 402025e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_chipcmd_cond) 402125e992a4SHeiner Kallweit { 402225e992a4SHeiner Kallweit return RTL_R8(tp, ChipCmd) & CmdReset; 402325e992a4SHeiner Kallweit } 402425e992a4SHeiner Kallweit 402525e992a4SHeiner Kallweit static void rtl_hw_reset(struct rtl8169_private *tp) 402625e992a4SHeiner Kallweit { 402725e992a4SHeiner Kallweit RTL_W8(tp, ChipCmd, CmdReset); 402825e992a4SHeiner Kallweit 402925e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_chipcmd_cond, 100, 100); 403025e992a4SHeiner Kallweit } 403125e992a4SHeiner Kallweit 403225e992a4SHeiner Kallweit static void rtl_request_firmware(struct rtl8169_private *tp) 403325e992a4SHeiner Kallweit { 403425e992a4SHeiner Kallweit struct rtl_fw *rtl_fw; 403525e992a4SHeiner Kallweit 403625e992a4SHeiner Kallweit /* firmware loaded already or no firmware available */ 403725e992a4SHeiner Kallweit if (tp->rtl_fw || !tp->fw_name) 403825e992a4SHeiner Kallweit return; 403925e992a4SHeiner Kallweit 404025e992a4SHeiner Kallweit rtl_fw = kzalloc(sizeof(*rtl_fw), GFP_KERNEL); 404125e992a4SHeiner Kallweit if (!rtl_fw) { 404225e992a4SHeiner Kallweit netif_warn(tp, ifup, tp->dev, "Unable to load firmware, out of memory\n"); 404325e992a4SHeiner Kallweit return; 404425e992a4SHeiner Kallweit } 404525e992a4SHeiner Kallweit 404625e992a4SHeiner Kallweit rtl_fw->phy_write = rtl_writephy; 404725e992a4SHeiner Kallweit rtl_fw->phy_read = rtl_readphy; 404825e992a4SHeiner Kallweit rtl_fw->mac_mcu_write = mac_mcu_write; 404925e992a4SHeiner Kallweit rtl_fw->mac_mcu_read = mac_mcu_read; 405025e992a4SHeiner Kallweit rtl_fw->fw_name = tp->fw_name; 405125e992a4SHeiner Kallweit rtl_fw->dev = tp_to_dev(tp); 405225e992a4SHeiner Kallweit 405325e992a4SHeiner Kallweit if (rtl_fw_request_firmware(rtl_fw)) 405425e992a4SHeiner Kallweit kfree(rtl_fw); 405525e992a4SHeiner Kallweit else 405625e992a4SHeiner Kallweit tp->rtl_fw = rtl_fw; 405725e992a4SHeiner Kallweit } 405825e992a4SHeiner Kallweit 405925e992a4SHeiner Kallweit static void rtl_rx_close(struct rtl8169_private *tp) 406025e992a4SHeiner Kallweit { 406125e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, RTL_R32(tp, RxConfig) & ~RX_CONFIG_ACCEPT_MASK); 406225e992a4SHeiner Kallweit } 406325e992a4SHeiner Kallweit 406425e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_npq_cond) 406525e992a4SHeiner Kallweit { 406625e992a4SHeiner Kallweit return RTL_R8(tp, TxPoll) & NPQ; 406725e992a4SHeiner Kallweit } 406825e992a4SHeiner Kallweit 406925e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_txcfg_empty_cond) 407025e992a4SHeiner Kallweit { 407125e992a4SHeiner Kallweit return RTL_R32(tp, TxConfig) & TXCFG_EMPTY; 407225e992a4SHeiner Kallweit } 407325e992a4SHeiner Kallweit 407425e992a4SHeiner Kallweit static void rtl8169_hw_reset(struct rtl8169_private *tp) 407525e992a4SHeiner Kallweit { 407625e992a4SHeiner Kallweit /* Disable interrupts */ 407725e992a4SHeiner Kallweit rtl8169_irq_mask_and_ack(tp); 407825e992a4SHeiner Kallweit 407925e992a4SHeiner Kallweit rtl_rx_close(tp); 408025e992a4SHeiner Kallweit 408125e992a4SHeiner Kallweit switch (tp->mac_version) { 408225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27: 408325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_28: 408425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31: 408525e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_npq_cond, 20, 42*42); 408625e992a4SHeiner Kallweit break; 408725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_34 ... RTL_GIGA_MAC_VER_38: 408825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_40 ... RTL_GIGA_MAC_VER_51: 408925e992a4SHeiner Kallweit RTL_W8(tp, ChipCmd, RTL_R8(tp, ChipCmd) | StopReq); 409025e992a4SHeiner Kallweit rtl_udelay_loop_wait_high(tp, &rtl_txcfg_empty_cond, 100, 666); 409125e992a4SHeiner Kallweit break; 409225e992a4SHeiner Kallweit default: 409325e992a4SHeiner Kallweit RTL_W8(tp, ChipCmd, RTL_R8(tp, ChipCmd) | StopReq); 409425e992a4SHeiner Kallweit udelay(100); 409525e992a4SHeiner Kallweit break; 409625e992a4SHeiner Kallweit } 409725e992a4SHeiner Kallweit 409825e992a4SHeiner Kallweit rtl_hw_reset(tp); 409925e992a4SHeiner Kallweit } 410025e992a4SHeiner Kallweit 410125e992a4SHeiner Kallweit static void rtl_set_tx_config_registers(struct rtl8169_private *tp) 410225e992a4SHeiner Kallweit { 410325e992a4SHeiner Kallweit u32 val = TX_DMA_BURST << TxDMAShift | 410425e992a4SHeiner Kallweit InterFrameGap << TxInterFrameGapShift; 410525e992a4SHeiner Kallweit 41069e9f33baSHeiner Kallweit if (rtl_is_8168evl_up(tp)) 410725e992a4SHeiner Kallweit val |= TXCFG_AUTO_FIFO; 410825e992a4SHeiner Kallweit 410925e992a4SHeiner Kallweit RTL_W32(tp, TxConfig, val); 411025e992a4SHeiner Kallweit } 411125e992a4SHeiner Kallweit 411225e992a4SHeiner Kallweit static void rtl_set_rx_max_size(struct rtl8169_private *tp) 411325e992a4SHeiner Kallweit { 411425e992a4SHeiner Kallweit /* Low hurts. Let's disable the filtering. */ 411525e992a4SHeiner Kallweit RTL_W16(tp, RxMaxSize, R8169_RX_BUF_SIZE + 1); 411625e992a4SHeiner Kallweit } 411725e992a4SHeiner Kallweit 411825e992a4SHeiner Kallweit static void rtl_set_rx_tx_desc_registers(struct rtl8169_private *tp) 411925e992a4SHeiner Kallweit { 412025e992a4SHeiner Kallweit /* 412125e992a4SHeiner Kallweit * Magic spell: some iop3xx ARM board needs the TxDescAddrHigh 412225e992a4SHeiner Kallweit * register to be written before TxDescAddrLow to work. 412325e992a4SHeiner Kallweit * Switching from MMIO to I/O access fixes the issue as well. 412425e992a4SHeiner Kallweit */ 412525e992a4SHeiner Kallweit RTL_W32(tp, TxDescStartAddrHigh, ((u64) tp->TxPhyAddr) >> 32); 412625e992a4SHeiner Kallweit RTL_W32(tp, TxDescStartAddrLow, ((u64) tp->TxPhyAddr) & DMA_BIT_MASK(32)); 412725e992a4SHeiner Kallweit RTL_W32(tp, RxDescAddrHigh, ((u64) tp->RxPhyAddr) >> 32); 412825e992a4SHeiner Kallweit RTL_W32(tp, RxDescAddrLow, ((u64) tp->RxPhyAddr) & DMA_BIT_MASK(32)); 412925e992a4SHeiner Kallweit } 413025e992a4SHeiner Kallweit 413125e992a4SHeiner Kallweit static void rtl8169_set_magic_reg(struct rtl8169_private *tp, unsigned mac_version) 413225e992a4SHeiner Kallweit { 413325e992a4SHeiner Kallweit u32 val; 413425e992a4SHeiner Kallweit 413525e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_05) 413625e992a4SHeiner Kallweit val = 0x000fff00; 413725e992a4SHeiner Kallweit else if (tp->mac_version == RTL_GIGA_MAC_VER_06) 413825e992a4SHeiner Kallweit val = 0x00ffff00; 413925e992a4SHeiner Kallweit else 414025e992a4SHeiner Kallweit return; 414125e992a4SHeiner Kallweit 414225e992a4SHeiner Kallweit if (RTL_R8(tp, Config2) & PCI_Clock_66MHz) 414325e992a4SHeiner Kallweit val |= 0xff; 414425e992a4SHeiner Kallweit 414525e992a4SHeiner Kallweit RTL_W32(tp, 0x7c, val); 414625e992a4SHeiner Kallweit } 414725e992a4SHeiner Kallweit 414825e992a4SHeiner Kallweit static void rtl_set_rx_mode(struct net_device *dev) 414925e992a4SHeiner Kallweit { 415025e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 415125e992a4SHeiner Kallweit u32 mc_filter[2]; /* Multicast hash filter */ 415225e992a4SHeiner Kallweit int rx_mode; 415325e992a4SHeiner Kallweit u32 tmp = 0; 415425e992a4SHeiner Kallweit 415525e992a4SHeiner Kallweit if (dev->flags & IFF_PROMISC) { 415625e992a4SHeiner Kallweit /* Unconditionally log net taps. */ 415725e992a4SHeiner Kallweit netif_notice(tp, link, dev, "Promiscuous mode enabled\n"); 415825e992a4SHeiner Kallweit rx_mode = 415925e992a4SHeiner Kallweit AcceptBroadcast | AcceptMulticast | AcceptMyPhys | 416025e992a4SHeiner Kallweit AcceptAllPhys; 416125e992a4SHeiner Kallweit mc_filter[1] = mc_filter[0] = 0xffffffff; 416225e992a4SHeiner Kallweit } else if ((netdev_mc_count(dev) > multicast_filter_limit) || 416325e992a4SHeiner Kallweit (dev->flags & IFF_ALLMULTI)) { 416425e992a4SHeiner Kallweit /* Too many to filter perfectly -- accept all multicasts. */ 416525e992a4SHeiner Kallweit rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys; 416625e992a4SHeiner Kallweit mc_filter[1] = mc_filter[0] = 0xffffffff; 416725e992a4SHeiner Kallweit } else { 416825e992a4SHeiner Kallweit struct netdev_hw_addr *ha; 416925e992a4SHeiner Kallweit 417025e992a4SHeiner Kallweit rx_mode = AcceptBroadcast | AcceptMyPhys; 417125e992a4SHeiner Kallweit mc_filter[1] = mc_filter[0] = 0; 417225e992a4SHeiner Kallweit netdev_for_each_mc_addr(ha, dev) { 417325e992a4SHeiner Kallweit int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26; 417425e992a4SHeiner Kallweit mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31); 417525e992a4SHeiner Kallweit rx_mode |= AcceptMulticast; 417625e992a4SHeiner Kallweit } 417725e992a4SHeiner Kallweit } 417825e992a4SHeiner Kallweit 417925e992a4SHeiner Kallweit if (dev->features & NETIF_F_RXALL) 418025e992a4SHeiner Kallweit rx_mode |= (AcceptErr | AcceptRunt); 418125e992a4SHeiner Kallweit 418225e992a4SHeiner Kallweit tmp = (RTL_R32(tp, RxConfig) & ~RX_CONFIG_ACCEPT_MASK) | rx_mode; 418325e992a4SHeiner Kallweit 418425e992a4SHeiner Kallweit if (tp->mac_version > RTL_GIGA_MAC_VER_06) { 418525e992a4SHeiner Kallweit u32 data = mc_filter[0]; 418625e992a4SHeiner Kallweit 418725e992a4SHeiner Kallweit mc_filter[0] = swab32(mc_filter[1]); 418825e992a4SHeiner Kallweit mc_filter[1] = swab32(data); 418925e992a4SHeiner Kallweit } 419025e992a4SHeiner Kallweit 419125e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_35) 419225e992a4SHeiner Kallweit mc_filter[1] = mc_filter[0] = 0xffffffff; 419325e992a4SHeiner Kallweit 419425e992a4SHeiner Kallweit RTL_W32(tp, MAR0 + 4, mc_filter[1]); 419525e992a4SHeiner Kallweit RTL_W32(tp, MAR0 + 0, mc_filter[0]); 419625e992a4SHeiner Kallweit 419725e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, tmp); 419825e992a4SHeiner Kallweit } 419925e992a4SHeiner Kallweit 420025e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_csiar_cond) 420125e992a4SHeiner Kallweit { 420225e992a4SHeiner Kallweit return RTL_R32(tp, CSIAR) & CSIAR_FLAG; 420325e992a4SHeiner Kallweit } 420425e992a4SHeiner Kallweit 420525e992a4SHeiner Kallweit static void rtl_csi_write(struct rtl8169_private *tp, int addr, int value) 420625e992a4SHeiner Kallweit { 420725e992a4SHeiner Kallweit u32 func = PCI_FUNC(tp->pci_dev->devfn); 420825e992a4SHeiner Kallweit 420925e992a4SHeiner Kallweit RTL_W32(tp, CSIDR, value); 421025e992a4SHeiner Kallweit RTL_W32(tp, CSIAR, CSIAR_WRITE_CMD | (addr & CSIAR_ADDR_MASK) | 421125e992a4SHeiner Kallweit CSIAR_BYTE_ENABLE | func << 16); 421225e992a4SHeiner Kallweit 421325e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_csiar_cond, 10, 100); 421425e992a4SHeiner Kallweit } 421525e992a4SHeiner Kallweit 421625e992a4SHeiner Kallweit static u32 rtl_csi_read(struct rtl8169_private *tp, int addr) 421725e992a4SHeiner Kallweit { 421825e992a4SHeiner Kallweit u32 func = PCI_FUNC(tp->pci_dev->devfn); 421925e992a4SHeiner Kallweit 422025e992a4SHeiner Kallweit RTL_W32(tp, CSIAR, (addr & CSIAR_ADDR_MASK) | func << 16 | 422125e992a4SHeiner Kallweit CSIAR_BYTE_ENABLE); 422225e992a4SHeiner Kallweit 422325e992a4SHeiner Kallweit return rtl_udelay_loop_wait_high(tp, &rtl_csiar_cond, 10, 100) ? 422425e992a4SHeiner Kallweit RTL_R32(tp, CSIDR) : ~0; 422525e992a4SHeiner Kallweit } 422625e992a4SHeiner Kallweit 422725e992a4SHeiner Kallweit static void rtl_csi_access_enable(struct rtl8169_private *tp, u8 val) 422825e992a4SHeiner Kallweit { 422925e992a4SHeiner Kallweit struct pci_dev *pdev = tp->pci_dev; 423025e992a4SHeiner Kallweit u32 csi; 423125e992a4SHeiner Kallweit 423225e992a4SHeiner Kallweit /* According to Realtek the value at config space address 0x070f 423325e992a4SHeiner Kallweit * controls the L0s/L1 entrance latency. We try standard ECAM access 423425e992a4SHeiner Kallweit * first and if it fails fall back to CSI. 423525e992a4SHeiner Kallweit */ 423625e992a4SHeiner Kallweit if (pdev->cfg_size > 0x070f && 423725e992a4SHeiner Kallweit pci_write_config_byte(pdev, 0x070f, val) == PCIBIOS_SUCCESSFUL) 423825e992a4SHeiner Kallweit return; 423925e992a4SHeiner Kallweit 424025e992a4SHeiner Kallweit netdev_notice_once(tp->dev, 424125e992a4SHeiner Kallweit "No native access to PCI extended config space, falling back to CSI\n"); 424225e992a4SHeiner Kallweit csi = rtl_csi_read(tp, 0x070c) & 0x00ffffff; 424325e992a4SHeiner Kallweit rtl_csi_write(tp, 0x070c, csi | val << 24); 424425e992a4SHeiner Kallweit } 424525e992a4SHeiner Kallweit 424625e992a4SHeiner Kallweit static void rtl_set_def_aspm_entry_latency(struct rtl8169_private *tp) 424725e992a4SHeiner Kallweit { 424825e992a4SHeiner Kallweit rtl_csi_access_enable(tp, 0x27); 424925e992a4SHeiner Kallweit } 425025e992a4SHeiner Kallweit 425125e992a4SHeiner Kallweit struct ephy_info { 425225e992a4SHeiner Kallweit unsigned int offset; 425325e992a4SHeiner Kallweit u16 mask; 425425e992a4SHeiner Kallweit u16 bits; 425525e992a4SHeiner Kallweit }; 425625e992a4SHeiner Kallweit 425725e992a4SHeiner Kallweit static void __rtl_ephy_init(struct rtl8169_private *tp, 425825e992a4SHeiner Kallweit const struct ephy_info *e, int len) 425925e992a4SHeiner Kallweit { 426025e992a4SHeiner Kallweit u16 w; 426125e992a4SHeiner Kallweit 426225e992a4SHeiner Kallweit while (len-- > 0) { 426325e992a4SHeiner Kallweit w = (rtl_ephy_read(tp, e->offset) & ~e->mask) | e->bits; 426425e992a4SHeiner Kallweit rtl_ephy_write(tp, e->offset, w); 426525e992a4SHeiner Kallweit e++; 426625e992a4SHeiner Kallweit } 426725e992a4SHeiner Kallweit } 426825e992a4SHeiner Kallweit 426925e992a4SHeiner Kallweit #define rtl_ephy_init(tp, a) __rtl_ephy_init(tp, a, ARRAY_SIZE(a)) 427025e992a4SHeiner Kallweit 427125e992a4SHeiner Kallweit static void rtl_disable_clock_request(struct rtl8169_private *tp) 427225e992a4SHeiner Kallweit { 427325e992a4SHeiner Kallweit pcie_capability_clear_word(tp->pci_dev, PCI_EXP_LNKCTL, 427425e992a4SHeiner Kallweit PCI_EXP_LNKCTL_CLKREQ_EN); 427525e992a4SHeiner Kallweit } 427625e992a4SHeiner Kallweit 427725e992a4SHeiner Kallweit static void rtl_enable_clock_request(struct rtl8169_private *tp) 427825e992a4SHeiner Kallweit { 427925e992a4SHeiner Kallweit pcie_capability_set_word(tp->pci_dev, PCI_EXP_LNKCTL, 428025e992a4SHeiner Kallweit PCI_EXP_LNKCTL_CLKREQ_EN); 428125e992a4SHeiner Kallweit } 428225e992a4SHeiner Kallweit 428325e992a4SHeiner Kallweit static void rtl_pcie_state_l2l3_disable(struct rtl8169_private *tp) 428425e992a4SHeiner Kallweit { 428525e992a4SHeiner Kallweit /* work around an issue when PCI reset occurs during L2/L3 state */ 428625e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Rdy_to_L23); 428725e992a4SHeiner Kallweit } 428825e992a4SHeiner Kallweit 428925e992a4SHeiner Kallweit static void rtl_hw_aspm_clkreq_enable(struct rtl8169_private *tp, bool enable) 429025e992a4SHeiner Kallweit { 429162b1b3b3SHeiner Kallweit /* Don't enable ASPM in the chip if OS can't control ASPM */ 429262b1b3b3SHeiner Kallweit if (enable && tp->aspm_manageable) { 429325e992a4SHeiner Kallweit RTL_W8(tp, Config5, RTL_R8(tp, Config5) | ASPM_en); 429425e992a4SHeiner Kallweit RTL_W8(tp, Config2, RTL_R8(tp, Config2) | ClkReqEn); 429525e992a4SHeiner Kallweit } else { 429625e992a4SHeiner Kallweit RTL_W8(tp, Config2, RTL_R8(tp, Config2) & ~ClkReqEn); 429725e992a4SHeiner Kallweit RTL_W8(tp, Config5, RTL_R8(tp, Config5) & ~ASPM_en); 429825e992a4SHeiner Kallweit } 429925e992a4SHeiner Kallweit 430025e992a4SHeiner Kallweit udelay(10); 430125e992a4SHeiner Kallweit } 430225e992a4SHeiner Kallweit 430325e992a4SHeiner Kallweit static void rtl_set_fifo_size(struct rtl8169_private *tp, u16 rx_stat, 430425e992a4SHeiner Kallweit u16 tx_stat, u16 rx_dyn, u16 tx_dyn) 430525e992a4SHeiner Kallweit { 430625e992a4SHeiner Kallweit /* Usage of dynamic vs. static FIFO is controlled by bit 430725e992a4SHeiner Kallweit * TXCFG_AUTO_FIFO. Exact meaning of FIFO values isn't known. 430825e992a4SHeiner Kallweit */ 430925e992a4SHeiner Kallweit rtl_eri_write(tp, 0xc8, ERIAR_MASK_1111, (rx_stat << 16) | rx_dyn); 431025e992a4SHeiner Kallweit rtl_eri_write(tp, 0xe8, ERIAR_MASK_1111, (tx_stat << 16) | tx_dyn); 431125e992a4SHeiner Kallweit } 431225e992a4SHeiner Kallweit 431325e992a4SHeiner Kallweit static void rtl8168g_set_pause_thresholds(struct rtl8169_private *tp, 431425e992a4SHeiner Kallweit u8 low, u8 high) 431525e992a4SHeiner Kallweit { 431625e992a4SHeiner Kallweit /* FIFO thresholds for pause flow control */ 431725e992a4SHeiner Kallweit rtl_eri_write(tp, 0xcc, ERIAR_MASK_0001, low); 431825e992a4SHeiner Kallweit rtl_eri_write(tp, 0xd0, ERIAR_MASK_0001, high); 431925e992a4SHeiner Kallweit } 432025e992a4SHeiner Kallweit 432125e992a4SHeiner Kallweit static void rtl_hw_start_8168bb(struct rtl8169_private *tp) 432225e992a4SHeiner Kallweit { 432325e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Beacon_en); 432425e992a4SHeiner Kallweit 432525e992a4SHeiner Kallweit if (tp->dev->mtu <= ETH_DATA_LEN) { 432625e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B | 432725e992a4SHeiner Kallweit PCI_EXP_DEVCTL_NOSNOOP_EN); 432825e992a4SHeiner Kallweit } 432925e992a4SHeiner Kallweit } 433025e992a4SHeiner Kallweit 433125e992a4SHeiner Kallweit static void rtl_hw_start_8168bef(struct rtl8169_private *tp) 433225e992a4SHeiner Kallweit { 433325e992a4SHeiner Kallweit rtl_hw_start_8168bb(tp); 433425e992a4SHeiner Kallweit 433525e992a4SHeiner Kallweit RTL_W8(tp, Config4, RTL_R8(tp, Config4) & ~(1 << 0)); 433625e992a4SHeiner Kallweit } 433725e992a4SHeiner Kallweit 433825e992a4SHeiner Kallweit static void __rtl_hw_start_8168cp(struct rtl8169_private *tp) 433925e992a4SHeiner Kallweit { 434025e992a4SHeiner Kallweit RTL_W8(tp, Config1, RTL_R8(tp, Config1) | Speed_down); 434125e992a4SHeiner Kallweit 434225e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Beacon_en); 434325e992a4SHeiner Kallweit 434425e992a4SHeiner Kallweit if (tp->dev->mtu <= ETH_DATA_LEN) 434525e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B); 434625e992a4SHeiner Kallweit 434725e992a4SHeiner Kallweit rtl_disable_clock_request(tp); 434825e992a4SHeiner Kallweit } 434925e992a4SHeiner Kallweit 435025e992a4SHeiner Kallweit static void rtl_hw_start_8168cp_1(struct rtl8169_private *tp) 435125e992a4SHeiner Kallweit { 435225e992a4SHeiner Kallweit static const struct ephy_info e_info_8168cp[] = { 435325e992a4SHeiner Kallweit { 0x01, 0, 0x0001 }, 435425e992a4SHeiner Kallweit { 0x02, 0x0800, 0x1000 }, 435525e992a4SHeiner Kallweit { 0x03, 0, 0x0042 }, 435625e992a4SHeiner Kallweit { 0x06, 0x0080, 0x0000 }, 435725e992a4SHeiner Kallweit { 0x07, 0, 0x2000 } 435825e992a4SHeiner Kallweit }; 435925e992a4SHeiner Kallweit 436025e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 436125e992a4SHeiner Kallweit 436225e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168cp); 436325e992a4SHeiner Kallweit 436425e992a4SHeiner Kallweit __rtl_hw_start_8168cp(tp); 436525e992a4SHeiner Kallweit } 436625e992a4SHeiner Kallweit 436725e992a4SHeiner Kallweit static void rtl_hw_start_8168cp_2(struct rtl8169_private *tp) 436825e992a4SHeiner Kallweit { 436925e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 437025e992a4SHeiner Kallweit 437125e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Beacon_en); 437225e992a4SHeiner Kallweit 437325e992a4SHeiner Kallweit if (tp->dev->mtu <= ETH_DATA_LEN) 437425e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B); 437525e992a4SHeiner Kallweit } 437625e992a4SHeiner Kallweit 437725e992a4SHeiner Kallweit static void rtl_hw_start_8168cp_3(struct rtl8169_private *tp) 437825e992a4SHeiner Kallweit { 437925e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 438025e992a4SHeiner Kallweit 438125e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Beacon_en); 438225e992a4SHeiner Kallweit 438325e992a4SHeiner Kallweit /* Magic. */ 438425e992a4SHeiner Kallweit RTL_W8(tp, DBG_REG, 0x20); 438525e992a4SHeiner Kallweit 438625e992a4SHeiner Kallweit if (tp->dev->mtu <= ETH_DATA_LEN) 438725e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B); 438825e992a4SHeiner Kallweit } 438925e992a4SHeiner Kallweit 439025e992a4SHeiner Kallweit static void rtl_hw_start_8168c_1(struct rtl8169_private *tp) 439125e992a4SHeiner Kallweit { 439225e992a4SHeiner Kallweit static const struct ephy_info e_info_8168c_1[] = { 439325e992a4SHeiner Kallweit { 0x02, 0x0800, 0x1000 }, 439425e992a4SHeiner Kallweit { 0x03, 0, 0x0002 }, 439525e992a4SHeiner Kallweit { 0x06, 0x0080, 0x0000 } 439625e992a4SHeiner Kallweit }; 439725e992a4SHeiner Kallweit 439825e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 439925e992a4SHeiner Kallweit 440025e992a4SHeiner Kallweit RTL_W8(tp, DBG_REG, 0x06 | FIX_NAK_1 | FIX_NAK_2); 440125e992a4SHeiner Kallweit 440225e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168c_1); 440325e992a4SHeiner Kallweit 440425e992a4SHeiner Kallweit __rtl_hw_start_8168cp(tp); 440525e992a4SHeiner Kallweit } 440625e992a4SHeiner Kallweit 440725e992a4SHeiner Kallweit static void rtl_hw_start_8168c_2(struct rtl8169_private *tp) 440825e992a4SHeiner Kallweit { 440925e992a4SHeiner Kallweit static const struct ephy_info e_info_8168c_2[] = { 441025e992a4SHeiner Kallweit { 0x01, 0, 0x0001 }, 441125e992a4SHeiner Kallweit { 0x03, 0x0400, 0x0220 } 441225e992a4SHeiner Kallweit }; 441325e992a4SHeiner Kallweit 441425e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 441525e992a4SHeiner Kallweit 441625e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168c_2); 441725e992a4SHeiner Kallweit 441825e992a4SHeiner Kallweit __rtl_hw_start_8168cp(tp); 441925e992a4SHeiner Kallweit } 442025e992a4SHeiner Kallweit 442125e992a4SHeiner Kallweit static void rtl_hw_start_8168c_3(struct rtl8169_private *tp) 442225e992a4SHeiner Kallweit { 442325e992a4SHeiner Kallweit rtl_hw_start_8168c_2(tp); 442425e992a4SHeiner Kallweit } 442525e992a4SHeiner Kallweit 442625e992a4SHeiner Kallweit static void rtl_hw_start_8168c_4(struct rtl8169_private *tp) 442725e992a4SHeiner Kallweit { 442825e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 442925e992a4SHeiner Kallweit 443025e992a4SHeiner Kallweit __rtl_hw_start_8168cp(tp); 443125e992a4SHeiner Kallweit } 443225e992a4SHeiner Kallweit 443325e992a4SHeiner Kallweit static void rtl_hw_start_8168d(struct rtl8169_private *tp) 443425e992a4SHeiner Kallweit { 443525e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 443625e992a4SHeiner Kallweit 443725e992a4SHeiner Kallweit rtl_disable_clock_request(tp); 443825e992a4SHeiner Kallweit 443925e992a4SHeiner Kallweit if (tp->dev->mtu <= ETH_DATA_LEN) 444025e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B); 444125e992a4SHeiner Kallweit } 444225e992a4SHeiner Kallweit 444325e992a4SHeiner Kallweit static void rtl_hw_start_8168dp(struct rtl8169_private *tp) 444425e992a4SHeiner Kallweit { 444525e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 444625e992a4SHeiner Kallweit 444725e992a4SHeiner Kallweit if (tp->dev->mtu <= ETH_DATA_LEN) 444825e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B); 444925e992a4SHeiner Kallweit 445025e992a4SHeiner Kallweit rtl_disable_clock_request(tp); 445125e992a4SHeiner Kallweit } 445225e992a4SHeiner Kallweit 445325e992a4SHeiner Kallweit static void rtl_hw_start_8168d_4(struct rtl8169_private *tp) 445425e992a4SHeiner Kallweit { 445525e992a4SHeiner Kallweit static const struct ephy_info e_info_8168d_4[] = { 445625e992a4SHeiner Kallweit { 0x0b, 0x0000, 0x0048 }, 445725e992a4SHeiner Kallweit { 0x19, 0x0020, 0x0050 }, 445825e992a4SHeiner Kallweit { 0x0c, 0x0100, 0x0020 } 445925e992a4SHeiner Kallweit }; 446025e992a4SHeiner Kallweit 446125e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 446225e992a4SHeiner Kallweit 446325e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B); 446425e992a4SHeiner Kallweit 446525e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168d_4); 446625e992a4SHeiner Kallweit 446725e992a4SHeiner Kallweit rtl_enable_clock_request(tp); 446825e992a4SHeiner Kallweit } 446925e992a4SHeiner Kallweit 447025e992a4SHeiner Kallweit static void rtl_hw_start_8168e_1(struct rtl8169_private *tp) 447125e992a4SHeiner Kallweit { 447225e992a4SHeiner Kallweit static const struct ephy_info e_info_8168e_1[] = { 447325e992a4SHeiner Kallweit { 0x00, 0x0200, 0x0100 }, 447425e992a4SHeiner Kallweit { 0x00, 0x0000, 0x0004 }, 447525e992a4SHeiner Kallweit { 0x06, 0x0002, 0x0001 }, 447625e992a4SHeiner Kallweit { 0x06, 0x0000, 0x0030 }, 447725e992a4SHeiner Kallweit { 0x07, 0x0000, 0x2000 }, 447825e992a4SHeiner Kallweit { 0x00, 0x0000, 0x0020 }, 447925e992a4SHeiner Kallweit { 0x03, 0x5800, 0x2000 }, 448025e992a4SHeiner Kallweit { 0x03, 0x0000, 0x0001 }, 448125e992a4SHeiner Kallweit { 0x01, 0x0800, 0x1000 }, 448225e992a4SHeiner Kallweit { 0x07, 0x0000, 0x4000 }, 448325e992a4SHeiner Kallweit { 0x1e, 0x0000, 0x2000 }, 448425e992a4SHeiner Kallweit { 0x19, 0xffff, 0xfe6c }, 448525e992a4SHeiner Kallweit { 0x0a, 0x0000, 0x0040 } 448625e992a4SHeiner Kallweit }; 448725e992a4SHeiner Kallweit 448825e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 448925e992a4SHeiner Kallweit 449025e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168e_1); 449125e992a4SHeiner Kallweit 449225e992a4SHeiner Kallweit if (tp->dev->mtu <= ETH_DATA_LEN) 449325e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B); 449425e992a4SHeiner Kallweit 449525e992a4SHeiner Kallweit rtl_disable_clock_request(tp); 449625e992a4SHeiner Kallweit 449725e992a4SHeiner Kallweit /* Reset tx FIFO pointer */ 449825e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) | TXPLA_RST); 449925e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) & ~TXPLA_RST); 450025e992a4SHeiner Kallweit 450125e992a4SHeiner Kallweit RTL_W8(tp, Config5, RTL_R8(tp, Config5) & ~Spi_en); 450225e992a4SHeiner Kallweit } 450325e992a4SHeiner Kallweit 450425e992a4SHeiner Kallweit static void rtl_hw_start_8168e_2(struct rtl8169_private *tp) 450525e992a4SHeiner Kallweit { 450625e992a4SHeiner Kallweit static const struct ephy_info e_info_8168e_2[] = { 450725e992a4SHeiner Kallweit { 0x09, 0x0000, 0x0080 }, 450825e992a4SHeiner Kallweit { 0x19, 0x0000, 0x0224 } 450925e992a4SHeiner Kallweit }; 451025e992a4SHeiner Kallweit 451125e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 451225e992a4SHeiner Kallweit 451325e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168e_2); 451425e992a4SHeiner Kallweit 451525e992a4SHeiner Kallweit if (tp->dev->mtu <= ETH_DATA_LEN) 451625e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B); 451725e992a4SHeiner Kallweit 451825e992a4SHeiner Kallweit rtl_eri_write(tp, 0xc0, ERIAR_MASK_0011, 0x0000); 451925e992a4SHeiner Kallweit rtl_eri_write(tp, 0xb8, ERIAR_MASK_0011, 0x0000); 452025e992a4SHeiner Kallweit rtl_set_fifo_size(tp, 0x10, 0x10, 0x02, 0x06); 452125e992a4SHeiner Kallweit rtl_eri_write(tp, 0xcc, ERIAR_MASK_1111, 0x00000050); 452225e992a4SHeiner Kallweit rtl_eri_write(tp, 0xd0, ERIAR_MASK_1111, 0x07ff0060); 452325e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0x1b0, ERIAR_MASK_0001, BIT(4)); 452425e992a4SHeiner Kallweit rtl_w0w1_eri(tp, 0x0d4, ERIAR_MASK_0011, 0x0c00, 0xff00); 452525e992a4SHeiner Kallweit 452625e992a4SHeiner Kallweit rtl_disable_clock_request(tp); 452725e992a4SHeiner Kallweit 452825e992a4SHeiner Kallweit RTL_W8(tp, MCU, RTL_R8(tp, MCU) & ~NOW_IS_OOB); 452925e992a4SHeiner Kallweit 453025e992a4SHeiner Kallweit rtl8168_config_eee_mac(tp); 453125e992a4SHeiner Kallweit 453225e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) | PFM_EN); 453325e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) | PWM_EN); 453425e992a4SHeiner Kallweit RTL_W8(tp, Config5, RTL_R8(tp, Config5) & ~Spi_en); 453525e992a4SHeiner Kallweit 453625e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 453725e992a4SHeiner Kallweit } 453825e992a4SHeiner Kallweit 453925e992a4SHeiner Kallweit static void rtl_hw_start_8168f(struct rtl8169_private *tp) 454025e992a4SHeiner Kallweit { 454125e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 454225e992a4SHeiner Kallweit 454325e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B); 454425e992a4SHeiner Kallweit 454525e992a4SHeiner Kallweit rtl_eri_write(tp, 0xc0, ERIAR_MASK_0011, 0x0000); 454625e992a4SHeiner Kallweit rtl_eri_write(tp, 0xb8, ERIAR_MASK_0011, 0x0000); 454725e992a4SHeiner Kallweit rtl_set_fifo_size(tp, 0x10, 0x10, 0x02, 0x06); 454825e992a4SHeiner Kallweit rtl_reset_packet_filter(tp); 454925e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0x1b0, ERIAR_MASK_0001, BIT(4)); 455025e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0x1d0, ERIAR_MASK_0001, BIT(4)); 455125e992a4SHeiner Kallweit rtl_eri_write(tp, 0xcc, ERIAR_MASK_1111, 0x00000050); 455225e992a4SHeiner Kallweit rtl_eri_write(tp, 0xd0, ERIAR_MASK_1111, 0x00000060); 455325e992a4SHeiner Kallweit 455425e992a4SHeiner Kallweit rtl_disable_clock_request(tp); 455525e992a4SHeiner Kallweit 455625e992a4SHeiner Kallweit RTL_W8(tp, MCU, RTL_R8(tp, MCU) & ~NOW_IS_OOB); 455725e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) | PFM_EN); 455825e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) | PWM_EN); 455925e992a4SHeiner Kallweit RTL_W8(tp, Config5, RTL_R8(tp, Config5) & ~Spi_en); 456025e992a4SHeiner Kallweit 456125e992a4SHeiner Kallweit rtl8168_config_eee_mac(tp); 456225e992a4SHeiner Kallweit } 456325e992a4SHeiner Kallweit 456425e992a4SHeiner Kallweit static void rtl_hw_start_8168f_1(struct rtl8169_private *tp) 456525e992a4SHeiner Kallweit { 456625e992a4SHeiner Kallweit static const struct ephy_info e_info_8168f_1[] = { 456725e992a4SHeiner Kallweit { 0x06, 0x00c0, 0x0020 }, 456825e992a4SHeiner Kallweit { 0x08, 0x0001, 0x0002 }, 456925e992a4SHeiner Kallweit { 0x09, 0x0000, 0x0080 }, 457025e992a4SHeiner Kallweit { 0x19, 0x0000, 0x0224 } 457125e992a4SHeiner Kallweit }; 457225e992a4SHeiner Kallweit 457325e992a4SHeiner Kallweit rtl_hw_start_8168f(tp); 457425e992a4SHeiner Kallweit 457525e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168f_1); 457625e992a4SHeiner Kallweit 457725e992a4SHeiner Kallweit rtl_w0w1_eri(tp, 0x0d4, ERIAR_MASK_0011, 0x0c00, 0xff00); 457825e992a4SHeiner Kallweit } 457925e992a4SHeiner Kallweit 458025e992a4SHeiner Kallweit static void rtl_hw_start_8411(struct rtl8169_private *tp) 458125e992a4SHeiner Kallweit { 458225e992a4SHeiner Kallweit static const struct ephy_info e_info_8168f_1[] = { 458325e992a4SHeiner Kallweit { 0x06, 0x00c0, 0x0020 }, 458425e992a4SHeiner Kallweit { 0x0f, 0xffff, 0x5200 }, 458525e992a4SHeiner Kallweit { 0x1e, 0x0000, 0x4000 }, 458625e992a4SHeiner Kallweit { 0x19, 0x0000, 0x0224 } 458725e992a4SHeiner Kallweit }; 458825e992a4SHeiner Kallweit 458925e992a4SHeiner Kallweit rtl_hw_start_8168f(tp); 459025e992a4SHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 459125e992a4SHeiner Kallweit 459225e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168f_1); 459325e992a4SHeiner Kallweit 459425e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0x0d4, ERIAR_MASK_0011, 0x0c00); 459525e992a4SHeiner Kallweit } 459625e992a4SHeiner Kallweit 459725e992a4SHeiner Kallweit static void rtl_hw_start_8168g(struct rtl8169_private *tp) 459825e992a4SHeiner Kallweit { 459925e992a4SHeiner Kallweit rtl_set_fifo_size(tp, 0x08, 0x10, 0x02, 0x06); 460025e992a4SHeiner Kallweit rtl8168g_set_pause_thresholds(tp, 0x38, 0x48); 460125e992a4SHeiner Kallweit 460225e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 460325e992a4SHeiner Kallweit 460425e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B); 460525e992a4SHeiner Kallweit 460625e992a4SHeiner Kallweit rtl_reset_packet_filter(tp); 460725e992a4SHeiner Kallweit rtl_eri_write(tp, 0x2f8, ERIAR_MASK_0011, 0x1d8f); 460825e992a4SHeiner Kallweit 460925e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) & ~RXDV_GATED_EN); 461025e992a4SHeiner Kallweit 461125e992a4SHeiner Kallweit rtl_eri_write(tp, 0xc0, ERIAR_MASK_0011, 0x0000); 461225e992a4SHeiner Kallweit rtl_eri_write(tp, 0xb8, ERIAR_MASK_0011, 0x0000); 461325e992a4SHeiner Kallweit 461425e992a4SHeiner Kallweit rtl8168_config_eee_mac(tp); 461525e992a4SHeiner Kallweit 461625e992a4SHeiner Kallweit rtl_w0w1_eri(tp, 0x2fc, ERIAR_MASK_0001, 0x01, 0x06); 461725e992a4SHeiner Kallweit rtl_eri_clear_bits(tp, 0x1b0, ERIAR_MASK_0011, BIT(12)); 461825e992a4SHeiner Kallweit 461925e992a4SHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 462025e992a4SHeiner Kallweit } 462125e992a4SHeiner Kallweit 462225e992a4SHeiner Kallweit static void rtl_hw_start_8168g_1(struct rtl8169_private *tp) 462325e992a4SHeiner Kallweit { 462425e992a4SHeiner Kallweit static const struct ephy_info e_info_8168g_1[] = { 462525e992a4SHeiner Kallweit { 0x00, 0x0000, 0x0008 }, 462625e992a4SHeiner Kallweit { 0x0c, 0x37d0, 0x0820 }, 462725e992a4SHeiner Kallweit { 0x1e, 0x0000, 0x0001 }, 462825e992a4SHeiner Kallweit { 0x19, 0x8000, 0x0000 } 462925e992a4SHeiner Kallweit }; 463025e992a4SHeiner Kallweit 463125e992a4SHeiner Kallweit rtl_hw_start_8168g(tp); 463225e992a4SHeiner Kallweit 463325e992a4SHeiner Kallweit /* disable aspm and clock request before access ephy */ 463425e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 463525e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168g_1); 463625e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 463725e992a4SHeiner Kallweit } 463825e992a4SHeiner Kallweit 463925e992a4SHeiner Kallweit static void rtl_hw_start_8168g_2(struct rtl8169_private *tp) 464025e992a4SHeiner Kallweit { 464125e992a4SHeiner Kallweit static const struct ephy_info e_info_8168g_2[] = { 464225e992a4SHeiner Kallweit { 0x00, 0x0000, 0x0008 }, 464325e992a4SHeiner Kallweit { 0x0c, 0x3df0, 0x0200 }, 464425e992a4SHeiner Kallweit { 0x19, 0xffff, 0xfc00 }, 464525e992a4SHeiner Kallweit { 0x1e, 0xffff, 0x20eb } 464625e992a4SHeiner Kallweit }; 464725e992a4SHeiner Kallweit 464825e992a4SHeiner Kallweit rtl_hw_start_8168g(tp); 464925e992a4SHeiner Kallweit 465025e992a4SHeiner Kallweit /* disable aspm and clock request before access ephy */ 465125e992a4SHeiner Kallweit RTL_W8(tp, Config2, RTL_R8(tp, Config2) & ~ClkReqEn); 465225e992a4SHeiner Kallweit RTL_W8(tp, Config5, RTL_R8(tp, Config5) & ~ASPM_en); 465325e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168g_2); 465425e992a4SHeiner Kallweit } 465525e992a4SHeiner Kallweit 465625e992a4SHeiner Kallweit static void rtl_hw_start_8411_2(struct rtl8169_private *tp) 465725e992a4SHeiner Kallweit { 465825e992a4SHeiner Kallweit static const struct ephy_info e_info_8411_2[] = { 465925e992a4SHeiner Kallweit { 0x00, 0x0000, 0x0008 }, 466025e992a4SHeiner Kallweit { 0x0c, 0x3df0, 0x0200 }, 466125e992a4SHeiner Kallweit { 0x0f, 0xffff, 0x5200 }, 466225e992a4SHeiner Kallweit { 0x19, 0x0020, 0x0000 }, 466325e992a4SHeiner Kallweit { 0x1e, 0x0000, 0x2000 } 466425e992a4SHeiner Kallweit }; 466525e992a4SHeiner Kallweit 466625e992a4SHeiner Kallweit rtl_hw_start_8168g(tp); 466725e992a4SHeiner Kallweit 466825e992a4SHeiner Kallweit /* disable aspm and clock request before access ephy */ 466925e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 467025e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8411_2); 467125e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 467225e992a4SHeiner Kallweit } 467325e992a4SHeiner Kallweit 467425e992a4SHeiner Kallweit static void rtl_hw_start_8168h_1(struct rtl8169_private *tp) 467525e992a4SHeiner Kallweit { 467625e992a4SHeiner Kallweit int rg_saw_cnt; 467725e992a4SHeiner Kallweit u32 data; 467825e992a4SHeiner Kallweit static const struct ephy_info e_info_8168h_1[] = { 467925e992a4SHeiner Kallweit { 0x1e, 0x0800, 0x0001 }, 468025e992a4SHeiner Kallweit { 0x1d, 0x0000, 0x0800 }, 468125e992a4SHeiner Kallweit { 0x05, 0xffff, 0x2089 }, 468225e992a4SHeiner Kallweit { 0x06, 0xffff, 0x5881 }, 468325e992a4SHeiner Kallweit { 0x04, 0xffff, 0x154a }, 468425e992a4SHeiner Kallweit { 0x01, 0xffff, 0x068b } 468525e992a4SHeiner Kallweit }; 468625e992a4SHeiner Kallweit 468725e992a4SHeiner Kallweit /* disable aspm and clock request before access ephy */ 468825e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 468925e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168h_1); 469025e992a4SHeiner Kallweit 469125e992a4SHeiner Kallweit rtl_set_fifo_size(tp, 0x08, 0x10, 0x02, 0x06); 469225e992a4SHeiner Kallweit rtl8168g_set_pause_thresholds(tp, 0x38, 0x48); 469325e992a4SHeiner Kallweit 469425e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 469525e992a4SHeiner Kallweit 469625e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B); 469725e992a4SHeiner Kallweit 469825e992a4SHeiner Kallweit rtl_reset_packet_filter(tp); 469925e992a4SHeiner Kallweit 470025e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0xdc, ERIAR_MASK_1111, BIT(4)); 470125e992a4SHeiner Kallweit 470225e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0xd4, ERIAR_MASK_1111, 0x1f00); 470325e992a4SHeiner Kallweit 470425e992a4SHeiner Kallweit rtl_eri_write(tp, 0x5f0, ERIAR_MASK_0011, 0x4f87); 470525e992a4SHeiner Kallweit 470625e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) & ~RXDV_GATED_EN); 470725e992a4SHeiner Kallweit 470825e992a4SHeiner Kallweit rtl_eri_write(tp, 0xc0, ERIAR_MASK_0011, 0x0000); 470925e992a4SHeiner Kallweit rtl_eri_write(tp, 0xb8, ERIAR_MASK_0011, 0x0000); 471025e992a4SHeiner Kallweit 471125e992a4SHeiner Kallweit rtl8168_config_eee_mac(tp); 471225e992a4SHeiner Kallweit 471325e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) & ~PFM_EN); 471425e992a4SHeiner Kallweit RTL_W8(tp, MISC_1, RTL_R8(tp, MISC_1) & ~PFM_D3COLD_EN); 471525e992a4SHeiner Kallweit 471625e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) & ~TX_10M_PS_EN); 471725e992a4SHeiner Kallweit 471825e992a4SHeiner Kallweit rtl_eri_clear_bits(tp, 0x1b0, ERIAR_MASK_0011, BIT(12)); 471925e992a4SHeiner Kallweit 472025e992a4SHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 472125e992a4SHeiner Kallweit 472225e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0c42); 472325e992a4SHeiner Kallweit rg_saw_cnt = (rtl_readphy(tp, 0x13) & 0x3fff); 472425e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 472525e992a4SHeiner Kallweit if (rg_saw_cnt > 0) { 472625e992a4SHeiner Kallweit u16 sw_cnt_1ms_ini; 472725e992a4SHeiner Kallweit 472825e992a4SHeiner Kallweit sw_cnt_1ms_ini = 16000000/rg_saw_cnt; 472925e992a4SHeiner Kallweit sw_cnt_1ms_ini &= 0x0fff; 473025e992a4SHeiner Kallweit data = r8168_mac_ocp_read(tp, 0xd412); 473125e992a4SHeiner Kallweit data &= ~0x0fff; 473225e992a4SHeiner Kallweit data |= sw_cnt_1ms_ini; 473325e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xd412, data); 473425e992a4SHeiner Kallweit } 473525e992a4SHeiner Kallweit 473625e992a4SHeiner Kallweit data = r8168_mac_ocp_read(tp, 0xe056); 473725e992a4SHeiner Kallweit data &= ~0xf0; 473825e992a4SHeiner Kallweit data |= 0x70; 473925e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xe056, data); 474025e992a4SHeiner Kallweit 474125e992a4SHeiner Kallweit data = r8168_mac_ocp_read(tp, 0xe052); 474225e992a4SHeiner Kallweit data &= ~0x6000; 474325e992a4SHeiner Kallweit data |= 0x8008; 474425e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xe052, data); 474525e992a4SHeiner Kallweit 474625e992a4SHeiner Kallweit data = r8168_mac_ocp_read(tp, 0xe0d6); 474725e992a4SHeiner Kallweit data &= ~0x01ff; 474825e992a4SHeiner Kallweit data |= 0x017f; 474925e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xe0d6, data); 475025e992a4SHeiner Kallweit 475125e992a4SHeiner Kallweit data = r8168_mac_ocp_read(tp, 0xd420); 475225e992a4SHeiner Kallweit data &= ~0x0fff; 475325e992a4SHeiner Kallweit data |= 0x047f; 475425e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xd420, data); 475525e992a4SHeiner Kallweit 475625e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xe63e, 0x0001); 475725e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xe63e, 0x0000); 475825e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xc094, 0x0000); 475925e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xc09e, 0x0000); 476025e992a4SHeiner Kallweit 476125e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 476225e992a4SHeiner Kallweit } 476325e992a4SHeiner Kallweit 476425e992a4SHeiner Kallweit static void rtl_hw_start_8168ep(struct rtl8169_private *tp) 476525e992a4SHeiner Kallweit { 476625e992a4SHeiner Kallweit rtl8168ep_stop_cmac(tp); 476725e992a4SHeiner Kallweit 476825e992a4SHeiner Kallweit rtl_set_fifo_size(tp, 0x08, 0x10, 0x02, 0x06); 476925e992a4SHeiner Kallweit rtl8168g_set_pause_thresholds(tp, 0x2f, 0x5f); 477025e992a4SHeiner Kallweit 477125e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 477225e992a4SHeiner Kallweit 477325e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B); 477425e992a4SHeiner Kallweit 477525e992a4SHeiner Kallweit rtl_reset_packet_filter(tp); 477625e992a4SHeiner Kallweit 477725e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0xd4, ERIAR_MASK_1111, 0x1f80); 477825e992a4SHeiner Kallweit 477925e992a4SHeiner Kallweit rtl_eri_write(tp, 0x5f0, ERIAR_MASK_0011, 0x4f87); 478025e992a4SHeiner Kallweit 478125e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) & ~RXDV_GATED_EN); 478225e992a4SHeiner Kallweit 478325e992a4SHeiner Kallweit rtl_eri_write(tp, 0xc0, ERIAR_MASK_0011, 0x0000); 478425e992a4SHeiner Kallweit rtl_eri_write(tp, 0xb8, ERIAR_MASK_0011, 0x0000); 478525e992a4SHeiner Kallweit 478625e992a4SHeiner Kallweit rtl8168_config_eee_mac(tp); 478725e992a4SHeiner Kallweit 478825e992a4SHeiner Kallweit rtl_w0w1_eri(tp, 0x2fc, ERIAR_MASK_0001, 0x01, 0x06); 478925e992a4SHeiner Kallweit 479025e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) & ~TX_10M_PS_EN); 479125e992a4SHeiner Kallweit 479225e992a4SHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 479325e992a4SHeiner Kallweit } 479425e992a4SHeiner Kallweit 479525e992a4SHeiner Kallweit static void rtl_hw_start_8168ep_1(struct rtl8169_private *tp) 479625e992a4SHeiner Kallweit { 479725e992a4SHeiner Kallweit static const struct ephy_info e_info_8168ep_1[] = { 479825e992a4SHeiner Kallweit { 0x00, 0xffff, 0x10ab }, 479925e992a4SHeiner Kallweit { 0x06, 0xffff, 0xf030 }, 480025e992a4SHeiner Kallweit { 0x08, 0xffff, 0x2006 }, 480125e992a4SHeiner Kallweit { 0x0d, 0xffff, 0x1666 }, 480225e992a4SHeiner Kallweit { 0x0c, 0x3ff0, 0x0000 } 480325e992a4SHeiner Kallweit }; 480425e992a4SHeiner Kallweit 480525e992a4SHeiner Kallweit /* disable aspm and clock request before access ephy */ 480625e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 480725e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168ep_1); 480825e992a4SHeiner Kallweit 480925e992a4SHeiner Kallweit rtl_hw_start_8168ep(tp); 481025e992a4SHeiner Kallweit 481125e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 481225e992a4SHeiner Kallweit } 481325e992a4SHeiner Kallweit 481425e992a4SHeiner Kallweit static void rtl_hw_start_8168ep_2(struct rtl8169_private *tp) 481525e992a4SHeiner Kallweit { 481625e992a4SHeiner Kallweit static const struct ephy_info e_info_8168ep_2[] = { 481725e992a4SHeiner Kallweit { 0x00, 0xffff, 0x10a3 }, 481825e992a4SHeiner Kallweit { 0x19, 0xffff, 0xfc00 }, 481925e992a4SHeiner Kallweit { 0x1e, 0xffff, 0x20ea } 482025e992a4SHeiner Kallweit }; 482125e992a4SHeiner Kallweit 482225e992a4SHeiner Kallweit /* disable aspm and clock request before access ephy */ 482325e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 482425e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168ep_2); 482525e992a4SHeiner Kallweit 482625e992a4SHeiner Kallweit rtl_hw_start_8168ep(tp); 482725e992a4SHeiner Kallweit 482825e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) & ~PFM_EN); 482925e992a4SHeiner Kallweit RTL_W8(tp, MISC_1, RTL_R8(tp, MISC_1) & ~PFM_D3COLD_EN); 483025e992a4SHeiner Kallweit 483125e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 483225e992a4SHeiner Kallweit } 483325e992a4SHeiner Kallweit 483425e992a4SHeiner Kallweit static void rtl_hw_start_8168ep_3(struct rtl8169_private *tp) 483525e992a4SHeiner Kallweit { 483625e992a4SHeiner Kallweit u32 data; 483725e992a4SHeiner Kallweit static const struct ephy_info e_info_8168ep_3[] = { 483825e992a4SHeiner Kallweit { 0x00, 0xffff, 0x10a3 }, 483925e992a4SHeiner Kallweit { 0x19, 0xffff, 0x7c00 }, 484025e992a4SHeiner Kallweit { 0x1e, 0xffff, 0x20eb }, 484125e992a4SHeiner Kallweit { 0x0d, 0xffff, 0x1666 } 484225e992a4SHeiner Kallweit }; 484325e992a4SHeiner Kallweit 484425e992a4SHeiner Kallweit /* disable aspm and clock request before access ephy */ 484525e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 484625e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168ep_3); 484725e992a4SHeiner Kallweit 484825e992a4SHeiner Kallweit rtl_hw_start_8168ep(tp); 484925e992a4SHeiner Kallweit 485025e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) & ~PFM_EN); 485125e992a4SHeiner Kallweit RTL_W8(tp, MISC_1, RTL_R8(tp, MISC_1) & ~PFM_D3COLD_EN); 485225e992a4SHeiner Kallweit 485325e992a4SHeiner Kallweit data = r8168_mac_ocp_read(tp, 0xd3e2); 485425e992a4SHeiner Kallweit data &= 0xf000; 485525e992a4SHeiner Kallweit data |= 0x0271; 485625e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xd3e2, data); 485725e992a4SHeiner Kallweit 485825e992a4SHeiner Kallweit data = r8168_mac_ocp_read(tp, 0xd3e4); 485925e992a4SHeiner Kallweit data &= 0xff00; 486025e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xd3e4, data); 486125e992a4SHeiner Kallweit 486225e992a4SHeiner Kallweit data = r8168_mac_ocp_read(tp, 0xe860); 486325e992a4SHeiner Kallweit data |= 0x0080; 486425e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xe860, data); 486525e992a4SHeiner Kallweit 486625e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 486725e992a4SHeiner Kallweit } 486825e992a4SHeiner Kallweit 486925e992a4SHeiner Kallweit static void rtl_hw_start_8102e_1(struct rtl8169_private *tp) 487025e992a4SHeiner Kallweit { 487125e992a4SHeiner Kallweit static const struct ephy_info e_info_8102e_1[] = { 487225e992a4SHeiner Kallweit { 0x01, 0, 0x6e65 }, 487325e992a4SHeiner Kallweit { 0x02, 0, 0x091f }, 487425e992a4SHeiner Kallweit { 0x03, 0, 0xc2f9 }, 487525e992a4SHeiner Kallweit { 0x06, 0, 0xafb5 }, 487625e992a4SHeiner Kallweit { 0x07, 0, 0x0e00 }, 487725e992a4SHeiner Kallweit { 0x19, 0, 0xec80 }, 487825e992a4SHeiner Kallweit { 0x01, 0, 0x2e65 }, 487925e992a4SHeiner Kallweit { 0x01, 0, 0x6e65 } 488025e992a4SHeiner Kallweit }; 488125e992a4SHeiner Kallweit u8 cfg1; 488225e992a4SHeiner Kallweit 488325e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 488425e992a4SHeiner Kallweit 488525e992a4SHeiner Kallweit RTL_W8(tp, DBG_REG, FIX_NAK_1); 488625e992a4SHeiner Kallweit 488725e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B); 488825e992a4SHeiner Kallweit 488925e992a4SHeiner Kallweit RTL_W8(tp, Config1, 489025e992a4SHeiner Kallweit LEDS1 | LEDS0 | Speed_down | MEMMAP | IOMAP | VPD | PMEnable); 489125e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Beacon_en); 489225e992a4SHeiner Kallweit 489325e992a4SHeiner Kallweit cfg1 = RTL_R8(tp, Config1); 489425e992a4SHeiner Kallweit if ((cfg1 & LEDS0) && (cfg1 & LEDS1)) 489525e992a4SHeiner Kallweit RTL_W8(tp, Config1, cfg1 & ~LEDS0); 489625e992a4SHeiner Kallweit 489725e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8102e_1); 489825e992a4SHeiner Kallweit } 489925e992a4SHeiner Kallweit 490025e992a4SHeiner Kallweit static void rtl_hw_start_8102e_2(struct rtl8169_private *tp) 490125e992a4SHeiner Kallweit { 490225e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 490325e992a4SHeiner Kallweit 490425e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B); 490525e992a4SHeiner Kallweit 490625e992a4SHeiner Kallweit RTL_W8(tp, Config1, MEMMAP | IOMAP | VPD | PMEnable); 490725e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Beacon_en); 490825e992a4SHeiner Kallweit } 490925e992a4SHeiner Kallweit 491025e992a4SHeiner Kallweit static void rtl_hw_start_8102e_3(struct rtl8169_private *tp) 491125e992a4SHeiner Kallweit { 491225e992a4SHeiner Kallweit rtl_hw_start_8102e_2(tp); 491325e992a4SHeiner Kallweit 491425e992a4SHeiner Kallweit rtl_ephy_write(tp, 0x03, 0xc2f9); 491525e992a4SHeiner Kallweit } 491625e992a4SHeiner Kallweit 491725e992a4SHeiner Kallweit static void rtl_hw_start_8105e_1(struct rtl8169_private *tp) 491825e992a4SHeiner Kallweit { 491925e992a4SHeiner Kallweit static const struct ephy_info e_info_8105e_1[] = { 492025e992a4SHeiner Kallweit { 0x07, 0, 0x4000 }, 492125e992a4SHeiner Kallweit { 0x19, 0, 0x0200 }, 492225e992a4SHeiner Kallweit { 0x19, 0, 0x0020 }, 492325e992a4SHeiner Kallweit { 0x1e, 0, 0x2000 }, 492425e992a4SHeiner Kallweit { 0x03, 0, 0x0001 }, 492525e992a4SHeiner Kallweit { 0x19, 0, 0x0100 }, 492625e992a4SHeiner Kallweit { 0x19, 0, 0x0004 }, 492725e992a4SHeiner Kallweit { 0x0a, 0, 0x0020 } 492825e992a4SHeiner Kallweit }; 492925e992a4SHeiner Kallweit 493025e992a4SHeiner Kallweit /* Force LAN exit from ASPM if Rx/Tx are not idle */ 493125e992a4SHeiner Kallweit RTL_W32(tp, FuncEvent, RTL_R32(tp, FuncEvent) | 0x002800); 493225e992a4SHeiner Kallweit 493325e992a4SHeiner Kallweit /* Disable Early Tally Counter */ 493425e992a4SHeiner Kallweit RTL_W32(tp, FuncEvent, RTL_R32(tp, FuncEvent) & ~0x010000); 493525e992a4SHeiner Kallweit 493625e992a4SHeiner Kallweit RTL_W8(tp, MCU, RTL_R8(tp, MCU) | EN_NDP | EN_OOB_RESET); 493725e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) | PFM_EN); 493825e992a4SHeiner Kallweit 493925e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8105e_1); 494025e992a4SHeiner Kallweit 494125e992a4SHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 494225e992a4SHeiner Kallweit } 494325e992a4SHeiner Kallweit 494425e992a4SHeiner Kallweit static void rtl_hw_start_8105e_2(struct rtl8169_private *tp) 494525e992a4SHeiner Kallweit { 494625e992a4SHeiner Kallweit rtl_hw_start_8105e_1(tp); 494725e992a4SHeiner Kallweit rtl_ephy_write(tp, 0x1e, rtl_ephy_read(tp, 0x1e) | 0x8000); 494825e992a4SHeiner Kallweit } 494925e992a4SHeiner Kallweit 495025e992a4SHeiner Kallweit static void rtl_hw_start_8402(struct rtl8169_private *tp) 495125e992a4SHeiner Kallweit { 495225e992a4SHeiner Kallweit static const struct ephy_info e_info_8402[] = { 495325e992a4SHeiner Kallweit { 0x19, 0xffff, 0xff64 }, 495425e992a4SHeiner Kallweit { 0x1e, 0, 0x4000 } 495525e992a4SHeiner Kallweit }; 495625e992a4SHeiner Kallweit 495725e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 495825e992a4SHeiner Kallweit 495925e992a4SHeiner Kallweit /* Force LAN exit from ASPM if Rx/Tx are not idle */ 496025e992a4SHeiner Kallweit RTL_W32(tp, FuncEvent, RTL_R32(tp, FuncEvent) | 0x002800); 496125e992a4SHeiner Kallweit 496225e992a4SHeiner Kallweit RTL_W8(tp, MCU, RTL_R8(tp, MCU) & ~NOW_IS_OOB); 496325e992a4SHeiner Kallweit 496425e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8402); 496525e992a4SHeiner Kallweit 496625e992a4SHeiner Kallweit rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B); 496725e992a4SHeiner Kallweit 496825e992a4SHeiner Kallweit rtl_set_fifo_size(tp, 0x00, 0x00, 0x02, 0x06); 496925e992a4SHeiner Kallweit rtl_reset_packet_filter(tp); 497025e992a4SHeiner Kallweit rtl_eri_write(tp, 0xc0, ERIAR_MASK_0011, 0x0000); 497125e992a4SHeiner Kallweit rtl_eri_write(tp, 0xb8, ERIAR_MASK_0011, 0x0000); 497225e992a4SHeiner Kallweit rtl_w0w1_eri(tp, 0x0d4, ERIAR_MASK_0011, 0x0e00, 0xff00); 497325e992a4SHeiner Kallweit 497425e992a4SHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 497525e992a4SHeiner Kallweit } 497625e992a4SHeiner Kallweit 497725e992a4SHeiner Kallweit static void rtl_hw_start_8106(struct rtl8169_private *tp) 497825e992a4SHeiner Kallweit { 497925e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 498025e992a4SHeiner Kallweit 498125e992a4SHeiner Kallweit /* Force LAN exit from ASPM if Rx/Tx are not idle */ 498225e992a4SHeiner Kallweit RTL_W32(tp, FuncEvent, RTL_R32(tp, FuncEvent) | 0x002800); 498325e992a4SHeiner Kallweit 498425e992a4SHeiner Kallweit RTL_W32(tp, MISC, (RTL_R32(tp, MISC) | DISABLE_LAN_EN) & ~EARLY_TALLY_EN); 498525e992a4SHeiner Kallweit RTL_W8(tp, MCU, RTL_R8(tp, MCU) | EN_NDP | EN_OOB_RESET); 498625e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) & ~PFM_EN); 498725e992a4SHeiner Kallweit 498825e992a4SHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 498925e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 499025e992a4SHeiner Kallweit } 499125e992a4SHeiner Kallweit 499225e992a4SHeiner Kallweit static void rtl_hw_config(struct rtl8169_private *tp) 499325e992a4SHeiner Kallweit { 499425e992a4SHeiner Kallweit static const rtl_generic_fct hw_configs[] = { 499525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_07] = rtl_hw_start_8102e_1, 499625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_08] = rtl_hw_start_8102e_3, 499725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_09] = rtl_hw_start_8102e_2, 499825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_10] = NULL, 499925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_11] = rtl_hw_start_8168bb, 500025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_12] = rtl_hw_start_8168bef, 500125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_13] = NULL, 500225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_14] = NULL, 500325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_15] = NULL, 500425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_16] = NULL, 500525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_17] = rtl_hw_start_8168bef, 500625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_18] = rtl_hw_start_8168cp_1, 500725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_19] = rtl_hw_start_8168c_1, 500825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_20] = rtl_hw_start_8168c_2, 500925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_21] = rtl_hw_start_8168c_3, 501025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_22] = rtl_hw_start_8168c_4, 501125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_23] = rtl_hw_start_8168cp_2, 501225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_24] = rtl_hw_start_8168cp_3, 501325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_25] = rtl_hw_start_8168d, 501425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_26] = rtl_hw_start_8168d, 501525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_27] = rtl_hw_start_8168d, 501625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_28] = rtl_hw_start_8168d_4, 501725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_29] = rtl_hw_start_8105e_1, 501825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_30] = rtl_hw_start_8105e_2, 501925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_31] = rtl_hw_start_8168dp, 502025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_32] = rtl_hw_start_8168e_1, 502125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_33] = rtl_hw_start_8168e_1, 502225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_34] = rtl_hw_start_8168e_2, 502325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_35] = rtl_hw_start_8168f_1, 502425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_36] = rtl_hw_start_8168f_1, 502525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_37] = rtl_hw_start_8402, 502625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_38] = rtl_hw_start_8411, 502725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_39] = rtl_hw_start_8106, 502825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_40] = rtl_hw_start_8168g_1, 502925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_41] = rtl_hw_start_8168g_1, 503025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_42] = rtl_hw_start_8168g_2, 503125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_43] = rtl_hw_start_8168g_2, 503225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_44] = rtl_hw_start_8411_2, 503325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_45] = rtl_hw_start_8168h_1, 503425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_46] = rtl_hw_start_8168h_1, 503525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_47] = rtl_hw_start_8168h_1, 503625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_48] = rtl_hw_start_8168h_1, 503725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_49] = rtl_hw_start_8168ep_1, 503825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_50] = rtl_hw_start_8168ep_2, 503925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_51] = rtl_hw_start_8168ep_3, 504025e992a4SHeiner Kallweit }; 504125e992a4SHeiner Kallweit 504225e992a4SHeiner Kallweit if (hw_configs[tp->mac_version]) 504325e992a4SHeiner Kallweit hw_configs[tp->mac_version](tp); 504425e992a4SHeiner Kallweit } 504525e992a4SHeiner Kallweit 504625e992a4SHeiner Kallweit static void rtl_hw_start_8168(struct rtl8169_private *tp) 504725e992a4SHeiner Kallweit { 504825e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_13 || 504925e992a4SHeiner Kallweit tp->mac_version == RTL_GIGA_MAC_VER_16) 505025e992a4SHeiner Kallweit pcie_capability_set_word(tp->pci_dev, PCI_EXP_DEVCTL, 505125e992a4SHeiner Kallweit PCI_EXP_DEVCTL_NOSNOOP_EN); 505225e992a4SHeiner Kallweit 5053272b2265SHeiner Kallweit if (rtl_is_8168evl_up(tp)) 5054272b2265SHeiner Kallweit RTL_W8(tp, MaxTxPacketSize, EarlySize); 5055272b2265SHeiner Kallweit else 505625e992a4SHeiner Kallweit RTL_W8(tp, MaxTxPacketSize, TxPacketMax); 505725e992a4SHeiner Kallweit 505825e992a4SHeiner Kallweit rtl_hw_config(tp); 505925e992a4SHeiner Kallweit } 506025e992a4SHeiner Kallweit 50616c19156eSHeiner Kallweit static void rtl_hw_start_8169(struct rtl8169_private *tp) 50626c19156eSHeiner Kallweit { 50636c19156eSHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_05) 50646c19156eSHeiner Kallweit pci_write_config_byte(tp->pci_dev, PCI_CACHE_LINE_SIZE, 0x08); 50656c19156eSHeiner Kallweit 50666c19156eSHeiner Kallweit RTL_W8(tp, EarlyTxThres, NoEarlyTx); 50676c19156eSHeiner Kallweit 50686c19156eSHeiner Kallweit tp->cp_cmd |= PCIMulRW; 50696c19156eSHeiner Kallweit 50706c19156eSHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_02 || 50716c19156eSHeiner Kallweit tp->mac_version == RTL_GIGA_MAC_VER_03) { 50726c19156eSHeiner Kallweit netif_dbg(tp, drv, tp->dev, 50736c19156eSHeiner Kallweit "Set MAC Reg C+CR Offset 0xe0. Bit 3 and Bit 14 MUST be 1\n"); 50746c19156eSHeiner Kallweit tp->cp_cmd |= (1 << 14); 50756c19156eSHeiner Kallweit } 50766c19156eSHeiner Kallweit 50776c19156eSHeiner Kallweit RTL_W16(tp, CPlusCmd, tp->cp_cmd); 50786c19156eSHeiner Kallweit 50796c19156eSHeiner Kallweit rtl8169_set_magic_reg(tp, tp->mac_version); 50806c19156eSHeiner Kallweit 50816c19156eSHeiner Kallweit RTL_W32(tp, RxMissed, 0); 50826c19156eSHeiner Kallweit } 50836c19156eSHeiner Kallweit 50846c19156eSHeiner Kallweit static void rtl_hw_start(struct rtl8169_private *tp) 50856c19156eSHeiner Kallweit { 50866c19156eSHeiner Kallweit rtl_unlock_config_regs(tp); 50876c19156eSHeiner Kallweit 50886c19156eSHeiner Kallweit tp->cp_cmd &= CPCMD_MASK; 50896c19156eSHeiner Kallweit RTL_W16(tp, CPlusCmd, tp->cp_cmd); 50906c19156eSHeiner Kallweit 50916c19156eSHeiner Kallweit if (tp->mac_version <= RTL_GIGA_MAC_VER_06) 50926c19156eSHeiner Kallweit rtl_hw_start_8169(tp); 50936c19156eSHeiner Kallweit else 50946c19156eSHeiner Kallweit rtl_hw_start_8168(tp); 50956c19156eSHeiner Kallweit 50966c19156eSHeiner Kallweit rtl_set_rx_max_size(tp); 50976c19156eSHeiner Kallweit rtl_set_rx_tx_desc_registers(tp); 50986c19156eSHeiner Kallweit rtl_lock_config_regs(tp); 50996c19156eSHeiner Kallweit 51006c19156eSHeiner Kallweit /* disable interrupt coalescing */ 51016c19156eSHeiner Kallweit RTL_W16(tp, IntrMitigate, 0x0000); 51026c19156eSHeiner Kallweit /* Initially a 10 us delay. Turned it into a PCI commit. - FR */ 51036c19156eSHeiner Kallweit RTL_R8(tp, IntrMask); 51046c19156eSHeiner Kallweit RTL_W8(tp, ChipCmd, CmdTxEnb | CmdRxEnb); 51056c19156eSHeiner Kallweit rtl_init_rxcfg(tp); 51066c19156eSHeiner Kallweit rtl_set_tx_config_registers(tp); 51076c19156eSHeiner Kallweit 51086c19156eSHeiner Kallweit rtl_set_rx_mode(tp->dev); 51096c19156eSHeiner Kallweit /* no early-rx interrupts */ 51106c19156eSHeiner Kallweit RTL_W16(tp, MultiIntr, RTL_R16(tp, MultiIntr) & 0xf000); 51116c19156eSHeiner Kallweit rtl_irq_enable(tp); 51126c19156eSHeiner Kallweit } 51136c19156eSHeiner Kallweit 511425e992a4SHeiner Kallweit static int rtl8169_change_mtu(struct net_device *dev, int new_mtu) 511525e992a4SHeiner Kallweit { 511625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 511725e992a4SHeiner Kallweit 511825e992a4SHeiner Kallweit if (new_mtu > ETH_DATA_LEN) 511925e992a4SHeiner Kallweit rtl_hw_jumbo_enable(tp); 512025e992a4SHeiner Kallweit else 512125e992a4SHeiner Kallweit rtl_hw_jumbo_disable(tp); 512225e992a4SHeiner Kallweit 512325e992a4SHeiner Kallweit dev->mtu = new_mtu; 512425e992a4SHeiner Kallweit netdev_update_features(dev); 512525e992a4SHeiner Kallweit 512625e992a4SHeiner Kallweit return 0; 512725e992a4SHeiner Kallweit } 512825e992a4SHeiner Kallweit 512925e992a4SHeiner Kallweit static inline void rtl8169_make_unusable_by_asic(struct RxDesc *desc) 513025e992a4SHeiner Kallweit { 513125e992a4SHeiner Kallweit desc->addr = cpu_to_le64(0x0badbadbadbadbadull); 513225e992a4SHeiner Kallweit desc->opts1 &= ~cpu_to_le32(DescOwn | RsvdMask); 513325e992a4SHeiner Kallweit } 513425e992a4SHeiner Kallweit 513525e992a4SHeiner Kallweit static void rtl8169_free_rx_databuff(struct rtl8169_private *tp, 513625e992a4SHeiner Kallweit void **data_buff, struct RxDesc *desc) 513725e992a4SHeiner Kallweit { 513825e992a4SHeiner Kallweit dma_unmap_single(tp_to_dev(tp), le64_to_cpu(desc->addr), 513925e992a4SHeiner Kallweit R8169_RX_BUF_SIZE, DMA_FROM_DEVICE); 514025e992a4SHeiner Kallweit 514125e992a4SHeiner Kallweit kfree(*data_buff); 514225e992a4SHeiner Kallweit *data_buff = NULL; 514325e992a4SHeiner Kallweit rtl8169_make_unusable_by_asic(desc); 514425e992a4SHeiner Kallweit } 514525e992a4SHeiner Kallweit 514625e992a4SHeiner Kallweit static inline void rtl8169_mark_to_asic(struct RxDesc *desc) 514725e992a4SHeiner Kallweit { 514825e992a4SHeiner Kallweit u32 eor = le32_to_cpu(desc->opts1) & RingEnd; 514925e992a4SHeiner Kallweit 515025e992a4SHeiner Kallweit /* Force memory writes to complete before releasing descriptor */ 515125e992a4SHeiner Kallweit dma_wmb(); 515225e992a4SHeiner Kallweit 515325e992a4SHeiner Kallweit desc->opts1 = cpu_to_le32(DescOwn | eor | R8169_RX_BUF_SIZE); 515425e992a4SHeiner Kallweit } 515525e992a4SHeiner Kallweit 515625e992a4SHeiner Kallweit static struct sk_buff *rtl8169_alloc_rx_data(struct rtl8169_private *tp, 515725e992a4SHeiner Kallweit struct RxDesc *desc) 515825e992a4SHeiner Kallweit { 515925e992a4SHeiner Kallweit void *data; 516025e992a4SHeiner Kallweit dma_addr_t mapping; 516125e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 516225e992a4SHeiner Kallweit int node = dev_to_node(d); 516325e992a4SHeiner Kallweit 516425e992a4SHeiner Kallweit data = kmalloc_node(R8169_RX_BUF_SIZE, GFP_KERNEL, node); 516525e992a4SHeiner Kallweit if (!data) 516625e992a4SHeiner Kallweit return NULL; 516725e992a4SHeiner Kallweit 516825e992a4SHeiner Kallweit /* Memory should be properly aligned, but better check. */ 516925e992a4SHeiner Kallweit if (!IS_ALIGNED((unsigned long)data, 8)) { 517025e992a4SHeiner Kallweit netdev_err_once(tp->dev, "RX buffer not 8-byte-aligned\n"); 517125e992a4SHeiner Kallweit goto err_out; 517225e992a4SHeiner Kallweit } 517325e992a4SHeiner Kallweit 517425e992a4SHeiner Kallweit mapping = dma_map_single(d, data, R8169_RX_BUF_SIZE, DMA_FROM_DEVICE); 517525e992a4SHeiner Kallweit if (unlikely(dma_mapping_error(d, mapping))) { 517625e992a4SHeiner Kallweit if (net_ratelimit()) 517725e992a4SHeiner Kallweit netif_err(tp, drv, tp->dev, "Failed to map RX DMA!\n"); 517825e992a4SHeiner Kallweit goto err_out; 517925e992a4SHeiner Kallweit } 518025e992a4SHeiner Kallweit 518125e992a4SHeiner Kallweit desc->addr = cpu_to_le64(mapping); 518225e992a4SHeiner Kallweit rtl8169_mark_to_asic(desc); 518325e992a4SHeiner Kallweit return data; 518425e992a4SHeiner Kallweit 518525e992a4SHeiner Kallweit err_out: 518625e992a4SHeiner Kallweit kfree(data); 518725e992a4SHeiner Kallweit return NULL; 518825e992a4SHeiner Kallweit } 518925e992a4SHeiner Kallweit 519025e992a4SHeiner Kallweit static void rtl8169_rx_clear(struct rtl8169_private *tp) 519125e992a4SHeiner Kallweit { 519225e992a4SHeiner Kallweit unsigned int i; 519325e992a4SHeiner Kallweit 519425e992a4SHeiner Kallweit for (i = 0; i < NUM_RX_DESC; i++) { 519525e992a4SHeiner Kallweit if (tp->Rx_databuff[i]) { 519625e992a4SHeiner Kallweit rtl8169_free_rx_databuff(tp, tp->Rx_databuff + i, 519725e992a4SHeiner Kallweit tp->RxDescArray + i); 519825e992a4SHeiner Kallweit } 519925e992a4SHeiner Kallweit } 520025e992a4SHeiner Kallweit } 520125e992a4SHeiner Kallweit 520225e992a4SHeiner Kallweit static inline void rtl8169_mark_as_last_descriptor(struct RxDesc *desc) 520325e992a4SHeiner Kallweit { 520425e992a4SHeiner Kallweit desc->opts1 |= cpu_to_le32(RingEnd); 520525e992a4SHeiner Kallweit } 520625e992a4SHeiner Kallweit 520725e992a4SHeiner Kallweit static int rtl8169_rx_fill(struct rtl8169_private *tp) 520825e992a4SHeiner Kallweit { 520925e992a4SHeiner Kallweit unsigned int i; 521025e992a4SHeiner Kallweit 521125e992a4SHeiner Kallweit for (i = 0; i < NUM_RX_DESC; i++) { 521225e992a4SHeiner Kallweit void *data; 521325e992a4SHeiner Kallweit 521425e992a4SHeiner Kallweit data = rtl8169_alloc_rx_data(tp, tp->RxDescArray + i); 521525e992a4SHeiner Kallweit if (!data) { 521625e992a4SHeiner Kallweit rtl8169_make_unusable_by_asic(tp->RxDescArray + i); 521725e992a4SHeiner Kallweit goto err_out; 521825e992a4SHeiner Kallweit } 521925e992a4SHeiner Kallweit tp->Rx_databuff[i] = data; 522025e992a4SHeiner Kallweit } 522125e992a4SHeiner Kallweit 522225e992a4SHeiner Kallweit rtl8169_mark_as_last_descriptor(tp->RxDescArray + NUM_RX_DESC - 1); 522325e992a4SHeiner Kallweit return 0; 522425e992a4SHeiner Kallweit 522525e992a4SHeiner Kallweit err_out: 522625e992a4SHeiner Kallweit rtl8169_rx_clear(tp); 522725e992a4SHeiner Kallweit return -ENOMEM; 522825e992a4SHeiner Kallweit } 522925e992a4SHeiner Kallweit 523025e992a4SHeiner Kallweit static int rtl8169_init_ring(struct rtl8169_private *tp) 523125e992a4SHeiner Kallweit { 523225e992a4SHeiner Kallweit rtl8169_init_ring_indexes(tp); 523325e992a4SHeiner Kallweit 523425e992a4SHeiner Kallweit memset(tp->tx_skb, 0, sizeof(tp->tx_skb)); 523525e992a4SHeiner Kallweit memset(tp->Rx_databuff, 0, sizeof(tp->Rx_databuff)); 523625e992a4SHeiner Kallweit 523725e992a4SHeiner Kallweit return rtl8169_rx_fill(tp); 523825e992a4SHeiner Kallweit } 523925e992a4SHeiner Kallweit 524025e992a4SHeiner Kallweit static void rtl8169_unmap_tx_skb(struct device *d, struct ring_info *tx_skb, 524125e992a4SHeiner Kallweit struct TxDesc *desc) 524225e992a4SHeiner Kallweit { 524325e992a4SHeiner Kallweit unsigned int len = tx_skb->len; 524425e992a4SHeiner Kallweit 524525e992a4SHeiner Kallweit dma_unmap_single(d, le64_to_cpu(desc->addr), len, DMA_TO_DEVICE); 524625e992a4SHeiner Kallweit 524725e992a4SHeiner Kallweit desc->opts1 = 0x00; 524825e992a4SHeiner Kallweit desc->opts2 = 0x00; 524925e992a4SHeiner Kallweit desc->addr = 0x00; 525025e992a4SHeiner Kallweit tx_skb->len = 0; 525125e992a4SHeiner Kallweit } 525225e992a4SHeiner Kallweit 525325e992a4SHeiner Kallweit static void rtl8169_tx_clear_range(struct rtl8169_private *tp, u32 start, 525425e992a4SHeiner Kallweit unsigned int n) 525525e992a4SHeiner Kallweit { 525625e992a4SHeiner Kallweit unsigned int i; 525725e992a4SHeiner Kallweit 525825e992a4SHeiner Kallweit for (i = 0; i < n; i++) { 525925e992a4SHeiner Kallweit unsigned int entry = (start + i) % NUM_TX_DESC; 526025e992a4SHeiner Kallweit struct ring_info *tx_skb = tp->tx_skb + entry; 526125e992a4SHeiner Kallweit unsigned int len = tx_skb->len; 526225e992a4SHeiner Kallweit 526325e992a4SHeiner Kallweit if (len) { 526425e992a4SHeiner Kallweit struct sk_buff *skb = tx_skb->skb; 526525e992a4SHeiner Kallweit 526625e992a4SHeiner Kallweit rtl8169_unmap_tx_skb(tp_to_dev(tp), tx_skb, 526725e992a4SHeiner Kallweit tp->TxDescArray + entry); 526825e992a4SHeiner Kallweit if (skb) { 526925e992a4SHeiner Kallweit dev_consume_skb_any(skb); 527025e992a4SHeiner Kallweit tx_skb->skb = NULL; 527125e992a4SHeiner Kallweit } 527225e992a4SHeiner Kallweit } 527325e992a4SHeiner Kallweit } 527425e992a4SHeiner Kallweit } 527525e992a4SHeiner Kallweit 527625e992a4SHeiner Kallweit static void rtl8169_tx_clear(struct rtl8169_private *tp) 527725e992a4SHeiner Kallweit { 527825e992a4SHeiner Kallweit rtl8169_tx_clear_range(tp, tp->dirty_tx, NUM_TX_DESC); 527925e992a4SHeiner Kallweit tp->cur_tx = tp->dirty_tx = 0; 528025e992a4SHeiner Kallweit netdev_reset_queue(tp->dev); 528125e992a4SHeiner Kallweit } 528225e992a4SHeiner Kallweit 528325e992a4SHeiner Kallweit static void rtl_reset_work(struct rtl8169_private *tp) 528425e992a4SHeiner Kallweit { 528525e992a4SHeiner Kallweit struct net_device *dev = tp->dev; 528625e992a4SHeiner Kallweit int i; 528725e992a4SHeiner Kallweit 528825e992a4SHeiner Kallweit napi_disable(&tp->napi); 528925e992a4SHeiner Kallweit netif_stop_queue(dev); 529025e992a4SHeiner Kallweit synchronize_rcu(); 529125e992a4SHeiner Kallweit 529225e992a4SHeiner Kallweit rtl8169_hw_reset(tp); 529325e992a4SHeiner Kallweit 529425e992a4SHeiner Kallweit for (i = 0; i < NUM_RX_DESC; i++) 529525e992a4SHeiner Kallweit rtl8169_mark_to_asic(tp->RxDescArray + i); 529625e992a4SHeiner Kallweit 529725e992a4SHeiner Kallweit rtl8169_tx_clear(tp); 529825e992a4SHeiner Kallweit rtl8169_init_ring_indexes(tp); 529925e992a4SHeiner Kallweit 530025e992a4SHeiner Kallweit napi_enable(&tp->napi); 530125e992a4SHeiner Kallweit rtl_hw_start(tp); 530225e992a4SHeiner Kallweit netif_wake_queue(dev); 530325e992a4SHeiner Kallweit } 530425e992a4SHeiner Kallweit 530525e992a4SHeiner Kallweit static void rtl8169_tx_timeout(struct net_device *dev) 530625e992a4SHeiner Kallweit { 530725e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 530825e992a4SHeiner Kallweit 530925e992a4SHeiner Kallweit rtl_schedule_task(tp, RTL_FLAG_TASK_RESET_PENDING); 531025e992a4SHeiner Kallweit } 531125e992a4SHeiner Kallweit 531225e992a4SHeiner Kallweit static __le32 rtl8169_get_txd_opts1(u32 opts0, u32 len, unsigned int entry) 531325e992a4SHeiner Kallweit { 531425e992a4SHeiner Kallweit u32 status = opts0 | len; 531525e992a4SHeiner Kallweit 531625e992a4SHeiner Kallweit if (entry == NUM_TX_DESC - 1) 531725e992a4SHeiner Kallweit status |= RingEnd; 531825e992a4SHeiner Kallweit 531925e992a4SHeiner Kallweit return cpu_to_le32(status); 532025e992a4SHeiner Kallweit } 532125e992a4SHeiner Kallweit 532225e992a4SHeiner Kallweit static int rtl8169_xmit_frags(struct rtl8169_private *tp, struct sk_buff *skb, 532325e992a4SHeiner Kallweit u32 *opts) 532425e992a4SHeiner Kallweit { 532525e992a4SHeiner Kallweit struct skb_shared_info *info = skb_shinfo(skb); 532625e992a4SHeiner Kallweit unsigned int cur_frag, entry; 532725e992a4SHeiner Kallweit struct TxDesc *uninitialized_var(txd); 532825e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 532925e992a4SHeiner Kallweit 533025e992a4SHeiner Kallweit entry = tp->cur_tx; 533125e992a4SHeiner Kallweit for (cur_frag = 0; cur_frag < info->nr_frags; cur_frag++) { 533225e992a4SHeiner Kallweit const skb_frag_t *frag = info->frags + cur_frag; 533325e992a4SHeiner Kallweit dma_addr_t mapping; 533425e992a4SHeiner Kallweit u32 len; 533525e992a4SHeiner Kallweit void *addr; 533625e992a4SHeiner Kallweit 533725e992a4SHeiner Kallweit entry = (entry + 1) % NUM_TX_DESC; 533825e992a4SHeiner Kallweit 533925e992a4SHeiner Kallweit txd = tp->TxDescArray + entry; 534025e992a4SHeiner Kallweit len = skb_frag_size(frag); 534125e992a4SHeiner Kallweit addr = skb_frag_address(frag); 534225e992a4SHeiner Kallweit mapping = dma_map_single(d, addr, len, DMA_TO_DEVICE); 534325e992a4SHeiner Kallweit if (unlikely(dma_mapping_error(d, mapping))) { 534425e992a4SHeiner Kallweit if (net_ratelimit()) 534525e992a4SHeiner Kallweit netif_err(tp, drv, tp->dev, 534625e992a4SHeiner Kallweit "Failed to map TX fragments DMA!\n"); 534725e992a4SHeiner Kallweit goto err_out; 534825e992a4SHeiner Kallweit } 534925e992a4SHeiner Kallweit 535025e992a4SHeiner Kallweit txd->opts1 = rtl8169_get_txd_opts1(opts[0], len, entry); 535125e992a4SHeiner Kallweit txd->opts2 = cpu_to_le32(opts[1]); 535225e992a4SHeiner Kallweit txd->addr = cpu_to_le64(mapping); 535325e992a4SHeiner Kallweit 535425e992a4SHeiner Kallweit tp->tx_skb[entry].len = len; 535525e992a4SHeiner Kallweit } 535625e992a4SHeiner Kallweit 535725e992a4SHeiner Kallweit if (cur_frag) { 535825e992a4SHeiner Kallweit tp->tx_skb[entry].skb = skb; 535925e992a4SHeiner Kallweit txd->opts1 |= cpu_to_le32(LastFrag); 536025e992a4SHeiner Kallweit } 536125e992a4SHeiner Kallweit 536225e992a4SHeiner Kallweit return cur_frag; 536325e992a4SHeiner Kallweit 536425e992a4SHeiner Kallweit err_out: 536525e992a4SHeiner Kallweit rtl8169_tx_clear_range(tp, tp->cur_tx + 1, cur_frag); 536625e992a4SHeiner Kallweit return -EIO; 536725e992a4SHeiner Kallweit } 536825e992a4SHeiner Kallweit 536925e992a4SHeiner Kallweit static bool rtl_test_hw_pad_bug(struct rtl8169_private *tp, struct sk_buff *skb) 537025e992a4SHeiner Kallweit { 537125e992a4SHeiner Kallweit return skb->len < ETH_ZLEN && tp->mac_version == RTL_GIGA_MAC_VER_34; 537225e992a4SHeiner Kallweit } 537325e992a4SHeiner Kallweit 537425e992a4SHeiner Kallweit static netdev_tx_t rtl8169_start_xmit(struct sk_buff *skb, 537525e992a4SHeiner Kallweit struct net_device *dev); 537625e992a4SHeiner Kallweit /* r8169_csum_workaround() 537725e992a4SHeiner Kallweit * The hw limites the value the transport offset. When the offset is out of the 537825e992a4SHeiner Kallweit * range, calculate the checksum by sw. 537925e992a4SHeiner Kallweit */ 538025e992a4SHeiner Kallweit static void r8169_csum_workaround(struct rtl8169_private *tp, 538125e992a4SHeiner Kallweit struct sk_buff *skb) 538225e992a4SHeiner Kallweit { 538325e992a4SHeiner Kallweit if (skb_is_gso(skb)) { 538425e992a4SHeiner Kallweit netdev_features_t features = tp->dev->features; 538525e992a4SHeiner Kallweit struct sk_buff *segs, *nskb; 538625e992a4SHeiner Kallweit 538725e992a4SHeiner Kallweit features &= ~(NETIF_F_SG | NETIF_F_IPV6_CSUM | NETIF_F_TSO6); 538825e992a4SHeiner Kallweit segs = skb_gso_segment(skb, features); 538925e992a4SHeiner Kallweit if (IS_ERR(segs) || !segs) 539025e992a4SHeiner Kallweit goto drop; 539125e992a4SHeiner Kallweit 539225e992a4SHeiner Kallweit do { 539325e992a4SHeiner Kallweit nskb = segs; 539425e992a4SHeiner Kallweit segs = segs->next; 539525e992a4SHeiner Kallweit nskb->next = NULL; 539625e992a4SHeiner Kallweit rtl8169_start_xmit(nskb, tp->dev); 539725e992a4SHeiner Kallweit } while (segs); 539825e992a4SHeiner Kallweit 539925e992a4SHeiner Kallweit dev_consume_skb_any(skb); 540025e992a4SHeiner Kallweit } else if (skb->ip_summed == CHECKSUM_PARTIAL) { 540125e992a4SHeiner Kallweit if (skb_checksum_help(skb) < 0) 540225e992a4SHeiner Kallweit goto drop; 540325e992a4SHeiner Kallweit 540425e992a4SHeiner Kallweit rtl8169_start_xmit(skb, tp->dev); 540525e992a4SHeiner Kallweit } else { 540625e992a4SHeiner Kallweit drop: 540725e992a4SHeiner Kallweit tp->dev->stats.tx_dropped++; 540825e992a4SHeiner Kallweit dev_kfree_skb_any(skb); 540925e992a4SHeiner Kallweit } 541025e992a4SHeiner Kallweit } 541125e992a4SHeiner Kallweit 541225e992a4SHeiner Kallweit /* msdn_giant_send_check() 541325e992a4SHeiner Kallweit * According to the document of microsoft, the TCP Pseudo Header excludes the 541425e992a4SHeiner Kallweit * packet length for IPv6 TCP large packets. 541525e992a4SHeiner Kallweit */ 541625e992a4SHeiner Kallweit static int msdn_giant_send_check(struct sk_buff *skb) 541725e992a4SHeiner Kallweit { 541825e992a4SHeiner Kallweit const struct ipv6hdr *ipv6h; 541925e992a4SHeiner Kallweit struct tcphdr *th; 542025e992a4SHeiner Kallweit int ret; 542125e992a4SHeiner Kallweit 542225e992a4SHeiner Kallweit ret = skb_cow_head(skb, 0); 542325e992a4SHeiner Kallweit if (ret) 542425e992a4SHeiner Kallweit return ret; 542525e992a4SHeiner Kallweit 542625e992a4SHeiner Kallweit ipv6h = ipv6_hdr(skb); 542725e992a4SHeiner Kallweit th = tcp_hdr(skb); 542825e992a4SHeiner Kallweit 542925e992a4SHeiner Kallweit th->check = 0; 543025e992a4SHeiner Kallweit th->check = ~tcp_v6_check(0, &ipv6h->saddr, &ipv6h->daddr, 0); 543125e992a4SHeiner Kallweit 543225e992a4SHeiner Kallweit return ret; 543325e992a4SHeiner Kallweit } 543425e992a4SHeiner Kallweit 543525e992a4SHeiner Kallweit static void rtl8169_tso_csum_v1(struct sk_buff *skb, u32 *opts) 543625e992a4SHeiner Kallweit { 543725e992a4SHeiner Kallweit u32 mss = skb_shinfo(skb)->gso_size; 543825e992a4SHeiner Kallweit 543925e992a4SHeiner Kallweit if (mss) { 544025e992a4SHeiner Kallweit opts[0] |= TD_LSO; 544125e992a4SHeiner Kallweit opts[0] |= min(mss, TD_MSS_MAX) << TD0_MSS_SHIFT; 544225e992a4SHeiner Kallweit } else if (skb->ip_summed == CHECKSUM_PARTIAL) { 544325e992a4SHeiner Kallweit const struct iphdr *ip = ip_hdr(skb); 544425e992a4SHeiner Kallweit 544525e992a4SHeiner Kallweit if (ip->protocol == IPPROTO_TCP) 544625e992a4SHeiner Kallweit opts[0] |= TD0_IP_CS | TD0_TCP_CS; 544725e992a4SHeiner Kallweit else if (ip->protocol == IPPROTO_UDP) 544825e992a4SHeiner Kallweit opts[0] |= TD0_IP_CS | TD0_UDP_CS; 544925e992a4SHeiner Kallweit else 545025e992a4SHeiner Kallweit WARN_ON_ONCE(1); 545125e992a4SHeiner Kallweit } 545225e992a4SHeiner Kallweit } 545325e992a4SHeiner Kallweit 545425e992a4SHeiner Kallweit static bool rtl8169_tso_csum_v2(struct rtl8169_private *tp, 545525e992a4SHeiner Kallweit struct sk_buff *skb, u32 *opts) 545625e992a4SHeiner Kallweit { 545725e992a4SHeiner Kallweit u32 transport_offset = (u32)skb_transport_offset(skb); 545825e992a4SHeiner Kallweit u32 mss = skb_shinfo(skb)->gso_size; 545925e992a4SHeiner Kallweit 546025e992a4SHeiner Kallweit if (mss) { 546125e992a4SHeiner Kallweit if (transport_offset > GTTCPHO_MAX) { 546225e992a4SHeiner Kallweit netif_warn(tp, tx_err, tp->dev, 546325e992a4SHeiner Kallweit "Invalid transport offset 0x%x for TSO\n", 546425e992a4SHeiner Kallweit transport_offset); 546525e992a4SHeiner Kallweit return false; 546625e992a4SHeiner Kallweit } 546725e992a4SHeiner Kallweit 546825e992a4SHeiner Kallweit switch (vlan_get_protocol(skb)) { 546925e992a4SHeiner Kallweit case htons(ETH_P_IP): 547025e992a4SHeiner Kallweit opts[0] |= TD1_GTSENV4; 547125e992a4SHeiner Kallweit break; 547225e992a4SHeiner Kallweit 547325e992a4SHeiner Kallweit case htons(ETH_P_IPV6): 547425e992a4SHeiner Kallweit if (msdn_giant_send_check(skb)) 547525e992a4SHeiner Kallweit return false; 547625e992a4SHeiner Kallweit 547725e992a4SHeiner Kallweit opts[0] |= TD1_GTSENV6; 547825e992a4SHeiner Kallweit break; 547925e992a4SHeiner Kallweit 548025e992a4SHeiner Kallweit default: 548125e992a4SHeiner Kallweit WARN_ON_ONCE(1); 548225e992a4SHeiner Kallweit break; 548325e992a4SHeiner Kallweit } 548425e992a4SHeiner Kallweit 548525e992a4SHeiner Kallweit opts[0] |= transport_offset << GTTCPHO_SHIFT; 548625e992a4SHeiner Kallweit opts[1] |= min(mss, TD_MSS_MAX) << TD1_MSS_SHIFT; 548725e992a4SHeiner Kallweit } else if (skb->ip_summed == CHECKSUM_PARTIAL) { 548825e992a4SHeiner Kallweit u8 ip_protocol; 548925e992a4SHeiner Kallweit 549025e992a4SHeiner Kallweit if (unlikely(rtl_test_hw_pad_bug(tp, skb))) 549125e992a4SHeiner Kallweit return !(skb_checksum_help(skb) || eth_skb_pad(skb)); 549225e992a4SHeiner Kallweit 549325e992a4SHeiner Kallweit if (transport_offset > TCPHO_MAX) { 549425e992a4SHeiner Kallweit netif_warn(tp, tx_err, tp->dev, 549525e992a4SHeiner Kallweit "Invalid transport offset 0x%x\n", 549625e992a4SHeiner Kallweit transport_offset); 549725e992a4SHeiner Kallweit return false; 549825e992a4SHeiner Kallweit } 549925e992a4SHeiner Kallweit 550025e992a4SHeiner Kallweit switch (vlan_get_protocol(skb)) { 550125e992a4SHeiner Kallweit case htons(ETH_P_IP): 550225e992a4SHeiner Kallweit opts[1] |= TD1_IPv4_CS; 550325e992a4SHeiner Kallweit ip_protocol = ip_hdr(skb)->protocol; 550425e992a4SHeiner Kallweit break; 550525e992a4SHeiner Kallweit 550625e992a4SHeiner Kallweit case htons(ETH_P_IPV6): 550725e992a4SHeiner Kallweit opts[1] |= TD1_IPv6_CS; 550825e992a4SHeiner Kallweit ip_protocol = ipv6_hdr(skb)->nexthdr; 550925e992a4SHeiner Kallweit break; 551025e992a4SHeiner Kallweit 551125e992a4SHeiner Kallweit default: 551225e992a4SHeiner Kallweit ip_protocol = IPPROTO_RAW; 551325e992a4SHeiner Kallweit break; 551425e992a4SHeiner Kallweit } 551525e992a4SHeiner Kallweit 551625e992a4SHeiner Kallweit if (ip_protocol == IPPROTO_TCP) 551725e992a4SHeiner Kallweit opts[1] |= TD1_TCP_CS; 551825e992a4SHeiner Kallweit else if (ip_protocol == IPPROTO_UDP) 551925e992a4SHeiner Kallweit opts[1] |= TD1_UDP_CS; 552025e992a4SHeiner Kallweit else 552125e992a4SHeiner Kallweit WARN_ON_ONCE(1); 552225e992a4SHeiner Kallweit 552325e992a4SHeiner Kallweit opts[1] |= transport_offset << TCPHO_SHIFT; 552425e992a4SHeiner Kallweit } else { 552525e992a4SHeiner Kallweit if (unlikely(rtl_test_hw_pad_bug(tp, skb))) 552625e992a4SHeiner Kallweit return !eth_skb_pad(skb); 552725e992a4SHeiner Kallweit } 552825e992a4SHeiner Kallweit 552925e992a4SHeiner Kallweit return true; 553025e992a4SHeiner Kallweit } 553125e992a4SHeiner Kallweit 553225e992a4SHeiner Kallweit static bool rtl_tx_slots_avail(struct rtl8169_private *tp, 553325e992a4SHeiner Kallweit unsigned int nr_frags) 553425e992a4SHeiner Kallweit { 553525e992a4SHeiner Kallweit unsigned int slots_avail = tp->dirty_tx + NUM_TX_DESC - tp->cur_tx; 553625e992a4SHeiner Kallweit 553725e992a4SHeiner Kallweit /* A skbuff with nr_frags needs nr_frags+1 entries in the tx queue */ 553825e992a4SHeiner Kallweit return slots_avail > nr_frags; 553925e992a4SHeiner Kallweit } 554025e992a4SHeiner Kallweit 554125e992a4SHeiner Kallweit /* Versions RTL8102e and from RTL8168c onwards support csum_v2 */ 554225e992a4SHeiner Kallweit static bool rtl_chip_supports_csum_v2(struct rtl8169_private *tp) 554325e992a4SHeiner Kallweit { 554425e992a4SHeiner Kallweit switch (tp->mac_version) { 554525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_02 ... RTL_GIGA_MAC_VER_06: 554625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_10 ... RTL_GIGA_MAC_VER_17: 554725e992a4SHeiner Kallweit return false; 554825e992a4SHeiner Kallweit default: 554925e992a4SHeiner Kallweit return true; 555025e992a4SHeiner Kallweit } 555125e992a4SHeiner Kallweit } 555225e992a4SHeiner Kallweit 555325e992a4SHeiner Kallweit static netdev_tx_t rtl8169_start_xmit(struct sk_buff *skb, 555425e992a4SHeiner Kallweit struct net_device *dev) 555525e992a4SHeiner Kallweit { 555625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 555725e992a4SHeiner Kallweit unsigned int entry = tp->cur_tx % NUM_TX_DESC; 555825e992a4SHeiner Kallweit struct TxDesc *txd = tp->TxDescArray + entry; 555925e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 556025e992a4SHeiner Kallweit dma_addr_t mapping; 556125e992a4SHeiner Kallweit u32 opts[2], len; 556225e992a4SHeiner Kallweit int frags; 556325e992a4SHeiner Kallweit 556425e992a4SHeiner Kallweit if (unlikely(!rtl_tx_slots_avail(tp, skb_shinfo(skb)->nr_frags))) { 556525e992a4SHeiner Kallweit netif_err(tp, drv, dev, "BUG! Tx Ring full when queue awake!\n"); 556625e992a4SHeiner Kallweit goto err_stop_0; 556725e992a4SHeiner Kallweit } 556825e992a4SHeiner Kallweit 556925e992a4SHeiner Kallweit if (unlikely(le32_to_cpu(txd->opts1) & DescOwn)) 557025e992a4SHeiner Kallweit goto err_stop_0; 557125e992a4SHeiner Kallweit 5572355f948aSHeiner Kallweit opts[1] = rtl8169_tx_vlan_tag(skb); 557325e992a4SHeiner Kallweit opts[0] = DescOwn; 557425e992a4SHeiner Kallweit 557525e992a4SHeiner Kallweit if (rtl_chip_supports_csum_v2(tp)) { 557625e992a4SHeiner Kallweit if (!rtl8169_tso_csum_v2(tp, skb, opts)) { 557725e992a4SHeiner Kallweit r8169_csum_workaround(tp, skb); 557825e992a4SHeiner Kallweit return NETDEV_TX_OK; 557925e992a4SHeiner Kallweit } 558025e992a4SHeiner Kallweit } else { 558125e992a4SHeiner Kallweit rtl8169_tso_csum_v1(skb, opts); 558225e992a4SHeiner Kallweit } 558325e992a4SHeiner Kallweit 558425e992a4SHeiner Kallweit len = skb_headlen(skb); 558525e992a4SHeiner Kallweit mapping = dma_map_single(d, skb->data, len, DMA_TO_DEVICE); 558625e992a4SHeiner Kallweit if (unlikely(dma_mapping_error(d, mapping))) { 558725e992a4SHeiner Kallweit if (net_ratelimit()) 558825e992a4SHeiner Kallweit netif_err(tp, drv, dev, "Failed to map TX DMA!\n"); 558925e992a4SHeiner Kallweit goto err_dma_0; 559025e992a4SHeiner Kallweit } 559125e992a4SHeiner Kallweit 559225e992a4SHeiner Kallweit tp->tx_skb[entry].len = len; 559325e992a4SHeiner Kallweit txd->addr = cpu_to_le64(mapping); 559425e992a4SHeiner Kallweit 559525e992a4SHeiner Kallweit frags = rtl8169_xmit_frags(tp, skb, opts); 559625e992a4SHeiner Kallweit if (frags < 0) 559725e992a4SHeiner Kallweit goto err_dma_1; 559825e992a4SHeiner Kallweit else if (frags) 559925e992a4SHeiner Kallweit opts[0] |= FirstFrag; 560025e992a4SHeiner Kallweit else { 560125e992a4SHeiner Kallweit opts[0] |= FirstFrag | LastFrag; 560225e992a4SHeiner Kallweit tp->tx_skb[entry].skb = skb; 560325e992a4SHeiner Kallweit } 560425e992a4SHeiner Kallweit 560525e992a4SHeiner Kallweit txd->opts2 = cpu_to_le32(opts[1]); 560625e992a4SHeiner Kallweit 560725e992a4SHeiner Kallweit netdev_sent_queue(dev, skb->len); 560825e992a4SHeiner Kallweit 560925e992a4SHeiner Kallweit skb_tx_timestamp(skb); 561025e992a4SHeiner Kallweit 561125e992a4SHeiner Kallweit /* Force memory writes to complete before releasing descriptor */ 561225e992a4SHeiner Kallweit dma_wmb(); 561325e992a4SHeiner Kallweit 561425e992a4SHeiner Kallweit txd->opts1 = rtl8169_get_txd_opts1(opts[0], len, entry); 561525e992a4SHeiner Kallweit 561625e992a4SHeiner Kallweit /* Force all memory writes to complete before notifying device */ 561725e992a4SHeiner Kallweit wmb(); 561825e992a4SHeiner Kallweit 561925e992a4SHeiner Kallweit tp->cur_tx += frags + 1; 562025e992a4SHeiner Kallweit 562125e992a4SHeiner Kallweit RTL_W8(tp, TxPoll, NPQ); 562225e992a4SHeiner Kallweit 562325e992a4SHeiner Kallweit if (!rtl_tx_slots_avail(tp, MAX_SKB_FRAGS)) { 562425e992a4SHeiner Kallweit /* Avoid wrongly optimistic queue wake-up: rtl_tx thread must 562525e992a4SHeiner Kallweit * not miss a ring update when it notices a stopped queue. 562625e992a4SHeiner Kallweit */ 562725e992a4SHeiner Kallweit smp_wmb(); 562825e992a4SHeiner Kallweit netif_stop_queue(dev); 562925e992a4SHeiner Kallweit /* Sync with rtl_tx: 563025e992a4SHeiner Kallweit * - publish queue status and cur_tx ring index (write barrier) 563125e992a4SHeiner Kallweit * - refresh dirty_tx ring index (read barrier). 563225e992a4SHeiner Kallweit * May the current thread have a pessimistic view of the ring 563325e992a4SHeiner Kallweit * status and forget to wake up queue, a racing rtl_tx thread 563425e992a4SHeiner Kallweit * can't. 563525e992a4SHeiner Kallweit */ 563625e992a4SHeiner Kallweit smp_mb(); 563725e992a4SHeiner Kallweit if (rtl_tx_slots_avail(tp, MAX_SKB_FRAGS)) 563825e992a4SHeiner Kallweit netif_start_queue(dev); 563925e992a4SHeiner Kallweit } 564025e992a4SHeiner Kallweit 564125e992a4SHeiner Kallweit return NETDEV_TX_OK; 564225e992a4SHeiner Kallweit 564325e992a4SHeiner Kallweit err_dma_1: 564425e992a4SHeiner Kallweit rtl8169_unmap_tx_skb(d, tp->tx_skb + entry, txd); 564525e992a4SHeiner Kallweit err_dma_0: 564625e992a4SHeiner Kallweit dev_kfree_skb_any(skb); 564725e992a4SHeiner Kallweit dev->stats.tx_dropped++; 564825e992a4SHeiner Kallweit return NETDEV_TX_OK; 564925e992a4SHeiner Kallweit 565025e992a4SHeiner Kallweit err_stop_0: 565125e992a4SHeiner Kallweit netif_stop_queue(dev); 565225e992a4SHeiner Kallweit dev->stats.tx_dropped++; 565325e992a4SHeiner Kallweit return NETDEV_TX_BUSY; 565425e992a4SHeiner Kallweit } 565525e992a4SHeiner Kallweit 565625e992a4SHeiner Kallweit static void rtl8169_pcierr_interrupt(struct net_device *dev) 565725e992a4SHeiner Kallweit { 565825e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 565925e992a4SHeiner Kallweit struct pci_dev *pdev = tp->pci_dev; 566025e992a4SHeiner Kallweit u16 pci_status, pci_cmd; 566125e992a4SHeiner Kallweit 566225e992a4SHeiner Kallweit pci_read_config_word(pdev, PCI_COMMAND, &pci_cmd); 566325e992a4SHeiner Kallweit pci_read_config_word(pdev, PCI_STATUS, &pci_status); 566425e992a4SHeiner Kallweit 566525e992a4SHeiner Kallweit netif_err(tp, intr, dev, "PCI error (cmd = 0x%04x, status = 0x%04x)\n", 566625e992a4SHeiner Kallweit pci_cmd, pci_status); 566725e992a4SHeiner Kallweit 566825e992a4SHeiner Kallweit /* 566925e992a4SHeiner Kallweit * The recovery sequence below admits a very elaborated explanation: 567025e992a4SHeiner Kallweit * - it seems to work; 567125e992a4SHeiner Kallweit * - I did not see what else could be done; 567225e992a4SHeiner Kallweit * - it makes iop3xx happy. 567325e992a4SHeiner Kallweit * 567425e992a4SHeiner Kallweit * Feel free to adjust to your needs. 567525e992a4SHeiner Kallweit */ 567625e992a4SHeiner Kallweit if (pdev->broken_parity_status) 567725e992a4SHeiner Kallweit pci_cmd &= ~PCI_COMMAND_PARITY; 567825e992a4SHeiner Kallweit else 567925e992a4SHeiner Kallweit pci_cmd |= PCI_COMMAND_SERR | PCI_COMMAND_PARITY; 568025e992a4SHeiner Kallweit 568125e992a4SHeiner Kallweit pci_write_config_word(pdev, PCI_COMMAND, pci_cmd); 568225e992a4SHeiner Kallweit 568325e992a4SHeiner Kallweit pci_write_config_word(pdev, PCI_STATUS, 568425e992a4SHeiner Kallweit pci_status & (PCI_STATUS_DETECTED_PARITY | 568525e992a4SHeiner Kallweit PCI_STATUS_SIG_SYSTEM_ERROR | PCI_STATUS_REC_MASTER_ABORT | 568625e992a4SHeiner Kallweit PCI_STATUS_REC_TARGET_ABORT | PCI_STATUS_SIG_TARGET_ABORT)); 568725e992a4SHeiner Kallweit 568825e992a4SHeiner Kallweit rtl_schedule_task(tp, RTL_FLAG_TASK_RESET_PENDING); 568925e992a4SHeiner Kallweit } 569025e992a4SHeiner Kallweit 569125e992a4SHeiner Kallweit static void rtl_tx(struct net_device *dev, struct rtl8169_private *tp, 569225e992a4SHeiner Kallweit int budget) 569325e992a4SHeiner Kallweit { 569425e992a4SHeiner Kallweit unsigned int dirty_tx, tx_left, bytes_compl = 0, pkts_compl = 0; 569525e992a4SHeiner Kallweit 569625e992a4SHeiner Kallweit dirty_tx = tp->dirty_tx; 569725e992a4SHeiner Kallweit smp_rmb(); 569825e992a4SHeiner Kallweit tx_left = tp->cur_tx - dirty_tx; 569925e992a4SHeiner Kallweit 570025e992a4SHeiner Kallweit while (tx_left > 0) { 570125e992a4SHeiner Kallweit unsigned int entry = dirty_tx % NUM_TX_DESC; 570225e992a4SHeiner Kallweit struct ring_info *tx_skb = tp->tx_skb + entry; 570325e992a4SHeiner Kallweit u32 status; 570425e992a4SHeiner Kallweit 570525e992a4SHeiner Kallweit status = le32_to_cpu(tp->TxDescArray[entry].opts1); 570625e992a4SHeiner Kallweit if (status & DescOwn) 570725e992a4SHeiner Kallweit break; 570825e992a4SHeiner Kallweit 570925e992a4SHeiner Kallweit /* This barrier is needed to keep us from reading 571025e992a4SHeiner Kallweit * any other fields out of the Tx descriptor until 571125e992a4SHeiner Kallweit * we know the status of DescOwn 571225e992a4SHeiner Kallweit */ 571325e992a4SHeiner Kallweit dma_rmb(); 571425e992a4SHeiner Kallweit 571525e992a4SHeiner Kallweit rtl8169_unmap_tx_skb(tp_to_dev(tp), tx_skb, 571625e992a4SHeiner Kallweit tp->TxDescArray + entry); 571725e992a4SHeiner Kallweit if (status & LastFrag) { 571825e992a4SHeiner Kallweit pkts_compl++; 571925e992a4SHeiner Kallweit bytes_compl += tx_skb->skb->len; 572025e992a4SHeiner Kallweit napi_consume_skb(tx_skb->skb, budget); 572125e992a4SHeiner Kallweit tx_skb->skb = NULL; 572225e992a4SHeiner Kallweit } 572325e992a4SHeiner Kallweit dirty_tx++; 572425e992a4SHeiner Kallweit tx_left--; 572525e992a4SHeiner Kallweit } 572625e992a4SHeiner Kallweit 572725e992a4SHeiner Kallweit if (tp->dirty_tx != dirty_tx) { 572825e992a4SHeiner Kallweit netdev_completed_queue(dev, pkts_compl, bytes_compl); 572925e992a4SHeiner Kallweit 573025e992a4SHeiner Kallweit u64_stats_update_begin(&tp->tx_stats.syncp); 573125e992a4SHeiner Kallweit tp->tx_stats.packets += pkts_compl; 573225e992a4SHeiner Kallweit tp->tx_stats.bytes += bytes_compl; 573325e992a4SHeiner Kallweit u64_stats_update_end(&tp->tx_stats.syncp); 573425e992a4SHeiner Kallweit 573525e992a4SHeiner Kallweit tp->dirty_tx = dirty_tx; 573625e992a4SHeiner Kallweit /* Sync with rtl8169_start_xmit: 573725e992a4SHeiner Kallweit * - publish dirty_tx ring index (write barrier) 573825e992a4SHeiner Kallweit * - refresh cur_tx ring index and queue status (read barrier) 573925e992a4SHeiner Kallweit * May the current thread miss the stopped queue condition, 574025e992a4SHeiner Kallweit * a racing xmit thread can only have a right view of the 574125e992a4SHeiner Kallweit * ring status. 574225e992a4SHeiner Kallweit */ 574325e992a4SHeiner Kallweit smp_mb(); 574425e992a4SHeiner Kallweit if (netif_queue_stopped(dev) && 574525e992a4SHeiner Kallweit rtl_tx_slots_avail(tp, MAX_SKB_FRAGS)) { 574625e992a4SHeiner Kallweit netif_wake_queue(dev); 574725e992a4SHeiner Kallweit } 574825e992a4SHeiner Kallweit /* 574925e992a4SHeiner Kallweit * 8168 hack: TxPoll requests are lost when the Tx packets are 575025e992a4SHeiner Kallweit * too close. Let's kick an extra TxPoll request when a burst 575125e992a4SHeiner Kallweit * of start_xmit activity is detected (if it is not detected, 575225e992a4SHeiner Kallweit * it is slow enough). -- FR 575325e992a4SHeiner Kallweit */ 575425e992a4SHeiner Kallweit if (tp->cur_tx != dirty_tx) 575525e992a4SHeiner Kallweit RTL_W8(tp, TxPoll, NPQ); 575625e992a4SHeiner Kallweit } 575725e992a4SHeiner Kallweit } 575825e992a4SHeiner Kallweit 575925e992a4SHeiner Kallweit static inline int rtl8169_fragmented_frame(u32 status) 576025e992a4SHeiner Kallweit { 576125e992a4SHeiner Kallweit return (status & (FirstFrag | LastFrag)) != (FirstFrag | LastFrag); 576225e992a4SHeiner Kallweit } 576325e992a4SHeiner Kallweit 576425e992a4SHeiner Kallweit static inline void rtl8169_rx_csum(struct sk_buff *skb, u32 opts1) 576525e992a4SHeiner Kallweit { 576625e992a4SHeiner Kallweit u32 status = opts1 & RxProtoMask; 576725e992a4SHeiner Kallweit 576825e992a4SHeiner Kallweit if (((status == RxProtoTCP) && !(opts1 & TCPFail)) || 576925e992a4SHeiner Kallweit ((status == RxProtoUDP) && !(opts1 & UDPFail))) 577025e992a4SHeiner Kallweit skb->ip_summed = CHECKSUM_UNNECESSARY; 577125e992a4SHeiner Kallweit else 577225e992a4SHeiner Kallweit skb_checksum_none_assert(skb); 577325e992a4SHeiner Kallweit } 577425e992a4SHeiner Kallweit 577525e992a4SHeiner Kallweit static struct sk_buff *rtl8169_try_rx_copy(void *data, 577625e992a4SHeiner Kallweit struct rtl8169_private *tp, 577725e992a4SHeiner Kallweit int pkt_size, 577825e992a4SHeiner Kallweit dma_addr_t addr) 577925e992a4SHeiner Kallweit { 578025e992a4SHeiner Kallweit struct sk_buff *skb; 578125e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 578225e992a4SHeiner Kallweit 578325e992a4SHeiner Kallweit dma_sync_single_for_cpu(d, addr, pkt_size, DMA_FROM_DEVICE); 578425e992a4SHeiner Kallweit prefetch(data); 578525e992a4SHeiner Kallweit skb = napi_alloc_skb(&tp->napi, pkt_size); 578625e992a4SHeiner Kallweit if (skb) 578725e992a4SHeiner Kallweit skb_copy_to_linear_data(skb, data, pkt_size); 578825e992a4SHeiner Kallweit dma_sync_single_for_device(d, addr, pkt_size, DMA_FROM_DEVICE); 578925e992a4SHeiner Kallweit 579025e992a4SHeiner Kallweit return skb; 579125e992a4SHeiner Kallweit } 579225e992a4SHeiner Kallweit 579325e992a4SHeiner Kallweit static int rtl_rx(struct net_device *dev, struct rtl8169_private *tp, u32 budget) 579425e992a4SHeiner Kallweit { 579525e992a4SHeiner Kallweit unsigned int cur_rx, rx_left; 579625e992a4SHeiner Kallweit unsigned int count; 579725e992a4SHeiner Kallweit 579825e992a4SHeiner Kallweit cur_rx = tp->cur_rx; 579925e992a4SHeiner Kallweit 580025e992a4SHeiner Kallweit for (rx_left = min(budget, NUM_RX_DESC); rx_left > 0; rx_left--, cur_rx++) { 580125e992a4SHeiner Kallweit unsigned int entry = cur_rx % NUM_RX_DESC; 580225e992a4SHeiner Kallweit struct RxDesc *desc = tp->RxDescArray + entry; 580325e992a4SHeiner Kallweit u32 status; 580425e992a4SHeiner Kallweit 580525e992a4SHeiner Kallweit status = le32_to_cpu(desc->opts1); 580625e992a4SHeiner Kallweit if (status & DescOwn) 580725e992a4SHeiner Kallweit break; 580825e992a4SHeiner Kallweit 580925e992a4SHeiner Kallweit /* This barrier is needed to keep us from reading 581025e992a4SHeiner Kallweit * any other fields out of the Rx descriptor until 581125e992a4SHeiner Kallweit * we know the status of DescOwn 581225e992a4SHeiner Kallweit */ 581325e992a4SHeiner Kallweit dma_rmb(); 581425e992a4SHeiner Kallweit 581525e992a4SHeiner Kallweit if (unlikely(status & RxRES)) { 581625e992a4SHeiner Kallweit netif_info(tp, rx_err, dev, "Rx ERROR. status = %08x\n", 581725e992a4SHeiner Kallweit status); 581825e992a4SHeiner Kallweit dev->stats.rx_errors++; 581925e992a4SHeiner Kallweit if (status & (RxRWT | RxRUNT)) 582025e992a4SHeiner Kallweit dev->stats.rx_length_errors++; 582125e992a4SHeiner Kallweit if (status & RxCRC) 582225e992a4SHeiner Kallweit dev->stats.rx_crc_errors++; 582325e992a4SHeiner Kallweit if (status & (RxRUNT | RxCRC) && !(status & RxRWT) && 582425e992a4SHeiner Kallweit dev->features & NETIF_F_RXALL) { 582525e992a4SHeiner Kallweit goto process_pkt; 582625e992a4SHeiner Kallweit } 582725e992a4SHeiner Kallweit } else { 582825e992a4SHeiner Kallweit struct sk_buff *skb; 582925e992a4SHeiner Kallweit dma_addr_t addr; 583025e992a4SHeiner Kallweit int pkt_size; 583125e992a4SHeiner Kallweit 583225e992a4SHeiner Kallweit process_pkt: 583325e992a4SHeiner Kallweit addr = le64_to_cpu(desc->addr); 583425e992a4SHeiner Kallweit if (likely(!(dev->features & NETIF_F_RXFCS))) 583525e992a4SHeiner Kallweit pkt_size = (status & 0x00003fff) - 4; 583625e992a4SHeiner Kallweit else 583725e992a4SHeiner Kallweit pkt_size = status & 0x00003fff; 583825e992a4SHeiner Kallweit 583925e992a4SHeiner Kallweit /* 584025e992a4SHeiner Kallweit * The driver does not support incoming fragmented 584125e992a4SHeiner Kallweit * frames. They are seen as a symptom of over-mtu 584225e992a4SHeiner Kallweit * sized frames. 584325e992a4SHeiner Kallweit */ 584425e992a4SHeiner Kallweit if (unlikely(rtl8169_fragmented_frame(status))) { 584525e992a4SHeiner Kallweit dev->stats.rx_dropped++; 584625e992a4SHeiner Kallweit dev->stats.rx_length_errors++; 584725e992a4SHeiner Kallweit goto release_descriptor; 584825e992a4SHeiner Kallweit } 584925e992a4SHeiner Kallweit 585025e992a4SHeiner Kallweit skb = rtl8169_try_rx_copy(tp->Rx_databuff[entry], 585125e992a4SHeiner Kallweit tp, pkt_size, addr); 585225e992a4SHeiner Kallweit if (!skb) { 585325e992a4SHeiner Kallweit dev->stats.rx_dropped++; 585425e992a4SHeiner Kallweit goto release_descriptor; 585525e992a4SHeiner Kallweit } 585625e992a4SHeiner Kallweit 585725e992a4SHeiner Kallweit rtl8169_rx_csum(skb, status); 585825e992a4SHeiner Kallweit skb_put(skb, pkt_size); 585925e992a4SHeiner Kallweit skb->protocol = eth_type_trans(skb, dev); 586025e992a4SHeiner Kallweit 586125e992a4SHeiner Kallweit rtl8169_rx_vlan_tag(desc, skb); 586225e992a4SHeiner Kallweit 586325e992a4SHeiner Kallweit if (skb->pkt_type == PACKET_MULTICAST) 586425e992a4SHeiner Kallweit dev->stats.multicast++; 586525e992a4SHeiner Kallweit 586625e992a4SHeiner Kallweit napi_gro_receive(&tp->napi, skb); 586725e992a4SHeiner Kallweit 586825e992a4SHeiner Kallweit u64_stats_update_begin(&tp->rx_stats.syncp); 586925e992a4SHeiner Kallweit tp->rx_stats.packets++; 587025e992a4SHeiner Kallweit tp->rx_stats.bytes += pkt_size; 587125e992a4SHeiner Kallweit u64_stats_update_end(&tp->rx_stats.syncp); 587225e992a4SHeiner Kallweit } 587325e992a4SHeiner Kallweit release_descriptor: 587425e992a4SHeiner Kallweit desc->opts2 = 0; 587525e992a4SHeiner Kallweit rtl8169_mark_to_asic(desc); 587625e992a4SHeiner Kallweit } 587725e992a4SHeiner Kallweit 587825e992a4SHeiner Kallweit count = cur_rx - tp->cur_rx; 587925e992a4SHeiner Kallweit tp->cur_rx = cur_rx; 588025e992a4SHeiner Kallweit 588125e992a4SHeiner Kallweit return count; 588225e992a4SHeiner Kallweit } 588325e992a4SHeiner Kallweit 588425e992a4SHeiner Kallweit static irqreturn_t rtl8169_interrupt(int irq, void *dev_instance) 588525e992a4SHeiner Kallweit { 588625e992a4SHeiner Kallweit struct rtl8169_private *tp = dev_instance; 588725e992a4SHeiner Kallweit u16 status = RTL_R16(tp, IntrStatus); 588825e992a4SHeiner Kallweit 588925e992a4SHeiner Kallweit if (!tp->irq_enabled || status == 0xffff || !(status & tp->irq_mask)) 589025e992a4SHeiner Kallweit return IRQ_NONE; 589125e992a4SHeiner Kallweit 589225e992a4SHeiner Kallweit if (unlikely(status & SYSErr)) { 589325e992a4SHeiner Kallweit rtl8169_pcierr_interrupt(tp->dev); 589425e992a4SHeiner Kallweit goto out; 589525e992a4SHeiner Kallweit } 589625e992a4SHeiner Kallweit 589725e992a4SHeiner Kallweit if (status & LinkChg) 589825e992a4SHeiner Kallweit phy_mac_interrupt(tp->phydev); 589925e992a4SHeiner Kallweit 590025e992a4SHeiner Kallweit if (unlikely(status & RxFIFOOver && 590125e992a4SHeiner Kallweit tp->mac_version == RTL_GIGA_MAC_VER_11)) { 590225e992a4SHeiner Kallweit netif_stop_queue(tp->dev); 590325e992a4SHeiner Kallweit /* XXX - Hack alert. See rtl_task(). */ 590425e992a4SHeiner Kallweit set_bit(RTL_FLAG_TASK_RESET_PENDING, tp->wk.flags); 590525e992a4SHeiner Kallweit } 590625e992a4SHeiner Kallweit 590725e992a4SHeiner Kallweit rtl_irq_disable(tp); 590825e992a4SHeiner Kallweit napi_schedule_irqoff(&tp->napi); 590925e992a4SHeiner Kallweit out: 591025e992a4SHeiner Kallweit rtl_ack_events(tp, status); 591125e992a4SHeiner Kallweit 591225e992a4SHeiner Kallweit return IRQ_HANDLED; 591325e992a4SHeiner Kallweit } 591425e992a4SHeiner Kallweit 591525e992a4SHeiner Kallweit static void rtl_task(struct work_struct *work) 591625e992a4SHeiner Kallweit { 591725e992a4SHeiner Kallweit static const struct { 591825e992a4SHeiner Kallweit int bitnr; 591925e992a4SHeiner Kallweit void (*action)(struct rtl8169_private *); 592025e992a4SHeiner Kallweit } rtl_work[] = { 592125e992a4SHeiner Kallweit { RTL_FLAG_TASK_RESET_PENDING, rtl_reset_work }, 592225e992a4SHeiner Kallweit }; 592325e992a4SHeiner Kallweit struct rtl8169_private *tp = 592425e992a4SHeiner Kallweit container_of(work, struct rtl8169_private, wk.work); 592525e992a4SHeiner Kallweit struct net_device *dev = tp->dev; 592625e992a4SHeiner Kallweit int i; 592725e992a4SHeiner Kallweit 592825e992a4SHeiner Kallweit rtl_lock_work(tp); 592925e992a4SHeiner Kallweit 593025e992a4SHeiner Kallweit if (!netif_running(dev) || 593125e992a4SHeiner Kallweit !test_bit(RTL_FLAG_TASK_ENABLED, tp->wk.flags)) 593225e992a4SHeiner Kallweit goto out_unlock; 593325e992a4SHeiner Kallweit 593425e992a4SHeiner Kallweit for (i = 0; i < ARRAY_SIZE(rtl_work); i++) { 593525e992a4SHeiner Kallweit bool pending; 593625e992a4SHeiner Kallweit 593725e992a4SHeiner Kallweit pending = test_and_clear_bit(rtl_work[i].bitnr, tp->wk.flags); 593825e992a4SHeiner Kallweit if (pending) 593925e992a4SHeiner Kallweit rtl_work[i].action(tp); 594025e992a4SHeiner Kallweit } 594125e992a4SHeiner Kallweit 594225e992a4SHeiner Kallweit out_unlock: 594325e992a4SHeiner Kallweit rtl_unlock_work(tp); 594425e992a4SHeiner Kallweit } 594525e992a4SHeiner Kallweit 594625e992a4SHeiner Kallweit static int rtl8169_poll(struct napi_struct *napi, int budget) 594725e992a4SHeiner Kallweit { 594825e992a4SHeiner Kallweit struct rtl8169_private *tp = container_of(napi, struct rtl8169_private, napi); 594925e992a4SHeiner Kallweit struct net_device *dev = tp->dev; 595025e992a4SHeiner Kallweit int work_done; 595125e992a4SHeiner Kallweit 595225e992a4SHeiner Kallweit work_done = rtl_rx(dev, tp, (u32) budget); 595325e992a4SHeiner Kallweit 595425e992a4SHeiner Kallweit rtl_tx(dev, tp, budget); 595525e992a4SHeiner Kallweit 595625e992a4SHeiner Kallweit if (work_done < budget) { 595725e992a4SHeiner Kallweit napi_complete_done(napi, work_done); 595825e992a4SHeiner Kallweit rtl_irq_enable(tp); 595925e992a4SHeiner Kallweit } 596025e992a4SHeiner Kallweit 596125e992a4SHeiner Kallweit return work_done; 596225e992a4SHeiner Kallweit } 596325e992a4SHeiner Kallweit 596425e992a4SHeiner Kallweit static void rtl8169_rx_missed(struct net_device *dev) 596525e992a4SHeiner Kallweit { 596625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 596725e992a4SHeiner Kallweit 596825e992a4SHeiner Kallweit if (tp->mac_version > RTL_GIGA_MAC_VER_06) 596925e992a4SHeiner Kallweit return; 597025e992a4SHeiner Kallweit 597125e992a4SHeiner Kallweit dev->stats.rx_missed_errors += RTL_R32(tp, RxMissed) & 0xffffff; 597225e992a4SHeiner Kallweit RTL_W32(tp, RxMissed, 0); 597325e992a4SHeiner Kallweit } 597425e992a4SHeiner Kallweit 597525e992a4SHeiner Kallweit static void r8169_phylink_handler(struct net_device *ndev) 597625e992a4SHeiner Kallweit { 597725e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(ndev); 597825e992a4SHeiner Kallweit 597925e992a4SHeiner Kallweit if (netif_carrier_ok(ndev)) { 598025e992a4SHeiner Kallweit rtl_link_chg_patch(tp); 598125e992a4SHeiner Kallweit pm_request_resume(&tp->pci_dev->dev); 598225e992a4SHeiner Kallweit } else { 598325e992a4SHeiner Kallweit pm_runtime_idle(&tp->pci_dev->dev); 598425e992a4SHeiner Kallweit } 598525e992a4SHeiner Kallweit 598625e992a4SHeiner Kallweit if (net_ratelimit()) 598725e992a4SHeiner Kallweit phy_print_status(tp->phydev); 598825e992a4SHeiner Kallweit } 598925e992a4SHeiner Kallweit 599025e992a4SHeiner Kallweit static int r8169_phy_connect(struct rtl8169_private *tp) 599125e992a4SHeiner Kallweit { 599225e992a4SHeiner Kallweit struct phy_device *phydev = tp->phydev; 599325e992a4SHeiner Kallweit phy_interface_t phy_mode; 599425e992a4SHeiner Kallweit int ret; 599525e992a4SHeiner Kallweit 599625e992a4SHeiner Kallweit phy_mode = tp->supports_gmii ? PHY_INTERFACE_MODE_GMII : 599725e992a4SHeiner Kallweit PHY_INTERFACE_MODE_MII; 599825e992a4SHeiner Kallweit 599925e992a4SHeiner Kallweit ret = phy_connect_direct(tp->dev, phydev, r8169_phylink_handler, 600025e992a4SHeiner Kallweit phy_mode); 600125e992a4SHeiner Kallweit if (ret) 600225e992a4SHeiner Kallweit return ret; 600325e992a4SHeiner Kallweit 600425e992a4SHeiner Kallweit if (tp->supports_gmii) 600525e992a4SHeiner Kallweit phy_remove_link_mode(phydev, 600625e992a4SHeiner Kallweit ETHTOOL_LINK_MODE_1000baseT_Half_BIT); 600725e992a4SHeiner Kallweit else 600825e992a4SHeiner Kallweit phy_set_max_speed(phydev, SPEED_100); 600925e992a4SHeiner Kallweit 601025e992a4SHeiner Kallweit phy_support_asym_pause(phydev); 601125e992a4SHeiner Kallweit 601225e992a4SHeiner Kallweit phy_attached_info(phydev); 601325e992a4SHeiner Kallweit 601425e992a4SHeiner Kallweit return 0; 601525e992a4SHeiner Kallweit } 601625e992a4SHeiner Kallweit 601725e992a4SHeiner Kallweit static void rtl8169_down(struct net_device *dev) 601825e992a4SHeiner Kallweit { 601925e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 602025e992a4SHeiner Kallweit 602125e992a4SHeiner Kallweit phy_stop(tp->phydev); 602225e992a4SHeiner Kallweit 602325e992a4SHeiner Kallweit napi_disable(&tp->napi); 602425e992a4SHeiner Kallweit netif_stop_queue(dev); 602525e992a4SHeiner Kallweit 602625e992a4SHeiner Kallweit rtl8169_hw_reset(tp); 602725e992a4SHeiner Kallweit /* 602825e992a4SHeiner Kallweit * At this point device interrupts can not be enabled in any function, 602925e992a4SHeiner Kallweit * as netif_running is not true (rtl8169_interrupt, rtl8169_reset_task) 603025e992a4SHeiner Kallweit * and napi is disabled (rtl8169_poll). 603125e992a4SHeiner Kallweit */ 603225e992a4SHeiner Kallweit rtl8169_rx_missed(dev); 603325e992a4SHeiner Kallweit 603425e992a4SHeiner Kallweit /* Give a racing hard_start_xmit a few cycles to complete. */ 603525e992a4SHeiner Kallweit synchronize_rcu(); 603625e992a4SHeiner Kallweit 603725e992a4SHeiner Kallweit rtl8169_tx_clear(tp); 603825e992a4SHeiner Kallweit 603925e992a4SHeiner Kallweit rtl8169_rx_clear(tp); 604025e992a4SHeiner Kallweit 604125e992a4SHeiner Kallweit rtl_pll_power_down(tp); 604225e992a4SHeiner Kallweit } 604325e992a4SHeiner Kallweit 604425e992a4SHeiner Kallweit static int rtl8169_close(struct net_device *dev) 604525e992a4SHeiner Kallweit { 604625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 604725e992a4SHeiner Kallweit struct pci_dev *pdev = tp->pci_dev; 604825e992a4SHeiner Kallweit 604925e992a4SHeiner Kallweit pm_runtime_get_sync(&pdev->dev); 605025e992a4SHeiner Kallweit 605125e992a4SHeiner Kallweit /* Update counters before going down */ 605225e992a4SHeiner Kallweit rtl8169_update_counters(tp); 605325e992a4SHeiner Kallweit 605425e992a4SHeiner Kallweit rtl_lock_work(tp); 605525e992a4SHeiner Kallweit /* Clear all task flags */ 605625e992a4SHeiner Kallweit bitmap_zero(tp->wk.flags, RTL_FLAG_MAX); 605725e992a4SHeiner Kallweit 605825e992a4SHeiner Kallweit rtl8169_down(dev); 605925e992a4SHeiner Kallweit rtl_unlock_work(tp); 606025e992a4SHeiner Kallweit 606125e992a4SHeiner Kallweit cancel_work_sync(&tp->wk.work); 606225e992a4SHeiner Kallweit 606325e992a4SHeiner Kallweit phy_disconnect(tp->phydev); 606425e992a4SHeiner Kallweit 606525e992a4SHeiner Kallweit pci_free_irq(pdev, 0, tp); 606625e992a4SHeiner Kallweit 606725e992a4SHeiner Kallweit dma_free_coherent(&pdev->dev, R8169_RX_RING_BYTES, tp->RxDescArray, 606825e992a4SHeiner Kallweit tp->RxPhyAddr); 606925e992a4SHeiner Kallweit dma_free_coherent(&pdev->dev, R8169_TX_RING_BYTES, tp->TxDescArray, 607025e992a4SHeiner Kallweit tp->TxPhyAddr); 607125e992a4SHeiner Kallweit tp->TxDescArray = NULL; 607225e992a4SHeiner Kallweit tp->RxDescArray = NULL; 607325e992a4SHeiner Kallweit 607425e992a4SHeiner Kallweit pm_runtime_put_sync(&pdev->dev); 607525e992a4SHeiner Kallweit 607625e992a4SHeiner Kallweit return 0; 607725e992a4SHeiner Kallweit } 607825e992a4SHeiner Kallweit 607925e992a4SHeiner Kallweit #ifdef CONFIG_NET_POLL_CONTROLLER 608025e992a4SHeiner Kallweit static void rtl8169_netpoll(struct net_device *dev) 608125e992a4SHeiner Kallweit { 608225e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 608325e992a4SHeiner Kallweit 608425e992a4SHeiner Kallweit rtl8169_interrupt(pci_irq_vector(tp->pci_dev, 0), tp); 608525e992a4SHeiner Kallweit } 608625e992a4SHeiner Kallweit #endif 608725e992a4SHeiner Kallweit 608825e992a4SHeiner Kallweit static int rtl_open(struct net_device *dev) 608925e992a4SHeiner Kallweit { 609025e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 609125e992a4SHeiner Kallweit struct pci_dev *pdev = tp->pci_dev; 609225e992a4SHeiner Kallweit int retval = -ENOMEM; 609325e992a4SHeiner Kallweit 609425e992a4SHeiner Kallweit pm_runtime_get_sync(&pdev->dev); 609525e992a4SHeiner Kallweit 609625e992a4SHeiner Kallweit /* 609725e992a4SHeiner Kallweit * Rx and Tx descriptors needs 256 bytes alignment. 609825e992a4SHeiner Kallweit * dma_alloc_coherent provides more. 609925e992a4SHeiner Kallweit */ 610025e992a4SHeiner Kallweit tp->TxDescArray = dma_alloc_coherent(&pdev->dev, R8169_TX_RING_BYTES, 610125e992a4SHeiner Kallweit &tp->TxPhyAddr, GFP_KERNEL); 610225e992a4SHeiner Kallweit if (!tp->TxDescArray) 610325e992a4SHeiner Kallweit goto err_pm_runtime_put; 610425e992a4SHeiner Kallweit 610525e992a4SHeiner Kallweit tp->RxDescArray = dma_alloc_coherent(&pdev->dev, R8169_RX_RING_BYTES, 610625e992a4SHeiner Kallweit &tp->RxPhyAddr, GFP_KERNEL); 610725e992a4SHeiner Kallweit if (!tp->RxDescArray) 610825e992a4SHeiner Kallweit goto err_free_tx_0; 610925e992a4SHeiner Kallweit 611025e992a4SHeiner Kallweit retval = rtl8169_init_ring(tp); 611125e992a4SHeiner Kallweit if (retval < 0) 611225e992a4SHeiner Kallweit goto err_free_rx_1; 611325e992a4SHeiner Kallweit 611425e992a4SHeiner Kallweit rtl_request_firmware(tp); 611525e992a4SHeiner Kallweit 611625e992a4SHeiner Kallweit retval = pci_request_irq(pdev, 0, rtl8169_interrupt, NULL, tp, 611725e992a4SHeiner Kallweit dev->name); 611825e992a4SHeiner Kallweit if (retval < 0) 611925e992a4SHeiner Kallweit goto err_release_fw_2; 612025e992a4SHeiner Kallweit 612125e992a4SHeiner Kallweit retval = r8169_phy_connect(tp); 612225e992a4SHeiner Kallweit if (retval) 612325e992a4SHeiner Kallweit goto err_free_irq; 612425e992a4SHeiner Kallweit 612525e992a4SHeiner Kallweit rtl_lock_work(tp); 612625e992a4SHeiner Kallweit 612725e992a4SHeiner Kallweit set_bit(RTL_FLAG_TASK_ENABLED, tp->wk.flags); 612825e992a4SHeiner Kallweit 612925e992a4SHeiner Kallweit napi_enable(&tp->napi); 613025e992a4SHeiner Kallweit 613125e992a4SHeiner Kallweit rtl8169_init_phy(dev, tp); 613225e992a4SHeiner Kallweit 613325e992a4SHeiner Kallweit rtl_pll_power_up(tp); 613425e992a4SHeiner Kallweit 613525e992a4SHeiner Kallweit rtl_hw_start(tp); 613625e992a4SHeiner Kallweit 613725e992a4SHeiner Kallweit if (!rtl8169_init_counter_offsets(tp)) 613825e992a4SHeiner Kallweit netif_warn(tp, hw, dev, "counter reset/update failed\n"); 613925e992a4SHeiner Kallweit 614025e992a4SHeiner Kallweit phy_start(tp->phydev); 614125e992a4SHeiner Kallweit netif_start_queue(dev); 614225e992a4SHeiner Kallweit 614325e992a4SHeiner Kallweit rtl_unlock_work(tp); 614425e992a4SHeiner Kallweit 614525e992a4SHeiner Kallweit pm_runtime_put_sync(&pdev->dev); 614625e992a4SHeiner Kallweit out: 614725e992a4SHeiner Kallweit return retval; 614825e992a4SHeiner Kallweit 614925e992a4SHeiner Kallweit err_free_irq: 615025e992a4SHeiner Kallweit pci_free_irq(pdev, 0, tp); 615125e992a4SHeiner Kallweit err_release_fw_2: 615225e992a4SHeiner Kallweit rtl_release_firmware(tp); 615325e992a4SHeiner Kallweit rtl8169_rx_clear(tp); 615425e992a4SHeiner Kallweit err_free_rx_1: 615525e992a4SHeiner Kallweit dma_free_coherent(&pdev->dev, R8169_RX_RING_BYTES, tp->RxDescArray, 615625e992a4SHeiner Kallweit tp->RxPhyAddr); 615725e992a4SHeiner Kallweit tp->RxDescArray = NULL; 615825e992a4SHeiner Kallweit err_free_tx_0: 615925e992a4SHeiner Kallweit dma_free_coherent(&pdev->dev, R8169_TX_RING_BYTES, tp->TxDescArray, 616025e992a4SHeiner Kallweit tp->TxPhyAddr); 616125e992a4SHeiner Kallweit tp->TxDescArray = NULL; 616225e992a4SHeiner Kallweit err_pm_runtime_put: 616325e992a4SHeiner Kallweit pm_runtime_put_noidle(&pdev->dev); 616425e992a4SHeiner Kallweit goto out; 616525e992a4SHeiner Kallweit } 616625e992a4SHeiner Kallweit 616725e992a4SHeiner Kallweit static void 616825e992a4SHeiner Kallweit rtl8169_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats) 616925e992a4SHeiner Kallweit { 617025e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 617125e992a4SHeiner Kallweit struct pci_dev *pdev = tp->pci_dev; 617225e992a4SHeiner Kallweit struct rtl8169_counters *counters = tp->counters; 617325e992a4SHeiner Kallweit unsigned int start; 617425e992a4SHeiner Kallweit 617525e992a4SHeiner Kallweit pm_runtime_get_noresume(&pdev->dev); 617625e992a4SHeiner Kallweit 617725e992a4SHeiner Kallweit if (netif_running(dev) && pm_runtime_active(&pdev->dev)) 617825e992a4SHeiner Kallweit rtl8169_rx_missed(dev); 617925e992a4SHeiner Kallweit 618025e992a4SHeiner Kallweit do { 618125e992a4SHeiner Kallweit start = u64_stats_fetch_begin_irq(&tp->rx_stats.syncp); 618225e992a4SHeiner Kallweit stats->rx_packets = tp->rx_stats.packets; 618325e992a4SHeiner Kallweit stats->rx_bytes = tp->rx_stats.bytes; 618425e992a4SHeiner Kallweit } while (u64_stats_fetch_retry_irq(&tp->rx_stats.syncp, start)); 618525e992a4SHeiner Kallweit 618625e992a4SHeiner Kallweit do { 618725e992a4SHeiner Kallweit start = u64_stats_fetch_begin_irq(&tp->tx_stats.syncp); 618825e992a4SHeiner Kallweit stats->tx_packets = tp->tx_stats.packets; 618925e992a4SHeiner Kallweit stats->tx_bytes = tp->tx_stats.bytes; 619025e992a4SHeiner Kallweit } while (u64_stats_fetch_retry_irq(&tp->tx_stats.syncp, start)); 619125e992a4SHeiner Kallweit 619225e992a4SHeiner Kallweit stats->rx_dropped = dev->stats.rx_dropped; 619325e992a4SHeiner Kallweit stats->tx_dropped = dev->stats.tx_dropped; 619425e992a4SHeiner Kallweit stats->rx_length_errors = dev->stats.rx_length_errors; 619525e992a4SHeiner Kallweit stats->rx_errors = dev->stats.rx_errors; 619625e992a4SHeiner Kallweit stats->rx_crc_errors = dev->stats.rx_crc_errors; 619725e992a4SHeiner Kallweit stats->rx_fifo_errors = dev->stats.rx_fifo_errors; 619825e992a4SHeiner Kallweit stats->rx_missed_errors = dev->stats.rx_missed_errors; 619925e992a4SHeiner Kallweit stats->multicast = dev->stats.multicast; 620025e992a4SHeiner Kallweit 620125e992a4SHeiner Kallweit /* 620225e992a4SHeiner Kallweit * Fetch additonal counter values missing in stats collected by driver 620325e992a4SHeiner Kallweit * from tally counters. 620425e992a4SHeiner Kallweit */ 620525e992a4SHeiner Kallweit if (pm_runtime_active(&pdev->dev)) 620625e992a4SHeiner Kallweit rtl8169_update_counters(tp); 620725e992a4SHeiner Kallweit 620825e992a4SHeiner Kallweit /* 620925e992a4SHeiner Kallweit * Subtract values fetched during initalization. 621025e992a4SHeiner Kallweit * See rtl8169_init_counter_offsets for a description why we do that. 621125e992a4SHeiner Kallweit */ 621225e992a4SHeiner Kallweit stats->tx_errors = le64_to_cpu(counters->tx_errors) - 621325e992a4SHeiner Kallweit le64_to_cpu(tp->tc_offset.tx_errors); 621425e992a4SHeiner Kallweit stats->collisions = le32_to_cpu(counters->tx_multi_collision) - 621525e992a4SHeiner Kallweit le32_to_cpu(tp->tc_offset.tx_multi_collision); 621625e992a4SHeiner Kallweit stats->tx_aborted_errors = le16_to_cpu(counters->tx_aborted) - 621725e992a4SHeiner Kallweit le16_to_cpu(tp->tc_offset.tx_aborted); 621825e992a4SHeiner Kallweit 621925e992a4SHeiner Kallweit pm_runtime_put_noidle(&pdev->dev); 622025e992a4SHeiner Kallweit } 622125e992a4SHeiner Kallweit 622225e992a4SHeiner Kallweit static void rtl8169_net_suspend(struct net_device *dev) 622325e992a4SHeiner Kallweit { 622425e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 622525e992a4SHeiner Kallweit 622625e992a4SHeiner Kallweit if (!netif_running(dev)) 622725e992a4SHeiner Kallweit return; 622825e992a4SHeiner Kallweit 622925e992a4SHeiner Kallweit phy_stop(tp->phydev); 623025e992a4SHeiner Kallweit netif_device_detach(dev); 623125e992a4SHeiner Kallweit 623225e992a4SHeiner Kallweit rtl_lock_work(tp); 623325e992a4SHeiner Kallweit napi_disable(&tp->napi); 623425e992a4SHeiner Kallweit /* Clear all task flags */ 623525e992a4SHeiner Kallweit bitmap_zero(tp->wk.flags, RTL_FLAG_MAX); 623625e992a4SHeiner Kallweit 623725e992a4SHeiner Kallweit rtl_unlock_work(tp); 623825e992a4SHeiner Kallweit 623925e992a4SHeiner Kallweit rtl_pll_power_down(tp); 624025e992a4SHeiner Kallweit } 624125e992a4SHeiner Kallweit 624225e992a4SHeiner Kallweit #ifdef CONFIG_PM 624325e992a4SHeiner Kallweit 624425e992a4SHeiner Kallweit static int rtl8169_suspend(struct device *device) 624525e992a4SHeiner Kallweit { 624625e992a4SHeiner Kallweit struct net_device *dev = dev_get_drvdata(device); 624725e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 624825e992a4SHeiner Kallweit 624925e992a4SHeiner Kallweit rtl8169_net_suspend(dev); 625025e992a4SHeiner Kallweit clk_disable_unprepare(tp->clk); 625125e992a4SHeiner Kallweit 625225e992a4SHeiner Kallweit return 0; 625325e992a4SHeiner Kallweit } 625425e992a4SHeiner Kallweit 625525e992a4SHeiner Kallweit static void __rtl8169_resume(struct net_device *dev) 625625e992a4SHeiner Kallweit { 625725e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 625825e992a4SHeiner Kallweit 625925e992a4SHeiner Kallweit netif_device_attach(dev); 626025e992a4SHeiner Kallweit 626125e992a4SHeiner Kallweit rtl_pll_power_up(tp); 626225e992a4SHeiner Kallweit rtl8169_init_phy(dev, tp); 626325e992a4SHeiner Kallweit 626425e992a4SHeiner Kallweit phy_start(tp->phydev); 626525e992a4SHeiner Kallweit 626625e992a4SHeiner Kallweit rtl_lock_work(tp); 626725e992a4SHeiner Kallweit napi_enable(&tp->napi); 626825e992a4SHeiner Kallweit set_bit(RTL_FLAG_TASK_ENABLED, tp->wk.flags); 626925e992a4SHeiner Kallweit rtl_reset_work(tp); 627025e992a4SHeiner Kallweit rtl_unlock_work(tp); 627125e992a4SHeiner Kallweit } 627225e992a4SHeiner Kallweit 627325e992a4SHeiner Kallweit static int rtl8169_resume(struct device *device) 627425e992a4SHeiner Kallweit { 627525e992a4SHeiner Kallweit struct net_device *dev = dev_get_drvdata(device); 627625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 627725e992a4SHeiner Kallweit 627825e992a4SHeiner Kallweit rtl_rar_set(tp, dev->dev_addr); 627925e992a4SHeiner Kallweit 628025e992a4SHeiner Kallweit clk_prepare_enable(tp->clk); 628125e992a4SHeiner Kallweit 628225e992a4SHeiner Kallweit if (netif_running(dev)) 628325e992a4SHeiner Kallweit __rtl8169_resume(dev); 628425e992a4SHeiner Kallweit 628525e992a4SHeiner Kallweit return 0; 628625e992a4SHeiner Kallweit } 628725e992a4SHeiner Kallweit 628825e992a4SHeiner Kallweit static int rtl8169_runtime_suspend(struct device *device) 628925e992a4SHeiner Kallweit { 629025e992a4SHeiner Kallweit struct net_device *dev = dev_get_drvdata(device); 629125e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 629225e992a4SHeiner Kallweit 629325e992a4SHeiner Kallweit if (!tp->TxDescArray) 629425e992a4SHeiner Kallweit return 0; 629525e992a4SHeiner Kallweit 629625e992a4SHeiner Kallweit rtl_lock_work(tp); 629725e992a4SHeiner Kallweit __rtl8169_set_wol(tp, WAKE_ANY); 629825e992a4SHeiner Kallweit rtl_unlock_work(tp); 629925e992a4SHeiner Kallweit 630025e992a4SHeiner Kallweit rtl8169_net_suspend(dev); 630125e992a4SHeiner Kallweit 630225e992a4SHeiner Kallweit /* Update counters before going runtime suspend */ 630325e992a4SHeiner Kallweit rtl8169_rx_missed(dev); 630425e992a4SHeiner Kallweit rtl8169_update_counters(tp); 630525e992a4SHeiner Kallweit 630625e992a4SHeiner Kallweit return 0; 630725e992a4SHeiner Kallweit } 630825e992a4SHeiner Kallweit 630925e992a4SHeiner Kallweit static int rtl8169_runtime_resume(struct device *device) 631025e992a4SHeiner Kallweit { 631125e992a4SHeiner Kallweit struct net_device *dev = dev_get_drvdata(device); 631225e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 631325e992a4SHeiner Kallweit 631425e992a4SHeiner Kallweit rtl_rar_set(tp, dev->dev_addr); 631525e992a4SHeiner Kallweit 631625e992a4SHeiner Kallweit if (!tp->TxDescArray) 631725e992a4SHeiner Kallweit return 0; 631825e992a4SHeiner Kallweit 631925e992a4SHeiner Kallweit rtl_lock_work(tp); 632025e992a4SHeiner Kallweit __rtl8169_set_wol(tp, tp->saved_wolopts); 632125e992a4SHeiner Kallweit rtl_unlock_work(tp); 632225e992a4SHeiner Kallweit 632325e992a4SHeiner Kallweit __rtl8169_resume(dev); 632425e992a4SHeiner Kallweit 632525e992a4SHeiner Kallweit return 0; 632625e992a4SHeiner Kallweit } 632725e992a4SHeiner Kallweit 632825e992a4SHeiner Kallweit static int rtl8169_runtime_idle(struct device *device) 632925e992a4SHeiner Kallweit { 633025e992a4SHeiner Kallweit struct net_device *dev = dev_get_drvdata(device); 633125e992a4SHeiner Kallweit 633225e992a4SHeiner Kallweit if (!netif_running(dev) || !netif_carrier_ok(dev)) 633325e992a4SHeiner Kallweit pm_schedule_suspend(device, 10000); 633425e992a4SHeiner Kallweit 633525e992a4SHeiner Kallweit return -EBUSY; 633625e992a4SHeiner Kallweit } 633725e992a4SHeiner Kallweit 633825e992a4SHeiner Kallweit static const struct dev_pm_ops rtl8169_pm_ops = { 633925e992a4SHeiner Kallweit .suspend = rtl8169_suspend, 634025e992a4SHeiner Kallweit .resume = rtl8169_resume, 634125e992a4SHeiner Kallweit .freeze = rtl8169_suspend, 634225e992a4SHeiner Kallweit .thaw = rtl8169_resume, 634325e992a4SHeiner Kallweit .poweroff = rtl8169_suspend, 634425e992a4SHeiner Kallweit .restore = rtl8169_resume, 634525e992a4SHeiner Kallweit .runtime_suspend = rtl8169_runtime_suspend, 634625e992a4SHeiner Kallweit .runtime_resume = rtl8169_runtime_resume, 634725e992a4SHeiner Kallweit .runtime_idle = rtl8169_runtime_idle, 634825e992a4SHeiner Kallweit }; 634925e992a4SHeiner Kallweit 635025e992a4SHeiner Kallweit #define RTL8169_PM_OPS (&rtl8169_pm_ops) 635125e992a4SHeiner Kallweit 635225e992a4SHeiner Kallweit #else /* !CONFIG_PM */ 635325e992a4SHeiner Kallweit 635425e992a4SHeiner Kallweit #define RTL8169_PM_OPS NULL 635525e992a4SHeiner Kallweit 635625e992a4SHeiner Kallweit #endif /* !CONFIG_PM */ 635725e992a4SHeiner Kallweit 635825e992a4SHeiner Kallweit static void rtl_wol_shutdown_quirk(struct rtl8169_private *tp) 635925e992a4SHeiner Kallweit { 636025e992a4SHeiner Kallweit /* WoL fails with 8168b when the receiver is disabled. */ 636125e992a4SHeiner Kallweit switch (tp->mac_version) { 636225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_11: 636325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_12: 636425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_17: 636525e992a4SHeiner Kallweit pci_clear_master(tp->pci_dev); 636625e992a4SHeiner Kallweit 636725e992a4SHeiner Kallweit RTL_W8(tp, ChipCmd, CmdRxEnb); 636825e992a4SHeiner Kallweit /* PCI commit */ 636925e992a4SHeiner Kallweit RTL_R8(tp, ChipCmd); 637025e992a4SHeiner Kallweit break; 637125e992a4SHeiner Kallweit default: 637225e992a4SHeiner Kallweit break; 637325e992a4SHeiner Kallweit } 637425e992a4SHeiner Kallweit } 637525e992a4SHeiner Kallweit 637625e992a4SHeiner Kallweit static void rtl_shutdown(struct pci_dev *pdev) 637725e992a4SHeiner Kallweit { 637825e992a4SHeiner Kallweit struct net_device *dev = pci_get_drvdata(pdev); 637925e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 638025e992a4SHeiner Kallweit 638125e992a4SHeiner Kallweit rtl8169_net_suspend(dev); 638225e992a4SHeiner Kallweit 638325e992a4SHeiner Kallweit /* Restore original MAC address */ 638425e992a4SHeiner Kallweit rtl_rar_set(tp, dev->perm_addr); 638525e992a4SHeiner Kallweit 638625e992a4SHeiner Kallweit rtl8169_hw_reset(tp); 638725e992a4SHeiner Kallweit 638825e992a4SHeiner Kallweit if (system_state == SYSTEM_POWER_OFF) { 638925e992a4SHeiner Kallweit if (tp->saved_wolopts) { 639025e992a4SHeiner Kallweit rtl_wol_suspend_quirk(tp); 639125e992a4SHeiner Kallweit rtl_wol_shutdown_quirk(tp); 639225e992a4SHeiner Kallweit } 639325e992a4SHeiner Kallweit 639425e992a4SHeiner Kallweit pci_wake_from_d3(pdev, true); 639525e992a4SHeiner Kallweit pci_set_power_state(pdev, PCI_D3hot); 639625e992a4SHeiner Kallweit } 639725e992a4SHeiner Kallweit } 639825e992a4SHeiner Kallweit 639925e992a4SHeiner Kallweit static void rtl_remove_one(struct pci_dev *pdev) 640025e992a4SHeiner Kallweit { 640125e992a4SHeiner Kallweit struct net_device *dev = pci_get_drvdata(pdev); 640225e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 640325e992a4SHeiner Kallweit 640425e992a4SHeiner Kallweit if (r8168_check_dash(tp)) 640525e992a4SHeiner Kallweit rtl8168_driver_stop(tp); 640625e992a4SHeiner Kallweit 640725e992a4SHeiner Kallweit netif_napi_del(&tp->napi); 640825e992a4SHeiner Kallweit 640925e992a4SHeiner Kallweit unregister_netdev(dev); 641025e992a4SHeiner Kallweit mdiobus_unregister(tp->phydev->mdio.bus); 641125e992a4SHeiner Kallweit 641225e992a4SHeiner Kallweit rtl_release_firmware(tp); 641325e992a4SHeiner Kallweit 641425e992a4SHeiner Kallweit if (pci_dev_run_wake(pdev)) 641525e992a4SHeiner Kallweit pm_runtime_get_noresume(&pdev->dev); 641625e992a4SHeiner Kallweit 641725e992a4SHeiner Kallweit /* restore original MAC address */ 641825e992a4SHeiner Kallweit rtl_rar_set(tp, dev->perm_addr); 641925e992a4SHeiner Kallweit } 642025e992a4SHeiner Kallweit 642125e992a4SHeiner Kallweit static const struct net_device_ops rtl_netdev_ops = { 642225e992a4SHeiner Kallweit .ndo_open = rtl_open, 642325e992a4SHeiner Kallweit .ndo_stop = rtl8169_close, 642425e992a4SHeiner Kallweit .ndo_get_stats64 = rtl8169_get_stats64, 642525e992a4SHeiner Kallweit .ndo_start_xmit = rtl8169_start_xmit, 642625e992a4SHeiner Kallweit .ndo_tx_timeout = rtl8169_tx_timeout, 642725e992a4SHeiner Kallweit .ndo_validate_addr = eth_validate_addr, 642825e992a4SHeiner Kallweit .ndo_change_mtu = rtl8169_change_mtu, 642925e992a4SHeiner Kallweit .ndo_fix_features = rtl8169_fix_features, 643025e992a4SHeiner Kallweit .ndo_set_features = rtl8169_set_features, 643125e992a4SHeiner Kallweit .ndo_set_mac_address = rtl_set_mac_address, 643225e992a4SHeiner Kallweit .ndo_do_ioctl = rtl8169_ioctl, 643325e992a4SHeiner Kallweit .ndo_set_rx_mode = rtl_set_rx_mode, 643425e992a4SHeiner Kallweit #ifdef CONFIG_NET_POLL_CONTROLLER 643525e992a4SHeiner Kallweit .ndo_poll_controller = rtl8169_netpoll, 643625e992a4SHeiner Kallweit #endif 643725e992a4SHeiner Kallweit 643825e992a4SHeiner Kallweit }; 643925e992a4SHeiner Kallweit 6440ec9a4088SHeiner Kallweit static void rtl_set_irq_mask(struct rtl8169_private *tp) 6441ec9a4088SHeiner Kallweit { 6442ec9a4088SHeiner Kallweit tp->irq_mask = RTL_EVENT_NAPI | LinkChg; 6443ec9a4088SHeiner Kallweit 6444ec9a4088SHeiner Kallweit if (tp->mac_version <= RTL_GIGA_MAC_VER_06) 6445ec9a4088SHeiner Kallweit tp->irq_mask |= SYSErr | RxOverflow | RxFIFOOver; 6446ec9a4088SHeiner Kallweit else if (tp->mac_version == RTL_GIGA_MAC_VER_11) 6447ec9a4088SHeiner Kallweit /* special workaround needed */ 6448ec9a4088SHeiner Kallweit tp->irq_mask |= RxFIFOOver; 6449ec9a4088SHeiner Kallweit else 6450ec9a4088SHeiner Kallweit tp->irq_mask |= RxOverflow; 6451ec9a4088SHeiner Kallweit } 6452ec9a4088SHeiner Kallweit 645325e992a4SHeiner Kallweit static int rtl_alloc_irq(struct rtl8169_private *tp) 645425e992a4SHeiner Kallweit { 645525e992a4SHeiner Kallweit unsigned int flags; 645625e992a4SHeiner Kallweit 645725e992a4SHeiner Kallweit if (tp->mac_version <= RTL_GIGA_MAC_VER_06) { 645825e992a4SHeiner Kallweit rtl_unlock_config_regs(tp); 645925e992a4SHeiner Kallweit RTL_W8(tp, Config2, RTL_R8(tp, Config2) & ~MSIEnable); 646025e992a4SHeiner Kallweit rtl_lock_config_regs(tp); 646125e992a4SHeiner Kallweit flags = PCI_IRQ_LEGACY; 646225e992a4SHeiner Kallweit } else { 646325e992a4SHeiner Kallweit flags = PCI_IRQ_ALL_TYPES; 646425e992a4SHeiner Kallweit } 646525e992a4SHeiner Kallweit 646625e992a4SHeiner Kallweit return pci_alloc_irq_vectors(tp->pci_dev, 1, 1, flags); 646725e992a4SHeiner Kallweit } 646825e992a4SHeiner Kallweit 646925e992a4SHeiner Kallweit static void rtl_read_mac_address(struct rtl8169_private *tp, 647025e992a4SHeiner Kallweit u8 mac_addr[ETH_ALEN]) 647125e992a4SHeiner Kallweit { 647225e992a4SHeiner Kallweit /* Get MAC address */ 64739e9f33baSHeiner Kallweit if (rtl_is_8168evl_up(tp) && tp->mac_version != RTL_GIGA_MAC_VER_34) { 64749e9f33baSHeiner Kallweit u32 value = rtl_eri_read(tp, 0xe0); 64759e9f33baSHeiner Kallweit 647625e992a4SHeiner Kallweit mac_addr[0] = (value >> 0) & 0xff; 647725e992a4SHeiner Kallweit mac_addr[1] = (value >> 8) & 0xff; 647825e992a4SHeiner Kallweit mac_addr[2] = (value >> 16) & 0xff; 647925e992a4SHeiner Kallweit mac_addr[3] = (value >> 24) & 0xff; 648025e992a4SHeiner Kallweit 648125e992a4SHeiner Kallweit value = rtl_eri_read(tp, 0xe4); 648225e992a4SHeiner Kallweit mac_addr[4] = (value >> 0) & 0xff; 648325e992a4SHeiner Kallweit mac_addr[5] = (value >> 8) & 0xff; 648425e992a4SHeiner Kallweit } 648525e992a4SHeiner Kallweit } 648625e992a4SHeiner Kallweit 648725e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_link_list_ready_cond) 648825e992a4SHeiner Kallweit { 648925e992a4SHeiner Kallweit return RTL_R8(tp, MCU) & LINK_LIST_RDY; 649025e992a4SHeiner Kallweit } 649125e992a4SHeiner Kallweit 649225e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_rxtx_empty_cond) 649325e992a4SHeiner Kallweit { 649425e992a4SHeiner Kallweit return (RTL_R8(tp, MCU) & RXTX_EMPTY) == RXTX_EMPTY; 649525e992a4SHeiner Kallweit } 649625e992a4SHeiner Kallweit 649725e992a4SHeiner Kallweit static int r8169_mdio_read_reg(struct mii_bus *mii_bus, int phyaddr, int phyreg) 649825e992a4SHeiner Kallweit { 649925e992a4SHeiner Kallweit struct rtl8169_private *tp = mii_bus->priv; 650025e992a4SHeiner Kallweit 650125e992a4SHeiner Kallweit if (phyaddr > 0) 650225e992a4SHeiner Kallweit return -ENODEV; 650325e992a4SHeiner Kallweit 650425e992a4SHeiner Kallweit return rtl_readphy(tp, phyreg); 650525e992a4SHeiner Kallweit } 650625e992a4SHeiner Kallweit 650725e992a4SHeiner Kallweit static int r8169_mdio_write_reg(struct mii_bus *mii_bus, int phyaddr, 650825e992a4SHeiner Kallweit int phyreg, u16 val) 650925e992a4SHeiner Kallweit { 651025e992a4SHeiner Kallweit struct rtl8169_private *tp = mii_bus->priv; 651125e992a4SHeiner Kallweit 651225e992a4SHeiner Kallweit if (phyaddr > 0) 651325e992a4SHeiner Kallweit return -ENODEV; 651425e992a4SHeiner Kallweit 651525e992a4SHeiner Kallweit rtl_writephy(tp, phyreg, val); 651625e992a4SHeiner Kallweit 651725e992a4SHeiner Kallweit return 0; 651825e992a4SHeiner Kallweit } 651925e992a4SHeiner Kallweit 652025e992a4SHeiner Kallweit static int r8169_mdio_register(struct rtl8169_private *tp) 652125e992a4SHeiner Kallweit { 652225e992a4SHeiner Kallweit struct pci_dev *pdev = tp->pci_dev; 652325e992a4SHeiner Kallweit struct mii_bus *new_bus; 652425e992a4SHeiner Kallweit int ret; 652525e992a4SHeiner Kallweit 652625e992a4SHeiner Kallweit new_bus = devm_mdiobus_alloc(&pdev->dev); 652725e992a4SHeiner Kallweit if (!new_bus) 652825e992a4SHeiner Kallweit return -ENOMEM; 652925e992a4SHeiner Kallweit 653025e992a4SHeiner Kallweit new_bus->name = "r8169"; 653125e992a4SHeiner Kallweit new_bus->priv = tp; 653225e992a4SHeiner Kallweit new_bus->parent = &pdev->dev; 653325e992a4SHeiner Kallweit new_bus->irq[0] = PHY_IGNORE_INTERRUPT; 653425e992a4SHeiner Kallweit snprintf(new_bus->id, MII_BUS_ID_SIZE, "r8169-%x", pci_dev_id(pdev)); 653525e992a4SHeiner Kallweit 653625e992a4SHeiner Kallweit new_bus->read = r8169_mdio_read_reg; 653725e992a4SHeiner Kallweit new_bus->write = r8169_mdio_write_reg; 653825e992a4SHeiner Kallweit 653925e992a4SHeiner Kallweit ret = mdiobus_register(new_bus); 654025e992a4SHeiner Kallweit if (ret) 654125e992a4SHeiner Kallweit return ret; 654225e992a4SHeiner Kallweit 654325e992a4SHeiner Kallweit tp->phydev = mdiobus_get_phy(new_bus, 0); 654425e992a4SHeiner Kallweit if (!tp->phydev) { 654525e992a4SHeiner Kallweit mdiobus_unregister(new_bus); 654625e992a4SHeiner Kallweit return -ENODEV; 654725e992a4SHeiner Kallweit } 654825e992a4SHeiner Kallweit 654925e992a4SHeiner Kallweit /* PHY will be woken up in rtl_open() */ 655025e992a4SHeiner Kallweit phy_suspend(tp->phydev); 655125e992a4SHeiner Kallweit 655225e992a4SHeiner Kallweit return 0; 655325e992a4SHeiner Kallweit } 655425e992a4SHeiner Kallweit 655525e992a4SHeiner Kallweit static void rtl_hw_init_8168g(struct rtl8169_private *tp) 655625e992a4SHeiner Kallweit { 655725e992a4SHeiner Kallweit u32 data; 655825e992a4SHeiner Kallweit 655925e992a4SHeiner Kallweit tp->ocp_base = OCP_STD_PHY_BASE; 656025e992a4SHeiner Kallweit 656125e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) | RXDV_GATED_EN); 656225e992a4SHeiner Kallweit 656325e992a4SHeiner Kallweit if (!rtl_udelay_loop_wait_high(tp, &rtl_txcfg_empty_cond, 100, 42)) 656425e992a4SHeiner Kallweit return; 656525e992a4SHeiner Kallweit 656625e992a4SHeiner Kallweit if (!rtl_udelay_loop_wait_high(tp, &rtl_rxtx_empty_cond, 100, 42)) 656725e992a4SHeiner Kallweit return; 656825e992a4SHeiner Kallweit 656925e992a4SHeiner Kallweit RTL_W8(tp, ChipCmd, RTL_R8(tp, ChipCmd) & ~(CmdTxEnb | CmdRxEnb)); 657025e992a4SHeiner Kallweit msleep(1); 657125e992a4SHeiner Kallweit RTL_W8(tp, MCU, RTL_R8(tp, MCU) & ~NOW_IS_OOB); 657225e992a4SHeiner Kallweit 657325e992a4SHeiner Kallweit data = r8168_mac_ocp_read(tp, 0xe8de); 657425e992a4SHeiner Kallweit data &= ~(1 << 14); 657525e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xe8de, data); 657625e992a4SHeiner Kallweit 657725e992a4SHeiner Kallweit if (!rtl_udelay_loop_wait_high(tp, &rtl_link_list_ready_cond, 100, 42)) 657825e992a4SHeiner Kallweit return; 657925e992a4SHeiner Kallweit 658025e992a4SHeiner Kallweit data = r8168_mac_ocp_read(tp, 0xe8de); 658125e992a4SHeiner Kallweit data |= (1 << 15); 658225e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xe8de, data); 658325e992a4SHeiner Kallweit 658425e992a4SHeiner Kallweit rtl_udelay_loop_wait_high(tp, &rtl_link_list_ready_cond, 100, 42); 658525e992a4SHeiner Kallweit } 658625e992a4SHeiner Kallweit 658725e992a4SHeiner Kallweit static void rtl_hw_initialize(struct rtl8169_private *tp) 658825e992a4SHeiner Kallweit { 658925e992a4SHeiner Kallweit switch (tp->mac_version) { 659025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_49 ... RTL_GIGA_MAC_VER_51: 659125e992a4SHeiner Kallweit rtl8168ep_stop_cmac(tp); 659225e992a4SHeiner Kallweit /* fall through */ 659325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_40 ... RTL_GIGA_MAC_VER_48: 659425e992a4SHeiner Kallweit rtl_hw_init_8168g(tp); 659525e992a4SHeiner Kallweit break; 659625e992a4SHeiner Kallweit default: 659725e992a4SHeiner Kallweit break; 659825e992a4SHeiner Kallweit } 659925e992a4SHeiner Kallweit } 660025e992a4SHeiner Kallweit 660125e992a4SHeiner Kallweit static int rtl_jumbo_max(struct rtl8169_private *tp) 660225e992a4SHeiner Kallweit { 660325e992a4SHeiner Kallweit /* Non-GBit versions don't support jumbo frames */ 660425e992a4SHeiner Kallweit if (!tp->supports_gmii) 660525e992a4SHeiner Kallweit return JUMBO_1K; 660625e992a4SHeiner Kallweit 660725e992a4SHeiner Kallweit switch (tp->mac_version) { 660825e992a4SHeiner Kallweit /* RTL8169 */ 660925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_02 ... RTL_GIGA_MAC_VER_06: 661025e992a4SHeiner Kallweit return JUMBO_7K; 661125e992a4SHeiner Kallweit /* RTL8168b */ 661225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_11: 661325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_12: 661425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_17: 661525e992a4SHeiner Kallweit return JUMBO_4K; 661625e992a4SHeiner Kallweit /* RTL8168c */ 661725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_18 ... RTL_GIGA_MAC_VER_24: 661825e992a4SHeiner Kallweit return JUMBO_6K; 661925e992a4SHeiner Kallweit default: 662025e992a4SHeiner Kallweit return JUMBO_9K; 662125e992a4SHeiner Kallweit } 662225e992a4SHeiner Kallweit } 662325e992a4SHeiner Kallweit 662425e992a4SHeiner Kallweit static void rtl_disable_clk(void *data) 662525e992a4SHeiner Kallweit { 662625e992a4SHeiner Kallweit clk_disable_unprepare(data); 662725e992a4SHeiner Kallweit } 662825e992a4SHeiner Kallweit 662925e992a4SHeiner Kallweit static int rtl_get_ether_clk(struct rtl8169_private *tp) 663025e992a4SHeiner Kallweit { 663125e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 663225e992a4SHeiner Kallweit struct clk *clk; 663325e992a4SHeiner Kallweit int rc; 663425e992a4SHeiner Kallweit 663525e992a4SHeiner Kallweit clk = devm_clk_get(d, "ether_clk"); 663625e992a4SHeiner Kallweit if (IS_ERR(clk)) { 663725e992a4SHeiner Kallweit rc = PTR_ERR(clk); 663825e992a4SHeiner Kallweit if (rc == -ENOENT) 663925e992a4SHeiner Kallweit /* clk-core allows NULL (for suspend / resume) */ 664025e992a4SHeiner Kallweit rc = 0; 664125e992a4SHeiner Kallweit else if (rc != -EPROBE_DEFER) 664225e992a4SHeiner Kallweit dev_err(d, "failed to get clk: %d\n", rc); 664325e992a4SHeiner Kallweit } else { 664425e992a4SHeiner Kallweit tp->clk = clk; 664525e992a4SHeiner Kallweit rc = clk_prepare_enable(clk); 664625e992a4SHeiner Kallweit if (rc) 664725e992a4SHeiner Kallweit dev_err(d, "failed to enable clk: %d\n", rc); 664825e992a4SHeiner Kallweit else 664925e992a4SHeiner Kallweit rc = devm_add_action_or_reset(d, rtl_disable_clk, clk); 665025e992a4SHeiner Kallweit } 665125e992a4SHeiner Kallweit 665225e992a4SHeiner Kallweit return rc; 665325e992a4SHeiner Kallweit } 665425e992a4SHeiner Kallweit 665525e992a4SHeiner Kallweit static int rtl_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) 665625e992a4SHeiner Kallweit { 665725e992a4SHeiner Kallweit /* align to u16 for is_valid_ether_addr() */ 665825e992a4SHeiner Kallweit u8 mac_addr[ETH_ALEN] __aligned(2) = {}; 665925e992a4SHeiner Kallweit struct rtl8169_private *tp; 666025e992a4SHeiner Kallweit struct net_device *dev; 666125e992a4SHeiner Kallweit int chipset, region, i; 666225e992a4SHeiner Kallweit int jumbo_max, rc; 666325e992a4SHeiner Kallweit 666425e992a4SHeiner Kallweit dev = devm_alloc_etherdev(&pdev->dev, sizeof (*tp)); 666525e992a4SHeiner Kallweit if (!dev) 666625e992a4SHeiner Kallweit return -ENOMEM; 666725e992a4SHeiner Kallweit 666825e992a4SHeiner Kallweit SET_NETDEV_DEV(dev, &pdev->dev); 666925e992a4SHeiner Kallweit dev->netdev_ops = &rtl_netdev_ops; 667025e992a4SHeiner Kallweit tp = netdev_priv(dev); 667125e992a4SHeiner Kallweit tp->dev = dev; 667225e992a4SHeiner Kallweit tp->pci_dev = pdev; 667325e992a4SHeiner Kallweit tp->msg_enable = netif_msg_init(debug.msg_enable, R8169_MSG_DEFAULT); 6674145a40e8SHeiner Kallweit tp->supports_gmii = ent->driver_data == RTL_CFG_NO_GBIT ? 0 : 1; 667525e992a4SHeiner Kallweit 667625e992a4SHeiner Kallweit /* Get the *optional* external "ether_clk" used on some boards */ 667725e992a4SHeiner Kallweit rc = rtl_get_ether_clk(tp); 667825e992a4SHeiner Kallweit if (rc) 667925e992a4SHeiner Kallweit return rc; 668025e992a4SHeiner Kallweit 668125e992a4SHeiner Kallweit /* Disable ASPM completely as that cause random device stop working 668225e992a4SHeiner Kallweit * problems as well as full system hangs for some PCIe devices users. 668325e992a4SHeiner Kallweit */ 668462b1b3b3SHeiner Kallweit rc = pci_disable_link_state(pdev, PCIE_LINK_STATE_L0S | 668562b1b3b3SHeiner Kallweit PCIE_LINK_STATE_L1); 668662b1b3b3SHeiner Kallweit tp->aspm_manageable = !rc; 668725e992a4SHeiner Kallweit 668825e992a4SHeiner Kallweit /* enable device (incl. PCI PM wakeup and hotplug setup) */ 668925e992a4SHeiner Kallweit rc = pcim_enable_device(pdev); 669025e992a4SHeiner Kallweit if (rc < 0) { 669125e992a4SHeiner Kallweit dev_err(&pdev->dev, "enable failure\n"); 669225e992a4SHeiner Kallweit return rc; 669325e992a4SHeiner Kallweit } 669425e992a4SHeiner Kallweit 669525e992a4SHeiner Kallweit if (pcim_set_mwi(pdev) < 0) 669625e992a4SHeiner Kallweit dev_info(&pdev->dev, "Mem-Wr-Inval unavailable\n"); 669725e992a4SHeiner Kallweit 669825e992a4SHeiner Kallweit /* use first MMIO region */ 669925e992a4SHeiner Kallweit region = ffs(pci_select_bars(pdev, IORESOURCE_MEM)) - 1; 670025e992a4SHeiner Kallweit if (region < 0) { 670125e992a4SHeiner Kallweit dev_err(&pdev->dev, "no MMIO resource found\n"); 670225e992a4SHeiner Kallweit return -ENODEV; 670325e992a4SHeiner Kallweit } 670425e992a4SHeiner Kallweit 670525e992a4SHeiner Kallweit /* check for weird/broken PCI region reporting */ 670625e992a4SHeiner Kallweit if (pci_resource_len(pdev, region) < R8169_REGS_SIZE) { 670725e992a4SHeiner Kallweit dev_err(&pdev->dev, "Invalid PCI region size(s), aborting\n"); 670825e992a4SHeiner Kallweit return -ENODEV; 670925e992a4SHeiner Kallweit } 671025e992a4SHeiner Kallweit 671125e992a4SHeiner Kallweit rc = pcim_iomap_regions(pdev, BIT(region), MODULENAME); 671225e992a4SHeiner Kallweit if (rc < 0) { 671325e992a4SHeiner Kallweit dev_err(&pdev->dev, "cannot remap MMIO, aborting\n"); 671425e992a4SHeiner Kallweit return rc; 671525e992a4SHeiner Kallweit } 671625e992a4SHeiner Kallweit 671725e992a4SHeiner Kallweit tp->mmio_addr = pcim_iomap_table(pdev)[region]; 671825e992a4SHeiner Kallweit 671925e992a4SHeiner Kallweit /* Identify chip attached to board */ 672025e992a4SHeiner Kallweit rtl8169_get_mac_version(tp); 672125e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_NONE) 672225e992a4SHeiner Kallweit return -ENODEV; 672325e992a4SHeiner Kallweit 672425e992a4SHeiner Kallweit tp->cp_cmd = RTL_R16(tp, CPlusCmd); 672525e992a4SHeiner Kallweit 672625e992a4SHeiner Kallweit if (sizeof(dma_addr_t) > 4 && tp->mac_version >= RTL_GIGA_MAC_VER_18 && 67273c18cbe3SHeiner Kallweit !dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64))) 672825e992a4SHeiner Kallweit dev->features |= NETIF_F_HIGHDMA; 672925e992a4SHeiner Kallweit 673025e992a4SHeiner Kallweit rtl_init_rxcfg(tp); 673125e992a4SHeiner Kallweit 673225e992a4SHeiner Kallweit rtl8169_irq_mask_and_ack(tp); 673325e992a4SHeiner Kallweit 673425e992a4SHeiner Kallweit rtl_hw_initialize(tp); 673525e992a4SHeiner Kallweit 673625e992a4SHeiner Kallweit rtl_hw_reset(tp); 673725e992a4SHeiner Kallweit 673825e992a4SHeiner Kallweit pci_set_master(pdev); 673925e992a4SHeiner Kallweit 674025e992a4SHeiner Kallweit chipset = tp->mac_version; 674125e992a4SHeiner Kallweit 674225e992a4SHeiner Kallweit rc = rtl_alloc_irq(tp); 674325e992a4SHeiner Kallweit if (rc < 0) { 674425e992a4SHeiner Kallweit dev_err(&pdev->dev, "Can't allocate interrupt\n"); 674525e992a4SHeiner Kallweit return rc; 674625e992a4SHeiner Kallweit } 674725e992a4SHeiner Kallweit 674825e992a4SHeiner Kallweit mutex_init(&tp->wk.mutex); 674925e992a4SHeiner Kallweit INIT_WORK(&tp->wk.work, rtl_task); 675025e992a4SHeiner Kallweit u64_stats_init(&tp->rx_stats.syncp); 675125e992a4SHeiner Kallweit u64_stats_init(&tp->tx_stats.syncp); 675225e992a4SHeiner Kallweit 675325e992a4SHeiner Kallweit /* get MAC address */ 675425e992a4SHeiner Kallweit rc = eth_platform_get_mac_address(&pdev->dev, mac_addr); 675525e992a4SHeiner Kallweit if (rc) 675625e992a4SHeiner Kallweit rtl_read_mac_address(tp, mac_addr); 675725e992a4SHeiner Kallweit 675825e992a4SHeiner Kallweit if (is_valid_ether_addr(mac_addr)) 675925e992a4SHeiner Kallweit rtl_rar_set(tp, mac_addr); 676025e992a4SHeiner Kallweit 676125e992a4SHeiner Kallweit for (i = 0; i < ETH_ALEN; i++) 676225e992a4SHeiner Kallweit dev->dev_addr[i] = RTL_R8(tp, MAC0 + i); 676325e992a4SHeiner Kallweit 676425e992a4SHeiner Kallweit dev->ethtool_ops = &rtl8169_ethtool_ops; 676525e992a4SHeiner Kallweit 676625e992a4SHeiner Kallweit netif_napi_add(dev, &tp->napi, rtl8169_poll, NAPI_POLL_WEIGHT); 676725e992a4SHeiner Kallweit 676825e992a4SHeiner Kallweit /* don't enable SG, IP_CSUM and TSO by default - it might not work 676925e992a4SHeiner Kallweit * properly for all devices */ 677025e992a4SHeiner Kallweit dev->features |= NETIF_F_RXCSUM | 677125e992a4SHeiner Kallweit NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX; 677225e992a4SHeiner Kallweit 677325e992a4SHeiner Kallweit dev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO | 677425e992a4SHeiner Kallweit NETIF_F_RXCSUM | NETIF_F_HW_VLAN_CTAG_TX | 677525e992a4SHeiner Kallweit NETIF_F_HW_VLAN_CTAG_RX; 677625e992a4SHeiner Kallweit dev->vlan_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO | 677725e992a4SHeiner Kallweit NETIF_F_HIGHDMA; 677825e992a4SHeiner Kallweit dev->priv_flags |= IFF_LIVE_ADDR_CHANGE; 677925e992a4SHeiner Kallweit 678025e992a4SHeiner Kallweit tp->cp_cmd |= RxChkSum | RxVlan; 678125e992a4SHeiner Kallweit 678225e992a4SHeiner Kallweit /* 678325e992a4SHeiner Kallweit * Pretend we are using VLANs; This bypasses a nasty bug where 678425e992a4SHeiner Kallweit * Interrupts stop flowing on high load on 8110SCd controllers. 678525e992a4SHeiner Kallweit */ 678625e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_05) 678725e992a4SHeiner Kallweit /* Disallow toggling */ 678825e992a4SHeiner Kallweit dev->hw_features &= ~NETIF_F_HW_VLAN_CTAG_RX; 678925e992a4SHeiner Kallweit 679025e992a4SHeiner Kallweit if (rtl_chip_supports_csum_v2(tp)) 679125e992a4SHeiner Kallweit dev->hw_features |= NETIF_F_IPV6_CSUM | NETIF_F_TSO6; 679225e992a4SHeiner Kallweit 679325e992a4SHeiner Kallweit dev->hw_features |= NETIF_F_RXALL; 679425e992a4SHeiner Kallweit dev->hw_features |= NETIF_F_RXFCS; 679525e992a4SHeiner Kallweit 679625e992a4SHeiner Kallweit /* MTU range: 60 - hw-specific max */ 679725e992a4SHeiner Kallweit dev->min_mtu = ETH_ZLEN; 679825e992a4SHeiner Kallweit jumbo_max = rtl_jumbo_max(tp); 679925e992a4SHeiner Kallweit dev->max_mtu = jumbo_max; 680025e992a4SHeiner Kallweit 6801ec9a4088SHeiner Kallweit rtl_set_irq_mask(tp); 68029fa0a8e1SHeiner Kallweit 680325e992a4SHeiner Kallweit tp->fw_name = rtl_chip_infos[chipset].fw_name; 680425e992a4SHeiner Kallweit 680525e992a4SHeiner Kallweit tp->counters = dmam_alloc_coherent (&pdev->dev, sizeof(*tp->counters), 680625e992a4SHeiner Kallweit &tp->counters_phys_addr, 680725e992a4SHeiner Kallweit GFP_KERNEL); 680825e992a4SHeiner Kallweit if (!tp->counters) 680925e992a4SHeiner Kallweit return -ENOMEM; 681025e992a4SHeiner Kallweit 681125e992a4SHeiner Kallweit pci_set_drvdata(pdev, dev); 681225e992a4SHeiner Kallweit 681325e992a4SHeiner Kallweit rc = r8169_mdio_register(tp); 681425e992a4SHeiner Kallweit if (rc) 681525e992a4SHeiner Kallweit return rc; 681625e992a4SHeiner Kallweit 681725e992a4SHeiner Kallweit /* chip gets powered up in rtl_open() */ 681825e992a4SHeiner Kallweit rtl_pll_power_down(tp); 681925e992a4SHeiner Kallweit 682025e992a4SHeiner Kallweit rc = register_netdev(dev); 682125e992a4SHeiner Kallweit if (rc) 682225e992a4SHeiner Kallweit goto err_mdio_unregister; 682325e992a4SHeiner Kallweit 682425e992a4SHeiner Kallweit netif_info(tp, probe, dev, "%s, %pM, XID %03x, IRQ %d\n", 682525e992a4SHeiner Kallweit rtl_chip_infos[chipset].name, dev->dev_addr, 682625e992a4SHeiner Kallweit (RTL_R32(tp, TxConfig) >> 20) & 0xfcf, 682725e992a4SHeiner Kallweit pci_irq_vector(pdev, 0)); 682825e992a4SHeiner Kallweit 682925e992a4SHeiner Kallweit if (jumbo_max > JUMBO_1K) 683025e992a4SHeiner Kallweit netif_info(tp, probe, dev, 683125e992a4SHeiner Kallweit "jumbo features [frames: %d bytes, tx checksumming: %s]\n", 683225e992a4SHeiner Kallweit jumbo_max, tp->mac_version <= RTL_GIGA_MAC_VER_06 ? 683325e992a4SHeiner Kallweit "ok" : "ko"); 683425e992a4SHeiner Kallweit 683525e992a4SHeiner Kallweit if (r8168_check_dash(tp)) 683625e992a4SHeiner Kallweit rtl8168_driver_start(tp); 683725e992a4SHeiner Kallweit 683825e992a4SHeiner Kallweit if (pci_dev_run_wake(pdev)) 683925e992a4SHeiner Kallweit pm_runtime_put_sync(&pdev->dev); 684025e992a4SHeiner Kallweit 684125e992a4SHeiner Kallweit return 0; 684225e992a4SHeiner Kallweit 684325e992a4SHeiner Kallweit err_mdio_unregister: 684425e992a4SHeiner Kallweit mdiobus_unregister(tp->phydev->mdio.bus); 684525e992a4SHeiner Kallweit return rc; 684625e992a4SHeiner Kallweit } 684725e992a4SHeiner Kallweit 684825e992a4SHeiner Kallweit static struct pci_driver rtl8169_pci_driver = { 684925e992a4SHeiner Kallweit .name = MODULENAME, 685025e992a4SHeiner Kallweit .id_table = rtl8169_pci_tbl, 685125e992a4SHeiner Kallweit .probe = rtl_init_one, 685225e992a4SHeiner Kallweit .remove = rtl_remove_one, 685325e992a4SHeiner Kallweit .shutdown = rtl_shutdown, 685425e992a4SHeiner Kallweit .driver.pm = RTL8169_PM_OPS, 685525e992a4SHeiner Kallweit }; 685625e992a4SHeiner Kallweit 685725e992a4SHeiner Kallweit module_pci_driver(rtl8169_pci_driver); 6858