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/ipv6.h> 3225e992a4SHeiner Kallweit #include <net/ip6_checksum.h> 3325e992a4SHeiner Kallweit 348197f9d2SHeiner Kallweit #include "r8169_firmware.h" 358197f9d2SHeiner Kallweit 3625e992a4SHeiner Kallweit #define MODULENAME "r8169" 3725e992a4SHeiner Kallweit 3825e992a4SHeiner Kallweit #define FIRMWARE_8168D_1 "rtl_nic/rtl8168d-1.fw" 3925e992a4SHeiner Kallweit #define FIRMWARE_8168D_2 "rtl_nic/rtl8168d-2.fw" 4025e992a4SHeiner Kallweit #define FIRMWARE_8168E_1 "rtl_nic/rtl8168e-1.fw" 4125e992a4SHeiner Kallweit #define FIRMWARE_8168E_2 "rtl_nic/rtl8168e-2.fw" 4225e992a4SHeiner Kallweit #define FIRMWARE_8168E_3 "rtl_nic/rtl8168e-3.fw" 4325e992a4SHeiner Kallweit #define FIRMWARE_8168F_1 "rtl_nic/rtl8168f-1.fw" 4425e992a4SHeiner Kallweit #define FIRMWARE_8168F_2 "rtl_nic/rtl8168f-2.fw" 4525e992a4SHeiner Kallweit #define FIRMWARE_8105E_1 "rtl_nic/rtl8105e-1.fw" 4625e992a4SHeiner Kallweit #define FIRMWARE_8402_1 "rtl_nic/rtl8402-1.fw" 4725e992a4SHeiner Kallweit #define FIRMWARE_8411_1 "rtl_nic/rtl8411-1.fw" 4825e992a4SHeiner Kallweit #define FIRMWARE_8411_2 "rtl_nic/rtl8411-2.fw" 4925e992a4SHeiner Kallweit #define FIRMWARE_8106E_1 "rtl_nic/rtl8106e-1.fw" 5025e992a4SHeiner Kallweit #define FIRMWARE_8106E_2 "rtl_nic/rtl8106e-2.fw" 5125e992a4SHeiner Kallweit #define FIRMWARE_8168G_2 "rtl_nic/rtl8168g-2.fw" 5225e992a4SHeiner Kallweit #define FIRMWARE_8168G_3 "rtl_nic/rtl8168g-3.fw" 5325e992a4SHeiner Kallweit #define FIRMWARE_8168H_1 "rtl_nic/rtl8168h-1.fw" 5425e992a4SHeiner Kallweit #define FIRMWARE_8168H_2 "rtl_nic/rtl8168h-2.fw" 55229c1e0dSHeiner Kallweit #define FIRMWARE_8168FP_3 "rtl_nic/rtl8168fp-3.fw" 5625e992a4SHeiner Kallweit #define FIRMWARE_8107E_1 "rtl_nic/rtl8107e-1.fw" 5725e992a4SHeiner Kallweit #define FIRMWARE_8107E_2 "rtl_nic/rtl8107e-2.fw" 5802bf642bSHeiner Kallweit #define FIRMWARE_8125A_3 "rtl_nic/rtl8125a-3.fw" 5925e992a4SHeiner Kallweit 6025e992a4SHeiner Kallweit #define R8169_MSG_DEFAULT \ 6125e992a4SHeiner Kallweit (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_IFUP | NETIF_MSG_IFDOWN) 6225e992a4SHeiner Kallweit 6325e992a4SHeiner Kallweit /* Maximum number of multicast addresses to filter (vs. Rx-all-multicast). 6425e992a4SHeiner Kallweit The RTL chips use a 64 element hash table based on the Ethernet CRC. */ 6581cd17a4SHeiner Kallweit #define MC_FILTER_LIMIT 32 6625e992a4SHeiner Kallweit 6725e992a4SHeiner Kallweit #define TX_DMA_BURST 7 /* Maximum PCI burst, '7' is unlimited */ 6825e992a4SHeiner Kallweit #define InterFrameGap 0x03 /* 3 means InterFrameGap = the shortest one */ 6925e992a4SHeiner Kallweit 7025e992a4SHeiner Kallweit #define R8169_REGS_SIZE 256 7125e992a4SHeiner Kallweit #define R8169_RX_BUF_SIZE (SZ_16K - 1) 7225e992a4SHeiner Kallweit #define NUM_TX_DESC 64 /* Number of Tx descriptor registers */ 7325e992a4SHeiner Kallweit #define NUM_RX_DESC 256U /* Number of Rx descriptor registers */ 7425e992a4SHeiner Kallweit #define R8169_TX_RING_BYTES (NUM_TX_DESC * sizeof(struct TxDesc)) 7525e992a4SHeiner Kallweit #define R8169_RX_RING_BYTES (NUM_RX_DESC * sizeof(struct RxDesc)) 7625e992a4SHeiner Kallweit 77145a40e8SHeiner Kallweit #define RTL_CFG_NO_GBIT 1 78145a40e8SHeiner Kallweit 7925e992a4SHeiner Kallweit /* write/read MMIO register */ 8025e992a4SHeiner Kallweit #define RTL_W8(tp, reg, val8) writeb((val8), tp->mmio_addr + (reg)) 8125e992a4SHeiner Kallweit #define RTL_W16(tp, reg, val16) writew((val16), tp->mmio_addr + (reg)) 8225e992a4SHeiner Kallweit #define RTL_W32(tp, reg, val32) writel((val32), tp->mmio_addr + (reg)) 8325e992a4SHeiner Kallweit #define RTL_R8(tp, reg) readb(tp->mmio_addr + (reg)) 8425e992a4SHeiner Kallweit #define RTL_R16(tp, reg) readw(tp->mmio_addr + (reg)) 8525e992a4SHeiner Kallweit #define RTL_R32(tp, reg) readl(tp->mmio_addr + (reg)) 8625e992a4SHeiner Kallweit 8725e992a4SHeiner Kallweit enum mac_version { 8825e992a4SHeiner Kallweit /* support for ancient RTL_GIGA_MAC_VER_01 has been removed */ 8925e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_02, 9025e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_03, 9125e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_04, 9225e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_05, 9325e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_06, 9425e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_07, 9525e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_08, 9625e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_09, 9725e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_10, 9825e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_11, 9925e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_12, 10025e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_13, 10125e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_14, 10225e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_15, 10325e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_16, 10425e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_17, 10525e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_18, 10625e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_19, 10725e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_20, 10825e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_21, 10925e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_22, 11025e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_23, 11125e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_24, 11225e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_25, 11325e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_26, 11425e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_27, 11525e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_28, 11625e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_29, 11725e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_30, 11825e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_31, 11925e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_32, 12025e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_33, 12125e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_34, 12225e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_35, 12325e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_36, 12425e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_37, 12525e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_38, 12625e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_39, 12725e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_40, 12825e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_41, 12925e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_42, 13025e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_43, 13125e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_44, 13225e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_45, 13325e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_46, 13425e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_47, 13525e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_48, 13625e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_49, 13725e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_50, 13825e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_51, 1391287723aSHeiner Kallweit RTL_GIGA_MAC_VER_52, 140f1bce4adSHeiner Kallweit RTL_GIGA_MAC_VER_60, 141f1bce4adSHeiner Kallweit RTL_GIGA_MAC_VER_61, 14225e992a4SHeiner Kallweit RTL_GIGA_MAC_NONE 14325e992a4SHeiner Kallweit }; 14425e992a4SHeiner Kallweit 14525e992a4SHeiner Kallweit #define JUMBO_1K ETH_DATA_LEN 14625e992a4SHeiner Kallweit #define JUMBO_4K (4*1024 - ETH_HLEN - 2) 14725e992a4SHeiner Kallweit #define JUMBO_6K (6*1024 - ETH_HLEN - 2) 14825e992a4SHeiner Kallweit #define JUMBO_7K (7*1024 - ETH_HLEN - 2) 14925e992a4SHeiner Kallweit #define JUMBO_9K (9*1024 - ETH_HLEN - 2) 15025e992a4SHeiner Kallweit 15125e992a4SHeiner Kallweit static const struct { 15225e992a4SHeiner Kallweit const char *name; 15325e992a4SHeiner Kallweit const char *fw_name; 15425e992a4SHeiner Kallweit } rtl_chip_infos[] = { 15525e992a4SHeiner Kallweit /* PCI devices. */ 15625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_02] = {"RTL8169s" }, 15725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_03] = {"RTL8110s" }, 15825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_04] = {"RTL8169sb/8110sb" }, 15925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_05] = {"RTL8169sc/8110sc" }, 16025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_06] = {"RTL8169sc/8110sc" }, 16125e992a4SHeiner Kallweit /* PCI-E devices. */ 16225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_07] = {"RTL8102e" }, 16325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_08] = {"RTL8102e" }, 1649e0773c3SHeiner Kallweit [RTL_GIGA_MAC_VER_09] = {"RTL8102e/RTL8103e" }, 16525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_10] = {"RTL8101e" }, 16625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_11] = {"RTL8168b/8111b" }, 16725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_12] = {"RTL8168b/8111b" }, 16825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_13] = {"RTL8101e" }, 16925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_14] = {"RTL8100e" }, 17025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_15] = {"RTL8100e" }, 17125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_16] = {"RTL8101e" }, 17225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_17] = {"RTL8168b/8111b" }, 17325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_18] = {"RTL8168cp/8111cp" }, 17425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_19] = {"RTL8168c/8111c" }, 17525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_20] = {"RTL8168c/8111c" }, 17625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_21] = {"RTL8168c/8111c" }, 17725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_22] = {"RTL8168c/8111c" }, 17825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_23] = {"RTL8168cp/8111cp" }, 17925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_24] = {"RTL8168cp/8111cp" }, 18025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_25] = {"RTL8168d/8111d", FIRMWARE_8168D_1}, 18125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_26] = {"RTL8168d/8111d", FIRMWARE_8168D_2}, 18225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_27] = {"RTL8168dp/8111dp" }, 18325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_28] = {"RTL8168dp/8111dp" }, 18425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_29] = {"RTL8105e", FIRMWARE_8105E_1}, 18525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_30] = {"RTL8105e", FIRMWARE_8105E_1}, 18625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_31] = {"RTL8168dp/8111dp" }, 18725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_32] = {"RTL8168e/8111e", FIRMWARE_8168E_1}, 18825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_33] = {"RTL8168e/8111e", FIRMWARE_8168E_2}, 18925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_34] = {"RTL8168evl/8111evl", FIRMWARE_8168E_3}, 19025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_35] = {"RTL8168f/8111f", FIRMWARE_8168F_1}, 19125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_36] = {"RTL8168f/8111f", FIRMWARE_8168F_2}, 19225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_37] = {"RTL8402", FIRMWARE_8402_1 }, 19325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_38] = {"RTL8411", FIRMWARE_8411_1 }, 19425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_39] = {"RTL8106e", FIRMWARE_8106E_1}, 19525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_40] = {"RTL8168g/8111g", FIRMWARE_8168G_2}, 19625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_41] = {"RTL8168g/8111g" }, 1979e0773c3SHeiner Kallweit [RTL_GIGA_MAC_VER_42] = {"RTL8168gu/8111gu", FIRMWARE_8168G_3}, 1989e0773c3SHeiner Kallweit [RTL_GIGA_MAC_VER_43] = {"RTL8106eus", FIRMWARE_8106E_2}, 1999e0773c3SHeiner Kallweit [RTL_GIGA_MAC_VER_44] = {"RTL8411b", FIRMWARE_8411_2 }, 20025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_45] = {"RTL8168h/8111h", FIRMWARE_8168H_1}, 20125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_46] = {"RTL8168h/8111h", FIRMWARE_8168H_2}, 20225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_47] = {"RTL8107e", FIRMWARE_8107E_1}, 20325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_48] = {"RTL8107e", FIRMWARE_8107E_2}, 20425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_49] = {"RTL8168ep/8111ep" }, 20525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_50] = {"RTL8168ep/8111ep" }, 20625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_51] = {"RTL8168ep/8111ep" }, 207229c1e0dSHeiner Kallweit [RTL_GIGA_MAC_VER_52] = {"RTL8168fp/RTL8117", FIRMWARE_8168FP_3}, 208f1bce4adSHeiner Kallweit [RTL_GIGA_MAC_VER_60] = {"RTL8125" }, 20902bf642bSHeiner Kallweit [RTL_GIGA_MAC_VER_61] = {"RTL8125", FIRMWARE_8125A_3}, 21025e992a4SHeiner Kallweit }; 21125e992a4SHeiner Kallweit 21225e992a4SHeiner Kallweit static const struct pci_device_id rtl8169_pci_tbl[] = { 213145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x2502) }, 214145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x2600) }, 215145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x8129) }, 216145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x8136), RTL_CFG_NO_GBIT }, 217145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x8161) }, 218145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x8167) }, 219145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x8168) }, 220145a40e8SHeiner Kallweit { PCI_VDEVICE(NCUBE, 0x8168) }, 221145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x8169) }, 22225e992a4SHeiner Kallweit { PCI_VENDOR_ID_DLINK, 0x4300, 223145a40e8SHeiner Kallweit PCI_VENDOR_ID_DLINK, 0x4b10, 0, 0 }, 2249d9f3fbaSHeiner Kallweit { PCI_VDEVICE(DLINK, 0x4300) }, 2259d9f3fbaSHeiner Kallweit { PCI_VDEVICE(DLINK, 0x4302) }, 2269d9f3fbaSHeiner Kallweit { PCI_VDEVICE(AT, 0xc107) }, 2279d9f3fbaSHeiner Kallweit { PCI_VDEVICE(USR, 0x0116) }, 2289d9f3fbaSHeiner Kallweit { PCI_VENDOR_ID_LINKSYS, 0x1032, PCI_ANY_ID, 0x0024 }, 2299d9f3fbaSHeiner Kallweit { 0x0001, 0x8168, PCI_ANY_ID, 0x2410 }, 230f1bce4adSHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x8125) }, 231f1bce4adSHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x3000) }, 23225e992a4SHeiner Kallweit {} 23325e992a4SHeiner Kallweit }; 23425e992a4SHeiner Kallweit 23525e992a4SHeiner Kallweit MODULE_DEVICE_TABLE(pci, rtl8169_pci_tbl); 23625e992a4SHeiner Kallweit 23725e992a4SHeiner Kallweit static struct { 23825e992a4SHeiner Kallweit u32 msg_enable; 23925e992a4SHeiner Kallweit } debug = { -1 }; 24025e992a4SHeiner Kallweit 24125e992a4SHeiner Kallweit enum rtl_registers { 24225e992a4SHeiner Kallweit MAC0 = 0, /* Ethernet hardware address. */ 24325e992a4SHeiner Kallweit MAC4 = 4, 24425e992a4SHeiner Kallweit MAR0 = 8, /* Multicast filter. */ 24525e992a4SHeiner Kallweit CounterAddrLow = 0x10, 24625e992a4SHeiner Kallweit CounterAddrHigh = 0x14, 24725e992a4SHeiner Kallweit TxDescStartAddrLow = 0x20, 24825e992a4SHeiner Kallweit TxDescStartAddrHigh = 0x24, 24925e992a4SHeiner Kallweit TxHDescStartAddrLow = 0x28, 25025e992a4SHeiner Kallweit TxHDescStartAddrHigh = 0x2c, 25125e992a4SHeiner Kallweit FLASH = 0x30, 25225e992a4SHeiner Kallweit ERSR = 0x36, 25325e992a4SHeiner Kallweit ChipCmd = 0x37, 25425e992a4SHeiner Kallweit TxPoll = 0x38, 25525e992a4SHeiner Kallweit IntrMask = 0x3c, 25625e992a4SHeiner Kallweit IntrStatus = 0x3e, 25725e992a4SHeiner Kallweit 25825e992a4SHeiner Kallweit TxConfig = 0x40, 25925e992a4SHeiner Kallweit #define TXCFG_AUTO_FIFO (1 << 7) /* 8111e-vl */ 26025e992a4SHeiner Kallweit #define TXCFG_EMPTY (1 << 11) /* 8111e-vl */ 26125e992a4SHeiner Kallweit 26225e992a4SHeiner Kallweit RxConfig = 0x44, 26325e992a4SHeiner Kallweit #define RX128_INT_EN (1 << 15) /* 8111c and later */ 26425e992a4SHeiner Kallweit #define RX_MULTI_EN (1 << 14) /* 8111c only */ 26525e992a4SHeiner Kallweit #define RXCFG_FIFO_SHIFT 13 26625e992a4SHeiner Kallweit /* No threshold before first PCI xfer */ 26725e992a4SHeiner Kallweit #define RX_FIFO_THRESH (7 << RXCFG_FIFO_SHIFT) 26825e992a4SHeiner Kallweit #define RX_EARLY_OFF (1 << 11) 26925e992a4SHeiner Kallweit #define RXCFG_DMA_SHIFT 8 27025e992a4SHeiner Kallweit /* Unlimited maximum PCI burst. */ 27125e992a4SHeiner Kallweit #define RX_DMA_BURST (7 << RXCFG_DMA_SHIFT) 27225e992a4SHeiner Kallweit 27325e992a4SHeiner Kallweit RxMissed = 0x4c, 27425e992a4SHeiner Kallweit Cfg9346 = 0x50, 27525e992a4SHeiner Kallweit Config0 = 0x51, 27625e992a4SHeiner Kallweit Config1 = 0x52, 27725e992a4SHeiner Kallweit Config2 = 0x53, 27825e992a4SHeiner Kallweit #define PME_SIGNAL (1 << 5) /* 8168c and later */ 27925e992a4SHeiner Kallweit 28025e992a4SHeiner Kallweit Config3 = 0x54, 28125e992a4SHeiner Kallweit Config4 = 0x55, 28225e992a4SHeiner Kallweit Config5 = 0x56, 28325e992a4SHeiner Kallweit PHYAR = 0x60, 28425e992a4SHeiner Kallweit PHYstatus = 0x6c, 28525e992a4SHeiner Kallweit RxMaxSize = 0xda, 28625e992a4SHeiner Kallweit CPlusCmd = 0xe0, 28725e992a4SHeiner Kallweit IntrMitigate = 0xe2, 28825e992a4SHeiner Kallweit 28925e992a4SHeiner Kallweit #define RTL_COALESCE_MASK 0x0f 29025e992a4SHeiner Kallweit #define RTL_COALESCE_SHIFT 4 29125e992a4SHeiner Kallweit #define RTL_COALESCE_T_MAX (RTL_COALESCE_MASK) 29225e992a4SHeiner Kallweit #define RTL_COALESCE_FRAME_MAX (RTL_COALESCE_MASK << 2) 29325e992a4SHeiner Kallweit 29425e992a4SHeiner Kallweit RxDescAddrLow = 0xe4, 29525e992a4SHeiner Kallweit RxDescAddrHigh = 0xe8, 29625e992a4SHeiner Kallweit EarlyTxThres = 0xec, /* 8169. Unit of 32 bytes. */ 29725e992a4SHeiner Kallweit 29825e992a4SHeiner Kallweit #define NoEarlyTx 0x3f /* Max value : no early transmit. */ 29925e992a4SHeiner Kallweit 30025e992a4SHeiner Kallweit MaxTxPacketSize = 0xec, /* 8101/8168. Unit of 128 bytes. */ 30125e992a4SHeiner Kallweit 30225e992a4SHeiner Kallweit #define TxPacketMax (8064 >> 7) 30325e992a4SHeiner Kallweit #define EarlySize 0x27 30425e992a4SHeiner Kallweit 30525e992a4SHeiner Kallweit FuncEvent = 0xf0, 30625e992a4SHeiner Kallweit FuncEventMask = 0xf4, 30725e992a4SHeiner Kallweit FuncPresetState = 0xf8, 30825e992a4SHeiner Kallweit IBCR0 = 0xf8, 30925e992a4SHeiner Kallweit IBCR2 = 0xf9, 31025e992a4SHeiner Kallweit IBIMR0 = 0xfa, 31125e992a4SHeiner Kallweit IBISR0 = 0xfb, 31225e992a4SHeiner Kallweit FuncForceEvent = 0xfc, 31325e992a4SHeiner Kallweit }; 31425e992a4SHeiner Kallweit 31525e992a4SHeiner Kallweit enum rtl8168_8101_registers { 31625e992a4SHeiner Kallweit CSIDR = 0x64, 31725e992a4SHeiner Kallweit CSIAR = 0x68, 31825e992a4SHeiner Kallweit #define CSIAR_FLAG 0x80000000 31925e992a4SHeiner Kallweit #define CSIAR_WRITE_CMD 0x80000000 32025e992a4SHeiner Kallweit #define CSIAR_BYTE_ENABLE 0x0000f000 32125e992a4SHeiner Kallweit #define CSIAR_ADDR_MASK 0x00000fff 32225e992a4SHeiner Kallweit PMCH = 0x6f, 32325e992a4SHeiner Kallweit EPHYAR = 0x80, 32425e992a4SHeiner Kallweit #define EPHYAR_FLAG 0x80000000 32525e992a4SHeiner Kallweit #define EPHYAR_WRITE_CMD 0x80000000 32625e992a4SHeiner Kallweit #define EPHYAR_REG_MASK 0x1f 32725e992a4SHeiner Kallweit #define EPHYAR_REG_SHIFT 16 32825e992a4SHeiner Kallweit #define EPHYAR_DATA_MASK 0xffff 32925e992a4SHeiner Kallweit DLLPR = 0xd0, 33025e992a4SHeiner Kallweit #define PFM_EN (1 << 6) 33125e992a4SHeiner Kallweit #define TX_10M_PS_EN (1 << 7) 33225e992a4SHeiner Kallweit DBG_REG = 0xd1, 33325e992a4SHeiner Kallweit #define FIX_NAK_1 (1 << 4) 33425e992a4SHeiner Kallweit #define FIX_NAK_2 (1 << 3) 33525e992a4SHeiner Kallweit TWSI = 0xd2, 33625e992a4SHeiner Kallweit MCU = 0xd3, 33725e992a4SHeiner Kallweit #define NOW_IS_OOB (1 << 7) 33825e992a4SHeiner Kallweit #define TX_EMPTY (1 << 5) 33925e992a4SHeiner Kallweit #define RX_EMPTY (1 << 4) 34025e992a4SHeiner Kallweit #define RXTX_EMPTY (TX_EMPTY | RX_EMPTY) 34125e992a4SHeiner Kallweit #define EN_NDP (1 << 3) 34225e992a4SHeiner Kallweit #define EN_OOB_RESET (1 << 2) 34325e992a4SHeiner Kallweit #define LINK_LIST_RDY (1 << 1) 34425e992a4SHeiner Kallweit EFUSEAR = 0xdc, 34525e992a4SHeiner Kallweit #define EFUSEAR_FLAG 0x80000000 34625e992a4SHeiner Kallweit #define EFUSEAR_WRITE_CMD 0x80000000 34725e992a4SHeiner Kallweit #define EFUSEAR_READ_CMD 0x00000000 34825e992a4SHeiner Kallweit #define EFUSEAR_REG_MASK 0x03ff 34925e992a4SHeiner Kallweit #define EFUSEAR_REG_SHIFT 8 35025e992a4SHeiner Kallweit #define EFUSEAR_DATA_MASK 0xff 35125e992a4SHeiner Kallweit MISC_1 = 0xf2, 35225e992a4SHeiner Kallweit #define PFM_D3COLD_EN (1 << 6) 35325e992a4SHeiner Kallweit }; 35425e992a4SHeiner Kallweit 35525e992a4SHeiner Kallweit enum rtl8168_registers { 35625e992a4SHeiner Kallweit LED_FREQ = 0x1a, 35725e992a4SHeiner Kallweit EEE_LED = 0x1b, 35825e992a4SHeiner Kallweit ERIDR = 0x70, 35925e992a4SHeiner Kallweit ERIAR = 0x74, 36025e992a4SHeiner Kallweit #define ERIAR_FLAG 0x80000000 36125e992a4SHeiner Kallweit #define ERIAR_WRITE_CMD 0x80000000 36225e992a4SHeiner Kallweit #define ERIAR_READ_CMD 0x00000000 36325e992a4SHeiner Kallweit #define ERIAR_ADDR_BYTE_ALIGN 4 36425e992a4SHeiner Kallweit #define ERIAR_TYPE_SHIFT 16 36525e992a4SHeiner Kallweit #define ERIAR_EXGMAC (0x00 << ERIAR_TYPE_SHIFT) 36625e992a4SHeiner Kallweit #define ERIAR_MSIX (0x01 << ERIAR_TYPE_SHIFT) 36725e992a4SHeiner Kallweit #define ERIAR_ASF (0x02 << ERIAR_TYPE_SHIFT) 36825e992a4SHeiner Kallweit #define ERIAR_OOB (0x02 << ERIAR_TYPE_SHIFT) 36925e992a4SHeiner Kallweit #define ERIAR_MASK_SHIFT 12 37025e992a4SHeiner Kallweit #define ERIAR_MASK_0001 (0x1 << ERIAR_MASK_SHIFT) 37125e992a4SHeiner Kallweit #define ERIAR_MASK_0011 (0x3 << ERIAR_MASK_SHIFT) 37225e992a4SHeiner Kallweit #define ERIAR_MASK_0100 (0x4 << ERIAR_MASK_SHIFT) 37325e992a4SHeiner Kallweit #define ERIAR_MASK_0101 (0x5 << ERIAR_MASK_SHIFT) 37425e992a4SHeiner Kallweit #define ERIAR_MASK_1111 (0xf << ERIAR_MASK_SHIFT) 37525e992a4SHeiner Kallweit EPHY_RXER_NUM = 0x7c, 37625e992a4SHeiner Kallweit OCPDR = 0xb0, /* OCP GPHY access */ 37725e992a4SHeiner Kallweit #define OCPDR_WRITE_CMD 0x80000000 37825e992a4SHeiner Kallweit #define OCPDR_READ_CMD 0x00000000 37925e992a4SHeiner Kallweit #define OCPDR_REG_MASK 0x7f 38025e992a4SHeiner Kallweit #define OCPDR_GPHY_REG_SHIFT 16 38125e992a4SHeiner Kallweit #define OCPDR_DATA_MASK 0xffff 38225e992a4SHeiner Kallweit OCPAR = 0xb4, 38325e992a4SHeiner Kallweit #define OCPAR_FLAG 0x80000000 38425e992a4SHeiner Kallweit #define OCPAR_GPHY_WRITE_CMD 0x8000f060 38525e992a4SHeiner Kallweit #define OCPAR_GPHY_READ_CMD 0x0000f060 38625e992a4SHeiner Kallweit GPHY_OCP = 0xb8, 38725e992a4SHeiner Kallweit RDSAR1 = 0xd0, /* 8168c only. Undocumented on 8168dp */ 38825e992a4SHeiner Kallweit MISC = 0xf0, /* 8168e only. */ 38925e992a4SHeiner Kallweit #define TXPLA_RST (1 << 29) 39025e992a4SHeiner Kallweit #define DISABLE_LAN_EN (1 << 23) /* Enable GPIO pin */ 39125e992a4SHeiner Kallweit #define PWM_EN (1 << 22) 39225e992a4SHeiner Kallweit #define RXDV_GATED_EN (1 << 19) 39325e992a4SHeiner Kallweit #define EARLY_TALLY_EN (1 << 16) 39425e992a4SHeiner Kallweit }; 39525e992a4SHeiner Kallweit 396f1bce4adSHeiner Kallweit enum rtl8125_registers { 397f1bce4adSHeiner Kallweit IntrMask_8125 = 0x38, 398f1bce4adSHeiner Kallweit IntrStatus_8125 = 0x3c, 399f1bce4adSHeiner Kallweit TxPoll_8125 = 0x90, 400f1bce4adSHeiner Kallweit MAC0_BKP = 0x19e0, 401f1bce4adSHeiner Kallweit }; 402f1bce4adSHeiner Kallweit 403f1bce4adSHeiner Kallweit #define RX_VLAN_INNER_8125 BIT(22) 404f1bce4adSHeiner Kallweit #define RX_VLAN_OUTER_8125 BIT(23) 405f1bce4adSHeiner Kallweit #define RX_VLAN_8125 (RX_VLAN_INNER_8125 | RX_VLAN_OUTER_8125) 406f1bce4adSHeiner Kallweit 407f1bce4adSHeiner Kallweit #define RX_FETCH_DFLT_8125 (8 << 27) 408f1bce4adSHeiner Kallweit 40925e992a4SHeiner Kallweit enum rtl_register_content { 41025e992a4SHeiner Kallweit /* InterruptStatusBits */ 41125e992a4SHeiner Kallweit SYSErr = 0x8000, 41225e992a4SHeiner Kallweit PCSTimeout = 0x4000, 41325e992a4SHeiner Kallweit SWInt = 0x0100, 41425e992a4SHeiner Kallweit TxDescUnavail = 0x0080, 41525e992a4SHeiner Kallweit RxFIFOOver = 0x0040, 41625e992a4SHeiner Kallweit LinkChg = 0x0020, 41725e992a4SHeiner Kallweit RxOverflow = 0x0010, 41825e992a4SHeiner Kallweit TxErr = 0x0008, 41925e992a4SHeiner Kallweit TxOK = 0x0004, 42025e992a4SHeiner Kallweit RxErr = 0x0002, 42125e992a4SHeiner Kallweit RxOK = 0x0001, 42225e992a4SHeiner Kallweit 42325e992a4SHeiner Kallweit /* RxStatusDesc */ 42425e992a4SHeiner Kallweit RxRWT = (1 << 22), 42525e992a4SHeiner Kallweit RxRES = (1 << 21), 42625e992a4SHeiner Kallweit RxRUNT = (1 << 20), 42725e992a4SHeiner Kallweit RxCRC = (1 << 19), 42825e992a4SHeiner Kallweit 42925e992a4SHeiner Kallweit /* ChipCmdBits */ 43025e992a4SHeiner Kallweit StopReq = 0x80, 43125e992a4SHeiner Kallweit CmdReset = 0x10, 43225e992a4SHeiner Kallweit CmdRxEnb = 0x08, 43325e992a4SHeiner Kallweit CmdTxEnb = 0x04, 43425e992a4SHeiner Kallweit RxBufEmpty = 0x01, 43525e992a4SHeiner Kallweit 43625e992a4SHeiner Kallweit /* TXPoll register p.5 */ 43725e992a4SHeiner Kallweit HPQ = 0x80, /* Poll cmd on the high prio queue */ 43825e992a4SHeiner Kallweit NPQ = 0x40, /* Poll cmd on the low prio queue */ 43925e992a4SHeiner Kallweit FSWInt = 0x01, /* Forced software interrupt */ 44025e992a4SHeiner Kallweit 44125e992a4SHeiner Kallweit /* Cfg9346Bits */ 44225e992a4SHeiner Kallweit Cfg9346_Lock = 0x00, 44325e992a4SHeiner Kallweit Cfg9346_Unlock = 0xc0, 44425e992a4SHeiner Kallweit 44525e992a4SHeiner Kallweit /* rx_mode_bits */ 44625e992a4SHeiner Kallweit AcceptErr = 0x20, 44725e992a4SHeiner Kallweit AcceptRunt = 0x10, 44825e992a4SHeiner Kallweit AcceptBroadcast = 0x08, 44925e992a4SHeiner Kallweit AcceptMulticast = 0x04, 45025e992a4SHeiner Kallweit AcceptMyPhys = 0x02, 45125e992a4SHeiner Kallweit AcceptAllPhys = 0x01, 45225e992a4SHeiner Kallweit #define RX_CONFIG_ACCEPT_MASK 0x3f 45325e992a4SHeiner Kallweit 45425e992a4SHeiner Kallweit /* TxConfigBits */ 45525e992a4SHeiner Kallweit TxInterFrameGapShift = 24, 45625e992a4SHeiner Kallweit TxDMAShift = 8, /* DMA burst value (0-7) is shift this many bits */ 45725e992a4SHeiner Kallweit 45825e992a4SHeiner Kallweit /* Config1 register p.24 */ 45925e992a4SHeiner Kallweit LEDS1 = (1 << 7), 46025e992a4SHeiner Kallweit LEDS0 = (1 << 6), 46125e992a4SHeiner Kallweit Speed_down = (1 << 4), 46225e992a4SHeiner Kallweit MEMMAP = (1 << 3), 46325e992a4SHeiner Kallweit IOMAP = (1 << 2), 46425e992a4SHeiner Kallweit VPD = (1 << 1), 46525e992a4SHeiner Kallweit PMEnable = (1 << 0), /* Power Management Enable */ 46625e992a4SHeiner Kallweit 46725e992a4SHeiner Kallweit /* Config2 register p. 25 */ 46825e992a4SHeiner Kallweit ClkReqEn = (1 << 7), /* Clock Request Enable */ 46925e992a4SHeiner Kallweit MSIEnable = (1 << 5), /* 8169 only. Reserved in the 8168. */ 47025e992a4SHeiner Kallweit PCI_Clock_66MHz = 0x01, 47125e992a4SHeiner Kallweit PCI_Clock_33MHz = 0x00, 47225e992a4SHeiner Kallweit 47325e992a4SHeiner Kallweit /* Config3 register p.25 */ 47425e992a4SHeiner Kallweit MagicPacket = (1 << 5), /* Wake up when receives a Magic Packet */ 47525e992a4SHeiner Kallweit LinkUp = (1 << 4), /* Wake up when the cable connection is re-established */ 47625e992a4SHeiner Kallweit Jumbo_En0 = (1 << 2), /* 8168 only. Reserved in the 8168b */ 47725e992a4SHeiner Kallweit Rdy_to_L23 = (1 << 1), /* L23 Enable */ 47825e992a4SHeiner Kallweit Beacon_en = (1 << 0), /* 8168 only. Reserved in the 8168b */ 47925e992a4SHeiner Kallweit 48025e992a4SHeiner Kallweit /* Config4 register */ 48125e992a4SHeiner Kallweit Jumbo_En1 = (1 << 1), /* 8168 only. Reserved in the 8168b */ 48225e992a4SHeiner Kallweit 48325e992a4SHeiner Kallweit /* Config5 register p.27 */ 48425e992a4SHeiner Kallweit BWF = (1 << 6), /* Accept Broadcast wakeup frame */ 48525e992a4SHeiner Kallweit MWF = (1 << 5), /* Accept Multicast wakeup frame */ 48625e992a4SHeiner Kallweit UWF = (1 << 4), /* Accept Unicast wakeup frame */ 48725e992a4SHeiner Kallweit Spi_en = (1 << 3), 48825e992a4SHeiner Kallweit LanWake = (1 << 1), /* LanWake enable/disable */ 48925e992a4SHeiner Kallweit PMEStatus = (1 << 0), /* PME status can be reset by PCI RST# */ 49025e992a4SHeiner Kallweit ASPM_en = (1 << 0), /* ASPM enable */ 49125e992a4SHeiner Kallweit 49225e992a4SHeiner Kallweit /* CPlusCmd p.31 */ 49325e992a4SHeiner Kallweit EnableBist = (1 << 15), // 8168 8101 49425e992a4SHeiner Kallweit Mac_dbgo_oe = (1 << 14), // 8168 8101 49509e65335SHeiner Kallweit EnAnaPLL = (1 << 14), // 8169 49625e992a4SHeiner Kallweit Normal_mode = (1 << 13), // unused 49725e992a4SHeiner Kallweit Force_half_dup = (1 << 12), // 8168 8101 49825e992a4SHeiner Kallweit Force_rxflow_en = (1 << 11), // 8168 8101 49925e992a4SHeiner Kallweit Force_txflow_en = (1 << 10), // 8168 8101 50025e992a4SHeiner Kallweit Cxpl_dbg_sel = (1 << 9), // 8168 8101 50125e992a4SHeiner Kallweit ASF = (1 << 8), // 8168 8101 50225e992a4SHeiner Kallweit PktCntrDisable = (1 << 7), // 8168 8101 50325e992a4SHeiner Kallweit Mac_dbgo_sel = 0x001c, // 8168 50425e992a4SHeiner Kallweit RxVlan = (1 << 6), 50525e992a4SHeiner Kallweit RxChkSum = (1 << 5), 50625e992a4SHeiner Kallweit PCIDAC = (1 << 4), 50725e992a4SHeiner Kallweit PCIMulRW = (1 << 3), 50825e992a4SHeiner Kallweit #define INTT_MASK GENMASK(1, 0) 509bc73241eSHeiner Kallweit #define CPCMD_MASK (Normal_mode | RxVlan | RxChkSum | INTT_MASK) 51025e992a4SHeiner Kallweit 51125e992a4SHeiner Kallweit /* rtl8169_PHYstatus */ 51225e992a4SHeiner Kallweit TBI_Enable = 0x80, 51325e992a4SHeiner Kallweit TxFlowCtrl = 0x40, 51425e992a4SHeiner Kallweit RxFlowCtrl = 0x20, 51525e992a4SHeiner Kallweit _1000bpsF = 0x10, 51625e992a4SHeiner Kallweit _100bps = 0x08, 51725e992a4SHeiner Kallweit _10bps = 0x04, 51825e992a4SHeiner Kallweit LinkStatus = 0x02, 51925e992a4SHeiner Kallweit FullDup = 0x01, 52025e992a4SHeiner Kallweit 52125e992a4SHeiner Kallweit /* ResetCounterCommand */ 52225e992a4SHeiner Kallweit CounterReset = 0x1, 52325e992a4SHeiner Kallweit 52425e992a4SHeiner Kallweit /* DumpCounterCommand */ 52525e992a4SHeiner Kallweit CounterDump = 0x8, 52625e992a4SHeiner Kallweit 52725e992a4SHeiner Kallweit /* magic enable v2 */ 52825e992a4SHeiner Kallweit MagicPacket_v2 = (1 << 16), /* Wake up when receives a Magic Packet */ 52925e992a4SHeiner Kallweit }; 53025e992a4SHeiner Kallweit 53125e992a4SHeiner Kallweit enum rtl_desc_bit { 53225e992a4SHeiner Kallweit /* First doubleword. */ 53325e992a4SHeiner Kallweit DescOwn = (1 << 31), /* Descriptor is owned by NIC */ 53425e992a4SHeiner Kallweit RingEnd = (1 << 30), /* End of descriptor ring */ 53525e992a4SHeiner Kallweit FirstFrag = (1 << 29), /* First segment of a packet */ 53625e992a4SHeiner Kallweit LastFrag = (1 << 28), /* Final segment of a packet */ 53725e992a4SHeiner Kallweit }; 53825e992a4SHeiner Kallweit 53925e992a4SHeiner Kallweit /* Generic case. */ 54025e992a4SHeiner Kallweit enum rtl_tx_desc_bit { 54125e992a4SHeiner Kallweit /* First doubleword. */ 54225e992a4SHeiner Kallweit TD_LSO = (1 << 27), /* Large Send Offload */ 54325e992a4SHeiner Kallweit #define TD_MSS_MAX 0x07ffu /* MSS value */ 54425e992a4SHeiner Kallweit 54525e992a4SHeiner Kallweit /* Second doubleword. */ 54625e992a4SHeiner Kallweit TxVlanTag = (1 << 17), /* Add VLAN tag */ 54725e992a4SHeiner Kallweit }; 54825e992a4SHeiner Kallweit 54925e992a4SHeiner Kallweit /* 8169, 8168b and 810x except 8102e. */ 55025e992a4SHeiner Kallweit enum rtl_tx_desc_bit_0 { 55125e992a4SHeiner Kallweit /* First doubleword. */ 55225e992a4SHeiner Kallweit #define TD0_MSS_SHIFT 16 /* MSS position (11 bits) */ 55325e992a4SHeiner Kallweit TD0_TCP_CS = (1 << 16), /* Calculate TCP/IP checksum */ 55425e992a4SHeiner Kallweit TD0_UDP_CS = (1 << 17), /* Calculate UDP/IP checksum */ 55525e992a4SHeiner Kallweit TD0_IP_CS = (1 << 18), /* Calculate IP checksum */ 55625e992a4SHeiner Kallweit }; 55725e992a4SHeiner Kallweit 55825e992a4SHeiner Kallweit /* 8102e, 8168c and beyond. */ 55925e992a4SHeiner Kallweit enum rtl_tx_desc_bit_1 { 56025e992a4SHeiner Kallweit /* First doubleword. */ 56125e992a4SHeiner Kallweit TD1_GTSENV4 = (1 << 26), /* Giant Send for IPv4 */ 56225e992a4SHeiner Kallweit TD1_GTSENV6 = (1 << 25), /* Giant Send for IPv6 */ 56325e992a4SHeiner Kallweit #define GTTCPHO_SHIFT 18 564e64e0c89SHeiner Kallweit #define GTTCPHO_MAX 0x7f 56525e992a4SHeiner Kallweit 56625e992a4SHeiner Kallweit /* Second doubleword. */ 56725e992a4SHeiner Kallweit #define TCPHO_SHIFT 18 568e64e0c89SHeiner Kallweit #define TCPHO_MAX 0x3ff 56925e992a4SHeiner Kallweit #define TD1_MSS_SHIFT 18 /* MSS position (11 bits) */ 57025e992a4SHeiner Kallweit TD1_IPv6_CS = (1 << 28), /* Calculate IPv6 checksum */ 57125e992a4SHeiner Kallweit TD1_IPv4_CS = (1 << 29), /* Calculate IPv4 checksum */ 57225e992a4SHeiner Kallweit TD1_TCP_CS = (1 << 30), /* Calculate TCP/IP checksum */ 57325e992a4SHeiner Kallweit TD1_UDP_CS = (1 << 31), /* Calculate UDP/IP checksum */ 57425e992a4SHeiner Kallweit }; 57525e992a4SHeiner Kallweit 57625e992a4SHeiner Kallweit enum rtl_rx_desc_bit { 57725e992a4SHeiner Kallweit /* Rx private */ 57825e992a4SHeiner Kallweit PID1 = (1 << 18), /* Protocol ID bit 1/2 */ 57925e992a4SHeiner Kallweit PID0 = (1 << 17), /* Protocol ID bit 0/2 */ 58025e992a4SHeiner Kallweit 58125e992a4SHeiner Kallweit #define RxProtoUDP (PID1) 58225e992a4SHeiner Kallweit #define RxProtoTCP (PID0) 58325e992a4SHeiner Kallweit #define RxProtoIP (PID1 | PID0) 58425e992a4SHeiner Kallweit #define RxProtoMask RxProtoIP 58525e992a4SHeiner Kallweit 58625e992a4SHeiner Kallweit IPFail = (1 << 16), /* IP checksum failed */ 58725e992a4SHeiner Kallweit UDPFail = (1 << 15), /* UDP/IP checksum failed */ 58825e992a4SHeiner Kallweit TCPFail = (1 << 14), /* TCP/IP checksum failed */ 58925e992a4SHeiner Kallweit RxVlanTag = (1 << 16), /* VLAN tag available */ 59025e992a4SHeiner Kallweit }; 59125e992a4SHeiner Kallweit 59225e992a4SHeiner Kallweit #define RsvdMask 0x3fffc000 59325e992a4SHeiner Kallweit 5940170d594SHeiner Kallweit #define RTL_GSO_MAX_SIZE_V1 32000 5950170d594SHeiner Kallweit #define RTL_GSO_MAX_SEGS_V1 24 5960170d594SHeiner Kallweit #define RTL_GSO_MAX_SIZE_V2 64000 5970170d594SHeiner Kallweit #define RTL_GSO_MAX_SEGS_V2 64 5980170d594SHeiner Kallweit 59925e992a4SHeiner Kallweit struct TxDesc { 60025e992a4SHeiner Kallweit __le32 opts1; 60125e992a4SHeiner Kallweit __le32 opts2; 60225e992a4SHeiner Kallweit __le64 addr; 60325e992a4SHeiner Kallweit }; 60425e992a4SHeiner Kallweit 60525e992a4SHeiner Kallweit struct RxDesc { 60625e992a4SHeiner Kallweit __le32 opts1; 60725e992a4SHeiner Kallweit __le32 opts2; 60825e992a4SHeiner Kallweit __le64 addr; 60925e992a4SHeiner Kallweit }; 61025e992a4SHeiner Kallweit 61125e992a4SHeiner Kallweit struct ring_info { 61225e992a4SHeiner Kallweit struct sk_buff *skb; 61325e992a4SHeiner Kallweit u32 len; 61425e992a4SHeiner Kallweit }; 61525e992a4SHeiner Kallweit 61625e992a4SHeiner Kallweit struct rtl8169_counters { 61725e992a4SHeiner Kallweit __le64 tx_packets; 61825e992a4SHeiner Kallweit __le64 rx_packets; 61925e992a4SHeiner Kallweit __le64 tx_errors; 62025e992a4SHeiner Kallweit __le32 rx_errors; 62125e992a4SHeiner Kallweit __le16 rx_missed; 62225e992a4SHeiner Kallweit __le16 align_errors; 62325e992a4SHeiner Kallweit __le32 tx_one_collision; 62425e992a4SHeiner Kallweit __le32 tx_multi_collision; 62525e992a4SHeiner Kallweit __le64 rx_unicast; 62625e992a4SHeiner Kallweit __le64 rx_broadcast; 62725e992a4SHeiner Kallweit __le32 rx_multicast; 62825e992a4SHeiner Kallweit __le16 tx_aborted; 62925e992a4SHeiner Kallweit __le16 tx_underun; 63025e992a4SHeiner Kallweit }; 63125e992a4SHeiner Kallweit 63225e992a4SHeiner Kallweit struct rtl8169_tc_offsets { 63325e992a4SHeiner Kallweit bool inited; 63425e992a4SHeiner Kallweit __le64 tx_errors; 63525e992a4SHeiner Kallweit __le32 tx_multi_collision; 63625e992a4SHeiner Kallweit __le16 tx_aborted; 63725e992a4SHeiner Kallweit }; 63825e992a4SHeiner Kallweit 63925e992a4SHeiner Kallweit enum rtl_flag { 64025e992a4SHeiner Kallweit RTL_FLAG_TASK_ENABLED = 0, 64125e992a4SHeiner Kallweit RTL_FLAG_TASK_RESET_PENDING, 64225e992a4SHeiner Kallweit RTL_FLAG_MAX 64325e992a4SHeiner Kallweit }; 64425e992a4SHeiner Kallweit 64525e992a4SHeiner Kallweit struct rtl8169_stats { 64625e992a4SHeiner Kallweit u64 packets; 64725e992a4SHeiner Kallweit u64 bytes; 64825e992a4SHeiner Kallweit struct u64_stats_sync syncp; 64925e992a4SHeiner Kallweit }; 65025e992a4SHeiner Kallweit 65125e992a4SHeiner Kallweit struct rtl8169_private { 65225e992a4SHeiner Kallweit void __iomem *mmio_addr; /* memory map physical address */ 65325e992a4SHeiner Kallweit struct pci_dev *pci_dev; 65425e992a4SHeiner Kallweit struct net_device *dev; 65525e992a4SHeiner Kallweit struct phy_device *phydev; 65625e992a4SHeiner Kallweit struct napi_struct napi; 65725e992a4SHeiner Kallweit u32 msg_enable; 65825e992a4SHeiner Kallweit enum mac_version mac_version; 65925e992a4SHeiner Kallweit u32 cur_rx; /* Index into the Rx descriptor buffer of next Rx pkt. */ 66025e992a4SHeiner Kallweit u32 cur_tx; /* Index into the Tx descriptor buffer of next Rx pkt. */ 66125e992a4SHeiner Kallweit u32 dirty_tx; 66225e992a4SHeiner Kallweit struct rtl8169_stats rx_stats; 66325e992a4SHeiner Kallweit struct rtl8169_stats tx_stats; 66425e992a4SHeiner Kallweit struct TxDesc *TxDescArray; /* 256-aligned Tx descriptor ring */ 66525e992a4SHeiner Kallweit struct RxDesc *RxDescArray; /* 256-aligned Rx descriptor ring */ 66625e992a4SHeiner Kallweit dma_addr_t TxPhyAddr; 66725e992a4SHeiner Kallweit dma_addr_t RxPhyAddr; 66832879f00SHeiner Kallweit struct page *Rx_databuff[NUM_RX_DESC]; /* Rx data buffers */ 66925e992a4SHeiner Kallweit struct ring_info tx_skb[NUM_TX_DESC]; /* Tx data buffers */ 67025e992a4SHeiner Kallweit u16 cp_cmd; 671c1d532d2SHeiner Kallweit u32 irq_mask; 67225e992a4SHeiner Kallweit struct clk *clk; 67325e992a4SHeiner Kallweit 67425e992a4SHeiner Kallweit struct { 67525e992a4SHeiner Kallweit DECLARE_BITMAP(flags, RTL_FLAG_MAX); 67625e992a4SHeiner Kallweit struct mutex mutex; 67725e992a4SHeiner Kallweit struct work_struct work; 67825e992a4SHeiner Kallweit } wk; 67925e992a4SHeiner Kallweit 68025e992a4SHeiner Kallweit unsigned irq_enabled:1; 68125e992a4SHeiner Kallweit unsigned supports_gmii:1; 68262b1b3b3SHeiner Kallweit unsigned aspm_manageable:1; 68325e992a4SHeiner Kallweit dma_addr_t counters_phys_addr; 68425e992a4SHeiner Kallweit struct rtl8169_counters *counters; 68525e992a4SHeiner Kallweit struct rtl8169_tc_offsets tc_offset; 68625e992a4SHeiner Kallweit u32 saved_wolopts; 6877ec3f872SHeiner Kallweit int eee_adv; 68825e992a4SHeiner Kallweit 68925e992a4SHeiner Kallweit const char *fw_name; 6908197f9d2SHeiner Kallweit struct rtl_fw *rtl_fw; 69125e992a4SHeiner Kallweit 69225e992a4SHeiner Kallweit u32 ocp_base; 69325e992a4SHeiner Kallweit }; 69425e992a4SHeiner Kallweit 69525e992a4SHeiner Kallweit typedef void (*rtl_generic_fct)(struct rtl8169_private *tp); 696becd837eSHeiner Kallweit typedef void (*rtl_phy_cfg_fct)(struct rtl8169_private *tp, 697becd837eSHeiner Kallweit struct phy_device *phydev); 69825e992a4SHeiner Kallweit 69925e992a4SHeiner Kallweit MODULE_AUTHOR("Realtek and the Linux r8169 crew <netdev@vger.kernel.org>"); 70025e992a4SHeiner Kallweit MODULE_DESCRIPTION("RealTek RTL-8169 Gigabit Ethernet driver"); 70125e992a4SHeiner Kallweit module_param_named(debug, debug.msg_enable, int, 0); 70225e992a4SHeiner Kallweit MODULE_PARM_DESC(debug, "Debug verbosity level (0=none, ..., 16=all)"); 70325e992a4SHeiner Kallweit MODULE_SOFTDEP("pre: realtek"); 70425e992a4SHeiner Kallweit MODULE_LICENSE("GPL"); 70525e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168D_1); 70625e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168D_2); 70725e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168E_1); 70825e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168E_2); 70925e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168E_3); 71025e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8105E_1); 71125e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168F_1); 71225e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168F_2); 71325e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8402_1); 71425e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8411_1); 71525e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8411_2); 71625e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8106E_1); 71725e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8106E_2); 71825e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168G_2); 71925e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168G_3); 72025e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168H_1); 72125e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168H_2); 722229c1e0dSHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168FP_3); 72325e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8107E_1); 72425e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8107E_2); 72502bf642bSHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8125A_3); 72625e992a4SHeiner Kallweit 72725e992a4SHeiner Kallweit static inline struct device *tp_to_dev(struct rtl8169_private *tp) 72825e992a4SHeiner Kallweit { 72925e992a4SHeiner Kallweit return &tp->pci_dev->dev; 73025e992a4SHeiner Kallweit } 73125e992a4SHeiner Kallweit 73225e992a4SHeiner Kallweit static void rtl_lock_work(struct rtl8169_private *tp) 73325e992a4SHeiner Kallweit { 73425e992a4SHeiner Kallweit mutex_lock(&tp->wk.mutex); 73525e992a4SHeiner Kallweit } 73625e992a4SHeiner Kallweit 73725e992a4SHeiner Kallweit static void rtl_unlock_work(struct rtl8169_private *tp) 73825e992a4SHeiner Kallweit { 73925e992a4SHeiner Kallweit mutex_unlock(&tp->wk.mutex); 74025e992a4SHeiner Kallweit } 74125e992a4SHeiner Kallweit 74225e992a4SHeiner Kallweit static void rtl_lock_config_regs(struct rtl8169_private *tp) 74325e992a4SHeiner Kallweit { 74425e992a4SHeiner Kallweit RTL_W8(tp, Cfg9346, Cfg9346_Lock); 74525e992a4SHeiner Kallweit } 74625e992a4SHeiner Kallweit 74725e992a4SHeiner Kallweit static void rtl_unlock_config_regs(struct rtl8169_private *tp) 74825e992a4SHeiner Kallweit { 74925e992a4SHeiner Kallweit RTL_W8(tp, Cfg9346, Cfg9346_Unlock); 75025e992a4SHeiner Kallweit } 75125e992a4SHeiner Kallweit 752f1bce4adSHeiner Kallweit static bool rtl_is_8125(struct rtl8169_private *tp) 753f1bce4adSHeiner Kallweit { 754f1bce4adSHeiner Kallweit return tp->mac_version >= RTL_GIGA_MAC_VER_60; 755f1bce4adSHeiner Kallweit } 756f1bce4adSHeiner Kallweit 7579e9f33baSHeiner Kallweit static bool rtl_is_8168evl_up(struct rtl8169_private *tp) 7589e9f33baSHeiner Kallweit { 7599e9f33baSHeiner Kallweit return tp->mac_version >= RTL_GIGA_MAC_VER_34 && 760c623305bSHeiner Kallweit tp->mac_version != RTL_GIGA_MAC_VER_39 && 7611287723aSHeiner Kallweit tp->mac_version <= RTL_GIGA_MAC_VER_52; 7629e9f33baSHeiner Kallweit } 7639e9f33baSHeiner Kallweit 7642e779ddbSHeiner Kallweit static bool rtl_supports_eee(struct rtl8169_private *tp) 7652e779ddbSHeiner Kallweit { 7662e779ddbSHeiner Kallweit return tp->mac_version >= RTL_GIGA_MAC_VER_34 && 7672e779ddbSHeiner Kallweit tp->mac_version != RTL_GIGA_MAC_VER_37 && 7682e779ddbSHeiner Kallweit tp->mac_version != RTL_GIGA_MAC_VER_39; 7692e779ddbSHeiner Kallweit } 7702e779ddbSHeiner Kallweit 771ce37115eSHeiner Kallweit static void rtl_read_mac_from_reg(struct rtl8169_private *tp, u8 *mac, int reg) 772ce37115eSHeiner Kallweit { 773ce37115eSHeiner Kallweit int i; 774ce37115eSHeiner Kallweit 775ce37115eSHeiner Kallweit for (i = 0; i < ETH_ALEN; i++) 776ce37115eSHeiner Kallweit mac[i] = RTL_R8(tp, reg + i); 777ce37115eSHeiner Kallweit } 778ce37115eSHeiner Kallweit 77925e992a4SHeiner Kallweit struct rtl_cond { 78025e992a4SHeiner Kallweit bool (*check)(struct rtl8169_private *); 78125e992a4SHeiner Kallweit const char *msg; 78225e992a4SHeiner Kallweit }; 78325e992a4SHeiner Kallweit 78425e992a4SHeiner Kallweit static void rtl_udelay(unsigned int d) 78525e992a4SHeiner Kallweit { 78625e992a4SHeiner Kallweit udelay(d); 78725e992a4SHeiner Kallweit } 78825e992a4SHeiner Kallweit 78925e992a4SHeiner Kallweit static bool rtl_loop_wait(struct rtl8169_private *tp, const struct rtl_cond *c, 79025e992a4SHeiner Kallweit void (*delay)(unsigned int), unsigned int d, int n, 79125e992a4SHeiner Kallweit bool high) 79225e992a4SHeiner Kallweit { 79325e992a4SHeiner Kallweit int i; 79425e992a4SHeiner Kallweit 79525e992a4SHeiner Kallweit for (i = 0; i < n; i++) { 79625e992a4SHeiner Kallweit if (c->check(tp) == high) 79725e992a4SHeiner Kallweit return true; 79825e992a4SHeiner Kallweit delay(d); 79925e992a4SHeiner Kallweit } 80025e992a4SHeiner Kallweit netif_err(tp, drv, tp->dev, "%s == %d (loop: %d, delay: %d).\n", 80125e992a4SHeiner Kallweit c->msg, !high, n, d); 80225e992a4SHeiner Kallweit return false; 80325e992a4SHeiner Kallweit } 80425e992a4SHeiner Kallweit 80525e992a4SHeiner Kallweit static bool rtl_udelay_loop_wait_high(struct rtl8169_private *tp, 80625e992a4SHeiner Kallweit const struct rtl_cond *c, 80725e992a4SHeiner Kallweit unsigned int d, int n) 80825e992a4SHeiner Kallweit { 80925e992a4SHeiner Kallweit return rtl_loop_wait(tp, c, rtl_udelay, d, n, true); 81025e992a4SHeiner Kallweit } 81125e992a4SHeiner Kallweit 81225e992a4SHeiner Kallweit static bool rtl_udelay_loop_wait_low(struct rtl8169_private *tp, 81325e992a4SHeiner Kallweit const struct rtl_cond *c, 81425e992a4SHeiner Kallweit unsigned int d, int n) 81525e992a4SHeiner Kallweit { 81625e992a4SHeiner Kallweit return rtl_loop_wait(tp, c, rtl_udelay, d, n, false); 81725e992a4SHeiner Kallweit } 81825e992a4SHeiner Kallweit 81925e992a4SHeiner Kallweit static bool rtl_msleep_loop_wait_high(struct rtl8169_private *tp, 82025e992a4SHeiner Kallweit const struct rtl_cond *c, 82125e992a4SHeiner Kallweit unsigned int d, int n) 82225e992a4SHeiner Kallweit { 82325e992a4SHeiner Kallweit return rtl_loop_wait(tp, c, msleep, d, n, true); 82425e992a4SHeiner Kallweit } 82525e992a4SHeiner Kallweit 82625e992a4SHeiner Kallweit static bool rtl_msleep_loop_wait_low(struct rtl8169_private *tp, 82725e992a4SHeiner Kallweit const struct rtl_cond *c, 82825e992a4SHeiner Kallweit unsigned int d, int n) 82925e992a4SHeiner Kallweit { 83025e992a4SHeiner Kallweit return rtl_loop_wait(tp, c, msleep, d, n, false); 83125e992a4SHeiner Kallweit } 83225e992a4SHeiner Kallweit 83325e992a4SHeiner Kallweit #define DECLARE_RTL_COND(name) \ 83425e992a4SHeiner Kallweit static bool name ## _check(struct rtl8169_private *); \ 83525e992a4SHeiner Kallweit \ 83625e992a4SHeiner Kallweit static const struct rtl_cond name = { \ 83725e992a4SHeiner Kallweit .check = name ## _check, \ 83825e992a4SHeiner Kallweit .msg = #name \ 83925e992a4SHeiner Kallweit }; \ 84025e992a4SHeiner Kallweit \ 84125e992a4SHeiner Kallweit static bool name ## _check(struct rtl8169_private *tp) 84225e992a4SHeiner Kallweit 84325e992a4SHeiner Kallweit static bool rtl_ocp_reg_failure(struct rtl8169_private *tp, u32 reg) 84425e992a4SHeiner Kallweit { 84525e992a4SHeiner Kallweit if (reg & 0xffff0001) { 84625e992a4SHeiner Kallweit netif_err(tp, drv, tp->dev, "Invalid ocp reg %x!\n", reg); 84725e992a4SHeiner Kallweit return true; 84825e992a4SHeiner Kallweit } 84925e992a4SHeiner Kallweit return false; 85025e992a4SHeiner Kallweit } 85125e992a4SHeiner Kallweit 85225e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_ocp_gphy_cond) 85325e992a4SHeiner Kallweit { 85425e992a4SHeiner Kallweit return RTL_R32(tp, GPHY_OCP) & OCPAR_FLAG; 85525e992a4SHeiner Kallweit } 85625e992a4SHeiner Kallweit 85725e992a4SHeiner Kallweit static void r8168_phy_ocp_write(struct rtl8169_private *tp, u32 reg, u32 data) 85825e992a4SHeiner Kallweit { 85925e992a4SHeiner Kallweit if (rtl_ocp_reg_failure(tp, reg)) 86025e992a4SHeiner Kallweit return; 86125e992a4SHeiner Kallweit 86225e992a4SHeiner Kallweit RTL_W32(tp, GPHY_OCP, OCPAR_FLAG | (reg << 15) | data); 86325e992a4SHeiner Kallweit 86425e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_ocp_gphy_cond, 25, 10); 86525e992a4SHeiner Kallweit } 86625e992a4SHeiner Kallweit 8679b994b4aSHeiner Kallweit static int r8168_phy_ocp_read(struct rtl8169_private *tp, u32 reg) 86825e992a4SHeiner Kallweit { 86925e992a4SHeiner Kallweit if (rtl_ocp_reg_failure(tp, reg)) 87025e992a4SHeiner Kallweit return 0; 87125e992a4SHeiner Kallweit 87225e992a4SHeiner Kallweit RTL_W32(tp, GPHY_OCP, reg << 15); 87325e992a4SHeiner Kallweit 87425e992a4SHeiner Kallweit return rtl_udelay_loop_wait_high(tp, &rtl_ocp_gphy_cond, 25, 10) ? 8759b994b4aSHeiner Kallweit (RTL_R32(tp, GPHY_OCP) & 0xffff) : -ETIMEDOUT; 87625e992a4SHeiner Kallweit } 87725e992a4SHeiner Kallweit 87825e992a4SHeiner Kallweit static void r8168_mac_ocp_write(struct rtl8169_private *tp, u32 reg, u32 data) 87925e992a4SHeiner Kallweit { 88025e992a4SHeiner Kallweit if (rtl_ocp_reg_failure(tp, reg)) 88125e992a4SHeiner Kallweit return; 88225e992a4SHeiner Kallweit 88325e992a4SHeiner Kallweit RTL_W32(tp, OCPDR, OCPAR_FLAG | (reg << 15) | data); 88425e992a4SHeiner Kallweit } 88525e992a4SHeiner Kallweit 88625e992a4SHeiner Kallweit static u16 r8168_mac_ocp_read(struct rtl8169_private *tp, u32 reg) 88725e992a4SHeiner Kallweit { 88825e992a4SHeiner Kallweit if (rtl_ocp_reg_failure(tp, reg)) 88925e992a4SHeiner Kallweit return 0; 89025e992a4SHeiner Kallweit 89125e992a4SHeiner Kallweit RTL_W32(tp, OCPDR, reg << 15); 89225e992a4SHeiner Kallweit 89325e992a4SHeiner Kallweit return RTL_R32(tp, OCPDR); 89425e992a4SHeiner Kallweit } 89525e992a4SHeiner Kallweit 896ef712edeSHeiner Kallweit static void r8168_mac_ocp_modify(struct rtl8169_private *tp, u32 reg, u16 mask, 897ef712edeSHeiner Kallweit u16 set) 898ef712edeSHeiner Kallweit { 899ef712edeSHeiner Kallweit u16 data = r8168_mac_ocp_read(tp, reg); 900ef712edeSHeiner Kallweit 901ef712edeSHeiner Kallweit r8168_mac_ocp_write(tp, reg, (data & ~mask) | set); 902ef712edeSHeiner Kallweit } 903ef712edeSHeiner Kallweit 90425e992a4SHeiner Kallweit #define OCP_STD_PHY_BASE 0xa400 90525e992a4SHeiner Kallweit 90625e992a4SHeiner Kallweit static void r8168g_mdio_write(struct rtl8169_private *tp, int reg, int value) 90725e992a4SHeiner Kallweit { 90825e992a4SHeiner Kallweit if (reg == 0x1f) { 90925e992a4SHeiner Kallweit tp->ocp_base = value ? value << 4 : OCP_STD_PHY_BASE; 91025e992a4SHeiner Kallweit return; 91125e992a4SHeiner Kallweit } 91225e992a4SHeiner Kallweit 91325e992a4SHeiner Kallweit if (tp->ocp_base != OCP_STD_PHY_BASE) 91425e992a4SHeiner Kallweit reg -= 0x10; 91525e992a4SHeiner Kallweit 91625e992a4SHeiner Kallweit r8168_phy_ocp_write(tp, tp->ocp_base + reg * 2, value); 91725e992a4SHeiner Kallweit } 91825e992a4SHeiner Kallweit 91925e992a4SHeiner Kallweit static int r8168g_mdio_read(struct rtl8169_private *tp, int reg) 92025e992a4SHeiner Kallweit { 9219c6850feSHeiner Kallweit if (reg == 0x1f) 9229c6850feSHeiner Kallweit return tp->ocp_base == OCP_STD_PHY_BASE ? 0 : tp->ocp_base >> 4; 9239c6850feSHeiner Kallweit 92425e992a4SHeiner Kallweit if (tp->ocp_base != OCP_STD_PHY_BASE) 92525e992a4SHeiner Kallweit reg -= 0x10; 92625e992a4SHeiner Kallweit 92725e992a4SHeiner Kallweit return r8168_phy_ocp_read(tp, tp->ocp_base + reg * 2); 92825e992a4SHeiner Kallweit } 92925e992a4SHeiner Kallweit 93025e992a4SHeiner Kallweit static void mac_mcu_write(struct rtl8169_private *tp, int reg, int value) 93125e992a4SHeiner Kallweit { 93225e992a4SHeiner Kallweit if (reg == 0x1f) { 93325e992a4SHeiner Kallweit tp->ocp_base = value << 4; 93425e992a4SHeiner Kallweit return; 93525e992a4SHeiner Kallweit } 93625e992a4SHeiner Kallweit 93725e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, tp->ocp_base + reg, value); 93825e992a4SHeiner Kallweit } 93925e992a4SHeiner Kallweit 94025e992a4SHeiner Kallweit static int mac_mcu_read(struct rtl8169_private *tp, int reg) 94125e992a4SHeiner Kallweit { 94225e992a4SHeiner Kallweit return r8168_mac_ocp_read(tp, tp->ocp_base + reg); 94325e992a4SHeiner Kallweit } 94425e992a4SHeiner Kallweit 94525e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_phyar_cond) 94625e992a4SHeiner Kallweit { 94725e992a4SHeiner Kallweit return RTL_R32(tp, PHYAR) & 0x80000000; 94825e992a4SHeiner Kallweit } 94925e992a4SHeiner Kallweit 95025e992a4SHeiner Kallweit static void r8169_mdio_write(struct rtl8169_private *tp, int reg, int value) 95125e992a4SHeiner Kallweit { 95225e992a4SHeiner Kallweit RTL_W32(tp, PHYAR, 0x80000000 | (reg & 0x1f) << 16 | (value & 0xffff)); 95325e992a4SHeiner Kallweit 95425e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_phyar_cond, 25, 20); 95525e992a4SHeiner Kallweit /* 95625e992a4SHeiner Kallweit * According to hardware specs a 20us delay is required after write 95725e992a4SHeiner Kallweit * complete indication, but before sending next command. 95825e992a4SHeiner Kallweit */ 95925e992a4SHeiner Kallweit udelay(20); 96025e992a4SHeiner Kallweit } 96125e992a4SHeiner Kallweit 96225e992a4SHeiner Kallweit static int r8169_mdio_read(struct rtl8169_private *tp, int reg) 96325e992a4SHeiner Kallweit { 96425e992a4SHeiner Kallweit int value; 96525e992a4SHeiner Kallweit 96625e992a4SHeiner Kallweit RTL_W32(tp, PHYAR, 0x0 | (reg & 0x1f) << 16); 96725e992a4SHeiner Kallweit 96825e992a4SHeiner Kallweit value = rtl_udelay_loop_wait_high(tp, &rtl_phyar_cond, 25, 20) ? 9699b994b4aSHeiner Kallweit RTL_R32(tp, PHYAR) & 0xffff : -ETIMEDOUT; 97025e992a4SHeiner Kallweit 97125e992a4SHeiner Kallweit /* 97225e992a4SHeiner Kallweit * According to hardware specs a 20us delay is required after read 97325e992a4SHeiner Kallweit * complete indication, but before sending next command. 97425e992a4SHeiner Kallweit */ 97525e992a4SHeiner Kallweit udelay(20); 97625e992a4SHeiner Kallweit 97725e992a4SHeiner Kallweit return value; 97825e992a4SHeiner Kallweit } 97925e992a4SHeiner Kallweit 98025e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_ocpar_cond) 98125e992a4SHeiner Kallweit { 98225e992a4SHeiner Kallweit return RTL_R32(tp, OCPAR) & OCPAR_FLAG; 98325e992a4SHeiner Kallweit } 98425e992a4SHeiner Kallweit 98525e992a4SHeiner Kallweit static void r8168dp_1_mdio_access(struct rtl8169_private *tp, int reg, u32 data) 98625e992a4SHeiner Kallweit { 98725e992a4SHeiner Kallweit RTL_W32(tp, OCPDR, data | ((reg & OCPDR_REG_MASK) << OCPDR_GPHY_REG_SHIFT)); 98825e992a4SHeiner Kallweit RTL_W32(tp, OCPAR, OCPAR_GPHY_WRITE_CMD); 98925e992a4SHeiner Kallweit RTL_W32(tp, EPHY_RXER_NUM, 0); 99025e992a4SHeiner Kallweit 99125e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_ocpar_cond, 1000, 100); 99225e992a4SHeiner Kallweit } 99325e992a4SHeiner Kallweit 99425e992a4SHeiner Kallweit static void r8168dp_1_mdio_write(struct rtl8169_private *tp, int reg, int value) 99525e992a4SHeiner Kallweit { 99625e992a4SHeiner Kallweit r8168dp_1_mdio_access(tp, reg, 99725e992a4SHeiner Kallweit OCPDR_WRITE_CMD | (value & OCPDR_DATA_MASK)); 99825e992a4SHeiner Kallweit } 99925e992a4SHeiner Kallweit 100025e992a4SHeiner Kallweit static int r8168dp_1_mdio_read(struct rtl8169_private *tp, int reg) 100125e992a4SHeiner Kallweit { 100225e992a4SHeiner Kallweit r8168dp_1_mdio_access(tp, reg, OCPDR_READ_CMD); 100325e992a4SHeiner Kallweit 100425e992a4SHeiner Kallweit mdelay(1); 100525e992a4SHeiner Kallweit RTL_W32(tp, OCPAR, OCPAR_GPHY_READ_CMD); 100625e992a4SHeiner Kallweit RTL_W32(tp, EPHY_RXER_NUM, 0); 100725e992a4SHeiner Kallweit 100825e992a4SHeiner Kallweit return rtl_udelay_loop_wait_high(tp, &rtl_ocpar_cond, 1000, 100) ? 10099b994b4aSHeiner Kallweit RTL_R32(tp, OCPDR) & OCPDR_DATA_MASK : -ETIMEDOUT; 101025e992a4SHeiner Kallweit } 101125e992a4SHeiner Kallweit 101225e992a4SHeiner Kallweit #define R8168DP_1_MDIO_ACCESS_BIT 0x00020000 101325e992a4SHeiner Kallweit 101425e992a4SHeiner Kallweit static void r8168dp_2_mdio_start(struct rtl8169_private *tp) 101525e992a4SHeiner Kallweit { 101625e992a4SHeiner Kallweit RTL_W32(tp, 0xd0, RTL_R32(tp, 0xd0) & ~R8168DP_1_MDIO_ACCESS_BIT); 101725e992a4SHeiner Kallweit } 101825e992a4SHeiner Kallweit 101925e992a4SHeiner Kallweit static void r8168dp_2_mdio_stop(struct rtl8169_private *tp) 102025e992a4SHeiner Kallweit { 102125e992a4SHeiner Kallweit RTL_W32(tp, 0xd0, RTL_R32(tp, 0xd0) | R8168DP_1_MDIO_ACCESS_BIT); 102225e992a4SHeiner Kallweit } 102325e992a4SHeiner Kallweit 102425e992a4SHeiner Kallweit static void r8168dp_2_mdio_write(struct rtl8169_private *tp, int reg, int value) 102525e992a4SHeiner Kallweit { 102625e992a4SHeiner Kallweit r8168dp_2_mdio_start(tp); 102725e992a4SHeiner Kallweit 102825e992a4SHeiner Kallweit r8169_mdio_write(tp, reg, value); 102925e992a4SHeiner Kallweit 103025e992a4SHeiner Kallweit r8168dp_2_mdio_stop(tp); 103125e992a4SHeiner Kallweit } 103225e992a4SHeiner Kallweit 103325e992a4SHeiner Kallweit static int r8168dp_2_mdio_read(struct rtl8169_private *tp, int reg) 103425e992a4SHeiner Kallweit { 103525e992a4SHeiner Kallweit int value; 103625e992a4SHeiner Kallweit 103762bdc8fdSHeiner Kallweit /* Work around issue with chip reporting wrong PHY ID */ 103862bdc8fdSHeiner Kallweit if (reg == MII_PHYSID2) 103962bdc8fdSHeiner Kallweit return 0xc912; 104062bdc8fdSHeiner Kallweit 104125e992a4SHeiner Kallweit r8168dp_2_mdio_start(tp); 104225e992a4SHeiner Kallweit 104325e992a4SHeiner Kallweit value = r8169_mdio_read(tp, reg); 104425e992a4SHeiner Kallweit 104525e992a4SHeiner Kallweit r8168dp_2_mdio_stop(tp); 104625e992a4SHeiner Kallweit 104725e992a4SHeiner Kallweit return value; 104825e992a4SHeiner Kallweit } 104925e992a4SHeiner Kallweit 105025e992a4SHeiner Kallweit static void rtl_writephy(struct rtl8169_private *tp, int location, int val) 105125e992a4SHeiner Kallweit { 105225e992a4SHeiner Kallweit switch (tp->mac_version) { 105325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27: 105425e992a4SHeiner Kallweit r8168dp_1_mdio_write(tp, location, val); 105525e992a4SHeiner Kallweit break; 105625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_28: 105725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31: 105825e992a4SHeiner Kallweit r8168dp_2_mdio_write(tp, location, val); 105925e992a4SHeiner Kallweit break; 1060f1bce4adSHeiner Kallweit case RTL_GIGA_MAC_VER_40 ... RTL_GIGA_MAC_VER_61: 106125e992a4SHeiner Kallweit r8168g_mdio_write(tp, location, val); 106225e992a4SHeiner Kallweit break; 106325e992a4SHeiner Kallweit default: 106425e992a4SHeiner Kallweit r8169_mdio_write(tp, location, val); 106525e992a4SHeiner Kallweit break; 106625e992a4SHeiner Kallweit } 106725e992a4SHeiner Kallweit } 106825e992a4SHeiner Kallweit 106925e992a4SHeiner Kallweit static int rtl_readphy(struct rtl8169_private *tp, int location) 107025e992a4SHeiner Kallweit { 107125e992a4SHeiner Kallweit switch (tp->mac_version) { 107225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27: 107325e992a4SHeiner Kallweit return r8168dp_1_mdio_read(tp, location); 107425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_28: 107525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31: 107625e992a4SHeiner Kallweit return r8168dp_2_mdio_read(tp, location); 1077f1bce4adSHeiner Kallweit case RTL_GIGA_MAC_VER_40 ... RTL_GIGA_MAC_VER_61: 107825e992a4SHeiner Kallweit return r8168g_mdio_read(tp, location); 107925e992a4SHeiner Kallweit default: 108025e992a4SHeiner Kallweit return r8169_mdio_read(tp, location); 108125e992a4SHeiner Kallweit } 108225e992a4SHeiner Kallweit } 108325e992a4SHeiner Kallweit 108425e992a4SHeiner Kallweit static void rtl_patchphy(struct rtl8169_private *tp, int reg_addr, int value) 108525e992a4SHeiner Kallweit { 108625e992a4SHeiner Kallweit rtl_writephy(tp, reg_addr, rtl_readphy(tp, reg_addr) | value); 108725e992a4SHeiner Kallweit } 108825e992a4SHeiner Kallweit 108925e992a4SHeiner Kallweit static void rtl_w0w1_phy(struct rtl8169_private *tp, int reg_addr, int p, int m) 109025e992a4SHeiner Kallweit { 109125e992a4SHeiner Kallweit int val; 109225e992a4SHeiner Kallweit 109325e992a4SHeiner Kallweit val = rtl_readphy(tp, reg_addr); 109425e992a4SHeiner Kallweit rtl_writephy(tp, reg_addr, (val & ~m) | p); 109525e992a4SHeiner Kallweit } 109625e992a4SHeiner Kallweit 10970721914aSHeiner Kallweit static void r8168d_modify_extpage(struct phy_device *phydev, int extpage, 10980721914aSHeiner Kallweit int reg, u16 mask, u16 val) 10990721914aSHeiner Kallweit { 11000721914aSHeiner Kallweit int oldpage = phy_select_page(phydev, 0x0007); 11010721914aSHeiner Kallweit 11020721914aSHeiner Kallweit __phy_write(phydev, 0x1e, extpage); 11030721914aSHeiner Kallweit __phy_modify(phydev, reg, mask, val); 11040721914aSHeiner Kallweit 11050721914aSHeiner Kallweit phy_restore_page(phydev, oldpage, 0); 11060721914aSHeiner Kallweit } 11070721914aSHeiner Kallweit 1108b5e189b4SHeiner Kallweit static void r8168d_phy_param(struct phy_device *phydev, u16 parm, 1109b5e189b4SHeiner Kallweit u16 mask, u16 val) 1110b5e189b4SHeiner Kallweit { 1111b5e189b4SHeiner Kallweit int oldpage = phy_select_page(phydev, 0x0005); 1112b5e189b4SHeiner Kallweit 1113b5e189b4SHeiner Kallweit __phy_write(phydev, 0x05, parm); 1114b5e189b4SHeiner Kallweit __phy_modify(phydev, 0x06, mask, val); 1115b5e189b4SHeiner Kallweit 1116b5e189b4SHeiner Kallweit phy_restore_page(phydev, oldpage, 0); 1117b5e189b4SHeiner Kallweit } 1118b5e189b4SHeiner Kallweit 11198bfdce1dSHeiner Kallweit static void r8168g_phy_param(struct phy_device *phydev, u16 parm, 11208bfdce1dSHeiner Kallweit u16 mask, u16 val) 11218bfdce1dSHeiner Kallweit { 11228bfdce1dSHeiner Kallweit int oldpage = phy_select_page(phydev, 0x0a43); 11238bfdce1dSHeiner Kallweit 11248bfdce1dSHeiner Kallweit __phy_write(phydev, 0x13, parm); 11258bfdce1dSHeiner Kallweit __phy_modify(phydev, 0x14, mask, val); 11268bfdce1dSHeiner Kallweit 11278bfdce1dSHeiner Kallweit phy_restore_page(phydev, oldpage, 0); 11288bfdce1dSHeiner Kallweit } 11298bfdce1dSHeiner Kallweit 113025e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_ephyar_cond) 113125e992a4SHeiner Kallweit { 113225e992a4SHeiner Kallweit return RTL_R32(tp, EPHYAR) & EPHYAR_FLAG; 113325e992a4SHeiner Kallweit } 113425e992a4SHeiner Kallweit 113525e992a4SHeiner Kallweit static void rtl_ephy_write(struct rtl8169_private *tp, int reg_addr, int value) 113625e992a4SHeiner Kallweit { 113725e992a4SHeiner Kallweit RTL_W32(tp, EPHYAR, EPHYAR_WRITE_CMD | (value & EPHYAR_DATA_MASK) | 113825e992a4SHeiner Kallweit (reg_addr & EPHYAR_REG_MASK) << EPHYAR_REG_SHIFT); 113925e992a4SHeiner Kallweit 114025e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_ephyar_cond, 10, 100); 114125e992a4SHeiner Kallweit 114225e992a4SHeiner Kallweit udelay(10); 114325e992a4SHeiner Kallweit } 114425e992a4SHeiner Kallweit 114525e992a4SHeiner Kallweit static u16 rtl_ephy_read(struct rtl8169_private *tp, int reg_addr) 114625e992a4SHeiner Kallweit { 114725e992a4SHeiner Kallweit RTL_W32(tp, EPHYAR, (reg_addr & EPHYAR_REG_MASK) << EPHYAR_REG_SHIFT); 114825e992a4SHeiner Kallweit 114925e992a4SHeiner Kallweit return rtl_udelay_loop_wait_high(tp, &rtl_ephyar_cond, 10, 100) ? 115025e992a4SHeiner Kallweit RTL_R32(tp, EPHYAR) & EPHYAR_DATA_MASK : ~0; 115125e992a4SHeiner Kallweit } 115225e992a4SHeiner Kallweit 115325e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_eriar_cond) 115425e992a4SHeiner Kallweit { 115525e992a4SHeiner Kallweit return RTL_R32(tp, ERIAR) & ERIAR_FLAG; 115625e992a4SHeiner Kallweit } 115725e992a4SHeiner Kallweit 115825e992a4SHeiner Kallweit static void _rtl_eri_write(struct rtl8169_private *tp, int addr, u32 mask, 115925e992a4SHeiner Kallweit u32 val, int type) 116025e992a4SHeiner Kallweit { 116125e992a4SHeiner Kallweit BUG_ON((addr & 3) || (mask == 0)); 116225e992a4SHeiner Kallweit RTL_W32(tp, ERIDR, val); 116325e992a4SHeiner Kallweit RTL_W32(tp, ERIAR, ERIAR_WRITE_CMD | type | mask | addr); 116425e992a4SHeiner Kallweit 116525e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_eriar_cond, 100, 100); 116625e992a4SHeiner Kallweit } 116725e992a4SHeiner Kallweit 116825e992a4SHeiner Kallweit static void rtl_eri_write(struct rtl8169_private *tp, int addr, u32 mask, 116925e992a4SHeiner Kallweit u32 val) 117025e992a4SHeiner Kallweit { 117125e992a4SHeiner Kallweit _rtl_eri_write(tp, addr, mask, val, ERIAR_EXGMAC); 117225e992a4SHeiner Kallweit } 117325e992a4SHeiner Kallweit 117425e992a4SHeiner Kallweit static u32 _rtl_eri_read(struct rtl8169_private *tp, int addr, int type) 117525e992a4SHeiner Kallweit { 117625e992a4SHeiner Kallweit RTL_W32(tp, ERIAR, ERIAR_READ_CMD | type | ERIAR_MASK_1111 | addr); 117725e992a4SHeiner Kallweit 117825e992a4SHeiner Kallweit return rtl_udelay_loop_wait_high(tp, &rtl_eriar_cond, 100, 100) ? 117925e992a4SHeiner Kallweit RTL_R32(tp, ERIDR) : ~0; 118025e992a4SHeiner Kallweit } 118125e992a4SHeiner Kallweit 118225e992a4SHeiner Kallweit static u32 rtl_eri_read(struct rtl8169_private *tp, int addr) 118325e992a4SHeiner Kallweit { 118425e992a4SHeiner Kallweit return _rtl_eri_read(tp, addr, ERIAR_EXGMAC); 118525e992a4SHeiner Kallweit } 118625e992a4SHeiner Kallweit 118725e992a4SHeiner Kallweit static void rtl_w0w1_eri(struct rtl8169_private *tp, int addr, u32 mask, u32 p, 118825e992a4SHeiner Kallweit u32 m) 118925e992a4SHeiner Kallweit { 119025e992a4SHeiner Kallweit u32 val; 119125e992a4SHeiner Kallweit 119225e992a4SHeiner Kallweit val = rtl_eri_read(tp, addr); 119325e992a4SHeiner Kallweit rtl_eri_write(tp, addr, mask, (val & ~m) | p); 119425e992a4SHeiner Kallweit } 119525e992a4SHeiner Kallweit 119625e992a4SHeiner Kallweit static void rtl_eri_set_bits(struct rtl8169_private *tp, int addr, u32 mask, 119725e992a4SHeiner Kallweit u32 p) 119825e992a4SHeiner Kallweit { 119925e992a4SHeiner Kallweit rtl_w0w1_eri(tp, addr, mask, p, 0); 120025e992a4SHeiner Kallweit } 120125e992a4SHeiner Kallweit 120225e992a4SHeiner Kallweit static void rtl_eri_clear_bits(struct rtl8169_private *tp, int addr, u32 mask, 120325e992a4SHeiner Kallweit u32 m) 120425e992a4SHeiner Kallweit { 120525e992a4SHeiner Kallweit rtl_w0w1_eri(tp, addr, mask, 0, m); 120625e992a4SHeiner Kallweit } 120725e992a4SHeiner Kallweit 120825e992a4SHeiner Kallweit static u32 r8168dp_ocp_read(struct rtl8169_private *tp, u8 mask, u16 reg) 120925e992a4SHeiner Kallweit { 121025e992a4SHeiner Kallweit RTL_W32(tp, OCPAR, ((u32)mask & 0x0f) << 12 | (reg & 0x0fff)); 121125e992a4SHeiner Kallweit return rtl_udelay_loop_wait_high(tp, &rtl_ocpar_cond, 100, 20) ? 121225e992a4SHeiner Kallweit RTL_R32(tp, OCPDR) : ~0; 121325e992a4SHeiner Kallweit } 121425e992a4SHeiner Kallweit 121525e992a4SHeiner Kallweit static u32 r8168ep_ocp_read(struct rtl8169_private *tp, u8 mask, u16 reg) 121625e992a4SHeiner Kallweit { 121725e992a4SHeiner Kallweit return _rtl_eri_read(tp, reg, ERIAR_OOB); 121825e992a4SHeiner Kallweit } 121925e992a4SHeiner Kallweit 122025e992a4SHeiner Kallweit static void r8168dp_ocp_write(struct rtl8169_private *tp, u8 mask, u16 reg, 122125e992a4SHeiner Kallweit u32 data) 122225e992a4SHeiner Kallweit { 122325e992a4SHeiner Kallweit RTL_W32(tp, OCPDR, data); 122425e992a4SHeiner Kallweit RTL_W32(tp, OCPAR, OCPAR_FLAG | ((u32)mask & 0x0f) << 12 | (reg & 0x0fff)); 122525e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_ocpar_cond, 100, 20); 122625e992a4SHeiner Kallweit } 122725e992a4SHeiner Kallweit 122825e992a4SHeiner Kallweit static void r8168ep_ocp_write(struct rtl8169_private *tp, u8 mask, u16 reg, 122925e992a4SHeiner Kallweit u32 data) 123025e992a4SHeiner Kallweit { 123125e992a4SHeiner Kallweit _rtl_eri_write(tp, reg, ((u32)mask & 0x0f) << ERIAR_MASK_SHIFT, 123225e992a4SHeiner Kallweit data, ERIAR_OOB); 123325e992a4SHeiner Kallweit } 123425e992a4SHeiner Kallweit 123525e992a4SHeiner Kallweit static void r8168dp_oob_notify(struct rtl8169_private *tp, u8 cmd) 123625e992a4SHeiner Kallweit { 123725e992a4SHeiner Kallweit rtl_eri_write(tp, 0xe8, ERIAR_MASK_0001, cmd); 123825e992a4SHeiner Kallweit 123925e992a4SHeiner Kallweit r8168dp_ocp_write(tp, 0x1, 0x30, 0x00000001); 124025e992a4SHeiner Kallweit } 124125e992a4SHeiner Kallweit 124225e992a4SHeiner Kallweit #define OOB_CMD_RESET 0x00 124325e992a4SHeiner Kallweit #define OOB_CMD_DRIVER_START 0x05 124425e992a4SHeiner Kallweit #define OOB_CMD_DRIVER_STOP 0x06 124525e992a4SHeiner Kallweit 124625e992a4SHeiner Kallweit static u16 rtl8168_get_ocp_reg(struct rtl8169_private *tp) 124725e992a4SHeiner Kallweit { 124825e992a4SHeiner Kallweit return (tp->mac_version == RTL_GIGA_MAC_VER_31) ? 0xb8 : 0x10; 124925e992a4SHeiner Kallweit } 125025e992a4SHeiner Kallweit 125125e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_dp_ocp_read_cond) 125225e992a4SHeiner Kallweit { 125325e992a4SHeiner Kallweit u16 reg; 125425e992a4SHeiner Kallweit 125525e992a4SHeiner Kallweit reg = rtl8168_get_ocp_reg(tp); 125625e992a4SHeiner Kallweit 125725e992a4SHeiner Kallweit return r8168dp_ocp_read(tp, 0x0f, reg) & 0x00000800; 125825e992a4SHeiner Kallweit } 125925e992a4SHeiner Kallweit 126025e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_ep_ocp_read_cond) 126125e992a4SHeiner Kallweit { 126225e992a4SHeiner Kallweit return r8168ep_ocp_read(tp, 0x0f, 0x124) & 0x00000001; 126325e992a4SHeiner Kallweit } 126425e992a4SHeiner Kallweit 126525e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_ocp_tx_cond) 126625e992a4SHeiner Kallweit { 126725e992a4SHeiner Kallweit return RTL_R8(tp, IBISR0) & 0x20; 126825e992a4SHeiner Kallweit } 126925e992a4SHeiner Kallweit 127025e992a4SHeiner Kallweit static void rtl8168ep_stop_cmac(struct rtl8169_private *tp) 127125e992a4SHeiner Kallweit { 127225e992a4SHeiner Kallweit RTL_W8(tp, IBCR2, RTL_R8(tp, IBCR2) & ~0x01); 127325e992a4SHeiner Kallweit rtl_msleep_loop_wait_high(tp, &rtl_ocp_tx_cond, 50, 2000); 127425e992a4SHeiner Kallweit RTL_W8(tp, IBISR0, RTL_R8(tp, IBISR0) | 0x20); 127525e992a4SHeiner Kallweit RTL_W8(tp, IBCR0, RTL_R8(tp, IBCR0) & ~0x01); 127625e992a4SHeiner Kallweit } 127725e992a4SHeiner Kallweit 127825e992a4SHeiner Kallweit static void rtl8168dp_driver_start(struct rtl8169_private *tp) 127925e992a4SHeiner Kallweit { 128025e992a4SHeiner Kallweit r8168dp_oob_notify(tp, OOB_CMD_DRIVER_START); 128125e992a4SHeiner Kallweit rtl_msleep_loop_wait_high(tp, &rtl_dp_ocp_read_cond, 10, 10); 128225e992a4SHeiner Kallweit } 128325e992a4SHeiner Kallweit 128425e992a4SHeiner Kallweit static void rtl8168ep_driver_start(struct rtl8169_private *tp) 128525e992a4SHeiner Kallweit { 128625e992a4SHeiner Kallweit r8168ep_ocp_write(tp, 0x01, 0x180, OOB_CMD_DRIVER_START); 128725e992a4SHeiner Kallweit r8168ep_ocp_write(tp, 0x01, 0x30, 128825e992a4SHeiner Kallweit r8168ep_ocp_read(tp, 0x01, 0x30) | 0x01); 128925e992a4SHeiner Kallweit rtl_msleep_loop_wait_high(tp, &rtl_ep_ocp_read_cond, 10, 10); 129025e992a4SHeiner Kallweit } 129125e992a4SHeiner Kallweit 129225e992a4SHeiner Kallweit static void rtl8168_driver_start(struct rtl8169_private *tp) 129325e992a4SHeiner Kallweit { 129425e992a4SHeiner Kallweit switch (tp->mac_version) { 129525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27: 129625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_28: 129725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31: 129825e992a4SHeiner Kallweit rtl8168dp_driver_start(tp); 129925e992a4SHeiner Kallweit break; 13001287723aSHeiner Kallweit case RTL_GIGA_MAC_VER_49 ... RTL_GIGA_MAC_VER_52: 130125e992a4SHeiner Kallweit rtl8168ep_driver_start(tp); 130225e992a4SHeiner Kallweit break; 130325e992a4SHeiner Kallweit default: 130425e992a4SHeiner Kallweit BUG(); 130525e992a4SHeiner Kallweit break; 130625e992a4SHeiner Kallweit } 130725e992a4SHeiner Kallweit } 130825e992a4SHeiner Kallweit 130925e992a4SHeiner Kallweit static void rtl8168dp_driver_stop(struct rtl8169_private *tp) 131025e992a4SHeiner Kallweit { 131125e992a4SHeiner Kallweit r8168dp_oob_notify(tp, OOB_CMD_DRIVER_STOP); 131225e992a4SHeiner Kallweit rtl_msleep_loop_wait_low(tp, &rtl_dp_ocp_read_cond, 10, 10); 131325e992a4SHeiner Kallweit } 131425e992a4SHeiner Kallweit 131525e992a4SHeiner Kallweit static void rtl8168ep_driver_stop(struct rtl8169_private *tp) 131625e992a4SHeiner Kallweit { 131725e992a4SHeiner Kallweit rtl8168ep_stop_cmac(tp); 131825e992a4SHeiner Kallweit r8168ep_ocp_write(tp, 0x01, 0x180, OOB_CMD_DRIVER_STOP); 131925e992a4SHeiner Kallweit r8168ep_ocp_write(tp, 0x01, 0x30, 132025e992a4SHeiner Kallweit r8168ep_ocp_read(tp, 0x01, 0x30) | 0x01); 132125e992a4SHeiner Kallweit rtl_msleep_loop_wait_low(tp, &rtl_ep_ocp_read_cond, 10, 10); 132225e992a4SHeiner Kallweit } 132325e992a4SHeiner Kallweit 132425e992a4SHeiner Kallweit static void rtl8168_driver_stop(struct rtl8169_private *tp) 132525e992a4SHeiner Kallweit { 132625e992a4SHeiner Kallweit switch (tp->mac_version) { 132725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27: 132825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_28: 132925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31: 133025e992a4SHeiner Kallweit rtl8168dp_driver_stop(tp); 133125e992a4SHeiner Kallweit break; 13321287723aSHeiner Kallweit case RTL_GIGA_MAC_VER_49 ... RTL_GIGA_MAC_VER_52: 133325e992a4SHeiner Kallweit rtl8168ep_driver_stop(tp); 133425e992a4SHeiner Kallweit break; 133525e992a4SHeiner Kallweit default: 133625e992a4SHeiner Kallweit BUG(); 133725e992a4SHeiner Kallweit break; 133825e992a4SHeiner Kallweit } 133925e992a4SHeiner Kallweit } 134025e992a4SHeiner Kallweit 134125e992a4SHeiner Kallweit static bool r8168dp_check_dash(struct rtl8169_private *tp) 134225e992a4SHeiner Kallweit { 134325e992a4SHeiner Kallweit u16 reg = rtl8168_get_ocp_reg(tp); 134425e992a4SHeiner Kallweit 134525e992a4SHeiner Kallweit return !!(r8168dp_ocp_read(tp, 0x0f, reg) & 0x00008000); 134625e992a4SHeiner Kallweit } 134725e992a4SHeiner Kallweit 134825e992a4SHeiner Kallweit static bool r8168ep_check_dash(struct rtl8169_private *tp) 134925e992a4SHeiner Kallweit { 135025e992a4SHeiner Kallweit return !!(r8168ep_ocp_read(tp, 0x0f, 0x128) & 0x00000001); 135125e992a4SHeiner Kallweit } 135225e992a4SHeiner Kallweit 135325e992a4SHeiner Kallweit static bool r8168_check_dash(struct rtl8169_private *tp) 135425e992a4SHeiner Kallweit { 135525e992a4SHeiner Kallweit switch (tp->mac_version) { 135625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27: 135725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_28: 135825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31: 135925e992a4SHeiner Kallweit return r8168dp_check_dash(tp); 13601287723aSHeiner Kallweit case RTL_GIGA_MAC_VER_49 ... RTL_GIGA_MAC_VER_52: 136125e992a4SHeiner Kallweit return r8168ep_check_dash(tp); 136225e992a4SHeiner Kallweit default: 136325e992a4SHeiner Kallweit return false; 136425e992a4SHeiner Kallweit } 136525e992a4SHeiner Kallweit } 136625e992a4SHeiner Kallweit 136725e992a4SHeiner Kallweit static void rtl_reset_packet_filter(struct rtl8169_private *tp) 136825e992a4SHeiner Kallweit { 136925e992a4SHeiner Kallweit rtl_eri_clear_bits(tp, 0xdc, ERIAR_MASK_0001, BIT(0)); 137025e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0xdc, ERIAR_MASK_0001, BIT(0)); 137125e992a4SHeiner Kallweit } 137225e992a4SHeiner Kallweit 137325e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_efusear_cond) 137425e992a4SHeiner Kallweit { 137525e992a4SHeiner Kallweit return RTL_R32(tp, EFUSEAR) & EFUSEAR_FLAG; 137625e992a4SHeiner Kallweit } 137725e992a4SHeiner Kallweit 137825e992a4SHeiner Kallweit static u8 rtl8168d_efuse_read(struct rtl8169_private *tp, int reg_addr) 137925e992a4SHeiner Kallweit { 138025e992a4SHeiner Kallweit RTL_W32(tp, EFUSEAR, (reg_addr & EFUSEAR_REG_MASK) << EFUSEAR_REG_SHIFT); 138125e992a4SHeiner Kallweit 138225e992a4SHeiner Kallweit return rtl_udelay_loop_wait_high(tp, &rtl_efusear_cond, 100, 300) ? 138325e992a4SHeiner Kallweit RTL_R32(tp, EFUSEAR) & EFUSEAR_DATA_MASK : ~0; 138425e992a4SHeiner Kallweit } 138525e992a4SHeiner Kallweit 1386c1d532d2SHeiner Kallweit static u32 rtl_get_events(struct rtl8169_private *tp) 1387c1d532d2SHeiner Kallweit { 1388f1bce4adSHeiner Kallweit if (rtl_is_8125(tp)) 1389f1bce4adSHeiner Kallweit return RTL_R32(tp, IntrStatus_8125); 1390f1bce4adSHeiner Kallweit else 1391c1d532d2SHeiner Kallweit return RTL_R16(tp, IntrStatus); 1392c1d532d2SHeiner Kallweit } 1393c1d532d2SHeiner Kallweit 1394c1d532d2SHeiner Kallweit static void rtl_ack_events(struct rtl8169_private *tp, u32 bits) 139525e992a4SHeiner Kallweit { 1396f1bce4adSHeiner Kallweit if (rtl_is_8125(tp)) 1397f1bce4adSHeiner Kallweit RTL_W32(tp, IntrStatus_8125, bits); 1398f1bce4adSHeiner Kallweit else 139925e992a4SHeiner Kallweit RTL_W16(tp, IntrStatus, bits); 140025e992a4SHeiner Kallweit } 140125e992a4SHeiner Kallweit 140225e992a4SHeiner Kallweit static void rtl_irq_disable(struct rtl8169_private *tp) 140325e992a4SHeiner Kallweit { 1404f1bce4adSHeiner Kallweit if (rtl_is_8125(tp)) 1405f1bce4adSHeiner Kallweit RTL_W32(tp, IntrMask_8125, 0); 1406f1bce4adSHeiner Kallweit else 140725e992a4SHeiner Kallweit RTL_W16(tp, IntrMask, 0); 140825e992a4SHeiner Kallweit tp->irq_enabled = 0; 140925e992a4SHeiner Kallweit } 141025e992a4SHeiner Kallweit 141125e992a4SHeiner Kallweit #define RTL_EVENT_NAPI_RX (RxOK | RxErr) 141225e992a4SHeiner Kallweit #define RTL_EVENT_NAPI_TX (TxOK | TxErr) 141325e992a4SHeiner Kallweit #define RTL_EVENT_NAPI (RTL_EVENT_NAPI_RX | RTL_EVENT_NAPI_TX) 141425e992a4SHeiner Kallweit 141525e992a4SHeiner Kallweit static void rtl_irq_enable(struct rtl8169_private *tp) 141625e992a4SHeiner Kallweit { 141725e992a4SHeiner Kallweit tp->irq_enabled = 1; 1418f1bce4adSHeiner Kallweit if (rtl_is_8125(tp)) 1419f1bce4adSHeiner Kallweit RTL_W32(tp, IntrMask_8125, tp->irq_mask); 1420f1bce4adSHeiner Kallweit else 142125e992a4SHeiner Kallweit RTL_W16(tp, IntrMask, tp->irq_mask); 142225e992a4SHeiner Kallweit } 142325e992a4SHeiner Kallweit 142425e992a4SHeiner Kallweit static void rtl8169_irq_mask_and_ack(struct rtl8169_private *tp) 142525e992a4SHeiner Kallweit { 142625e992a4SHeiner Kallweit rtl_irq_disable(tp); 1427c1d532d2SHeiner Kallweit rtl_ack_events(tp, 0xffffffff); 142825e992a4SHeiner Kallweit /* PCI commit */ 142925e992a4SHeiner Kallweit RTL_R8(tp, ChipCmd); 143025e992a4SHeiner Kallweit } 143125e992a4SHeiner Kallweit 143225e992a4SHeiner Kallweit static void rtl_link_chg_patch(struct rtl8169_private *tp) 143325e992a4SHeiner Kallweit { 143425e992a4SHeiner Kallweit struct net_device *dev = tp->dev; 143525e992a4SHeiner Kallweit struct phy_device *phydev = tp->phydev; 143625e992a4SHeiner Kallweit 143725e992a4SHeiner Kallweit if (!netif_running(dev)) 143825e992a4SHeiner Kallweit return; 143925e992a4SHeiner Kallweit 144025e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_34 || 144125e992a4SHeiner Kallweit tp->mac_version == RTL_GIGA_MAC_VER_38) { 144225e992a4SHeiner Kallweit if (phydev->speed == SPEED_1000) { 144325e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1bc, ERIAR_MASK_1111, 0x00000011); 144425e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1dc, ERIAR_MASK_1111, 0x00000005); 144525e992a4SHeiner Kallweit } else if (phydev->speed == SPEED_100) { 144625e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1bc, ERIAR_MASK_1111, 0x0000001f); 144725e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1dc, ERIAR_MASK_1111, 0x00000005); 144825e992a4SHeiner Kallweit } else { 144925e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1bc, ERIAR_MASK_1111, 0x0000001f); 145025e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1dc, ERIAR_MASK_1111, 0x0000003f); 145125e992a4SHeiner Kallweit } 145225e992a4SHeiner Kallweit rtl_reset_packet_filter(tp); 145325e992a4SHeiner Kallweit } else if (tp->mac_version == RTL_GIGA_MAC_VER_35 || 145425e992a4SHeiner Kallweit tp->mac_version == RTL_GIGA_MAC_VER_36) { 145525e992a4SHeiner Kallweit if (phydev->speed == SPEED_1000) { 145625e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1bc, ERIAR_MASK_1111, 0x00000011); 145725e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1dc, ERIAR_MASK_1111, 0x00000005); 145825e992a4SHeiner Kallweit } else { 145925e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1bc, ERIAR_MASK_1111, 0x0000001f); 146025e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1dc, ERIAR_MASK_1111, 0x0000003f); 146125e992a4SHeiner Kallweit } 146225e992a4SHeiner Kallweit } else if (tp->mac_version == RTL_GIGA_MAC_VER_37) { 146325e992a4SHeiner Kallweit if (phydev->speed == SPEED_10) { 146425e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1d0, ERIAR_MASK_0011, 0x4d02); 146525e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1dc, ERIAR_MASK_0011, 0x0060a); 146625e992a4SHeiner Kallweit } else { 146725e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1d0, ERIAR_MASK_0011, 0x0000); 146825e992a4SHeiner Kallweit } 146925e992a4SHeiner Kallweit } 147025e992a4SHeiner Kallweit } 147125e992a4SHeiner Kallweit 147225e992a4SHeiner Kallweit #define WAKE_ANY (WAKE_PHY | WAKE_MAGIC | WAKE_UCAST | WAKE_BCAST | WAKE_MCAST) 147325e992a4SHeiner Kallweit 147425e992a4SHeiner Kallweit static void rtl8169_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol) 147525e992a4SHeiner Kallweit { 147625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 147725e992a4SHeiner Kallweit 147825e992a4SHeiner Kallweit rtl_lock_work(tp); 147925e992a4SHeiner Kallweit wol->supported = WAKE_ANY; 148025e992a4SHeiner Kallweit wol->wolopts = tp->saved_wolopts; 148125e992a4SHeiner Kallweit rtl_unlock_work(tp); 148225e992a4SHeiner Kallweit } 148325e992a4SHeiner Kallweit 148425e992a4SHeiner Kallweit static void __rtl8169_set_wol(struct rtl8169_private *tp, u32 wolopts) 148525e992a4SHeiner Kallweit { 148625e992a4SHeiner Kallweit static const struct { 148725e992a4SHeiner Kallweit u32 opt; 148825e992a4SHeiner Kallweit u16 reg; 148925e992a4SHeiner Kallweit u8 mask; 149025e992a4SHeiner Kallweit } cfg[] = { 149125e992a4SHeiner Kallweit { WAKE_PHY, Config3, LinkUp }, 149225e992a4SHeiner Kallweit { WAKE_UCAST, Config5, UWF }, 149325e992a4SHeiner Kallweit { WAKE_BCAST, Config5, BWF }, 149425e992a4SHeiner Kallweit { WAKE_MCAST, Config5, MWF }, 149525e992a4SHeiner Kallweit { WAKE_ANY, Config5, LanWake }, 149625e992a4SHeiner Kallweit { WAKE_MAGIC, Config3, MagicPacket } 149725e992a4SHeiner Kallweit }; 1498f1bce4adSHeiner Kallweit unsigned int i, tmp = ARRAY_SIZE(cfg); 149925e992a4SHeiner Kallweit u8 options; 150025e992a4SHeiner Kallweit 150125e992a4SHeiner Kallweit rtl_unlock_config_regs(tp); 150225e992a4SHeiner Kallweit 15039e9f33baSHeiner Kallweit if (rtl_is_8168evl_up(tp)) { 1504f1bce4adSHeiner Kallweit tmp--; 150525e992a4SHeiner Kallweit if (wolopts & WAKE_MAGIC) 150625e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0x0dc, ERIAR_MASK_0100, 150725e992a4SHeiner Kallweit MagicPacket_v2); 150825e992a4SHeiner Kallweit else 150925e992a4SHeiner Kallweit rtl_eri_clear_bits(tp, 0x0dc, ERIAR_MASK_0100, 151025e992a4SHeiner Kallweit MagicPacket_v2); 1511f1bce4adSHeiner Kallweit } else if (rtl_is_8125(tp)) { 1512f1bce4adSHeiner Kallweit tmp--; 1513f1bce4adSHeiner Kallweit if (wolopts & WAKE_MAGIC) 1514f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xc0b6, 0, BIT(0)); 1515f1bce4adSHeiner Kallweit else 1516f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xc0b6, BIT(0), 0); 151725e992a4SHeiner Kallweit } 151825e992a4SHeiner Kallweit 151925e992a4SHeiner Kallweit for (i = 0; i < tmp; i++) { 152025e992a4SHeiner Kallweit options = RTL_R8(tp, cfg[i].reg) & ~cfg[i].mask; 152125e992a4SHeiner Kallweit if (wolopts & cfg[i].opt) 152225e992a4SHeiner Kallweit options |= cfg[i].mask; 152325e992a4SHeiner Kallweit RTL_W8(tp, cfg[i].reg, options); 152425e992a4SHeiner Kallweit } 152525e992a4SHeiner Kallweit 152625e992a4SHeiner Kallweit switch (tp->mac_version) { 1527edcde3eeSHeiner Kallweit case RTL_GIGA_MAC_VER_02 ... RTL_GIGA_MAC_VER_06: 152825e992a4SHeiner Kallweit options = RTL_R8(tp, Config1) & ~PMEnable; 152925e992a4SHeiner Kallweit if (wolopts) 153025e992a4SHeiner Kallweit options |= PMEnable; 153125e992a4SHeiner Kallweit RTL_W8(tp, Config1, options); 153225e992a4SHeiner Kallweit break; 1533edcde3eeSHeiner Kallweit case RTL_GIGA_MAC_VER_34: 1534edcde3eeSHeiner Kallweit case RTL_GIGA_MAC_VER_37: 15351287723aSHeiner Kallweit case RTL_GIGA_MAC_VER_39 ... RTL_GIGA_MAC_VER_52: 153625e992a4SHeiner Kallweit options = RTL_R8(tp, Config2) & ~PME_SIGNAL; 153725e992a4SHeiner Kallweit if (wolopts) 153825e992a4SHeiner Kallweit options |= PME_SIGNAL; 153925e992a4SHeiner Kallweit RTL_W8(tp, Config2, options); 154025e992a4SHeiner Kallweit break; 1541edcde3eeSHeiner Kallweit default: 1542edcde3eeSHeiner Kallweit break; 154325e992a4SHeiner Kallweit } 154425e992a4SHeiner Kallweit 154525e992a4SHeiner Kallweit rtl_lock_config_regs(tp); 154625e992a4SHeiner Kallweit 154725e992a4SHeiner Kallweit device_set_wakeup_enable(tp_to_dev(tp), wolopts); 1548398fd408SHeiner Kallweit tp->dev->wol_enabled = wolopts ? 1 : 0; 154925e992a4SHeiner Kallweit } 155025e992a4SHeiner Kallweit 155125e992a4SHeiner Kallweit static int rtl8169_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol) 155225e992a4SHeiner Kallweit { 155325e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 155425e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 155525e992a4SHeiner Kallweit 155625e992a4SHeiner Kallweit if (wol->wolopts & ~WAKE_ANY) 155725e992a4SHeiner Kallweit return -EINVAL; 155825e992a4SHeiner Kallweit 155925e992a4SHeiner Kallweit pm_runtime_get_noresume(d); 156025e992a4SHeiner Kallweit 156125e992a4SHeiner Kallweit rtl_lock_work(tp); 156225e992a4SHeiner Kallweit 156325e992a4SHeiner Kallweit tp->saved_wolopts = wol->wolopts; 156425e992a4SHeiner Kallweit 156525e992a4SHeiner Kallweit if (pm_runtime_active(d)) 156625e992a4SHeiner Kallweit __rtl8169_set_wol(tp, tp->saved_wolopts); 156725e992a4SHeiner Kallweit 156825e992a4SHeiner Kallweit rtl_unlock_work(tp); 156925e992a4SHeiner Kallweit 157025e992a4SHeiner Kallweit pm_runtime_put_noidle(d); 157125e992a4SHeiner Kallweit 157225e992a4SHeiner Kallweit return 0; 157325e992a4SHeiner Kallweit } 157425e992a4SHeiner Kallweit 157525e992a4SHeiner Kallweit static void rtl8169_get_drvinfo(struct net_device *dev, 157625e992a4SHeiner Kallweit struct ethtool_drvinfo *info) 157725e992a4SHeiner Kallweit { 157825e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 157925e992a4SHeiner Kallweit struct rtl_fw *rtl_fw = tp->rtl_fw; 158025e992a4SHeiner Kallweit 158125e992a4SHeiner Kallweit strlcpy(info->driver, MODULENAME, sizeof(info->driver)); 158225e992a4SHeiner Kallweit strlcpy(info->bus_info, pci_name(tp->pci_dev), sizeof(info->bus_info)); 158325e992a4SHeiner Kallweit BUILD_BUG_ON(sizeof(info->fw_version) < sizeof(rtl_fw->version)); 158425e992a4SHeiner Kallweit if (rtl_fw) 158525e992a4SHeiner Kallweit strlcpy(info->fw_version, rtl_fw->version, 158625e992a4SHeiner Kallweit sizeof(info->fw_version)); 158725e992a4SHeiner Kallweit } 158825e992a4SHeiner Kallweit 158925e992a4SHeiner Kallweit static int rtl8169_get_regs_len(struct net_device *dev) 159025e992a4SHeiner Kallweit { 159125e992a4SHeiner Kallweit return R8169_REGS_SIZE; 159225e992a4SHeiner Kallweit } 159325e992a4SHeiner Kallweit 159425e992a4SHeiner Kallweit static netdev_features_t rtl8169_fix_features(struct net_device *dev, 159525e992a4SHeiner Kallweit netdev_features_t features) 159625e992a4SHeiner Kallweit { 159725e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 159825e992a4SHeiner Kallweit 159925e992a4SHeiner Kallweit if (dev->mtu > TD_MSS_MAX) 160025e992a4SHeiner Kallweit features &= ~NETIF_F_ALL_TSO; 160125e992a4SHeiner Kallweit 160225e992a4SHeiner Kallweit if (dev->mtu > JUMBO_1K && 160325e992a4SHeiner Kallweit tp->mac_version > RTL_GIGA_MAC_VER_06) 16047cb83b21SHeiner Kallweit features &= ~(NETIF_F_CSUM_MASK | NETIF_F_ALL_TSO); 160525e992a4SHeiner Kallweit 160625e992a4SHeiner Kallweit return features; 160725e992a4SHeiner Kallweit } 160825e992a4SHeiner Kallweit 160925e992a4SHeiner Kallweit static int rtl8169_set_features(struct net_device *dev, 161025e992a4SHeiner Kallweit netdev_features_t features) 161125e992a4SHeiner Kallweit { 161225e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 161325e992a4SHeiner Kallweit u32 rx_config; 161425e992a4SHeiner Kallweit 161525e992a4SHeiner Kallweit rtl_lock_work(tp); 161625e992a4SHeiner Kallweit 161725e992a4SHeiner Kallweit rx_config = RTL_R32(tp, RxConfig); 161825e992a4SHeiner Kallweit if (features & NETIF_F_RXALL) 161925e992a4SHeiner Kallweit rx_config |= (AcceptErr | AcceptRunt); 162025e992a4SHeiner Kallweit else 162125e992a4SHeiner Kallweit rx_config &= ~(AcceptErr | AcceptRunt); 162225e992a4SHeiner Kallweit 1623f1bce4adSHeiner Kallweit if (rtl_is_8125(tp)) { 1624f1bce4adSHeiner Kallweit if (features & NETIF_F_HW_VLAN_CTAG_RX) 1625f1bce4adSHeiner Kallweit rx_config |= RX_VLAN_8125; 1626f1bce4adSHeiner Kallweit else 1627f1bce4adSHeiner Kallweit rx_config &= ~RX_VLAN_8125; 1628f1bce4adSHeiner Kallweit } 1629f1bce4adSHeiner Kallweit 163025e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, rx_config); 163125e992a4SHeiner Kallweit 163225e992a4SHeiner Kallweit if (features & NETIF_F_RXCSUM) 163325e992a4SHeiner Kallweit tp->cp_cmd |= RxChkSum; 163425e992a4SHeiner Kallweit else 163525e992a4SHeiner Kallweit tp->cp_cmd &= ~RxChkSum; 163625e992a4SHeiner Kallweit 1637f1bce4adSHeiner Kallweit if (!rtl_is_8125(tp)) { 163825e992a4SHeiner Kallweit if (features & NETIF_F_HW_VLAN_CTAG_RX) 163925e992a4SHeiner Kallweit tp->cp_cmd |= RxVlan; 164025e992a4SHeiner Kallweit else 164125e992a4SHeiner Kallweit tp->cp_cmd &= ~RxVlan; 1642f1bce4adSHeiner Kallweit } 164325e992a4SHeiner Kallweit 164425e992a4SHeiner Kallweit RTL_W16(tp, CPlusCmd, tp->cp_cmd); 164525e992a4SHeiner Kallweit RTL_R16(tp, CPlusCmd); 164625e992a4SHeiner Kallweit 164725e992a4SHeiner Kallweit rtl_unlock_work(tp); 164825e992a4SHeiner Kallweit 164925e992a4SHeiner Kallweit return 0; 165025e992a4SHeiner Kallweit } 165125e992a4SHeiner Kallweit 165225e992a4SHeiner Kallweit static inline u32 rtl8169_tx_vlan_tag(struct sk_buff *skb) 165325e992a4SHeiner Kallweit { 165425e992a4SHeiner Kallweit return (skb_vlan_tag_present(skb)) ? 16557424edbbSHeiner Kallweit TxVlanTag | swab16(skb_vlan_tag_get(skb)) : 0x00; 165625e992a4SHeiner Kallweit } 165725e992a4SHeiner Kallweit 165825e992a4SHeiner Kallweit static void rtl8169_rx_vlan_tag(struct RxDesc *desc, struct sk_buff *skb) 165925e992a4SHeiner Kallweit { 166025e992a4SHeiner Kallweit u32 opts2 = le32_to_cpu(desc->opts2); 166125e992a4SHeiner Kallweit 166225e992a4SHeiner Kallweit if (opts2 & RxVlanTag) 16637424edbbSHeiner Kallweit __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), swab16(opts2 & 0xffff)); 166425e992a4SHeiner Kallweit } 166525e992a4SHeiner Kallweit 166625e992a4SHeiner Kallweit static void rtl8169_get_regs(struct net_device *dev, struct ethtool_regs *regs, 166725e992a4SHeiner Kallweit void *p) 166825e992a4SHeiner Kallweit { 166925e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 167025e992a4SHeiner Kallweit u32 __iomem *data = tp->mmio_addr; 167125e992a4SHeiner Kallweit u32 *dw = p; 167225e992a4SHeiner Kallweit int i; 167325e992a4SHeiner Kallweit 167425e992a4SHeiner Kallweit rtl_lock_work(tp); 167525e992a4SHeiner Kallweit for (i = 0; i < R8169_REGS_SIZE; i += 4) 167625e992a4SHeiner Kallweit memcpy_fromio(dw++, data++, 4); 167725e992a4SHeiner Kallweit rtl_unlock_work(tp); 167825e992a4SHeiner Kallweit } 167925e992a4SHeiner Kallweit 168025e992a4SHeiner Kallweit static u32 rtl8169_get_msglevel(struct net_device *dev) 168125e992a4SHeiner Kallweit { 168225e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 168325e992a4SHeiner Kallweit 168425e992a4SHeiner Kallweit return tp->msg_enable; 168525e992a4SHeiner Kallweit } 168625e992a4SHeiner Kallweit 168725e992a4SHeiner Kallweit static void rtl8169_set_msglevel(struct net_device *dev, u32 value) 168825e992a4SHeiner Kallweit { 168925e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 169025e992a4SHeiner Kallweit 169125e992a4SHeiner Kallweit tp->msg_enable = value; 169225e992a4SHeiner Kallweit } 169325e992a4SHeiner Kallweit 169425e992a4SHeiner Kallweit static const char rtl8169_gstrings[][ETH_GSTRING_LEN] = { 169525e992a4SHeiner Kallweit "tx_packets", 169625e992a4SHeiner Kallweit "rx_packets", 169725e992a4SHeiner Kallweit "tx_errors", 169825e992a4SHeiner Kallweit "rx_errors", 169925e992a4SHeiner Kallweit "rx_missed", 170025e992a4SHeiner Kallweit "align_errors", 170125e992a4SHeiner Kallweit "tx_single_collisions", 170225e992a4SHeiner Kallweit "tx_multi_collisions", 170325e992a4SHeiner Kallweit "unicast", 170425e992a4SHeiner Kallweit "broadcast", 170525e992a4SHeiner Kallweit "multicast", 170625e992a4SHeiner Kallweit "tx_aborted", 170725e992a4SHeiner Kallweit "tx_underrun", 170825e992a4SHeiner Kallweit }; 170925e992a4SHeiner Kallweit 171025e992a4SHeiner Kallweit static int rtl8169_get_sset_count(struct net_device *dev, int sset) 171125e992a4SHeiner Kallweit { 171225e992a4SHeiner Kallweit switch (sset) { 171325e992a4SHeiner Kallweit case ETH_SS_STATS: 171425e992a4SHeiner Kallweit return ARRAY_SIZE(rtl8169_gstrings); 171525e992a4SHeiner Kallweit default: 171625e992a4SHeiner Kallweit return -EOPNOTSUPP; 171725e992a4SHeiner Kallweit } 171825e992a4SHeiner Kallweit } 171925e992a4SHeiner Kallweit 172025e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_counters_cond) 172125e992a4SHeiner Kallweit { 172225e992a4SHeiner Kallweit return RTL_R32(tp, CounterAddrLow) & (CounterReset | CounterDump); 172325e992a4SHeiner Kallweit } 172425e992a4SHeiner Kallweit 172525e992a4SHeiner Kallweit static bool rtl8169_do_counters(struct rtl8169_private *tp, u32 counter_cmd) 172625e992a4SHeiner Kallweit { 172725e992a4SHeiner Kallweit dma_addr_t paddr = tp->counters_phys_addr; 172825e992a4SHeiner Kallweit u32 cmd; 172925e992a4SHeiner Kallweit 173025e992a4SHeiner Kallweit RTL_W32(tp, CounterAddrHigh, (u64)paddr >> 32); 173125e992a4SHeiner Kallweit RTL_R32(tp, CounterAddrHigh); 173225e992a4SHeiner Kallweit cmd = (u64)paddr & DMA_BIT_MASK(32); 173325e992a4SHeiner Kallweit RTL_W32(tp, CounterAddrLow, cmd); 173425e992a4SHeiner Kallweit RTL_W32(tp, CounterAddrLow, cmd | counter_cmd); 173525e992a4SHeiner Kallweit 173625e992a4SHeiner Kallweit return rtl_udelay_loop_wait_low(tp, &rtl_counters_cond, 10, 1000); 173725e992a4SHeiner Kallweit } 173825e992a4SHeiner Kallweit 173925e992a4SHeiner Kallweit static bool rtl8169_reset_counters(struct rtl8169_private *tp) 174025e992a4SHeiner Kallweit { 174125e992a4SHeiner Kallweit /* 174225e992a4SHeiner Kallweit * Versions prior to RTL_GIGA_MAC_VER_19 don't support resetting the 174325e992a4SHeiner Kallweit * tally counters. 174425e992a4SHeiner Kallweit */ 174525e992a4SHeiner Kallweit if (tp->mac_version < RTL_GIGA_MAC_VER_19) 174625e992a4SHeiner Kallweit return true; 174725e992a4SHeiner Kallweit 174825e992a4SHeiner Kallweit return rtl8169_do_counters(tp, CounterReset); 174925e992a4SHeiner Kallweit } 175025e992a4SHeiner Kallweit 175125e992a4SHeiner Kallweit static bool rtl8169_update_counters(struct rtl8169_private *tp) 175225e992a4SHeiner Kallweit { 175325e992a4SHeiner Kallweit u8 val = RTL_R8(tp, ChipCmd); 175425e992a4SHeiner Kallweit 175525e992a4SHeiner Kallweit /* 175625e992a4SHeiner Kallweit * Some chips are unable to dump tally counters when the receiver 175725e992a4SHeiner Kallweit * is disabled. If 0xff chip may be in a PCI power-save state. 175825e992a4SHeiner Kallweit */ 175925e992a4SHeiner Kallweit if (!(val & CmdRxEnb) || val == 0xff) 176025e992a4SHeiner Kallweit return true; 176125e992a4SHeiner Kallweit 176225e992a4SHeiner Kallweit return rtl8169_do_counters(tp, CounterDump); 176325e992a4SHeiner Kallweit } 176425e992a4SHeiner Kallweit 176525e992a4SHeiner Kallweit static bool rtl8169_init_counter_offsets(struct rtl8169_private *tp) 176625e992a4SHeiner Kallweit { 176725e992a4SHeiner Kallweit struct rtl8169_counters *counters = tp->counters; 176825e992a4SHeiner Kallweit bool ret = false; 176925e992a4SHeiner Kallweit 177025e992a4SHeiner Kallweit /* 177125e992a4SHeiner Kallweit * rtl8169_init_counter_offsets is called from rtl_open. On chip 177225e992a4SHeiner Kallweit * versions prior to RTL_GIGA_MAC_VER_19 the tally counters are only 177325e992a4SHeiner Kallweit * reset by a power cycle, while the counter values collected by the 177425e992a4SHeiner Kallweit * driver are reset at every driver unload/load cycle. 177525e992a4SHeiner Kallweit * 177625e992a4SHeiner Kallweit * To make sure the HW values returned by @get_stats64 match the SW 177725e992a4SHeiner Kallweit * values, we collect the initial values at first open(*) and use them 177825e992a4SHeiner Kallweit * as offsets to normalize the values returned by @get_stats64. 177925e992a4SHeiner Kallweit * 178025e992a4SHeiner Kallweit * (*) We can't call rtl8169_init_counter_offsets from rtl_init_one 178125e992a4SHeiner Kallweit * for the reason stated in rtl8169_update_counters; CmdRxEnb is only 178225e992a4SHeiner Kallweit * set at open time by rtl_hw_start. 178325e992a4SHeiner Kallweit */ 178425e992a4SHeiner Kallweit 178525e992a4SHeiner Kallweit if (tp->tc_offset.inited) 178625e992a4SHeiner Kallweit return true; 178725e992a4SHeiner Kallweit 178825e992a4SHeiner Kallweit /* If both, reset and update fail, propagate to caller. */ 178925e992a4SHeiner Kallweit if (rtl8169_reset_counters(tp)) 179025e992a4SHeiner Kallweit ret = true; 179125e992a4SHeiner Kallweit 179225e992a4SHeiner Kallweit if (rtl8169_update_counters(tp)) 179325e992a4SHeiner Kallweit ret = true; 179425e992a4SHeiner Kallweit 179525e992a4SHeiner Kallweit tp->tc_offset.tx_errors = counters->tx_errors; 179625e992a4SHeiner Kallweit tp->tc_offset.tx_multi_collision = counters->tx_multi_collision; 179725e992a4SHeiner Kallweit tp->tc_offset.tx_aborted = counters->tx_aborted; 179825e992a4SHeiner Kallweit tp->tc_offset.inited = true; 179925e992a4SHeiner Kallweit 180025e992a4SHeiner Kallweit return ret; 180125e992a4SHeiner Kallweit } 180225e992a4SHeiner Kallweit 180325e992a4SHeiner Kallweit static void rtl8169_get_ethtool_stats(struct net_device *dev, 180425e992a4SHeiner Kallweit struct ethtool_stats *stats, u64 *data) 180525e992a4SHeiner Kallweit { 180625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 180725e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 180825e992a4SHeiner Kallweit struct rtl8169_counters *counters = tp->counters; 180925e992a4SHeiner Kallweit 181025e992a4SHeiner Kallweit ASSERT_RTNL(); 181125e992a4SHeiner Kallweit 181225e992a4SHeiner Kallweit pm_runtime_get_noresume(d); 181325e992a4SHeiner Kallweit 181425e992a4SHeiner Kallweit if (pm_runtime_active(d)) 181525e992a4SHeiner Kallweit rtl8169_update_counters(tp); 181625e992a4SHeiner Kallweit 181725e992a4SHeiner Kallweit pm_runtime_put_noidle(d); 181825e992a4SHeiner Kallweit 181925e992a4SHeiner Kallweit data[0] = le64_to_cpu(counters->tx_packets); 182025e992a4SHeiner Kallweit data[1] = le64_to_cpu(counters->rx_packets); 182125e992a4SHeiner Kallweit data[2] = le64_to_cpu(counters->tx_errors); 182225e992a4SHeiner Kallweit data[3] = le32_to_cpu(counters->rx_errors); 182325e992a4SHeiner Kallweit data[4] = le16_to_cpu(counters->rx_missed); 182425e992a4SHeiner Kallweit data[5] = le16_to_cpu(counters->align_errors); 182525e992a4SHeiner Kallweit data[6] = le32_to_cpu(counters->tx_one_collision); 182625e992a4SHeiner Kallweit data[7] = le32_to_cpu(counters->tx_multi_collision); 182725e992a4SHeiner Kallweit data[8] = le64_to_cpu(counters->rx_unicast); 182825e992a4SHeiner Kallweit data[9] = le64_to_cpu(counters->rx_broadcast); 182925e992a4SHeiner Kallweit data[10] = le32_to_cpu(counters->rx_multicast); 183025e992a4SHeiner Kallweit data[11] = le16_to_cpu(counters->tx_aborted); 183125e992a4SHeiner Kallweit data[12] = le16_to_cpu(counters->tx_underun); 183225e992a4SHeiner Kallweit } 183325e992a4SHeiner Kallweit 183425e992a4SHeiner Kallweit static void rtl8169_get_strings(struct net_device *dev, u32 stringset, u8 *data) 183525e992a4SHeiner Kallweit { 183625e992a4SHeiner Kallweit switch(stringset) { 183725e992a4SHeiner Kallweit case ETH_SS_STATS: 183825e992a4SHeiner Kallweit memcpy(data, *rtl8169_gstrings, sizeof(rtl8169_gstrings)); 183925e992a4SHeiner Kallweit break; 184025e992a4SHeiner Kallweit } 184125e992a4SHeiner Kallweit } 184225e992a4SHeiner Kallweit 184325e992a4SHeiner Kallweit /* 184425e992a4SHeiner Kallweit * Interrupt coalescing 184525e992a4SHeiner Kallweit * 184625e992a4SHeiner Kallweit * > 1 - the availability of the IntrMitigate (0xe2) register through the 184725e992a4SHeiner Kallweit * > 8169, 8168 and 810x line of chipsets 184825e992a4SHeiner Kallweit * 184925e992a4SHeiner Kallweit * 8169, 8168, and 8136(810x) serial chipsets support it. 185025e992a4SHeiner Kallweit * 185125e992a4SHeiner Kallweit * > 2 - the Tx timer unit at gigabit speed 185225e992a4SHeiner Kallweit * 185325e992a4SHeiner Kallweit * The unit of the timer depends on both the speed and the setting of CPlusCmd 185425e992a4SHeiner Kallweit * (0xe0) bit 1 and bit 0. 185525e992a4SHeiner Kallweit * 185625e992a4SHeiner Kallweit * For 8169 185725e992a4SHeiner Kallweit * bit[1:0] \ speed 1000M 100M 10M 185825e992a4SHeiner Kallweit * 0 0 320ns 2.56us 40.96us 185925e992a4SHeiner Kallweit * 0 1 2.56us 20.48us 327.7us 186025e992a4SHeiner Kallweit * 1 0 5.12us 40.96us 655.4us 186125e992a4SHeiner Kallweit * 1 1 10.24us 81.92us 1.31ms 186225e992a4SHeiner Kallweit * 186325e992a4SHeiner Kallweit * For the other 186425e992a4SHeiner Kallweit * bit[1:0] \ speed 1000M 100M 10M 186525e992a4SHeiner Kallweit * 0 0 5us 2.56us 40.96us 186625e992a4SHeiner Kallweit * 0 1 40us 20.48us 327.7us 186725e992a4SHeiner Kallweit * 1 0 80us 40.96us 655.4us 186825e992a4SHeiner Kallweit * 1 1 160us 81.92us 1.31ms 186925e992a4SHeiner Kallweit */ 187025e992a4SHeiner Kallweit 187125e992a4SHeiner Kallweit /* rx/tx scale factors for one particular CPlusCmd[0:1] value */ 187225e992a4SHeiner Kallweit struct rtl_coalesce_scale { 187325e992a4SHeiner Kallweit /* Rx / Tx */ 187425e992a4SHeiner Kallweit u32 nsecs[2]; 187525e992a4SHeiner Kallweit }; 187625e992a4SHeiner Kallweit 187725e992a4SHeiner Kallweit /* rx/tx scale factors for all CPlusCmd[0:1] cases */ 187825e992a4SHeiner Kallweit struct rtl_coalesce_info { 187925e992a4SHeiner Kallweit u32 speed; 188025e992a4SHeiner Kallweit struct rtl_coalesce_scale scalev[4]; /* each CPlusCmd[0:1] case */ 188125e992a4SHeiner Kallweit }; 188225e992a4SHeiner Kallweit 188325e992a4SHeiner Kallweit /* produce (r,t) pairs with each being in series of *1, *8, *8*2, *8*2*2 */ 188425e992a4SHeiner Kallweit #define rxtx_x1822(r, t) { \ 188525e992a4SHeiner Kallweit {{(r), (t)}}, \ 188625e992a4SHeiner Kallweit {{(r)*8, (t)*8}}, \ 188725e992a4SHeiner Kallweit {{(r)*8*2, (t)*8*2}}, \ 188825e992a4SHeiner Kallweit {{(r)*8*2*2, (t)*8*2*2}}, \ 188925e992a4SHeiner Kallweit } 189025e992a4SHeiner Kallweit static const struct rtl_coalesce_info rtl_coalesce_info_8169[] = { 189125e992a4SHeiner Kallweit /* speed delays: rx00 tx00 */ 189225e992a4SHeiner Kallweit { SPEED_10, rxtx_x1822(40960, 40960) }, 189325e992a4SHeiner Kallweit { SPEED_100, rxtx_x1822( 2560, 2560) }, 189425e992a4SHeiner Kallweit { SPEED_1000, rxtx_x1822( 320, 320) }, 189525e992a4SHeiner Kallweit { 0 }, 189625e992a4SHeiner Kallweit }; 189725e992a4SHeiner Kallweit 189825e992a4SHeiner Kallweit static const struct rtl_coalesce_info rtl_coalesce_info_8168_8136[] = { 189925e992a4SHeiner Kallweit /* speed delays: rx00 tx00 */ 190025e992a4SHeiner Kallweit { SPEED_10, rxtx_x1822(40960, 40960) }, 190125e992a4SHeiner Kallweit { SPEED_100, rxtx_x1822( 2560, 2560) }, 190225e992a4SHeiner Kallweit { SPEED_1000, rxtx_x1822( 5000, 5000) }, 190325e992a4SHeiner Kallweit { 0 }, 190425e992a4SHeiner Kallweit }; 190525e992a4SHeiner Kallweit #undef rxtx_x1822 190625e992a4SHeiner Kallweit 190725e992a4SHeiner Kallweit /* get rx/tx scale vector corresponding to current speed */ 190825e992a4SHeiner Kallweit static const struct rtl_coalesce_info *rtl_coalesce_info(struct net_device *dev) 190925e992a4SHeiner Kallweit { 191025e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 191125e992a4SHeiner Kallweit const struct rtl_coalesce_info *ci; 191225e992a4SHeiner Kallweit 191320023d3eSHeiner Kallweit if (tp->mac_version <= RTL_GIGA_MAC_VER_06) 191420023d3eSHeiner Kallweit ci = rtl_coalesce_info_8169; 191520023d3eSHeiner Kallweit else 191620023d3eSHeiner Kallweit ci = rtl_coalesce_info_8168_8136; 191725e992a4SHeiner Kallweit 191820023d3eSHeiner Kallweit for (; ci->speed; ci++) { 191920023d3eSHeiner Kallweit if (tp->phydev->speed == ci->speed) 192025e992a4SHeiner Kallweit return ci; 192125e992a4SHeiner Kallweit } 192225e992a4SHeiner Kallweit 192325e992a4SHeiner Kallweit return ERR_PTR(-ELNRNG); 192425e992a4SHeiner Kallweit } 192525e992a4SHeiner Kallweit 192625e992a4SHeiner Kallweit static int rtl_get_coalesce(struct net_device *dev, struct ethtool_coalesce *ec) 192725e992a4SHeiner Kallweit { 192825e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 192925e992a4SHeiner Kallweit const struct rtl_coalesce_info *ci; 193025e992a4SHeiner Kallweit const struct rtl_coalesce_scale *scale; 193125e992a4SHeiner Kallweit struct { 193225e992a4SHeiner Kallweit u32 *max_frames; 193325e992a4SHeiner Kallweit u32 *usecs; 193425e992a4SHeiner Kallweit } coal_settings [] = { 193525e992a4SHeiner Kallweit { &ec->rx_max_coalesced_frames, &ec->rx_coalesce_usecs }, 193625e992a4SHeiner Kallweit { &ec->tx_max_coalesced_frames, &ec->tx_coalesce_usecs } 193725e992a4SHeiner Kallweit }, *p = coal_settings; 193825e992a4SHeiner Kallweit int i; 193925e992a4SHeiner Kallweit u16 w; 194025e992a4SHeiner Kallweit 1941f1bce4adSHeiner Kallweit if (rtl_is_8125(tp)) 1942f1bce4adSHeiner Kallweit return -EOPNOTSUPP; 1943f1bce4adSHeiner Kallweit 194425e992a4SHeiner Kallweit memset(ec, 0, sizeof(*ec)); 194525e992a4SHeiner Kallweit 194625e992a4SHeiner Kallweit /* get rx/tx scale corresponding to current speed and CPlusCmd[0:1] */ 194725e992a4SHeiner Kallweit ci = rtl_coalesce_info(dev); 194825e992a4SHeiner Kallweit if (IS_ERR(ci)) 194925e992a4SHeiner Kallweit return PTR_ERR(ci); 195025e992a4SHeiner Kallweit 195125e992a4SHeiner Kallweit scale = &ci->scalev[tp->cp_cmd & INTT_MASK]; 195225e992a4SHeiner Kallweit 195325e992a4SHeiner Kallweit /* read IntrMitigate and adjust according to scale */ 195425e992a4SHeiner Kallweit for (w = RTL_R16(tp, IntrMitigate); w; w >>= RTL_COALESCE_SHIFT, p++) { 195525e992a4SHeiner Kallweit *p->max_frames = (w & RTL_COALESCE_MASK) << 2; 195625e992a4SHeiner Kallweit w >>= RTL_COALESCE_SHIFT; 195725e992a4SHeiner Kallweit *p->usecs = w & RTL_COALESCE_MASK; 195825e992a4SHeiner Kallweit } 195925e992a4SHeiner Kallweit 196025e992a4SHeiner Kallweit for (i = 0; i < 2; i++) { 196125e992a4SHeiner Kallweit p = coal_settings + i; 196225e992a4SHeiner Kallweit *p->usecs = (*p->usecs * scale->nsecs[i]) / 1000; 196325e992a4SHeiner Kallweit 196425e992a4SHeiner Kallweit /* 196525e992a4SHeiner Kallweit * ethtool_coalesce says it is illegal to set both usecs and 196625e992a4SHeiner Kallweit * max_frames to 0. 196725e992a4SHeiner Kallweit */ 196825e992a4SHeiner Kallweit if (!*p->usecs && !*p->max_frames) 196925e992a4SHeiner Kallweit *p->max_frames = 1; 197025e992a4SHeiner Kallweit } 197125e992a4SHeiner Kallweit 197225e992a4SHeiner Kallweit return 0; 197325e992a4SHeiner Kallweit } 197425e992a4SHeiner Kallweit 197525e992a4SHeiner Kallweit /* choose appropriate scale factor and CPlusCmd[0:1] for (speed, nsec) */ 197625e992a4SHeiner Kallweit static const struct rtl_coalesce_scale *rtl_coalesce_choose_scale( 197725e992a4SHeiner Kallweit struct net_device *dev, u32 nsec, u16 *cp01) 197825e992a4SHeiner Kallweit { 197925e992a4SHeiner Kallweit const struct rtl_coalesce_info *ci; 198025e992a4SHeiner Kallweit u16 i; 198125e992a4SHeiner Kallweit 198225e992a4SHeiner Kallweit ci = rtl_coalesce_info(dev); 198325e992a4SHeiner Kallweit if (IS_ERR(ci)) 198425e992a4SHeiner Kallweit return ERR_CAST(ci); 198525e992a4SHeiner Kallweit 198625e992a4SHeiner Kallweit for (i = 0; i < 4; i++) { 198725e992a4SHeiner Kallweit u32 rxtx_maxscale = max(ci->scalev[i].nsecs[0], 198825e992a4SHeiner Kallweit ci->scalev[i].nsecs[1]); 198925e992a4SHeiner Kallweit if (nsec <= rxtx_maxscale * RTL_COALESCE_T_MAX) { 199025e992a4SHeiner Kallweit *cp01 = i; 199125e992a4SHeiner Kallweit return &ci->scalev[i]; 199225e992a4SHeiner Kallweit } 199325e992a4SHeiner Kallweit } 199425e992a4SHeiner Kallweit 199525e992a4SHeiner Kallweit return ERR_PTR(-EINVAL); 199625e992a4SHeiner Kallweit } 199725e992a4SHeiner Kallweit 199825e992a4SHeiner Kallweit static int rtl_set_coalesce(struct net_device *dev, struct ethtool_coalesce *ec) 199925e992a4SHeiner Kallweit { 200025e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 200125e992a4SHeiner Kallweit const struct rtl_coalesce_scale *scale; 200225e992a4SHeiner Kallweit struct { 200325e992a4SHeiner Kallweit u32 frames; 200425e992a4SHeiner Kallweit u32 usecs; 200525e992a4SHeiner Kallweit } coal_settings [] = { 200625e992a4SHeiner Kallweit { ec->rx_max_coalesced_frames, ec->rx_coalesce_usecs }, 200725e992a4SHeiner Kallweit { ec->tx_max_coalesced_frames, ec->tx_coalesce_usecs } 200825e992a4SHeiner Kallweit }, *p = coal_settings; 200925e992a4SHeiner Kallweit u16 w = 0, cp01; 201025e992a4SHeiner Kallweit int i; 201125e992a4SHeiner Kallweit 2012f1bce4adSHeiner Kallweit if (rtl_is_8125(tp)) 2013f1bce4adSHeiner Kallweit return -EOPNOTSUPP; 2014f1bce4adSHeiner Kallweit 201525e992a4SHeiner Kallweit scale = rtl_coalesce_choose_scale(dev, 201625e992a4SHeiner Kallweit max(p[0].usecs, p[1].usecs) * 1000, &cp01); 201725e992a4SHeiner Kallweit if (IS_ERR(scale)) 201825e992a4SHeiner Kallweit return PTR_ERR(scale); 201925e992a4SHeiner Kallweit 202025e992a4SHeiner Kallweit for (i = 0; i < 2; i++, p++) { 202125e992a4SHeiner Kallweit u32 units; 202225e992a4SHeiner Kallweit 202325e992a4SHeiner Kallweit /* 202425e992a4SHeiner Kallweit * accept max_frames=1 we returned in rtl_get_coalesce. 202525e992a4SHeiner Kallweit * accept it not only when usecs=0 because of e.g. the following scenario: 202625e992a4SHeiner Kallweit * 202725e992a4SHeiner Kallweit * - both rx_usecs=0 & rx_frames=0 in hardware (no delay on RX) 202825e992a4SHeiner Kallweit * - rtl_get_coalesce returns rx_usecs=0, rx_frames=1 202925e992a4SHeiner Kallweit * - then user does `ethtool -C eth0 rx-usecs 100` 203025e992a4SHeiner Kallweit * 203125e992a4SHeiner Kallweit * since ethtool sends to kernel whole ethtool_coalesce 203225e992a4SHeiner Kallweit * settings, if we do not handle rx_usecs=!0, rx_frames=1 203325e992a4SHeiner Kallweit * we'll reject it below in `frames % 4 != 0`. 203425e992a4SHeiner Kallweit */ 203525e992a4SHeiner Kallweit if (p->frames == 1) { 203625e992a4SHeiner Kallweit p->frames = 0; 203725e992a4SHeiner Kallweit } 203825e992a4SHeiner Kallweit 203925e992a4SHeiner Kallweit units = p->usecs * 1000 / scale->nsecs[i]; 204025e992a4SHeiner Kallweit if (p->frames > RTL_COALESCE_FRAME_MAX || p->frames % 4) 204125e992a4SHeiner Kallweit return -EINVAL; 204225e992a4SHeiner Kallweit 204325e992a4SHeiner Kallweit w <<= RTL_COALESCE_SHIFT; 204425e992a4SHeiner Kallweit w |= units; 204525e992a4SHeiner Kallweit w <<= RTL_COALESCE_SHIFT; 204625e992a4SHeiner Kallweit w |= p->frames >> 2; 204725e992a4SHeiner Kallweit } 204825e992a4SHeiner Kallweit 204925e992a4SHeiner Kallweit rtl_lock_work(tp); 205025e992a4SHeiner Kallweit 205125e992a4SHeiner Kallweit RTL_W16(tp, IntrMitigate, swab16(w)); 205225e992a4SHeiner Kallweit 205325e992a4SHeiner Kallweit tp->cp_cmd = (tp->cp_cmd & ~INTT_MASK) | cp01; 205425e992a4SHeiner Kallweit RTL_W16(tp, CPlusCmd, tp->cp_cmd); 205525e992a4SHeiner Kallweit RTL_R16(tp, CPlusCmd); 205625e992a4SHeiner Kallweit 205725e992a4SHeiner Kallweit rtl_unlock_work(tp); 205825e992a4SHeiner Kallweit 205925e992a4SHeiner Kallweit return 0; 206025e992a4SHeiner Kallweit } 206125e992a4SHeiner Kallweit 206225e992a4SHeiner Kallweit static int rtl8169_get_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 ret; 206725e992a4SHeiner Kallweit 20682e779ddbSHeiner Kallweit if (!rtl_supports_eee(tp)) 20692e779ddbSHeiner Kallweit return -EOPNOTSUPP; 20702e779ddbSHeiner Kallweit 207125e992a4SHeiner Kallweit pm_runtime_get_noresume(d); 207225e992a4SHeiner Kallweit 207325e992a4SHeiner Kallweit if (!pm_runtime_active(d)) { 207425e992a4SHeiner Kallweit ret = -EOPNOTSUPP; 20752e779ddbSHeiner Kallweit } else { 20762e779ddbSHeiner Kallweit ret = phy_ethtool_get_eee(tp->phydev, data); 207725e992a4SHeiner Kallweit } 207825e992a4SHeiner Kallweit 207925e992a4SHeiner Kallweit pm_runtime_put_noidle(d); 20802e779ddbSHeiner Kallweit 20812e779ddbSHeiner Kallweit return ret; 208225e992a4SHeiner Kallweit } 208325e992a4SHeiner Kallweit 208425e992a4SHeiner Kallweit static int rtl8169_set_eee(struct net_device *dev, struct ethtool_eee *data) 208525e992a4SHeiner Kallweit { 208625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 208725e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 20882e779ddbSHeiner Kallweit int ret; 20892e779ddbSHeiner Kallweit 20902e779ddbSHeiner Kallweit if (!rtl_supports_eee(tp)) 20912e779ddbSHeiner Kallweit return -EOPNOTSUPP; 209225e992a4SHeiner Kallweit 209325e992a4SHeiner Kallweit pm_runtime_get_noresume(d); 209425e992a4SHeiner Kallweit 20952e779ddbSHeiner Kallweit if (!pm_runtime_active(d)) { 209625e992a4SHeiner Kallweit ret = -EOPNOTSUPP; 209725e992a4SHeiner Kallweit goto out; 209825e992a4SHeiner Kallweit } 209925e992a4SHeiner Kallweit 210025e992a4SHeiner Kallweit if (dev->phydev->autoneg == AUTONEG_DISABLE || 210125e992a4SHeiner Kallweit dev->phydev->duplex != DUPLEX_FULL) { 210225e992a4SHeiner Kallweit ret = -EPROTONOSUPPORT; 210325e992a4SHeiner Kallweit goto out; 210425e992a4SHeiner Kallweit } 210525e992a4SHeiner Kallweit 21062e779ddbSHeiner Kallweit ret = phy_ethtool_set_eee(tp->phydev, data); 21077ec3f872SHeiner Kallweit 21087ec3f872SHeiner Kallweit if (!ret) 21097ec3f872SHeiner Kallweit tp->eee_adv = phy_read_mmd(dev->phydev, MDIO_MMD_AN, 21107ec3f872SHeiner Kallweit MDIO_AN_EEE_ADV); 211125e992a4SHeiner Kallweit out: 211225e992a4SHeiner Kallweit pm_runtime_put_noidle(d); 21132e779ddbSHeiner Kallweit return ret; 211425e992a4SHeiner Kallweit } 211525e992a4SHeiner Kallweit 211625e992a4SHeiner Kallweit static const struct ethtool_ops rtl8169_ethtool_ops = { 211725e992a4SHeiner Kallweit .get_drvinfo = rtl8169_get_drvinfo, 211825e992a4SHeiner Kallweit .get_regs_len = rtl8169_get_regs_len, 211925e992a4SHeiner Kallweit .get_link = ethtool_op_get_link, 212025e992a4SHeiner Kallweit .get_coalesce = rtl_get_coalesce, 212125e992a4SHeiner Kallweit .set_coalesce = rtl_set_coalesce, 212225e992a4SHeiner Kallweit .get_msglevel = rtl8169_get_msglevel, 212325e992a4SHeiner Kallweit .set_msglevel = rtl8169_set_msglevel, 212425e992a4SHeiner Kallweit .get_regs = rtl8169_get_regs, 212525e992a4SHeiner Kallweit .get_wol = rtl8169_get_wol, 212625e992a4SHeiner Kallweit .set_wol = rtl8169_set_wol, 212725e992a4SHeiner Kallweit .get_strings = rtl8169_get_strings, 212825e992a4SHeiner Kallweit .get_sset_count = rtl8169_get_sset_count, 212925e992a4SHeiner Kallweit .get_ethtool_stats = rtl8169_get_ethtool_stats, 213025e992a4SHeiner Kallweit .get_ts_info = ethtool_op_get_ts_info, 213125e992a4SHeiner Kallweit .nway_reset = phy_ethtool_nway_reset, 213225e992a4SHeiner Kallweit .get_eee = rtl8169_get_eee, 213325e992a4SHeiner Kallweit .set_eee = rtl8169_set_eee, 213425e992a4SHeiner Kallweit .get_link_ksettings = phy_ethtool_get_link_ksettings, 213525e992a4SHeiner Kallweit .set_link_ksettings = phy_ethtool_set_link_ksettings, 213625e992a4SHeiner Kallweit }; 213725e992a4SHeiner Kallweit 213825e992a4SHeiner Kallweit static void rtl_enable_eee(struct rtl8169_private *tp) 213925e992a4SHeiner Kallweit { 21402e779ddbSHeiner Kallweit struct phy_device *phydev = tp->phydev; 21417ec3f872SHeiner Kallweit int adv; 214225e992a4SHeiner Kallweit 21437ec3f872SHeiner Kallweit /* respect EEE advertisement the user may have set */ 21447ec3f872SHeiner Kallweit if (tp->eee_adv >= 0) 21457ec3f872SHeiner Kallweit adv = tp->eee_adv; 21467ec3f872SHeiner Kallweit else 21477ec3f872SHeiner Kallweit adv = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE); 21487ec3f872SHeiner Kallweit 21497ec3f872SHeiner Kallweit if (adv >= 0) 21507ec3f872SHeiner Kallweit phy_write_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV, adv); 215125e992a4SHeiner Kallweit } 215225e992a4SHeiner Kallweit 215325e992a4SHeiner Kallweit static void rtl8169_get_mac_version(struct rtl8169_private *tp) 215425e992a4SHeiner Kallweit { 215525e992a4SHeiner Kallweit /* 215625e992a4SHeiner Kallweit * The driver currently handles the 8168Bf and the 8168Be identically 215725e992a4SHeiner Kallweit * but they can be identified more specifically through the test below 215825e992a4SHeiner Kallweit * if needed: 215925e992a4SHeiner Kallweit * 216025e992a4SHeiner Kallweit * (RTL_R32(tp, TxConfig) & 0x700000) == 0x500000 ? 8168Bf : 8168Be 216125e992a4SHeiner Kallweit * 216225e992a4SHeiner Kallweit * Same thing for the 8101Eb and the 8101Ec: 216325e992a4SHeiner Kallweit * 216425e992a4SHeiner Kallweit * (RTL_R32(tp, TxConfig) & 0x700000) == 0x200000 ? 8101Eb : 8101Ec 216525e992a4SHeiner Kallweit */ 216625e992a4SHeiner Kallweit static const struct rtl_mac_info { 216725e992a4SHeiner Kallweit u16 mask; 216825e992a4SHeiner Kallweit u16 val; 216925e992a4SHeiner Kallweit u16 mac_version; 217025e992a4SHeiner Kallweit } mac_info[] = { 2171f1bce4adSHeiner Kallweit /* 8125 family. */ 2172f1bce4adSHeiner Kallweit { 0x7cf, 0x608, RTL_GIGA_MAC_VER_60 }, 2173f1bce4adSHeiner Kallweit { 0x7c8, 0x608, RTL_GIGA_MAC_VER_61 }, 2174f1bce4adSHeiner Kallweit 21751287723aSHeiner Kallweit /* RTL8117 */ 21761287723aSHeiner Kallweit { 0x7cf, 0x54a, RTL_GIGA_MAC_VER_52 }, 21771287723aSHeiner Kallweit 217825e992a4SHeiner Kallweit /* 8168EP family. */ 217925e992a4SHeiner Kallweit { 0x7cf, 0x502, RTL_GIGA_MAC_VER_51 }, 218025e992a4SHeiner Kallweit { 0x7cf, 0x501, RTL_GIGA_MAC_VER_50 }, 218125e992a4SHeiner Kallweit { 0x7cf, 0x500, RTL_GIGA_MAC_VER_49 }, 218225e992a4SHeiner Kallweit 218325e992a4SHeiner Kallweit /* 8168H family. */ 218425e992a4SHeiner Kallweit { 0x7cf, 0x541, RTL_GIGA_MAC_VER_46 }, 218525e992a4SHeiner Kallweit { 0x7cf, 0x540, RTL_GIGA_MAC_VER_45 }, 218625e992a4SHeiner Kallweit 218725e992a4SHeiner Kallweit /* 8168G family. */ 218825e992a4SHeiner Kallweit { 0x7cf, 0x5c8, RTL_GIGA_MAC_VER_44 }, 218925e992a4SHeiner Kallweit { 0x7cf, 0x509, RTL_GIGA_MAC_VER_42 }, 219025e992a4SHeiner Kallweit { 0x7cf, 0x4c1, RTL_GIGA_MAC_VER_41 }, 219125e992a4SHeiner Kallweit { 0x7cf, 0x4c0, RTL_GIGA_MAC_VER_40 }, 219225e992a4SHeiner Kallweit 219325e992a4SHeiner Kallweit /* 8168F family. */ 219425e992a4SHeiner Kallweit { 0x7c8, 0x488, RTL_GIGA_MAC_VER_38 }, 219525e992a4SHeiner Kallweit { 0x7cf, 0x481, RTL_GIGA_MAC_VER_36 }, 219625e992a4SHeiner Kallweit { 0x7cf, 0x480, RTL_GIGA_MAC_VER_35 }, 219725e992a4SHeiner Kallweit 219825e992a4SHeiner Kallweit /* 8168E family. */ 219925e992a4SHeiner Kallweit { 0x7c8, 0x2c8, RTL_GIGA_MAC_VER_34 }, 220025e992a4SHeiner Kallweit { 0x7cf, 0x2c1, RTL_GIGA_MAC_VER_32 }, 220125e992a4SHeiner Kallweit { 0x7c8, 0x2c0, RTL_GIGA_MAC_VER_33 }, 220225e992a4SHeiner Kallweit 220325e992a4SHeiner Kallweit /* 8168D family. */ 220425e992a4SHeiner Kallweit { 0x7cf, 0x281, RTL_GIGA_MAC_VER_25 }, 220525e992a4SHeiner Kallweit { 0x7c8, 0x280, RTL_GIGA_MAC_VER_26 }, 220625e992a4SHeiner Kallweit 220725e992a4SHeiner Kallweit /* 8168DP family. */ 220825e992a4SHeiner Kallweit { 0x7cf, 0x288, RTL_GIGA_MAC_VER_27 }, 220925e992a4SHeiner Kallweit { 0x7cf, 0x28a, RTL_GIGA_MAC_VER_28 }, 221025e992a4SHeiner Kallweit { 0x7cf, 0x28b, RTL_GIGA_MAC_VER_31 }, 221125e992a4SHeiner Kallweit 221225e992a4SHeiner Kallweit /* 8168C family. */ 221325e992a4SHeiner Kallweit { 0x7cf, 0x3c9, RTL_GIGA_MAC_VER_23 }, 221425e992a4SHeiner Kallweit { 0x7cf, 0x3c8, RTL_GIGA_MAC_VER_18 }, 221525e992a4SHeiner Kallweit { 0x7c8, 0x3c8, RTL_GIGA_MAC_VER_24 }, 221625e992a4SHeiner Kallweit { 0x7cf, 0x3c0, RTL_GIGA_MAC_VER_19 }, 221725e992a4SHeiner Kallweit { 0x7cf, 0x3c2, RTL_GIGA_MAC_VER_20 }, 221825e992a4SHeiner Kallweit { 0x7cf, 0x3c3, RTL_GIGA_MAC_VER_21 }, 221925e992a4SHeiner Kallweit { 0x7c8, 0x3c0, RTL_GIGA_MAC_VER_22 }, 222025e992a4SHeiner Kallweit 222125e992a4SHeiner Kallweit /* 8168B family. */ 222225e992a4SHeiner Kallweit { 0x7cf, 0x380, RTL_GIGA_MAC_VER_12 }, 222325e992a4SHeiner Kallweit { 0x7c8, 0x380, RTL_GIGA_MAC_VER_17 }, 222425e992a4SHeiner Kallweit { 0x7c8, 0x300, RTL_GIGA_MAC_VER_11 }, 222525e992a4SHeiner Kallweit 222625e992a4SHeiner Kallweit /* 8101 family. */ 222725e992a4SHeiner Kallweit { 0x7c8, 0x448, RTL_GIGA_MAC_VER_39 }, 222825e992a4SHeiner Kallweit { 0x7c8, 0x440, RTL_GIGA_MAC_VER_37 }, 222925e992a4SHeiner Kallweit { 0x7cf, 0x409, RTL_GIGA_MAC_VER_29 }, 223025e992a4SHeiner Kallweit { 0x7c8, 0x408, RTL_GIGA_MAC_VER_30 }, 223125e992a4SHeiner Kallweit { 0x7cf, 0x349, RTL_GIGA_MAC_VER_08 }, 223225e992a4SHeiner Kallweit { 0x7cf, 0x249, RTL_GIGA_MAC_VER_08 }, 223325e992a4SHeiner Kallweit { 0x7cf, 0x348, RTL_GIGA_MAC_VER_07 }, 223425e992a4SHeiner Kallweit { 0x7cf, 0x248, RTL_GIGA_MAC_VER_07 }, 223525e992a4SHeiner Kallweit { 0x7cf, 0x340, RTL_GIGA_MAC_VER_13 }, 223625e992a4SHeiner Kallweit { 0x7cf, 0x343, RTL_GIGA_MAC_VER_10 }, 223725e992a4SHeiner Kallweit { 0x7cf, 0x342, RTL_GIGA_MAC_VER_16 }, 223825e992a4SHeiner Kallweit { 0x7c8, 0x348, RTL_GIGA_MAC_VER_09 }, 223925e992a4SHeiner Kallweit { 0x7c8, 0x248, RTL_GIGA_MAC_VER_09 }, 224025e992a4SHeiner Kallweit { 0x7c8, 0x340, RTL_GIGA_MAC_VER_16 }, 224125e992a4SHeiner Kallweit /* FIXME: where did these entries come from ? -- FR */ 224225e992a4SHeiner Kallweit { 0xfc8, 0x388, RTL_GIGA_MAC_VER_15 }, 224325e992a4SHeiner Kallweit { 0xfc8, 0x308, RTL_GIGA_MAC_VER_14 }, 224425e992a4SHeiner Kallweit 224525e992a4SHeiner Kallweit /* 8110 family. */ 224625e992a4SHeiner Kallweit { 0xfc8, 0x980, RTL_GIGA_MAC_VER_06 }, 224725e992a4SHeiner Kallweit { 0xfc8, 0x180, RTL_GIGA_MAC_VER_05 }, 224825e992a4SHeiner Kallweit { 0xfc8, 0x100, RTL_GIGA_MAC_VER_04 }, 224925e992a4SHeiner Kallweit { 0xfc8, 0x040, RTL_GIGA_MAC_VER_03 }, 225025e992a4SHeiner Kallweit { 0xfc8, 0x008, RTL_GIGA_MAC_VER_02 }, 225125e992a4SHeiner Kallweit 225225e992a4SHeiner Kallweit /* Catch-all */ 225325e992a4SHeiner Kallweit { 0x000, 0x000, RTL_GIGA_MAC_NONE } 225425e992a4SHeiner Kallweit }; 225525e992a4SHeiner Kallweit const struct rtl_mac_info *p = mac_info; 225625e992a4SHeiner Kallweit u16 reg = RTL_R32(tp, TxConfig) >> 20; 225725e992a4SHeiner Kallweit 225825e992a4SHeiner Kallweit while ((reg & p->mask) != p->val) 225925e992a4SHeiner Kallweit p++; 226025e992a4SHeiner Kallweit tp->mac_version = p->mac_version; 226125e992a4SHeiner Kallweit 226225e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_NONE) { 226325e992a4SHeiner Kallweit dev_err(tp_to_dev(tp), "unknown chip XID %03x\n", reg & 0xfcf); 226425e992a4SHeiner Kallweit } else if (!tp->supports_gmii) { 226525e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_42) 226625e992a4SHeiner Kallweit tp->mac_version = RTL_GIGA_MAC_VER_43; 226725e992a4SHeiner Kallweit else if (tp->mac_version == RTL_GIGA_MAC_VER_45) 226825e992a4SHeiner Kallweit tp->mac_version = RTL_GIGA_MAC_VER_47; 226925e992a4SHeiner Kallweit else if (tp->mac_version == RTL_GIGA_MAC_VER_46) 227025e992a4SHeiner Kallweit tp->mac_version = RTL_GIGA_MAC_VER_48; 227125e992a4SHeiner Kallweit } 227225e992a4SHeiner Kallweit } 227325e992a4SHeiner Kallweit 227425e992a4SHeiner Kallweit struct phy_reg { 227525e992a4SHeiner Kallweit u16 reg; 227625e992a4SHeiner Kallweit u16 val; 227725e992a4SHeiner Kallweit }; 227825e992a4SHeiner Kallweit 227925e992a4SHeiner Kallweit static void __rtl_writephy_batch(struct rtl8169_private *tp, 228025e992a4SHeiner Kallweit const struct phy_reg *regs, int len) 228125e992a4SHeiner Kallweit { 228225e992a4SHeiner Kallweit while (len-- > 0) { 228325e992a4SHeiner Kallweit rtl_writephy(tp, regs->reg, regs->val); 228425e992a4SHeiner Kallweit regs++; 228525e992a4SHeiner Kallweit } 228625e992a4SHeiner Kallweit } 228725e992a4SHeiner Kallweit 228825e992a4SHeiner Kallweit #define rtl_writephy_batch(tp, a) __rtl_writephy_batch(tp, a, ARRAY_SIZE(a)) 228925e992a4SHeiner Kallweit 229025e992a4SHeiner Kallweit static void rtl_release_firmware(struct rtl8169_private *tp) 229125e992a4SHeiner Kallweit { 229225e992a4SHeiner Kallweit if (tp->rtl_fw) { 229325e992a4SHeiner Kallweit rtl_fw_release_firmware(tp->rtl_fw); 229425e992a4SHeiner Kallweit kfree(tp->rtl_fw); 229525e992a4SHeiner Kallweit tp->rtl_fw = NULL; 229625e992a4SHeiner Kallweit } 229725e992a4SHeiner Kallweit } 229825e992a4SHeiner Kallweit 229925e992a4SHeiner Kallweit static void rtl_apply_firmware(struct rtl8169_private *tp) 230025e992a4SHeiner Kallweit { 230125e992a4SHeiner Kallweit /* TODO: release firmware if rtl_fw_write_firmware signals failure. */ 230225e992a4SHeiner Kallweit if (tp->rtl_fw) 230325e992a4SHeiner Kallweit rtl_fw_write_firmware(tp, tp->rtl_fw); 230425e992a4SHeiner Kallweit } 230525e992a4SHeiner Kallweit 230625e992a4SHeiner Kallweit static void rtl8168_config_eee_mac(struct rtl8169_private *tp) 230725e992a4SHeiner Kallweit { 230825e992a4SHeiner Kallweit /* Adjust EEE LED frequency */ 230925e992a4SHeiner Kallweit if (tp->mac_version != RTL_GIGA_MAC_VER_38) 231025e992a4SHeiner Kallweit RTL_W8(tp, EEE_LED, RTL_R8(tp, EEE_LED) & ~0x07); 231125e992a4SHeiner Kallweit 231225e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0x1b0, ERIAR_MASK_1111, 0x0003); 231325e992a4SHeiner Kallweit } 231425e992a4SHeiner Kallweit 2315b3a42e3aSHeiner Kallweit static void rtl8125_config_eee_mac(struct rtl8169_private *tp) 2316b3a42e3aSHeiner Kallweit { 2317b3a42e3aSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe040, 0, BIT(1) | BIT(0)); 2318b3a42e3aSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xeb62, 0, BIT(2) | BIT(1)); 2319b3a42e3aSHeiner Kallweit } 2320b3a42e3aSHeiner Kallweit 232125e992a4SHeiner Kallweit static void rtl8168f_config_eee_phy(struct rtl8169_private *tp) 232225e992a4SHeiner Kallweit { 232325e992a4SHeiner Kallweit struct phy_device *phydev = tp->phydev; 232425e992a4SHeiner Kallweit 2325d0db136fSHeiner Kallweit r8168d_modify_extpage(phydev, 0x0020, 0x15, 0, BIT(8)); 2326b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b85, 0, BIT(13)); 232725e992a4SHeiner Kallweit } 232825e992a4SHeiner Kallweit 232925e992a4SHeiner Kallweit static void rtl8168g_config_eee_phy(struct rtl8169_private *tp) 233025e992a4SHeiner Kallweit { 233125e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0a43, 0x11, 0, BIT(4)); 233225e992a4SHeiner Kallweit } 233325e992a4SHeiner Kallweit 2334b6cef26fSHeiner Kallweit static void rtl8168h_config_eee_phy(struct rtl8169_private *tp) 2335b6cef26fSHeiner Kallweit { 2336b6cef26fSHeiner Kallweit struct phy_device *phydev = tp->phydev; 2337b6cef26fSHeiner Kallweit 2338b6cef26fSHeiner Kallweit rtl8168g_config_eee_phy(tp); 2339b6cef26fSHeiner Kallweit 2340b6cef26fSHeiner Kallweit phy_modify_paged(phydev, 0xa4a, 0x11, 0x0000, 0x0200); 2341b6cef26fSHeiner Kallweit phy_modify_paged(phydev, 0xa42, 0x14, 0x0000, 0x0080); 2342b6cef26fSHeiner Kallweit } 2343b6cef26fSHeiner Kallweit 2344b3a42e3aSHeiner Kallweit static void rtl8125_config_eee_phy(struct rtl8169_private *tp) 2345b3a42e3aSHeiner Kallweit { 2346b3a42e3aSHeiner Kallweit struct phy_device *phydev = tp->phydev; 2347b3a42e3aSHeiner Kallweit 2348b3a42e3aSHeiner Kallweit rtl8168h_config_eee_phy(tp); 2349b3a42e3aSHeiner Kallweit 2350b3a42e3aSHeiner Kallweit phy_modify_paged(phydev, 0xa6d, 0x12, 0x0001, 0x0000); 2351b3a42e3aSHeiner Kallweit phy_modify_paged(phydev, 0xa6d, 0x14, 0x0010, 0x0000); 2352b3a42e3aSHeiner Kallweit } 2353b3a42e3aSHeiner Kallweit 2354becd837eSHeiner Kallweit static void rtl8169s_hw_phy_config(struct rtl8169_private *tp, 2355becd837eSHeiner Kallweit struct phy_device *phydev) 235625e992a4SHeiner Kallweit { 235725e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 235825e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 235925e992a4SHeiner Kallweit { 0x06, 0x006e }, 236025e992a4SHeiner Kallweit { 0x08, 0x0708 }, 236125e992a4SHeiner Kallweit { 0x15, 0x4000 }, 236225e992a4SHeiner Kallweit { 0x18, 0x65c7 }, 236325e992a4SHeiner Kallweit 236425e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 236525e992a4SHeiner Kallweit { 0x03, 0x00a1 }, 236625e992a4SHeiner Kallweit { 0x02, 0x0008 }, 236725e992a4SHeiner Kallweit { 0x01, 0x0120 }, 236825e992a4SHeiner Kallweit { 0x00, 0x1000 }, 236925e992a4SHeiner Kallweit { 0x04, 0x0800 }, 237025e992a4SHeiner Kallweit { 0x04, 0x0000 }, 237125e992a4SHeiner Kallweit 237225e992a4SHeiner Kallweit { 0x03, 0xff41 }, 237325e992a4SHeiner Kallweit { 0x02, 0xdf60 }, 237425e992a4SHeiner Kallweit { 0x01, 0x0140 }, 237525e992a4SHeiner Kallweit { 0x00, 0x0077 }, 237625e992a4SHeiner Kallweit { 0x04, 0x7800 }, 237725e992a4SHeiner Kallweit { 0x04, 0x7000 }, 237825e992a4SHeiner Kallweit 237925e992a4SHeiner Kallweit { 0x03, 0x802f }, 238025e992a4SHeiner Kallweit { 0x02, 0x4f02 }, 238125e992a4SHeiner Kallweit { 0x01, 0x0409 }, 238225e992a4SHeiner Kallweit { 0x00, 0xf0f9 }, 238325e992a4SHeiner Kallweit { 0x04, 0x9800 }, 238425e992a4SHeiner Kallweit { 0x04, 0x9000 }, 238525e992a4SHeiner Kallweit 238625e992a4SHeiner Kallweit { 0x03, 0xdf01 }, 238725e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 238825e992a4SHeiner Kallweit { 0x01, 0xff95 }, 238925e992a4SHeiner Kallweit { 0x00, 0xba00 }, 239025e992a4SHeiner Kallweit { 0x04, 0xa800 }, 239125e992a4SHeiner Kallweit { 0x04, 0xa000 }, 239225e992a4SHeiner Kallweit 239325e992a4SHeiner Kallweit { 0x03, 0xff41 }, 239425e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 239525e992a4SHeiner Kallweit { 0x01, 0x0140 }, 239625e992a4SHeiner Kallweit { 0x00, 0x00bb }, 239725e992a4SHeiner Kallweit { 0x04, 0xb800 }, 239825e992a4SHeiner Kallweit { 0x04, 0xb000 }, 239925e992a4SHeiner Kallweit 240025e992a4SHeiner Kallweit { 0x03, 0xdf41 }, 240125e992a4SHeiner Kallweit { 0x02, 0xdc60 }, 240225e992a4SHeiner Kallweit { 0x01, 0x6340 }, 240325e992a4SHeiner Kallweit { 0x00, 0x007d }, 240425e992a4SHeiner Kallweit { 0x04, 0xd800 }, 240525e992a4SHeiner Kallweit { 0x04, 0xd000 }, 240625e992a4SHeiner Kallweit 240725e992a4SHeiner Kallweit { 0x03, 0xdf01 }, 240825e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 240925e992a4SHeiner Kallweit { 0x01, 0x100a }, 241025e992a4SHeiner Kallweit { 0x00, 0xa0ff }, 241125e992a4SHeiner Kallweit { 0x04, 0xf800 }, 241225e992a4SHeiner Kallweit { 0x04, 0xf000 }, 241325e992a4SHeiner Kallweit 241425e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 241525e992a4SHeiner Kallweit { 0x0b, 0x0000 }, 241625e992a4SHeiner Kallweit { 0x00, 0x9200 } 241725e992a4SHeiner Kallweit }; 241825e992a4SHeiner Kallweit 241925e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 242025e992a4SHeiner Kallweit } 242125e992a4SHeiner Kallweit 2422becd837eSHeiner Kallweit static void rtl8169sb_hw_phy_config(struct rtl8169_private *tp, 2423becd837eSHeiner Kallweit struct phy_device *phydev) 242425e992a4SHeiner Kallweit { 2425becd837eSHeiner Kallweit phy_write_paged(phydev, 0x0002, 0x01, 0x90d0); 242625e992a4SHeiner Kallweit } 242725e992a4SHeiner Kallweit 242825e992a4SHeiner Kallweit static void rtl8169scd_hw_phy_config_quirk(struct rtl8169_private *tp) 242925e992a4SHeiner Kallweit { 243025e992a4SHeiner Kallweit struct pci_dev *pdev = tp->pci_dev; 243125e992a4SHeiner Kallweit 243225e992a4SHeiner Kallweit if ((pdev->subsystem_vendor != PCI_VENDOR_ID_GIGABYTE) || 243325e992a4SHeiner Kallweit (pdev->subsystem_device != 0xe000)) 243425e992a4SHeiner Kallweit return; 243525e992a4SHeiner Kallweit 24363a129e3fSHeiner Kallweit phy_write_paged(tp->phydev, 0x0001, 0x10, 0xf01b); 243725e992a4SHeiner Kallweit } 243825e992a4SHeiner Kallweit 2439becd837eSHeiner Kallweit static void rtl8169scd_hw_phy_config(struct rtl8169_private *tp, 2440becd837eSHeiner Kallweit struct phy_device *phydev) 244125e992a4SHeiner Kallweit { 244225e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 244325e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 244425e992a4SHeiner Kallweit { 0x04, 0x0000 }, 244525e992a4SHeiner Kallweit { 0x03, 0x00a1 }, 244625e992a4SHeiner Kallweit { 0x02, 0x0008 }, 244725e992a4SHeiner Kallweit { 0x01, 0x0120 }, 244825e992a4SHeiner Kallweit { 0x00, 0x1000 }, 244925e992a4SHeiner Kallweit { 0x04, 0x0800 }, 245025e992a4SHeiner Kallweit { 0x04, 0x9000 }, 245125e992a4SHeiner Kallweit { 0x03, 0x802f }, 245225e992a4SHeiner Kallweit { 0x02, 0x4f02 }, 245325e992a4SHeiner Kallweit { 0x01, 0x0409 }, 245425e992a4SHeiner Kallweit { 0x00, 0xf099 }, 245525e992a4SHeiner Kallweit { 0x04, 0x9800 }, 245625e992a4SHeiner Kallweit { 0x04, 0xa000 }, 245725e992a4SHeiner Kallweit { 0x03, 0xdf01 }, 245825e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 245925e992a4SHeiner Kallweit { 0x01, 0xff95 }, 246025e992a4SHeiner Kallweit { 0x00, 0xba00 }, 246125e992a4SHeiner Kallweit { 0x04, 0xa800 }, 246225e992a4SHeiner Kallweit { 0x04, 0xf000 }, 246325e992a4SHeiner Kallweit { 0x03, 0xdf01 }, 246425e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 246525e992a4SHeiner Kallweit { 0x01, 0x101a }, 246625e992a4SHeiner Kallweit { 0x00, 0xa0ff }, 246725e992a4SHeiner Kallweit { 0x04, 0xf800 }, 246825e992a4SHeiner Kallweit { 0x04, 0x0000 }, 246925e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 247025e992a4SHeiner Kallweit 247125e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 247225e992a4SHeiner Kallweit { 0x10, 0xf41b }, 247325e992a4SHeiner Kallweit { 0x14, 0xfb54 }, 247425e992a4SHeiner Kallweit { 0x18, 0xf5c7 }, 247525e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 247625e992a4SHeiner Kallweit 247725e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 247825e992a4SHeiner Kallweit { 0x17, 0x0cc0 }, 247925e992a4SHeiner Kallweit { 0x1f, 0x0000 } 248025e992a4SHeiner Kallweit }; 248125e992a4SHeiner Kallweit 248225e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 248325e992a4SHeiner Kallweit 248425e992a4SHeiner Kallweit rtl8169scd_hw_phy_config_quirk(tp); 248525e992a4SHeiner Kallweit } 248625e992a4SHeiner Kallweit 2487becd837eSHeiner Kallweit static void rtl8169sce_hw_phy_config(struct rtl8169_private *tp, 2488becd837eSHeiner Kallweit struct phy_device *phydev) 248925e992a4SHeiner Kallweit { 249025e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 249125e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 249225e992a4SHeiner Kallweit { 0x04, 0x0000 }, 249325e992a4SHeiner Kallweit { 0x03, 0x00a1 }, 249425e992a4SHeiner Kallweit { 0x02, 0x0008 }, 249525e992a4SHeiner Kallweit { 0x01, 0x0120 }, 249625e992a4SHeiner Kallweit { 0x00, 0x1000 }, 249725e992a4SHeiner Kallweit { 0x04, 0x0800 }, 249825e992a4SHeiner Kallweit { 0x04, 0x9000 }, 249925e992a4SHeiner Kallweit { 0x03, 0x802f }, 250025e992a4SHeiner Kallweit { 0x02, 0x4f02 }, 250125e992a4SHeiner Kallweit { 0x01, 0x0409 }, 250225e992a4SHeiner Kallweit { 0x00, 0xf099 }, 250325e992a4SHeiner Kallweit { 0x04, 0x9800 }, 250425e992a4SHeiner Kallweit { 0x04, 0xa000 }, 250525e992a4SHeiner Kallweit { 0x03, 0xdf01 }, 250625e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 250725e992a4SHeiner Kallweit { 0x01, 0xff95 }, 250825e992a4SHeiner Kallweit { 0x00, 0xba00 }, 250925e992a4SHeiner Kallweit { 0x04, 0xa800 }, 251025e992a4SHeiner Kallweit { 0x04, 0xf000 }, 251125e992a4SHeiner Kallweit { 0x03, 0xdf01 }, 251225e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 251325e992a4SHeiner Kallweit { 0x01, 0x101a }, 251425e992a4SHeiner Kallweit { 0x00, 0xa0ff }, 251525e992a4SHeiner Kallweit { 0x04, 0xf800 }, 251625e992a4SHeiner Kallweit { 0x04, 0x0000 }, 251725e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 251825e992a4SHeiner Kallweit 251925e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 252025e992a4SHeiner Kallweit { 0x0b, 0x8480 }, 252125e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 252225e992a4SHeiner Kallweit 252325e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 252425e992a4SHeiner Kallweit { 0x18, 0x67c7 }, 252525e992a4SHeiner Kallweit { 0x04, 0x2000 }, 252625e992a4SHeiner Kallweit { 0x03, 0x002f }, 252725e992a4SHeiner Kallweit { 0x02, 0x4360 }, 252825e992a4SHeiner Kallweit { 0x01, 0x0109 }, 252925e992a4SHeiner Kallweit { 0x00, 0x3022 }, 253025e992a4SHeiner Kallweit { 0x04, 0x2800 }, 253125e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 253225e992a4SHeiner Kallweit 253325e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 253425e992a4SHeiner Kallweit { 0x17, 0x0cc0 }, 253525e992a4SHeiner Kallweit { 0x1f, 0x0000 } 253625e992a4SHeiner Kallweit }; 253725e992a4SHeiner Kallweit 253825e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 253925e992a4SHeiner Kallweit } 254025e992a4SHeiner Kallweit 2541becd837eSHeiner Kallweit static void rtl8168bb_hw_phy_config(struct rtl8169_private *tp, 2542becd837eSHeiner Kallweit struct phy_device *phydev) 254325e992a4SHeiner Kallweit { 254425e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0001); 254525e992a4SHeiner Kallweit rtl_patchphy(tp, 0x16, 1 << 0); 25463a129e3fSHeiner Kallweit rtl_writephy(tp, 0x10, 0xf41b); 25473a129e3fSHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 254825e992a4SHeiner Kallweit } 254925e992a4SHeiner Kallweit 2550becd837eSHeiner Kallweit static void rtl8168bef_hw_phy_config(struct rtl8169_private *tp, 2551becd837eSHeiner Kallweit struct phy_device *phydev) 255225e992a4SHeiner Kallweit { 2553becd837eSHeiner Kallweit phy_write_paged(phydev, 0x0001, 0x10, 0xf41b); 255425e992a4SHeiner Kallweit } 255525e992a4SHeiner Kallweit 2556becd837eSHeiner Kallweit static void rtl8168cp_1_hw_phy_config(struct rtl8169_private *tp, 2557becd837eSHeiner Kallweit struct phy_device *phydev) 255825e992a4SHeiner Kallweit { 2559becd837eSHeiner Kallweit phy_write(phydev, 0x1d, 0x0f00); 2560becd837eSHeiner Kallweit phy_write_paged(phydev, 0x0002, 0x0c, 0x1ec8); 256125e992a4SHeiner Kallweit } 256225e992a4SHeiner Kallweit 2563becd837eSHeiner Kallweit static void rtl8168cp_2_hw_phy_config(struct rtl8169_private *tp, 2564becd837eSHeiner Kallweit struct phy_device *phydev) 256525e992a4SHeiner Kallweit { 2566becd837eSHeiner Kallweit phy_set_bits(phydev, 0x14, BIT(5)); 2567becd837eSHeiner Kallweit phy_set_bits(phydev, 0x0d, BIT(5)); 2568becd837eSHeiner Kallweit phy_write_paged(phydev, 0x0001, 0x1d, 0x3d98); 256925e992a4SHeiner Kallweit } 257025e992a4SHeiner Kallweit 2571becd837eSHeiner Kallweit static void rtl8168c_1_hw_phy_config(struct rtl8169_private *tp, 2572becd837eSHeiner Kallweit struct phy_device *phydev) 257325e992a4SHeiner Kallweit { 257425e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 257525e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 257625e992a4SHeiner Kallweit { 0x12, 0x2300 }, 257725e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 257825e992a4SHeiner Kallweit { 0x00, 0x88d4 }, 257925e992a4SHeiner Kallweit { 0x01, 0x82b1 }, 258025e992a4SHeiner Kallweit { 0x03, 0x7002 }, 258125e992a4SHeiner Kallweit { 0x08, 0x9e30 }, 258225e992a4SHeiner Kallweit { 0x09, 0x01f0 }, 258325e992a4SHeiner Kallweit { 0x0a, 0x5500 }, 258425e992a4SHeiner Kallweit { 0x0c, 0x00c8 }, 258525e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 258625e992a4SHeiner Kallweit { 0x12, 0xc096 }, 258725e992a4SHeiner Kallweit { 0x16, 0x000a }, 258825e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 258925e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 259025e992a4SHeiner Kallweit { 0x09, 0x2000 }, 259125e992a4SHeiner Kallweit { 0x09, 0x0000 } 259225e992a4SHeiner Kallweit }; 259325e992a4SHeiner Kallweit 259425e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 259525e992a4SHeiner Kallweit 259625e992a4SHeiner Kallweit rtl_patchphy(tp, 0x14, 1 << 5); 259725e992a4SHeiner Kallweit rtl_patchphy(tp, 0x0d, 1 << 5); 259825e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 259925e992a4SHeiner Kallweit } 260025e992a4SHeiner Kallweit 2601becd837eSHeiner Kallweit static void rtl8168c_2_hw_phy_config(struct rtl8169_private *tp, 2602becd837eSHeiner Kallweit struct phy_device *phydev) 260325e992a4SHeiner Kallweit { 260425e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 260525e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 260625e992a4SHeiner Kallweit { 0x12, 0x2300 }, 260725e992a4SHeiner Kallweit { 0x03, 0x802f }, 260825e992a4SHeiner Kallweit { 0x02, 0x4f02 }, 260925e992a4SHeiner Kallweit { 0x01, 0x0409 }, 261025e992a4SHeiner Kallweit { 0x00, 0xf099 }, 261125e992a4SHeiner Kallweit { 0x04, 0x9800 }, 261225e992a4SHeiner Kallweit { 0x04, 0x9000 }, 261325e992a4SHeiner Kallweit { 0x1d, 0x3d98 }, 261425e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 261525e992a4SHeiner Kallweit { 0x0c, 0x7eb8 }, 261625e992a4SHeiner Kallweit { 0x06, 0x0761 }, 261725e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 261825e992a4SHeiner Kallweit { 0x16, 0x0f0a }, 261925e992a4SHeiner Kallweit { 0x1f, 0x0000 } 262025e992a4SHeiner Kallweit }; 262125e992a4SHeiner Kallweit 262225e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 262325e992a4SHeiner Kallweit 262425e992a4SHeiner Kallweit rtl_patchphy(tp, 0x16, 1 << 0); 262525e992a4SHeiner Kallweit rtl_patchphy(tp, 0x14, 1 << 5); 262625e992a4SHeiner Kallweit rtl_patchphy(tp, 0x0d, 1 << 5); 262725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 262825e992a4SHeiner Kallweit } 262925e992a4SHeiner Kallweit 2630becd837eSHeiner Kallweit static void rtl8168c_3_hw_phy_config(struct rtl8169_private *tp, 2631becd837eSHeiner Kallweit struct phy_device *phydev) 263225e992a4SHeiner Kallweit { 263325e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 263425e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 263525e992a4SHeiner Kallweit { 0x12, 0x2300 }, 263625e992a4SHeiner Kallweit { 0x1d, 0x3d98 }, 263725e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 263825e992a4SHeiner Kallweit { 0x0c, 0x7eb8 }, 263925e992a4SHeiner Kallweit { 0x06, 0x5461 }, 264025e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 264125e992a4SHeiner Kallweit { 0x16, 0x0f0a }, 264225e992a4SHeiner Kallweit { 0x1f, 0x0000 } 264325e992a4SHeiner Kallweit }; 264425e992a4SHeiner Kallweit 264525e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 264625e992a4SHeiner Kallweit 264725e992a4SHeiner Kallweit rtl_patchphy(tp, 0x16, 1 << 0); 264825e992a4SHeiner Kallweit rtl_patchphy(tp, 0x14, 1 << 5); 264925e992a4SHeiner Kallweit rtl_patchphy(tp, 0x0d, 1 << 5); 265025e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 265125e992a4SHeiner Kallweit } 265225e992a4SHeiner Kallweit 265325e992a4SHeiner Kallweit static const struct phy_reg rtl8168d_1_phy_reg_init_0[] = { 265425e992a4SHeiner Kallweit /* Channel Estimation */ 265525e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 265625e992a4SHeiner Kallweit { 0x06, 0x4064 }, 265725e992a4SHeiner Kallweit { 0x07, 0x2863 }, 265825e992a4SHeiner Kallweit { 0x08, 0x059c }, 265925e992a4SHeiner Kallweit { 0x09, 0x26b4 }, 266025e992a4SHeiner Kallweit { 0x0a, 0x6a19 }, 266125e992a4SHeiner Kallweit { 0x0b, 0xdcc8 }, 266225e992a4SHeiner Kallweit { 0x10, 0xf06d }, 266325e992a4SHeiner Kallweit { 0x14, 0x7f68 }, 266425e992a4SHeiner Kallweit { 0x18, 0x7fd9 }, 266525e992a4SHeiner Kallweit { 0x1c, 0xf0ff }, 266625e992a4SHeiner Kallweit { 0x1d, 0x3d9c }, 266725e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 266825e992a4SHeiner Kallweit { 0x12, 0xf49f }, 266925e992a4SHeiner Kallweit { 0x13, 0x070b }, 267025e992a4SHeiner Kallweit { 0x1a, 0x05ad }, 267125e992a4SHeiner Kallweit { 0x14, 0x94c0 }, 267225e992a4SHeiner Kallweit 267325e992a4SHeiner Kallweit /* 267425e992a4SHeiner Kallweit * Tx Error Issue 267525e992a4SHeiner Kallweit * Enhance line driver power 267625e992a4SHeiner Kallweit */ 267725e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 267825e992a4SHeiner Kallweit { 0x06, 0x5561 }, 267925e992a4SHeiner Kallweit { 0x1f, 0x0005 }, 268025e992a4SHeiner Kallweit { 0x05, 0x8332 }, 268125e992a4SHeiner Kallweit { 0x06, 0x5561 }, 268225e992a4SHeiner Kallweit 268325e992a4SHeiner Kallweit /* 268425e992a4SHeiner Kallweit * Can not link to 1Gbps with bad cable 268525e992a4SHeiner Kallweit * Decrease SNR threshold form 21.07dB to 19.04dB 268625e992a4SHeiner Kallweit */ 268725e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 268825e992a4SHeiner Kallweit { 0x17, 0x0cc0 }, 268925e992a4SHeiner Kallweit 269025e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 269125e992a4SHeiner Kallweit { 0x0d, 0xf880 } 269225e992a4SHeiner Kallweit }; 269325e992a4SHeiner Kallweit 269425e992a4SHeiner Kallweit static const struct phy_reg rtl8168d_1_phy_reg_init_1[] = { 269525e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 269625e992a4SHeiner Kallweit { 0x05, 0x669a }, 269725e992a4SHeiner Kallweit { 0x1f, 0x0005 }, 269825e992a4SHeiner Kallweit { 0x05, 0x8330 }, 269925e992a4SHeiner Kallweit { 0x06, 0x669a }, 270025e992a4SHeiner Kallweit { 0x1f, 0x0002 } 270125e992a4SHeiner Kallweit }; 270225e992a4SHeiner Kallweit 2703718af5bcSHeiner Kallweit static void rtl8168d_apply_firmware_cond(struct rtl8169_private *tp, u16 val) 2704718af5bcSHeiner Kallweit { 2705718af5bcSHeiner Kallweit u16 reg_val; 2706718af5bcSHeiner Kallweit 2707718af5bcSHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0005); 2708718af5bcSHeiner Kallweit rtl_writephy(tp, 0x05, 0x001b); 2709718af5bcSHeiner Kallweit reg_val = rtl_readphy(tp, 0x06); 2710718af5bcSHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 2711718af5bcSHeiner Kallweit 2712718af5bcSHeiner Kallweit if (reg_val != val) 2713718af5bcSHeiner Kallweit netif_warn(tp, hw, tp->dev, "chipset not ready for firmware\n"); 2714718af5bcSHeiner Kallweit else 2715718af5bcSHeiner Kallweit rtl_apply_firmware(tp); 2716718af5bcSHeiner Kallweit } 2717718af5bcSHeiner Kallweit 2718becd837eSHeiner Kallweit static void rtl8168d_1_hw_phy_config(struct rtl8169_private *tp, 2719becd837eSHeiner Kallweit struct phy_device *phydev) 272025e992a4SHeiner Kallweit { 272125e992a4SHeiner Kallweit rtl_writephy_batch(tp, rtl8168d_1_phy_reg_init_0); 272225e992a4SHeiner Kallweit 272325e992a4SHeiner Kallweit /* 272425e992a4SHeiner Kallweit * Rx Error Issue 272525e992a4SHeiner Kallweit * Fine Tune Switching regulator parameter 272625e992a4SHeiner Kallweit */ 272725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 272825e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x0b, 0x0010, 0x00ef); 272925e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x0c, 0xa200, 0x5d00); 273025e992a4SHeiner Kallweit 273125e992a4SHeiner Kallweit if (rtl8168d_efuse_read(tp, 0x01) == 0xb1) { 273225e992a4SHeiner Kallweit int val; 273325e992a4SHeiner Kallweit 273425e992a4SHeiner Kallweit rtl_writephy_batch(tp, rtl8168d_1_phy_reg_init_1); 273525e992a4SHeiner Kallweit 273625e992a4SHeiner Kallweit val = rtl_readphy(tp, 0x0d); 273725e992a4SHeiner Kallweit 273825e992a4SHeiner Kallweit if ((val & 0x00ff) != 0x006c) { 273925e992a4SHeiner Kallweit static const u32 set[] = { 274025e992a4SHeiner Kallweit 0x0065, 0x0066, 0x0067, 0x0068, 274125e992a4SHeiner Kallweit 0x0069, 0x006a, 0x006b, 0x006c 274225e992a4SHeiner Kallweit }; 274325e992a4SHeiner Kallweit int i; 274425e992a4SHeiner Kallweit 274525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 274625e992a4SHeiner Kallweit 274725e992a4SHeiner Kallweit val &= 0xff00; 274825e992a4SHeiner Kallweit for (i = 0; i < ARRAY_SIZE(set); i++) 274925e992a4SHeiner Kallweit rtl_writephy(tp, 0x0d, val | set[i]); 275025e992a4SHeiner Kallweit } 275125e992a4SHeiner Kallweit } else { 2752becd837eSHeiner Kallweit phy_write_paged(phydev, 0x0002, 0x05, 0x6662); 2753becd837eSHeiner Kallweit r8168d_phy_param(phydev, 0x8330, 0xffff, 0x6662); 275425e992a4SHeiner Kallweit } 275525e992a4SHeiner Kallweit 275625e992a4SHeiner Kallweit /* RSET couple improve */ 275725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 275825e992a4SHeiner Kallweit rtl_patchphy(tp, 0x0d, 0x0300); 275925e992a4SHeiner Kallweit rtl_patchphy(tp, 0x0f, 0x0010); 276025e992a4SHeiner Kallweit 276125e992a4SHeiner Kallweit /* Fine tune PLL performance */ 276225e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 276325e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x02, 0x0100, 0x0600); 276425e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x03, 0x0000, 0xe000); 276525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 2766718af5bcSHeiner Kallweit 2767718af5bcSHeiner Kallweit rtl8168d_apply_firmware_cond(tp, 0xbf00); 276825e992a4SHeiner Kallweit } 276925e992a4SHeiner Kallweit 2770becd837eSHeiner Kallweit static void rtl8168d_2_hw_phy_config(struct rtl8169_private *tp, 2771becd837eSHeiner Kallweit struct phy_device *phydev) 277225e992a4SHeiner Kallweit { 277325e992a4SHeiner Kallweit rtl_writephy_batch(tp, rtl8168d_1_phy_reg_init_0); 277425e992a4SHeiner Kallweit 277525e992a4SHeiner Kallweit if (rtl8168d_efuse_read(tp, 0x01) == 0xb1) { 277625e992a4SHeiner Kallweit int val; 277725e992a4SHeiner Kallweit 277825e992a4SHeiner Kallweit rtl_writephy_batch(tp, rtl8168d_1_phy_reg_init_1); 277925e992a4SHeiner Kallweit 278025e992a4SHeiner Kallweit val = rtl_readphy(tp, 0x0d); 278125e992a4SHeiner Kallweit if ((val & 0x00ff) != 0x006c) { 278225e992a4SHeiner Kallweit static const u32 set[] = { 278325e992a4SHeiner Kallweit 0x0065, 0x0066, 0x0067, 0x0068, 278425e992a4SHeiner Kallweit 0x0069, 0x006a, 0x006b, 0x006c 278525e992a4SHeiner Kallweit }; 278625e992a4SHeiner Kallweit int i; 278725e992a4SHeiner Kallweit 278825e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 278925e992a4SHeiner Kallweit 279025e992a4SHeiner Kallweit val &= 0xff00; 279125e992a4SHeiner Kallweit for (i = 0; i < ARRAY_SIZE(set); i++) 279225e992a4SHeiner Kallweit rtl_writephy(tp, 0x0d, val | set[i]); 279325e992a4SHeiner Kallweit } 279425e992a4SHeiner Kallweit } else { 2795becd837eSHeiner Kallweit phy_write_paged(phydev, 0x0002, 0x05, 0x2642); 2796becd837eSHeiner Kallweit r8168d_phy_param(phydev, 0x8330, 0xffff, 0x2642); 279725e992a4SHeiner Kallweit } 279825e992a4SHeiner Kallweit 279925e992a4SHeiner Kallweit /* Fine tune PLL performance */ 280025e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 280125e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x02, 0x0100, 0x0600); 280225e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x03, 0x0000, 0xe000); 280325e992a4SHeiner Kallweit 280425e992a4SHeiner Kallweit /* Switching regulator Slew rate */ 280525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 280625e992a4SHeiner Kallweit rtl_patchphy(tp, 0x0f, 0x0017); 280725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 2808718af5bcSHeiner Kallweit 2809718af5bcSHeiner Kallweit rtl8168d_apply_firmware_cond(tp, 0xb300); 281025e992a4SHeiner Kallweit } 281125e992a4SHeiner Kallweit 2812becd837eSHeiner Kallweit static void rtl8168d_3_hw_phy_config(struct rtl8169_private *tp, 2813becd837eSHeiner Kallweit struct phy_device *phydev) 281425e992a4SHeiner Kallweit { 281525e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 281625e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 281725e992a4SHeiner Kallweit { 0x10, 0x0008 }, 281825e992a4SHeiner Kallweit { 0x0d, 0x006c }, 281925e992a4SHeiner Kallweit 282025e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 282125e992a4SHeiner Kallweit { 0x0d, 0xf880 }, 282225e992a4SHeiner Kallweit 282325e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 282425e992a4SHeiner Kallweit { 0x17, 0x0cc0 }, 282525e992a4SHeiner Kallweit 282625e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 282725e992a4SHeiner Kallweit { 0x0b, 0xa4d8 }, 282825e992a4SHeiner Kallweit { 0x09, 0x281c }, 282925e992a4SHeiner Kallweit { 0x07, 0x2883 }, 283025e992a4SHeiner Kallweit { 0x0a, 0x6b35 }, 283125e992a4SHeiner Kallweit { 0x1d, 0x3da4 }, 283225e992a4SHeiner Kallweit { 0x1c, 0xeffd }, 283325e992a4SHeiner Kallweit { 0x14, 0x7f52 }, 283425e992a4SHeiner Kallweit { 0x18, 0x7fc6 }, 283525e992a4SHeiner Kallweit { 0x08, 0x0601 }, 283625e992a4SHeiner Kallweit { 0x06, 0x4063 }, 283725e992a4SHeiner Kallweit { 0x10, 0xf074 }, 283825e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 283925e992a4SHeiner Kallweit { 0x13, 0x0789 }, 284025e992a4SHeiner Kallweit { 0x12, 0xf4bd }, 284125e992a4SHeiner Kallweit { 0x1a, 0x04fd }, 284225e992a4SHeiner Kallweit { 0x14, 0x84b0 }, 284325e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 284425e992a4SHeiner Kallweit { 0x00, 0x9200 }, 284525e992a4SHeiner Kallweit 284625e992a4SHeiner Kallweit { 0x1f, 0x0005 }, 284725e992a4SHeiner Kallweit { 0x01, 0x0340 }, 284825e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 284925e992a4SHeiner Kallweit { 0x04, 0x4000 }, 285025e992a4SHeiner Kallweit { 0x03, 0x1d21 }, 285125e992a4SHeiner Kallweit { 0x02, 0x0c32 }, 285225e992a4SHeiner Kallweit { 0x01, 0x0200 }, 285325e992a4SHeiner Kallweit { 0x00, 0x5554 }, 285425e992a4SHeiner Kallweit { 0x04, 0x4800 }, 285525e992a4SHeiner Kallweit { 0x04, 0x4000 }, 285625e992a4SHeiner Kallweit { 0x04, 0xf000 }, 285725e992a4SHeiner Kallweit { 0x03, 0xdf01 }, 285825e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 285925e992a4SHeiner Kallweit { 0x01, 0x101a }, 286025e992a4SHeiner Kallweit { 0x00, 0xa0ff }, 286125e992a4SHeiner Kallweit { 0x04, 0xf800 }, 286225e992a4SHeiner Kallweit { 0x04, 0xf000 }, 286325e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 286425e992a4SHeiner Kallweit }; 286525e992a4SHeiner Kallweit 286625e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 28670721914aSHeiner Kallweit 2868becd837eSHeiner Kallweit r8168d_modify_extpage(phydev, 0x0023, 0x16, 0xffff, 0x0000); 286925e992a4SHeiner Kallweit } 287025e992a4SHeiner Kallweit 2871becd837eSHeiner Kallweit static void rtl8168d_4_hw_phy_config(struct rtl8169_private *tp, 2872becd837eSHeiner Kallweit struct phy_device *phydev) 287325e992a4SHeiner Kallweit { 2874becd837eSHeiner Kallweit phy_write_paged(phydev, 0x0001, 0x17, 0x0cc0); 2875becd837eSHeiner Kallweit r8168d_modify_extpage(phydev, 0x002d, 0x18, 0xffff, 0x0040); 2876becd837eSHeiner Kallweit phy_set_bits(phydev, 0x0d, BIT(5)); 287725e992a4SHeiner Kallweit } 287825e992a4SHeiner Kallweit 2879becd837eSHeiner Kallweit static void rtl8168e_1_hw_phy_config(struct rtl8169_private *tp, 2880becd837eSHeiner Kallweit struct phy_device *phydev) 288125e992a4SHeiner Kallweit { 288225e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 288325e992a4SHeiner Kallweit /* Channel estimation fine tune */ 288425e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 288525e992a4SHeiner Kallweit { 0x0b, 0x6c20 }, 288625e992a4SHeiner Kallweit { 0x07, 0x2872 }, 288725e992a4SHeiner Kallweit { 0x1c, 0xefff }, 288825e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 288925e992a4SHeiner Kallweit { 0x14, 0x6420 }, 289025e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 289125e992a4SHeiner Kallweit }; 289225e992a4SHeiner Kallweit 289325e992a4SHeiner Kallweit rtl_apply_firmware(tp); 289425e992a4SHeiner Kallweit 2895b5e189b4SHeiner Kallweit /* Enable Delay cap */ 2896b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b80, 0xffff, 0xc896); 2897b5e189b4SHeiner Kallweit 289825e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 289925e992a4SHeiner Kallweit 29000721914aSHeiner Kallweit /* Update PFM & 10M TX idle timer */ 29010721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x002f, 0x15, 0xffff, 0x1919); 29020721914aSHeiner Kallweit 29030721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x00ac, 0x18, 0xffff, 0x0006); 29040721914aSHeiner Kallweit 290525e992a4SHeiner Kallweit /* DCO enable for 10M IDLE Power */ 29060721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x0023, 0x17, 0x0000, 0x0006); 290725e992a4SHeiner Kallweit 290825e992a4SHeiner Kallweit /* For impedance matching */ 29093a129e3fSHeiner Kallweit phy_modify_paged(phydev, 0x0002, 0x08, 0x7f00, 0x8000); 291025e992a4SHeiner Kallweit 291125e992a4SHeiner Kallweit /* PHY auto speed down */ 29120721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x002d, 0x18, 0x0000, 0x0050); 29130721914aSHeiner Kallweit phy_set_bits(phydev, 0x14, BIT(15)); 291425e992a4SHeiner Kallweit 2915b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b86, 0x0000, 0x0001); 2916b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b85, 0x2000, 0x0000); 291725e992a4SHeiner Kallweit 29180721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x0020, 0x15, 0x1100, 0x0000); 29190721914aSHeiner Kallweit phy_write_paged(phydev, 0x0006, 0x00, 0x5a00); 2920b5e189b4SHeiner Kallweit 2921b5e189b4SHeiner Kallweit phy_write_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV, 0x0000); 292225e992a4SHeiner Kallweit } 292325e992a4SHeiner Kallweit 292425e992a4SHeiner Kallweit static void rtl_rar_exgmac_set(struct rtl8169_private *tp, u8 *addr) 292525e992a4SHeiner Kallweit { 292625e992a4SHeiner Kallweit const u16 w[] = { 292725e992a4SHeiner Kallweit addr[0] | (addr[1] << 8), 292825e992a4SHeiner Kallweit addr[2] | (addr[3] << 8), 292925e992a4SHeiner Kallweit addr[4] | (addr[5] << 8) 293025e992a4SHeiner Kallweit }; 293125e992a4SHeiner Kallweit 293225e992a4SHeiner Kallweit rtl_eri_write(tp, 0xe0, ERIAR_MASK_1111, w[0] | (w[1] << 16)); 293325e992a4SHeiner Kallweit rtl_eri_write(tp, 0xe4, ERIAR_MASK_1111, w[2]); 293425e992a4SHeiner Kallweit rtl_eri_write(tp, 0xf0, ERIAR_MASK_1111, w[0] << 16); 293525e992a4SHeiner Kallweit rtl_eri_write(tp, 0xf4, ERIAR_MASK_1111, w[1] | (w[2] << 16)); 293625e992a4SHeiner Kallweit } 293725e992a4SHeiner Kallweit 2938becd837eSHeiner Kallweit static void rtl8168e_2_hw_phy_config(struct rtl8169_private *tp, 2939becd837eSHeiner Kallweit struct phy_device *phydev) 294025e992a4SHeiner Kallweit { 294125e992a4SHeiner Kallweit rtl_apply_firmware(tp); 294225e992a4SHeiner Kallweit 29430721914aSHeiner Kallweit /* Enable Delay cap */ 29440721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x00ac, 0x18, 0xffff, 0x0006); 29450721914aSHeiner Kallweit 29460721914aSHeiner Kallweit /* Channel estimation fine tune */ 29470721914aSHeiner Kallweit phy_write_paged(phydev, 0x0003, 0x09, 0xa20f); 294825e992a4SHeiner Kallweit 2949b5e189b4SHeiner Kallweit /* Green Setting */ 2950b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b5b, 0xffff, 0x9222); 2951b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b6d, 0xffff, 0x8000); 2952b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b76, 0xffff, 0x8000); 2953b5e189b4SHeiner Kallweit 295425e992a4SHeiner Kallweit /* For 4-corner performance improve */ 295525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0005); 295625e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x8b80); 295725e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x17, 0x0006, 0x0000); 295825e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 295925e992a4SHeiner Kallweit 296025e992a4SHeiner Kallweit /* PHY auto speed down */ 29610721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x002d, 0x18, 0x0000, 0x0010); 29620721914aSHeiner Kallweit phy_set_bits(phydev, 0x14, BIT(15)); 296325e992a4SHeiner Kallweit 296425e992a4SHeiner Kallweit /* improve 10M EEE waveform */ 2965b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b86, 0x0000, 0x0001); 296625e992a4SHeiner Kallweit 296725e992a4SHeiner Kallweit /* Improve 2-pair detection performance */ 2968b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b85, 0x0000, 0x4000); 296925e992a4SHeiner Kallweit 297025e992a4SHeiner Kallweit rtl8168f_config_eee_phy(tp); 297125e992a4SHeiner Kallweit 297225e992a4SHeiner Kallweit /* Green feature */ 297325e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0003); 297425e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x19, 0x0001, 0x0000); 297525e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x10, 0x0400, 0x0000); 297625e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 297725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0005); 297825e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x01, 0x0100, 0x0000); 297925e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 298025e992a4SHeiner Kallweit } 298125e992a4SHeiner Kallweit 2982becd837eSHeiner Kallweit static void rtl8168f_hw_phy_config(struct rtl8169_private *tp, 2983becd837eSHeiner Kallweit struct phy_device *phydev) 298425e992a4SHeiner Kallweit { 298525e992a4SHeiner Kallweit /* For 4-corner performance improve */ 2986b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b80, 0x0000, 0x0006); 298725e992a4SHeiner Kallweit 298825e992a4SHeiner Kallweit /* PHY auto speed down */ 29890721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x002d, 0x18, 0x0000, 0x0010); 29900721914aSHeiner Kallweit phy_set_bits(phydev, 0x14, BIT(15)); 299125e992a4SHeiner Kallweit 299225e992a4SHeiner Kallweit /* Improve 10M EEE waveform */ 2993b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b86, 0x0000, 0x0001); 299425e992a4SHeiner Kallweit 299525e992a4SHeiner Kallweit rtl8168f_config_eee_phy(tp); 299625e992a4SHeiner Kallweit } 299725e992a4SHeiner Kallweit 2998becd837eSHeiner Kallweit static void rtl8168f_1_hw_phy_config(struct rtl8169_private *tp, 2999becd837eSHeiner Kallweit struct phy_device *phydev) 300025e992a4SHeiner Kallweit { 300125e992a4SHeiner Kallweit rtl_apply_firmware(tp); 300225e992a4SHeiner Kallweit 3003b5e189b4SHeiner Kallweit /* Channel estimation fine tune */ 3004b5e189b4SHeiner Kallweit phy_write_paged(phydev, 0x0003, 0x09, 0xa20f); 3005b5e189b4SHeiner Kallweit 3006b5e189b4SHeiner Kallweit /* Modify green table for giga & fnet */ 3007b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b55, 0xffff, 0x0000); 3008b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b5e, 0xffff, 0x0000); 3009b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b67, 0xffff, 0x0000); 3010b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b70, 0xffff, 0x0000); 30110721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x0078, 0x17, 0xffff, 0x0000); 30120721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x0078, 0x19, 0xffff, 0x00fb); 3013b5e189b4SHeiner Kallweit 3014b5e189b4SHeiner Kallweit /* Modify green table for 10M */ 3015b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b79, 0xffff, 0xaa00); 3016b5e189b4SHeiner Kallweit 3017b5e189b4SHeiner Kallweit /* Disable hiimpedance detection (RTCT) */ 3018b5e189b4SHeiner Kallweit phy_write_paged(phydev, 0x0003, 0x01, 0x328a); 301925e992a4SHeiner Kallweit 3020becd837eSHeiner Kallweit rtl8168f_hw_phy_config(tp, phydev); 302125e992a4SHeiner Kallweit 302225e992a4SHeiner Kallweit /* Improve 2-pair detection performance */ 3023b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b85, 0x0000, 0x4000); 302425e992a4SHeiner Kallweit } 302525e992a4SHeiner Kallweit 3026becd837eSHeiner Kallweit static void rtl8168f_2_hw_phy_config(struct rtl8169_private *tp, 3027becd837eSHeiner Kallweit struct phy_device *phydev) 302825e992a4SHeiner Kallweit { 302925e992a4SHeiner Kallweit rtl_apply_firmware(tp); 303025e992a4SHeiner Kallweit 3031becd837eSHeiner Kallweit rtl8168f_hw_phy_config(tp, phydev); 303225e992a4SHeiner Kallweit } 303325e992a4SHeiner Kallweit 3034becd837eSHeiner Kallweit static void rtl8411_hw_phy_config(struct rtl8169_private *tp, 3035becd837eSHeiner Kallweit struct phy_device *phydev) 303625e992a4SHeiner Kallweit { 303725e992a4SHeiner Kallweit rtl_apply_firmware(tp); 303825e992a4SHeiner Kallweit 3039becd837eSHeiner Kallweit rtl8168f_hw_phy_config(tp, phydev); 304025e992a4SHeiner Kallweit 304125e992a4SHeiner Kallweit /* Improve 2-pair detection performance */ 3042b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b85, 0x0000, 0x4000); 304325e992a4SHeiner Kallweit 3044b5e189b4SHeiner Kallweit /* Channel estimation fine tune */ 3045b5e189b4SHeiner Kallweit phy_write_paged(phydev, 0x0003, 0x09, 0xa20f); 3046b5e189b4SHeiner Kallweit 3047b5e189b4SHeiner Kallweit /* Modify green table for giga & fnet */ 3048b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b55, 0xffff, 0x0000); 3049b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b5e, 0xffff, 0x0000); 3050b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b67, 0xffff, 0x0000); 3051b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b70, 0xffff, 0x0000); 30520721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x0078, 0x17, 0xffff, 0x0000); 30530721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x0078, 0x19, 0xffff, 0x00aa); 3054b5e189b4SHeiner Kallweit 3055b5e189b4SHeiner Kallweit /* Modify green table for 10M */ 3056b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b79, 0xffff, 0xaa00); 3057b5e189b4SHeiner Kallweit 3058b5e189b4SHeiner Kallweit /* Disable hiimpedance detection (RTCT) */ 3059b5e189b4SHeiner Kallweit phy_write_paged(phydev, 0x0003, 0x01, 0x328a); 306025e992a4SHeiner Kallweit 306125e992a4SHeiner Kallweit /* Modify green table for giga */ 3062b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b54, 0x0800, 0x0000); 3063b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b5d, 0x0800, 0x0000); 3064b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8a7c, 0x0100, 0x0000); 3065b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8a7f, 0x0000, 0x0100); 3066b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8a82, 0x0100, 0x0000); 3067b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8a85, 0x0100, 0x0000); 3068b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8a88, 0x0100, 0x0000); 306925e992a4SHeiner Kallweit 307025e992a4SHeiner Kallweit /* uc same-seed solution */ 3071b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b85, 0x0000, 0x8000); 307225e992a4SHeiner Kallweit 307325e992a4SHeiner Kallweit /* Green feature */ 307425e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0003); 307525e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x19, 0x0000, 0x0001); 307625e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x10, 0x0000, 0x0400); 307725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 307825e992a4SHeiner Kallweit } 307925e992a4SHeiner Kallweit 308025e992a4SHeiner Kallweit static void rtl8168g_disable_aldps(struct rtl8169_private *tp) 308125e992a4SHeiner Kallweit { 308225e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0a43, 0x10, BIT(2), 0); 308325e992a4SHeiner Kallweit } 308425e992a4SHeiner Kallweit 308525e992a4SHeiner Kallweit static void rtl8168g_phy_adjust_10m_aldps(struct rtl8169_private *tp) 308625e992a4SHeiner Kallweit { 308725e992a4SHeiner Kallweit struct phy_device *phydev = tp->phydev; 308825e992a4SHeiner Kallweit 308925e992a4SHeiner Kallweit phy_modify_paged(phydev, 0x0bcc, 0x14, BIT(8), 0); 309025e992a4SHeiner Kallweit phy_modify_paged(phydev, 0x0a44, 0x11, 0, BIT(7) | BIT(6)); 30918bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8084, 0x6000, 0x0000); 30928bfdce1dSHeiner Kallweit phy_modify_paged(phydev, 0x0a43, 0x10, 0x0000, 0x1003); 309325e992a4SHeiner Kallweit } 309425e992a4SHeiner Kallweit 3095becd837eSHeiner Kallweit static void rtl8168g_1_hw_phy_config(struct rtl8169_private *tp, 3096becd837eSHeiner Kallweit struct phy_device *phydev) 309725e992a4SHeiner Kallweit { 309825e992a4SHeiner Kallweit int ret; 309925e992a4SHeiner Kallweit 310025e992a4SHeiner Kallweit rtl_apply_firmware(tp); 310125e992a4SHeiner Kallweit 3102becd837eSHeiner Kallweit ret = phy_read_paged(phydev, 0x0a46, 0x10); 310325e992a4SHeiner Kallweit if (ret & BIT(8)) 3104becd837eSHeiner Kallweit phy_modify_paged(phydev, 0x0bcc, 0x12, BIT(15), 0); 310525e992a4SHeiner Kallweit else 3106becd837eSHeiner Kallweit phy_modify_paged(phydev, 0x0bcc, 0x12, 0, BIT(15)); 310725e992a4SHeiner Kallweit 3108becd837eSHeiner Kallweit ret = phy_read_paged(phydev, 0x0a46, 0x13); 310925e992a4SHeiner Kallweit if (ret & BIT(8)) 3110becd837eSHeiner Kallweit phy_modify_paged(phydev, 0x0c41, 0x15, 0, BIT(1)); 311125e992a4SHeiner Kallweit else 3112becd837eSHeiner Kallweit phy_modify_paged(phydev, 0x0c41, 0x15, BIT(1), 0); 311325e992a4SHeiner Kallweit 311425e992a4SHeiner Kallweit /* Enable PHY auto speed down */ 3115becd837eSHeiner Kallweit phy_modify_paged(phydev, 0x0a44, 0x11, 0, BIT(3) | BIT(2)); 311625e992a4SHeiner Kallweit 311725e992a4SHeiner Kallweit rtl8168g_phy_adjust_10m_aldps(tp); 311825e992a4SHeiner Kallweit 311925e992a4SHeiner Kallweit /* EEE auto-fallback function */ 3120becd837eSHeiner Kallweit phy_modify_paged(phydev, 0x0a4b, 0x11, 0, BIT(2)); 312125e992a4SHeiner Kallweit 312225e992a4SHeiner Kallweit /* Enable UC LPF tune function */ 3123becd837eSHeiner Kallweit r8168g_phy_param(phydev, 0x8012, 0x0000, 0x8000); 312425e992a4SHeiner Kallweit 3125becd837eSHeiner Kallweit phy_modify_paged(phydev, 0x0c42, 0x11, BIT(13), BIT(14)); 312625e992a4SHeiner Kallweit 312725e992a4SHeiner Kallweit /* Improve SWR Efficiency */ 312825e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0bcd); 312925e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x5065); 313025e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0xd065); 313125e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0bc8); 313225e992a4SHeiner Kallweit rtl_writephy(tp, 0x11, 0x5655); 313325e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0bcd); 313425e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x1065); 313525e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x9065); 313625e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x1065); 313725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 313825e992a4SHeiner Kallweit 313925e992a4SHeiner Kallweit rtl8168g_disable_aldps(tp); 314025e992a4SHeiner Kallweit rtl8168g_config_eee_phy(tp); 314125e992a4SHeiner Kallweit } 314225e992a4SHeiner Kallweit 3143becd837eSHeiner Kallweit static void rtl8168g_2_hw_phy_config(struct rtl8169_private *tp, 3144becd837eSHeiner Kallweit struct phy_device *phydev) 314525e992a4SHeiner Kallweit { 314625e992a4SHeiner Kallweit rtl_apply_firmware(tp); 314725e992a4SHeiner Kallweit rtl8168g_config_eee_phy(tp); 314825e992a4SHeiner Kallweit } 314925e992a4SHeiner Kallweit 3150becd837eSHeiner Kallweit static void rtl8168h_1_hw_phy_config(struct rtl8169_private *tp, 3151becd837eSHeiner Kallweit struct phy_device *phydev) 315225e992a4SHeiner Kallweit { 315325e992a4SHeiner Kallweit u16 dout_tapbin; 315425e992a4SHeiner Kallweit u32 data; 315525e992a4SHeiner Kallweit 315625e992a4SHeiner Kallweit rtl_apply_firmware(tp); 315725e992a4SHeiner Kallweit 315825e992a4SHeiner Kallweit /* CHN EST parameters adjust - giga master */ 31598bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x809b, 0xf800, 0x8000); 31608bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80a2, 0xff00, 0x8000); 31618bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80a4, 0xff00, 0x8500); 31628bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x809c, 0xff00, 0xbd00); 316325e992a4SHeiner Kallweit 316425e992a4SHeiner Kallweit /* CHN EST parameters adjust - giga slave */ 31658bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80ad, 0xf800, 0x7000); 31668bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80b4, 0xff00, 0x5000); 31678bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80ac, 0xff00, 0x4000); 316825e992a4SHeiner Kallweit 316925e992a4SHeiner Kallweit /* CHN EST parameters adjust - fnet */ 31708bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x808e, 0xff00, 0x1200); 31718bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8090, 0xff00, 0xe500); 31728bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8092, 0xff00, 0x9f00); 317325e992a4SHeiner Kallweit 317425e992a4SHeiner Kallweit /* enable R-tune & PGA-retune function */ 317525e992a4SHeiner Kallweit dout_tapbin = 0; 31768bfdce1dSHeiner Kallweit data = phy_read_paged(phydev, 0x0a46, 0x13); 317725e992a4SHeiner Kallweit data &= 3; 317825e992a4SHeiner Kallweit data <<= 2; 317925e992a4SHeiner Kallweit dout_tapbin |= data; 31808bfdce1dSHeiner Kallweit data = phy_read_paged(phydev, 0x0a46, 0x12); 318125e992a4SHeiner Kallweit data &= 0xc000; 318225e992a4SHeiner Kallweit data >>= 14; 318325e992a4SHeiner Kallweit dout_tapbin |= data; 318425e992a4SHeiner Kallweit dout_tapbin = ~(dout_tapbin^0x08); 318525e992a4SHeiner Kallweit dout_tapbin <<= 12; 318625e992a4SHeiner Kallweit dout_tapbin &= 0xf000; 318725e992a4SHeiner Kallweit 31888bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x827a, 0xf000, dout_tapbin); 31898bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x827b, 0xf000, dout_tapbin); 31908bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x827c, 0xf000, dout_tapbin); 31918bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x827d, 0xf000, dout_tapbin); 31928bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x0811, 0x0000, 0x0800); 31938bfdce1dSHeiner Kallweit phy_modify_paged(phydev, 0x0a42, 0x16, 0x0000, 0x0002); 319425e992a4SHeiner Kallweit 319525e992a4SHeiner Kallweit /* enable GPHY 10M */ 3196becd837eSHeiner Kallweit phy_modify_paged(phydev, 0x0a44, 0x11, 0, BIT(11)); 319725e992a4SHeiner Kallweit 319825e992a4SHeiner Kallweit /* SAR ADC performance */ 3199becd837eSHeiner Kallweit phy_modify_paged(phydev, 0x0bca, 0x17, BIT(12) | BIT(13), BIT(14)); 320025e992a4SHeiner Kallweit 32018bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x803f, 0x3000, 0x0000); 32028bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8047, 0x3000, 0x0000); 32038bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x804f, 0x3000, 0x0000); 32048bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8057, 0x3000, 0x0000); 32058bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x805f, 0x3000, 0x0000); 32068bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8067, 0x3000, 0x0000); 32078bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x806f, 0x3000, 0x0000); 320825e992a4SHeiner Kallweit 320925e992a4SHeiner Kallweit /* disable phy pfm mode */ 3210becd837eSHeiner Kallweit phy_modify_paged(phydev, 0x0a44, 0x11, BIT(7), 0); 321125e992a4SHeiner Kallweit 321225e992a4SHeiner Kallweit rtl8168g_disable_aldps(tp); 3213b6cef26fSHeiner Kallweit rtl8168h_config_eee_phy(tp); 321425e992a4SHeiner Kallweit } 321525e992a4SHeiner Kallweit 32163127f7c9SHeiner Kallweit static u16 rtl8168h_2_get_adc_bias_ioffset(struct rtl8169_private *tp) 32173127f7c9SHeiner Kallweit { 32183127f7c9SHeiner Kallweit u16 data1, data2, ioffset; 32193127f7c9SHeiner Kallweit 32203127f7c9SHeiner Kallweit r8168_mac_ocp_write(tp, 0xdd02, 0x807d); 32213127f7c9SHeiner Kallweit data1 = r8168_mac_ocp_read(tp, 0xdd02); 32223127f7c9SHeiner Kallweit data2 = r8168_mac_ocp_read(tp, 0xdd00); 32233127f7c9SHeiner Kallweit 32243127f7c9SHeiner Kallweit ioffset = (data2 >> 1) & 0x7ff8; 32253127f7c9SHeiner Kallweit ioffset |= data2 & 0x0007; 32263127f7c9SHeiner Kallweit if (data1 & BIT(7)) 32273127f7c9SHeiner Kallweit ioffset |= BIT(15); 32283127f7c9SHeiner Kallweit 32293127f7c9SHeiner Kallweit return ioffset; 32303127f7c9SHeiner Kallweit } 32313127f7c9SHeiner Kallweit 3232becd837eSHeiner Kallweit static void rtl8168h_2_hw_phy_config(struct rtl8169_private *tp, 3233becd837eSHeiner Kallweit struct phy_device *phydev) 323425e992a4SHeiner Kallweit { 32353127f7c9SHeiner Kallweit u16 ioffset, rlen; 323625e992a4SHeiner Kallweit u32 data; 323725e992a4SHeiner Kallweit 323825e992a4SHeiner Kallweit rtl_apply_firmware(tp); 323925e992a4SHeiner Kallweit 324025e992a4SHeiner Kallweit /* CHIN EST parameter update */ 32418bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x808a, 0x003f, 0x000a); 324225e992a4SHeiner Kallweit 324325e992a4SHeiner Kallweit /* enable R-tune & PGA-retune function */ 32448bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x0811, 0x0000, 0x0800); 32458bfdce1dSHeiner Kallweit phy_modify_paged(phydev, 0x0a42, 0x16, 0x0000, 0x0002); 324625e992a4SHeiner Kallweit 324725e992a4SHeiner Kallweit /* enable GPHY 10M */ 3248becd837eSHeiner Kallweit phy_modify_paged(phydev, 0x0a44, 0x11, 0, BIT(11)); 324925e992a4SHeiner Kallweit 32503127f7c9SHeiner Kallweit ioffset = rtl8168h_2_get_adc_bias_ioffset(tp); 32513127f7c9SHeiner Kallweit if (ioffset != 0xffff) 32523127f7c9SHeiner Kallweit phy_write_paged(phydev, 0x0bcf, 0x16, ioffset); 325325e992a4SHeiner Kallweit 325425e992a4SHeiner Kallweit /* Modify rlen (TX LPF corner frequency) level */ 32558bfdce1dSHeiner Kallweit data = phy_read_paged(phydev, 0x0bcd, 0x16); 325625e992a4SHeiner Kallweit data &= 0x000f; 325725e992a4SHeiner Kallweit rlen = 0; 325825e992a4SHeiner Kallweit if (data > 3) 325925e992a4SHeiner Kallweit rlen = data - 3; 326025e992a4SHeiner Kallweit data = rlen | (rlen<<4) | (rlen<<8) | (rlen<<12); 32618bfdce1dSHeiner Kallweit phy_write_paged(phydev, 0x0bcd, 0x17, data); 326225e992a4SHeiner Kallweit 326325e992a4SHeiner Kallweit /* disable phy pfm mode */ 32648bfdce1dSHeiner Kallweit phy_modify_paged(phydev, 0x0a44, 0x11, BIT(7), 0); 326525e992a4SHeiner Kallweit 326625e992a4SHeiner Kallweit rtl8168g_disable_aldps(tp); 326725e992a4SHeiner Kallweit rtl8168g_config_eee_phy(tp); 326825e992a4SHeiner Kallweit } 326925e992a4SHeiner Kallweit 3270becd837eSHeiner Kallweit static void rtl8168ep_1_hw_phy_config(struct rtl8169_private *tp, 3271becd837eSHeiner Kallweit struct phy_device *phydev) 327225e992a4SHeiner Kallweit { 327325e992a4SHeiner Kallweit /* Enable PHY auto speed down */ 32748bfdce1dSHeiner Kallweit phy_modify_paged(phydev, 0x0a44, 0x11, 0, BIT(3) | BIT(2)); 327525e992a4SHeiner Kallweit 327625e992a4SHeiner Kallweit rtl8168g_phy_adjust_10m_aldps(tp); 327725e992a4SHeiner Kallweit 327825e992a4SHeiner Kallweit /* Enable EEE auto-fallback function */ 32798bfdce1dSHeiner Kallweit phy_modify_paged(phydev, 0x0a4b, 0x11, 0, BIT(2)); 328025e992a4SHeiner Kallweit 328125e992a4SHeiner Kallweit /* Enable UC LPF tune function */ 32828bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8012, 0x0000, 0x8000); 328325e992a4SHeiner Kallweit 328425e992a4SHeiner Kallweit /* set rg_sel_sdm_rate */ 32858bfdce1dSHeiner Kallweit phy_modify_paged(phydev, 0x0c42, 0x11, BIT(13), BIT(14)); 328625e992a4SHeiner Kallweit 328725e992a4SHeiner Kallweit rtl8168g_disable_aldps(tp); 328825e992a4SHeiner Kallweit rtl8168g_config_eee_phy(tp); 328925e992a4SHeiner Kallweit } 329025e992a4SHeiner Kallweit 3291becd837eSHeiner Kallweit static void rtl8168ep_2_hw_phy_config(struct rtl8169_private *tp, 3292becd837eSHeiner Kallweit struct phy_device *phydev) 329325e992a4SHeiner Kallweit { 329425e992a4SHeiner Kallweit rtl8168g_phy_adjust_10m_aldps(tp); 329525e992a4SHeiner Kallweit 329625e992a4SHeiner Kallweit /* Enable UC LPF tune function */ 32978bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8012, 0x0000, 0x8000); 329825e992a4SHeiner Kallweit 329925e992a4SHeiner Kallweit /* Set rg_sel_sdm_rate */ 3300becd837eSHeiner Kallweit phy_modify_paged(phydev, 0x0c42, 0x11, BIT(13), BIT(14)); 330125e992a4SHeiner Kallweit 330225e992a4SHeiner Kallweit /* Channel estimation parameters */ 33038bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80f3, 0xff00, 0x8b00); 33048bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80f0, 0xff00, 0x3a00); 33058bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80ef, 0xff00, 0x0500); 33068bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80f6, 0xff00, 0x6e00); 33078bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80ec, 0xff00, 0x6800); 33088bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80ed, 0xff00, 0x7c00); 33098bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80f2, 0xff00, 0xf400); 33108bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80f4, 0xff00, 0x8500); 33118bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8110, 0xff00, 0xa800); 33128bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x810f, 0xff00, 0x1d00); 33138bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8111, 0xff00, 0xf500); 33148bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8113, 0xff00, 0x6100); 33158bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8115, 0xff00, 0x9200); 33168bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x810e, 0xff00, 0x0400); 33178bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x810c, 0xff00, 0x7c00); 33188bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x810b, 0xff00, 0x5a00); 33198bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80d1, 0xff00, 0xff00); 33208bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80cd, 0xff00, 0x9e00); 33218bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80d3, 0xff00, 0x0e00); 33228bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80d5, 0xff00, 0xca00); 33238bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80d7, 0xff00, 0x8400); 332425e992a4SHeiner Kallweit 332525e992a4SHeiner Kallweit /* Force PWM-mode */ 332625e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0bcd); 332725e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x5065); 332825e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0xd065); 332925e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0bc8); 333025e992a4SHeiner Kallweit rtl_writephy(tp, 0x12, 0x00ed); 333125e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0bcd); 333225e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x1065); 333325e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x9065); 333425e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x1065); 333525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 333625e992a4SHeiner Kallweit 333725e992a4SHeiner Kallweit rtl8168g_disable_aldps(tp); 333825e992a4SHeiner Kallweit rtl8168g_config_eee_phy(tp); 333925e992a4SHeiner Kallweit } 334025e992a4SHeiner Kallweit 3341becd837eSHeiner Kallweit static void rtl8117_hw_phy_config(struct rtl8169_private *tp, 3342becd837eSHeiner Kallweit struct phy_device *phydev) 33431287723aSHeiner Kallweit { 33441287723aSHeiner Kallweit /* CHN EST parameters adjust - fnet */ 33451287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x808e, 0xff00, 0x4800); 33461287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x8090, 0xff00, 0xcc00); 33471287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x8092, 0xff00, 0xb000); 33481287723aSHeiner Kallweit 33491287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x8088, 0xff00, 0x6000); 33501287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x808b, 0x3f00, 0x0b00); 33511287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x808d, 0x1f00, 0x0600); 33521287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x808c, 0xff00, 0xb000); 33531287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x80a0, 0xff00, 0x2800); 33541287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x80a2, 0xff00, 0x5000); 33551287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x809b, 0xf800, 0xb000); 33561287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x809a, 0xff00, 0x4b00); 33571287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x809d, 0x3f00, 0x0800); 33581287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x80a1, 0xff00, 0x7000); 33591287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x809f, 0x1f00, 0x0300); 33601287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x809e, 0xff00, 0x8800); 33611287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x80b2, 0xff00, 0x2200); 33621287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x80ad, 0xf800, 0x9800); 33631287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x80af, 0x3f00, 0x0800); 33641287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x80b3, 0xff00, 0x6f00); 33651287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x80b1, 0x1f00, 0x0300); 33661287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x80b0, 0xff00, 0x9300); 33671287723aSHeiner Kallweit 33681287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x8011, 0x0000, 0x0800); 33691287723aSHeiner Kallweit 33701287723aSHeiner Kallweit /* enable GPHY 10M */ 3371becd837eSHeiner Kallweit phy_modify_paged(phydev, 0x0a44, 0x11, 0, BIT(11)); 33721287723aSHeiner Kallweit 33731287723aSHeiner Kallweit r8168g_phy_param(phydev, 0x8016, 0x0000, 0x0400); 33741287723aSHeiner Kallweit 33751287723aSHeiner Kallweit rtl8168g_disable_aldps(tp); 33761287723aSHeiner Kallweit rtl8168h_config_eee_phy(tp); 33771287723aSHeiner Kallweit } 33781287723aSHeiner Kallweit 3379becd837eSHeiner Kallweit static void rtl8102e_hw_phy_config(struct rtl8169_private *tp, 3380becd837eSHeiner Kallweit struct phy_device *phydev) 338125e992a4SHeiner Kallweit { 338225e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 338325e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 338425e992a4SHeiner Kallweit { 0x08, 0x441d }, 338525e992a4SHeiner Kallweit { 0x01, 0x9100 }, 338625e992a4SHeiner Kallweit { 0x1f, 0x0000 } 338725e992a4SHeiner Kallweit }; 338825e992a4SHeiner Kallweit 338925e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 339025e992a4SHeiner Kallweit rtl_patchphy(tp, 0x11, 1 << 12); 339125e992a4SHeiner Kallweit rtl_patchphy(tp, 0x19, 1 << 13); 339225e992a4SHeiner Kallweit rtl_patchphy(tp, 0x10, 1 << 15); 339325e992a4SHeiner Kallweit 339425e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 339525e992a4SHeiner Kallweit } 339625e992a4SHeiner Kallweit 3397becd837eSHeiner Kallweit static void rtl8105e_hw_phy_config(struct rtl8169_private *tp, 3398becd837eSHeiner Kallweit struct phy_device *phydev) 339925e992a4SHeiner Kallweit { 340025e992a4SHeiner Kallweit /* Disable ALDPS before ram code */ 3401becd837eSHeiner Kallweit phy_write(phydev, 0x18, 0x0310); 340225e992a4SHeiner Kallweit msleep(100); 340325e992a4SHeiner Kallweit 340425e992a4SHeiner Kallweit rtl_apply_firmware(tp); 340525e992a4SHeiner Kallweit 3406becd837eSHeiner Kallweit phy_write_paged(phydev, 0x0005, 0x1a, 0x0000); 3407becd837eSHeiner Kallweit phy_write_paged(phydev, 0x0004, 0x1c, 0x0000); 3408becd837eSHeiner Kallweit phy_write_paged(phydev, 0x0001, 0x15, 0x7701); 340925e992a4SHeiner Kallweit } 341025e992a4SHeiner Kallweit 3411becd837eSHeiner Kallweit static void rtl8402_hw_phy_config(struct rtl8169_private *tp, 3412becd837eSHeiner Kallweit struct phy_device *phydev) 341325e992a4SHeiner Kallweit { 341425e992a4SHeiner Kallweit /* Disable ALDPS before setting firmware */ 3415becd837eSHeiner Kallweit phy_write(phydev, 0x18, 0x0310); 341625e992a4SHeiner Kallweit msleep(20); 341725e992a4SHeiner Kallweit 341825e992a4SHeiner Kallweit rtl_apply_firmware(tp); 341925e992a4SHeiner Kallweit 342025e992a4SHeiner Kallweit /* EEE setting */ 342125e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1b0, ERIAR_MASK_0011, 0x0000); 342225e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0004); 342325e992a4SHeiner Kallweit rtl_writephy(tp, 0x10, 0x401f); 342425e992a4SHeiner Kallweit rtl_writephy(tp, 0x19, 0x7030); 342525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 342625e992a4SHeiner Kallweit } 342725e992a4SHeiner Kallweit 3428becd837eSHeiner Kallweit static void rtl8106e_hw_phy_config(struct rtl8169_private *tp, 3429becd837eSHeiner Kallweit struct phy_device *phydev) 343025e992a4SHeiner Kallweit { 343125e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 343225e992a4SHeiner Kallweit { 0x1f, 0x0004 }, 343325e992a4SHeiner Kallweit { 0x10, 0xc07f }, 343425e992a4SHeiner Kallweit { 0x19, 0x7030 }, 343525e992a4SHeiner Kallweit { 0x1f, 0x0000 } 343625e992a4SHeiner Kallweit }; 343725e992a4SHeiner Kallweit 343825e992a4SHeiner Kallweit /* Disable ALDPS before ram code */ 3439becd837eSHeiner Kallweit phy_write(phydev, 0x18, 0x0310); 344025e992a4SHeiner Kallweit msleep(100); 344125e992a4SHeiner Kallweit 344225e992a4SHeiner Kallweit rtl_apply_firmware(tp); 344325e992a4SHeiner Kallweit 344425e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1b0, ERIAR_MASK_0011, 0x0000); 344525e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 344625e992a4SHeiner Kallweit 344725e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1d0, ERIAR_MASK_0011, 0x0000); 344825e992a4SHeiner Kallweit } 344925e992a4SHeiner Kallweit 3450becd837eSHeiner Kallweit static void rtl8125_1_hw_phy_config(struct rtl8169_private *tp, 3451becd837eSHeiner Kallweit struct phy_device *phydev) 345202bf642bSHeiner Kallweit { 345302bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad4, 0x10, 0x03ff, 0x0084); 345402bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad4, 0x17, 0x0000, 0x0010); 345502bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad1, 0x13, 0x03ff, 0x0006); 345602bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad3, 0x11, 0x003f, 0x0006); 345702bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xac0, 0x14, 0x0000, 0x1100); 345802bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xac8, 0x15, 0xf000, 0x7000); 345902bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad1, 0x14, 0x0000, 0x0400); 346002bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad1, 0x15, 0x0000, 0x03ff); 346102bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad1, 0x16, 0x0000, 0x03ff); 346202bf642bSHeiner Kallweit 34638bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80ea, 0xff00, 0xc400); 34648bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80eb, 0x0700, 0x0300); 34658bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80f8, 0xff00, 0x1c00); 34668bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80f1, 0xff00, 0x3000); 34678bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80fe, 0xff00, 0xa500); 34688bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8102, 0xff00, 0x5000); 34698bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8105, 0xff00, 0x3300); 34708bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8100, 0xff00, 0x7000); 34718bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8104, 0xff00, 0xf000); 34728bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8106, 0xff00, 0x6500); 34738bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80dc, 0xff00, 0xed00); 34748bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80df, 0x0000, 0x0100); 34758bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80e1, 0x0100, 0x0000); 347602bf642bSHeiner Kallweit 347702bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xbf0, 0x13, 0x003f, 0x0038); 34788bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x819f, 0xffff, 0xd0b6); 347902bf642bSHeiner Kallweit 348002bf642bSHeiner Kallweit phy_write_paged(phydev, 0xbc3, 0x12, 0x5555); 348102bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xbf0, 0x15, 0x0e00, 0x0a00); 348202bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xa5c, 0x10, 0x0400, 0x0000); 348302bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xa44, 0x11, 0x0000, 0x0800); 3484b3a42e3aSHeiner Kallweit 3485b3a42e3aSHeiner Kallweit rtl8125_config_eee_phy(tp); 348602bf642bSHeiner Kallweit } 348702bf642bSHeiner Kallweit 3488becd837eSHeiner Kallweit static void rtl8125_2_hw_phy_config(struct rtl8169_private *tp, 3489becd837eSHeiner Kallweit struct phy_device *phydev) 349002bf642bSHeiner Kallweit { 349102bf642bSHeiner Kallweit int i; 349202bf642bSHeiner Kallweit 349302bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad4, 0x17, 0x0000, 0x0010); 349402bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad1, 0x13, 0x03ff, 0x03ff); 349502bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad3, 0x11, 0x003f, 0x0006); 349602bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xac0, 0x14, 0x1100, 0x0000); 349702bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xacc, 0x10, 0x0003, 0x0002); 349802bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad4, 0x10, 0x00e7, 0x0044); 349902bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xac1, 0x12, 0x0080, 0x0000); 350002bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xac8, 0x10, 0x0300, 0x0000); 350102bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xac5, 0x17, 0x0007, 0x0002); 350202bf642bSHeiner Kallweit phy_write_paged(phydev, 0xad4, 0x16, 0x00a8); 350302bf642bSHeiner Kallweit phy_write_paged(phydev, 0xac5, 0x16, 0x01ff); 350402bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xac8, 0x15, 0x00f0, 0x0030); 350502bf642bSHeiner Kallweit 350602bf642bSHeiner Kallweit phy_write(phydev, 0x1f, 0x0b87); 350702bf642bSHeiner Kallweit phy_write(phydev, 0x16, 0x80a2); 350802bf642bSHeiner Kallweit phy_write(phydev, 0x17, 0x0153); 350902bf642bSHeiner Kallweit phy_write(phydev, 0x16, 0x809c); 351002bf642bSHeiner Kallweit phy_write(phydev, 0x17, 0x0153); 351102bf642bSHeiner Kallweit phy_write(phydev, 0x1f, 0x0000); 351202bf642bSHeiner Kallweit 351302bf642bSHeiner Kallweit phy_write(phydev, 0x1f, 0x0a43); 351402bf642bSHeiner Kallweit phy_write(phydev, 0x13, 0x81B3); 351502bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x0043); 351602bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x00A7); 351702bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x00D6); 351802bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x00EC); 351902bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x00F6); 352002bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x00FB); 352102bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x00FD); 352202bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x00FF); 352302bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x00BB); 352402bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x0058); 352502bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x0029); 352602bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x0013); 352702bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x0009); 352802bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x0004); 352902bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x0002); 353002bf642bSHeiner Kallweit for (i = 0; i < 25; i++) 353102bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x0000); 353202bf642bSHeiner Kallweit phy_write(phydev, 0x1f, 0x0000); 353302bf642bSHeiner Kallweit 35348bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8257, 0xffff, 0x020F); 35358bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80ea, 0xffff, 0x7843); 35368bfdce1dSHeiner Kallweit 353702bf642bSHeiner Kallweit rtl_apply_firmware(tp); 353802bf642bSHeiner Kallweit 353902bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xd06, 0x14, 0x0000, 0x2000); 354002bf642bSHeiner Kallweit 35418bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x81a2, 0x0000, 0x0100); 354202bf642bSHeiner Kallweit 354302bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xb54, 0x16, 0xff00, 0xdb00); 354402bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xa45, 0x12, 0x0001, 0x0000); 354502bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xa5d, 0x12, 0x0000, 0x0020); 354602bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad4, 0x17, 0x0010, 0x0000); 354702bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xa86, 0x15, 0x0001, 0x0000); 354802bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xa44, 0x11, 0x0000, 0x0800); 3549b3a42e3aSHeiner Kallweit 3550b3a42e3aSHeiner Kallweit rtl8125_config_eee_phy(tp); 355102bf642bSHeiner Kallweit } 355202bf642bSHeiner Kallweit 3553becd837eSHeiner Kallweit static void r8169_hw_phy_config(struct rtl8169_private *tp, 3554becd837eSHeiner Kallweit struct phy_device *phydev, 3555becd837eSHeiner Kallweit enum mac_version ver) 355625e992a4SHeiner Kallweit { 3557becd837eSHeiner Kallweit static const rtl_phy_cfg_fct phy_configs[] = { 355825e992a4SHeiner Kallweit /* PCI devices. */ 355925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_02] = rtl8169s_hw_phy_config, 356025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_03] = rtl8169s_hw_phy_config, 356125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_04] = rtl8169sb_hw_phy_config, 356225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_05] = rtl8169scd_hw_phy_config, 356325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_06] = rtl8169sce_hw_phy_config, 356425e992a4SHeiner Kallweit /* PCI-E devices. */ 356525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_07] = rtl8102e_hw_phy_config, 356625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_08] = rtl8102e_hw_phy_config, 356725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_09] = rtl8102e_hw_phy_config, 356825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_10] = NULL, 356925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_11] = rtl8168bb_hw_phy_config, 357025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_12] = rtl8168bef_hw_phy_config, 357125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_13] = NULL, 357225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_14] = NULL, 357325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_15] = NULL, 357425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_16] = NULL, 357525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_17] = rtl8168bef_hw_phy_config, 357625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_18] = rtl8168cp_1_hw_phy_config, 357725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_19] = rtl8168c_1_hw_phy_config, 357825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_20] = rtl8168c_2_hw_phy_config, 357925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_21] = rtl8168c_3_hw_phy_config, 3580afa26427SHeiner Kallweit [RTL_GIGA_MAC_VER_22] = rtl8168c_3_hw_phy_config, 358125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_23] = rtl8168cp_2_hw_phy_config, 358225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_24] = rtl8168cp_2_hw_phy_config, 358325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_25] = rtl8168d_1_hw_phy_config, 358425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_26] = rtl8168d_2_hw_phy_config, 358525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_27] = rtl8168d_3_hw_phy_config, 358625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_28] = rtl8168d_4_hw_phy_config, 358725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_29] = rtl8105e_hw_phy_config, 358825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_30] = rtl8105e_hw_phy_config, 358925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_31] = NULL, 359025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_32] = rtl8168e_1_hw_phy_config, 359125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_33] = rtl8168e_1_hw_phy_config, 359225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_34] = rtl8168e_2_hw_phy_config, 359325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_35] = rtl8168f_1_hw_phy_config, 359425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_36] = rtl8168f_2_hw_phy_config, 359525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_37] = rtl8402_hw_phy_config, 359625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_38] = rtl8411_hw_phy_config, 359725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_39] = rtl8106e_hw_phy_config, 359825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_40] = rtl8168g_1_hw_phy_config, 359925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_41] = NULL, 360025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_42] = rtl8168g_2_hw_phy_config, 360125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_43] = rtl8168g_2_hw_phy_config, 360225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_44] = rtl8168g_2_hw_phy_config, 360325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_45] = rtl8168h_1_hw_phy_config, 360425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_46] = rtl8168h_2_hw_phy_config, 360525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_47] = rtl8168h_1_hw_phy_config, 360625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_48] = rtl8168h_2_hw_phy_config, 360725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_49] = rtl8168ep_1_hw_phy_config, 360825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_50] = rtl8168ep_2_hw_phy_config, 360925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_51] = rtl8168ep_2_hw_phy_config, 36101287723aSHeiner Kallweit [RTL_GIGA_MAC_VER_52] = rtl8117_hw_phy_config, 361102bf642bSHeiner Kallweit [RTL_GIGA_MAC_VER_60] = rtl8125_1_hw_phy_config, 361202bf642bSHeiner Kallweit [RTL_GIGA_MAC_VER_61] = rtl8125_2_hw_phy_config, 361325e992a4SHeiner Kallweit }; 361425e992a4SHeiner Kallweit 3615becd837eSHeiner Kallweit if (phy_configs[ver]) 3616becd837eSHeiner Kallweit phy_configs[ver](tp, phydev); 361725e992a4SHeiner Kallweit } 361825e992a4SHeiner Kallweit 361925e992a4SHeiner Kallweit static void rtl_schedule_task(struct rtl8169_private *tp, enum rtl_flag flag) 362025e992a4SHeiner Kallweit { 362125e992a4SHeiner Kallweit if (!test_and_set_bit(flag, tp->wk.flags)) 362225e992a4SHeiner Kallweit schedule_work(&tp->wk.work); 362325e992a4SHeiner Kallweit } 362425e992a4SHeiner Kallweit 3625b5aed0b3SHeiner Kallweit static void rtl8169_init_phy(struct rtl8169_private *tp) 362625e992a4SHeiner Kallweit { 3627becd837eSHeiner Kallweit r8169_hw_phy_config(tp, tp->phydev, tp->mac_version); 362825e992a4SHeiner Kallweit 362925e992a4SHeiner Kallweit if (tp->mac_version <= RTL_GIGA_MAC_VER_06) { 363025e992a4SHeiner Kallweit pci_write_config_byte(tp->pci_dev, PCI_LATENCY_TIMER, 0x40); 363125e992a4SHeiner Kallweit pci_write_config_byte(tp->pci_dev, PCI_CACHE_LINE_SIZE, 0x08); 3632b5aed0b3SHeiner Kallweit /* set undocumented MAC Reg C+CR Offset 0x82h */ 363325e992a4SHeiner Kallweit RTL_W8(tp, 0x82, 0x01); 363425e992a4SHeiner Kallweit } 363525e992a4SHeiner Kallweit 363625e992a4SHeiner Kallweit /* We may have called phy_speed_down before */ 363725e992a4SHeiner Kallweit phy_speed_up(tp->phydev); 363825e992a4SHeiner Kallweit 3639af779778SHeiner Kallweit if (rtl_supports_eee(tp)) 3640af779778SHeiner Kallweit rtl_enable_eee(tp); 3641af779778SHeiner Kallweit 364225e992a4SHeiner Kallweit genphy_soft_reset(tp->phydev); 364325e992a4SHeiner Kallweit } 364425e992a4SHeiner Kallweit 364525e992a4SHeiner Kallweit static void rtl_rar_set(struct rtl8169_private *tp, u8 *addr) 364625e992a4SHeiner Kallweit { 364725e992a4SHeiner Kallweit rtl_lock_work(tp); 364825e992a4SHeiner Kallweit 364925e992a4SHeiner Kallweit rtl_unlock_config_regs(tp); 365025e992a4SHeiner Kallweit 365125e992a4SHeiner Kallweit RTL_W32(tp, MAC4, addr[4] | addr[5] << 8); 365225e992a4SHeiner Kallweit RTL_R32(tp, MAC4); 365325e992a4SHeiner Kallweit 365425e992a4SHeiner Kallweit RTL_W32(tp, MAC0, addr[0] | addr[1] << 8 | addr[2] << 16 | addr[3] << 24); 365525e992a4SHeiner Kallweit RTL_R32(tp, MAC0); 365625e992a4SHeiner Kallweit 365725e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_34) 365825e992a4SHeiner Kallweit rtl_rar_exgmac_set(tp, addr); 365925e992a4SHeiner Kallweit 366025e992a4SHeiner Kallweit rtl_lock_config_regs(tp); 366125e992a4SHeiner Kallweit 366225e992a4SHeiner Kallweit rtl_unlock_work(tp); 366325e992a4SHeiner Kallweit } 366425e992a4SHeiner Kallweit 366525e992a4SHeiner Kallweit static int rtl_set_mac_address(struct net_device *dev, void *p) 366625e992a4SHeiner Kallweit { 366725e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 366825e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 366925e992a4SHeiner Kallweit int ret; 367025e992a4SHeiner Kallweit 367125e992a4SHeiner Kallweit ret = eth_mac_addr(dev, p); 367225e992a4SHeiner Kallweit if (ret) 367325e992a4SHeiner Kallweit return ret; 367425e992a4SHeiner Kallweit 367525e992a4SHeiner Kallweit pm_runtime_get_noresume(d); 367625e992a4SHeiner Kallweit 367725e992a4SHeiner Kallweit if (pm_runtime_active(d)) 367825e992a4SHeiner Kallweit rtl_rar_set(tp, dev->dev_addr); 367925e992a4SHeiner Kallweit 368025e992a4SHeiner Kallweit pm_runtime_put_noidle(d); 368125e992a4SHeiner Kallweit 368225e992a4SHeiner Kallweit return 0; 368325e992a4SHeiner Kallweit } 368425e992a4SHeiner Kallweit 368525e992a4SHeiner Kallweit static int rtl8169_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 368625e992a4SHeiner Kallweit { 368725e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 368825e992a4SHeiner Kallweit 368925e992a4SHeiner Kallweit if (!netif_running(dev)) 369025e992a4SHeiner Kallweit return -ENODEV; 369125e992a4SHeiner Kallweit 369225e992a4SHeiner Kallweit return phy_mii_ioctl(tp->phydev, ifr, cmd); 369325e992a4SHeiner Kallweit } 369425e992a4SHeiner Kallweit 369525e992a4SHeiner Kallweit static void rtl_wol_suspend_quirk(struct rtl8169_private *tp) 369625e992a4SHeiner Kallweit { 369725e992a4SHeiner Kallweit switch (tp->mac_version) { 369825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_25: 369925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_26: 370025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_29: 370125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_30: 370225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_32: 370325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_33: 370425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_34: 370500222d13SHeiner Kallweit case RTL_GIGA_MAC_VER_37 ... RTL_GIGA_MAC_VER_61: 370625e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, RTL_R32(tp, RxConfig) | 370725e992a4SHeiner Kallweit AcceptBroadcast | AcceptMulticast | AcceptMyPhys); 370825e992a4SHeiner Kallweit break; 370925e992a4SHeiner Kallweit default: 371025e992a4SHeiner Kallweit break; 371125e992a4SHeiner Kallweit } 371225e992a4SHeiner Kallweit } 371325e992a4SHeiner Kallweit 371425e992a4SHeiner Kallweit static void rtl_pll_power_down(struct rtl8169_private *tp) 371525e992a4SHeiner Kallweit { 371625e992a4SHeiner Kallweit if (r8168_check_dash(tp)) 371725e992a4SHeiner Kallweit return; 371825e992a4SHeiner Kallweit 371925e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_32 || 372025e992a4SHeiner Kallweit tp->mac_version == RTL_GIGA_MAC_VER_33) 372125e992a4SHeiner Kallweit rtl_ephy_write(tp, 0x19, 0xff64); 372225e992a4SHeiner Kallweit 372325e992a4SHeiner Kallweit if (device_may_wakeup(tp_to_dev(tp))) { 372425e992a4SHeiner Kallweit phy_speed_down(tp->phydev, false); 372525e992a4SHeiner Kallweit rtl_wol_suspend_quirk(tp); 372625e992a4SHeiner Kallweit return; 372725e992a4SHeiner Kallweit } 372825e992a4SHeiner Kallweit 372925e992a4SHeiner Kallweit switch (tp->mac_version) { 373025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_25 ... RTL_GIGA_MAC_VER_33: 373125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_37: 373225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_39: 373325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_43: 373425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_44: 373525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_45: 373625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_46: 373725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_47: 373825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_48: 373925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_50: 374025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_51: 37411287723aSHeiner Kallweit case RTL_GIGA_MAC_VER_52: 3742f1bce4adSHeiner Kallweit case RTL_GIGA_MAC_VER_60: 3743f1bce4adSHeiner Kallweit case RTL_GIGA_MAC_VER_61: 374425e992a4SHeiner Kallweit RTL_W8(tp, PMCH, RTL_R8(tp, PMCH) & ~0x80); 374525e992a4SHeiner Kallweit break; 374625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_40: 374725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_41: 374825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_49: 374925e992a4SHeiner Kallweit rtl_eri_clear_bits(tp, 0x1a8, ERIAR_MASK_1111, 0xfc000000); 375025e992a4SHeiner Kallweit RTL_W8(tp, PMCH, RTL_R8(tp, PMCH) & ~0x80); 375125e992a4SHeiner Kallweit break; 375225e992a4SHeiner Kallweit default: 375325e992a4SHeiner Kallweit break; 375425e992a4SHeiner Kallweit } 375525e992a4SHeiner Kallweit } 375625e992a4SHeiner Kallweit 375725e992a4SHeiner Kallweit static void rtl_pll_power_up(struct rtl8169_private *tp) 375825e992a4SHeiner Kallweit { 375925e992a4SHeiner Kallweit switch (tp->mac_version) { 376025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_25 ... RTL_GIGA_MAC_VER_33: 376125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_37: 376225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_39: 376325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_43: 376425e992a4SHeiner Kallweit RTL_W8(tp, PMCH, RTL_R8(tp, PMCH) | 0x80); 376525e992a4SHeiner Kallweit break; 376625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_44: 376725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_45: 376825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_46: 376925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_47: 377025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_48: 377125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_50: 377225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_51: 37731287723aSHeiner Kallweit case RTL_GIGA_MAC_VER_52: 3774f1bce4adSHeiner Kallweit case RTL_GIGA_MAC_VER_60: 3775f1bce4adSHeiner Kallweit case RTL_GIGA_MAC_VER_61: 377625e992a4SHeiner Kallweit RTL_W8(tp, PMCH, RTL_R8(tp, PMCH) | 0xc0); 377725e992a4SHeiner Kallweit break; 377825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_40: 377925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_41: 378025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_49: 378125e992a4SHeiner Kallweit RTL_W8(tp, PMCH, RTL_R8(tp, PMCH) | 0xc0); 378225e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0x1a8, ERIAR_MASK_1111, 0xfc000000); 378325e992a4SHeiner Kallweit break; 378425e992a4SHeiner Kallweit default: 378525e992a4SHeiner Kallweit break; 378625e992a4SHeiner Kallweit } 378725e992a4SHeiner Kallweit 378825e992a4SHeiner Kallweit phy_resume(tp->phydev); 378925e992a4SHeiner Kallweit /* give MAC/PHY some time to resume */ 379025e992a4SHeiner Kallweit msleep(20); 379125e992a4SHeiner Kallweit } 379225e992a4SHeiner Kallweit 379325e992a4SHeiner Kallweit static void rtl_init_rxcfg(struct rtl8169_private *tp) 379425e992a4SHeiner Kallweit { 379525e992a4SHeiner Kallweit switch (tp->mac_version) { 379625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_02 ... RTL_GIGA_MAC_VER_06: 379725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_10 ... RTL_GIGA_MAC_VER_17: 379825e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, RX_FIFO_THRESH | RX_DMA_BURST); 379925e992a4SHeiner Kallweit break; 380025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_18 ... RTL_GIGA_MAC_VER_24: 380125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_34 ... RTL_GIGA_MAC_VER_36: 380225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_38: 380325e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, RX128_INT_EN | RX_MULTI_EN | RX_DMA_BURST); 380425e992a4SHeiner Kallweit break; 38051287723aSHeiner Kallweit case RTL_GIGA_MAC_VER_40 ... RTL_GIGA_MAC_VER_52: 380625e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, RX128_INT_EN | RX_MULTI_EN | RX_DMA_BURST | RX_EARLY_OFF); 380725e992a4SHeiner Kallweit break; 3808f1bce4adSHeiner Kallweit case RTL_GIGA_MAC_VER_60 ... RTL_GIGA_MAC_VER_61: 3809f1bce4adSHeiner Kallweit RTL_W32(tp, RxConfig, RX_FETCH_DFLT_8125 | RX_VLAN_8125 | 3810f1bce4adSHeiner Kallweit RX_DMA_BURST); 3811f1bce4adSHeiner Kallweit break; 381225e992a4SHeiner Kallweit default: 381325e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, RX128_INT_EN | RX_DMA_BURST); 381425e992a4SHeiner Kallweit break; 381525e992a4SHeiner Kallweit } 381625e992a4SHeiner Kallweit } 381725e992a4SHeiner Kallweit 381825e992a4SHeiner Kallweit static void rtl8169_init_ring_indexes(struct rtl8169_private *tp) 381925e992a4SHeiner Kallweit { 382025e992a4SHeiner Kallweit tp->dirty_tx = tp->cur_tx = tp->cur_rx = 0; 382125e992a4SHeiner Kallweit } 382225e992a4SHeiner Kallweit 382325e992a4SHeiner Kallweit static void r8168c_hw_jumbo_enable(struct rtl8169_private *tp) 382425e992a4SHeiner Kallweit { 382525e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) | Jumbo_En0); 382625e992a4SHeiner Kallweit RTL_W8(tp, Config4, RTL_R8(tp, Config4) | Jumbo_En1); 382725e992a4SHeiner Kallweit } 382825e992a4SHeiner Kallweit 382925e992a4SHeiner Kallweit static void r8168c_hw_jumbo_disable(struct rtl8169_private *tp) 383025e992a4SHeiner Kallweit { 383125e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Jumbo_En0); 383225e992a4SHeiner Kallweit RTL_W8(tp, Config4, RTL_R8(tp, Config4) & ~Jumbo_En1); 383325e992a4SHeiner Kallweit } 383425e992a4SHeiner Kallweit 383525e992a4SHeiner Kallweit static void r8168dp_hw_jumbo_enable(struct rtl8169_private *tp) 383625e992a4SHeiner Kallweit { 383725e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) | Jumbo_En0); 383825e992a4SHeiner Kallweit } 383925e992a4SHeiner Kallweit 384025e992a4SHeiner Kallweit static void r8168dp_hw_jumbo_disable(struct rtl8169_private *tp) 384125e992a4SHeiner Kallweit { 384225e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Jumbo_En0); 384325e992a4SHeiner Kallweit } 384425e992a4SHeiner Kallweit 384525e992a4SHeiner Kallweit static void r8168e_hw_jumbo_enable(struct rtl8169_private *tp) 384625e992a4SHeiner Kallweit { 384725e992a4SHeiner Kallweit RTL_W8(tp, MaxTxPacketSize, 0x3f); 384825e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) | Jumbo_En0); 384925e992a4SHeiner Kallweit RTL_W8(tp, Config4, RTL_R8(tp, Config4) | 0x01); 385025e992a4SHeiner Kallweit } 385125e992a4SHeiner Kallweit 385225e992a4SHeiner Kallweit static void r8168e_hw_jumbo_disable(struct rtl8169_private *tp) 385325e992a4SHeiner Kallweit { 385425e992a4SHeiner Kallweit RTL_W8(tp, MaxTxPacketSize, 0x0c); 385525e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Jumbo_En0); 385625e992a4SHeiner Kallweit RTL_W8(tp, Config4, RTL_R8(tp, Config4) & ~0x01); 385725e992a4SHeiner Kallweit } 385825e992a4SHeiner Kallweit 385925e992a4SHeiner Kallweit static void r8168b_1_hw_jumbo_enable(struct rtl8169_private *tp) 386025e992a4SHeiner Kallweit { 386125e992a4SHeiner Kallweit RTL_W8(tp, Config4, RTL_R8(tp, Config4) | (1 << 0)); 386225e992a4SHeiner Kallweit } 386325e992a4SHeiner Kallweit 386425e992a4SHeiner Kallweit static void r8168b_1_hw_jumbo_disable(struct rtl8169_private *tp) 386525e992a4SHeiner Kallweit { 386625e992a4SHeiner Kallweit RTL_W8(tp, Config4, RTL_R8(tp, Config4) & ~(1 << 0)); 386725e992a4SHeiner Kallweit } 386825e992a4SHeiner Kallweit 386925e992a4SHeiner Kallweit static void rtl_hw_jumbo_enable(struct rtl8169_private *tp) 387025e992a4SHeiner Kallweit { 387125e992a4SHeiner Kallweit rtl_unlock_config_regs(tp); 387225e992a4SHeiner Kallweit switch (tp->mac_version) { 387325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_12: 387425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_17: 387525e992a4SHeiner Kallweit r8168b_1_hw_jumbo_enable(tp); 387625e992a4SHeiner Kallweit break; 387725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_18 ... RTL_GIGA_MAC_VER_26: 387825e992a4SHeiner Kallweit r8168c_hw_jumbo_enable(tp); 387925e992a4SHeiner Kallweit break; 388025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27 ... RTL_GIGA_MAC_VER_28: 388125e992a4SHeiner Kallweit r8168dp_hw_jumbo_enable(tp); 388225e992a4SHeiner Kallweit break; 388314012c9fSHeiner Kallweit case RTL_GIGA_MAC_VER_31 ... RTL_GIGA_MAC_VER_33: 388425e992a4SHeiner Kallweit r8168e_hw_jumbo_enable(tp); 388525e992a4SHeiner Kallweit break; 388625e992a4SHeiner Kallweit default: 388725e992a4SHeiner Kallweit break; 388825e992a4SHeiner Kallweit } 388925e992a4SHeiner Kallweit rtl_lock_config_regs(tp); 389025e992a4SHeiner Kallweit } 389125e992a4SHeiner Kallweit 389225e992a4SHeiner Kallweit static void rtl_hw_jumbo_disable(struct rtl8169_private *tp) 389325e992a4SHeiner Kallweit { 389425e992a4SHeiner Kallweit rtl_unlock_config_regs(tp); 389525e992a4SHeiner Kallweit switch (tp->mac_version) { 389625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_12: 389725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_17: 389825e992a4SHeiner Kallweit r8168b_1_hw_jumbo_disable(tp); 389925e992a4SHeiner Kallweit break; 390025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_18 ... RTL_GIGA_MAC_VER_26: 390125e992a4SHeiner Kallweit r8168c_hw_jumbo_disable(tp); 390225e992a4SHeiner Kallweit break; 390325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27 ... RTL_GIGA_MAC_VER_28: 390425e992a4SHeiner Kallweit r8168dp_hw_jumbo_disable(tp); 390525e992a4SHeiner Kallweit break; 39060fc75219SHeiner Kallweit case RTL_GIGA_MAC_VER_31 ... RTL_GIGA_MAC_VER_33: 390725e992a4SHeiner Kallweit r8168e_hw_jumbo_disable(tp); 390825e992a4SHeiner Kallweit break; 390925e992a4SHeiner Kallweit default: 391025e992a4SHeiner Kallweit break; 391125e992a4SHeiner Kallweit } 391225e992a4SHeiner Kallweit rtl_lock_config_regs(tp); 391325e992a4SHeiner Kallweit } 391425e992a4SHeiner Kallweit 39154ebcb113SHeiner Kallweit static void rtl_jumbo_config(struct rtl8169_private *tp, int mtu) 39164ebcb113SHeiner Kallweit { 39174ebcb113SHeiner Kallweit if (mtu > ETH_DATA_LEN) 39184ebcb113SHeiner Kallweit rtl_hw_jumbo_enable(tp); 39194ebcb113SHeiner Kallweit else 39204ebcb113SHeiner Kallweit rtl_hw_jumbo_disable(tp); 39214ebcb113SHeiner Kallweit } 39224ebcb113SHeiner Kallweit 392325e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_chipcmd_cond) 392425e992a4SHeiner Kallweit { 392525e992a4SHeiner Kallweit return RTL_R8(tp, ChipCmd) & CmdReset; 392625e992a4SHeiner Kallweit } 392725e992a4SHeiner Kallweit 392825e992a4SHeiner Kallweit static void rtl_hw_reset(struct rtl8169_private *tp) 392925e992a4SHeiner Kallweit { 393025e992a4SHeiner Kallweit RTL_W8(tp, ChipCmd, CmdReset); 393125e992a4SHeiner Kallweit 393225e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_chipcmd_cond, 100, 100); 393325e992a4SHeiner Kallweit } 393425e992a4SHeiner Kallweit 393525e992a4SHeiner Kallweit static void rtl_request_firmware(struct rtl8169_private *tp) 393625e992a4SHeiner Kallweit { 393725e992a4SHeiner Kallweit struct rtl_fw *rtl_fw; 393825e992a4SHeiner Kallweit 393925e992a4SHeiner Kallweit /* firmware loaded already or no firmware available */ 394025e992a4SHeiner Kallweit if (tp->rtl_fw || !tp->fw_name) 394125e992a4SHeiner Kallweit return; 394225e992a4SHeiner Kallweit 394325e992a4SHeiner Kallweit rtl_fw = kzalloc(sizeof(*rtl_fw), GFP_KERNEL); 394425e992a4SHeiner Kallweit if (!rtl_fw) { 394525e992a4SHeiner Kallweit netif_warn(tp, ifup, tp->dev, "Unable to load firmware, out of memory\n"); 394625e992a4SHeiner Kallweit return; 394725e992a4SHeiner Kallweit } 394825e992a4SHeiner Kallweit 394925e992a4SHeiner Kallweit rtl_fw->phy_write = rtl_writephy; 395025e992a4SHeiner Kallweit rtl_fw->phy_read = rtl_readphy; 395125e992a4SHeiner Kallweit rtl_fw->mac_mcu_write = mac_mcu_write; 395225e992a4SHeiner Kallweit rtl_fw->mac_mcu_read = mac_mcu_read; 395325e992a4SHeiner Kallweit rtl_fw->fw_name = tp->fw_name; 395425e992a4SHeiner Kallweit rtl_fw->dev = tp_to_dev(tp); 395525e992a4SHeiner Kallweit 395625e992a4SHeiner Kallweit if (rtl_fw_request_firmware(rtl_fw)) 395725e992a4SHeiner Kallweit kfree(rtl_fw); 395825e992a4SHeiner Kallweit else 395925e992a4SHeiner Kallweit tp->rtl_fw = rtl_fw; 396025e992a4SHeiner Kallweit } 396125e992a4SHeiner Kallweit 396225e992a4SHeiner Kallweit static void rtl_rx_close(struct rtl8169_private *tp) 396325e992a4SHeiner Kallweit { 396425e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, RTL_R32(tp, RxConfig) & ~RX_CONFIG_ACCEPT_MASK); 396525e992a4SHeiner Kallweit } 396625e992a4SHeiner Kallweit 396725e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_npq_cond) 396825e992a4SHeiner Kallweit { 396925e992a4SHeiner Kallweit return RTL_R8(tp, TxPoll) & NPQ; 397025e992a4SHeiner Kallweit } 397125e992a4SHeiner Kallweit 397225e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_txcfg_empty_cond) 397325e992a4SHeiner Kallweit { 397425e992a4SHeiner Kallweit return RTL_R32(tp, TxConfig) & TXCFG_EMPTY; 397525e992a4SHeiner Kallweit } 397625e992a4SHeiner Kallweit 397725e992a4SHeiner Kallweit static void rtl8169_hw_reset(struct rtl8169_private *tp) 397825e992a4SHeiner Kallweit { 397925e992a4SHeiner Kallweit /* Disable interrupts */ 398025e992a4SHeiner Kallweit rtl8169_irq_mask_and_ack(tp); 398125e992a4SHeiner Kallweit 398225e992a4SHeiner Kallweit rtl_rx_close(tp); 398325e992a4SHeiner Kallweit 398425e992a4SHeiner Kallweit switch (tp->mac_version) { 398525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27: 398625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_28: 398725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31: 398825e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_npq_cond, 20, 42*42); 398925e992a4SHeiner Kallweit break; 399025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_34 ... RTL_GIGA_MAC_VER_38: 39911287723aSHeiner Kallweit case RTL_GIGA_MAC_VER_40 ... RTL_GIGA_MAC_VER_52: 399225e992a4SHeiner Kallweit RTL_W8(tp, ChipCmd, RTL_R8(tp, ChipCmd) | StopReq); 399325e992a4SHeiner Kallweit rtl_udelay_loop_wait_high(tp, &rtl_txcfg_empty_cond, 100, 666); 399425e992a4SHeiner Kallweit break; 399525e992a4SHeiner Kallweit default: 399625e992a4SHeiner Kallweit RTL_W8(tp, ChipCmd, RTL_R8(tp, ChipCmd) | StopReq); 399725e992a4SHeiner Kallweit udelay(100); 399825e992a4SHeiner Kallweit break; 399925e992a4SHeiner Kallweit } 400025e992a4SHeiner Kallweit 400125e992a4SHeiner Kallweit rtl_hw_reset(tp); 400225e992a4SHeiner Kallweit } 400325e992a4SHeiner Kallweit 400425e992a4SHeiner Kallweit static void rtl_set_tx_config_registers(struct rtl8169_private *tp) 400525e992a4SHeiner Kallweit { 400625e992a4SHeiner Kallweit u32 val = TX_DMA_BURST << TxDMAShift | 400725e992a4SHeiner Kallweit InterFrameGap << TxInterFrameGapShift; 400825e992a4SHeiner Kallweit 40099e9f33baSHeiner Kallweit if (rtl_is_8168evl_up(tp)) 401025e992a4SHeiner Kallweit val |= TXCFG_AUTO_FIFO; 401125e992a4SHeiner Kallweit 401225e992a4SHeiner Kallweit RTL_W32(tp, TxConfig, val); 401325e992a4SHeiner Kallweit } 401425e992a4SHeiner Kallweit 401525e992a4SHeiner Kallweit static void rtl_set_rx_max_size(struct rtl8169_private *tp) 401625e992a4SHeiner Kallweit { 401725e992a4SHeiner Kallweit /* Low hurts. Let's disable the filtering. */ 401825e992a4SHeiner Kallweit RTL_W16(tp, RxMaxSize, R8169_RX_BUF_SIZE + 1); 401925e992a4SHeiner Kallweit } 402025e992a4SHeiner Kallweit 402125e992a4SHeiner Kallweit static void rtl_set_rx_tx_desc_registers(struct rtl8169_private *tp) 402225e992a4SHeiner Kallweit { 402325e992a4SHeiner Kallweit /* 402425e992a4SHeiner Kallweit * Magic spell: some iop3xx ARM board needs the TxDescAddrHigh 402525e992a4SHeiner Kallweit * register to be written before TxDescAddrLow to work. 402625e992a4SHeiner Kallweit * Switching from MMIO to I/O access fixes the issue as well. 402725e992a4SHeiner Kallweit */ 402825e992a4SHeiner Kallweit RTL_W32(tp, TxDescStartAddrHigh, ((u64) tp->TxPhyAddr) >> 32); 402925e992a4SHeiner Kallweit RTL_W32(tp, TxDescStartAddrLow, ((u64) tp->TxPhyAddr) & DMA_BIT_MASK(32)); 403025e992a4SHeiner Kallweit RTL_W32(tp, RxDescAddrHigh, ((u64) tp->RxPhyAddr) >> 32); 403125e992a4SHeiner Kallweit RTL_W32(tp, RxDescAddrLow, ((u64) tp->RxPhyAddr) & DMA_BIT_MASK(32)); 403225e992a4SHeiner Kallweit } 403325e992a4SHeiner Kallweit 403425e992a4SHeiner Kallweit static void rtl8169_set_magic_reg(struct rtl8169_private *tp, unsigned mac_version) 403525e992a4SHeiner Kallweit { 403625e992a4SHeiner Kallweit u32 val; 403725e992a4SHeiner Kallweit 403825e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_05) 403925e992a4SHeiner Kallweit val = 0x000fff00; 404025e992a4SHeiner Kallweit else if (tp->mac_version == RTL_GIGA_MAC_VER_06) 404125e992a4SHeiner Kallweit val = 0x00ffff00; 404225e992a4SHeiner Kallweit else 404325e992a4SHeiner Kallweit return; 404425e992a4SHeiner Kallweit 404525e992a4SHeiner Kallweit if (RTL_R8(tp, Config2) & PCI_Clock_66MHz) 404625e992a4SHeiner Kallweit val |= 0xff; 404725e992a4SHeiner Kallweit 404825e992a4SHeiner Kallweit RTL_W32(tp, 0x7c, val); 404925e992a4SHeiner Kallweit } 405025e992a4SHeiner Kallweit 405125e992a4SHeiner Kallweit static void rtl_set_rx_mode(struct net_device *dev) 405225e992a4SHeiner Kallweit { 405381cd17a4SHeiner Kallweit u32 rx_mode = AcceptBroadcast | AcceptMyPhys | AcceptMulticast; 405481cd17a4SHeiner Kallweit /* Multicast hash filter */ 405581cd17a4SHeiner Kallweit u32 mc_filter[2] = { 0xffffffff, 0xffffffff }; 405625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 405781cd17a4SHeiner Kallweit u32 tmp; 405825e992a4SHeiner Kallweit 405925e992a4SHeiner Kallweit if (dev->flags & IFF_PROMISC) { 406025e992a4SHeiner Kallweit /* Unconditionally log net taps. */ 406125e992a4SHeiner Kallweit netif_notice(tp, link, dev, "Promiscuous mode enabled\n"); 406281cd17a4SHeiner Kallweit rx_mode |= AcceptAllPhys; 406381cd17a4SHeiner Kallweit } else if (netdev_mc_count(dev) > MC_FILTER_LIMIT || 406481cd17a4SHeiner Kallweit dev->flags & IFF_ALLMULTI || 406581cd17a4SHeiner Kallweit tp->mac_version == RTL_GIGA_MAC_VER_35) { 406681cd17a4SHeiner Kallweit /* accept all multicasts */ 406781cd17a4SHeiner Kallweit } else if (netdev_mc_empty(dev)) { 406881cd17a4SHeiner Kallweit rx_mode &= ~AcceptMulticast; 406925e992a4SHeiner Kallweit } else { 407025e992a4SHeiner Kallweit struct netdev_hw_addr *ha; 407125e992a4SHeiner Kallweit 407225e992a4SHeiner Kallweit mc_filter[1] = mc_filter[0] = 0; 407325e992a4SHeiner Kallweit netdev_for_each_mc_addr(ha, dev) { 407481cd17a4SHeiner Kallweit u32 bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26; 407581cd17a4SHeiner Kallweit mc_filter[bit_nr >> 5] |= BIT(bit_nr & 31); 407681cd17a4SHeiner Kallweit } 407781cd17a4SHeiner Kallweit 407881cd17a4SHeiner Kallweit if (tp->mac_version > RTL_GIGA_MAC_VER_06) { 407981cd17a4SHeiner Kallweit tmp = mc_filter[0]; 408081cd17a4SHeiner Kallweit mc_filter[0] = swab32(mc_filter[1]); 408181cd17a4SHeiner Kallweit mc_filter[1] = swab32(tmp); 408225e992a4SHeiner Kallweit } 408325e992a4SHeiner Kallweit } 408425e992a4SHeiner Kallweit 408525e992a4SHeiner Kallweit if (dev->features & NETIF_F_RXALL) 408625e992a4SHeiner Kallweit rx_mode |= (AcceptErr | AcceptRunt); 408725e992a4SHeiner Kallweit 408825e992a4SHeiner Kallweit RTL_W32(tp, MAR0 + 4, mc_filter[1]); 408925e992a4SHeiner Kallweit RTL_W32(tp, MAR0 + 0, mc_filter[0]); 409025e992a4SHeiner Kallweit 409181cd17a4SHeiner Kallweit tmp = RTL_R32(tp, RxConfig); 409281cd17a4SHeiner Kallweit RTL_W32(tp, RxConfig, (tmp & ~RX_CONFIG_ACCEPT_MASK) | rx_mode); 409325e992a4SHeiner Kallweit } 409425e992a4SHeiner Kallweit 409525e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_csiar_cond) 409625e992a4SHeiner Kallweit { 409725e992a4SHeiner Kallweit return RTL_R32(tp, CSIAR) & CSIAR_FLAG; 409825e992a4SHeiner Kallweit } 409925e992a4SHeiner Kallweit 410025e992a4SHeiner Kallweit static void rtl_csi_write(struct rtl8169_private *tp, int addr, int value) 410125e992a4SHeiner Kallweit { 410225e992a4SHeiner Kallweit u32 func = PCI_FUNC(tp->pci_dev->devfn); 410325e992a4SHeiner Kallweit 410425e992a4SHeiner Kallweit RTL_W32(tp, CSIDR, value); 410525e992a4SHeiner Kallweit RTL_W32(tp, CSIAR, CSIAR_WRITE_CMD | (addr & CSIAR_ADDR_MASK) | 410625e992a4SHeiner Kallweit CSIAR_BYTE_ENABLE | func << 16); 410725e992a4SHeiner Kallweit 410825e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_csiar_cond, 10, 100); 410925e992a4SHeiner Kallweit } 411025e992a4SHeiner Kallweit 411125e992a4SHeiner Kallweit static u32 rtl_csi_read(struct rtl8169_private *tp, int addr) 411225e992a4SHeiner Kallweit { 411325e992a4SHeiner Kallweit u32 func = PCI_FUNC(tp->pci_dev->devfn); 411425e992a4SHeiner Kallweit 411525e992a4SHeiner Kallweit RTL_W32(tp, CSIAR, (addr & CSIAR_ADDR_MASK) | func << 16 | 411625e992a4SHeiner Kallweit CSIAR_BYTE_ENABLE); 411725e992a4SHeiner Kallweit 411825e992a4SHeiner Kallweit return rtl_udelay_loop_wait_high(tp, &rtl_csiar_cond, 10, 100) ? 411925e992a4SHeiner Kallweit RTL_R32(tp, CSIDR) : ~0; 412025e992a4SHeiner Kallweit } 412125e992a4SHeiner Kallweit 412225e992a4SHeiner Kallweit static void rtl_csi_access_enable(struct rtl8169_private *tp, u8 val) 412325e992a4SHeiner Kallweit { 412425e992a4SHeiner Kallweit struct pci_dev *pdev = tp->pci_dev; 412525e992a4SHeiner Kallweit u32 csi; 412625e992a4SHeiner Kallweit 412725e992a4SHeiner Kallweit /* According to Realtek the value at config space address 0x070f 412825e992a4SHeiner Kallweit * controls the L0s/L1 entrance latency. We try standard ECAM access 412925e992a4SHeiner Kallweit * first and if it fails fall back to CSI. 413025e992a4SHeiner Kallweit */ 413125e992a4SHeiner Kallweit if (pdev->cfg_size > 0x070f && 413225e992a4SHeiner Kallweit pci_write_config_byte(pdev, 0x070f, val) == PCIBIOS_SUCCESSFUL) 413325e992a4SHeiner Kallweit return; 413425e992a4SHeiner Kallweit 413525e992a4SHeiner Kallweit netdev_notice_once(tp->dev, 413625e992a4SHeiner Kallweit "No native access to PCI extended config space, falling back to CSI\n"); 413725e992a4SHeiner Kallweit csi = rtl_csi_read(tp, 0x070c) & 0x00ffffff; 413825e992a4SHeiner Kallweit rtl_csi_write(tp, 0x070c, csi | val << 24); 413925e992a4SHeiner Kallweit } 414025e992a4SHeiner Kallweit 414125e992a4SHeiner Kallweit static void rtl_set_def_aspm_entry_latency(struct rtl8169_private *tp) 414225e992a4SHeiner Kallweit { 414325e992a4SHeiner Kallweit rtl_csi_access_enable(tp, 0x27); 414425e992a4SHeiner Kallweit } 414525e992a4SHeiner Kallweit 414625e992a4SHeiner Kallweit struct ephy_info { 414725e992a4SHeiner Kallweit unsigned int offset; 414825e992a4SHeiner Kallweit u16 mask; 414925e992a4SHeiner Kallweit u16 bits; 415025e992a4SHeiner Kallweit }; 415125e992a4SHeiner Kallweit 415225e992a4SHeiner Kallweit static void __rtl_ephy_init(struct rtl8169_private *tp, 415325e992a4SHeiner Kallweit const struct ephy_info *e, int len) 415425e992a4SHeiner Kallweit { 415525e992a4SHeiner Kallweit u16 w; 415625e992a4SHeiner Kallweit 415725e992a4SHeiner Kallweit while (len-- > 0) { 415825e992a4SHeiner Kallweit w = (rtl_ephy_read(tp, e->offset) & ~e->mask) | e->bits; 415925e992a4SHeiner Kallweit rtl_ephy_write(tp, e->offset, w); 416025e992a4SHeiner Kallweit e++; 416125e992a4SHeiner Kallweit } 416225e992a4SHeiner Kallweit } 416325e992a4SHeiner Kallweit 416425e992a4SHeiner Kallweit #define rtl_ephy_init(tp, a) __rtl_ephy_init(tp, a, ARRAY_SIZE(a)) 416525e992a4SHeiner Kallweit 416625e992a4SHeiner Kallweit static void rtl_disable_clock_request(struct rtl8169_private *tp) 416725e992a4SHeiner Kallweit { 416825e992a4SHeiner Kallweit pcie_capability_clear_word(tp->pci_dev, PCI_EXP_LNKCTL, 416925e992a4SHeiner Kallweit PCI_EXP_LNKCTL_CLKREQ_EN); 417025e992a4SHeiner Kallweit } 417125e992a4SHeiner Kallweit 417225e992a4SHeiner Kallweit static void rtl_enable_clock_request(struct rtl8169_private *tp) 417325e992a4SHeiner Kallweit { 417425e992a4SHeiner Kallweit pcie_capability_set_word(tp->pci_dev, PCI_EXP_LNKCTL, 417525e992a4SHeiner Kallweit PCI_EXP_LNKCTL_CLKREQ_EN); 417625e992a4SHeiner Kallweit } 417725e992a4SHeiner Kallweit 417825e992a4SHeiner Kallweit static void rtl_pcie_state_l2l3_disable(struct rtl8169_private *tp) 417925e992a4SHeiner Kallweit { 418025e992a4SHeiner Kallweit /* work around an issue when PCI reset occurs during L2/L3 state */ 418125e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Rdy_to_L23); 418225e992a4SHeiner Kallweit } 418325e992a4SHeiner Kallweit 418425e992a4SHeiner Kallweit static void rtl_hw_aspm_clkreq_enable(struct rtl8169_private *tp, bool enable) 418525e992a4SHeiner Kallweit { 418662b1b3b3SHeiner Kallweit /* Don't enable ASPM in the chip if OS can't control ASPM */ 418762b1b3b3SHeiner Kallweit if (enable && tp->aspm_manageable) { 418825e992a4SHeiner Kallweit RTL_W8(tp, Config5, RTL_R8(tp, Config5) | ASPM_en); 418925e992a4SHeiner Kallweit RTL_W8(tp, Config2, RTL_R8(tp, Config2) | ClkReqEn); 419025e992a4SHeiner Kallweit } else { 419125e992a4SHeiner Kallweit RTL_W8(tp, Config2, RTL_R8(tp, Config2) & ~ClkReqEn); 419225e992a4SHeiner Kallweit RTL_W8(tp, Config5, RTL_R8(tp, Config5) & ~ASPM_en); 419325e992a4SHeiner Kallweit } 419425e992a4SHeiner Kallweit 419525e992a4SHeiner Kallweit udelay(10); 419625e992a4SHeiner Kallweit } 419725e992a4SHeiner Kallweit 419825e992a4SHeiner Kallweit static void rtl_set_fifo_size(struct rtl8169_private *tp, u16 rx_stat, 419925e992a4SHeiner Kallweit u16 tx_stat, u16 rx_dyn, u16 tx_dyn) 420025e992a4SHeiner Kallweit { 420125e992a4SHeiner Kallweit /* Usage of dynamic vs. static FIFO is controlled by bit 420225e992a4SHeiner Kallweit * TXCFG_AUTO_FIFO. Exact meaning of FIFO values isn't known. 420325e992a4SHeiner Kallweit */ 420425e992a4SHeiner Kallweit rtl_eri_write(tp, 0xc8, ERIAR_MASK_1111, (rx_stat << 16) | rx_dyn); 420525e992a4SHeiner Kallweit rtl_eri_write(tp, 0xe8, ERIAR_MASK_1111, (tx_stat << 16) | tx_dyn); 420625e992a4SHeiner Kallweit } 420725e992a4SHeiner Kallweit 420825e992a4SHeiner Kallweit static void rtl8168g_set_pause_thresholds(struct rtl8169_private *tp, 420925e992a4SHeiner Kallweit u8 low, u8 high) 421025e992a4SHeiner Kallweit { 421125e992a4SHeiner Kallweit /* FIFO thresholds for pause flow control */ 421225e992a4SHeiner Kallweit rtl_eri_write(tp, 0xcc, ERIAR_MASK_0001, low); 421325e992a4SHeiner Kallweit rtl_eri_write(tp, 0xd0, ERIAR_MASK_0001, high); 421425e992a4SHeiner Kallweit } 421525e992a4SHeiner Kallweit 421694b5ff74SHeiner Kallweit static void rtl_hw_start_8168b(struct rtl8169_private *tp) 421725e992a4SHeiner Kallweit { 421825e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Beacon_en); 421925e992a4SHeiner Kallweit } 422025e992a4SHeiner Kallweit 422125e992a4SHeiner Kallweit static void __rtl_hw_start_8168cp(struct rtl8169_private *tp) 422225e992a4SHeiner Kallweit { 422325e992a4SHeiner Kallweit RTL_W8(tp, Config1, RTL_R8(tp, Config1) | Speed_down); 422425e992a4SHeiner Kallweit 422525e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Beacon_en); 422625e992a4SHeiner Kallweit 422725e992a4SHeiner Kallweit rtl_disable_clock_request(tp); 422825e992a4SHeiner Kallweit } 422925e992a4SHeiner Kallweit 423025e992a4SHeiner Kallweit static void rtl_hw_start_8168cp_1(struct rtl8169_private *tp) 423125e992a4SHeiner Kallweit { 423225e992a4SHeiner Kallweit static const struct ephy_info e_info_8168cp[] = { 423325e992a4SHeiner Kallweit { 0x01, 0, 0x0001 }, 423425e992a4SHeiner Kallweit { 0x02, 0x0800, 0x1000 }, 423525e992a4SHeiner Kallweit { 0x03, 0, 0x0042 }, 423625e992a4SHeiner Kallweit { 0x06, 0x0080, 0x0000 }, 423725e992a4SHeiner Kallweit { 0x07, 0, 0x2000 } 423825e992a4SHeiner Kallweit }; 423925e992a4SHeiner Kallweit 424025e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 424125e992a4SHeiner Kallweit 424225e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168cp); 424325e992a4SHeiner Kallweit 424425e992a4SHeiner Kallweit __rtl_hw_start_8168cp(tp); 424525e992a4SHeiner Kallweit } 424625e992a4SHeiner Kallweit 424725e992a4SHeiner Kallweit static void rtl_hw_start_8168cp_2(struct rtl8169_private *tp) 424825e992a4SHeiner Kallweit { 424925e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 425025e992a4SHeiner Kallweit 425125e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Beacon_en); 425225e992a4SHeiner Kallweit } 425325e992a4SHeiner Kallweit 425425e992a4SHeiner Kallweit static void rtl_hw_start_8168cp_3(struct rtl8169_private *tp) 425525e992a4SHeiner Kallweit { 425625e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 425725e992a4SHeiner Kallweit 425825e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Beacon_en); 425925e992a4SHeiner Kallweit 426025e992a4SHeiner Kallweit /* Magic. */ 426125e992a4SHeiner Kallweit RTL_W8(tp, DBG_REG, 0x20); 426225e992a4SHeiner Kallweit } 426325e992a4SHeiner Kallweit 426425e992a4SHeiner Kallweit static void rtl_hw_start_8168c_1(struct rtl8169_private *tp) 426525e992a4SHeiner Kallweit { 426625e992a4SHeiner Kallweit static const struct ephy_info e_info_8168c_1[] = { 426725e992a4SHeiner Kallweit { 0x02, 0x0800, 0x1000 }, 426825e992a4SHeiner Kallweit { 0x03, 0, 0x0002 }, 426925e992a4SHeiner Kallweit { 0x06, 0x0080, 0x0000 } 427025e992a4SHeiner Kallweit }; 427125e992a4SHeiner Kallweit 427225e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 427325e992a4SHeiner Kallweit 427425e992a4SHeiner Kallweit RTL_W8(tp, DBG_REG, 0x06 | FIX_NAK_1 | FIX_NAK_2); 427525e992a4SHeiner Kallweit 427625e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168c_1); 427725e992a4SHeiner Kallweit 427825e992a4SHeiner Kallweit __rtl_hw_start_8168cp(tp); 427925e992a4SHeiner Kallweit } 428025e992a4SHeiner Kallweit 428125e992a4SHeiner Kallweit static void rtl_hw_start_8168c_2(struct rtl8169_private *tp) 428225e992a4SHeiner Kallweit { 428325e992a4SHeiner Kallweit static const struct ephy_info e_info_8168c_2[] = { 428425e992a4SHeiner Kallweit { 0x01, 0, 0x0001 }, 4285a7a92cf8SHeiner Kallweit { 0x03, 0x0400, 0x0020 } 428625e992a4SHeiner Kallweit }; 428725e992a4SHeiner Kallweit 428825e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 428925e992a4SHeiner Kallweit 429025e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168c_2); 429125e992a4SHeiner Kallweit 429225e992a4SHeiner Kallweit __rtl_hw_start_8168cp(tp); 429325e992a4SHeiner Kallweit } 429425e992a4SHeiner Kallweit 429525e992a4SHeiner Kallweit static void rtl_hw_start_8168c_3(struct rtl8169_private *tp) 429625e992a4SHeiner Kallweit { 429725e992a4SHeiner Kallweit rtl_hw_start_8168c_2(tp); 429825e992a4SHeiner Kallweit } 429925e992a4SHeiner Kallweit 430025e992a4SHeiner Kallweit static void rtl_hw_start_8168c_4(struct rtl8169_private *tp) 430125e992a4SHeiner Kallweit { 430225e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 430325e992a4SHeiner Kallweit 430425e992a4SHeiner Kallweit __rtl_hw_start_8168cp(tp); 430525e992a4SHeiner Kallweit } 430625e992a4SHeiner Kallweit 430725e992a4SHeiner Kallweit static void rtl_hw_start_8168d(struct rtl8169_private *tp) 430825e992a4SHeiner Kallweit { 430925e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 431025e992a4SHeiner Kallweit 431125e992a4SHeiner Kallweit rtl_disable_clock_request(tp); 431225e992a4SHeiner Kallweit } 431325e992a4SHeiner Kallweit 431425e992a4SHeiner Kallweit static void rtl_hw_start_8168d_4(struct rtl8169_private *tp) 431525e992a4SHeiner Kallweit { 431625e992a4SHeiner Kallweit static const struct ephy_info e_info_8168d_4[] = { 431725e992a4SHeiner Kallweit { 0x0b, 0x0000, 0x0048 }, 431825e992a4SHeiner Kallweit { 0x19, 0x0020, 0x0050 }, 4319a7a92cf8SHeiner Kallweit { 0x0c, 0x0100, 0x0020 }, 4320a7a92cf8SHeiner Kallweit { 0x10, 0x0004, 0x0000 }, 432125e992a4SHeiner Kallweit }; 432225e992a4SHeiner Kallweit 432325e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 432425e992a4SHeiner Kallweit 432525e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168d_4); 432625e992a4SHeiner Kallweit 432725e992a4SHeiner Kallweit rtl_enable_clock_request(tp); 432825e992a4SHeiner Kallweit } 432925e992a4SHeiner Kallweit 433025e992a4SHeiner Kallweit static void rtl_hw_start_8168e_1(struct rtl8169_private *tp) 433125e992a4SHeiner Kallweit { 433225e992a4SHeiner Kallweit static const struct ephy_info e_info_8168e_1[] = { 433325e992a4SHeiner Kallweit { 0x00, 0x0200, 0x0100 }, 433425e992a4SHeiner Kallweit { 0x00, 0x0000, 0x0004 }, 433525e992a4SHeiner Kallweit { 0x06, 0x0002, 0x0001 }, 433625e992a4SHeiner Kallweit { 0x06, 0x0000, 0x0030 }, 433725e992a4SHeiner Kallweit { 0x07, 0x0000, 0x2000 }, 433825e992a4SHeiner Kallweit { 0x00, 0x0000, 0x0020 }, 433925e992a4SHeiner Kallweit { 0x03, 0x5800, 0x2000 }, 434025e992a4SHeiner Kallweit { 0x03, 0x0000, 0x0001 }, 434125e992a4SHeiner Kallweit { 0x01, 0x0800, 0x1000 }, 434225e992a4SHeiner Kallweit { 0x07, 0x0000, 0x4000 }, 434325e992a4SHeiner Kallweit { 0x1e, 0x0000, 0x2000 }, 434425e992a4SHeiner Kallweit { 0x19, 0xffff, 0xfe6c }, 434525e992a4SHeiner Kallweit { 0x0a, 0x0000, 0x0040 } 434625e992a4SHeiner Kallweit }; 434725e992a4SHeiner Kallweit 434825e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 434925e992a4SHeiner Kallweit 435025e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168e_1); 435125e992a4SHeiner Kallweit 435225e992a4SHeiner Kallweit rtl_disable_clock_request(tp); 435325e992a4SHeiner Kallweit 435425e992a4SHeiner Kallweit /* Reset tx FIFO pointer */ 435525e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) | TXPLA_RST); 435625e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) & ~TXPLA_RST); 435725e992a4SHeiner Kallweit 435825e992a4SHeiner Kallweit RTL_W8(tp, Config5, RTL_R8(tp, Config5) & ~Spi_en); 435925e992a4SHeiner Kallweit } 436025e992a4SHeiner Kallweit 436125e992a4SHeiner Kallweit static void rtl_hw_start_8168e_2(struct rtl8169_private *tp) 436225e992a4SHeiner Kallweit { 436325e992a4SHeiner Kallweit static const struct ephy_info e_info_8168e_2[] = { 436425e992a4SHeiner Kallweit { 0x09, 0x0000, 0x0080 }, 4365a7a92cf8SHeiner Kallweit { 0x19, 0x0000, 0x0224 }, 4366a7a92cf8SHeiner Kallweit { 0x00, 0x0000, 0x0004 }, 4367a7a92cf8SHeiner Kallweit { 0x0c, 0x3df0, 0x0200 }, 436825e992a4SHeiner Kallweit }; 436925e992a4SHeiner Kallweit 437025e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 437125e992a4SHeiner Kallweit 437225e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168e_2); 437325e992a4SHeiner Kallweit 437425e992a4SHeiner Kallweit rtl_eri_write(tp, 0xc0, ERIAR_MASK_0011, 0x0000); 437525e992a4SHeiner Kallweit rtl_eri_write(tp, 0xb8, ERIAR_MASK_0011, 0x0000); 437625e992a4SHeiner Kallweit rtl_set_fifo_size(tp, 0x10, 0x10, 0x02, 0x06); 437725e992a4SHeiner Kallweit rtl_eri_write(tp, 0xcc, ERIAR_MASK_1111, 0x00000050); 437825e992a4SHeiner Kallweit rtl_eri_write(tp, 0xd0, ERIAR_MASK_1111, 0x07ff0060); 437925e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0x1b0, ERIAR_MASK_0001, BIT(4)); 438025e992a4SHeiner Kallweit rtl_w0w1_eri(tp, 0x0d4, ERIAR_MASK_0011, 0x0c00, 0xff00); 438125e992a4SHeiner Kallweit 438225e992a4SHeiner Kallweit rtl_disable_clock_request(tp); 438325e992a4SHeiner Kallweit 438425e992a4SHeiner Kallweit RTL_W8(tp, MCU, RTL_R8(tp, MCU) & ~NOW_IS_OOB); 438525e992a4SHeiner Kallweit 438625e992a4SHeiner Kallweit rtl8168_config_eee_mac(tp); 438725e992a4SHeiner Kallweit 438825e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) | PFM_EN); 438925e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) | PWM_EN); 439025e992a4SHeiner Kallweit RTL_W8(tp, Config5, RTL_R8(tp, Config5) & ~Spi_en); 439125e992a4SHeiner Kallweit 439225e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 439325e992a4SHeiner Kallweit } 439425e992a4SHeiner Kallweit 439525e992a4SHeiner Kallweit static void rtl_hw_start_8168f(struct rtl8169_private *tp) 439625e992a4SHeiner Kallweit { 439725e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 439825e992a4SHeiner Kallweit 439925e992a4SHeiner Kallweit rtl_eri_write(tp, 0xc0, ERIAR_MASK_0011, 0x0000); 440025e992a4SHeiner Kallweit rtl_eri_write(tp, 0xb8, ERIAR_MASK_0011, 0x0000); 440125e992a4SHeiner Kallweit rtl_set_fifo_size(tp, 0x10, 0x10, 0x02, 0x06); 440225e992a4SHeiner Kallweit rtl_reset_packet_filter(tp); 440325e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0x1b0, ERIAR_MASK_0001, BIT(4)); 440425e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0x1d0, ERIAR_MASK_0001, BIT(4)); 440525e992a4SHeiner Kallweit rtl_eri_write(tp, 0xcc, ERIAR_MASK_1111, 0x00000050); 440625e992a4SHeiner Kallweit rtl_eri_write(tp, 0xd0, ERIAR_MASK_1111, 0x00000060); 440725e992a4SHeiner Kallweit 440825e992a4SHeiner Kallweit rtl_disable_clock_request(tp); 440925e992a4SHeiner Kallweit 441025e992a4SHeiner Kallweit RTL_W8(tp, MCU, RTL_R8(tp, MCU) & ~NOW_IS_OOB); 441125e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) | PFM_EN); 441225e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) | PWM_EN); 441325e992a4SHeiner Kallweit RTL_W8(tp, Config5, RTL_R8(tp, Config5) & ~Spi_en); 441425e992a4SHeiner Kallweit 441525e992a4SHeiner Kallweit rtl8168_config_eee_mac(tp); 441625e992a4SHeiner Kallweit } 441725e992a4SHeiner Kallweit 441825e992a4SHeiner Kallweit static void rtl_hw_start_8168f_1(struct rtl8169_private *tp) 441925e992a4SHeiner Kallweit { 442025e992a4SHeiner Kallweit static const struct ephy_info e_info_8168f_1[] = { 442125e992a4SHeiner Kallweit { 0x06, 0x00c0, 0x0020 }, 442225e992a4SHeiner Kallweit { 0x08, 0x0001, 0x0002 }, 442325e992a4SHeiner Kallweit { 0x09, 0x0000, 0x0080 }, 4424a7a92cf8SHeiner Kallweit { 0x19, 0x0000, 0x0224 }, 4425a7a92cf8SHeiner Kallweit { 0x00, 0x0000, 0x0004 }, 4426a7a92cf8SHeiner Kallweit { 0x0c, 0x3df0, 0x0200 }, 442725e992a4SHeiner Kallweit }; 442825e992a4SHeiner Kallweit 442925e992a4SHeiner Kallweit rtl_hw_start_8168f(tp); 443025e992a4SHeiner Kallweit 443125e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168f_1); 443225e992a4SHeiner Kallweit 443325e992a4SHeiner Kallweit rtl_w0w1_eri(tp, 0x0d4, ERIAR_MASK_0011, 0x0c00, 0xff00); 443425e992a4SHeiner Kallweit } 443525e992a4SHeiner Kallweit 443625e992a4SHeiner Kallweit static void rtl_hw_start_8411(struct rtl8169_private *tp) 443725e992a4SHeiner Kallweit { 443825e992a4SHeiner Kallweit static const struct ephy_info e_info_8168f_1[] = { 443925e992a4SHeiner Kallweit { 0x06, 0x00c0, 0x0020 }, 444025e992a4SHeiner Kallweit { 0x0f, 0xffff, 0x5200 }, 4441a7a92cf8SHeiner Kallweit { 0x19, 0x0000, 0x0224 }, 4442a7a92cf8SHeiner Kallweit { 0x00, 0x0000, 0x0004 }, 4443a7a92cf8SHeiner Kallweit { 0x0c, 0x3df0, 0x0200 }, 444425e992a4SHeiner Kallweit }; 444525e992a4SHeiner Kallweit 444625e992a4SHeiner Kallweit rtl_hw_start_8168f(tp); 444725e992a4SHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 444825e992a4SHeiner Kallweit 444925e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168f_1); 445025e992a4SHeiner Kallweit 445125e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0x0d4, ERIAR_MASK_0011, 0x0c00); 445225e992a4SHeiner Kallweit } 445325e992a4SHeiner Kallweit 445425e992a4SHeiner Kallweit static void rtl_hw_start_8168g(struct rtl8169_private *tp) 445525e992a4SHeiner Kallweit { 445625e992a4SHeiner Kallweit rtl_set_fifo_size(tp, 0x08, 0x10, 0x02, 0x06); 445725e992a4SHeiner Kallweit rtl8168g_set_pause_thresholds(tp, 0x38, 0x48); 445825e992a4SHeiner Kallweit 445925e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 446025e992a4SHeiner Kallweit 446125e992a4SHeiner Kallweit rtl_reset_packet_filter(tp); 446225e992a4SHeiner Kallweit rtl_eri_write(tp, 0x2f8, ERIAR_MASK_0011, 0x1d8f); 446325e992a4SHeiner Kallweit 446425e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) & ~RXDV_GATED_EN); 446525e992a4SHeiner Kallweit 446625e992a4SHeiner Kallweit rtl_eri_write(tp, 0xc0, ERIAR_MASK_0011, 0x0000); 446725e992a4SHeiner Kallweit rtl_eri_write(tp, 0xb8, ERIAR_MASK_0011, 0x0000); 446825e992a4SHeiner Kallweit 446925e992a4SHeiner Kallweit rtl8168_config_eee_mac(tp); 447025e992a4SHeiner Kallweit 447125e992a4SHeiner Kallweit rtl_w0w1_eri(tp, 0x2fc, ERIAR_MASK_0001, 0x01, 0x06); 447225e992a4SHeiner Kallweit rtl_eri_clear_bits(tp, 0x1b0, ERIAR_MASK_0011, BIT(12)); 447325e992a4SHeiner Kallweit 447425e992a4SHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 447525e992a4SHeiner Kallweit } 447625e992a4SHeiner Kallweit 447725e992a4SHeiner Kallweit static void rtl_hw_start_8168g_1(struct rtl8169_private *tp) 447825e992a4SHeiner Kallweit { 447925e992a4SHeiner Kallweit static const struct ephy_info e_info_8168g_1[] = { 4480a7a92cf8SHeiner Kallweit { 0x00, 0x0008, 0x0000 }, 4481a7a92cf8SHeiner Kallweit { 0x0c, 0x3ff0, 0x0820 }, 448225e992a4SHeiner Kallweit { 0x1e, 0x0000, 0x0001 }, 448325e992a4SHeiner Kallweit { 0x19, 0x8000, 0x0000 } 448425e992a4SHeiner Kallweit }; 448525e992a4SHeiner Kallweit 448625e992a4SHeiner Kallweit rtl_hw_start_8168g(tp); 448725e992a4SHeiner Kallweit 448825e992a4SHeiner Kallweit /* disable aspm and clock request before access ephy */ 448925e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 449025e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168g_1); 449125e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 449225e992a4SHeiner Kallweit } 449325e992a4SHeiner Kallweit 449425e992a4SHeiner Kallweit static void rtl_hw_start_8168g_2(struct rtl8169_private *tp) 449525e992a4SHeiner Kallweit { 449625e992a4SHeiner Kallweit static const struct ephy_info e_info_8168g_2[] = { 4497a7a92cf8SHeiner Kallweit { 0x00, 0x0008, 0x0000 }, 4498a7a92cf8SHeiner Kallweit { 0x0c, 0x3ff0, 0x0820 }, 4499a7a92cf8SHeiner Kallweit { 0x19, 0xffff, 0x7c00 }, 4500a7a92cf8SHeiner Kallweit { 0x1e, 0xffff, 0x20eb }, 4501a7a92cf8SHeiner Kallweit { 0x0d, 0xffff, 0x1666 }, 4502a7a92cf8SHeiner Kallweit { 0x00, 0xffff, 0x10a3 }, 4503a7a92cf8SHeiner Kallweit { 0x06, 0xffff, 0xf050 }, 4504a7a92cf8SHeiner Kallweit { 0x04, 0x0000, 0x0010 }, 4505a7a92cf8SHeiner Kallweit { 0x1d, 0x4000, 0x0000 }, 450625e992a4SHeiner Kallweit }; 450725e992a4SHeiner Kallweit 450825e992a4SHeiner Kallweit rtl_hw_start_8168g(tp); 450925e992a4SHeiner Kallweit 451025e992a4SHeiner Kallweit /* disable aspm and clock request before access ephy */ 4511ebdcebcbSHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 451225e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168g_2); 451325e992a4SHeiner Kallweit } 451425e992a4SHeiner Kallweit 451525e992a4SHeiner Kallweit static void rtl_hw_start_8411_2(struct rtl8169_private *tp) 451625e992a4SHeiner Kallweit { 451725e992a4SHeiner Kallweit static const struct ephy_info e_info_8411_2[] = { 4518a7a92cf8SHeiner Kallweit { 0x00, 0x0008, 0x0000 }, 4519a7a92cf8SHeiner Kallweit { 0x0c, 0x37d0, 0x0820 }, 4520a7a92cf8SHeiner Kallweit { 0x1e, 0x0000, 0x0001 }, 4521a7a92cf8SHeiner Kallweit { 0x19, 0x8021, 0x0000 }, 4522a7a92cf8SHeiner Kallweit { 0x1e, 0x0000, 0x2000 }, 4523a7a92cf8SHeiner Kallweit { 0x0d, 0x0100, 0x0200 }, 4524a7a92cf8SHeiner Kallweit { 0x00, 0x0000, 0x0080 }, 4525a7a92cf8SHeiner Kallweit { 0x06, 0x0000, 0x0010 }, 4526a7a92cf8SHeiner Kallweit { 0x04, 0x0000, 0x0010 }, 4527a7a92cf8SHeiner Kallweit { 0x1d, 0x0000, 0x4000 }, 452825e992a4SHeiner Kallweit }; 452925e992a4SHeiner Kallweit 453025e992a4SHeiner Kallweit rtl_hw_start_8168g(tp); 453125e992a4SHeiner Kallweit 453225e992a4SHeiner Kallweit /* disable aspm and clock request before access ephy */ 453325e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 453425e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8411_2); 4535fe4e8db0SHeiner Kallweit 4536fe4e8db0SHeiner Kallweit /* The following Realtek-provided magic fixes an issue with the RX unit 4537fe4e8db0SHeiner Kallweit * getting confused after the PHY having been powered-down. 4538fe4e8db0SHeiner Kallweit */ 4539fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC28, 0x0000); 4540fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC2A, 0x0000); 4541fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC2C, 0x0000); 4542fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC2E, 0x0000); 4543fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC30, 0x0000); 4544fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC32, 0x0000); 4545fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC34, 0x0000); 4546fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC36, 0x0000); 4547fe4e8db0SHeiner Kallweit mdelay(3); 4548fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC26, 0x0000); 4549fe4e8db0SHeiner Kallweit 4550fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF800, 0xE008); 4551fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF802, 0xE00A); 4552fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF804, 0xE00C); 4553fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF806, 0xE00E); 4554fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF808, 0xE027); 4555fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF80A, 0xE04F); 4556fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF80C, 0xE05E); 4557fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF80E, 0xE065); 4558fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF810, 0xC602); 4559fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF812, 0xBE00); 4560fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF814, 0x0000); 4561fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF816, 0xC502); 4562fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF818, 0xBD00); 4563fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF81A, 0x074C); 4564fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF81C, 0xC302); 4565fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF81E, 0xBB00); 4566fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF820, 0x080A); 4567fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF822, 0x6420); 4568fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF824, 0x48C2); 4569fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF826, 0x8C20); 4570fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF828, 0xC516); 4571fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF82A, 0x64A4); 4572fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF82C, 0x49C0); 4573fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF82E, 0xF009); 4574fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF830, 0x74A2); 4575fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF832, 0x8CA5); 4576fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF834, 0x74A0); 4577fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF836, 0xC50E); 4578fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF838, 0x9CA2); 4579fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF83A, 0x1C11); 4580fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF83C, 0x9CA0); 4581fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF83E, 0xE006); 4582fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF840, 0x74F8); 4583fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF842, 0x48C4); 4584fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF844, 0x8CF8); 4585fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF846, 0xC404); 4586fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF848, 0xBC00); 4587fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF84A, 0xC403); 4588fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF84C, 0xBC00); 4589fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF84E, 0x0BF2); 4590fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF850, 0x0C0A); 4591fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF852, 0xE434); 4592fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF854, 0xD3C0); 4593fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF856, 0x49D9); 4594fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF858, 0xF01F); 4595fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF85A, 0xC526); 4596fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF85C, 0x64A5); 4597fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF85E, 0x1400); 4598fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF860, 0xF007); 4599fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF862, 0x0C01); 4600fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF864, 0x8CA5); 4601fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF866, 0x1C15); 4602fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF868, 0xC51B); 4603fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF86A, 0x9CA0); 4604fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF86C, 0xE013); 4605fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF86E, 0xC519); 4606fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF870, 0x74A0); 4607fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF872, 0x48C4); 4608fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF874, 0x8CA0); 4609fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF876, 0xC516); 4610fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF878, 0x74A4); 4611fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF87A, 0x48C8); 4612fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF87C, 0x48CA); 4613fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF87E, 0x9CA4); 4614fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF880, 0xC512); 4615fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF882, 0x1B00); 4616fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF884, 0x9BA0); 4617fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF886, 0x1B1C); 4618fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF888, 0x483F); 4619fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF88A, 0x9BA2); 4620fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF88C, 0x1B04); 4621fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF88E, 0xC508); 4622fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF890, 0x9BA0); 4623fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF892, 0xC505); 4624fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF894, 0xBD00); 4625fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF896, 0xC502); 4626fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF898, 0xBD00); 4627fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF89A, 0x0300); 4628fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF89C, 0x051E); 4629fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF89E, 0xE434); 4630fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8A0, 0xE018); 4631fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8A2, 0xE092); 4632fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8A4, 0xDE20); 4633fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8A6, 0xD3C0); 4634fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8A8, 0xC50F); 4635fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8AA, 0x76A4); 4636fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8AC, 0x49E3); 4637fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8AE, 0xF007); 4638fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8B0, 0x49C0); 4639fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8B2, 0xF103); 4640fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8B4, 0xC607); 4641fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8B6, 0xBE00); 4642fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8B8, 0xC606); 4643fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8BA, 0xBE00); 4644fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8BC, 0xC602); 4645fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8BE, 0xBE00); 4646fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8C0, 0x0C4C); 4647fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8C2, 0x0C28); 4648fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8C4, 0x0C2C); 4649fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8C6, 0xDC00); 4650fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8C8, 0xC707); 4651fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8CA, 0x1D00); 4652fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8CC, 0x8DE2); 4653fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8CE, 0x48C1); 4654fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8D0, 0xC502); 4655fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8D2, 0xBD00); 4656fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8D4, 0x00AA); 4657fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8D6, 0xE0C0); 4658fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8D8, 0xC502); 4659fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8DA, 0xBD00); 4660fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8DC, 0x0132); 4661fe4e8db0SHeiner Kallweit 4662fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC26, 0x8000); 4663fe4e8db0SHeiner Kallweit 4664fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC2A, 0x0743); 4665fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC2C, 0x0801); 4666fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC2E, 0x0BE9); 4667fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC30, 0x02FD); 4668fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC32, 0x0C25); 4669fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC34, 0x00A9); 4670fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC36, 0x012D); 4671fe4e8db0SHeiner Kallweit 467225e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 467325e992a4SHeiner Kallweit } 467425e992a4SHeiner Kallweit 467525e992a4SHeiner Kallweit static void rtl_hw_start_8168h_1(struct rtl8169_private *tp) 467625e992a4SHeiner Kallweit { 467725e992a4SHeiner Kallweit static const struct ephy_info e_info_8168h_1[] = { 467825e992a4SHeiner Kallweit { 0x1e, 0x0800, 0x0001 }, 467925e992a4SHeiner Kallweit { 0x1d, 0x0000, 0x0800 }, 468025e992a4SHeiner Kallweit { 0x05, 0xffff, 0x2089 }, 468125e992a4SHeiner Kallweit { 0x06, 0xffff, 0x5881 }, 4682a7a92cf8SHeiner Kallweit { 0x04, 0xffff, 0x854a }, 468325e992a4SHeiner Kallweit { 0x01, 0xffff, 0x068b } 468425e992a4SHeiner Kallweit }; 4685ef712edeSHeiner Kallweit int rg_saw_cnt; 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_reset_packet_filter(tp); 469725e992a4SHeiner Kallweit 469825e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0xdc, ERIAR_MASK_1111, BIT(4)); 469925e992a4SHeiner Kallweit 470025e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0xd4, ERIAR_MASK_1111, 0x1f00); 470125e992a4SHeiner Kallweit 470225e992a4SHeiner Kallweit rtl_eri_write(tp, 0x5f0, ERIAR_MASK_0011, 0x4f87); 470325e992a4SHeiner Kallweit 470425e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) & ~RXDV_GATED_EN); 470525e992a4SHeiner Kallweit 470625e992a4SHeiner Kallweit rtl_eri_write(tp, 0xc0, ERIAR_MASK_0011, 0x0000); 470725e992a4SHeiner Kallweit rtl_eri_write(tp, 0xb8, ERIAR_MASK_0011, 0x0000); 470825e992a4SHeiner Kallweit 470925e992a4SHeiner Kallweit rtl8168_config_eee_mac(tp); 471025e992a4SHeiner Kallweit 471125e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) & ~PFM_EN); 471225e992a4SHeiner Kallweit RTL_W8(tp, MISC_1, RTL_R8(tp, MISC_1) & ~PFM_D3COLD_EN); 471325e992a4SHeiner Kallweit 471425e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) & ~TX_10M_PS_EN); 471525e992a4SHeiner Kallweit 471625e992a4SHeiner Kallweit rtl_eri_clear_bits(tp, 0x1b0, ERIAR_MASK_0011, BIT(12)); 471725e992a4SHeiner Kallweit 471825e992a4SHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 471925e992a4SHeiner Kallweit 472025e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0c42); 472125e992a4SHeiner Kallweit rg_saw_cnt = (rtl_readphy(tp, 0x13) & 0x3fff); 472225e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 472325e992a4SHeiner Kallweit if (rg_saw_cnt > 0) { 472425e992a4SHeiner Kallweit u16 sw_cnt_1ms_ini; 472525e992a4SHeiner Kallweit 472625e992a4SHeiner Kallweit sw_cnt_1ms_ini = 16000000/rg_saw_cnt; 472725e992a4SHeiner Kallweit sw_cnt_1ms_ini &= 0x0fff; 4728ef712edeSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xd412, 0x0fff, sw_cnt_1ms_ini); 472925e992a4SHeiner Kallweit } 473025e992a4SHeiner Kallweit 4731ef712edeSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe056, 0x00f0, 0x0070); 4732ef712edeSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe052, 0x6000, 0x8008); 4733ef712edeSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe0d6, 0x01ff, 0x017f); 4734ef712edeSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xd420, 0x0fff, 0x047f); 473525e992a4SHeiner Kallweit 473625e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xe63e, 0x0001); 473725e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xe63e, 0x0000); 473825e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xc094, 0x0000); 473925e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xc09e, 0x0000); 474025e992a4SHeiner Kallweit 474125e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 474225e992a4SHeiner Kallweit } 474325e992a4SHeiner Kallweit 474425e992a4SHeiner Kallweit static void rtl_hw_start_8168ep(struct rtl8169_private *tp) 474525e992a4SHeiner Kallweit { 474625e992a4SHeiner Kallweit rtl8168ep_stop_cmac(tp); 474725e992a4SHeiner Kallweit 474825e992a4SHeiner Kallweit rtl_set_fifo_size(tp, 0x08, 0x10, 0x02, 0x06); 474925e992a4SHeiner Kallweit rtl8168g_set_pause_thresholds(tp, 0x2f, 0x5f); 475025e992a4SHeiner Kallweit 475125e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 475225e992a4SHeiner Kallweit 475325e992a4SHeiner Kallweit rtl_reset_packet_filter(tp); 475425e992a4SHeiner Kallweit 475525e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0xd4, ERIAR_MASK_1111, 0x1f80); 475625e992a4SHeiner Kallweit 475725e992a4SHeiner Kallweit rtl_eri_write(tp, 0x5f0, ERIAR_MASK_0011, 0x4f87); 475825e992a4SHeiner Kallweit 475925e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) & ~RXDV_GATED_EN); 476025e992a4SHeiner Kallweit 476125e992a4SHeiner Kallweit rtl_eri_write(tp, 0xc0, ERIAR_MASK_0011, 0x0000); 476225e992a4SHeiner Kallweit rtl_eri_write(tp, 0xb8, ERIAR_MASK_0011, 0x0000); 476325e992a4SHeiner Kallweit 476425e992a4SHeiner Kallweit rtl8168_config_eee_mac(tp); 476525e992a4SHeiner Kallweit 476625e992a4SHeiner Kallweit rtl_w0w1_eri(tp, 0x2fc, ERIAR_MASK_0001, 0x01, 0x06); 476725e992a4SHeiner Kallweit 476825e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) & ~TX_10M_PS_EN); 476925e992a4SHeiner Kallweit 477025e992a4SHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 477125e992a4SHeiner Kallweit } 477225e992a4SHeiner Kallweit 477325e992a4SHeiner Kallweit static void rtl_hw_start_8168ep_1(struct rtl8169_private *tp) 477425e992a4SHeiner Kallweit { 477525e992a4SHeiner Kallweit static const struct ephy_info e_info_8168ep_1[] = { 477625e992a4SHeiner Kallweit { 0x00, 0xffff, 0x10ab }, 477725e992a4SHeiner Kallweit { 0x06, 0xffff, 0xf030 }, 477825e992a4SHeiner Kallweit { 0x08, 0xffff, 0x2006 }, 477925e992a4SHeiner Kallweit { 0x0d, 0xffff, 0x1666 }, 478025e992a4SHeiner Kallweit { 0x0c, 0x3ff0, 0x0000 } 478125e992a4SHeiner Kallweit }; 478225e992a4SHeiner Kallweit 478325e992a4SHeiner Kallweit /* disable aspm and clock request before access ephy */ 478425e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 478525e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168ep_1); 478625e992a4SHeiner Kallweit 478725e992a4SHeiner Kallweit rtl_hw_start_8168ep(tp); 478825e992a4SHeiner Kallweit 478925e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 479025e992a4SHeiner Kallweit } 479125e992a4SHeiner Kallweit 479225e992a4SHeiner Kallweit static void rtl_hw_start_8168ep_2(struct rtl8169_private *tp) 479325e992a4SHeiner Kallweit { 479425e992a4SHeiner Kallweit static const struct ephy_info e_info_8168ep_2[] = { 479525e992a4SHeiner Kallweit { 0x00, 0xffff, 0x10a3 }, 479625e992a4SHeiner Kallweit { 0x19, 0xffff, 0xfc00 }, 479725e992a4SHeiner Kallweit { 0x1e, 0xffff, 0x20ea } 479825e992a4SHeiner Kallweit }; 479925e992a4SHeiner Kallweit 480025e992a4SHeiner Kallweit /* disable aspm and clock request before access ephy */ 480125e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 480225e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168ep_2); 480325e992a4SHeiner Kallweit 480425e992a4SHeiner Kallweit rtl_hw_start_8168ep(tp); 480525e992a4SHeiner Kallweit 480625e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) & ~PFM_EN); 480725e992a4SHeiner Kallweit RTL_W8(tp, MISC_1, RTL_R8(tp, MISC_1) & ~PFM_D3COLD_EN); 480825e992a4SHeiner Kallweit 480925e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 481025e992a4SHeiner Kallweit } 481125e992a4SHeiner Kallweit 481225e992a4SHeiner Kallweit static void rtl_hw_start_8168ep_3(struct rtl8169_private *tp) 481325e992a4SHeiner Kallweit { 481425e992a4SHeiner Kallweit static const struct ephy_info e_info_8168ep_3[] = { 4815a7a92cf8SHeiner Kallweit { 0x00, 0x0000, 0x0080 }, 4816a7a92cf8SHeiner Kallweit { 0x0d, 0x0100, 0x0200 }, 4817a7a92cf8SHeiner Kallweit { 0x19, 0x8021, 0x0000 }, 4818a7a92cf8SHeiner Kallweit { 0x1e, 0x0000, 0x2000 }, 481925e992a4SHeiner Kallweit }; 482025e992a4SHeiner Kallweit 482125e992a4SHeiner Kallweit /* disable aspm and clock request before access ephy */ 482225e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 482325e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168ep_3); 482425e992a4SHeiner Kallweit 482525e992a4SHeiner Kallweit rtl_hw_start_8168ep(tp); 482625e992a4SHeiner Kallweit 482725e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) & ~PFM_EN); 482825e992a4SHeiner Kallweit RTL_W8(tp, MISC_1, RTL_R8(tp, MISC_1) & ~PFM_D3COLD_EN); 482925e992a4SHeiner Kallweit 4830ef712edeSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xd3e2, 0x0fff, 0x0271); 4831ef712edeSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xd3e4, 0x00ff, 0x0000); 4832ef712edeSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe860, 0x0000, 0x0080); 483325e992a4SHeiner Kallweit 483425e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 483525e992a4SHeiner Kallweit } 483625e992a4SHeiner Kallweit 48371287723aSHeiner Kallweit static void rtl_hw_start_8117(struct rtl8169_private *tp) 48381287723aSHeiner Kallweit { 48391287723aSHeiner Kallweit static const struct ephy_info e_info_8117[] = { 48401287723aSHeiner Kallweit { 0x19, 0x0040, 0x1100 }, 48411287723aSHeiner Kallweit { 0x59, 0x0040, 0x1100 }, 48421287723aSHeiner Kallweit }; 48431287723aSHeiner Kallweit int rg_saw_cnt; 48441287723aSHeiner Kallweit 48451287723aSHeiner Kallweit rtl8168ep_stop_cmac(tp); 48461287723aSHeiner Kallweit 48471287723aSHeiner Kallweit /* disable aspm and clock request before access ephy */ 48481287723aSHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 48491287723aSHeiner Kallweit rtl_ephy_init(tp, e_info_8117); 48501287723aSHeiner Kallweit 48511287723aSHeiner Kallweit rtl_set_fifo_size(tp, 0x08, 0x10, 0x02, 0x06); 48521287723aSHeiner Kallweit rtl8168g_set_pause_thresholds(tp, 0x2f, 0x5f); 48531287723aSHeiner Kallweit 48541287723aSHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 48551287723aSHeiner Kallweit 48561287723aSHeiner Kallweit rtl_reset_packet_filter(tp); 48571287723aSHeiner Kallweit 48581287723aSHeiner Kallweit rtl_eri_set_bits(tp, 0xd4, ERIAR_MASK_1111, 0x1f90); 48591287723aSHeiner Kallweit 48601287723aSHeiner Kallweit rtl_eri_write(tp, 0x5f0, ERIAR_MASK_0011, 0x4f87); 48611287723aSHeiner Kallweit 48621287723aSHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) & ~RXDV_GATED_EN); 48631287723aSHeiner Kallweit 48641287723aSHeiner Kallweit rtl_eri_write(tp, 0xc0, ERIAR_MASK_0011, 0x0000); 48651287723aSHeiner Kallweit rtl_eri_write(tp, 0xb8, ERIAR_MASK_0011, 0x0000); 48661287723aSHeiner Kallweit 48671287723aSHeiner Kallweit rtl8168_config_eee_mac(tp); 48681287723aSHeiner Kallweit 48691287723aSHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) & ~PFM_EN); 48701287723aSHeiner Kallweit RTL_W8(tp, MISC_1, RTL_R8(tp, MISC_1) & ~PFM_D3COLD_EN); 48711287723aSHeiner Kallweit 48721287723aSHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) & ~TX_10M_PS_EN); 48731287723aSHeiner Kallweit 48741287723aSHeiner Kallweit rtl_eri_clear_bits(tp, 0x1b0, ERIAR_MASK_0011, BIT(12)); 48751287723aSHeiner Kallweit 48761287723aSHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 48771287723aSHeiner Kallweit 48781287723aSHeiner Kallweit rg_saw_cnt = phy_read_paged(tp->phydev, 0x0c42, 0x13) & 0x3fff; 48791287723aSHeiner Kallweit if (rg_saw_cnt > 0) { 48801287723aSHeiner Kallweit u16 sw_cnt_1ms_ini; 48811287723aSHeiner Kallweit 48821287723aSHeiner Kallweit sw_cnt_1ms_ini = (16000000 / rg_saw_cnt) & 0x0fff; 48831287723aSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xd412, 0x0fff, sw_cnt_1ms_ini); 48841287723aSHeiner Kallweit } 48851287723aSHeiner Kallweit 48861287723aSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe056, 0x00f0, 0x0070); 48871287723aSHeiner Kallweit r8168_mac_ocp_write(tp, 0xea80, 0x0003); 48881287723aSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe052, 0x0000, 0x0009); 48891287723aSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xd420, 0x0fff, 0x047f); 48901287723aSHeiner Kallweit 48911287723aSHeiner Kallweit r8168_mac_ocp_write(tp, 0xe63e, 0x0001); 48921287723aSHeiner Kallweit r8168_mac_ocp_write(tp, 0xe63e, 0x0000); 48931287723aSHeiner Kallweit r8168_mac_ocp_write(tp, 0xc094, 0x0000); 48941287723aSHeiner Kallweit r8168_mac_ocp_write(tp, 0xc09e, 0x0000); 48951287723aSHeiner Kallweit 4896229c1e0dSHeiner Kallweit /* firmware is for MAC only */ 4897229c1e0dSHeiner Kallweit rtl_apply_firmware(tp); 4898229c1e0dSHeiner Kallweit 48991287723aSHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 49001287723aSHeiner Kallweit } 49011287723aSHeiner Kallweit 490225e992a4SHeiner Kallweit static void rtl_hw_start_8102e_1(struct rtl8169_private *tp) 490325e992a4SHeiner Kallweit { 490425e992a4SHeiner Kallweit static const struct ephy_info e_info_8102e_1[] = { 490525e992a4SHeiner Kallweit { 0x01, 0, 0x6e65 }, 490625e992a4SHeiner Kallweit { 0x02, 0, 0x091f }, 490725e992a4SHeiner Kallweit { 0x03, 0, 0xc2f9 }, 490825e992a4SHeiner Kallweit { 0x06, 0, 0xafb5 }, 490925e992a4SHeiner Kallweit { 0x07, 0, 0x0e00 }, 491025e992a4SHeiner Kallweit { 0x19, 0, 0xec80 }, 491125e992a4SHeiner Kallweit { 0x01, 0, 0x2e65 }, 491225e992a4SHeiner Kallweit { 0x01, 0, 0x6e65 } 491325e992a4SHeiner Kallweit }; 491425e992a4SHeiner Kallweit u8 cfg1; 491525e992a4SHeiner Kallweit 491625e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 491725e992a4SHeiner Kallweit 491825e992a4SHeiner Kallweit RTL_W8(tp, DBG_REG, FIX_NAK_1); 491925e992a4SHeiner Kallweit 492025e992a4SHeiner Kallweit RTL_W8(tp, Config1, 492125e992a4SHeiner Kallweit LEDS1 | LEDS0 | Speed_down | MEMMAP | IOMAP | VPD | PMEnable); 492225e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Beacon_en); 492325e992a4SHeiner Kallweit 492425e992a4SHeiner Kallweit cfg1 = RTL_R8(tp, Config1); 492525e992a4SHeiner Kallweit if ((cfg1 & LEDS0) && (cfg1 & LEDS1)) 492625e992a4SHeiner Kallweit RTL_W8(tp, Config1, cfg1 & ~LEDS0); 492725e992a4SHeiner Kallweit 492825e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8102e_1); 492925e992a4SHeiner Kallweit } 493025e992a4SHeiner Kallweit 493125e992a4SHeiner Kallweit static void rtl_hw_start_8102e_2(struct rtl8169_private *tp) 493225e992a4SHeiner Kallweit { 493325e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 493425e992a4SHeiner Kallweit 493525e992a4SHeiner Kallweit RTL_W8(tp, Config1, MEMMAP | IOMAP | VPD | PMEnable); 493625e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Beacon_en); 493725e992a4SHeiner Kallweit } 493825e992a4SHeiner Kallweit 493925e992a4SHeiner Kallweit static void rtl_hw_start_8102e_3(struct rtl8169_private *tp) 494025e992a4SHeiner Kallweit { 494125e992a4SHeiner Kallweit rtl_hw_start_8102e_2(tp); 494225e992a4SHeiner Kallweit 494325e992a4SHeiner Kallweit rtl_ephy_write(tp, 0x03, 0xc2f9); 494425e992a4SHeiner Kallweit } 494525e992a4SHeiner Kallweit 494625e992a4SHeiner Kallweit static void rtl_hw_start_8105e_1(struct rtl8169_private *tp) 494725e992a4SHeiner Kallweit { 494825e992a4SHeiner Kallweit static const struct ephy_info e_info_8105e_1[] = { 494925e992a4SHeiner Kallweit { 0x07, 0, 0x4000 }, 495025e992a4SHeiner Kallweit { 0x19, 0, 0x0200 }, 495125e992a4SHeiner Kallweit { 0x19, 0, 0x0020 }, 495225e992a4SHeiner Kallweit { 0x1e, 0, 0x2000 }, 495325e992a4SHeiner Kallweit { 0x03, 0, 0x0001 }, 495425e992a4SHeiner Kallweit { 0x19, 0, 0x0100 }, 495525e992a4SHeiner Kallweit { 0x19, 0, 0x0004 }, 495625e992a4SHeiner Kallweit { 0x0a, 0, 0x0020 } 495725e992a4SHeiner Kallweit }; 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 /* Disable Early Tally Counter */ 496325e992a4SHeiner Kallweit RTL_W32(tp, FuncEvent, RTL_R32(tp, FuncEvent) & ~0x010000); 496425e992a4SHeiner Kallweit 496525e992a4SHeiner Kallweit RTL_W8(tp, MCU, RTL_R8(tp, MCU) | EN_NDP | EN_OOB_RESET); 496625e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) | PFM_EN); 496725e992a4SHeiner Kallweit 496825e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8105e_1); 496925e992a4SHeiner Kallweit 497025e992a4SHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 497125e992a4SHeiner Kallweit } 497225e992a4SHeiner Kallweit 497325e992a4SHeiner Kallweit static void rtl_hw_start_8105e_2(struct rtl8169_private *tp) 497425e992a4SHeiner Kallweit { 497525e992a4SHeiner Kallweit rtl_hw_start_8105e_1(tp); 497625e992a4SHeiner Kallweit rtl_ephy_write(tp, 0x1e, rtl_ephy_read(tp, 0x1e) | 0x8000); 497725e992a4SHeiner Kallweit } 497825e992a4SHeiner Kallweit 497925e992a4SHeiner Kallweit static void rtl_hw_start_8402(struct rtl8169_private *tp) 498025e992a4SHeiner Kallweit { 498125e992a4SHeiner Kallweit static const struct ephy_info e_info_8402[] = { 498225e992a4SHeiner Kallweit { 0x19, 0xffff, 0xff64 }, 498325e992a4SHeiner Kallweit { 0x1e, 0, 0x4000 } 498425e992a4SHeiner Kallweit }; 498525e992a4SHeiner Kallweit 498625e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 498725e992a4SHeiner Kallweit 498825e992a4SHeiner Kallweit /* Force LAN exit from ASPM if Rx/Tx are not idle */ 498925e992a4SHeiner Kallweit RTL_W32(tp, FuncEvent, RTL_R32(tp, FuncEvent) | 0x002800); 499025e992a4SHeiner Kallweit 499125e992a4SHeiner Kallweit RTL_W8(tp, MCU, RTL_R8(tp, MCU) & ~NOW_IS_OOB); 499225e992a4SHeiner Kallweit 499325e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8402); 499425e992a4SHeiner Kallweit 499525e992a4SHeiner Kallweit rtl_set_fifo_size(tp, 0x00, 0x00, 0x02, 0x06); 499625e992a4SHeiner Kallweit rtl_reset_packet_filter(tp); 499725e992a4SHeiner Kallweit rtl_eri_write(tp, 0xc0, ERIAR_MASK_0011, 0x0000); 499825e992a4SHeiner Kallweit rtl_eri_write(tp, 0xb8, ERIAR_MASK_0011, 0x0000); 499925e992a4SHeiner Kallweit rtl_w0w1_eri(tp, 0x0d4, ERIAR_MASK_0011, 0x0e00, 0xff00); 500025e992a4SHeiner Kallweit 500125e992a4SHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 500225e992a4SHeiner Kallweit } 500325e992a4SHeiner Kallweit 500425e992a4SHeiner Kallweit static void rtl_hw_start_8106(struct rtl8169_private *tp) 500525e992a4SHeiner Kallweit { 500625e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 500725e992a4SHeiner Kallweit 500825e992a4SHeiner Kallweit /* Force LAN exit from ASPM if Rx/Tx are not idle */ 500925e992a4SHeiner Kallweit RTL_W32(tp, FuncEvent, RTL_R32(tp, FuncEvent) | 0x002800); 501025e992a4SHeiner Kallweit 501125e992a4SHeiner Kallweit RTL_W32(tp, MISC, (RTL_R32(tp, MISC) | DISABLE_LAN_EN) & ~EARLY_TALLY_EN); 501225e992a4SHeiner Kallweit RTL_W8(tp, MCU, RTL_R8(tp, MCU) | EN_NDP | EN_OOB_RESET); 501325e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) & ~PFM_EN); 501425e992a4SHeiner Kallweit 501525e992a4SHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 501625e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 501725e992a4SHeiner Kallweit } 501825e992a4SHeiner Kallweit 5019f1bce4adSHeiner Kallweit DECLARE_RTL_COND(rtl_mac_ocp_e00e_cond) 5020f1bce4adSHeiner Kallweit { 5021f1bce4adSHeiner Kallweit return r8168_mac_ocp_read(tp, 0xe00e) & BIT(13); 5022f1bce4adSHeiner Kallweit } 5023f1bce4adSHeiner Kallweit 5024f1bce4adSHeiner Kallweit static void rtl_hw_start_8125_common(struct rtl8169_private *tp) 5025f1bce4adSHeiner Kallweit { 5026f1bce4adSHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 5027f1bce4adSHeiner Kallweit 5028f1bce4adSHeiner Kallweit RTL_W16(tp, 0x382, 0x221b); 5029f1bce4adSHeiner Kallweit RTL_W8(tp, 0x4500, 0); 5030f1bce4adSHeiner Kallweit RTL_W16(tp, 0x4800, 0); 5031f1bce4adSHeiner Kallweit 5032f1bce4adSHeiner Kallweit /* disable UPS */ 5033f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xd40a, 0x0010, 0x0000); 5034f1bce4adSHeiner Kallweit 5035f1bce4adSHeiner Kallweit RTL_W8(tp, Config1, RTL_R8(tp, Config1) & ~0x10); 5036f1bce4adSHeiner Kallweit 5037f1bce4adSHeiner Kallweit r8168_mac_ocp_write(tp, 0xc140, 0xffff); 5038f1bce4adSHeiner Kallweit r8168_mac_ocp_write(tp, 0xc142, 0xffff); 5039f1bce4adSHeiner Kallweit 5040f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xd3e2, 0x0fff, 0x03a9); 5041f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xd3e4, 0x00ff, 0x0000); 5042f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe860, 0x0000, 0x0080); 5043f1bce4adSHeiner Kallweit 5044f1bce4adSHeiner Kallweit /* disable new tx descriptor format */ 5045f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xeb58, 0x0001, 0x0000); 5046f1bce4adSHeiner Kallweit 5047f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe614, 0x0700, 0x0400); 5048f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe63e, 0x0c30, 0x0020); 5049f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xc0b4, 0x0000, 0x000c); 5050f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xeb6a, 0x00ff, 0x0033); 5051f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xeb50, 0x03e0, 0x0040); 5052f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe056, 0x00f0, 0x0030); 5053f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe040, 0x1000, 0x0000); 5054f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe0c0, 0x4f0f, 0x4403); 5055f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe052, 0x0080, 0x0067); 5056f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xc0ac, 0x0080, 0x1f00); 5057f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xd430, 0x0fff, 0x047f); 5058f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe84c, 0x0000, 0x00c0); 5059f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xea1c, 0x0004, 0x0000); 5060f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xeb54, 0x0000, 0x0001); 5061f1bce4adSHeiner Kallweit udelay(1); 5062f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xeb54, 0x0001, 0x0000); 5063f1bce4adSHeiner Kallweit RTL_W16(tp, 0x1880, RTL_R16(tp, 0x1880) & ~0x0030); 5064f1bce4adSHeiner Kallweit 5065f1bce4adSHeiner Kallweit r8168_mac_ocp_write(tp, 0xe098, 0xc302); 5066f1bce4adSHeiner Kallweit 5067f1bce4adSHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_mac_ocp_e00e_cond, 1000, 10); 5068f1bce4adSHeiner Kallweit 5069b3a42e3aSHeiner Kallweit rtl8125_config_eee_mac(tp); 5070b3a42e3aSHeiner Kallweit 5071f1bce4adSHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) & ~RXDV_GATED_EN); 5072f1bce4adSHeiner Kallweit udelay(10); 5073f1bce4adSHeiner Kallweit } 5074f1bce4adSHeiner Kallweit 5075f1bce4adSHeiner Kallweit static void rtl_hw_start_8125_1(struct rtl8169_private *tp) 5076f1bce4adSHeiner Kallweit { 5077f1bce4adSHeiner Kallweit static const struct ephy_info e_info_8125_1[] = { 5078f1bce4adSHeiner Kallweit { 0x01, 0xffff, 0xa812 }, 5079f1bce4adSHeiner Kallweit { 0x09, 0xffff, 0x520c }, 5080f1bce4adSHeiner Kallweit { 0x04, 0xffff, 0xd000 }, 5081f1bce4adSHeiner Kallweit { 0x0d, 0xffff, 0xf702 }, 5082f1bce4adSHeiner Kallweit { 0x0a, 0xffff, 0x8653 }, 5083f1bce4adSHeiner Kallweit { 0x06, 0xffff, 0x001e }, 5084f1bce4adSHeiner Kallweit { 0x08, 0xffff, 0x3595 }, 5085f1bce4adSHeiner Kallweit { 0x20, 0xffff, 0x9455 }, 5086f1bce4adSHeiner Kallweit { 0x21, 0xffff, 0x99ff }, 5087f1bce4adSHeiner Kallweit { 0x02, 0xffff, 0x6046 }, 5088f1bce4adSHeiner Kallweit { 0x29, 0xffff, 0xfe00 }, 5089f1bce4adSHeiner Kallweit { 0x23, 0xffff, 0xab62 }, 5090f1bce4adSHeiner Kallweit 5091f1bce4adSHeiner Kallweit { 0x41, 0xffff, 0xa80c }, 5092f1bce4adSHeiner Kallweit { 0x49, 0xffff, 0x520c }, 5093f1bce4adSHeiner Kallweit { 0x44, 0xffff, 0xd000 }, 5094f1bce4adSHeiner Kallweit { 0x4d, 0xffff, 0xf702 }, 5095f1bce4adSHeiner Kallweit { 0x4a, 0xffff, 0x8653 }, 5096f1bce4adSHeiner Kallweit { 0x46, 0xffff, 0x001e }, 5097f1bce4adSHeiner Kallweit { 0x48, 0xffff, 0x3595 }, 5098f1bce4adSHeiner Kallweit { 0x60, 0xffff, 0x9455 }, 5099f1bce4adSHeiner Kallweit { 0x61, 0xffff, 0x99ff }, 5100f1bce4adSHeiner Kallweit { 0x42, 0xffff, 0x6046 }, 5101f1bce4adSHeiner Kallweit { 0x69, 0xffff, 0xfe00 }, 5102f1bce4adSHeiner Kallweit { 0x63, 0xffff, 0xab62 }, 5103f1bce4adSHeiner Kallweit }; 5104f1bce4adSHeiner Kallweit 5105f1bce4adSHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 5106f1bce4adSHeiner Kallweit 5107f1bce4adSHeiner Kallweit /* disable aspm and clock request before access ephy */ 5108f1bce4adSHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 5109f1bce4adSHeiner Kallweit rtl_ephy_init(tp, e_info_8125_1); 5110f1bce4adSHeiner Kallweit 5111f1bce4adSHeiner Kallweit rtl_hw_start_8125_common(tp); 5112f1bce4adSHeiner Kallweit } 5113f1bce4adSHeiner Kallweit 5114f1bce4adSHeiner Kallweit static void rtl_hw_start_8125_2(struct rtl8169_private *tp) 5115f1bce4adSHeiner Kallweit { 5116f1bce4adSHeiner Kallweit static const struct ephy_info e_info_8125_2[] = { 5117f1bce4adSHeiner Kallweit { 0x04, 0xffff, 0xd000 }, 5118f1bce4adSHeiner Kallweit { 0x0a, 0xffff, 0x8653 }, 5119f1bce4adSHeiner Kallweit { 0x23, 0xffff, 0xab66 }, 5120f1bce4adSHeiner Kallweit { 0x20, 0xffff, 0x9455 }, 5121f1bce4adSHeiner Kallweit { 0x21, 0xffff, 0x99ff }, 5122f1bce4adSHeiner Kallweit { 0x29, 0xffff, 0xfe04 }, 5123f1bce4adSHeiner Kallweit 5124f1bce4adSHeiner Kallweit { 0x44, 0xffff, 0xd000 }, 5125f1bce4adSHeiner Kallweit { 0x4a, 0xffff, 0x8653 }, 5126f1bce4adSHeiner Kallweit { 0x63, 0xffff, 0xab66 }, 5127f1bce4adSHeiner Kallweit { 0x60, 0xffff, 0x9455 }, 5128f1bce4adSHeiner Kallweit { 0x61, 0xffff, 0x99ff }, 5129f1bce4adSHeiner Kallweit { 0x69, 0xffff, 0xfe04 }, 5130f1bce4adSHeiner Kallweit }; 5131f1bce4adSHeiner Kallweit 5132f1bce4adSHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 5133f1bce4adSHeiner Kallweit 5134f1bce4adSHeiner Kallweit /* disable aspm and clock request before access ephy */ 5135f1bce4adSHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 5136f1bce4adSHeiner Kallweit rtl_ephy_init(tp, e_info_8125_2); 5137f1bce4adSHeiner Kallweit 5138f1bce4adSHeiner Kallweit rtl_hw_start_8125_common(tp); 5139f1bce4adSHeiner Kallweit } 5140f1bce4adSHeiner Kallweit 514125e992a4SHeiner Kallweit static void rtl_hw_config(struct rtl8169_private *tp) 514225e992a4SHeiner Kallweit { 514325e992a4SHeiner Kallweit static const rtl_generic_fct hw_configs[] = { 514425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_07] = rtl_hw_start_8102e_1, 514525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_08] = rtl_hw_start_8102e_3, 514625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_09] = rtl_hw_start_8102e_2, 514725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_10] = NULL, 514894b5ff74SHeiner Kallweit [RTL_GIGA_MAC_VER_11] = rtl_hw_start_8168b, 514994b5ff74SHeiner Kallweit [RTL_GIGA_MAC_VER_12] = rtl_hw_start_8168b, 515025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_13] = NULL, 515125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_14] = NULL, 515225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_15] = NULL, 515325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_16] = NULL, 515494b5ff74SHeiner Kallweit [RTL_GIGA_MAC_VER_17] = rtl_hw_start_8168b, 515525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_18] = rtl_hw_start_8168cp_1, 515625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_19] = rtl_hw_start_8168c_1, 515725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_20] = rtl_hw_start_8168c_2, 515825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_21] = rtl_hw_start_8168c_3, 515925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_22] = rtl_hw_start_8168c_4, 516025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_23] = rtl_hw_start_8168cp_2, 516125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_24] = rtl_hw_start_8168cp_3, 516225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_25] = rtl_hw_start_8168d, 516325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_26] = rtl_hw_start_8168d, 516425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_27] = rtl_hw_start_8168d, 516525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_28] = rtl_hw_start_8168d_4, 516625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_29] = rtl_hw_start_8105e_1, 516725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_30] = rtl_hw_start_8105e_2, 51680a413e6bSHeiner Kallweit [RTL_GIGA_MAC_VER_31] = rtl_hw_start_8168d, 516925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_32] = rtl_hw_start_8168e_1, 517025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_33] = rtl_hw_start_8168e_1, 517125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_34] = rtl_hw_start_8168e_2, 517225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_35] = rtl_hw_start_8168f_1, 517325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_36] = rtl_hw_start_8168f_1, 517425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_37] = rtl_hw_start_8402, 517525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_38] = rtl_hw_start_8411, 517625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_39] = rtl_hw_start_8106, 517725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_40] = rtl_hw_start_8168g_1, 517825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_41] = rtl_hw_start_8168g_1, 517925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_42] = rtl_hw_start_8168g_2, 518025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_43] = rtl_hw_start_8168g_2, 518125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_44] = rtl_hw_start_8411_2, 518225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_45] = rtl_hw_start_8168h_1, 518325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_46] = rtl_hw_start_8168h_1, 518425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_47] = rtl_hw_start_8168h_1, 518525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_48] = rtl_hw_start_8168h_1, 518625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_49] = rtl_hw_start_8168ep_1, 518725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_50] = rtl_hw_start_8168ep_2, 518825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_51] = rtl_hw_start_8168ep_3, 51891287723aSHeiner Kallweit [RTL_GIGA_MAC_VER_52] = rtl_hw_start_8117, 5190f1bce4adSHeiner Kallweit [RTL_GIGA_MAC_VER_60] = rtl_hw_start_8125_1, 5191f1bce4adSHeiner Kallweit [RTL_GIGA_MAC_VER_61] = rtl_hw_start_8125_2, 519225e992a4SHeiner Kallweit }; 519325e992a4SHeiner Kallweit 519425e992a4SHeiner Kallweit if (hw_configs[tp->mac_version]) 519525e992a4SHeiner Kallweit hw_configs[tp->mac_version](tp); 519625e992a4SHeiner Kallweit } 519725e992a4SHeiner Kallweit 5198f1bce4adSHeiner Kallweit static void rtl_hw_start_8125(struct rtl8169_private *tp) 5199f1bce4adSHeiner Kallweit { 5200f1bce4adSHeiner Kallweit int i; 5201f1bce4adSHeiner Kallweit 5202f1bce4adSHeiner Kallweit /* disable interrupt coalescing */ 5203f1bce4adSHeiner Kallweit for (i = 0xa00; i < 0xb00; i += 4) 5204f1bce4adSHeiner Kallweit RTL_W32(tp, i, 0); 5205f1bce4adSHeiner Kallweit 5206f1bce4adSHeiner Kallweit rtl_hw_config(tp); 5207f1bce4adSHeiner Kallweit } 5208f1bce4adSHeiner Kallweit 520925e992a4SHeiner Kallweit static void rtl_hw_start_8168(struct rtl8169_private *tp) 521025e992a4SHeiner Kallweit { 5211272b2265SHeiner Kallweit if (rtl_is_8168evl_up(tp)) 5212272b2265SHeiner Kallweit RTL_W8(tp, MaxTxPacketSize, EarlySize); 5213272b2265SHeiner Kallweit else 521425e992a4SHeiner Kallweit RTL_W8(tp, MaxTxPacketSize, TxPacketMax); 521525e992a4SHeiner Kallweit 521625e992a4SHeiner Kallweit rtl_hw_config(tp); 5217bcf2b868SHeiner Kallweit 5218bcf2b868SHeiner Kallweit /* disable interrupt coalescing */ 5219bcf2b868SHeiner Kallweit RTL_W16(tp, IntrMitigate, 0x0000); 522025e992a4SHeiner Kallweit } 522125e992a4SHeiner Kallweit 52226c19156eSHeiner Kallweit static void rtl_hw_start_8169(struct rtl8169_private *tp) 52236c19156eSHeiner Kallweit { 52246c19156eSHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_05) 52256c19156eSHeiner Kallweit pci_write_config_byte(tp->pci_dev, PCI_CACHE_LINE_SIZE, 0x08); 52266c19156eSHeiner Kallweit 52276c19156eSHeiner Kallweit RTL_W8(tp, EarlyTxThres, NoEarlyTx); 52286c19156eSHeiner Kallweit 52296c19156eSHeiner Kallweit tp->cp_cmd |= PCIMulRW; 52306c19156eSHeiner Kallweit 52316c19156eSHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_02 || 523209e65335SHeiner Kallweit tp->mac_version == RTL_GIGA_MAC_VER_03) 523309e65335SHeiner Kallweit tp->cp_cmd |= EnAnaPLL; 52346c19156eSHeiner Kallweit 52356c19156eSHeiner Kallweit RTL_W16(tp, CPlusCmd, tp->cp_cmd); 52366c19156eSHeiner Kallweit 52376c19156eSHeiner Kallweit rtl8169_set_magic_reg(tp, tp->mac_version); 52386c19156eSHeiner Kallweit 52396c19156eSHeiner Kallweit RTL_W32(tp, RxMissed, 0); 5240bcf2b868SHeiner Kallweit 5241bcf2b868SHeiner Kallweit /* disable interrupt coalescing */ 5242bcf2b868SHeiner Kallweit RTL_W16(tp, IntrMitigate, 0x0000); 52436c19156eSHeiner Kallweit } 52446c19156eSHeiner Kallweit 52456c19156eSHeiner Kallweit static void rtl_hw_start(struct rtl8169_private *tp) 52466c19156eSHeiner Kallweit { 52476c19156eSHeiner Kallweit rtl_unlock_config_regs(tp); 52486c19156eSHeiner Kallweit 52496c19156eSHeiner Kallweit tp->cp_cmd &= CPCMD_MASK; 52506c19156eSHeiner Kallweit RTL_W16(tp, CPlusCmd, tp->cp_cmd); 52516c19156eSHeiner Kallweit 52526c19156eSHeiner Kallweit if (tp->mac_version <= RTL_GIGA_MAC_VER_06) 52536c19156eSHeiner Kallweit rtl_hw_start_8169(tp); 5254f1bce4adSHeiner Kallweit else if (rtl_is_8125(tp)) 5255f1bce4adSHeiner Kallweit rtl_hw_start_8125(tp); 52566c19156eSHeiner Kallweit else 52576c19156eSHeiner Kallweit rtl_hw_start_8168(tp); 52586c19156eSHeiner Kallweit 52596c19156eSHeiner Kallweit rtl_set_rx_max_size(tp); 52606c19156eSHeiner Kallweit rtl_set_rx_tx_desc_registers(tp); 52616c19156eSHeiner Kallweit rtl_lock_config_regs(tp); 52626c19156eSHeiner Kallweit 52634ebcb113SHeiner Kallweit rtl_jumbo_config(tp, tp->dev->mtu); 52644ebcb113SHeiner Kallweit 52656c19156eSHeiner Kallweit /* Initially a 10 us delay. Turned it into a PCI commit. - FR */ 52667366016dSHeiner Kallweit RTL_R16(tp, CPlusCmd); 52676c19156eSHeiner Kallweit RTL_W8(tp, ChipCmd, CmdTxEnb | CmdRxEnb); 52686c19156eSHeiner Kallweit rtl_init_rxcfg(tp); 52696c19156eSHeiner Kallweit rtl_set_tx_config_registers(tp); 52706c19156eSHeiner Kallweit rtl_set_rx_mode(tp->dev); 52716c19156eSHeiner Kallweit rtl_irq_enable(tp); 52726c19156eSHeiner Kallweit } 52736c19156eSHeiner Kallweit 527425e992a4SHeiner Kallweit static int rtl8169_change_mtu(struct net_device *dev, int new_mtu) 527525e992a4SHeiner Kallweit { 527625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 527725e992a4SHeiner Kallweit 52784ebcb113SHeiner Kallweit rtl_jumbo_config(tp, new_mtu); 527925e992a4SHeiner Kallweit 528025e992a4SHeiner Kallweit dev->mtu = new_mtu; 528125e992a4SHeiner Kallweit netdev_update_features(dev); 528225e992a4SHeiner Kallweit 528325e992a4SHeiner Kallweit return 0; 528425e992a4SHeiner Kallweit } 528525e992a4SHeiner Kallweit 528625e992a4SHeiner Kallweit static inline void rtl8169_make_unusable_by_asic(struct RxDesc *desc) 528725e992a4SHeiner Kallweit { 528825e992a4SHeiner Kallweit desc->addr = cpu_to_le64(0x0badbadbadbadbadull); 528925e992a4SHeiner Kallweit desc->opts1 &= ~cpu_to_le32(DescOwn | RsvdMask); 529025e992a4SHeiner Kallweit } 529125e992a4SHeiner Kallweit 529225e992a4SHeiner Kallweit static inline void rtl8169_mark_to_asic(struct RxDesc *desc) 529325e992a4SHeiner Kallweit { 529425e992a4SHeiner Kallweit u32 eor = le32_to_cpu(desc->opts1) & RingEnd; 529525e992a4SHeiner Kallweit 529625e992a4SHeiner Kallweit /* Force memory writes to complete before releasing descriptor */ 529725e992a4SHeiner Kallweit dma_wmb(); 529825e992a4SHeiner Kallweit 529925e992a4SHeiner Kallweit desc->opts1 = cpu_to_le32(DescOwn | eor | R8169_RX_BUF_SIZE); 530025e992a4SHeiner Kallweit } 530125e992a4SHeiner Kallweit 530232879f00SHeiner Kallweit static struct page *rtl8169_alloc_rx_data(struct rtl8169_private *tp, 530325e992a4SHeiner Kallweit struct RxDesc *desc) 530425e992a4SHeiner Kallweit { 530525e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 530625e992a4SHeiner Kallweit int node = dev_to_node(d); 530732879f00SHeiner Kallweit dma_addr_t mapping; 530832879f00SHeiner Kallweit struct page *data; 530925e992a4SHeiner Kallweit 531032879f00SHeiner Kallweit data = alloc_pages_node(node, GFP_KERNEL, get_order(R8169_RX_BUF_SIZE)); 531125e992a4SHeiner Kallweit if (!data) 531225e992a4SHeiner Kallweit return NULL; 531325e992a4SHeiner Kallweit 531432879f00SHeiner Kallweit mapping = dma_map_page(d, data, 0, R8169_RX_BUF_SIZE, DMA_FROM_DEVICE); 531525e992a4SHeiner Kallweit if (unlikely(dma_mapping_error(d, mapping))) { 531625e992a4SHeiner Kallweit if (net_ratelimit()) 531725e992a4SHeiner Kallweit netif_err(tp, drv, tp->dev, "Failed to map RX DMA!\n"); 531832879f00SHeiner Kallweit __free_pages(data, get_order(R8169_RX_BUF_SIZE)); 531932879f00SHeiner Kallweit return NULL; 532025e992a4SHeiner Kallweit } 532125e992a4SHeiner Kallweit 532225e992a4SHeiner Kallweit desc->addr = cpu_to_le64(mapping); 532325e992a4SHeiner Kallweit rtl8169_mark_to_asic(desc); 532425e992a4SHeiner Kallweit 532532879f00SHeiner Kallweit return data; 532625e992a4SHeiner Kallweit } 532725e992a4SHeiner Kallweit 532825e992a4SHeiner Kallweit static void rtl8169_rx_clear(struct rtl8169_private *tp) 532925e992a4SHeiner Kallweit { 533025e992a4SHeiner Kallweit unsigned int i; 533125e992a4SHeiner Kallweit 5332eb2e7f09SHeiner Kallweit for (i = 0; i < NUM_RX_DESC && tp->Rx_databuff[i]; i++) { 5333eb2e7f09SHeiner Kallweit dma_unmap_page(tp_to_dev(tp), 5334eb2e7f09SHeiner Kallweit le64_to_cpu(tp->RxDescArray[i].addr), 5335eb2e7f09SHeiner Kallweit R8169_RX_BUF_SIZE, DMA_FROM_DEVICE); 5336eb2e7f09SHeiner Kallweit __free_pages(tp->Rx_databuff[i], get_order(R8169_RX_BUF_SIZE)); 5337eb2e7f09SHeiner Kallweit tp->Rx_databuff[i] = NULL; 5338eb2e7f09SHeiner Kallweit rtl8169_make_unusable_by_asic(tp->RxDescArray + i); 533925e992a4SHeiner Kallweit } 534025e992a4SHeiner Kallweit } 534125e992a4SHeiner Kallweit 534225e992a4SHeiner Kallweit static inline void rtl8169_mark_as_last_descriptor(struct RxDesc *desc) 534325e992a4SHeiner Kallweit { 534425e992a4SHeiner Kallweit desc->opts1 |= cpu_to_le32(RingEnd); 534525e992a4SHeiner Kallweit } 534625e992a4SHeiner Kallweit 534725e992a4SHeiner Kallweit static int rtl8169_rx_fill(struct rtl8169_private *tp) 534825e992a4SHeiner Kallweit { 534925e992a4SHeiner Kallweit unsigned int i; 535025e992a4SHeiner Kallweit 535125e992a4SHeiner Kallweit for (i = 0; i < NUM_RX_DESC; i++) { 535232879f00SHeiner Kallweit struct page *data; 535325e992a4SHeiner Kallweit 535425e992a4SHeiner Kallweit data = rtl8169_alloc_rx_data(tp, tp->RxDescArray + i); 535525e992a4SHeiner Kallweit if (!data) { 5356e4b5c7a5SHeiner Kallweit rtl8169_rx_clear(tp); 5357e4b5c7a5SHeiner Kallweit return -ENOMEM; 535825e992a4SHeiner Kallweit } 535925e992a4SHeiner Kallweit tp->Rx_databuff[i] = data; 536025e992a4SHeiner Kallweit } 536125e992a4SHeiner Kallweit 536225e992a4SHeiner Kallweit rtl8169_mark_as_last_descriptor(tp->RxDescArray + NUM_RX_DESC - 1); 536325e992a4SHeiner Kallweit 5364e4b5c7a5SHeiner Kallweit return 0; 536525e992a4SHeiner Kallweit } 536625e992a4SHeiner Kallweit 536725e992a4SHeiner Kallweit static int rtl8169_init_ring(struct rtl8169_private *tp) 536825e992a4SHeiner Kallweit { 536925e992a4SHeiner Kallweit rtl8169_init_ring_indexes(tp); 537025e992a4SHeiner Kallweit 537125e992a4SHeiner Kallweit memset(tp->tx_skb, 0, sizeof(tp->tx_skb)); 537225e992a4SHeiner Kallweit memset(tp->Rx_databuff, 0, sizeof(tp->Rx_databuff)); 537325e992a4SHeiner Kallweit 537425e992a4SHeiner Kallweit return rtl8169_rx_fill(tp); 537525e992a4SHeiner Kallweit } 537625e992a4SHeiner Kallweit 537725e992a4SHeiner Kallweit static void rtl8169_unmap_tx_skb(struct device *d, struct ring_info *tx_skb, 537825e992a4SHeiner Kallweit struct TxDesc *desc) 537925e992a4SHeiner Kallweit { 538025e992a4SHeiner Kallweit unsigned int len = tx_skb->len; 538125e992a4SHeiner Kallweit 538225e992a4SHeiner Kallweit dma_unmap_single(d, le64_to_cpu(desc->addr), len, DMA_TO_DEVICE); 538325e992a4SHeiner Kallweit 538425e992a4SHeiner Kallweit desc->opts1 = 0x00; 538525e992a4SHeiner Kallweit desc->opts2 = 0x00; 538625e992a4SHeiner Kallweit desc->addr = 0x00; 538725e992a4SHeiner Kallweit tx_skb->len = 0; 538825e992a4SHeiner Kallweit } 538925e992a4SHeiner Kallweit 539025e992a4SHeiner Kallweit static void rtl8169_tx_clear_range(struct rtl8169_private *tp, u32 start, 539125e992a4SHeiner Kallweit unsigned int n) 539225e992a4SHeiner Kallweit { 539325e992a4SHeiner Kallweit unsigned int i; 539425e992a4SHeiner Kallweit 539525e992a4SHeiner Kallweit for (i = 0; i < n; i++) { 539625e992a4SHeiner Kallweit unsigned int entry = (start + i) % NUM_TX_DESC; 539725e992a4SHeiner Kallweit struct ring_info *tx_skb = tp->tx_skb + entry; 539825e992a4SHeiner Kallweit unsigned int len = tx_skb->len; 539925e992a4SHeiner Kallweit 540025e992a4SHeiner Kallweit if (len) { 540125e992a4SHeiner Kallweit struct sk_buff *skb = tx_skb->skb; 540225e992a4SHeiner Kallweit 540325e992a4SHeiner Kallweit rtl8169_unmap_tx_skb(tp_to_dev(tp), tx_skb, 540425e992a4SHeiner Kallweit tp->TxDescArray + entry); 540525e992a4SHeiner Kallweit if (skb) { 540625e992a4SHeiner Kallweit dev_consume_skb_any(skb); 540725e992a4SHeiner Kallweit tx_skb->skb = NULL; 540825e992a4SHeiner Kallweit } 540925e992a4SHeiner Kallweit } 541025e992a4SHeiner Kallweit } 541125e992a4SHeiner Kallweit } 541225e992a4SHeiner Kallweit 541325e992a4SHeiner Kallweit static void rtl8169_tx_clear(struct rtl8169_private *tp) 541425e992a4SHeiner Kallweit { 541525e992a4SHeiner Kallweit rtl8169_tx_clear_range(tp, tp->dirty_tx, NUM_TX_DESC); 541625e992a4SHeiner Kallweit tp->cur_tx = tp->dirty_tx = 0; 541725e992a4SHeiner Kallweit netdev_reset_queue(tp->dev); 541825e992a4SHeiner Kallweit } 541925e992a4SHeiner Kallweit 542025e992a4SHeiner Kallweit static void rtl_reset_work(struct rtl8169_private *tp) 542125e992a4SHeiner Kallweit { 542225e992a4SHeiner Kallweit struct net_device *dev = tp->dev; 542325e992a4SHeiner Kallweit int i; 542425e992a4SHeiner Kallweit 542525e992a4SHeiner Kallweit napi_disable(&tp->napi); 542625e992a4SHeiner Kallweit netif_stop_queue(dev); 542725e992a4SHeiner Kallweit synchronize_rcu(); 542825e992a4SHeiner Kallweit 542925e992a4SHeiner Kallweit rtl8169_hw_reset(tp); 543025e992a4SHeiner Kallweit 543125e992a4SHeiner Kallweit for (i = 0; i < NUM_RX_DESC; i++) 543225e992a4SHeiner Kallweit rtl8169_mark_to_asic(tp->RxDescArray + i); 543325e992a4SHeiner Kallweit 543425e992a4SHeiner Kallweit rtl8169_tx_clear(tp); 543525e992a4SHeiner Kallweit rtl8169_init_ring_indexes(tp); 543625e992a4SHeiner Kallweit 543725e992a4SHeiner Kallweit napi_enable(&tp->napi); 543825e992a4SHeiner Kallweit rtl_hw_start(tp); 543925e992a4SHeiner Kallweit netif_wake_queue(dev); 544025e992a4SHeiner Kallweit } 544125e992a4SHeiner Kallweit 54420290bd29SMichael S. Tsirkin static void rtl8169_tx_timeout(struct net_device *dev, unsigned int txqueue) 544325e992a4SHeiner Kallweit { 544425e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 544525e992a4SHeiner Kallweit 544625e992a4SHeiner Kallweit rtl_schedule_task(tp, RTL_FLAG_TASK_RESET_PENDING); 544725e992a4SHeiner Kallweit } 544825e992a4SHeiner Kallweit 544925e992a4SHeiner Kallweit static __le32 rtl8169_get_txd_opts1(u32 opts0, u32 len, unsigned int entry) 545025e992a4SHeiner Kallweit { 545125e992a4SHeiner Kallweit u32 status = opts0 | len; 545225e992a4SHeiner Kallweit 545325e992a4SHeiner Kallweit if (entry == NUM_TX_DESC - 1) 545425e992a4SHeiner Kallweit status |= RingEnd; 545525e992a4SHeiner Kallweit 545625e992a4SHeiner Kallweit return cpu_to_le32(status); 545725e992a4SHeiner Kallweit } 545825e992a4SHeiner Kallweit 545925e992a4SHeiner Kallweit static int rtl8169_xmit_frags(struct rtl8169_private *tp, struct sk_buff *skb, 546025e992a4SHeiner Kallweit u32 *opts) 546125e992a4SHeiner Kallweit { 546225e992a4SHeiner Kallweit struct skb_shared_info *info = skb_shinfo(skb); 546325e992a4SHeiner Kallweit unsigned int cur_frag, entry; 546425e992a4SHeiner Kallweit struct TxDesc *uninitialized_var(txd); 546525e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 546625e992a4SHeiner Kallweit 546725e992a4SHeiner Kallweit entry = tp->cur_tx; 546825e992a4SHeiner Kallweit for (cur_frag = 0; cur_frag < info->nr_frags; cur_frag++) { 546925e992a4SHeiner Kallweit const skb_frag_t *frag = info->frags + cur_frag; 547025e992a4SHeiner Kallweit dma_addr_t mapping; 547125e992a4SHeiner Kallweit u32 len; 547225e992a4SHeiner Kallweit void *addr; 547325e992a4SHeiner Kallweit 547425e992a4SHeiner Kallweit entry = (entry + 1) % NUM_TX_DESC; 547525e992a4SHeiner Kallweit 547625e992a4SHeiner Kallweit txd = tp->TxDescArray + entry; 547725e992a4SHeiner Kallweit len = skb_frag_size(frag); 547825e992a4SHeiner Kallweit addr = skb_frag_address(frag); 547925e992a4SHeiner Kallweit mapping = dma_map_single(d, addr, len, DMA_TO_DEVICE); 548025e992a4SHeiner Kallweit if (unlikely(dma_mapping_error(d, mapping))) { 548125e992a4SHeiner Kallweit if (net_ratelimit()) 548225e992a4SHeiner Kallweit netif_err(tp, drv, tp->dev, 548325e992a4SHeiner Kallweit "Failed to map TX fragments DMA!\n"); 548425e992a4SHeiner Kallweit goto err_out; 548525e992a4SHeiner Kallweit } 548625e992a4SHeiner Kallweit 548725e992a4SHeiner Kallweit txd->opts1 = rtl8169_get_txd_opts1(opts[0], len, entry); 548825e992a4SHeiner Kallweit txd->opts2 = cpu_to_le32(opts[1]); 548925e992a4SHeiner Kallweit txd->addr = cpu_to_le64(mapping); 549025e992a4SHeiner Kallweit 549125e992a4SHeiner Kallweit tp->tx_skb[entry].len = len; 549225e992a4SHeiner Kallweit } 549325e992a4SHeiner Kallweit 549425e992a4SHeiner Kallweit if (cur_frag) { 549525e992a4SHeiner Kallweit tp->tx_skb[entry].skb = skb; 549625e992a4SHeiner Kallweit txd->opts1 |= cpu_to_le32(LastFrag); 549725e992a4SHeiner Kallweit } 549825e992a4SHeiner Kallweit 549925e992a4SHeiner Kallweit return cur_frag; 550025e992a4SHeiner Kallweit 550125e992a4SHeiner Kallweit err_out: 550225e992a4SHeiner Kallweit rtl8169_tx_clear_range(tp, tp->cur_tx + 1, cur_frag); 550325e992a4SHeiner Kallweit return -EIO; 550425e992a4SHeiner Kallweit } 550525e992a4SHeiner Kallweit 550625e992a4SHeiner Kallweit static bool rtl_test_hw_pad_bug(struct rtl8169_private *tp, struct sk_buff *skb) 550725e992a4SHeiner Kallweit { 550825e992a4SHeiner Kallweit return skb->len < ETH_ZLEN && tp->mac_version == RTL_GIGA_MAC_VER_34; 550925e992a4SHeiner Kallweit } 551025e992a4SHeiner Kallweit 551125e992a4SHeiner Kallweit /* msdn_giant_send_check() 551225e992a4SHeiner Kallweit * According to the document of microsoft, the TCP Pseudo Header excludes the 551325e992a4SHeiner Kallweit * packet length for IPv6 TCP large packets. 551425e992a4SHeiner Kallweit */ 551525e992a4SHeiner Kallweit static int msdn_giant_send_check(struct sk_buff *skb) 551625e992a4SHeiner Kallweit { 551725e992a4SHeiner Kallweit const struct ipv6hdr *ipv6h; 551825e992a4SHeiner Kallweit struct tcphdr *th; 551925e992a4SHeiner Kallweit int ret; 552025e992a4SHeiner Kallweit 552125e992a4SHeiner Kallweit ret = skb_cow_head(skb, 0); 552225e992a4SHeiner Kallweit if (ret) 552325e992a4SHeiner Kallweit return ret; 552425e992a4SHeiner Kallweit 552525e992a4SHeiner Kallweit ipv6h = ipv6_hdr(skb); 552625e992a4SHeiner Kallweit th = tcp_hdr(skb); 552725e992a4SHeiner Kallweit 552825e992a4SHeiner Kallweit th->check = 0; 552925e992a4SHeiner Kallweit th->check = ~tcp_v6_check(0, &ipv6h->saddr, &ipv6h->daddr, 0); 553025e992a4SHeiner Kallweit 553125e992a4SHeiner Kallweit return ret; 553225e992a4SHeiner Kallweit } 553325e992a4SHeiner Kallweit 553425e992a4SHeiner Kallweit static void rtl8169_tso_csum_v1(struct sk_buff *skb, u32 *opts) 553525e992a4SHeiner Kallweit { 553625e992a4SHeiner Kallweit u32 mss = skb_shinfo(skb)->gso_size; 553725e992a4SHeiner Kallweit 553825e992a4SHeiner Kallweit if (mss) { 553925e992a4SHeiner Kallweit opts[0] |= TD_LSO; 554025e992a4SHeiner Kallweit opts[0] |= min(mss, TD_MSS_MAX) << TD0_MSS_SHIFT; 554125e992a4SHeiner Kallweit } else if (skb->ip_summed == CHECKSUM_PARTIAL) { 554225e992a4SHeiner Kallweit const struct iphdr *ip = ip_hdr(skb); 554325e992a4SHeiner Kallweit 554425e992a4SHeiner Kallweit if (ip->protocol == IPPROTO_TCP) 554525e992a4SHeiner Kallweit opts[0] |= TD0_IP_CS | TD0_TCP_CS; 554625e992a4SHeiner Kallweit else if (ip->protocol == IPPROTO_UDP) 554725e992a4SHeiner Kallweit opts[0] |= TD0_IP_CS | TD0_UDP_CS; 554825e992a4SHeiner Kallweit else 554925e992a4SHeiner Kallweit WARN_ON_ONCE(1); 555025e992a4SHeiner Kallweit } 555125e992a4SHeiner Kallweit } 555225e992a4SHeiner Kallweit 555325e992a4SHeiner Kallweit static bool rtl8169_tso_csum_v2(struct rtl8169_private *tp, 555425e992a4SHeiner Kallweit struct sk_buff *skb, u32 *opts) 555525e992a4SHeiner Kallweit { 555625e992a4SHeiner Kallweit u32 transport_offset = (u32)skb_transport_offset(skb); 555725e992a4SHeiner Kallweit u32 mss = skb_shinfo(skb)->gso_size; 555825e992a4SHeiner Kallweit 555925e992a4SHeiner Kallweit if (mss) { 556025e992a4SHeiner Kallweit switch (vlan_get_protocol(skb)) { 556125e992a4SHeiner Kallweit case htons(ETH_P_IP): 556225e992a4SHeiner Kallweit opts[0] |= TD1_GTSENV4; 556325e992a4SHeiner Kallweit break; 556425e992a4SHeiner Kallweit 556525e992a4SHeiner Kallweit case htons(ETH_P_IPV6): 556625e992a4SHeiner Kallweit if (msdn_giant_send_check(skb)) 556725e992a4SHeiner Kallweit return false; 556825e992a4SHeiner Kallweit 556925e992a4SHeiner Kallweit opts[0] |= TD1_GTSENV6; 557025e992a4SHeiner Kallweit break; 557125e992a4SHeiner Kallweit 557225e992a4SHeiner Kallweit default: 557325e992a4SHeiner Kallweit WARN_ON_ONCE(1); 557425e992a4SHeiner Kallweit break; 557525e992a4SHeiner Kallweit } 557625e992a4SHeiner Kallweit 557725e992a4SHeiner Kallweit opts[0] |= transport_offset << GTTCPHO_SHIFT; 557825e992a4SHeiner Kallweit opts[1] |= min(mss, TD_MSS_MAX) << TD1_MSS_SHIFT; 557925e992a4SHeiner Kallweit } else if (skb->ip_summed == CHECKSUM_PARTIAL) { 558025e992a4SHeiner Kallweit u8 ip_protocol; 558125e992a4SHeiner Kallweit 558225e992a4SHeiner Kallweit switch (vlan_get_protocol(skb)) { 558325e992a4SHeiner Kallweit case htons(ETH_P_IP): 558425e992a4SHeiner Kallweit opts[1] |= TD1_IPv4_CS; 558525e992a4SHeiner Kallweit ip_protocol = ip_hdr(skb)->protocol; 558625e992a4SHeiner Kallweit break; 558725e992a4SHeiner Kallweit 558825e992a4SHeiner Kallweit case htons(ETH_P_IPV6): 558925e992a4SHeiner Kallweit opts[1] |= TD1_IPv6_CS; 559025e992a4SHeiner Kallweit ip_protocol = ipv6_hdr(skb)->nexthdr; 559125e992a4SHeiner Kallweit break; 559225e992a4SHeiner Kallweit 559325e992a4SHeiner Kallweit default: 559425e992a4SHeiner Kallweit ip_protocol = IPPROTO_RAW; 559525e992a4SHeiner Kallweit break; 559625e992a4SHeiner Kallweit } 559725e992a4SHeiner Kallweit 559825e992a4SHeiner Kallweit if (ip_protocol == IPPROTO_TCP) 559925e992a4SHeiner Kallweit opts[1] |= TD1_TCP_CS; 560025e992a4SHeiner Kallweit else if (ip_protocol == IPPROTO_UDP) 560125e992a4SHeiner Kallweit opts[1] |= TD1_UDP_CS; 560225e992a4SHeiner Kallweit else 560325e992a4SHeiner Kallweit WARN_ON_ONCE(1); 560425e992a4SHeiner Kallweit 560525e992a4SHeiner Kallweit opts[1] |= transport_offset << TCPHO_SHIFT; 560625e992a4SHeiner Kallweit } else { 560725e992a4SHeiner Kallweit if (unlikely(rtl_test_hw_pad_bug(tp, skb))) 560825e992a4SHeiner Kallweit return !eth_skb_pad(skb); 560925e992a4SHeiner Kallweit } 561025e992a4SHeiner Kallweit 561125e992a4SHeiner Kallweit return true; 561225e992a4SHeiner Kallweit } 561325e992a4SHeiner Kallweit 561425e992a4SHeiner Kallweit static bool rtl_tx_slots_avail(struct rtl8169_private *tp, 561525e992a4SHeiner Kallweit unsigned int nr_frags) 561625e992a4SHeiner Kallweit { 561725e992a4SHeiner Kallweit unsigned int slots_avail = tp->dirty_tx + NUM_TX_DESC - tp->cur_tx; 561825e992a4SHeiner Kallweit 561925e992a4SHeiner Kallweit /* A skbuff with nr_frags needs nr_frags+1 entries in the tx queue */ 562025e992a4SHeiner Kallweit return slots_avail > nr_frags; 562125e992a4SHeiner Kallweit } 562225e992a4SHeiner Kallweit 562325e992a4SHeiner Kallweit /* Versions RTL8102e and from RTL8168c onwards support csum_v2 */ 562425e992a4SHeiner Kallweit static bool rtl_chip_supports_csum_v2(struct rtl8169_private *tp) 562525e992a4SHeiner Kallweit { 562625e992a4SHeiner Kallweit switch (tp->mac_version) { 562725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_02 ... RTL_GIGA_MAC_VER_06: 562825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_10 ... RTL_GIGA_MAC_VER_17: 562925e992a4SHeiner Kallweit return false; 563025e992a4SHeiner Kallweit default: 563125e992a4SHeiner Kallweit return true; 563225e992a4SHeiner Kallweit } 563325e992a4SHeiner Kallweit } 563425e992a4SHeiner Kallweit 5635f1bce4adSHeiner Kallweit static void rtl8169_doorbell(struct rtl8169_private *tp) 5636f1bce4adSHeiner Kallweit { 5637f1bce4adSHeiner Kallweit if (rtl_is_8125(tp)) 5638f1bce4adSHeiner Kallweit RTL_W16(tp, TxPoll_8125, BIT(0)); 5639f1bce4adSHeiner Kallweit else 5640f1bce4adSHeiner Kallweit RTL_W8(tp, TxPoll, NPQ); 5641f1bce4adSHeiner Kallweit } 5642f1bce4adSHeiner Kallweit 564325e992a4SHeiner Kallweit static netdev_tx_t rtl8169_start_xmit(struct sk_buff *skb, 564425e992a4SHeiner Kallweit struct net_device *dev) 564525e992a4SHeiner Kallweit { 564625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 564725e992a4SHeiner Kallweit unsigned int entry = tp->cur_tx % NUM_TX_DESC; 564825e992a4SHeiner Kallweit struct TxDesc *txd = tp->TxDescArray + entry; 564925e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 565025e992a4SHeiner Kallweit dma_addr_t mapping; 565125e992a4SHeiner Kallweit u32 opts[2], len; 5652ef143585SHeiner Kallweit bool stop_queue; 5653ef143585SHeiner Kallweit bool door_bell; 565425e992a4SHeiner Kallweit int frags; 565525e992a4SHeiner Kallweit 565625e992a4SHeiner Kallweit if (unlikely(!rtl_tx_slots_avail(tp, skb_shinfo(skb)->nr_frags))) { 565725e992a4SHeiner Kallweit netif_err(tp, drv, dev, "BUG! Tx Ring full when queue awake!\n"); 565825e992a4SHeiner Kallweit goto err_stop_0; 565925e992a4SHeiner Kallweit } 566025e992a4SHeiner Kallweit 566125e992a4SHeiner Kallweit if (unlikely(le32_to_cpu(txd->opts1) & DescOwn)) 566225e992a4SHeiner Kallweit goto err_stop_0; 566325e992a4SHeiner Kallweit 5664355f948aSHeiner Kallweit opts[1] = rtl8169_tx_vlan_tag(skb); 566525e992a4SHeiner Kallweit opts[0] = DescOwn; 566625e992a4SHeiner Kallweit 566725e992a4SHeiner Kallweit if (rtl_chip_supports_csum_v2(tp)) { 566896ea772eSHeiner Kallweit if (!rtl8169_tso_csum_v2(tp, skb, opts)) 566996ea772eSHeiner Kallweit goto err_dma_0; 567025e992a4SHeiner Kallweit } else { 567125e992a4SHeiner Kallweit rtl8169_tso_csum_v1(skb, opts); 567225e992a4SHeiner Kallweit } 567325e992a4SHeiner Kallweit 567425e992a4SHeiner Kallweit len = skb_headlen(skb); 567525e992a4SHeiner Kallweit mapping = dma_map_single(d, skb->data, len, DMA_TO_DEVICE); 567625e992a4SHeiner Kallweit if (unlikely(dma_mapping_error(d, mapping))) { 567725e992a4SHeiner Kallweit if (net_ratelimit()) 567825e992a4SHeiner Kallweit netif_err(tp, drv, dev, "Failed to map TX DMA!\n"); 567925e992a4SHeiner Kallweit goto err_dma_0; 568025e992a4SHeiner Kallweit } 568125e992a4SHeiner Kallweit 568225e992a4SHeiner Kallweit tp->tx_skb[entry].len = len; 568325e992a4SHeiner Kallweit txd->addr = cpu_to_le64(mapping); 568425e992a4SHeiner Kallweit 568525e992a4SHeiner Kallweit frags = rtl8169_xmit_frags(tp, skb, opts); 568625e992a4SHeiner Kallweit if (frags < 0) 568725e992a4SHeiner Kallweit goto err_dma_1; 568825e992a4SHeiner Kallweit else if (frags) 568925e992a4SHeiner Kallweit opts[0] |= FirstFrag; 569025e992a4SHeiner Kallweit else { 569125e992a4SHeiner Kallweit opts[0] |= FirstFrag | LastFrag; 569225e992a4SHeiner Kallweit tp->tx_skb[entry].skb = skb; 569325e992a4SHeiner Kallweit } 569425e992a4SHeiner Kallweit 569525e992a4SHeiner Kallweit txd->opts2 = cpu_to_le32(opts[1]); 569625e992a4SHeiner Kallweit 569725e992a4SHeiner Kallweit skb_tx_timestamp(skb); 569825e992a4SHeiner Kallweit 569925e992a4SHeiner Kallweit /* Force memory writes to complete before releasing descriptor */ 570025e992a4SHeiner Kallweit dma_wmb(); 570125e992a4SHeiner Kallweit 5702ef143585SHeiner Kallweit door_bell = __netdev_sent_queue(dev, skb->len, netdev_xmit_more()); 5703ef143585SHeiner Kallweit 570425e992a4SHeiner Kallweit txd->opts1 = rtl8169_get_txd_opts1(opts[0], len, entry); 570525e992a4SHeiner Kallweit 570625e992a4SHeiner Kallweit /* Force all memory writes to complete before notifying device */ 570725e992a4SHeiner Kallweit wmb(); 570825e992a4SHeiner Kallweit 570925e992a4SHeiner Kallweit tp->cur_tx += frags + 1; 571025e992a4SHeiner Kallweit 5711ef143585SHeiner Kallweit stop_queue = !rtl_tx_slots_avail(tp, MAX_SKB_FRAGS); 5712ef143585SHeiner Kallweit if (unlikely(stop_queue)) { 571325e992a4SHeiner Kallweit /* Avoid wrongly optimistic queue wake-up: rtl_tx thread must 571425e992a4SHeiner Kallweit * not miss a ring update when it notices a stopped queue. 571525e992a4SHeiner Kallweit */ 571625e992a4SHeiner Kallweit smp_wmb(); 571725e992a4SHeiner Kallweit netif_stop_queue(dev); 57184773f9bdSHeiner Kallweit door_bell = true; 5719ef143585SHeiner Kallweit } 5720ef143585SHeiner Kallweit 5721ef143585SHeiner Kallweit if (door_bell) 5722f1bce4adSHeiner Kallweit rtl8169_doorbell(tp); 5723ef143585SHeiner Kallweit 5724ef143585SHeiner Kallweit if (unlikely(stop_queue)) { 572525e992a4SHeiner Kallweit /* Sync with rtl_tx: 572625e992a4SHeiner Kallweit * - publish queue status and cur_tx ring index (write barrier) 572725e992a4SHeiner Kallweit * - refresh dirty_tx ring index (read barrier). 572825e992a4SHeiner Kallweit * May the current thread have a pessimistic view of the ring 572925e992a4SHeiner Kallweit * status and forget to wake up queue, a racing rtl_tx thread 573025e992a4SHeiner Kallweit * can't. 573125e992a4SHeiner Kallweit */ 573225e992a4SHeiner Kallweit smp_mb(); 573325e992a4SHeiner Kallweit if (rtl_tx_slots_avail(tp, MAX_SKB_FRAGS)) 573425e992a4SHeiner Kallweit netif_start_queue(dev); 573525e992a4SHeiner Kallweit } 573625e992a4SHeiner Kallweit 573725e992a4SHeiner Kallweit return NETDEV_TX_OK; 573825e992a4SHeiner Kallweit 573925e992a4SHeiner Kallweit err_dma_1: 574025e992a4SHeiner Kallweit rtl8169_unmap_tx_skb(d, tp->tx_skb + entry, txd); 574125e992a4SHeiner Kallweit err_dma_0: 574225e992a4SHeiner Kallweit dev_kfree_skb_any(skb); 574325e992a4SHeiner Kallweit dev->stats.tx_dropped++; 574425e992a4SHeiner Kallweit return NETDEV_TX_OK; 574525e992a4SHeiner Kallweit 574625e992a4SHeiner Kallweit err_stop_0: 574725e992a4SHeiner Kallweit netif_stop_queue(dev); 574825e992a4SHeiner Kallweit dev->stats.tx_dropped++; 574925e992a4SHeiner Kallweit return NETDEV_TX_BUSY; 575025e992a4SHeiner Kallweit } 575125e992a4SHeiner Kallweit 5752e64e0c89SHeiner Kallweit static netdev_features_t rtl8169_features_check(struct sk_buff *skb, 5753e64e0c89SHeiner Kallweit struct net_device *dev, 5754e64e0c89SHeiner Kallweit netdev_features_t features) 5755e64e0c89SHeiner Kallweit { 5756e64e0c89SHeiner Kallweit int transport_offset = skb_transport_offset(skb); 5757e64e0c89SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 5758e64e0c89SHeiner Kallweit 5759e64e0c89SHeiner Kallweit if (skb_is_gso(skb)) { 5760e64e0c89SHeiner Kallweit if (transport_offset > GTTCPHO_MAX && 5761e64e0c89SHeiner Kallweit rtl_chip_supports_csum_v2(tp)) 5762e64e0c89SHeiner Kallweit features &= ~NETIF_F_ALL_TSO; 5763e64e0c89SHeiner Kallweit } else if (skb->ip_summed == CHECKSUM_PARTIAL) { 5764e64e0c89SHeiner Kallweit if (skb->len < ETH_ZLEN) { 5765e64e0c89SHeiner Kallweit switch (tp->mac_version) { 5766e64e0c89SHeiner Kallweit case RTL_GIGA_MAC_VER_11: 5767e64e0c89SHeiner Kallweit case RTL_GIGA_MAC_VER_12: 5768e64e0c89SHeiner Kallweit case RTL_GIGA_MAC_VER_17: 5769e64e0c89SHeiner Kallweit case RTL_GIGA_MAC_VER_34: 5770e64e0c89SHeiner Kallweit features &= ~NETIF_F_CSUM_MASK; 5771e64e0c89SHeiner Kallweit break; 5772e64e0c89SHeiner Kallweit default: 5773e64e0c89SHeiner Kallweit break; 5774e64e0c89SHeiner Kallweit } 5775e64e0c89SHeiner Kallweit } 5776e64e0c89SHeiner Kallweit 5777e64e0c89SHeiner Kallweit if (transport_offset > TCPHO_MAX && 5778e64e0c89SHeiner Kallweit rtl_chip_supports_csum_v2(tp)) 5779e64e0c89SHeiner Kallweit features &= ~NETIF_F_CSUM_MASK; 5780e64e0c89SHeiner Kallweit } 5781e64e0c89SHeiner Kallweit 5782e64e0c89SHeiner Kallweit return vlan_features_check(skb, features); 5783e64e0c89SHeiner Kallweit } 5784e64e0c89SHeiner Kallweit 578525e992a4SHeiner Kallweit static void rtl8169_pcierr_interrupt(struct net_device *dev) 578625e992a4SHeiner Kallweit { 578725e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 578825e992a4SHeiner Kallweit struct pci_dev *pdev = tp->pci_dev; 578925e992a4SHeiner Kallweit u16 pci_status, pci_cmd; 579025e992a4SHeiner Kallweit 579125e992a4SHeiner Kallweit pci_read_config_word(pdev, PCI_COMMAND, &pci_cmd); 579225e992a4SHeiner Kallweit pci_read_config_word(pdev, PCI_STATUS, &pci_status); 579325e992a4SHeiner Kallweit 579425e992a4SHeiner Kallweit netif_err(tp, intr, dev, "PCI error (cmd = 0x%04x, status = 0x%04x)\n", 579525e992a4SHeiner Kallweit pci_cmd, pci_status); 579625e992a4SHeiner Kallweit 579725e992a4SHeiner Kallweit /* 579825e992a4SHeiner Kallweit * The recovery sequence below admits a very elaborated explanation: 579925e992a4SHeiner Kallweit * - it seems to work; 580025e992a4SHeiner Kallweit * - I did not see what else could be done; 580125e992a4SHeiner Kallweit * - it makes iop3xx happy. 580225e992a4SHeiner Kallweit * 580325e992a4SHeiner Kallweit * Feel free to adjust to your needs. 580425e992a4SHeiner Kallweit */ 580525e992a4SHeiner Kallweit if (pdev->broken_parity_status) 580625e992a4SHeiner Kallweit pci_cmd &= ~PCI_COMMAND_PARITY; 580725e992a4SHeiner Kallweit else 580825e992a4SHeiner Kallweit pci_cmd |= PCI_COMMAND_SERR | PCI_COMMAND_PARITY; 580925e992a4SHeiner Kallweit 581025e992a4SHeiner Kallweit pci_write_config_word(pdev, PCI_COMMAND, pci_cmd); 581125e992a4SHeiner Kallweit 581225e992a4SHeiner Kallweit pci_write_config_word(pdev, PCI_STATUS, 581325e992a4SHeiner Kallweit pci_status & (PCI_STATUS_DETECTED_PARITY | 581425e992a4SHeiner Kallweit PCI_STATUS_SIG_SYSTEM_ERROR | PCI_STATUS_REC_MASTER_ABORT | 581525e992a4SHeiner Kallweit PCI_STATUS_REC_TARGET_ABORT | PCI_STATUS_SIG_TARGET_ABORT)); 581625e992a4SHeiner Kallweit 581725e992a4SHeiner Kallweit rtl_schedule_task(tp, RTL_FLAG_TASK_RESET_PENDING); 581825e992a4SHeiner Kallweit } 581925e992a4SHeiner Kallweit 582025e992a4SHeiner Kallweit static void rtl_tx(struct net_device *dev, struct rtl8169_private *tp, 582125e992a4SHeiner Kallweit int budget) 582225e992a4SHeiner Kallweit { 582325e992a4SHeiner Kallweit unsigned int dirty_tx, tx_left, bytes_compl = 0, pkts_compl = 0; 582425e992a4SHeiner Kallweit 582525e992a4SHeiner Kallweit dirty_tx = tp->dirty_tx; 582625e992a4SHeiner Kallweit smp_rmb(); 582725e992a4SHeiner Kallweit tx_left = tp->cur_tx - dirty_tx; 582825e992a4SHeiner Kallweit 582925e992a4SHeiner Kallweit while (tx_left > 0) { 583025e992a4SHeiner Kallweit unsigned int entry = dirty_tx % NUM_TX_DESC; 583125e992a4SHeiner Kallweit struct ring_info *tx_skb = tp->tx_skb + entry; 583225e992a4SHeiner Kallweit u32 status; 583325e992a4SHeiner Kallweit 583425e992a4SHeiner Kallweit status = le32_to_cpu(tp->TxDescArray[entry].opts1); 583525e992a4SHeiner Kallweit if (status & DescOwn) 583625e992a4SHeiner Kallweit break; 583725e992a4SHeiner Kallweit 583825e992a4SHeiner Kallweit /* This barrier is needed to keep us from reading 583925e992a4SHeiner Kallweit * any other fields out of the Tx descriptor until 584025e992a4SHeiner Kallweit * we know the status of DescOwn 584125e992a4SHeiner Kallweit */ 584225e992a4SHeiner Kallweit dma_rmb(); 584325e992a4SHeiner Kallweit 584425e992a4SHeiner Kallweit rtl8169_unmap_tx_skb(tp_to_dev(tp), tx_skb, 584525e992a4SHeiner Kallweit tp->TxDescArray + entry); 5846ae84bc18SHeiner Kallweit if (tx_skb->skb) { 584725e992a4SHeiner Kallweit pkts_compl++; 584825e992a4SHeiner Kallweit bytes_compl += tx_skb->skb->len; 584925e992a4SHeiner Kallweit napi_consume_skb(tx_skb->skb, budget); 585025e992a4SHeiner Kallweit tx_skb->skb = NULL; 585125e992a4SHeiner Kallweit } 585225e992a4SHeiner Kallweit dirty_tx++; 585325e992a4SHeiner Kallweit tx_left--; 585425e992a4SHeiner Kallweit } 585525e992a4SHeiner Kallweit 585625e992a4SHeiner Kallweit if (tp->dirty_tx != dirty_tx) { 585725e992a4SHeiner Kallweit netdev_completed_queue(dev, pkts_compl, bytes_compl); 585825e992a4SHeiner Kallweit 585925e992a4SHeiner Kallweit u64_stats_update_begin(&tp->tx_stats.syncp); 586025e992a4SHeiner Kallweit tp->tx_stats.packets += pkts_compl; 586125e992a4SHeiner Kallweit tp->tx_stats.bytes += bytes_compl; 586225e992a4SHeiner Kallweit u64_stats_update_end(&tp->tx_stats.syncp); 586325e992a4SHeiner Kallweit 586425e992a4SHeiner Kallweit tp->dirty_tx = dirty_tx; 586525e992a4SHeiner Kallweit /* Sync with rtl8169_start_xmit: 586625e992a4SHeiner Kallweit * - publish dirty_tx ring index (write barrier) 586725e992a4SHeiner Kallweit * - refresh cur_tx ring index and queue status (read barrier) 586825e992a4SHeiner Kallweit * May the current thread miss the stopped queue condition, 586925e992a4SHeiner Kallweit * a racing xmit thread can only have a right view of the 587025e992a4SHeiner Kallweit * ring status. 587125e992a4SHeiner Kallweit */ 587225e992a4SHeiner Kallweit smp_mb(); 587325e992a4SHeiner Kallweit if (netif_queue_stopped(dev) && 587425e992a4SHeiner Kallweit rtl_tx_slots_avail(tp, MAX_SKB_FRAGS)) { 587525e992a4SHeiner Kallweit netif_wake_queue(dev); 587625e992a4SHeiner Kallweit } 587725e992a4SHeiner Kallweit /* 587825e992a4SHeiner Kallweit * 8168 hack: TxPoll requests are lost when the Tx packets are 587925e992a4SHeiner Kallweit * too close. Let's kick an extra TxPoll request when a burst 588025e992a4SHeiner Kallweit * of start_xmit activity is detected (if it is not detected, 588125e992a4SHeiner Kallweit * it is slow enough). -- FR 588225e992a4SHeiner Kallweit */ 588325e992a4SHeiner Kallweit if (tp->cur_tx != dirty_tx) 5884f1bce4adSHeiner Kallweit rtl8169_doorbell(tp); 588525e992a4SHeiner Kallweit } 588625e992a4SHeiner Kallweit } 588725e992a4SHeiner Kallweit 588825e992a4SHeiner Kallweit static inline int rtl8169_fragmented_frame(u32 status) 588925e992a4SHeiner Kallweit { 589025e992a4SHeiner Kallweit return (status & (FirstFrag | LastFrag)) != (FirstFrag | LastFrag); 589125e992a4SHeiner Kallweit } 589225e992a4SHeiner Kallweit 589325e992a4SHeiner Kallweit static inline void rtl8169_rx_csum(struct sk_buff *skb, u32 opts1) 589425e992a4SHeiner Kallweit { 589525e992a4SHeiner Kallweit u32 status = opts1 & RxProtoMask; 589625e992a4SHeiner Kallweit 589725e992a4SHeiner Kallweit if (((status == RxProtoTCP) && !(opts1 & TCPFail)) || 589825e992a4SHeiner Kallweit ((status == RxProtoUDP) && !(opts1 & UDPFail))) 589925e992a4SHeiner Kallweit skb->ip_summed = CHECKSUM_UNNECESSARY; 590025e992a4SHeiner Kallweit else 590125e992a4SHeiner Kallweit skb_checksum_none_assert(skb); 590225e992a4SHeiner Kallweit } 590325e992a4SHeiner Kallweit 590425e992a4SHeiner Kallweit static int rtl_rx(struct net_device *dev, struct rtl8169_private *tp, u32 budget) 590525e992a4SHeiner Kallweit { 590625e992a4SHeiner Kallweit unsigned int cur_rx, rx_left; 590725e992a4SHeiner Kallweit unsigned int count; 590825e992a4SHeiner Kallweit 590925e992a4SHeiner Kallweit cur_rx = tp->cur_rx; 591025e992a4SHeiner Kallweit 591125e992a4SHeiner Kallweit for (rx_left = min(budget, NUM_RX_DESC); rx_left > 0; rx_left--, cur_rx++) { 591225e992a4SHeiner Kallweit unsigned int entry = cur_rx % NUM_RX_DESC; 591332879f00SHeiner Kallweit const void *rx_buf = page_address(tp->Rx_databuff[entry]); 591425e992a4SHeiner Kallweit struct RxDesc *desc = tp->RxDescArray + entry; 591525e992a4SHeiner Kallweit u32 status; 591625e992a4SHeiner Kallweit 591725e992a4SHeiner Kallweit status = le32_to_cpu(desc->opts1); 591825e992a4SHeiner Kallweit if (status & DescOwn) 591925e992a4SHeiner Kallweit break; 592025e992a4SHeiner Kallweit 592125e992a4SHeiner Kallweit /* This barrier is needed to keep us from reading 592225e992a4SHeiner Kallweit * any other fields out of the Rx descriptor until 592325e992a4SHeiner Kallweit * we know the status of DescOwn 592425e992a4SHeiner Kallweit */ 592525e992a4SHeiner Kallweit dma_rmb(); 592625e992a4SHeiner Kallweit 592725e992a4SHeiner Kallweit if (unlikely(status & RxRES)) { 592825e992a4SHeiner Kallweit netif_info(tp, rx_err, dev, "Rx ERROR. status = %08x\n", 592925e992a4SHeiner Kallweit status); 593025e992a4SHeiner Kallweit dev->stats.rx_errors++; 593125e992a4SHeiner Kallweit if (status & (RxRWT | RxRUNT)) 593225e992a4SHeiner Kallweit dev->stats.rx_length_errors++; 593325e992a4SHeiner Kallweit if (status & RxCRC) 593425e992a4SHeiner Kallweit dev->stats.rx_crc_errors++; 593525e992a4SHeiner Kallweit if (status & (RxRUNT | RxCRC) && !(status & RxRWT) && 593625e992a4SHeiner Kallweit dev->features & NETIF_F_RXALL) { 593725e992a4SHeiner Kallweit goto process_pkt; 593825e992a4SHeiner Kallweit } 593925e992a4SHeiner Kallweit } else { 5940fcd4e608SHeiner Kallweit unsigned int pkt_size; 594125e992a4SHeiner Kallweit struct sk_buff *skb; 594225e992a4SHeiner Kallweit 594325e992a4SHeiner Kallweit process_pkt: 5944fcd4e608SHeiner Kallweit pkt_size = status & GENMASK(13, 0); 594525e992a4SHeiner Kallweit if (likely(!(dev->features & NETIF_F_RXFCS))) 5946fcd4e608SHeiner Kallweit pkt_size -= ETH_FCS_LEN; 594725e992a4SHeiner Kallweit /* 594825e992a4SHeiner Kallweit * The driver does not support incoming fragmented 594925e992a4SHeiner Kallweit * frames. They are seen as a symptom of over-mtu 595025e992a4SHeiner Kallweit * sized frames. 595125e992a4SHeiner Kallweit */ 595225e992a4SHeiner Kallweit if (unlikely(rtl8169_fragmented_frame(status))) { 595325e992a4SHeiner Kallweit dev->stats.rx_dropped++; 595425e992a4SHeiner Kallweit dev->stats.rx_length_errors++; 595525e992a4SHeiner Kallweit goto release_descriptor; 595625e992a4SHeiner Kallweit } 595725e992a4SHeiner Kallweit 5958fcd4e608SHeiner Kallweit skb = napi_alloc_skb(&tp->napi, pkt_size); 5959fcd4e608SHeiner Kallweit if (unlikely(!skb)) { 596025e992a4SHeiner Kallweit dev->stats.rx_dropped++; 596125e992a4SHeiner Kallweit goto release_descriptor; 596225e992a4SHeiner Kallweit } 596325e992a4SHeiner Kallweit 59643c95e501SHeiner Kallweit dma_sync_single_for_cpu(tp_to_dev(tp), 59653c95e501SHeiner Kallweit le64_to_cpu(desc->addr), 59663c95e501SHeiner Kallweit pkt_size, DMA_FROM_DEVICE); 596732879f00SHeiner Kallweit prefetch(rx_buf); 596832879f00SHeiner Kallweit skb_copy_to_linear_data(skb, rx_buf, pkt_size); 5969fcd4e608SHeiner Kallweit skb->tail += pkt_size; 5970fcd4e608SHeiner Kallweit skb->len = pkt_size; 5971fcd4e608SHeiner Kallweit 5972d4ed7463SHeiner Kallweit dma_sync_single_for_device(tp_to_dev(tp), 5973d4ed7463SHeiner Kallweit le64_to_cpu(desc->addr), 5974d4ed7463SHeiner Kallweit pkt_size, DMA_FROM_DEVICE); 5975d4ed7463SHeiner Kallweit 597625e992a4SHeiner Kallweit rtl8169_rx_csum(skb, status); 597725e992a4SHeiner Kallweit skb->protocol = eth_type_trans(skb, dev); 597825e992a4SHeiner Kallweit 597925e992a4SHeiner Kallweit rtl8169_rx_vlan_tag(desc, skb); 598025e992a4SHeiner Kallweit 598125e992a4SHeiner Kallweit if (skb->pkt_type == PACKET_MULTICAST) 598225e992a4SHeiner Kallweit dev->stats.multicast++; 598325e992a4SHeiner Kallweit 598425e992a4SHeiner Kallweit napi_gro_receive(&tp->napi, skb); 598525e992a4SHeiner Kallweit 598625e992a4SHeiner Kallweit u64_stats_update_begin(&tp->rx_stats.syncp); 598725e992a4SHeiner Kallweit tp->rx_stats.packets++; 598825e992a4SHeiner Kallweit tp->rx_stats.bytes += pkt_size; 598925e992a4SHeiner Kallweit u64_stats_update_end(&tp->rx_stats.syncp); 599025e992a4SHeiner Kallweit } 599125e992a4SHeiner Kallweit release_descriptor: 599225e992a4SHeiner Kallweit desc->opts2 = 0; 599325e992a4SHeiner Kallweit rtl8169_mark_to_asic(desc); 599425e992a4SHeiner Kallweit } 599525e992a4SHeiner Kallweit 599625e992a4SHeiner Kallweit count = cur_rx - tp->cur_rx; 599725e992a4SHeiner Kallweit tp->cur_rx = cur_rx; 599825e992a4SHeiner Kallweit 599925e992a4SHeiner Kallweit return count; 600025e992a4SHeiner Kallweit } 600125e992a4SHeiner Kallweit 600225e992a4SHeiner Kallweit static irqreturn_t rtl8169_interrupt(int irq, void *dev_instance) 600325e992a4SHeiner Kallweit { 600425e992a4SHeiner Kallweit struct rtl8169_private *tp = dev_instance; 6005c1d532d2SHeiner Kallweit u32 status = rtl_get_events(tp); 600625e992a4SHeiner Kallweit 6007c1d532d2SHeiner Kallweit if (!tp->irq_enabled || (status & 0xffff) == 0xffff || 6008c1d532d2SHeiner Kallweit !(status & tp->irq_mask)) 600925e992a4SHeiner Kallweit return IRQ_NONE; 601025e992a4SHeiner Kallweit 601125e992a4SHeiner Kallweit if (unlikely(status & SYSErr)) { 601225e992a4SHeiner Kallweit rtl8169_pcierr_interrupt(tp->dev); 601325e992a4SHeiner Kallweit goto out; 601425e992a4SHeiner Kallweit } 601525e992a4SHeiner Kallweit 601625e992a4SHeiner Kallweit if (status & LinkChg) 601725e992a4SHeiner Kallweit phy_mac_interrupt(tp->phydev); 601825e992a4SHeiner Kallweit 601925e992a4SHeiner Kallweit if (unlikely(status & RxFIFOOver && 602025e992a4SHeiner Kallweit tp->mac_version == RTL_GIGA_MAC_VER_11)) { 602125e992a4SHeiner Kallweit netif_stop_queue(tp->dev); 602225e992a4SHeiner Kallweit /* XXX - Hack alert. See rtl_task(). */ 602325e992a4SHeiner Kallweit set_bit(RTL_FLAG_TASK_RESET_PENDING, tp->wk.flags); 602425e992a4SHeiner Kallweit } 602525e992a4SHeiner Kallweit 602625e992a4SHeiner Kallweit rtl_irq_disable(tp); 602725e992a4SHeiner Kallweit napi_schedule_irqoff(&tp->napi); 602825e992a4SHeiner Kallweit out: 602925e992a4SHeiner Kallweit rtl_ack_events(tp, status); 603025e992a4SHeiner Kallweit 603125e992a4SHeiner Kallweit return IRQ_HANDLED; 603225e992a4SHeiner Kallweit } 603325e992a4SHeiner Kallweit 603425e992a4SHeiner Kallweit static void rtl_task(struct work_struct *work) 603525e992a4SHeiner Kallweit { 603625e992a4SHeiner Kallweit static const struct { 603725e992a4SHeiner Kallweit int bitnr; 603825e992a4SHeiner Kallweit void (*action)(struct rtl8169_private *); 603925e992a4SHeiner Kallweit } rtl_work[] = { 604025e992a4SHeiner Kallweit { RTL_FLAG_TASK_RESET_PENDING, rtl_reset_work }, 604125e992a4SHeiner Kallweit }; 604225e992a4SHeiner Kallweit struct rtl8169_private *tp = 604325e992a4SHeiner Kallweit container_of(work, struct rtl8169_private, wk.work); 604425e992a4SHeiner Kallweit struct net_device *dev = tp->dev; 604525e992a4SHeiner Kallweit int i; 604625e992a4SHeiner Kallweit 604725e992a4SHeiner Kallweit rtl_lock_work(tp); 604825e992a4SHeiner Kallweit 604925e992a4SHeiner Kallweit if (!netif_running(dev) || 605025e992a4SHeiner Kallweit !test_bit(RTL_FLAG_TASK_ENABLED, tp->wk.flags)) 605125e992a4SHeiner Kallweit goto out_unlock; 605225e992a4SHeiner Kallweit 605325e992a4SHeiner Kallweit for (i = 0; i < ARRAY_SIZE(rtl_work); i++) { 605425e992a4SHeiner Kallweit bool pending; 605525e992a4SHeiner Kallweit 605625e992a4SHeiner Kallweit pending = test_and_clear_bit(rtl_work[i].bitnr, tp->wk.flags); 605725e992a4SHeiner Kallweit if (pending) 605825e992a4SHeiner Kallweit rtl_work[i].action(tp); 605925e992a4SHeiner Kallweit } 606025e992a4SHeiner Kallweit 606125e992a4SHeiner Kallweit out_unlock: 606225e992a4SHeiner Kallweit rtl_unlock_work(tp); 606325e992a4SHeiner Kallweit } 606425e992a4SHeiner Kallweit 606525e992a4SHeiner Kallweit static int rtl8169_poll(struct napi_struct *napi, int budget) 606625e992a4SHeiner Kallweit { 606725e992a4SHeiner Kallweit struct rtl8169_private *tp = container_of(napi, struct rtl8169_private, napi); 606825e992a4SHeiner Kallweit struct net_device *dev = tp->dev; 606925e992a4SHeiner Kallweit int work_done; 607025e992a4SHeiner Kallweit 607125e992a4SHeiner Kallweit work_done = rtl_rx(dev, tp, (u32) budget); 607225e992a4SHeiner Kallweit 607325e992a4SHeiner Kallweit rtl_tx(dev, tp, budget); 607425e992a4SHeiner Kallweit 607525e992a4SHeiner Kallweit if (work_done < budget) { 607625e992a4SHeiner Kallweit napi_complete_done(napi, work_done); 607725e992a4SHeiner Kallweit rtl_irq_enable(tp); 607825e992a4SHeiner Kallweit } 607925e992a4SHeiner Kallweit 608025e992a4SHeiner Kallweit return work_done; 608125e992a4SHeiner Kallweit } 608225e992a4SHeiner Kallweit 608325e992a4SHeiner Kallweit static void rtl8169_rx_missed(struct net_device *dev) 608425e992a4SHeiner Kallweit { 608525e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 608625e992a4SHeiner Kallweit 608725e992a4SHeiner Kallweit if (tp->mac_version > RTL_GIGA_MAC_VER_06) 608825e992a4SHeiner Kallweit return; 608925e992a4SHeiner Kallweit 609025e992a4SHeiner Kallweit dev->stats.rx_missed_errors += RTL_R32(tp, RxMissed) & 0xffffff; 609125e992a4SHeiner Kallweit RTL_W32(tp, RxMissed, 0); 609225e992a4SHeiner Kallweit } 609325e992a4SHeiner Kallweit 609425e992a4SHeiner Kallweit static void r8169_phylink_handler(struct net_device *ndev) 609525e992a4SHeiner Kallweit { 609625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(ndev); 609725e992a4SHeiner Kallweit 609825e992a4SHeiner Kallweit if (netif_carrier_ok(ndev)) { 609925e992a4SHeiner Kallweit rtl_link_chg_patch(tp); 610025e992a4SHeiner Kallweit pm_request_resume(&tp->pci_dev->dev); 610125e992a4SHeiner Kallweit } else { 610225e992a4SHeiner Kallweit pm_runtime_idle(&tp->pci_dev->dev); 610325e992a4SHeiner Kallweit } 610425e992a4SHeiner Kallweit 610525e992a4SHeiner Kallweit if (net_ratelimit()) 610625e992a4SHeiner Kallweit phy_print_status(tp->phydev); 610725e992a4SHeiner Kallweit } 610825e992a4SHeiner Kallweit 610925e992a4SHeiner Kallweit static int r8169_phy_connect(struct rtl8169_private *tp) 611025e992a4SHeiner Kallweit { 611125e992a4SHeiner Kallweit struct phy_device *phydev = tp->phydev; 611225e992a4SHeiner Kallweit phy_interface_t phy_mode; 611325e992a4SHeiner Kallweit int ret; 611425e992a4SHeiner Kallweit 611525e992a4SHeiner Kallweit phy_mode = tp->supports_gmii ? PHY_INTERFACE_MODE_GMII : 611625e992a4SHeiner Kallweit PHY_INTERFACE_MODE_MII; 611725e992a4SHeiner Kallweit 611825e992a4SHeiner Kallweit ret = phy_connect_direct(tp->dev, phydev, r8169_phylink_handler, 611925e992a4SHeiner Kallweit phy_mode); 612025e992a4SHeiner Kallweit if (ret) 612125e992a4SHeiner Kallweit return ret; 612225e992a4SHeiner Kallweit 612366058b1cSHeiner Kallweit if (!tp->supports_gmii) 612425e992a4SHeiner Kallweit phy_set_max_speed(phydev, SPEED_100); 612525e992a4SHeiner Kallweit 612625e992a4SHeiner Kallweit phy_support_asym_pause(phydev); 612725e992a4SHeiner Kallweit 612825e992a4SHeiner Kallweit phy_attached_info(phydev); 612925e992a4SHeiner Kallweit 613025e992a4SHeiner Kallweit return 0; 613125e992a4SHeiner Kallweit } 613225e992a4SHeiner Kallweit 613325e992a4SHeiner Kallweit static void rtl8169_down(struct net_device *dev) 613425e992a4SHeiner Kallweit { 613525e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 613625e992a4SHeiner Kallweit 613725e992a4SHeiner Kallweit phy_stop(tp->phydev); 613825e992a4SHeiner Kallweit 613925e992a4SHeiner Kallweit napi_disable(&tp->napi); 614025e992a4SHeiner Kallweit netif_stop_queue(dev); 614125e992a4SHeiner Kallweit 614225e992a4SHeiner Kallweit rtl8169_hw_reset(tp); 614325e992a4SHeiner Kallweit /* 614425e992a4SHeiner Kallweit * At this point device interrupts can not be enabled in any function, 614525e992a4SHeiner Kallweit * as netif_running is not true (rtl8169_interrupt, rtl8169_reset_task) 614625e992a4SHeiner Kallweit * and napi is disabled (rtl8169_poll). 614725e992a4SHeiner Kallweit */ 614825e992a4SHeiner Kallweit rtl8169_rx_missed(dev); 614925e992a4SHeiner Kallweit 615025e992a4SHeiner Kallweit /* Give a racing hard_start_xmit a few cycles to complete. */ 615125e992a4SHeiner Kallweit synchronize_rcu(); 615225e992a4SHeiner Kallweit 615325e992a4SHeiner Kallweit rtl8169_tx_clear(tp); 615425e992a4SHeiner Kallweit 615525e992a4SHeiner Kallweit rtl8169_rx_clear(tp); 615625e992a4SHeiner Kallweit 615725e992a4SHeiner Kallweit rtl_pll_power_down(tp); 615825e992a4SHeiner Kallweit } 615925e992a4SHeiner Kallweit 616025e992a4SHeiner Kallweit static int rtl8169_close(struct net_device *dev) 616125e992a4SHeiner Kallweit { 616225e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 616325e992a4SHeiner Kallweit struct pci_dev *pdev = tp->pci_dev; 616425e992a4SHeiner Kallweit 616525e992a4SHeiner Kallweit pm_runtime_get_sync(&pdev->dev); 616625e992a4SHeiner Kallweit 616725e992a4SHeiner Kallweit /* Update counters before going down */ 616825e992a4SHeiner Kallweit rtl8169_update_counters(tp); 616925e992a4SHeiner Kallweit 617025e992a4SHeiner Kallweit rtl_lock_work(tp); 617125e992a4SHeiner Kallweit /* Clear all task flags */ 617225e992a4SHeiner Kallweit bitmap_zero(tp->wk.flags, RTL_FLAG_MAX); 617325e992a4SHeiner Kallweit 617425e992a4SHeiner Kallweit rtl8169_down(dev); 617525e992a4SHeiner Kallweit rtl_unlock_work(tp); 617625e992a4SHeiner Kallweit 617725e992a4SHeiner Kallweit cancel_work_sync(&tp->wk.work); 617825e992a4SHeiner Kallweit 617925e992a4SHeiner Kallweit phy_disconnect(tp->phydev); 618025e992a4SHeiner Kallweit 618125e992a4SHeiner Kallweit pci_free_irq(pdev, 0, tp); 618225e992a4SHeiner Kallweit 618325e992a4SHeiner Kallweit dma_free_coherent(&pdev->dev, R8169_RX_RING_BYTES, tp->RxDescArray, 618425e992a4SHeiner Kallweit tp->RxPhyAddr); 618525e992a4SHeiner Kallweit dma_free_coherent(&pdev->dev, R8169_TX_RING_BYTES, tp->TxDescArray, 618625e992a4SHeiner Kallweit tp->TxPhyAddr); 618725e992a4SHeiner Kallweit tp->TxDescArray = NULL; 618825e992a4SHeiner Kallweit tp->RxDescArray = NULL; 618925e992a4SHeiner Kallweit 619025e992a4SHeiner Kallweit pm_runtime_put_sync(&pdev->dev); 619125e992a4SHeiner Kallweit 619225e992a4SHeiner Kallweit return 0; 619325e992a4SHeiner Kallweit } 619425e992a4SHeiner Kallweit 619525e992a4SHeiner Kallweit #ifdef CONFIG_NET_POLL_CONTROLLER 619625e992a4SHeiner Kallweit static void rtl8169_netpoll(struct net_device *dev) 619725e992a4SHeiner Kallweit { 619825e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 619925e992a4SHeiner Kallweit 620025e992a4SHeiner Kallweit rtl8169_interrupt(pci_irq_vector(tp->pci_dev, 0), tp); 620125e992a4SHeiner Kallweit } 620225e992a4SHeiner Kallweit #endif 620325e992a4SHeiner Kallweit 620425e992a4SHeiner Kallweit static int rtl_open(struct net_device *dev) 620525e992a4SHeiner Kallweit { 620625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 620725e992a4SHeiner Kallweit struct pci_dev *pdev = tp->pci_dev; 620825e992a4SHeiner Kallweit int retval = -ENOMEM; 620925e992a4SHeiner Kallweit 621025e992a4SHeiner Kallweit pm_runtime_get_sync(&pdev->dev); 621125e992a4SHeiner Kallweit 621225e992a4SHeiner Kallweit /* 621325e992a4SHeiner Kallweit * Rx and Tx descriptors needs 256 bytes alignment. 621425e992a4SHeiner Kallweit * dma_alloc_coherent provides more. 621525e992a4SHeiner Kallweit */ 621625e992a4SHeiner Kallweit tp->TxDescArray = dma_alloc_coherent(&pdev->dev, R8169_TX_RING_BYTES, 621725e992a4SHeiner Kallweit &tp->TxPhyAddr, GFP_KERNEL); 621825e992a4SHeiner Kallweit if (!tp->TxDescArray) 621925e992a4SHeiner Kallweit goto err_pm_runtime_put; 622025e992a4SHeiner Kallweit 622125e992a4SHeiner Kallweit tp->RxDescArray = dma_alloc_coherent(&pdev->dev, R8169_RX_RING_BYTES, 622225e992a4SHeiner Kallweit &tp->RxPhyAddr, GFP_KERNEL); 622325e992a4SHeiner Kallweit if (!tp->RxDescArray) 622425e992a4SHeiner Kallweit goto err_free_tx_0; 622525e992a4SHeiner Kallweit 622625e992a4SHeiner Kallweit retval = rtl8169_init_ring(tp); 622725e992a4SHeiner Kallweit if (retval < 0) 622825e992a4SHeiner Kallweit goto err_free_rx_1; 622925e992a4SHeiner Kallweit 623025e992a4SHeiner Kallweit rtl_request_firmware(tp); 623125e992a4SHeiner Kallweit 623225e992a4SHeiner Kallweit retval = pci_request_irq(pdev, 0, rtl8169_interrupt, NULL, tp, 623325e992a4SHeiner Kallweit dev->name); 623425e992a4SHeiner Kallweit if (retval < 0) 623525e992a4SHeiner Kallweit goto err_release_fw_2; 623625e992a4SHeiner Kallweit 623725e992a4SHeiner Kallweit retval = r8169_phy_connect(tp); 623825e992a4SHeiner Kallweit if (retval) 623925e992a4SHeiner Kallweit goto err_free_irq; 624025e992a4SHeiner Kallweit 624125e992a4SHeiner Kallweit rtl_lock_work(tp); 624225e992a4SHeiner Kallweit 624325e992a4SHeiner Kallweit set_bit(RTL_FLAG_TASK_ENABLED, tp->wk.flags); 624425e992a4SHeiner Kallweit 624525e992a4SHeiner Kallweit napi_enable(&tp->napi); 624625e992a4SHeiner Kallweit 6247b5aed0b3SHeiner Kallweit rtl8169_init_phy(tp); 624825e992a4SHeiner Kallweit 624925e992a4SHeiner Kallweit rtl_pll_power_up(tp); 625025e992a4SHeiner Kallweit 625125e992a4SHeiner Kallweit rtl_hw_start(tp); 625225e992a4SHeiner Kallweit 625325e992a4SHeiner Kallweit if (!rtl8169_init_counter_offsets(tp)) 625425e992a4SHeiner Kallweit netif_warn(tp, hw, dev, "counter reset/update failed\n"); 625525e992a4SHeiner Kallweit 625625e992a4SHeiner Kallweit phy_start(tp->phydev); 625725e992a4SHeiner Kallweit netif_start_queue(dev); 625825e992a4SHeiner Kallweit 625925e992a4SHeiner Kallweit rtl_unlock_work(tp); 626025e992a4SHeiner Kallweit 626125e992a4SHeiner Kallweit pm_runtime_put_sync(&pdev->dev); 626225e992a4SHeiner Kallweit out: 626325e992a4SHeiner Kallweit return retval; 626425e992a4SHeiner Kallweit 626525e992a4SHeiner Kallweit err_free_irq: 626625e992a4SHeiner Kallweit pci_free_irq(pdev, 0, tp); 626725e992a4SHeiner Kallweit err_release_fw_2: 626825e992a4SHeiner Kallweit rtl_release_firmware(tp); 626925e992a4SHeiner Kallweit rtl8169_rx_clear(tp); 627025e992a4SHeiner Kallweit err_free_rx_1: 627125e992a4SHeiner Kallweit dma_free_coherent(&pdev->dev, R8169_RX_RING_BYTES, tp->RxDescArray, 627225e992a4SHeiner Kallweit tp->RxPhyAddr); 627325e992a4SHeiner Kallweit tp->RxDescArray = NULL; 627425e992a4SHeiner Kallweit err_free_tx_0: 627525e992a4SHeiner Kallweit dma_free_coherent(&pdev->dev, R8169_TX_RING_BYTES, tp->TxDescArray, 627625e992a4SHeiner Kallweit tp->TxPhyAddr); 627725e992a4SHeiner Kallweit tp->TxDescArray = NULL; 627825e992a4SHeiner Kallweit err_pm_runtime_put: 627925e992a4SHeiner Kallweit pm_runtime_put_noidle(&pdev->dev); 628025e992a4SHeiner Kallweit goto out; 628125e992a4SHeiner Kallweit } 628225e992a4SHeiner Kallweit 628325e992a4SHeiner Kallweit static void 628425e992a4SHeiner Kallweit rtl8169_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats) 628525e992a4SHeiner Kallweit { 628625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 628725e992a4SHeiner Kallweit struct pci_dev *pdev = tp->pci_dev; 628825e992a4SHeiner Kallweit struct rtl8169_counters *counters = tp->counters; 628925e992a4SHeiner Kallweit unsigned int start; 629025e992a4SHeiner Kallweit 629125e992a4SHeiner Kallweit pm_runtime_get_noresume(&pdev->dev); 629225e992a4SHeiner Kallweit 629325e992a4SHeiner Kallweit if (netif_running(dev) && pm_runtime_active(&pdev->dev)) 629425e992a4SHeiner Kallweit rtl8169_rx_missed(dev); 629525e992a4SHeiner Kallweit 629625e992a4SHeiner Kallweit do { 629725e992a4SHeiner Kallweit start = u64_stats_fetch_begin_irq(&tp->rx_stats.syncp); 629825e992a4SHeiner Kallweit stats->rx_packets = tp->rx_stats.packets; 629925e992a4SHeiner Kallweit stats->rx_bytes = tp->rx_stats.bytes; 630025e992a4SHeiner Kallweit } while (u64_stats_fetch_retry_irq(&tp->rx_stats.syncp, start)); 630125e992a4SHeiner Kallweit 630225e992a4SHeiner Kallweit do { 630325e992a4SHeiner Kallweit start = u64_stats_fetch_begin_irq(&tp->tx_stats.syncp); 630425e992a4SHeiner Kallweit stats->tx_packets = tp->tx_stats.packets; 630525e992a4SHeiner Kallweit stats->tx_bytes = tp->tx_stats.bytes; 630625e992a4SHeiner Kallweit } while (u64_stats_fetch_retry_irq(&tp->tx_stats.syncp, start)); 630725e992a4SHeiner Kallweit 630825e992a4SHeiner Kallweit stats->rx_dropped = dev->stats.rx_dropped; 630925e992a4SHeiner Kallweit stats->tx_dropped = dev->stats.tx_dropped; 631025e992a4SHeiner Kallweit stats->rx_length_errors = dev->stats.rx_length_errors; 631125e992a4SHeiner Kallweit stats->rx_errors = dev->stats.rx_errors; 631225e992a4SHeiner Kallweit stats->rx_crc_errors = dev->stats.rx_crc_errors; 631325e992a4SHeiner Kallweit stats->rx_fifo_errors = dev->stats.rx_fifo_errors; 631425e992a4SHeiner Kallweit stats->rx_missed_errors = dev->stats.rx_missed_errors; 631525e992a4SHeiner Kallweit stats->multicast = dev->stats.multicast; 631625e992a4SHeiner Kallweit 631725e992a4SHeiner Kallweit /* 6318ed72a9bbSCorentin Musard * Fetch additional counter values missing in stats collected by driver 631925e992a4SHeiner Kallweit * from tally counters. 632025e992a4SHeiner Kallweit */ 632125e992a4SHeiner Kallweit if (pm_runtime_active(&pdev->dev)) 632225e992a4SHeiner Kallweit rtl8169_update_counters(tp); 632325e992a4SHeiner Kallweit 632425e992a4SHeiner Kallweit /* 632525e992a4SHeiner Kallweit * Subtract values fetched during initalization. 632625e992a4SHeiner Kallweit * See rtl8169_init_counter_offsets for a description why we do that. 632725e992a4SHeiner Kallweit */ 632825e992a4SHeiner Kallweit stats->tx_errors = le64_to_cpu(counters->tx_errors) - 632925e992a4SHeiner Kallweit le64_to_cpu(tp->tc_offset.tx_errors); 633025e992a4SHeiner Kallweit stats->collisions = le32_to_cpu(counters->tx_multi_collision) - 633125e992a4SHeiner Kallweit le32_to_cpu(tp->tc_offset.tx_multi_collision); 633225e992a4SHeiner Kallweit stats->tx_aborted_errors = le16_to_cpu(counters->tx_aborted) - 633325e992a4SHeiner Kallweit le16_to_cpu(tp->tc_offset.tx_aborted); 633425e992a4SHeiner Kallweit 633525e992a4SHeiner Kallweit pm_runtime_put_noidle(&pdev->dev); 633625e992a4SHeiner Kallweit } 633725e992a4SHeiner Kallweit 633825e992a4SHeiner Kallweit static void rtl8169_net_suspend(struct net_device *dev) 633925e992a4SHeiner Kallweit { 634025e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 634125e992a4SHeiner Kallweit 634225e992a4SHeiner Kallweit if (!netif_running(dev)) 634325e992a4SHeiner Kallweit return; 634425e992a4SHeiner Kallweit 634525e992a4SHeiner Kallweit phy_stop(tp->phydev); 634625e992a4SHeiner Kallweit netif_device_detach(dev); 634725e992a4SHeiner Kallweit 634825e992a4SHeiner Kallweit rtl_lock_work(tp); 634925e992a4SHeiner Kallweit napi_disable(&tp->napi); 635025e992a4SHeiner Kallweit /* Clear all task flags */ 635125e992a4SHeiner Kallweit bitmap_zero(tp->wk.flags, RTL_FLAG_MAX); 635225e992a4SHeiner Kallweit 635325e992a4SHeiner Kallweit rtl_unlock_work(tp); 635425e992a4SHeiner Kallweit 635525e992a4SHeiner Kallweit rtl_pll_power_down(tp); 635625e992a4SHeiner Kallweit } 635725e992a4SHeiner Kallweit 635825e992a4SHeiner Kallweit #ifdef CONFIG_PM 635925e992a4SHeiner Kallweit 636025e992a4SHeiner Kallweit static int rtl8169_suspend(struct device *device) 636125e992a4SHeiner Kallweit { 636225e992a4SHeiner Kallweit struct net_device *dev = dev_get_drvdata(device); 636325e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 636425e992a4SHeiner Kallweit 636525e992a4SHeiner Kallweit rtl8169_net_suspend(dev); 636625e992a4SHeiner Kallweit clk_disable_unprepare(tp->clk); 636725e992a4SHeiner Kallweit 636825e992a4SHeiner Kallweit return 0; 636925e992a4SHeiner Kallweit } 637025e992a4SHeiner Kallweit 637125e992a4SHeiner Kallweit static void __rtl8169_resume(struct net_device *dev) 637225e992a4SHeiner Kallweit { 637325e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 637425e992a4SHeiner Kallweit 637525e992a4SHeiner Kallweit netif_device_attach(dev); 637625e992a4SHeiner Kallweit 637725e992a4SHeiner Kallweit rtl_pll_power_up(tp); 6378b5aed0b3SHeiner Kallweit rtl8169_init_phy(tp); 637925e992a4SHeiner Kallweit 638025e992a4SHeiner Kallweit phy_start(tp->phydev); 638125e992a4SHeiner Kallweit 638225e992a4SHeiner Kallweit rtl_lock_work(tp); 638325e992a4SHeiner Kallweit napi_enable(&tp->napi); 638425e992a4SHeiner Kallweit set_bit(RTL_FLAG_TASK_ENABLED, tp->wk.flags); 638525e992a4SHeiner Kallweit rtl_reset_work(tp); 638625e992a4SHeiner Kallweit rtl_unlock_work(tp); 638725e992a4SHeiner Kallweit } 638825e992a4SHeiner Kallweit 638925e992a4SHeiner Kallweit static int rtl8169_resume(struct device *device) 639025e992a4SHeiner Kallweit { 639125e992a4SHeiner Kallweit struct net_device *dev = dev_get_drvdata(device); 639225e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 639325e992a4SHeiner Kallweit 639425e992a4SHeiner Kallweit rtl_rar_set(tp, dev->dev_addr); 639525e992a4SHeiner Kallweit 639625e992a4SHeiner Kallweit clk_prepare_enable(tp->clk); 639725e992a4SHeiner Kallweit 639825e992a4SHeiner Kallweit if (netif_running(dev)) 639925e992a4SHeiner Kallweit __rtl8169_resume(dev); 640025e992a4SHeiner Kallweit 640125e992a4SHeiner Kallweit return 0; 640225e992a4SHeiner Kallweit } 640325e992a4SHeiner Kallweit 640425e992a4SHeiner Kallweit static int rtl8169_runtime_suspend(struct device *device) 640525e992a4SHeiner Kallweit { 640625e992a4SHeiner Kallweit struct net_device *dev = dev_get_drvdata(device); 640725e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 640825e992a4SHeiner Kallweit 640925e992a4SHeiner Kallweit if (!tp->TxDescArray) 641025e992a4SHeiner Kallweit return 0; 641125e992a4SHeiner Kallweit 641225e992a4SHeiner Kallweit rtl_lock_work(tp); 641325e992a4SHeiner Kallweit __rtl8169_set_wol(tp, WAKE_ANY); 641425e992a4SHeiner Kallweit rtl_unlock_work(tp); 641525e992a4SHeiner Kallweit 641625e992a4SHeiner Kallweit rtl8169_net_suspend(dev); 641725e992a4SHeiner Kallweit 641825e992a4SHeiner Kallweit /* Update counters before going runtime suspend */ 641925e992a4SHeiner Kallweit rtl8169_rx_missed(dev); 642025e992a4SHeiner Kallweit rtl8169_update_counters(tp); 642125e992a4SHeiner Kallweit 642225e992a4SHeiner Kallweit return 0; 642325e992a4SHeiner Kallweit } 642425e992a4SHeiner Kallweit 642525e992a4SHeiner Kallweit static int rtl8169_runtime_resume(struct device *device) 642625e992a4SHeiner Kallweit { 642725e992a4SHeiner Kallweit struct net_device *dev = dev_get_drvdata(device); 642825e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 642925e992a4SHeiner Kallweit 643025e992a4SHeiner Kallweit rtl_rar_set(tp, dev->dev_addr); 643125e992a4SHeiner Kallweit 643225e992a4SHeiner Kallweit if (!tp->TxDescArray) 643325e992a4SHeiner Kallweit return 0; 643425e992a4SHeiner Kallweit 643525e992a4SHeiner Kallweit rtl_lock_work(tp); 643625e992a4SHeiner Kallweit __rtl8169_set_wol(tp, tp->saved_wolopts); 643725e992a4SHeiner Kallweit rtl_unlock_work(tp); 643825e992a4SHeiner Kallweit 643925e992a4SHeiner Kallweit __rtl8169_resume(dev); 644025e992a4SHeiner Kallweit 644125e992a4SHeiner Kallweit return 0; 644225e992a4SHeiner Kallweit } 644325e992a4SHeiner Kallweit 644425e992a4SHeiner Kallweit static int rtl8169_runtime_idle(struct device *device) 644525e992a4SHeiner Kallweit { 644625e992a4SHeiner Kallweit struct net_device *dev = dev_get_drvdata(device); 644725e992a4SHeiner Kallweit 644825e992a4SHeiner Kallweit if (!netif_running(dev) || !netif_carrier_ok(dev)) 644925e992a4SHeiner Kallweit pm_schedule_suspend(device, 10000); 645025e992a4SHeiner Kallweit 645125e992a4SHeiner Kallweit return -EBUSY; 645225e992a4SHeiner Kallweit } 645325e992a4SHeiner Kallweit 645425e992a4SHeiner Kallweit static const struct dev_pm_ops rtl8169_pm_ops = { 645525e992a4SHeiner Kallweit .suspend = rtl8169_suspend, 645625e992a4SHeiner Kallweit .resume = rtl8169_resume, 645725e992a4SHeiner Kallweit .freeze = rtl8169_suspend, 645825e992a4SHeiner Kallweit .thaw = rtl8169_resume, 645925e992a4SHeiner Kallweit .poweroff = rtl8169_suspend, 646025e992a4SHeiner Kallweit .restore = rtl8169_resume, 646125e992a4SHeiner Kallweit .runtime_suspend = rtl8169_runtime_suspend, 646225e992a4SHeiner Kallweit .runtime_resume = rtl8169_runtime_resume, 646325e992a4SHeiner Kallweit .runtime_idle = rtl8169_runtime_idle, 646425e992a4SHeiner Kallweit }; 646525e992a4SHeiner Kallweit 646625e992a4SHeiner Kallweit #define RTL8169_PM_OPS (&rtl8169_pm_ops) 646725e992a4SHeiner Kallweit 646825e992a4SHeiner Kallweit #else /* !CONFIG_PM */ 646925e992a4SHeiner Kallweit 647025e992a4SHeiner Kallweit #define RTL8169_PM_OPS NULL 647125e992a4SHeiner Kallweit 647225e992a4SHeiner Kallweit #endif /* !CONFIG_PM */ 647325e992a4SHeiner Kallweit 647425e992a4SHeiner Kallweit static void rtl_wol_shutdown_quirk(struct rtl8169_private *tp) 647525e992a4SHeiner Kallweit { 647625e992a4SHeiner Kallweit /* WoL fails with 8168b when the receiver is disabled. */ 647725e992a4SHeiner Kallweit switch (tp->mac_version) { 647825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_11: 647925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_12: 648025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_17: 648125e992a4SHeiner Kallweit pci_clear_master(tp->pci_dev); 648225e992a4SHeiner Kallweit 648325e992a4SHeiner Kallweit RTL_W8(tp, ChipCmd, CmdRxEnb); 648425e992a4SHeiner Kallweit /* PCI commit */ 648525e992a4SHeiner Kallweit RTL_R8(tp, ChipCmd); 648625e992a4SHeiner Kallweit break; 648725e992a4SHeiner Kallweit default: 648825e992a4SHeiner Kallweit break; 648925e992a4SHeiner Kallweit } 649025e992a4SHeiner Kallweit } 649125e992a4SHeiner Kallweit 649225e992a4SHeiner Kallweit static void rtl_shutdown(struct pci_dev *pdev) 649325e992a4SHeiner Kallweit { 649425e992a4SHeiner Kallweit struct net_device *dev = pci_get_drvdata(pdev); 649525e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 649625e992a4SHeiner Kallweit 649725e992a4SHeiner Kallweit rtl8169_net_suspend(dev); 649825e992a4SHeiner Kallweit 649925e992a4SHeiner Kallweit /* Restore original MAC address */ 650025e992a4SHeiner Kallweit rtl_rar_set(tp, dev->perm_addr); 650125e992a4SHeiner Kallweit 650225e992a4SHeiner Kallweit rtl8169_hw_reset(tp); 650325e992a4SHeiner Kallweit 650425e992a4SHeiner Kallweit if (system_state == SYSTEM_POWER_OFF) { 650525e992a4SHeiner Kallweit if (tp->saved_wolopts) { 650625e992a4SHeiner Kallweit rtl_wol_suspend_quirk(tp); 650725e992a4SHeiner Kallweit rtl_wol_shutdown_quirk(tp); 650825e992a4SHeiner Kallweit } 650925e992a4SHeiner Kallweit 651025e992a4SHeiner Kallweit pci_wake_from_d3(pdev, true); 651125e992a4SHeiner Kallweit pci_set_power_state(pdev, PCI_D3hot); 651225e992a4SHeiner Kallweit } 651325e992a4SHeiner Kallweit } 651425e992a4SHeiner Kallweit 651525e992a4SHeiner Kallweit static void rtl_remove_one(struct pci_dev *pdev) 651625e992a4SHeiner Kallweit { 651725e992a4SHeiner Kallweit struct net_device *dev = pci_get_drvdata(pdev); 651825e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 651925e992a4SHeiner Kallweit 652025e992a4SHeiner Kallweit if (r8168_check_dash(tp)) 652125e992a4SHeiner Kallweit rtl8168_driver_stop(tp); 652225e992a4SHeiner Kallweit 652325e992a4SHeiner Kallweit netif_napi_del(&tp->napi); 652425e992a4SHeiner Kallweit 652525e992a4SHeiner Kallweit unregister_netdev(dev); 652625e992a4SHeiner Kallweit mdiobus_unregister(tp->phydev->mdio.bus); 652725e992a4SHeiner Kallweit 652825e992a4SHeiner Kallweit rtl_release_firmware(tp); 652925e992a4SHeiner Kallweit 653025e992a4SHeiner Kallweit if (pci_dev_run_wake(pdev)) 653125e992a4SHeiner Kallweit pm_runtime_get_noresume(&pdev->dev); 653225e992a4SHeiner Kallweit 653325e992a4SHeiner Kallweit /* restore original MAC address */ 653425e992a4SHeiner Kallweit rtl_rar_set(tp, dev->perm_addr); 653525e992a4SHeiner Kallweit } 653625e992a4SHeiner Kallweit 653725e992a4SHeiner Kallweit static const struct net_device_ops rtl_netdev_ops = { 653825e992a4SHeiner Kallweit .ndo_open = rtl_open, 653925e992a4SHeiner Kallweit .ndo_stop = rtl8169_close, 654025e992a4SHeiner Kallweit .ndo_get_stats64 = rtl8169_get_stats64, 654125e992a4SHeiner Kallweit .ndo_start_xmit = rtl8169_start_xmit, 6542e64e0c89SHeiner Kallweit .ndo_features_check = rtl8169_features_check, 654325e992a4SHeiner Kallweit .ndo_tx_timeout = rtl8169_tx_timeout, 654425e992a4SHeiner Kallweit .ndo_validate_addr = eth_validate_addr, 654525e992a4SHeiner Kallweit .ndo_change_mtu = rtl8169_change_mtu, 654625e992a4SHeiner Kallweit .ndo_fix_features = rtl8169_fix_features, 654725e992a4SHeiner Kallweit .ndo_set_features = rtl8169_set_features, 654825e992a4SHeiner Kallweit .ndo_set_mac_address = rtl_set_mac_address, 654925e992a4SHeiner Kallweit .ndo_do_ioctl = rtl8169_ioctl, 655025e992a4SHeiner Kallweit .ndo_set_rx_mode = rtl_set_rx_mode, 655125e992a4SHeiner Kallweit #ifdef CONFIG_NET_POLL_CONTROLLER 655225e992a4SHeiner Kallweit .ndo_poll_controller = rtl8169_netpoll, 655325e992a4SHeiner Kallweit #endif 655425e992a4SHeiner Kallweit 655525e992a4SHeiner Kallweit }; 655625e992a4SHeiner Kallweit 6557ec9a4088SHeiner Kallweit static void rtl_set_irq_mask(struct rtl8169_private *tp) 6558ec9a4088SHeiner Kallweit { 6559ec9a4088SHeiner Kallweit tp->irq_mask = RTL_EVENT_NAPI | LinkChg; 6560ec9a4088SHeiner Kallweit 6561ec9a4088SHeiner Kallweit if (tp->mac_version <= RTL_GIGA_MAC_VER_06) 6562ec9a4088SHeiner Kallweit tp->irq_mask |= SYSErr | RxOverflow | RxFIFOOver; 6563ec9a4088SHeiner Kallweit else if (tp->mac_version == RTL_GIGA_MAC_VER_11) 6564ec9a4088SHeiner Kallweit /* special workaround needed */ 6565ec9a4088SHeiner Kallweit tp->irq_mask |= RxFIFOOver; 6566ec9a4088SHeiner Kallweit else 6567ec9a4088SHeiner Kallweit tp->irq_mask |= RxOverflow; 6568ec9a4088SHeiner Kallweit } 6569ec9a4088SHeiner Kallweit 657025e992a4SHeiner Kallweit static int rtl_alloc_irq(struct rtl8169_private *tp) 657125e992a4SHeiner Kallweit { 657225e992a4SHeiner Kallweit unsigned int flags; 657325e992a4SHeiner Kallweit 6574003bd5b4SHeiner Kallweit switch (tp->mac_version) { 6575003bd5b4SHeiner Kallweit case RTL_GIGA_MAC_VER_02 ... RTL_GIGA_MAC_VER_06: 657625e992a4SHeiner Kallweit rtl_unlock_config_regs(tp); 657725e992a4SHeiner Kallweit RTL_W8(tp, Config2, RTL_R8(tp, Config2) & ~MSIEnable); 657825e992a4SHeiner Kallweit rtl_lock_config_regs(tp); 6579003bd5b4SHeiner Kallweit /* fall through */ 6580003bd5b4SHeiner Kallweit case RTL_GIGA_MAC_VER_07 ... RTL_GIGA_MAC_VER_24: 658125e992a4SHeiner Kallweit flags = PCI_IRQ_LEGACY; 6582003bd5b4SHeiner Kallweit break; 6583003bd5b4SHeiner Kallweit default: 658425e992a4SHeiner Kallweit flags = PCI_IRQ_ALL_TYPES; 6585003bd5b4SHeiner Kallweit break; 658625e992a4SHeiner Kallweit } 658725e992a4SHeiner Kallweit 658825e992a4SHeiner Kallweit return pci_alloc_irq_vectors(tp->pci_dev, 1, 1, flags); 658925e992a4SHeiner Kallweit } 659025e992a4SHeiner Kallweit 659125e992a4SHeiner Kallweit static void rtl_read_mac_address(struct rtl8169_private *tp, 659225e992a4SHeiner Kallweit u8 mac_addr[ETH_ALEN]) 659325e992a4SHeiner Kallweit { 659425e992a4SHeiner Kallweit /* Get MAC address */ 65959e9f33baSHeiner Kallweit if (rtl_is_8168evl_up(tp) && tp->mac_version != RTL_GIGA_MAC_VER_34) { 65969e9f33baSHeiner Kallweit u32 value = rtl_eri_read(tp, 0xe0); 65979e9f33baSHeiner Kallweit 659825e992a4SHeiner Kallweit mac_addr[0] = (value >> 0) & 0xff; 659925e992a4SHeiner Kallweit mac_addr[1] = (value >> 8) & 0xff; 660025e992a4SHeiner Kallweit mac_addr[2] = (value >> 16) & 0xff; 660125e992a4SHeiner Kallweit mac_addr[3] = (value >> 24) & 0xff; 660225e992a4SHeiner Kallweit 660325e992a4SHeiner Kallweit value = rtl_eri_read(tp, 0xe4); 660425e992a4SHeiner Kallweit mac_addr[4] = (value >> 0) & 0xff; 660525e992a4SHeiner Kallweit mac_addr[5] = (value >> 8) & 0xff; 6606f1bce4adSHeiner Kallweit } else if (rtl_is_8125(tp)) { 6607f1bce4adSHeiner Kallweit rtl_read_mac_from_reg(tp, mac_addr, MAC0_BKP); 660825e992a4SHeiner Kallweit } 660925e992a4SHeiner Kallweit } 661025e992a4SHeiner Kallweit 661125e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_link_list_ready_cond) 661225e992a4SHeiner Kallweit { 661325e992a4SHeiner Kallweit return RTL_R8(tp, MCU) & LINK_LIST_RDY; 661425e992a4SHeiner Kallweit } 661525e992a4SHeiner Kallweit 661625e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_rxtx_empty_cond) 661725e992a4SHeiner Kallweit { 661825e992a4SHeiner Kallweit return (RTL_R8(tp, MCU) & RXTX_EMPTY) == RXTX_EMPTY; 661925e992a4SHeiner Kallweit } 662025e992a4SHeiner Kallweit 662125e992a4SHeiner Kallweit static int r8169_mdio_read_reg(struct mii_bus *mii_bus, int phyaddr, int phyreg) 662225e992a4SHeiner Kallweit { 662325e992a4SHeiner Kallweit struct rtl8169_private *tp = mii_bus->priv; 662425e992a4SHeiner Kallweit 662525e992a4SHeiner Kallweit if (phyaddr > 0) 662625e992a4SHeiner Kallweit return -ENODEV; 662725e992a4SHeiner Kallweit 662825e992a4SHeiner Kallweit return rtl_readphy(tp, phyreg); 662925e992a4SHeiner Kallweit } 663025e992a4SHeiner Kallweit 663125e992a4SHeiner Kallweit static int r8169_mdio_write_reg(struct mii_bus *mii_bus, int phyaddr, 663225e992a4SHeiner Kallweit int phyreg, u16 val) 663325e992a4SHeiner Kallweit { 663425e992a4SHeiner Kallweit struct rtl8169_private *tp = mii_bus->priv; 663525e992a4SHeiner Kallweit 663625e992a4SHeiner Kallweit if (phyaddr > 0) 663725e992a4SHeiner Kallweit return -ENODEV; 663825e992a4SHeiner Kallweit 663925e992a4SHeiner Kallweit rtl_writephy(tp, phyreg, val); 664025e992a4SHeiner Kallweit 664125e992a4SHeiner Kallweit return 0; 664225e992a4SHeiner Kallweit } 664325e992a4SHeiner Kallweit 664425e992a4SHeiner Kallweit static int r8169_mdio_register(struct rtl8169_private *tp) 664525e992a4SHeiner Kallweit { 664625e992a4SHeiner Kallweit struct pci_dev *pdev = tp->pci_dev; 664725e992a4SHeiner Kallweit struct mii_bus *new_bus; 664825e992a4SHeiner Kallweit int ret; 664925e992a4SHeiner Kallweit 665025e992a4SHeiner Kallweit new_bus = devm_mdiobus_alloc(&pdev->dev); 665125e992a4SHeiner Kallweit if (!new_bus) 665225e992a4SHeiner Kallweit return -ENOMEM; 665325e992a4SHeiner Kallweit 665425e992a4SHeiner Kallweit new_bus->name = "r8169"; 665525e992a4SHeiner Kallweit new_bus->priv = tp; 665625e992a4SHeiner Kallweit new_bus->parent = &pdev->dev; 665725e992a4SHeiner Kallweit new_bus->irq[0] = PHY_IGNORE_INTERRUPT; 665825e992a4SHeiner Kallweit snprintf(new_bus->id, MII_BUS_ID_SIZE, "r8169-%x", pci_dev_id(pdev)); 665925e992a4SHeiner Kallweit 666025e992a4SHeiner Kallweit new_bus->read = r8169_mdio_read_reg; 666125e992a4SHeiner Kallweit new_bus->write = r8169_mdio_write_reg; 666225e992a4SHeiner Kallweit 666325e992a4SHeiner Kallweit ret = mdiobus_register(new_bus); 666425e992a4SHeiner Kallweit if (ret) 666525e992a4SHeiner Kallweit return ret; 666625e992a4SHeiner Kallweit 666725e992a4SHeiner Kallweit tp->phydev = mdiobus_get_phy(new_bus, 0); 666825e992a4SHeiner Kallweit if (!tp->phydev) { 666925e992a4SHeiner Kallweit mdiobus_unregister(new_bus); 667025e992a4SHeiner Kallweit return -ENODEV; 667125e992a4SHeiner Kallweit } 667225e992a4SHeiner Kallweit 667325e992a4SHeiner Kallweit /* PHY will be woken up in rtl_open() */ 667425e992a4SHeiner Kallweit phy_suspend(tp->phydev); 667525e992a4SHeiner Kallweit 667625e992a4SHeiner Kallweit return 0; 667725e992a4SHeiner Kallweit } 667825e992a4SHeiner Kallweit 667925e992a4SHeiner Kallweit static void rtl_hw_init_8168g(struct rtl8169_private *tp) 668025e992a4SHeiner Kallweit { 668125e992a4SHeiner Kallweit tp->ocp_base = OCP_STD_PHY_BASE; 668225e992a4SHeiner Kallweit 668325e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) | RXDV_GATED_EN); 668425e992a4SHeiner Kallweit 668525e992a4SHeiner Kallweit if (!rtl_udelay_loop_wait_high(tp, &rtl_txcfg_empty_cond, 100, 42)) 668625e992a4SHeiner Kallweit return; 668725e992a4SHeiner Kallweit 668825e992a4SHeiner Kallweit if (!rtl_udelay_loop_wait_high(tp, &rtl_rxtx_empty_cond, 100, 42)) 668925e992a4SHeiner Kallweit return; 669025e992a4SHeiner Kallweit 669125e992a4SHeiner Kallweit RTL_W8(tp, ChipCmd, RTL_R8(tp, ChipCmd) & ~(CmdTxEnb | CmdRxEnb)); 669225e992a4SHeiner Kallweit msleep(1); 669325e992a4SHeiner Kallweit RTL_W8(tp, MCU, RTL_R8(tp, MCU) & ~NOW_IS_OOB); 669425e992a4SHeiner Kallweit 6695ef712edeSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe8de, BIT(14), 0); 669625e992a4SHeiner Kallweit 669725e992a4SHeiner Kallweit if (!rtl_udelay_loop_wait_high(tp, &rtl_link_list_ready_cond, 100, 42)) 669825e992a4SHeiner Kallweit return; 669925e992a4SHeiner Kallweit 6700ef712edeSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe8de, 0, BIT(15)); 670125e992a4SHeiner Kallweit 670225e992a4SHeiner Kallweit rtl_udelay_loop_wait_high(tp, &rtl_link_list_ready_cond, 100, 42); 670325e992a4SHeiner Kallweit } 670425e992a4SHeiner Kallweit 6705f1bce4adSHeiner Kallweit static void rtl_hw_init_8125(struct rtl8169_private *tp) 6706f1bce4adSHeiner Kallweit { 6707f1bce4adSHeiner Kallweit tp->ocp_base = OCP_STD_PHY_BASE; 6708f1bce4adSHeiner Kallweit 6709f1bce4adSHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) | RXDV_GATED_EN); 6710f1bce4adSHeiner Kallweit 6711f1bce4adSHeiner Kallweit if (!rtl_udelay_loop_wait_high(tp, &rtl_rxtx_empty_cond, 100, 42)) 6712f1bce4adSHeiner Kallweit return; 6713f1bce4adSHeiner Kallweit 6714f1bce4adSHeiner Kallweit RTL_W8(tp, ChipCmd, RTL_R8(tp, ChipCmd) & ~(CmdTxEnb | CmdRxEnb)); 6715f1bce4adSHeiner Kallweit msleep(1); 6716f1bce4adSHeiner Kallweit RTL_W8(tp, MCU, RTL_R8(tp, MCU) & ~NOW_IS_OOB); 6717f1bce4adSHeiner Kallweit 6718f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe8de, BIT(14), 0); 6719f1bce4adSHeiner Kallweit 6720f1bce4adSHeiner Kallweit if (!rtl_udelay_loop_wait_high(tp, &rtl_link_list_ready_cond, 100, 42)) 6721f1bce4adSHeiner Kallweit return; 6722f1bce4adSHeiner Kallweit 6723f1bce4adSHeiner Kallweit r8168_mac_ocp_write(tp, 0xc0aa, 0x07d0); 6724f1bce4adSHeiner Kallweit r8168_mac_ocp_write(tp, 0xc0a6, 0x0150); 6725f1bce4adSHeiner Kallweit r8168_mac_ocp_write(tp, 0xc01e, 0x5555); 6726f1bce4adSHeiner Kallweit 6727f1bce4adSHeiner Kallweit rtl_udelay_loop_wait_high(tp, &rtl_link_list_ready_cond, 100, 42); 6728f1bce4adSHeiner Kallweit } 6729f1bce4adSHeiner Kallweit 673025e992a4SHeiner Kallweit static void rtl_hw_initialize(struct rtl8169_private *tp) 673125e992a4SHeiner Kallweit { 673225e992a4SHeiner Kallweit switch (tp->mac_version) { 67331287723aSHeiner Kallweit case RTL_GIGA_MAC_VER_49 ... RTL_GIGA_MAC_VER_52: 673425e992a4SHeiner Kallweit rtl8168ep_stop_cmac(tp); 673525e992a4SHeiner Kallweit /* fall through */ 673625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_40 ... RTL_GIGA_MAC_VER_48: 673725e992a4SHeiner Kallweit rtl_hw_init_8168g(tp); 673825e992a4SHeiner Kallweit break; 6739f1bce4adSHeiner Kallweit case RTL_GIGA_MAC_VER_60 ... RTL_GIGA_MAC_VER_61: 6740f1bce4adSHeiner Kallweit rtl_hw_init_8125(tp); 6741f1bce4adSHeiner Kallweit break; 674225e992a4SHeiner Kallweit default: 674325e992a4SHeiner Kallweit break; 674425e992a4SHeiner Kallweit } 674525e992a4SHeiner Kallweit } 674625e992a4SHeiner Kallweit 674725e992a4SHeiner Kallweit static int rtl_jumbo_max(struct rtl8169_private *tp) 674825e992a4SHeiner Kallweit { 674925e992a4SHeiner Kallweit /* Non-GBit versions don't support jumbo frames */ 675025e992a4SHeiner Kallweit if (!tp->supports_gmii) 675125e992a4SHeiner Kallweit return JUMBO_1K; 675225e992a4SHeiner Kallweit 675325e992a4SHeiner Kallweit switch (tp->mac_version) { 675425e992a4SHeiner Kallweit /* RTL8169 */ 675525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_02 ... RTL_GIGA_MAC_VER_06: 675625e992a4SHeiner Kallweit return JUMBO_7K; 675725e992a4SHeiner Kallweit /* RTL8168b */ 675825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_11: 675925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_12: 676025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_17: 676125e992a4SHeiner Kallweit return JUMBO_4K; 676225e992a4SHeiner Kallweit /* RTL8168c */ 676325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_18 ... RTL_GIGA_MAC_VER_24: 676425e992a4SHeiner Kallweit return JUMBO_6K; 676525e992a4SHeiner Kallweit default: 676625e992a4SHeiner Kallweit return JUMBO_9K; 676725e992a4SHeiner Kallweit } 676825e992a4SHeiner Kallweit } 676925e992a4SHeiner Kallweit 677025e992a4SHeiner Kallweit static void rtl_disable_clk(void *data) 677125e992a4SHeiner Kallweit { 677225e992a4SHeiner Kallweit clk_disable_unprepare(data); 677325e992a4SHeiner Kallweit } 677425e992a4SHeiner Kallweit 677525e992a4SHeiner Kallweit static int rtl_get_ether_clk(struct rtl8169_private *tp) 677625e992a4SHeiner Kallweit { 677725e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 677825e992a4SHeiner Kallweit struct clk *clk; 677925e992a4SHeiner Kallweit int rc; 678025e992a4SHeiner Kallweit 678125e992a4SHeiner Kallweit clk = devm_clk_get(d, "ether_clk"); 678225e992a4SHeiner Kallweit if (IS_ERR(clk)) { 678325e992a4SHeiner Kallweit rc = PTR_ERR(clk); 678425e992a4SHeiner Kallweit if (rc == -ENOENT) 678525e992a4SHeiner Kallweit /* clk-core allows NULL (for suspend / resume) */ 678625e992a4SHeiner Kallweit rc = 0; 678725e992a4SHeiner Kallweit else if (rc != -EPROBE_DEFER) 678825e992a4SHeiner Kallweit dev_err(d, "failed to get clk: %d\n", rc); 678925e992a4SHeiner Kallweit } else { 679025e992a4SHeiner Kallweit tp->clk = clk; 679125e992a4SHeiner Kallweit rc = clk_prepare_enable(clk); 679225e992a4SHeiner Kallweit if (rc) 679325e992a4SHeiner Kallweit dev_err(d, "failed to enable clk: %d\n", rc); 679425e992a4SHeiner Kallweit else 679525e992a4SHeiner Kallweit rc = devm_add_action_or_reset(d, rtl_disable_clk, clk); 679625e992a4SHeiner Kallweit } 679725e992a4SHeiner Kallweit 679825e992a4SHeiner Kallweit return rc; 679925e992a4SHeiner Kallweit } 680025e992a4SHeiner Kallweit 6801c782e204SHeiner Kallweit static void rtl_init_mac_address(struct rtl8169_private *tp) 6802c782e204SHeiner Kallweit { 6803c782e204SHeiner Kallweit struct net_device *dev = tp->dev; 6804c782e204SHeiner Kallweit u8 *mac_addr = dev->dev_addr; 6805ce37115eSHeiner Kallweit int rc; 6806c782e204SHeiner Kallweit 6807c782e204SHeiner Kallweit rc = eth_platform_get_mac_address(tp_to_dev(tp), mac_addr); 6808c782e204SHeiner Kallweit if (!rc) 6809c782e204SHeiner Kallweit goto done; 6810c782e204SHeiner Kallweit 6811c782e204SHeiner Kallweit rtl_read_mac_address(tp, mac_addr); 6812c782e204SHeiner Kallweit if (is_valid_ether_addr(mac_addr)) 6813c782e204SHeiner Kallweit goto done; 6814c782e204SHeiner Kallweit 6815ce37115eSHeiner Kallweit rtl_read_mac_from_reg(tp, mac_addr, MAC0); 6816c782e204SHeiner Kallweit if (is_valid_ether_addr(mac_addr)) 6817c782e204SHeiner Kallweit goto done; 6818c782e204SHeiner Kallweit 6819c782e204SHeiner Kallweit eth_hw_addr_random(dev); 6820c782e204SHeiner Kallweit dev_warn(tp_to_dev(tp), "can't read MAC address, setting random one\n"); 6821c782e204SHeiner Kallweit done: 6822c782e204SHeiner Kallweit rtl_rar_set(tp, mac_addr); 6823c782e204SHeiner Kallweit } 6824c782e204SHeiner Kallweit 682525e992a4SHeiner Kallweit static int rtl_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) 682625e992a4SHeiner Kallweit { 682725e992a4SHeiner Kallweit struct rtl8169_private *tp; 682825e992a4SHeiner Kallweit struct net_device *dev; 6829c782e204SHeiner Kallweit int chipset, region; 683025e992a4SHeiner Kallweit int jumbo_max, rc; 683125e992a4SHeiner Kallweit 6832f3259377SHeiner Kallweit /* Some tools for creating an initramfs don't consider softdeps, then 6833f3259377SHeiner Kallweit * r8169.ko may be in initramfs, but realtek.ko not. Then the generic 6834f3259377SHeiner Kallweit * PHY driver is used that doesn't work with most chip versions. 6835f3259377SHeiner Kallweit */ 6836f3259377SHeiner Kallweit if (!driver_find("RTL8201CP Ethernet", &mdio_bus_type)) { 6837f3259377SHeiner Kallweit dev_err(&pdev->dev, "realtek.ko not loaded, maybe it needs to be added to initramfs?\n"); 6838f3259377SHeiner Kallweit return -ENOENT; 6839f3259377SHeiner Kallweit } 6840f3259377SHeiner Kallweit 684125e992a4SHeiner Kallweit dev = devm_alloc_etherdev(&pdev->dev, sizeof (*tp)); 684225e992a4SHeiner Kallweit if (!dev) 684325e992a4SHeiner Kallweit return -ENOMEM; 684425e992a4SHeiner Kallweit 684525e992a4SHeiner Kallweit SET_NETDEV_DEV(dev, &pdev->dev); 684625e992a4SHeiner Kallweit dev->netdev_ops = &rtl_netdev_ops; 684725e992a4SHeiner Kallweit tp = netdev_priv(dev); 684825e992a4SHeiner Kallweit tp->dev = dev; 684925e992a4SHeiner Kallweit tp->pci_dev = pdev; 685025e992a4SHeiner Kallweit tp->msg_enable = netif_msg_init(debug.msg_enable, R8169_MSG_DEFAULT); 6851145a40e8SHeiner Kallweit tp->supports_gmii = ent->driver_data == RTL_CFG_NO_GBIT ? 0 : 1; 68527ec3f872SHeiner Kallweit tp->eee_adv = -1; 685325e992a4SHeiner Kallweit 685425e992a4SHeiner Kallweit /* Get the *optional* external "ether_clk" used on some boards */ 685525e992a4SHeiner Kallweit rc = rtl_get_ether_clk(tp); 685625e992a4SHeiner Kallweit if (rc) 685725e992a4SHeiner Kallweit return rc; 685825e992a4SHeiner Kallweit 685925e992a4SHeiner Kallweit /* Disable ASPM completely as that cause random device stop working 686025e992a4SHeiner Kallweit * problems as well as full system hangs for some PCIe devices users. 686125e992a4SHeiner Kallweit */ 686262b1b3b3SHeiner Kallweit rc = pci_disable_link_state(pdev, PCIE_LINK_STATE_L0S | 686362b1b3b3SHeiner Kallweit PCIE_LINK_STATE_L1); 686462b1b3b3SHeiner Kallweit tp->aspm_manageable = !rc; 686525e992a4SHeiner Kallweit 686625e992a4SHeiner Kallweit /* enable device (incl. PCI PM wakeup and hotplug setup) */ 686725e992a4SHeiner Kallweit rc = pcim_enable_device(pdev); 686825e992a4SHeiner Kallweit if (rc < 0) { 686925e992a4SHeiner Kallweit dev_err(&pdev->dev, "enable failure\n"); 687025e992a4SHeiner Kallweit return rc; 687125e992a4SHeiner Kallweit } 687225e992a4SHeiner Kallweit 687325e992a4SHeiner Kallweit if (pcim_set_mwi(pdev) < 0) 687425e992a4SHeiner Kallweit dev_info(&pdev->dev, "Mem-Wr-Inval unavailable\n"); 687525e992a4SHeiner Kallweit 687625e992a4SHeiner Kallweit /* use first MMIO region */ 687725e992a4SHeiner Kallweit region = ffs(pci_select_bars(pdev, IORESOURCE_MEM)) - 1; 687825e992a4SHeiner Kallweit if (region < 0) { 687925e992a4SHeiner Kallweit dev_err(&pdev->dev, "no MMIO resource found\n"); 688025e992a4SHeiner Kallweit return -ENODEV; 688125e992a4SHeiner Kallweit } 688225e992a4SHeiner Kallweit 688325e992a4SHeiner Kallweit /* check for weird/broken PCI region reporting */ 688425e992a4SHeiner Kallweit if (pci_resource_len(pdev, region) < R8169_REGS_SIZE) { 688525e992a4SHeiner Kallweit dev_err(&pdev->dev, "Invalid PCI region size(s), aborting\n"); 688625e992a4SHeiner Kallweit return -ENODEV; 688725e992a4SHeiner Kallweit } 688825e992a4SHeiner Kallweit 688925e992a4SHeiner Kallweit rc = pcim_iomap_regions(pdev, BIT(region), MODULENAME); 689025e992a4SHeiner Kallweit if (rc < 0) { 689125e992a4SHeiner Kallweit dev_err(&pdev->dev, "cannot remap MMIO, aborting\n"); 689225e992a4SHeiner Kallweit return rc; 689325e992a4SHeiner Kallweit } 689425e992a4SHeiner Kallweit 689525e992a4SHeiner Kallweit tp->mmio_addr = pcim_iomap_table(pdev)[region]; 689625e992a4SHeiner Kallweit 689725e992a4SHeiner Kallweit /* Identify chip attached to board */ 689825e992a4SHeiner Kallweit rtl8169_get_mac_version(tp); 689925e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_NONE) 690025e992a4SHeiner Kallweit return -ENODEV; 690125e992a4SHeiner Kallweit 690225e992a4SHeiner Kallweit tp->cp_cmd = RTL_R16(tp, CPlusCmd); 690325e992a4SHeiner Kallweit 690425e992a4SHeiner Kallweit if (sizeof(dma_addr_t) > 4 && tp->mac_version >= RTL_GIGA_MAC_VER_18 && 69053c18cbe3SHeiner Kallweit !dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64))) 690625e992a4SHeiner Kallweit dev->features |= NETIF_F_HIGHDMA; 690725e992a4SHeiner Kallweit 690825e992a4SHeiner Kallweit rtl_init_rxcfg(tp); 690925e992a4SHeiner Kallweit 691025e992a4SHeiner Kallweit rtl8169_irq_mask_and_ack(tp); 691125e992a4SHeiner Kallweit 691225e992a4SHeiner Kallweit rtl_hw_initialize(tp); 691325e992a4SHeiner Kallweit 691425e992a4SHeiner Kallweit rtl_hw_reset(tp); 691525e992a4SHeiner Kallweit 691625e992a4SHeiner Kallweit pci_set_master(pdev); 691725e992a4SHeiner Kallweit 691825e992a4SHeiner Kallweit chipset = tp->mac_version; 691925e992a4SHeiner Kallweit 692025e992a4SHeiner Kallweit rc = rtl_alloc_irq(tp); 692125e992a4SHeiner Kallweit if (rc < 0) { 692225e992a4SHeiner Kallweit dev_err(&pdev->dev, "Can't allocate interrupt\n"); 692325e992a4SHeiner Kallweit return rc; 692425e992a4SHeiner Kallweit } 692525e992a4SHeiner Kallweit 692625e992a4SHeiner Kallweit mutex_init(&tp->wk.mutex); 692725e992a4SHeiner Kallweit INIT_WORK(&tp->wk.work, rtl_task); 692825e992a4SHeiner Kallweit u64_stats_init(&tp->rx_stats.syncp); 692925e992a4SHeiner Kallweit u64_stats_init(&tp->tx_stats.syncp); 693025e992a4SHeiner Kallweit 6931c782e204SHeiner Kallweit rtl_init_mac_address(tp); 693225e992a4SHeiner Kallweit 693325e992a4SHeiner Kallweit dev->ethtool_ops = &rtl8169_ethtool_ops; 693425e992a4SHeiner Kallweit 693525e992a4SHeiner Kallweit netif_napi_add(dev, &tp->napi, rtl8169_poll, NAPI_POLL_WEIGHT); 693625e992a4SHeiner Kallweit 693793681cd7SHeiner Kallweit dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO | 693893681cd7SHeiner Kallweit NETIF_F_RXCSUM | NETIF_F_HW_VLAN_CTAG_TX | 693993681cd7SHeiner Kallweit NETIF_F_HW_VLAN_CTAG_RX; 694025e992a4SHeiner Kallweit dev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO | 694125e992a4SHeiner Kallweit NETIF_F_RXCSUM | NETIF_F_HW_VLAN_CTAG_TX | 694225e992a4SHeiner Kallweit NETIF_F_HW_VLAN_CTAG_RX; 694325e992a4SHeiner Kallweit dev->vlan_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO | 694425e992a4SHeiner Kallweit NETIF_F_HIGHDMA; 694525e992a4SHeiner Kallweit dev->priv_flags |= IFF_LIVE_ADDR_CHANGE; 694625e992a4SHeiner Kallweit 6947dc161162SHeiner Kallweit tp->cp_cmd |= RxChkSum; 6948dc161162SHeiner Kallweit /* RTL8125 uses register RxConfig for VLAN offloading config */ 6949dc161162SHeiner Kallweit if (!rtl_is_8125(tp)) 6950dc161162SHeiner Kallweit tp->cp_cmd |= RxVlan; 695125e992a4SHeiner Kallweit /* 695225e992a4SHeiner Kallweit * Pretend we are using VLANs; This bypasses a nasty bug where 695325e992a4SHeiner Kallweit * Interrupts stop flowing on high load on 8110SCd controllers. 695425e992a4SHeiner Kallweit */ 695525e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_05) 695625e992a4SHeiner Kallweit /* Disallow toggling */ 695725e992a4SHeiner Kallweit dev->hw_features &= ~NETIF_F_HW_VLAN_CTAG_RX; 695825e992a4SHeiner Kallweit 69590170d594SHeiner Kallweit if (rtl_chip_supports_csum_v2(tp)) { 696025e992a4SHeiner Kallweit dev->hw_features |= NETIF_F_IPV6_CSUM | NETIF_F_TSO6; 696193681cd7SHeiner Kallweit dev->features |= NETIF_F_IPV6_CSUM | NETIF_F_TSO6; 69620170d594SHeiner Kallweit dev->gso_max_size = RTL_GSO_MAX_SIZE_V2; 69630170d594SHeiner Kallweit dev->gso_max_segs = RTL_GSO_MAX_SEGS_V2; 69640170d594SHeiner Kallweit } else { 69650170d594SHeiner Kallweit dev->gso_max_size = RTL_GSO_MAX_SIZE_V1; 69660170d594SHeiner Kallweit dev->gso_max_segs = RTL_GSO_MAX_SEGS_V1; 69670170d594SHeiner Kallweit } 696825e992a4SHeiner Kallweit 6969a0783cd0SCorinna Vinschen /* RTL8168e-vl and one RTL8168c variant are known to have a 6970a0783cd0SCorinna Vinschen * HW issue with TSO. 6971a0783cd0SCorinna Vinschen */ 6972a0783cd0SCorinna Vinschen if (tp->mac_version == RTL_GIGA_MAC_VER_34 || 6973a0783cd0SCorinna Vinschen tp->mac_version == RTL_GIGA_MAC_VER_22) { 6974a7eb6a4fSHolger Hoffstätte dev->vlan_features &= ~(NETIF_F_ALL_TSO | NETIF_F_SG); 6975a7eb6a4fSHolger Hoffstätte dev->hw_features &= ~(NETIF_F_ALL_TSO | NETIF_F_SG); 6976a7eb6a4fSHolger Hoffstätte dev->features &= ~(NETIF_F_ALL_TSO | NETIF_F_SG); 697793681cd7SHeiner Kallweit } 697893681cd7SHeiner Kallweit 697925e992a4SHeiner Kallweit dev->hw_features |= NETIF_F_RXALL; 698025e992a4SHeiner Kallweit dev->hw_features |= NETIF_F_RXFCS; 698125e992a4SHeiner Kallweit 698225e992a4SHeiner Kallweit /* MTU range: 60 - hw-specific max */ 698325e992a4SHeiner Kallweit dev->min_mtu = ETH_ZLEN; 698425e992a4SHeiner Kallweit jumbo_max = rtl_jumbo_max(tp); 698525e992a4SHeiner Kallweit dev->max_mtu = jumbo_max; 698625e992a4SHeiner Kallweit 6987ec9a4088SHeiner Kallweit rtl_set_irq_mask(tp); 69889fa0a8e1SHeiner Kallweit 698925e992a4SHeiner Kallweit tp->fw_name = rtl_chip_infos[chipset].fw_name; 699025e992a4SHeiner Kallweit 699125e992a4SHeiner Kallweit tp->counters = dmam_alloc_coherent (&pdev->dev, sizeof(*tp->counters), 699225e992a4SHeiner Kallweit &tp->counters_phys_addr, 699325e992a4SHeiner Kallweit GFP_KERNEL); 699425e992a4SHeiner Kallweit if (!tp->counters) 699525e992a4SHeiner Kallweit return -ENOMEM; 699625e992a4SHeiner Kallweit 699725e992a4SHeiner Kallweit pci_set_drvdata(pdev, dev); 699825e992a4SHeiner Kallweit 699925e992a4SHeiner Kallweit rc = r8169_mdio_register(tp); 700025e992a4SHeiner Kallweit if (rc) 700125e992a4SHeiner Kallweit return rc; 700225e992a4SHeiner Kallweit 700325e992a4SHeiner Kallweit /* chip gets powered up in rtl_open() */ 700425e992a4SHeiner Kallweit rtl_pll_power_down(tp); 700525e992a4SHeiner Kallweit 700625e992a4SHeiner Kallweit rc = register_netdev(dev); 700725e992a4SHeiner Kallweit if (rc) 700825e992a4SHeiner Kallweit goto err_mdio_unregister; 700925e992a4SHeiner Kallweit 701025e992a4SHeiner Kallweit netif_info(tp, probe, dev, "%s, %pM, XID %03x, IRQ %d\n", 701125e992a4SHeiner Kallweit rtl_chip_infos[chipset].name, dev->dev_addr, 701225e992a4SHeiner Kallweit (RTL_R32(tp, TxConfig) >> 20) & 0xfcf, 701325e992a4SHeiner Kallweit pci_irq_vector(pdev, 0)); 701425e992a4SHeiner Kallweit 701525e992a4SHeiner Kallweit if (jumbo_max > JUMBO_1K) 701625e992a4SHeiner Kallweit netif_info(tp, probe, dev, 701725e992a4SHeiner Kallweit "jumbo features [frames: %d bytes, tx checksumming: %s]\n", 701825e992a4SHeiner Kallweit jumbo_max, tp->mac_version <= RTL_GIGA_MAC_VER_06 ? 701925e992a4SHeiner Kallweit "ok" : "ko"); 702025e992a4SHeiner Kallweit 702125e992a4SHeiner Kallweit if (r8168_check_dash(tp)) 702225e992a4SHeiner Kallweit rtl8168_driver_start(tp); 702325e992a4SHeiner Kallweit 702425e992a4SHeiner Kallweit if (pci_dev_run_wake(pdev)) 702525e992a4SHeiner Kallweit pm_runtime_put_sync(&pdev->dev); 702625e992a4SHeiner Kallweit 702725e992a4SHeiner Kallweit return 0; 702825e992a4SHeiner Kallweit 702925e992a4SHeiner Kallweit err_mdio_unregister: 703025e992a4SHeiner Kallweit mdiobus_unregister(tp->phydev->mdio.bus); 703125e992a4SHeiner Kallweit return rc; 703225e992a4SHeiner Kallweit } 703325e992a4SHeiner Kallweit 703425e992a4SHeiner Kallweit static struct pci_driver rtl8169_pci_driver = { 703525e992a4SHeiner Kallweit .name = MODULENAME, 703625e992a4SHeiner Kallweit .id_table = rtl8169_pci_tbl, 703725e992a4SHeiner Kallweit .probe = rtl_init_one, 703825e992a4SHeiner Kallweit .remove = rtl_remove_one, 703925e992a4SHeiner Kallweit .shutdown = rtl_shutdown, 704025e992a4SHeiner Kallweit .driver.pm = RTL8169_PM_OPS, 704125e992a4SHeiner Kallweit }; 704225e992a4SHeiner Kallweit 704325e992a4SHeiner Kallweit module_pci_driver(rtl8169_pci_driver); 7044